G4SandiaTable Class Reference

#include <G4SandiaTable.hh>

Collaboration diagram for G4SandiaTable:

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	GetSandiaCofForMaterialPAI (G4int, G4int) const
G4double	GetSandiaMatTablePAI (G4int, G4int) const
const G4double *	GetSandiaCofForMaterialPAI (G4double energy) const
G4OrderedTable *	GetSandiaMatrixPAI ()
void	SetVerbose (G4int ver)
	G4SandiaTable (__void__ &)
	G4SandiaTable (G4int)
	G4SandiaTable ()
void	Initialize (G4Material *)
void	Initialize (G4int)
void	SandiaSwap (G4double **da, G4int i, G4int j)
void	SandiaSort (G4double **da, G4int sz)
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
G4double **	GetPointerToCof ()
G4bool	GetLowerI1 ()
void	SetLowerI1 (G4bool flag)

Static Public Member Functions
static G4double	GetZtoA (G4int Z)

Private Member Functions
void	ComputeMatSandiaMatrix ()
void	ComputeMatSandiaMatrixPAI ()
G4int	GetNbOfIntervals (G4int Z)
G4double	GetSandiaPerAtom (G4int Z, G4int, G4int)
G4double	GetIonizationPot (G4int Z) const
void	ComputeMatTable ()
	G4SandiaTable (G4SandiaTable &)
G4SandiaTable &	operator= (const G4SandiaTable &right)

Private Attributes
std::vector< G4double >	fSandiaCofPerAtom
G4Material *	fMaterial
G4int	fMatNbOfIntervals
G4OrderedTable *	fMatSandiaMatrix
G4OrderedTable *	fMatSandiaMatrixPAI
G4double **	fPhotoAbsorptionCof
G4int	fMaxInterval
G4int	fVerbose
G4bool	fLowerI1

Static Private Attributes
static const G4int	fNumberOfElements = 100
static const G4int	fIntervalLimit = 100
static const G4int	fNumberOfIntervals = 980
static const G4int	fH2OlowerInt = 23
static const G4double	fSandiaTable [981][5]
static const G4double	fH2OlowerI1 [23][5]
static const G4int	fNbOfIntervals [101]
static const G4double	fZtoAratio [101]
static const G4double	fIonizationPotentials [101]
static const G4double	funitc [5]
static const G4double	fnulcof [4] = {0.0}
static G4int	fCumulInterval [101] = {0}

Detailed Description

Definition at line 67 of file G4SandiaTable.hh.

Constructor & Destructor Documentation

G4SandiaTable() [1/5]

G4SandiaTable::G4SandiaTable

(

G4Material *

material

)

Definition at line 70 of file G4SandiaTable.cc.

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

  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
}

Here is the call graph for this function:

~G4SandiaTable()

G4SandiaTable::~G4SandiaTable

(

)

Definition at line 116 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() [2/5]

G4SandiaTable::G4SandiaTable

(

__void__ &

)

Definition at line 103 of file G4SandiaTable.cc.

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

G4SandiaTable() [3/5]

G4SandiaTable::G4SandiaTable

(

G4int

matIndex

)

Definition at line 614 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];
      // ComputeMatTable();
    }
  else
    {
      G4Exception("G4SandiaTable::G4SandiaTable(G4int matIndex)", "mat401",
          FatalException, "wrong matIndex");
    }
}

Here is the call graph for this function:

G4SandiaTable() [4/5]

G4SandiaTable::G4SandiaTable

(

)

Definition at line 645 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);
}

Here is the caller graph for this function:

G4SandiaTable() [5/5]

G4SandiaTable::G4SandiaTable ( G4SandiaTable &  )

private

Member Function Documentation

ComputeMatSandiaMatrix()

void G4SandiaTable::ComputeMatSandiaMatrix ( )

private

Definition at line 211 of file G4SandiaTable.cc.

{  
  //get list of elements
  const G4int NbElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();
  
  G4int* Z = new G4int[NbElm];               //Atomic number
   
  //determine the maximum number of energy-intervals for this material
  
  G4int MaxIntervals = 0;
  G4int elm;
    
  for ( elm = 0; elm < NbElm; elm++ ) 
  {
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
     
  //copy the Energy bins in a tmp1 array
  //(take care of the Ionization Potential of each element)
  
  G4double* tmp1 = new G4double[MaxIntervals]; 
  G4double IonizationPot;
  G4int interval1 = 0;

  for ( elm = 0; elm < NbElm; elm++ ) 
  {
    IonizationPot = GetIonizationPot(Z[elm]);

    for(G4int row = fCumulInterval[Z[elm]-1]; row<fCumulInterval[Z[elm]]; ++row)
    {
      tmp1[interval1++] = std::max(fSandiaTable[row][0]*keV,IonizationPot);
    }
  }   
        
  //sort the energies in strickly increasing values in a tmp2 array
  //(eliminate redondances)
  
  G4double* tmp2 = new G4double[MaxIntervals];
  G4double Emin;
  G4int interval2 = 0;
  
  do 
  {
    Emin = DBL_MAX;

    for ( G4int i1 = 0; i1 < MaxIntervals; i1++ ) 
    {
      if (tmp1[i1] < Emin) Emin = tmp1[i1];          //find the minimum
    }
    if (Emin < DBL_MAX) tmp2[interval2++] = Emin;
    //copy Emin in tmp2
    for ( G4int j1 = 0; j1 < MaxIntervals; j1++ ) 
    {
      if (tmp1[j1] <= Emin) tmp1[j1] = DBL_MAX;      //eliminate from tmp1
    }
    // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  } while (Emin < DBL_MAX);
                            
  //create the sandia matrix for this material
    
  fMatSandiaMatrix = new G4OrderedTable();
  G4int interval;

  for (interval = 0; interval < interval2; interval++ ) 
  {
    fMatSandiaMatrix->push_back( new G4DataVector(5,0.) );
  }
  
  //ready to compute the Sandia coefs for the material
  
  const G4double* NbOfAtomsPerVolume = fMaterial->GetVecNbOfAtomsPerVolume();
  
  static const G4double prec = 1.e-03*eV;
  G4double coef, oldsum(0.), newsum(0.);
  fMatNbOfIntervals = 0;
         
  for ( interval = 0; interval < interval2; interval++ ) 
  {
    Emin = (*(*fMatSandiaMatrix)[fMatNbOfIntervals])[0] = tmp2[interval];

    for ( G4int k = 1; k < 5; ++k ) {
      (*(*fMatSandiaMatrix)[fMatNbOfIntervals])[k] = 0.;      
    }
    newsum = 0.;
      
    for ( elm = 0; elm < NbElm; elm++ ) 
    {    
      GetSandiaCofPerAtom(Z[elm], Emin+prec, fSandiaCofPerAtom);

      for ( G4int j = 1; j < 5; ++j ) 
      {
    coef = NbOfAtomsPerVolume[elm]*fSandiaCofPerAtom[j-1];
    (*(*fMatSandiaMatrix)[fMatNbOfIntervals])[j] += coef;
    newsum += std::fabs(coef);
      }                            
    }                                            
    //check for null or redondant intervals
     
    if (newsum != oldsum) { oldsum = newsum; fMatNbOfIntervals++;}
  }
  delete [] Z;
  delete [] tmp1;
  delete [] tmp2;

  //  fMaxInterval = fMatNbOfIntervals; // vmg 16.02.11

  if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
  {
    G4cout<<"mma, G4SandiaTable::ComputeMatSandiaMatrix(), mat = "
      <<fMaterial->GetName()<<G4endl;

    for( G4int i = 0; i < fMatNbOfIntervals; ++i)
    {
      G4cout<<i<<"\t"<<GetSandiaCofForMaterial(i,0)/keV<<" keV \t"
        <<this->GetSandiaCofForMaterial(i,1)
        <<"\t"<<this->GetSandiaCofForMaterial(i,2)
        <<"\t"<<this->GetSandiaCofForMaterial(i,3)
        <<"\t"<<this->GetSandiaCofForMaterial(i,4)<<G4endl;
    }   
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeMatSandiaMatrixPAI()

void G4SandiaTable::ComputeMatSandiaMatrixPAI ( )

private

Definition at line 339 of file G4SandiaTable.cc.

{  
  G4int MaxIntervals = 0;
  G4int elm, c, i, j, jj, k, k1, k2, c1, n1;    

  const G4int noElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();
  
  std::vector<G4int> Z(noElm);               //Atomic number

  for ( elm = 0; elm < noElm; elm++ )
  { 
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
  fMaxInterval = MaxIntervals + 2;

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

  G4DataVector fPhotoAbsorptionCof0(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof1(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof2(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof3(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof4(fMaxInterval);

  for( c = 0; c < fMaxInterval; ++c )   // just in case
  {
    fPhotoAbsorptionCof0[c] = 0.;
    fPhotoAbsorptionCof1[c] = 0.;
    fPhotoAbsorptionCof2[c] = 0.;
    fPhotoAbsorptionCof3[c] = 0.;
    fPhotoAbsorptionCof4[c] = 0.;
  }
  c = 1;

  for(i = 0; i < noElm; ++i)
  {
    G4double I1 = fIonizationPotentials[Z[i]]*keV;  // I1 in keV
    n1          = 1;                                    
 
    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;
    }
    G4int flag = 0;
    
    for( c1 = 1; c1 < c; c1++ )
    {
      if( fPhotoAbsorptionCof0[c1] == I1 ) // this value already has existed
      {
    flag = 1;                      
    break;                         
      }
    }
    if(flag == 0)
    {
      fPhotoAbsorptionCof0[c] = I1;
      ++c;
    }
    for( k2 = k1; k2 < n2; k2++ )
    {
      flag = 0;

      for( c1 = 1; c1 < c; c1++ )
      {
        if( fPhotoAbsorptionCof0[c1] == fSandiaTable[k2][0] )
        {
      flag = 1;
      break;
        }
      }
      if(flag == 0)
      {
        fPhotoAbsorptionCof0[c] = fSandiaTable[k2][0];
    ++c;
      }
    }       
  }   // end for(i)
  // sort out

  for( i = 1; i < c; ++i ) 
  {
    for( j = i + 1; j < c;  ++j )
    {
      if( fPhotoAbsorptionCof0[i] > fPhotoAbsorptionCof0[j] ) 
      {
        G4double tmp = fPhotoAbsorptionCof0[i];
    fPhotoAbsorptionCof0[i] = fPhotoAbsorptionCof0[j];
    fPhotoAbsorptionCof0[j] = tmp;
      }
    }
    if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
    {
      G4cout<<i<<"\t energy = "<<fPhotoAbsorptionCof0[i]<<G4endl;
    }
  } 
  fMaxInterval = c;
 
  const G4double* fractionW = fMaterial->GetFractionVector();

  if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
  {
    for( i = 0; i < noElm; ++i ) 
      G4cout<<i<<" = elN, fraction = "<<fractionW[i]<<G4endl;
  }      
   
  for( i = 0; i < noElm; ++i )
  {
    n1 = 1;
    G4double 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)
    {
      G4double B1 = fSandiaTable[k][0];
      G4double B2 = fSandiaTable[k+1][0];

      for(G4int q = 1; q < fMaxInterval-1; q++)
      {
    G4double E1 = fPhotoAbsorptionCof0[q];
    G4double E2 = fPhotoAbsorptionCof0[q+1];

        if ( fVerbose > 0  )
        {
          G4cout<<"k = "<<k<<", q = "<<q<<", B1 = "<<B1<<", B2 = "<<B2
        <<", E1 = "<<E1<<", E2 = "<<E2<<G4endl;
        }      
    if( B1 > E1 || B2 < E2 || E1 < I1 )  
    {
          if ( fVerbose > 0  )
          {
            G4cout<<"continue for: B1 = "<<B1<<", B2 = "<<B2<<", E1 = "
          <<E1<<", E2 = "<<E2<<G4endl;
          }      
          continue;
    }       
    fPhotoAbsorptionCof1[q] += fSandiaTable[k][1]*fractionW[i];
    fPhotoAbsorptionCof2[q] += fSandiaTable[k][2]*fractionW[i];
    fPhotoAbsorptionCof3[q] += fSandiaTable[k][3]*fractionW[i];
    fPhotoAbsorptionCof4[q] += fSandiaTable[k][4]*fractionW[i];
      }  
    }   
    // Last interval

    fPhotoAbsorptionCof1[fMaxInterval-1] += fSandiaTable[k][1]*fractionW[i];
    fPhotoAbsorptionCof2[fMaxInterval-1] += fSandiaTable[k][2]*fractionW[i];
    fPhotoAbsorptionCof3[fMaxInterval-1] += fSandiaTable[k][3]*fractionW[i];
    fPhotoAbsorptionCof4[fMaxInterval-1] += fSandiaTable[k][4]*fractionW[i];
  }     // for(i)  
  c = 0;     // Deleting of first intervals where all coefficients = 0

  do                        
  {
    ++c;

    if( fPhotoAbsorptionCof1[c] != 0.0 ||
    fPhotoAbsorptionCof2[c] != 0.0 ||
        fPhotoAbsorptionCof3[c] != 0.0 || 
    fPhotoAbsorptionCof4[c] != 0.0     )  continue;

    if ( fVerbose > 0 )
    {
      G4cout<<c<<" = number with zero cofs"<<G4endl;
    }      
    for( jj = 2; jj < fMaxInterval; ++jj )
    {
      fPhotoAbsorptionCof0[jj-1] = fPhotoAbsorptionCof0[jj];
      fPhotoAbsorptionCof1[jj-1] = fPhotoAbsorptionCof1[jj];
      fPhotoAbsorptionCof2[jj-1] = fPhotoAbsorptionCof2[jj];
      fPhotoAbsorptionCof3[jj-1] = fPhotoAbsorptionCof3[jj];
      fPhotoAbsorptionCof4[jj-1] = fPhotoAbsorptionCof4[jj];
    }
    --fMaxInterval;
    --c; 
  }
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while( c < fMaxInterval - 1 ); 

  if( fPhotoAbsorptionCof0[fMaxInterval-1] == 0.0 ) fMaxInterval--; 
    
  // create the sandia matrix for this material
  
  fMatSandiaMatrixPAI = new G4OrderedTable();

  G4double density = fMaterial->GetDensity();

  for (i = 0; i < fMaxInterval; ++i) // -> G4units
  {
    fPhotoAbsorptionCof0[i+1] *= funitc[0];
    fPhotoAbsorptionCof1[i+1] *= funitc[1]*density;
    fPhotoAbsorptionCof2[i+1] *= funitc[2]*density;
    fPhotoAbsorptionCof3[i+1] *= funitc[3]*density;
    fPhotoAbsorptionCof4[i+1] *= funitc[4]*density;
  }
  if(fLowerI1)
  {
    if( fMaterial->GetName() == "G4_WATER")
    {
      fMaxInterval += fH2OlowerInt;

      for (i = 0; i < fMaxInterval; ++i) // init vector table
      {
        fMatSandiaMatrixPAI->push_back( new G4DataVector(5,0.) );
      }                 
      for (i = 0; i < fH2OlowerInt; ++i)
      {
        (*(*fMatSandiaMatrixPAI)[i])[0] = fH2OlowerI1[i][0];
        (*(*fMatSandiaMatrixPAI)[i])[1] = fH2OlowerI1[i][1]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[2] = fH2OlowerI1[i][2]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[3] = fH2OlowerI1[i][3]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[4] = fH2OlowerI1[i][4]; // *density;
      }
      for (i = fH2OlowerInt; i < fMaxInterval; ++i)
      {
        (*(*fMatSandiaMatrixPAI)[i])[0] = fPhotoAbsorptionCof0[i+1-fH2OlowerInt];
        (*(*fMatSandiaMatrixPAI)[i])[1] = fPhotoAbsorptionCof1[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[2] = fPhotoAbsorptionCof2[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[3] = fPhotoAbsorptionCof3[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[4] = fPhotoAbsorptionCof4[i+1-fH2OlowerInt]; // *density;
      }
    }
  }
  else
  { 
    for (i = 0; i < fMaxInterval; ++i) // init vector table
    {
      fMatSandiaMatrixPAI->push_back( new G4DataVector(5,0.) );
    }               
    for (i = 0; i < fMaxInterval; ++i)
    {
      (*(*fMatSandiaMatrixPAI)[i])[0] = fPhotoAbsorptionCof0[i+1];
      (*(*fMatSandiaMatrixPAI)[i])[1] = fPhotoAbsorptionCof1[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[2] = fPhotoAbsorptionCof2[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[3] = fPhotoAbsorptionCof3[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[4] = fPhotoAbsorptionCof4[i+1]; // *density;
    }
  }
  // --fMaxInterval; 
  // to avoid duplicate at 500 keV or extra zeros in last interval

  if ( fVerbose > 0  )
  {
    G4cout<<"vmg, G4SandiaTable::ComputeMatSandiaMatrixPAI(), mat = "
      <<fMaterial->GetName()<<G4endl;

    for( i = 0; i < fMaxInterval; ++i)
    {
      G4cout<<i<<"\t"<<GetSandiaMatTablePAI(i,0)/keV<<" keV \t"
        <<this->GetSandiaMatTablePAI(i,1)
        <<"\t"<<this->GetSandiaMatTablePAI(i,2)
        <<"\t"<<this->GetSandiaMatTablePAI(i,3)
        <<"\t"<<this->GetSandiaMatTablePAI(i,4)<<G4endl;
    }   
  }
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeMatTable()

void G4SandiaTable::ComputeMatTable ( )

private

Definition at line 1045 of file G4SandiaTable.cc.

{
  G4int MaxIntervals = 0;
  G4int elm, c, i, j, jj, k, kk, k1, k2, c1, n1;    

  const G4int noElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();  
  G4int* Z = new G4int[noElm];               //Atomic number

  for (elm = 0; elm<noElm; ++elm)
  { 
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
  fMaxInterval = 0;

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

  //  G4cout<<"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)   // just in case
  {
     fPhotoAbsorptionCof[c][0] = 0.;
  }
  c = 1;

  for(i = 0; i < noElm; ++i)
  {
    G4double 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;
    }
    G4int 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];
    ++c;
      }
    }       
  }   // end for(i)
  
  SandiaSort(fPhotoAbsorptionCof,c);
  fMaxInterval = c;
 
  const G4double* fractionW = fMaterial->GetFractionVector();
   
  for(i = 0; i < fMaxInterval; ++i)
  {
      for(j = 1; j < 5; ++j) fPhotoAbsorptionCof[i][j] = 0.;
  }
  for(i = 0; i < noElm; ++i)
  {
      n1 = 1;
      G4double 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)
      {
         G4double B1 = fSandiaTable[k][0];
         G4double B2 = fSandiaTable[k+1][0];
         for(G4int q = 1; q < fMaxInterval-1; q++)
         {
            G4double E1 = fPhotoAbsorptionCof[q][0];
            G4double E2 = fPhotoAbsorptionCof[q+1][0];
            if(B1 > E1 || B2 < E2 || E1 < I1)
        {
           continue;
        }
        for(j = 1; j < 5; ++j)
        {
               fPhotoAbsorptionCof[q][j] += fSandiaTable[k][j]*fractionW[i];
        }
      }  
       }   
       for(j = 1; j < 5; ++j)   // Last interval
       {
     fPhotoAbsorptionCof[fMaxInterval-1][j] += 
       fSandiaTable[k][j]*fractionW[i];
       }
  }     // 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 < fMaxInterval; ++jj)
    {
      for(kk = 0; kk < 5; ++kk)
      {
         fPhotoAbsorptionCof[jj-1][kk]= fPhotoAbsorptionCof[jj][kk];
      }
    }
    --fMaxInterval;
    --c;
  }
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while( c < fMaxInterval - 1 );
    
  // create the sandia matrix for this material

  --fMaxInterval;  // vmg 20.11.10
    
  fMatSandiaMatrix = new G4OrderedTable();
 
  for (i = 0; i < fMaxInterval; ++i)
  {
     fMatSandiaMatrix->push_back(new G4DataVector(5,0.));
  }             
  for ( i = 0; i < fMaxInterval; ++i )
  {
    for( j = 0; j < 5; ++j )
    {
      (*(*fMatSandiaMatrix)[i])[j] = fPhotoAbsorptionCof[i+1][j];
    }     
  }
  fMatNbOfIntervals = fMaxInterval; 
                    
  if ( fVerbose > 0 )
  {
    G4cout<<"vmg, G4SandiaTable::ComputeMatTable(), mat = "
      <<fMaterial->GetName()<<G4endl;

    for ( i = 0; i < fMaxInterval; ++i )
    {
      // G4cout<<i<<"\t"<<(*(*fMatSandiaMatrix)[i])[0]<<" keV \t"
      // <<(*(*fMatSandiaMatrix)[i])[1]
      //       <<"\t"<<(*(*fMatSandiaMatrix)[i])[2]<<"\t"
      // <<(*(*fMatSandiaMatrix)[i])[3]
      //   <<"\t"<<(*(*fMatSandiaMatrix)[i])[4]<<G4endl;

      G4cout<<i<<"\t"<<GetSandiaCofForMaterial(i,0)/keV
        <<" keV \t"<<this->GetSandiaCofForMaterial(i,1)
        <<"\t"<<this->GetSandiaCofForMaterial(i,2)
        <<"\t"<<this->GetSandiaCofForMaterial(i,3)
        <<"\t"<<this->GetSandiaCofForMaterial(i,4)<<G4endl;
    }
  }                 
  delete [] Z;
  return;
}  

Here is the call graph for this function:

Here is the caller graph for this function:

GetIonizationPot()

G4double G4SandiaTable::GetIonizationPot ( G4int  Z ) const

private

Definition at line 1025 of file G4SandiaTable.cc.

{
  assert (Z>0 && Z<101);
  return fIonizationPotentials[Z]*CLHEP::eV;
}

Here is the caller graph for this function:

GetLowerI1()

G4bool G4SandiaTable::GetLowerI1 ( )

inline

Definition at line 175 of file G4SandiaTable.hh.

{return fLowerI1;};

Here is the caller graph for this function:

GetMatNbOfIntervals()

G4int G4SandiaTable::GetMatNbOfIntervals

(

)

const

Definition at line 922 of file G4SandiaTable.cc.

{
  return fMatNbOfIntervals;
}

GetMaxInterval()

G4int G4SandiaTable::GetMaxInterval

(

)

const

Definition at line 689 of file G4SandiaTable.cc.

{ 
  return fMaxInterval;
}

Here is the caller graph for this function:

GetNbOfIntervals()

G4int G4SandiaTable::GetNbOfIntervals ( G4int  Z )

private

Definition at line 929 of file G4SandiaTable.cc.

{
  assert (Z>0 && Z<101);  
  return fNbOfIntervals[Z];
}

Here is the caller graph for this function:

GetPhotoAbsorpCof()

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

Definition at line 715 of file G4SandiaTable.cc.

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

Here is the caller graph for this function:

GetPointerToCof()

G4double ** G4SandiaTable::GetPointerToCof

(

)

Definition at line 696 of file G4SandiaTable.cc.

{ 
  if(!fPhotoAbsorptionCof) { ComputeMatTable(); }
  return fPhotoAbsorptionCof;
}

Here is the call graph for this function:

GetSandiaCofForMaterial() [1/2]

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

Definition at line 954 of file G4SandiaTable.cc.

{
  assert (interval>=0 && interval<fMatNbOfIntervals && j>=0 && j<5);
  return ((*(*fMatSandiaMatrix)[interval])[j]); 
}

Here is the caller graph for this function:

GetSandiaCofForMaterial() [2/2]

const G4double * G4SandiaTable::GetSandiaCofForMaterial

(

G4double

energy

)

const

Definition at line 963 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]);
}

GetSandiaCofForMaterialPAI() [1/2]

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

Definition at line 987 of file G4SandiaTable.cc.

{
  assert(fMatSandiaMatrixPAI && interval>=0 && 
     interval<fMatNbOfIntervals && j>=0 && j<5);
  return ((*(*fMatSandiaMatrixPAI)[interval])[j]); 
}

GetSandiaCofForMaterialPAI() [2/2]

const G4double * G4SandiaTable::GetSandiaCofForMaterialPAI

(

G4double

energy

)

const

Definition at line 997 of file G4SandiaTable.cc.

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

GetSandiaCofPerAtom()

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

Definition at line 137 of file G4SandiaTable.cc.

{
  assert(4 <= coeff.size());
  G4double Emin  = fSandiaTable[fCumulInterval[Z-1]][0]*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]*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:

GetSandiaCofWater()

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

Definition at line 170 of file G4SandiaTable.cc.

{
  assert(4 <= coeff.size());
  G4int i = 0;
  if(energy > fH2OlowerI1[0][0]*keV) {   
    i = fH2OlowerInt - 1;
    for(; i>0; --i) {
      if(energy >= fH2OlowerI1[i][0]*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:

GetSandiaMatrixPAI()

G4OrderedTable * G4SandiaTable::GetSandiaMatrixPAI

(

)

Definition at line 1034 of file G4SandiaTable.cc.

{
  if(!fMatSandiaMatrixPAI) { ComputeMatSandiaMatrixPAI(); }
  return fMatSandiaMatrixPAI;
}

Here is the call graph for this function:

GetSandiaMatTable()

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

Definition at line 978 of file G4SandiaTable.cc.

{
  assert(interval >= 0 && interval < fMaxInterval && j >= 0 && j < 5 );
  return ((*(*fMatSandiaMatrix)[interval])[j])*funitc[j]; 
}

Here is the caller graph for this function:

GetSandiaMatTablePAI()

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

Definition at line 1015 of file G4SandiaTable.cc.

{
  assert(fMatSandiaMatrixPAI && interval >= 0 && 
     interval < fMaxInterval && j >= 0 && j < 5 );
  return ((*(*fMatSandiaMatrixPAI)[interval])[j]); // *funitc[j];-> to method 
}

Here is the caller graph for this function:

GetSandiaPerAtom()

G4double G4SandiaTable::GetSandiaPerAtom ( G4int  Z, G4int  interval, G4int  j  )

private

Definition at line 938 of file G4SandiaTable.cc.

{
  assert (Z>0 && Z<101 && interval>=0 && interval<fNbOfIntervals[Z]
      && j>=0 && j<5);

  G4int row = fCumulInterval[Z-1] + interval;
  G4double x = fSandiaTable[row][0]*CLHEP::keV;
  if (j > 0) {
    x = Z*CLHEP::amu/fZtoAratio[Z]*fSandiaTable[row][j]*funitc[j];     
  }
  return x;
}

Here is the caller graph for this function:

GetWaterCofForMaterial()

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

Definition at line 196 of file G4SandiaTable.cc.

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

GetWaterEnergyLimit()

G4double G4SandiaTable::GetWaterEnergyLimit

(

)

const

Definition at line 189 of file G4SandiaTable.cc.

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

GetZtoA()

G4double G4SandiaTable::GetZtoA ( G4int  Z )

static

Definition at line 203 of file G4SandiaTable.cc.

{
  assert (Z>0 && Z<101);
  return fZtoAratio[Z];
}

Here is the caller graph for this function:

Initialize() [1/2]

void G4SandiaTable::Initialize

(

G4Material *

mat

)

Definition at line 662 of file G4SandiaTable.cc.

{
  fMaterial = mat;
  ComputeMatSandiaMatrixPAI();
}

Here is the call graph for this function:

Initialize() [2/2]

void G4SandiaTable::Initialize

(

G4int

matIndex

)

Definition at line 670 of file G4SandiaTable.cc.

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

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

Here is the call graph for this function:

operator=()

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

private

Here is the caller graph for this function:

SandiaIntervals()

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

Definition at line 742 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 call graph for this function:

Here is the caller graph for this function:

SandiaMixing()

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

Definition at line 838 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:

SandiaSort()

void G4SandiaTable::SandiaSort	(	G4double **	da,
		G4int	sz
	)

Definition at line 726 of file G4SandiaTable.cc.

{
  for(G4int i = 1;i < sz; ++i ) 
   {
     for(G4int j = i + 1;j < sz; ++j )
     {
       if(da[i][0] > da[j][0])   SandiaSwap(da,i,j);      
     }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SandiaSwap()

void G4SandiaTable::SandiaSwap	(	G4double **	da,
		G4int	i,
		G4int	j
	)

Definition at line 704 of file G4SandiaTable.cc.

{
  G4double tmp = da[i][0] ;
  da[i][0] = da[j][0] ;
  da[j][0] = tmp ;
}

Here is the caller graph for this function:

SetLowerI1()

void G4SandiaTable::SetLowerI1 ( G4bool  flag )

inline

Definition at line 176 of file G4SandiaTable.hh.

{fLowerI1=flag;};

Here is the call graph for this function:

SetVerbose()

void G4SandiaTable::SetVerbose ( G4int  ver )

inline

Definition at line 98 of file G4SandiaTable.hh.

{ fVerbose = ver; };

Here is the call graph for this function:

Member Data Documentation

fCumulInterval

G4int G4SandiaTable::fCumulInterval = {0}

staticprivate

Definition at line 132 of file G4SandiaTable.hh.

fH2OlowerI1

const G4double G4SandiaTable::fH2OlowerI1

staticprivate

Definition at line 124 of file G4SandiaTable.hh.

fH2OlowerInt

const G4int G4SandiaTable::fH2OlowerInt = 23

staticprivate

Definition at line 121 of file G4SandiaTable.hh.

fIntervalLimit

const G4int G4SandiaTable::fIntervalLimit = 100

staticprivate

Definition at line 119 of file G4SandiaTable.hh.

fIonizationPotentials

const G4double G4SandiaTable::fIonizationPotentials

staticprivate

Definition at line 127 of file G4SandiaTable.hh.

fLowerI1

G4bool G4SandiaTable::fLowerI1

private

Definition at line 192 of file G4SandiaTable.hh.

fMaterial

G4Material* G4SandiaTable::fMaterial

private

Definition at line 138 of file G4SandiaTable.hh.

fMatNbOfIntervals

G4int G4SandiaTable::fMatNbOfIntervals

private

Definition at line 139 of file G4SandiaTable.hh.

fMatSandiaMatrix

G4OrderedTable* G4SandiaTable::fMatSandiaMatrix

private

Definition at line 140 of file G4SandiaTable.hh.

fMatSandiaMatrixPAI

G4OrderedTable* G4SandiaTable::fMatSandiaMatrixPAI

private

Definition at line 141 of file G4SandiaTable.hh.

fMaxInterval

G4int G4SandiaTable::fMaxInterval

private

Definition at line 190 of file G4SandiaTable.hh.

fNbOfIntervals

const G4int G4SandiaTable::fNbOfIntervals

staticprivate

Definition at line 125 of file G4SandiaTable.hh.

fnulcof

const G4double G4SandiaTable::fnulcof = {0.0}

staticprivate

Definition at line 129 of file G4SandiaTable.hh.

fNumberOfElements

const G4int G4SandiaTable::fNumberOfElements = 100

staticprivate

Definition at line 118 of file G4SandiaTable.hh.

fNumberOfIntervals

const G4int G4SandiaTable::fNumberOfIntervals = 980

staticprivate

Definition at line 120 of file G4SandiaTable.hh.

fPhotoAbsorptionCof

G4double** G4SandiaTable::fPhotoAbsorptionCof

private

Definition at line 188 of file G4SandiaTable.hh.

fSandiaCofPerAtom

std::vector<G4double> G4SandiaTable::fSandiaCofPerAtom

private

Definition at line 135 of file G4SandiaTable.hh.

fSandiaTable

const G4double G4SandiaTable::fSandiaTable

staticprivate

Definition at line 123 of file G4SandiaTable.hh.

funitc

const G4double G4SandiaTable::funitc

staticprivate

Initial value:

= 
{
  CLHEP::keV,
  CLHEP::cm2*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV*CLHEP::keV*CLHEP::keV/CLHEP::g
}

Definition at line 128 of file G4SandiaTable.hh.

fVerbose

G4int G4SandiaTable::fVerbose

private

Definition at line 191 of file G4SandiaTable.hh.

fZtoAratio

const G4double G4SandiaTable::fZtoAratio

staticprivate

Definition at line 126 of file G4SandiaTable.hh.

---

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

• G4SandiaTable.hh
• G4StaticSandiaData.hh
• G4SandiaTable.cc