MURE.hxx

Go to the documentation of this file.

/*
  This file is part of MURE,
  Copyright (C) 2007-2021 MURE developers.
 
  MURE is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  MURE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with MURE.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef _MURE_HXX_
#define _MURE_HXX_
 
#include <fstream>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
 
#include "MUREGlobal.hxx"
#include "TFunctor.hxx"
 
#include "TemperatureMap.hxx"
#include "BasePriority.hxx"
#include "SpecialIsomer.hxx"
 
#include "ConnectorPlugin.hxx"
#include "EvolutionSolver.hxx"
 
#include "SurfaceCard.hxx"
#include "Shape.hxx"
#include "Cell.hxx"
#include "PinCell.hxx"
 
#include "MCSource.hxx"
//#include "ReactorMesh.hxx"
#include "MureTally.hxx"
#include "MeshTally.hxx"
#include "MureTimeEnergyGrid.hxx"
 
using namespace std;
 
 
class MURE
{
    friend class MureTrojan;
  public:
    MURE(string name = "xsdir");
    MURE(const MURE &m);        
    ~MURE();                    
    void Delete(bool DeleteConnector = true); 
    void Copy(const MURE &m);   
 
 
    void SetConnectorPlugin(ConnectorPlugin *plugin);
 
    ConnectorPlugin *GetConnectorPlugin(); 
 
 
    void SetMessageLevel(int level)
    {
        fMessageLevel = level;
    }
    int GetMessageLevel()
    {
        return fMessageLevel;   
    }
 
 
    void SetSilentDebug(bool flag = true)
    {
        fSilentDebug = flag;
    }
    bool GetSilentDebug()
    {
        return fSilentDebug;   
    }
 
 
 
    void Evolution(
        vector < double > T,    
        int Start = 0,          
        bool BrutalStop = false 
    );
 
    bool IsEvolutionRequired()
    {
        return fEvolutionRequired;   
    }
    void SetEvolutionRequired(bool flag = true)
    {
        fEvolutionRequired = flag;   
    }
    void SetPower(double Power)
    {
        GetEvolutionSolver() -> SetPower(Power);   
    }
 
    EvolutionSolver *GetEvolutionSolver()
    {
        return fEvolutionSolver;   
    }
 
    void AddList2DepletionTallyList(vector<ZAI *> NucleiList, int matnum);
    void AddZAI2GlobalDepletionTallyList(ZAI Nuclei);
    bool IsInDepletionList(ZAI *deplzai, int matnum);
    void PrintDepletionTallyList();
    int GetSizeOfDepletionTallyList()
    {
        return int(fMatnumDepletionTallyList.size());
    }
    vector<vector<ZAI *>> GetDepletionTallyListZAI()
    {
        return fZAIDepletionTallyList;
    }
    vector<int> GetDepletionTallyListINT()
    {
        return fMatnumDepletionTallyList;
    }
 
 
    void SetTallyNormalizationFactor(double val)
    {
        GetEvolutionSolver() -> SetTallyNormalizationFactor(val);
    }
 
    void SetAllFissionEnergies(double Energy = 2.0e08);
    double GetFissionEnergies()
    {
        return fSetAllFissionEnergies;   
    }
 
 
    void SetFissionReleasedFile(string name);
    string GetFissionReleasedFile()
    {
        return fFissionReleasedFN;   
    }
 
 
 
 
    void SetSource(MCSource *source);
    MCSource *GetSource();      
 
    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 = nullptr, int NT = 0);
    void SetTemperatureMap(TemperatureMap *TM);
    TemperatureMap *GetTemperatureMap()
    {
        return fTemperatureMap;   
    }
    BasePriority *GetBasePriority()
    {
        return fBasePriority;   
    }
    void SetBasePriority(BasePriority *UserBasePriority);       
 
 
    void SetReactionListInitMethod(TSpecificFunctor < ReactionList > *method)
    {
        fReactionListInitMethod = method;
    }
    TFunctor *GetReactionListInitMethod()
    {
        return fReactionListInitMethod;   
    }
 
 
 
 
    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 SetMCNucleusThreshold(double epsilon = 1e-6)
    {
        fMCNucleusThreshold = epsilon;
    }
    double GetMCNucleusThreshold()
    {
        return fMCNucleusThreshold;   
    }
    void SetExtendedReactionList()
    {
        fExtendedReactionList = true;
    }
    bool GetExtendedReactionList()
    {
        return fExtendedReactionList;
    }
 
 
    void SetListOfWantedNucleiFN(string name)
    {
        fListOfWantedNucleiFN = name;
    }
    string GetListOfWantedNucleiFN()
    {
        return fListOfWantedNucleiFN;   
    }
 
 
    void SetShortestHalfLife(double time = 3600)
    {
        fShortestHalfTimeThres = time;
    }
    double GetShortestHalfLife()
    {
        return fShortestHalfTimeThres;   
    }
 
 
    void AddReactionNameForcedCut(string NewReactionNameForcedCut);
 
    vector < string > GetReactionNamesForcedCutVector();
 
    void SetReactionNumbersForcedCutVector(vector < int > ReactionNumbersForcedCutUser)
    {
        fReactionNumbersForcedCutVector = ReactionNumbersForcedCutUser;
    }
 
    void AddReactionNumberForcedCut(int NewReactionNumberForcedCut)
    {
        fReactionNumbersForcedCutVector.push_back(NewReactionNumberForcedCut);
    }
 
    vector < int > GetReactionNumbersForcedCutVector()
    {
        return fReactionNumbersForcedCutVector;
    }
 
    vector < string > GetAllPossibleReactionNames();
    void SetZAIsForcedCutVector(vector < ZAI *> ZAIsForceCutUser)
    {
        fZAIsForcedCutVector = ZAIsForceCutUser;   
    }
    void AddZAIForcedCut(int Z, int A, int I = 0); 
    vector < ZAI *> GetZAIsForcedCutVector()
    {
        return fZAIsForcedCutVector;   
    }
    void PutElasticXSinDATA(bool RegisterElasticXSinDATA = true)
    {
        fRegisterElasticXSinDATA = RegisterElasticXSinDATA;   
    }
    bool IsElasticXSinDATA()
    {
        return fRegisterElasticXSinDATA;   
    }
 
 
    void SetReactionDepth(int depth = 10000)
    {
        fReactionDepth = depth;
    }
    int GetReactionDepth()
    {
        return fReactionDepth;   
    }
 
 
    void SetDATADIR(string name = "");
    string GetDATADIR()
    {
        return fDataDirectoryName;   
    }
 
 
    string GetEnvVar(const std::string envName);
    string GetDATAPATH();
 
 
    void SetEnsdfDATADIR(string name = "");
    string GetEnsdfDATADIR()
    {
        return fEnsdfDataDirectoryName;
    }
 
    void SetNucleiChartFileName(string name = "chart.jeff3.1.1");
 
    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 ReadSpecialIsomerFile(map<int, map<int, map<int, ZAI *> > > &TheChart); 
    void SetSpecialIsomerFileName(string name = ""); 
    vector<SpecialIsomer> &GetSpecialIsomerVector()
    {
        return fSpecialIsomerVector;   
    }
 
 
    void SetMCExec(string Exec)
    {
        fMCExec = Exec;
    }
    string GetMCExec()
    {
        return fMCExec;   
    }
 
 
    void SetUseNewRandomSeed(long int dbcn = - 1);
    long int GetRandomSeed()
    {
        return fRandomSeedGenerator;
    }
 
 
    void SetAutoXSDIR(bool cond = true)
    {
        fIsAutoXSDIR = cond;
    }
    bool IsAutoXSDIR()
    {
        return fIsAutoXSDIR;   
    }
 
    void RemoveXSDIR(); 
 
    void SetXSDIRName(string acefile = "xsdir")
    {
        fXSDIRName = acefile;   
    }
    string GetXSDIRName()
    {
        return fXSDIRName;   
    }
 
 
    void SetMCRunDirectory(string name = "MUREOutput", string option = "");
    string GetMCRunDirectory()
    {
        return fMCRunDirectory;   
    }
    void FindMCRunDirectory(string OriginalMCRunDir);  
    void BuildMCFile(string FileString = "");          
 
    string GetMCInputBaseFileName()
    {
        return fMCInputBaseFileName;   
    }
    string GetRealMCInputFileName()
    {
        return fMCInputFileName;   
    }
    void SetMCInputFileName(string Name)
    {
        fMCInputBaseFileName = Name;   
    }
    void SetRealMCInputFileName(string Name)
    {
        fMCInputFileName = Name;   
    }
    void SetMaximumNumberOfDigitInEvolution(int maxi){fNbOfDigitInEvo = maxi;}  
    int  GetMaximumNumberOfDigitInEvolution(){return fNbOfDigitInEvo;}          
    void ConstructFileName(string FileName);    
    string ConstructFileName(string FileName, int EvoNum, int ThermoNum = - 1); 
    bool IsAutoNumberFileName()
    {
        return fAutoNumberFileName;   
    }
    void SetAutoNumberFileName(bool flag)
    {
        fAutoNumberFileName = flag;   
    }
 
    void SetRunMultiMC(int n)
    {
        fRunMultiMC = n;   
    }
    int GetRunMultiMC()
    {
        return fRunMultiMC;   
    }
    void RunMultiMC(int n); 
    void RunMC();           
 
 
 
    void SetPVM(int n_processor);
    bool IsPVM()
    {
        return fPVM;   
    }
 
 
    void SetMPI(int n_processor, string MPIExec = "mpiexec");
    bool IsMPI()
    {
        return fMPI;   
    }
    string GetMPIExec()
    {
        return fMPIExec;   
    }
 
 
    void SetOMP(int n_thread)
    {
        fOMP = n_thread;   
    }
    int GetOMP()
    {
        return fOMP;   
    }
 
    int GetNProcessors()
    {
        return fNprocessors;   
    }
 
 
 
    void AddSpecialCard(string);
    vector < string >  &GetSpecialCard()
    {
        return fSpecialCard;   
    }
    void SetSpecialCard(int i, string str)
    {
        fSpecialCard[i] = str;   
    }
 
    void SetComment(string Comment = "This comment is never read...")
    {
        fComment = Comment;   
    }
    string GetComment()
    {
        return fComment;   
    }
 
    void AddSpecialSurface(string);
 
    vector < string >   GetSpecialSurfaceCard()
    {
        return fSpecialSurfaceCard;   
    }
 
 
    int GetMCNPThermoRunNumber()
    {
        return fMCNPThermoRunNumber;   
    }
    void SetMCNPThermoRunNumber(int value = 0)
    {
        fMCNPThermoRunNumber = value;   
    }
    void IncreaseMCNPThermoRunNumber()
    {
        fMCNPThermoRunNumber++;   
    }
    //vector<ReactorMesh*> GetReactorMeshVector() {return fReactorMesh;}       //!< Returns the reactor mesh vector
    //void SetNewReactorMeshObject(ReactorMesh *RM) {fReactorMesh.push_back(RM);} //!< Add a new ReactorMesh Object into the vector
    void BuildCOBRAFiles();  
 
    void SetCOBRACalculationRequired(int NumberOfIteration)
    {
        fNumberOfIterationNTH = NumberOfIteration;    //@- say that COBRA Calculation is required during Fuel Depletion with NumberOfIterations N/TH a each fuel depletion step
        fCOBRACalculationRequired = true;
        fThermoHydraulicsRequired = true;
    }
    void SetThermoHydraulicsRequired(bool flag = true)
    {
        fThermoHydraulicsRequired = flag;   //@- say that thermo is needed
    }
    bool IsThermoHydraulicsRequired()
    {
        return fThermoHydraulicsRequired;   //@- returns true if thermo is needed
    }
 
    //void BuildTHTalliesMultiGroup();
 
    //void UpdateTHSigmaPhiMultiGroup();
    void SetUserDefaultHydraulicModel()
    {
        fUserDefaultHydraulicModel = true;   //@- use the default MURE team hydraulics models instead of COBRA ones
    }
 
    double GetKeff()
    {
        return fKeff;   
    }
    double GetKeff_Err()
    {
        return fKeff_Err;   
    }
    void SetKeff(double k)
    {
        fKeff = k;   
    }
    void SetKeff_Err(double dk)
    {
        fKeff_Err = dk;   
    }
    void UpdateKeff();  
 
    bool IsVolumeCalculationNeeded(); 
    void FindMissingVolume(); 
    void SetVolumeNPS(int nps = 400000)
    {
        fVolumeNPS = nps;   
    }
    int  GetVolumeNPS()
    {
        return fVolumeNPS;   
    }
    void SetVarianceVolumeWarning(double variance = 0.005)
    {
        fVarianceVolumeWarning = variance;   
    }
    double GetVarianceVolumeWarning()
    {
        return fVarianceVolumeWarning;   
    }
 
    void SetOutermostShape(Shape_ptr s)
    {
        fOutermostShape = s;
    }
    Shape_ptr GetOutermostShape()
    {
        return fOutermostShape;   
    }
    void SetOutermostCell(Cell *c)
    {
        fOutermostCell = c;
        SetOutermostShape(fOutermostCell->GetShape());
    }
    Cell *GetOutermostCell()
    {
        return fOutermostCell;   
    }
 
    void SetSourceSphereRadius(double R)
    {
        fSourceSphereR = R;   
    }
    void SetSourceSphereCenter(double *O)
    {
        fSourceSphereO = O;   
    }
    double GetSourceSphereRadius()
    {
        return fSourceSphereR;   
    }
    double *GetSourceSphereCenter()
    {
        return fSourceSphereO;   
    }
 
    void AddCellOfUnknownVolume(Cell *theCell); 
    void AddShapeOfUnknownArea(Shape *theShape);
    vector < Cell *>  &GetCellOfUnknownVolume()
    {
        return fCellOfUnknownVolume;
    }
    vector < Shape *> &GetShapeOfUnknownArea()
    {
        return fShapeOfUnknownArea;
    }
    Cell *FindCellOfUnknownVolume(int CellNo);
    void SetFromVolumeCalculation(bool flag)
    {
        fIsFromVolumeCalculation = flag;
    }
    bool GetFromVolumeCalculation()
    {
        return fIsFromVolumeCalculation;
    }
 
 
 
    void StartGUI();  
 
    void IntegrateMassInEvolvingCells();  
    double GetTotalAtoms();  
 
    void WriteGlobalNucleiTree(string fname = "UnionOfAllTrees.dat"); 
    void AddToGlobalNucleiVector(Nucleus_ptr &nuc);  
    void AddToNucleiErrorMap(Nucleus *nuc, string ErrType)
    {
        fNucleiErrorMap[nuc] += " " + ErrType;   
    }
    void SumUpNucleiError(ostream &Out = cerr) ;  
    map < Nucleus *, string > &GetNucleiErrorMap()
    {
        return fNucleiErrorMap;   
    }
    vector < Nucleus_ptr > &GetGlobalNucleiVector()
    {
        return fGlobalNucleiVector;   
    }
 
    bool IsBaseSummaryRead()
    {
        return fIsBaseSummaryRead;   
    }
    void ReadBaseSummary();             
    string GetBaseSummaryLine(int i);   
    void AddLineToBaseSummary(string line);
    int GetFirstContinuousZIndexInBaseSummary(int z)
    {
        return fFirstContinuousZIndexInBaseSummary[z];   
    }
    int GetFirstThermalZIndexInBaseSummary(int z)
    {
        return fFirstThermalZIndexInBaseSummary[z];   
    }
    void CheckExtensions();    
    void CheckNucleusDataBaseError();
 
    void SetMCNPUserDefinedGeometry()
    {
        fMUREInputGeometry = false;   
    }
    bool IsMCNPUserDefinedGeometry()
    {
        return ! fMUREInputGeometry;   
    }
    void SetUserGeometryInputFile(string name); 
    string GetUserGeometryInputFile()
    {
        return fUserGeometryInputFile;
    }
 
    void SaveBackupMureFile(string TheFileName); 
 
    string GetTotalRunTime();      
    double GetRunTime()
    {
        return (time(nullptr) - fStartTime);   
    }
 
    void Dump();    
    void  CheckMandatoryPointeur(); 
    double FindFissileEnrichment(double DesiredKeff, double EnrichmentFirstGuess, Material *Fertile, Material *Fissile, Material *&Target);
 
    void SetSerpentDopplerBroadening()
    {
        fSerpentDopplerBroadening = true;
    }
    bool IsSerpentDopplerBroadening()
    {
        return fSerpentDopplerBroadening;
    }
    void SetDisableViolentSimplifyNode(bool flag)
    {
        fDisableViolentSimplifyNode = flag;
    }
    bool GetDisableViolentSimplifyNode()
    {
        return fDisableViolentSimplifyNode;
    }
 
 
    void AddTally(MureTally *T); 
    void AddMeshTally(MeshTally *MT); 
    vector < MeshTally *> &GetMeshTally()
    {
        return fMeshTallyVector;   
    }
    vector < MureTally *> &GetTallyVector()
    {
        return fTallyVector;   
    }
    void ResetDetectorVector();
    MureTally *FindTally(int TallyNo);
 
 
    int NextTallyNum(int i = 0);
    void AddTimeEnergyGrid(MureTimeEnergyGrid *TheEnergyGrid); 
    vector < MureTimeEnergyGrid *> GetTimeEnergyGrids(); 
    MureTimeEnergyGrid *FindTimeEnergyGrid(int num);
    bool IsSameTimeEnergyGridForAllTallies()
    {
        return fIsSameTimeEnergyGridForAllTallies;   
    }
    void SetSameTimeEnergyGridForAllTallies();  
    void SetESpectrum()
    {
        fSetESpectrum = true;   
    }
    bool IsESpectrum()
    {
        return fSetESpectrum;   
    }
    void UseEnergyBinsFile(string Filename);    
    vector < double > &GetEnergyBins()
    {
        return fEnergyBins;   
    }
    bool IsUseEnergyBinsFile()
    {
        return fUseEnergyBinsFile;   
    }
    void SetESpectrumTallyNumber(int num)
    {
        fESpectrumTallyNumber = num;   
    }
    int GetESpectrumTallyNumber()
    {
        return fESpectrumTallyNumber;   
    }
 
 
    void SetMaterialNum(int num)
    {
        fLastMaterialNum = num;   
    }
    int GetMaterialNum()
    {
        return fLastMaterialNum;   
    }
 
 
    int NextCellNum();     
    int NextSurfaceNum();  
    int NextMaterialNum(); 
    int NextUniverseNum(); 
 
    int NextTransformationNum();   
    void SetLastTallyNum(int Num);      
 
    vector < Cell *> &GetCellVector()
    {
        return fCellVector;   
    }
    void AddCell(Cell *theCell)
    {
        fCellVector.push_back(theCell);   
    }
    Cell *FindCell(Cell *TheCell);  
    Cell *FindCell(int CellNo);     
    vector < Cell *> &GetTrueCellVector()
    {
        return fTrueCellVector;   
    }
 
    vector < PinCell *> &GetPinCellVector()
    {
        return fPinCellVector;   
    }
    void AddPinCell(PinCell *thePinCell)
    {
        fPinCellVector.push_back(thePinCell);   
    }
    PinCell *FindPinCell(PinCell *pin);
    PinCell *FindPinCell(int Universe);
 
    vector < Material *> &GetMaterialVector()
    {
        return fMaterialVector;   
    }
    void AddMaterial(Material *theMaterial);        
    void RemoveMaterial(Material *TheMaterial);     
    Material *FindMaterial(Material *TheMaterial);  
    Material *FindMaterial(int MaterialNumber);     
 
    void DontAddMaterial()
    {
        fAddMaterial = false;   
    }
    bool IsAllowedToAddMaterial()
    {
        return fAddMaterial;
    }
 
    void AddSurfaceCard(SurfaceCard *card);    
    void RemoveSurfaceCard(vector < SurfaceCard *> ::iterator it);      
    vector < SurfaceCard *> &GetMureSurfaceCardVector()
    {
        return fSurfaceCardVector;   
    }
    void ClearSurfaceCardVector();
 
    void AddTransformation(Transformation *tr)
    {
        fTransformationVector.push_back(tr);   
    }
    vector < Transformation *> &GetTransformationVector()
    {
        return fTransformationVector;   
    }
    Transformation *FindTransformation(int transformation_number);
 
    void SetBetaCalculation(bool flag = true)
    {
        fBetaCalculationRequired = flag;   
    }
    bool IsBetaCalculation()
    {
        return fBetaCalculationRequired;   
    }
    bool IsNucleusUsedForBeta(int Z, int A); 
    void CalculateBetaI(); 
    void SumAllCellToBetaCalculation(); 
    void ResetAllBetaValues(); 
    void SetMaterialForPartialTallyNormalization(int matnum);
    void SetMaterialForPartialTallyNormalization(vector<int> matnum)
    {
        fMaterialForTallyNormalization = matnum;
    };
    vector<int> GetMaterialForPartialTallyNormalization()
    {
        return fMaterialForTallyNormalization;
    };
 
 
  private:
    void PrintBanner();             
    static bool fIsBannerPrinted;   
    
    int     fStartTime;     
    int     fMessageLevel;  
    bool    fSilentDebug;   
 
    bool    fMaterialUpdated;
 
    int fLastCellNum;      
    int fLastSurfaceNum;   
    int fLastMaterialNum;  
    int fLastUniverseNum;  
    int      fLastTallyNum[8];  
 
    string  fComment;      
 
    vector < Cell *>    fCellVector;    
    vector < PinCell *> fPinCellVector; 
    vector < Material *> fMaterialVector;
    bool    fAddMaterial; 
    vector < Nucleus_ptr >  fGlobalNucleiVector;
    vector < Cell *>        fTrueCellVector;
    vector < Cell *>        fCellOfUnknownVolume;
    vector < Shape *>       fShapeOfUnknownArea; 
 
    vector < SurfaceCard *> fSurfaceCardVector; 
    vector < MureTally *>   fTallyVector;       
    vector < MeshTally *>   fMeshTallyVector;   
    vector < Transformation *>  fTransformationVector;  
 
    string  fDataDirectoryName;     
    string  fEnsdfDataDirectoryName;
    string  fMCRunDirectory;        
    string  fMCInputBaseFileName;   
    string  fMCInputFileName;       
    bool    fAutoNumberFileName;    
    int     fNbOfDigitInEvo;        
 
    TemperatureMap  *fTemperatureMap;  
    map < Nucleus *, string >  fNucleiErrorMap;  
    BasePriority    *fBasePriority;     
    double          fReactionThreshold; 
    TFunctor        *fReactionListInitMethod;
    double  fShortestHalfTimeThres; 
    int     fReactionDepth;         
    double  fMeanEnergySpectrum;    
    double  fMCNucleusThreshold;    
    double  fSetAllFissionEnergies; 
    string  fFissionReleasedFN;     
    bool    fKeepOnlyFissionProductSelection;   
    string  fKeepOnlyFissionProductSelectionFN; 
 
    string  fSpecialIsomerFileName;             
    vector  < SpecialIsomer >    fSpecialIsomerVector;  
    string  fListOfWantedNucleiFN;  
    vector  < int > fReactionNumbersForcedCutVector; 
    vector  < ZAI *> fZAIsForcedCutVector; 
    bool    fRegisterElasticXSinDATA; 
 
    string  fXSDIRName;     
    bool    fIsAutoXSDIR;   
 
    string  fMCExec;        
 
    int     fVolumeNPS;    
    double  fVarianceVolumeWarning;  
    double  fSourceSphereR; 
    double  *fSourceSphereO;
    bool    fIsFromVolumeCalculation; 
 
    string  fNucleiChartFileName; 
    string  fReactionDataFile;    
    string  fMassDataFileName;    
    string  fNaturalIsotopeMassFileName;
    string  fFPASCIIFileName;     
    string  fFPBinaryFileName;    
    string  fBaseSummaryFileName; 
    vector  < string > fBaseSummary;
    bool    fIsBaseSummaryRead;     
    vector  < int > fFirstContinuousZIndexInBaseSummary;
    vector  < int > fFirstThermalZIndexInBaseSummary;   
 
    string  fMode;        
    vector  < string >  fSpecialSurfaceCard;
    vector  < string >  fSpecialCard;   
    int    fLastTransformNum;      
 
    bool    fThermoHydraulicsRequired;
    bool    fCOBRACalculationRequired;
    int     fNumberOfIterationNTH;      
    bool    fUserDefaultHydraulicModel; 
    int     fMCNPThermoRunNumber;       
 
    double  fKeff;      
    double  fKeff_Err;  
 
    bool    fSetESpectrum;      
    bool    fUseEnergyBinsFile; 
    string  fEnergyBinsFileName;
    int     fESpectrumTallyNumber;
    vector  < MureTimeEnergyGrid *> fTimeEnergyGrids;
    vector  < double >   fEnergyBins;
    bool    fIsSameTimeEnergyGridForAllTallies;
    Shape_ptr   fOutermostShape;  
    Cell        *fOutermostCell;
 
    int     fNprocessors;  
    string  fMPIExec;      
    bool    fPVM;          
    bool    fMPI;          
    int     fOMP;          
    int     fRunMultiMC;   
    long int fRandomSeedGenerator; 
    bool    fForceConstRandomSeedForMultiRun;
 
    MCSource *fReactivityCoeffsSource ;
 
    bool    fMUREInputGeometry;     
    string  fUserGeometryInputFile; 
 
    bool    fBetaCalculationRequired;     
    vector  < double > fNSigmaFisPhiTotalOfNucleus; 
 
    ConnectorPlugin *fConnectorPlugin;
    bool    fIsConnectorPluginCalled;
 
    bool    fEvolutionRequired; 
    EvolutionSolver *fEvolutionSolver; 
 
    bool    fSerpentDopplerBroadening;
 
    bool    fExtendedReactionList;
 
    vector<int> fMaterialForTallyNormalization; 
    vector<ZAI *> fGlobalZAIDepletionTallyList; 
    vector< vector<ZAI *> > fZAIDepletionTallyList; 
    vector<int> fMatnumDepletionTallyList; 
 
    bool fDisableViolentSimplifyNode; 
};
 
#endif