#include <G4EMDissociation.hh>

Inheritance diagram for G4EMDissociation:

Public Member Functions
	G4EMDissociation ()

	G4EMDissociation (const G4EMDissociation &emd)

	G4EMDissociation (G4ExcitationHandler *)

	~G4EMDissociation ()

const G4EMDissociation &	operator= (G4EMDissociation &right)

virtual G4HadFinalState *	ApplyYourself (const G4HadProjectile &, G4Nucleus &)

Public Member Functions inherited from G4HadronicInteraction
	G4HadronicInteraction (const G4String &modelName="HadronicModel")

virtual	~G4HadronicInteraction ()

virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)

virtual G4bool	IsApplicable (const G4HadProjectile &, G4Nucleus &)

G4double	GetMinEnergy () const

G4double	GetMinEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMinEnergy (G4double anEnergy)

void	SetMinEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMinEnergy (G4double anEnergy, const G4Material *aMaterial)

G4double	GetMaxEnergy () const

G4double	GetMaxEnergy (const G4Material aMaterial, const G4Element anElement) const

void	SetMaxEnergy (const G4double anEnergy)

void	SetMaxEnergy (G4double anEnergy, const G4Element *anElement)

void	SetMaxEnergy (G4double anEnergy, const G4Material *aMaterial)

const G4HadronicInteraction *	GetMyPointer () const

virtual G4int	GetVerboseLevel () const

virtual void	SetVerboseLevel (G4int value)

const G4String &	GetModelName () const

void	DeActivateFor (const G4Material *aMaterial)

void	ActivateFor (const G4Material *aMaterial)

void	DeActivateFor (const G4Element *anElement)

void	ActivateFor (const G4Element *anElement)

G4bool	IsBlocked (const G4Material *aMaterial) const

G4bool	IsBlocked (const G4Element *anElement) const

void	SetRecoilEnergyThreshold (G4double val)

G4double	GetRecoilEnergyThreshold () const

G4bool	operator== (const G4HadronicInteraction &right) const

G4bool	operator!= (const G4HadronicInteraction &right) const

virtual const std::pair < G4double, G4double >	GetFatalEnergyCheckLevels () const

virtual std::pair< G4double, G4double >	GetEnergyMomentumCheckLevels () const

void	SetEnergyMomentumCheckLevels (G4double relativeLevel, G4double absoluteLevel)

virtual void	ModelDescription (std::ostream &outFile) const

Additional Inherited Members
Protected Member Functions inherited from G4HadronicInteraction
void	SetModelName (const G4String &nam)

G4bool	IsBlocked () const

void	Block ()

Protected Attributes inherited from G4HadronicInteraction
G4HadFinalState	theParticleChange

G4int	verboseLevel

G4double	theMinEnergy

G4double	theMaxEnergy

G4bool	isBlocked

Detailed Description

Definition at line 78 of file G4EMDissociation.hh.

Constructor & Destructor Documentation

G4EMDissociation::G4EMDissociation ( )

Definition at line 83 of file G4EMDissociation.cc.

References python.hepunit::GeV, python.hepunit::MeV, G4ExcitationHandler::SetEvaporation(), G4ExcitationHandler::SetFermiModel(), G4ExcitationHandler::SetMaxAandZForFermiBreakUp(), G4HadronicInteraction::SetMaxEnergy(), G4ExcitationHandler::SetMinEForMultiFrag(), G4HadronicInteraction::SetMinEnergy(), G4ExcitationHandler::SetMultiFragmentation(), and G4HadronicInteraction::verboseLevel.

                                   :G4HadronicInteraction("EMDissociation") {
 
   // Send message to stdout to advise that the G4EMDissociation model is being
   // used.
   PrintWelcomeMessage();
 
   // No de-excitation handler has been supplied - define the default handler.
   theExcitationHandler            = new G4ExcitationHandler;
   G4Evaporation* theEvaporation   = new G4Evaporation;
   G4FermiBreakUp* theFermiBreakUp = new G4FermiBreakUp;
   G4StatMF* theMF                 = new G4StatMF;
   theExcitationHandler->SetEvaporation(theEvaporation);
   theExcitationHandler->SetFermiModel(theFermiBreakUp);
   theExcitationHandler->SetMultiFragmentation(theMF);
   theExcitationHandler->SetMaxAandZForFermiBreakUp(12, 6);
   theExcitationHandler->SetMinEForMultiFrag(5.0*MeV);
   handlerDefinedInternally = true;
 
   // This EM dissociation model needs access to the cross-sections held in
   // G4EMDissociationCrossSection.
   dissociationCrossSection = new G4EMDissociationCrossSection;
   thePhotonSpectrum = new G4EMDissociationSpectrum;
 
   // Set the minimum and maximum range for the model (despite nomanclature, this
   // is in energy per nucleon number).    
   SetMinEnergy(100.0*MeV);
   SetMaxEnergy(500.0*GeV);
 
   // Set the default verbose level to 0 - no output.
   verboseLevel = 0;
 }

G4EMDissociation::G4EMDissociation ( const G4EMDissociation & emd )

G4EMDissociation::G4EMDissociation ( G4ExcitationHandler * aExcitationHandler )

Definition at line 137 of file G4EMDissociation.cc.

References python.hepunit::GeV, python.hepunit::MeV, G4HadronicInteraction::SetMaxEnergy(), G4HadronicInteraction::SetMinEnergy(), and G4HadronicInteraction::verboseLevel.

 {
   // Send message to stdout to advise that the G4EMDissociation model is being
   // used.
   PrintWelcomeMessage();
   
   theExcitationHandler     = aExcitationHandler;
   handlerDefinedInternally = false;
 
   // This EM dissociation model needs access to the cross-sections held in
   // G4EMDissociationCrossSection.
   dissociationCrossSection = new G4EMDissociationCrossSection;
   thePhotonSpectrum = new G4EMDissociationSpectrum;
 
   // Set the minimum and maximum range for the model (despite nomanclature, this
   // is in energy per nucleon number)    
   SetMinEnergy(100.0*MeV);
   SetMaxEnergy(500.0*GeV);
   verboseLevel = 0;
 }

G4EMDissociation::~G4EMDissociation ( )

Definition at line 159 of file G4EMDissociation.cc.

                                     {
   if (handlerDefinedInternally) delete theExcitationHandler;
   // delete dissociationCrossSection;
   // Cross section deleted by G4CrossSectionRegistry; don't do it here
   // Bug reported by Gong Ding in Bug Report #1339
   delete thePhotonSpectrum;
 }

Member Function Documentation

G4HadFinalState * G4EMDissociation::ApplyYourself	(	const G4HadProjectile &	theTrack,
		G4Nucleus &	theTarget
	)

virtual

Implements G4HadronicInteraction.

Definition at line 169 of file G4EMDissociation.cc.

References test::b, CLHEP::HepLorentzVector::beta(), CLHEP::HepLorentzVector::boost(), G4HadFinalState::Clear(), G4DynamicParticle::DumpInfo(), CLHEP::HepLorentzVector::e(), python.hepunit::eV, CLHEP::HepLorentzVector::findBoostToCM(), G4cout, G4endl, G4UniformRand, G4HadProjectile::Get4Momentum(), G4DynamicParticle::Get4Momentum(), G4Nucleus::GetA_asInt(), G4ParticleDefinition::GetBaryonNumber(), G4HadProjectile::GetDefinition(), G4HadProjectile::GetKineticEnergy(), G4NucleiProperties::GetNuclearMass(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4HadProjectile::GetTotalEnergy(), G4Nucleus::GetZ_asInt(), G4Neutron::NeutronDefinition(), python.hepunit::pi, G4InuclParticleNames::pp, G4Proton::ProtonDefinition(), python.hepunit::rad, G4DynamicParticle::Set4Momentum(), CLHEP::HepLorentzVector::setE(), CLHEP::Hep3Vector::setMag(), stopAndKill, test::v, and CLHEP::HepLorentzVector::vect().

 {
   // The secondaries will be returned in G4HadFinalState &theParticleChange -
   // initialise this.
 
   theParticleChange.Clear();
   theParticleChange.SetStatusChange(stopAndKill);
 
   // Get relevant information about the projectile and target (A, Z) and
   // energy/nuc, momentum, velocity, Lorentz factor and rest-mass of the
   // projectile.
 
   const G4ParticleDefinition *definitionP = theTrack.GetDefinition();
   const G4double AP  = definitionP->GetBaryonNumber();
   const G4double ZP  = definitionP->GetPDGCharge();
   G4LorentzVector pP = theTrack.Get4Momentum();
   G4double E         = theTrack.GetKineticEnergy()/AP;
   G4double MP        = theTrack.GetTotalEnergy() - E*AP;
   G4double b         = pP.beta();
   G4double AT        = theTarget.GetA_asInt();
   G4double ZT        = theTarget.GetZ_asInt();
   G4double MT        = G4NucleiProperties::GetNuclearMass(AT,ZT);
 
   // Depending upon the verbosity level, output the initial information on the
   // projectile and target
   if (verboseLevel >= 2) {
     G4cout.precision(6);
     G4cout <<"########################################"
            <<"########################################"
            <<G4endl;
     G4cout <<"IN G4EMDissociation" <<G4endl;
     G4cout <<"Initial projectile A=" <<AP 
            <<", Z=" <<ZP
            <<G4endl; 
     G4cout <<"Initial target     A=" <<AT
            <<", Z=" <<ZT
            <<G4endl;
     G4cout <<"Projectile momentum and Energy/nuc = " <<pP <<" ," <<E <<G4endl;
   }
 
   // Initialise the variables which will be used with the phase-space decay and
   // to boost the secondaries from the interaction.
   
   G4ParticleDefinition *typeNucleon  = NULL;
   G4ParticleDefinition *typeDaughter = NULL;
   G4double Eg                        = 0.0;
   G4double mass                      = 0.0;
   G4ThreeVector boost = G4ThreeVector(0.0, 0.0, 0.0);
 
   // Determine the cross-sections at the giant dipole and giant quadrupole
   // resonance energies for the projectile and then target.  The information is
   // initially provided in the G4PhysicsFreeVector individually for the E1
   // and E2 fields. These are then summed.
 
   G4double bmin = thePhotonSpectrum->GetClosestApproach(AP, ZP, AT, ZT, b);
   G4PhysicsFreeVector *crossSectionP = dissociationCrossSection->
     GetCrossSectionForProjectile(AP, ZP, AT, ZT, b, bmin);
   G4PhysicsFreeVector *crossSectionT = dissociationCrossSection->
     GetCrossSectionForTarget(AP, ZP, AT, ZT, b, bmin);
 
   G4double totCrossSectionP = (*crossSectionP)[0]+(*crossSectionP)[1];
   G4double totCrossSectionT = (*crossSectionT)[0]+(*crossSectionT)[1];
 
   // Now sample whether the interaction involved EM dissociation of the projectile
   // or the target.
 
   if (G4UniformRand() <
     totCrossSectionP / (totCrossSectionP + totCrossSectionT)) {
 
     // It was the projectile which underwent EM dissociation.  Define the Lorentz
     // boost to be applied to the secondaries, and sample whether a proton or a
     // neutron was ejected.  Then determine the energy of the virtual gamma ray
     // which passed from the target nucleus ... this will be used to define the
     // excitation of the projectile.
 
     mass  = MP;
     if (G4UniformRand() < dissociationCrossSection->
       GetWilsonProbabilityForProtonDissociation (AP, ZP))
     {
       if (verboseLevel >= 2)
         G4cout <<"Projectile underwent EM dissociation producing a proton"
                <<G4endl;
       typeNucleon = G4Proton::ProtonDefinition();
       typeDaughter = G4ParticleTable::GetParticleTable()->
       GetIon((G4int) ZP-1, (G4int) AP-1, 0.0);
     }
     else
     {
       if (verboseLevel >= 2)
         G4cout <<"Projectile underwent EM dissociation producing a neutron"
                <<G4endl;
       typeNucleon = G4Neutron::NeutronDefinition();
       typeDaughter = G4ParticleTable::GetParticleTable()->
       GetIon((G4int) ZP, (G4int) AP-1, 0.0);
     }
     if (G4UniformRand() < (*crossSectionP)[0]/totCrossSectionP)
     {
       Eg = crossSectionP->GetLowEdgeEnergy(0);
       if (verboseLevel >= 2)
         G4cout <<"Transition type was E1" <<G4endl;
     }
     else
     {
       Eg = crossSectionP->GetLowEdgeEnergy(1);
       if (verboseLevel >= 2)
         G4cout <<"Transition type was E2" <<G4endl;
     }
 
     // We need to define a Lorentz vector with the original momentum, but total
     // energy includes the projectile and virtual gamma.  This is then used
     // to calculate the boost required for the secondaries.
 
     pP.setE(pP.e()+Eg);
     boost = pP.findBoostToCM();
   }
   else
   {
     // It was the target which underwent EM dissociation.  Sample whether a
     // proton or a neutron was ejected.  Then determine the energy of the virtual 
     // gamma ray which passed from the projectile nucleus ... this will be used to
     // define the excitation of the target.
 
     mass = MT;
     if (G4UniformRand() < dissociationCrossSection->
       GetWilsonProbabilityForProtonDissociation (AT, ZT))
     {
       if (verboseLevel >= 2)
         G4cout <<"Target underwent EM dissociation producing a proton"
                <<G4endl;
       typeNucleon = G4Proton::ProtonDefinition();
       typeDaughter = G4ParticleTable::GetParticleTable()->
       GetIon((G4int) ZT-1, (G4int) AT-1, 0.0);
     }
     else
     {
       if (verboseLevel >= 2)
         G4cout <<"Target underwent EM dissociation producing a neutron"
                <<G4endl;
       typeNucleon = G4Neutron::NeutronDefinition();
       typeDaughter = G4ParticleTable::GetParticleTable()->
       GetIon((G4int) ZT, (G4int) AT-1, 0.0);
     }
     if (G4UniformRand() < (*crossSectionT)[0]/totCrossSectionT)
     {
       Eg = crossSectionT->GetLowEdgeEnergy(0);
       if (verboseLevel >= 2)
         G4cout <<"Transition type was E1" <<G4endl;
     }
     else
     {
       Eg = crossSectionT->GetLowEdgeEnergy(1);
       if (verboseLevel >= 2)
         G4cout <<"Transition type was E2" <<G4endl;
     }
 
     // Add the projectile to theParticleChange, less the energy of the
     // not-so-virtual gamma-ray.  Not that at the moment, no lateral momentum
     // is transferred between the projectile and target nuclei.
 
     G4ThreeVector v = pP.vect();
     v.setMag(1.0);
     G4DynamicParticle *changedP = new G4DynamicParticle
       (const_cast<G4ParticleDefinition*>(definitionP), v, E*AP-Eg);
     theParticleChange.AddSecondary (changedP);
     if (verboseLevel >= 2)
     {
       G4cout <<"Projectile change:" <<G4endl;
       changedP->DumpInfo();
     }
   }
 
   // Perform a two-body decay based on the restmass energy of the parent and
   // gamma-ray, and the masses of the daughters. In the frame of reference of
   // the nucles, the angular distribution is sampled isotropically, but the
   // the nucleon and secondary nucleus are boosted if they've come from the
   // projectile.
 
   G4double e  = mass + Eg;
   G4double mass1 = typeNucleon->GetPDGMass();
   G4double mass2 = typeDaughter->GetPDGMass();
   G4double pp = (e+mass1+mass2)*(e+mass1-mass2)*
                 (e-mass1+mass2)*(e-mass1-mass2)/(4.0*e*e);
   if (pp < 0.0) {
     pp = 1.0*eV;
 //    if (verboseLevel >`= 1)
 //    {
 //      G4cout <<"IN G4EMDissociation::ApplyYoursef" <<G4endl;
 //      G4cout <<"Error in mass of secondaries compared with primary:" <<G4endl;
 //      G4cout <<"Rest mass of primary      = " <<mass <<" MeV" <<G4endl;
 //      G4cout <<"Virtual gamma energy      = " <<Eg   <<" MeV" <<G4endl;
 //      G4cout <<"Rest mass of secondary #1 = " <<mass1   <<" MeV" <<G4endl;
 //      G4cout <<"Rest mass of secondary #2 = " <<mass2   <<" MeV" <<G4endl;
 //    }
   }
   else
     pp = std::sqrt(pp);
   G4double costheta = 2.*G4UniformRand()-1.0;
   G4double sintheta = std::sqrt((1.0 - costheta)*(1.0 + costheta));
   G4double phi      = 2.0*pi*G4UniformRand()*rad;
   G4ThreeVector direction(sintheta*std::cos(phi),sintheta*std::sin(phi),costheta);
   G4DynamicParticle *dynamicNucleon =
     new G4DynamicParticle(typeNucleon, direction*pp);
   dynamicNucleon->Set4Momentum(dynamicNucleon->Get4Momentum().boost(-boost));
   G4DynamicParticle *dynamicDaughter =
     new G4DynamicParticle(typeDaughter, -direction*pp);
   dynamicDaughter->Set4Momentum(dynamicDaughter->Get4Momentum().boost(-boost));
 
   // The "decay" products have to be transferred to the G4HadFinalState object.
   // Furthermore, the residual nucleus should be de-excited.
 
   theParticleChange.AddSecondary (dynamicNucleon);
   if (verboseLevel >= 2) {
     G4cout <<"Nucleon from the EMD process:" <<G4endl;
     dynamicNucleon->DumpInfo();
   }
 
   G4Fragment* theFragment = new
     G4Fragment((G4int) typeDaughter->GetBaryonNumber(),
     (G4int) typeDaughter->GetPDGCharge(), dynamicDaughter->Get4Momentum());
 
   if (verboseLevel >= 2) {
     G4cout <<"Dynamic properties of the prefragment:" <<G4endl;
     G4cout.precision(6);
     dynamicDaughter->DumpInfo();
     G4cout <<"Nuclear properties of the prefragment:" <<G4endl;
     G4cout <<theFragment <<G4endl;
   }
 
   G4ReactionProductVector* products =
                       theExcitationHandler->BreakItUp(*theFragment);
   delete theFragment;
   theFragment = NULL;
   
   G4DynamicParticle* secondary = 0;
   G4ReactionProductVector::iterator iter;
   for (iter = products->begin(); iter != products->end(); ++iter) {
     secondary = new G4DynamicParticle((*iter)->GetDefinition(),
     (*iter)->GetTotalEnergy(), (*iter)->GetMomentum());
     theParticleChange.AddSecondary (secondary);
   }
   delete products;
 
   if (verboseLevel >= 2)
     G4cout <<"########################################"
            <<"########################################"
            <<G4endl;
  
   return &theParticleChange;
 }

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation