G4RDBremsstrahlungParameters Class Reference

#include <G4RDBremsstrahlungParameters.hh>

Collaboration diagram for G4RDBremsstrahlungParameters:

Public Member Functions
	G4RDBremsstrahlungParameters (const G4String &name, size_t num, G4int minZ=1, G4int maxZ=99)
	~G4RDBremsstrahlungParameters ()
G4double	Parameter (G4int parameterIndex, G4int Z, G4double energy) const
G4double	ParameterC (G4int index) const
void	PrintData () const

Private Member Functions
	G4RDBremsstrahlungParameters (const G4RDBremsstrahlungParameters &)
G4RDBremsstrahlungParameters &	operator= (const G4RDBremsstrahlungParameters &right)
void	LoadData (const G4String &name)

Private Attributes
std::map< G4int, G4RDVEMDataSet *, std::less< G4int > >	param
G4DataVector	paramC
G4DataVector	activeZ
G4int	zMin
G4int	zMax
size_t	length

Detailed Description

Definition at line 63 of file G4RDBremsstrahlungParameters.hh.

Constructor & Destructor Documentation

G4RDBremsstrahlungParameters() [1/2]

G4RDBremsstrahlungParameters::G4RDBremsstrahlungParameters	(	const G4String &	name,
		size_t	num,
		G4int	minZ = 1,
		G4int	maxZ = 99
	)

Definition at line 53 of file G4RDBremsstrahlungParameters.cc.

  : zMin(minZ),
    zMax(maxZ),
    length(num)
{
  LoadData(name);
}

Here is the call graph for this function:

~G4RDBremsstrahlungParameters()

G4RDBremsstrahlungParameters::~G4RDBremsstrahlungParameters

(

)

Definition at line 63 of file G4RDBremsstrahlungParameters.cc.

{
  // Reset the map of data sets: remove the data sets from the map
  std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::iterator pos;

  for (pos = param.begin(); pos != param.end(); ++pos)
    {
      G4RDVEMDataSet* dataSet = (*pos).second;
      delete dataSet;
    }

  activeZ.clear();
  paramC.clear();
}

G4RDBremsstrahlungParameters() [2/2]

G4RDBremsstrahlungParameters::G4RDBremsstrahlungParameters ( const G4RDBremsstrahlungParameters &  )

private

Member Function Documentation

LoadData()

void G4RDBremsstrahlungParameters::LoadData ( const G4String &  name )

private

Definition at line 104 of file G4RDBremsstrahlungParameters.cc.

{
  // Build the complete string identifying the file with the data set

  // define active elements

  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  if (materialTable == 0)
     G4Exception("G4RDBremsstrahlungParameters::LoadData()",
                 "DataNotFound", FatalException, "No MaterialTable found!");

  G4int nMaterials = G4Material::GetNumberOfMaterials();

  G4double x = 1.e-9;
  for (G4int mm=0; mm<100; mm++) {
    paramC.push_back(x);
  }

  for (G4int m=0; m<nMaterials; m++) {

    const G4Material* material= (*materialTable)[m];
    const G4ElementVector* elementVector = material->GetElementVector();
    const G4int nElements = material->GetNumberOfElements();

    for (G4int iEl=0; iEl<nElements; iEl++) {
      G4Element* element = (*elementVector)[iEl];
      G4double Z = element->GetZ();
      G4int iz = (G4int)Z;
      if(iz < 100)
            paramC[iz] = 0.217635e-33*(material->GetTotNbOfElectPerVolume());
      if (!(activeZ.contains(Z))) {
     activeZ.push_back(Z);
      }
    }
  }

  // Read parameters

  char* path = getenv("G4LEDATA");
  if (path == 0)
    {
      G4String excep("G4LEDATA environment variable not set!");
      G4Exception("G4RDBremsstrahlungParameters::LoadData()",
                  "InvalidSetup", FatalException, excep);
    }

  G4String pathString_a(path);
  G4String name_a = pathString_a + name;
  std::ifstream file_a(name_a);
  std::filebuf* lsdp_a = file_a.rdbuf();

  if (! (lsdp_a->is_open()) )
    {
      G4String stringConversion2("Cannot open file ");
      G4String excep = stringConversion2 + name_a;
      G4Exception("G4RDBremsstrahlungParameters::LoadData()",
                  "FileNotFound", 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 = 0.0;
  G4double sum = 0.0;
  G4int z    = 0;

  std::vector<G4DataVector*> a;
  for (size_t j=0; j<length; j++) {
    G4DataVector* aa = new G4DataVector();
    a.push_back(aa);
  }
  G4DataVector e;
  e.clear();

  do {
    file_a >> ener >> sum;

    // End of file
    if (ener == (G4double)(-2)) {
      break;

      // End of next element
    } else if (ener == (G4double)(-1)) {

      z++;
      G4double Z = (G4double)z;

    // fill map if Z is used
      if (activeZ.contains(Z)) {

    for (size_t k=0; k<length; k++) {

        G4int id = z*length + k;
        G4RDVDataSetAlgorithm* inter  = new G4RDLogLogInterpolation();
        G4DataVector* eVector = new G4DataVector;
        size_t eSize = e.size();
        for (size_t s=0; s<eSize; s++) {
           eVector->push_back(e[s]);
        }
        G4RDVEMDataSet* set = new G4RDEMDataSet(id,eVector,a[k],inter,1.,1.);
            param[id] = set;
    }
        a.clear();
        for (size_t j=0; j<length; j++) {
            G4DataVector* aa = new G4DataVector();
            a.push_back(aa);
        }
      } else {
        for (size_t j=0; j<length; j++) {
          a[j]->clear();
        }
      }
      e.clear();

    } else {

      if(ener > 1000.) ener = 1000.;
      e.push_back(ener);
      a[length-1]->push_back(sum);

      for (size_t j=0; j<length-1; j++) {
    G4double qRead;
    file_a >> qRead;
    a[j]->push_back(qRead);
      }

    }
  } while (ener != (G4double)(-2));

  file_a.close();

}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Parameter()

G4double G4RDBremsstrahlungParameters::Parameter	(	G4int	parameterIndex,
		G4int	Z,
		G4double	energy
	)		const

Definition at line 79 of file G4RDBremsstrahlungParameters.cc.

{
  G4double value = 0.;
  G4int id = Z*length + parameterIndex;
  std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::const_iterator pos;

  pos = param.find(id);
  if (pos!= param.end()) {

    G4RDVEMDataSet* dataSet = (*pos).second;
    const G4DataVector ener = dataSet->GetEnergies(0);
    G4double ee = std::max(ener.front(),std::min(ener.back(),energy));
    value = dataSet->FindValue(ee);

  } else {
    G4cout << "WARNING: G4RDBremsstrahlungParameters::FindValue "
           << "did not find ID = "
           << id << G4endl;
  }

  return value;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParameterC()

G4double G4RDBremsstrahlungParameters::ParameterC

(

G4int

index

)

const

Definition at line 241 of file G4RDBremsstrahlungParameters.cc.

{
  G4int n = paramC.size();
  if (id < 0 || id >= n)
    {
      G4String stringConversion1("Wrong id = ");
      G4String stringConversion2(id);
      G4String ex = stringConversion1 + stringConversion2;
      G4Exception("G4RDBremsstrahlungParameters::ParameterC()",
                  "InvalidSetup", FatalException, ex);
    }

  return paramC[id];
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintData()

void G4RDBremsstrahlungParameters::PrintData

(

)

const

Definition at line 257 of file G4RDBremsstrahlungParameters.cc.

{

  G4cout << G4endl;
  G4cout << "===== G4RDBremsstrahlungParameters =====" << G4endl;
  G4cout << G4endl;
  G4cout << "===== Parameters =====" << G4endl;
  G4cout << G4endl;

  size_t nZ = activeZ.size();
  std::map<G4int,G4RDVEMDataSet*,std::less<G4int> >::const_iterator pos;

  for (size_t j=0; j<nZ; j++) {
    G4int Z = (G4int)activeZ[j];

    for (size_t i=0; i<length; i++) {

      pos = param.find(Z*length + i);
      if (pos!= param.end()) {

        G4cout << "===== Z= " << Z
                 << " parameter[" << i << "]  ====="
                 << G4endl;
        G4RDVEMDataSet* dataSet = (*pos).second;
        dataSet->PrintData();
      }
    }
  }

  G4cout << "==========================================" << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activeZ

G4DataVector G4RDBremsstrahlungParameters::activeZ

private

Definition at line 88 of file G4RDBremsstrahlungParameters.hh.

length

size_t G4RDBremsstrahlungParameters::length

private

Definition at line 93 of file G4RDBremsstrahlungParameters.hh.

param

std::map<G4int,G4RDVEMDataSet*,std::less<G4int> > G4RDBremsstrahlungParameters::param

private

Definition at line 85 of file G4RDBremsstrahlungParameters.hh.

paramC

G4DataVector G4RDBremsstrahlungParameters::paramC

private

Definition at line 87 of file G4RDBremsstrahlungParameters.hh.

zMax

G4int G4RDBremsstrahlungParameters::zMax

private

Definition at line 91 of file G4RDBremsstrahlungParameters.hh.

zMin

G4int G4RDBremsstrahlungParameters::zMin

private

Definition at line 90 of file G4RDBremsstrahlungParameters.hh.

---

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

• G4RDBremsstrahlungParameters.hh
• G4RDBremsstrahlungParameters.cc