G4PreCompoundModel Class Reference

#include <G4PreCompoundModel.hh>

Inheritance diagram for G4PreCompoundModel:

Public Member Functions
	G4PreCompoundModel (G4ExcitationHandler *ptr=0)
virtual	~G4PreCompoundModel ()
virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &thePrimary, G4Nucleus &theNucleus)
virtual G4ReactionProductVector *	DeExcite (G4Fragment &aFragment)
virtual void	ModelDescription (std::ostream &outFile) const
void	UseHETCEmission ()
void	UseDefaultEmission ()
void	UseGNASHTransition ()
void	UseDefaultTransition ()
void	SetOPTxs (G4int opt)
void	UseSICB ()
void	UseNGB ()
void	UseSCO ()
void	UseCEMtr ()

---

Detailed Description

Definition at line 64 of file G4PreCompoundModel.hh.

---

Constructor & Destructor Documentation

G4PreCompoundModel::G4PreCompoundModel

(

G4ExcitationHandler *

ptr = 0

)

Definition at line 66 of file G4PreCompoundModel.cc.

References G4PreCompoundParameters::GetAddress(), G4Neutron::Neutron(), G4Proton::Proton(), G4PreCompoundEmission::SetDefaultModel(), G4VPreCompoundModel::SetExcitationHandler(), G4PreCompoundEmission::SetHETCModel(), G4PreCompoundEmission::SetOPTxs(), G4VPreCompoundTransitions::UseCEMtr(), G4VPreCompoundTransitions::UseNGB(), and G4PreCompoundEmission::UseSICB().

  : G4VPreCompoundModel(ptr,"PRECO"), useHETCEmission(false), 
    useGNASHTransition(false), OPTxs(3), useSICB(false), 
    useNGB(false), useSCO(false), useCEMtr(true), maxZ(3), maxA(5) 
                                      //maxZ(9), maxA(17)
{
  if(!ptr) { SetExcitationHandler(new G4ExcitationHandler()); }
  theParameters = G4PreCompoundParameters::GetAddress();

  theEmission = new G4PreCompoundEmission();
  if(useHETCEmission) { theEmission->SetHETCModel(); }
  else { theEmission->SetDefaultModel(); }
  theEmission->SetOPTxs(OPTxs);
  theEmission->UseSICB(useSICB);

  if(useGNASHTransition) { theTransition = new G4GNASHTransitions; }
  else { theTransition = new G4PreCompoundTransitions(); }
  theTransition->UseNGB(useNGB);
  theTransition->UseCEMtr(useCEMtr);

  proton = G4Proton::Proton();
  neutron = G4Neutron::Neutron();
}

G4PreCompoundModel::~G4PreCompoundModel

(

)

[virtual]

Definition at line 90 of file G4PreCompoundModel.cc.

References G4VPreCompoundModel::GetExcitationHandler().

{
  delete theEmission;
  delete theTransition;
  delete GetExcitationHandler();
}

---

Member Function Documentation

G4HadFinalState * G4PreCompoundModel::ApplyYourself	(	const G4HadProjectile &	thePrimary,
		G4Nucleus &	theNucleus
	)			[virtual]

Implements G4VPreCompoundModel.

Definition at line 121 of file G4PreCompoundModel.cc.

References G4HadFinalState::AddSecondary(), G4HadFinalState::Clear(), DeExcite(), G4endl, G4HadProjectile::Get4Momentum(), G4Nucleus::GetA_asInt(), G4HadProjectile::GetDefinition(), G4HadProjectile::GetGlobalTime(), G4NucleiProperties::GetNuclearMass(), G4ParticleDefinition::GetParticleName(), G4Nucleus::GetZ_asInt(), G4Fragment::SetCreationTime(), G4Fragment::SetNumberOfExcitedParticle(), G4Fragment::SetNumberOfHoles(), G4HadFinalState::SetStatusChange(), and stopAndKill.

{  
  const G4ParticleDefinition* primary = thePrimary.GetDefinition();
  if(primary != neutron && primary != proton) {
    std::ostringstream errOs;
    errOs << "BAD primary type in G4PreCompoundModel: " 
          << primary->GetParticleName() <<G4endl;
    throw G4HadronicException(__FILE__, __LINE__, errOs.str());
  }

  G4int Zp = 0;
  G4int Ap = 1;
  if(primary == proton) { Zp = 1; }

  G4int A = theNucleus.GetA_asInt();
  G4int Z = theNucleus.GetZ_asInt();
   
  //G4cout << "### G4PreCompoundModel::ApplyYourself: A= " << A << " Z= " << Z
  //     << " Ap= " << Ap << " Zp= " << Zp << G4endl; 
  // 4-Momentum
  G4LorentzVector p = thePrimary.Get4Momentum();
  G4double mass = G4NucleiProperties::GetNuclearMass(A, Z);
  p += G4LorentzVector(0.0,0.0,0.0,mass);
  //G4cout << "Primary 4-mom " << p << "  mass= " << mass << G4endl;

  // prepare fragment
  G4Fragment anInitialState(A + Ap, Z + Zp, p);

  // projectile and target nucleons
  // Add nucleon on which interaction happens
  //++Ap;
  //if(A*G4UniformRand() <= G4double(Z)) { Zp += 1; }
  anInitialState.SetNumberOfExcitedParticle(2, 1);
  anInitialState.SetNumberOfHoles(1,0);
  //  anInitialState.SetNumberOfExcitedParticle(Ap, Zp);
  // anInitialState.SetNumberOfHoles(Ap,Zp);

  anInitialState.SetCreationTime(thePrimary.GetGlobalTime());
  
  // call excitation handler
  G4ReactionProductVector * result = DeExcite(anInitialState);

  // fill particle change
  theResult.Clear();
  theResult.SetStatusChange(stopAndKill);
  for(G4ReactionProductVector::iterator i= result->begin(); i != result->end(); ++i)
    {
      G4DynamicParticle * aNew = 
        new G4DynamicParticle((*i)->GetDefinition(),
                              (*i)->GetTotalEnergy(),
                              (*i)->GetMomentum());
      delete (*i);
      theResult.AddSecondary(aNew);
    }
  delete result;
  
  //return the filled particle change
  return &theResult;
}

G4ReactionProductVector * G4PreCompoundModel::DeExcite

(

G4Fragment &

aFragment

)

[virtual]

Implements G4VPreCompoundModel.

Definition at line 184 of file G4PreCompoundModel.cc.

References G4VPreCompoundTransitions::CalculateProbability(), G4lrint(), G4UniformRand, G4Fragment::GetA_asInt(), G4Fragment::GetExcitationEnergy(), G4PreCompoundParameters::GetLevelDensity(), G4Fragment::GetNumberOfExcitons(), G4PreCompoundEmission::GetTotalProbability(), G4VPreCompoundTransitions::GetTransitionProb1(), G4VPreCompoundTransitions::GetTransitionProb2(), G4VPreCompoundTransitions::GetTransitionProb3(), G4Fragment::GetZ_asInt(), G4PreCompoundEmission::Initialize(), G4PreCompoundEmission::PerformEmission(), and G4VPreCompoundTransitions::PerformTransition().

Referenced by ApplyYourself(), and G4LowEIonFragmentation::ApplyYourself().

{
  G4ReactionProductVector * Result = new G4ReactionProductVector;
  G4double Eex = aFragment.GetExcitationEnergy();
  G4int Z = aFragment.GetZ_asInt(); 
  G4int A = aFragment.GetA_asInt(); 

  //G4cout << "### G4PreCompoundModel::DeExcite" << G4endl;
  //G4cout << aFragment << G4endl;
 
  // Perform Equilibrium Emission 
  if ((Z < maxZ && A < maxA) || Eex < MeV /*|| Eex > 3.*MeV*A*/) {
    PerformEquilibriumEmission(aFragment, Result);
    return Result;
  }
  
  // main loop  
  for (;;) {
    
    //fragment++;
    //G4cout<<"-------------------------------------------------------------------"<<G4endl;
    //G4cout<<"Fragment number .. "<<fragment<<G4endl;
    
    // Initialize fragment according with the nucleus parameters
    //G4cout << "### Loop over fragment" << G4endl;
    //G4cout << aFragment << G4endl;

    theEmission->Initialize(aFragment);
    
    G4double gg = (6.0/pi2)*aFragment.GetA_asInt()*theParameters->GetLevelDensity();
    
    G4int EquilibriumExcitonNumber = 
      G4lrint(std::sqrt(2*gg*aFragment.GetExcitationEnergy()));
    //   
    //    G4cout<<"Neq="<<EquilibriumExcitonNumber<<G4endl;
    //
    // J. M. Quesada (Jan. 08)  equilibrium hole number could be used as preeq.
    // evap. delimiter (IAEA report)
    
    // Loop for transitions, it is performed while there are preequilibrium transitions.
    G4bool ThereIsTransition = false;
    
    //        G4cout<<"----------------------------------------"<<G4endl;
    //        G4double NP=aFragment.GetNumberOfParticles();
    //        G4double NH=aFragment.GetNumberOfHoles();
    //        G4double NE=aFragment.GetNumberOfExcitons();
    //        G4cout<<" Ex. Energy="<<aFragment.GetExcitationEnergy()<<G4endl;
    //        G4cout<<"N. excitons="<<NE<<"  N. Part="<<NP<<"N. Holes ="<<NH<<G4endl;
    //G4int transition=0;
    do {
      //transition++;
      //G4cout<<"transition number .."<<transition<<G4endl;
      //G4cout<<" n ="<<aFragment.GetNumberOfExcitons()<<G4endl;
      G4bool go_ahead = false;
      // soft cutoff criterium as an "ad-hoc" solution to force increase in  evaporation  
      G4int test = aFragment.GetNumberOfExcitons();
      if (test <= EquilibriumExcitonNumber) { go_ahead=true; }

      //J. M. Quesada (Apr. 08): soft-cutoff switched off by default
      if (useSCO && !go_ahead)
        {
          G4double x = G4double(test)/G4double(EquilibriumExcitonNumber) - 1;
          if( G4UniformRand() < 1.0 -  std::exp(-x*x/0.32) ) { go_ahead = true; }
        } 
        
      // JMQ: WARNING:  CalculateProbability MUST be called prior to Get methods !! 
      // (O values would be returned otherwise)
      G4double TotalTransitionProbability = 
        theTransition->CalculateProbability(aFragment);
      G4double P1 = theTransition->GetTransitionProb1();
      G4double P2 = theTransition->GetTransitionProb2();
      G4double P3 = theTransition->GetTransitionProb3();
      //G4cout<<"#0 P1="<<P1<<" P2="<<P2<<"  P3="<<P3<<G4endl;
      
      //J.M. Quesada (May 2008) Physical criterium (lamdas)  PREVAILS over 
      //                        approximation (critical exciton number)
      //V.Ivanchenko (May 2011) added check on number of nucleons
      //                        to send a fragment to FermiBreakUp
      if(!go_ahead || P1 <= P2+P3 || 
         (aFragment.GetZ_asInt() < maxZ && aFragment.GetA_asInt() < maxA) )        
        {
          //G4cout<<"#4 EquilibriumEmission"<<G4endl; 
          PerformEquilibriumEmission(aFragment,Result);
          return Result;
        }
      else 
        {
          G4double TotalEmissionProbability = 
            theEmission->GetTotalProbability(aFragment);
          //
          //G4cout<<"#1 TotalEmissionProbability="<<TotalEmissionProbability<<" Nex= " 
          //    <<aFragment.GetNumberOfExcitons()<<G4endl;
          //
          // Check if number of excitons is greater than 0
          // else perform equilibrium emission
          if (aFragment.GetNumberOfExcitons() <= 0) 
            {
              PerformEquilibriumEmission(aFragment,Result);
              return Result;
            }
            
          //J.M.Quesada (May 08) this has already been done in order to decide  
          //                     what to do (preeq-eq) 
          // Sum of all probabilities
          G4double TotalProbability = TotalEmissionProbability 
            + TotalTransitionProbability;
            
          // Select subprocess
          if (TotalProbability*G4UniformRand() > TotalEmissionProbability) 
            {
              //G4cout<<"#2 Transition"<<G4endl; 
              // It will be transition to state with a new number of excitons
              ThereIsTransition = true;         
              // Perform the transition
              theTransition->PerformTransition(aFragment);
            } 
          else 
            {
              //G4cout<<"#3 Emission"<<G4endl; 
              // It will be fragment emission
              ThereIsTransition = false;
              Result->push_back(theEmission->PerformEmission(aFragment));
            }
        }
    } while (ThereIsTransition);   // end of do loop
  } // end of for (;;) loop
  return Result;
}

void G4PreCompoundModel::ModelDescription

(

std::ostream &

outFile

)

const [virtual]

Reimplemented from G4HadronicInteraction.

Definition at line 97 of file G4PreCompoundModel.cc.

{
        outFile << "The GEANT4 precompound model is considered as an extension of the\n"
                <<      "hadron kinetic model. It gives a possibility to extend the low energy range\n"
                <<      "of the hadron kinetic model for nucleon-nucleus inelastic collision and it \n"
                <<      "provides a ”smooth” transition from kinetic stage of reaction described by the\n"
                <<      "hadron kinetic model to the equilibrium stage of reaction described by the\n"
                <<      "equilibrium deexcitation models.\n"
                <<      "The initial information for calculation of pre-compound nuclear stage\n"
                <<      "consists of the atomic mass number A, charge Z of residual nucleus, its\n"
                <<      "four momentum P0 , excitation energy U and number of excitons n, which equals\n"
                <<      "the sum of the number of particles p (from them p_Z are charged) and the number of\n"
                <<      "holes h.\n"
                <<      "At the preequilibrium stage of reaction, we follow the exciton model approach in ref. [1],\n"
                <<      "taking into account the competition among all possible nuclear transitions\n"
                <<      "with ∆n = +2, −2, 0 (which are defined by their associated transition probabilities) and\n"
                <<      "the emission of neutrons, protons, deutrons, thritium and helium nuclei (also defined by\n"
                <<      "their associated emission  probabilities according to exciton model)\n"
                <<      "\n"
                <<      "[1] K.K. Gudima, S.G. Mashnik, V.D. Toneev, Nucl. Phys. A401 329 (1983)\n"
                << std::endl;
}

void G4PreCompoundModel::SetOPTxs

(

G4int

opt

)

Definition at line 345 of file G4PreCompoundModel.cc.

References G4PreCompoundEmission::SetOPTxs().

{ 
  OPTxs = opt; 
  theEmission->SetOPTxs(OPTxs);
}

void G4PreCompoundModel::UseCEMtr

(

)

Definition at line 367 of file G4PreCompoundModel.cc.

{ 
  useCEMtr = true; 
}

void G4PreCompoundModel::UseDefaultEmission

(

)

Definition at line 323 of file G4PreCompoundModel.cc.

References G4PreCompoundEmission::SetDefaultModel().

{ 
  useHETCEmission = false; 
  theEmission->SetDefaultModel();
}

void G4PreCompoundModel::UseDefaultTransition

(

)

Definition at line 337 of file G4PreCompoundModel.cc.

References G4VPreCompoundTransitions::UseCEMtr(), and G4VPreCompoundTransitions::UseNGB().

                                              { 
  useGNASHTransition = false; 
  delete theTransition;
  theTransition = new G4PreCompoundTransitions();
  theTransition->UseNGB(useNGB);
  theTransition->UseCEMtr(useCEMtr);
}

void G4PreCompoundModel::UseGNASHTransition

(

)

Definition at line 329 of file G4PreCompoundModel.cc.

References G4VPreCompoundTransitions::UseCEMtr(), and G4VPreCompoundTransitions::UseNGB().

                                            { 
  useGNASHTransition = true; 
  delete theTransition;
  theTransition = new G4GNASHTransitions;
  theTransition->UseNGB(useNGB);
  theTransition->UseCEMtr(useCEMtr);
}

void G4PreCompoundModel::UseHETCEmission

(

)

Definition at line 317 of file G4PreCompoundModel.cc.

References G4PreCompoundEmission::SetHETCModel().

{ 
  useHETCEmission = true; 
  theEmission->SetHETCModel();
}

void G4PreCompoundModel::UseNGB

(

)

Definition at line 357 of file G4PreCompoundModel.cc.

{ 
  useNGB = true; 
}

void G4PreCompoundModel::UseSCO

(

)

Definition at line 362 of file G4PreCompoundModel.cc.

{ 
  useSCO = true; 
}

void G4PreCompoundModel::UseSICB

(

)

Definition at line 351 of file G4PreCompoundModel.cc.

References G4PreCompoundEmission::UseSICB().

{ 
  useSICB = true; 
  theEmission->UseSICB(useSICB);
}

---

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

• G4PreCompoundModel.hh
• G4PreCompoundModel.cc

---