#include <G4NuDEXStatisticalNucleus.hh>

Public Member Functions
	G4NuDEXStatisticalNucleus (G4int Z, G4int A)

	~G4NuDEXStatisticalNucleus ()

G4int	Init (const char dirname, const char inputfname=0)

G4int	GenerateCascade (G4int InitialLevel, G4double ExcitationEnergy, std::vector< char > &pType, std::vector< double > &pEnergy, std::vector< double > &pTime)

G4int	GetClosestLevel (G4double Energy, G4int spinx2, G4bool parity)

G4double	GetLevelEnergy (G4int i_level)

void	GetSnAndI0 (G4double &sn, G4double &i0)

Level *	GetLevel (G4int i_level)

void	ChangeLevelSpinParityAndBR (G4int i_level, G4int newspinx2, G4bool newParity, G4int nlevels, G4double width, unsigned int seed=0)

void	ChangeThermalCaptureLevelBR (G4double LevelEnergy, G4double absoluteIntensity)

void	SetSomeInitalParameters (G4int LDtype=-1, G4int PSFFlag=-1, G4double MaxSpin=-1, G4int minlevelsperband=-1, G4double BandWidth_MeV=0, G4double maxExcEnergy=0, G4int BrOption=-1, G4int sampleGammaWidths=-1, unsigned int aseed1=0, unsigned int aseed2=0, unsigned int aseed3=0)

void	SetInitialParameters02 (G4int knownLevelsFlag=-1, G4int electronConversionFlag=-1, G4double primGamNormFactor=-1, G4double primGamEcut=-1, G4double ecrit=-1)

void	SetBandWidth (G4double bandWidth)

void	SetBrOption (G4int BrOption)

void	SetRandom1Seed (unsigned int seed)

void	SetRandom2Seed (unsigned int seed)

void	SetRandom3Seed (unsigned int seed)

G4NuDEXRandom *	GetRandom3 ()

G4bool	HasBeenInitialized ()

void	PrintAll (std::ostream &out)

void	PrintParameters (std::ostream &out)

void	PrintKnownLevels (std::ostream &out)

void	PrintLevelDensity (std::ostream &out)

void	PrintLevelScheme (std::ostream &out)

void	PrintThermalPrimaryTransitions (std::ostream &out)

void	PrintPSF (std::ostream &out)

void	PrintICC (std::ostream &out)

void	PrintTotalCumulBR (G4int i_level, std::ostream &out)

void	PrintBR (G4int i_level, G4double MaxExcEneToPrint_MeV, std::ostream &out)

void	PrintInput01 (std::ostream &out)

void	PrintKnownLevelsInDEGENformat (std::ostream &out)

void	PrintLevelSchemeInDEGENformat (const char *fname, G4int MaxLevelID=-1)

Detailed Description

Definition at line 100 of file G4NuDEXStatisticalNucleus.hh.

Constructor & Destructor Documentation

◆ G4NuDEXStatisticalNucleus()

G4NuDEXStatisticalNucleus::G4NuDEXStatisticalNucleus	(	G4int	Z,
		G4int	A )

Definition at line 50 of file G4NuDEXStatisticalNucleus.cc.

                                                                   {
 
  //The default values for these flags are in "GeneralStatNuclParameters.dat"
  //Can be changed with G4NuDEXStatisticalNucleus::SetSomeInitalParameters(...)
  LevelDensityType=-1;
  PSFflag=-1;
  maxspinx2=-1;
  MinLevelsPerBand=-1;
  BandWidth=0;
  MaxExcEnergy=0;
  BROpt=-1;
  SampleGammaWidths=-1;
 
  //The default values for these flags are in G4NuDEXStatisticalNucleus::Init(...)
  //Can be changed via G4NuDEXStatisticalNucleus::SetInitialParameters02(...):
  ElectronConversionFlag=-1; // All EC
  KnownLevelsFlag=-1; //Use all known levels
  PrimaryGammasIntensityNormFactor=-1;
  PrimaryGammasEcut=-1; //If primary gammas, do not create new primary gammas going to the "Primary gammas" region.
  Ecrit=-1;
  
  hasBeenInitialized=false;
  NBands=-1;
  theLevels=0;
  theKnownLevels=0;
  NKnownLevels=0; NUnknownLevels=0; NLevels=0; KnownLevelsVectorSize=0;
  theRandom1=0;
  theRandom2=0;
  theRandom3=0;
  theLD=0;
  theICC=0;
  thePSF=0;
  TotalGammaRho=0;
  theThermalCaptureLevelCumulBR=0;
  TotalCumulBR=0;
 
  Z_Int=Z;
  A_Int=A;
 
  //Random generators:
  seed1=1234567;
  seed2=1234567;
  seed3=1234567;
  theRandom1= new G4NuDEXRandom(seed1);
  theRandom2= new G4NuDEXRandom(seed2);
  theRandom3= new G4NuDEXRandom(seed3);
  Rand1seedProvided=false; Rand2seedProvided=false; Rand3seedProvided=false;
}

◆ ~G4NuDEXStatisticalNucleus()

G4NuDEXStatisticalNucleus::~G4NuDEXStatisticalNucleus ( )

Definition at line 135 of file G4NuDEXStatisticalNucleus.cc.

                                                     {
 
  if(theLevels!=0){delete [] theLevels;}
  for(G4int i=0;i<KnownLevelsVectorSize;i++){
    if(theKnownLevels[i].Ndecays>0){
      delete [] theKnownLevels[i].decayFraction;
      delete [] theKnownLevels[i].decayMode;
    }
    if(theKnownLevels[i].NGammas>0){
      delete [] theKnownLevels[i].FinalLevelID;
      delete [] theKnownLevels[i].multipolarity;
      delete [] theKnownLevels[i].Eg;
      delete [] theKnownLevels[i].cumulPtot;
      delete [] theKnownLevels[i].Pg;
      delete [] theKnownLevels[i].Pe;
      delete [] theKnownLevels[i].Icc;
    }
  }
  if(theKnownLevels!=0){delete [] theKnownLevels;}
  if(theRandom1!=0){delete theRandom1;}
  if(theRandom2!=0){delete theRandom2;}
  if(theRandom3!=0){delete theRandom3;}
  if(theLD!=0){delete theLD;}
  if(theICC!=0){delete theICC;}
  if(thePSF!=0){delete thePSF;}
  if(TotalGammaRho!=0){delete [] TotalGammaRho;}
  if(theThermalCaptureLevelCumulBR!=0){delete [] theThermalCaptureLevelCumulBR;}
  if(TotalCumulBR!=0){
    for(G4int i=0;i<NLevels;i++){
      if(TotalCumulBR[i]!=0){delete [] TotalCumulBR[i];}
    }
    delete [] TotalCumulBR;
  }
}

Member Function Documentation

◆ ChangeLevelSpinParityAndBR()

void G4NuDEXStatisticalNucleus::ChangeLevelSpinParityAndBR	(	G4int	i_level,
		G4int	newspinx2,
		G4bool	newParity,
		G4int	nlevels,
		G4double	width,
		unsigned int	seed = 0 )

Definition at line 571 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                                                                       {
 
  if(i_level==-1){ //change BR of thermal, ignore arguments
    if(Sn>0 && NLevels>1){
      CreateThermalCaptureLevel(seed);
      GenerateThermalCaptureLevelBR(theLibDir.c_str());
    }
    return;
  }
 
  if(i_level<0 || i_level>=NLevels){
    std::cout<<" i_level = "<<i_level<<" ------ NLevels = "<<NLevels<<std::endl;
    NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
  }
 
  //Do not apply to known levels:
  if(i_level<NKnownLevels || theLevels[i_level].KnownLevelID>0){
    std::cout<<" ####### WARNING: you are trying to change the BR, spin, parity, etc. of a known level --> nothing is done ############"<<std::endl;
    return;
    //NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
  }
 
  theLevels[i_level].spinx2=newspinx2;
  theLevels[i_level].parity=newParity;
  if(seed>0){
    theLevels[i_level].seed=seed;
  }
  else{
    theLevels[i_level].seed=theRandom2->Integer(4294967295)+1;
  }
  if(nlevels>=0){
    theLevels[i_level].NLevels=nlevels;
  }
  if(width>=0){
    theLevels[i_level].Width=width;
  }
 
  if(TotalGammaRho[i_level]>=0){ //then we have to change TotalGammaRho[i_level]
    G4double* br_vector=0;
    if(TotalCumulBR!=0){
      br_vector=TotalCumulBR[i_level];
    }
    TotalGammaRho[i_level]=ComputeDecayIntensities(i_level,br_vector);
  }
 
}

◆ ChangeThermalCaptureLevelBR()

void G4NuDEXStatisticalNucleus::ChangeThermalCaptureLevelBR	(	G4double	LevelEnergy,
		G4double	absoluteIntensity )

Definition at line 2019 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                          {
 
  if(!theThermalCaptureLevelCumulBR){return;}
  G4int level_id=GetClosestLevel(LevelEnergy,-1,true);
  if(level_id<0 || level_id>=NLevelsBelowThermalCaptureLevel){
    std::cout<<" ############## WARNING in "<<__FILE__<<", line "<<__LINE__<<" ##############"<<std::endl;
    std::cout<<"  ---> "<<level_id<<"  "<<LevelEnergy<<std::endl;
  }
 
  for(G4int i=NLevelsBelowThermalCaptureLevel-1;i>0;i--){
    theThermalCaptureLevelCumulBR[i]-=theThermalCaptureLevelCumulBR[i-1];
  }
  G4double OldIntensity=theThermalCaptureLevelCumulBR[level_id];
  theThermalCaptureLevelCumulBR[level_id]=absoluteIntensity*(1.-OldIntensity)/(1.-absoluteIntensity);
 
  for(G4int i=1;i<NLevelsBelowThermalCaptureLevel;i++){
    theThermalCaptureLevelCumulBR[i]+=theThermalCaptureLevelCumulBR[i-1];
  }
  for(G4int i=0;i<NLevelsBelowThermalCaptureLevel;i++){
   theThermalCaptureLevelCumulBR[i]/=theThermalCaptureLevelCumulBR[NLevelsBelowThermalCaptureLevel-1];
  }
  if(level_id==0){
    std::cout<<" Thermal primary gammas to level "<<level_id<<", with E="<<theLevels[level_id].Energy<<" MeV changed from "<<OldIntensity<<" to "<<theThermalCaptureLevelCumulBR[level_id]<<std::endl;
  }
  else{
    std::cout<<" Thermal primary gammas to level "<<level_id<<", with E="<<theLevels[level_id].Energy<<" MeV changed from "<<OldIntensity<<" to "<<theThermalCaptureLevelCumulBR[level_id]-theThermalCaptureLevelCumulBR[level_id-1]<<std::endl;
  }
}

◆ GenerateCascade()

G4int G4NuDEXStatisticalNucleus::GenerateCascade	(	G4int	InitialLevel,
		G4double	ExcitationEnergy,
		std::vector< char > &	pType,
		std::vector< double > &	pEnergy,
		std::vector< double > &	pTime )

Definition at line 356 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                                                                                       {
 
  pType.clear();
  pEnergy.clear();
  pTime.clear();
  
  if(ExcitationEnergy<0){
    ExcitationEnergy=Sn-(A_Int-1.)/(G4double)A_Int*ExcitationEnergy;
  }
  if(ExcitationEnergy<=0){
    return 0;
  }
 
  G4int Npar=0;
  G4int f_level=0,multipol=0;
  G4double alpha,E_trans,Exc_ene_i,Exc_ene_f; //icc factor, energy of the transition, initial/final excitation energy
  G4double EmissionTime=0; //in seconds
  G4int NTransition=0;
  //G4double TotalCascadeEnergy1=0,TotalCascadeEnergy2=0;
  
  //Start:
  G4int i_level=InitialLevel;
  Exc_ene_i=ExcitationEnergy;
 
 
  if(i_level==0){ //could happen
    pType.push_back('g');
    pEnergy.push_back(Exc_ene_i);
    pTime.push_back(0);
    Npar++;
  }
  
  //Loop:
  while(i_level!=0){
 
    NTransition++;
    //--------------------------------------------
    //Sample final level:
    if(i_level==-1){ //thermal level
      if(!theThermalCaptureLevelCumulBR){
    f_level=0;
    std::cout<<" ############## NuDEX: WARNING, there are no thermal capture for ZA="<<A_Int+1000*Z_Int-1<<" , with Sn = "<<Sn<<" ##############"<<std::endl; 
      }
      else{
    //Sample final level:
    G4double randnumber=theRandom3->Uniform();
    f_level=-1;
    for(G4int i=0;i<NLevelsBelowThermalCaptureLevel;i++){
      if(theThermalCaptureLevelCumulBR[i]>randnumber){
        multipol=GetMultipolarity(&theThermalCaptureLevel,&theLevels[i]);
        f_level=i;
        break;
      }
    }
      }
      if(f_level<0){
    NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
      }
      Exc_ene_f=theLevels[f_level].Energy;
    }
    else if(i_level>0){
      f_level=SampleFinalLevel(i_level,multipol,alpha,NTransition);
    }
    else{
      NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
    }
    //--------------------------------------------
 
    //Energy of the transition:
    Exc_ene_f=theLevels[f_level].Energy;
 
    //We sample the final energy if it is a band of levels:
    if(theLevels[f_level].Width!=0){
      Exc_ene_f+=theRandom3->Uniform(-theLevels[f_level].Width,+theLevels[f_level].Width);
    }
    E_trans=Exc_ene_i-Exc_ene_f;
    if(E_trans<=0){
      //std::cout<<"Exc_ene_i = "<<Exc_ene_i<<"  Exc_ene_f = "<<Exc_ene_f<<std::endl;
      //std::cout<<" ####### WARNING: E_trans = "<<E_trans<<" for i="<<i_level<<" with E = "<<theLevels[std::max(i_level,0)].Energy<<" to  f="<<f_level<<" with E = "<<theLevels[f_level].Energy<<" ########"<<std::endl;  
      return -1;
    }
    //------------------------------------------------------------
    //Emission time:
    if(i_level<NKnownLevels && i_level>0){
      if(theKnownLevels[i_level].T12>0){
    EmissionTime+=theRandom3->Exp(theKnownLevels[i_level].T12/std::log(2));
      }
    }
    //------------------------------------------------------------
 
    //------------------------------------------------------------
    //calculate electron conversion:
    G4bool ele_conv=false;
    if(ElectronConversionFlag>0){
      if(i_level<NKnownLevels && i_level>0){ //ElectronConversionFlag=1,2
    ele_conv=theICC->SampleInternalConversion(E_trans,multipol,alpha); //use the alpha value from the know level value
      }
      else if(ElectronConversionFlag==2){
        ele_conv=theICC->SampleInternalConversion(E_trans,multipol); //calculate alpha (icc factor)
      }
    }
    //------------------------------------------------------------
    //std::cout<<" ---- "<<Exc_ene_i<<"  "<<Exc_ene_f<<"  "<<E_trans<<"  "<<multipol<<"  "<<ele_conv<<std::endl;
    //TotalCascadeEnergy1+=E_trans;
    
    //------------------------------------------------------------
    //Fill result:
    if(ele_conv){
      for(G4int i=0;i<theICC->Ne;i++){
    pType.push_back('e');
    pEnergy.push_back(theICC->Eele[i]);
    pTime.push_back(EmissionTime);
    Npar++;
      }
      for(G4int i=0;i<theICC->Ng;i++){
    pType.push_back('g');
    pEnergy.push_back(theICC->Egam[i]);
    pTime.push_back(EmissionTime);  
    Npar++;
      }
    }
    else{
      pType.push_back('g');
      pEnergy.push_back(E_trans);
      pTime.push_back(EmissionTime);          
      Npar++;
    }
    //------------------------------------------------------------
    i_level=f_level;
    Exc_ene_i=Exc_ene_f;
  }
 
  //for(G4int i=0;i<Npar;i++){TotalCascadeEnergy2+=pEnergy[i];}
  //std::cout<<" Total energy: "<<TotalCascadeEnergy1<<"  "<<TotalCascadeEnergy2<<std::endl; getchar();
  
  
  if(i_level!=0){
    NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
  }
  return Npar;
}

◆ GetClosestLevel()

G4int G4NuDEXStatisticalNucleus::GetClosestLevel	(	G4double	Energy,
		G4int	spinx2,
		G4bool	parity )

Definition at line 832 of file G4NuDEXStatisticalNucleus.cc.

                                                                                          {
 
  //std::cout<<" XXX finding closest level of spin "<<spinx2/2.<<" and parity "<<parity<<" to "<<Energy<<" MeV"<<std::endl;
 
  //------------------------------------------------------------------------------
  // We try to go closer to the solution, otherwise it takes too much time:
  G4int i_down=0,i_up=NLevels-1;
  G4int i_close_down=0,i_close_up=NLevels-1;
  G4int i_close=0;
  while(i_close_up-i_close_down>10){
    i_close=(i_close_up+i_close_down)/2;
    if(theLevels[i_close].Energy>Energy){
      i_close_up=i_close;
    }
    else{
      i_close_down=i_close;
    }
  }
 
  for(G4int i=i_close_up;i<NLevels;i++){
    i_up=i;
    if((theLevels[i].spinx2==spinx2 && theLevels[i].parity==parity) || spinx2<0){
      break;
    }
  }
  for(G4int i=i_close_down;i>=0;i--){
    i_down=i;
    if((theLevels[i].spinx2==spinx2 && theLevels[i].parity==parity) || spinx2<0){
      break;
    }
  }
  //------------------------------------------------------------------------------
 
  G4double MinEnergyDistance=-1,EnergyDistance;
  G4int result=-1;
  for(G4int i=i_down;i<=i_up;i++){
    EnergyDistance=std::fabs(theLevels[i].Energy-Energy);
    if((theLevels[i].spinx2==spinx2 && theLevels[i].parity==parity) || spinx2<0){ //then this is a candidate
      if(EnergyDistance<MinEnergyDistance || MinEnergyDistance<0){
    MinEnergyDistance=EnergyDistance;
    result=i;
      }
    }
  }
  //std::cout<<" XXX found --> "<<result<<std::endl;
 
 
  return result;
}

Referenced by ChangeThermalCaptureLevelBR().

◆ GetLevel()

Level * G4NuDEXStatisticalNucleus::GetLevel ( G4int i_level )

Definition at line 883 of file G4NuDEXStatisticalNucleus.cc.

                                                       {
 
  if(i_level>=0 && i_level<NLevels){
    return &theLevels[i_level];
  }
  if(i_level==-1){
    return &theThermalCaptureLevel;
  }
  
  std::cout<<" ############ WARNING: for ZA="<<A_Int+1000*Z_Int<<" , requested level i_level="<<i_level<<" does not exist ############"<<std::endl;
 
  return 0;
}

◆ GetLevelEnergy()

G4double G4NuDEXStatisticalNucleus::GetLevelEnergy ( G4int i_level )

Definition at line 897 of file G4NuDEXStatisticalNucleus.cc.

                                                               {
 
  if(i_level>=0 && i_level<NLevels){
    return theLevels[i_level].Energy;
  }
 
  return -1;
}

◆ GetRandom3()

G4NuDEXRandom * G4NuDEXStatisticalNucleus::GetRandom3 ( )

inline

Definition at line 131 of file G4NuDEXStatisticalNucleus.hh.

131{return theRandom3;}

◆ GetSnAndI0()

void G4NuDEXStatisticalNucleus::GetSnAndI0	(	G4double &	sn,
		G4double &	i0 )

inline

Definition at line 118 of file G4NuDEXStatisticalNucleus.hh.

118{sn=Sn; i0=I0;}

◆ HasBeenInitialized()

G4bool G4NuDEXStatisticalNucleus::HasBeenInitialized ( )

inline

Definition at line 132 of file G4NuDEXStatisticalNucleus.hh.

132{return hasBeenInitialized;}

◆ Init()

G4int G4NuDEXStatisticalNucleus::Init	(	const char *	dirname,
		const char *	inputfname = 0 )

Definition at line 171 of file G4NuDEXStatisticalNucleus.cc.

                                                                               {
 
  hasBeenInitialized=true;
  //-------------------------------------------------------------------
  //First, we read data from files:
  G4int check=0;
  char fname[1000],defaultinputfname[1000];
  theLibDir=std::string(dirname);
 
  //Special (default) input file:
  snprintf(defaultinputfname,1000,"%s/SpecialInputs/ZA_%d.dat",dirname,Z_Int*1000+A_Int);
  G4int HasDefaultInput=ReadSpecialInputFile(defaultinputfname);
  char* definputfn=0;
  if(HasDefaultInput>0){definputfn=defaultinputfname;}
  
  //General statistical parameters:
  snprintf(fname,1000,"%s/GeneralStatNuclParameters.dat",dirname);
  check=ReadGeneralStatNuclParameters(fname); if(check<0){return -1;}
 
  //Some default, if not initialized yet:
  if(ElectronConversionFlag<0){ElectronConversionFlag=2;} // All EC
  if(KnownLevelsFlag<0){KnownLevelsFlag=1;} //Use all known levels
  if(PrimaryGammasIntensityNormFactor<0){PrimaryGammasIntensityNormFactor=1;}
  if(PrimaryGammasEcut<0){PrimaryGammasEcut=0;} 
  if(Ecrit<0){
    snprintf(fname,1000,"%s/KnownLevels/levels-param.data",dirname);
    check=ReadEcrit(fname); if(check<0){return -1;}
  }
 
  
  //Level density:
  theLD=new G4NuDEXLevelDensity(Z_Int,A_Int,LevelDensityType);
  check=theLD->ReadLDParameters(dirname,inputfname,definputfn); //if(check<0){return -1;}
  LevelDensityType=theLD->GetLDType(); //because it can be changed by inputfname or due to lack of data
  if(check<0){
    delete theLD; theLD=0;
    Sn=-1; D0=-1; I0=-1000;
  }
  else{
    theLD->GetSnD0I0Vals(Sn,D0,I0);
  }
 
  //Known level sheme:
  snprintf(fname,1000,"%s/KnownLevels/z%03d.dat",dirname,Z_Int);
  check=ReadKnownLevels(fname); if(check<0){return -1;}  //here we get/crosscheck Sn
  I0=TakeTargetNucleiI0(fname,check); if(check<0){return -1;} //if no I0 --> out
 
  if(MaxExcEnergy<=0){
    if(Sn>0){
      MaxExcEnergy=Sn-MaxExcEnergy;
    }
    else{
      MaxExcEnergy=1-MaxExcEnergy;
    }
  }
 
  //If we don't have level density and the known level scheme is not complete, then we can do nothing ...
  if(theLD==0 && Ecrit<MaxExcEnergy){
    std::cout<<" ###### WARNING: No level density and level scheme not complete for ZA="<<1000*Z_Int+A_Int<<" --> Ecrit="<<Ecrit<<" MeV and MaxExcEnergy = "<<MaxExcEnergy<<" MeV ######"<<std::endl;
    return -1;
  }
  //-------------------------------------------------------------------
 
  //------------------------------------------------------------------- 
  //Init some variables:
  E_unk_min=Ecrit;
  E_unk_max=MaxExcEnergy;
  
  NBands=0;
  if(BandWidth>0){//then we have to create some bands
    NBands=0;
    while(E_unk_min+BandWidth*NBands<MaxExcEnergy){
      NBands++;
    }
    E_unk_max=E_unk_min+BandWidth*NBands;
  }
 
  Emin_bands=E_unk_min;
  Emax_bands=E_unk_max;
  //-------------------------------------------------------------------
 
 
  //Make some checks:
  MakeSomeParameterChecks01();
 
  //Level scheme:
  //std::cout<<" creating level scheme ..."<<std::endl;
  CreateLevelScheme();
  //std::cout<<" ............. done"<<std::endl;
 
  if(KnownLevelsFlag==1){
    InsertHighEnergyKnownLevels();
  }
 
  //We set the precursors for each level:
  for(G4int i=0;i<NLevels;i++){
    theLevels[NLevels-1-i].seed=theRandom2->Integer(4294967295)+1;
  }
 
  //Internal conversion:
  theICC=new G4NuDEXInternalConversion(Z_Int);
  snprintf(fname,1000,"%s/ICC_factors.dat",dirname);
  theICC->Init(fname);
  theICC->SetRandom4Seed(theRandom3->GetSeed()); //same seed as for generating the cascades
 
  //PSF:
  thePSF=new G4NuDEXPSF(Z_Int,A_Int);
  thePSF->Init(dirname,theLD,inputfname,definputfn,PSFflag);
 
  //We compute the missing BR in the known part of the level scheme:
  ComputeKnownLevelsMissingBR();
 
  //Init TotalGammaRho:
  TotalGammaRho=new G4double[NLevels];
  for(G4int i=0;i<NLevels-1;i++){
    TotalGammaRho[i]=-1;
  }
 
  //Thermal capture level:
  if(Sn>0 && NLevels>1){
    CreateThermalCaptureLevel();
    GenerateThermalCaptureLevelBR(dirname);
  }
 
  //Init TotalCumulBR, if BROpt==1,2
  if(BROpt==1 || BROpt==2){
    TotalCumulBR=new G4double*[NLevels];
    for(G4int i=0;i<NLevels;i++){
      TotalCumulBR[i]=0;
    }
  }
 
  return 0;
}

◆ PrintAll()

void G4NuDEXStatisticalNucleus::PrintAll ( std::ostream & out )

Definition at line 2302 of file G4NuDEXStatisticalNucleus.cc.

                                                       {
 
  PrintParameters(out);
  PrintKnownLevels(out);
  PrintLevelDensity(out);
  PrintLevelScheme(out);
  PrintThermalPrimaryTransitions(out);
  PrintPSF(out);
  PrintICC(out);
 
}

◆ PrintBR()

void G4NuDEXStatisticalNucleus::PrintBR	(	G4int	i_level,
		G4double	MaxExcEneToPrint_MeV,
		std::ostream &	out )

Definition at line 2234 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                  {
 
  if(TotalCumulBR[i_level]!=0){
    out<<" #################################################### "<<std::endl;
    out<<" BR FROM LEVEL "<<i_level<<" with ENERGY "<<theLevels[i_level].Energy<<std::endl;
    for(G4int i=0;i<i_level;i++){
      if(theLevels[i].Energy<MaxExcEneToPrint_MeV || MaxExcEneToPrint_MeV<0){
    if(i==0){
      out<<theLevels[i].Energy<<"  "<<theLevels[i].spinx2/2.<<"  "<<theLevels[i].parity<<"  "<<TotalCumulBR[i_level][i]<<std::endl;
    }
    else{
      out<<theLevels[i].Energy<<"  "<<theLevels[i].spinx2/2.<<"  "<<theLevels[i].parity<<"  "<<TotalCumulBR[i_level][i]-TotalCumulBR[i_level][i-1]<<std::endl;
    }
      }
    }
    out<<" #################################################### "<<std::endl;
  }
  
  
}

◆ PrintICC()

void G4NuDEXStatisticalNucleus::PrintICC ( std::ostream & out )

Definition at line 2296 of file G4NuDEXStatisticalNucleus.cc.

                                                       {
 
  theICC->PrintICC(out);
 
}

Referenced by PrintAll().

◆ PrintInput01()

void G4NuDEXStatisticalNucleus::PrintInput01 ( std::ostream & out )

Definition at line 2316 of file G4NuDEXStatisticalNucleus.cc.

                                                           {
 
  out<<"LEVELDENSITYTYPE "<<LevelDensityType<<std::endl;
  out<<"MAXSPIN "<<maxspinx2/2.<<std::endl;
  out<<"MINLEVELSPERBAND "<<MinLevelsPerBand<<std::endl;
  out<<"BANDWIDTH_MEV "<<BandWidth<<std::endl;
  out<<"MAXEXCENERGY_MEV "<<MaxExcEnergy<<std::endl;
  out<<"ECRIT_MEV "<<Ecrit<<std::endl;
  out<<"KNOWNLEVELSFLAG "<<KnownLevelsFlag<<std::endl;
  out<<std::endl;
  out<<"PSF_FLAG "<<PSFflag<<std::endl;
  out<<"BROPTION "<<BROpt<<std::endl;
  out<<"SAMPLEGAMMAWIDTHS "<<SampleGammaWidths<<std::endl;
  out<<std::endl;
  out<<"SEED1 "<<seed1<<std::endl;
  out<<"SEED2 "<<seed2<<std::endl;
  out<<"SEED3 "<<seed3<<std::endl;
  out<<std::endl;
  out<<"ELECTRONCONVERSIONFLAG "<<ElectronConversionFlag<<std::endl;
  out<<"PRIMARYTHCAPGAMNORM "<<PrimaryGammasIntensityNormFactor<<std::endl;
  out<<"PRIMARYGAMMASECUT "<<PrimaryGammasEcut<<std::endl;
  out<<std::endl;
  theLD->PrintParametersInInputFileFormat(out);
  thePSF->PrintPSFParametersInInputFileFormat(out);
  out<<std::endl;
  out<<"END"<<std::endl;
 
}

◆ PrintKnownLevels()

void G4NuDEXStatisticalNucleus::PrintKnownLevels ( std::ostream & out )

Definition at line 2072 of file G4NuDEXStatisticalNucleus.cc.

                                                               {
 
  out<<" ########################################################################################################## "<<std::endl;
  out<<" KNOWN_LEVEL_SCHEME "<<std::endl;
  out<<" NKnownLevels = "<<NKnownLevels<<std::endl;
  char buffer[1000];
 
  //for(G4int i=0;i<NKnownLevels;i++){
  for(G4int i=0;i<KnownLevelsVectorSize;i++){
    snprintf(buffer,1000,"%3d %10.4g %5g %2d %10.4g %3d %3d",theKnownLevels[i].id+1,theKnownLevels[i].Energy,theKnownLevels[i].spinx2/2.,2*(G4int)theKnownLevels[i].parity-1,theKnownLevels[i].T12,theKnownLevels[i].NGammas,theKnownLevels[i].Ndecays);
    out<<buffer;
    for(G4int j=0;j<theKnownLevels[i].Ndecays;j++){
      snprintf(buffer,1000,"    %10.4g %7s",theKnownLevels[i].decayFraction[j],theKnownLevels[i].decayMode[j].c_str());
      out<<buffer;
    }
    out<<std::endl;
    for(G4int j=0;j<theKnownLevels[i].NGammas;j++){
      snprintf(buffer,1000,"                                      %4d %10.4g %10.4g %10.4g %10.4g %10.4g %2d",theKnownLevels[i].FinalLevelID[j]+1,theKnownLevels[i].Eg[j],theKnownLevels[i].Pg[j],theKnownLevels[i].Pe[j],theKnownLevels[i].Icc[j],theKnownLevels[i].cumulPtot[j],theKnownLevels[i].multipolarity[j]);
      out<<buffer<<std::endl;
    }
  }
  out<<" ########################################################################################################## "<<std::endl;
 
}

Referenced by PrintAll().

◆ PrintKnownLevelsInDEGENformat()

void G4NuDEXStatisticalNucleus::PrintKnownLevelsInDEGENformat ( std::ostream & out )

Definition at line 2097 of file G4NuDEXStatisticalNucleus.cc.

                                                                            {
 
  out<<" ########################################################################################################## "<<std::endl;
  out<<" KNOWN_LEVES_DEGEN "<<std::endl;
  out<<" NKnownLevels = "<<NKnownLevels<<std::endl;
  char buffer[1000];
 
  for(G4int i=0;i<NKnownLevels;i++){
    G4double MaxIntens=-100;
    G4double GammaEnergy;
    for(G4int j=0;j<theKnownLevels[i].NGammas;j++){
      if(theKnownLevels[i].Pg[j]>MaxIntens){MaxIntens=theKnownLevels[i].Pg[j];}
    }
    for(G4int j=0;j<theKnownLevels[i].NGammas;j++){
      //snprintf(buffer,1000,"%10.3f %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f",theKnownLevels[i].Energy*1000.,theKnownLevels[i].spinx2/2.,2.*(G4int)theKnownLevels[i].parity-1,theKnownLevels[i].Eg[j]*1000.,0.,theKnownLevels[i].Pg[j]/MaxIntens*100.,0.,theKnownLevels[i].Icc[j]);
      GammaEnergy=theKnownLevels[i].Energy-theKnownLevels[theKnownLevels[i].FinalLevelID[j]].Energy;
      snprintf(buffer,1000,"%10.3f %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f %9.3f",theKnownLevels[i].Energy*1000.,theKnownLevels[i].spinx2/2.,2.*(G4int)theKnownLevels[i].parity-1,GammaEnergy*1000.,0.,theKnownLevels[i].Pg[j]/MaxIntens*100.,0.,theKnownLevels[i].Icc[j]);
      out<<buffer<<std::endl;
    }
  }  
  out<<" ########################################################################################################## "<<std::endl;
 
}

◆ PrintLevelDensity()

void G4NuDEXStatisticalNucleus::PrintLevelDensity ( std::ostream & out )

Definition at line 2121 of file G4NuDEXStatisticalNucleus.cc.

                                                                {
 
  if(theLD==0){return;}
 
  G4double Emin=0;
  G4double Emax=E_unk_max;
  G4int np=100;
 
  out<<" ###################################################################################### "<<std::endl;
  out<<" LEVELDENSITY"<<std::endl;
  G4double ene,exp=0;
  G4double *ld=new G4double[maxspinx2+2];
  G4bool *WriteThisSpin=new G4bool[maxspinx2+1];
 
  for(G4int spx2=0;spx2<=maxspinx2;spx2++){
    WriteThisSpin[spx2]=true;
    if(((A_Int+spx2)%2)!=0){
      WriteThisSpin[spx2]=false;
    }
  }
 
  out<<np<<"  "<<Emin<<"  "<<Emax<<"  "<<Ecrit<<"  "<<maxspinx2<<std::endl;
  out<<"ENE   EXP   TOT   SUM(J)";
  for(G4int spx2=0;spx2<=maxspinx2;spx2++){
    if(WriteThisSpin[spx2]){out<<"   J="<<spx2/2.;}
  }
  out<<std::endl;
 
  for(G4int i=0;i<np;i++){
    ene=Emin+(Emax-Emin)*i/(G4double)(np-1);
    exp=0;
    for(G4int j=0;j<NLevels;j++){if(theLevels[j].Energy<ene){exp+=theLevels[j].NLevels;}}
    out<<ene<<"  "<<exp<<"  ";
    ld[maxspinx2+1]=0;
    for(G4int spx2=0;spx2<=maxspinx2;spx2++){
      ld[spx2]=2*theLD->GetLevelDensity(ene,spx2/2.,true);
      ld[maxspinx2+1]+=ld[spx2];
    }
    //out<<ld[maxspinx2+1];
    out<<theLD->GetLevelDensity(ene,0,true,true)<<"  "<<ld[maxspinx2+1];
    for(G4int spx2=0;spx2<=maxspinx2;spx2++){
      if(WriteThisSpin[spx2]){out<<"   "<<ld[spx2];}
    }
    out<<std::endl;
  }
  out<<" ###################################################################################### "<<std::endl;
 
  delete [] ld;
  delete [] WriteThisSpin;
}

Referenced by PrintAll().

◆ PrintLevelScheme()

void G4NuDEXStatisticalNucleus::PrintLevelScheme ( std::ostream & out )

Definition at line 2186 of file G4NuDEXStatisticalNucleus.cc.

                                                               {
  out<<" ###################################################################################### "<<std::endl;
  out<<" LEVELSCHEME"<<std::endl;
  for(G4int i=0;i<NLevels;i++){
    out<<i<<"  "<<theLevels[i].Energy<<"  "<<theLevels[i].spinx2/2.<<"  "<<theLevels[i].parity<<"  "<<theLevels[i].KnownLevelID<<"  "<<theLevels[i].NLevels<<"  "<<theLevels[i].Width<<"  "<<theLevels[i].seed<<std::endl;
  }
  out<<" ###################################################################################### "<<std::endl;
}

Referenced by PrintAll().

◆ PrintLevelSchemeInDEGENformat()

void G4NuDEXStatisticalNucleus::PrintLevelSchemeInDEGENformat	(	const char *	fname,
		G4int	MaxLevelID = -1 )

Definition at line 2172 of file G4NuDEXStatisticalNucleus.cc.

                                                                                               {
 
  std::ofstream out(fname);
  char buffer[1000];
  for(G4int i=0;i<NLevels;i++){
    if(theLevels[i].Energy>Ecrit && (MaxLevelID>0 && i<=MaxLevelID)){
      snprintf(buffer,1000,"%13.5f %17.8f %17.8f ",theLevels[i].Energy*1000.,theLevels[i].spinx2/2.,2.*(G4int)theLevels[i].parity-1);
      out<<buffer<<std::endl;
    }
  }
  out.close();
 
}

◆ PrintParameters()

void G4NuDEXStatisticalNucleus::PrintParameters ( std::ostream & out )

Definition at line 2048 of file G4NuDEXStatisticalNucleus.cc.

                                                              {
 
  out<<" ###################################################################################### "<<std::endl;
  out<<" GENERAL_PARS"<<std::endl;
  out<<" Z = "<<Z_Int<<"  A = "<<A_Int<<std::endl;
  out<<" Sn = "<<Sn<<"  I0(ZA-1) = "<<I0<<std::endl;
  if(theLD!=0){theLD->PrintParameters(out);}
  else{out<<" No level density"<<std::endl;}
  out<<" PSFflag = "<<PSFflag<<std::endl;
  out<<" Ecrit = "<<Ecrit<<std::endl;
  out<<" E_unknown_min = "<<E_unk_min<<"  E_unknown_max = "<<E_unk_max<<std::endl;
  out<<" maxspin = "<<maxspinx2/2.<<std::endl;
  out<<" MaxExcEnergy = "<<MaxExcEnergy<<std::endl;
  out<<" NBands = "<<NBands<<"  MinLevelsPerBand = "<<MinLevelsPerBand<<"  BandWidth = "<<BandWidth<<std::endl;
  out<<" Emin_bands = "<<Emin_bands<<"  Emax_bands = "<<Emax_bands<<std::endl;
  out<<" NLevels = "<<NLevels<<"   NKnownLevels = "<<NKnownLevels<<"   NUnknownLevels = "<<NUnknownLevels<<std::endl;
  out<<" BROpt = "<<BROpt<<"   SampleGammaWidths = "<<SampleGammaWidths<<std::endl;
  out<<" PrimaryGammasIntensityNormFactor = "<<PrimaryGammasIntensityNormFactor<<"   PrimaryGammasEcut = "<<PrimaryGammasEcut<<std::endl;
  out<<" KnownLevelsFlag = "<<KnownLevelsFlag<<std::endl;
  out<<" ElectronConversionFlag = "<<ElectronConversionFlag<<std::endl;
  out<<" ###################################################################################### "<<std::endl;
 
}

Referenced by PrintAll().

◆ PrintPSF()

void G4NuDEXStatisticalNucleus::PrintPSF ( std::ostream & out )

Definition at line 2256 of file G4NuDEXStatisticalNucleus.cc.

                                                       {
 
  thePSF->PrintPSFParameters(out);
 
  G4int NVals=400;
  G4int nEnePSF=(G4int)Sn+1; //number of excitation energies where the PSF are evaluated
  G4double EnePSF[200];
  G4double Emin=0;
  G4double Emax=10;
  G4double xval,e1,m1,e2;
 
  out<<" #################################################### "<<std::endl;
  out<<" PSF"<<std::endl;
  out<<" "<<NVals<<"  "<<Emin<<"  "<<Emax<<"  "<<nEnePSF<<std::endl;
  EnePSF[0]=Sn;
  for(G4int i=1;i<nEnePSF;i++){
    EnePSF[i]=i;
  }
  for(G4int i=0;i<nEnePSF;i++){
    out<<"  "<<EnePSF[i];
  }
  out<<std::endl;
  char word[1000];
  out<<"    E          E1        M1        E2 "<<std::endl;
  for(G4int i=0;i<nEnePSF;i++){
    for(G4int j=0;j<NVals;j++){
      xval=Emin+(Emax-Emin)*j/(NVals-1.);
      if(xval==0){xval=1.e-6;}
      e1=thePSF->GetE1(xval,EnePSF[i]);
      m1=thePSF->GetM1(xval,EnePSF[i]);
      e2=thePSF->GetE2(xval,EnePSF[i]);
      snprintf(word,1000," %10.4E %10.4E %10.4E %10.4E",xval,e1,m1,e2);
      out<<word<<std::endl;
    }
  }
  out<<" #################################################### "<<std::endl;
 
}

Referenced by PrintAll().

◆ PrintThermalPrimaryTransitions()

void G4NuDEXStatisticalNucleus::PrintThermalPrimaryTransitions ( std::ostream & out )

Definition at line 2195 of file G4NuDEXStatisticalNucleus.cc.

                                                                             {
 
  out<<" #################################################### "<<std::endl;
  out<<" THERMAL PRIMARY TRANSITIONS"<<std::endl;
  out<<" "<<NLevelsBelowThermalCaptureLevel<<std::endl;
  if(theThermalCaptureLevelCumulBR!=0){
    out<<" "<<0<<"  "<<theLevels[0].Energy<<"  "<<Sn-theLevels[0].Energy<<"  "<<theThermalCaptureLevelCumulBR[0]<<std::endl;
    for(G4int i=1;i<NLevelsBelowThermalCaptureLevel;i++){
      out<<" "<<i<<"  "<<theLevels[i].Energy<<"  "<<Sn-theLevels[i].Energy<<"  "<<theThermalCaptureLevelCumulBR[i]-theThermalCaptureLevelCumulBR[i-1]<<std::endl;
    }
  }
  out<<" #################################################### "<<std::endl;
 
  G4double ThresholdIntensity=0.01;
  out<<" #################################################### "<<std::endl;
  out<<" STRONGEST THERMAL PRIMARY TRANSITIONS"<<std::endl;
  out<<" "<<NLevelsBelowThermalCaptureLevel<<std::endl;
  if(theThermalCaptureLevelCumulBR!=0){
    if(theThermalCaptureLevelCumulBR[0]>ThresholdIntensity){out<<" "<<0<<"  "<<theLevels[0].Energy<<"  "<<Sn-theLevels[0].Energy<<"  "<<theThermalCaptureLevelCumulBR[0]<<std::endl;}
    for(G4int i=1;i<NLevelsBelowThermalCaptureLevel;i++){
      if(theThermalCaptureLevelCumulBR[i]-theThermalCaptureLevelCumulBR[i-1]>ThresholdIntensity){out<<" "<<i<<"  "<<theLevels[i].Energy<<"  "<<Sn-theLevels[i].Energy<<"  "<<theThermalCaptureLevelCumulBR[i]-theThermalCaptureLevelCumulBR[i-1]<<std::endl;}
    }
  }
  out<<" #################################################### "<<std::endl;
}

Referenced by PrintAll().

◆ PrintTotalCumulBR()

void G4NuDEXStatisticalNucleus::PrintTotalCumulBR	(	G4int	i_level,
		std::ostream &	out )

Definition at line 2221 of file G4NuDEXStatisticalNucleus.cc.

                                                                              {
 
  if(TotalCumulBR[i_level]!=0){
    out<<" #################################################### "<<std::endl;
    out<<" CUMULBR FROM LEVEL "<<i_level<<" with ENERGY "<<theLevels[i_level].Energy<<std::endl;
    for(G4int i=0;i<i_level;i++){
      out<<theLevels[i].Energy<<"  "<<theLevels[i].spinx2/2.<<"  "<<theLevels[i].parity<<"  "<<TotalCumulBR[i_level][i]<<std::endl;
    }
    out<<" #################################################### "<<std::endl;
  }
 
}

◆ SetBandWidth()

void G4NuDEXStatisticalNucleus::SetBandWidth ( G4double bandWidth )

inline

Definition at line 125 of file G4NuDEXStatisticalNucleus.hh.

125{ if(bandWidth==0){bandWidth=-1;} BandWidth=bandWidth;} //So it is not re-written with the lib-params.

◆ SetBrOption()

void G4NuDEXStatisticalNucleus::SetBrOption ( G4int BrOption )

inline

Definition at line 126 of file G4NuDEXStatisticalNucleus.hh.

126{BROpt=BrOption;}

◆ SetInitialParameters02()

void G4NuDEXStatisticalNucleus::SetInitialParameters02	(	G4int	knownLevelsFlag = -1,
		G4int	electronConversionFlag = -1,
		G4double	primGamNormFactor = -1,
		G4double	primGamEcut = -1,
		G4double	ecrit = -1 )

Definition at line 99 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                                                                                       {
  if(hasBeenInitialized){
    //std::cout<<" ############## Error: G4NuDEXStatisticalNucleus::SetInitialParameters02 cannot be used after initializing the nucleus  ##############"<<std::endl;
    NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
  }
  if(knownLevelsFlag>=0){KnownLevelsFlag=knownLevelsFlag;}
  if(electronConversionFlag>=0){ElectronConversionFlag=electronConversionFlag;}
  if(primGamNormFactor>=0){PrimaryGammasIntensityNormFactor=primGamNormFactor;}
  if(primGamEcut>=0){PrimaryGammasEcut=primGamEcut;}
  if(ecrit>=0){Ecrit=ecrit;}
 
}

◆ SetRandom1Seed()

void G4NuDEXStatisticalNucleus::SetRandom1Seed ( unsigned int seed )

inline

Definition at line 127 of file G4NuDEXStatisticalNucleus.hh.

127{theRandom1->SetSeed(seed); Rand1seedProvided=true;}

◆ SetRandom2Seed()

void G4NuDEXStatisticalNucleus::SetRandom2Seed ( unsigned int seed )

inline

Definition at line 128 of file G4NuDEXStatisticalNucleus.hh.

128{theRandom2->SetSeed(seed); Rand2seedProvided=true;}

◆ SetRandom3Seed()

void G4NuDEXStatisticalNucleus::SetRandom3Seed ( unsigned int seed )

inline

Definition at line 129 of file G4NuDEXStatisticalNucleus.hh.

129{theRandom3->SetSeed(seed); Rand3seedProvided=true;}

◆ SetSomeInitalParameters()

void G4NuDEXStatisticalNucleus::SetSomeInitalParameters	(	G4int	LDtype = -1,
		G4int	PSFFlag = -1,
		G4double	MaxSpin = -1,
		G4int	minlevelsperband = -1,
		G4double	BandWidth_MeV = 0,
		G4double	maxExcEnergy = 0,
		G4int	BrOption = -1,
		G4int	sampleGammaWidths = -1,
		unsigned int	aseed1 = 0,
		unsigned int	aseed2 = 0,
		unsigned int	aseed3 = 0 )

Definition at line 112 of file G4NuDEXStatisticalNucleus.cc.

                                                                                                                                                                                                                                                                         {
 
  if(hasBeenInitialized){
    std::cout<<" ############## Error: G4NuDEXStatisticalNucleus::SetSomeInitalParameters cannot be used after initializing the nucleus  ##############"<<std::endl;
    NuDEXException(__FILE__,std::to_string(__LINE__).c_str(),"##### Error in NuDEX #####");
  }
 
  if(LDtype>0){LevelDensityType=LDtype;}
  if(PSFFlag>=0){PSFflag=PSFFlag;}
  if(MaxSpin>0){maxspinx2=(G4int)(2.*MaxSpin+0.01);}
  if(minlevelsperband>0){MinLevelsPerBand=minlevelsperband;}
  if(BandWidth_MeV!=0){BandWidth=BandWidth_MeV;}
  if(maxExcEnergy!=0){MaxExcEnergy=maxExcEnergy;}
  if(BrOption>0){BROpt=BrOption;}
  if(sampleGammaWidths>=0){SampleGammaWidths=sampleGammaWidths;}
  if(aseed1>0){seed1=aseed1; theRandom1->SetSeed(seed1); Rand1seedProvided=true;}
  if(aseed2>0){seed2=aseed2; theRandom2->SetSeed(seed2); Rand2seedProvided=true;}
  if(aseed3>0){seed3=aseed3; theRandom3->SetSeed(seed3); Rand3seedProvided=true;}
 
}

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ G4NuDEXStatisticalNucleus()

◆ ~G4NuDEXStatisticalNucleus()

Member Function Documentation

◆ ChangeLevelSpinParityAndBR()

◆ ChangeThermalCaptureLevelBR()

◆ GenerateCascade()

◆ GetClosestLevel()

◆ GetLevel()

◆ GetLevelEnergy()

◆ GetRandom3()

◆ GetSnAndI0()

◆ HasBeenInitialized()

◆ Init()

◆ PrintAll()

◆ PrintBR()

◆ PrintICC()

◆ PrintInput01()

◆ PrintKnownLevels()

◆ PrintKnownLevelsInDEGENformat()

◆ PrintLevelDensity()

◆ PrintLevelScheme()

◆ PrintLevelSchemeInDEGENformat()

◆ PrintParameters()

◆ PrintPSF()

◆ PrintThermalPrimaryTransitions()

◆ PrintTotalCumulBR()

◆ SetBandWidth()

◆ SetBrOption()

◆ SetInitialParameters02()

◆ SetRandom1Seed()

◆ SetRandom2Seed()

◆ SetRandom3Seed()

◆ SetSomeInitalParameters()