Cell.hxx

Go to the documentation of this file.

#ifndef _CELL_HXX_
#define _CELL_HXX_

#include "MureHeaders.hxx"
#include <libValErr/ValErr.hxx>

//________________________________________________________________________
//
//      Cell
//________________________________________________________________________

struct EqualReaction
{

        bool operator()( Reaction r1,  Reaction r2 ) const
        {
            if(r1.GetCode()[0]<r2.GetCode()[0]) return true ;
            return false;
        }
};
class Shape;


class Cell
{
 public :

    Cell(Shape_ptr theShape, Material *theMaterial=0, int theImportance=1, double theTemperature=-10); 

    Cell(int theNumber, Material *theMaterial, double theVolume, int theImportance=1, double theTemperature=-10); 
    Cell( Material *theMaterial,int theNumber, double theVolume, double theTemperature);
    Cell(const Cell &c);    
    ~Cell();                

    
    void        SetShape(Shape_ptr theShape){fShape=theShape;}  
    Shape_ptr   GetShape(){return fShape;}                      
    void        SetMaterial(Material *theMaterial);             
    Material*   GetMaterial(){return fMaterial;}                
    void        SetTemperature(double T);                       
    double      GetTemperature(){return fTemperature;}          
    void        SetImportance(int imp);                     
    void        SetImportance(int part,int imp){fImportance[part]=imp;}
    vector<int> GetImportance(){return fImportance;}        
    vector<string> GetParticle(){return fParticle;}         
    void        AddParticle(string Part, int Imp);          
    int         GetNumber(){return fNumber;}                
    void        SetNumber(int Number){fNumber=Number;}      

    double  GetVolume(){return fVolume;}
    void    SetVolume(double V);            
    double  GetMass();                      

    void        SetComment(string Comment=""){fComment=Comment;}    
    string      GetComment(){return fComment;}                  
    

    void AddSpatialVariable(string name,double value);
    vector<string> &GetSpatialVariableNames() {return fSpatialVariableNames;}   
    vector<double> &GetSpatialVariables() {return fSpatialVariables;}           
    bool IsSpatialVariable(string name);                    
    double GetSpatialVariable(string name);                 
    
    


    void Lattice(int LatticeType,int *RangeX,int *RangeY=0,int *RangeZ=0);

    void Lattice(int LatticeType,int Xmin=0,int Xmax=0,int Ymin=0,int Ymax=0,int Zmin=0,int Zmax=0);

    int FillLattice(int Universe,int *Pos=0,int Trans=0);

    int FillLattice(Shape_ptr theShape,int *Pos=0, int OldUniverse=0,int Trans=0);
    int     GetUniverse(){return fShape->GetUniverse();}
    int     ***GetLattice() {return fLattice;}              
    int     **GetLatticeRange() {return fLatticeRange;}     
    int     ***GetTransLattice() {return fTransLattice;}    
    
    
    
    // Like But methods start here
    Cell* LikeBut(Cell *InsertionCell, double x=0, double y=0, double z=0); 
    void SetLikeNumber(int Number) {fLikeNumber=Number; fIsLikeBut=true;}   
    void SetTransformation(Transformation* TR) {fTransformation=TR;}        
    Transformation* GetTransformation() {return fTransformation;}           
    void ExcludeCell(Cell* ACell) {fExcludedCells.push_back(ACell);}        
    
        

    bool IsEvolving(){return fEvolving;}    

    void SetEvolutiveSystem(EvolutiveSystem* es){fEvolutiveSystem = es;}    
    EvolutiveSystem* GetEvolutiveSystem() {return fEvolutiveSystem;}        
    
    void SetTallyNumber(int num){fTallyNum=num;}    
    int  GetTallyNumber(){return fTallyNum;}        
    void SetTallyBinNumber(int num){fTallyBinNum=num;}
    int  GetTallyBinNumber(){return fTallyBinNum;}  
    void SetFlux(double phi){fFlux=phi;}            
    void SetFlux(ValErr_t phi){fMCNPFlux=phi;}      
    double GetFlux(){return fFlux;}                 
    ValErr_t GetMCNPFlux(){return fMCNPFlux;}       

    void BuildMultiGroupFlux(int N);                            
    void SetMultiGroupFlux(int i,ValErr_t Flux){fPhiE[i]=Flux;} 
    ValErr_t GetMultiGroupFlux(int i){return fPhiE[i];}         
    vector<ValErr_t> &GetMultiGroupFlux(){return fPhiE;}        
    int GetNEnergyGroup(){return fNEnergyGroup;}                
    void SetEnergyGroup(float *E){fEnergyGroups=E;}             
    float* GetEnergyGroups(){return fEnergyGroups;}             


    void SetTrueCell(){fIsTrueCell = true;}     
    bool GetTrueCell(){return fIsTrueCell;}     
    void SetGlobalTallyNumber(int num){fGlobalTallyNum = num;}  
    int GetGlobalTallyNumber(){ return fGlobalTallyNum;}        
    
    void SetCellAbsorptions(ValErr_t rate){fCellAbsorptions = rate;}            
    void SetCellN2N(ValErr_t rate){fCellN2N = rate;} 
    void SetCellN3N(ValErr_t rate){fCellN3N = rate;} 
    void SetCellFissions(ValErr_t  rate){fCellFissions = rate;}     
    void SetCellNuFissions(ValErr_t rate){fCellNuFissions = rate;}  

    void SetControlRate(Reaction r,ValErr_t rate){fControlRate[r] = rate;}
    void SetControlRate(int ReactionCode,ValErr_t rate){fControlRate[Reaction(ReactionCode)] = rate;}
        
    ValErr_t GetCellAbsorptions(){ return fCellAbsorptions;}  
    ValErr_t GetCellN2N(){return fCellN2N ;} 
    ValErr_t GetCellN3N(){return fCellN3N ;} 
    ValErr_t GetCellFissions(){return fCellFissions;}  
    ValErr_t GetCellNuFissions(){return fCellNuFissions;}
    ValErr_t GetControlRate(Reaction r){return fControlRate[r];}
    ValErr_t GetControlRate(int ReactionCode){return fControlRate[Reaction(ReactionCode)];}

    bool IsFissile();   
    bool IsControlRod(){return fControlRod;} 
    void SetControlRod(double InitialLength, bool flag=true);   
    void SetControlRodLength(double l){fControlRodLength=l;}    
    double GetControlRodLength(){return fControlRodLength;}     


    
    bool IsFuel(){return fFuel;}                            
    bool IsModerator(){return fModerator;}                  
    void SetFuel(bool flag = true){fFuel=flag;}             
    void SetModerator(bool flag = true){fModerator=flag;}   
    
    void SetZone(int z){fZone=z;}       
    int  GetZone(){return fZone;}       
    void SetZlevel(int z){fZlevel=z;}   
    int  GetZlevel(){return fZlevel;}   
    
    void SetGuideTubeCoolant() {fGuideTubeCoolant=true;}    
    bool IsGuideTubeCoolant() {return fGuideTubeCoolant;}   
    double GetLocalKeff();  
    
    void AddBetaCollector(BetaCollector* BC) {fCellBetaCollectors.push_back(BC);}

    string Print();         
    bool IsVirtual(){return fVirtual;}
    
    void SetTHLevelPosition(int level) {fTHLevelPosition=level;}    
    int  GetTHLevelPosition() {return fTHLevelPosition;}    
    void SetTHZonePosition(int zone) {fTHZonePosition=zone;}    
    int  GetTHZonePosition() {return fTHZonePosition;}  
    void AddToNuNSigmaFisPhi(double Value) {fNuNSigmaFisPhiTotalOfCell+=Value;} 
    void SetNuNSigmaFisPhi(double Value) {fNuNSigmaFisPhiTotalOfCell=Value;} 
    double GetNuNSigmaFisPhi() {return fNuNSigmaFisPhiTotalOfCell;} 
    void SetNSigmaFisPhiOfNucleus(int i,double Value) {fNSigmaFisPhiOfNucleus[i]=Value;} 
    double GetNSigmaFisPhiOfNucleus(int i) {return fNSigmaFisPhiOfNucleus[i];} 
    vector<double> GetNSigmaFisPhiOfAllNucleus() {return fNSigmaFisPhiOfNucleus;}

    
private:
    //double    CalculateNatoms();  //!< Do the number of atoms calculation for the cell.
    
    int         fNumber;            
    Shape_ptr   fShape;             
    Material    *fMaterial;         
    double      fTemperature;       
    double      fFlux;              
    ValErr_t    fMCNPFlux;          
    int         fGlobalImportance; 
    vector<int> fImportance;        
    vector<string> fParticle;           
    string      fComment;           
    double      fVolume;            
    int         fLatticeType;       
    int     **fLatticeRange;        
    int     ***fLattice;            
    bool        fEvolving;          
    double      fMass;              
    double      fNatoms;            
    EvolutiveSystem *fEvolutiveSystem;      
    bool        fFromCopy;          
    int     fTallyNum;              
    int     fTallyBinNum;           
    vector<double> fSpatialVariables;       
    vector<string> fSpatialVariableNames;   
    bool    fIsTrueCell;            
    int fGlobalTallyNum;            
    
    vector <BetaCollector*> fCellBetaCollectors; 
    
    ValErr_t fCellAbsorptions;          
    ValErr_t fCellN2N;                  
    ValErr_t fCellN3N;                  
    ValErr_t fCellNuFissions;           
    ValErr_t fCellFissions;             
    map<Reaction,ValErr_t,EqualReaction> fControlRate;  
    bool fCellCanFission;               
    vector<double>fCellGlobalRatesVector;
    int ***fTransLattice;               
    bool    fControlRod;                

    double  fControlRodLength;          
    
    // All the variables needed to define cells as Like But
    bool fIsLikeBut;                    
    int fLikeNumber;                    
    Transformation* fTransformation;    
    vector<Cell*> fExcludedCells;       

    bool        fFuel;      
    bool        fModerator; 
    bool        fVirtual;   
    int         fZlevel;    
    int         fZone;      
    bool        fGuideTubeCoolant;  
    double      fLocalKeff; 
    vector<ValErr_t> fPhiE;     
    float       *fEnergyGroups; 
    int         fNEnergyGroup;  
    int         fTHLevelPosition;   
    int         fTHZonePosition;    
    double fNuNSigmaFisPhiTotalOfCell;  
    vector<double> fNSigmaFisPhiOfNucleus; 
};

#endif