G4PreCompoundEmissionInt Class Reference

#include <G4PreCompoundEmissionInt.hh>

Public Member Functions
	G4PreCompoundEmissionInt (G4int verb)
	~G4PreCompoundEmissionInt ()
void	SetDefaultModel ()
void	SetHETCModel ()
G4ReactionProduct *	PerformEmission (G4Fragment &aFragment)
G4double	GetTotalProbability (const G4Fragment &aFragment)
void	SetOPTxs (G4int)
void	UseSICB (G4bool)
	G4PreCompoundEmissionInt (const G4PreCompoundEmissionInt &right)=delete
const G4PreCompoundEmissionInt &	operator= (const G4PreCompoundEmissionInt &right)=delete
G4bool	operator== (const G4PreCompoundEmissionInt &right) const =delete
G4bool	operator!= (const G4PreCompoundEmissionInt &right) const =delete

Detailed Description

Definition at line 49 of file G4PreCompoundEmissionInt.hh.

Constructor & Destructor Documentation

G4PreCompoundEmissionInt() [1/2]

G4PreCompoundEmissionInt::G4PreCompoundEmissionInt ( G4int verb )

explicit

Definition at line 48 of file G4PreCompoundEmissionInt.cc.

  : fVerbose(verb)
{
  theFragmentsFactory = new G4PreCompoundEmissionFactory();
  theFragmentsVector = 
    new G4PreCompoundFragmentVector(theFragmentsFactory->GetFragmentVector());
  g4calc = G4Pow::GetInstance();
  fNuclData = G4NuclearLevelData::GetInstance();
  G4DeexPrecoParameters* param = fNuclData->GetParameters();
  fFermiEnergy  = param->GetFermiEnergy();
  fUseAngularGenerator = param->UseAngularGen();
  fModelID = G4PhysicsModelCatalog::GetModelID("model_PRECO");
}

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

~G4PreCompoundEmissionInt()

G4PreCompoundEmissionInt::~G4PreCompoundEmissionInt

(

)

Definition at line 62 of file G4PreCompoundEmissionInt.cc.

{
  delete theFragmentsFactory; 
  delete theFragmentsVector; 
}

G4PreCompoundEmissionInt() [2/2]

G4PreCompoundEmissionInt::G4PreCompoundEmissionInt ( const G4PreCompoundEmissionInt & right )

delete

Member Function Documentation

GetTotalProbability()

G4double G4PreCompoundEmissionInt::GetTotalProbability ( const G4Fragment & aFragment )

inline

Definition at line 101 of file G4PreCompoundEmissionInt.hh.

{
  return theFragmentsVector->CalculateProbabilities(aFragment);
}

operator!=()

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

delete

operator=()

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

delete

operator==()

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

delete

PerformEmission()

G4ReactionProduct * G4PreCompoundEmissionInt::PerformEmission

(

G4Fragment &

aFragment

)

Definition at line 93 of file G4PreCompoundEmissionInt.cc.

{
  G4ReactionProduct* res = nullptr;
  // Choose a Fragment for emission
  G4VPreCompoundFragment* thePreFragment =
    theFragmentsVector->ChooseFragment();
  if (thePreFragment == nullptr) {
    G4cout << "G4PreCompoundEmission::PerformEmission : "
       << "I couldn't choose a fragment while trying to de-excite\n" 
       << aFragment << G4endl;
    throw G4HadronicException(__FILE__, __LINE__, "");
    return res;
  }
 
  // Kinetic Energy of emitted fragment
  G4double kinEnergy = thePreFragment->SampleKineticEnergy(aFragment);
  kinEnergy = std::max(kinEnergy, 0.0);
  
  // Calculate the fragment momentum (three vector theFinalMomentum)
  if(fUseAngularGenerator) {
    AngularDistribution(thePreFragment,aFragment,kinEnergy);
  } else {
    G4double pmag = 
      std::sqrt(kinEnergy*(kinEnergy + 2.0*thePreFragment->GetNuclearMass()));
    theFinalMomentum = pmag*G4RandomDirection();
  }
 
  // Mass of emittef fragment
  G4double EmittedMass = thePreFragment->GetNuclearMass();
  // Now we can calculate the four momentum 
  // both options are valid and give the same result but 2nd one is faster
  G4LorentzVector Emitted4Momentum(theFinalMomentum,EmittedMass + kinEnergy);
 
  if (2 < fVerbose) {
    G4cout << "             Emitted  Z="
       << thePreFragment->GetZ() << " A=" << thePreFragment->GetA() 
       << " Ekin(MeV)=" << kinEnergy << " 4-mom C.M.S.: "
       << Emitted4Momentum << G4endl;
  }
  
  // Perform Lorentz boost
  G4LorentzVector Rest4Momentum = aFragment.GetMomentum();
  Emitted4Momentum.boost(Rest4Momentum.boostVector());  
 
  // Set emitted fragment momentum
  thePreFragment->SetMomentum(Emitted4Momentum);    
 
  // Residual nucleus
  Rest4Momentum -= Emitted4Momentum;
    
  // Update nucleus parameters
  // Z and A
  G4int prodZ = thePreFragment->GetZ();
  G4int prodA = thePreFragment->GetA();
  G4int Z = aFragment.GetZ_asInt() - prodZ;
  G4int A = aFragment.GetA_asInt() - prodA;
    
  // Number of excitons
  G4int np = aFragment.GetNumberOfParticles() - prodA;
  np = std::min(std::max(np, 0), A);
  G4int nz = aFragment.GetNumberOfCharged() - prodZ;
  nz = std::min(std::max(nz, 0), np);
 
  // update fragment
  aFragment.SetZandA_asInt(Z, A);
  aFragment.SetNumberOfExcitedParticle(np, nz);
 
  // Update nucleus momentum 
  // A check on consistence of Z, A, and mass will be performed
  aFragment.SetMomentum(Rest4Momentum);
    
  // Create a G4ReactionProduct 
  res = thePreFragment->GetReactionProduct();
 
  // Set the creator model ID
  aFragment.SetCreatorModelID(fModelID);
  if (res != nullptr) { res->SetCreatorModelID(fModelID); }
  
  return res;
}

SetDefaultModel()

void G4PreCompoundEmissionInt::SetDefaultModel

(

)

Definition at line 68 of file G4PreCompoundEmissionInt.cc.

{
  if (theFragmentsFactory) { delete theFragmentsFactory; }
  theFragmentsFactory = new G4PreCompoundEmissionFactory();
  if (theFragmentsVector) {
    theFragmentsVector->SetVector(theFragmentsFactory->GetFragmentVector());
  } else {
    theFragmentsVector = 
      new G4PreCompoundFragmentVector(theFragmentsFactory->GetFragmentVector());
  }
}

SetHETCModel()

void G4PreCompoundEmissionInt::SetHETCModel

(

)

Definition at line 80 of file G4PreCompoundEmissionInt.cc.

{
  if (theFragmentsFactory) delete theFragmentsFactory;
  theFragmentsFactory = new G4HETCEmissionFactory();
  if (theFragmentsVector) {
    theFragmentsVector->SetVector(theFragmentsFactory->GetFragmentVector());
  } else {
    theFragmentsVector = 
      new G4PreCompoundFragmentVector(theFragmentsFactory->GetFragmentVector());
  }
}

SetOPTxs()

void G4PreCompoundEmissionInt::SetOPTxs ( G4int opt )

inline

Definition at line 106 of file G4PreCompoundEmissionInt.hh.

{
  theFragmentsVector->SetOPTxs(opt);
}

UseSICB()

void G4PreCompoundEmissionInt::UseSICB ( G4bool use )

inline

Definition at line 111 of file G4PreCompoundEmissionInt.hh.

{
  theFragmentsVector->UseSICB(use);
}

---

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

• G4PreCompoundEmissionInt.hh
• G4PreCompoundEmissionInt.cc