G4VAtomDeexcitation Class Reference

#include <G4VAtomDeexcitation.hh>

Inheritance diagram for G4VAtomDeexcitation:

Public Member Functions
	G4VAtomDeexcitation (const G4String &modname="Deexcitation")
virtual	~G4VAtomDeexcitation ()
void	InitialiseAtomicDeexcitation ()
virtual void	InitialiseForNewRun ()=0
virtual void	InitialiseForExtraAtom (G4int Z)=0
void	SetDeexcitationActiveRegion (const G4String &rname, G4bool valDeexcitation, G4bool valAuger, G4bool valPIXE)
void	SetFluo (G4bool)
G4bool	IsFluoActive () const
void	SetAuger (G4bool)
G4bool	IsAugerActive () const
void	SetAugerCascade (G4bool)
G4bool	IsAugerCascadeActive () const
void	SetPIXE (G4bool)
G4bool	IsPIXEActive () const
const G4String &	GetName () const
const std::vector< G4bool > &	GetListOfActiveAtoms () const
void	SetVerboseLevel (G4int)
G4int	GetVerboseLevel () const
G4bool	CheckDeexcitationActiveRegion (G4int coupleIndex)
G4bool	CheckAugerActiveRegion (G4int coupleIndex)
virtual const G4AtomicShell *	GetAtomicShell (G4int Z, G4AtomicShellEnumerator shell)=0
void	GenerateParticles (std::vector< G4DynamicParticle * > *secVect, const G4AtomicShell *, G4int Z, G4int coupleIndex)
virtual void	GenerateParticles (std::vector< G4DynamicParticle * > *secVect, const G4AtomicShell *, G4int Z, G4double gammaCut, G4double eCut)=0
virtual G4double	GetShellIonisationCrossSectionPerAtom (const G4ParticleDefinition *, G4int Z, G4AtomicShellEnumerator shell, G4double kinE, const G4Material *mat=nullptr)=0
virtual G4double	ComputeShellIonisationCrossSectionPerAtom (const G4ParticleDefinition *, G4int Z, G4AtomicShellEnumerator shell, G4double kinE, const G4Material *mat=nullptr)=0
void	AlongStepDeexcitation (std::vector< G4Track * > &tracks, const G4Step &step, G4double &eLoss, G4int coupleIndex)
	G4VAtomDeexcitation (G4VAtomDeexcitation &)=delete
G4VAtomDeexcitation &	operator= (const G4VAtomDeexcitation &right)=delete

Detailed Description

Definition at line 64 of file G4VAtomDeexcitation.hh.

Constructor & Destructor Documentation

G4VAtomDeexcitation() [1/2]

G4VAtomDeexcitation::G4VAtomDeexcitation ( const G4String & modname = "Deexcitation" )

explicit

Definition at line 72 of file G4VAtomDeexcitation.cc.

  : name(modname)
{
  vdyn.reserve(5);
  theCoupleTable = nullptr;
  gamma = G4Gamma::Gamma();
}

Referenced by G4UAtomicDeexcitation::G4UAtomicDeexcitation(), G4VAtomDeexcitation(), and operator=().

~G4VAtomDeexcitation()

G4VAtomDeexcitation::~G4VAtomDeexcitation ( )

virtualdefault

G4VAtomDeexcitation() [2/2]

G4VAtomDeexcitation::G4VAtomDeexcitation ( G4VAtomDeexcitation & )

delete

Member Function Documentation

AlongStepDeexcitation()

void G4VAtomDeexcitation::AlongStepDeexcitation	(	std::vector< G4Track * > &	tracks,
		const G4Step &	step,
		G4double &	eLoss,
		G4int	coupleIndex )

Definition at line 260 of file G4VAtomDeexcitation.cc.

{
  G4double truelength = step.GetStepLength();
  if(!flagPIXE && !activePIXEMedia[coupleIndex]) { return; }
  if(eLossMax <= 0.0 || truelength <= 0.0)       { return; }
 
  // step parameters
  const G4StepPoint* preStep = step.GetPreStepPoint();
  const G4ThreeVector prePos = preStep->GetPosition();
  const G4ThreeVector delta = step.GetPostStepPoint()->GetPosition() - prePos;
  const G4double preTime = preStep->GetGlobalTime();
  const G4double dt = step.GetPostStepPoint()->GetGlobalTime() - preTime;
 
  // particle parameters
  const G4Track* track = step.GetTrack();
  const G4ParticleDefinition* part = track->GetDefinition();
  G4double ekin = preStep->GetKineticEnergy(); 
 
  // media parameters
  G4double gCut = (*theCoupleTable->GetEnergyCutsVector(0))[coupleIndex];
  if(ignoreCuts) { gCut = 0.0; }
  G4double eCut = DBL_MAX;
  if(CheckAugerActiveRegion(coupleIndex)) { 
    eCut = (*theCoupleTable->GetEnergyCutsVector(1))[coupleIndex];
    if(ignoreCuts) { eCut = 0.0; }    
  }
 
  //G4cout<<"!Sample PIXE gCut(MeV)= "<<gCut<<"  eCut(MeV)= "<<eCut
  //        <<" Ekin(MeV)= " << ekin/MeV << G4endl;
 
  const G4Material* material = preStep->GetMaterial();
  const G4ElementVector* theElementVector = material->GetElementVector();
  const G4double* theAtomNumDensityVector = 
    material->GetVecNbOfAtomsPerVolume();
  const std::size_t nelm = material->GetNumberOfElements();
 
  // loop over deexcitations
  for(std::size_t i=0; i<nelm; ++i) {
    G4int Z = (*theElementVector)[i]->GetZasInt();
    if(activeZ[Z] && Z < 93) {  
      G4int nshells = 
        std::min(9,(*theElementVector)[i]->GetNbOfAtomicShells());
      G4double rho = truelength*theAtomNumDensityVector[i];
      //G4cout<<"   Z "<< Z <<" is active  x(mm)= " << truelength/mm << G4endl;
      for(G4int ii=0; ii<nshells; ++ii) {
        auto as = (G4AtomicShellEnumerator)(ii);
        const G4AtomicShell* shell = GetAtomicShell(Z, as);
        const G4double bindingEnergy = shell->BindingEnergy();
 
        if(gCut > bindingEnergy) { break; }
 
        if(eLossMax > bindingEnergy) { 
          G4double sig = rho*
            GetShellIonisationCrossSectionPerAtom(part, Z, as, ekin, material);
 
          // mfp is mean free path in units of step size
          if(sig > 0.0) {
            G4double mfp = 1.0/sig;
            G4double stot = 0.0;
            //G4cout << " Shell " << ii << " mfp(mm)= " << mfp/mm << G4endl;
            // sample ionisation points
            do {
              stot -= mfp*G4Log(G4UniformRand());
              if( stot > 1.0 || eLossMax < bindingEnergy) { break; }
              // sample deexcitation
              vdyn.clear();
              GenerateParticles(&vdyn, shell, Z, gCut, eCut); 
              std::size_t nsec = vdyn.size();
              if(nsec > 0) {
                G4ThreeVector r = prePos  + stot*delta;
                G4double time   = preTime + stot*dt;
                for(std::size_t j=0; j<nsec; ++j) {
                  G4DynamicParticle* dp = vdyn[j];
                  G4double e = dp->GetKineticEnergy();
 
                  // save new secondary if there is enough energy
                  if(eLossMax >= e) {
                    eLossMax -= e;                    
                    G4Track* t = new G4Track(dp, time, r);
 
                    // defined secondary type
                    if(dp->GetDefinition() == gamma) { 
                      t->SetCreatorModelID(_GammaPIXE);
                    } else {
                      t->SetCreatorModelID(_ePIXE);
                    }
                    tracks.push_back(t);
                  } else {
                    delete dp;
                  }
                }
              }
              // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
            } while (stot < 1.0);
          }
        }
      }
    } 
  }
  return;
}

CheckAugerActiveRegion()

G4bool G4VAtomDeexcitation::CheckAugerActiveRegion ( G4int coupleIndex )

inline

Definition at line 266 of file G4VAtomDeexcitation.hh.

{
  return (idx < nCouples) ? activeAugerMedia[idx] : false;
}

Referenced by AlongStepDeexcitation(), and GenerateParticles().

CheckDeexcitationActiveRegion()

G4bool G4VAtomDeexcitation::CheckDeexcitationActiveRegion ( G4int coupleIndex )

inline

Definition at line 260 of file G4VAtomDeexcitation.hh.

{
  return (idx < nCouples) ? activeDeexcitationMedia[idx] : false;
}

ComputeShellIonisationCrossSectionPerAtom()

virtual G4double G4VAtomDeexcitation::ComputeShellIonisationCrossSectionPerAtom ( const G4ParticleDefinition * , G4int Z, G4AtomicShellEnumerator shell, G4double kinE, const G4Material * mat = nullptr )

pure virtual

Implemented in G4UAtomicDeexcitation.

Referenced by G4EmCalculator::ComputeShellIonisationCrossSectionPerAtom().

GenerateParticles() [1/2]

virtual void G4VAtomDeexcitation::GenerateParticles ( std::vector< G4DynamicParticle * > * secVect, const G4AtomicShell * , G4int Z, G4double gammaCut, G4double eCut )

pure virtual

Implemented in G4UAtomicDeexcitation.

GenerateParticles() [2/2]

void G4VAtomDeexcitation::GenerateParticles	(	std::vector< G4DynamicParticle * > *	secVect,
		const G4AtomicShell *	as,
		G4int	Z,
		G4int	coupleIndex )

Definition at line 234 of file G4VAtomDeexcitation.cc.

{
  G4double gCut = DBL_MAX;
  if(ignoreCuts) {
    gCut = 0.0;
  } else if (nullptr != theCoupleTable) {
    gCut = (*(theCoupleTable->GetEnergyCutsVector(0)))[idx];
  }
  if(gCut < as->BindingEnergy()) {
    G4double eCut = DBL_MAX;
    if(CheckAugerActiveRegion(idx)) {
      if(ignoreCuts) {
        eCut = 0.0;
      } else if (nullptr != theCoupleTable) {
        eCut = (*(theCoupleTable->GetEnergyCutsVector(1)))[idx];
      }
    }
    GenerateParticles(v, as, Z, gCut, eCut);
  }
}

Referenced by AlongStepDeexcitation(), G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), and GenerateParticles().

GetAtomicShell()

virtual const G4AtomicShell * G4VAtomDeexcitation::GetAtomicShell ( G4int Z, G4AtomicShellEnumerator shell )

pure virtual

Implemented in G4UAtomicDeexcitation.

Referenced by AlongStepDeexcitation(), G4ECDecay::DecayIt(), and G4ITDecay::DecayIt().

GetListOfActiveAtoms()

const std::vector< G4bool > & G4VAtomDeexcitation::GetListOfActiveAtoms ( ) const

inline

Definition at line 244 of file G4VAtomDeexcitation.hh.

{
  return activeZ;
}

GetName()

const G4String & G4VAtomDeexcitation::GetName ( ) const

inline

Definition at line 238 of file G4VAtomDeexcitation.hh.

{
  return name;
}

Referenced by SetDeexcitationActiveRegion().

GetShellIonisationCrossSectionPerAtom()

virtual G4double G4VAtomDeexcitation::GetShellIonisationCrossSectionPerAtom ( const G4ParticleDefinition * , G4int Z, G4AtomicShellEnumerator shell, G4double kinE, const G4Material * mat = nullptr )

pure virtual

Implemented in G4UAtomicDeexcitation.

Referenced by AlongStepDeexcitation(), and G4EmCalculator::GetShellIonisationCrossSectionPerAtom().

GetVerboseLevel()

G4int G4VAtomDeexcitation::GetVerboseLevel ( ) const

inline

Definition at line 254 of file G4VAtomDeexcitation.hh.

{
  return verbose;
}

InitialiseAtomicDeexcitation()

void G4VAtomDeexcitation::InitialiseAtomicDeexcitation

(

)

Definition at line 86 of file G4VAtomDeexcitation.cc.

{
  G4EmParameters* theParameters = G4EmParameters::Instance();
  theParameters->DefineRegParamForDeex(this);
 
  // Define list of couples
  theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
  nCouples = (G4int)theCoupleTable->GetTableSize();
 
  // needed for unit tests
  std::size_t nn = std::max(nCouples, 1);
  if(activeDeexcitationMedia.size() != nn) {
    activeDeexcitationMedia.resize(nn, false);
    activeAugerMedia.resize(nn, false);
    activePIXEMedia.resize(nn, false);
  }
  if(activeZ.size() != 93) { activeZ.resize(93, false); }
 
  // initialisation of flags and options
  // normally there is no locksed flags
  if(!isActiveLocked) { isActive  = theParameters->Fluo(); }
  if(!isAugerLocked)  { flagAuger = theParameters->Auger(); }
  if(!isPIXELocked)   { flagPIXE  = theParameters->Pixe(); }
  ignoreCuts = theParameters->DeexcitationIgnoreCut();
 
  // Define list of regions
  std::size_t nRegions = deRegions.size();
  // check if deexcitation is active for the given run
  if(!isActive && 0 == nRegions) { return; }
 
  // if no active regions add a world
  if(0 == nRegions) {
    SetDeexcitationActiveRegion("World",isActive,flagAuger,flagPIXE);
    nRegions = deRegions.size();
  }
 
  if(0 < verbose) {
    G4cout << G4endl;
    G4cout << "### ===  Deexcitation model " << name 
           << " is activated for " << nRegions;
    if(1 == nRegions) { G4cout << " region:" << G4endl; }
    else              { G4cout << " regions:" << G4endl;}
  }
 
  // Identify active media
  const G4RegionStore* regionStore = G4RegionStore::GetInstance();
  for(std::size_t j=0; j<nRegions; ++j) {
    const G4Region* reg = regionStore->GetRegion(activeRegions[j], false);
    if(nullptr != reg && 0 < nCouples) {
      const G4ProductionCuts* rpcuts = reg->GetProductionCuts();
      if(0 < verbose) {
        G4cout << "          " << activeRegions[j]
               << "  " << deRegions[j]  << "  " << AugerRegions[j]
               << "  " << PIXERegions[j] << G4endl;  
      }
      for(G4int i=0; i<nCouples; ++i) {
        const G4MaterialCutsCouple* couple =
          theCoupleTable->GetMaterialCutsCouple(i);
        if (couple->GetProductionCuts() == rpcuts) {
          activeDeexcitationMedia[i] = deRegions[j];
          activeAugerMedia[i] = AugerRegions[j];
          activePIXEMedia[i] = PIXERegions[j];
        }
      }
    }
  }
  std::size_t nelm = G4Element::GetNumberOfElements();
  //G4cout << nelm << G4endl;
  for(std::size_t k=0; k<nelm; ++k) {
    G4int Z = (*(G4Element::GetElementTable()))[k]->GetZasInt();
    if(Z > 5 && Z < 93) { 
      activeZ[Z] = true;
      //G4cout << "!!! Active de-excitation Z= " << Z << G4endl;  
    }
  }
 
  // Initialise derived class
  InitialiseForNewRun();
 
  if(0 < verbose && flagAuger) {
    G4cout << "### ===  Auger flag: " << flagAuger 
           << G4endl;
  }
  if(0 < verbose) {
    G4cout << "### ===  Ignore cuts flag:   " << ignoreCuts
           << G4endl;
  }
  if(0 < verbose && flagPIXE) {
    G4cout << "### ===  PIXE model for hadrons: " 
           << theParameters->PIXECrossSectionModel()
           << G4endl;  
    G4cout << "### ===  PIXE model for e+-:     " 
           << theParameters->PIXEElectronCrossSectionModel()
           << G4endl;  
  }
}

Referenced by LBE::ConstructGeneral().

InitialiseForExtraAtom()

virtual void G4VAtomDeexcitation::InitialiseForExtraAtom ( G4int Z )

pure virtual

Implemented in G4UAtomicDeexcitation.

InitialiseForNewRun()

virtual void G4VAtomDeexcitation::InitialiseForNewRun ( )

pure virtual

Implemented in G4UAtomicDeexcitation.

Referenced by InitialiseAtomicDeexcitation().

IsAugerActive()

G4bool G4VAtomDeexcitation::IsAugerActive ( ) const

inline

Definition at line 213 of file G4VAtomDeexcitation.hh.

{
  return flagAuger;
}

IsAugerCascadeActive()

G4bool G4VAtomDeexcitation::IsAugerCascadeActive ( ) const

inline

Definition at line 223 of file G4VAtomDeexcitation.hh.

{
  return flagAuger;
}

Referenced by G4UAtomicDeexcitation::GenerateParticles().

IsFluoActive()

G4bool G4VAtomDeexcitation::IsFluoActive ( ) const

inline

Definition at line 203 of file G4VAtomDeexcitation.hh.

{
  return isActive;
}

Referenced by G4ECDecay::DecayIt(), G4ITDecay::DecayIt(), and G4UAtomicDeexcitation::InitialiseForNewRun().

IsPIXEActive()

G4bool G4VAtomDeexcitation::IsPIXEActive ( ) const

inline

Definition at line 233 of file G4VAtomDeexcitation.hh.

{
  return flagPIXE;
}

Referenced by G4PenelopeIonisationModel::Initialise(), and G4UAtomicDeexcitation::InitialiseForNewRun().

operator=()

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

delete

SetAuger()

void G4VAtomDeexcitation::SetAuger ( G4bool val )

inline

Definition at line 208 of file G4VAtomDeexcitation.hh.

{
  if(!isAugerLocked) { flagAuger = val; isAugerLocked = true; }
}

Referenced by SetAugerCascade().

SetAugerCascade()

void G4VAtomDeexcitation::SetAugerCascade ( G4bool val )

inline

Definition at line 218 of file G4VAtomDeexcitation.hh.

{
  SetAuger(val);
}

SetDeexcitationActiveRegion()

void G4VAtomDeexcitation::SetDeexcitationActiveRegion	(	const G4String &	rname,
		G4bool	valDeexcitation,
		G4bool	valAuger,
		G4bool	valPIXE )

Definition at line 186 of file G4VAtomDeexcitation.cc.

{
  // no PIXE in parallel world
  if(rname == "DefaultRegionForParallelWorld") { return; }
 
  G4String ss = rname;
  /*  
  G4cout << "### G4VAtomDeexcitation::SetDeexcitationActiveRegion " << ss 
         << "  " << valDeexcitation << "  " << valAuger
         << "  " << valPIXE << G4endl;
  */
  if(ss == "world" || ss == "World" || ss == "WORLD") {
    ss = "DefaultRegionForTheWorld";
  }
  std::size_t n = deRegions.size();
  for(std::size_t i=0; i<n; ++i) {
 
    // Region already exist
    if(ss == activeRegions[i]) {
      deRegions[i] = valDeexcitation;
      AugerRegions[i] = valAuger;
      PIXERegions[i] = valPIXE;
      return;  
    }
  }
  // New region
  activeRegions.push_back(ss);
  deRegions.push_back(valDeexcitation);
  AugerRegions.push_back(valAuger);
  PIXERegions.push_back(valPIXE);
 
  // if de-excitation defined for the world volume 
  // it should be active for all G4Regions
  if(ss == "DefaultRegionForTheWorld") {
    G4RegionStore* regions = G4RegionStore::GetInstance();
    std::size_t nn = regions->size();
    for(std::size_t i=0; i<nn; ++i) {
      if(ss == (*regions)[i]->GetName()) { continue; }
      SetDeexcitationActiveRegion((*regions)[i]->GetName(), valDeexcitation,
                                  valAuger, valPIXE);
                                  
    }
  }
}

Referenced by G4EmLowEParameters::DefineRegParamForDeex(), InitialiseAtomicDeexcitation(), and SetDeexcitationActiveRegion().

SetFluo()

void G4VAtomDeexcitation::SetFluo ( G4bool val )

inline

Definition at line 198 of file G4VAtomDeexcitation.hh.

{
  if(!isActiveLocked) { isActive = val; isActiveLocked = true; }
}

SetPIXE()

void G4VAtomDeexcitation::SetPIXE ( G4bool val )

inline

Definition at line 228 of file G4VAtomDeexcitation.hh.

{
  if(!isPIXELocked) { flagPIXE = val;  isPIXELocked = true; }
}

SetVerboseLevel()

void G4VAtomDeexcitation::SetVerboseLevel ( G4int val )

inline

Definition at line 249 of file G4VAtomDeexcitation.hh.

{
  verbose = val;
}

---

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

• G4VAtomDeexcitation.hh
• G4VAtomDeexcitation.cc