Tally.hxx

Go to the documentation of this file.

#ifndef _TALLY_HXX_
#define _TALLY_HXX_

#include "MureHeaders.hxx"
#include <vector>
using namespace std;

enum TallyType {kSurfaceCurrent=1,kSurfaceFlux,kCellFlux=4,
                kEnergyDeposition=6,kFissionEnergyDeposition};
                

class TallyBin
{
 protected:
    TallyBin(int celltype, vector<double> vol,double surf); 
 public:
    TallyBin(const TallyBin &b); 
    TallyBin(); 
    virtual ~TallyBin(){}; 
    virtual TallyBin *Clone(){return new TallyBin(*this);} //<! The "Virtual Copy Constructor"
    
    virtual bool    IsSimpleBin(){return 0;} 
    virtual bool    IsGroupBin(){return 0;} 
    virtual bool    IsLatticeBin(){return 0;} 

    int             GetCellType(){return fCellType;}
    virtual string  Print(int BeforeRparenthesis=0){return "";} 
    virtual string  PrintVolume(); 

    virtual bool    NeedVolume(){if(fCellType) return (fVolume[0]==-1); else return /*(fSurface==-1)*/ false;}

    vector<double>  GetVolume(){return fVolume;}

    double  GetVolume(int i){return fVolume[i];}
    double  GetSurface(){return fSurface;} 
    int     GetNumberOfVolume(){return fVolume.size();} 

    void    SetSurface(double S,bool Inc=false);            

    void    SetVolume(double V,int i=0,bool Inc=false); 
    virtual bool IsInBin(int num){return false;} 
    void    SetBinVolume(vector<double> V); 

 protected:
    int             fCellType;  
    vector<double>  fVolume;    
    double          fSurface;   

};


class SimpleBin :public TallyBin
{
 public:
    SimpleBin(const SimpleBin &b); 
    SimpleBin(Cell *C); 
    SimpleBin(Shape_ptr S); 
    SimpleBin(int universe); 
    SimpleBin(); 
    TallyBin *Clone() {return new SimpleBin(*this);} 
    virtual ~SimpleBin(){fBin.clear(); fIsBinUniverse.clear();} 
    
    void    AddSurface(int num) {fBin.push_back(num);} 

    
    bool    IsSimpleBin(){return 1;} 
    string  Print(int BeforeRparenthesis=0); 
    string  PrintVolume(); 
    bool    IsInBin(int num); 
    
 private:
    vector<int>     fBin; 
    vector<bool>    fIsBinUniverse; 

};


class GroupBin :public TallyBin
{
 public:
    GroupBin(const GroupBin &b); 
    GroupBin(Cell *C); 
    GroupBin(Shape_ptr S); 
    GroupBin(TallyBin *theTallyBin); 
    GroupBin(int universe); 
    TallyBin *Clone() {return new GroupBin(*this);} 
    ~GroupBin(); 
    
    bool IsGroupBin(){return 1;} 
    void Add(Cell *C); 
    void Add(Shape_ptr S); 
    void Add(TallyBin *theTallyBin); 
    void Add(int universe); 
    string Print(int BeforeRparenthesis=0); 
    bool IsInBin(int num); 

 private:

    vector<TallyBin*>   fBin; 
};


class LatticeBin:public TallyBin
{
 public:
    LatticeBin(const LatticeBin &b); 
    LatticeBin(Cell *C, string pos = ""); 
    LatticeBin(TallyBin *theTallyBin); 
    LatticeBin(int universe); 
    ~LatticeBin(); 
    TallyBin *Clone() {return new LatticeBin(*this);} 
    
    bool IsLatticeBin(){return 1;} 

    void Add(Cell *C,int InclusionLevel=0, string pos = "");
    void Add(TallyBin *theTallyBin,int InclusionLevel=0);
    void Add(int universe,int InclusionLevel=0); 
    void AddContainer(Cell *C, string pos = ""); 
    void AddContainer(TallyBin *theTallyBin); 
    void AddContainer(int universe); 
    string Print(int BeforeRparenthesis=0); 
    string PrintVolume(); 
    bool IsInBin(int num); 
    
    vector< vector<TallyBin*> > GetLevelVector()    {return fLevel;} 
    
 private:
    vector< vector<TallyBin*> > fLevel; 
    vector< vector< bool > >    fHasPosition; 
    vector< vector< string > >  fPosition; 
};


class Reaction
{
 public:
    Reaction(const Reaction &r); 
    Reaction(int code){fCode.push_back(code);} 
    void Add(int code); 
    void Multiply(int code); 
    string Print(); 
    vector<int> GetCode(){return fCode;} 
    bool operator==(const Reaction r)const ; 
 private:
    vector<int>     fCode; 
    vector<char>    fOperator; 
};


class TallyFM
{
 public:
    TallyFM(Material *M,int reaction,double constant=1);
    TallyFM(Material *M,Reaction *R,double constant=1);
    TallyFM(int MatNumber,int reaction,double constant=1);

    TallyFM(int MatNumber,Reaction *R,double constant=1);
    
    TallyFM(const TallyFM &fm); 
    ~TallyFM(); 
    string Print(); 
    int GetMaterial(){return fMatNumber;}

 private:
    void Init(int MatNumber,Reaction *R,double constant=1); 
    double              fConstant; 
    int                 fMatNumber; 
    Reaction*           fReaction; 
};




class Tally
{
 public:    
    Tally(int type=kCellFlux,const char *particle="N");
    Tally(int type,int particle);
    Tally(const Tally &t); 
    Tally *Clone() {return new Tally(*this);}
    ~Tally(); 
    
    void    Add(Cell *C); 
    void    Add(Shape_ptr S); 
    void    Add(TallyBin *theTallyBin); 
    void    Add(int universe); 
    void    Add(TallyFM *FM){fMultiplicator.push_back(FM);} 
    void    AddMultiplicator(Material *M,int reaction,double constant=1); 
    void    AddMultiplicator(Material *M,Reaction *R,double constant=1); 

    void    AddEnergy(int NE,double *E);
    void    AddEnergy(vector<double>E);
    void    AddEnergy(int NE,double Emin,double Emax,bool Linear=false);
    void    AddEnergy(double Emin,double Emax,int N_by_Decade=10);
    void    AddMultiGroupEnergy(double Emin,double Emax,double decad_mult=1);
    void    AddTime(int NT,double *T);
    void    AddTime(int NT,double Tmin,double Tmax,bool Linear=false);
    void    AddTime(double Tmin,double Tmax,int N_by_Decade=10);
    void AddFluenceToDoseConversion(bool ELinear=false,bool CFLinear=false);

    string Print(); 
    string PrintFM(); 
    void PrintET(ofstream &Out); 
    
    
    bool    NeedVolume(); 
    int     GetNumber(){return fNumber;} 
    vector<double>  GetBinVolume(int i); 
    double          GetBinSurface(int i); 
    void    SetBinSurface(int i,double S); 
    void    SetBinVolume(int i,double V,int k=0); 
    TallyBin*   GetBin(int i){return fBin[i];} 
    vector<TallyBin*>   &GetBin(){return fBin;} 
    int                 GetType(){return fType;} 
    void                SetType(int type){fType=type;} 
    int     IsInTallyBin(int num); 
    string  GetParticle(){return fParticle;} 
    void    SkipVolumeCalculation(){fSkipVolumeCalc=true;} 
    bool    IsVolumeCalculationSkept(){return fSkipVolumeCalc;} 
    void    SetParticleN(){fParticle="N";} 
    void    SetParticleNP(){fParticle="N,P";} 
    void    SetParticleNE(){fParticle="N,E";} 
    void    SetParticleNPE(){fParticle="N,P,E";} 
    void    SetComment(string str){fComment=str;} 
    void    SetParentheses(bool flag=true){fParentheses=flag;}
    vector<TallyFM*> &GetMultiplicator(){return fMultiplicator;}
    
    vector<double> GetEnergyBinningVector() {return fE;}    
    void SetETBinForAllTallies(bool flag=true){fETBinForAllTallies=flag;}   
    void SetNotPrintable(bool flag=true){fNotPrintable=flag;}   

 private:           
    int                 fType; 
    int                 fNumber; 
    string              fParticle; 
    int                 fLinearT; 
    vector <double>     fT; 
    int                 fLinearE; 
    vector <double>     fE; 
    vector<TallyBin*>   fBin; 
    vector<TallyFM*>    fMultiplicator; 
    bool                fSkipVolumeCalc;
    string              fComment; 
    bool                fParentheses; 
    bool                fETBinForAllTallies; 
    bool                fNotPrintable; 
    bool                fStar;
    vector<double>      fEnergy;
    vector<double>      fConversionFactor;
    bool                fELinearFTD;
    bool                fCFLinearFTD;

};




#endif