ReactionList.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 _ReactionList_
#define _ReactionList_
 
#include <cmath>
#include <map>
#include <string>
#include <fstream>
#include <vector>
 
#include "ReadXSFile.hxx"
 
using namespace std;
 
enum DecayId {kGamma = 0, kBeta_minus = 1, kBeta_plus, kIsomericTransition,
              kAlpha, kNeutron, kSpontaneousFission, kProton, kUnknown = 10
             };
 
class ZAI;
 
 
class ReactionList
{
  public:
 
    ReactionList(ZAI *zai = nullptr);
    ReactionList(const ReactionList &r);
    //~ReactionList(); //!< Normal destructor
 
 
    void FindReactions();
    void SetReactionListDir(string str = "ReactionList"); 
    void SetReactionThreshold(double sigma = 1e-2)
    {
        fReactionThreshold = sigma;   
    }
    void InitAll(bool state);   
    void InitSimple();          
    void InitFissionTest();     
    void InitU5Only();          
    void InitAuto();            
 
 
    void ReactionAutoDetection();
 
    void N_fission(bool state = true)
    {
        fList[k_Fission] = state;   
    }
    void N_gamma(bool state = true)
    {
        fList[kN_gamma] = state;   
    }
    void N_2N(bool state = true)
    {
        fList[kN_2N] = state;   
    }
    void N_3N(bool state = true)
    {
        fList[kN_3N] = state;   
    }
    void N_4N(bool state = true)
    {
        fList[kN_4N] = state;   
    }
    void N_p(bool state = true)
    {
        fList[kN_p] = state;   
    }
    void N_d(bool state = true)
    {
        fList[kN_d] = state;   
    }
    void N_t(bool state = true)
    {
        fList[kN_t] = state;   
    }
    void N_He3(bool state = true)
    {
        fList[kN_He3] = state;   
    }
    void N_alpha(bool state = true)
    {
        fList[kN_alpha] = state;   
    }
    void N_Np(bool state = true)
    {
        fList[kN_Np] = state;   
    }
    void N_Nd(bool state = true)
    {
        fList[kN_Nd] = state;   
    }
    void N_Nt(bool state = true)
    {
        fList[kN_Nt] = state;   
    }
    void N_NHe3(bool state = true)
    {
        fList[kN_NHe3] = state;   
    }
    void N_Nalpha(bool state = true)
    {
        fList[kN_Nalpha] = state;   
    }
    void N_2Np(bool state = true)
    {
        fList[kN_2Np] = state;   
    }
    void N_3Np(bool state = true)
    {
        fList[kN_3Np] = state;   
    }
    void N_2Nd(bool state = true)
    {
        fList[kN_2Nd] = state;   
    }
    void N_2Nalpha(bool state = true)
    {
        fList[kN_2Nalpha] = state;   
    }
    void N_3Nalpha(bool state = true)
    {
        fList[kN_3Nalpha] = state;   
    }
    void N_2p(bool state = true)
    {
        fList[kN_2p] = state;   
    }
    void N_2alpha(bool state = true)
    {
        fList[kN_2alpha] = state;   
    }
    void N_3alpha(bool state = true)
    {
        fList[kN_3alpha] = state;   
    }
    void N_N2p(bool state = true)
    {
        fList[kN_N2p] = state;   
    }
    void N_N2alpha(bool state = true)
    {
        fList[kN_N2alpha] = state;   
    }
    void N_N3alpha(bool state = true)
    {
        fList[kN_N3alpha] = state;   
    }
    void N_pd(bool state = true)
    {
        fList[kN_pd] = state;   
    }
    void N_pt(bool state = true)
    {
        fList[kN_pt] = state;   
    }
    void N_palpha(bool state = true)
    {
        fList[kN_palpha] = state;   
    }
    void N_dalpha(bool state = true)
    {
        fList[kN_dalpha] = state;   
    }
    void N_d2alpha(bool state = true)
    {
        fList[kN_d2alpha] = state;   
    }
    void N_t2alpha(bool state = true)
    {
        fList[kN_t2alpha] = state;   
    }
    void N_Npalpha(bool state = true)
    {
        fList[kN_Npalpha] = state;   
    }
    void N_2N2alpha(bool state = true)
    {
        fList[kN_2N2alpha] = state;   
    }
    void N_Nd2alpha(bool state = true)
    {
        fList[kN_Nd2alpha] = state;   
    }
    void N_Nt2alpha(bool state = true)
    {
        fList[kN_Nt2alpha] = state;   
    }
 
    void SetNumberOfReactions(int reaction_number)
    {
        fN = reaction_number;   
    }
    int GetNumberOfReactions()
    {
        return fN;   
    }
 
    bool    IsReactionAllowed(int reaction_code);
    int     GetReactionArray(int i)
    {
        return fReactionArray[i];   
    }
    int     GetReactionArraySize()
    {
        return fN;   
    }
 
    void WriteReactionList(int other_isomer);       
    void InitReactionArray(bool extended = false);  
    string Print(); 
    string PrintReaction(int reaction_code);
    int *Return_DaughterConstituents(ZAI *, int);
 
  protected:
 
    ZAI     *fZAI; 
    map     < int, bool >  fList;   
    double  fReactionThreshold;     
    string  fReactionListDir;       
    static vector   <int> fReactionArray;   
    static vector   <string> fReactionName; 
    static int      fN; 
 
    //static int    *fReactionArray;//!< ENDF code for reaction (used as index of fList)
    //static string *fReactionName; //!< Reaction Name (e.g., N_2N)
    //ifstream      fXsdir; //!< XSDIR file
    //string        fXsdirName; //!< XSDIR file name
 
  private:
 
    // int ORIGEN_MTs[8] = {2, 4, 16, 17, 18, 102, 103, 107}; // inel, n2n, n3n, nf, ng, np,na
    static int iElasticPosition;
};
#endif