ZAI.hxx

Go to the documentation of this file.

#ifndef _ZAI_
#define _ZAI_ 

#include <math.h>
#include <vector>
#include <iostream>
#include <string>
using namespace std;

#include "MureHeaders.hxx"


class ZAIReaction
{
public:
    ZAIReaction(){fCode=0; fWeight=0;} 
    ZAIReaction(int code, double weight){fCode=code; fWeight=weight;} 
    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 Z, int A, int I,bool decay=true);
    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(short Z){fZ=Z;} 
    void SetA(short A){fA=A;} 
    void SetI(short I){fI=I;} 
    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); 
    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 FirtsGeneration=false,double BR=0);

    string PrintDecay(string tab="",bool WithDaughter=true,bool FirtsGeneration=false,double BR=0);

    string PrintReaction(string tab="",bool WithDaughter=true,bool FirtsGeneration=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 ShowZAI(int Z,int A,int I,ZAI* &TheZai);
    void Used(){fUsed=true;}    
    void NotUsed(){fUsed=false;}    
    bool IsUsed(){return fUsed;}    
    double BranchingRatioSum();     
    double BranchingRatio(int i){return fDecayBranchingRatio[i];} 
    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 PrivateShowZAI(int Z,int A,int I,ZAI* &TheZai);

    string PrivatePrintReaction(string tab="",bool WithDaughter=true,bool FirtsGeneration=false,bool firstcall=true);
    
    
    string  fName;  
    short   fZ;     
    short   fA;     
    short   fI;     
    double  fMass;  
    double  fHalfLifeTime;  
    string  fAllDecays;     
    ReactionList    *fAllowedReaction;  
    vector<ZAI *>   fDecayDaughter;     
    vector<ZAI *>   fDecayParent;       
    vector<double>  fDecayBranchingRatio;
    vector<int>     fDecayMode;         
    vector<ZAI *>   fReactionDaughter;  
    vector<ZAI *>   fReactionParent;    
    
    vector<ZAIReaction *>   fReactionCode;  
    bool            fUsed;      
    bool            fDelete;    
    bool            fStable;    
    bool            fFissionProduct;    
    int             fInbase;    
    bool            fHasIsomer; 
    bool            fCanFission;    
    bool            fIsRealFissile; 
    bool            fCanEmitBeta;   
    bool            fCanEmitDelayedNeutron; 
    
    ZAI*            fAlternateZAI;  
    static vector<ZAI*> fExploredZAI;
    XSDIRLine       *fSaveXSDIRLine;    
    double  fEnergyReleasedFromFission; 

    bool    fNonEvolvingZai;            
    vector<ZAI*>            fCutBetaDaughters; //<! List of the ZAI that were cut
    bool                    fIsMotherOfBetaDecayer; 
    vector<double>          fCutBetaBR; 

 public:
    bool            fHaveBeenHere;      
    double          fNubar;             
};
#endif