Nucleus.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 _NUCLEUS_
#define _NUCLEUS_
#include <libValErr/ValErr.hxx>
#include <vector>
#include <map>
#include <string>
#include <sstream>
#include <iostream>
#include <utility>
#include <algorithm>
 
#include "TReference.hxx"
#include "ZAI.hxx"
#include "NucleusMCRecord.hxx"
 
class NucleusMCRecord;
 
using namespace std;
 
class Nucleus;
 
typedef Reference_ptr < Nucleus > Nucleus_ptr;
 
class Cell;
 
 
class Nucleus : public TReference
{
  public:
 
    Nucleus(int aZ, int aA, int aI = 0, bool Moderator = 0, bool Evolution = false);
 
    Nucleus(int aZ, int aA, int aI, 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() override;                    
 
    int  Z()
    {
        return fZAI -> Z();   
    }
    int  A()
    {
        return fZAI -> A();   
    }
    int  I()
    {
        return fZAI -> I();   
    }
    ZAI *GetZAI()
    {
        return fZAI;   
    }
    void SetZAI(int aZ, int aA, int aI);                        
    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 IsModerator()
    {
        return fModerator;   
    }
    string GetModeratorLine()
    {
        return fModeratorLine;   
    }
    void SetModeratorName(string name)
    {
        fModeratorName = name;    
        fModerator = true;
    }
    void SetModeratorLine(string line)
    {
        fModeratorLine = line;   
    }
 
 
    void SetModeratorCategory(string ModeratorCategory)
    {
        fModeratorCategory = ModeratorCategory;
    }
    string GetModeratorCategory(){return fModeratorCategory;}
 
 
    string FindMCCode();
 
    void FindMCCode2();
    //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 FindMCModeratorName();        
 
 
    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;   
    }
 
 
    double GetSigmaPhi(Cell *cell, int ReactionCode);
 
 
    ValErr_t GetMCSigmaPhi(Cell *cell, int ReactionCode);
 
 
    ValErr_t    GetMCSigma(Cell *cell, int ReactionCode);
 
 
    ValErr_t GetMCSigmaPhi2(Cell *cell, int ReactionCode);
 
 
    double GetSigmaPhi2(Cell *cell, int ReactionCode);
 
 
    ValErr_t GetMCSigmaFM(int BinNum, int FMBinNum);
 
 
    ValErr_t    GetMCSigma2(Cell *cell, int ReactionCode);
 
 
    ValErr_t GetMCSigmaPhiFM(int BinNum, int FMBinNum);
 
 
 
    void    SetMCSigmaPhi(int BinNum, int FMBinNum, ValErr_t r);
 
 
    void    SetMCSigmaPhi2(int BinNum, int FMBinNum, ValErr_t r);
 
 
    void    SetMCSigma2(int BinNum, int FMBinNum, ValErr_t xs);
 
 
    void    SetMCSigma(int BinNum, int FMBinNum, ValErr_t xs);
 
 
 
 
 
    void SetTotalSigma(double xs)
    {
        fTotalSigma = xs;   
    }
    double GetTotalSigma()
    {
        return fTotalSigma;   
    }
    double GetTotalSigmaPhi(Cell *cell);            
    void SetTotalSigmaPhi(int BinNum, double xs);    
    int GetNumberOfReactions();
    int GetNumberOfCells();
    bool IsInThatCell(int CellNum);
    int GetCellBinNumber(int CellNum);
    int GetNumberOfMultiplicatorBinInCell(int CellNum);
 
    vector < NucleusMCRecord *> &GetNucleusMCRecord()
    {
        return fNucleusMCRecord;
    }
    void AddNucleusMCRecord(int TallyNum, int CellNumber, int TallyBinIdx);
    void ClearNucleusMCRecord();
 
    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 IsFirstTimeReactionAsk(int ReactionCode);        
    void SetFirstTimeReactionAsk2False(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 SetNuSigmaFisPhi(int BinNum, double Value); 
    vector < double > GetNuSigmaFisPhi()
    {
        return fNuSigmaFisPhi;   
    }
    double GetNuSigmaFisPhi(int BinNum); 
    double GetNuSigmaFisPhi(Cell *cell); 
 
 
  private:
 
    double  GetSigmaPhi(int BinNum, int ReactionCode);
 
    double  GetSigmaPhi2(int BinNum, int ReactionCode);
 
    ValErr_t    GetMCSigmaPhi(int BinNum, int ReactionCode);
 
    ValErr_t    GetMCSigmaPhi2(int BinNum, int ReactionCode);
 
    double  GetSigmaPhi(Cell *cell, ZAI *daughter);
 
    ValErr_t    GetMCSigmaPhi(Cell *cell, ZAI *daughter);
 
 
    ValErr_t    GetMCSigma(int BinNum, int ReactionCode);
 
    ValErr_t    GetMCSigma2(int BinNum, int ReactionCode);
 
    ValErr_t    GetMCSigma(Cell *cell, ZAI *daughter);
 
 
 
    void InitSigmaPhi();                
    int FindReactionCode(ZAI *daughter);
    int FindCellBin(Cell *cell);        
 
    int NumberOfReactions();            
    bool IsModeratorCategoryOk(string Code);
 
    ZAI     *fZAI;              
 
    bool    fEvolution;         
 
    bool    fPseudoNucleus;     
    bool    fDuplicate;             
    bool    fAlreadyWarn;           
 
    bool    fModerator;         
    string  fModeratorName;     
    string  fModeratorLine;     
    string  fModeratorCategory; 
 
    bool    fUserCode;          
    string  fIdCode;            
    string  fIdCode2;           
    int     fGlobalNucleiIndex; 
    string  fBestLine;          
    string  fBestLine2;         
 
    double  fTemperature;       
    double  fBaseTemperature1;  
    double  fBaseTemperature2;  
    bool    fTemperatureEvolution;  
 
    vector  < NucleusMCRecord *>    fNucleusMCRecord;
    int     fNReaction;         
    int     fNBinCell;          
 
 
    vector  < vector < vector < ValErr_t > > >  fSigmaPhi;
 
    vector  < vector < vector < ValErr_t > > >  fSigmaPhi2;
 
    vector  < vector < ValErr_t > > fMCSigmaPhi;
 
    vector  < vector < ValErr_t > > fMCSigmaPhi2;
 
    vector  < vector < ValErr_t > > fMCSigmaPhi3;
 
    vector  < vector < ValErr_t > > fMCSigma;
 
    vector  < vector < ValErr_t > > fMCSigma2;
    vector  < double >  fTotalSigmaPhi;  
    //int   fFMTotalBinNum;     //!< FM Tally bin Number for total reaction rate
    vector  < int > fXSCode;        
    vector  < double > fNuSigmaFisPhi;
    double  fTotalSigma;        
 
    vector  < double >  fMCTime;         
 
    vector  < vector < double > > fFitSlope;    
    vector  < vector < double > > fIntersept;   
    vector  < vector < double > > fFitSlope2;   
    vector  < vector < double > > fIntersept2;  
 
    map     < int, bool >   fFirstTimeReactionAsk;
    bool     **fASK;                
};
#endif