MURE.hxx

Go to the documentation of this file.

#ifndef _MURE_HXX_
#define _MURE_HXX_

#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <libmctal/TMctal.hxx>
#include <libmctal/TMTally.hxx>
#include "MureHeaders.hxx"
 
using namespace std;

class Cell;
class Shape;
class Sphere;
class Tally;
class EvolutiveSystem; 

#define LOG_LEVEL_DEBUG   0
#define LOG_LEVEL_WARNING 2
#define LOG_LEVEL_IMPORTANT_WARNING 3
#define LOG_LEVEL_ALERT   4
#define LOG_LEVEL_ERROR   5

#define __METHOD_NAME__ __macro_method_name__(__PRETTY_FUNCTION__)
const int NODEBUG=0;
const int DODEBUG=0;
#define LOG_DEBUG(msg)   {if ((!NODEBUG)&&((DODEBUG)||(!gMURE->GetSilentDebug()))&&(gMURE->GetMessageLevel()<=LOG_LEVEL_DEBUG)) cout<<__METHOD_NAME__<<" : "<<msg<<endl;}
#define LOG_INFO(msg)    { cout<<msg<<endl;}
#define LOG_WARN(msg)    {if ((!gMURE->GetSilentDebug())&&(gMURE->GetMessageLevel()<=LOG_LEVEL_WARNING)) {ostringstream s;s<<msg;cout<<left<<setw(75)<<setfill('*')<<("**** WARNING in "+__METHOD_NAME__+" ")<<endl;cout<<wordwrap(s.str(),75)<<endl;}}
#define LOG_IMP_WARN(msg)    {if (gMURE->GetMessageLevel()<=LOG_LEVEL_IMPORTANT_WARNING) {ostringstream s;s<<msg;cout<<left<<setw(75)<<setfill('*')<<("**** WARNING in "+__METHOD_NAME__+" ")<<endl;cout<<wordwrap(s.str(),75)<<endl;cout<<left<<setw(75)<<setfill('*')<<"*"<<endl;}}
#define LOG_ALERT(msg)   {if (gMURE->GetMessageLevel()<=LOG_LEVEL_ALERT)   {ostringstream s;s<<msg;cout<<left<<setw(75)<<setfill('!')<<("!!!! ALERT in "+__METHOD_NAME__+" ")<<endl;cout<<wordwrap(s.str(),75)<<endl;cout<<setw(75)<<setfill('=')<<"!"<<endl;}}
#define LOG_ERROR(msg)   {if (gMURE->GetMessageLevel()<=LOG_LEVEL_ERROR)   {ostringstream s;s<<msg;cout<<left<<setw(75)<<setfill('=')<<("==== ERROR in "+__METHOD_NAME__+" ")<<endl;cout<<wordwrap(s.str(),75)<<endl;cout<<setw(75)<<setfill('=')<<"= Exiting MURE ="<<endl;}exit(0);}


class MURE
{
 public:
    MURE(string name = "xsdir"); 
    MURE(const MURE &m); 
    ~MURE(); 

    

    void Evolution(
    vector<double>T,        
    int Start=0,            
    bool BrutalStop=false   
    ); 


    void SetPredictorCorrector(bool middle_step=false);
    bool IsPredictorCorrector(){return fPredictorCorrector;}    
    bool IsPredictorStep(){return fPredictorStep;}              
    double GetPCEvaluationTime(){return fPCEvaluationTime;}     
    

    void FindPredictorCorrectorStep();

    void UseMultiGroupTallies(bool StdTallyFor238U=false){fMultigroupTallies=true;fU8StdTally=StdTallyFor238U;}
    void SetMultiGroupDecadeMultiplcator(int N=1){fMultiGroupDecadeMultiplcator=N;} 
    bool IsMultiGroupTalliesUsed(){return fMultigroupTallies;}  
    bool IsTHMultiGroupTalliesUsed(){return fTHMultigroupTallies;}  
    

    void AddCellToGroup(Cell* TheCell, int GroupNumber=0);
    vector<Cell *> & GetCellGroup(int GroupNumber){return fGroupCellVector[GroupNumber];} 
    int NumberOfCellGroup(){return fGroupCellVector.size();} 
 
  
    void SetPower(double Power){fPower = Power;}    
    double GetPower(){return fPower;}               

    double GetInitialHNMass() {if (!fInitHNMassInTon) {CalculateInitialHNMass();} return fInitHNMassInTon;}     
    
    void SetEvolutionControl(EvolutionControl *EC){fEvolutionControl=EC;}   
    EvolutionControl *GetEvolutionControl(){return fEvolutionControl;}      

    void SetMaterialControl(){fMaterialControl = true;} 
    bool GetMaterialControl(){return fMaterialControl;} 
    ControlMaterial* GetControlMaterial();  
    void AddControlRodCell(Cell* TheCell){fControlRodCell.push_back(TheCell);} 
    vector<Cell*> &GetControlRodCell(){return fControlRodCell;} 
    ValErr_t GetAbs(){return fGlobalAbsorptions;} 
    ValErr_t GetN2N(){return fGlobalN2N;}                       
    ValErr_t GetN3N(){return fGlobalN3N;}                       
    ValErr_t GetFiss(){return fGlobalFissions;}                 
    ValErr_t GetNuFiss(){return fGlobalNuFissions;}             
    ValErr_t GetNeutronLosses(){return fGlobalNeutronLosses;}   
    void SetGlobalRates(); 

    
    

    void SetBrutalStopKValue(double brutalstopvalue){fBrutalStopKValue = brutalstopvalue; fBrutalStop = true;}
    

    void SetControlRate(Reaction r,ValErr_t rate){fControlRate[r] = rate;} 
    

    void SetControlRate(int ReactionCode,ValErr_t rate){fControlRate[Reaction(ReactionCode)] = rate;}
    ValErr_t GetControlRate(Reaction r){return fControlRate[r];}        
    ValErr_t GetControlRate(int ReactionCode){return fControlRate[Reaction(ReactionCode)];}
    

    void SetOutermostShape(Shape_ptr s){fOutermostShape=s;}
    Shape_ptr GetOutermostShape(){return fOutermostShape;} 

    void CalculateInitialHNMass();  
    double GetBurnUp();         


    void SetSource(MCNPSource *source){fSource=source;} 
    MCNPSource* GetSource(){return fSource;}            
    

    void UsePreviousRunSource(string FirstSource = "");
    bool GetUsePrevSource(){return fUsePrevSource;} 
    void SetUsePrevSource(bool flag=true){fUsePrevSource =flag;} 
    string GetSourceFileName(){return fSourceFile;}         
    void SetSourceFileName(string name){fSourceFile=name;}  
    void SetOriginalSourceFileName(string name){fOriginalSourceFile=name;}  


    void SetModeN(){fMode="N";}         
    void SetModeNP(){fMode="N P";}      
    void SetModeNE(){fMode="N E";}      
    void SetModeNPE(){fMode="N P E";}   
    void SetModePE(){fMode="P E";}      
    void SetModeP(){fMode="P";}     
    void SetMode(string MyMode="N"){fMode=MyMode;}      
    string GetMode(){return fMode;}     



    void SetSpectrumType(string type="thermal");

    double GetSpectrumType(){return fMeanEnergySpectrum;}

    void SetTemperatureMap(double *T=0,int NT=0);
    TemperatureMap *GetTemperatureMap(){return fTemperatureMap;}
    BasePriority *GetBasePriority(){return fBasePriority;}      
    void SetBasePriority(BasePriority *UserBasePriority);       


    void SetReactionListInitMethod(TSpecificFunctor<ReactionList>* method){fReactionListInitMethod=method;}
    TFunctor* GetReactionListInitMethod(){return fReactionListInitMethod;}      
    
    

    void SetDATADIR(string name="");
    string GetDATADIR(){return fDataDirectoryName;} 
    

    void SetEnsdfDATADIR(string name="");
    string GetEnsdfDATADIR(){return fEnsdfDataDirectoryName;} 

    void SetNucleiChartFileName(string name="chart.JEF3T");
    string GetNucleiChartFileName(){return fNucleiChartFileName;} 
    

    void SetReactionDataFileName(string name="AvailableReactionChart.dat");
    string GetReactionDataFileName(){return fReactionDataFile;} 
    

    void SetMassDataFileName(string name="Mass.dat");
    string GetMassDataFileName(){return fMassDataFileName;} 
    

    void SetNaturalIsotopeMassFileName(string name="NaturalIsotopeMass.dat");
    string GetNaturalIsotopeMassFileName(){return fNaturalIsotopeMassFileName;} 
    

    void SetFPASCIIFileName(string name="FPavailable.dat");
    char *GetFPASCIIFileName(){return (char*)(fFPASCIIFileName.c_str());} 
    

    void SetFPBinaryFileName(string name="FPyield.bin");
    char *GetFPBinaryFileName(){return (char*)(fFPBinaryFileName.c_str());} 
    void SetBaseSummaryFileName(string name="BaseSummary.dat");             
    string GetBaseSummaryFileName(){return fBaseSummaryFileName;}           
    
    void ReadEvolvingCellCompositions(string filename); 
    void WriteEvolvingCellCompositions(string filename);

    void ReadBinaryEvolutionData(string filename);  
    void WriteBinaryEvolutionData(string filename); 
    
    void ReadEvolutionData(string filename);        
    void WriteEvolutionData(string filename);       
                                                    
    void WriteKeffData();       
    void WriteNFissionsData();  
    void ReadSpecialIsomerFile();
    void SetSpecialIsomerFileName(string name="");



    void SetMCNPRunDirectory(string name="MUREOutput", string option="");
    string GetMCNPRunDirectory(){return fMCNPRunDirectory; }    
    void BuildMCNPFile(string FileString="");                   
    void SetMCNPExec(string Exec="mcnp4c"){fMCNPExec=Exec;}     
    string GetMCNPExec() {return fMCNPExec;}                    
    string GetMCNPInputFileName(){return fMCNPInputBaseFileName;} 
    string GetRealMCNPInputFileName(){return fMCNPInputFileName;} 
    string GetMFileName(){return fMFileName;}   
    void SetMCNPInputFileName(string Name){fMCNPInputBaseFileName=Name;} 
    void SetRealMCNPInputFileName(string Name){fMCNPInputFileName=Name;} 
    void RunMCNP();             
    void RunMultiMCNP(int n);   
    void SetRunMultiMCNP(int n){fRunMultiMCNP=n;}   
    void FindMCNPRunDirectory(string OriginalMCNPRunDir);   
    void ConstructFileName(string FileName);                
    string ConstructFileName(string FileName,int EvoNum,int ThermoNum=-1);  
    

    void SetUseNewDBCN(long int dbcn=-1);



    void SetRemove_r_files(bool flag=true){fRemove_r_files =flag;}  
    bool GetRemove_r_files(){return fRemove_r_files;}               
    void SetWriteBinaryData(bool flag=true){fWriteBinaryData=flag;} 
    void SetWriteASCIIData(bool flag=true){fWriteASCIIData=flag;}   
    bool IsWriteBinaryData(){return fWriteBinaryData;}              
    bool IsWriteASCIIData(){return fWriteASCIIData;}                
    int GetMessageLevel(){return fMessageLevel;}                    
    

    void SetMessageLevel(int level){fMessageLevel=level;}           
    bool GetSilentDebug(){return fSilentDebug;} 
    

    void SetSilentDebug(bool flag=true){fSilentDebug=flag;}
    
  
    

    void SetPVM(int n_processor,bool mcnp4b=false);

    void SetMPI(int n_processor,string MPIExec="mpiexec");
    void SetOMP(int n_thread){fOMP=n_thread;} 
    int GetOMP(){return fOMP;}  
    
    int GetNProcessors(){return fNprocessors;}  
    bool IsMCNP4B(){return fMCNP4B;}            



    void AddSpecialSurface(string);


    void AddSpecial(string);
    

    void SetComment(string Comment="This comment is never read..."){fComment=Comment;}
    string GetComment(){return fComment;}
    void SetPRDMP(string prdmp="2J -1 1"){fPRDMP=prdmp;} 

    void WriteMCNPFileNoTallies(string FileName="inp", bool tmpvol=false);  
    

    void WriteLine(string line,ostream &Out=cout,int IsComment=0,int IsTruncated=0, char separator='&');
  

    void SetAllFissionEnergies(double Energy=2.0e08);
    double GetFissionEnergies() {return fSetAllFissionEnergies;} 


    void SetFissionReleasedFile(string name){fFissionReleasedFN=name;}
    string GetFissionReleasedFile(){return fFissionReleasedFN;} 


    void FitTallyNormalizationFactor();
    bool IsFitTallyNormalizationFactor(){return fFittedTNF;}    
    void SetFitTallyNormalizationFactor(){fFittedTNF=true;}     
    

    int GetMCNPFissionsPerSecondSize(){return fMCNPFissionsPerSecond.size();}

    double GetMCNPFissionsPerSecond(int i){return fMCNPFissionsPerSecond[i];}

    void SetMCNPFissionsPerSourceNeutron(int i,double val){fMCNPFissionsPerSecond[i]=val;}

    void AddToMCNPFissionsPerSourceNeutron(int i,double val){fMCNPFissionsPerSecond[i]+=val;}

    double NormalizeMCNPFissionsPerSecond();
    void UpdateTallyNormalizationFactor();  
    double GetTallyNormalizationFactor();   
    void SetTallyNormalizationFactor(double val){fTallyNormalizationFactor=val;}

    void SetCorrectNormalizationFactor(bool flag=true) {fCorrectNormalizationFactor=flag;}
    bool GetCorrectNormalizationFactor() {return fCorrectNormalizationFactor;}


    

    void SetNrk(int Nrk=10) {fNrk = Nrk;}

    void SetDTRK(double dt=-1) {fDTRK = dt;}

    void SetMaxDtRK(double dtmax=-1) {fDTMaxRK = dtmax;}
    
    int GetNrk(){return fNrk;} 

    void SetXe135Equilibrium(double t=3*9.14*3600); 
    bool IsXe135Equilibrium(){return fXe135Equilibrium;} 
    double GetXe135EquilibriumTime(){return fXe135EquilibriumTime;}


    int FindLastMCNPRunNumber();                                    
    void SetCurrentMCNPTime(double time){fCurrentMCNPTime=time;}    
    double GetCurrentMCNPTime(){return fCurrentMCNPTime;}           
    void SetNextMCNPTime(double time){fNextMCNPTime=time;}          
    double GetNextMCNPTime(){return fNextMCNPTime;}                 
    void SetCurrentTime(double time){fCurrentTime=time;}            
    double GetCurrentTime(){return fCurrentTime;}                   
    double GetCurrentRKStep(){return fCurrentRKStep;}               
    int GetCurrentRKNumber(){return fCurrentRKNumber;}              
    int GetMCNPRunNumber(){return fMCNPRunNumber;}                  
    int GetMCNPThermoRunNumber(){return fMCNPThermoRunNumber;}      
    void SetMCNPThermoRunNumber(int value=0){fMCNPThermoRunNumber=value;}
    void IncreaseMCNPThermoRunNumber() {fMCNPThermoRunNumber++;}    
    double GetTimeUnitConverter(){return fTimeUnitConverter;} 
    string GetTimeUnit(){return fTimeUnit;}                   
    void SetTimeUnit(double t);                               


    

    void SetPartialMCNPRun(bool flag=true){fPartialMCNPRun=flag;}      
    bool IsPartialMCNPRun(){return fPartialMCNPRun;}                
    bool IsPartialParticleMCNPRun(){return fPartialParticleMCNPRun;}
    
    void SetPartialMCNPRunDirectory(string name="PartialRun"){fPartialMCNPRunDir=name;}
    void SetSourcePartialFactor(int N=2){fSourcePartialFactor=N;}   
    int GetSourcePartialFactor(){return fSourcePartialFactor;}      

  
    

    void KeepOnlyFissionProductSelection(string name="");
    string GetKeepOnlyFissionProductSelectionFN(){return fKeepOnlyFissionProductSelectionFN;} 
    bool IsOnlyFissionProductSelection(){return fKeepOnlyFissionProductSelection;}  
    void SetReactionThreshold(double sigma=1e-2){fReactionThreshold=sigma+1e-9;}
    double GetReactionThreshold(){return fReactionThreshold;}                   
    

    void SetMCNPNucleusThreshold(double epsilon=1e-6){fMCNPNucleusThreshold=epsilon;}
    double GetMCNPNucleusThreshold(){return fMCNPNucleusThreshold;}             
    

    void SetListOfWantedNucleiFN(string name){fListOfWantedNucleiFN=name;}
    string GetListOfWantedNucleiFN(){return fListOfWantedNucleiFN;} 
    

    void SetShortestHalfLife(double time=3600){fShortestHalfTimeThres=time;}
    double GetShortestHalfLife(){return fShortestHalfTimeThres;}
    

    void SetReactionDepth(int depth=10000){fReactionDepth=depth;}
    int GetReactionDepth(){return fReactionDepth;}  
  
  

    void RebuildPerturbativeMaterials(); 

    void RebuildTallies();                         
    vector<ReactorMesh*> GetReactorMeshVector() {return fReactorMesh;}          
    void SetNewReactorMeshObject(ReactorMesh* RM) {fReactorMesh.push_back(RM);} 
    void BuildCOBRAFiles(); 

    void SetCOBRACalculationRequired(int NumberOfIteration) {fNumberOfIterationNTH=NumberOfIteration;fCOBRACalculationRequired=true;fThermoHydraulicsRequired=true;} //@- say that COBRA Calculation is required during Fuel Depletion with NumberOfIterations N/TH a each fuel depletion step
    void SetThermoHydraulicsRequired(bool flag=true) {fThermoHydraulicsRequired=flag;} //@- say that thermo is needed
    bool IsThermoHydraulicsRequired(){return fThermoHydraulicsRequired;}    //@- returns true if thermo is needed
    void SetUserDefaultHydraulicModel() {fUserDefaultHydraulicModel=true;} //@- use the default MURE team hydraulics models instead of COBRA ones
  
    void StartGUI();                    

    void PlotGeometry(bool Continue=0); 
    
    void SetEvolutionRequired(bool flag=true) {fEvolutionRequired=flag;} 
    bool IsEvolutionRequired(){return fEvolutionRequired;}          

    void WriteGlobalNucleiTree(string fname="UnionOfAllTrees.dat"); 
    void IntegrateMassInEvolvingCells();    
    double GetTotalAtoms();

    double GetKeff(){return fKeff;}         
    double GetKeff_Err(){return fKeff_Err;} 
    void SetKeff(double k){fKeff=k;}        
    void UpdateKeff();                      
        
    void AddToGlobalNucleiVector(Nucleus_ptr &nuc);             
    void AddToNucleiErrorMap(Nucleus* nuc, string ErrType) {fNucleiErrorMap[nuc]+= " "+ErrType;} 
    void SumUpNucleiError(ostream &Out=cerr) ;              
    vector <Nucleus_ptr> GetGlobalNucleiVector() {return fGlobalNucleiVector;} 
    map<Nucleus*, string> &GetNucleiErrorMap() {return fNucleiErrorMap;}    
        
    void SetAutoXSDIR(bool cond=true){fIsAutoXSDIR=cond;} 
    void BuildXSDIR(); 
    void RemoveXSDIR() {stringstream m; m<<"rm "<<GetMCNPRunDirectory()<<"/xsdir";system(m.str().c_str());} 
    string GetXSDIRName() {return fXSDIRName;} 
    
    void SetESpectrum(){fSetESpectrum=true;} 
    void UseEnergyBinsFile(string Filename); 
 
    bool IsCooling(int MCNPRunNumber);  
    void SetCooling(vector<bool> C);    
    void SetMCNPUserDefinedGeometry(){fMUREInputGeometry=false;}    
    bool IsMCNPUserDefinedGeometry(){return !fMUREInputGeometry;}   
    void SetUserGeometryInputFile(string name); 
    void FindTallyInMCNPUserFile();
         
    void SaveBackupMureFile(string TheFileName); 


    void VerifyPower(); 
    
    void BuildPerturbativeMaterials();  
    string GetTotalRunTime();           
    double GetRunTime() {return (time(0)-fStartTime);} 
    
    void Dump();        
    void Annihilate();  

    bool BaseSummaryReadIn() {return fBaseSummaryReadIn;}               
    void ReadInBaseSummary();                                           
    string GetBaseSummaryLine(int i);                                   
    void AddLineToBaseSummary(string line);
    int GetFirstContinuousZIndexInBaseSummary(int z){return fFirstContinuousZIndexInBaseSummary[z];} 
    int GetFirstThermalZIndexInBaseSummary(int z){return fFirstThermalZIndexInBaseSummary[z];}      
    

    void FitSigmaPhi(bool flag=true){fFitSigmaPhi=flag;}
    bool IsFitSigmaPhi(){return fFitSigmaPhi;}      
    int GetFitRangeNumber(){return fFitRange;}      
    void SetFitRangeNumber(int n=4){fFitRange=n;}   


    void SmoothSigmaPhi(bool flag=true){fSmoothSigmaPhi=flag;}
    bool IsSmoothSigmaPhi(){return fSmoothSigmaPhi;}
    bool IsFitSigmaPhiPC(){return fFitSigmaPhiPC ;} 
    void SetFitSigmaPhiPC(bool flag=true){fFitSigmaPhiPC=flag;} 
    

    void BuildTallies();

    void BuildTalliesMultiGroup();

    void BuildTHTalliesMultiGroup();

    void UpdateSigmaPhi();

    void UpdateSigmaPhiMultiGroup();
    /*
     Only for "pertubative material" automatically built, the flux is normalized using the TallyNormalizationFactor.
    */
    void UpdateSigma();

    void UpdateTHSigmaPhiMultiGroup();
    void AddTally(Tally *T); 

    void AddMeshTally(MeshTally *MT); 

    void TransMogrify();            
    void PredictorTransMogrify();   

    
    
    void SetMaterialNum(unsigned num){fLastMaterialNum=num;}    
    unsigned GetMaterialNum(){return fLastMaterialNum;}         
    
    unsigned NextCellNum();     
    unsigned NextSurfaceNum();  
    unsigned NextMaterialNum(); 
    unsigned NextUniverseNum(); 
    unsigned NextTallyNum(int type);
    unsigned NextTransformNum();    
    void SetLastTallyNum(int Num);  
    
    void AddCell(Cell *theCell){fCellVector.push_back(theCell);}    
    void AddMaterial(Material *theMaterial);                        
    void DontAddMaterial(){fAddMaterial=false;}
    bool AllowToAddMaterial(){return fAddMaterial;}
    void AddSurface(Surface *theSurface);                           
    void AddEvolutiveSystem(EvolutiveSystem *theEvolutiveSystem);   
    void AddOutCoreEvolutiveSystem(EvolutiveSystem *theEvolutiveSystem);

    vector<Cell*> GetTrueCellVector(){return fTrueCellVector;}      
    
    void RemoveSurface(vector <Surface *>::iterator it);            
    vector<Surface *> &GetSurfaceVector(){return fSurfaceVector;}   
    void AddUnknownVolume(Cell *theCell);                           
    void AddUnknownSurface(Shape *theShape);                        
    vector<Cell *> &GetCellVector() {return fCellVector;}           
    void RemoveMaterial(Material *TheMaterial);                     
    Cell* FindCell(Cell *TheCell);                                  
    Cell* FindCell(int CellNo);                                     
    Material* FindMaterial(Material *TheMaterial);                  
    Material* FindMaterial(int MaterialNumber);                     
    Material* FindPerturbativeMaterial(Nucleus_ptr TheNucleus);     
    Material* FindPerturbativeMaterial(Material *TheCellMat);       
    vector<Tally*> & GetTallyVector(){return fTallyVector;}
    vector<Material*> GetPerturbativeMaterial() {return fPerturbativeMaterial;} 
    void AddZAIThatFissions(ZAI *zai);  
    vector<EvolutiveSystem *> GetEvolutiveSystemVector(){return fEvolutiveSystemVector;} 
    vector<EvolutiveSystem *> GetOutCoreEvolutiveSystemVector(){return fOutCoreEvolutiveSystemVector;} 
    vector<Material *> &GetMaterialVector(){return fMaterialVector;}    
    vector<ZAI *> &GetZAIThatFission(){return fZAIThatFission;}     
    vector<SpecialIsomer> &GetSpecialIsomerVector(){return fSpecialIsomerVector;}
  
    

    bool GetMCNPVolume();   

    void FindMissingVolume(); 
    
    void SetVolumeNPS(int nps=400000){fVolumeNPS=nps;}      
    void SetVolumeWarning(double variance=0.005){fVolumeWarning=variance;} 
    void SetSourceSphereRadius(double R){fSourceSphereR=R;} 
    void SetSourceSphereCenter(double *O){fSourceSphereO=O;}
    void AddToNuSigmaFisPhiTotal(double Value) {fNuSigmaFisPhiTotal+=Value;} 
    bool IsNucleusUsedForBeta(int Z, int A); 
    void SumAllCellToBetaCalculation(); 
    void CalculateBetaI(); 
    void SetBetaCalculation() {fBetaCalculationRequired=true;} 
    void ResetAllBetaValues(); 
    void FinishOnMCNPRun(bool flag=true){fFinishOnMCNPRun=flag;}    
    double FindFissileEnrichment(double DesiredKeff, double EnrichmentFirstGuess, Material* Fertile, Material* Fissile, Material* Target);

 private:
    
    void UpdateMaterial();      
    void Delete();              
    void Copy(const MURE &m);   
    void WriteCell(ostream &Out); 
    void WriteSurface(ostream &Out,bool tmpvol=false);  
    void WriteMaterial(ostream &Out);                   
    void WriteMCNPFile(string FileName="inp",bool tmpvol=false);
    void CopyMCNPFile(string FileName); 
    void FindExtrapolateSigmaPhi();     

    void InitTNFFit();          
    void CheckExtensions();     
    void CheckCompositions();   
    
    int fMessageLevel;          
    bool fSilentDebug;          
    unsigned fLastCellNum;      
    unsigned fLastSurfaceNum;   
    unsigned fLastMaterialNum;  
    unsigned fLastUniverseNum;  
    int  fLastTallyNum[8];      
    unsigned fLastTransformNum; 
    string   fComment;          
    string   fMCNPExec;         
    int      fVolumeNPS;        
    double   fVolumeWarning;    
    double   fSourceSphereR;    
    double*  fSourceSphereO;    
    MCNPSource*     fSource;    
    vector<Cell *>      fCellVector;    
    vector<vector<Cell *> >     fGroupCellVector;   
    vector<Material *>  fMaterialVector;
    vector<Cell *>      fTrueCellVector;
    vector<Surface *>   fSurfaceVector; 
    vector<Tally*>      fTallyVector;   
    vector<MeshTally*>  fMeshTallyVector;   
    vector<string>      fSpecialSurfaceCard;
    vector<string>      fSpecialCard;   
    vector<EvolutiveSystem *>  fEvolutiveSystemVector;          
    vector<EvolutiveSystem *>  fOutCoreEvolutiveSystemVector;   
    
    vector<Cell *>      fCellofUnknownVol;  
    vector<Shape *>     fSurfofUnknownArea; 
    string              fDataDirectoryName; 
    string              fEnsdfDataDirectoryName;
    string              fMCNPRunDirectory;  
    string              fMCNPInputBaseFileName; 
    string              fMCNPInputFileName;     
    string              fMFileName;             
    string              fNucleiChartFileName;   
    string              fReactionDataFile;      
    string              fMassDataFileName;      
    string              fNaturalIsotopeMassFileName;
    string              fFPASCIIFileName;       
    string              fFPBinaryFileName;      
    string              fBaseSummaryFileName;   
    double              fShortestHalfTimeThres; 
    int                 fReactionDepth;         
    double              fMeanEnergySpectrum;    
    string              fMode;              
    string              fPRDMP;                 
    vector<Nucleus_ptr>     fGlobalNucleiVector;
    vector<Material*>       fPerturbativeMaterial;
        
    vector<ZAI *>           fZAIThatFission;    
    vector<double>          fMCNPFissionsPerSecond; 
    
    TemperatureMap          *fTemperatureMap;   
    map<Nucleus*,string>    fNucleiErrorMap;    
    bool                    fEvolutionRequired; 
    bool                    fThermoHydraulicsRequired;
    bool                    fCOBRACalculationRequired;
    int                     fNumberOfIterationNTH;
    bool                    fUserDefaultHydraulicModel; 
    BasePriority            *fBasePriority;     
    bool                    fFromCopy;          
    bool                    fFromRebuildTallies;
    bool                    fMaterialUpdated;   
    TFunctor                *fReactionListInitMethod;
    
    double  fPower;                     
    double  fTallyNormalizationFactor;  
                                         
    double  fReactionThreshold; 
    string  fXSDIRName ;        
    bool    fIsAutoXSDIR ;      
    double  fCurrentMCNPTime;   
    double  fNextMCNPTime;      
    double  fCurrentTime;       
    double  fKeff;              
    double  fKeff_Err;          
    int fNrk;                    
    double  fDTRK;              
    double fDTMaxRK;            
    string  fSourceFile;        
    string  fOriginalSourceFile;        
    bool    fUsePrevSource;     
             
    bool    fFitSigmaPhi;       
    bool    fSmoothSigmaPhi;    
    int     fMCNPRunNumber;     
    int     fMCNPThermoRunNumber; 
    int     fCurrentRKNumber;   
    double  fCurrentRKStep;     
    int     fFitRange;          
    double  fDeltaK;            
    double  fConstantK;         
    bool    fMaterialControl;   
    vector<Cell*>   fControlRodCell; 
    bool    fSetESpectrum;      
    bool fUseEnergyBinsFile;    
    string fEnergyBinsFileName; 
    
    EvolutionControl    *fEvolutionControl; 
    double  fMCNPNucleusThreshold;          

    map<Reaction,ValErr_t,EqualReaction>    fControlRate ;
    ValErr_t fGlobalAbsorptions;        
    ValErr_t fGlobalFissions;           
    ValErr_t fGlobalNuFissions;         
    ValErr_t fGlobalN2N;                
    ValErr_t fGlobalN3N;                
    ValErr_t fGlobalNeutronLosses;      
    
    int fGlobalLossesTallyNumber;       
    int fESpectrumTallyNumber;          
    vector<double>fEnergyBins;          
    
    Shape_ptr fOutermostShape;          
    vector<bool> fIsCooling;            
    bool fIsCoolingUsed;                
    bool fMCNP4B;               
    int  fNprocessors;          
    string fMPIExec;            
    bool fPVM;                  
    bool fMPI;                  
    int  fOMP;                  
    MCNPSource* fReactivityCoeffsSource ;
    
    bool fRemove_r_files;           
    double fSetAllFissionEnergies;  
    bool fBrutalStop;           
    double fBrutalStopKValue;   
    int fMureDataWritingVersion;
    
    string fFissionReleasedFN;      
    
    bool fMUREInputGeometry;        
    string fUserGeometryInputFile;  
    
    bool fKeepOnlyFissionProductSelection;      
    string fKeepOnlyFissionProductSelectionFN;  
    
    vector<double>  fFitTNF;            
    vector<double>  fMCNPTimeForFit;    
    double fFitTNFSlope;                
    double fInterseptTNF;               
    bool fFittedTNF;                    
    bool fTallyRebuild;                 
    
    bool fPartialMCNPRun;           
    bool fPartialParticleMCNPRun;   
    string fPartialMCNPRunDir;      
    int fSourcePartialFactor;       
    
    string fListOfWantedNucleiFN;   
    bool    fWriteBinaryData;       
    bool    fWriteASCIIData;        
    bool    fCorrectNormalizationFactor; 
    double  fTimeUnitConverter; 
    string  fTimeUnit;          
    int fRunMultiMCNP;          
    int fStartTime;             
    vector<ReactorMesh*> fReactorMesh;  
    bool    fMultigroupTallies;         
    bool    fTHMultigroupTallies;           
    int     fMultiGroupDecadeMultiplcator; 
    bool    fU8StdTally;                   
        
    bool fPredictorCorrector;           
    double fPCEvaluationTime;           
    bool fPredictorStep;                
    bool fFitSigmaPhiPC;                
    double fInitHNMassInTon;            
    vector<string> fBaseSummary;        
    bool fBaseSummaryReadIn;            
    vector<int> fFirstContinuousZIndexInBaseSummary;
    vector<int> fFirstThermalZIndexInBaseSummary;
    bool fBetaCalculationRequired;      
    double fNuSigmaFisPhiTotal;         
    vector<double> fNSigmaFisPhiTotalOfNucleus; 
    long int fRandomSeedGenerator; 
    bool fFinishOnMCNPRun;  
    bool    fAddMaterial; 
    vector<SpecialIsomer>   fSpecialIsomerVector;   
    string  fSpecialIsomerFileName;                 
    bool fXe135Equilibrium;         
    double fXe135EquilibriumTime;  


}; 

#endif