#include <G4LevelReader.hh>

Collaboration diagram for G4LevelReader:

Public Member Functions
	G4LevelReader ()

	~G4LevelReader ()

const G4LevelManager *	CreateLevelManager (G4int Z, G4int A)

const G4LevelManager *	MakeLevelManager (G4int Z, G4int A, const G4String &filename)

void	SetVerbose (G4int val)

Private Member Functions
G4bool	ReadDataItem (std::istream &dataFile, G4double &x)

G4bool	ReadDataItem (std::istream &dataFile, G4String &x)

const std::vector< G4float > *	NormalizedICCProbability (G4int Z)

	G4LevelReader (const G4LevelReader &right)

const G4LevelReader &	operator= (const G4LevelReader &right)

G4bool	operator== (const G4LevelReader &right) const

G4bool	operator!= (const G4LevelReader &right) const

Private Attributes
G4double	fMinProbability

G4double	fTimeFactor

G4double	fEnergy

G4double	fCurrEnergy

G4double	fTrEnergy

G4double	fProb

G4double	fTime

G4double	fSpin

G4double	fAlpha

G4double	fICC [10]

G4String	fDirectory

G4String	fFile

G4String	fPol

char	buffer [20]

char	bufp [2]

G4int	fVerbose

G4float	fNorm1

G4float	fNorm2

std::vector< G4float >	vEnergy

std::vector< G4float >	vTime

std::vector< G4float >	vTimeg

std::vector< G4int >	vSpin

std::vector< const G4NucLevel * >	vLevel

std::vector< G4float >	vTransEnergy

std::vector< G4float >	vGammaCumProbability

std::vector< G4float >	vGammaECumProbability

std::vector< G4float >	vGammaProbability

std::vector< G4int >	vTrans

std::vector< const std::vector< G4float > * >	vShellProbability

Static Private Attributes
static G4String	fTrans [10]

Detailed Description

Definition at line 52 of file G4LevelReader.hh.

Constructor & Destructor Documentation

◆ G4LevelReader() [1/2]

G4LevelReader::G4LevelReader ( )

Definition at line 56 of file G4LevelReader.cc.

   : fMinProbability(1.e-8),fVerbose(0)
 {
   fTimeFactor = CLHEP::second/G4Pow::GetInstance()->logZ(2);
   char* directory = getenv("G4LEVELGAMMADATA");
   if(directory) {
     fDirectory = directory;
   } else {
     G4Exception("G4LevelReader()","had0707",FatalException,
         "Environment variable G4LEVELGAMMADATA is not defined");
     fDirectory = "";
   } 
   fFile = fDirectory + "/z100.a200";
   fPol = "  ";
   for(G4int i=0; i<10; ++i) { fICC[i] = 0.0; }
   for(G4int i=0; i<20; ++i) { buffer[i] = ' '; }
   bufp[0] = bufp[1] = ' ';
 
   fEnergy = fCurrEnergy = fTrEnergy = fProb = fTime = fSpin = fAlpha = 0.0;
   fNorm1 = fNorm2 = 0.0f;
 
   size_t nn = 10;
   vTransEnergy.reserve(nn);
   vGammaCumProbability.reserve(nn);
   vGammaECumProbability.reserve(nn);
   vGammaProbability.reserve(nn);
   vShellProbability.reserve(nn);
   vTrans.reserve(nn);
 
   nn = 100;
   vEnergy.reserve(nn);
   vTime.reserve(nn);
   vTimeg.reserve(nn);
   vSpin.reserve(nn);
   vLevel.reserve(nn);
 }

Here is the call graph for this function:

◆ ~G4LevelReader()

G4LevelReader::~G4LevelReader ( )

Definition at line 93 of file G4LevelReader.cc.

94 {}

◆ G4LevelReader() [2/2]

G4LevelReader::G4LevelReader ( const G4LevelReader & right )

private

Member Function Documentation

◆ CreateLevelManager()

const G4LevelManager * G4LevelReader::CreateLevelManager	(	G4int	Z,
		G4int	A
	)

Definition at line 97 of file G4LevelReader.cc.

 {
   std::ostringstream ss;
   ss << "/z" << Z << ".a" << A;
   G4String st =  G4String(ss.str());
   fFile = fDirectory + st;
   return MakeLevelManager(Z, A, fFile);
 }

Here is the call graph for this function:

◆ MakeLevelManager()

const G4LevelManager * G4LevelReader::MakeLevelManager	(	G4int	Z,
		G4int	A,
		const G4String &	filename
	)

Definition at line 107 of file G4LevelReader.cc.

 {
   vEnergy.clear();
   vTime.clear();
   vTimeg.clear();
   vSpin.clear();
   vLevel.clear();
 
   vEnergy.push_back(0.0f);
   vTime.push_back(FLT_MAX);
   vTimeg.push_back(FLT_MAX);
   vSpin.push_back(0);
   vLevel.push_back(nullptr);
 
   std::ifstream infile(filename, std::ios::in);
 
   // file is not opened
   if (!infile.is_open()) {
     if (fVerbose > 0) {
       G4cout << " G4LevelReader: fail open file for Z= " 
          << Z << " A= " << A 
          << " <" << filename << ">" <<  G4endl;
     }
 
   } else {
 
     if (fVerbose > 0) {
       G4cout << "G4LevelReader: open file for Z= " 
          << Z << " A= " << A 
          << " <" << filename << ">" <<  G4endl;
     }
     // read line by line
     G4bool end = false;
     G4bool next = true;
     G4int nline = -1;
     fCurrEnergy = DBL_MAX;
     do {
       fPol = "  ";
       ++nline;
       G4bool isOK = (ReadDataItem(infile,fEnergy)   &&
              ReadDataItem(infile,fTrEnergy) &&
              ReadDataItem(infile,fProb)     &&
              ReadDataItem(infile,fPol)      &&
              ReadDataItem(infile,fTime)     &&
              ReadDataItem(infile,fSpin)     &&
              ReadDataItem(infile,fAlpha));
 
       fEnergy   *= CLHEP::keV;
       fTrEnergy *= CLHEP::keV;
 
       if(isOK) {
     for(G4int i=0; i<10; ++i) { 
       isOK = (isOK && (ReadDataItem(infile,fICC[i])));
     }
       }
       if(!isOK) {
     end = true; 
     next = false; 
       }
       if(fVerbose > 1) {
     G4cout << "#Line " << nline << " " << fEnergy << " " << fTrEnergy 
            << " " << fProb << " " <<  fPol << " " << fTime << " " 
            << fSpin << " " << fAlpha << G4endl;
     G4cout << "      ";
     for(G4int i=0; i<10; ++i) { G4cout << fICC[i] << " "; }
     G4cout << G4endl;
       }
       // end of nuclear level data
       if(end || fEnergy > fCurrEnergy) {
     size_t nn = vTransEnergy.size();
     if(nn > 0) {
       if(fVerbose > 1) {
         G4cout << "Reader: new level E= " << fCurrEnergy 
            << " Ntransitions= " << nn << " fNorm1= " << fNorm1 
            << " fNorm2= " << fNorm2 << G4endl;
       } 
       if(fNorm1 > 0.0f) {
         --nn;
         fNorm1 = 1.0f/fNorm1; 
         vTimeg.push_back(((G4float)(fTime*fTimeFactor))*fNorm2*fNorm1);
         fNorm2 = 1.0f/fNorm2; 
         for(size_t i=0; i<nn; ++i) {
           vGammaCumProbability[i]  *= fNorm1;
           vGammaECumProbability[i] *= fNorm2;
           if(fVerbose > 2) {
         G4cout << "Probabilities[" << i << "]= " << vGammaCumProbability[i]
                << "  " << vGammaECumProbability[i] 
                << " Etran= " << vTransEnergy[i]
                << G4endl;
           }
         }
         vGammaCumProbability[nn]  = 1.0f;
         vGammaECumProbability[nn] = 1.0f;
         if(fVerbose > 2) {
           G4cout << "Probabilities[" << nn << "]= " << vGammaCumProbability[nn]
              << "  " << vGammaECumProbability[nn] 
              << " Etran= " << vTransEnergy[nn]
              << G4endl;
         }
         //case of X-level
       } else {
         vTimeg.push_back(0.0f);
         vGammaCumProbability[0]  = 0.0f;
         vGammaECumProbability[0] = 0.0f;
       }
       
       vLevel.push_back(new G4NucLevel(vTransEnergy,
                       vGammaCumProbability,
                       vGammaECumProbability,
                       vGammaProbability,
                       vTrans,
                       vShellProbability));
       vTransEnergy.clear();
       vGammaCumProbability.clear();
       vGammaECumProbability.clear();
       vGammaProbability.clear();
       vShellProbability.clear();
       vTrans.clear();
     }
         if(!end) { next = true; }
       }
       fCurrEnergy = fEnergy;
       // begin nuclear level data
       if(next) {
     if(fVerbose > 2) {
       G4cout << "== Reader: begin of new level E= " << fEnergy << G4endl;
     } 
     vEnergy.push_back((G4float)fEnergy);
     vTime.push_back((G4float)(fTime*fTimeFactor));
     if(fSpin > 20.0) { fSpin = 0.0; }
     fProb = std::max(fProb, fMinProbability);  
     vSpin.push_back(G4lrint(2*fSpin));
     fNorm1 = 0.0f;
     fNorm2 = 0.0f;
     next = false;
       } 
       // continue filling level data
       if(!end) {
         if(fProb > 0.0) {
       // by default transition to a ground state
           G4float efinal = (G4float)(fEnergy - fTrEnergy);
           G4float elevel = 0.0f;
       // do not check initial energy
       G4int nn = vEnergy.size() - 1;
       if(0 < nn) {
         G4float ediffMin = std::abs(efinal);
         for(G4int i=0; i<nn; ++i) {
               G4float ediff = std::abs(efinal - vEnergy[i]);
           /*
           G4cout << "Elevel[" << i << "]= " << vEnergy[i] 
              << " Efinal= " << efinal
              << " Ediff= " << ediff
              << " EdiffMin= " << ediffMin << G4endl;
           */
           if(ediff < ediffMin) {
         ediffMin = ediff;
                 elevel = vEnergy[i];
           }
         }
       }
       G4double x = 1.0 + fAlpha;
       fNorm1 += (G4float)fProb;
       fNorm2 += (G4float)(fProb*x);
       vTransEnergy.push_back(elevel);
       vGammaCumProbability.push_back(fNorm1);
       vGammaECumProbability.push_back(fNorm2);
       vGammaProbability.push_back((G4float)(1.0/x));
       G4int tnum = 0;
           if(std::abs(vEnergy[nn] - elevel) < x_energy) { tnum = 1; }
       //for(; tnum<10; ++tnum) { if(fTrans[tnum] == fPol) { break; } }
       vTrans.push_back(tnum);
       if(fAlpha > 0.0) {
         vShellProbability.push_back(NormalizedICCProbability(Z));
       } else {
         vShellProbability.push_back(nullptr);
       }
     }
       }
       if(nline > 10000) {
     G4cout << "G4LevelReader: Line #" << nline << " Z= " << Z << " A= "
            << " this file is too long - stop loading" << G4endl;
     end = true;
       }
       // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
     } while (!end);
     infile.close();
   }
 
   G4LevelManager* man = nullptr;
   if(vEnergy.size() >= 2) {
     man = new G4LevelManager(vEnergy,vTime,vTimeg,vSpin,vLevel); 
     if(fVerbose > 0) {
       G4cout << "=== Reader: new manager for Z= " << Z << " A= " << A 
          << " Nlevels= " << vEnergy.size() << " E[0]= " 
          << vEnergy[0]/CLHEP::MeV << " MeV   Emax= " 
          << man->MaxLevelEnergy()/CLHEP::MeV << " MeV "
          << " S: " <<  vEnergy.size() << " " << vTime.size()
          << " " << vTimeg.size() << " " << vSpin.size() << " " << vLevel.size() 
          << G4endl;
     }
   } 
   return man;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NormalizedICCProbability()

const std::vector< G4float > * G4LevelReader::NormalizedICCProbability ( G4int Z )

private

Definition at line 332 of file G4LevelReader.cc.

 {
   std::vector<G4float>* vec = nullptr;
   G4int LL = 3;
   G4int M = 5;
   G4int N = 1;
   if(Z <= 4) {
     LL = 1;
     M = N = 0;
   } else if(Z <= 6) {
     LL = 2;
     M = N = 0;
   } else if(Z <= 10) {
     M = N = 0;
   } else if(Z <= 12) {
     M = 1;
     N = 0;
   } else if(Z <= 17) {
     M = 2;
     N = 0;
   } else if(Z == 18) {
     M = 3;
     N = 0;
   } else if(Z <= 20) {
     M = 3;
   } else if(Z <= 27) {
     M = 4;
   }
   G4double norm = 0.0;
   if(LL < 3) { for(G4int i=LL+1; i<=4; ++i) { fICC[i] = 0.0; } }
   if(M < 5) { for(G4int i=M+4; i<=8; ++i) { fICC[i] = 0.0; } }
   if(N < 1) { fICC[9] = 0.0; }
   for(G4int i=0; i<10; ++i) {
     norm += fICC[i]; 
     fICC[i] = norm;
   }
   if(norm > 0.0) {
     norm = 1.0/norm;
     vec = new std::vector<G4float>;
     vec->reserve(10);
     for(G4int i=0; i<9; ++i) {
       vec->push_back((G4float)(fICC[i]*norm)); 
     }
     vec->push_back(1.0f);
   }
   return vec;
 }

Here is the caller graph for this function:

◆ operator!=()

G4bool G4LevelReader::operator!= ( const G4LevelReader & right ) const

private

◆ operator=()

const G4LevelReader& G4LevelReader::operator= ( const G4LevelReader & right )

private

◆ operator==()

G4bool G4LevelReader::operator== ( const G4LevelReader & right ) const

private

◆ ReadDataItem() [1/2]

G4bool G4LevelReader::ReadDataItem	(	std::istream &	dataFile,
		G4double &	x
	)

private

Definition at line 311 of file G4LevelReader.cc.

 {
   x = 0.0;
   for(G4int i=0; i<20; ++i) { buffer[i] = ' '; }
   G4bool okay = true;
   dataFile >> buffer;
   if(dataFile.fail()) { okay = false; }
   else { x = strtod(buffer, 0); }
 
   return okay;
 }

Here is the caller graph for this function:

◆ ReadDataItem() [2/2]

G4bool G4LevelReader::ReadDataItem	(	std::istream &	dataFile,
		G4String &	x
	)

private

Definition at line 323 of file G4LevelReader.cc.

 {
   G4bool okay = true;
   dataFile >> bufp;
   if(dataFile.fail()) { okay = false; }
   else { x = G4String(bufp, 2); }
   return okay;
 }

◆ SetVerbose()

void G4LevelReader::SetVerbose ( G4int val )

inline

Definition at line 122 of file G4LevelReader.hh.

 {
   fVerbose = val;
 }

Member Data Documentation

◆ buffer

char G4LevelReader::buffer[20]

private

Definition at line 100 of file G4LevelReader.hh.

◆ bufp

char G4LevelReader::bufp[2]

private

Definition at line 101 of file G4LevelReader.hh.

◆ fAlpha

G4double G4LevelReader::fAlpha

private

Definition at line 92 of file G4LevelReader.hh.

◆ fCurrEnergy

G4double G4LevelReader::fCurrEnergy

private

Definition at line 87 of file G4LevelReader.hh.

◆ fDirectory

G4String G4LevelReader::fDirectory

private

Definition at line 96 of file G4LevelReader.hh.

◆ fEnergy

G4double G4LevelReader::fEnergy

private

Definition at line 86 of file G4LevelReader.hh.

◆ fFile

G4String G4LevelReader::fFile

private

Definition at line 97 of file G4LevelReader.hh.

◆ fICC

G4double G4LevelReader::fICC[10]

private

Definition at line 93 of file G4LevelReader.hh.

◆ fMinProbability

G4double G4LevelReader::fMinProbability

private

Definition at line 83 of file G4LevelReader.hh.

◆ fNorm1

G4float G4LevelReader::fNorm1

private

Definition at line 105 of file G4LevelReader.hh.

◆ fNorm2

G4float G4LevelReader::fNorm2

private

Definition at line 106 of file G4LevelReader.hh.

◆ fPol

G4String G4LevelReader::fPol

private

Definition at line 98 of file G4LevelReader.hh.

◆ fProb

G4double G4LevelReader::fProb

private

Definition at line 89 of file G4LevelReader.hh.

◆ fSpin

G4double G4LevelReader::fSpin

private

Definition at line 91 of file G4LevelReader.hh.

◆ fTime

G4double G4LevelReader::fTime

private

Definition at line 90 of file G4LevelReader.hh.

◆ fTimeFactor

G4double G4LevelReader::fTimeFactor

private

Definition at line 84 of file G4LevelReader.hh.

◆ fTrans

G4String G4LevelReader::fTrans

staticprivate

Initial value:

= {

"1-", "1+", "2-", "2+", "3-", "3+", "4-", "4+", "5-", "5+"}

Definition at line 95 of file G4LevelReader.hh.

◆ fTrEnergy

G4double G4LevelReader::fTrEnergy

private

Definition at line 88 of file G4LevelReader.hh.

◆ fVerbose

G4int G4LevelReader::fVerbose

private

Definition at line 103 of file G4LevelReader.hh.

◆ vEnergy

std::vector<G4float> G4LevelReader::vEnergy

private

Definition at line 108 of file G4LevelReader.hh.

◆ vGammaCumProbability

std::vector<G4float> G4LevelReader::vGammaCumProbability

private

Definition at line 115 of file G4LevelReader.hh.

◆ vGammaECumProbability

std::vector<G4float> G4LevelReader::vGammaECumProbability

private

Definition at line 116 of file G4LevelReader.hh.

◆ vGammaProbability

std::vector<G4float> G4LevelReader::vGammaProbability

private

Definition at line 117 of file G4LevelReader.hh.

◆ vLevel

std::vector<const G4NucLevel*> G4LevelReader::vLevel

private

Definition at line 112 of file G4LevelReader.hh.

◆ vShellProbability

std::vector<const std::vector<G4float>*> G4LevelReader::vShellProbability

private

Definition at line 119 of file G4LevelReader.hh.

◆ vSpin

std::vector<G4int> G4LevelReader::vSpin

private

Definition at line 111 of file G4LevelReader.hh.

◆ vTime

std::vector<G4float> G4LevelReader::vTime

private

Definition at line 109 of file G4LevelReader.hh.

◆ vTimeg

std::vector<G4float> G4LevelReader::vTimeg

private

Definition at line 110 of file G4LevelReader.hh.

◆ vTrans

std::vector<G4int> G4LevelReader::vTrans

private

Definition at line 118 of file G4LevelReader.hh.

◆ vTransEnergy

std::vector<G4float> G4LevelReader::vTransEnergy

private

Definition at line 114 of file G4LevelReader.hh.

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

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4LevelReader() [1/2]

◆ ~G4LevelReader()

◆ G4LevelReader() [2/2]

Member Function Documentation

◆ CreateLevelManager()

◆ MakeLevelManager()

◆ NormalizedICCProbability()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ ReadDataItem() [1/2]

◆ ReadDataItem() [2/2]

◆ SetVerbose()

Member Data Documentation

◆ buffer

◆ bufp

◆ fAlpha

◆ fCurrEnergy

◆ fDirectory

◆ fEnergy

◆ fFile

◆ fICC

◆ fMinProbability

◆ fNorm1

◆ fNorm2

◆ fPol

◆ fProb

◆ fSpin

◆ fTime

◆ fTimeFactor

◆ fTrans

◆ fTrEnergy

◆ fVerbose

◆ vEnergy

◆ vGammaCumProbability

◆ vGammaECumProbability

◆ vGammaProbability

◆ vLevel

◆ vShellProbability

◆ vSpin

◆ vTime

◆ vTimeg

◆ vTrans

◆ vTransEnergy