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 &) const
void	PrintCrossSectionHtml (const G4VCrossSectionDataSet *cs) const
void	AddDataSet (G4VCrossSectionDataSet *)
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 63 of file G4CrossSectionDataStore.hh.

Constructor & Destructor Documentation

G4CrossSectionDataStore::G4CrossSectionDataStore

(

)

Definition at line 63 of file G4CrossSectionDataStore.cc.

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

Here is the call graph for this function:

G4CrossSectionDataStore::~G4CrossSectionDataStore

(

)

Definition at line 76 of file G4CrossSectionDataStore.cc.

{}

Member Function Documentation

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 ) {
        std::ostringstream msg;
        msg<<"Attempting to request FastPath for couple: "<<pdef->GetParticleName()<<","<<mat->GetName();
        msg<<" but combination already exists";
        throw G4HadronicException(__FILE__,__LINE__,msg.str());
    }
}

void G4CrossSectionDataStore::AddDataSet ( G4VCrossSectionDataSet *  p )

inline

Definition at line 160 of file G4CrossSectionDataStore.hh.

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

Here is the caller graph for this function:

void G4CrossSectionDataStore::BuildPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

Definition at line 496 of file G4CrossSectionDataStore.cc.

{
  if (nDataSetList == 0) 
    {
      throw G4HadronicException(__FILE__, __LINE__, 
                "G4CrossSectionDataStore: no data sets registered");
      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;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

Definition at line 573 of file G4CrossSectionDataStore.cc.

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

  G4double ehi = 0;
  G4double elo = 0;
  G4String physListName(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]);         
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CrossSectionDataStore::DumpPhysicsTable

(

const G4ParticleDefinition &

aParticleType

)

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

Here is the caller graph for this function:

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

inline

Definition at line 155 of file G4CrossSectionDataStore.hh.

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

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

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

inline

Definition at line 137 of file G4CrossSectionDataStore.hh.

{ return fastPathFlags; }

Here is the caller graph for this function:

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

inline

Definition at line 135 of file G4CrossSectionDataStore.hh.

{ return fastPathParams; }

Here is the caller graph for this function:

void G4CrossSectionDataStore::PrintCrossSectionHtml

(

const G4VCrossSectionDataSet *

cs

)

const

Definition at line 605 of file G4CrossSectionDataStore.cc.

{
   G4String dirName(getenv("G4PhysListDocDir"));
    G4String physListName(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";

}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 395 of file G4CrossSectionDataStore.cc.

{
  counters.SampleZandA();

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

  G4double cross = GetCrossSection(part, mat , true);
  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4CrossSectionDataStore::SetVerboseLevel ( G4int  value )

inline

Definition at line 166 of file G4CrossSectionDataStore.hh.

{
  verboseLevel = value;
}

Friends And Related Function Documentation

friend struct G4FastPathHadronicCrossSection::fastPathEntry

friend

Definition at line 141 of file G4CrossSectionDataStore.hh.

---

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

• geant4.10.03.p01/source/processes/hadronic/cross_sections/include/G4CrossSectionDataStore.hh
• geant4.10.03.p01/source/processes/hadronic/cross_sections/src/G4CrossSectionDataStore.cc