G4SandiaTable Class Reference

#include <G4SandiaTable.hh>

Public Member Functions
	G4SandiaTable (G4Material *)
	~G4SandiaTable ()
void	GetSandiaCofPerAtom (G4int Z, G4double energy, std::vector< G4double > &coeff) const
void	GetSandiaCofWater (G4double energy, std::vector< G4double > &coeff) const
G4double	GetWaterEnergyLimit () const
G4double	GetWaterCofForMaterial (G4int, G4int) const
G4int	GetMatNbOfIntervals () const
G4double	GetSandiaCofForMaterial (G4int, G4int) const
G4double	GetSandiaMatTable (G4int, G4int) const
const G4double *	GetSandiaCofForMaterial (G4double energy) const
G4double	GetSandiaMatTablePAI (G4int, G4int) const
const G4double *	GetSandiaCofForMaterialPAI (G4double energy) const
void	SetVerbose (G4int ver)
	G4SandiaTable (__void__ &)
	G4SandiaTable (G4int matIndex)
	G4SandiaTable ()
void	Initialize (G4Material *)
G4int	SandiaIntervals (G4int Z[], G4int el)
G4int	SandiaMixing (G4int Z[], const G4double *fractionW, G4int el, G4int mi)
G4double	GetPhotoAbsorpCof (G4int i, G4int j) const
G4int	GetMaxInterval () const
G4bool	GetLowerI1 ()
void	SetLowerI1 (G4bool flag)

Static Public Member Functions
static G4double	GetZtoA (G4int Z)

Detailed Description

Definition at line 66 of file G4SandiaTable.hh.

Constructor & Destructor Documentation

G4SandiaTable::G4SandiaTable

(

G4Material *

material

)

Definition at line 68 of file G4SandiaTable.cc.

  : fMaterial(material)
{
  fMatSandiaMatrix    = nullptr; 
  fMatSandiaMatrixPAI = nullptr;
  fPhotoAbsorptionCof = nullptr;

  fMatNbOfIntervals   = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  

  //build the CumulInterval array
  if(0 == fCumulInterval[0]) {
    fCumulInterval[0] = 1;

    for (G4int Z=1; Z<101; ++Z) {
      fCumulInterval[Z] = fCumulInterval[Z-1] + fNbOfIntervals[Z];
    }
  }
  
  fMaxInterval = 0;
  fSandiaCofPerAtom.resize(4,0.0);
  fLowerI1 = false;
  //compute macroscopic Sandia coefs for a material   
  ComputeMatSandiaMatrix(); // mma
}

G4SandiaTable::~G4SandiaTable

(

)

Definition at line 114 of file G4SandiaTable.cc.

{ 
  if(fMatSandiaMatrix) 
  {
    fMatSandiaMatrix->clearAndDestroy();
    delete fMatSandiaMatrix;
  }
  if(fMatSandiaMatrixPAI) 
  {
    fMatSandiaMatrixPAI->clearAndDestroy();
    delete fMatSandiaMatrixPAI;
  }
  if(fPhotoAbsorptionCof)
  {
    delete [] fPhotoAbsorptionCof;
  }
}

Here is the call graph for this function:

G4SandiaTable::G4SandiaTable

(

__void__ &

)

Definition at line 101 of file G4SandiaTable.cc.

  : fMaterial(nullptr),fMatSandiaMatrix(nullptr),
    fMatSandiaMatrixPAI(nullptr),fPhotoAbsorptionCof(nullptr)
{
  fMaxInterval = 0;
  fMatNbOfIntervals = 0;
  fLowerI1 = false;
  fVerbose          = 0;  
  fSandiaCofPerAtom.resize(4,0.0);
}

G4SandiaTable::G4SandiaTable

(

G4int

matIndex

)

Definition at line 661 of file G4SandiaTable.cc.

{ 
  fMaterial           = 0;
  fMatNbOfIntervals   = 0;
  fMatSandiaMatrix    = 0; 
  fMatSandiaMatrixPAI = 0;
  fPhotoAbsorptionCof = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  
  fLowerI1 = false;

  fSandiaCofPerAtom.resize(4,0.0);

  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  G4int numberOfMat = G4Material::GetNumberOfMaterials();

  if ( matIndex >= 0 && matIndex < numberOfMat)
    {
      fMaterial = (*theMaterialTable)[matIndex];
    }
  else
    {
      G4Exception("G4SandiaTable::G4SandiaTable(G4int matIndex)", "mat401",
          FatalException, "wrong matIndex");
    }
}

Here is the call graph for this function:

G4SandiaTable::G4SandiaTable

(

)

Definition at line 691 of file G4SandiaTable.cc.

{ 
  fMaterial           = 0;
  fMatNbOfIntervals   = 0;
  fMatSandiaMatrix    = 0; 
  fMatSandiaMatrixPAI = 0;
  fPhotoAbsorptionCof = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  
  fLowerI1 = false;

  fSandiaCofPerAtom.resize(4,0.0);
}

Member Function Documentation

G4bool G4SandiaTable::GetLowerI1 ( )

inline

Definition at line 153 of file G4SandiaTable.hh.

{return fLowerI1;};

Here is the caller graph for this function:

G4int G4SandiaTable::GetMatNbOfIntervals

(

)

const

Definition at line 949 of file G4SandiaTable.cc.

{
  return fMatNbOfIntervals;
}

G4int G4SandiaTable::GetMaxInterval

(

)

const

Definition at line 716 of file G4SandiaTable.cc.

{ 
  return fMaxInterval;
}

Here is the caller graph for this function:

G4double G4SandiaTable::GetPhotoAbsorpCof	(	G4int	i,
		G4int	j
	)		const

Definition at line 742 of file G4SandiaTable.cc.

{
  return  fPhotoAbsorptionCof[i][j]*funitc[j];
}

Here is the caller graph for this function:

G4double G4SandiaTable::GetSandiaCofForMaterial	(	G4int	interval,
		G4int	j
	)		const

Definition at line 983 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(interval<0 || interval>=fMatNbOfIntervals) {
    PrintErrorV("GetSandiaCofForMaterial");
    interval = (interval<0) ? 0 : fMatNbOfIntervals-1;
  }
  if(j<0 || j>4) {
    PrintErrorV("GetSandiaCofForMaterial");
    j = (j<0) ? 0 : 4;
  }
#endif
  return ((*(*fMatSandiaMatrix)[interval])[j]); 
}

Here is the caller graph for this function:

const G4double * G4SandiaTable::GetSandiaCofForMaterial

(

G4double

energy

)

const

Definition at line 1001 of file G4SandiaTable.cc.

{
  G4int interval = 0;
  if (energy > (*(*fMatSandiaMatrix)[0])[0]) { 
    interval = fMatNbOfIntervals - 1;
    // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
    while ((interval>0)&&(energy<(*(*fMatSandiaMatrix)[interval])[0])) 
      { --interval; }
  } 
  return &((*(*fMatSandiaMatrix)[interval])[1]);
}

const G4double* G4SandiaTable::GetSandiaCofForMaterialPAI

(

G4double

energy

)

const

void G4SandiaTable::GetSandiaCofPerAtom	(	G4int	Z,
		G4double	energy,
		std::vector< G4double > &	coeff
	)		const

Definition at line 135 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(Z < 1 || Z > 100) {
    Z = PrintErrorZ(Z, "GetSandiaCofPerAtom");
  } 
  if(4 > coeff.size()) { 
    PrintErrorV("GetSandiaCofPerAtom(): input vector is resized"); 
    coeff.resize(4);
  }
#endif
  G4double Emin  = fSandiaTable[fCumulInterval[Z-1]][0]*CLHEP::keV;
  //G4double Iopot = fIonizationPotentials[Z]*eV;
  //if (Emin  < Iopot) Emin = Iopot;

  G4int row = 0;  
  if (energy <= Emin) { 
    energy = Emin; 

  } else {   
    G4int interval = fNbOfIntervals[Z] - 1;
    row = fCumulInterval[Z-1] + interval;
    // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
    while ((interval>0) && (energy<fSandiaTable[row][0]*CLHEP::keV)) {
      --interval;
      row = fCumulInterval[Z-1] + interval;
    }
  }

  G4double AoverAvo = Z*amu/fZtoAratio[Z];
         
  coeff[0]=AoverAvo*funitc[1]*fSandiaTable[row][1];     
  coeff[1]=AoverAvo*funitc[2]*fSandiaTable[row][2];     
  coeff[2]=AoverAvo*funitc[3]*fSandiaTable[row][3];     
  coeff[3]=AoverAvo*funitc[4]*fSandiaTable[row][4];              
}

Here is the caller graph for this function:

void G4SandiaTable::GetSandiaCofWater	(	G4double	energy,
		std::vector< G4double > &	coeff
	)		const

Definition at line 176 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(4 > coeff.size()) { 
    PrintErrorV("GetSandiaCofWater: input vector is resized"); 
    coeff.resize(4);
  }
#endif
  G4int i = 0;
  if(energy > fH2OlowerI1[0][0]*CLHEP::keV) {   
    i = fH2OlowerInt - 1;
    for(; i>0; --i) {
      if(energy >= fH2OlowerI1[i][0]*CLHEP::keV) { break; }
    }
  }
  coeff[0]=funitc[1]*fH2OlowerI1[i][1];     
  coeff[1]=funitc[2]*fH2OlowerI1[i][2];     
  coeff[2]=funitc[3]*fH2OlowerI1[i][3];     
  coeff[3]=funitc[4]*fH2OlowerI1[i][4];
}

Here is the caller graph for this function:

G4double G4SandiaTable::GetSandiaMatTable	(	G4int	interval,
		G4int	j
	)		const

Definition at line 1016 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(interval<0 || interval>=fMatNbOfIntervals) {
    PrintErrorV("GetSandiaCofForMaterial");
    interval = (interval<0) ? 0 : fMatNbOfIntervals-1;
  }
  if(j<0 || j>4) {
    PrintErrorV("GetSandiaCofForMaterial");
    j = (j<0) ? 0 : 4;
  }
#endif
  return ((*(*fMatSandiaMatrix)[interval])[j])*funitc[j]; 
}

Here is the caller graph for this function:

G4double G4SandiaTable::GetSandiaMatTablePAI	(	G4int	interval,
		G4int	j
	)		const

Definition at line 1034 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(interval<0 || interval>=fMaxInterval) {
    PrintErrorV("GetSandiaCofForMaterialPAI");
    interval = (interval<0) ? 0 : fMaxInterval-1;
  }
  if(j<0 || j>4) {
    PrintErrorV("GetSandiaCofForMaterialPAI");
    j = (j<0) ? 0 : 4;
  }
#endif
  return ((*(*fMatSandiaMatrixPAI)[interval])[j]); 
}

Here is the caller graph for this function:

G4double G4SandiaTable::GetWaterCofForMaterial	(	G4int	i,
		G4int	j
	)		const

Definition at line 207 of file G4SandiaTable.cc.

{
  return  fH2OlowerI1[i][j]*funitc[j];
}

G4double G4SandiaTable::GetWaterEnergyLimit

(

)

const

Definition at line 200 of file G4SandiaTable.cc.

{
  return fH2OlowerI1[fH2OlowerInt - 1][0]*CLHEP::keV;
}

G4double G4SandiaTable::GetZtoA ( G4int  Z )

static

Definition at line 214 of file G4SandiaTable.cc.

{
#ifdef G4VERBOSE
  if(Z < 1 || Z > 100) {
    Z = PrintErrorZ(Z, "GetSandiaCofPerAtom");
  } 
#endif
  return fZtoAratio[Z];
}

Here is the caller graph for this function:

void G4SandiaTable::Initialize

(

G4Material *

mat

)

Definition at line 708 of file G4SandiaTable.cc.

{
  fMaterial = mat;
  ComputeMatSandiaMatrixPAI();
}

G4int G4SandiaTable::SandiaIntervals	(	G4int	Z[],
		G4int	el
	)

Definition at line 769 of file G4SandiaTable.cc.

{
  G4int c,  i, flag = 0, n1 = 1;
  G4int j, c1, k1, k2;
  G4double I1;
  fMaxInterval = 0;

  for( i = 0; i < el; ++i )  fMaxInterval += fNbOfIntervals[ Z[i] ]; 

  fMaxInterval += 2;

  if( fVerbose > 0 ) {
    G4cout<<"begin sanInt, fMaxInterval = "<<fMaxInterval<<G4endl;
  }

  fPhotoAbsorptionCof = new G4double* [fMaxInterval];

  for( i = 0; i < fMaxInterval; ++i ) {
    fPhotoAbsorptionCof[i] = new G4double[5];
  }
  //  for(c = 0; c < fIntervalLimit; ++c)   // just in case

  for( c = 0; c < fMaxInterval; ++c ) { fPhotoAbsorptionCof[c][0] = 0.; }
  
  c = 1;

  for( i = 0; i < el; ++i )
  {
    I1 = fIonizationPotentials[ Z[i] ]*keV;  // First ionization
    n1 = 1;                                  // potential in keV

    for( j = 1; j < Z[i]; ++j )  n1 += fNbOfIntervals[j];
    
    G4int n2 = n1 + fNbOfIntervals[Z[i]];
    
    for( k1 = n1; k1 < n2; k1++ )
    {
      if( I1  > fSandiaTable[k1][0] )
      {
     continue;    // no ionization for energies smaller than I1 (first
      }            // ionisation potential)          
      break;
    }
    flag = 0;
    
    for( c1 = 1; c1 < c; c1++ )
    {
      if( fPhotoAbsorptionCof[c1][0] == I1 ) // this value already has existed
      {
    flag = 1;                      
    break;                         
      }
    }
    if( flag == 0 )
    {
      fPhotoAbsorptionCof[c][0] = I1;
      ++c;
    }
    for( k2 = k1; k2 < n2; k2++ )
    {
      flag = 0;

      for( c1 = 1; c1 < c; c1++ )
      {
        if( fPhotoAbsorptionCof[c1][0] == fSandiaTable[k2][0] )
        {
      flag = 1;
      break;
        }
      }
      if( flag == 0 )
      {
        fPhotoAbsorptionCof[c][0] = fSandiaTable[k2][0];
    if( fVerbose > 0 ) {
      G4cout<<"sanInt, c = "<<c<<", E_c = "<<fPhotoAbsorptionCof[c][0]
        <<G4endl;
    }
    ++c;
      }
    }       
  }   // end for(i)
  
  SandiaSort(fPhotoAbsorptionCof,c);
  fMaxInterval = c;
  if( fVerbose > 0 ) {
    G4cout<<"end SanInt, fMaxInterval = "<<fMaxInterval<<G4endl;
  }
  return c;
}   

Here is the caller graph for this function:

G4int G4SandiaTable::SandiaMixing	(	G4int	Z[],
		const G4double *	fractionW,
		G4int	el,
		G4int	mi
	)

Definition at line 865 of file G4SandiaTable.cc.

{
  G4int i, j, n1, k, c=1, jj, kk;
  G4double I1, B1, B2, E1, E2;
   
  for( i = 0; i < mi; ++i )
  {
    for( j = 1; j < 5; ++j ) fPhotoAbsorptionCof[i][j] = 0.;
  }
  for( i = 0; i < el; ++i )
  {
    n1 = 1;
    I1 = fIonizationPotentials[Z[i]]*keV;

    for( j = 1; j < Z[i]; ++j )   n1 += fNbOfIntervals[j];
      
    G4int n2 = n1 + fNbOfIntervals[Z[i]] - 1;

    for( k = n1; k < n2; ++k )
    {
      B1 = fSandiaTable[k][0];
      B2 = fSandiaTable[k+1][0];

      for( c = 1; c < mi-1; ++c )
      {
        E1 = fPhotoAbsorptionCof[c][0];
        E2 = fPhotoAbsorptionCof[c+1][0];

        if( B1 > E1 || B2 < E2 || E1 < I1 )   continue;
        
    for( j = 1; j < 5; ++j ) 
    {
          fPhotoAbsorptionCof[c][j] += fSandiaTable[k][j]*fractionW[i];
          if( fVerbose > 0 )
      {
        G4cout<<"c="<<c<<"; j="<<j<<"; fST="<<fSandiaTable[k][j]
          <<"; frW="<<fractionW[i]<<G4endl;
      }
    }       
      }  
    }   
    for( j = 1; j < 5; ++j )   // Last interval
    {
      fPhotoAbsorptionCof[mi-1][j] += fSandiaTable[k][j]*fractionW[i];
      if( fVerbose > 0 )
      {
    G4cout<<"mi-1="<<mi-1<<"; j="<<j<<"; fST="<<fSandiaTable[k][j]
          <<"; frW="<<fractionW[i]<<G4endl;
      }
    }
  }     // for(i)
  c = 0;     // Deleting of first intervals where all coefficients = 0

  do                        
  {
    ++c;

    if( fPhotoAbsorptionCof[c][1] != 0.0 ||
    fPhotoAbsorptionCof[c][2] != 0.0 ||
        fPhotoAbsorptionCof[c][3] != 0.0 || 
    fPhotoAbsorptionCof[c][4] != 0.0     )  continue;
       
    for( jj = 2; jj < mi; ++jj )
    {
      for( kk = 0; kk < 5; ++kk ) {
    fPhotoAbsorptionCof[jj-1][kk] = fPhotoAbsorptionCof[jj][kk];
      }
    }
    mi--;
    c--;
  }
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while( c < mi - 1 );

  if( fVerbose > 0 ) G4cout<<"end SanMix, mi = "<<mi<<G4endl;
    
  return mi;
}  

Here is the caller graph for this function:

void G4SandiaTable::SetLowerI1 ( G4bool  flag )

inline

Definition at line 154 of file G4SandiaTable.hh.

{fLowerI1=flag;};

void G4SandiaTable::SetVerbose ( G4int  ver )

inline

Definition at line 95 of file G4SandiaTable.hh.

{ fVerbose = ver; };

---

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

• geant4.10.03.p01/source/materials/include/G4SandiaTable.hh
• geant4.10.03.p01/source/materials/include/G4StaticSandiaData.hh
• geant4.10.03.p01/source/materials/src/G4SandiaTable.cc