G4ExcitationHandler Class Reference

#include <G4ExcitationHandler.hh>

Public Member Functions
G4ReactionProductVector *	BreakItUp (const G4Fragment &theInitialState)
	G4ExcitationHandler ()
G4VEvaporation *	GetEvaporation ()
G4VFermiBreakUp *	GetFermiModel ()
G4VMultiFragmentation *	GetMultiFragmentation ()
G4VEvaporationChannel *	GetPhotonEvaporation ()
void	Initialise ()
void	ModelDescription (std::ostream &outFile) const
void	SetDeexChannelsType (G4DeexChannelType val)
void	SetEvaporation (G4VEvaporation *ptr, G4bool isLocal=false)
void	SetFermiModel (G4VFermiBreakUp *ptr)
void	SetMaxAandZForFermiBreakUp (G4int anA, G4int aZ)
void	SetMaxAForFermiBreakUp (G4int anA)
void	SetMaxZForFermiBreakUp (G4int aZ)
void	SetMinEForMultiFrag (G4double anE)
void	SetMultiFragmentation (G4VMultiFragmentation *ptr)
void	SetOPTxs (G4int opt)
void	SetPhotonEvaporation (G4VEvaporationChannel *ptr)
void	UseSICB ()
	~G4ExcitationHandler ()

Private Member Functions
	G4ExcitationHandler (const G4ExcitationHandler &right)
G4bool	operator!= (const G4ExcitationHandler &right) const
const G4ExcitationHandler &	operator= (const G4ExcitationHandler &right)
G4bool	operator== (const G4ExcitationHandler &right) const
void	SetParameters ()
void	SortSecondaryFragment (G4Fragment *)

Private Attributes
G4int	fVerbose
G4int	fWarnings
G4int	icID
G4bool	isActive
G4bool	isEvapLocal
G4bool	isInitialised
G4int	maxAForFermiBreakUp
G4double	maxExcitation
G4int	maxZForFermiBreakUp
G4double	minEForMultiFrag
G4double	minExcitation
G4NistManager *	nist
std::vector< G4Fragment * >	results
const G4ParticleDefinition *	theAlpha
const G4ParticleDefinition *	theDeuteron
const G4ParticleDefinition *	theElectron
std::vector< G4Fragment * >	theEvapList
G4VEvaporation *	theEvaporation
G4VFermiBreakUp *	theFermiModel
const G4ParticleDefinition *	theHe3
G4VMultiFragmentation *	theMultiFragmentation
const G4ParticleDefinition *	theNeutron
G4VEvaporationChannel *	thePhotonEvaporation
const G4ParticleDefinition *	theProton
std::vector< G4Fragment * >	theResults
G4IonTable *	theTableOfIons
const G4ParticleDefinition *	theTriton

Detailed Description

Definition at line 62 of file G4ExcitationHandler.hh.

Constructor & Destructor Documentation

G4ExcitationHandler() [1/2]

G4ExcitationHandler::G4ExcitationHandler ( )

explicit

Definition at line 86 of file G4ExcitationHandler.cc.

  : icID(0),maxZForFermiBreakUp(9),maxAForFermiBreakUp(17),
    fVerbose(1),fWarnings(0),minEForMultiFrag(1.*CLHEP::TeV),
    minExcitation(1.*CLHEP::eV),maxExcitation(100.*CLHEP::MeV),
    isInitialised(false),isEvapLocal(true),isActive(true)
{                                                                          
  theTableOfIons = G4ParticleTable::GetParticleTable()->GetIonTable();
  nist = G4NistManager::Instance();
  
  theMultiFragmentation = nullptr;
  theFermiModel = nullptr;
  theEvaporation = nullptr;
  thePhotonEvaporation = nullptr;
  theResults.reserve(60);
  results.reserve(30);
  theEvapList.reserve(30);
 
  G4Pow::GetInstance();
  theElectron = G4Electron::Electron();
  theNeutron = G4Neutron::NeutronDefinition();
  theProton = G4Proton::ProtonDefinition();
  theDeuteron = G4Deuteron::DeuteronDefinition();
  theTriton = G4Triton::TritonDefinition();
  theHe3 = G4He3::He3Definition();
  theAlpha = G4Alpha::AlphaDefinition();;
 
  if(fVerbose > 1) { G4cout << "### New handler " << this << G4endl; }
}

References G4Alpha::AlphaDefinition(), G4Deuteron::DeuteronDefinition(), G4Electron::Electron(), fVerbose, G4cout, G4endl, G4Pow::GetInstance(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetParticleTable(), G4He3::He3Definition(), G4NistManager::Instance(), G4Neutron::NeutronDefinition(), nist, G4Proton::ProtonDefinition(), results, theAlpha, theDeuteron, theElectron, theEvapList, theEvaporation, theFermiModel, theHe3, theMultiFragmentation, theNeutron, thePhotonEvaporation, theProton, theResults, theTableOfIons, theTriton, and G4Triton::TritonDefinition().

~G4ExcitationHandler()

G4ExcitationHandler::~G4ExcitationHandler

(

)

Definition at line 115 of file G4ExcitationHandler.cc.

{
  delete theMultiFragmentation;
  delete theFermiModel;
  if(isEvapLocal) { delete theEvaporation; } 
}

References isEvapLocal, theEvaporation, theFermiModel, and theMultiFragmentation.

G4ExcitationHandler() [2/2]

G4ExcitationHandler::G4ExcitationHandler ( const G4ExcitationHandler &  right )

private

Member Function Documentation

BreakItUp()

G4ReactionProductVector * G4ExcitationHandler::BreakItUp

(

const G4Fragment &

theInitialState

)

Definition at line 279 of file G4ExcitationHandler.cc.

{
  // Variables existing until end of method
  G4Fragment * theInitialStatePtr = new G4Fragment(theInitialState);
  if(fVerbose > 1) {
    G4cout << "@@@@@@@@@@ Start G4Excitation Handler @@@@@@@@@@@@@ " << G4endl;
    G4cout << theInitialState << G4endl;  
  }
  if(!isInitialised) { Initialise(); }
 
  // pointer to fragment vector which receives temporal results
  G4FragmentVector * theTempResult = nullptr;
 
  theResults.clear();
  theEvapList.clear();
   
  // Variables to describe the excited configuration
  G4double exEnergy = theInitialState.GetExcitationEnergy();
  G4int A = theInitialState.GetA_asInt();
  G4int Z = theInitialState.GetZ_asInt();
 
  // too much excitation
  if(exEnergy > A*maxExcitation && A > 0) {
    ++fWarnings;
    if(fWarnings < 0) {
      G4ExceptionDescription ed;
      ed << "High excitation Fragment Z= " << Z << " A= " << A 
     << " Eex/A(MeV)= " << exEnergy/A;
      G4Exception("G4ExcitationHandler::BreakItUp()","had0034",JustWarning,ed,"");
    }
  }
  
  // In case A <= 1 the fragment will not perform any nucleon emission
  if (A <= 1 || !isActive) {
    theResults.push_back( theInitialStatePtr );
 
    // check if a fragment is stable
  } else if(exEnergy < minExcitation && nist->GetIsotopeAbundance(Z, A) > 0.0) {
    theResults.push_back( theInitialStatePtr );
 
    // JMQ 150909: first step in de-excitation is treated separately 
    // Fragments after the first step are stored in theEvapList 
  } else {      
    if((A<maxAForFermiBreakUp && Z<maxZForFermiBreakUp) 
       || exEnergy <= minEForMultiFrag*A) { 
      theEvapList.push_back(theInitialStatePtr); 
 
    // Statistical Multifragmentation will take place only once
    } else {
      theTempResult = theMultiFragmentation->BreakItUp(theInitialState);
      if(!theTempResult) { 
    theEvapList.push_back(theInitialStatePtr); 
      } else {
    size_t nsec = theTempResult->size();
 
    // no fragmentation
    if(0 == nsec) { 
      theEvapList.push_back(theInitialStatePtr); 
 
      // secondary are produced - sort out secondary fragments
    } else {
      G4bool deletePrimary = true;
      for (auto ptr : *theTempResult) {  
        if(ptr == theInitialStatePtr) { deletePrimary = false; }
        SortSecondaryFragment(ptr);
      }
      if( deletePrimary ) { delete theInitialStatePtr; }
    }
    delete theTempResult; // end multifragmentation
      }
    }
  }
  if(fVerbose > 2) {    
    G4cout << "## After first step of handler " << theEvapList.size() 
           << " for evap;  "
       << theResults.size() << " results. " << G4endl; 
  }
  // -----------------------------------
  // FermiBreakUp and De-excitation loop
  // -----------------------------------
      
  static const G4int countmax = 1000;
  size_t kk;
  for (kk=0; kk<theEvapList.size(); ++kk) {
    G4Fragment* frag = theEvapList[kk];
    if(fVerbose > 3) {  
      G4cout << "Next evaporate: " << G4endl;  
      G4cout << *frag << G4endl;  
    }
    if(kk >= countmax) {
      G4ExceptionDescription ed;
      ed << "Infinite loop in the de-excitation module: " << kk
     << " iterations \n"
     << "      Initial fragment: \n" << theInitialState
     << "\n      Current fragment: \n" << *frag;
      G4Exception("G4ExcitationHandler::BreakItUp","had0333",FatalException,
          ed,"Stop execution");
      
    }
    A = frag->GetA_asInt(); 
    Z = frag->GetZ_asInt();
    results.clear();
    if(fVerbose > 2) {
      G4cout << "G4ExcitationHandler# " << kk << " Z= " << Z << " A= " << A 
             << " Eex(MeV)= " << frag->GetExcitationEnergy() << G4endl;
    }     
    // Fermi Break-Up 
    if(theFermiModel->IsApplicable(Z, A, frag->GetExcitationEnergy())) {
      theFermiModel->BreakFragment(&results, frag);
      size_t nsec = results.size();
      if(fVerbose > 2) { G4cout << "FermiBreakUp Nsec= " << nsec << G4endl; }
 
      // FBU takes care to delete input fragment or add it to the results
      // The secondary may be excited - photo-evaporation should be applied
      if(1 < nsec) {
    for(auto & res : results) {
      SortSecondaryFragment(res);
    }
    continue;
      }
      // evaporation will be applied
    }
    // apply Evaporation, residual nucleus is always added to the results
    // photon evaporation is possible 
    theEvaporation->BreakFragment(&results, frag); 
    if(fVerbose > 3) { 
      G4cout << "Evaporation Nsec= " << results.size() << G4endl; 
    }
    if(0 == results.size()) {
      theResults.push_back(frag);
    } else {
      SortSecondaryFragment(frag);
    }
 
    // Sort out secondary fragments
    for (auto & res : results) {
      if(fVerbose > 4) {
    G4cout << "Evaporated product #" << *res << G4endl;  
      }
      SortSecondaryFragment(res);
    } // end of loop on secondary
  } // end of the loop over theEvapList
  if(fVerbose > 2) {    
    G4cout << "## After 2nd step of handler " << theEvapList.size() 
           << " was evap;  "
       << theResults.size() << " results. " << G4endl; 
  }
  G4ReactionProductVector * theReactionProductVector = 
    new G4ReactionProductVector();
 
  // MAC (24/07/08)
  // To optimise the storing speed, we reserve space 
  // in memory for the vector
  theReactionProductVector->reserve( theResults.size() );
 
  if(fVerbose > 2) {    
    G4cout << "### ExcitationHandler provides " << theResults.size() 
       << " evaporated products:" << G4endl;
  }
  for (auto & frag : theResults) {
 
    // in the case of dummy de-excitation, excitation energy is transfered 
    // into kinetic energy of output ion
    if(!isActive) {
      G4double mass = frag->GetGroundStateMass();
      G4double ptot = (frag->GetMomentum()).vect().mag();
      G4double etot = (frag->GetMomentum()).e();
      G4double fac  = (etot <= mass || 0.0 == ptot) ? 0.0 
    : std::sqrt((etot - mass)*(etot + mass))/ptot; 
      G4LorentzVector lv((frag->GetMomentum()).px()*fac, 
             (frag->GetMomentum()).py()*fac,
             (frag->GetMomentum()).pz()*fac, etot);
      frag->SetMomentum(lv);
    }
    if(fVerbose > 3) { 
      G4cout << *frag;
      if(frag->NuclearPolarization()) { 
    G4cout << "  " << frag->NuclearPolarization(); 
      }
      G4cout << G4endl;
    }
 
    G4int fragmentA = frag->GetA_asInt();
    G4int fragmentZ = frag->GetZ_asInt();
    G4double etot= frag->GetMomentum().e();
    G4double eexc = 0.0;
    const G4ParticleDefinition* theKindOfFragment = nullptr;
    if (fragmentA == 0) {       // photon or e-
      theKindOfFragment = frag->GetParticleDefinition();   
    } else if (fragmentA == 1 && fragmentZ == 0) { // neutron
      theKindOfFragment = theNeutron;
    } else if (fragmentA == 1 && fragmentZ == 1) { // proton
      theKindOfFragment = theProton;
    } else if (fragmentA == 2 && fragmentZ == 1) { // deuteron
      theKindOfFragment = theDeuteron;
    } else if (fragmentA == 3 && fragmentZ == 1) { // triton
      theKindOfFragment = theTriton;
    } else if (fragmentA == 3 && fragmentZ == 2) { // helium3
      theKindOfFragment = theHe3;
    } else if (fragmentA == 4 && fragmentZ == 2) { // alpha
      theKindOfFragment = theAlpha;
    } else {
 
      // fragment
      eexc = frag->GetExcitationEnergy();
      G4int idxf = frag->GetFloatingLevelNumber();
      if(eexc < minExcitation) { 
    eexc = 0.0; 
        idxf = 0;
      }
 
      theKindOfFragment = theTableOfIons->GetIon(fragmentZ,fragmentA,eexc,
                                                 G4Ions::FloatLevelBase(idxf));
      if(fVerbose > 3) {
    G4cout << "### EXCH: Find ion Z= " << fragmentZ 
               << " A= " << fragmentA
           << " Eexc(MeV)= " << eexc/MeV << " idx= " << idxf 
           << G4endl;
      }
    }
    // fragment identified
    if(theKindOfFragment) {
      G4ReactionProduct * theNew = new G4ReactionProduct(theKindOfFragment);
      theNew->SetMomentum(frag->GetMomentum().vect());
      theNew->SetTotalEnergy(etot);
      theNew->SetFormationTime(frag->GetCreationTime());
      if(theKindOfFragment == theElectron) {
    theNew->SetCreatorModelID(icID);
      } else {
    theNew->SetCreatorModelID(frag->GetCreatorModelID());
      }
      theReactionProductVector->push_back(theNew);
 
      // fragment not found out ground state is created
    } else { 
      theKindOfFragment = 
    theTableOfIons->GetIon(fragmentZ,fragmentA,0.0,noFloat,0);
      if(theKindOfFragment) {
    G4ThreeVector mom(0.0,0.0,0.0); 
    G4double ionmass = theKindOfFragment->GetPDGMass();
    if(etot <= ionmass) {
      etot = ionmass;
    } else {
      G4double ptot = std::sqrt((etot - ionmass)*(etot + ionmass));
      mom = (frag->GetMomentum().vect().unit())*ptot;
    }
    G4ReactionProduct * theNew = new G4ReactionProduct(theKindOfFragment);
    theNew->SetMomentum(mom);
    theNew->SetTotalEnergy(etot);
    theNew->SetFormationTime(frag->GetCreationTime());
    theNew->SetCreatorModelID(frag->GetCreatorModelID());
    theReactionProductVector->push_back(theNew);
    if(fVerbose > 3) {
      G4cout << "          ground state, energy corrected E(MeV)= " 
                 << etot << G4endl;
    }
      }
    }
    delete frag;
  }
  if(fVerbose > 3) {    
    G4cout << "@@@@@@@@@@ End G4Excitation Handler "<< G4endl;
  }
  return theReactionProductVector;
}

References A, G4VEvaporation::BreakFragment(), G4VFermiBreakUp::BreakFragment(), G4VMultiFragmentation::BreakItUp(), fac, FatalException, G4Ions::FloatLevelBase(), fVerbose, fWarnings, G4cout, G4endl, G4Exception(), G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4IonTable::GetIon(), G4ParticleDefinition::GetPDGMass(), G4Fragment::GetZ_asInt(), icID, Initialise(), isActive, G4VFermiBreakUp::IsApplicable(), isInitialised, JustWarning, maxAForFermiBreakUp, maxExcitation, maxZForFermiBreakUp, MeV, minEForMultiFrag, minExcitation, noFloat, results, G4ReactionProduct::SetCreatorModelID(), G4ReactionProduct::SetFormationTime(), G4ReactionProduct::SetMomentum(), G4ReactionProduct::SetTotalEnergy(), SortSecondaryFragment(), theAlpha, theDeuteron, theElectron, theEvapList, theEvaporation, theFermiModel, theHe3, theMultiFragmentation, theNeutron, theProton, theResults, theTableOfIons, theTriton, and Z.

Referenced by G4WilsonAbrasionModel::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4LowEIonFragmentation::ApplyYourself(), G4BinaryCascade::DeExcite(), G4PreCompoundDeexcitation::deExcite(), G4BinaryLightIonReaction::DeExciteSpectatorNucleus(), and G4PreCompoundModel::PerformEquilibriumEmission().

GetEvaporation()

G4VEvaporation * G4ExcitationHandler::GetEvaporation

(

)

Definition at line 254 of file G4ExcitationHandler.cc.

{
  if(!theEvaporation) { SetParameters(); }
  return theEvaporation;
}

References SetParameters(), and theEvaporation.

Referenced by G4INCLXXInterface::G4INCLXXInterface().

GetFermiModel()

G4VFermiBreakUp * G4ExcitationHandler::GetFermiModel

(

)

Definition at line 266 of file G4ExcitationHandler.cc.

{
  if(!theFermiModel) { SetParameters(); }
  return theFermiModel;
}

References SetParameters(), and theFermiModel.

GetMultiFragmentation()

G4VMultiFragmentation * G4ExcitationHandler::GetMultiFragmentation

(

)

Definition at line 260 of file G4ExcitationHandler.cc.

{
  if(!theMultiFragmentation) { SetParameters(); }
  return theMultiFragmentation;
}

References SetParameters(), and theMultiFragmentation.

GetPhotonEvaporation()

G4VEvaporationChannel * G4ExcitationHandler::GetPhotonEvaporation

(

)

Definition at line 272 of file G4ExcitationHandler.cc.

{
  if(!thePhotonEvaporation) { SetParameters(); }
  return thePhotonEvaporation;
}

References SetParameters(), and thePhotonEvaporation.

Initialise()

void G4ExcitationHandler::Initialise

(

)

Definition at line 158 of file G4ExcitationHandler.cc.

{
  if(isInitialised) { return; }
  if(fVerbose > 1) {
    G4cout << "G4ExcitationHandler::Initialise() started " << this << G4endl;
  }
  G4DeexPrecoParameters* param = 
    G4NuclearLevelData::GetInstance()->GetParameters();
  isInitialised = true;
  SetParameters();
  if(isActive) {
    theFermiModel->Initialise();
    theEvaporation->InitialiseChannels();
  }
  // dump level is controlled by parameter class
  param->Dump();
}

References G4DeexPrecoParameters::Dump(), fVerbose, G4cout, G4endl, G4NuclearLevelData::GetInstance(), G4NuclearLevelData::GetParameters(), G4VFermiBreakUp::Initialise(), G4VEvaporation::InitialiseChannels(), isActive, isInitialised, SetParameters(), theEvaporation, and theFermiModel.

Referenced by BreakItUp(), G4AblaInterface::InitialiseModel(), and G4PreCompoundModel::InitialiseModel().

ModelDescription()

void G4ExcitationHandler::ModelDescription

(

std::ostream &

outFile

)

const

Definition at line 545 of file G4ExcitationHandler.cc.

{
  outFile << "G4ExcitationHandler description\n"
      << "This class samples de-excitation of excited nucleus using\n"
      << "Fermi Break-up model for light fragments (Z < 9, A < 17), "
      << "evaporation, fission, and photo-evaporation models. Evaporated\n"
      << "particle may be proton, neutron, and other light fragment \n"
      << "(Z < 13, A < 29). During photon evaporation produced gamma \n"
      << "or electrons due to internal conversion \n";
}

Referenced by G4BinaryCascade::ModelDescription(), and G4BinaryCascade::PropagateModelDescription().

operator!=()

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

private

operator=()

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

private

operator==()

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

private

SetDeexChannelsType()

void G4ExcitationHandler::SetDeexChannelsType

(

G4DeexChannelType

val

)

Definition at line 222 of file G4ExcitationHandler.cc.

{
  G4Evaporation* evap = static_cast<G4Evaporation*>(theEvaporation);
  if(fVerbose > 1) {
    G4cout << "G4ExcitationHandler::SetDeexChannelsType " << val 
       << " for " << this << G4endl;
  }
  if(val == fDummy) { 
    isActive = false;
    return; 
  }
  if(!evap) { return; }
  if(val == fEvaporation) {
    evap->SetDefaultChannel();
  } else if(val == fCombined) {
    evap->SetCombinedChannel();
  } else if(val == fGEM) {
    evap->SetGEMChannel();
  } else if(val == fGEMVI) {
    evap->SetGEMVIChannel();
  }
  evap->InitialiseChannels();
  if(fVerbose > 1) {
    if(G4Threading::IsMasterThread()) {
      G4cout << "Number of de-excitation channels is changed to: " 
         << theEvaporation->GetNumberOfChannels();
      G4cout << " " << this;
    }
    G4cout << G4endl; 
  }
}

References fCombined, fDummy, fEvaporation, fGEM, fGEMVI, fVerbose, G4cout, G4endl, G4VEvaporation::GetNumberOfChannels(), G4Evaporation::InitialiseChannels(), isActive, G4Threading::IsMasterThread(), G4Evaporation::SetCombinedChannel(), G4Evaporation::SetDefaultChannel(), G4Evaporation::SetGEMChannel(), G4Evaporation::SetGEMVIChannel(), and theEvaporation.

Referenced by G4QMDReaction::G4QMDReaction().

SetEvaporation()

void G4ExcitationHandler::SetEvaporation	(	G4VEvaporation *	ptr,
		G4bool	isLocal = false
	)

Definition at line 176 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != theEvaporation) {
    delete theEvaporation; 
    theEvaporation = ptr;
    SetPhotonEvaporation(ptr->GetPhotonEvaporation());
    theEvaporation->SetFermiBreakUp(theFermiModel);
    isEvapLocal = flag;
    if(fVerbose > 1) {
      G4cout << "G4ExcitationHandler::SetEvaporation() for " << this << G4endl;
    }
  }
}

References fVerbose, G4cout, G4endl, G4VEvaporation::GetPhotonEvaporation(), isEvapLocal, G4VEvaporation::SetFermiBreakUp(), SetPhotonEvaporation(), theEvaporation, and theFermiModel.

Referenced by G4QMDReaction::G4QMDReaction(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), SetParameters(), and G4WilsonAbrasionModel::SetUseAblation().

SetFermiModel()

void G4ExcitationHandler::SetFermiModel

(

G4VFermiBreakUp *

ptr

)

Definition at line 199 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != theFermiModel) {
    delete theFermiModel;
    theFermiModel = ptr;
    if(theEvaporation) { theEvaporation->SetFermiBreakUp(theFermiModel); }
  }
}

References G4VEvaporation::SetFermiBreakUp(), theEvaporation, and theFermiModel.

Referenced by SetParameters().

SetMaxAandZForFermiBreakUp()

void G4ExcitationHandler::SetMaxAandZForFermiBreakUp ( G4int  anA, G4int  aZ  )

inline

Definition at line 168 of file G4ExcitationHandler.hh.

{
  SetMaxAForFermiBreakUp(anA);
  SetMaxZForFermiBreakUp(aZ);
}

References SetMaxAForFermiBreakUp(), and SetMaxZForFermiBreakUp().

SetMaxAForFermiBreakUp()

void G4ExcitationHandler::SetMaxAForFermiBreakUp ( G4int  anA )

inline

Definition at line 163 of file G4ExcitationHandler.hh.

{
  maxAForFermiBreakUp = anA;
}

References maxAForFermiBreakUp.

Referenced by SetMaxAandZForFermiBreakUp().

SetMaxZForFermiBreakUp()

void G4ExcitationHandler::SetMaxZForFermiBreakUp ( G4int  aZ )

inline

Definition at line 158 of file G4ExcitationHandler.hh.

{
  maxZForFermiBreakUp = aZ;
}

References maxZForFermiBreakUp.

Referenced by SetMaxAandZForFermiBreakUp().

SetMinEForMultiFrag()

void G4ExcitationHandler::SetMinEForMultiFrag ( G4double  anE )

inline

Definition at line 174 of file G4ExcitationHandler.hh.

{
  minEForMultiFrag = anE;
}

References minEForMultiFrag.

Referenced by G4EMDissociation::G4EMDissociation().

SetMultiFragmentation()

void G4ExcitationHandler::SetMultiFragmentation

(

G4VMultiFragmentation *

ptr

)

Definition at line 191 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != theMultiFragmentation) {
    delete theMultiFragmentation;
    theMultiFragmentation = ptr;
  }
}

References theMultiFragmentation.

Referenced by SetParameters().

SetOPTxs()

void G4ExcitationHandler::SetOPTxs ( G4int  opt )

inline

Definition at line 179 of file G4ExcitationHandler.hh.

{}

SetParameters()

void G4ExcitationHandler::SetParameters ( )

private

Definition at line 122 of file G4ExcitationHandler.cc.

{
  G4NuclearLevelData* ndata = G4NuclearLevelData::GetInstance();
  auto param = ndata->GetParameters();
  isActive = true;
  // check if de-excitation is needed
  if(fDummy == param->GetDeexChannelsType()) { 
    isActive = false; 
  } else {
    // upload data for elements used in geometry
    G4int Zmax = 20;
    const G4ElementTable* table = G4Element::GetElementTable();
    for(auto & elm : *table) { Zmax = std::max(Zmax, elm->GetZasInt()); }
    ndata->UploadNuclearLevelData(Zmax+1);
  }
  minEForMultiFrag = param->GetMinExPerNucleounForMF();
  minExcitation = param->GetMinExcitation();
  maxExcitation = param->GetPrecoHighEnergy();
  icID = G4PhysicsModelCatalog::GetModelID("model_e-InternalConversion");
 
  // allowing local debug printout 
  fVerbose = std::max(fVerbose, param->GetVerbose());
  if(isActive) {
    if(!thePhotonEvaporation)  { SetPhotonEvaporation(new G4PhotonEvaporation()); }
    if(!theEvaporation) { 
      SetEvaporation(new G4Evaporation(thePhotonEvaporation), true); 
    }
    if(!theFermiModel)         { SetFermiModel(new G4FermiBreakUpVI()); }
    if(!theMultiFragmentation) { SetMultiFragmentation(new G4StatMF()); }
  }
  theFermiModel->SetVerbose(fVerbose);
  if(fVerbose > 1) {
    G4cout << "G4ExcitationHandler::SetParameters() done " << this << G4endl;
  }
}

References fDummy, fVerbose, G4cout, G4endl, G4Element::GetElementTable(), G4NuclearLevelData::GetInstance(), G4PhysicsModelCatalog::GetModelID(), G4NuclearLevelData::GetParameters(), icID, isActive, G4INCL::Math::max(), maxExcitation, minEForMultiFrag, minExcitation, SetEvaporation(), SetFermiModel(), SetMultiFragmentation(), SetPhotonEvaporation(), G4VFermiBreakUp::SetVerbose(), theEvaporation, theFermiModel, theMultiFragmentation, thePhotonEvaporation, and G4NuclearLevelData::UploadNuclearLevelData().

Referenced by GetEvaporation(), GetFermiModel(), GetMultiFragmentation(), GetPhotonEvaporation(), and Initialise().

SetPhotonEvaporation()

void G4ExcitationHandler::SetPhotonEvaporation

(

G4VEvaporationChannel *

ptr

)

Definition at line 209 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != thePhotonEvaporation) {
    delete thePhotonEvaporation;
    thePhotonEvaporation = ptr;
    if(theEvaporation) { theEvaporation->SetPhotonEvaporation(ptr); }
    if(fVerbose > 1) {
      G4cout << "G4ExcitationHandler::SetPhotonEvaporation() " << ptr 
             << " for handler " << this << G4endl;
    }
  }
}

References fVerbose, G4cout, G4endl, G4VEvaporation::SetPhotonEvaporation(), theEvaporation, and thePhotonEvaporation.

Referenced by SetEvaporation(), and SetParameters().

SortSecondaryFragment()

void G4ExcitationHandler::SortSecondaryFragment ( G4Fragment *  frag )

inlineprivate

Definition at line 185 of file G4ExcitationHandler.hh.

{ 
  G4int A = frag->GetA_asInt();  
 
  // gamma, e-, p, n
  if(A <= 1) { 
    theResults.push_back(frag); 
  } else if(frag->GetExcitationEnergy() < minExcitation) {
    // cold fragments
    G4int Z = frag->GetZ_asInt(); 
       
    // is stable or d, t, He3, He4
    if(nist->GetIsotopeAbundance(Z, A) > 0.0 || (A == 3 && (Z == 1 || Z == 2)) ) {
      theResults.push_back(frag); // stable fragment 
    } else {
      theEvapList.push_back(frag);
    }
    // hot fragments are unstable
  } else { 
    theEvapList.push_back(frag);  
  }
}

References A, G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4NistManager::GetIsotopeAbundance(), G4Fragment::GetZ_asInt(), minExcitation, nist, theEvapList, theResults, and Z.

Referenced by BreakItUp().

UseSICB()

void G4ExcitationHandler::UseSICB ( )

inline

Definition at line 182 of file G4ExcitationHandler.hh.

{}

Field Documentation

fVerbose

G4int G4ExcitationHandler::fVerbose

private

Definition at line 137 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), Initialise(), SetDeexChannelsType(), SetEvaporation(), SetParameters(), and SetPhotonEvaporation().

fWarnings

G4int G4ExcitationHandler::fWarnings

private

Definition at line 138 of file G4ExcitationHandler.hh.

Referenced by BreakItUp().

icID

G4int G4ExcitationHandler::icID

private

Definition at line 132 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and SetParameters().

isActive

G4bool G4ExcitationHandler::isActive

private

Definition at line 146 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), Initialise(), SetDeexChannelsType(), and SetParameters().

isEvapLocal

G4bool G4ExcitationHandler::isEvapLocal

private

Definition at line 145 of file G4ExcitationHandler.hh.

Referenced by SetEvaporation(), and ~G4ExcitationHandler().

isInitialised

G4bool G4ExcitationHandler::isInitialised

private

Definition at line 144 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and Initialise().

maxAForFermiBreakUp

G4int G4ExcitationHandler::maxAForFermiBreakUp

private

Definition at line 135 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and SetMaxAForFermiBreakUp().

maxExcitation

G4double G4ExcitationHandler::maxExcitation

private

Definition at line 142 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and SetParameters().

maxZForFermiBreakUp

G4int G4ExcitationHandler::maxZForFermiBreakUp

private

Definition at line 134 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and SetMaxZForFermiBreakUp().

minEForMultiFrag

G4double G4ExcitationHandler::minEForMultiFrag

private

Definition at line 140 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), SetMinEForMultiFrag(), and SetParameters().

minExcitation

G4double G4ExcitationHandler::minExcitation

private

Definition at line 141 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), SetParameters(), and SortSecondaryFragment().

nist

G4NistManager* G4ExcitationHandler::nist

private

Definition at line 122 of file G4ExcitationHandler.hh.

Referenced by G4ExcitationHandler(), and SortSecondaryFragment().

results

std::vector<G4Fragment*> G4ExcitationHandler::results

private

Definition at line 152 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theAlpha

const G4ParticleDefinition* G4ExcitationHandler::theAlpha

private

Definition at line 130 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theDeuteron

const G4ParticleDefinition* G4ExcitationHandler::theDeuteron

private

Definition at line 127 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theElectron

const G4ParticleDefinition* G4ExcitationHandler::theElectron

private

Definition at line 124 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theEvapList

std::vector<G4Fragment*> G4ExcitationHandler::theEvapList

private

Definition at line 155 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), and SortSecondaryFragment().

theEvaporation

G4VEvaporation* G4ExcitationHandler::theEvaporation

private

Definition at line 117 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), GetEvaporation(), Initialise(), SetDeexChannelsType(), SetEvaporation(), SetFermiModel(), SetParameters(), SetPhotonEvaporation(), and ~G4ExcitationHandler().

theFermiModel

G4VFermiBreakUp* G4ExcitationHandler::theFermiModel

private

Definition at line 119 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), GetFermiModel(), Initialise(), SetEvaporation(), SetFermiModel(), SetParameters(), and ~G4ExcitationHandler().

theHe3

const G4ParticleDefinition* G4ExcitationHandler::theHe3

private

Definition at line 129 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theMultiFragmentation

G4VMultiFragmentation* G4ExcitationHandler::theMultiFragmentation

private

Definition at line 118 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), GetMultiFragmentation(), SetMultiFragmentation(), SetParameters(), and ~G4ExcitationHandler().

theNeutron

const G4ParticleDefinition* G4ExcitationHandler::theNeutron

private

Definition at line 125 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

thePhotonEvaporation

G4VEvaporationChannel* G4ExcitationHandler::thePhotonEvaporation

private

Definition at line 120 of file G4ExcitationHandler.hh.

Referenced by G4ExcitationHandler(), GetPhotonEvaporation(), SetParameters(), and SetPhotonEvaporation().

theProton

const G4ParticleDefinition* G4ExcitationHandler::theProton

private

Definition at line 126 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theResults

std::vector<G4Fragment*> G4ExcitationHandler::theResults

private

Definition at line 149 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), G4ExcitationHandler(), and SortSecondaryFragment().

theTableOfIons

G4IonTable* G4ExcitationHandler::theTableOfIons

private

Definition at line 121 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

theTriton

const G4ParticleDefinition* G4ExcitationHandler::theTriton

private

Definition at line 128 of file G4ExcitationHandler.hh.

Referenced by BreakItUp(), and G4ExcitationHandler().

---

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

• source/processes/hadronic/models/de_excitation/handler/include/G4ExcitationHandler.hh
• source/processes/hadronic/models/de_excitation/handler/src/G4ExcitationHandler.cc