G4PhotonEvaporation Class Reference

#include <G4PhotonEvaporation.hh>

Inheritance diagram for G4PhotonEvaporation:

Collaboration diagram for G4PhotonEvaporation:

Public Member Functions
	G4PhotonEvaporation (G4GammaTransition *ptr=0)
virtual	~G4PhotonEvaporation ()
virtual G4Fragment *	EmittedFragment (G4Fragment *theNucleus)
virtual G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
virtual G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual G4FragmentVector *	BreakUp (const G4Fragment &theNucleus)
virtual G4FragmentVector *	BreakItUp (const G4Fragment &theNucleus)
virtual G4double	GetEmissionProbability (G4Fragment *theNucleus)
virtual G4double	GetFinalLevelEnergy (G4int Z, G4int A, G4double energy)
virtual G4double	GetUpperLevelEnergy (G4int Z, G4int A)
void	SetGammaTransition (G4GammaTransition *)
void	SetMaxHalfLife (G4double)
virtual void	SetICM (G4bool)
virtual void	RDMForced (G4bool)
void	SetVerboseLevel (G4int verbose)
G4int	GetVacantShellNumber () const
Public Member Functions inherited from G4VEvaporationChannel
	G4VEvaporationChannel (const G4String &aName="")
virtual	~G4VEvaporationChannel ()
virtual void	Initialise ()
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
virtual void	Dump () const
G4double	GetMaxLevelEnergy (G4int Z, G4int A)
G4double	GetNearestLevelEnergy (G4int Z, G4int A, G4double energy)
void	SetPhotonEvaporation (G4VEvaporationChannel *p)
void	SetOPTxs (G4int opt)
void	UseSICB (G4bool use)

Private Member Functions
G4Fragment *	GenerateGamma (G4Fragment *nucleus)
void	InitialiseLevelManager (G4int Z, G4int A)
	G4PhotonEvaporation (const G4PhotonEvaporation &right)
const G4PhotonEvaporation &	operator= (const G4PhotonEvaporation &right)

Private Attributes
G4NuclearLevelData *	fNuclearLevelData
const G4LevelManager *	fLevelManager
G4GammaTransition *	fTransition
G4int	fVerbose
G4int	theZ
G4int	theA
G4int	fPoints
G4int	fCode
G4int	vShellNumber
size_t	fIndex
G4double	fCummProbability [MAXDEPOINT]
G4double	fLevelEnergyMax
G4double	fExcEnergy
G4double	fFermiEnergy
G4double	fProbability
G4double	fStep
G4double	fTimeLimit
G4double	fMaxLifeTime
G4bool	fICM
G4bool	fRDM
G4bool	fSampleTime

Static Private Attributes
static G4float	GREnergy [MAXGRDATA] = {0.0f}
static G4float	GRWidth [MAXGRDATA] = {0.0f}

Additional Inherited Members
Protected Attributes inherited from G4VEvaporationChannel
G4int	OPTxs
G4bool	useSICB

Detailed Description

Definition at line 64 of file G4PhotonEvaporation.hh.

Constructor & Destructor Documentation

G4PhotonEvaporation() [1/2]

G4PhotonEvaporation::G4PhotonEvaporation

(

G4GammaTransition *

ptr = 0

)

Definition at line 67 of file G4PhotonEvaporation.cc.

  : fLevelManager(nullptr), fTransition(p), fVerbose(0), fPoints(0), 
    vShellNumber(-1), fIndex(0), fTimeLimit(DBL_MAX), fMaxLifeTime(DBL_MAX), 
    fICM(false), fRDM(false), fSampleTime(true)
{
  fNuclearLevelData = G4NuclearLevelData::GetInstance(); 
  if(!fTransition) { 
    char* en = getenv("G4UseNuclearPolarization"); 
    if(en) { fTransition = new G4PolarizedGammaTransition(); }
    else   { fTransition = new G4GammaTransition(); }
  }

  char* env = getenv("G4AddTimeLimitToPhotonEvaporation"); 
  if(env) { fTimeLimit = 1.e-16*CLHEP::second; }

  theA = theZ = fCode = 0;
  fLevelEnergyMax = fStep = fExcEnergy = fFermiEnergy = fProbability = 0.0;

  for(G4int i=0; i<MAXDEPOINT; ++i) { fCummProbability[i] = 0.0; }
  if(0.0f == GREnergy[1]) {
    G4Pow* g4pow = G4Pow::GetInstance();
    for (G4int A=1; A<MAXGRDATA; ++A) {
      GREnergy[A] = (G4float)(40.3*CLHEP::MeV/g4pow->powZ(A,0.2));
      GRWidth[A] = GRWfactor*GREnergy[A];
    }
  } 
}

Here is the call graph for this function:

~G4PhotonEvaporation()

G4PhotonEvaporation::~G4PhotonEvaporation ( )

virtual

Definition at line 95 of file G4PhotonEvaporation.cc.

{ 
  delete fTransition;
}

G4PhotonEvaporation() [2/2]

G4PhotonEvaporation::G4PhotonEvaporation ( const G4PhotonEvaporation &  right )

private

Member Function Documentation

BreakItUp()

G4FragmentVector * G4PhotonEvaporation::BreakItUp ( const G4Fragment &  theNucleus )

virtual

Definition at line 136 of file G4PhotonEvaporation.cc.

{
  //G4cout << "G4PhotonEvaporation::BreakItUp" << G4endl;
  G4Fragment* aNucleus = new G4Fragment(nucleus);
  G4FragmentVector* products = new G4FragmentVector();
  BreakUpChain(products, aNucleus);
  products->push_back(aNucleus);
  return products;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BreakUp()

G4FragmentVector * G4PhotonEvaporation::BreakUp ( const G4Fragment &  theNucleus )

virtual

Implements G4VEvaporationChannel.

Definition at line 125 of file G4PhotonEvaporation.cc.

{
  //G4cout << "G4PhotonEvaporation::BreakUp" << G4endl;
  G4Fragment* aNucleus = new G4Fragment(nucleus);
  G4FragmentVector* products = new G4FragmentVector();
  BreakUpChain(products, aNucleus);
  products->push_back(aNucleus);
  return products;
}

Here is the call graph for this function:

BreakUpChain()

G4bool G4PhotonEvaporation::BreakUpChain ( G4FragmentVector *  theResult, G4Fragment *  theNucleus  )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 146 of file G4PhotonEvaporation.cc.

{
  if(fVerbose > 0) {
    G4cout << "G4PhotonEvaporation::BreakUpChain RDM= " << fRDM << " "
       << *nucleus << G4endl;
  }
  G4Fragment* gamma = 0;
  if(fRDM) { fSampleTime = false; }
  else     { fSampleTime = true; }

  do {
    gamma = GenerateGamma(nucleus);
    if(gamma) { 
      products->push_back(gamma);
      if(fVerbose > 0) {
    G4cout << "G4PhotonEvaporation::BreakUpChain: "   
           << *gamma << G4endl;
    G4cout << "   Residual: " << *nucleus << G4endl;
      }
      // for next decays in the chain always sample time
      fSampleTime = true;
    } 
    // Loop checking, 05-Aug-2015, Vladimir Ivanchenko
  } while(gamma);
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BreakUpFragment()

G4FragmentVector * G4PhotonEvaporation::BreakUpFragment ( G4Fragment *  theNucleus )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 116 of file G4PhotonEvaporation.cc.

{
  //G4cout << "G4PhotonEvaporation::BreakUpFragment" << G4endl;
  G4FragmentVector* products = new G4FragmentVector();
  BreakUpChain(products, nucleus);
  return products;
}

Here is the call graph for this function:

EmittedFragment()

G4Fragment * G4PhotonEvaporation::EmittedFragment ( G4Fragment *  theNucleus )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 101 of file G4PhotonEvaporation.cc.

{
  if(fRDM) { fSampleTime = false; }
  else     { fSampleTime = true; }

  G4Fragment* gamma = GenerateGamma(nucleus);
  if(fVerbose > 0) {
    G4cout << "G4PhotonEvaporation::EmittedFragment: RDM= " << fRDM << G4endl; 
    if(gamma) { G4cout << *gamma << G4endl; }
    G4cout << "   Residual: " << *nucleus << G4endl;
  }
  return gamma; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateGamma()

G4Fragment * G4PhotonEvaporation::GenerateGamma ( G4Fragment *  nucleus )

private

Definition at line 269 of file G4PhotonEvaporation.cc.

{
  G4Fragment* result = 0;
  G4double eexc = nucleus->GetExcitationEnergy();
  if(eexc < Tolerance) { return result; }

  InitialiseLevelManager(nucleus->GetZ_asInt(), nucleus->GetA_asInt());

  G4double time = nucleus->GetCreationTime();

  G4double efinal = 0.0;
  vShellNumber    = -1;
  size_t shell    = 0;
  G4int  deltaS   = 1;
  G4bool isGamma  = true;
  G4bool isLongLived  = false;
  G4bool isX = false;
  G4bool icm = fICM;

  if(fVerbose > 1) {
    G4cout << "GenerateGamma: Exc= " << eexc << " Emax= " 
       << fLevelEnergyMax << " fEex= " << fExcEnergy 
       << " fCode= " << fCode << " fPoints= " << fPoints 
       << " fProb= " << fProbability << G4endl;
  }
  // continues part
  if(!fLevelManager || eexc > fLevelEnergyMax + Tolerance) {
    //G4cout << "Continues fPoints= " << fPoints << " " << fLevelManager << G4endl;

    // we compare current excitation versus value used for probability 
    // computation and also Z and A used for probability computation 
    if(fCode != 1000*theZ + theA || eexc != fExcEnergy) { 
      GetEmissionProbability(nucleus); 
    }
    if(fProbability == 0.0) { return result; }
    G4double y = fProbability*G4UniformRand();
    for(G4int i=1; i<fPoints; ++i) {
      //G4cout << "y= " << y << " cummProb= " << fCummProbability[i] << G4endl;
      if(y <= fCummProbability[i]) {
    efinal = fStep*((i - 1) + (y - fCummProbability[i-1])
            /(fCummProbability[i] - fCummProbability[i-1]));
    break;
      }
    }
    // final discrete level
    if(fLevelManager && efinal <=  fLevelEnergyMax + Tolerance) {
      //G4cout << "Efinal= " << efinal << "  idx= " << fIndex << G4endl;
      fIndex = fLevelManager->NearestLevelIndex(efinal, fIndex);
      efinal = (G4double)fLevelManager->LevelEnergy(fIndex);
    }
    //discrete part
  } else { 
    fIndex = fLevelManager->NearestLevelIndex(eexc, fIndex);
    if(fVerbose > 1) {
      G4cout << "Discrete emission from level Index= " << fIndex 
         << " Elevel= " << fLevelManager->LevelEnergy(fIndex)
         << "  RDM= " << fRDM << "  ICM= " << fICM << G4endl;
    }
    if(0 == fIndex) { return result; }
    const G4NucLevel* level = fLevelManager->GetLevel(fIndex);

    // radioactive decay model call transitions one by one
    // for X-level corresponding gamma transition is forced 
    // from the previous one; this is needed, because
    // X-level assumes a competition between beta amd gamma 
    // decay probabilities
    isX = level->IsXLevel();
    if(isX && fRDM && fIndex > 0) {
      --fIndex;
      level = fLevelManager->GetLevel(fIndex);
      isX = level->IsXLevel();
    }

    G4double ltime = 0.0;
    if(fICM) { ltime = (G4double)fLevelManager->LifeTime(fIndex); }
    else     { ltime = (G4double)fLevelManager->LifeTimeGamma(fIndex); }

    if(ltime >= fMaxLifeTime) { return result; }
    if(ltime > fTimeLimit) { 
      icm = true; 
      isLongLived = true;
    }
    size_t ntrans = level->NumberOfTransitions();
    size_t idx = 0;
    if(fVerbose > 1) {
      G4cout << "Ntrans= " << ntrans << " idx= " << idx << " isX= " << isX 
         << " icm= " << icm << G4endl;
    }
    if(!isX) {
      if(1 < ntrans) {
    G4double rndm = G4UniformRand();
    if(icm) { idx = level->SampleGammaETransition(rndm); }
    else    { idx = level->SampleGammaTransition(rndm); }
    //G4cout << "Sampled idx= " << idx << "  rndm= " << rndm << G4endl;
      }
      if(icm) {
    G4double rndm = G4UniformRand();
    G4double prob = level->GammaProbability(idx);
    if(rndm > prob) {
      rndm = (rndm - prob)/(1.0 - prob);
      shell = level->SampleShell(idx, rndm);
      vShellNumber = shell;
          isGamma = false;
    }
      }
    }
    efinal = (G4double)level->FinalExcitationEnergy(idx);
    fIndex += idx;
    fIndex = (fIndex >= ntrans) ? fIndex - ntrans : 0; 

    if(fSampleTime && ltime > 0.0) { 
      time -= ltime*G4Log(G4UniformRand()); 
    }
  }
  // no gamma emission for X-level
  if(isX) {
    G4ThreeVector v = nucleus->GetMomentum().vect().unit();
    G4double mass = nucleus->GetGroundStateMass() + efinal;
    G4double e = std::max(mass,nucleus->GetMomentum().e()); 
    G4double mom = std::sqrt((e - mass)*(e + mass)); 
    v *= mom;
    nucleus->SetMomentum(G4LorentzVector(v.x(),v.y(),v.z(),e));
    if(fVerbose > 1) { 
      G4cout << "X-level Eexc= " << nucleus->GetExcitationEnergy() 
         << G4endl;
    }
    // normal case
  } else { 
    result = fTransition->SampleTransition(nucleus, efinal,
                       deltaS, shell,
                       isGamma, isLongLived);
    if(result) { result->SetCreationTime(time); }
  }
  nucleus->SetCreationTime(time);
  
  if(fVerbose > 1) { 
    G4cout << "Final level E= " << efinal << " time= " << time 
       << " idx= " << fIndex << " isX " << isX 
       << " isGamma: " << isGamma << " isLongLived: " << isLongLived
       << " deltaS= " << deltaS << " shell= " << shell << G4endl;
  }
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEmissionProbability()

G4double G4PhotonEvaporation::GetEmissionProbability ( G4Fragment *  theNucleus )

virtual

Implements G4VEvaporationChannel.

Definition at line 175 of file G4PhotonEvaporation.cc.

{
  fProbability = 0.0;
  fExcEnergy = nucleus->GetExcitationEnergy();
  G4int Z = nucleus->GetZ_asInt();
  G4int A = nucleus->GetA_asInt();
  fCode = 1000*Z + A;
  if(fVerbose > 1) {
    G4cout << "G4PhotonEvaporation::GetEmissionProbability: Z=" 
       << Z << " A=" << A << " Eexc(MeV)= " << fExcEnergy << G4endl; 
  }
  // ignore gamma de-excitation for exotic fragments 
  // and for very low excitations
  if(0 >= Z || 1 >= A || Z == A || Tolerance >= fExcEnergy)
    { return fProbability; }

  // ignore gamma de-excitation for highly excited levels
  if(A >= MAXGRDATA) { A =  MAXGRDATA-1; }
  //G4cout<<" GREnergy= "<< GREnergy[A]<<" GRWidth= "<<GRWidth[A]<<G4endl; 
  if(fExcEnergy >= (G4double)(GREfactor*GRWidth[A] + GREnergy[A])) { 
    return fProbability; 
  }

  // probability computed assuming continium transitions
  // VI: continium transition are limited only to final states
  //     below Fermi energy (this approach needs further evaluation)
  fFermiEnergy = std::max(0.0, nucleus->ComputeGroundStateMass(Z, A-1) 
    + CLHEP::neutron_mass_c2 - nucleus->GetGroundStateMass());

  // max energy level for continues transition
  G4double emax = std::min(fFermiEnergy, fExcEnergy);
  const G4double eexcfac = 0.99;
  if(0.0 == emax || fExcEnergy*eexcfac <= emax) { emax = fExcEnergy*eexcfac; }

  fStep = emax;
  fPoints = std::min((G4int)(fStep/MaxDeltaEnergy) + 2, MAXDEPOINT);
  fStep /= ((G4double)(fPoints - 1));
  if(fVerbose > 1) {
    G4cout << "Emax= " << emax << " Npoints= " << fPoints 
       <<" Efermi= " << fFermiEnergy << "  Eex= " << fExcEnergy << G4endl;
  }
  // integrate probabilities
  G4double eres = (G4double)GREnergy[A];
  G4double wres = (G4double)GRWidth[A];
  G4double eres2= eres*eres;
  G4double wres2= wres*wres;
  G4double xsqr = std::sqrt(A*LevelDensity*fExcEnergy);

  G4double egam    = fExcEnergy - emax;
  G4double gammaE2 = egam*egam;
  G4double gammaR2 = gammaE2*wres*wres;
  G4double egdp2   = gammaE2 - eres*eres;

  G4double p0 = G4Exp(2*(std::sqrt(A*LevelDensity*emax) - xsqr))
    *gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
  G4double p1(0.0);

  for(G4int i=1; i<fPoints; ++i) {
    egam += fStep;
    gammaE2 = egam*egam;
    gammaR2 = gammaE2*wres2;
    egdp2   = gammaE2 - eres2;
    //G4cout << "Egamma= " << egam << "  Eex= " << fExcEnergy
    //<< "  p0= " << p0 << " p1= " << p1 << G4endl;
    p1 = G4Exp(2*(std::sqrt(A*LevelDensity*std::abs(fExcEnergy - egam)) - xsqr))
      *gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
    fProbability += (p1 + p0);
    fCummProbability[i] = fProbability;
    p0 = p1;
  }
  fProbability *= 0.5*fStep*NormC*A;
  if(fVerbose > 1) { G4cout << "prob= " << fProbability << G4endl; }
  return fProbability;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetFinalLevelEnergy()

G4double G4PhotonEvaporation::GetFinalLevelEnergy ( G4int  Z, G4int  A, G4double  energy  )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 251 of file G4PhotonEvaporation.cc.

{
  G4double E = energy;
  InitialiseLevelManager(Z, A);
  if(fLevelManager) { 
    E = (G4double)fLevelManager->NearestLevelEnergy(energy, fIndex); 
    if(E > fLevelEnergyMax + Tolerance) { E = energy; }
  }
  return E;
}

Here is the call graph for this function:

GetUpperLevelEnergy()

G4double G4PhotonEvaporation::GetUpperLevelEnergy ( G4int  Z, G4int  A  )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 262 of file G4PhotonEvaporation.cc.

{
  InitialiseLevelManager(Z, A);
  return fLevelEnergyMax;
}

Here is the call graph for this function:

GetVacantShellNumber()

G4int G4PhotonEvaporation::GetVacantShellNumber ( ) const

inline

Definition at line 167 of file G4PhotonEvaporation.hh.

{ 
  return vShellNumber;
}

Here is the caller graph for this function:

InitialiseLevelManager()

void G4PhotonEvaporation::InitialiseLevelManager ( G4int  Z, G4int  A  )

inlineprivate

Definition at line 153 of file G4PhotonEvaporation.hh.

{
  if(Z != theZ || A != theA) {
    theZ = Z;
    theA = A;
    fIndex = 0;
    fLevelManager = fNuclearLevelData->GetLevelManager(theZ, theA);
    fLevelEnergyMax = 0.0;
    if(fLevelManager) { 
      fLevelEnergyMax = (G4double)fLevelManager->MaxLevelEnergy();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

RDMForced()

void G4PhotonEvaporation::RDMForced ( G4bool  val )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 432 of file G4PhotonEvaporation.cc.

{
  fRDM = val;
}

Here is the caller graph for this function:

SetGammaTransition()

void G4PhotonEvaporation::SetGammaTransition

(

G4GammaTransition *

p

)

Definition at line 419 of file G4PhotonEvaporation.cc.

{
  if(p != fTransition) {
    delete fTransition;
    fTransition = p;
  }
}

SetICM()

void G4PhotonEvaporation::SetICM ( G4bool  val )

virtual

Reimplemented from G4VEvaporationChannel.

Definition at line 427 of file G4PhotonEvaporation.cc.

{
  fICM = val;
}

Here is the caller graph for this function:

SetMaxHalfLife()

void G4PhotonEvaporation::SetMaxHalfLife

(

G4double

val

)

Definition at line 413 of file G4PhotonEvaporation.cc.

{
  static const G4double tfact = G4Pow::GetInstance()->logZ(2);
  fMaxLifeTime = val/tfact;
}

Here is the call graph for this function:

SetVerboseLevel()

void G4PhotonEvaporation::SetVerboseLevel ( G4int  verbose )

inline

Definition at line 147 of file G4PhotonEvaporation.hh.

{
  fVerbose = verbose;
}

Member Data Documentation

fCode

G4int G4PhotonEvaporation::fCode

private

Definition at line 125 of file G4PhotonEvaporation.hh.

fCummProbability

G4double G4PhotonEvaporation::fCummProbability[MAXDEPOINT]

private

Definition at line 132 of file G4PhotonEvaporation.hh.

fExcEnergy

G4double G4PhotonEvaporation::fExcEnergy

private

Definition at line 135 of file G4PhotonEvaporation.hh.

fFermiEnergy

G4double G4PhotonEvaporation::fFermiEnergy

private

Definition at line 136 of file G4PhotonEvaporation.hh.

fICM

G4bool G4PhotonEvaporation::fICM

private

Definition at line 142 of file G4PhotonEvaporation.hh.

fIndex

size_t G4PhotonEvaporation::fIndex

private

Definition at line 127 of file G4PhotonEvaporation.hh.

fLevelEnergyMax

G4double G4PhotonEvaporation::fLevelEnergyMax

private

Definition at line 134 of file G4PhotonEvaporation.hh.

fLevelManager

const G4LevelManager* G4PhotonEvaporation::fLevelManager

private

Definition at line 118 of file G4PhotonEvaporation.hh.

fMaxLifeTime

G4double G4PhotonEvaporation::fMaxLifeTime

private

Definition at line 140 of file G4PhotonEvaporation.hh.

fNuclearLevelData

G4NuclearLevelData* G4PhotonEvaporation::fNuclearLevelData

private

Definition at line 117 of file G4PhotonEvaporation.hh.

fPoints

G4int G4PhotonEvaporation::fPoints

private

Definition at line 124 of file G4PhotonEvaporation.hh.

fProbability

G4double G4PhotonEvaporation::fProbability

private

Definition at line 137 of file G4PhotonEvaporation.hh.

fRDM

G4bool G4PhotonEvaporation::fRDM

private

Definition at line 143 of file G4PhotonEvaporation.hh.

fSampleTime

G4bool G4PhotonEvaporation::fSampleTime

private

Definition at line 144 of file G4PhotonEvaporation.hh.

fStep

G4double G4PhotonEvaporation::fStep

private

Definition at line 138 of file G4PhotonEvaporation.hh.

fTimeLimit

G4double G4PhotonEvaporation::fTimeLimit

private

Definition at line 139 of file G4PhotonEvaporation.hh.

fTransition

G4GammaTransition* G4PhotonEvaporation::fTransition

private

Definition at line 119 of file G4PhotonEvaporation.hh.

fVerbose

G4int G4PhotonEvaporation::fVerbose

private

Definition at line 121 of file G4PhotonEvaporation.hh.

GREnergy

G4float G4PhotonEvaporation::GREnergy = {0.0f}

staticprivate

Definition at line 129 of file G4PhotonEvaporation.hh.

GRWidth

G4float G4PhotonEvaporation::GRWidth = {0.0f}

staticprivate

Definition at line 130 of file G4PhotonEvaporation.hh.

theA

G4int G4PhotonEvaporation::theA

private

Definition at line 123 of file G4PhotonEvaporation.hh.

theZ

G4int G4PhotonEvaporation::theZ

private

Definition at line 122 of file G4PhotonEvaporation.hh.

vShellNumber

G4int G4PhotonEvaporation::vShellNumber

private

Definition at line 126 of file G4PhotonEvaporation.hh.

---

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

• G4PhotonEvaporation.hh
• G4PhotonEvaporation.cc