#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)

Detailed Description

Definition at line 64 of file G4VAtomDeexcitation.hh.

Constructor & Destructor Documentation

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

explicit

Definition at line 70 of file G4VAtomDeexcitation.cc.

   : verbose(1), name(modname), isActive(false), flagAuger(false),
     flagAugerCascade(false), flagPIXE(false), ignoreCuts(false),
     isActiveLocked(false), isAugerLocked(false),
     isAugerCascadeLocked(false), isPIXELocked(false)
 {
   theParameters = G4EmParameters::Instance();
   vdyn.reserve(5);
   theCoupleTable = nullptr;
   G4String gg = "gammaPIXE";
   G4String ee = "e-PIXE";
   if(pixeIDg < 0) { pixeIDg = G4PhysicsModelCatalog::Register(gg); }
   if(pixeIDe < 0) { pixeIDe = G4PhysicsModelCatalog::Register(ee); }
   gamma = G4Gamma::Gamma();
 }

Here is the call graph for this function:

G4VAtomDeexcitation::~G4VAtomDeexcitation ( )

virtual

Definition at line 88 of file G4VAtomDeexcitation.cc.

89 {}

Member Function Documentation

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

Definition at line 242 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();
   G4ThreeVector prePos = preStep->GetPosition();
   G4ThreeVector delta = step.GetPostStepPoint()->GetPosition() - prePos;
   G4double preTime = preStep->GetGlobalTime();
   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();
   G4int nelm = material->GetNumberOfElements();
 
   // loop over deexcitations
   for(G4int 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) {
         G4AtomicShellEnumerator as = G4AtomicShellEnumerator(ii);
         const G4AtomicShell* shell = GetAtomicShell(Z, as);
         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*std::log(G4UniformRand());
               if( stot > 1.0 || eLossMax < bindingEnergy) { break; }
               // sample deexcitation
               vdyn.clear();
               GenerateParticles(&vdyn, shell, Z, gCut, eCut); 
               G4int nsec = vdyn.size();
               if(nsec > 0) {
                 G4ThreeVector r = prePos  + stot*delta;
                 G4double time   = preTime + stot*dt;
                 for(G4int 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->SetCreatorModelIndex(pixeIDg);
                     } else {
                       t->SetCreatorModelIndex(pixeIDe);
                     }
 
                     tracks.push_back(t);
                   } else {
                     delete dp;
                   }
                 }
               }
               // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
             } while (stot < 1.0);
           }
         }
       }
     } 
   }
   return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4VAtomDeexcitation::CheckAugerActiveRegion ( G4int coupleIndex )

inline

Definition at line 268 of file G4VAtomDeexcitation.hh.

 {
   return (activeAugerMedia[coupleIndex]);
 }

Here is the caller graph for this function:

G4bool G4VAtomDeexcitation::CheckDeexcitationActiveRegion ( G4int coupleIndex )

inline

Definition at line 262 of file G4VAtomDeexcitation.hh.

 {
   return (activeDeexcitationMedia[coupleIndex]);
 }

Here is the caller graph for this function:

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

pure virtual

Implemented in G4UAtomicDeexcitation.

Here is the caller graph for this function:

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

inline

Definition at line 274 of file G4VAtomDeexcitation.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

pure virtual

Implemented in G4UAtomicDeexcitation.

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

pure virtual

Implemented in G4UAtomicDeexcitation.

Here is the caller graph for this function:

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

inline

Definition at line 246 of file G4VAtomDeexcitation.hh.

 {
   return activeZ;
 }

const G4String & G4VAtomDeexcitation::GetName ( ) const

inline

Definition at line 240 of file G4VAtomDeexcitation.hh.

 {
   return name;
 }

Here is the caller graph for this function:

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

pure virtual

Implemented in G4UAtomicDeexcitation.

Here is the caller graph for this function:

G4int G4VAtomDeexcitation::GetVerboseLevel ( ) const

inline

Definition at line 256 of file G4VAtomDeexcitation.hh.

 {
   return verbose;
 }

void G4VAtomDeexcitation::InitialiseAtomicDeexcitation ( )

Definition at line 93 of file G4VAtomDeexcitation.cc.

 {
   theParameters->DefineRegParamForDeex(this);
 
   // Define list of couples
   theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
   G4int numOfCouples = theCoupleTable->GetTableSize();
 
   // needed for unit tests
   G4int nn = std::max(numOfCouples, 1);
   activeDeexcitationMedia.resize(nn, false);
   activeAugerMedia.resize(nn, false);
   activePIXEMedia.resize(nn, false);
   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(!isAugerCascadeLocked) { flagAugerCascade = theParameters->AugerCascade(); }
   if(!isPIXELocked)         { flagPIXE  = theParameters->Pixe(); }
   ignoreCuts = theParameters->DeexcitationIgnoreCut();
 
   // Define list of regions
   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
   G4RegionStore* regionStore = G4RegionStore::GetInstance();
   for(size_t j=0; j<nRegions; ++j) {
     const G4Region* reg = regionStore->GetRegion(activeRegions[j], false);
     if(reg && 0 < numOfCouples) {
       const G4ProductionCuts* rpcuts = reg->GetProductionCuts();
       if(0 < verbose) {
         G4cout << "          " << activeRegions[j]
            << "  " << deRegions[j]  << "  " << AugerRegions[j]
            << "  " << PIXERegions[j] << G4endl;  
       }
       for(G4int i=0; i<numOfCouples; ++i) {
         const G4MaterialCutsCouple* couple =
           theCoupleTable->GetMaterialCutsCouple(i);
         if (couple->GetProductionCuts() == rpcuts) {
           activeDeexcitationMedia[i] = deRegions[j];
           activeAugerMedia[i] = AugerRegions[j];
           activePIXEMedia[i] = PIXERegions[j];
         }
       }
     }
   }
   G4int nelm = G4Element::GetNumberOfElements();
   //G4cout << nelm << G4endl;
   for(G4int 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 cascade flag: " << flagAugerCascade 
        << 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;  
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void G4VAtomDeexcitation::InitialiseForExtraAtom ( G4int Z )

pure virtual

Implemented in G4UAtomicDeexcitation.

virtual void G4VAtomDeexcitation::InitialiseForNewRun ( )

pure virtual

Implemented in G4UAtomicDeexcitation.

Here is the caller graph for this function:

G4bool G4VAtomDeexcitation::IsAugerActive ( ) const

inline

Definition at line 215 of file G4VAtomDeexcitation.hh.

 {
   return flagAuger;
 }

G4bool G4VAtomDeexcitation::IsAugerCascadeActive ( ) const

inline

Definition at line 225 of file G4VAtomDeexcitation.hh.

 {
   return flagAugerCascade;
 }

Here is the caller graph for this function:

G4bool G4VAtomDeexcitation::IsFluoActive ( ) const

inline

Definition at line 205 of file G4VAtomDeexcitation.hh.

 {
   return isActive;
 }

Here is the caller graph for this function:

G4bool G4VAtomDeexcitation::IsPIXEActive ( ) const

inline

Definition at line 235 of file G4VAtomDeexcitation.hh.

 {
   return flagPIXE;
 }

Here is the caller graph for this function:

void G4VAtomDeexcitation::SetAuger ( G4bool val )

inline

Definition at line 210 of file G4VAtomDeexcitation.hh.

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

void G4VAtomDeexcitation::SetAugerCascade ( G4bool val )

inline

Definition at line 220 of file G4VAtomDeexcitation.hh.

 {
   if(!isAugerCascadeLocked) { flagAugerCascade = val;  isAugerCascadeLocked = true; }
 }

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

Definition at line 191 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";
   }
   size_t n = deRegions.size();
   for(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();
     G4int nn = regions->size();
     for(G4int i=0; i<nn; ++i) {
       if(ss == (*regions)[i]->GetName()) { continue; }
       SetDeexcitationActiveRegion((*regions)[i]->GetName(), valDeexcitation,
                                   valAuger, valPIXE);
                                   
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VAtomDeexcitation::SetFluo ( G4bool val )

inline

Definition at line 200 of file G4VAtomDeexcitation.hh.

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

void G4VAtomDeexcitation::SetPIXE ( G4bool val )

inline

Definition at line 230 of file G4VAtomDeexcitation.hh.

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

void G4VAtomDeexcitation::SetVerboseLevel ( G4int val )

inline

Definition at line 251 of file G4VAtomDeexcitation.hh.

 {
   verbose = val;
 }

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

geant4.10.03.p01/source/processes/electromagnetic/utils/include/G4VAtomDeexcitation.hh
geant4.10.03.p01/source/processes/electromagnetic/utils/src/G4VAtomDeexcitation.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation