G4ParticleHPThermalScatteringData Class Reference

#include <G4ParticleHPThermalScatteringData.hh>

Inheritance diagram for G4ParticleHPThermalScatteringData:

Public Member Functions
	G4ParticleHPThermalScatteringData ()
	~G4ParticleHPThermalScatteringData () override
G4bool	IsIsoApplicable (const G4DynamicParticle *, G4int, G4int, const G4Element *, const G4Material *) override
G4double	GetIsoCrossSection (const G4DynamicParticle *, G4int, G4int, const G4Isotope *, const G4Element *, const G4Material *) override
G4bool	IsApplicable (const G4DynamicParticle *, const G4Element *)
G4double	GetCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetInelasticCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetCoherentCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
G4double	GetIncoherentCrossSection (const G4DynamicParticle *, const G4Element *, const G4Material *)
void	BuildPhysicsTable (const G4ParticleDefinition &) override
void	DumpPhysicsTable (const G4ParticleDefinition &) override
void	AddUserThermalScatteringFile (const G4String &, const G4String &)
void	CrossSectionDescription (std::ostream &) const override
Public Member Functions inherited from G4VCrossSectionDataSet
	G4VCrossSectionDataSet (const G4String &nam="")
virtual	~G4VCrossSectionDataSet ()
virtual G4bool	IsElementApplicable (const G4DynamicParticle *, G4int Z, 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	ComputeCrossSectionPerElement (G4double kinEnergy, G4double loge, const G4ParticleDefinition *, const G4Element *, const G4Material *mat=nullptr)
virtual G4double	GetElementCrossSection (const G4DynamicParticle *, G4int Z, const G4Material *mat=nullptr)
virtual G4double	ComputeIsoCrossSection (G4double kinEnergy, G4double loge, const G4ParticleDefinition *, 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	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
void	SetName (const G4String &nam)
G4VCrossSectionDataSet &	operator= (const G4VCrossSectionDataSet &right)=delete
	G4VCrossSectionDataSet (const G4VCrossSectionDataSet &)=delete

Additional Inherited Members
Protected Attributes inherited from G4VCrossSectionDataSet
G4int	verboseLevel {0}
G4String	name

Detailed Description

Definition at line 56 of file G4ParticleHPThermalScatteringData.hh.

Constructor & Destructor Documentation

G4ParticleHPThermalScatteringData()

G4ParticleHPThermalScatteringData::G4ParticleHPThermalScatteringData

(

)

Definition at line 44 of file G4ParticleHPThermalScatteringData.cc.

  : G4VCrossSectionDataSet("NeutronHPThermalScatteringData")
{
  // Upper limit of neutron energy
  emax = 4 * eV;
  SetMinKinEnergy(0 * MeV);
  SetMaxKinEnergy(emax);
 
  ke_cache = 0.0;
  xs_cache = 0.0;
  element_cache = nullptr;
  material_cache = nullptr;
 
  indexOfThermalElement.clear();
 
  names = new G4ParticleHPThermalScatteringNames();
}

~G4ParticleHPThermalScatteringData()

G4ParticleHPThermalScatteringData::~G4ParticleHPThermalScatteringData ( )

override

Definition at line 62 of file G4ParticleHPThermalScatteringData.cc.

{
  clearCurrentXSData();
 
  delete names;
}

Member Function Documentation

AddUserThermalScatteringFile()

void G4ParticleHPThermalScatteringData::AddUserThermalScatteringFile	(	const G4String &	nameG4Element,
		const G4String &	filename )

Definition at line 445 of file G4ParticleHPThermalScatteringData.cc.

{
  names->AddThermalElement(nameG4Element, filename);
}

BuildPhysicsTable()

void G4ParticleHPThermalScatteringData::BuildPhysicsTable ( const G4ParticleDefinition & aP )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 161 of file G4ParticleHPThermalScatteringData.cc.

{
  if (&aP != G4Neutron::Neutron())
    throw G4HadronicException(__FILE__, __LINE__,
                              "Attempt to use NeutronHP data for particles other than neutrons!!!");
 
  // std::map < std::pair < G4Material* , const G4Element* > , G4int > dic;
  //
  dic.clear();
  if (G4Threading::IsMasterThread()) clearCurrentXSData();
 
  std::map<G4String, G4int> co_dic;
 
  // Searching Nist Materials
  static G4ThreadLocal G4MaterialTable* theMaterialTable = nullptr;
  if (theMaterialTable == nullptr) theMaterialTable = G4Material::GetMaterialTable();
  std::size_t numberOfMaterials = G4Material::GetNumberOfMaterials();
  for (std::size_t i = 0; i < numberOfMaterials; ++i) {
    G4Material* material = (*theMaterialTable)[i];
    auto numberOfElements = (G4int)material->GetNumberOfElements();
    for (G4int j = 0; j < numberOfElements; ++j) {
      const G4Element* element = material->GetElement(j);
      if (names->IsThisThermalElement(material->GetName(), element->GetName())) {
        G4int ts_ID_of_this_geometry;
        G4String ts_ndl_name = names->GetTS_NDL_Name(material->GetName(), element->GetName());
        if (co_dic.find(ts_ndl_name) != co_dic.cend()) {
          ts_ID_of_this_geometry = co_dic.find(ts_ndl_name)->second;
        }
        else {
          ts_ID_of_this_geometry = (G4int)co_dic.size();
          co_dic.insert(std::pair<G4String, G4int>(ts_ndl_name, ts_ID_of_this_geometry));
        }
 
        dic.insert(std::pair<std::pair<G4Material*, const G4Element*>, G4int>(
          std::pair<G4Material*, const G4Element*>(material, element), ts_ID_of_this_geometry));
      }
    }
  }
 
  // Searching TS Elements
  auto theElementTable = G4Element::GetElementTable();
  std::size_t numberOfElements = G4Element::GetNumberOfElements();
 
  for (std::size_t i = 0; i < numberOfElements; ++i) {
    const G4Element* element = (*theElementTable)[i];
    if (names->IsThisThermalElement(element->GetName())) {
      if (names->IsThisThermalElement(element->GetName())) {
        G4int ts_ID_of_this_geometry;
        G4String ts_ndl_name = names->GetTS_NDL_Name(element->GetName());
        if (co_dic.find(ts_ndl_name) != co_dic.cend()) {
          ts_ID_of_this_geometry = co_dic.find(ts_ndl_name)->second;
        }
        else {
          ts_ID_of_this_geometry = (G4int)co_dic.size();
          co_dic.insert(std::pair<G4String, G4int>(ts_ndl_name, ts_ID_of_this_geometry));
        }
 
        dic.insert(std::pair<std::pair<const G4Material*, const G4Element*>, G4int>(
          std::pair<const G4Material*, const G4Element*>((G4Material*)nullptr, element),
          ts_ID_of_this_geometry));
      }
    }
  }
 
  G4cout << G4endl;
  G4cout << "Neutron HP Thermal Scattering Data: Following material-element pairs and/or elements "
            "are registered."
         << G4endl;
  for (const auto& it : dic) {
    if (it.first.first != nullptr) {
      G4cout << "Material " << it.first.first->GetName() << " - Element "
             << it.first.second->GetName() << ",  internal thermal scattering id " << it.second
             << G4endl;
    }
    else {
      G4cout << "Element " << it.first.second->GetName() << ",  internal thermal scattering id "
             << it.second << G4endl;
    }
  }
  G4cout << G4endl;
 
  G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
 
  coherent = hpmanager->GetThermalScatteringCoherentCrossSections();
  incoherent = hpmanager->GetThermalScatteringIncoherentCrossSections();
  inelastic = hpmanager->GetThermalScatteringInelasticCrossSections();
 
  if (G4Threading::IsMasterThread()) {
    if (coherent == nullptr)
      coherent = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
    if (incoherent == nullptr)
      incoherent = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
    if (inelastic == nullptr)
      inelastic = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
 
    // Read Cross Section Data files
 
    G4String dirName;
    if (G4FindDataDir("G4NEUTRONHPDATA") == nullptr)
      throw G4HadronicException(
        __FILE__, __LINE__,
        "Please setenv G4NEUTRONHPDATA to point to the neutron cross-section files.");
    G4String baseName = G4FindDataDir("G4NEUTRONHPDATA");
 
    dirName = baseName + "/ThermalScattering";
 
    G4String ndl_filename;
    G4String full_name;
 
    for (const auto& it : co_dic) {
      ndl_filename = it.first;
      G4int ts_ID = it.second;
 
      // Coherent
      full_name = dirName + "/Coherent/CrossSection/" + ndl_filename;
      auto coh_amapTemp_EnergyCross = readData(full_name);
      coherent->insert(std::pair<G4int, std::map<G4double, G4ParticleHPVector*>*>(
        ts_ID, coh_amapTemp_EnergyCross));
 
      // Incoherent
      full_name = dirName + "/Incoherent/CrossSection/" + ndl_filename;
      auto incoh_amapTemp_EnergyCross = readData(full_name);
      incoherent->insert(std::pair<G4int, std::map<G4double, G4ParticleHPVector*>*>(
        ts_ID, incoh_amapTemp_EnergyCross));
 
      // Inelastic
      full_name = dirName + "/Inelastic/CrossSection/" + ndl_filename;
      auto inela_amapTemp_EnergyCross = readData(full_name);
      inelastic->insert(std::pair<G4int, std::map<G4double, G4ParticleHPVector*>*>(
        ts_ID, inela_amapTemp_EnergyCross));
    }
    hpmanager->RegisterThermalScatteringCoherentCrossSections(coherent);
    hpmanager->RegisterThermalScatteringIncoherentCrossSections(incoherent);
    hpmanager->RegisterThermalScatteringInelasticCrossSections(inelastic);
  }
}

CrossSectionDescription()

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

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 451 of file G4ParticleHPThermalScatteringData.cc.

{
  outFile << "High Precision cross data based on thermal scattering data in evaluated nuclear data "
             "libraries for neutrons below 5eV on specific materials\n";
}

DumpPhysicsTable()

void G4ParticleHPThermalScatteringData::DumpPhysicsTable ( const G4ParticleDefinition & aP )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 322 of file G4ParticleHPThermalScatteringData.cc.

{
  if (&aP != G4Neutron::Neutron())
    throw G4HadronicException(__FILE__, __LINE__,
                              "Attempt to use NeutronHP data for particles other than neutrons!!!");
}

GetCoherentCrossSection()

G4double G4ParticleHPThermalScatteringData::GetCoherentCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM )

Definition at line 361 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
  G4int ts_id = getTS_ID(aM, anE);
  G4double aT = aM->GetTemperature();
  result = GetX(aP, aT, coherent->find(ts_id)->second);
  return result;
}

GetCrossSection()

G4double G4ParticleHPThermalScatteringData::GetCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM )

Definition at line 329 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
 
  G4int ts_id = getTS_ID(aM, anE);
 
  if (ts_id == -1) return result;
 
  G4double aT = aM->GetTemperature();
 
  G4double Xcoh = GetX(aP, aT, coherent->find(ts_id)->second);
  G4double Xincoh = GetX(aP, aT, incoherent->find(ts_id)->second);
  G4double Xinela = GetX(aP, aT, inelastic->find(ts_id)->second);
 
  result = Xcoh + Xincoh + Xinela;
 
  return result;
}

Referenced by GetIsoCrossSection().

GetIncoherentCrossSection()

G4double G4ParticleHPThermalScatteringData::GetIncoherentCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM )

Definition at line 372 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
  G4int ts_id = getTS_ID(aM, anE);
  G4double aT = aM->GetTemperature();
  result = GetX(aP, aT, incoherent->find(ts_id)->second);
  return result;
}

GetInelasticCrossSection()

G4double G4ParticleHPThermalScatteringData::GetInelasticCrossSection	(	const G4DynamicParticle *	aP,
		const G4Element *	anE,
		const G4Material *	aM )

Definition at line 350 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
  G4int ts_id = getTS_ID(aM, anE);
  G4double aT = aM->GetTemperature();
  result = GetX(aP, aT, inelastic->find(ts_id)->second);
  return result;
}

GetIsoCrossSection()

G4double G4ParticleHPThermalScatteringData::GetIsoCrossSection ( const G4DynamicParticle * dp, G4int , G4int , const G4Isotope * , const G4Element * element, const G4Material * material )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 87 of file G4ParticleHPThermalScatteringData.cc.

{
  ke_cache = dp->GetKineticEnergy();
  element_cache = element;
  material_cache = material;
  G4double xs = GetCrossSection(dp, element, material);
  xs_cache = xs;
  return xs;
}

IsApplicable()

G4bool G4ParticleHPThermalScatteringData::IsApplicable	(	const G4DynamicParticle *	aP,
		const G4Element *	anEle )

Definition at line 140 of file G4ParticleHPThermalScatteringData.cc.

{
  G4bool result = false;
 
  G4double eKin = aP->GetKineticEnergy();
  // Check energy
  if (eKin < emax) {
    // Check Particle Species
    if (aP->GetDefinition() == G4Neutron::Neutron()) {
      // anEle is one of Thermal elements
      auto ie = (G4int)anEle->GetIndex();
      for (int it : indexOfThermalElement) {
        if (ie == it) return true;
      }
    }
  }
 
  return result;
}

IsIsoApplicable()

G4bool G4ParticleHPThermalScatteringData::IsIsoApplicable ( const G4DynamicParticle * dp, G4int , G4int , const G4Element * element, const G4Material * material )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 69 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double eKin = dp->GetKineticEnergy();
  if (eKin > 4.0 * eV  // GetMaxKinEnergy()
      || eKin < 0  // GetMinKinEnergy()
      || dp->GetDefinition() != G4Neutron::Neutron())
    return false;
 
  if (dic.find(std::pair<const G4Material*, const G4Element*>((G4Material*)nullptr, element))
        != dic.end()
      || dic.find(std::pair<const G4Material*, const G4Element*>(material, element)) != dic.end())
    return true;
 
  return false;
}

---

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

• G4ParticleHPThermalScatteringData.hh
• G4ParticleHPThermalScatteringData.cc