G4PenelopeCrossSection Class Reference

#include <G4PenelopeCrossSection.hh>

Collaboration diagram for G4PenelopeCrossSection:

Public Member Functions
	G4PenelopeCrossSection (size_t nOfEnergyPoints, size_t nOfShells=0)
	~G4PenelopeCrossSection ()
G4double	GetTotalCrossSection (G4double energy) const
	Returns total cross section at the given energy. More...
G4double	GetHardCrossSection (G4double energy) const
	Returns hard cross section at the given energy. More...
G4double	GetSoftStoppingPower (G4double energy) const
	Returns the total stopping power due to soft collisions. More...
G4double	GetShellCrossSection (size_t shellID, G4double energy) const
	Returns the hard cross section for the given shell (per molecule) More...
G4double	GetNormalizedShellCrossSection (size_t shellID, G4double energy) const
	Returns the hard cross section for the given shell (normalized to 1) More...
size_t	GetNumberOfShells () const
void	AddCrossSectionPoint (size_t binNumber, G4double energy, G4double XH0, G4double XH1, G4double XH2, G4double XS0, G4double XS1, G4double XS2)
void	AddShellCrossSectionPoint (size_t binNumber, size_t shellID, G4double energy, G4double xs)
void	NormalizeShellCrossSections ()

Private Member Functions
G4PenelopeCrossSection &	operator= (const G4PenelopeCrossSection &right)
	G4PenelopeCrossSection (const G4PenelopeCrossSection &)

Private Attributes
G4bool	isNormalized
size_t	numberOfEnergyPoints
size_t	numberOfShells
G4PhysicsTable *	softCrossSections
G4PhysicsTable *	hardCrossSections
G4PhysicsTable *	shellCrossSections
G4PhysicsTable *	shellNormalizedCrossSections

Detailed Description

Definition at line 72 of file G4PenelopeCrossSection.hh.

Constructor & Destructor Documentation

G4PenelopeCrossSection() [1/2]

G4PenelopeCrossSection::G4PenelopeCrossSection	(	size_t	nOfEnergyPoints,
		size_t	nOfShells = 0
	)

Definition at line 45 of file G4PenelopeCrossSection.cc.

                                                                             :
  numberOfEnergyPoints(nPointsE),numberOfShells(nShells),softCrossSections(0),
  hardCrossSections(0),shellCrossSections(0),shellNormalizedCrossSections(0)
{
  //check the number of points is not zero
  if (!numberOfEnergyPoints)
    {
      G4ExceptionDescription ed;
      ed << "G4PenelopeCrossSection: invalid number of energy points " << G4endl;
      G4Exception("G4PenelopeCrossSection::G4PenelopeCrossSection()",
          "em2017",FatalException,ed);
    }

  isNormalized = false;

  // 1) soft XS table
  softCrossSections = new G4PhysicsTable();
  //the table contains 3 G4PhysicsFreeVectors,
  //(softCrossSections)[0] -->  log XS0 vs. log E
  //(softCrossSections)[1] -->  log XS1 vs. log E
  //(softCrossSections)[2] -->  log XS2 vs. log E

  //everything is log-log
  for (size_t i=0;i<3;i++)
    softCrossSections->push_back(new G4PhysicsFreeVector(numberOfEnergyPoints));

  //2) hard XS table
  hardCrossSections = new G4PhysicsTable();
  //the table contains 3 G4PhysicsFreeVectors,
  //(hardCrossSections)[0] -->  log XH0 vs. log E
  //(hardCrossSections)[1] -->  log XH1 vs. log E
  //(hardCrossSections)[2] -->  log XH2 vs. log E

  //everything is log-log
  for (size_t i=0;i<3;i++)
    hardCrossSections->push_back(new G4PhysicsFreeVector(numberOfEnergyPoints));

  //3) shell XS table, if it is the case
  if (numberOfShells)
    {
      shellCrossSections = new G4PhysicsTable();
      shellNormalizedCrossSections = new G4PhysicsTable();
      //the table has to contain numberofShells G4PhysicsFreeVectors,
      //(theTable)[ishell] --> cross section for shell #ishell
      for (size_t i=0;i<numberOfShells;i++)
    {
      shellCrossSections->push_back(new G4PhysicsFreeVector(numberOfEnergyPoints));
      shellNormalizedCrossSections->push_back(new G4PhysicsFreeVector(numberOfEnergyPoints));
    }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

~G4PenelopeCrossSection()

G4PenelopeCrossSection::~G4PenelopeCrossSection

(

)

Definition at line 98 of file G4PenelopeCrossSection.cc.

{
  //clean up tables
  if (shellCrossSections)
    {
      //shellCrossSections->clearAndDestroy();
      delete shellCrossSections;
    }
  if (shellNormalizedCrossSections)
    {
      //shellNormalizedCrossSections->clearAndDestroy();
      delete shellNormalizedCrossSections;
    }
  if (softCrossSections)
    {
      //softCrossSections->clearAndDestroy();
      delete softCrossSections;
    }
  if (hardCrossSections)
    {
      //hardCrossSections->clearAndDestroy();
      delete hardCrossSections;
    }
}

G4PenelopeCrossSection() [2/2]

G4PenelopeCrossSection::G4PenelopeCrossSection ( const G4PenelopeCrossSection &  )

private

Member Function Documentation

AddCrossSectionPoint()

void G4PenelopeCrossSection::AddCrossSectionPoint	(	size_t	binNumber,
		G4double	energy,
		G4double	XH0,
		G4double	XH1,
		G4double	XH2,
		G4double	XS0,
		G4double	XS1,
		G4double	XS2
	)

Public interface for the master thread

Definition at line 124 of file G4PenelopeCrossSection.cc.

{
  if (!softCrossSections || !hardCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::AddCrossSectionPoint" <<
    G4endl;
      G4cout << "Trying to fill un-initialized tables" << G4endl;
      return;
    }

  //fill vectors
  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*softCrossSections)[0];

  if (binNumber >= numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::AddCrossSectionPoint" <<
    G4endl;
      G4cout << "Trying to register more points than originally declared" << G4endl;
      return;
    }
   G4double logEne = std::log(energy);

   //XS0
   G4double val = std::log(std::max(XS0,1e-42*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   //XS1
   theVector = (G4PhysicsFreeVector*) (*softCrossSections)[1];
   val =  std::log(std::max(XS1,1e-42*eV*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   //XS2
   theVector = (G4PhysicsFreeVector*) (*softCrossSections)[2];
   val =  std::log(std::max(XS2,1e-42*eV*eV*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   //XH0
   theVector = (G4PhysicsFreeVector*) (*hardCrossSections)[0];
   val =  std::log(std::max(XH0,1e-42*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   //XH1
   theVector = (G4PhysicsFreeVector*) (*hardCrossSections)[1];
   val =  std::log(std::max(XH1,1e-42*eV*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

    //XH2
   theVector = (G4PhysicsFreeVector*) (*hardCrossSections)[2];
   val =  std::log(std::max(XH2,1e-42*eV*eV*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddShellCrossSectionPoint()

void G4PenelopeCrossSection::AddShellCrossSectionPoint	(	size_t	binNumber,
		size_t	shellID,
		G4double	energy,
		G4double	xs
	)

Definition at line 184 of file G4PenelopeCrossSection.cc.

{
  if (!shellCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::AddShellCrossSectionPoint" <<
    G4endl;
      G4cout << "Trying to fill un-initialized table" << G4endl;
      return;
    }

  if (shellID >= numberOfShells)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::AddShellCrossSectionPoint" <<
    G4endl;
      G4cout << "Trying to fill shell #" << shellID << " while the maximum is "
         <<  numberOfShells-1 << G4endl;
      return;
    }

  //fill vector
  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*shellCrossSections)[shellID];

  if (binNumber >= numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::AddShellCrossSectionPoint" <<
    G4endl;
      G4cout << "Trying to register more points than originally declared" << G4endl;
      return;
    }
   G4double logEne = std::log(energy);
   G4double val = std::log(std::max(xs,1e-42*cm2)); //avoid log(0)
   theVector->PutValue(binNumber,logEne,val);

   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetHardCrossSection()

G4double G4PenelopeCrossSection::GetHardCrossSection

(

G4double

energy

)

const

Returns hard cross section at the given energy.

Definition at line 269 of file G4PenelopeCrossSection.cc.

{
  G4double result = 0;
  //take here XH0
  if (!hardCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetHardCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return result;
    }

  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*hardCrossSections)[0];
  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetHardCrossSection" <<
    G4endl;
      G4cout << "Hard cross section table looks not filled" << G4endl;
      return result;
    }
  G4double logene = std::log(energy);
  G4double logXS = theVector->Value(logene);
  result = G4Exp(logXS);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetNormalizedShellCrossSection()

G4double G4PenelopeCrossSection::GetNormalizedShellCrossSection	(	size_t	shellID,
		G4double	energy
	)		const

Returns the hard cross section for the given shell (normalized to 1)

Definition at line 364 of file G4PenelopeCrossSection.cc.

{
  G4double result = 0;
  if (!shellNormalizedCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return result;
    }

  if (!isNormalized)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" << G4endl;
      G4cout << "The table of normalized cross section is not initialized" << G4endl;
    }


  if (shellID >= numberOfShells)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve shell #" << shellID << " while the maximum is "
         <<  numberOfShells-1 << G4endl;
      return result;
    }

  const G4PhysicsFreeVector* theVector =
    (G4PhysicsFreeVector*) (*shellNormalizedCrossSections)[shellID];

  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Shell cross section table looks not filled" << G4endl;
      return result;
    }
  G4double logene = std::log(energy);
  G4double logXS = theVector->Value(logene);
  result = G4Exp(logXS);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetNumberOfShells()

size_t G4PenelopeCrossSection::GetNumberOfShells ( ) const

inline

Definition at line 94 of file G4PenelopeCrossSection.hh.

{return numberOfShells;};

Here is the call graph for this function:

GetShellCrossSection()

G4double G4PenelopeCrossSection::GetShellCrossSection	(	size_t	shellID,
		G4double	energy
	)		const

Returns the hard cross section for the given shell (per molecule)

Definition at line 328 of file G4PenelopeCrossSection.cc.

{
  G4double result = 0;
  if (!shellCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return result;
    }
  if (shellID >= numberOfShells)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve shell #" << shellID << " while the maximum is "
         <<  numberOfShells-1 << G4endl;
      return result;
    }

  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*shellCrossSections)[shellID];

  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Shell cross section table looks not filled" << G4endl;
      return result;
    }
  G4double logene = std::log(energy);
  G4double logXS = theVector->Value(logene);
  result = G4Exp(logXS);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetSoftStoppingPower()

G4double G4PenelopeCrossSection::GetSoftStoppingPower

(

G4double

energy

)

const

Returns the total stopping power due to soft collisions.

Definition at line 299 of file G4PenelopeCrossSection.cc.

{
  G4double result = 0;
  //take here XH0
  if (!softCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetSoftStoppingPower" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return result;
    }

  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*softCrossSections)[1];
  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetSoftStoppingPower" <<
    G4endl;
      G4cout << "Soft cross section table looks not filled" << G4endl;
      return result;
    }
  G4double logene = std::log(energy);
  G4double logXS = theVector->Value(logene);
  result = G4Exp(logXS);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetTotalCrossSection()

G4double G4PenelopeCrossSection::GetTotalCrossSection

(

G4double

energy

)

const

Returns total cross section at the given energy.

Definition at line 225 of file G4PenelopeCrossSection.cc.

{
  G4double result = 0;
  //take here XS0 + XH0
  if (!softCrossSections || !hardCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetTotalCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return result;
    }

  // 1) soft part
  G4PhysicsFreeVector* theVector = (G4PhysicsFreeVector*) (*softCrossSections)[0];
  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetTotalCrossSection" <<
    G4endl;
      G4cout << "Soft cross section table looks not filled" << G4endl;
      return result;
    }
  G4double logene = std::log(energy);
  G4double logXS = theVector->Value(logene);
  G4double softXS = G4Exp(logXS);

   // 2) hard part
  theVector = (G4PhysicsFreeVector*) (*hardCrossSections)[0];
  if (theVector->GetVectorLength() < numberOfEnergyPoints)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetTotalCrossSection" <<
    G4endl;
      G4cout << "Hard cross section table looks not filled" << G4endl;
      return result;
    }
  logXS = theVector->Value(logene);
  G4double hardXS = G4Exp(logXS);

  result = hardXS + softXS;
  return result;

}

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeShellCrossSections()

void G4PenelopeCrossSection::NormalizeShellCrossSections

(

)

Definition at line 412 of file G4PenelopeCrossSection.cc.

{
  if (isNormalized) //already done!
    {
      G4cout << "G4PenelopeCrossSection::NormalizeShellCrossSections()" << G4endl;
      G4cout << "already invoked. Ignore it" << G4endl;
      return;
    }

  if (!shellNormalizedCrossSections)
    {
      G4cout << "Something wrong in G4PenelopeCrossSection::GetShellCrossSection" <<
    G4endl;
      G4cout << "Trying to retrieve from un-initialized tables" << G4endl;
      return;
    }

  for (size_t i=0;i<numberOfEnergyPoints;i++) //loop on energy
    {
      //energy grid is the same for all shells

      //Recalculate manually the XS factor, to avoid problems with
      //underflows
      G4double normFactor = 0.;
      for (size_t shellID=0;shellID<numberOfShells;shellID++)
    {
      G4PhysicsFreeVector* theVec =
        (G4PhysicsFreeVector*) (*shellCrossSections)[shellID];

      normFactor += G4Exp((*theVec)[i]);
    }
      G4double logNormFactor = std::log(normFactor);
      //Normalize
      for (size_t shellID=0;shellID<numberOfShells;shellID++)
    {
     G4PhysicsFreeVector* theVec =
        (G4PhysicsFreeVector*) (*shellNormalizedCrossSections)[shellID];
     G4PhysicsFreeVector* theFullVec =
       (G4PhysicsFreeVector*) (*shellCrossSections)[shellID];
     G4double previousValue = (*theFullVec)[i]; //log(XS)
     G4double logEnergy = theFullVec->GetLowEdgeEnergy(i);
     //log(XS/normFactor) = log(XS) - log(normFactor)
     theVec->PutValue(i,logEnergy,previousValue-logNormFactor);
    }
    }

  isNormalized = true;


  /*
  //TESTING
  for (size_t shellID=0;shellID<numberOfShells;shellID++)
    {
      G4cout << "SHELL " << shellID << G4endl;
      G4PhysicsFreeVector* theVec =
    (G4PhysicsFreeVector*) (*shellCrossSections)[shellID];
      for (size_t i=0;i<numberOfEnergyPoints;i++) //loop on energy
    {
      G4double logene = theVec->GetLowEdgeEnergy(i);
      G4cout << G4Exp(logene)/MeV << " " << G4Exp((*theVec)[i]) << G4endl;
    }
    }
  */

  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Here is the caller graph for this function:

Member Data Documentation

hardCrossSections

G4PhysicsTable* G4PenelopeCrossSection::hardCrossSections

private

Definition at line 122 of file G4PenelopeCrossSection.hh.

isNormalized

G4bool G4PenelopeCrossSection::isNormalized

private

Definition at line 111 of file G4PenelopeCrossSection.hh.

numberOfEnergyPoints

size_t G4PenelopeCrossSection::numberOfEnergyPoints

private

Definition at line 113 of file G4PenelopeCrossSection.hh.

numberOfShells

size_t G4PenelopeCrossSection::numberOfShells

private

Definition at line 114 of file G4PenelopeCrossSection.hh.

shellCrossSections

G4PhysicsTable* G4PenelopeCrossSection::shellCrossSections

private

Definition at line 125 of file G4PenelopeCrossSection.hh.

shellNormalizedCrossSections

G4PhysicsTable* G4PenelopeCrossSection::shellNormalizedCrossSections

private

Definition at line 126 of file G4PenelopeCrossSection.hh.

softCrossSections

G4PhysicsTable* G4PenelopeCrossSection::softCrossSections

private

Definition at line 119 of file G4PenelopeCrossSection.hh.

---

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

• G4PenelopeCrossSection.hh
• G4PenelopeCrossSection.cc