ZAI.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 _ZAI_
#define _ZAI_
 
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
 
#include "XSDIRLine.hxx"
#include "ReactionList.hxx"
 
class ReactionList;
class XSDIRLine;
 
using namespace std;
 
 
 
class ZAIReaction
{
  public:
    ZAIReaction()
    {
        fCode = 0;    
        fWeight = 0;
    }
    ZAIReaction(int code, double weight)
    {
        fCode = code;    
        fWeight = weight;
    }
    ZAIReaction(ZAIReaction const &zr)
    {
        fCode = zr.fCode ;    
        fWeight = zr.fWeight;
    }
    ~ZAIReaction() {/*cout<<"DEST ZAIReaction "<<this<<endl;*/}
    void SetCode(int code)
    {
        fCode = code;   
    }
    int GetCode()
    {
        return fCode;   
    }
    void SetWeight(double weight)
    {
        fWeight = weight;   
    }
    double GetWeight()
    {
        return fWeight;   
    }
 
    void SetReaction(int code, double weight)
    {
        fCode = code;
        fWeight = weight;
    }
 
  private:
    int fCode;         
    double fWeight; 
};
 
 
 
class ZAI
{
  public:
 
    ZAI(int aZ, int aA, int aI);
    ZAI(); 
    ZAI(const ZAI &zai);
    ~ZAI(); 
 
    int  Z()
    {
        return fZ;   
    }
    int  A()
    {
        return fA;   
    }
    int  I()
    {
        return fI;   
    }
    int  N()
    {
        return fA - fZ;   
    }
    void SetZ(int aZ)
    {
        fZ = aZ;   
    }
    void SetA(int aA)
    {
        fA = aA;   
    }
    void SetI(int aI)
    {
        fI = aI;   
    }
    void SetMass(double m)
    {
        fMass = m;   
    }
    double GetMass();                 
    void SetName(string Name)
    {
        fName = Name;   
    }
    string GetName()
    {
        return fName;   
    }
    string GetFullName();           
 
    void SetHalfLifeTime(double T_12)
    {
        fHalfLifeTime = T_12;   
    }
    double GetHalfLifeTime()
    {
        return fHalfLifeTime;   
    }
    void SetDecayConstant(double lambda)
    {
        fHalfLifeTime = log(2.) / lambda;   
    }
    double GetDecayConstant()
    {
        if (fHalfLifeTime)return log(2.) / fHalfLifeTime;    
        return 0.;
    }
 
    int  GetDecayDaughterSize()
    {
        return fDecayDaughter.size();   
    }
    ZAI *GetDecayDaughter(int i)
    {
        return fDecayDaughter[i];   
    }
    vector < ZAI *>  &GetDecayDaughter()
    {
        return fDecayDaughter;   
    }
    int  GetDecayParentSize()
    {
        return fDecayParent.size();   
    }
    vector < double > &GetDecayBranchingRatio()
    {
        return fDecayBranchingRatio;   
    }
    double GetDecayBranchingRatio(int i)
    {
        return fDecayBranchingRatio[i];   
    }
    void SetDecayBranchingRatio(int i, double BR)
    {
        fDecayBranchingRatio[i] = BR;   
    }
    ZAI *GetDecayParent(int i)
    {
        return fDecayParent[i];   
    }
    vector < ZAI *>  &GetDecayParent()
    {
        return fDecayParent;   
    }
    void AddDecayDaughter(ZAI *Daughter, double BR, int DecayMode); 
    void AddDecayParent(ZAI *Parent); 
    void CutFromMammaDecay(ZAI *mamma); 
    string GetAllDecays()
    {
        return fAllDecays;   
    }
    void SetAllDecays(string decays)
    {
        fAllDecays = decays;   
    }
    vector < int > &GetDecayMode()
    {
        return fDecayMode;   
    }
    int GetDecayMode(int i)
    {
        return fDecayMode[i];   
    }
    void Stable()
    {
        fStable = true;   
    }
    bool IsStable()
    {
        return fStable;   
    }
 
    void SetReactionList(ReactionList *l); 
    ReactionList *GetReactionList()
    {
        return fAllowedReaction;   
    }
 
    int  GetReactionDaughterSize()
    {
        return fReactionDaughter.size();   
    }
    int  GetReactionParentSize()
    {
        return fReactionParent.size();   
    }
    ZAI *GetReactionParent(int i)
    {
        return fReactionParent[i];   
    }
    vector < ZAI *>  &GetReactionParent()
    {
        return fReactionParent;   
    }
    ZAI *GetReactionDaughter(int i)
    {
        return fReactionDaughter[i];   
    }
    vector < ZAI *>  &GetReactionDaughter()
    {
        return fReactionDaughter;   
    }
    void AddReactionDaughter(ZAI *Daughter, int code, double weight, bool replace = false); 
    void AddReactionParent(ZAI *Parent); 
    void CutFromMammaReaction(ZAI *mamma); 
    vector < ZAIReaction *>   &GetZAIReaction()
    {
        return fReactionCode;   
    }
    int GetReactionCode(int i)
    {
        return GetZAIReaction()[i] -> GetCode();   
    }
    double GetReactionWeight(int i)
    {
        return GetZAIReaction()[i] -> GetWeight();   
    }
    void RemoveReactionDaugther();
 
    void SetCanFission(bool state = true)
    {
        fCanFission = state;   
    }
    bool CanFission()
    {
        return fCanFission;   
    }
 
    void SetIsRealFissile(bool state = true)
    {
        fIsRealFissile = state;   
    }
    bool IsRealFissile()
    {
        return fIsRealFissile;   
    }
    double ApproximateNubar()
    {
        return fNubar;   
    }
    void SetApproximateNubar(double nu)
    {
        fNubar = nu;   
    }
    void FindApproximateNubar();                      
    void FissionProduct()
    {
        fFissionProduct = true;   
    }
    bool IsFissionProduct()
    {
        return fFissionProduct;   
    }
    void SetEnergyReleasedFromFission(double Energy)
    {
        fEnergyReleasedFromFission = Energy;   
    }
    double GetEnergyReleasedFromFission()
    {
        return fEnergyReleasedFromFission;   
    }
 
 
    string Print(string tab = "", bool WithDaughter = true, bool FirstGeneration = false, double BR = 0);
 
    string PrintDecay(string tab = "", bool WithDaughter = true, bool FirstGeneration = false, double BR = 0);
 
    string PrintReaction(string tab = "", bool WithDaughter = true, bool FirstGeneration = false);
    string PrintParent();          
    string PrintInfo();            
    string PrintName();            
 
    void ResetDummy(); 
 
 
    void SetInDataBase(int state)
    {
        fInbase = state - 1;
    }
    bool IsInDataBase();            
    XSDIRLine *GetSaveXSDIRLine()
    {
        return fSaveXSDIRLine;   
    }
 
 
    XSDIRLine *FindXSDIRLine(int &other_isomer);
 
 
    bool IsZAIInMyFamilly(int Z, int A, int I, ZAI *&ZaiOfMyFamilly);
    void Used()
    {
        fUsed = true;   
    }
    void NotUsed()
    {
        fUsed = false;   
    }
    bool IsUsed()
    {
        return fUsed;   
    }
    double BranchingRatioSum();     
    //double BranchingRatio(int i){return fDecayBranchingRatio[i];} //!< returns the ith decay branching ratio
    void Delete()
    {
        fDelete = true;   
    }
    bool IsDelete()
    {
        return fDelete;   
    }
    void AddedToMaterial()
    {
        fExploredZAI.push_back(this);    
        fHaveBeenHere = true;
    }
    bool IsAddedToMaterial()
    {
        return fHaveBeenHere;   
    }
 
 
    void FindMass(); 
 
 
    void SetCanEmitBeta()
    {
        fCanEmitBeta = true;   
    }
    bool CanEmitBeta()
    {
        return fCanEmitBeta;   
    }
 
    void SetCanEmitDelayedNeutron()
    {
        fCanEmitDelayedNeutron = true;   
    }
    bool CanEmitDelayedNeutron()
    {
        return fCanEmitDelayedNeutron;   
    }
 
    void SetHasIsomer()
    {
        fHasIsomer = true;   
    }
    bool HasIsomer()
    {
        return fHasIsomer;   
    }
    void SetAlternateZAI(ZAI *zai)
    {
        fAlternateZAI = zai;   
    }
    ZAI *GetAlternateZAI()
    {
        return fAlternateZAI;   
    }
    bool operator== (ZAI zai);                
    void ForceNonEvolvingZai()
    {
        fNonEvolvingZai = true;   
    }
    bool IsForceNonEvolvingZai()
    {
        return fNonEvolvingZai;   
    }
 
    void SetIsMotherOfCutBetaDecayer(ZAI *daughter, double BR); 
 
  protected:
 
    void IncrementBR(int num, double BR)
    {
        fDecayBranchingRatio[num] += BR;
    }
 
    bool PrivateIsZAIInMyFamilly(int Z, int A, int I, ZAI *&ZaiOfMyFamilly); 
 
    string PrivatePrintReaction(string tab = "", bool WithDaughter = true, bool FirstGeneration = false, bool firstcall = true);
 
 
    string  fName;  
    int   fZ;     
    int   fA;     
    int   fI;     
    double  fMass;  
    double  fHalfLifeTime;  
 
    string  fAllDecays;     
    bool    fAllowedReactionWasSet;
    ReactionList    *fAllowedReaction;  
    vector  < ZAI * > fDecayDaughter;   
    vector  < ZAI * > fDecayParent;     
    vector  < double > fDecayBranchingRatio;
    vector  < int >  fDecayMode;            
    vector  < ZAI * > fReactionDaughter;    
    vector  < ZAI * > fReactionParent;      
    vector  < ZAIReaction * > fReactionCode; 
    bool    fNonEvolvingZai;            
 
    bool    fUsed;  
    bool    fDelete;
    bool    fStable;
    int     fInbase;        
 
    bool    fHasIsomer;     
    bool    fFissionProduct;
    bool    fCanFission;    
    bool    fIsRealFissile; 
    bool    fCanEmitBeta;   
    bool    fCanEmitDelayedNeutron; 
    bool    fIsMotherOfBetaDecayer;     
    double  fEnergyReleasedFromFission; 
 
    ZAI     *fAlternateZAI; 
    static vector < ZAI *>  fExploredZAI;
    XSDIRLine   *fSaveXSDIRLine;        
 
    vector  < ZAI *>  fCutBetaDaughters; 
    vector  < double >   fCutBetaBR;    
 
  public:
    bool    fHaveBeenHere;  
    double  fNubar;         
};
#endif