G4PiNuclearCrossSection Class Reference

#include <G4PiNuclearCrossSection.hh>

Inheritance diagram for G4PiNuclearCrossSection:

Public Member Functions
	G4PiNuclearCrossSection ()
virtual	~G4PiNuclearCrossSection ()
virtual G4bool	IsElementApplicable (const G4DynamicParticle *aParticle, G4int Z, const G4Material *)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *particle, G4int Z, const G4Material *)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	CrossSectionDescription (std::ostream &) const
G4double	GetTotalXsc ()
G4double	GetElasticXsc ()
Public Member Functions inherited from G4VCrossSectionDataSet
	G4VCrossSectionDataSet (const G4String &nam="")
virtual	~G4VCrossSectionDataSet ()
virtual G4bool	IsElementApplicable (const G4DynamicParticle *, G4int Z, const G4Material *mat=nullptr)
virtual G4bool	IsIsoApplicable (const G4DynamicParticle *, G4int Z, G4int A, const G4Element *elm=nullptr, const G4Material *mat=nullptr)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=nullptr)
G4double	ComputeCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *mat=nullptr)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat=nullptr)
virtual G4double	GetIsoCrossSection (const G4DynamicParticle *, G4int Z, G4int A, const G4Isotope *iso=nullptr, const G4Element *elm=nullptr, const G4Material *mat=nullptr)
virtual const G4Isotope *	SelectIsotope (const G4Element *, G4double kinEnergy, G4double logE)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	DumpPhysicsTable (const G4ParticleDefinition &)
virtual void	CrossSectionDescription (std::ostream &) const
virtual G4int	GetVerboseLevel () const
virtual void	SetVerboseLevel (G4int value)
G4double	GetMinKinEnergy () const
void	SetMinKinEnergy (G4double value)
G4double	GetMaxKinEnergy () const
void	SetMaxKinEnergy (G4double value)
bool	ForAllAtomsAndEnergies () const
void	SetForAllAtomsAndEnergies (G4bool val)
const G4String &	GetName () const

Static Public Member Functions
static const char *	Default_Name ()

Additional Inherited Members
Protected Member Functions inherited from G4VCrossSectionDataSet
void	SetName (const G4String &)
Protected Attributes inherited from G4VCrossSectionDataSet
G4int	verboseLevel

Detailed Description

Definition at line 37 of file G4PiNuclearCrossSection.hh.

Constructor & Destructor Documentation

G4PiNuclearCrossSection()

G4PiNuclearCrossSection::G4PiNuclearCrossSection

(

)

Definition at line 386 of file G4PiNuclearCrossSection.cc.

 : G4VCrossSectionDataSet(Default_Name()),
   fTotalXsc(0.0), fElasticXsc(0.0)
{
  SetMinKinEnergy(0.0);
  SetMaxKinEnergy(99.9*TeV);
   
  thePimData.push_back(new G4PiData(he_t,   he_in,  e1, 38));
  thePipData.push_back(new G4PiData(he_t,   he_in,  e1, 38));
  thePimData.push_back(new G4PiData(be_m_t, be_m_in, e1, 38));
  thePipData.push_back(new G4PiData(be_p_t, be_p_in, e1, 24));
  thePimData.push_back(new G4PiData(c_m_t,  c_m_in,  e2, 39));
  thePipData.push_back(new G4PiData(c_p_t,  c_p_in,  e2, 24));
  thePimData.push_back(new G4PiData(n_m_t,  n_m_in,  e2, 39));
  thePipData.push_back(new G4PiData(n_p_t,  n_p_in,  e2, 27));
  thePimData.push_back(new G4PiData(o_m_t,  o_m_in,  e3, 31));
  thePipData.push_back(new G4PiData(o_p_t,  o_p_in,  e3, 20));
  thePimData.push_back(new G4PiData(na_m_t, na_m_in, e3, 31));
  thePipData.push_back(new G4PiData(na_p_t, na_p_in, e3, 22));
  thePimData.push_back(new G4PiData(al_m_t, al_m_in, e3_1, 31));
  thePipData.push_back(new G4PiData(al_p_t, al_p_in, e3_1, 21));
  thePimData.push_back(new G4PiData(ca_m_t, ca_m_in, e3_1, 31));
  thePipData.push_back(new G4PiData(ca_p_t, ca_p_in, e3_1, 23));
  thePimData.push_back(new G4PiData(fe_m_t, fe_m_in, e4, 32));
  thePipData.push_back(new G4PiData(fe_p_t, fe_p_in, e4, 25));
  thePimData.push_back(new G4PiData(cu_m_t, cu_m_in, e4, 32));
  thePipData.push_back(new G4PiData(cu_p_t, cu_p_in, e4, 25));
  thePimData.push_back(new G4PiData(mo_m_t, mo_m_in, e5, 34));
  thePipData.push_back(new G4PiData(mo_p_t, mo_p_in, e5, 27));
  thePimData.push_back(new G4PiData(cd_m_t, cd_m_in, e5, 34));
  thePipData.push_back(new G4PiData(cd_p_t, cd_p_in, e5, 28));
  thePimData.push_back(new G4PiData(sn_m_t, sn_m_in, e6, 35));
  thePipData.push_back(new G4PiData(sn_p_t, sn_p_in, e6, 29));
  thePimData.push_back(new G4PiData(w_m_t,  w_m_in,  e6, 35));
  thePipData.push_back(new G4PiData(w_p_t,  w_p_in,  e6, 30));
  thePimData.push_back(new G4PiData(pb_m_t, pb_m_in, e7, 35));
  thePipData.push_back(new G4PiData(pb_p_t, pb_p_in, e7, 30));
  thePimData.push_back(new G4PiData(u_m_t,  u_m_in,  e7, 35));
  thePipData.push_back(new G4PiData(u_p_t,  u_p_in,  e7, 30));
 
  theZ.push_back(2); // He
  theZ.push_back(4); // Be
  theZ.push_back(6); // C
  theZ.push_back(7); // N
  theZ.push_back(8); // O
  theZ.push_back(11); // Na
  theZ.push_back(13); // Al
  theZ.push_back(20); // Ca
  theZ.push_back(26); // Fe
  theZ.push_back(29); // Cu
  theZ.push_back(42); // Mo
  theZ.push_back(48); // Cd
  theZ.push_back(50); // Sn
  theZ.push_back(74); // W
  theZ.push_back(82); // Pb
  theZ.push_back(92); // U
}

~G4PiNuclearCrossSection()

G4PiNuclearCrossSection::~G4PiNuclearCrossSection ( )

virtual

Definition at line 444 of file G4PiNuclearCrossSection.cc.

{
  for(auto xsec : thePimData) { delete xsec; }
  for(auto xsec : thePipData) { delete xsec; }
}

Member Function Documentation

BuildPhysicsTable()

void G4PiNuclearCrossSection::BuildPhysicsTable ( const G4ParticleDefinition &  p )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 469 of file G4PiNuclearCrossSection.cc.

{
  if(&p != G4PionMinus::PionMinus() && &p != G4PionPlus::PionPlus()) {
    G4ExceptionDescription ed;
    ed << "This cross section is applicable only to pions and not to " 
       << p.GetParticleName() << G4endl; 
    G4Exception("G4PiNuclearCrossSection::BuildPhysicsTable", "had001", 
        FatalException, ed);
  }
}

CrossSectionDescription()

void G4PiNuclearCrossSection::CrossSectionDescription ( std::ostream &  outFile ) const

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 452 of file G4PiNuclearCrossSection.cc.

{
  outFile << "G4PiNuclearCrossSection calculates the pion inelastic cross\n"
          << "section for all nuclei heavier than hydrogen.  It uses the\n"
          << "Barashenkov cross sections and is valid for all incident\n"
          << "energies.\n"; 
}

Default_Name()

static const char * G4PiNuclearCrossSection::Default_Name ( )

inlinestatic

Definition at line 44 of file G4PiNuclearCrossSection.hh.

{return "G4PiNuclearCrossSection";}

GetElasticXsc()

G4double G4PiNuclearCrossSection::GetElasticXsc ( )

inline

Definition at line 60 of file G4PiNuclearCrossSection.hh.

{return fElasticXsc;};

GetElementCrossSection()

G4double G4PiNuclearCrossSection::GetElementCrossSection ( const G4DynamicParticle *  particle, G4int  Z, const G4Material *    )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 481 of file G4PiNuclearCrossSection.cc.

{
  G4double charge = particle->GetDefinition()->GetPDGCharge();
  G4double kineticEnergy = particle->GetKineticEnergy();
 
  // body
 
  G4double result = 0;
  //  debug.push_back(Z);
  size_t it = 0;
 
  while(it < theZ.size() && Z > theZ[it]) it++; /* Loop checking, 08.01.2016, W. Pokorski */
 
  //  debug.push_back(theZ[it]);
  //  debug.push_back(kineticEnergy);
 
  if( it == theZ.size() ) 
  {
    //AR-24Apr2018 Switch to treat transuranic elements as uranium  
    const G4bool isHeavyElementAllowed = true;
    if ( isHeavyElementAllowed ) {
      it--;
      G4int zz = (Z > 100) ? 100 : Z;  // Above Fermium, treat it as Fermium
      // The cross section for a transuranic element is scaled from the
      // corresponding cross section of Uranium, as follows:
      //   (atomic_weight_element/atomic_weight_uranium)^0.75
      // Notes:
      // - The exponent "0.75" is used to be consistent with the method
      //   G4PiNuclearCrossSection::Interpolate (otherwise I would use 2/3);
      // - We use for Uranium 238.02891 and for the transuranic elements
      //   the values showed below in the comment.
      const std::vector<G4double> vecScaling{ 0.996756,    // <A>=237.0 for Np (Z=93)
                                              1.018756,    // <A>=244.0 for Pu (Z=94)
                                              1.015623,    // <A>=243.0 for Am (Z=95)
                                              1.028136,    // <A>=247.0 for Cm (Z=96)
                                              1.028136,    // <A>=247.0 for Bk (Z=97)
                                              1.040598,    // <A>=251.0 for Cf (Z=98)
                                              1.043706,    // <A>=252.0 for Es (Z=99)
                                              1.059199 };  // <A>=257.0 for Fm (Z=100)
      result =    vecScaling[zz-93] * thePimData[it]->ReactionXSection( kineticEnergy );
      fTotalXsc = vecScaling[zz-93] * thePimData[it]->TotalXSection( kineticEnergy );
      fElasticXsc = std::max(fTotalXsc - result, 0.0);
      return result;
    } else {
      G4ExceptionDescription ed;
      ed << "This cross section not applicable to Z= " << Z << " projectile: "  
     << particle->GetParticleDefinition()->GetParticleName() << G4endl; 
      G4Exception("G4PiNuclearCrossSection::GetElementCrossSection", "had001", 
          FatalException, ed);
    }
  }
  G4int Z1, Z2;
  G4double x1, x2, xt1, xt2;
  if( charge < 0 )
  {
    if( theZ[it] == Z )
    {
      result = thePimData[it]->ReactionXSection(kineticEnergy);
      fTotalXsc = thePimData[it]->TotalXSection(kineticEnergy);
 
      //      debug.push_back("D1 ");
      //      debug.push_back(result);
      //      debug.push_back(fTotalXsc);
    }
    else
    {
      x1 = thePimData[it-1]->ReactionXSection(kineticEnergy);
      xt1 = thePimData[it-1]->TotalXSection(kineticEnergy);
      Z1 = theZ[it-1];
      x2 = thePimData[it]->ReactionXSection(kineticEnergy);
      xt2 = thePimData[it]->TotalXSection(kineticEnergy);
      Z2 = theZ[it];
 
      result = Interpolate(Z1, Z2, Z, x1, x2);
      fTotalXsc = Interpolate(Z1, Z2, Z, xt1, xt2);
 
      //      debug.push_back("D2 ");
      //      debug.push_back(x1);
      //      debug.push_back(x2);
      //      debug.push_back(xt1);
      //      debug.push_back(xt2);
      //      debug.push_back(Z1);
      //      debug.push_back(Z2);
      //      debug.push_back(result);
      //      debug.push_back(fTotalXsc);
    }
  }
  else
  {
    if(theZ[it]==Z)
    {
      // at high energies, when no data for pi+, use pi- 
      std::vector<G4PiData *> * theData = &thePimData;
      if(thePipData[it]->AppliesTo(kineticEnergy))
      {
        theData = &thePipData;
      }
      result = theData->operator[](it)->ReactionXSection(kineticEnergy);
      fTotalXsc = theData->operator[](it)->TotalXSection(kineticEnergy);
 
      //      debug.push_back("D3 ");
      //      debug.push_back(result);
      //      debug.push_back(fTotalXsc);
    }
    else
    {
      std::vector<G4PiData *> * theLData = &thePimData;
      if(thePipData[it-1]->AppliesTo(kineticEnergy))
      {
        theLData = &thePipData;
      }
      std::vector<G4PiData *> * theHData = &thePimData;
      if(thePipData[it]->AppliesTo(kineticEnergy))
      {
        theHData = &thePipData;
      }
      x1 = theLData->operator[](it-1)->ReactionXSection(kineticEnergy);
      xt1 = theLData->operator[](it-1)->TotalXSection(kineticEnergy);
      Z1 = theZ[it-1];
      x2 = theHData->operator[](it)->ReactionXSection(kineticEnergy);
      xt2 = theHData->operator[](it)->TotalXSection(kineticEnergy);
      Z2 = theZ[it];
 
      result = Interpolate(Z1, Z2, Z, x1, x2);
      fTotalXsc = Interpolate(Z1, Z2, Z, xt1, xt2);
 
      //      debug.push_back("D4 ");
      //      debug.push_back(x1);
      //      debug.push_back(xt1);
      //      debug.push_back(x2);
      //      debug.push_back(xt2);
      //      debug.push_back(Z1);
      //      debug.push_back(Z2);
      //      debug.push_back(result);
      //      debug.push_back(fTotalXsc);
    }
  }
  //  debug.dump();
 
  fElasticXsc = fTotalXsc - result;
  if( fElasticXsc < 0.) fElasticXsc = 0.;
 
  return result;
}

GetTotalXsc()

G4double G4PiNuclearCrossSection::GetTotalXsc ( )

inline

Definition at line 59 of file G4PiNuclearCrossSection.hh.

{return fTotalXsc;};

IsElementApplicable()

G4bool G4PiNuclearCrossSection::IsElementApplicable ( const G4DynamicParticle *  aParticle, G4int  Z, const G4Material *    )

virtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 462 of file G4PiNuclearCrossSection.cc.

{
  return (1 < Z);
}

---

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

• G4PiNuclearCrossSection.hh
• G4PiNuclearCrossSection.cc