G4PhotonEvaporation Class Reference

#include <G4PhotonEvaporation.hh>

Inheritance diagram for G4PhotonEvaporation:

Public Member Functions
	G4PhotonEvaporation (G4GammaTransition *ptr=nullptr)
	~G4PhotonEvaporation () override
void	Initialise () override
G4Fragment *	EmittedFragment (G4Fragment *theNucleus) override
G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus) override
G4FragmentVector *	BreakItUp (const G4Fragment &theNucleus)
G4double	GetEmissionProbability (G4Fragment *theNucleus) override
G4double	ComputeInverseXSection (G4Fragment *theNucleus, G4double kinEnergy) override
G4double	ComputeProbability (G4Fragment *theNucleus, G4double kinEnergy) override
G4double	GetFinalLevelEnergy (G4int Z, G4int A, G4double energy)
G4double	GetUpperLevelEnergy (G4int Z, G4int A)
void	SetGammaTransition (G4GammaTransition *)
void	SetICM (G4bool) override
void	RDMForced (G4bool) override
void	SetVerboseLevel (G4int verbose)
G4int	GetVacantShellNumber () const
	G4PhotonEvaporation (const G4PhotonEvaporation &right)=delete
const G4PhotonEvaporation &	operator= (const G4PhotonEvaporation &right)=delete
Public Member Functions inherited from G4VEvaporationChannel
	G4VEvaporationChannel (const G4String &aName="")
virtual	~G4VEvaporationChannel ()=default
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual void	Dump () const
void	SetOPTxs (G4int)
void	UseSICB (G4bool)
	G4VEvaporationChannel (const G4VEvaporationChannel &right)=delete
const G4VEvaporationChannel &	operator= (const G4VEvaporationChannel &right)=delete
G4bool	operator== (const G4VEvaporationChannel &right) const =delete
G4bool	operator!= (const G4VEvaporationChannel &right) const =delete

Additional Inherited Members
Protected Attributes inherited from G4VEvaporationChannel
G4int	OPTxs {3}
G4bool	useSICB {true}

Detailed Description

Definition at line 55 of file G4PhotonEvaporation.hh.

Constructor & Destructor Documentation

G4PhotonEvaporation() [1/2]

G4PhotonEvaporation::G4PhotonEvaporation ( G4GammaTransition * ptr = nullptr )

explicit

Definition at line 63 of file G4PhotonEvaporation.cc.

  : fTransition(p), fPolarization(nullptr), fVerbose(1)
{
  if (fVerbose > 1) {
    G4cout << "### New G4PhotonEvaporation() " << this << G4endl;
  }
  fNuclearLevelData = G4NuclearLevelData::GetInstance(); 
  fTolerance = 20*CLHEP::eV;
  fCummProbability[0] = 0.0;
  if(nullptr == fTransition) { fTransition = new G4GammaTransition(); }
 
  fSecID = G4PhysicsModelCatalog::GetModelID("model_G4PhotonEvaporation");
 
  if(0.0f == GREnergy[2]) { InitialiseGRData(); }
}

Referenced by G4PhotonEvaporation(), and operator=().

~G4PhotonEvaporation()

G4PhotonEvaporation::~G4PhotonEvaporation ( )

override

Definition at line 79 of file G4PhotonEvaporation.cc.

{ 
  delete fTransition;
}

G4PhotonEvaporation() [2/2]

G4PhotonEvaporation::G4PhotonEvaporation ( const G4PhotonEvaporation & right )

delete

Member Function Documentation

BreakItUp()

G4FragmentVector * G4PhotonEvaporation::BreakItUp

(

const G4Fragment &

theNucleus

)

Definition at line 172 of file G4PhotonEvaporation.cc.

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

Referenced by G4LENDCapture::ApplyYourself(), and G4NeutronHPCaptureFS::ApplyYourself().

BreakUpChain()

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

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 185 of file G4PhotonEvaporation.cc.

{
  if(!isInitialised) { Initialise(); }
  if(fVerbose > 1) {
    G4cout << "G4PhotonEvaporation::BreakUpChain RDM= " << fRDM << " "
           << *nucleus << G4endl;
  }
  G4Fragment* gamma = nullptr;
  fSampleTime = !fRDM;
 
  // start decay chain from unpolarized state
  if(fCorrelatedGamma) {
    fPolarization = new G4NuclearPolarization(nucleus->GetZ_asInt(),
                                              nucleus->GetA_asInt(),
                                              nucleus->GetExcitationEnergy());
    nucleus->SetNuclearPolarization(fPolarization);
  }
 
  do {
    gamma = GenerateGamma(nucleus);
    if (nullptr != gamma) {
      gamma->SetCreatorModelID(fSecID);
      products->push_back(gamma);
    }
    // for next decays in the chain always sample time
    fSampleTime = true;
    if (fVerbose > 2) {
      G4cout << "G4PhotonEvaporation::BreakUpChain: next decay" << G4endl;
      if (nullptr != gamma) { G4cout << "   " << *gamma << G4endl; }
      else { G4cout << "   not possible" << G4endl; }
      G4cout << "   Residual: " << *nucleus << G4endl;
    }
    // Loop checking, 22-Dec-2024, Vladimir Ivanchenko
  } while (!(nucleus->IsLongLived() || nucleus->GetExcitationEnergy() <= fTolerance));
 
  // clear nuclear polarization end of chain
  if(nullptr != fPolarization) {
    delete fPolarization;
    fPolarization = nullptr;
    nucleus->SetNuclearPolarization(fPolarization);
  }  
  return false;
}

Referenced by BreakItUp().

ComputeInverseXSection()

G4double G4PhotonEvaporation::ComputeInverseXSection ( G4Fragment * theNucleus, G4double kinEnergy )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 321 of file G4PhotonEvaporation.cc.

{
  return 0.0;
}

ComputeProbability()

G4double G4PhotonEvaporation::ComputeProbability ( G4Fragment * theNucleus, G4double kinEnergy )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 327 of file G4PhotonEvaporation.cc.

{
  return GetEmissionProbability(theNucleus);
}

EmittedFragment()

G4Fragment * G4PhotonEvaporation::EmittedFragment ( G4Fragment * theNucleus )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 118 of file G4PhotonEvaporation.cc.

{
  if(!isInitialised) { Initialise(); }
  fSampleTime = !fRDM;
  if (fRDM) {
    nucleus->SetNumberOfElectrons(nucleus->GetZ_asInt());
  }
 
  // potentially external code may set initial polarization
  // but only for radioactive decay nuclear polarization is considered
  G4NuclearPolarizationStore* fNucPStore = nullptr;
  if(fCorrelatedGamma && fRDM) {
    fNucPStore = G4NuclearPolarizationStore::GetInstance();
    auto nucp = nucleus->GetNuclearPolarization();
    if(nullptr != nucp) { 
      fNucPStore->RemoveMe(nucp);
    } 
    fPolarization = fNucPStore->FindOrBuild(nucleus->GetZ_asInt(),
                                            nucleus->GetA_asInt(),
                                            nucleus->GetExcitationEnergy());
    nucleus->SetNuclearPolarization(fPolarization);
  }
  if(fVerbose > 2) { 
    G4cout << "G4PhotonEvaporation::EmittedFragment: " 
           << *nucleus << G4endl;
    if (nullptr != fPolarization) { G4cout << "NucPolar: " << fPolarization << G4endl; }
    G4cout << " CorrGamma: " << fCorrelatedGamma << " RDM: " << fRDM
           << " fPolarization: " << fPolarization << G4endl;
  }
  G4Fragment* gamma = GenerateGamma(nucleus);
  
  if(gamma != nullptr) { gamma->SetCreatorModelID(fSecID); }
  
  // remove G4NuclearPolarizaton when reach ground state
  if (nullptr != fNucPStore && nullptr != fPolarization && 0 == fIndex) {
    if(fVerbose > 3) { 
      G4cout << "G4PhotonEvaporation::EmittedFragment: remove " 
             << fPolarization << G4endl;
    }
    fNucPStore->RemoveMe(fPolarization);
    fPolarization = nullptr;
    nucleus->SetNuclearPolarization(fPolarization);
  }
 
  if(fVerbose > 2) {
    G4cout << "G4PhotonEvaporation::EmittedFragment: RDM= " 
           << fRDM << " done:" << G4endl; 
    if(gamma) { G4cout << *gamma << G4endl; }
    G4cout << "   Residual: " << *nucleus << G4endl;
  }
  return gamma; 
}

GetEmissionProbability()

G4double G4PhotonEvaporation::GetEmissionProbability ( G4Fragment * theNucleus )

overridevirtual

Implements G4VEvaporationChannel.

Definition at line 231 of file G4PhotonEvaporation.cc.

{
  if(!isInitialised) { Initialise(); }
  fProbability = 0.0;
  fExcEnergy = nucleus->GetExcitationEnergy();
  G4int Z = nucleus->GetZ_asInt();
  G4int A = nucleus->GetA_asInt();
  if(fVerbose > 2) {
    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 || fTolerance >= fExcEnergy)
    { return fProbability; }
 
  // ignore gamma de-excitation for highly excited levels
  if(A >= MAXGRDATA) { A =  MAXGRDATA-1; }
 
  static const G4double GREfactor = 5.0;
  G4double edelta = GREfactor*(G4double)GRWidth[A] + (G4double)GREnergy[A];
  if (fVerbose > 2)
    G4cout << "   GREnergy=" << GREnergy[A] << " GRWidth="<<GRWidth[A]
       << " Edelta=" << edelta <<G4endl; 
  if (fExcEnergy >= edelta) { 
    return fProbability; 
  }
 
  // probability computed assuming continium transitions in the frame of the nucleus
  fStep = fExcEnergy;
  const G4double MaxDeltaEnergy = CLHEP::MeV;
  fPoints = std::min((G4int)(fStep/MaxDeltaEnergy) + 2, MAXDEPOINT);
  fStep /= ((G4double)(fPoints - 1));
 
  if(fVerbose > 2) {
    G4cout << "  Npoints= " << fPoints 
           << "  Eex=" << fExcEnergy << " Estep=" << fStep << G4endl;
  }
 
  // integrate probabilities
  G4double eres = (G4double)GREnergy[A];
  G4double wres = (G4double)GRWidth[A];
  G4double eres2= eres*eres;
  G4double wres2= wres*wres;
 
  // initial state
  G4double levelDensity = fNuclearLevelData->GetLevelDensity(Z,A,fExcEnergy);
  G4double xdrt = G4Exp(2*std::sqrt(levelDensity*fExcEnergy));
 
  // the loop over excitation energy of the residual nucleus
  // from 0 to fExcEnergy
  // gamma energy is defined via non-relativistic formula
  G4double egam    = fExcEnergy;
  G4double gammaE2 = egam*egam;
  G4double gammaR2 = gammaE2*wres2;
  G4double egdp2   = gammaE2 - eres2;
 
  G4double p0 = egam*gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
  G4double p1, e;
 
  for(G4int i=1; i<fPoints; ++i) {
    egam -= fStep;
    if (i + 1 == fPoints) {
      p1 = 0.0;
    } else {
      gammaE2 = egam*egam;
      gammaR2 = gammaE2*wres2;
      egdp2   = gammaE2 - eres2;
      e = fExcEnergy - egam;
      levelDensity = fNuclearLevelData->GetLevelDensity(Z, A, e);
      p1 = egam*G4Exp(2.0*(std::sqrt(levelDensity*e)))*gammaR2*gammaE2/(egdp2*egdp2 + gammaR2);
    }
    fProbability += (p1 + p0);
    fCummProbability[i] = fProbability;
    if(fVerbose > 3) {
      G4cout << "Egamma= " << egam << "  Eex= " << fExcEnergy
             << "  p0= " << p0 << " p1= " << p1 << " sum= " 
             << fCummProbability[i] <<G4endl;
    }
    p0 = p1;
  }
 
  static const G4double NormC = 1.25*CLHEP::millibarn
    /(CLHEP::pi2*CLHEP::hbarc*CLHEP::hbarc);
  fProbability *= fStep*NormC*A/xdrt;
  if(fVerbose > 1) { G4cout << "prob= " << fProbability << G4endl; }
  return fProbability;
}

Referenced by ComputeProbability().

GetFinalLevelEnergy()

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

Definition at line 333 of file G4PhotonEvaporation.cc.

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

GetUpperLevelEnergy()

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

Definition at line 344 of file G4PhotonEvaporation.cc.

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

GetVacantShellNumber()

G4int G4PhotonEvaporation::GetVacantShellNumber ( ) const

inline

Definition at line 168 of file G4PhotonEvaporation.hh.

{ 
  return vShellNumber;
}

Initialise()

void G4PhotonEvaporation::Initialise ( )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 84 of file G4PhotonEvaporation.cc.

{
  if (isInitialised) { return; }
  isInitialised = true;
 
  G4DeexPrecoParameters* param = fNuclearLevelData->GetParameters();
  fTolerance = param->GetMinExcitation();
  fMaxLifeTime = param->GetMaxLifeTime();
  fLocalTimeLimit = fRDM ? fMaxLifeTime : std::max(fMaxLifeTime, timeLimit);
  fCorrelatedGamma = param->CorrelatedGamma();
  fICM = param->GetInternalConversionFlag();
  fVerbose = param->GetVerbose();
 
  fTransition->SetPolarizationFlag(fCorrelatedGamma);
  fTransition->SetTwoJMAX(param->GetTwoJMAX());
  fTransition->SetVerbose(fVerbose);
  if (fVerbose > 1) {
    G4cout << "### G4PhotonEvaporation is initialized " << this << G4endl;   
  }
}

Referenced by BreakUpChain(), EmittedFragment(), GetEmissionProbability(), and G4NuDEXNeutronCaptureModel::InitialiseModel().

operator=()

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

delete

RDMForced()

void G4PhotonEvaporation::RDMForced ( G4bool val )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 621 of file G4PhotonEvaporation.cc.

{
  fRDM = val;
}

SetGammaTransition()

void G4PhotonEvaporation::SetGammaTransition

(

G4GammaTransition *

p

)

Definition at line 608 of file G4PhotonEvaporation.cc.

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

SetICM()

void G4PhotonEvaporation::SetICM ( G4bool val )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 616 of file G4PhotonEvaporation.cc.

{
  fICM = val;
}

Referenced by G4LENDCapture::ApplyYourself(), and G4NeutronHPCaptureFS::ApplyYourself().

SetVerboseLevel()

void G4PhotonEvaporation::SetVerboseLevel ( G4int verbose )

inline

Definition at line 151 of file G4PhotonEvaporation.hh.

{
  fVerbose = verbose;
}

---

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

• G4PhotonEvaporation.hh
• G4PhotonEvaporation.cc