G4ExcitationHandler Class Reference

#include <G4ExcitationHandler.hh>

Public Member Functions
	G4ExcitationHandler ()
	~G4ExcitationHandler ()
G4ReactionProductVector *	BreakItUp (const G4Fragment &theInitialState) const
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)
G4VEvaporation *	GetEvaporation ()
G4VMultiFragmentation *	GetMultiFragmentation ()
G4VFermiBreakUp *	GetFermiModel ()
G4VEvaporationChannel *	GetPhotonEvaporation ()
void	SetOPTxs (G4int opt)
void	UseSICB ()

Detailed Description

Definition at line 63 of file G4ExcitationHandler.hh.

Constructor & Destructor Documentation

G4ExcitationHandler::G4ExcitationHandler

(

)

Definition at line 89 of file G4ExcitationHandler.cc.

References fDelayedEmission, G4Pow::GetInstance(), G4ParticleTable::GetIonTable(), G4ParticleTable::GetParticleTable(), and G4FermiFragmentsPool::Instance().

                                        :
  maxZForFermiBreakUp(9),maxAForFermiBreakUp(17),minEForMultiFrag(4*GeV),
  minExcitation(keV),OPTxs(3),useSICB(false),isEvapLocal(true)
{                                                                          
  theTableOfIons = G4ParticleTable::GetParticleTable()->GetIonTable();
  
  theMultiFragmentation = new G4StatMF;
  theFermiModel = new G4FermiBreakUp;
  thePhotonEvaporation = new G4PhotonEvaporation("ExcitationHandler",fDelayedEmission);
  theEvaporation = new G4Evaporation(thePhotonEvaporation);
  thePool = G4FermiFragmentsPool::Instance();
  SetParameters();
  G4Pow::GetInstance();
}

G4ExcitationHandler::~G4ExcitationHandler

(

)

Definition at line 104 of file G4ExcitationHandler.cc.

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

Member Function Documentation

G4ReactionProductVector * G4ExcitationHandler::BreakItUp

(

const G4Fragment &

theInitialState

)

const

Definition at line 121 of file G4ExcitationHandler.cc.

References G4Alpha::AlphaDefinition(), G4VFermiBreakUp::BreakItUp(), G4VMultiFragmentation::BreakItUp(), G4VEvaporation::BreakItUp(), G4VEvaporationChannel::BreakUpFragment(), G4Deuteron::DeuteronDefinition(), G4Fragment::GetA_asInt(), G4VFermiFragment::GetExcitationEnergy(), G4Ions::GetExcitationEnergy(), G4Fragment::GetExcitationEnergy(), G4FermiFragmentsPool::GetFragment(), G4IonTable::GetIon(), G4NistManager::GetIsotopeAbundance(), G4ParticleDefinition::GetPDGMass(), G4Fragment::GetZ_asInt(), G4He3::He3Definition(), G4NistManager::Instance(), G4VFermiFragment::IsStable(), G4Neutron::NeutronDefinition(), G4Proton::ProtonDefinition(), G4ReactionProduct::SetFormationTime(), G4ReactionProduct::SetMomentum(), G4ReactionProduct::SetTotalEnergy(), and G4Triton::TritonDefinition().

Referenced by G4ParaFissionModel::ApplyYourself(), G4LowEIonFragmentation::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4WilsonAbrasionModel::ApplyYourself(), and G4PreCompoundDeexcitation::deExcite().

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

  // pointer to fragment vector which receives temporal results
  G4FragmentVector * theTempResult = 0;     
 
  // list of fragments to apply Evaporation or Fermi Break-Up
  std::list<G4Fragment*> theEvapList;        

  // list of fragments to apply PhotonEvaporation 
  std::list<G4Fragment*> thePhotoEvapList;

  // list of fragments to store final result   
  std::list<G4Fragment*> theResults;
  //
  //G4cout << theInitialState << G4endl;  
  
  // Variables to describe the excited configuration
  G4double exEnergy = theInitialState.GetExcitationEnergy();
  G4int A = theInitialState.GetA_asInt();
  G4int Z = theInitialState.GetZ_asInt();

  G4NistManager* nist = G4NistManager::Instance();
  
  // 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 );
    }  
  else  
    {      
      // JMQ 150909: first step in de-excitation is treated separately 
      // Fragments after the first step are stored in theEvapList 
      // Statistical Multifragmentation will take place only once
      //
      // move to evaporation loop
      if((A<maxAForFermiBreakUp && Z<maxZForFermiBreakUp) 
     || exEnergy <= minEForMultiFrag*A) 
    { 
      theEvapList.push_back(theInitialStatePtr); 
    }
      else  
        {
          theTempResult = theMultiFragmentation->BreakItUp(theInitialState);
      if(!theTempResult) { theEvapList.push_back(theInitialStatePtr); }
      else {
        size_t nsec = theTempResult->size();
        if(0 == nsec) { theEvapList.push_back(theInitialStatePtr); }
        else {
          // secondary are produced
          // Sort out secondary fragments
          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 {

              // check if the cold fragment is from FBU pool
              const G4VFermiFragment* ffrag = thePool->GetFragment(Z, A);
              if(ffrag) {
            if(ffrag->IsStable()) { theResults.push_back(*j); }
            else                  { theEvapList.push_back(*j); }

            // cold fragment may be unstable
              } else {
            theEvapList.push_back(*j); 
              }
            }

            // hot fragments are unstable
          } else { theEvapList.push_back(*j); } 
        }
          }
          if( deletePrimary ) { delete theInitialStatePtr; }
        }
        delete theTempResult;
      }
    }
    }
  /*
  G4cout << "## After first step " << theEvapList.size() << " for evap;  "
   << thePhotoEvapList.size() << " for photo-evap; " 
   << theResults.size() << " results. " << G4endl; 
  */
  // -----------------------------------
  // FermiBreakUp and De-excitation loop
  // -----------------------------------
      
  std::list<G4Fragment*>::iterator iList;
  for (iList = theEvapList.begin(); iList != theEvapList.end(); ++iList)
    {
      //G4cout << "Next evaporate: " << G4endl;  
      //G4cout << *iList << G4endl;  
      A = (*iList)->GetA_asInt(); 
      Z = (*iList)->GetZ_asInt();
      
      // Fermi Break-Up 
      G4bool wasFBU = false;
      if (A < maxAForFermiBreakUp && Z < maxZForFermiBreakUp) 
    {
      theTempResult = theFermiModel->BreakItUp(*(*iList));
      wasFBU = true; 
      // if initial fragment returned unchanged try to evaporate it
          if(1 == theTempResult->size()) {
            delete *(theTempResult->begin());
            delete theTempResult;
        theTempResult = theEvaporation->BreakItUp(*(*iList)); 
      }
    }
      else // apply Evaporation in another case
    {
      theTempResult = theEvaporation->BreakItUp(*(*iList));
    }
      
      G4bool deletePrimary = true;
      size_t nsec = theTempResult->size();
      //G4cout << "Nproducts= " << nsec << G4endl;  
          
      // Sort out secondary fragments
      if ( nsec > 0 ) {
    G4FragmentVector::iterator j;
    for (j = theTempResult->begin(); j != theTempResult->end(); ++j) {
      if((*j) == (*iList)) { deletePrimary = false; }

      //G4cout << *j << G4endl;  
      A = (*j)->GetA_asInt();
      exEnergy = (*j)->GetExcitationEnergy();

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

      // evaporation is not possible
      else if(1 == nsec) { 
        if(exEnergy < minExcitation) { theResults.push_back(*j); }
        else                         { thePhotoEvapList.push_back(*j); }

      } else { // Analyse fragment

        // cold fragment
        if(exEnergy < minExcitation) {
          Z = (*j)->GetZ_asInt();

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

          } else {
        const G4VFermiFragment* ffrag = thePool->GetFragment(Z, A);

        // isotope from FBU pool
        if(ffrag) {
          if(ffrag->IsStable()) { theResults.push_back(*j); }
          else                  { theEvapList.push_back(*j); }

          // isotope may be unstable
        } else {
          theEvapList.push_back(*j);
        }   
          }

          // hot fragment
        } else if (wasFBU) { 
          thePhotoEvapList.push_back(*j); // FBU applied only once 
        } else {  
          theEvapList.push_back(*j);        
        }
      }
    }
      }
      if( deletePrimary ) { delete (*iList); }
      delete theTempResult;
    } // 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
  for(iList = thePhotoEvapList.begin(); iList != thePhotoEvapList.end(); ++iList)
    {
      //G4cout << "Next photon evaporate: " << thePhotonEvaporation << G4endl;  
      //G4cout << *iList << G4endl;
      exEnergy = (*iList)->GetExcitationEnergy();

      // only hot fragments
      if(exEnergy > minExcitation) {  
    theTempResult = thePhotonEvaporation->BreakUpFragment(*iList);    
    size_t nsec = theTempResult->size();
    //G4cout << "Nproducts= " << nsec << G4endl;  
      
    // if there is a gamma emission then
    if (nsec > 0)
      {
        G4FragmentVector::iterator j;
        for (j = theTempResult->begin(); j != theTempResult->end(); ++j)
          {
        theResults.push_back(*j); 
          }
      }
    delete theTempResult;
      }

      // priamry fragment is kept
      theResults.push_back(*iList); 

    } // 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;

  std::list<G4Fragment*>::iterator i;
  for (i = theResults.begin(); i != theResults.end(); ++i) 
    {
      theFragmentA = (*i)->GetA_asInt();
      theFragmentZ = (*i)->GetZ_asInt();
      G4double etot= (*i)->GetMomentum().e();
      G4ParticleDefinition* theKindOfFragment = 0;
      if (theFragmentA == 0) {       // photon or e-
    theKindOfFragment = (*i)->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 {

    // ground state by default
        G4double eexc = (*i)->GetExcitationEnergy();
        G4double excitation = eexc;

    G4int level = 0;
    theKindOfFragment = 
      theTableOfIons->GetIon(theFragmentZ,theFragmentA,level);
    /*
    G4cout << "### Find ion Z= " << theFragmentZ << " A= " << theFragmentA
           << " Eexc(MeV)= " << excitation/MeV << "  " 
           << theKindOfFragment << G4endl;
    */
    // production of an isomer
        if(eexc > minExcitation) {
          G4double elevel1 = 0.0;
          G4double elevel2 = 0.0;
      G4ParticleDefinition* ion = 0; 
          for(level=1; level<9; ++level) {
        ion = theTableOfIons->GetIon(theFragmentZ,theFragmentA,level);
            //G4cout << level << "  " << ion << G4endl;
            if(ion) {
          G4Ions* ip = dynamic_cast<G4Ions*>(ion);
          if(ip) {
        elevel2 = ip->GetExcitationEnergy();
        //G4cout<<"   Level "<<level<<" E(MeV)= "<<elevel2/MeV<<G4endl;
        // close level
        if(std::fabs(eexc - elevel2) < minExcitation) {
          excitation = eexc - elevel2;
          theKindOfFragment = ion;
          break;
          // previous level was closer
        } else if(elevel2 - eexc >= eexc - elevel1) {
          excitation = eexc - elevel1;
          break;
          // will check next level and save current
        } else {
          theKindOfFragment = ion;
          excitation = eexc - elevel2;
          elevel1 = elevel2;
        }
          }
        } else {
          break;
        }
      }
    }
    // correction of total energy for ground state isotopes
    etot += excitation;
        G4double ionmass = theKindOfFragment->GetPDGMass();
        if(etot < ionmass) { etot = ionmass; }
      }
      if (theKindOfFragment != 0) 
    {
      G4ReactionProduct * theNew = new G4ReactionProduct(theKindOfFragment);
      theNew->SetMomentum((*i)->GetMomentum().vect());
      theNew->SetTotalEnergy(etot);
      theNew->SetFormationTime((*i)->GetCreationTime());
      theReactionProductVector->push_back(theNew);
    }
      delete (*i);
    }

  return theReactionProductVector;
}

G4VEvaporation * G4ExcitationHandler::GetEvaporation ( )

inline

Definition at line 132 of file G4ExcitationHandler.hh.

{
  return theEvaporation;
}

G4VFermiBreakUp * G4ExcitationHandler::GetFermiModel ( )

inline

Definition at line 142 of file G4ExcitationHandler.hh.

{
  return theFermiModel;
}

G4VMultiFragmentation * G4ExcitationHandler::GetMultiFragmentation ( )

inline

Definition at line 137 of file G4ExcitationHandler.hh.

{
  return theMultiFragmentation;
}

G4VEvaporationChannel * G4ExcitationHandler::GetPhotonEvaporation ( )

inline

Definition at line 147 of file G4ExcitationHandler.hh.

{
  return thePhotonEvaporation;
}

void G4ExcitationHandler::SetEvaporation

(

G4VEvaporation *

ptr

)

Definition at line 456 of file G4ExcitationHandler.cc.

References G4VEvaporation::GetPhotonEvaporation().

Referenced by B03PhysicsList::ConstructHad(), exrdmPhysListHadron::ConstructProcess(), G4EMDissociation::G4EMDissociation(), G4QMDReaction::G4QMDReaction(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4WilsonAbrasionModel::SetUseAblation().

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

void G4ExcitationHandler::SetFermiModel

(

G4VFermiBreakUp *

ptr

)

Definition at line 476 of file G4ExcitationHandler.cc.

Referenced by B03PhysicsList::ConstructHad(), exrdmPhysListHadron::ConstructProcess(), G4EMDissociation::G4EMDissociation(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4WilsonAbrasionModel::SetUseAblation().

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

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

Definition at line 503 of file G4ExcitationHandler.cc.

References SetMaxAForFermiBreakUp(), and SetMaxZForFermiBreakUp().

Referenced by B03PhysicsList::ConstructHad(), exrdmPhysListHadron::ConstructProcess(), G4EMDissociation::G4EMDissociation(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4WilsonAbrasionModel::SetUseAblation().

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

void G4ExcitationHandler::SetMaxAForFermiBreakUp

(

G4int

anA

)

Definition at line 498 of file G4ExcitationHandler.cc.

Referenced by SetMaxAandZForFermiBreakUp().

{
  maxAForFermiBreakUp = anA;
}

void G4ExcitationHandler::SetMaxZForFermiBreakUp

(

G4int

aZ

)

Definition at line 493 of file G4ExcitationHandler.cc.

Referenced by SetMaxAandZForFermiBreakUp().

{
  maxZForFermiBreakUp = aZ;
}

void G4ExcitationHandler::SetMinEForMultiFrag

(

G4double

anE

)

Definition at line 509 of file G4ExcitationHandler.cc.

Referenced by B03PhysicsList::ConstructHad(), exrdmPhysListHadron::ConstructProcess(), G4EMDissociation::G4EMDissociation(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4WilsonAbrasionModel::SetUseAblation().

{
  minEForMultiFrag = anE;
}

void G4ExcitationHandler::SetMultiFragmentation

(

G4VMultiFragmentation *

ptr

)

Definition at line 468 of file G4ExcitationHandler.cc.

Referenced by B03PhysicsList::ConstructHad(), exrdmPhysListHadron::ConstructProcess(), G4EMDissociation::G4EMDissociation(), G4WilsonAbrasionModel::G4WilsonAbrasionModel(), and G4WilsonAbrasionModel::SetUseAblation().

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

void G4ExcitationHandler::SetOPTxs ( G4int  opt )

inline

Definition at line 152 of file G4ExcitationHandler.hh.

{ 
  OPTxs = opt; 
  SetParameters();
}

void G4ExcitationHandler::SetPhotonEvaporation

(

G4VEvaporationChannel *

ptr

)

Definition at line 485 of file G4ExcitationHandler.cc.

References G4VEvaporation::SetPhotonEvaporation().

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

void G4ExcitationHandler::UseSICB ( )

inline

Definition at line 158 of file G4ExcitationHandler.hh.

{ 
  useSICB = true; 
  SetParameters();
}

---

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

• G4ExcitationHandler.hh
• G4ExcitationHandler.cc