G4GSMottCorrection Class Reference

#include <G4GSMottCorrection.hh>

Public Member Functions
	G4GSMottCorrection (G4bool iselectron=true)
	~G4GSMottCorrection ()
void	Initialise ()
void	GetMottCorrectionFactors (G4double logekin, G4double beta2, G4int matindx, G4double &mcToScr, G4double &mcToQ1, G4double &mcToG2PerG1)
G4double	GetMottRejectionValue (G4double logekin, G4double G4beta2, G4double q1, G4double cost, G4int matindx, G4int &ekindx, G4int &deltindx)

Static Public Member Functions
static G4int	GetMaxZet ()

Detailed Description

Definition at line 87 of file G4GSMottCorrection.hh.

Constructor & Destructor Documentation

G4GSMottCorrection()

G4GSMottCorrection::G4GSMottCorrection

(

G4bool

iselectron = true

)

Definition at line 71 of file G4GSMottCorrection.cc.

                                                        : fIsElectron(iselectron) {
  // init grids related data member values
  fMaxEkin        = CLHEP::electron_mass_c2*(1./std::sqrt(1.-gMaxBeta2)-1.);
  fLogMinEkin     = G4Log(gMinEkin);
  fInvLogDelEkin  = (gNumEkin-gNumBeta2)/G4Log(gMidEkin/gMinEkin);
  G4double pt2    = gMidEkin*(gMidEkin+2.0*CLHEP::electron_mass_c2);
  fMinBeta2       = pt2/(pt2+CLHEP::electron_mass_c2*CLHEP::electron_mass_c2);
  fInvDelBeta2    = (gNumBeta2-1.)/(gMaxBeta2-fMinBeta2);
  fInvDelDelta    = (gNumDelta-1.)/gMaxDelta;
  fInvDelAngle    = gNumAngle-1.;
}

~G4GSMottCorrection()

G4GSMottCorrection::~G4GSMottCorrection

(

)

Definition at line 84 of file G4GSMottCorrection.cc.

                                        {
  ClearMCDataPerElement();
  ClearMCDataPerMaterial();
}

Member Function Documentation

GetMaxZet()

static G4int G4GSMottCorrection::GetMaxZet ( )

inlinestatic

Definition at line 101 of file G4GSMottCorrection.hh.

{ return gMaxZet; }

GetMottCorrectionFactors()

void G4GSMottCorrection::GetMottCorrectionFactors	(	G4double	logekin,
		G4double	beta2,
		G4int	matindx,
		G4double &	mcToScr,
		G4double &	mcToQ1,
		G4double &	mcToG2PerG1
	)

Definition at line 90 of file G4GSMottCorrection.cc.

                                                                                           {
  G4int    ekinIndxLow = 0;
  G4double remRfaction = 0.;
  if (beta2>=gMaxBeta2) {
    ekinIndxLow = gNumEkin - 1;
    // remRfaction = -1.
  } else if (beta2>=fMinBeta2) {  // linear interpolation on \beta^2
    remRfaction   = (beta2 - fMinBeta2) * fInvDelBeta2;
    ekinIndxLow   = (G4int)remRfaction;
    remRfaction  -= ekinIndxLow;
    ekinIndxLow  += (gNumEkin - gNumBeta2);
  } else if (logekin>=fLogMinEkin) {
    remRfaction   = (logekin - fLogMinEkin) * fInvLogDelEkin;
    ekinIndxLow   = (G4int)remRfaction;
    remRfaction  -= ekinIndxLow;
  } // the defaults otherwise i.e. use the lowest energy values when ekin is smaller than the minum ekin
  //
  DataPerEkin *perEkinLow  = fMCDataPerMaterial[matindx]->fDataPerEkin[ekinIndxLow];
  mcToScr      = perEkinLow->fMCScreening;
  mcToQ1       = perEkinLow->fMCFirstMoment;
  mcToG2PerG1  = perEkinLow->fMCSecondMoment;
  if (remRfaction>0.) {
    DataPerEkin *perEkinHigh = fMCDataPerMaterial[matindx]->fDataPerEkin[ekinIndxLow+1];
    mcToScr      += remRfaction*(perEkinHigh->fMCScreening    - perEkinLow->fMCScreening);
    mcToQ1       += remRfaction*(perEkinHigh->fMCFirstMoment  - perEkinLow->fMCFirstMoment);
    mcToG2PerG1  += remRfaction*(perEkinHigh->fMCSecondMoment - perEkinLow->fMCSecondMoment);
  }
}

GetMottRejectionValue()

double G4GSMottCorrection::GetMottRejectionValue	(	G4double	logekin,
		G4double	G4beta2,
		G4double	q1,
		G4double	cost,
		G4int	matindx,
		G4int &	ekindx,
		G4int &	deltindx
	)

Definition at line 122 of file G4GSMottCorrection.cc.

                                                                                                {
  G4double val   = 1.0;
  G4double delta = q1/(0.5+q1);
  // check if converged to 1 for all angles => accept cost
  if (delta>=gMaxDelta) {
    return val;
  }
  //
  // check if kinetic energy index needs to be determined
  if (ekindx<0) {
    G4int    ekinIndxLow  = 0;
    G4double probIndxHigh = 0.;  // will be the prob. of taking the ekinIndxLow+1 bin
    if (beta2>gMaxBeta2) {
      ekinIndxLow = gNumEkin - 1;
      // probIndxHigh = -1.
    } else if (beta2>=fMinBeta2) {    // linear interpolation on \beta^2
      probIndxHigh  = (beta2 - fMinBeta2) * fInvDelBeta2;
      ekinIndxLow   = (G4int)probIndxHigh;
      probIndxHigh -= ekinIndxLow;
      ekinIndxLow  += (gNumEkin - gNumBeta2);
    } else if (logekin>fLogMinEkin) { // linear interpolation on \ln(E_{kin})
      probIndxHigh  = (logekin - fLogMinEkin) * fInvLogDelEkin;
      ekinIndxLow   = (G4int)probIndxHigh;
      probIndxHigh -= ekinIndxLow;
    } // the defaults otherwise i.e. use the lowest energy values when ekin is smaller than the minum ekin
    //
    // check if need to take the higher ekin index
    if (G4UniformRand()<probIndxHigh) {
      ++ekinIndxLow;
    }
    // set kinetic energy grid index
    ekindx = ekinIndxLow;
  }
  // check if delta value index needs to be determined (note: in case of single scattering deltindx will be set to 0 by
  // by the caller but the ekindx will be -1: kinetic energy index is not known but the delta index is known)
  if (deltindx<0) {
    // note: delta is for sure < gMaxDelta at this point ( and minimum delta value is 0)
    G4double probIndxHigh = delta*fInvDelDelta;  // will be the prob. of taking the deltIndxLow+1 bin
    G4int    deltIndxLow  = (G4int)probIndxHigh;
    probIndxHigh         -= deltIndxLow;
    // check if need to take the higher delta index
    if (G4UniformRand()<probIndxHigh) {
      ++deltIndxLow;
    }
    // set the delta value grid index
    deltindx = deltIndxLow;
  }
  //
  // get the corresponding distribution
  DataPerDelta *perDelta  = fMCDataPerMaterial[matindx]->fDataPerEkin[ekindx]->fDataPerDelta[deltindx];
  //
  // determine lower index of the angular bin
  G4double ang         = std::sqrt(0.5*(1.-cost)); // sin(0.5\theta) in [0,1]
  G4double remRfaction = ang*fInvDelAngle;
  G4int    angIndx     = (G4int)remRfaction;
  remRfaction         -= angIndx;
  if (angIndx<gNumAngle-2) { // normal case: linear interpolation
    val          = remRfaction*(perDelta->fRejFuntion[angIndx+1]-perDelta->fRejFuntion[angIndx]) + perDelta->fRejFuntion[angIndx];
  } else {   // last bin
    G4double dum = ang-1.+1./fInvDelAngle;
    val          = perDelta->fSA + dum*(perDelta->fSB + dum*(perDelta->fSC + dum*perDelta->fSD));
  }
  return val;
}

Initialise()

void G4GSMottCorrection::Initialise

(

)

Definition at line 189 of file G4GSMottCorrection.cc.

                                    {
  // load Mott-correction data for each elements that belongs to materials that are used in the detector
  InitMCDataPerElement();
  // clrea Mott-correction data per material
  ClearMCDataPerMaterial();
  // initialise Mott-correction data for the materials that are used in the detector
  InitMCDataPerMaterials();
}

---

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

• G4GSMottCorrection.hh
• G4GSMottCorrection.cc