G4GEMChannelVI Class Reference

#include <G4GEMChannelVI.hh>

Inheritance diagram for G4GEMChannelVI:

Public Member Functions
	G4GEMChannelVI (G4int theA, G4int theZ)
	~G4GEMChannelVI () override
void	Initialise () override
G4double	ProbabilityDensityFunction (G4double ekin) override
G4double	GetEmissionProbability (G4Fragment *theNucleus) override
G4Fragment *	EmittedFragment (G4Fragment *theNucleus) override
const G4String &	ModelName () const override
G4double	GetCurrentXS ()
void	Dump () const override
	G4GEMChannelVI (const G4GEMChannelVI &right)=delete
const G4GEMChannelVI &	operator= (const G4GEMChannelVI &right)=delete
G4bool	operator== (const G4GEMChannelVI &right) const =delete
G4bool	operator!= (const G4GEMChannelVI &right) const =delete
Public Member Functions inherited from G4VEvaporationChannel
	G4VEvaporationChannel (const G4String &aName="")
virtual	~G4VEvaporationChannel ()=default
virtual G4double	GetLifeTime (G4Fragment *theNucleus)
virtual G4bool	BreakUpChain (G4FragmentVector *theResult, G4Fragment *theNucleus)
G4FragmentVector *	BreakUpFragment (G4Fragment *theNucleus)
virtual G4double	ComputeInverseXSection (G4Fragment *theNucleus, G4double kinEnergy)
virtual G4double	ComputeProbability (G4Fragment *theNucleus, G4double kinEnergy)
virtual void	SetICM (G4bool)
virtual void	RDMForced (G4bool)
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
Public Member Functions inherited from G4VSIntegration
	G4VSIntegration ()=default
virtual	~G4VSIntegration ()=default
void	InitialiseIntegrator (G4double accuracy, G4double fact1, G4double fact2, G4double de, G4double dmin, G4double dmax)
G4double	ComputeIntegral (const G4double emin, const G4double emax)
G4double	SampleValue ()
	G4VSIntegration (const G4VSIntegration &)=delete
G4VSIntegration &	operator= (const G4VSIntegration &)=delete
G4bool	operator== (const G4VSIntegration &right) const =delete
G4bool	operator!= (const G4VSIntegration &right) const =delete
void	SetVerbose (G4int verb)

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

Detailed Description

Definition at line 44 of file G4GEMChannelVI.hh.

Constructor & Destructor Documentation

G4GEMChannelVI() [1/2]

G4GEMChannelVI::G4GEMChannelVI ( G4int theA, G4int theZ )

explicit

Definition at line 65 of file G4GEMChannelVI.cc.

  : evapA(theA), evapZ(theZ)
{
  nData = G4NuclearLevelData::GetInstance();
  pairingCorrection = nData->GetPairingCorrection();
  if (evapZ > 2) { lManagerEvap = nData->GetLevelManager(evapZ, evapA); }
  fEvapMass = G4NucleiProperties::GetNuclearMass(evapA, evapZ);
  fEvapMass2 = fEvapMass*fEvapMass;
 
  cBarrier = new G4CoulombBarrier(evapA, evapZ);
 
  fTolerance = 10*CLHEP::keV;
  fCoeff = fEvapMass/((CLHEP::pi*CLHEP::hbarc)*(CLHEP::pi*CLHEP::hbarc));
 
  std::ostringstream ss;
  ss << "GEMVI_" << "Z" << evapZ << "_A" << evapA;
  fModelName = ss.str();
  
  fNeutron = G4Neutron::Neutron();
  fProton = G4Proton::Proton();
 
  secID = G4PhysicsModelCatalog::GetModelID("model_G4GEMChannelVI");
  const G4ParticleDefinition* part = nullptr;
  if (evapZ == 0 && evapA == 1) {
    indexC = 0;
    fCoeff *= 2.0;
    part = fNeutron;
  } else if (evapZ == 1 && evapA == 1) {
    indexC = 1;
    fCoeff *= 2.0;
    part = fProton;
  } else if (evapZ == 1 && evapA == 2) {
    indexC = 2;
    fCoeff *= 3.0;
    part = G4Deuteron::Deuteron();
  } else if (evapZ == 1 && evapA == 3) {
    indexC = 3;
    fCoeff *= 2.0;
    part = G4Triton::Triton();
  } else if (evapZ == 2 && evapA == 3) {
    indexC = 4;
    fCoeff *= 2.0;
    part = G4He3::He3();
  } else if (evapZ == 2 && evapA == 4) {
    indexC = 5;
    part = G4Alpha::Alpha();
  } else {
    G4int N = evapA - evapZ;
    fCoeff *= (1 + (evapZ - 2*(evapZ/2)))*(1 + (N - 2*(N/2)));
  }
  g4pow = G4Pow::GetInstance();
  
  G4double de = (0 == indexC) ? 0.15*CLHEP::MeV : 0.25*CLHEP::MeV;
  InitialiseIntegrator(0.01, 0.25, 1.3, de, 0.1*CLHEP::MeV, 2*CLHEP::MeV);
 
  if (indexC <= 6) { fXSection = new G4InterfaceToXS(part, indexC); }
}

Referenced by G4GEMChannelVI(), operator!=(), operator=(), and operator==().

~G4GEMChannelVI()

G4GEMChannelVI::~G4GEMChannelVI ( )

override

Definition at line 123 of file G4GEMChannelVI.cc.

{
  delete cBarrier;
  delete fXSection;
}

G4GEMChannelVI() [2/2]

G4GEMChannelVI::G4GEMChannelVI ( const G4GEMChannelVI & right )

delete

Member Function Documentation

Dump()

void G4GEMChannelVI::Dump ( ) const

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 350 of file G4GEMChannelVI.cc.

{}

EmittedFragment()

G4Fragment * G4GEMChannelVI::EmittedFragment ( G4Fragment * theNucleus )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 257 of file G4GEMChannelVI.cc.

{
  // assumed, that TotalProbability(...) was already called
  // if value iz zero no possiblity to sample final state
  G4Fragment* evFragment = nullptr;
  lManagerRes = nData->GetLevelManager(resZ, resA);
  G4double e2 = fMass - fEvapMass - fResMass;
  fEvapExc = 0.0;
 
  // sample excitation of the evaporation fragment
  if (nProbEvap > 1) {
    G4double q = prob[nProbEvap - 1];
    if (q > 0.0) {
      q *= G4UniformRand();
      for (G4int i=0; i < nProbEvap; ++i) {
    if (q <= prob[i]) {
      if (0 == i) { break; }
      G4double e1 = fDeltaEvap*((i - 1) + (q - prob[i - 1])/(prob[i] - prob[i - 1]));
      fEvapExc = CorrectExcitation(e1, lManagerEvap);
      e2 -= fEvapExc;
      e2 = std::max(e2, 0.0);
    }
      }
    }
  }
  if (ComputeIntegral(0.5*bCoulomb, e2) <= 0.0) { return evFragment; }
 
  // sample free energy
  G4double e = SampleValue();
  // compute excitation of the residual fragment
  fResExc = CorrectExcitation(e2 - e, lManagerRes);
 
  // final kinematics
  G4double m1 = fEvapMass + fEvapExc;
  G4double m2 = fResMass + fResExc;
 
  G4double ekin = 0.5*e*(e + 2*m2)/(e + m1 + m2);
  G4LorentzVector lv(std::sqrt(ekin*(ekin + 2.0*m1))
             *G4RandomDirection(), ekin + m1);
  G4LorentzVector lv0 = theNucleus->GetMomentum();
  lv.boost(lv0.boostVector());
  evFragment = new G4Fragment(evapA, evapZ, lv);
  evFragment->SetCreatorModelID(secID);
 
  // residual
  lv0 -= lv;
  theNucleus->SetZandA_asInt(resZ, resA);
  theNucleus->SetMomentum(lv0);
  theNucleus->SetCreatorModelID(secID);
  
  return evFragment;  
}

GetCurrentXS()

G4double G4GEMChannelVI::GetCurrentXS ( )

inline

Definition at line 62 of file G4GEMChannelVI.hh.

{ return recentXS; };

GetEmissionProbability()

G4double G4GEMChannelVI::GetEmissionProbability ( G4Fragment * theNucleus )

overridevirtual

Implements G4VEvaporationChannel.

Definition at line 134 of file G4GEMChannelVI.cc.

{
  fragZ = fragment->GetZ_asInt();
  fragA = fragment->GetA_asInt();
  resZ = fragZ - evapZ;
  resA = fragA - evapA;
  // G4cout << "G4GEMChannelVI::GetEmissionProbability Z=" << evapZ <<  " A=" << evapA << " resZ=" << resZ << " resA=" << resA << G4endl;
  // to avoid double counting
  if (resA < evapA || resA < resZ || resZ < 1 ||
      (resA == evapA && resZ < evapZ)) { return 0.0; }
 
  fFragExc = fragment->GetExcitationEnergy();
  fMass = fragment->GetGroundStateMass() + fFragExc;
  fResMass = G4NucleiProperties::GetNuclearMass(resA, resZ);
  fResA13 = g4pow->Z13(resA);
  xsfactor = g4pow->Z23(fragA)/g4pow->Z23(resA);
 
  // limit for the case when both evaporation and residual 
  // fragments are in ground states
  if (fMass <= fEvapMass + fResMass) { return 0.0; } 
 
  a0 = G4DeexPrecoUtility::LevelDensity(fragZ, fragA, indexC);
  delta0 = nData->GetPairingCorrection(fragZ, fragA);
  delta1 = nData->GetPairingCorrection(resZ, resA);
  fE0 = std::max(fFragExc - delta0, 0.0);
  
  if (indexC > 0) {
    bCoulomb = cBarrier->GetCoulombBarrier(resA, resZ, fFragExc);
  }
  G4double elim = 0.5*bCoulomb;
  G4double de = fMass - fEvapMass - fResMass - elim;
  if (de < fTolerance) { return 0.0; }
  nProbEvap = 1;
  fDeltaEvap = de;
  if (7 == indexC) {
    G4int n = (G4int)(de/dExc) + 1;
    nProbEvap = std::min(n, nProbMax);
    if (nProbEvap > 1) { fDeltaEvap /= (G4double)(nProbEvap - 1); }
  }
 
  if (2 < fVerbose) {
    G4cout << "## G4GEMChannelVI::GetEmissionProbability fragZ="
       << fragZ << " fragA=" << fragA << " Z=" << evapZ << " A=" << evapA
       << " Eex(MeV)=" << fFragExc << " nProbEvap=" << nProbEvap
       << " nProbRes=" << nProbRes << " CB=" << bCoulomb
       << " Elim=" << fEnergyLimitXS << " XSfac=" << xsfactor << G4endl;
  }
 
  // m1 is the mass of emitted excited fragment
  // e2 - free energy in the 2-body decay
  G4double sump = 0.0;
  for (G4int i = 0; i < nProbEvap; ++i) {
    fEvapExc = fDeltaEvap*i;
    G4double m1 = fEvapMass + fEvapExc;
    G4double e2 = fMass - m1 - fResMass;
    e2 = std::max(e2, 0.0);
    if (e2 <= elim + fTolerance) {
      nProbEvap = i + 1;
      prob[i] = sump;
      break;
    }
    G4double p = ComputeIntegral(elim, e2);
    sump += p;
    prob[i] = sump;
    if (2 < fVerbose) {
      G4cout << i << ". e1=" << elim << " e2=" << e2 << " e2-e1="
         << e2 - elim << " fEvapExc=" << fEvapExc
         << " Probability=" << p << G4endl;
    }
  }
  if (nProbEvap > 1) { sump /= (G4double)nProbEvap; }
  return sump;
}

Initialise()

void G4GEMChannelVI::Initialise ( )

overridevirtual

Reimplemented from G4VEvaporationChannel.

Definition at line 129 of file G4GEMChannelVI.cc.

{
  G4VEvaporationChannel::Initialise(); 
}

ModelName()

const G4String & G4GEMChannelVI::ModelName ( ) const

overridevirtual

Reimplemented from G4VSIntegration.

Definition at line 345 of file G4GEMChannelVI.cc.

{
  return fModelName;
}

operator!=()

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

delete

operator=()

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

delete

operator==()

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

delete

ProbabilityDensityFunction()

G4double G4GEMChannelVI::ProbabilityDensityFunction ( G4double ekin )

overridevirtual

Implements G4VSIntegration.

Definition at line 208 of file G4GEMChannelVI.cc.

{
  // e is free energy 
  G4double m1 = fEvapMass + fEvapExc;
  fResExc = fMass - m1 - fResMass - e;
  if (fResExc < 0.0 || 0.0 == e) { return 0.0; }
  fE1 = std::max(fResExc - delta1, 0.0);
  a1 = G4DeexPrecoUtility::LevelDensity(resZ, resA, indexC);
  G4double m2 = fResMass + fResExc;
  G4double elab = 0.5*(fMass + m1 + m2)*(fMass - m1 - m2)/m2;
  G4double xs = CrossSection(elab);
  G4double res =
    fCoeff*G4Exp(2.0*(std::sqrt(a1*fE1) - std::sqrt(a0*fE0)))*e*xs;
 
  //G4cout << "e=" << e << " elab=" << elab << " xs(mb)="
  //     << xs/CLHEP::millibarn << " prob=" << res << G4endl;
  return res;
}

---

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

• G4GEMChannelVI.hh
• G4GEMChannelVI.cc