#include <G4CrossSectionDataStore.hh>

Public Member Functions
void	AddDataSet (G4VCrossSectionDataSet *)

void	AddDataSet (G4VCrossSectionDataSet *, size_t)

void	BuildPhysicsTable (const G4ParticleDefinition &)

G4double	ComputeCrossSection (const G4DynamicParticle , const G4Material )

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

void	DumpPhysicsTable (const G4ParticleDefinition &)

	G4CrossSectionDataStore ()

G4double	GetCrossSection (const G4DynamicParticle , const G4Element , const G4Material *)

G4double	GetCrossSection (const G4DynamicParticle , const G4Material )

G4double	GetCrossSection (const G4DynamicParticle , G4int Z, G4int A, const G4Isotope , const G4Element , const G4Material )

void	PrintCrossSectionHtml (const G4VCrossSectionDataSet *cs) const

const G4Element *	SampleZandA (const G4DynamicParticle , const G4Material , G4Nucleus &target)

void	SetVerboseLevel (G4int value)

	~G4CrossSectionDataStore ()

Private Member Functions
	G4CrossSectionDataStore (const G4CrossSectionDataStore &)

G4double	GetIsoCrossSection (const G4DynamicParticle , G4int Z, G4int A, const G4Isotope , const G4Element , const G4Material aMaterial, G4int index)

G4String	HtmlFileName (const G4String &in) const

G4CrossSectionDataStore &	operator= (const G4CrossSectionDataStore &right)

Private Attributes
const G4Material *	currentMaterial

std::vector< G4VCrossSectionDataSet * >	dataSetList

G4double	matCrossSection

G4double	matKinEnergy

const G4ParticleDefinition *	matParticle

G4int	nDataSetList

G4NistManager *	nist

G4int	verboseLevel

std::vector< G4double >	xsecelm

std::vector< G4double >	xseciso

Detailed Description

Definition at line 61 of file G4CrossSectionDataStore.hh.

Constructor & Destructor Documentation

◆ G4CrossSectionDataStore() [1/2]

G4CrossSectionDataStore::G4CrossSectionDataStore ( )

Definition at line 60 of file G4CrossSectionDataStore.cc.

  : nist(G4NistManager::Instance())
  , currentMaterial(nullptr)
  , matParticle(nullptr)
  , matKinEnergy(0.0)
  , matCrossSection(0.0)
  , nDataSetList(0)
  , verboseLevel(0)
{}

◆ ~G4CrossSectionDataStore()

G4CrossSectionDataStore::~G4CrossSectionDataStore ( )

Definition at line 72 of file G4CrossSectionDataStore.cc.

73{}

◆ G4CrossSectionDataStore() [2/2]

G4CrossSectionDataStore::G4CrossSectionDataStore ( const G4CrossSectionDataStore & )

private

Member Function Documentation

◆ AddDataSet() [1/2]

void G4CrossSectionDataStore::AddDataSet ( G4VCrossSectionDataSet * p )

Definition at line 423 of file G4CrossSectionDataStore.cc.

{
  if(p->ForAllAtomsAndEnergies()) { 
    dataSetList.clear();
    nDataSetList = 0;
  }
  dataSetList.push_back(p);
  ++nDataSetList;
}

References dataSetList, G4VCrossSectionDataSet::ForAllAtomsAndEnergies(), and nDataSetList.

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

◆ AddDataSet() [2/2]

void G4CrossSectionDataStore::AddDataSet	(	G4VCrossSectionDataSet *	p,
		size_t	i
	)

Definition at line 437 of file G4CrossSectionDataStore.cc.

{
  if(p->ForAllAtomsAndEnergies()) {
    dataSetList.clear();
    dataSetList.push_back(p);
    nDataSetList = 1;
  } else {
    if ( i > dataSetList.size() ) i = dataSetList.size(); 
    std::vector< G4VCrossSectionDataSet* >::iterator it = dataSetList.end() - i;
    dataSetList.insert(it , p);
    ++nDataSetList;
  }
}

References dataSetList, G4VCrossSectionDataSet::ForAllAtomsAndEnergies(), and nDataSetList.

◆ BuildPhysicsTable()

void G4CrossSectionDataStore::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

Definition at line 310 of file G4CrossSectionDataStore.cc.

{
  if (nDataSetList == 0) {
    G4ExceptionDescription ed;
    ed << "No cross section is registered for " 
       << aParticleType.GetParticleName() << G4endl;
    G4Exception("G4CrossSectionDataStore::BuildPhysicsTable", "had001", 
                FatalException, ed);
    return;
  }
  for (G4int i=0; i<nDataSetList; ++i) {
    dataSetList[i]->BuildPhysicsTable(aParticleType);
  } 
}

References dataSetList, FatalException, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), and nDataSetList.

Referenced by G4HadronicProcess::BuildPhysicsTable().

◆ ComputeCrossSection()

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

Definition at line 106 of file G4CrossSectionDataStore.cc.

{
  if(part->GetKineticEnergy() == matKinEnergy && mat == currentMaterial &&
     part->GetDefinition() == matParticle)
    return matCrossSection;
 
  currentMaterial = mat;
  matParticle = part->GetDefinition();
  matKinEnergy = part->GetKineticEnergy();
  matCrossSection = 0.0;
 
  size_t nElements = mat->GetNumberOfElements();
  const G4double* nAtomsPerVolume = mat->GetVecNbOfAtomsPerVolume();
 
  if(xsecelm.size() < nElements) { xsecelm.resize(nElements); }
 
  for(size_t i=0; i<nElements; ++i) {
    matCrossSection += nAtomsPerVolume[i] *
      GetCrossSection(part, mat->GetElement(i), mat);
    xsecelm[i] = matCrossSection;
  }
  return matCrossSection;
}

References currentMaterial, GetCrossSection(), G4DynamicParticle::GetDefinition(), G4Material::GetElement(), G4DynamicParticle::GetKineticEnergy(), G4Material::GetNumberOfElements(), G4Material::GetVecNbOfAtomsPerVolume(), matCrossSection, matKinEnergy, matParticle, and xsecelm.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4NeutrinoElectronProcess::GetMeanFreePath(), G4HadronicProcess::GetMeanFreePath(), G4ElNeutrinoNucleusProcess::GetMeanFreePath(), G4MuNeutrinoNucleusProcess::GetMeanFreePath(), G4HadronXSDataTable::Initialise(), G4HadronicProcess::PostStepDoIt(), and G4GammaGeneralProcess::SelectHadProcess().

◆ DumpHtml()

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

Definition at line 355 of file G4CrossSectionDataStore.cc.

{
  // Write cross section data set info to html physics list
  // documentation page
 
  G4double ehi = 0;
  G4double elo = 0;
  G4String physListName(std::getenv("G4PhysListName"));
  for (G4int i = nDataSetList-1; i > 0; i--) {
    elo = dataSetList[i]->GetMinKinEnergy()/GeV;
    ehi = dataSetList[i]->GetMaxKinEnergy()/GeV;
    outFile << "      <li><b><a href=\"" << physListName << "_"
             << dataSetList[i]->GetName() << ".html\"> "
            << dataSetList[i]->GetName() << "</a> from "
            << elo << " GeV to " << ehi << " GeV </b></li>\n";
     //G4cerr << i << ": XS for " << pD.GetParticleName() << " : " << dataSetList[i]->GetName() 
     //       << " typeid : " << typeid(dataSetList[i]).name()<< G4endl;            
     PrintCrossSectionHtml(dataSetList[i]);         
  }
 
  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";
     PrintCrossSectionHtml(dataSetList[0]);         
  }
}

References dataSetList, GeV, nDataSetList, and PrintCrossSectionHtml().

Referenced by G4HadronicProcessStore::PrintHtml().

◆ DumpPhysicsTable()

void G4CrossSectionDataStore::DumpPhysicsTable ( const G4ParticleDefinition & aParticleType )

Definition at line 328 of file G4CrossSectionDataStore.cc.

{
  // 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);
      }
  }
}

References dataSetList, e1, e2, G4BestUnit, G4cout, G4endl, and nDataSetList.

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

◆ GetCrossSection() [1/3]

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

Definition at line 133 of file G4CrossSectionDataStore.cc.

{
  G4int i = nDataSetList - 1;
  G4int Z = elm->GetZasInt();
 
  if(elm->GetNaturalAbundanceFlag() &&
     dataSetList[i]->IsElementApplicable(part, Z, mat))
  {
    // element wise cross section
    return dataSetList[i]->GetElementCrossSection(part, Z, mat);
  }
 
  // isotope wise cross section
  size_t nIso = elm->GetNumberOfIsotopes();
 
  // user-defined isotope abundances
  const G4double* abundVector = elm->GetRelativeAbundanceVector();
 
  G4double sigma = 0.0;
 
  for(size_t j = 0; j < nIso; ++j)
  {
    const G4Isotope* iso = elm->GetIsotope(j);
    sigma += abundVector[j] *
             GetIsoCrossSection(part, Z, iso->GetN(), iso, elm, mat, i);
  }
 
  return sigma;
}

References dataSetList, GetIsoCrossSection(), G4Element::GetIsotope(), G4Isotope::GetN(), G4Element::GetNaturalAbundanceFlag(), G4Element::GetNumberOfIsotopes(), G4Element::GetRelativeAbundanceVector(), G4Element::GetZasInt(), nDataSetList, and Z.

◆ GetCrossSection() [2/3]

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

Definition at line 78 of file G4CrossSectionDataStore.cc.

{
  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;
}

References currentMaterial, GetCrossSection(), G4DynamicParticle::GetDefinition(), G4Material::GetElementVector(), G4DynamicParticle::GetKineticEnergy(), G4Material::GetNumberOfElements(), G4Material::GetVecNbOfAtomsPerVolume(), matCrossSection, matKinEnergy, matParticle, and xsecelm.

Referenced by ComputeCrossSection(), G4HadElementSelector::G4HadElementSelector(), GetCrossSection(), G4ChargeExchangeProcess::GetElementCrossSection(), and G4HadronicProcess::GetElementCrossSection().

◆ GetCrossSection() [3/3]

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

Definition at line 206 of file G4CrossSectionDataStore.cc.

{
  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);
    }
  }
  G4ExceptionDescription ed;
  ed << "No isotope cross section found for " 
     << part->GetDefinition()->GetParticleName() 
     << " off Element " << elm->GetName()
     << "  in " << mat->GetName() << " Z= " << Z << " A= " << A
     << " E(MeV)= " << part->GetKineticEnergy()/MeV << G4endl; 
  G4Exception("G4CrossSectionDataStore::GetCrossSection", "had001", 
              FatalException, ed);
  return 0.0;
}

References A, dataSetList, FatalException, G4endl, G4Exception(), G4DynamicParticle::GetDefinition(), G4DynamicParticle::GetKineticEnergy(), G4Element::GetName(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), MeV, nDataSetList, and Z.

◆ GetIsoCrossSection()

G4double G4CrossSectionDataStore::GetIsoCrossSection	(	const G4DynamicParticle *	part,
		G4int	Z,
		G4int	A,
		const G4Isotope *	iso,
		const G4Element *	elm,
		const G4Material *	aMaterial,
		G4int	index
	)

private

Definition at line 168 of file G4CrossSectionDataStore.cc.

{
  // this methods is called after the check that dataSetList[idx] 
  // depend on isotopes, so for this DataSet only isotopes are checked
 
  // isotope-wise cross section does exist
  if(dataSetList[idx]->IsIsoApplicable(part, Z, A, elm, mat) ) {
    return dataSetList[idx]->GetIsoCrossSection(part, Z, A, iso, elm, mat);
 
  } else {
    // seach for other dataSet
    for (G4int j = nDataSetList-1; j >= 0; --j) { 
      if (dataSetList[j]->IsElementApplicable(part, Z, mat)) {
    return dataSetList[j]->GetElementCrossSection(part, Z, mat);
      } else if (dataSetList[j]->IsIsoApplicable(part, Z, A, elm, mat)) {
    return dataSetList[j]->GetIsoCrossSection(part, Z, A, iso, elm, mat);
      }
    }
  }
  G4ExceptionDescription ed;
  ed << "No isotope cross section found for " 
     << part->GetDefinition()->GetParticleName() 
     << " off Element " << elm->GetName()
     << "  in " << mat->GetName() << " Z= " << Z << " A= " << A
     << " E(MeV)= " << part->GetKineticEnergy()/MeV << G4endl; 
  G4Exception("G4CrossSectionDataStore::GetIsoCrossSection", "had001", 
              FatalException, ed);
  return 0.0;
}

References A, dataSetList, FatalException, G4endl, G4Exception(), G4DynamicParticle::GetDefinition(), G4DynamicParticle::GetKineticEnergy(), G4Element::GetName(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), MeV, nDataSetList, and Z.

Referenced by GetCrossSection(), and SampleZandA().

◆ HtmlFileName()

G4String G4CrossSectionDataStore::HtmlFileName ( const G4String & in ) const

private

Definition at line 410 of file G4CrossSectionDataStore.cc.

{
   G4String str(in);
   // replace blanks by _  C++11 version:
   std::transform(str.begin(), str.end(), str.begin(), [](char ch) {
       return ch == ' ' ? '_' : ch;
   });
   str=str + ".html";       
   return str;
}

References G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by PrintCrossSectionHtml().

◆ operator=()

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

private

◆ PrintCrossSectionHtml()

void G4CrossSectionDataStore::PrintCrossSectionHtml ( const G4VCrossSectionDataSet * cs ) const

Definition at line 387 of file G4CrossSectionDataStore.cc.

{
  G4String dirName(std::getenv("G4PhysListDocDir"));
  G4String physListName(std::getenv("G4PhysListName"));
 
    G4String pathName = dirName + "/" + physListName + "_" + HtmlFileName(cs->GetName());
    std::ofstream outCS;
    outCS.open(pathName);
    outCS << "<html>\n";
    outCS << "<head>\n";
    outCS << "<title>Description of " << cs->GetName() 
         << "</title>\n";
    outCS << "</head>\n";
    outCS << "<body>\n";
 
    cs->CrossSectionDescription(outCS);
 
    outCS << "</body>\n";
    outCS << "</html>\n";
 
}

References G4VCrossSectionDataSet::CrossSectionDescription(), G4VCrossSectionDataSet::GetName(), and HtmlFileName().

Referenced by DumpHtml().

◆ SampleZandA()

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

Definition at line 231 of file G4CrossSectionDataStore.cc.

{
  size_t nElements = mat->GetNumberOfElements();
  const G4Element* anElement = mat->GetElement(0);
 
  // select element from a compound 
  if(1 < nElements) {
    G4double cross = matCrossSection*G4UniformRand();
    for(size_t i=0; i<nElements; ++i) {
      if(cross <= xsecelm[i]) {
    anElement = mat->GetElement(i);
        break;
      }
    }
  }
 
  G4int Z = anElement->GetZasInt();
  const G4Isotope* iso = nullptr;
 
  G4int i = nDataSetList-1;
  if (dataSetList[i]->IsElementApplicable(part, Z, mat)) {
 
    //----------------------------------------------------------------
    // element-wise cross section
    // isotope cross section is not computed
    //----------------------------------------------------------------
    size_t nIso = anElement->GetNumberOfIsotopes();
    iso = anElement->GetIsotope(0);
 
    // more than 1 isotope
    if(1 < nIso) { 
      iso = dataSetList[i]->SelectIsotope(anElement, 
                                          part->GetKineticEnergy(),
                      part->GetLogKineticEnergy());
    }
  } else {
 
    //----------------------------------------------------------------
    // isotope-wise cross section
    // isotope cross section is computed
    //----------------------------------------------------------------
    size_t nIso = anElement->GetNumberOfIsotopes();
    iso = anElement->GetIsotope(0);
 
    // more than 1 isotope
    if(1 < nIso) {
      const G4double* abundVector = anElement->GetRelativeAbundanceVector();
      if(xseciso.size() < nIso) { xseciso.resize(nIso); }
 
      G4double cross = 0.0;
      size_t j;
      for (j = 0; j<nIso; ++j) {
    G4double xsec = 0.0;
    if(abundVector[j] > 0.0) {
      iso = anElement->GetIsotope(j);
      xsec = abundVector[j]*
        GetIsoCrossSection(part, Z, iso->GetN(), iso, anElement, mat, i);
    }
    cross += xsec;
    xseciso[j] = cross;
      }
      cross *= G4UniformRand();
      for (j = 0; j<nIso; ++j) {
    if(cross <= xseciso[j]) {
      iso = anElement->GetIsotope(j);
      break;
    }
      }
    }
  }
  target.SetIsotope(iso);
  return anElement;
}