G4RToEConvForGamma Class Reference

#include <G4RToEConvForGamma.hh>

Inheritance diagram for G4RToEConvForGamma:

Public Member Functions
	G4RToEConvForGamma ()
virtual	~G4RToEConvForGamma ()
Protected Types
typedef G4LossTable	G4CrossSectionTable
Protected Member Functions
virtual G4double	ComputeLoss (G4double AtomicNumber, G4double KineticEnergy) const
virtual void	BuildRangeVector (const G4Material *aMaterial, G4RangeVector *rangeVector)
void	BuildAbsorptionLengthVector (const G4Material *aMaterial, G4RangeVector *rangeVector)
G4double	ComputeCrossSection (G4double AtomicNumber, G4double KineticEnergy) const

---

Detailed Description

Definition at line 51 of file G4RToEConvForGamma.hh.

---

Member Typedef Documentation

typedef G4LossTable G4RToEConvForGamma::G4CrossSectionTable [protected]

Definition at line 74 of file G4RToEConvForGamma.hh.

---

Constructor & Destructor Documentation

G4RToEConvForGamma::G4RToEConvForGamma

(

)

Definition at line 44 of file G4RToEConvForGamma.cc.

References G4ParticleTable::FindParticle(), G4cout, G4endl, G4ParticleTable::GetParticleTable(), G4VRangeToEnergyConverter::GetVerboseLevel(), and G4VRangeToEnergyConverter::theParticle.

                                       : G4VRangeToEnergyConverter()
{    
  theParticle =  G4ParticleTable::GetParticleTable()->FindParticle("gamma");
  if (theParticle ==0) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << " G4RToEConvForGamma::G4RToEConvForGamma() ";
      G4cout << " Gamma is not defined !!" << G4endl;
    }
#endif
  } 
}

G4RToEConvForGamma::~G4RToEConvForGamma

(

)

[virtual]

Definition at line 57 of file G4RToEConvForGamma.cc.

{ 
}

---

Member Function Documentation

void G4RToEConvForGamma::BuildAbsorptionLengthVector	(	const G4Material *	aMaterial,
		G4RangeVector *	rangeVector
	)			[protected]

Definition at line 65 of file G4RToEConvForGamma.cc.

References G4Material::GetAtomicNumDensityVector(), G4Material::GetElementVector(), G4Material::GetNumberOfElements(), G4VRangeToEnergyConverter::theLossTable, and G4VRangeToEnergyConverter::TotBin.

Referenced by BuildRangeVector().

{
  // fill the absorption length vector for this material
  // absorption length is defined here as
  //
  //    absorption length = 5./ macroscopic absorption cross section
  //
  const G4CrossSectionTable* aCrossSectionTable = (G4CrossSectionTable*)(theLossTable);
  const G4ElementVector* elementVector = aMaterial->GetElementVector();
  const G4double* atomicNumDensityVector = aMaterial->GetAtomicNumDensityVector();

  //  fill absorption length vector
  G4int NumEl = aMaterial->GetNumberOfElements();
  G4double absorptionLengthMax = 0.0;
  for (size_t ibin=0; ibin<size_t(TotBin); ibin++) {
    G4double SIGMA = 0. ;
    for (size_t iel=0; iel<size_t(NumEl); iel++) {
      G4int IndEl = (*elementVector)[iel]->GetIndex();
      SIGMA +=  atomicNumDensityVector[iel]*
                   (*((*aCrossSectionTable)[IndEl]))[ibin];
    }
    //  absorption length=5./SIGMA
    absorptionLengthVector->PutValue(ibin, 5./SIGMA);
    if (absorptionLengthMax < 5./SIGMA ) absorptionLengthMax = 5./SIGMA;
  }
}

void G4RToEConvForGamma::BuildRangeVector	(	const G4Material *	aMaterial,
		G4RangeVector *	rangeVector
	)			[inline, protected, virtual]

Definition at line 93 of file G4RToEConvForGamma.hh.

References BuildAbsorptionLengthVector().

{
  BuildAbsorptionLengthVector(aMaterial, rangeVector);
}

G4double G4RToEConvForGamma::ComputeCrossSection	(	G4double	AtomicNumber,
		G4double	KineticEnergy
	)			const [protected]

Definition at line 99 of file G4RToEConvForGamma.cc.

Referenced by ComputeLoss().

{
  //  Compute the "absorption" cross section of the photon "absorption"
  //  cross section means here the sum of the cross sections of the
  //  pair production, Compton scattering and photoelectric processes
  static G4double Z;  
  const  G4double t1keV = 1.*keV;
  const  G4double t200keV = 200.*keV;
  const  G4double t100MeV = 100.*MeV;

  static G4double s200keV, s1keV;
  static G4double tmin, tlow; 
  static G4double smin, slow;
  static G4double cmin, clow, chigh;
  //  compute Z dependent quantities in the case of a new AtomicNumber
  if(std::abs(AtomicNumber-Z)>0.1)  {
    Z = AtomicNumber;
    G4double Zsquare = Z*Z;
    G4double Zlog = std::log(Z);
    G4double Zlogsquare = Zlog*Zlog;

    s200keV = (0.2651-0.1501*Zlog+0.02283*Zlogsquare)*Zsquare;
    tmin = (0.552+218.5/Z+557.17/Zsquare)*MeV;
    smin = (0.01239+0.005585*Zlog-0.000923*Zlogsquare)*std::exp(1.5*Zlog);
    cmin=std::log(s200keV/smin)/(std::log(tmin/t200keV)*std::log(tmin/t200keV));
    tlow = 0.2*std::exp(-7.355/std::sqrt(Z))*MeV;
    slow = s200keV*std::exp(0.042*Z*std::log(t200keV/tlow)*std::log(t200keV/tlow));
    s1keV = 300.*Zsquare;
    clow =std::log(s1keV/slow)/std::log(tlow/t1keV);

    chigh=(7.55e-5-0.0542e-5*Z)*Zsquare*Z/std::log(t100MeV/tmin);
  }

  //  calculate the cross section (using an approximate empirical formula)
  G4double xs;
  if ( KineticEnergy<tlow ) {
    if(KineticEnergy<t1keV) xs = slow*std::exp(clow*std::log(tlow/t1keV));
    else                    xs = slow*std::exp(clow*std::log(tlow/KineticEnergy));

  } else if ( KineticEnergy<t200keV ) {
    xs = s200keV
         * std::exp(0.042*Z*std::log(t200keV/KineticEnergy)*std::log(t200keV/KineticEnergy));

  } else if( KineticEnergy<tmin ){
    xs = smin
         * std::exp(cmin*std::log(tmin/KineticEnergy)*std::log(tmin/KineticEnergy));

  } else {
    xs = smin + chigh*std::log(KineticEnergy/tmin);

  }
  return xs * barn;
}

G4double G4RToEConvForGamma::ComputeLoss	(	G4double	AtomicNumber,
		G4double	KineticEnergy
	)			const [inline, protected, virtual]

Implements G4VRangeToEnergyConverter.

Definition at line 86 of file G4RToEConvForGamma.hh.

References ComputeCrossSection().

{
  return ComputeCrossSection(AtomicNumber,KineticEnergy);
}

---

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

• G4RToEConvForGamma.hh
• G4RToEConvForGamma.cc

---