G4CrossSectionDataStore Class Reference

#include <G4CrossSectionDataStore.hh>

Public Member Functions
	G4CrossSectionDataStore ()
	~G4CrossSectionDataStore ()
G4double	GetCrossSection (const G4DynamicParticle *, const G4Material *)
G4double	ComputeCrossSection (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 *)
const G4Element *	SampleZandA (const G4DynamicParticle *, const G4Material *, G4Nucleus &target)
void	BuildPhysicsTable (const G4ParticleDefinition &)
void	DumpPhysicsTable (const G4ParticleDefinition &)
void	DumpHtml (const G4ParticleDefinition &, std::ofstream &) const
void	PrintCrossSectionHtml (const G4VCrossSectionDataSet *cs) const
void	AddDataSet (G4VCrossSectionDataSet *)
void	AddDataSet (G4VCrossSectionDataSet *, size_t)
void	SetVerboseLevel (G4int value)
const G4FastPathHadronicCrossSection::fastPathParameters &	GetFastPathParameters () const
const G4FastPathHadronicCrossSection::controlFlag &	GetFastPathControlFlags () const
void	DumpFastPath (const G4ParticleDefinition *, const G4Material *, std::ostream &os)
void	ActivateFastPath (const G4ParticleDefinition *, const G4Material *, G4double)

Friends
struct	G4FastPathHadronicCrossSection::fastPathEntry

Detailed Description

Definition at line 62 of file G4CrossSectionDataStore.hh.

Constructor & Destructor Documentation

G4CrossSectionDataStore()

G4CrossSectionDataStore::G4CrossSectionDataStore

(

)

Definition at line 60 of file G4CrossSectionDataStore.cc.

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

~G4CrossSectionDataStore()

G4CrossSectionDataStore::~G4CrossSectionDataStore

(

)

Definition at line 73 of file G4CrossSectionDataStore.cc.

{}

Member Function Documentation

ActivateFastPath()

void G4CrossSectionDataStore::ActivateFastPath	(	const G4ParticleDefinition *	pdef,
		const G4Material *	mat,
		G4double	min_cutoff
	)

Definition at line 531 of file G4CrossSectionDataStore.cc.

{
  assert(pdef!=nullptr&&mat!=nullptr);
  G4FastPathHadronicCrossSection::G4CrossSectionDataStore_Key key={pdef,mat};
  if ( requests.insert( { key , min_cutoff } ).second ) {
    G4ExceptionDescription ed;
    ed << "Attempting to request FastPath for couple: <"
       << pdef->GetParticleName() << ", " <<mat->GetName() 
       << "> but combination already exists" << G4endl;
    G4Exception("G4CrossSectionDataStore::ActivateFastPath", "had001", 
                FatalException, ed);
  }
}

AddDataSet() [1/2]

void G4CrossSectionDataStore::AddDataSet

(

G4VCrossSectionDataSet *

p

)

Definition at line 644 of file G4CrossSectionDataStore.cc.

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

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

AddDataSet() [2/2]

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

Definition at line 658 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;
  }
}

BuildPhysicsTable()

void G4CrossSectionDataStore::BuildPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 494 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);
  } 
  //A.Dotti: if fast-path has been requested we can now create the surrogate
  //         model for fast path.
  if ( fastPathFlags.useFastPathIfAvailable ) {
      fastPathFlags.initializationPhase = true;
      using my_value_type=G4FastPathHadronicCrossSection::G4CrossSectionDataStore_Requests::value_type;
      //Loop on all requests, if particle matches create the corresponding fsat-path
      std::for_each( requests.begin() , requests.end() ,
              [&aParticleType,this](const my_value_type& req) {
                  if ( aParticleType == *req.part_mat.first ) {
                      G4FastPathHadronicCrossSection::cycleCountEntry* entry =
                              new G4FastPathHadronicCrossSection::cycleCountEntry(aParticleType.GetParticleName(),req.part_mat.second);
                      entry->fastPath =
                              new G4FastPathHadronicCrossSection::fastPathEntry(&aParticleType,req.part_mat.second,req.min_cutoff);
                      entry->fastPath->Initialize(this);
                      fastPathCache[req.part_mat] = entry;
                  }
              }
          );
      fastPathFlags.initializationPhase = false;
  }
}

Referenced by G4HadronicProcess::BuildPhysicsTable().

ComputeCrossSection()

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

Definition at line 268 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.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;
}

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

DumpFastPath()

void G4CrossSectionDataStore::DumpFastPath	(	const G4ParticleDefinition *	pd,
		const G4Material *	mat,
		std::ostream &	os
	)

Definition at line 249 of file G4CrossSectionDataStore.cc.

{
    const G4FastPathHadronicCrossSection::cycleCountEntry* entry = fastPathCache[{pd,mat}];
    if ( entry != nullptr ) {
        if ( entry->fastPath != nullptr ) {
            os<<*entry->fastPath;
        } else {
            os<<"#Cache entry for {"<<(pd!=nullptr?pd->GetParticleName():"UNDEFINED")<<",";
            os<<(mat!=nullptr?mat->GetName():"UNDEFINED")<<"} found, but no fast path defined";
        }
    } else {
        os<<"#Cache entry for {"<<(pd!=nullptr?pd->GetParticleName():"UNDEFINED")<<",";
        os<<(mat!=nullptr?mat->GetName():"UNDEFINED")<<"} not found.";
    }
}

DumpHtml()

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

Definition at line 576 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]);         
  }
}

Referenced by G4HadronicProcessStore::PrintHtml().

DumpPhysicsTable()

void G4CrossSectionDataStore::DumpPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 549 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);
      }
  }
}

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

GetCrossSection() [1/3]

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

Definition at line 296 of file G4CrossSectionDataStore.cc.

{
  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 = elm->GetZasInt();
  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
    size_t nIso = elm->GetNumberOfIsotopes();    
 
    // user-defined isotope abundances        
    const G4double* abundVector = elm->GetRelativeAbundanceVector();
 
    for (size_t j=0; j<nIso; ++j) {
      if(abundVector[j] > 0.0) {
    const G4Isotope* iso = elm->GetIsotope(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;
}

GetCrossSection() [2/3]

G4double G4CrossSectionDataStore::GetCrossSection ( const G4DynamicParticle *  particle, const G4Material *  material  )

inline

Definition at line 156 of file G4CrossSectionDataStore.hh.

                                                                                                                        {
    //By default tries to use the fast-path mechanism
    return GetCrossSection( particle , material , false);
}

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

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

GetFastPathControlFlags()

const G4FastPathHadronicCrossSection::controlFlag & G4CrossSectionDataStore::GetFastPathControlFlags ( ) const

inline

Definition at line 138 of file G4CrossSectionDataStore.hh.

{ return fastPathFlags; }

Referenced by G4FastPathHadronicCrossSection::fastPathEntry::Initialize().

GetFastPathParameters()

const G4FastPathHadronicCrossSection::fastPathParameters & G4CrossSectionDataStore::GetFastPathParameters ( ) const

inline

Definition at line 136 of file G4CrossSectionDataStore.hh.

{ return fastPathParams; }

Referenced by G4FastPathHadronicCrossSection::fastPathEntry::Initialize().

PrintCrossSectionHtml()

void G4CrossSectionDataStore::PrintCrossSectionHtml

(

const G4VCrossSectionDataSet *

cs

)

const

Definition at line 608 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";
 
}

Referenced by DumpHtml().

SampleZandA()

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

Definition at line 415 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;
}

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

SetVerboseLevel()

void G4CrossSectionDataStore::SetVerboseLevel ( G4int  value )

inline

Definition at line 161 of file G4CrossSectionDataStore.hh.

{
  verboseLevel = value;
}

Friends And Related Function Documentation

G4FastPathHadronicCrossSection::fastPathEntry

friend struct G4FastPathHadronicCrossSection::fastPathEntry

friend

Definition at line 142 of file G4CrossSectionDataStore.hh.

---

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

• G4CrossSectionDataStore.hh
• G4CrossSectionDataStore.cc