G4PenelopeBremsstrahlungFS Class Reference

#include <G4PenelopeBremsstrahlungFS.hh>

Public Member Functions
	G4PenelopeBremsstrahlungFS ()
	~G4PenelopeBremsstrahlungFS ()
G4double	GetEffectiveZSquared (const G4Material *mat)
void	ClearTables ()
size_t	GetNBinsX ()
G4double	GetMomentumIntegral (G4double *y, G4double up, G4int momOrder)
G4PhysicsTable *	GetScaledXSTable (const G4Material *, G4double cut)
G4double	SampleGammaEnergy (G4double energy, const G4Material *, G4double cut)

Detailed Description

Definition at line 55 of file G4PenelopeBremsstrahlungFS.hh.

Constructor & Destructor Documentation

G4PenelopeBremsstrahlungFS()

G4PenelopeBremsstrahlungFS::G4PenelopeBremsstrahlungFS

(

)

Definition at line 50 of file G4PenelopeBremsstrahlungFS.cc.

                                                       : 
  theReducedXSTable(0),theEffectiveZSq(0),theSamplingTable(0),
  thePBcut(0)
{
  G4double tempvector[nBinsX] = 
    {1.0e-12,0.025e0,0.05e0,0.075e0,0.1e0,0.15e0,0.2e0,0.25e0,
    0.3e0,0.35e0,0.4e0,0.45e0,0.5e0,0.55e0,0.6e0,0.65e0,0.7e0,
    0.75e0,0.8e0,0.85e0,0.9e0,0.925e0,0.95e0,0.97e0,0.99e0,
    0.995e0,0.999e0,0.9995e0,0.9999e0,0.99995e0,0.99999e0,1.0e0};
 
  for (size_t ix=0;ix<nBinsX;ix++)
    theXGrid[ix] = tempvector[ix];
 
  for (size_t i=0;i<nBinsE;i++)
    theEGrid[i] = 0.;
 
  theElementData = new std::map<G4int,G4DataVector*>;
  theTempVec = new G4PhysicsFreeVector(nBinsX);
}

~G4PenelopeBremsstrahlungFS()

G4PenelopeBremsstrahlungFS::~G4PenelopeBremsstrahlungFS

(

)

Definition at line 72 of file G4PenelopeBremsstrahlungFS.cc.

{
  ClearTables();
 
  if (theTempVec)
    delete theTempVec;
 
  //Clear manually theElementData
  std::map<G4int,G4DataVector*>::iterator i;
  if (theElementData)
    {
      for (i=theElementData->begin(); i != theElementData->end(); i++)        
    delete i->second;        
      delete theElementData;
      theElementData = 0;
    }
 
}

Member Function Documentation

ClearTables()

void G4PenelopeBremsstrahlungFS::ClearTables

(

)

Definition at line 94 of file G4PenelopeBremsstrahlungFS.cc.

{  
  std::map< std::pair<const G4Material*,G4double> ,G4PhysicsTable*>::iterator j;
 
  if (theReducedXSTable)
    {
      for (j=theReducedXSTable->begin(); j != theReducedXSTable->end(); j++)
    {
      G4PhysicsTable* tab = j->second;
      tab->clearAndDestroy();
          delete tab;
    }
      delete theReducedXSTable;
      theReducedXSTable = 0;
    }
 
  if (theSamplingTable)
    {
      for (j=theSamplingTable->begin(); j != theSamplingTable->end(); j++)
    {
      G4PhysicsTable* tab = j->second;
      tab->clearAndDestroy();
          delete tab;
    }
      delete theSamplingTable;
      theSamplingTable = 0;
    }
 
  std::map< std::pair<const G4Material*,G4double> ,G4PhysicsFreeVector*>::iterator kk;
  if (thePBcut)
    {
      for (kk=thePBcut->begin(); kk != thePBcut->end(); kk++)   
    delete kk->second;
      delete thePBcut;
      thePBcut = 0;      
    }
 
 
  if (theEffectiveZSq)
    {
      delete theEffectiveZSq;
      theEffectiveZSq = 0;
    }
  
 return;
}

Referenced by ~G4PenelopeBremsstrahlungFS().

GetEffectiveZSquared()

G4double G4PenelopeBremsstrahlungFS::GetEffectiveZSquared

(

const G4Material *

mat

)

Definition at line 143 of file G4PenelopeBremsstrahlungFS.cc.

{
  if (!theEffectiveZSq)
    {
      G4ExceptionDescription ed;
      ed << "The container for the <Z^2> values is not initialized" << G4endl;
      G4Exception("G4PenelopeBremsstrahlungFS::GetEffectiveZSquared()",
          "em2007",FatalException,ed);
      return 0;
    }
  //found in the table: return it 
  if (theEffectiveZSq->count(material))
    return theEffectiveZSq->find(material)->second;    
  else
    {
      G4ExceptionDescription ed;
      ed << "The value of  <Z^2> is not properly set for material " << 
    material->GetName() << G4endl;
      //requires running of BuildScaledXSTable()
      G4Exception("G4PenelopeBremsstrahlungFS::GetEffectiveZSquared()",
          "em2008",FatalException,ed);
    }
  return 0;
}

GetMomentumIntegral()

G4double G4PenelopeBremsstrahlungFS::GetMomentumIntegral	(	G4double *	y,
		G4double	up,
		G4int	momOrder
	)

Definition at line 400 of file G4PenelopeBremsstrahlungFS.cc.

{
  //Corresponds to the function RLMOM of Penelope
  //This method performs the calculation of the integral of (x^momOrder)*y over the interval
  //from x[0] to xup, obtained by linear interpolation on a table of y. 
  //The independent variable is assumed to take positive values only.
  //
  size_t size = nBinsX;
  const G4double eps = 1e-35;
 
  //Check that the call is valid
  if (momOrder<-1 || size<2 || theXGrid[0]<0)
    {
      G4Exception("G4PenelopeBremsstrahlungFS::GetMomentumIntegral()",
          "em2011",FatalException,"Invalid call");
    }
 
  for (size_t i=1;i<size;i++)
    {
      if (theXGrid[i]<0 || theXGrid[i]<theXGrid[i-1])
    {
      G4ExceptionDescription ed;
      ed << "Invalid call for bin " << i << G4endl;
      G4Exception("G4PenelopeBremsstrahlungFS::GetMomentumIntegral()",
          "em2012",FatalException,ed);
    }
    }
 
  //Compute the integral
  G4double result = 0;
  if (xup < theXGrid[0])
    return result;
  bool loopAgain = true;
  G4double xt = std::min(xup,theXGrid[size-1]);
  G4double xtc = 0;
  for (size_t i=0;i<size-1;i++)
    {
      G4double x1 = std::max(theXGrid[i],eps);
      G4double y1 = y[i];
      G4double x2 = std::max(theXGrid[i+1],eps);
      G4double y2 = y[i+1];
      if (xt < x2)
    {
      xtc = xt;
      loopAgain = false;
    }
      else
    xtc = x2;
      G4double dx = x2-x1;
      G4double dy = y2-y1;
      G4double ds = 0;
      if (std::fabs(dx)>1e-14*std::fabs(dy))
    {
      G4double b=dy/dx;
      G4double a=y1-b*x1;    
      if (momOrder == -1)       
        ds = a*std::log(xtc/x1)+b*(xtc-x1);
      else if (momOrder == 0) //speed it up, not using pow()
        ds = a*(xtc-x1) + 0.5*b*(xtc*xtc-x1*x1);
      else
        ds = a*(std::pow(xtc,momOrder+1)-std::pow(x1,momOrder+1))/((G4double) (momOrder + 1))
          + b*(std::pow(xtc,momOrder+2)-std::pow(x1,momOrder+2))/((G4double) (momOrder + 2));       
    }
      else
    ds = 0.5*(y1+y2)*(xtc-x1)*std::pow(xtc,momOrder);
      result += ds;
      if (!loopAgain) 
    return result;
    }
  return result;
}

GetNBinsX()

size_t G4PenelopeBremsstrahlungFS::GetNBinsX ( )

inline

Definition at line 64 of file G4PenelopeBremsstrahlungFS.hh.

{return nBinsX;};

GetScaledXSTable()

G4PhysicsTable * G4PenelopeBremsstrahlungFS::GetScaledXSTable	(	const G4Material *	mat,
		G4double	cut
	)

Definition at line 476 of file G4PenelopeBremsstrahlungFS.cc.

{
  //check if the container exists (if not, create it)
  if (!theReducedXSTable)
    theReducedXSTable = new std::map< std::pair<const G4Material*,G4double> ,
    G4PhysicsTable*>;
  if (!theEffectiveZSq)
    theEffectiveZSq = new std::map<const G4Material*,G4double>;
 
  //check if it already contains the entry
  std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
  if (!(theReducedXSTable->count(theKey))) //not found
    BuildScaledXSTable(mat,cut);
  
  if (!(theReducedXSTable->count(theKey)))
    {
      G4Exception("G4PenelopeBremsstrahlungFS::GetScaledXSTable()",
          "em2013",FatalException,"Unable to retrieve the cross section table");
    }
 
  return theReducedXSTable->find(theKey)->second;
}

SampleGammaEnergy()

G4double G4PenelopeBremsstrahlungFS::SampleGammaEnergy	(	G4double	energy,
		const G4Material *	mat,
		G4double	cut
	)

Definition at line 571 of file G4PenelopeBremsstrahlungFS.cc.

{
  if (!theSamplingTable)    
    theSamplingTable = 
      new std::map< std::pair<const G4Material*,G4double> , G4PhysicsTable*>;
  if (!thePBcut)
    thePBcut = 
      new std::map< std::pair<const G4Material*,G4double> , G4PhysicsFreeVector* >;
 
  std::pair<const G4Material*,G4double> theKey = std::make_pair(mat,cut);
  
  if (!(theSamplingTable->count(theKey)))
    {
      InitializeEnergySampling(mat,cut);
      if (!(theSamplingTable->count(theKey)) || !(thePBcut->count(theKey)))
    {
      G4ExceptionDescription ed;
      ed << "Unable to create the SamplingTable: " << 
        theSamplingTable->count(theKey) << " " << 
        thePBcut->count(theKey) << G4endl;
      G4Exception("G4PenelopeBremsstrahlungFS::SampleGammaEnergy()",
              "em2014",FatalException,ed);    
    }
    }
 
  G4PhysicsTable* theTableInte = theSamplingTable->find(theKey)->second;
  G4PhysicsTable* theTableRed = theReducedXSTable->find(theKey)->second;
 
  //Find the energy bin using bi-partition
  size_t eBin = 0;
  G4bool firstOrLastBin = false;
 
  if (energy < theEGrid[0]) //below first bin
    {
      eBin = 0;
      firstOrLastBin = true;
    }
  else if (energy > theEGrid[nBinsE-1]) //after last bin
    {
      eBin = nBinsE-1;
      firstOrLastBin = true;
    }
  else
    {
      size_t i=0;
      size_t j=nBinsE-1;
      while ((j-i)>1)
    {
      size_t k = (i+j)/2;
      if (energy > theEGrid[k])
        i = k;
      else
        j = k;   
    }
      eBin = i;
    }
 
  //Get the appropriate physics vector
  G4PhysicsFreeVector* theVec1 = (G4PhysicsFreeVector*) (*theTableInte)[eBin];
 
  //use a "temporary" vector which contains the linear interpolation of the x spectra 
  //in energy
 
  //theTempVect is allocated only once (member variable), but it is overwritten at 
  //every call of this method (because the interpolation factors change!)
  if (!firstOrLastBin)
    {  
      G4PhysicsFreeVector* theVec2 = (G4PhysicsFreeVector*) (*theTableInte)[eBin+1];
      for (size_t iloop=0;iloop<nBinsX;iloop++)
    {
      G4double val = (*theVec1)[iloop]+(((*theVec2)[iloop]-(*theVec1)[iloop]))*
        (energy-theEGrid[eBin])/(theEGrid[eBin+1]-theEGrid[eBin]);
      theTempVec->PutValue(iloop,theXGrid[iloop],val);
    }      
    }
  else //first or last bin, no interpolation
    {
      for (size_t iloop=0;iloop<nBinsX;iloop++) 
    theTempVec->PutValue(iloop,theXGrid[iloop],(*theVec1)[iloop]);  
    }
 
  //Start the game
  G4double pbcut = (*(thePBcut->find(theKey)->second))[eBin];
 
  if (!firstOrLastBin) //linear interpolation on pbcut as well
    {
      pbcut = (*(thePBcut->find(theKey)->second))[eBin] + 
    ((*(thePBcut->find(theKey)->second))[eBin+1]-(*(thePBcut->find(theKey)->second))[eBin])*
    (energy-theEGrid[eBin])/(theEGrid[eBin+1]-theEGrid[eBin]);
    }
 
  G4double pCumulative = (*theTempVec)[nBinsX-1]; //last value  
 
  G4double eGamma = 0;
  do
    {    
      G4double pt = pbcut + G4UniformRand()*(pCumulative - pbcut);
 
      //find where it is
      size_t ibin = 0;
      if (pt < (*theTempVec)[0])
    ibin = 0;
      else if (pt > (*theTempVec)[nBinsX-1])
    {
      //We observed problems due to numerical rounding here (STT). 
      //delta here is a tiny positive number
      G4double delta = pt-(*theTempVec)[nBinsX-1];
      if (delta < pt*1e-10) // very small! Numerical rounding only
        {
          ibin = nBinsX-2;
          G4ExceptionDescription ed;
          ed << "Found that (pt > (*theTempVec)[nBinsX-1]) with pt = " << pt << 
        " , (*theTempVec)[nBinsX-1] = " << (*theTempVec)[nBinsX-1] << " and delta = " << 
        (pt-(*theTempVec)[nBinsX-1]) << G4endl;
          ed << "Possible symptom of problem with numerical precision" << G4endl;
          G4Exception("G4PenelopeBremsstrahlungFS::SampleGammaEnergy()",
              "em2015",JustWarning,ed);
        }
      else //real problem
        {
          G4ExceptionDescription ed;
          ed << "Crash at (pt > (*theTempVec)[nBinsX-1]) with pt = " << pt << 
        " , (*theTempVec)[nBinsX-1]=" << (*theTempVec)[nBinsX-1] << " and nBinsX = " << 
        nBinsX << G4endl;
          ed << "Material: " << mat->GetName() << ", energy = " << energy/keV << " keV" << 
        G4endl;
          G4Exception("G4PenelopeBremsstrahlungFS::SampleGammaEnergy()",
              "em2015",FatalException,ed);    
        }
    }
      else
    {
      size_t i=0;
      size_t j=nBinsX-1;
      while ((j-i)>1)
        {
          size_t k = (i+j)/2;
          if (pt > (*theTempVec)[k])
        i = k;
          else
        j = k;
        }
      ibin = i;
    }
    
      G4double w1 = theXGrid[ibin];
      G4double w2 = theXGrid[ibin+1];            
 
      G4PhysicsFreeVector* v1 = (G4PhysicsFreeVector*) (*theTableRed)[ibin];
      G4PhysicsFreeVector* v2 = (G4PhysicsFreeVector*) (*theTableRed)[ibin+1];     
      //Remember: the table theReducedXSTable has a fake first point in energy
      //so, it contains one more bin than nBinsE.
      G4double pdf1 = std::exp((*v1)[eBin+1]);
      G4double pdf2 = std::exp((*v2)[eBin+1]);    
      G4double deltaW = w2-w1;
      G4double dpdfb = pdf2-pdf1;
      G4double B = dpdfb/deltaW;
      G4double A = pdf1-B*w1;
      //I already made an interpolation in energy, so I can use the actual value for the 
      //calculation of the wbcut, instead of the grid values (except for the last bin)
      G4double wbcut  = (cut < energy) ? cut/energy : 1.0;
      if (firstOrLastBin) //this is an particular case: no interpolation available
    wbcut  = (cut < theEGrid[eBin]) ? cut/theEGrid[eBin] : 1.0;
     
      if (w1 < wbcut)
    w1 = wbcut;
      if (w2 < w1)
    {
      G4cout << "Warning in G4PenelopeBremsstrahlungFS::SampleX()" << G4endl;
      G4cout << "Conflicting end-point values: w1=" << w1 << "; w2 = " << w2 << G4endl;
      G4cout << "wbcut = " << wbcut << " energy= " << energy/keV << " keV" << G4endl;
      G4cout << "cut = " << cut/keV << " keV" << G4endl;
      return w1*energy;
    }
  
      G4double pmax = std::max(A+B*w1,A+B*w2);
      G4bool loopAgain = false;    
      do
    {
      loopAgain = false;
      eGamma = w1* std::pow((w2/w1),G4UniformRand());
      if  (G4UniformRand()*pmax > (A+B*eGamma))
        loopAgain = true;   
    }while(loopAgain);     
      eGamma *= energy;
    }while(eGamma < cut); //repeat if sampled sub-cut!  
 
  return eGamma;
}

Referenced by G4PenelopeBremsstrahlungModel::SampleSecondaries().

---

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

• G4PenelopeBremsstrahlungFS.hh
• G4PenelopeBremsstrahlungFS.cc