G4ShellEMDataSet Class Reference

#include <G4ShellEMDataSet.hh>

Inheritance diagram for G4ShellEMDataSet:

Public Member Functions
	G4ShellEMDataSet (G4int Z, G4VDataSetAlgorithm *algo, G4double eUnit=CLHEP::MeV, G4double dataUnit=CLHEP::barn)
virtual	~G4ShellEMDataSet ()
G4double	FindValue (G4double energy, G4int componentId=0) const override
void	PrintData (void) const override
const G4VEMDataSet *	GetComponent (G4int componentId) const override
void	AddComponent (G4VEMDataSet *dataSet) override
size_t	NumberOfComponents (void) const override
const G4DataVector &	GetEnergies (G4int componentId) const override
const G4DataVector &	GetData (G4int componentId) const override
const G4DataVector &	GetLogEnergies (G4int componentId) const override
const G4DataVector &	GetLogData (G4int componentId) const override
void	SetEnergiesData (G4DataVector *energies, G4DataVector *data, G4int componentId) override
void	SetLogEnergiesData (G4DataVector *energies, G4DataVector *data, G4DataVector *log_energies, G4DataVector *log_data, G4int componentId) override
G4bool	LoadData (const G4String &fileName) override
G4bool	LoadNonLogData (const G4String &fileName) override
G4bool	SaveData (const G4String &fileName) const override
G4double	RandomSelect (G4int) const override
	G4ShellEMDataSet (const G4ShellEMDataSet &copy)=delete
G4ShellEMDataSet &	operator= (const G4ShellEMDataSet &right)=delete
Public Member Functions inherited from G4VEMDataSet
	G4VEMDataSet ()
virtual	~G4VEMDataSet ()
	G4VEMDataSet (const G4VEMDataSet &copy)=delete
G4VEMDataSet &	operator= (const G4VEMDataSet &right)=delete

Protected Member Functions
G4double	GetUnitEnergies () const
G4double	GetUnitData () const
const G4VDataSetAlgorithm *	GetAlgorithm () const
void	CleanUpComponents ()

Detailed Description

Definition at line 59 of file G4ShellEMDataSet.hh.

Constructor & Destructor Documentation

G4ShellEMDataSet() [1/2]

G4ShellEMDataSet::G4ShellEMDataSet ( G4int Z, G4VDataSetAlgorithm * algo, G4double eUnit = CLHEP::MeV, G4double dataUnit = CLHEP::barn )

explicit

Definition at line 63 of file G4ShellEMDataSet.cc.

  : 
  algorithm(algo),
  unitEnergies(eUnit),
  unitData(dataUnit),
  z(zeta)
{
  if (algorithm == nullptr) 
    G4Exception("G4ShellEMDataSet::G4ShellEMDataSet()","em0007",
        FatalErrorInArgument, "Interpolation == 0");
}

~G4ShellEMDataSet()

G4ShellEMDataSet::~G4ShellEMDataSet ( )

virtual

Definition at line 78 of file G4ShellEMDataSet.cc.

{
  CleanUpComponents();
  if (algorithm) delete algorithm;
}

G4ShellEMDataSet() [2/2]

G4ShellEMDataSet::G4ShellEMDataSet ( const G4ShellEMDataSet & copy )

delete

Member Function Documentation

AddComponent()

void G4ShellEMDataSet::AddComponent ( G4VEMDataSet * dataSet )

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 73 of file G4ShellEMDataSet.hh.

{ components.push_back(dataSet); }

Referenced by LoadData(), and LoadNonLogData().

CleanUpComponents()

void G4ShellEMDataSet::CleanUpComponents ( )

protected

Definition at line 399 of file G4ShellEMDataSet.cc.

{
  while (!components.empty())
    {
      if (components.back()) delete components.back();
      components.pop_back();
    }
}

Referenced by LoadData(), LoadNonLogData(), and ~G4ShellEMDataSet().

FindValue()

G4double G4ShellEMDataSet::FindValue ( G4double energy, G4int componentId = 0 ) const

overridevirtual

Implements G4VEMDataSet.

Definition at line 85 of file G4ShellEMDataSet.cc.

{
  // Returns the sum over the shells corresponding to e
  G4double value = 0.;
 
  std::vector<G4VEMDataSet *>::const_iterator i(components.begin());
  std::vector<G4VEMDataSet *>::const_iterator end(components.end());
 
  while (i != end)
    {
      value += (*i)->FindValue(energy);
      i++;
    }
 
  return value;
}

GetAlgorithm()

const G4VDataSetAlgorithm * G4ShellEMDataSet::GetAlgorithm ( ) const

inlineprotected

Definition at line 100 of file G4ShellEMDataSet.hh.

{ return algorithm; }   

GetComponent()

const G4VEMDataSet * G4ShellEMDataSet::GetComponent ( G4int componentId ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 72 of file G4ShellEMDataSet.hh.

{ return components[componentId]; }

Referenced by GetData(), GetEnergies(), GetLogData(), GetLogEnergies(), PrintData(), and SaveData().

GetData()

const G4DataVector & G4ShellEMDataSet::GetData ( G4int componentId ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 77 of file G4ShellEMDataSet.hh.

{ return GetComponent(componentId)->GetData(0); }

GetEnergies()

const G4DataVector & G4ShellEMDataSet::GetEnergies ( G4int componentId ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 76 of file G4ShellEMDataSet.hh.

{ return GetComponent(componentId)->GetEnergies(0); }

GetLogData()

const G4DataVector & G4ShellEMDataSet::GetLogData ( G4int componentId ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 80 of file G4ShellEMDataSet.hh.

{ return GetComponent(componentId)->GetLogData(0); }

GetLogEnergies()

const G4DataVector & G4ShellEMDataSet::GetLogEnergies ( G4int componentId ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 78 of file G4ShellEMDataSet.hh.

  { return GetComponent(componentId)->GetLogEnergies(0); }

GetUnitData()

G4double G4ShellEMDataSet::GetUnitData ( ) const

inlineprotected

Definition at line 99 of file G4ShellEMDataSet.hh.

{ return unitData; }

GetUnitEnergies()

G4double G4ShellEMDataSet::GetUnitEnergies ( ) const

inlineprotected

Definition at line 98 of file G4ShellEMDataSet.hh.

{ return unitEnergies; }

LoadData()

G4bool G4ShellEMDataSet::LoadData ( const G4String & fileName )

overridevirtual

Implements G4VEMDataSet.

Definition at line 165 of file G4ShellEMDataSet.cc.

{
  CleanUpComponents();
 
  G4String fullFileName = FullFileName(file);
  std::ifstream in(fullFileName);
 
  if (!in.is_open())
    {
      G4String message("Data file \"");
      message += fullFileName;
      message += "\" not found";
      G4Exception("G4ShellEMDataSet::LoadData()", "em0003",FatalException, message);
      return 0;
    }
  
  G4DataVector* orig_shell_energies = 0;
  G4DataVector* orig_shell_data = 0;
  G4DataVector* log_shell_energies = 0;
  G4DataVector* log_shell_data = 0;
 
  G4double a = 0.;
  G4int shellIndex = 0;
  G4int k = 0;
  G4int nColumns = 2;
 
  do
    {
      in >> a;
 
      if (a==0.) a=1e-300;
 
      // The file is organized into four columns:
      // 1st column contains the values of energy
      // 2nd column contains the corresponding data value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
      //
      if (a == -1)
    {
      if ((k%nColumns == 0) && (orig_shell_energies != 0) )
        {
         AddComponent(new G4EMDataSet(shellIndex, orig_shell_energies, 
                      orig_shell_data, log_shell_energies, 
                      log_shell_data, algorithm->Clone(), 
                      unitEnergies, unitData));
          orig_shell_energies = 0;
          orig_shell_data = 0;
              log_shell_energies = 0;
              log_shell_data = 0;
        }
    }
      else if (a != -2)
    {
      if (orig_shell_energies == 0)
        {
         orig_shell_energies = new G4DataVector;
         orig_shell_data = new G4DataVector;
             log_shell_energies = new G4DataVector;
             log_shell_data = new G4DataVector;
        }
      if (k%nColumns == 0)
            {
         orig_shell_energies->push_back(a*unitEnergies);
         log_shell_energies->push_back(std::log10(a) + std::log10(unitEnergies));
            }
      else if (k%nColumns == 1)
            {
         orig_shell_data->push_back(a*unitData);
             log_shell_data->push_back(std::log10(a) + std::log10(unitData));
            }
          k++;
    }
      else k = 1;
    }
  while (a != -2);  // End of file
 
  delete orig_shell_energies;
  delete orig_shell_data;
  delete log_shell_energies;
  delete log_shell_data;
 
  return true;
}

LoadNonLogData()

G4bool G4ShellEMDataSet::LoadNonLogData ( const G4String & fileName )

overridevirtual

Implements G4VEMDataSet.

Definition at line 252 of file G4ShellEMDataSet.cc.

{
  CleanUpComponents();
 
  G4String fullFileName = FullFileName(file);
  std::ifstream in(fullFileName);
 
  if (!in.is_open())
    {
      G4String message("G4ShellEMDataSet::LoadData - data file \"");
      message += fullFileName;
      message += "\" not found";
      G4Exception("G4ShellEMDataSet::LoadNonLogData()", "em0003",FatalException, message);
      return 0;
    }
 
  G4DataVector* orig_shell_energies = 0;
  G4DataVector* orig_shell_data = 0;
 
  G4double a = 0.;
  G4int shellIndex = 0;
  G4int k = 0;
  G4int nColumns = 2;
 
  do
    {
      in >> a;
      // The file is organized into four columns:
      // 1st column contains the values of energy
      // 2nd column contains the corresponding data value
      // The file terminates with the pattern: -1   -1
      //                                       -2   -2
      //
      if (a == -1)
    {
      if ((k%nColumns == 0) && (orig_shell_energies != 0) )
        {
         AddComponent(new G4EMDataSet(shellIndex, orig_shell_energies, 
                      orig_shell_data, algorithm->Clone(), 
                      unitEnergies, unitData));
          orig_shell_energies = 0;
          orig_shell_data = 0;
        }
    }
      else if (a != -2)
    {
      if (orig_shell_energies == 0)
        {
         orig_shell_energies = new G4DataVector;
         orig_shell_data = new G4DataVector;
        }
      if (k%nColumns == 0)
            {
         orig_shell_energies->push_back(a*unitEnergies);
            }
      else if (k%nColumns == 1)
            {
         orig_shell_data->push_back(a*unitData);
            }
          k++;
    }
      else k = 1;
    }
  while (a != -2);  // End of file
 
 
  delete orig_shell_energies;
  delete orig_shell_data;
 
  return true;
}

NumberOfComponents()

size_t G4ShellEMDataSet::NumberOfComponents ( void ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 74 of file G4ShellEMDataSet.hh.

{ return components.size(); }

Referenced by PrintData(), and SaveData().

operator=()

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

delete

PrintData()

void G4ShellEMDataSet::PrintData ( void ) const

overridevirtual

Implements G4VEMDataSet.

Definition at line 104 of file G4ShellEMDataSet.cc.

{
  const G4int n = (G4int)NumberOfComponents();
 
  G4cout << "The data set has " << n << " components" << G4endl;
  G4cout << G4endl;
 
  G4int i = 0;
 
  while (i < n)
    {
      G4cout << "--- Component " << i << " ---" << G4endl;
      GetComponent(i)->PrintData();
      ++i;
    }
}

RandomSelect()

G4double G4ShellEMDataSet::RandomSelect ( G4int ) const

inlineoverridevirtual

Implements G4VEMDataSet.

Definition at line 92 of file G4ShellEMDataSet.hh.

{ return -1.; };

SaveData()

G4bool G4ShellEMDataSet::SaveData ( const G4String & fileName ) const

overridevirtual

Implements G4VEMDataSet.

Definition at line 326 of file G4ShellEMDataSet.cc.

{
  G4String fullFileName = FullFileName(file);
  std::ofstream out(fullFileName);
 
  if (!out.is_open())
    {
      G4String message("Cannot open \"");
      message += fullFileName;
      message += "\"";
      G4Exception("G4EMDataSet::SaveData()","em0005",FatalException,message);
    }
 
  const G4int n = (G4int)NumberOfComponents();
  G4int k = 0;
 
  while (k < n)
    {
      const G4VEMDataSet* component = GetComponent(k);
  
      if (component)
    {
      const G4DataVector& energies = component->GetEnergies(0);
      const G4DataVector& data = component->GetData(0);
 
      G4DataVector::const_iterator i = energies.cbegin();
      G4DataVector::const_iterator endI = energies.cend();
      G4DataVector::const_iterator j = data.cbegin();
  
      while (i != endI)
        {
          out.precision(10);
          out.width(15);
          out.setf(std::ofstream::left);
          out << ((*i)/unitEnergies) << ' ';
 
          out.precision(10);
          out.width(15);
          out.setf(std::ofstream::left);
          out << ((*j)/unitData) << std::endl;
          i++;
          j++;
        }
    }
  
      out.precision(10);
      out.width(15);
      out.setf(std::ofstream::left);
      out << -1.f << ' ';
 
      out.precision(10);
      out.width(15);
      out.setf(std::ofstream::left);
      out << -1.f << std::endl;
  
      k++;
    }
 
  out.precision(10);
  out.width(15);
  out.setf(std::ofstream::left);
  out << -2.f << ' ';
 
  out.precision(10);
  out.width(15);
  out.setf(std::ofstream::left);
  out << -2.f << std::endl;
 
  return true;
}

SetEnergiesData()

void G4ShellEMDataSet::SetEnergiesData ( G4DataVector * energies, G4DataVector * data, G4int componentId )

overridevirtual

Implements G4VEMDataSet.

Definition at line 123 of file G4ShellEMDataSet.cc.

{
  G4VEMDataSet* component = components[componentId]; 
  if (component)
    {
      component->SetEnergiesData(energies, data, 0);
      return;
    }
 
  G4String msg = "component ";
  msg += static_cast<char>(componentId);
  msg += " not found";
 
  G4Exception("G4ShellEMDataSet::SetEnergiesData()","em0008", FatalErrorInArgument ,msg);
}

SetLogEnergiesData()

void G4ShellEMDataSet::SetLogEnergiesData ( G4DataVector * energies, G4DataVector * data, G4DataVector * log_energies, G4DataVector * log_data, G4int componentId )

overridevirtual

Implements G4VEMDataSet.

Definition at line 143 of file G4ShellEMDataSet.cc.

{
  G4VEMDataSet* component = components[componentId]; 
  if (component)
    {
      component->SetLogEnergiesData(energies, data, log_energies, log_data, 0);
      return;
    }
 
  G4String msg = "component ";
  msg += static_cast<char>(componentId);
  msg += " not found";
  G4Exception("G4ShellEMDataSet::SetLogEnergiesData()","em0008", 
          FatalErrorInArgument ,msg);
}

---

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

• G4ShellEMDataSet.hh
• G4ShellEMDataSet.cc