G4EMDissociation Class Reference

#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 G4HadFinalState *	ApplyYourself (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
virtual G4double	SampleInvariantT (const G4ParticleDefinition *p, G4double plab, G4int Z, G4int A)
virtual G4bool	IsApplicable (const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
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)
G4int	GetVerboseLevel () const
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
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
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	InitialiseModel ()
	G4HadronicInteraction (const G4HadronicInteraction &right)=delete
const G4HadronicInteraction &	operator= (const G4HadronicInteraction &right)=delete
G4bool	operator== (const G4HadronicInteraction &right) const =delete
G4bool	operator!= (const G4HadronicInteraction &right) const =delete

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() [1/3]

G4EMDissociation::G4EMDissociation

(

)

Definition at line 78 of file G4EMDissociation.cc.

                                  :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;
  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() [2/3]

G4EMDissociation::G4EMDissociation

(

const G4EMDissociation &

emd

)

G4EMDissociation() [3/3]

G4EMDissociation::G4EMDissociation

(

G4ExcitationHandler *

aExcitationHandler

)

Definition at line 103 of file G4EMDissociation.cc.

{
  // 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::~G4EMDissociation

(

)

Definition at line 125 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

ApplyYourself()

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

virtual

Reimplemented from G4HadronicInteraction.

Definition at line 134 of file G4EMDissociation.cc.

{
  // 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 = G4IonTable::GetIonTable()->
      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 = G4IonTable::GetIonTable()->
      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( std::sqrt( pP.vect().mag2() + (mass + Eg)*(mass + 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 = G4IonTable::GetIonTable()->
      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 = G4IonTable::GetIonTable()->
      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 (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(), false);
 
  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;
 
  delete crossSectionP;
  delete crossSectionT;
 
  if (verboseLevel >= 2)
    G4cout <<"########################################"
           <<"########################################"
           <<G4endl;
 
  return &theParticleChange;
}

operator=()

const G4EMDissociation & G4EMDissociation::operator=

(

G4EMDissociation &

right

)

---

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

• G4EMDissociation.hh
• G4EMDissociation.cc