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 48 of file G4ParticleHPThermalScatteringData.cc.

  : G4VCrossSectionDataSet("NeutronHPThermalScatteringData")
{
  // Upper limit of neutron energy
  emax = 4 * CLHEP::eV;
  SetMinKinEnergy(0 * MeV);
  SetMaxKinEnergy(emax);
 
  ke_cache = 0.0;
  xs_cache = 0.0;
  element_cache = nullptr;
  material_cache = nullptr;
 
  if (nullptr == names) {
    isInitializer = true;
    indexOfThermalElement = new std::vector<G4int>;
    names = new G4ParticleHPThermalScatteringNames();
    dic = new std::map<std::pair<const G4Material*, const G4Element*>, G4int>;
 
    G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
    coherent = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
    incoherent = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
    inelastic = new std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>;
 
    hpmanager->RegisterThermalScatteringCoherentCrossSections(coherent);
    hpmanager->RegisterThermalScatteringIncoherentCrossSections(incoherent);
    hpmanager->RegisterThermalScatteringInelasticCrossSections(inelastic);
  }
}

~G4ParticleHPThermalScatteringData()

G4ParticleHPThermalScatteringData::~G4ParticleHPThermalScatteringData ( )

override

Definition at line 78 of file G4ParticleHPThermalScatteringData.cc.

{
  if (!isInitializer) return;  
 
  clearCurrentXSData(coherent);
  clearCurrentXSData(incoherent);
  clearCurrentXSData(inelastic);
 
  delete names;
  delete dic;
  delete indexOfThermalElement;
  names = nullptr;
  dic = nullptr;
  indexOfThermalElement = nullptr;
}

Member Function Documentation

AddUserThermalScatteringFile()

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

Definition at line 421 of file G4ParticleHPThermalScatteringData.cc.

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

BuildPhysicsTable()

void G4ParticleHPThermalScatteringData::BuildPhysicsTable ( const G4ParticleDefinition & aP )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 153 of file G4ParticleHPThermalScatteringData.cc.

{
  if (&aP != G4Neutron::Neutron()) {
    G4ExceptionDescription ed;
    ed << "Neutron thermal scattering cannot be applied to " << aP.GetParticleName();
 
    G4Exception("G4ParticleHPThermalScatteringData::BuildPhysicsTable","hp0001",
        FatalException, ed, " run stopped");
    return;
  }
 
  // Common initialisation for all threads
  G4ParticleHPManager* hpmanager = G4ParticleHPManager::GetInstance();
  verbose = hpmanager->GetVerboseLevel();
 
  coherent = hpmanager->GetThermalScatteringCoherentCrossSections();
  incoherent = hpmanager->GetThermalScatteringIncoherentCrossSections();
  inelastic = hpmanager->GetThermalScatteringInelasticCrossSections();
 
  // The initialisation is performed only in the master thread
  if (!isInitializer)
    return;
 
  std::map<G4String, G4int> co_dic;
 
  // Searching Materials
  auto const 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 const 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())) {
      G4int ts_ID_of_this_geometry;
      const 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));
    }
  }
 
  if (0 < verbose) {
    G4cout << "##T## Neutron HP Thermal Scattering Data: Following material-element pairs and/or elements "
      "are registered for " << dic->size() << " materials." << G4endl;
 
    if (dic->empty()) return;
    
    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;
  }
  
  // Read Cross Section Data files
  const G4String dirName = hpmanager->GetNeutronHPPath() + "/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));
  }
}

CrossSectionDescription()

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

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 427 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 & )

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 300 of file G4ParticleHPThermalScatteringData.cc.

{}

GetCoherentCrossSection()

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

Definition at line 341 of file G4ParticleHPThermalScatteringData.cc.

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

GetCrossSection()

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

Definition at line 303 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
  G4int ts_id = getTS_ID(aM, anE);
  
  if (ts_id == -1) return result;
 
  G4double aT = aM->GetTemperature();
 
  auto u = coherent->find(ts_id);
  G4double Xcoh = (u != coherent->end()) ? GetX(aP, aT, u->second) : 0.0;
  auto v = incoherent->find(ts_id);
  G4double Xincoh = (v != incoherent->end()) ? GetX(aP, aT, v->second) : 0.0;
  auto w = inelastic->find(ts_id);
  G4double Xinela = (w != inelastic->end()) ? GetX(aP, aT, w->second) : 0.0;
 
  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 354 of file G4ParticleHPThermalScatteringData.cc.

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

GetInelasticCrossSection()

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

Definition at line 326 of file G4ParticleHPThermalScatteringData.cc.

{
  G4double result = 0;
  G4int ts_id = getTS_ID(aM, anE);
  if (ts_id == -1) return result;
  G4double aT = aM->GetTemperature();
  auto ptr = inelastic->find(ts_id);
  if (ptr != inelastic->end()) {
    result = GetX(aP, aT, ptr->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 109 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 138 of file G4ParticleHPThermalScatteringData.cc.

{
  // Check energy
  if (aP->GetKineticEnergy() > emax)
    return false;
 
  // anEle is one of Thermal elements
  auto ie = (G4int)anEle->GetIndex();
  for (auto const& it : *indexOfThermalElement) {
    if (ie == it) return true;
  }
  return false;
}

IsIsoApplicable()

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

overridevirtual

Reimplemented from G4VCrossSectionDataSet.

Definition at line 94 of file G4ParticleHPThermalScatteringData.cc.

{
  if (dp->GetKineticEnergy() > emax)
    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