G4LevelReader Class Reference

#include <G4LevelReader.hh>

Public Member Functions
	G4LevelReader (G4NuclearLevelData *)
const G4LevelManager *	CreateLevelManager (G4int Z, G4int A)
const G4LevelManager *	CreateLevelManagerNEW (G4int Z, G4int A)
const G4LevelManager *	MakeLevelManager (G4int Z, G4int A, const G4String &filename)
const G4LevelManager *	MakeLevelManagerNEW (G4int Z, G4int A, const G4String &filename)
void	SetVerbose (G4int val)

Detailed Description

Definition at line 55 of file G4LevelReader.hh.

Constructor & Destructor Documentation

G4LevelReader::G4LevelReader ( G4NuclearLevelData *  ptr )

explicit

Definition at line 56 of file G4LevelReader.cc.

  : fData(ptr),fAlphaMax(9.0f+9),fVerbose(0),fLevelMax(632),fTransMax(80)
{
  fParam = fData->GetParameters();
  fTimeFactor = (G4float)(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.0f; }
  for(G4int i=0; i<nbufmax; ++i) { buffer[i] = ' '; }
  for(G4int i=0; i<nbuf1; ++i)   { buff1[i] = ' '; }
  for(G4int i=0; i<nbuf2; ++i)   { buff2[i] = ' '; }
  bufp[0] = bufp[1] = bufp[2] = ' ';

  fEnergy = fCurrEnergy = fTrEnergy = 0.0;
  fTime = fProb = fSpin = fAlpha = fRatio = fNorm1 = 0.0f;

  vTrans.resize(fTransMax,0);
  vRatio.resize(fTransMax,0.0f);
  vGammaCumProbability.resize(fTransMax,0.0f);
  vGammaProbability.resize(fTransMax,0.0f);
  vShellProbability.resize(fTransMax,nullptr);
  vMpRatio.resize(fTransMax,0.0f);

  vEnergy.resize(fLevelMax,0.0f);
  vSpin.resize(fLevelMax,0);
  vLevel.resize(fLevelMax,nullptr);
}

Here is the call graph for this function:

Member Function Documentation

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

Definition at line 93 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:

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

Definition at line 431 of file G4LevelReader.cc.

{
  std::ostringstream ss;
  ss << "/correlated_gamma/z" << Z << ".a" << A;
  G4String st = G4String(ss.str());
  fFile = fDirectory + st;
  std::ifstream infile(fFile, std::ios::in);

  // file is not opened
  if (!infile.is_open()) {
    if(fVerbose > 0) {
      G4ExceptionDescription ed;
      ed << " for Z= " << Z << " A= " << A  
     << " <" << fFile << "> is not opened!"; 
      G4Exception("G4LevelReader::CreateLevelManagerNEW(..)","had014",
          JustWarning, ed, "");
    }
    return nullptr;
  }
  if (fVerbose > 0) {
    G4cout << "G4LevelReader: open file for Z= " 
       << Z << " A= " << A 
       << " <" << fFile << ">" <<  G4endl;
  }
  return LevelManager(Z, A, 0, infile);
}

Here is the call graph for this function:

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

Definition at line 103 of file G4LevelReader.cc.

{
  vEnergy.resize(1,0.0f);
  vSpin.resize(1,0);
  vLevel.resize(1,nullptr);

  vTrans.clear();
  vGammaCumProbability.clear();
  vGammaProbability.clear();
  vShellProbability.clear();
  vMpRatio.clear();

  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 {

    G4bool allLevels = fParam->StoreAllLevels();
    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;
    G4int  spin;
    G4int  index(0);
    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));
      /*
      G4cout << fEnergy << " " << fTrEnergy << " " << fProb << " " 
         << fPol << " " << fTime << " " << fSpin << " " << fAlpha 
         << " " << isOK << " " << fVerbose << G4endl;
      */
      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 = vTrans.size();
    if(nn > 0) {
      --nn;
      if(fVerbose > 1) {
        G4cout << "Reader: new level E= " << fEnergy 
           << " Ntransitions= " << nn+1 << " fNorm1= " << fNorm1 
           << G4endl;
      } 
      if(fNorm1 > 0.0f) { 
        fNorm1 = 1.0f/fNorm1; 
        for(size_t i=0; i<nn; ++i) {
          vGammaCumProbability[i]  *= fNorm1;
          if(fVerbose > 2) {
        G4cout << "Probabilities[" << i 
               << "]= " << vGammaCumProbability[i]
               << " idxTrans= " << index
               << G4endl;
          }
        }
        vGammaCumProbability[nn]  = 1.0f;
        if(fVerbose > 2) {
          G4cout << "Probabilities[" << nn << "]= " 
             << vGammaCumProbability[nn]
             << " IdxTrans= " << index
             << G4endl;
        }
        vLevel.push_back(new G4NucLevel(vTrans.size(), fTime,
                        vTrans,
                        vGammaCumProbability,
                        vGammaProbability,
                        vMpRatio,
                        vShellProbability));
        //case of X-level
      } else {
            spin += 100000;
            fTime = 0.0f;
        vLevel.push_back(nullptr);
      }
    } else {
      vLevel.push_back(nullptr);
    }
    vSpin.push_back(spin);      
    vTrans.clear();
    vGammaCumProbability.clear();
    vGammaProbability.clear();
    vShellProbability.clear();
    vMpRatio.clear();
        if(!end) { next = true; }
      }
      G4float ener = (G4float)fEnergy;
      // begin nuclear level data
      if(next) {
    if(fVerbose > 1) {
      G4cout << "== Reader: begin of new level E= " << fEnergy 
         << "  Prob= " << fProb << G4endl;
    } 
    // protection for bad level energy
    size_t nn = vEnergy.size();
    if(0 < nn && vEnergy[nn-1] > ener) { 
      ener = vEnergy[nn-1]; 
    } 
    vEnergy.push_back(ener);
        fCurrEnergy = fEnergy;
    fTime *= fTimeFactor;
    if(fSpin > 20.0f) { fSpin = 0.0; }
        spin = (G4int)(fSpin+fSpin);
    fNorm1 = 0.0f;
    next = false;
      } 
      // continue filling level data
      if(!end) {
        if(fProb > 0.0f) {
      // by default transition to a ground state
          G4float efinal = (G4float)std::max(fEnergy - fTrEnergy,0.0);
          G4float elevel = 0.0f;
          size_t  idxLevel = 0;
      G4int tnum = 0;
      // do not check initial energy
      size_t nn = vEnergy.size();
      static const G4float x_energy = (G4float)(0.1*CLHEP::eV);
      if(1 < nn) {
        G4float ediffMin = (G4float)fEnergy;
        for(size_t i=0; i<nn-1; ++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];
        idxLevel = i;
                if(ediff <= x_energy) { break; }
          }
        }
        if(std::abs(vEnergy[nn-1] - elevel) < x_energy) { tnum = 1; }
      }
      G4float x = 1.0f + fAlpha;
      fNorm1 += x*fProb;
      vGammaCumProbability.push_back(fNorm1);
      vGammaProbability.push_back(1.0f/x);
      vMpRatio.push_back(0.0f);
      vTrans.push_back(tnum + idxLevel*10000);
      if(allLevels && fAlpha > 0.0f) {
        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.size(),vEnergy,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() 
         << " " << vSpin.size() << " " << vLevel.size() 
         << G4endl;
    }
  } 
  return man;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 459 of file G4LevelReader.cc.

{
  std::ifstream infile(filename, std::ios::in);

  // file is not opened
  if (!infile.is_open()) {
    G4ExceptionDescription ed;
    ed << " for Z= " << Z << " A= " << A  
       << " data file <" << filename << "> is not opened!";
    G4Exception("G4LevelReader::MakeLevelManagerNEW(..)","had014",
        JustWarning, ed, "Check G4LEVELGAMMADATA");
    return nullptr;
  }
  if (fVerbose > 0) {
    G4cout << "G4LevelReader: open file for Z= " 
       << Z << " A= " << A 
       << " <" << filename << ">" <<  G4endl;
  }
  return LevelManager(Z, A, 0, infile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4LevelReader::SetVerbose ( G4int  val )

inline

Definition at line 149 of file G4LevelReader.hh.

{
  fVerbose = val;
}

---

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

• geant4.10.03.p01/source/processes/hadronic/models/de_excitation/management/include/G4LevelReader.hh
• geant4.10.03.p01/source/processes/hadronic/models/de_excitation/management/src/G4LevelReader.cc