G4ExcitationHandler Class Reference

#include <G4ExcitationHandler.hh>

Collaboration diagram for G4ExcitationHandler:

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

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

Private Attributes
G4VEvaporation *	theEvaporation
G4VMultiFragmentation *	theMultiFragmentation
G4VFermiBreakUp *	theFermiModel
G4VEvaporationChannel *	thePhotonEvaporation
G4FermiFragmentsPool *	thePool
G4int	maxZForFermiBreakUp
G4int	maxAForFermiBreakUp
G4double	minEForMultiFrag
G4double	minExcitation
G4IonTable *	theTableOfIons
G4NistManager *	nist
G4int	OPTxs
G4bool	useSICB
G4bool	isEvapLocal
std::vector< G4Fragment * >	theResults
std::vector< G4Fragment * >	results
std::vector< G4Fragment * >	thePhotoEvapList
std::vector< G4Fragment * >	theEvapList

Detailed Description

Definition at line 64 of file G4ExcitationHandler.hh.

Constructor & Destructor Documentation

G4ExcitationHandler() [1/2]

G4ExcitationHandler::G4ExcitationHandler

(

)

Definition at line 84 of file G4ExcitationHandler.cc.

                                        :
  maxZForFermiBreakUp(9),maxAForFermiBreakUp(17),minEForMultiFrag(400*GeV),
  minExcitation(0.1*keV),OPTxs(3),useSICB(false),isEvapLocal(true)
{                                                                          
  theTableOfIons = G4ParticleTable::GetParticleTable()->GetIonTable();
  nist = G4NistManager::Instance();
  
  theMultiFragmentation = new G4StatMF();
  theFermiModel = new G4FermiBreakUp();
  theEvaporation = new G4Evaporation();
  thePhotonEvaporation = theEvaporation->GetPhotonEvaporation();
  thePool = G4FermiFragmentsPool::Instance();
  SetParameters();
  G4Pow::GetInstance();
  theResults.reserve(60);
  results.reserve(30);
  theEvapList.reserve(30);
  thePhotoEvapList.reserve(10);
  //G4cout << "### New handler " << this << G4endl;
}

Here is the call graph for this function:

~G4ExcitationHandler()

G4ExcitationHandler::~G4ExcitationHandler

(

)

Definition at line 105 of file G4ExcitationHandler.cc.

{
  //G4cout << "### Delete handler " << this << G4endl;
  delete theMultiFragmentation;
  delete theFermiModel;
  if(isEvapLocal) { delete theEvaporation; } 
}

G4ExcitationHandler() [2/2]

G4ExcitationHandler::G4ExcitationHandler ( const G4ExcitationHandler &  right )

private

Member Function Documentation

BreakItUp()

G4ReactionProductVector * G4ExcitationHandler::BreakItUp

(

const G4Fragment &

theInitialState

)

Definition at line 114 of file G4ExcitationHandler.cc.

{   
  //G4cout << "@@@@@@@@@@ Start G4Excitation Handler @@@@@@@@@@@@@" << G4endl;
  // Variables existing until end of method
  G4Fragment * theInitialStatePtr = new G4Fragment(theInitialState);
  //G4cout << theInitialState << G4endl;  

  // pointer to fragment vector which receives temporal results
  G4FragmentVector * theTempResult = 0;     

  theResults.clear();
  thePhotoEvapList.clear();
  theEvapList.clear();
   
  // Variables to describe the excited configuration
  G4double exEnergy = theInitialState.GetExcitationEnergy();
  G4int A = theInitialState.GetA_asInt();
  G4int Z = theInitialState.GetZ_asInt();
  
  // In case A <= 1 the fragment will not perform any nucleon emission
  if (A <= 1) {
    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;
      G4FragmentVector::iterator j;
      for (j = theTempResult->begin(); j != theTempResult->end(); ++j) {  
        if((*j) == theInitialStatePtr) { deletePrimary = false; }
        A = (*j)->GetA_asInt();  

        // gamma, p, n
        if(A <= 1) { 
          theResults.push_back(*j); 

          // Analyse fragment A > 1
        } else {
          G4double exEnergy1 = (*j)->GetExcitationEnergy();

          // cold fragments
          if(exEnergy1 < minExcitation) {
        Z = (*j)->GetZ_asInt(); 
        if(nist->GetIsotopeAbundance(Z, A) > 0.0) { 
          theResults.push_back(*j); // stable fragment 
        } else {
          theEvapList.push_back(*j);
        }
        // hot fragments are unstable
          } else { 
        theEvapList.push_back(*j); 
          } 
        }
      }
      if( deletePrimary ) { delete theInitialStatePtr; }
    }
    delete theTempResult; // end multifragmentation
      }
    }
  }
  /*
  G4cout << "## After first step " << theEvapList.size() << " for evap;  "
  << thePhotoEvapList.size() << " for photo-evap; " 
  << theResults.size() << " results. " << G4endl; 
  */
  // -----------------------------------
  // FermiBreakUp and De-excitation loop
  // -----------------------------------
      
  static const G4int countmax = 1000;
  G4Fragment* frag;
  size_t kk;
  for (kk=0; kk<theEvapList.size(); ++kk) {
    frag = theEvapList[kk];
    //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();
      
    // Fermi Break-Up 
    if(A < maxAForFermiBreakUp && Z < maxZForFermiBreakUp && Z > 0 && A > Z) {
      G4double etot = frag->GetExcitationEnergy() + frag->GetGroundStateMass();
      if(thePool->IsApplicable(Z, A, etot)) {
    theFermiModel->BreakFragment(&results, frag);
        size_t nsec = results.size();
    //G4cout << "FermiBreakUp Nsec= " << nsec << G4endl;

    // FBU takes care to delete input fragment or add it to the results
    // results may be excited - photo-evaporation should be applied
    // If no final products then the fragment should be de-excited 
    // by evaporation
    if(0 < nsec) {
          for(size_t j=0; j<nsec; ++j) {
        exEnergy = results[j]->GetExcitationEnergy();
        if(exEnergy < minExcitation) { theResults.push_back(results[j]); }
        else                   { thePhotoEvapList.push_back(results[j]); }
          }
      continue; 
    }
      }
    }
    // apply Evaporation, residual nucleus is always added to the results
    theEvaporation->BreakFragment(&results, frag); 
    size_t nsec = results.size();
    //G4cout << "Evaporation Nsec= " << nsec << G4endl;
          
    // no evaporation
    if(1 >= nsec) {
      theResults.push_back(frag);
      continue;
    }

    // Sort out secondary fragments
    for (size_t j = 0; j<nsec; ++j) {
      //G4cout << "Evaporated product #" << j << G4endl;
      //G4cout << results[j] << G4endl;  
      A = results[j]->GetA_asInt();
      //G4cout << "A= " << A << G4endl;
      if(A <= 1) { 
    theResults.push_back(results[j]);   // gamma, p, n
    continue;
      } 
      exEnergy = results[j]->GetExcitationEnergy();

      // hot fragment
      if(exEnergy >= minExcitation) {
    theEvapList.push_back(results[j]);        
        
    // cold fragment
      } else {  
    Z = results[j]->GetZ_asInt();

    // natural isotope
    if(nist->GetIsotopeAbundance(Z, A) > 0.0) { 
      theResults.push_back(results[j]); // stable fragment 

    } else {
      theEvapList.push_back(results[j]);      
    }
      }
    } // end of loop on secondary
  } // end of the loop over theEvapList
  /* 
  G4cout << "## After 2nd step " << theEvapList.size() << " was evap;  "
     << thePhotoEvapList.size() << " for photo-evap; " 
     << theResults.size() << " results. " << G4endl; 
  */
  // -----------------------
  // Photon-Evaporation loop
  // -----------------------
  
  // at this point only photon evaporation is possible
  size_t kkmax = thePhotoEvapList.size();
  for (kk=0; kk<kkmax; ++kk) {
    frag = thePhotoEvapList[kk];
    //G4cout << "Next photon evaporate: " << thePhotonEvaporation << G4endl;  
    //G4cout << *frag << G4endl;
    exEnergy = frag->GetExcitationEnergy();

    // photon de-excitation only for hot fragments
    if(exEnergy > minExcitation) {  
      thePhotonEvaporation->BreakUpChain(&theResults, frag);
    }

    // priamry fragment is kept
    theResults.push_back(frag); 

  } // end of photon-evaporation loop
  /*
  G4cout << "## After 3d step " << theEvapList.size() << " was evap;  "
     << thePhotoEvapList.size() << " was photo-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() );

  G4int theFragmentA, theFragmentZ;

  //G4cout << "### ExcitationHandler provides " << theResults.size() 
  //     << " evaporated products:" << G4endl;
  kkmax = theResults.size();
  for (kk=0; kk<kkmax; ++kk) {
    frag = theResults[kk];
    //G4cout << *frag << G4endl;  

    theFragmentA = frag->GetA_asInt();
    theFragmentZ = frag->GetZ_asInt();
    G4double etot= frag->GetMomentum().e();
    G4double eexc = 0.0;
    const G4ParticleDefinition* theKindOfFragment = 0;
    if (theFragmentA == 0) {       // photon or e-
      theKindOfFragment = frag->GetParticleDefinition();   
    } else if (theFragmentA == 1 && theFragmentZ == 0) { // neutron
      theKindOfFragment = G4Neutron::NeutronDefinition();
    } else if (theFragmentA == 1 && theFragmentZ == 1) { // proton
      theKindOfFragment = G4Proton::ProtonDefinition();
    } else if (theFragmentA == 2 && theFragmentZ == 1) { // deuteron
      theKindOfFragment = G4Deuteron::DeuteronDefinition();
    } else if (theFragmentA == 3 && theFragmentZ == 1) { // triton
      theKindOfFragment = G4Triton::TritonDefinition();
    } else if (theFragmentA == 3 && theFragmentZ == 2) { // helium3
      theKindOfFragment = G4He3::He3Definition();
    } else if (theFragmentA == 4 && theFragmentZ == 2) { // alpha
      theKindOfFragment = G4Alpha::AlphaDefinition();;
    } else {

      // fragment
      eexc = frag->GetExcitationEnergy();
      if(eexc < minExcitation) { eexc = 0.0; }
      theKindOfFragment = theTableOfIons->GetIon(theFragmentZ,theFragmentA,eexc);
      /*        
    G4cout << "### Find ion Z= " << theFragmentZ << " A= " << theFragmentA
           << " Eexc(MeV)= " << eexc/MeV << "  " << theKindOfFragment 
           << G4endl;
      */
    }
    // fragment identified
    if(theKindOfFragment) {
      G4ReactionProduct * theNew = new G4ReactionProduct(theKindOfFragment);
      theNew->SetMomentum(frag->GetMomentum().vect());
      theNew->SetTotalEnergy(etot);
      theNew->SetFormationTime(frag->GetCreationTime());
      theReactionProductVector->push_back(theNew);

      // fragment not found out ground state is created
    } else { 
      theKindOfFragment = theTableOfIons->GetIon(theFragmentZ,theFragmentA,0.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());
    theReactionProductVector->push_back(theNew);
    /*  
      G4cout << "### Find ion Z= " << theFragmentZ << " A= " << theFragmentA
      << " ground state, energy corrected  " << theKindOfFragment << G4endl;
    } else {
        G4cout << "### Find ion Z= " << theFragmentZ 
        << " A= " << theFragmentA << " failed  " << G4endl;
      */
      }
    }
    delete frag;
  }
  return theReactionProductVector;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEvaporation()

G4VEvaporation * G4ExcitationHandler::GetEvaporation ( )

inline

Definition at line 141 of file G4ExcitationHandler.hh.

{
  return theEvaporation;
}

Here is the caller graph for this function:

GetFermiModel()

G4VFermiBreakUp * G4ExcitationHandler::GetFermiModel ( )

inline

Definition at line 151 of file G4ExcitationHandler.hh.

{
  return theFermiModel;
}

GetMultiFragmentation()

G4VMultiFragmentation * G4ExcitationHandler::GetMultiFragmentation ( )

inline

Definition at line 146 of file G4ExcitationHandler.hh.

{
  return theMultiFragmentation;
}

GetPhotonEvaporation()

G4VEvaporationChannel * G4ExcitationHandler::GetPhotonEvaporation ( )

inline

Definition at line 156 of file G4ExcitationHandler.hh.

{
  return thePhotonEvaporation;
}

ModelDescription()

void G4ExcitationHandler::ModelDescription

(

std::ostream &

outFile

)

const

Definition at line 473 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";
}

Here is the caller graph for this function:

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

SetEvaporation()

void G4ExcitationHandler::SetEvaporation

(

G4VEvaporation *

ptr

)

Definition at line 415 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != theEvaporation) {
    delete theEvaporation; 
    theEvaporation = ptr;
    thePhotonEvaporation = ptr->GetPhotonEvaporation();
    SetParameters();
    isEvapLocal = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetFermiModel()

void G4ExcitationHandler::SetFermiModel

(

G4VFermiBreakUp *

ptr

)

Definition at line 435 of file G4ExcitationHandler.cc.

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

Here is the caller graph for this function:

SetMaxAandZForFermiBreakUp()

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

Definition at line 463 of file G4ExcitationHandler.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetMaxAForFermiBreakUp()

void G4ExcitationHandler::SetMaxAForFermiBreakUp

(

G4int

anA

)

Definition at line 458 of file G4ExcitationHandler.cc.

{
  maxAForFermiBreakUp = anA;
}

Here is the caller graph for this function:

SetMaxZForFermiBreakUp()

void G4ExcitationHandler::SetMaxZForFermiBreakUp

(

G4int

aZ

)

Definition at line 453 of file G4ExcitationHandler.cc.

{
  maxZForFermiBreakUp = aZ;
}

Here is the caller graph for this function:

SetMinEForMultiFrag()

void G4ExcitationHandler::SetMinEForMultiFrag

(

G4double

anE

)

Definition at line 469 of file G4ExcitationHandler.cc.

{
  minEForMultiFrag = anE;
}

Here is the caller graph for this function:

SetMultiFragmentation()

void G4ExcitationHandler::SetMultiFragmentation

(

G4VMultiFragmentation *

ptr

)

Definition at line 427 of file G4ExcitationHandler.cc.

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

Here is the caller graph for this function:

SetOPTxs()

void G4ExcitationHandler::SetOPTxs ( G4int  opt )

inline

Definition at line 161 of file G4ExcitationHandler.hh.

{ 
  OPTxs = opt; 
  SetParameters();
}

Here is the call graph for this function:

SetParameters()

void G4ExcitationHandler::SetParameters ( )

private

Definition at line 406 of file G4ExcitationHandler.cc.

{
  //for inverse cross section choice
  theEvaporation->SetOPTxs(OPTxs);
  //for the choice of superimposed Coulomb Barrier for inverse cross sections
  theEvaporation->UseSICB(useSICB);
  theEvaporation->InitialiseChannels();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetPhotonEvaporation()

void G4ExcitationHandler::SetPhotonEvaporation

(

G4VEvaporationChannel *

ptr

)

Definition at line 444 of file G4ExcitationHandler.cc.

{
  if(ptr && ptr != thePhotonEvaporation) {
    thePhotonEvaporation = ptr;
    theEvaporation->SetPhotonEvaporation(ptr);
    ptr->Initialise();
  }
}

Here is the call graph for this function:

UseSICB()

void G4ExcitationHandler::UseSICB ( )

inline

Definition at line 167 of file G4ExcitationHandler.hh.

{ 
  useSICB = true; 
  SetParameters();
}

Here is the call graph for this function:

Member Data Documentation

isEvapLocal

G4bool G4ExcitationHandler::isEvapLocal

private

Definition at line 126 of file G4ExcitationHandler.hh.

maxAForFermiBreakUp

G4int G4ExcitationHandler::maxAForFermiBreakUp

private

Definition at line 117 of file G4ExcitationHandler.hh.

maxZForFermiBreakUp

G4int G4ExcitationHandler::maxZForFermiBreakUp

private

Definition at line 116 of file G4ExcitationHandler.hh.

minEForMultiFrag

G4double G4ExcitationHandler::minEForMultiFrag

private

Definition at line 118 of file G4ExcitationHandler.hh.

minExcitation

G4double G4ExcitationHandler::minExcitation

private

Definition at line 119 of file G4ExcitationHandler.hh.

nist

G4NistManager* G4ExcitationHandler::nist

private

Definition at line 122 of file G4ExcitationHandler.hh.

OPTxs

G4int G4ExcitationHandler::OPTxs

private

Definition at line 124 of file G4ExcitationHandler.hh.

results

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

private

Definition at line 132 of file G4ExcitationHandler.hh.

theEvapList

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

private

Definition at line 138 of file G4ExcitationHandler.hh.

theEvaporation

G4VEvaporation* G4ExcitationHandler::theEvaporation

private

Definition at line 109 of file G4ExcitationHandler.hh.

theFermiModel

G4VFermiBreakUp* G4ExcitationHandler::theFermiModel

private

Definition at line 111 of file G4ExcitationHandler.hh.

theMultiFragmentation

G4VMultiFragmentation* G4ExcitationHandler::theMultiFragmentation

private

Definition at line 110 of file G4ExcitationHandler.hh.

thePhotoEvapList

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

private

Definition at line 135 of file G4ExcitationHandler.hh.

thePhotonEvaporation

G4VEvaporationChannel* G4ExcitationHandler::thePhotonEvaporation

private

Definition at line 112 of file G4ExcitationHandler.hh.

thePool

G4FermiFragmentsPool* G4ExcitationHandler::thePool

private

Definition at line 114 of file G4ExcitationHandler.hh.

theResults

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

private

Definition at line 129 of file G4ExcitationHandler.hh.

theTableOfIons

G4IonTable* G4ExcitationHandler::theTableOfIons

private

Definition at line 121 of file G4ExcitationHandler.hh.

useSICB

G4bool G4ExcitationHandler::useSICB

private

Definition at line 125 of file G4ExcitationHandler.hh.

---

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

• G4ExcitationHandler.hh
• G4ExcitationHandler.cc