G4GoudsmitSaundersonTable Class Reference

#include <G4GoudsmitSaundersonTable.hh>

Collaboration diagram for G4GoudsmitSaundersonTable:

Public Member Functions
	G4GoudsmitSaundersonTable ()
	~G4GoudsmitSaundersonTable ()
void	Initialise ()
G4double	SampleCosTheta (G4double, G4double, G4double, G4double, G4double, G4double)
G4double	SampleCosThetaII (G4double, G4double, G4double, G4double, G4double, G4double)
G4double	GetScreeningParam (G4double)
void	Sampling (G4double, G4double, G4double, G4double &, G4double &)
G4double	GetMoliereBc (G4int matindx)
G4double	GetMoliereXc2 (G4int matindx)

Private Member Functions
G4GoudsmitSaundersonTable &	operator= (const G4GoudsmitSaundersonTable &right)
	G4GoudsmitSaundersonTable (const G4GoudsmitSaundersonTable &)
void	LoadMSCData ()
void	LoadMSCDataII ()
void	InitMoliereMSCParams ()

Static Private Attributes
static G4bool	fgIsInitialised = FALSE
static const G4int	fgNumLambdas = 76
static const G4int	fgNumLamG1II = 22
static const G4double	fgLambdaValues []
static std::vector< G4double > *	fgMoliereBc = 0
static std::vector< G4double > *	fgMoliereXc2 = 0

Detailed Description

Definition at line 72 of file G4GoudsmitSaundersonTable.hh.

Constructor & Destructor Documentation

G4GoudsmitSaundersonTable() [1/2]

G4GoudsmitSaundersonTable::G4GoudsmitSaundersonTable ( )

inline

Definition at line 76 of file G4GoudsmitSaundersonTable.hh.

{};

Here is the call graph for this function:

Here is the caller graph for this function:

~G4GoudsmitSaundersonTable()

G4GoudsmitSaundersonTable::~G4GoudsmitSaundersonTable

(

)

Definition at line 299 of file G4GoudsmitSaundersonTable.cc.

                                                     {
  if(fgMoliereBc){
    delete fgMoliereBc;
    fgMoliereBc = 0;
  }
  if(fgMoliereXc2){
    delete fgMoliereXc2;
    fgMoliereXc2 = 0;
  }
  fgIsInitialised = FALSE;
}

Here is the caller graph for this function:

G4GoudsmitSaundersonTable() [2/2]

G4GoudsmitSaundersonTable::G4GoudsmitSaundersonTable ( const G4GoudsmitSaundersonTable &  )

private

Member Function Documentation

GetMoliereBc()

G4double G4GoudsmitSaundersonTable::GetMoliereBc ( G4int  matindx )

inline

Definition at line 104 of file G4GoudsmitSaundersonTable.hh.

{return (*fgMoliereBc)[matindx];}

Here is the caller graph for this function:

GetMoliereXc2()

G4double G4GoudsmitSaundersonTable::GetMoliereXc2 ( G4int  matindx )

inline

Definition at line 105 of file G4GoudsmitSaundersonTable.hh.

{return (*fgMoliereXc2)[matindx];}

Here is the call graph for this function:

Here is the caller graph for this function:

GetScreeningParam()

G4double G4GoudsmitSaundersonTable::GetScreeningParam

(

G4double

G1

)

Definition at line 563 of file G4GoudsmitSaundersonTable.cc.

                                                                {
   if(G1<fgG1Values[0])                      return fgScreeningParam[0];
   if(G1>fgG1Values[fgNumScreeningParams-1]) return fgScreeningParam[fgNumScreeningParams-1];
   // normal case
   const G4double lng10   = -2.30258509299405e+01;   //log(fgG1Values[0]);
   const G4double invlng1 =  6.948711710452e+00;     //1./log(fgG1Values[i+1]/fgG1Values[i])
   G4double logG1 = G4Log(G1);
   G4int k = (G4int)((logG1-lng10)*invlng1);
 return G4Exp(logG1*fgSrcAValues[k])*fgSrcBValues[k]; // log-log linear
}

Here is the call graph for this function:

Here is the caller graph for this function:

Initialise()

void G4GoudsmitSaundersonTable::Initialise

(

)

Definition at line 288 of file G4GoudsmitSaundersonTable.cc.

                                          {
   if(!fgIsInitialised){
     LoadMSCData();
     LoadMSCDataII();
     fgIsInitialised = TRUE;
   }

   InitMoliereMSCParams();
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitMoliereMSCParams()

void G4GoudsmitSaundersonTable::InitMoliereMSCParams ( )

private

Definition at line 747 of file G4GoudsmitSaundersonTable.cc.

                                                    {
   const G4double const1   = 7821.6;      // [cm2/g]
   const G4double const2   = 0.1569;      // [cm2 MeV2 / g]
   const G4double finstrc2 = 5.325135453E-5; // fine-structure const. square

   G4MaterialTable *theMaterialTable = G4Material::GetMaterialTable();
   // get number of materials in the table
   unsigned int numMaterials = theMaterialTable->size();
   // make sure that we have long enough vectors
   if(!fgMoliereBc) {
     fgMoliereBc  = new std::vector<G4double>(numMaterials);
     fgMoliereXc2 = new std::vector<G4double>(numMaterials);
   } else {
     fgMoliereBc->resize(numMaterials);
     fgMoliereXc2->resize(numMaterials);
   }

   const G4double xims = 0.0; // use xi_MS = 0.0 value now. We will see later on.
   for(unsigned int imat = 0; imat < numMaterials; ++imat) {
     const G4Material      *theMaterial  = (*theMaterialTable)[imat];
     const G4ElementVector *theElemVect  = theMaterial->GetElementVector();

     const G4int     numelems        = theMaterial->GetNumberOfElements();
     const G4double* theFractionVect = theMaterial->GetFractionVector();
     G4double zs = 0.0;
     G4double zx = 0.0;
     G4double ze = 0.0;

     for(G4int ielem = 0; ielem < numelems; ielem++) {
       G4double izet = (*theElemVect)[ielem]->GetZ();
       G4double iwa  = (*theElemVect)[ielem]->GetN();
//       G4int ipz     = theAtomsVect[ielem];
       G4double ipz  = theFractionVect[ielem];

       G4double dum  = ipz/iwa*izet*(izet+xims);
       zs += dum;
       ze += dum*(-2.0/3.0)*G4Log(izet);
       zx += dum*G4Log(1.0+3.34*finstrc2*izet*izet);
//       wa += ipz*iwa;
     }
     G4double density = theMaterial->GetDensity()*CLHEP::cm3/CLHEP::g; // [g/cm3]

     (*fgMoliereBc)[theMaterial->GetIndex()]  = const1*density*zs*G4Exp(ze/zs)/G4Exp(zx/zs);  //[1/cm]
     (*fgMoliereXc2)[theMaterial->GetIndex()] = const2*density*zs;  // [MeV2/cm]

     // change to Geant4 internal units of 1/length and energ2/length
     (*fgMoliereBc)[theMaterial->GetIndex()]  *= 1.0/CLHEP::cm;
     (*fgMoliereXc2)[theMaterial->GetIndex()] *= CLHEP::MeV*CLHEP::MeV/CLHEP::cm;
   }

}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadMSCData()

void G4GoudsmitSaundersonTable::LoadMSCData ( )

private

Definition at line 575 of file G4GoudsmitSaundersonTable.cc.

                                           {
 G4double dum;
 char  basename[512];
 char* path = getenv("G4LEDATA");
 if (!path) {
    G4Exception("G4GoudsmitSaundersonTable::LoadMSCData()","em0006",
        FatalException,
        "Environment variable G4LEDATA not defined");
    return;
 }

 std::string pathString(path);
 sprintf(basename,"inverseq2CDF");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCData()","em0006",
         FatalException,
         msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInverseQ2CDFs[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }


 sprintf(basename,"inverseq2CDFRatInterpPA");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCData()","em0006",
         FatalException,
         msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInterParamsA2[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }

 sprintf(basename,"inverseq2CDFRatInterpPB");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCData()","em0006",
        FatalException,
        msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInterParamsB2[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadMSCDataII()

void G4GoudsmitSaundersonTable::LoadMSCDataII ( )

private

Definition at line 661 of file G4GoudsmitSaundersonTable.cc.

                                             {
G4double dum;
char  basename[512];
char* path = getenv("G4LEDATA");
if (!path) {
   G4Exception("G4GoudsmitSaundersonTable::LoadMSCDataII()","em0006",
        FatalException,
        "Environment variable G4LEDATA not defined");
   return;
}


 std::string pathString(path);
 sprintf(basename,"inverseq2CDFII");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCDataII()","em0006",
         FatalException,
         msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1II;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1II+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInverseQ2CDFsII[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }


 sprintf(basename,"inverseq2CDFRatInterpPAII");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCDataII()","em0006",
         FatalException,
         msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1II;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1II+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInterParamsA2II[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }

 sprintf(basename,"inverseq2CDFRatInterpPBII");
 for(int k = 0; k < fgNumLambdas; ++k){
   char fname[512];
   sprintf(fname,"%s/msc_GS/%s_%d",path,basename,k);
   std::ifstream infile(fname,std::ios::in);
   if(!infile.is_open()){
     char msgc[512];
     sprintf(msgc,"Cannot open file: %s .",fname);
     G4Exception("G4GoudsmitSaundersonTable::LoadMSCDataII()","em0006",
        FatalException,
        msgc);
     return;
   }

   int limk = k*fgNumUvalues*fgNumLamG1II;
   for(int i = 0; i < fgNumUvalues; ++i)
    for(int j = 0; j < fgNumLamG1II+1; ++j)
    if(j==0) infile >> dum;
    else     infile >> fgInterParamsB2II[limk+(j-1)*fgNumUvalues+i];

   infile.close();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Here is the caller graph for this function:

SampleCosTheta()

G4double G4GoudsmitSaundersonTable::SampleCosTheta	(	G4double	lambdavalue,
		G4double	lamG1value,
		G4double	screeningparam,
		G4double	rndm1,
		G4double	rndm2,
		G4double	rndm3
	)

Definition at line 314 of file G4GoudsmitSaundersonTable.cc.

                                           {
  const G4double lnl0   = 0.0;              //log(fgLambdaValues[0]);
  const G4double invlnl = 6.5144172285e+00; //1./log(fgLambdaValues[i+1]/fgLambdaValues[i])
  G4double logLambdaVal = G4Log(lambdavalue);
  G4int lambdaindx = (G4int)((logLambdaVal-lnl0)*invlnl);

  const G4double dd = 1.0/0.0499; // delta
  G4int lamg1indx  = (G4int)((lamG1value-fgLamG1Values[0])*dd);

  G4double probOfLamJ = G4Log(fgLambdaValues[lambdaindx+1]/lambdavalue)*invlnl;
  if(rndm1 > probOfLamJ)
     ++lambdaindx;

  // store 1.0/(fgLamG1Values[lamg1indx+1]-fgLamG1Values[lamg1indx]) const value
  const G4double onePerLamG1Diff = dd;
  G4double probOfLamG1J = (fgLamG1Values[lamg1indx+1]-lamG1value)*onePerLamG1Diff;
  if(rndm2 > probOfLamG1J)
     ++lamg1indx;

  G4int begin = lambdaindx*(fgNumLamG1*fgNumUvalues)+lamg1indx*fgNumUvalues;

  // sample bin
  G4int indx =  (G4int)(rndm3*100); // value/delatU ahol deltaU = 0.01; find u-indx
  G4double cp1 = fgUValues[indx];
//  G4double cp2 = fgUValues[indx+1];
  indx +=begin;

  G4double u1  = fgInverseQ2CDFs[indx];
  G4double u2  = fgInverseQ2CDFs[indx+1];

  G4double dum1 = rndm3 - cp1;
  const G4double dum2  = 0.01;//cp2-cp1;  // this is constans 0.01
  const G4double dum22 = 0.0001;
  // rational interpolation of the inverse CDF
  G4double sample= u1+(1.0+fgInterParamsA2[indx]+fgInterParamsB2[indx])*dum1*dum2/(dum22+
               dum1*dum2*fgInterParamsA2[indx]+fgInterParamsB2[indx]*dum1*dum1)*(u2-u1);

  // transform back u to cos(theta) :
  // -compute parameter value a = w2*screening_parameter
  G4double t = logLambdaVal;
  G4double dum;
  if(lambdavalue >= 10.0)
    dum = 0.5*(-2.77164+t*( 2.94874-t*(0.1535754-t*0.00552888) ));
  else
    dum = 0.5*(1.347+t*(0.209364-t*(0.45525-t*(0.50142-t*0.081234))));

  G4double a = dum*(lambdavalue+4.0)*screeningparam;

  // this is the sampled cos(theta)
  return (2.0*a*sample)/(1.0-sample+a);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SampleCosThetaII()

G4double G4GoudsmitSaundersonTable::SampleCosThetaII	(	G4double	lambdavalue,
		G4double	lamG1value,
		G4double	screeningparam,
		G4double	rndm1,
		G4double	rndm2,
		G4double	rndm3
	)

Definition at line 371 of file G4GoudsmitSaundersonTable.cc.

                                           {
  const G4double lnl0   = 0.0;              //log(fgLambdaValues[0]);
  const G4double invlnl = 6.5144172285e+00; //1./log(fgLambdaValues[i+1]/fgLambdaValues[i])
  G4double logLambdaVal = G4Log(lambdavalue);
  G4int lambdaindx = (G4int)((logLambdaVal-lnl0)*invlnl);

  const G4double dd = 1.0/0.333; // delta
  G4int lamg1indx  = (G4int)((lamG1value-fgLamG1ValuesII[0])*dd);

  G4double probOfLamJ = G4Log(fgLambdaValues[lambdaindx+1]/lambdavalue)*invlnl;
  if(rndm1 > probOfLamJ)
     ++lambdaindx;

  // store 1.0/(fgLamG1Values[lamg1indx+1]-fgLamG1Values[lamg1indx]) const value
  const G4double onePerLamG1Diff = dd;
  G4double probOfLamG1J = (fgLamG1ValuesII[lamg1indx+1]-lamG1value)*onePerLamG1Diff;
  if(rndm2 > probOfLamG1J)
     ++lamg1indx;

  // protection against cases when the sampled lamG1 values are not possible due
  // to the fact that G1<=1 (G1 = lam_el/lam_tr1)
  // -- in theory it should never happen when lamg1indx=0 but check it just to be sure
  if(fgLamG1ValuesII[lamg1indx]>lambdavalue && lamg1indx>0) 
    --lamg1indx;
    

  G4int begin = lambdaindx*(fgNumLamG1II*fgNumUvalues)+lamg1indx*fgNumUvalues;

  // sample bin
  G4int indx =  (G4int)(rndm3*100); // value/delatU ahol deltaU = 0.01; find u-indx
  G4double cp1 = fgUValues[indx];
//  G4double cp2 = fgUValues[indx+1];
  indx +=begin;

  G4double u1  = fgInverseQ2CDFsII[indx];
  G4double u2  = fgInverseQ2CDFsII[indx+1];

  G4double dum1 = rndm3 - cp1;
  const G4double dum2  = 0.01;//cp2-cp1;  // this is constans 0.01
  const G4double dum22 = 0.0001;
  // rational interpolation of the inverse CDF
  G4double sample= u1+(1.0+fgInterParamsA2II[indx]+fgInterParamsB2II[indx])*dum1*dum2/(dum22+
               dum1*dum2*fgInterParamsA2II[indx]+fgInterParamsB2II[indx]*dum1*dum1)*(u2-u1);

  // transform back u to cos(theta) :
  // -compute parameter value a = w2*screening_parameter
  G4double t = logLambdaVal;
  G4double dum = 0.;
  if(lambdavalue >= 10.0)
    dum = 0.5*(-2.77164+t*( 2.94874-t*(0.1535754-t*0.00552888) ));
  else
    dum = 0.5*(1.347+t*(0.209364-t*(0.45525-t*(0.50142-t*0.081234))));

  G4double a = dum*(lambdavalue+4.0)*screeningparam;

  // this is the sampled cos(theta)
  return (2.0*a*sample)/(1.0-sample+a);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sampling()

void G4GoudsmitSaundersonTable::Sampling	(	G4double	lambdavalue,
		G4double	lamG1value,
		G4double	scrPar,
		G4double &	cost,
		G4double &	sint
	)

**** let it izotropic if we are above the grid i.e. true path length is long

Definition at line 435 of file G4GoudsmitSaundersonTable.cc.

                                                                            {
  G4double rand0 = G4UniformRand();
  G4double expn  = G4Exp(-lambdavalue);

  //
  // no scattering case
  //
  if(rand0 < expn) {
    cost = 1.0;
    sint = 0.0;
    return;
  }

  //
  // single scattering case : sample (analitically) from the single scattering PDF
  //                          that corresponds to the modified-Wentzel DCS i.e.
  //                          Wentzel DCS that gives back the PWA first-transport mfp
  //
  if( rand0 < (1.+lambdavalue)*expn) {
    G4double rand1 = G4UniformRand();
    // sampling 1-cos(theta)
    G4double dum0  = 2.0*scrPar*rand1/(1.0 - rand1 + scrPar);
    // add protections
    if(dum0 < 0.0)       dum0 = 0.0;
    else if(dum0 > 2.0 ) dum0 = 2.0;
    // compute cos(theta) and sin(theta)
    cost = 1.0 - dum0;
    sint = std::sqrt(dum0*(2.0 - dum0));
    return;
  }

  //
  // handle this case:
  //      -lambdavalue < 1 i.e. mean #elastic events along the step is < 1 but
  //       the currently sampled case is not 0 or 1 scattering. [Our minimal
  //       lambdavalue (that we have precomputed, transformed angular distributions
  //       stored in a form of equally probabe intervalls together with rational
  //       interp. parameters) is 1.]
  //      -probability of having n elastic events follows Poisson stat. with
  //       lambdavalue parameter.
  //      -the max. probability (when lambdavalue=1) of having more than one
  //       elastic events is 0.2642411 and the prob of having 2,3,..,n elastic
  //       events decays rapidly with n. So set a max n to 10.
  //      -sampling of this cases is done in a one-by-one single elastic event way
  //       where the current #elastic event is sampled from the Poisson distr.
  //      -(other possibility would be to use lambdavalue=1 distribution because
  //        they are very close)
  if(lambdavalue < 1.0) {
     G4double prob, cumprob;
     prob = cumprob = expn;
     G4double curcost,cursint;
     // init cos(theta) and sin(theta) to the zero scattering values
     cost = 1.0;
     sint = 0.0;

     for(G4int iel = 1; iel < 10; ++iel){
        // prob of having iel scattering from Poisson
        prob    *= lambdavalue/(G4double)iel;
        cumprob += prob;
        //
        //sample cos(theta) from the singe scattering pdf
        //
        G4double rand1 = G4UniformRand();
        // sampling 1-cos(theta)
        G4double dum0  = 2.0*scrPar*rand1/(1.0 - rand1 + scrPar);
        // compute cos(theta) and sin(theta)
        curcost = 1.0 - dum0;
        cursint = dum0*(2.0 - dum0);
        //
        // if we got current deflection that is not too small
        // then update cos(theta) sin(theta)
        if(cursint > 1.0e-20){
          cursint = std::sqrt(cursint);
          G4double curphi = CLHEP::twopi*G4UniformRand();
          cost = cost*curcost - sint*cursint*std::cos(curphi);
          sint = std::sqrt(std::max(0.0, (1.0-cost)*(1.0+cost)));
        }
        //
        // check if we have done enough scattering i.e. sampling from the Poisson
        if( rand0 < cumprob)
          return;
     }
     // if reached the max iter i.e. 10
     return;
  }


  //  IT IS DONE NOW IN THE MODEL
  //if(lamG1value>fgLamG1Values[fgNumLamG1-1]) {
  //  cost = 1.-2.*G4UniformRand();
  //  sint = std::sqrt((1.-cost)*(1.+cost));
  //  return;
  //}


  //
  // multiple scattering case with lambdavalue >= 1:
  //   - use the precomputed and transformed Goudsmit-Saunderson angular
  //     distributions that are stored in a form of equally probabe intervalls
  //     together with the corresponding rational interp. parameters
  //
  // add protections
  if(lamG1value<fgLamG1Values[0]) lamG1value = fgLamG1Values[0];
  if(lamG1value>fgLamG1ValuesII[fgNumLamG1II-1]) lamG1value = fgLamG1ValuesII[fgNumLamG1II-1];

  // sample 1-cos(theta) :: depending on the grids
  G4double dum0 = 0.0;
  if(lamG1value<fgLamG1Values[fgNumLamG1-1]) {
      dum0 = SampleCosTheta(lambdavalue, lamG1value, scrPar, G4UniformRand(),
                                 G4UniformRand(), G4UniformRand());

  } else {
    dum0 = SampleCosThetaII(lambdavalue, lamG1value, scrPar, G4UniformRand(),
                               G4UniformRand(), G4UniformRand());
  }

  // add protections
  if(dum0 < 0.0)  dum0 = 0.0;
  if(dum0 > 2.0 ) dum0 = 2.0;

  // compute cos(theta) and sin(theta)
     cost = 1.0-dum0;
     sint = std::sqrt(dum0*(2.0 - dum0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fgIsInitialised

G4bool G4GoudsmitSaundersonTable::fgIsInitialised = FALSE

staticprivate

Definition at line 178 of file G4GoudsmitSaundersonTable.hh.

fgLambdaValues

const G4double G4GoudsmitSaundersonTable::fgLambdaValues

staticprivate

Initial value:

={
    1.000000000000e+00, 1.165914401180e+00, 1.359356390879e+00, 1.584893192461e+00,
    1.847849797422e+00, 2.154434690032e+00, 2.511886431510e+00, 2.928644564625e+00,
    3.414548873834e+00, 3.981071705535e+00, 4.641588833613e+00, 5.411695265465e+00,
    6.309573444802e+00, 7.356422544596e+00, 8.576958985909e+00, 1.000000000000e+01,
    1.165914401180e+01, 1.359356390879e+01, 1.584893192461e+01, 1.847849797422e+01,
    2.154434690032e+01, 2.511886431510e+01, 2.928644564625e+01, 3.414548873834e+01,
    3.981071705535e+01, 4.641588833613e+01, 5.411695265465e+01, 6.309573444802e+01,
    7.356422544596e+01, 8.576958985909e+01, 1.000000000000e+02, 1.165914401180e+02,
    1.359356390879e+02, 1.584893192461e+02, 1.847849797422e+02, 2.154434690032e+02,
    2.511886431510e+02, 2.928644564625e+02, 3.414548873834e+02, 3.981071705535e+02,
    4.641588833613e+02, 5.411695265465e+02, 6.309573444802e+02, 7.356422544596e+02,
    8.576958985909e+02, 1.000000000000e+03, 1.165914401180e+03, 1.359356390879e+03,
    1.584893192461e+03, 1.847849797422e+03, 2.154434690032e+03, 2.511886431510e+03,
    2.928644564625e+03, 3.414548873834e+03, 3.981071705535e+03, 4.641588833613e+03,
    5.411695265465e+03, 6.309573444802e+03, 7.356422544596e+03, 8.576958985909e+03,
    1.000000000000e+04, 1.165914401180e+04, 1.359356390879e+04, 1.584893192461e+04,
    1.847849797422e+04, 2.154434690032e+04, 2.511886431510e+04, 2.928644564625e+04,
    3.414548873834e+04, 3.981071705535e+04, 4.641588833613e+04, 5.411695265465e+04,
    6.309573444802e+04, 7.356422544596e+04, 8.576958985909e+04, 1.000000000000e+05
}

number of s/{e} $-values; size = fgNumLambdas = 76

Definition at line 135 of file G4GoudsmitSaundersonTable.hh.

fgMoliereBc

std::vector< G4double > * G4GoudsmitSaundersonTable::fgMoliereBc = 0

staticprivate

the grid of b_lambda_{c} $ and {e} $) under the screened Rutherford cross section approximation. (These are used in G4GoudsmitSaundersonMscModel if fgIsUsePWATotalXsecData is FALSE.)

Definition at line 173 of file G4GoudsmitSaundersonTable.hh.

fgMoliereXc2

std::vector< G4double > * G4GoudsmitSaundersonTable::fgMoliereXc2 = 0

staticprivate

Definition at line 174 of file G4GoudsmitSaundersonTable.hh.

fgNumLambdas

const G4int G4GoudsmitSaundersonTable::fgNumLambdas = 76

staticprivate

size of grids of some parameters

Definition at line 125 of file G4GoudsmitSaundersonTable.hh.

fgNumLamG1II

const G4int G4GoudsmitSaundersonTable::fgNumLamG1II = 22

staticprivate

number of s/{e}G_{1} $-values

Definition at line 127 of file G4GoudsmitSaundersonTable.hh.

---

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

• G4GoudsmitSaundersonTable.hh
• G4GoudsmitSaundersonTable.cc