Nucleus.hxx

Go to the documentation of this file.

#ifndef _NUCLEUS_
#define _NUCLEUS_ 

#include <math.h>
#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include "MureHeaders.hxx"
#include <libValErr/ValErr.hxx>

using namespace std;

//________________________________________________________________________
class Cell; 
//________________________________________________________________________
//

class Nucleus; 
typedef Reference_ptr<Nucleus> Nucleus_ptr; 


class Nucleus : public TReference
{
 public:

    Nucleus(int Z, int A, int I=0, bool Moderator=0, bool Evolution=false);

    Nucleus(int Z, int A, int I, double T, bool Moderator=0, bool Evolution=false);

    Nucleus(ZAI* zai, double T, bool Moderator=0, bool Evolution=false);
    //Nucleus(const Nucleus &n);    //!< Copy constructor 
    Nucleus(const Nucleus &n, bool clone=false);    
    ~Nucleus();                 

    int  Z(){return fZAI->Z();}                     
    int  A(){return fZAI->A();}                     
    int  I(){return fZAI->I();}                     
    ZAI* GetZAI(){return fZAI;}                 
    void SetZAI(ZAI *zai);                      
    double GetMass(){return fZAI->GetMass();}   
    void SetMass(double m){fZAI->SetMass(m);}   
    double GetTemperature(){return fTemperature;}   
    void SetTemperature(double T){fIdCode=""; fIdCode2=""; fTemperature=T;}  
    
    bool GetModerator(){return fModerator;}     
    string GetModeratorLine(){return fModeratorLine;}
    void SetModeratorName(string name){fModeratorName=name;fModerator=true;}
    void SetModeratorLine(string line){fModeratorLine=line;}        
    

    void SetModeratorCategory(string ModeratorCatgory){fModeratorCategory=ModeratorCatgory;}
    
    

    string FindMCNPCode();

    void FindMCNPCode2();
    //void AddCell(Cell *cell){fCellVector.push_back(cell);}    //!< Say that this Nucleus is in cell
    void SetXSExtension(string code);                           
    void SetXSDIRLine(string Line){fBestLine=Line; fUserCode=false;}    
    string GetIdCode(){return fIdCode;}                         
    string GetIdCode2();                        
    void SetIdCode(string code=""){fIdCode=code;}               
    string GetBestLine(){return fBestLine;}         
    string GetBestLine2();      
    void SetBestLine(string BestLine){fBestLine = BestLine;}        
    void SetGlobalNucleiIndex(int Index) {fGlobalNucleiIndex=Index;}
    string FindMCNPModeratorName();     
    

    double FindCode(double Temperature, string Type,bool AllWarning=false);
    
    void SetXSCode(vector<int> XSC){fXSCode=XSC;}   
    vector<int> GetXSCode(){return fXSCode;}        
    bool IsUserCode(){return fUserCode;}            



    ValErr_t GetMCNPSigmaPhiFM(int BinNum,int FMBinNum);

    double  GetSigmaPhi(int BinNum,int ReactionCode);

    double  GetSigmaPhi2(int BinNum,int ReactionCode);

    ValErr_t    GetMCNPSigmaPhi(int BinNum,int ReactionCode);

    ValErr_t    GetMCNPSigmaPhi2(int BinNum,int ReactionCode);

    double  GetSigmaPhi(Cell *cell,ZAI *daughter);

    ValErr_t    GetMCNPSigmaPhi(Cell *cell,ZAI *daughter);

    double GetSigmaPhi(Cell *cell, int ReactionCode); 

    double GetSigmaPhi2(Cell *cell, int ReactionCode); 

    ValErr_t GetMCNPSigmaPhi(Cell *cell, int ReactionCode); 

    ValErr_t GetMCNPSigmaPhi2(Cell *cell, int ReactionCode); 


    void    SetMCNPSigmaPhi(int BinNum,int FMBinNum,ValErr_t r);    

    void    SetMCNPSigmaPhi2(int BinNum,int FMBinNum,ValErr_t r);   

    void    SetMCNPSigma(int BinNum,int FMBinNum,ValErr_t xs);  

    void    SetMCNPSigma2(int BinNum,int FMBinNum,ValErr_t xs); 

    double GetSigmaFM(int BinNum,int FMBinNum);

    ValErr_t GetMCNPSigmaFM(int BinNum,int FMBinNum);

    ValErr_t    GetMCNPSigma(int BinNum,int ReactionCode);

    ValErr_t    GetMCNPSigma2(int BinNum,int ReactionCode);

    ValErr_t    GetMCNPSigma(Cell *cell,ZAI *daughter);

    ValErr_t    GetMCNPSigma(Cell *cell, int ReactionCode); 

    ValErr_t    GetMCNPSigma2(Cell *cell, int ReactionCode); 
    void SetTotalSigma(double xs){fTotalSigma=xs;}  
    double GetTotalSigma(){return fTotalSigma;}     
    double GetTotalSigmaPhi(Cell *cell);            
    void SetTotalSigmaPhi(int BinNum,double xs);    
    void SetFMTotalBinNum(int FMbin) {fFMTotalBinNum=FMbin;}
    int GetFMTotalBinNum(){return fFMTotalBinNum;}  
    
    void SetTallyNumber(int num){fTallyNum=num;}    
    int  GetTallyNumber(){return fTallyNum;}        
    vector<int> GetFMBinNumber(){return fFMBinNum;} 
    vector<int> GetBinNumber(){return fBinNum;}     
    vector<int> GetCellNumber(){return fCellNum;}   

    vector<int> SetFMBinNumber(int &FMBinNum);
    void SetBinNumber(int BinNum);          
    void SetCellNumber(int CellNum);        
    int FindFMBin(int ReactionCode);        
    void FindSlope(int BinNum,int FMBinNum); 
    void FindSmooth(int BinNum,int FMBinNum); 


    string Print(); 
    string PrintPseudoNucleus(double proportion);   
    void SetEvolution(bool Evolution){fEvolution=Evolution;} 
    bool IsEvolutive(){return fEvolution;}          
    int GetGlobalNucleiIndex() {return fGlobalNucleiIndex;} 
    void ResetFirstReaction();                  
    bool IsFirstReaction(int ReactionCode);     
    void SetFirstReaction(int ReactionCode);    
    

    void Duplicate(bool flag){fDuplicate=flag;}
    bool IsDuplicate(){return fDuplicate;}                  
    void SetAlreadyWarn(bool flag=true){fAlreadyWarn=flag;} 
    bool IsAlreadyWarn(){return fAlreadyWarn;}              


    bool IsTemperatureEvolution(){return fTemperatureEvolution;} 
    bool IsPseudoNucleus(){return fPseudoNucleus;}
    void SetPseudoNucleus(bool flag=true) {fPseudoNucleus=flag;} 
    void SetTemperatureEvolution(bool flag=true){fTemperatureEvolution=flag;} 
    void ClearBinVector() {fBinNum.clear();}     
    void ClearFMBinVector() {fFMBinNum.clear();} 
    void SetNuSigmaFisPhi(int BinNum,double Value); 
    vector<double> GetNuSigmaFisPhi() {return fNuSigmaFisPhi;} 
    double GetNuSigmaFisPhi(int BinNum); 
    double GetNuSigmaFisPhi(Cell *cell); 

    
    
 private:
    void InitSigmaPhi();                    
    int FindReactionCode(ZAI *daughter);    
    int FindCellBin(Cell *cell);            
    
    int NumberOfReaction();                 
    bool IsModeratorCategoryOk(string Code);

    ZAI             *fZAI;              
    bool            fModerator;         
    bool            fEvolution;         
    bool            fUserCode;          
    bool            fPseudoNucleus;     
    string          fModeratorName;     
    string          fModeratorLine;     
    string          fModeratorCategory; 
    string          fIdCode;            
    string          fIdCode2;           
    double          fTemperature;       
    double          fBaseTemperature1;  
    double          fBaseTemperature2;  
    int             fGlobalNucleiIndex; 
    string          fBestLine;          
    string          fBestLine2;         
    int             fTallyNum;          
    vector<int>     fFMBinNum;          
    vector<int>     fBinNum;            
    vector<int>     fCellNum;           
    

    vector<vector<vector<ValErr_t> > >  fSigmaPhi;

    vector<vector<vector<ValErr_t> > >  fSigmaPhi2;

    vector<vector<ValErr_t> >   fMCNPSigmaPhi;

    vector<vector<ValErr_t> >   fMCNPSigmaPhi2;

    vector<vector<ValErr_t> >   fMCNPSigmaPhi3;

    vector<vector<ValErr_t> >   fMCNPSigma;

    vector<vector<ValErr_t> >   fMCNPSigma2;
    vector<double>  fTotalSigmaPhi;     
    int             fFMTotalBinNum;     
    double          fTotalSigma;        
    int             fNReaction;         
    map<int,bool>   fFirstReaction;     
    vector<double>  fMCNPTime;          
    vector<vector<double> > fFitSlope;  
    vector<vector<double> > fIntersept; 
    vector<vector<double> > fFitSlope2; 
    vector<vector<double> > fIntersept2;    
    bool            fDuplicate;         
    bool            fAlreadyWarn;       
    bool            fTemperatureEvolution; 
    bool            **fASK; 
    vector<int>     fXSCode;
    vector<double>          fNuSigmaFisPhi;     
};
#endif