G4LivermorePhotoElectricModel Class Reference

#include <G4LivermorePhotoElectricModel.hh>

Inheritance diagram for G4LivermorePhotoElectricModel:

Public Member Functions
	G4LivermorePhotoElectricModel (const G4String &nam="LivermorePhElectric")
virtual	~G4LivermorePhotoElectricModel ()
virtual void	Initialise (const G4ParticleDefinition *, const G4DataVector &)
virtual G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0, G4double cut=0, G4double emax=DBL_MAX)
virtual void	SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy)
void	SetLimitNumberOfShells (G4int)
Protected Attributes
G4ParticleChangeForGamma *	fParticleChange

---

Detailed Description

Definition at line 50 of file G4LivermorePhotoElectricModel.hh.

---

Constructor & Destructor Documentation

G4LivermorePhotoElectricModel::G4LivermorePhotoElectricModel

(

const G4String &

nam = "LivermorePhElectric"

)

Definition at line 54 of file G4LivermorePhotoElectricModel.cc.

References G4Electron::Electron(), G4cout, G4endl, G4Gamma::Gamma(), G4VEmModel::SetAngularDistribution(), and G4VEmModel::SetDeexcitationFlag().

  : G4VEmModel(nam),fParticleChange(0),maxZ(99),
    nShellLimit(100),fDeexcitationActive(false),isInitialised(false),
    fAtomDeexcitation(0)
{ 
  verboseLevel= 0;
  // Verbosity scale:
  // 0 = nothing 
  // 1 = warning for energy non-conservation 
  // 2 = details of energy budget
  // 3 = calculation of cross sections, file openings, sampling of atoms
  // 4 = entering in methods

  theGamma    = G4Gamma::Gamma();
  theElectron = G4Electron::Electron();

  // default generator
  SetAngularDistribution(new G4SauterGavrilaAngularDistribution());

  for(G4int i=0; i<maxZ; ++i) { 
    fCrossSection[i] = 0; 
    fCrossSectionLE[i] = 0; 
    fNShells[i] = 0;
    fNShellsUsed[i] = 0;
  }

  if(verboseLevel>0) {
    G4cout << "Livermore PhotoElectric is constructed " 
           << " nShellLimit= " << nShellLimit << G4endl;
  }

  //Mark this model as "applicable" for atomic deexcitation
  SetDeexcitationFlag(true);
}

G4LivermorePhotoElectricModel::~G4LivermorePhotoElectricModel

(

)

[virtual]

Definition at line 92 of file G4LivermorePhotoElectricModel.cc.

{  
  for(G4int i=0; i<maxZ; ++i) { 
    delete fCrossSection[i]; 
    delete fCrossSectionLE[i]; 
  }
}

---

Member Function Documentation

G4double G4LivermorePhotoElectricModel::ComputeCrossSectionPerAtom	(	const G4ParticleDefinition *	,
		G4double	kinEnergy,
		G4double	Z,
		G4double	A = 0,
		G4double	cut = 0,
		G4double	emax = DBL_MAX
	)			[virtual]

Reimplemented from G4VEmModel.

Definition at line 155 of file G4LivermorePhotoElectricModel.cc.

References G4cout, G4endl, G4lrint(), and G4VEmModel::Value().

{
  if (verboseLevel > 3) {
    G4cout << "G4LivermorePhotoElectricModel::Calling ComputeCrossSectionPerAtom()" 
           << " Z= " << ZZ << "  R(keV)= " << energy/keV << G4endl;
  }
  G4double cs = 0.0;
  G4double gammaEnergy = energy;

  G4int Z = G4lrint(ZZ);
  if(Z < 1 || Z >= maxZ) { return cs; }

  // element was not initialised
  if(!fCrossSection[Z]) {
    char* path = getenv("G4LEDATA");
    ReadData(Z, path);
    if(!fCrossSection[Z]) { return cs; }
  }

  G4int idx = fNShells[Z]*6 - 4;
  if (gammaEnergy <= (fParam[Z])[idx-1]) { return cs; }
  
  G4double x1 = 1.0/gammaEnergy;
  G4double x2 = x1*x1;
  G4double x3 = x2*x1;

  // parameterisation
  if(gammaEnergy >= (fParam[Z])[0]) {
    G4double x4 = x2*x2;
    cs = x1*((fParam[Z])[idx] + x1*(fParam[Z])[idx+1]
             + x2*(fParam[Z])[idx+2] + x3*(fParam[Z])[idx+3] 
             + x4*(fParam[Z])[idx+4]);
    // high energy part
  } else if(gammaEnergy >= (fParam[Z])[1]) {
    cs = x3*(fCrossSection[Z])->Value(gammaEnergy);

    // low energy part
  } else {
    cs = x3*(fCrossSectionLE[Z])->Value(gammaEnergy);
  }
  if (verboseLevel > 1) { 
    G4cout << "LivermorePhotoElectricModel: E(keV)= " << gammaEnergy/keV
           << " Z= " << Z << " cross(barn)= " << cs/barn << G4endl;
  }
  return cs;
}

void G4LivermorePhotoElectricModel::Initialise	(	const G4ParticleDefinition *	,
		const G4DataVector &
	)			[virtual]

Implements G4VEmModel.

Definition at line 103 of file G4LivermorePhotoElectricModel.cc.

References G4LossTableManager::AtomDeexcitation(), fParticleChange, G4cout, G4endl, G4Material::GetElementVector(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Material::GetNumberOfElements(), G4VEmModel::GetParticleChangeForGamma(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), G4LossTableManager::Instance(), and G4VAtomDeexcitation::IsFluoActive().

{
  if (verboseLevel > 2) {
    G4cout << "Calling G4LivermorePhotoElectricModel::Initialise()" << G4endl;
  }

  char* path = getenv("G4LEDATA");

  G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = theCoupleTable->GetTableSize();
  
  for(G4int i=0; i<numOfCouples; ++i) 
  {
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
    const G4Material* material = couple->GetMaterial();
    const G4ElementVector* theElementVector = material->GetElementVector();
    G4int nelm = material->GetNumberOfElements();
    
    for (G4int j=0; j<nelm; ++j) 
    {        
      G4int Z = (G4int)(*theElementVector)[j]->GetZ();
      if(Z < 1)          { Z = 1; }
      else if(Z > maxZ)  { Z = maxZ; }
      if(!fCrossSection[Z]) { ReadData(Z, path); }
    }
  }  
  //  
  if (verboseLevel > 2) {
    G4cout << "Loaded cross section files for LivermorePhotoElectric model" 
           << G4endl;
  }
  if(!isInitialised) {
    isInitialised = true;
    fParticleChange = GetParticleChangeForGamma();

    fAtomDeexcitation = G4LossTableManager::Instance()->AtomDeexcitation();
  }
  fDeexcitationActive = false;
  if(fAtomDeexcitation) { 
    fDeexcitationActive = fAtomDeexcitation->IsFluoActive(); 
  }

  if (verboseLevel > 0) { 
    G4cout << "LivermorePhotoElectric model is initialized " << G4endl
           << G4endl;
  }
}

void G4LivermorePhotoElectricModel::SampleSecondaries	(	std::vector< G4DynamicParticle * > *	,
		const G4MaterialCutsCouple *	,
		const G4DynamicParticle *	,
		G4double	tmin,
		G4double	maxEnergy
	)			[virtual]

Implements G4VEmModel.

Definition at line 209 of file G4LivermorePhotoElectricModel.cc.

References G4InuclSpecialFunctions::bindingEnergy(), G4VAtomDeexcitation::CheckDeexcitationActiveRegion(), fParticleChange, fStopAndKill, G4cout, G4endl, G4lrint(), G4UniformRand, G4VAtomDeexcitation::GenerateParticles(), G4VEmModel::GetAngularDistribution(), G4VAtomDeexcitation::GetAtomicShell(), G4ElementData::GetComponentID(), G4MaterialCutsCouple::GetIndex(), G4DynamicParticle::GetKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4ElementData::GetValueForComponent(), G4Element::GetZ(), G4InuclParticleNames::nn, G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeTrackStatus(), G4VEmAngularDistribution::SampleDirection(), G4VEmModel::SelectRandomAtom(), G4ParticleChangeForGamma::SetProposedKineticEnergy(), and G4VEmModel::Value().

{
  G4double gammaEnergy = aDynamicGamma->GetKineticEnergy();
  if (verboseLevel > 3) {
    G4cout << "G4LivermorePhotoElectricModel::SampleSecondaries() Egamma(keV)= "
           << gammaEnergy/keV << G4endl;
  }
  
  // kill incident photon
  fParticleChange->SetProposedKineticEnergy(0.);
  fParticleChange->ProposeTrackStatus(fStopAndKill);   
 
  // Returns the normalized direction of the momentum
  G4ThreeVector photonDirection = aDynamicGamma->GetMomentumDirection(); 

  // Select randomly one element in the current material
  //G4cout << "Select random atom Egamma(keV)= " << gammaEnergy/keV << G4endl;
  const G4Element* elm = SelectRandomAtom(couple->GetMaterial(),theGamma,
                                          gammaEnergy);
  G4int Z = G4lrint(elm->GetZ());

  // Select the ionised shell in the current atom according to shell 
  //   cross sections
  // G4cout << "Select random shell Z= " << Z << G4endl;

  if(Z >= maxZ) { Z = maxZ-1; }

  // element was not initialised
  if(!fCrossSection[Z]) {
    char* path = getenv("G4LEDATA");
    ReadData(Z, path);
    if(!fCrossSection[Z]) { 
      fParticleChange->ProposeLocalEnergyDeposit(gammaEnergy);
      return;
    }
  }
  
  // shell index
  size_t shellIdx = 0;
  size_t nn = fNShellsUsed[Z];

  if(nn > 1) {
    if(gammaEnergy >= (fParam[Z])[0]) {
      G4double x1 = 1.0/gammaEnergy;
      G4double x2 = x1*x1;
      G4double x3 = x2*x1;
      G4double x4 = x3*x1;
      G4int idx   = nn*6 - 4;
      // when do sampling common factors are not taken into account
      // so cross section is not real
      G4double cs0 = G4UniformRand()*((fParam[Z])[idx] + x1*(fParam[Z])[idx+1]
                                      + x2*(fParam[Z])[idx+2] 
                                      + x3*(fParam[Z])[idx+3] 
                                      + x4*(fParam[Z])[idx+4]);
      for(shellIdx=0; shellIdx<nn; ++shellIdx) {
        idx = shellIdx*6 + 2;
        if(gammaEnergy > (fParam[Z])[idx-1]) {
          G4double cs = (fParam[Z])[idx] + x1*(fParam[Z])[idx+1] 
            + x2*(fParam[Z])[idx+2] + x3*(fParam[Z])[idx+3] 
            + x4*(fParam[Z])[idx+4];
          if(cs >= cs0) { break; }
        }
      }
      if(shellIdx >= nn) { shellIdx = nn-1; }

    } else {

      // when do sampling common factors are not taken into account
      // so cross section is not real
      G4double cs = G4UniformRand();

      if(gammaEnergy >= (fParam[Z])[1]) {
        cs *= (fCrossSection[Z])->Value(gammaEnergy);
      } else {
        cs *= (fCrossSectionLE[Z])->Value(gammaEnergy);
      }

      for(size_t j=0; j<nn; ++j) {
        shellIdx = (size_t)fShellCrossSection.GetComponentID(Z, j);
        if(gammaEnergy > (fParam[Z])[6*shellIdx+1]) {
          cs -= fShellCrossSection.GetValueForComponent(Z, j, gammaEnergy);
        }
        if(cs <= 0.0 || j+1 == nn) { break; }
      }
    }
  }

  G4double bindingEnergy = (fParam[Z])[shellIdx*6 + 1];
  //G4cout << "Z= " << Z << " shellIdx= " << shellIdx 
  //       << " nShells= " << fNShells[Z] 
  //       << " Ebind(keV)= " << bindingEnergy/keV 
  //       << " Egamma(keV)= " << gammaEnergy/keV << G4endl;

  const G4AtomicShell* shell = 0;

  // no de-excitation from the last shell
  if(fDeexcitationActive && shellIdx + 1 < nn) {
    G4AtomicShellEnumerator as = G4AtomicShellEnumerator(shellIdx);
    shell = fAtomDeexcitation->GetAtomicShell(Z, as);
  }

  // If binding energy of the selected shell is larger than photon energy
  //    do not generate secondaries
  if(gammaEnergy < bindingEnergy) {
    fParticleChange->ProposeLocalEnergyDeposit(gammaEnergy);
    return;
  }

  // Primary outcoming electron
  G4double eKineticEnergy = gammaEnergy - bindingEnergy;
  G4double edep = bindingEnergy;

  // Calculate direction of the photoelectron
  G4ThreeVector electronDirection = 
    GetAngularDistribution()->SampleDirection(aDynamicGamma, 
                                              eKineticEnergy,
                                              shellIdx, 
                                              couple->GetMaterial());

  // The electron is created 
  G4DynamicParticle* electron = new G4DynamicParticle (theElectron,
                                                       electronDirection,
                                                       eKineticEnergy);
  fvect->push_back(electron);

  // Sample deexcitation
  if(shell) {
    G4int index = couple->GetIndex();
    if(fAtomDeexcitation->CheckDeexcitationActiveRegion(index)) {
      size_t nbefore = fvect->size();

      fAtomDeexcitation->GenerateParticles(fvect, shell, Z, index);
      size_t nafter = fvect->size();
      if(nafter > nbefore) {
        for (size_t j=nbefore; j<nafter; ++j) {
          edep -= ((*fvect)[j])->GetKineticEnergy();
        } 
      }
    }
  }
  // energy balance - excitation energy left
  if(edep > 0.0) {
    fParticleChange->ProposeLocalEnergyDeposit(edep);
  }
}

void G4LivermorePhotoElectricModel::SetLimitNumberOfShells

(

G4int

)

[inline]

Definition at line 110 of file G4LivermorePhotoElectricModel.hh.

{
  nShellLimit = n;
}

---

Field Documentation

G4ParticleChangeForGamma* G4LivermorePhotoElectricModel::fParticleChange [protected]

Definition at line 80 of file G4LivermorePhotoElectricModel.hh.

Referenced by Initialise(), and SampleSecondaries().

---

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

• G4LivermorePhotoElectricModel.hh
• G4LivermorePhotoElectricModel.cc

---