G4eIonisationParameters Class Reference

#include <G4eIonisationParameters.hh>

Public Member Functions
G4double	Excitation (G4int Z, G4double e) const
	G4eIonisationParameters ()
	G4eIonisationParameters (const G4eIonisationParameters &)=delete
G4eIonisationParameters &	operator= (const G4eIonisationParameters &right)=delete
G4double	Parameter (G4int Z, G4int shellIndex, G4int parameterIndex, G4double e) const
void	PrintData () const
	~G4eIonisationParameters ()

Private Member Functions
void	LoadData ()

Private Attributes
G4DataVector	activeZ
std::map< G4int, G4VEMDataSet *, std::less< G4int > >	excit
size_t	length = 24
std::map< G4int, G4VEMDataSet *, std::less< G4int > >	param

Detailed Description

Definition at line 58 of file G4eIonisationParameters.hh.

Constructor & Destructor Documentation

G4eIonisationParameters() [1/2]

G4eIonisationParameters::G4eIonisationParameters ( )

explicit

Definition at line 63 of file G4eIonisationParameters.cc.

{
  LoadData();
}

References LoadData().

~G4eIonisationParameters()

G4eIonisationParameters::~G4eIonisationParameters

(

)

Definition at line 70 of file G4eIonisationParameters.cc.

{ 
  // Reset the map of data sets: remove the data sets from the map 
  for (auto& pos : param)
    {
      G4VEMDataSet* dataSet =  pos.second;
      delete dataSet;
      dataSet = nullptr;
    }
  for (auto& pos : excit)
    { 
      G4VEMDataSet* dataSet =  pos.second;
      delete dataSet;
      dataSet = nullptr;
    }
  activeZ.clear();
}

References activeZ, excit, param, and pos.

G4eIonisationParameters() [2/2]

G4eIonisationParameters::G4eIonisationParameters ( const G4eIonisationParameters &  )

delete

Member Function Documentation

Excitation()

G4double G4eIonisationParameters::Excitation	(	G4int	Z,
		G4double	e
	)		const

Definition at line 124 of file G4eIonisationParameters.cc.

{
  G4double value = 0.;
  auto pos = excit.find(Z);
  if (pos!= excit.end()) {
    G4VEMDataSet* dataSet = (*pos).second;
 
    const G4DataVector ener = dataSet->GetEnergies(0);
    G4double ee = std::max(ener.front(),std::min(ener.back(),e));
    value = dataSet->FindValue(ee);
  } else {
    G4cout << "WARNING: G4IonisationParameters::Excitation "
           << "did not find ID = "
           << Z << G4endl;
  }
 
  return value;
}

References excit, G4VEMDataSet::FindValue(), G4cout, G4endl, G4VEMDataSet::GetEnergies(), G4INCL::Math::max(), G4INCL::Math::min(), pos, and Z.

Referenced by G4eIonisationSpectrum::Excitation().

LoadData()

void G4eIonisationParameters::LoadData ( )

private

Definition at line 145 of file G4eIonisationParameters.cc.

{
  // ---------------------------------------
  // Please document what are the parameters 
  // ---------------------------------------
 
  // define active elements
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == nullptr)
     G4Exception("G4eIonisationParameters::LoadData",
            "em1001",FatalException,"Unable to find MaterialTable");
 
  G4int nMaterials = G4Material::GetNumberOfMaterials();
  
  for (G4int mLocal=0; mLocal<nMaterials; mLocal++) {
 
    const G4Material* material= (*materialTable)[mLocal];        
    const G4ElementVector* elementVector = material->GetElementVector();
    const size_t nElements = material->GetNumberOfElements();
      
    for (size_t iEl=0; iEl<nElements; iEl++) {
      G4double Z = (*elementVector)[iEl]->GetZ();
      if (!(activeZ.contains(Z))) {
    activeZ.push_back(Z);
      }
    }
  }
  
  char* path = std::getenv("G4LEDATA");
  if (!path)
    { 
      G4Exception("G4BremsstrahlungParameters::LoadData",
            "em0006",FatalException,"G4LEDATA environment variable not set");
      return;
    }
    
  G4String pathString(path);
  G4String path2("/ioni/ion-sp-");
  pathString += path2;  
  
  G4double energy, sum;
  
  size_t nZ = activeZ.size();
  
  for (size_t i=0; i<nZ; i++) {
    
    G4int Z = (G4int)activeZ[i];
    std::ostringstream ost;
    ost << pathString << Z << ".dat";
    G4String name(ost.str());
 
    std::ifstream file(name);
    std::filebuf* lsdp = file.rdbuf();
 
    if (! (lsdp->is_open()) ) {
      G4String excep = G4String("data file: ")
      + name + G4String(" not found");
      G4Exception("G4eIonisationParameters::LoadData",
            "em0003",FatalException,excep);
    }
 
    // The file is organized into:
    // For each shell there are two lines:
    //    1st line:
    // 1st column is the energy of incident e-,
    // 2d  column is the parameter of screan term;
    //    2d line:
    // 3 energy (MeV) subdividing different approximation area of the spectrum
    // 20 point on the spectrum
    // The shell terminates with the pattern: -1   -1
    // The file terminates with the pattern: -2   -2
 
    std::vector<G4VEMDataSet*> p;
    for (size_t k=0; k<length; k++) 
      {
    G4VDataSetAlgorithm* inter = new G4LinLogLogInterpolation();
    G4VEMDataSet* composite = new G4CompositeEMDataSet(inter,1.,1.);
    p.push_back(composite);
      }
 
    G4int shell = 0;
    std::vector<G4DataVector*> a;
    a.resize(length);
    G4DataVector e;
    G4bool isReady = false;
    do {
      file >> energy >> sum;
      //Check if energy is valid
      if (energy < -2)
    {
      G4String excep("invalid data file");
          G4Exception("G4eIonisationParameters::LoadData",
            "em0005",FatalException,excep);
      return;
    }
 
      if (energy == -2) break;
 
      if (energy >  -1) {
    // new energy
    if(!isReady) {
      isReady = true;
      e.clear();
      for (size_t j=0; j<length; ++j) { 
        a[j] = new G4DataVector(); 
      }  
    }
        e.push_back(energy);
        a[0]->push_back(sum);
        for (size_t j=1; j<length; ++j) {
      G4double qRead;
      file >> qRead;
      a[j]->push_back(qRead);
    }    
 
      } else {
 
        // End of set for a shell, fill the map
    for (size_t k=0; k<length; k++) {
 
          G4VDataSetAlgorithm* interp;
          if(0 == k) { interp  = new G4LinLogLogInterpolation(); }
          else       { interp  = new G4LogLogInterpolation(); }
 
      G4DataVector* eVector = new G4DataVector;
      size_t eSize = e.size();
      for (size_t sLocal=0; sLocal<eSize; sLocal++) {
        eVector->push_back(e[sLocal]);
      }
      G4VEMDataSet* set = new G4EMDataSet(shell,eVector,a[k],interp,1.,1.);
 
      p[k]->AddComponent(set);
    } 
      
    // next shell
        ++shell;
        isReady = false;
      }
    } while (energy > -2);
    
    file.close();
 
    for (size_t kk=0; kk<length; kk++) 
      {
    G4int id = Z*100 + kk;
    param[id] = p[kk];
      }
  }
 
  G4String pathString_a(path);
  G4String name_a = pathString_a + G4String("/ioni/ion-ex-av.dat");  
  std::ifstream file_a(name_a);
  std::filebuf* lsdp_a = file_a.rdbuf();
  G4String pathString_b(path);
  G4String name_b = pathString_b + G4String("/ioni/ion-ex-sig.dat");  
  std::ifstream file_b(name_b);
  std::filebuf* lsdp_b = file_b.rdbuf();
  
  if (! (lsdp_a->is_open()) ) {
     G4String excep = G4String("cannot open file ")
                    + name_a;
     G4Exception("G4eIonisationParameters::LoadData",
            "em0003",FatalException,excep);
  }  
  if (! (lsdp_b->is_open()) ) {
     G4String excep = G4String("cannot open file ")
                    + name_b;
     G4Exception("G4eIonisationParameters::LoadData",
            "em0003",FatalException,excep);
  }  
 
  // The file is organized into two columns:
  // 1st column is the energy
  // 2nd column is the corresponding value
  // The file terminates with the pattern: -1   -1
  //                                       -2   -2
 
  G4double ener, ener1, sig, sig1;
  G4int z    = 0;
 
  G4DataVector e;
  e.clear();
  G4DataVector d;
  d.clear();
 
  do {
    file_a >> ener >> sig;
    file_b >> ener1 >> sig1;
    
    if(ener != ener1) {
      G4cout << "G4eIonisationParameters: problem in excitation data "
             << "ener= " << ener
             << " ener1= " << ener1
             << G4endl;
    }
 
    // End of file
    if (ener == -2) {
      break;
 
      // End of next element
    } else if (ener == -1) {
 
      z++;
      G4double Z = (G4double)z;
    
    // fill map if Z is used
      if (activeZ.contains(Z)) {
 
    G4VDataSetAlgorithm* inter  = new G4LinInterpolation();
    G4DataVector* eVector = new G4DataVector;
    G4DataVector* dVector = new G4DataVector;
    size_t eSize = e.size();
    for (size_t sLocal2=0; sLocal2<eSize; sLocal2++) {
           eVector->push_back(e[sLocal2]);
           dVector->push_back(d[sLocal2]);
    }
    G4VEMDataSet* set = new G4EMDataSet(z,eVector,dVector,inter,1.,1.);
        excit[z] = set; 
      }
      e.clear();
      d.clear();
  
    } else {
 
      e.push_back(ener*MeV);
      d.push_back(sig1*sig*barn*MeV);
    }
  } while (ener != -2);
  
  file_a.close();
 
}

References activeZ, barn, G4DataVector::contains(), G4INCL::KinematicsUtils::energy(), excit, FatalException, geant4_check_module_cycles::file, G4cout, G4endl, G4Exception(), G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), length, eplot::material, MeV, G4InuclParticleNames::name(), param, and Z.

Referenced by G4eIonisationParameters().

operator=()

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

delete

Parameter()

G4double G4eIonisationParameters::Parameter	(	G4int	Z,
		G4int	shellIndex,
		G4int	parameterIndex,
		G4double	e
	)		const

Definition at line 90 of file G4eIonisationParameters.cc.

{
  G4double value = 0.;
  G4int id = Z*100 + parameterIndex;
 
  auto pos = param.find(id);
  if (pos!= param.end()) {
    G4VEMDataSet* dataSet = (*pos).second;
    G4int nShells = dataSet->NumberOfComponents();
 
    if(shellIndex < nShells) { 
      const G4VEMDataSet* component = dataSet->GetComponent(shellIndex);
      const G4DataVector ener = component->GetEnergies(0);
      G4double ee = std::max(ener.front(),std::min(ener.back(),e));
      value = component->FindValue(ee);
    } else {
      G4cout << "WARNING: G4IonisationParameters::FindParameter "
             << "has no parameters for shell= " << shellIndex 
             << "; Z= " << Z
             << G4endl;
    }
  } else {
    G4cout << "WARNING: G4IonisationParameters::Parameter "
           << "did not find ID = "
           << shellIndex << G4endl;
  }
 
  return value;
}

References G4VEMDataSet::FindValue(), G4cout, G4endl, G4VEMDataSet::GetComponent(), G4VEMDataSet::GetEnergies(), G4INCL::Math::max(), G4INCL::Math::min(), G4VEMDataSet::NumberOfComponents(), param, pos, and Z.

Referenced by G4eIonisationSpectrum::AverageEnergy(), G4eIonisationSpectrum::Probability(), and G4eIonisationSpectrum::SampleEnergy().

PrintData()

void G4eIonisationParameters::PrintData

(

void

)

const

Definition at line 382 of file G4eIonisationParameters.cc.

{
  G4cout << G4endl;
  G4cout << "===== G4eIonisationParameters =====" << G4endl;
  G4cout << G4endl;
 
  size_t nZ = activeZ.size();
  std::map<G4int,G4VEMDataSet*,std::less<G4int> >::const_iterator pos;
 
  for (size_t i=0; i<nZ; i++) {
    G4int Z = (G4int)activeZ[i];      
 
    for (size_t j=0; j<length; j++) {
    
      G4int index = Z*100 + j;
 
      pos = param.find(index);
      if (pos!= param.end()) {
        G4VEMDataSet* dataSet = (*pos).second;
        size_t nShells = dataSet->NumberOfComponents();
 
        for (size_t k=0; k<nShells; k++) {
 
          G4cout << "===== Z= " << Z << " shell= " << k 
                 << " parameter[" << j << "]  =====" 
                 << G4endl;
          const G4VEMDataSet* comp = dataSet->GetComponent(k);
          comp->PrintData();
    }
      }
    }
  }
  G4cout << "====================================" << G4endl;
}

References activeZ, G4cout, G4endl, G4VEMDataSet::GetComponent(), length, G4VEMDataSet::NumberOfComponents(), param, pos, G4VEMDataSet::PrintData(), and Z.

Referenced by G4eIonisationSpectrum::PrintData().

Field Documentation

activeZ

G4DataVector G4eIonisationParameters::activeZ

private

Definition at line 76 of file G4eIonisationParameters.hh.

Referenced by LoadData(), PrintData(), and ~G4eIonisationParameters().

excit

std::map<G4int,G4VEMDataSet*,std::less<G4int> > G4eIonisationParameters::excit

private

Definition at line 79 of file G4eIonisationParameters.hh.

Referenced by Excitation(), LoadData(), and ~G4eIonisationParameters().

length

size_t G4eIonisationParameters::length = 24

private

Definition at line 81 of file G4eIonisationParameters.hh.

Referenced by LoadData(), and PrintData().

param

std::map<G4int,G4VEMDataSet*,std::less<G4int> > G4eIonisationParameters::param

private

Definition at line 78 of file G4eIonisationParameters.hh.

Referenced by LoadData(), Parameter(), PrintData(), and ~G4eIonisationParameters().

---

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

• source/processes/electromagnetic/lowenergy/include/G4eIonisationParameters.hh
• source/processes/electromagnetic/lowenergy/src/G4eIonisationParameters.cc