G4CrossSectionDataStore Class Reference

#include <G4CrossSectionDataStore.hh>

Public Member Functions
	G4CrossSectionDataStore ()
	~G4CrossSectionDataStore ()
G4double	GetCrossSection (const G4DynamicParticle *, const G4Material *)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetCrossSection (const G4DynamicParticle *, G4int Z, G4int A, const G4Isotope *, const G4Element *, const G4Material *)
G4Element *	SampleZandA (const G4DynamicParticle *, const G4Material *, G4Nucleus &target)
void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DumpPhysicsTable (const G4ParticleDefinition &)
void	DumpHtml (const G4ParticleDefinition &, std::ofstream &)
void	AddDataSet (G4VCrossSectionDataSet *)
void	SetVerboseLevel (G4int value)

Detailed Description

Definition at line 60 of file G4CrossSectionDataStore.hh.

Constructor & Destructor Documentation

G4CrossSectionDataStore::G4CrossSectionDataStore

(

)

Definition at line 62 of file G4CrossSectionDataStore.cc.

References G4NistManager::Instance().

                                                 :
  nDataSetList(0), verboseLevel(0)
{
  nist = G4NistManager::Instance();
  currentMaterial = elmMaterial = 0;
  currentElement = 0;  //ALB 14-Aug-2012 Coverity fix.
  matParticle = elmParticle = 0;
  matKinEnergy = elmKinEnergy = matCrossSection = elmCrossSection = 0.0;
}

G4CrossSectionDataStore::~G4CrossSectionDataStore

(

)

Definition at line 74 of file G4CrossSectionDataStore.cc.

{}

Member Function Documentation

void G4CrossSectionDataStore::AddDataSet ( G4VCrossSectionDataSet *  p )

inline

Definition at line 128 of file G4CrossSectionDataStore.hh.

Referenced by G4HadronicProcess::AddDataSet(), G4ElectronNuclearProcess::G4ElectronNuclearProcess(), G4PhotoNuclearProcess::G4PhotoNuclearProcess(), and G4PositronNuclearProcess::G4PositronNuclearProcess().

{
  dataSetList.push_back(p);
  ++nDataSetList;
}

void G4CrossSectionDataStore::BuildPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 334 of file G4CrossSectionDataStore.cc.

Referenced by G4HadronicProcess::BuildPhysicsTable().

{
  if (nDataSetList == 0) 
    {
      throw G4HadronicException(__FILE__, __LINE__, 
                "G4CrossSectionDataStore: no data sets registered");
      return;
    }
  for (G4int i=0; i<nDataSetList; ++i) {
    dataSetList[i]->BuildPhysicsTable(aParticleType);
  } 
}

void G4CrossSectionDataStore::DumpHtml	(	const G4ParticleDefinition &	,
		std::ofstream &	outFile
	)

Definition at line 377 of file G4CrossSectionDataStore.cc.

References python.hepunit::GeV.

Referenced by G4HadronicProcessStore::PrintHtml().

{
  // Write cross section data set info to html physics list
  // documentation page

  G4double ehi = 0;
  G4double elo = 0;
  for (G4int i = nDataSetList-1; i > 0; i--) {
    elo = dataSetList[i]->GetMinKinEnergy()/GeV;
    ehi = dataSetList[i]->GetMaxKinEnergy()/GeV;
    outFile << "      <li><b><a href=\"" << dataSetList[i]->GetName() << ".html\"> "
            << dataSetList[i]->GetName() << "</a> from "
            << elo << " GeV to " << ehi << " GeV </b></li>\n";
  }

  G4double defaultHi = dataSetList[0]->GetMaxKinEnergy()/GeV;
  if (ehi < defaultHi) {
    outFile << "      <li><b><a href=\"" << dataSetList[0]->GetName() << ".html\"> "
            << dataSetList[0]->GetName() << "</a> from "
            << ehi << " GeV to " << defaultHi << " GeV </b></li>\n";
  }
}

void G4CrossSectionDataStore::DumpPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 350 of file G4CrossSectionDataStore.cc.

References G4BestUnit, G4cout, and G4endl.

Referenced by G4ChargeExchangeProcess::DumpPhysicsTable(), and G4HadronicProcess::DumpPhysicsTable().

{
  // Print out all cross section data sets used and the energies at
  // which they apply

  if (nDataSetList == 0) {
    G4cout << "WARNING - G4CrossSectionDataStore::DumpPhysicsTable: "
       << " no data sets registered" << G4endl;
    return;
  }

  for (G4int i = nDataSetList-1; i >= 0; --i) {
    G4double e1 = dataSetList[i]->GetMinKinEnergy();
    G4double e2 = dataSetList[i]->GetMaxKinEnergy();
     G4cout 
      << "     Cr_sctns: " << std::setw(25) << dataSetList[i]->GetName() << ": "
      <<  G4BestUnit(e1, "Energy")
      << " ---> "
      <<  G4BestUnit(e2, "Energy") << "\n";
      if (dataSetList[i]->GetName() == "G4CrossSectionPairGG") {
        dataSetList[i]->DumpPhysicsTable(aParticleType);
      }
  }
}

G4double G4CrossSectionDataStore::GetCrossSection	(	const G4DynamicParticle *	part,
		const G4Material *	mat
	)

Definition at line 80 of file G4CrossSectionDataStore.cc.

References G4DynamicParticle::GetDefinition(), G4Material::GetElementVector(), G4DynamicParticle::GetKineticEnergy(), G4Material::GetNumberOfElements(), and G4Material::GetVecNbOfAtomsPerVolume().

Referenced by G4ChargeExchangeProcess::GetElementCrossSection(), G4HadronicProcess::GetElementCrossSection(), G4HadronicProcess::GetMeanFreePath(), and SampleZandA().

{
  if(mat == currentMaterial && part->GetDefinition() == matParticle
     && part->GetKineticEnergy() == matKinEnergy) 
    { return matCrossSection; }
  
  currentMaterial = mat;
  matParticle = part->GetDefinition();
  matKinEnergy = part->GetKineticEnergy();
  matCrossSection = 0;

  G4int nElements = mat->GetNumberOfElements();
  const G4double* nAtomsPerVolume = mat->GetVecNbOfAtomsPerVolume();

  if(G4int(xsecelm.size()) < nElements) { xsecelm.resize(nElements); }

  for(G4int i=0; i<nElements; ++i) {
    matCrossSection += nAtomsPerVolume[i] * 
      GetCrossSection(part, (*mat->GetElementVector())[i], mat);
    xsecelm[i] = matCrossSection;
  }
  return matCrossSection;
}

G4double G4CrossSectionDataStore::GetCrossSection	(	const G4DynamicParticle *	part,
		const G4Element *	elm,
		const G4Material *	mat
	)

Definition at line 108 of file G4CrossSectionDataStore.cc.

References G4lrint(), G4DynamicParticle::GetDefinition(), G4Element::GetIsotopeVector(), G4DynamicParticle::GetKineticEnergy(), G4Isotope::GetN(), G4Element::GetNaturalAbundanceFlag(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), and G4Element::GetZ().

{
  if(mat == elmMaterial && elm == currentElement &&
     part->GetDefinition() == elmParticle &&
     part->GetKineticEnergy() == elmKinEnergy) 
    { return elmCrossSection; }

  elmMaterial = mat;
  currentElement = elm;
  elmParticle = part->GetDefinition();
  elmKinEnergy = part->GetKineticEnergy();
  elmCrossSection = 0.0;

  G4int i = nDataSetList-1;  
  G4int Z = G4lrint(elm->GetZ());
  if (elm->GetNaturalAbundanceFlag() &&
      dataSetList[i]->IsElementApplicable(part, Z, mat)) {

    // element wise cross section
    elmCrossSection = dataSetList[i]->GetElementCrossSection(part, Z, mat);

    //G4cout << "Element wise " << elmParticle->GetParticleName() 
    //     << " xsec(barn)= " <<  elmCrossSection/barn 
    //     << "  E(MeV)= " << elmKinEnergy/MeV 
    //     << " Z= " << Z << " AbundFlag= " << elm->GetNaturalAbandancesFlag()
    //     <<G4endl;

  } else {
    // isotope wise cross section
    G4int nIso = elm->GetNumberOfIsotopes();    
    G4Isotope* iso = 0;

    // user-defined isotope abundances        
    G4IsotopeVector* isoVector = elm->GetIsotopeVector();
    G4double* abundVector = elm->GetRelativeAbundanceVector();

    for (G4int j = 0; j<nIso; ++j) {
      if(abundVector[j] > 0.0) {
    iso = (*isoVector)[j];
    elmCrossSection += abundVector[j]*
      GetIsoCrossSection(part, Z, iso->GetN(), iso, elm, mat, i);
    //G4cout << "Isotope wise " << elmParticle->GetParticleName() 
    //       << " xsec(barn)= " <<  elmCrossSection/barn 
    //       << "  E(MeV)= " << elmKinEnergy/MeV 
    //       << " Z= " << Z << "  A= " << iso->GetN() << "  j= " << j << G4endl;
      }
    }
  }
  //G4cout << "  E(MeV)= " << elmKinEnergy/MeV 
  //     << "xsec(barn)= " <<  elmCrossSection/barn <<G4endl;
  return elmCrossSection;
}

G4double G4CrossSectionDataStore::GetCrossSection	(	const G4DynamicParticle *	part,
		G4int	Z,
		G4int	A,
		const G4Isotope *	iso,
		const G4Element *	elm,
		const G4Material *	mat
	)

Definition at line 207 of file G4CrossSectionDataStore.cc.

References G4cout, G4endl, G4DynamicParticle::GetDefinition(), G4DynamicParticle::GetKineticEnergy(), G4Element::GetName(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), and python.hepunit::MeV.

{
  for (G4int i = nDataSetList-1; i >= 0; --i) {
    if (dataSetList[i]->IsIsoApplicable(part, Z, A, elm, mat) ) {
      return dataSetList[i]->GetIsoCrossSection(part, Z, A, iso, elm, mat);
    }
  }
  G4cout << "G4CrossSectionDataStore::GetCrossSection ERROR: "
     << " no isotope cross section found"
     << G4endl;
  G4cout << "  for " << part->GetDefinition()->GetParticleName() 
     << " off Element " << elm->GetName()
         << "  in " << mat->GetName() 
     << " Z= " << Z << " A= " << A
     << " E(MeV)= " << part->GetKineticEnergy()/MeV << G4endl; 
  throw G4HadronicException(__FILE__, __LINE__, 
                      " no applicable data set found for the isotope");
  return 0.0;
}

G4Element * G4CrossSectionDataStore::SampleZandA	(	const G4DynamicParticle *	part,
		const G4Material *	mat,
		G4Nucleus &	target
	)

Definition at line 234 of file G4CrossSectionDataStore.cc.

References G4cout, G4endl, G4lrint(), G4UniformRand, GetCrossSection(), G4Material::GetElementVector(), G4Element::GetIsotopeVector(), G4DynamicParticle::GetKineticEnergy(), G4Element::GetName(), G4Material::GetNumberOfElements(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), G4Element::GetZ(), and G4Nucleus::SetIsotope().

Referenced by G4HadronElasticProcess::PostStepDoIt(), and G4HadronicProcess::PostStepDoIt().

{
  G4int nElements = mat->GetNumberOfElements();
  const G4ElementVector* theElementVector = mat->GetElementVector();
  G4Element* anElement = (*theElementVector)[0];

  G4double cross = GetCrossSection(part, mat);

  // select element from a compound 
  if(1 < nElements) {
    cross *= G4UniformRand();
    for(G4int i=0; i<nElements; ++i) {
      if(cross <= xsecelm[i]) {
    anElement = (*theElementVector)[i];
        break;
      }
    }
  }

  G4int Z = G4lrint(anElement->GetZ());
  G4Isotope* iso = 0;

  G4int i = nDataSetList-1; 
  if (dataSetList[i]->IsElementApplicable(part, Z, mat)) {

    //----------------------------------------------------------------
    // element-wise cross section
    // isotope cross section is not computed
    //----------------------------------------------------------------
    G4int nIso = anElement->GetNumberOfIsotopes();
    if (0 >= nIso) { 
      G4cout << " Element " << anElement->GetName() << " Z= " << Z 
         << " has no isotopes " << G4endl; 
      throw G4HadronicException(__FILE__, __LINE__, 
                      " Isotope vector is not defined");
      return anElement;
    }
    // isotope abundances        
    G4IsotopeVector* isoVector = anElement->GetIsotopeVector();
    iso = (*isoVector)[0];

    // more than 1 isotope
    if(1 < nIso) { 
      iso = dataSetList[i]->SelectIsotope(anElement, part->GetKineticEnergy());
    }

  } else {

    //----------------------------------------------------------------
    // isotope-wise cross section
    // isotope cross section is computed
    //----------------------------------------------------------------
    G4int nIso = anElement->GetNumberOfIsotopes();
    cross = 0.0;

    if (0 >= nIso) { 
      G4cout << " Element " << anElement->GetName() << " Z= " << Z 
         << " has no isotopes " << G4endl; 
      throw G4HadronicException(__FILE__, __LINE__, 
                      " Isotope vector is not defined");
      return anElement;
    }

    // user-defined isotope abundances        
    G4IsotopeVector* isoVector = anElement->GetIsotopeVector();
    iso = (*isoVector)[0];

    // more than 1 isotope
    if(1 < nIso) {
      G4double* abundVector = anElement->GetRelativeAbundanceVector();
      if(G4int(xseciso.size()) < nIso) { xseciso.resize(nIso); }

      for (G4int j = 0; j<nIso; ++j) {
    G4double xsec = 0.0;
    if(abundVector[j] > 0.0) {
      iso = (*isoVector)[j];
      xsec = abundVector[j]*
        GetIsoCrossSection(part, Z, iso->GetN(), iso, anElement, mat, i);
    }
    cross += xsec;
    xseciso[j] = cross;
      }
      cross *= G4UniformRand();
      for (G4int j = 0; j<nIso; ++j) {
    if(cross <= xseciso[j]) {
      iso = (*isoVector)[j];
      break;
    }
      }
    }
  }
  target.SetIsotope(iso);
  return anElement;
}

void G4CrossSectionDataStore::SetVerboseLevel ( G4int  value )

inline

Definition at line 134 of file G4CrossSectionDataStore.hh.

{
  verboseLevel = value;
}

---

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

• G4CrossSectionDataStore.hh
• G4CrossSectionDataStore.cc