G4PolarizedAnnihilation Class Reference

#include <G4PolarizedAnnihilation.hh>

Inheritance diagram for G4PolarizedAnnihilation:

Public Member Functions
void	ActivateForcedInteraction (G4double length=0.0, const G4String &r="", G4bool flag=true)
void	ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)
void	AddEmModel (G4int, G4VEmModel *, const G4Region *region=nullptr)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData) override
G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition) override
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &) override
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
G4double	ComputeCrossSectionPerAtom (G4double kineticEnergy, G4double Z, G4double A=0., G4double cut=0.0)
G4double	CrossSectionBiasingFactor () const
G4double	CrossSectionPerVolume (G4double kineticEnergy, const G4MaterialCutsCouple *couple, G4double logKinEnergy=DBL_MAX)
void	CurrentSetup (const G4MaterialCutsCouple *, G4double energy)
virtual void	DumpInfo () const override
G4VEmModel *	EmModel (size_t index=0) const
virtual void	EndTracking ()
std::vector< G4double > *	EnergyOfCrossSectionMax () const
std::vector< G4double > *	FindLambdaMax ()
	G4PolarizedAnnihilation (const G4PolarizedAnnihilation &)=delete
	G4PolarizedAnnihilation (const G4String &name="pol-annihil")
const G4Element *	GetCurrentElement () const
G4double	GetCurrentInteractionLength () const
const G4VEmModel *	GetCurrentModel () const
virtual G4VEmProcess *	GetEmProcess (const G4String &name)
G4double	GetLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)
G4double	GetLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple, G4double logKinEnergy)
const G4VProcess *	GetMasterProcess () const
virtual G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4VEmModel *	GetModelByIndex (G4int idx=0, G4bool ver=false) const
G4double	GetNumberOfInteractionLengthLeft () const
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
G4double	GetPILfactor () const
virtual const G4ProcessManager *	GetProcessManager ()
const G4String &	GetProcessName () const
G4int	GetProcessSubType () const
G4ProcessType	GetProcessType () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4int	GetVerboseLevel () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	IsApplicable (const G4ParticleDefinition &p) final
G4bool	isAtRestDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
G4PhysicsTable *	LambdaTable () const
G4PhysicsTable *	LambdaTablePrim () const
G4double	MeanFreePath (const G4Track &track)
G4int	NumberOfModels () const
G4bool	operator!= (const G4VProcess &right) const
G4PolarizedAnnihilation &	operator= (const G4PolarizedAnnihilation &right)=delete
G4bool	operator== (const G4VProcess &right) const
const G4ParticleDefinition *	Particle () const
G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
void	PreparePhysicsTable (const G4ParticleDefinition &) override
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
virtual void	ProcessDescription (std::ostream &) const override
virtual void	ResetNumberOfInteractionLengthLeft ()
G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override
const G4ParticleDefinition *	SecondaryParticle () const
G4VEmModel *	SelectModelForMaterial (G4double kinEnergy, size_t idxCouple) const
void	SetBuildTableFlag (G4bool val)
void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)
void	SetCrossSectionType (G4CrossSectionType val)
void	SetEmMasterProcess (const G4VEmProcess *)
void	SetEmModel (G4VEmModel *, G4int index=0)
void	SetEnergyOfCrossSectionMax (std::vector< G4double > *)
void	SetLambdaBinning (G4int nbins)
virtual void	SetMasterProcess (G4VProcess *masterP)
void	SetMaxKinEnergy (G4double e)
void	SetMinKinEnergy (G4double e)
void	SetMinKinEnergyPrim (G4double e)
void	SetPILfactor (G4double value)
virtual void	SetProcessManager (const G4ProcessManager *)
void	SetProcessSubType (G4int)
void	SetProcessType (G4ProcessType)
void	SetVerboseLevel (G4int value)
void	StartTracking (G4Track *) override
G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override
G4bool	UseBaseMaterial () const
virtual	~G4PolarizedAnnihilation () override

Static Public Member Functions
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
G4bool	ApplyCuts () const
void	ClearNumberOfInteractionLengthLeft ()
G4CrossSectionType	CrossSectionType () const
size_t	CurrentMaterialCutsCoupleIndex () const
void	DefineMaterial (const G4MaterialCutsCouple *couple)
G4double	DensityFactor (G4int idx) const
G4int	DensityIndex (G4int idx) const
G4double	GetElectronEnergyCut ()
G4double	GetGammaEnergyCut ()
G4ParticleChangeForGamma *	GetParticleChange ()
const G4Element *	GetTargetElement () const
const G4Isotope *	GetTargetIsotope () const
void	InitialiseProcess (const G4ParticleDefinition *) override
G4int	LambdaBinning () const
G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *)
const G4MaterialCutsCouple *	MaterialCutsCouple () const
G4double	MaxKinEnergy () const
G4double	MinKinEnergy () const
virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition *, const G4Material *)
G4double	PolarAngleLimit () const
G4double	RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)
G4VEmModel *	SelectModel (G4double kinEnergy, size_t)
void	SetParticle (const G4ParticleDefinition *p)
void	SetSecondaryParticle (const G4ParticleDefinition *p)
void	SetSplineFlag (G4bool val)
void	SetStartFromNullFlag (G4bool val)
void	StreamProcessInfo (std::ostream &outFile) const override
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange
const G4ProcessManager *	aProcessManager = nullptr
G4int	augerID = _AugerElectron
size_t	basedCoupleIndex = 0
G4bool	baseMat = false
G4int	biasID = _EM
G4EmBiasingManager *	biasManager = nullptr
size_t	coupleIdxLambda = 0
const G4MaterialCutsCouple *	currentCouple = nullptr
size_t	currentCoupleIndex = 0
G4double	currentInteractionLength = -1.0
const G4Material *	currentMaterial = nullptr
G4bool	enableAlongStepDoIt = true
G4bool	enableAtRestDoIt = true
G4bool	enablePostStepDoIt = true
G4int	fluoID = _Fluorescence
G4ParticleChangeForGamma	fParticleChange
size_t	idxLambda = 0
G4bool	isTheMaster = true
G4int	mainSecondaries = 1
G4double	mfpKinEnergy = DBL_MAX
G4VParticleChange *	pParticleChange = nullptr
G4double	preStepKinEnergy = 0.0
G4double	preStepLambda = 0.0
G4double	preStepLogKinEnergy = LOG_EKIN_MIN
G4int	secID = _EM
std::vector< G4DynamicParticle * >	secParticles
std::vector< G4double > *	theEnergyOfCrossSectionMax = nullptr
G4double	theInitialNumberOfInteractionLength = -1.0
G4double	theNumberOfInteractionLengthLeft = -1.0
G4String	thePhysicsTableFileName
G4double	thePILfactor = 1.0
G4String	theProcessName
G4int	theProcessSubType = -1
G4ProcessType	theProcessType = fNotDefined
G4int	tripletID = _TripletElectron
G4int	verboseLevel = 0

Private Member Functions
void	BuildAsymmetryTables (const G4ParticleDefinition &part)
void	BuildLambdaTable ()
void	CleanTables ()
void	Clear ()
G4double	ComputeAsymmetry (G4double energy, const G4MaterialCutsCouple *couple, const G4ParticleDefinition &particle, G4double cut, G4double &tasm)
G4double	ComputeCurrentLambda (G4double kinEnergy)
void	ComputeIntegralLambda (G4double kinEnergy, G4double logKinEnergy)
G4double	ComputeSaturationFactor (const G4Track &aTrack)
G4double	GetCurrentLambda (G4double kinEnergy)
G4double	GetCurrentLambda (G4double kinEnergy, G4double logKinEnergy)
G4double	GetLambdaFromTable (G4double kinEnergy)
G4double	GetLambdaFromTable (G4double kinEnergy, G4double logKinEnergy)
G4double	GetLambdaFromTablePrim (G4double kinEnergy)
G4double	GetLambdaFromTablePrim (G4double kinEnergy, G4double logKinEnergy)
void	PrintWarning (G4String tit, G4double val)
void	StreamInfo (std::ostream &outFile, const G4ParticleDefinition &, G4bool rst=false) const

Private Attributes
G4bool	actBinning = false
G4bool	actMaxKinEnergy = false
G4bool	actMinKinEnergy = false
G4bool	applyCuts = false
const G4Material *	baseMaterial = nullptr
G4double	biasFactor = 1.0
G4bool	biasFlag = false
G4bool	buildLambdaTable = true
G4VEmModel *	currentModel = nullptr
const G4ParticleDefinition *	currentParticle = nullptr
std::vector< G4VEmModel * >	emModels
G4PhysicsTable *	fAsymmetryTable
G4PolarizedAnnihilationModel *	fEmModel
G4int	fEntanglementModelID
G4double	fFactor = 1.0
G4double	fLambda = 0.0
G4double	fLambdaEnergy = 0.0
G4ProcessTable *	fProcessTable = nullptr
G4PhysicsTable *	fTransverseAsymmetryTable
G4CrossSectionType	fXSType = fEmNoIntegral
G4bool	isInitialised = false
G4bool	isIon = false
G4double	lambdaFactor = 0.8
G4LossTableManager *	lManager = nullptr
G4double	logLambdaFactor
G4double	massRatio = 1.0
const G4VEmProcess *	masterProc = nullptr
G4VProcess *	masterProcessShadow = nullptr
G4double	maxKinEnergy
G4double	minKinEnergy
G4double	minKinEnergyPrim = DBL_MAX
G4EmModelManager *	modelManager = nullptr
G4int	nLambdaBins = 84
G4int	numberOfModels = 0
const G4ParticleDefinition *	particle = nullptr
const G4ParticleDefinition *	secondaryParticle = nullptr
G4bool	splineFlag = true
G4bool	startFromNull = false
const std::vector< G4double > *	theCuts = nullptr
const std::vector< G4double > *	theCutsElectron = nullptr
const std::vector< G4double > *	theCutsGamma = nullptr
const std::vector< G4double > *	theCutsPositron = nullptr
G4EmDataHandler *	theData = nullptr
const std::vector< G4double > *	theDensityFactor = nullptr
const std::vector< G4int > *	theDensityIdx = nullptr
const G4ParticleDefinition *	theElectron
const G4ParticleDefinition *	theGamma
G4PhysicsTable *	theLambdaTable = nullptr
G4PhysicsTable *	theLambdaTablePrim = nullptr
G4EmParameters *	theParameters = nullptr
const G4ParticleDefinition *	thePositron = nullptr
G4bool	weightFlag = false

Detailed Description

Definition at line 47 of file G4PolarizedAnnihilation.hh.

Constructor & Destructor Documentation

G4PolarizedAnnihilation() [1/2]

G4PolarizedAnnihilation::G4PolarizedAnnihilation ( const G4String &  name = "pol-annihil" )

explicit

Definition at line 51 of file G4PolarizedAnnihilation.cc.

  : G4eplusAnnihilation(name)
  , fAsymmetryTable(nullptr)
  , fTransverseAsymmetryTable(nullptr)
{
  fEmModel = new G4PolarizedAnnihilationModel();
  SetEmModel(fEmModel);
}

References fEmModel, and G4VEmProcess::SetEmModel().

~G4PolarizedAnnihilation()

G4PolarizedAnnihilation::~G4PolarizedAnnihilation ( )

overridevirtual

Definition at line 61 of file G4PolarizedAnnihilation.cc.

{ CleanTables(); }

References CleanTables().

G4PolarizedAnnihilation() [2/2]

G4PolarizedAnnihilation::G4PolarizedAnnihilation ( const G4PolarizedAnnihilation &  )

delete

Member Function Documentation

ActivateForcedInteraction()

void G4VEmProcess::ActivateForcedInteraction ( G4double  length = 0.0, const G4String &  r = "", G4bool  flag = true  )

inherited

Definition at line 1129 of file G4VEmProcess.cc.

{
  if(nullptr == biasManager) { biasManager = new G4EmBiasingManager(); }
  if(1 < verboseLevel) {
    G4cout << "### ActivateForcedInteraction: for " 
           << particle->GetParticleName() 
           << " and process " << GetProcessName()
           << " length(mm)= " << length/mm
           << " in G4Region <" << r 
           << "> weightFlag= " << flag 
           << G4endl; 
  }
  weightFlag = flag;
  biasManager->ActivateForcedInteraction(length, r);
}

References G4EmBiasingManager::ActivateForcedInteraction(), G4VEmProcess::biasManager, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), mm, G4VEmProcess::particle, G4VProcess::verboseLevel, and G4VEmProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

ActivateSecondaryBiasing()

void G4VEmProcess::ActivateSecondaryBiasing ( const G4String &  region, G4double  factor, G4double  energyLimit  )

inherited

Definition at line 1149 of file G4VEmProcess.cc.

{
  if (0.0 <= factor) {
 
    // Range cut can be applied only for e-
    if(0.0 == factor && secondaryParticle != G4Electron::Electron())
      { return; }
 
    if(!biasManager) { biasManager = new G4EmBiasingManager(); }
    biasManager->ActivateSecondaryBiasing(region, factor, energyLimit);
    if(1 < verboseLevel) {
      G4cout << "### ActivateSecondaryBiasing: for "
       << " process " << GetProcessName()
       << " factor= " << factor
       << " in G4Region <" << region
       << "> energyLimit(MeV)= " << energyLimit/MeV
       << G4endl;
    }
  }
}

References G4EmBiasingManager::ActivateSecondaryBiasing(), G4VEmProcess::biasManager, G4Electron::Electron(), G4cout, G4endl, G4VProcess::GetProcessName(), MeV, G4VEmProcess::secondaryParticle, and G4VProcess::verboseLevel.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

AddEmModel()

void G4VEmProcess::AddEmModel ( G4int  order, G4VEmModel *  ptr, const G4Region *  region = nullptr  )

inherited

Definition at line 146 of file G4VEmProcess.cc.

{
  if(nullptr == ptr) { return; }
  G4VEmFluctuationModel* fm = nullptr;
  modelManager->AddEmModel(order, ptr, fm, region);
  ptr->SetParticleChange(pParticleChange);
}

References G4EmModelManager::AddEmModel(), G4VEmProcess::modelManager, G4VProcess::pParticleChange, and G4VEmModel::SetParticleChange().

Referenced by LBE::ConstructEM(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4eeToHadrons::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), G4EmConfigurator::PrepareModels(), and G4EmConfigurator::SetModelForRegion().

AlongStepDoIt()

virtual G4VParticleChange * G4VDiscreteProcess::AlongStepDoIt ( const G4Track &  , const G4Step &    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

                              { return 0; }

AlongStepGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AlongStepGetPhysicalInteractionLength ( const G4Track &  , G4double  , G4double  , G4double &  , G4GPILSelection *    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 70 of file G4VDiscreteProcess.hh.

                              { return -1.0; }

AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  proposedSafety, G4GPILSelection *  selection  )

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

ApplyCuts()

G4bool G4VEmProcess::ApplyCuts ( ) const

inlineprotectedinherited

Definition at line 459 of file G4VEmProcess.hh.

{
  return applyCuts;
}

References G4VEmProcess::applyCuts.

Referenced by G4eplusAnnihilation::AtRestDoIt().

AtRestDoIt()

G4VParticleChange * G4eplusAnnihilation::AtRestDoIt ( const G4Track &  track, const G4Step &  stepData  )

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 124 of file G4eplusAnnihilation.cc.

{
  fParticleChange.InitializeForPostStep(track);
 
  DefineMaterial(track.GetMaterialCutsCouple());
  size_t idx = CurrentMaterialCutsCoupleIndex();
  G4double ene(0.0);
  G4VEmModel* model = SelectModel(ene, idx);
 
  // define new weight for primary and secondaries
  G4double weight = fParticleChange.GetParentWeight();
 
  // sample secondaries
  secParticles.clear();
  G4double gammaCut = GetGammaEnergyCut();
  model->SampleSecondaries(&secParticles, MaterialCutsCouple(), 
               track.GetDynamicParticle(), gammaCut);
 
  G4int num0 = secParticles.size();
 
  // splitting or Russian roulette
  if(biasManager) {
    if(biasManager->SecondaryBiasingRegion(idx)) {
      G4double eloss = 0.0;
      weight *= biasManager->ApplySecondaryBiasing(
    secParticles, track, model, &fParticleChange, eloss, 
        idx, gammaCut, step.GetPostStepPoint()->GetSafety());
      if(eloss > 0.0) {
        eloss += fParticleChange.GetLocalEnergyDeposit();
        fParticleChange.ProposeLocalEnergyDeposit(eloss);
      }
    }
  }
 
  // save secondaries
  G4int num = secParticles.size();
 
  // Check that entanglement is switched on... (the following flag is
  // set by /process/em/QuantumEntanglement).
  G4bool entangled = G4EmParameters::Instance()->QuantumEntanglement();
  // ...and that we have two gammas with both gammas' energies above
  // gammaCut (entanglement is only programmed for e+ e- -> gamma gamma).
  G4bool entangledgammagamma = false;
  if (entangled) {
    if (num == 2) {
      entangledgammagamma = true;
      for (const auto* p: secParticles) {
        if (p->GetDefinition() != theGamma ||
            p->GetKineticEnergy() < gammaCut) {
          entangledgammagamma = false;
        }
      }
    }
  }
 
  // Prepare a shared pointer for psossible use below. If it is used, the
  // shared pointer is copied into the tracks through G4EntanglementAuxInfo.
  // This ensures the clip board lasts until both tracks are destroyed.
  std::shared_ptr<G4eplusAnnihilationEntanglementClipBoard> clipBoard;
  if (entangledgammagamma) {
    clipBoard = std::make_shared<G4eplusAnnihilationEntanglementClipBoard>();
    clipBoard->SetParentParticleDefinition(track.GetDefinition());
  }
 
  if(num > 0) {
 
    fParticleChange.SetNumberOfSecondaries(num);
    G4double edep = fParticleChange.GetLocalEnergyDeposit();
    G4double time = track.GetGlobalTime();
     
    for (G4int i=0; i<num; ++i) {
      if (secParticles[i]) {
        G4DynamicParticle* dp = secParticles[i];
        const G4ParticleDefinition* p = dp->GetParticleDefinition();
        G4double e = dp->GetKineticEnergy();
        G4bool good = true;
        if(ApplyCuts()) {
          if (p == theGamma) {
            if (e < gammaCut) { good = false; }
          } else if (p == theElectron) {
            if (e < GetElectronEnergyCut()) { good = false; }
          }
          // added secondary if it is good
        }
        if (good) { 
          G4Track* t = new G4Track(dp, time, track.GetPosition());
          t->SetTouchableHandle(track.GetTouchableHandle());
          if (entangledgammagamma) {
        // entangledgammagamma is only true when there are only two gammas
        // (See code above where entangledgammagamma is calculated.)
            if (i == 0) { // First gamma
              clipBoard->SetTrackA(t);
            } else if (i == 1) {  // Second gamma
              clipBoard->SetTrackB(t);
            }
            t->SetAuxiliaryTrackInformation
            (fEntanglementModelID,new G4EntanglementAuxInfo(clipBoard));
          }
          if (biasManager) {
            t->SetWeight(weight * biasManager->GetWeight(i));
          } else {
            t->SetWeight(weight);
          }
          pParticleChange->AddSecondary(t);
 
          // define type of secondary
          if(i < mainSecondaries) { t->SetCreatorModelID(secID); }
          else if(i < num0) {
            if(p == theGamma) { 
              t->SetCreatorModelID(fluoID);
            } else {
              t->SetCreatorModelID(augerID);
        }
      } else {
            t->SetCreatorModelID(biasID);
          }
          /* 
          G4cout << "Secondary(post step) has weight " << t->GetWeight() 
                 << ", Ekin= " << t->GetKineticEnergy()/MeV << " MeV "
                 << GetProcessName() << " fluoID= " << fluoID
                 << " augerID= " << augerID <<G4endl;
          */
        } else {
          delete dp;
          edep += e;
        }
      } 
    }
    fParticleChange.ProposeLocalEnergyDeposit(edep);
  }
  return &fParticleChange;
}

References G4VParticleChange::AddSecondary(), G4VEmProcess::ApplyCuts(), G4EmBiasingManager::ApplySecondaryBiasing(), G4VEmProcess::augerID, G4VEmProcess::biasID, G4VEmProcess::biasManager, G4VEmProcess::CurrentMaterialCutsCoupleIndex(), G4VEmProcess::DefineMaterial(), G4eplusAnnihilation::fEntanglementModelID, G4VEmProcess::fluoID, G4VEmProcess::fParticleChange, G4Track::GetDefinition(), G4Track::GetDynamicParticle(), G4VEmProcess::GetElectronEnergyCut(), G4VEmProcess::GetGammaEnergyCut(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4VParticleChange::GetLocalEnergyDeposit(), G4Track::GetMaterialCutsCouple(), G4VParticleChange::GetParentWeight(), G4DynamicParticle::GetParticleDefinition(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4StepPoint::GetSafety(), G4Track::GetTouchableHandle(), G4EmBiasingManager::GetWeight(), G4ParticleChangeForGamma::InitializeForPostStep(), G4EmParameters::Instance(), G4VEmProcess::mainSecondaries, G4VEmProcess::MaterialCutsCouple(), G4VProcess::pParticleChange, G4VParticleChange::ProposeLocalEnergyDeposit(), G4EmParameters::QuantumEntanglement(), G4VEmModel::SampleSecondaries(), G4VEmProcess::secID, G4EmBiasingManager::SecondaryBiasingRegion(), G4VEmProcess::secParticles, G4VEmProcess::SelectModel(), G4Track::SetAuxiliaryTrackInformation(), G4Track::SetCreatorModelID(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), G4eplusAnnihilation::theElectron, and G4eplusAnnihilation::theGamma.

AtRestGetPhysicalInteractionLength()

G4double G4eplusAnnihilation::AtRestGetPhysicalInteractionLength ( const G4Track &  track, G4ForceCondition *  condition  )

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 97 of file G4eplusAnnihilation.cc.

{
  *condition = NotForced;
  return 0.0;
}

References condition(), and NotForced.

AtRestGPIL()

G4double G4VProcess::AtRestGPIL ( const G4Track &  track, G4ForceCondition *  condition  )

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

BuildAsymmetryTables()

void G4PolarizedAnnihilation::BuildAsymmetryTables ( const G4ParticleDefinition &  part )

private

Definition at line 236 of file G4PolarizedAnnihilation.cc.

{
  // cleanup old, initialise new table
  CleanTables();
  fAsymmetryTable = G4PhysicsTableHelper::PreparePhysicsTable(fAsymmetryTable);
  fTransverseAsymmetryTable =
    G4PhysicsTableHelper::PreparePhysicsTable(fTransverseAsymmetryTable);
  if(nullptr == fAsymmetryTable) return;
 
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
  for(size_t i = 0; i < numOfCouples; ++i)
  {
    if(fAsymmetryTable->GetFlag(i))
    {
      // create physics vector and fill it
      const G4MaterialCutsCouple* couple =
        theCoupleTable->GetMaterialCutsCouple(i);
 
      // use same parameters as for lambda
      G4PhysicsVector* aVector = LambdaPhysicsVector(couple);
      G4PhysicsVector* tVector = LambdaPhysicsVector(couple);
      G4int nn = aVector->GetVectorLength();
      for(G4int j = 0; j < nn; ++j)
      {
        G4double energy = aVector->Energy(j);
        G4double tasm   = 0.;
        G4double asym = ComputeAsymmetry(energy, couple, part, 0., tasm);
        aVector->PutValue(j, asym);
        tVector->PutValue(j, tasm);
      }
      if(aVector->GetSpline()) {
    aVector->FillSecondDerivatives();
    tVector->FillSecondDerivatives();
      }
      G4PhysicsTableHelper::SetPhysicsVector(fAsymmetryTable, i, aVector);
      G4PhysicsTableHelper::SetPhysicsVector(fTransverseAsymmetryTable, i,
                                             tVector);
    }
  }
}

References CleanTables(), ComputeAsymmetry(), G4PhysicsVector::Energy(), G4INCL::KinematicsUtils::energy(), fAsymmetryTable, G4PhysicsVector::FillSecondDerivatives(), fTransverseAsymmetryTable, G4PhysicsTable::GetFlag(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4PhysicsVector::GetSpline(), G4ProductionCutsTable::GetTableSize(), G4PhysicsVector::GetVectorLength(), G4VEmProcess::LambdaPhysicsVector(), G4InuclParticleNames::nn, G4PhysicsTableHelper::PreparePhysicsTable(), G4PhysicsVector::PutValue(), and G4PhysicsTableHelper::SetPhysicsVector().

Referenced by BuildPhysicsTable().

BuildLambdaTable()

void G4VEmProcess::BuildLambdaTable ( )

privateinherited

Definition at line 387 of file G4VEmProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4EmProcess::BuildLambdaTable() for process "
           << GetProcessName() << " and particle "
           << particle->GetParticleName() << "  " << this
           << G4endl;
  }
 
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
 
  G4PhysicsLogVector* aVector = nullptr;
  G4PhysicsLogVector* aVectorPrim = nullptr;
  G4PhysicsLogVector* bVectorPrim = nullptr;
 
  G4double scale = theParameters->MaxKinEnergy()/theParameters->MinKinEnergy();
  G4int nbin = 
    theParameters->NumberOfBinsPerDecade()*G4lrint(std::log10(scale));
  scale = G4Log(scale);
  if(actBinning) { nbin = std::max(nbin, nLambdaBins); }
  G4double emax1 = std::min(maxKinEnergy, minKinEnergyPrim);
    
  for(size_t i=0; i<numOfCouples; ++i) {
 
    if (bld->GetFlag(i)) {
 
      // create physics vector and fill it
      const G4MaterialCutsCouple* couple = 
        theCoupleTable->GetMaterialCutsCouple(i);
 
      // build main table
      if(buildLambdaTable) {
        delete (*theLambdaTable)[i];
 
        // if start from zero then change the scale
        G4double emin = minKinEnergy;
        G4bool startNull = false;
        if(startFromNull) {
          G4double e = MinPrimaryEnergy(particle,couple->GetMaterial());
          if(e >= emin) {
            emin = e;
            startNull = true;
          }
        }
        G4double emax = emax1;
        if(emax <= emin) { emax = 2*emin; }
        G4int bin = G4lrint(nbin*G4Log(emax/emin)/scale);
        if(bin < 3) { bin = 3; }
        aVector = new G4PhysicsLogVector(emin, emax, bin, splineFlag);
        modelManager->FillLambdaVector(aVector, couple, startNull);
        if(splineFlag) { aVector->FillSecondDerivatives(); }
        G4PhysicsTableHelper::SetPhysicsVector(theLambdaTable, i, aVector);
      }
      // build high energy table
      if(minKinEnergyPrim < maxKinEnergy) { 
        delete (*theLambdaTablePrim)[i];
 
        // start not from zero and always use spline
        if(!bVectorPrim) {
          G4int bin = G4lrint(nbin*G4Log(maxKinEnergy/minKinEnergyPrim)/scale);
          if(bin < 3) { bin = 3; }
          aVectorPrim = 
            new G4PhysicsLogVector(minKinEnergyPrim, maxKinEnergy, bin, true);
          bVectorPrim = aVectorPrim;
        } else {
          aVectorPrim = new G4PhysicsLogVector(*bVectorPrim);
        }
        modelManager->FillLambdaVector(aVectorPrim, couple, false, 
                                       fIsCrossSectionPrim);
        aVectorPrim->FillSecondDerivatives();
        G4PhysicsTableHelper::SetPhysicsVector(theLambdaTablePrim, i, 
                                               aVectorPrim);
      }
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "Lambda table is built for "
           << particle->GetParticleName()
           << G4endl;
  }
}

References G4VEmProcess::actBinning, G4VEmProcess::buildLambdaTable, emax, G4EmModelManager::FillLambdaVector(), G4PhysicsVector::FillSecondDerivatives(), fIsCrossSectionPrim, G4cout, G4endl, G4Log(), G4lrint(), G4LossTableBuilder::GetFlag(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmProcess::lManager, G4INCL::Math::max(), G4EmParameters::MaxKinEnergy(), G4VEmProcess::maxKinEnergy, G4INCL::Math::min(), G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::MinPrimaryEnergy(), G4VEmProcess::modelManager, G4VEmProcess::nLambdaBins, G4EmParameters::NumberOfBinsPerDecade(), G4VEmProcess::particle, G4PhysicsTableHelper::SetPhysicsVector(), G4VEmProcess::splineFlag, G4VEmProcess::startFromNull, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, G4VEmProcess::theParameters, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable().

BuildPhysicsTable()

void G4PolarizedAnnihilation::BuildPhysicsTable ( const G4ParticleDefinition &  part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 225 of file G4PolarizedAnnihilation.cc.

{
  G4VEmProcess::BuildPhysicsTable(part);
  if(isTheMaster)
  {
    BuildAsymmetryTables(part);
  }
}

References BuildAsymmetryTables(), G4VEmProcess::BuildPhysicsTable(), and G4VEmProcess::isTheMaster.

BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

CleanTables()

void G4PolarizedAnnihilation::CleanTables ( )

private

Definition at line 64 of file G4PolarizedAnnihilation.cc.

{
  if(fAsymmetryTable)
  {
    fAsymmetryTable->clearAndDestroy();
    delete fAsymmetryTable;
    fAsymmetryTable = nullptr;
  }
  if(fTransverseAsymmetryTable)
  {
    fTransverseAsymmetryTable->clearAndDestroy();
    delete fTransverseAsymmetryTable;
    fTransverseAsymmetryTable = nullptr;
  }
}

References G4PhysicsTable::clearAndDestroy(), fAsymmetryTable, and fTransverseAsymmetryTable.

Referenced by BuildAsymmetryTables(), and ~G4PolarizedAnnihilation().

Clear()

void G4VEmProcess::Clear ( )

privateinherited

Definition at line 130 of file G4VEmProcess.cc.

{
  currentCouple = nullptr;
  preStepLambda = 0.0;
}

References G4VEmProcess::currentCouple, and G4VEmProcess::preStepLambda.

Referenced by G4VEmProcess::PreparePhysicsTable().

ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4RadioactiveDecay::DecayAnalog(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4Decay::EndTracking(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4VAdjointReverseReaction::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

ComputeAsymmetry()

G4double G4PolarizedAnnihilation::ComputeAsymmetry ( G4double  energy, const G4MaterialCutsCouple *  couple, const G4ParticleDefinition &  particle, G4double  cut, G4double &  tasm  )

private

Definition at line 282 of file G4PolarizedAnnihilation.cc.

{
  G4double lAsymmetry = 0.0;
  tAsymmetry          = 0.0;
 
  // calculate polarized cross section
  G4ThreeVector targetPolarization = G4ThreeVector(0., 0., 1.);
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma2 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
 
  // calculate transversely polarized cross section
  targetPolarization = G4ThreeVector(1., 0., 0.);
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma3 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
 
  // calculate unpolarized cross section
  targetPolarization = G4ThreeVector();
  fEmModel->SetTargetPolarization(targetPolarization);
  fEmModel->SetBeamPolarization(targetPolarization);
  G4double sigma0 =
    fEmModel->CrossSection(couple, &aParticle, energy, cut, energy);
 
  // determine asymmetries
  if(sigma0 > 0.)
  {
    lAsymmetry = sigma2 / sigma0 - 1.;
    tAsymmetry = sigma3 / sigma0 - 1.;
  }
  return lAsymmetry;
}

References G4VEmModel::CrossSection(), G4INCL::KinematicsUtils::energy(), fEmModel, G4PolarizedAnnihilationModel::SetBeamPolarization(), and G4PolarizedAnnihilationModel::SetTargetPolarization().

Referenced by BuildAsymmetryTables().

ComputeCrossSectionPerAtom()

G4double G4VEmProcess::ComputeCrossSectionPerAtom ( G4double  kineticEnergy, G4double  Z, G4double  A = 0., G4double  cut = 0.0  )

inherited

Definition at line 1010 of file G4VEmProcess.cc.

{
  SelectModel(kinEnergy, currentCoupleIndex);
  return (currentModel) ? 
    currentModel->ComputeCrossSectionPerAtom(currentParticle, kinEnergy,
                                             Z, A, cut) : 0.0;
}

References A, G4VEmModel::ComputeCrossSectionPerAtom(), G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentModel, G4VEmProcess::currentParticle, G4VEmProcess::SelectModel(), and Z.

ComputeCurrentLambda()

G4double G4VEmProcess::ComputeCurrentLambda ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 562 of file G4VEmProcess.hh.

{
  return currentModel->CrossSectionPerVolume(baseMaterial, currentParticle, e);
}

References G4VEmProcess::baseMaterial, G4VEmModel::CrossSectionPerVolume(), G4VEmProcess::currentModel, and G4VEmProcess::currentParticle.

Referenced by G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::RecalculateLambda().

ComputeIntegralLambda()

void G4VEmProcess::ComputeIntegralLambda ( G4double  kinEnergy, G4double  logKinEnergy  )

privateinherited

Definition at line 637 of file G4VEmProcess.cc.

{
  if(fXSType == fEmNoIntegral) {
    preStepLambda = GetCurrentLambda(e, loge);
 
  } else if(fXSType == fEmIncreasing) {
    if(e/lambdaFactor < mfpKinEnergy) {
      mfpKinEnergy = e;
      preStepLambda = GetCurrentLambda(e, loge); 
    }
 
  } else if(fXSType == fEmDecreasing) {
    if(e < mfpKinEnergy) { 
      const G4double e1 = e*lambdaFactor;
      preStepLambda = GetCurrentLambda(e1); 
      mfpKinEnergy = e1;
    }
 
  } else if(fXSType == fEmOnePeak) {
    const G4double epeak = (*theEnergyOfCrossSectionMax)[currentCoupleIndex];
    if(e <= epeak) {
      if(e/lambdaFactor < mfpKinEnergy) {
        mfpKinEnergy = e;
        preStepLambda = GetCurrentLambda(e, loge); 
      }
    } else if(e < mfpKinEnergy) { 
      const G4double e1 = std::max(epeak, e*lambdaFactor);
      preStepLambda = GetCurrentLambda(e1); 
      mfpKinEnergy = e1;
    }
 
  } else {
    preStepLambda = GetCurrentLambda(e, loge); 
  }
}

References G4VEmProcess::currentCoupleIndex, e1, fEmDecreasing, fEmIncreasing, fEmNoIntegral, fEmOnePeak, G4VEmProcess::fXSType, G4VEmProcess::GetCurrentLambda(), G4VEmProcess::lambdaFactor, G4INCL::Math::max(), G4VEmProcess::mfpKinEnergy, and G4VEmProcess::preStepLambda.

Referenced by G4VEmProcess::PostStepGetPhysicalInteractionLength().

ComputeSaturationFactor()

G4double G4PolarizedAnnihilation::ComputeSaturationFactor ( const G4Track &  aTrack )

private

Definition at line 139 of file G4PolarizedAnnihilation.cc.

{
  G4Material* aMaterial       = track.GetMaterial();
  G4VPhysicalVolume* aPVolume = track.GetVolume();
  G4LogicalVolume* aLVolume   = aPVolume->GetLogicalVolume();
 
  G4PolarizationManager* polarizationManager =
    G4PolarizationManager::GetInstance();
 
  const G4bool volumeIsPolarized = polarizationManager->IsPolarized(aLVolume);
  G4StokesVector electronPolarization =
    polarizationManager->GetVolumePolarization(aLVolume);
 
  G4double factor = 1.0;
 
  if(volumeIsPolarized)
  {
    // *** get asymmetry, if target is polarized ***
    const G4DynamicParticle* aDynamicPositron = track.GetDynamicParticle();
    const G4double positronEnergy = aDynamicPositron->GetKineticEnergy();
    const G4StokesVector positronPolarization =
      G4StokesVector(track.GetPolarization());
    const G4ParticleMomentum positronDirection0 =
      aDynamicPositron->GetMomentumDirection();
 
    if(verboseLevel >= 2)
    {
      G4cout << "G4PolarizedAnnihilation::ComputeSaturationFactor: " << G4endl;
      G4cout << " Mom " << positronDirection0 << G4endl;
      G4cout << " Polarization " << positronPolarization << G4endl;
      G4cout << " MaterialPol. " << electronPolarization << G4endl;
      G4cout << " Phys. Volume " << aPVolume->GetName() << G4endl;
      G4cout << " Log. Volume  " << aLVolume->GetName() << G4endl;
      G4cout << " Material     " << aMaterial << G4endl;
    }
 
    size_t midx                    = CurrentMaterialCutsCoupleIndex();
    const G4PhysicsVector* aVector = nullptr;
    const G4PhysicsVector* bVector = nullptr;
    if(midx < fAsymmetryTable->size())
    {
      aVector = (*fAsymmetryTable)(midx);
    }
    if(midx < fTransverseAsymmetryTable->size())
    {
      bVector = (*fTransverseAsymmetryTable)(midx);
    }
    if(aVector && bVector)
    {
      G4double lAsymmetry = aVector->Value(positronEnergy);
      G4double tAsymmetry = bVector->Value(positronEnergy);
      G4double polZZ =
        positronPolarization.z() * (electronPolarization * positronDirection0);
      G4double polXX =
        positronPolarization.x() *
        (electronPolarization *
         G4PolarizationHelper::GetParticleFrameX(positronDirection0));
      G4double polYY =
        positronPolarization.y() *
        (electronPolarization *
         G4PolarizationHelper::GetParticleFrameY(positronDirection0));
 
      factor /= (1. + polZZ * lAsymmetry + (polXX + polYY) * tAsymmetry);
 
      if(verboseLevel >= 2)
      {
        G4cout << " Asymmetry:     " << lAsymmetry << ", " << tAsymmetry
               << G4endl;
        G4cout << " PolProduct:    " << polXX << ", " << polYY << ", " << polZZ
               << G4endl;
        G4cout << " Factor:        " << factor << G4endl;
      }
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "Problem with asymmetry tables: material index " << midx
         << " is out of range or tables are not filled";
      G4Exception("G4PolarizedAnnihilation::ComputeSaturationFactor", "em0048",
                  JustWarning, ed, "");
    }
  }
  return factor;
}

References G4VEmProcess::CurrentMaterialCutsCoupleIndex(), G4cout, G4endl, G4Exception(), G4Track::GetDynamicParticle(), G4PolarizationManager::GetInstance(), G4DynamicParticle::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4Track::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4LogicalVolume::GetName(), G4VPhysicalVolume::GetName(), G4PolarizationHelper::GetParticleFrameX(), G4PolarizationHelper::GetParticleFrameY(), G4Track::GetPolarization(), G4Track::GetVolume(), G4PolarizationManager::GetVolumePolarization(), G4PolarizationManager::IsPolarized(), JustWarning, G4PhysicsVector::Value(), G4VProcess::verboseLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

CrossSectionBiasingFactor()

G4double G4VEmProcess::CrossSectionBiasingFactor ( ) const

inlineinherited

Definition at line 650 of file G4VEmProcess.hh.

{
  return biasFactor;
}

References G4VEmProcess::biasFactor.

CrossSectionPerVolume()

G4double G4VEmProcess::CrossSectionPerVolume ( G4double  kineticEnergy, const G4MaterialCutsCouple *  couple, G4double  logKinEnergy = DBL_MAX  )

inherited

Definition at line 978 of file G4VEmProcess.cc.

{
  G4double cross = RecalculateLambda(kinEnergy, couple);
  return std::max(cross, 0.0);
}

References G4INCL::Math::max(), and G4VEmProcess::RecalculateLambda().

Referenced by G4EmCalculator::GetCrossSectionPerVolume().

CrossSectionType()

G4CrossSectionType G4VEmProcess::CrossSectionType ( ) const

inlineprotectedinherited

Definition at line 699 of file G4VEmProcess.hh.

{
  return fXSType;
}

References G4VEmProcess::fXSType.

CurrentMaterialCutsCoupleIndex()

size_t G4VEmProcess::CurrentMaterialCutsCoupleIndex ( ) const

inlineprotectedinherited

Definition at line 466 of file G4VEmProcess.hh.

{
  return currentCoupleIndex;
}

References G4VEmProcess::currentCoupleIndex.

Referenced by G4eplusAnnihilation::AtRestDoIt(), ComputeSaturationFactor(), and G4PolarizedCompton::ComputeSaturationFactor().

CurrentSetup()

void G4VEmProcess::CurrentSetup ( const G4MaterialCutsCouple *  couple, G4double  energy  )

inlineinherited

Definition at line 600 of file G4VEmProcess.hh.

{
  DefineMaterial(couple);
  SelectModel(energy*massRatio, currentCoupleIndex);
}

References G4VEmProcess::currentCoupleIndex, G4VEmProcess::DefineMaterial(), G4INCL::KinematicsUtils::energy(), G4VEmProcess::massRatio, and G4VEmProcess::SelectModel().

Referenced by G4VEmProcess::GetLambda(), G4VEmProcess::MeanFreePath(), G4VEmProcess::RecalculateLambda(), and G4GammaGeneralProcess::SelectEmProcess().

DefineMaterial()

void G4VEmProcess::DefineMaterial ( const G4MaterialCutsCouple *  couple )

inlineprotectedinherited

Definition at line 494 of file G4VEmProcess.hh.

{
  if(couple != currentCouple) {
    currentCouple = couple;
    baseMaterial = currentMaterial = couple->GetMaterial();
    basedCoupleIndex = currentCoupleIndex = couple->GetIndex();
    fFactor = biasFactor;
    mfpKinEnergy = DBL_MAX;
    if(baseMat) {
      basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex];
      if(nullptr != currentMaterial->GetBaseMaterial())
        baseMaterial = currentMaterial->GetBaseMaterial();
      fFactor *= (*theDensityFactor)[currentCoupleIndex];
    }
  }
}

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::baseMat, G4VEmProcess::baseMaterial, G4VEmProcess::biasFactor, G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentMaterial, DBL_MAX, G4VEmProcess::fFactor, G4Material::GetBaseMaterial(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), and G4VEmProcess::mfpKinEnergy.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::CurrentSetup(), G4VEmProcess::LambdaPhysicsVector(), and G4VEmProcess::PostStepGetPhysicalInteractionLength().

DensityFactor()

G4double G4VEmProcess::DensityFactor ( G4int  idx ) const

inlineprotectedinherited

Definition at line 770 of file G4VEmProcess.hh.

{
  return (*theDensityFactor)[idx];  
}

References G4VEmProcess::theDensityFactor.

Referenced by G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength().

DensityIndex()

G4int G4VEmProcess::DensityIndex ( G4int  idx ) const

inlineprotectedinherited

Definition at line 763 of file G4VEmProcess.hh.

{
  return (*theDensityIdx)[idx];  
}

References G4VEmProcess::theDensityIdx.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), and G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength().

DumpInfo()

virtual void G4PolarizedAnnihilation::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 55 of file G4PolarizedAnnihilation.hh.

{ ProcessDescription(G4cout); };

References G4cout, and ProcessDescription().

EmModel()

G4VEmModel * G4VEmProcess::EmModel ( size_t  index = 0 ) const

inlineinherited

Definition at line 805 of file G4VEmProcess.hh.

{
  return (index < emModels.size()) ? emModels[index] : nullptr;
}

References G4VEmProcess::emModels.

Referenced by G4EmCalculator::ComputeNuclearDEDX(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), G4DNAAttachment::PrintInfo(), G4DNAChargeDecrease::PrintInfo(), G4DNAChargeIncrease::PrintInfo(), G4DNADissociation::PrintInfo(), G4DNAElastic::PrintInfo(), G4DNAExcitation::PrintInfo(), G4DNAIonisation::PrintInfo(), G4DNAPlasmonExcitation::PrintInfo(), G4DNAPositronium::PrintInfo(), G4DNARotExcitation::PrintInfo(), and G4DNAVibExcitation::PrintInfo().

EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

EnergyOfCrossSectionMax()

std::vector< G4double > * G4VEmProcess::EnergyOfCrossSectionMax ( ) const

inlineinherited

Definition at line 671 of file G4VEmProcess.hh.

{
  return theEnergyOfCrossSectionMax;
}

References G4VEmProcess::theEnergyOfCrossSectionMax.

Referenced by G4VEmProcess::BuildPhysicsTable().

FindLambdaMax()

std::vector< G4double > * G4VEmProcess::FindLambdaMax ( )

inherited

Definition at line 1021 of file G4VEmProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::FindLambdaMax: " 
           << particle->GetParticleName() 
           << " and process " << GetProcessName() << "  " << G4endl; 
  }
  std::vector<G4double>* ptr = nullptr;
  if(fXSType != fEmOnePeak) { return ptr; }
 
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  size_t n = theCoupleTable->GetTableSize();
  ptr = new std::vector<G4double>;
  ptr->resize(n, DBL_MAX);
 
  G4bool isPeak = false;
  const G4double g4log10 = G4Log(10.);
  const G4double scale = theParameters->NumberOfBinsPerDecade()/g4log10;
 
  for(size_t i=0; i<n; ++i) {
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
    G4double emin = std::max(minKinEnergy, MinPrimaryEnergy(particle, couple->GetMaterial()));
    G4double emax = std::max(maxKinEnergy, emin + emin);
    G4double ee = G4Log(emax/emin);
    G4int nbin = G4lrint(ee*scale);
    if(nbin < 4) { nbin = 4; }
    G4double x = G4Exp(ee/nbin);
    G4double sm = 0.0;
    G4double em = emin;
    G4double e = emin;
    for(G4int j=0; j<=nbin; ++j) {
      G4double sig = RecalculateLambda(e, couple);
      //G4cout << j << "  E=" << e << " Lambda=" << sig << G4endl;
      if(sig >= sm) {
    em = e;
    sm = sig;
    e *= x;
      } else {
    isPeak = true;
    (*ptr)[i] = em;
    break;
      }
    }
    if(1 < verboseLevel) {
      G4cout << "  " << i << ".  Epeak(GeV)=" << em/GeV
         << " SigmaMax(1/mm)=" << sm
         << " Emin(GeV)=" << emin/GeV << " Emax(GeV)=" << emax/GeV
         << "   " << couple->GetMaterial()->GetName() << G4endl;
    }
  }
  // there is no peak for any material
  if(!isPeak) {
    delete ptr;
    ptr = nullptr;
  }
  return ptr;
}

References DBL_MAX, emax, fEmOnePeak, G4VEmProcess::fXSType, G4cout, G4endl, G4Exp(), G4Log(), G4lrint(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), GeV, G4INCL::Math::max(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::MinPrimaryEnergy(), CLHEP::detail::n, G4EmParameters::NumberOfBinsPerDecade(), G4VEmProcess::particle, G4VEmProcess::RecalculateLambda(), G4InuclParticleNames::sm, G4VEmProcess::theParameters, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable().

GetCurrentElement()

const G4Element * G4VEmProcess::GetCurrentElement ( ) const

inherited

Definition at line 1104 of file G4VEmProcess.cc.

{
  return (nullptr != currentModel) ? currentModel->GetCurrentElement() : nullptr; 
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentElement().

GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

GetCurrentLambda() [1/2]

G4double G4VEmProcess::GetCurrentLambda ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 569 of file G4VEmProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    if(e >= minKinEnergyPrim) { fLambda = GetLambdaFromTablePrim(e); }
    else if(nullptr != theLambdaTable) { fLambda = GetLambdaFromTable(e); }
    else { fLambda = ComputeCurrentLambda(e); }
    fLambda *= fFactor;
  }
  return fLambda;
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::coupleIdxLambda, G4VEmProcess::currentCoupleIndex, G4VEmProcess::fFactor, G4VEmProcess::fLambda, G4VEmProcess::fLambdaEnergy, G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::minKinEnergyPrim, and G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::GetLambda(), G4VEmProcess::MeanFreePath(), and G4VEmProcess::PostStepDoIt().

GetCurrentLambda() [2/2]

G4double G4VEmProcess::GetCurrentLambda ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 584 of file G4VEmProcess.hh.

{
  if(currentCoupleIndex != coupleIdxLambda || fLambdaEnergy != e) {
    coupleIdxLambda = currentCoupleIndex;
    fLambdaEnergy = e;
    if(e >= minKinEnergyPrim) { fLambda = GetLambdaFromTablePrim(e, loge); }
    else if(nullptr != theLambdaTable) { fLambda = GetLambdaFromTable(e, loge); }
    else { fLambda = ComputeCurrentLambda(e); }
    fLambda *= fFactor;
  }
  return fLambda;
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::coupleIdxLambda, G4VEmProcess::currentCoupleIndex, G4VEmProcess::fFactor, G4VEmProcess::fLambda, G4VEmProcess::fLambdaEnergy, G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::minKinEnergyPrim, and G4VEmProcess::theLambdaTable.

GetCurrentModel()

const G4VEmModel * G4VEmProcess::GetCurrentModel ( ) const

inlineinherited

Definition at line 784 of file G4VEmProcess.hh.

{
  return currentModel;
}

References G4VEmProcess::currentModel.

GetElectronEnergyCut()

G4double G4VEmProcess::GetElectronEnergyCut ( )

inlineprotectedinherited

Definition at line 487 of file G4VEmProcess.hh.

{
  return (*theCutsElectron)[currentCoupleIndex];
}

References G4VEmProcess::currentCoupleIndex, and G4VEmProcess::theCutsElectron.

Referenced by G4eplusAnnihilation::AtRestDoIt().

GetEmProcess()

G4VEmProcess * G4VEmProcess::GetEmProcess ( const G4String &  name )

virtualinherited

Reimplemented in G4GammaGeneralProcess.

Definition at line 1220 of file G4VEmProcess.cc.

{
  return (nam == GetProcessName()) ? this : nullptr;
}

References G4VProcess::GetProcessName().

Referenced by G4EmCalculator::FindDiscreteProcess().

GetGammaEnergyCut()

G4double G4VEmProcess::GetGammaEnergyCut ( )

inlineprotectedinherited

Definition at line 480 of file G4VEmProcess.hh.

{
  return (*theCutsGamma)[currentCoupleIndex];
}

References G4VEmProcess::currentCoupleIndex, and G4VEmProcess::theCutsGamma.

Referenced by G4eplusAnnihilation::AtRestDoIt().

GetLambda() [1/2]

G4double G4VEmProcess::GetLambda ( G4double  kinEnergy, const G4MaterialCutsCouple *  couple  )

inherited

Definition at line 1228 of file G4VEmProcess.cc.

{
  CurrentSetup(couple, kinEnergy);
  return GetCurrentLambda(kinEnergy, G4Log(kinEnergy));
}

References G4VEmProcess::CurrentSetup(), G4Log(), and G4VEmProcess::GetCurrentLambda().

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4AdjointComptonModel::RapidSampleSecondaries(), and G4GammaGeneralProcess::TotalCrossSectionPerVolume().

GetLambda() [2/2]

G4double G4VEmProcess::GetLambda ( G4double  kinEnergy, const G4MaterialCutsCouple *  couple, G4double  logKinEnergy  )

inlineinherited

Definition at line 609 of file G4VEmProcess.hh.

{
  CurrentSetup(couple, kinEnergy);
  return GetCurrentLambda(kinEnergy, logKinEnergy);
}

References G4VEmProcess::CurrentSetup(), and G4VEmProcess::GetCurrentLambda().

GetLambdaFromTable() [1/2]

G4double G4VEmProcess::GetLambdaFromTable ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 534 of file G4VEmProcess.hh.

{
  return ((*theLambdaTable)[basedCoupleIndex])->Value(e, idxLambda);
}

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::idxLambda, and G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::GetCurrentLambda().

GetLambdaFromTable() [2/2]

G4double G4VEmProcess::GetLambdaFromTable ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 541 of file G4VEmProcess.hh.

{
  return ((*theLambdaTable)[basedCoupleIndex])->LogVectorValue(e, loge);
}

References G4VEmProcess::basedCoupleIndex, and G4VEmProcess::theLambdaTable.

GetLambdaFromTablePrim() [1/2]

G4double G4VEmProcess::GetLambdaFromTablePrim ( G4double  kinEnergy )

inlineprivateinherited

Definition at line 548 of file G4VEmProcess.hh.

{
  return ((*theLambdaTablePrim)[basedCoupleIndex])->Value(e, idxLambda)/e;
}

References G4VEmProcess::basedCoupleIndex, G4VEmProcess::idxLambda, and G4VEmProcess::theLambdaTablePrim.

Referenced by G4VEmProcess::GetCurrentLambda().

GetLambdaFromTablePrim() [2/2]

G4double G4VEmProcess::GetLambdaFromTablePrim ( G4double  kinEnergy, G4double  logKinEnergy  )

inlineprivateinherited

Definition at line 555 of file G4VEmProcess.hh.

{
  return ((*theLambdaTablePrim)[basedCoupleIndex])->LogVectorValue(e, loge)/e;
}

References G4VEmProcess::basedCoupleIndex, and G4VEmProcess::theLambdaTablePrim.

GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

GetMeanFreePath()

G4double G4PolarizedAnnihilation::GetMeanFreePath ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

overridevirtual

Implements G4VDiscreteProcess.

Definition at line 81 of file G4PolarizedAnnihilation.cc.

{
  G4double mfp =
    G4VEmProcess::GetMeanFreePath(track, previousStepSize, condition);
 
  if(nullptr != fAsymmetryTable && nullptr != fTransverseAsymmetryTable && mfp < DBL_MAX)
  {
    mfp *= ComputeSaturationFactor(track);
  }
  if(verboseLevel >= 2)
  {
    G4cout << "G4PolarizedAnnihilation::MeanFreePath:  " << mfp / mm << " mm "
           << G4endl;
  }
  return mfp;
}

References ComputeSaturationFactor(), condition(), DBL_MAX, fAsymmetryTable, fTransverseAsymmetryTable, G4cout, G4endl, G4VEmProcess::GetMeanFreePath(), mm, and G4VProcess::verboseLevel.

GetModelByIndex()

G4VEmModel * G4VEmProcess::GetModelByIndex ( G4int  idx = 0, G4bool  ver = false  ) const

inherited

Definition at line 168 of file G4VEmProcess.cc.

{
  return modelManager->GetModel(idx, ver);
}

References G4EmModelManager::GetModel(), and G4VEmProcess::modelManager.

Referenced by G4VEmProcess::BuildPhysicsTable().

GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

GetParticleChange()

G4ParticleChangeForGamma * G4VEmProcess::GetParticleChange ( )

inlineprotectedinherited

Definition at line 713 of file G4VEmProcess.hh.

{
  return &fParticleChange;
}

References G4VEmProcess::fParticleChange.

GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName ( const G4ParticleDefinition *  particle, const G4String &  directory, const G4String &  tableName, G4bool  ascii = false  )

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

GetTargetElement()

const G4Element * G4VEmProcess::GetTargetElement ( ) const

inlineprotectedinherited

Definition at line 749 of file G4VEmProcess.hh.

{
  return currentModel->GetCurrentElement();
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentElement().

GetTargetIsotope()

const G4Isotope * G4VEmProcess::GetTargetIsotope ( ) const

inlineprotectedinherited

Definition at line 756 of file G4VEmProcess.hh.

{
  return currentModel->GetCurrentIsotope();
}

References G4VEmProcess::currentModel, and G4VEmModel::GetCurrentIsotope().

GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

InitialiseProcess()

void G4eplusAnnihilation::InitialiseProcess ( const G4ParticleDefinition *  )

overrideprotectedvirtualinherited

Implements G4VEmProcess.

Definition at line 106 of file G4eplusAnnihilation.cc.

{
  if(!isInitialised) {
    isInitialised = true;
    if(nullptr == EmModel(0)) { SetEmModel(new G4eeToTwoGammaModel()); }
    EmModel(0)->SetLowEnergyLimit(MinKinEnergy());
    EmModel(0)->SetHighEnergyLimit(MaxKinEnergy());
    AddEmModel(1, EmModel(0));
  }
}

References G4VEmProcess::AddEmModel(), G4VEmProcess::EmModel(), G4eplusAnnihilation::isInitialised, G4VEmProcess::MaxKinEnergy(), G4VEmProcess::MinKinEnergy(), G4VEmProcess::SetEmModel(), G4VEmModel::SetHighEnergyLimit(), and G4VEmModel::SetLowEnergyLimit().

isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

IsApplicable()

G4bool G4eplusAnnihilation::IsApplicable ( const G4ParticleDefinition &  p )

finalvirtualinherited

Implements G4VEmProcess.

Definition at line 90 of file G4eplusAnnihilation.cc.

{
  return (&p == G4Positron::Positron());
}

References G4Positron::Positron().

isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

LambdaBinning()

G4int G4VEmProcess::LambdaBinning ( ) const

inlineprotectedinherited

Definition at line 629 of file G4VEmProcess.hh.

{
  return nLambdaBins;
}

References G4VEmProcess::nLambdaBins.

Referenced by G4PolarizedCompton::BuildAsymmetryTable().

LambdaPhysicsVector()

G4PhysicsVector * G4VEmProcess::LambdaPhysicsVector ( const G4MaterialCutsCouple *  couple )

protectedinherited

Definition at line 1094 of file G4VEmProcess.cc.

{
  DefineMaterial(couple);
  G4PhysicsVector* newv = new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, 
                                                 nLambdaBins, splineFlag);
  return newv;
}

References G4VEmProcess::DefineMaterial(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, and G4VEmProcess::splineFlag.

Referenced by BuildAsymmetryTables().

LambdaTable()

G4PhysicsTable * G4VEmProcess::LambdaTable ( ) const

inlineinherited

Definition at line 657 of file G4VEmProcess.hh.

{
  return theLambdaTable;
}

References G4VEmProcess::theLambdaTable.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4EmCalculator::FindLambdaTable().

LambdaTablePrim()

G4PhysicsTable * G4VEmProcess::LambdaTablePrim ( ) const

inlineinherited

Definition at line 664 of file G4VEmProcess.hh.

{
  return theLambdaTablePrim;
}

References G4VEmProcess::theLambdaTablePrim.

Referenced by G4VEmProcess::BuildPhysicsTable().

MaterialCutsCouple()

const G4MaterialCutsCouple * G4VEmProcess::MaterialCutsCouple ( ) const

inlineprotectedinherited

Definition at line 473 of file G4VEmProcess.hh.

{
  return currentCouple;
}

References G4VEmProcess::currentCouple.

Referenced by G4eplusAnnihilation::AtRestDoIt().

MaxKinEnergy()

G4double G4VEmProcess::MaxKinEnergy ( ) const

inlineprotectedinherited

Definition at line 643 of file G4VEmProcess.hh.

{
  return maxKinEnergy;
}

References G4VEmProcess::maxKinEnergy.

Referenced by G4PolarizedCompton::BuildAsymmetryTable(), G4eplusAnnihilation::InitialiseProcess(), and G4VEmProcess::SetMinKinEnergyPrim().

MeanFreePath()

G4double G4VEmProcess::MeanFreePath ( const G4Track &  track )

inherited

Definition at line 998 of file G4VEmProcess.cc.

{
  const G4double kinEnergy = track.GetKineticEnergy();
  CurrentSetup(track.GetMaterialCutsCouple(), kinEnergy);
  const G4double xs = GetCurrentLambda(kinEnergy,
                             track.GetDynamicParticle()->GetLogKineticEnergy());
  return (0.0 < xs) ? 1.0/xs : DBL_MAX; 
}

References G4VEmProcess::CurrentSetup(), DBL_MAX, G4VEmProcess::GetCurrentLambda(), G4Track::GetDynamicParticle(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetLogKineticEnergy(), and G4Track::GetMaterialCutsCouple().

Referenced by G4GammaGeneralProcess::GetMeanFreePath(), and G4VEmProcess::GetMeanFreePath().

MinKinEnergy()

G4double G4VEmProcess::MinKinEnergy ( ) const

inlineprotectedinherited

Definition at line 636 of file G4VEmProcess.hh.

{
  return minKinEnergy;
}

References G4VEmProcess::minKinEnergy.

Referenced by G4PolarizedCompton::BuildAsymmetryTable(), and G4eplusAnnihilation::InitialiseProcess().

MinPrimaryEnergy()

G4double G4VEmProcess::MinPrimaryEnergy ( const G4ParticleDefinition *  , const G4Material *    )

protectedvirtualinherited

Reimplemented in G4CoulombScattering, and G4GammaConversion.

Definition at line 138 of file G4VEmProcess.cc.

{
  return 0.0;
}

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::FindLambdaMax().

NumberOfModels()

G4int G4VEmProcess::NumberOfModels ( ) const

inlineinherited

Definition at line 798 of file G4VEmProcess.hh.

{
  return numberOfModels;
}

References G4VEmProcess::numberOfModels.

operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess &  right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

operator=()

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

delete

operator==()

G4bool G4VProcess::operator== ( const G4VProcess &  right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

Particle()

const G4ParticleDefinition * G4VEmProcess::Particle ( ) const

inlineinherited

Definition at line 678 of file G4VEmProcess.hh.

{
  return particle;
}

References G4VEmProcess::particle.

PolarAngleLimit()

G4double G4VEmProcess::PolarAngleLimit ( ) const

inlineprotectedinherited

Definition at line 1236 of file G4VEmProcess.cc.

{
  return theParameters->MscThetaLimit();
}

References G4EmParameters::MscThetaLimit(), and G4VEmProcess::theParameters.

PostStepDoIt()

G4VParticleChange * G4VEmProcess::PostStepDoIt ( const G4Track &  track, const G4Step &  step  )

overridevirtualinherited

Reimplemented from G4VDiscreteProcess.

Definition at line 675 of file G4VEmProcess.cc.

{
  // In all cases clear number of interaction lengths
  theNumberOfInteractionLengthLeft = -1.0;
  mfpKinEnergy = DBL_MAX;
 
  fParticleChange.InitializeForPostStep(track);
 
  // Do not make anything if particle is stopped, the annihilation then
  // should be performed by the AtRestDoIt!
  if (track.GetTrackStatus() == fStopButAlive) { return &fParticleChange; }
 
  const G4double finalT    = track.GetKineticEnergy();
 
  // forced process - should happen only once per track
  if(biasFlag) {
    if(biasManager->ForcedInteractionRegion(currentCoupleIndex)) {
      biasFlag = false;
    }
  }
 
  // check active and select model
  const G4double scaledEnergy = finalT*massRatio;
  SelectModel(scaledEnergy, currentCoupleIndex);
  if(!currentModel->IsActive(scaledEnergy)) { return &fParticleChange; }
 
  // Integral approach
  if (fXSType != fEmNoIntegral) {
    const G4double logFinalT = track.GetDynamicParticle()->GetLogKineticEnergy();
    const G4double lx = std::max(GetCurrentLambda(finalT, logFinalT), 0.0);
    const G4double lg = preStepLambda;
    if(finalT < mfpKinEnergy) {
      mfpKinEnergy = finalT;
      preStepLambda = lx;
    }
#ifdef G4VERBOSE
    if(lg < lx && 1 < verboseLevel) {
      G4cout << "WARNING: for " << currentParticle->GetParticleName() 
             << " and " << GetProcessName()
             << " E(MeV)= " << finalT/MeV
             << " preLambda= " << lg << " < " << lx << " (postLambda) "
             << G4endl;  
    }
#endif
    if(lg*G4UniformRand() >= lx) {
      return &fParticleChange;
    }
  }
 
  // define new weight for primary and secondaries
  G4double weight = fParticleChange.GetParentWeight();
  if(weightFlag) { 
    weight /= biasFactor; 
    fParticleChange.ProposeWeight(weight);
  }
  
#ifdef G4VERBOSE
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::PostStepDoIt: Sample secondary; E= "
           << finalT/MeV
           << " MeV; model= (" << currentModel->LowEnergyLimit()
           << ", " <<  currentModel->HighEnergyLimit() << ")"
           << G4endl;
  }
#endif
 
  // sample secondaries
  secParticles.clear();
  currentModel->SampleSecondaries(&secParticles, 
                                  currentCouple, 
                                  track.GetDynamicParticle(),
                                  (*theCuts)[currentCoupleIndex]);
 
  G4int num0 = secParticles.size();
 
  // splitting or Russian roulette
  if(biasManager) {
    if(biasManager->SecondaryBiasingRegion(currentCoupleIndex)) {
      G4double eloss = 0.0;
      weight *= biasManager->ApplySecondaryBiasing(
        secParticles, track, currentModel, &fParticleChange, eloss, 
        currentCoupleIndex, (*theCuts)[currentCoupleIndex],
        step.GetPostStepPoint()->GetSafety());
      if(eloss > 0.0) {
        eloss += fParticleChange.GetLocalEnergyDeposit();
        fParticleChange.ProposeLocalEnergyDeposit(eloss);
      }
    }
  }
 
  // save secondaries
  G4int num = secParticles.size();
  if(num > 0) {
 
    fParticleChange.SetNumberOfSecondaries(num);
    G4double edep = fParticleChange.GetLocalEnergyDeposit();
    G4double time = track.GetGlobalTime();
 
    G4int n1(0), n2(0);
    if(num > mainSecondaries) { 
      currentModel->FillNumberOfSecondaries(n1, n2);
    }
     
    for (G4int i=0; i<num; ++i) {
      G4DynamicParticle* dp = secParticles[i];
      if (nullptr != dp) {
        const G4ParticleDefinition* p = dp->GetParticleDefinition();
        G4double e = dp->GetKineticEnergy();
        G4bool good = true;
        if(applyCuts) {
          if (p == theGamma) {
            if (e < (*theCutsGamma)[currentCoupleIndex]) { good = false; }
 
          } else if (p == theElectron) {
            if (e < (*theCutsElectron)[currentCoupleIndex]) { good = false; }
 
          } else if (p == thePositron) {
            if (electron_mass_c2 < (*theCutsGamma)[currentCoupleIndex] &&
                e < (*theCutsPositron)[currentCoupleIndex]) {
              good = false;
              e += 2.0*electron_mass_c2;
            }
          }
          // added secondary if it is good
        }
        if (good) { 
          G4Track* t = new G4Track(dp, time, track.GetPosition());
          t->SetTouchableHandle(track.GetTouchableHandle());
          if (biasManager) {
            t->SetWeight(weight * biasManager->GetWeight(i));
          } else {
            t->SetWeight(weight);
          }
          pParticleChange->AddSecondary(t);
 
          // define type of secondary
          if(i < mainSecondaries) { 
            t->SetCreatorModelID(secID);
            if(GetProcessSubType() == fComptonScattering && p == theGamma) {
              t->SetCreatorModelID(_ComptonGamma);
            }
          } else if(i < mainSecondaries + n1) {
            t->SetCreatorModelID(tripletID);
          } else if(i < mainSecondaries + n1 + n2) {
            t->SetCreatorModelID(_IonRecoil);
          } else {
            if(i < num0) {
              if(p == theGamma) { 
                t->SetCreatorModelID(fluoID);
              } else {
                t->SetCreatorModelID(augerID);
              }
            } else {
              t->SetCreatorModelID(secID);
            }
          }
          /* 
          G4cout << "Secondary(post step) has weight " << t->GetWeight() 
                 << ", Ekin= " << t->GetKineticEnergy()/MeV << " MeV "
                 << GetProcessName() << " fluoID= " << fluoID
                 << " augerID= " << augerID <<G4endl;
          */
        } else {
          delete dp;
          edep += e;
        }
      } 
    }
    fParticleChange.ProposeLocalEnergyDeposit(edep);
  }
 
  if(0.0 == fParticleChange.GetProposedKineticEnergy() &&
     fAlive == fParticleChange.GetTrackStatus()) {
    if(particle->GetProcessManager()->GetAtRestProcessVector()->size() > 0)
         { fParticleChange.ProposeTrackStatus(fStopButAlive); }
    else { fParticleChange.ProposeTrackStatus(fStopAndKill); }
  }
 
  return &fParticleChange;
}

References _ComptonGamma, _IonRecoil, G4VParticleChange::AddSecondary(), G4VEmProcess::applyCuts, G4EmBiasingManager::ApplySecondaryBiasing(), G4VEmProcess::augerID, G4VEmProcess::biasFactor, G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentModel, G4VEmProcess::currentParticle, DBL_MAX, source.hepunit::electron_mass_c2, fAlive, fComptonScattering, fEmNoIntegral, G4VEmModel::FillNumberOfSecondaries(), G4VEmProcess::fluoID, G4EmBiasingManager::ForcedInteractionRegion(), G4VEmProcess::fParticleChange, fStopAndKill, fStopButAlive, G4VEmProcess::fXSType, G4cout, G4endl, G4UniformRand, G4ProcessManager::GetAtRestProcessVector(), G4VEmProcess::GetCurrentLambda(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetKineticEnergy(), G4VParticleChange::GetLocalEnergyDeposit(), G4DynamicParticle::GetLogKineticEnergy(), G4VParticleChange::GetParentWeight(), G4DynamicParticle::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4ParticleChangeForGamma::GetProposedKineticEnergy(), G4StepPoint::GetSafety(), G4Track::GetTouchableHandle(), G4Track::GetTrackStatus(), G4VParticleChange::GetTrackStatus(), G4EmBiasingManager::GetWeight(), G4VEmModel::HighEnergyLimit(), G4ParticleChangeForGamma::InitializeForPostStep(), G4VEmModel::IsActive(), G4VEmModel::LowEnergyLimit(), G4VEmProcess::mainSecondaries, G4VEmProcess::massRatio, G4INCL::Math::max(), MeV, G4VEmProcess::mfpKinEnergy, G4VEmProcess::particle, G4VProcess::pParticleChange, G4VEmProcess::preStepLambda, G4VParticleChange::ProposeLocalEnergyDeposit(), G4VParticleChange::ProposeTrackStatus(), G4VParticleChange::ProposeWeight(), G4VEmModel::SampleSecondaries(), G4VEmProcess::secID, G4EmBiasingManager::SecondaryBiasingRegion(), G4VEmProcess::secParticles, G4VEmProcess::SelectModel(), G4Track::SetCreatorModelID(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetTouchableHandle(), G4Track::SetWeight(), G4ProcessVector::size(), G4VEmProcess::theCuts, G4VEmProcess::theCutsElectron, G4VEmProcess::theCutsGamma, G4VEmProcess::theCutsPositron, G4VEmProcess::theElectron, G4VEmProcess::theGamma, G4VProcess::theNumberOfInteractionLengthLeft, G4VEmProcess::thePositron, G4VEmProcess::tripletID, G4VProcess::verboseLevel, and G4VEmProcess::weightFlag.

PostStepGetPhysicalInteractionLength()

G4double G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 101 of file G4PolarizedAnnihilation.cc.

{
  // save previous values
  G4double nLength = theNumberOfInteractionLengthLeft;
  G4double iLength = currentInteractionLength;
 
  // *** compute unpolarized step limit ***
  // this changes theNumberOfInteractionLengthLeft and currentInteractionLength
  G4double x = G4VEmProcess::PostStepGetPhysicalInteractionLength(
    track, previousStepSize, condition);
  G4double x0      = x;
  G4double satFact = 1.0;
 
  // *** add corrections on polarisation ***
  if(nullptr != fAsymmetryTable && nullptr != fTransverseAsymmetryTable && x < DBL_MAX)
  {
    satFact            = ComputeSaturationFactor(track);
    G4double curLength = currentInteractionLength * satFact;
    G4double prvLength = iLength * satFact;
    if(nLength > 0.0)
    {
      theNumberOfInteractionLengthLeft =
        std::max(nLength - previousStepSize / prvLength, 0.0);
    }
    x = theNumberOfInteractionLengthLeft * curLength;
  }
  if(verboseLevel >= 2)
  {
    G4cout << "G4PolarizedAnnihilation::PostStepGPIL: " << std::setprecision(8)
           << x / mm << " mm;" << G4endl
           << "                         unpolarized value: "
           << std::setprecision(8) << x0 / mm << " mm." << G4endl;
  }
  return x;
}

References ComputeSaturationFactor(), condition(), G4VProcess::currentInteractionLength, DBL_MAX, fAsymmetryTable, fTransverseAsymmetryTable, G4cout, G4endl, G4INCL::Math::max(), mm, G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

PostStepGPIL()

G4double G4VProcess::PostStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

PreparePhysicsTable()

void G4VEmProcess::PreparePhysicsTable ( const G4ParticleDefinition &  part )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 175 of file G4VEmProcess.cc.

{
  isTheMaster = lManager->IsMaster();
  if(nullptr == particle) { SetParticle(&part); }
 
  if(part.GetParticleType() == "nucleus" && 
     part.GetParticleSubType() == "generic") {
 
    G4String pname = part.GetParticleName();
    if(pname != "deuteron" && pname != "triton" &&
       pname != "alpha" && pname != "He3" &&
       pname != "alpha+"   && pname != "helium" &&
       pname != "hydrogen") {
 
      particle = G4GenericIon::GenericIon();
      isIon = true;
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << " local particle " << particle->GetParticleName() 
           << G4endl;
  }
 
  if(particle != &part) { return; }
 
  lManager->PreparePhysicsTable(&part, this, isTheMaster);
 
  Clear();
  InitialiseProcess(particle);
 
  G4LossTableBuilder* bld = lManager->GetTableBuilder();
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
 
  // initialisation of the process  
  if(!actMinKinEnergy) { minKinEnergy = theParameters->MinKinEnergy(); }
  if(!actMaxKinEnergy) { maxKinEnergy = theParameters->MaxKinEnergy(); }
 
  if(isTheMaster) { 
    SetVerboseLevel(theParameters->Verbose());
    if(nullptr == theData) { theData = new G4EmDataHandler(2); }
    if(fEmOnePeak == fXSType) { 
      if(nullptr == theEnergyOfCrossSectionMax) {
        theEnergyOfCrossSectionMax = new std::vector<G4double>;
      }
      size_t n = theCoupleTable->GetTableSize();
      theEnergyOfCrossSectionMax->resize(n, DBL_MAX);
    }
  } else {  
    SetVerboseLevel(theParameters->WorkerVerbose()); 
  }
  applyCuts       = theParameters->ApplyCuts();
  lambdaFactor    = theParameters->LambdaFactor();
  logLambdaFactor = G4Log(lambdaFactor);
  theParameters->DefineRegParamForEM(this);
 
  // integral option may be disabled
  if(!theParameters->Integral()) { fXSType = fEmNoIntegral; }
 
  // prepare tables
  if(buildLambdaTable && isTheMaster){
    theLambdaTable = theData->MakeTable(0);
    bld->InitialiseBaseMaterials(theLambdaTable);
  }
  // high energy table
  if(isTheMaster && minKinEnergyPrim < maxKinEnergy){
    theLambdaTablePrim = theData->MakeTable(1);
    bld->InitialiseBaseMaterials(theLambdaTablePrim);
  }
  baseMat = bld->GetBaseMaterialFlag();
 
  // initialisation of models
  numberOfModels = modelManager->NumberOfModels();
  for(G4int i=0; i<numberOfModels; ++i) {
    G4VEmModel* mod = modelManager->GetModel(i);
    if(nullptr == mod) { continue; }
    if(nullptr == currentModel) { currentModel = mod; }
    mod->SetPolarAngleLimit(theParameters->MscThetaLimit());
    mod->SetMasterThread(isTheMaster);
    if(mod->HighEnergyLimit() > maxKinEnergy) {
      mod->SetHighEnergyLimit(maxKinEnergy);
    }
    SetEmModel(mod);
    mod->SetUseBaseMaterials(baseMat);
  }
 
  if(nullptr != lManager->AtomDeexcitation()) { 
    modelManager->SetFluoFlag(true); 
  }
  fLambdaEnergy = 0.0;
 
  theCuts = 
    modelManager->Initialise(particle,secondaryParticle,1.0,verboseLevel);
  theCutsGamma    = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
  theCutsElectron = theCoupleTable->GetEnergyCutsVector(idxG4ElectronCut);
  theCutsPositron = theCoupleTable->GetEnergyCutsVector(idxG4PositronCut);
 
  // forced biasing
  if(biasManager) { 
    biasManager->Initialise(part,GetProcessName(),verboseLevel); 
    biasFlag = false;
  }
 
  // defined ID of secondary particles
  G4int stype = GetProcessSubType();
  if(stype == fAnnihilation) {
    secID = _Annihilation;
    tripletID = _TripletGamma;
  } else if(stype == fGammaConversion) {
    secID = _PairProduction;
    mainSecondaries = 2;
  } else if(stype == fPhotoElectricEffect) {
    secID = _PhotoElectron;
  } else if(stype == fComptonScattering) {
    secID = _ComptonElectron;
  } else if(stype >= fLowEnergyElastic) {
    secID = fDNAUnknownModel;
  }  
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::PreparePhysicsTable() done for " 
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << "  baseMat=" << baseMat << G4endl;
  }
}

References _Annihilation, _ComptonElectron, _PairProduction, _PhotoElectron, _TripletGamma, G4VEmProcess::actMaxKinEnergy, G4VEmProcess::actMinKinEnergy, G4EmParameters::ApplyCuts(), G4VEmProcess::applyCuts, G4LossTableManager::AtomDeexcitation(), G4VEmProcess::baseMat, G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::buildLambdaTable, G4VEmProcess::Clear(), G4VEmProcess::currentModel, DBL_MAX, G4EmParameters::DefineRegParamForEM(), fAnnihilation, fComptonScattering, fDNAUnknownModel, fEmNoIntegral, fEmOnePeak, fGammaConversion, G4VEmProcess::fLambdaEnergy, fLowEnergyElastic, fPhotoElectricEffect, G4VEmProcess::fXSType, G4cout, G4endl, G4Log(), G4GenericIon::GenericIon(), G4LossTableBuilder::GetBaseMaterialFlag(), G4ProductionCutsTable::GetEnergyCutsVector(), G4EmModelManager::GetModel(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetParticleType(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4ProductionCutsTable::GetProductionCutsTable(), G4LossTableManager::GetTableBuilder(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::HighEnergyLimit(), idxG4ElectronCut, idxG4GammaCut, idxG4PositronCut, G4EmBiasingManager::Initialise(), G4EmModelManager::Initialise(), G4LossTableBuilder::InitialiseBaseMaterials(), G4VEmProcess::InitialiseProcess(), G4EmParameters::Integral(), G4VEmProcess::isIon, G4LossTableManager::IsMaster(), G4VEmProcess::isTheMaster, G4EmParameters::LambdaFactor(), G4VEmProcess::lambdaFactor, G4VEmProcess::lManager, G4VEmProcess::logLambdaFactor, G4VEmProcess::mainSecondaries, G4EmDataHandler::MakeTable(), G4EmParameters::MaxKinEnergy(), G4VEmProcess::maxKinEnergy, G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::modelManager, G4EmParameters::MscThetaLimit(), CLHEP::detail::n, G4EmModelManager::NumberOfModels(), G4VEmProcess::numberOfModels, G4VEmProcess::particle, eplot::pname, G4LossTableManager::PreparePhysicsTable(), G4VEmProcess::secID, G4VEmProcess::secondaryParticle, G4VEmProcess::SetEmModel(), G4EmModelManager::SetFluoFlag(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetMasterThread(), G4VEmProcess::SetParticle(), G4VEmModel::SetPolarAngleLimit(), G4VEmModel::SetUseBaseMaterials(), G4VProcess::SetVerboseLevel(), G4VEmProcess::theCuts, G4VEmProcess::theCutsElectron, G4VEmProcess::theCutsGamma, G4VEmProcess::theCutsPositron, G4VEmProcess::theData, G4VEmProcess::theEnergyOfCrossSectionMax, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, G4VEmProcess::theParameters, G4VEmProcess::tripletID, G4EmParameters::Verbose(), G4VProcess::verboseLevel, and G4EmParameters::WorkerVerbose().

Referenced by G4GammaGeneralProcess::PreparePhysicsTable().

PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

PrintWarning()

void G4VEmProcess::PrintWarning ( G4String  tit, G4double  val  )

privateinherited

Definition at line 1243 of file G4VEmProcess.cc.

{
  G4String ss = "G4VEmProcess::" + tit;
  G4ExceptionDescription ed;
  ed << "Parameter is out of range: " << val 
     << " it will have no effect!\n" << "  Process " 
     << GetProcessName() << "  nbins= " << theParameters->NumberOfBins()
     << " Emin(keV)= " << theParameters->MinKinEnergy()/keV 
     << " Emax(GeV)= " << theParameters->MaxKinEnergy()/GeV;
  G4Exception(ss, "em0044", JustWarning, ed);
}

References G4Exception(), G4VProcess::GetProcessName(), GeV, JustWarning, keV, G4EmParameters::MaxKinEnergy(), G4EmParameters::MinKinEnergy(), G4EmParameters::NumberOfBins(), and G4VEmProcess::theParameters.

Referenced by G4VEmProcess::SetLambdaBinning(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::SetMinKinEnergyPrim().

ProcessDescription()

void G4PolarizedAnnihilation::ProcessDescription ( std::ostream &  out ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 320 of file G4PolarizedAnnihilation.cc.

{
  out << "Polarized model for positron annihilation into 2 photons.\n";
}

Referenced by DumpInfo().

RecalculateLambda()

G4double G4VEmProcess::RecalculateLambda ( G4double  kinEnergy, const G4MaterialCutsCouple *  couple  )

inlineprotectedinherited

Definition at line 619 of file G4VEmProcess.hh.

{
  CurrentSetup(couple, e);
  return fFactor*ComputeCurrentLambda(e);
}

References G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::CurrentSetup(), and G4VEmProcess::fFactor.

Referenced by G4VEmProcess::CrossSectionPerVolume(), and G4VEmProcess::FindLambdaMax().

ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft(), G4WrapperProcess::ResetNumberOfInteractionLengthLeft(), G4AdjointProcessEquivalentToDirectProcess::ResetNumberOfInteractionLengthLeft(), and G4Decay::StartTracking().

RetrievePhysicsTable()

G4bool G4VEmProcess::RetrievePhysicsTable ( const G4ParticleDefinition *  part, const G4String &  directory, G4bool  ascii  )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 907 of file G4VEmProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4VEmProcess::RetrievePhysicsTable() for "
           << part->GetParticleName() << " and process "
           << GetProcessName() << G4endl;
  }
  G4bool yes = true;
 
  if((!buildLambdaTable && minKinEnergyPrim > maxKinEnergy) 
     || particle != part) { return yes; }
 
  const G4String particleName = part->GetParticleName();
 
  if(buildLambdaTable) {
    const G4String& filename = 
      GetPhysicsTableFileName(part,directory,"Lambda",ascii);
    yes = G4PhysicsTableHelper::RetrievePhysicsTable(theLambdaTable,
                                                     filename,ascii,
                                                     splineFlag);
    if ( yes ) {
      if (0 < verboseLevel) {
        G4cout << "Lambda table for " << particleName 
               << " is Retrieved from <"
               << filename << ">"
               << G4endl;
      }
      if(splineFlag) {
        for(auto & v : *theLambdaTable) {
          if(nullptr != v) { v->FillSecondDerivatives(); }
        }
      }
 
    } else {
      if (1 < verboseLevel) {
        G4cout << "Lambda table for " << particleName << " in file <"
               << filename << "> is not exist"
               << G4endl;
      }
    }
  }
  if(minKinEnergyPrim < maxKinEnergy) {
    const G4String& filename = 
      GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
    yes = G4PhysicsTableHelper::RetrievePhysicsTable(theLambdaTablePrim,
                                                     filename,ascii,true);
    if ( yes ) {
      if (0 < verboseLevel) {
        G4cout << "Lambda table prim for " << particleName 
               << " is Retrieved from <"
               << filename << ">"
               << G4endl;
      }
      for(auto & v : *theLambdaTablePrim) {
        if(nullptr != v) { v->FillSecondDerivatives(); }
      }
    } else {
      if (1 < verboseLevel) {
        G4cout << "Lambda table prim for " << particleName << " in file <"
               << filename << "> is not exist"
               << G4endl;
      }
    }
  }
  return yes;
}

References G4VEmProcess::buildLambdaTable, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::particle, G4PhysicsTableHelper::RetrievePhysicsTable(), G4VEmProcess::splineFlag, G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4GammaGeneralProcess::RetrievePhysicsTable().

SecondaryParticle()

const G4ParticleDefinition * G4VEmProcess::SecondaryParticle ( ) const

inlineinherited

Definition at line 685 of file G4VEmProcess.hh.

{
  return secondaryParticle;
}

References G4VEmProcess::secondaryParticle.

SelectModel()

G4VEmModel * G4VEmProcess::SelectModel ( G4double  kinEnergy, size_t    )

inlineprotectedinherited

Definition at line 514 of file G4VEmProcess.hh.

{
  if(1 < numberOfModels) {
    currentModel = modelManager->SelectModel(kinEnergy, currentCoupleIndex);
  }
  currentModel->SetCurrentCouple(currentCouple);
  return currentModel;
}

References G4VEmProcess::currentCouple, G4VEmProcess::currentCoupleIndex, G4VEmProcess::currentModel, G4VEmProcess::modelManager, G4VEmProcess::numberOfModels, G4EmModelManager::SelectModel(), and G4VEmModel::SetCurrentCouple().

Referenced by G4NuclearStopping::AlongStepDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::CurrentSetup(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PostStepGetPhysicalInteractionLength().

SelectModelForMaterial()

G4VEmModel * G4VEmProcess::SelectModelForMaterial ( G4double  kinEnergy, size_t  idxCouple  ) const

inlineinherited

Definition at line 526 of file G4VEmProcess.hh.

{
  return modelManager->SelectModel(kinEnergy, idxCouple);
}

References G4VEmProcess::modelManager, and G4EmModelManager::SelectModel().

Referenced by G4EmCalculator::FindEmModel().

SetBuildTableFlag()

void G4VEmProcess::SetBuildTableFlag ( G4bool  val )

inlineinherited

Definition at line 706 of file G4VEmProcess.hh.

{
  buildLambdaTable = val;
}

References G4VEmProcess::buildLambdaTable.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4NuclearStopping::G4NuclearStopping(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RayleighScattering::G4RayleighScattering(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), and G4CoulombScattering::InitialiseProcess().

SetCrossSectionBiasingFactor()

void G4VEmProcess::SetCrossSectionBiasingFactor ( G4double  f, G4bool  flag = true  )

inherited

Definition at line 1111 of file G4VEmProcess.cc.

{
  if(f > 0.0) { 
    biasFactor = f; 
    weightFlag = flag;
    if(1 < verboseLevel) {
      G4cout << "### SetCrossSectionBiasingFactor: for " 
             << particle->GetParticleName() 
             << " and process " << GetProcessName()
             << " biasFactor= " << f << " weightFlag= " << flag 
             << G4endl; 
    }
  }
}

References G4VEmProcess::biasFactor, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VEmProcess::particle, G4VProcess::verboseLevel, and G4VEmProcess::weightFlag.

Referenced by G4EmExtraParameters::DefineRegParamForEM().

SetCrossSectionType()

void G4VEmProcess::SetCrossSectionType ( G4CrossSectionType  val )

inlineinherited

Definition at line 692 of file G4VEmProcess.hh.

{
  fXSType = val; 
}

References G4VEmProcess::fXSType.

Referenced by G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), and G4CoulombScattering::InitialiseProcess().

SetEmMasterProcess()

void G4VEmProcess::SetEmMasterProcess ( const G4VEmProcess *  ptr )

inlineinherited

Definition at line 791 of file G4VEmProcess.hh.

{ 
  masterProc = ptr;
}

References G4VEmProcess::masterProc.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable().

SetEmModel()

void G4VEmProcess::SetEmModel ( G4VEmModel *  ptr, G4int  index = 0  )

inherited

Definition at line 157 of file G4VEmProcess.cc.

{
  if(nullptr == ptr) { return; }
  if(!emModels.empty()) {
    for(auto & em : emModels) { if(em == ptr) { return; } }
  }
  emModels.push_back(ptr);
}

References G4VEmProcess::emModels.

Referenced by G4EmDNAPhysics::ConstructGammaPositronProcesses(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmDNAPhysics_option2::ConstructProcess(), G4EmDNAPhysics_option3::ConstructProcess(), G4EmDNAPhysics_option4::ConstructProcess(), G4EmDNAPhysics_option5::ConstructProcess(), G4EmDNAPhysics_option6::ConstructProcess(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), G4EmDNAPhysics_stationary::ConstructProcess(), G4EmDNAPhysicsActivator::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4EmDNAPhysicsActivator::DeactivateNuclearStopping(), G4EmModelActivator::FindOrAddProcess(), G4PolarizedAnnihilation(), G4DNAAttachment::InitialiseProcess(), G4DNAChargeDecrease::InitialiseProcess(), G4DNAChargeIncrease::InitialiseProcess(), G4DNADissociation::InitialiseProcess(), G4DNAElastic::InitialiseProcess(), G4DNAElectronSolvation::InitialiseProcess(), G4DNAExcitation::InitialiseProcess(), G4DNAIonisation::InitialiseProcess(), G4DNAPlasmonExcitation::InitialiseProcess(), G4DNAPositronium::InitialiseProcess(), G4DNARotExcitation::InitialiseProcess(), G4DNAVibExcitation::InitialiseProcess(), G4NuclearStopping::InitialiseProcess(), G4eeToHadrons::InitialiseProcess(), G4JAEAElasticScattering::InitialiseProcess(), G4MicroElecElastic::InitialiseProcess(), G4MicroElecInelastic::InitialiseProcess(), G4MicroElecLOPhononScattering::InitialiseProcess(), G4RayleighScattering::InitialiseProcess(), G4PolarizedCompton::InitialiseProcess(), G4PolarizedGammaConversion::InitialiseProcess(), G4PolarizedPhotoElectric::InitialiseProcess(), G4ComptonScattering::InitialiseProcess(), G4CoulombScattering::InitialiseProcess(), G4eplusAnnihilation::InitialiseProcess(), G4GammaConversion::InitialiseProcess(), G4PhotoElectricEffect::InitialiseProcess(), and G4VEmProcess::PreparePhysicsTable().

SetEnergyOfCrossSectionMax()

void G4VEmProcess::SetEnergyOfCrossSectionMax ( std::vector< G4double > *  ptr )

inherited

Definition at line 1082 of file G4VEmProcess.cc.

{
  if(nullptr == ptr) {
    fXSType = fEmIncreasing;
  } else {
    theEnergyOfCrossSectionMax = ptr;
  }
}

References fEmIncreasing, G4VEmProcess::fXSType, and G4VEmProcess::theEnergyOfCrossSectionMax.

Referenced by G4VEmProcess::BuildPhysicsTable().

SetLambdaBinning()

void G4VEmProcess::SetLambdaBinning ( G4int  nbins )

inherited

Definition at line 1174 of file G4VEmProcess.cc.

{
  if(5 < n && n < 10000000) {  
    nLambdaBins = n; 
    actBinning = true;
  } else { 
    G4double e = (G4double)n;
    PrintWarning("SetLambdaBinning", e); 
  } 
}

References G4VEmProcess::actBinning, CLHEP::detail::n, G4VEmProcess::nLambdaBins, and G4VEmProcess::PrintWarning().

Referenced by G4GammaConversion::G4GammaConversion(), and G4PolarizedGammaConversion::G4PolarizedGammaConversion().

SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess *  masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

SetMaxKinEnergy()

void G4VEmProcess::SetMaxKinEnergy ( G4double  e )

inherited

Definition at line 1199 of file G4VEmProcess.cc.

{
  if(minKinEnergy < e && e < 1.e+6*TeV) { 
    nLambdaBins = G4lrint(nLambdaBins*G4Log(e/minKinEnergy)
                          /G4Log(maxKinEnergy/minKinEnergy));
    maxKinEnergy = e;
    actMaxKinEnergy = true;
  } else { PrintWarning("SetMaxKinEnergy", e); } 
}

References G4VEmProcess::actMaxKinEnergy, G4Log(), G4lrint(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, G4VEmProcess::PrintWarning(), and TeV.

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), and G4EmStandardPhysicsWVI::ConstructProcess().

SetMinKinEnergy()

void G4VEmProcess::SetMinKinEnergy ( G4double  e )

inherited

Definition at line 1187 of file G4VEmProcess.cc.

{
  if(1.e-3*eV < e && e < maxKinEnergy) { 
    nLambdaBins = G4lrint(nLambdaBins*G4Log(maxKinEnergy/e)
                          /G4Log(maxKinEnergy/minKinEnergy));
    minKinEnergy = e;
    actMinKinEnergy = true;
  } else { PrintWarning("SetMinKinEnergy", e); } 
}

References G4VEmProcess::actMinKinEnergy, eV, G4Log(), G4lrint(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::nLambdaBins, and G4VEmProcess::PrintWarning().

Referenced by G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4GammaConversion::G4GammaConversion(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), and G4GammaConversion::InitialiseProcess().

SetMinKinEnergyPrim()

void G4VEmProcess::SetMinKinEnergyPrim ( G4double  e )

inherited

Definition at line 1211 of file G4VEmProcess.cc.

{
  if(theParameters->MinKinEnergy() <= e && 
     e <= theParameters->MaxKinEnergy()) { minKinEnergyPrim = e; } 
  else { PrintWarning("SetMinKinEnergyPrim", e); } 
}

References G4VEmProcess::MaxKinEnergy(), G4EmParameters::MinKinEnergy(), G4VEmProcess::minKinEnergyPrim, G4VEmProcess::PrintWarning(), and G4VEmProcess::theParameters.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), and G4RayleighScattering::G4RayleighScattering().

SetParticle()

void G4VEmProcess::SetParticle ( const G4ParticleDefinition *  p )

inlineprotectedinherited

Definition at line 720 of file G4VEmProcess.hh.

{
  particle = p;
  currentParticle = p;
}

References G4VEmProcess::currentParticle, and G4VEmProcess::particle.

Referenced by G4GammaGeneralProcess::G4GammaGeneralProcess(), G4eeToHadrons::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), and G4VEmProcess::PreparePhysicsTable().

SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager *  procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

SetSecondaryParticle()

void G4VEmProcess::SetSecondaryParticle ( const G4ParticleDefinition *  p )

inlineprotectedinherited

Definition at line 728 of file G4VEmProcess.hh.

{
  secondaryParticle = p;
}

References G4VEmProcess::secondaryParticle.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eeToHadrons::G4eeToHadrons(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), and G4PolarizedPhotoElectric::G4PolarizedPhotoElectric().

SetSplineFlag()

void G4VEmProcess::SetSplineFlag ( G4bool  val )

inlineprotectedinherited

Definition at line 742 of file G4VEmProcess.hh.

{
  splineFlag = val;
}

References G4VEmProcess::splineFlag.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PolarizedCompton::G4PolarizedCompton(), and G4RayleighScattering::G4RayleighScattering().

SetStartFromNullFlag()

void G4VEmProcess::SetStartFromNullFlag ( G4bool  val )

inlineprotectedinherited

Definition at line 735 of file G4VEmProcess.hh.

{
  startFromNull = val;
}

References G4VEmProcess::startFromNull.

Referenced by G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4eplusAnnihilation::G4eplusAnnihilation(), G4GammaConversion::G4GammaConversion(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4PolarizedCompton::G4PolarizedCompton(), G4RayleighScattering::G4RayleighScattering(), and G4CoulombScattering::InitialiseProcess().

SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

StartTracking()

void G4VEmProcess::StartTracking ( G4Track *  track )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 549 of file G4VEmProcess.cc.

{
  // reset parameters for the new track
  currentParticle = track->GetParticleDefinition();
  theNumberOfInteractionLengthLeft = -1.0;
  mfpKinEnergy = DBL_MAX;
 
  if(isIon) { massRatio = proton_mass_c2/currentParticle->GetPDGMass(); }
 
  // forced biasing only for primary particles
  if(biasManager) {
    if(0 == track->GetParentID()) {
      // primary particle
      biasFlag = true; 
      biasManager->ResetForcedInteraction(); 
    }
  }
}

References G4VEmProcess::biasFlag, G4VEmProcess::biasManager, G4VEmProcess::currentParticle, DBL_MAX, G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetPDGMass(), G4VEmProcess::isIon, G4VEmProcess::massRatio, G4VEmProcess::mfpKinEnergy, source.hepunit::proton_mass_c2, G4EmBiasingManager::ResetForcedInteraction(), and G4VProcess::theNumberOfInteractionLengthLeft.

StorePhysicsTable()

G4bool G4VEmProcess::StorePhysicsTable ( const G4ParticleDefinition *  part, const G4String &  directory, G4bool  ascii = false  )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 859 of file G4VEmProcess.cc.

{
  G4bool yes = true;
  if(!isTheMaster) { return yes; }
 
  if ( theLambdaTable && part == particle) {
    const G4String& nam = 
      GetPhysicsTableFileName(part,directory,"Lambda",ascii);
    yes = theLambdaTable->StorePhysicsTable(nam,ascii);
 
    if ( yes ) {
      if(0 < verboseLevel) G4cout << "Stored: " << nam << G4endl;
    } else {
      G4cout << "Fail to store Physics Table for " 
             << particle->GetParticleName()
             << " and process " << GetProcessName()
             << " in the directory <" << directory
             << "> " << G4endl;
    }
  }
  if ( theLambdaTablePrim && part == particle) {
    const G4String& name = 
      GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
    yes = theLambdaTablePrim->StorePhysicsTable(name,ascii);
 
    if ( yes ) {
      if(0 < verboseLevel) {
        G4cout << "Physics table prim is stored for " 
               << particle->GetParticleName()
               << " and process " << GetProcessName()
               << " in the directory <" << directory
               << "> " << G4endl;
      }
    } else {
      G4cout << "Fail to store Physics Table Prim for " 
             << particle->GetParticleName()
             << " and process " << GetProcessName()
             << " in the directory <" << directory
             << "> " << G4endl;
    }
  }
  return yes;
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4VEmProcess::isTheMaster, G4InuclParticleNames::name(), G4VEmProcess::particle, G4PhysicsTable::StorePhysicsTable(), G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4GammaGeneralProcess::StorePhysicsTable().

StreamInfo()

void G4VEmProcess::StreamInfo ( std::ostream &  outFile, const G4ParticleDefinition &  part, G4bool  rst = false  ) const

privateinherited

Definition at line 477 of file G4VEmProcess.cc.

{
  G4String indent = (rst ? "  " : "");
  out << std::setprecision(6);
  out << G4endl << indent << GetProcessName() << ": ";
  if (!rst) {
    out << " for " << part.GetParticleName();
  }
  if(fXSType != fEmNoIntegral)  { out << " XStype:" << fXSType; }
  if(applyCuts) { out << " applyCuts:1 "; }
  out << " SubType=" << GetProcessSubType();
  if(biasFactor != 1.0) { out << "  BiasingFactor= " << biasFactor; }
  out << " BuildTable=" << buildLambdaTable << G4endl;
  if(buildLambdaTable) {
    if(particle == &part) { 
      size_t length = theLambdaTable->length();
      for(size_t i=0; i<length; ++i) {
        G4PhysicsVector* v = (*theLambdaTable)[i];
        if(v) {
          out << "      Lambda table from ";
          G4double emin = v->Energy(0);
          G4double emax = v->GetMaxEnergy();
          G4int nbin = v->GetVectorLength() - 1;
          if(emin > minKinEnergy) { out << "threshold "; }
          else { out << G4BestUnit(emin,"Energy"); } 
          out << " to "
              << G4BestUnit(emax,"Energy")
              << ", " << G4lrint(nbin/std::log10(emax/emin))
              << " bins/decade, spline: " 
              << splineFlag << G4endl;
          break;
        }
      }
    } else {
      out << "      Used Lambda table of " 
      << particle->GetParticleName() << G4endl;
    }
  }
  if(minKinEnergyPrim < maxKinEnergy) {
    if(particle == &part) { 
      size_t length = theLambdaTablePrim->length();
      for(size_t i=0; i<length; ++i) {
        G4PhysicsVector* v = (*theLambdaTablePrim)[i];
        if(v) { 
          out << "      LambdaPrime table from "
              << G4BestUnit(v->Energy(0),"Energy") 
              << " to "
              << G4BestUnit(v->GetMaxEnergy(),"Energy")
              << " in " << v->GetVectorLength()-1
              << " bins " << G4endl;
          break;
        }
      }
    } else {
      out << "      Used LambdaPrime table of " 
               << particle->GetParticleName() << G4endl;
    }
  }
  StreamProcessInfo(out);
  modelManager->DumpModelList(out, verboseLevel);
 
  if(verboseLevel > 2 && buildLambdaTable) {
    out << "      LambdaTable address= " << theLambdaTable << G4endl;
    if(theLambdaTable && particle == &part) { 
      out << (*theLambdaTable) << G4endl;
    }
  }
}

References G4VEmProcess::applyCuts, G4VEmProcess::biasFactor, G4VEmProcess::buildLambdaTable, G4EmModelManager::DumpModelList(), emax, G4PhysicsVector::Energy(), fEmNoIntegral, G4VEmProcess::fXSType, G4BestUnit, G4endl, G4lrint(), G4PhysicsVector::GetMaxEnergy(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4PhysicsVector::GetVectorLength(), G4PhysicsTable::length(), G4VEmProcess::maxKinEnergy, G4VEmProcess::minKinEnergy, G4VEmProcess::minKinEnergyPrim, G4VEmProcess::modelManager, G4VEmProcess::particle, G4VEmProcess::splineFlag, G4VEmProcess::StreamProcessInfo(), G4VEmProcess::theLambdaTable, G4VEmProcess::theLambdaTablePrim, and G4VProcess::verboseLevel.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4VEmProcess::ProcessDescription().

StreamProcessInfo()

void G4eplusAnnihilation::StreamProcessInfo ( std::ostream &  outFile ) const

overrideprotectedvirtualinherited

Reimplemented from G4VEmProcess.

Definition at line 119 of file G4eplusAnnihilation.cc.

{} 

SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

UseBaseMaterial()

G4bool G4VEmProcess::UseBaseMaterial ( ) const

inlineinherited

Definition at line 777 of file G4VEmProcess.hh.

{
  return baseMat;
}

References G4VEmProcess::baseMat.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), and G4VEmProcess::BuildPhysicsTable().

Field Documentation

actBinning

G4bool G4VEmProcess::actBinning = false

privateinherited

Definition at line 439 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::SetLambdaBinning().

actMaxKinEnergy

G4bool G4VEmProcess::actMaxKinEnergy = false

privateinherited

Definition at line 438 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SetMaxKinEnergy().

actMinKinEnergy

G4bool G4VEmProcess::actMinKinEnergy = false

privateinherited

Definition at line 437 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SetMinKinEnergy().

aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ErrorEnergyLoss::AlongStepDoIt(), G4hImpactIonisation::AlongStepDoIt(), G4DNAMolecularDissociation::DecayIt(), G4OpBoundaryProcess::DoAbsorption(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4VProcess::G4VProcess(), G4PhononDownconversion::MakeLTSecondaries(), G4PhononDownconversion::MakeTTSecondaries(), G4SpecialCuts::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4PhononDownconversion::PostStepDoIt(), G4PhononReflection::PostStepDoIt(), G4PhononScattering::PostStepDoIt(), G4StepLimiter::PostStepDoIt(), G4UserSpecialCuts::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4AnnihiToMuPair::PostStepDoIt(), G4GammaConversionToMuons::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4ForwardXrayTR::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4hImpactIonisation::PostStepDoIt(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

applyCuts

G4bool G4VEmProcess::applyCuts = false

privateinherited

Definition at line 434 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ApplyCuts(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::StreamInfo().

aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

augerID

G4int G4VEmProcess::augerID = _AugerElectron

protectedinherited

Definition at line 420 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4VEmProcess::PostStepDoIt().

basedCoupleIndex

size_t G4VEmProcess::basedCoupleIndex = 0

protectedinherited

Definition at line 424 of file G4VEmProcess.hh.

Referenced by G4GammaGeneralProcess::ComputeGeneralLambda(), G4VEmProcess::DefineMaterial(), G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4GammaGeneralProcess::GetProbability(), and G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength().

baseMat

G4bool G4VEmProcess::baseMat = false

protectedinherited

Definition at line 429 of file G4VEmProcess.hh.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::DefineMaterial(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::UseBaseMaterial().

baseMaterial

const G4Material* G4VEmProcess::baseMaterial = nullptr

privateinherited

Definition at line 364 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCurrentLambda(), and G4VEmProcess::DefineMaterial().

biasFactor

G4double G4VEmProcess::biasFactor = 1.0

privateinherited

Definition at line 395 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::CrossSectionBiasingFactor(), G4VEmProcess::DefineMaterial(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::SetCrossSectionBiasingFactor(), and G4VEmProcess::StreamInfo().

biasFlag

G4bool G4VEmProcess::biasFlag = false

privateinherited

Definition at line 441 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::StartTracking().

biasID

G4int G4VEmProcess::biasID = _EM

protectedinherited

Definition at line 421 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt().

biasManager

G4EmBiasingManager* G4VEmProcess::biasManager = nullptr

protectedinherited

Definition at line 381 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::StartTracking(), and G4VEmProcess::~G4VEmProcess().

buildLambdaTable

G4bool G4VEmProcess::buildLambdaTable = true

privateinherited

Definition at line 433 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetBuildTableFlag(), and G4VEmProcess::StreamInfo().

coupleIdxLambda

size_t G4VEmProcess::coupleIdxLambda = 0

protectedinherited

Definition at line 425 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda().

currentCouple

const G4MaterialCutsCouple* G4VEmProcess::currentCouple = nullptr

protectedinherited

Definition at line 379 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::Clear(), G4VEmProcess::DefineMaterial(), G4VEmProcess::MaterialCutsCouple(), G4VEmProcess::PostStepDoIt(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4GammaGeneralProcess::SelectEmProcess(), G4VEmProcess::SelectModel(), and G4GammaGeneralProcess::TotalCrossSectionPerVolume().

currentCoupleIndex

size_t G4VEmProcess::currentCoupleIndex = 0

protectedinherited

Definition at line 423 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::CurrentMaterialCutsCoupleIndex(), G4VEmProcess::CurrentSetup(), G4VEmProcess::DefineMaterial(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::GetElectronEnergyCut(), G4VEmProcess::GetGammaEnergyCut(), G4VEmProcess::PostStepDoIt(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEmProcess::SelectModel().

currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

Referenced by G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::EndTracking(), G4Decay::EndTracking(), G4VProcess::GetCurrentInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::StartTracking(), G4Decay::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

currentMaterial

const G4Material* G4VEmProcess::currentMaterial = nullptr

protectedinherited

Definition at line 380 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DefineMaterial(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), and G4GammaGeneralProcess::SelectHadProcess().

currentModel

G4VEmModel* G4VEmProcess::currentModel = nullptr

privateinherited

Definition at line 361 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::GetCurrentElement(), G4VEmProcess::GetCurrentModel(), G4VEmProcess::GetTargetElement(), G4VEmProcess::GetTargetIsotope(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SelectModel().

currentParticle

const G4ParticleDefinition* G4VEmProcess::currentParticle = nullptr

privateinherited

Definition at line 354 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeCrossSectionPerAtom(), G4VEmProcess::ComputeCurrentLambda(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::SetParticle(), and G4VEmProcess::StartTracking().

emModels

std::vector<G4VEmModel*> G4VEmProcess::emModels

privateinherited

Definition at line 453 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::EmModel(), and G4VEmProcess::SetEmModel().

enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

fAsymmetryTable

G4PhysicsTable* G4PolarizedAnnihilation::fAsymmetryTable

private

Definition at line 85 of file G4PolarizedAnnihilation.hh.

Referenced by BuildAsymmetryTables(), CleanTables(), GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

fEmModel

G4PolarizedAnnihilationModel* G4PolarizedAnnihilation::fEmModel

private

Definition at line 82 of file G4PolarizedAnnihilation.hh.

Referenced by ComputeAsymmetry(), and G4PolarizedAnnihilation().

fEntanglementModelID

G4int G4eplusAnnihilation::fEntanglementModelID

privateinherited

Definition at line 102 of file G4eplusAnnihilation.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4eplusAnnihilation::G4eplusAnnihilation().

fFactor

G4double G4VEmProcess::fFactor = 1.0

privateinherited

Definition at line 397 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DefineMaterial(), G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::RecalculateLambda().

fLambda

G4double G4VEmProcess::fLambda = 0.0

privateinherited

Definition at line 398 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda().

fLambdaEnergy

G4double G4VEmProcess::fLambdaEnergy = 0.0

privateinherited

Definition at line 399 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetCurrentLambda(), and G4VEmProcess::PreparePhysicsTable().

fluoID

G4int G4VEmProcess::fluoID = _Fluorescence

protectedinherited

Definition at line 419 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4VEmProcess::PostStepDoIt().

fParticleChange

G4ParticleChangeForGamma G4VEmProcess::fParticleChange

protectedinherited

Definition at line 448 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::GetParticleChange(), G4GammaGeneralProcess::PostStepDoIt(), and G4VEmProcess::PostStepDoIt().

fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

fTransverseAsymmetryTable

G4PhysicsTable* G4PolarizedAnnihilation::fTransverseAsymmetryTable

private

Definition at line 87 of file G4PolarizedAnnihilation.hh.

Referenced by BuildAsymmetryTables(), CleanTables(), GetMeanFreePath(), and PostStepGetPhysicalInteractionLength().

fXSType

G4CrossSectionType G4VEmProcess::fXSType = fEmNoIntegral

privateinherited

Definition at line 410 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::CrossSectionType(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetCrossSectionType(), G4VEmProcess::SetEnergyOfCrossSectionMax(), and G4VEmProcess::StreamInfo().

idxLambda

size_t G4VEmProcess::idxLambda = 0

protectedinherited

Definition at line 426 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetLambdaFromTable(), and G4VEmProcess::GetLambdaFromTablePrim().

isInitialised

G4bool G4eplusAnnihilation::isInitialised = false

privateinherited

Definition at line 99 of file G4eplusAnnihilation.hh.

Referenced by G4eplusAnnihilation::InitialiseProcess().

isIon

G4bool G4VEmProcess::isIon = false

privateinherited

Definition at line 440 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::StartTracking().

isTheMaster

G4bool G4VEmProcess::isTheMaster = true

protectedinherited

Definition at line 428 of file G4VEmProcess.hh.

Referenced by G4GammaGeneralProcess::BuildPhysicsTable(), BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4GammaGeneralProcess::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4GammaGeneralProcess::~G4GammaGeneralProcess(), and G4VEmProcess::~G4VEmProcess().

lambdaFactor

G4double G4VEmProcess::lambdaFactor = 0.8

privateinherited

Definition at line 393 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PreparePhysicsTable().

lManager

G4LossTableManager* G4VEmProcess::lManager = nullptr

privateinherited

Definition at line 362 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::~G4VEmProcess().

logLambdaFactor

G4double G4VEmProcess::logLambdaFactor

privateinherited

Definition at line 394 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PreparePhysicsTable().

mainSecondaries

G4int G4VEmProcess::mainSecondaries = 1

protectedinherited

Definition at line 417 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4eplusAnnihilation::G4eplusAnnihilation(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

massRatio

G4double G4VEmProcess::massRatio = 1.0

privateinherited

Definition at line 396 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::CurrentSetup(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEmProcess::StartTracking().

masterProc

const G4VEmProcess* G4VEmProcess::masterProc = nullptr

privateinherited

Definition at line 359 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), and G4VEmProcess::SetEmMasterProcess().

masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

maxKinEnergy

G4double G4VEmProcess::maxKinEnergy

privateinherited

Definition at line 391 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::MaxKinEnergy(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::StreamInfo().

mfpKinEnergy

G4double G4VEmProcess::mfpKinEnergy = DBL_MAX

protectedinherited

Definition at line 403 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ComputeIntegralLambda(), G4VEmProcess::DefineMaterial(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::StartTracking().

minKinEnergy

G4double G4VEmProcess::minKinEnergy

privateinherited

Definition at line 390 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::MinKinEnergy(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetMaxKinEnergy(), G4VEmProcess::SetMinKinEnergy(), and G4VEmProcess::StreamInfo().

minKinEnergyPrim

G4double G4VEmProcess::minKinEnergyPrim = DBL_MAX

privateinherited

Definition at line 392 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetMinKinEnergyPrim(), and G4VEmProcess::StreamInfo().

modelManager

G4EmModelManager* G4VEmProcess::modelManager = nullptr

privateinherited

Definition at line 352 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::AddEmModel(), G4VEmProcess::BuildLambdaTable(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::GetModelByIndex(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SelectModel(), G4VEmProcess::SelectModelForMaterial(), G4VEmProcess::StreamInfo(), and G4VEmProcess::~G4VEmProcess().

nLambdaBins

G4int G4VEmProcess::nLambdaBins = 84

privateinherited

Definition at line 413 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::LambdaBinning(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::SetLambdaBinning(), G4VEmProcess::SetMaxKinEnergy(), and G4VEmProcess::SetMinKinEnergy().

numberOfModels

G4int G4VEmProcess::numberOfModels = 0

privateinherited

Definition at line 412 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::NumberOfModels(), G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::SelectModel().

particle

const G4ParticleDefinition* G4VEmProcess::particle = nullptr

privateinherited

Definition at line 353 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), emcalc_gui.MainWindow::cb_select_particle(), emcalc_gui.MainWindow::cb_show_plot(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::Particle(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::ProcessDescription(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEmProcess::SetParticle(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

preStepKinEnergy

G4double G4VEmProcess::preStepKinEnergy = 0.0

protectedinherited

Definition at line 404 of file G4VEmProcess.hh.

Referenced by G4GammaGeneralProcess::ComputeGeneralLambda(), G4GammaGeneralProcess::GetProbability(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::SelectEmProcess(), and G4GammaGeneralProcess::TotalCrossSectionPerVolume().

preStepLambda

G4double G4VEmProcess::preStepLambda = 0.0

protectedinherited

Definition at line 406 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::Clear(), G4VEmProcess::ComputeIntegralLambda(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4GammaGeneralProcess::PreparePhysicsTable().

preStepLogKinEnergy

G4double G4VEmProcess::preStepLogKinEnergy = LOG_EKIN_MIN

protectedinherited

Definition at line 405 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepGetPhysicalInteractionLength().

secID

G4int G4VEmProcess::secID = _EM

protectedinherited

Definition at line 418 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

secondaryParticle

const G4ParticleDefinition* G4VEmProcess::secondaryParticle = nullptr

privateinherited

Definition at line 358 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateSecondaryBiasing(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SecondaryParticle(), and G4VEmProcess::SetSecondaryParticle().

secParticles

std::vector<G4DynamicParticle*> G4VEmProcess::secParticles

protectedinherited

Definition at line 447 of file G4VEmProcess.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PostStepDoIt().

splineFlag

G4bool G4VEmProcess::splineFlag = true

privateinherited

Definition at line 436 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::LambdaPhysicsVector(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::SetSplineFlag(), and G4VEmProcess::StreamInfo().

startFromNull

G4bool G4VEmProcess::startFromNull = false

privateinherited

Definition at line 435 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEmProcess::SetStartFromNullFlag().

theCuts

const std::vector<G4double>* G4VEmProcess::theCuts = nullptr

privateinherited

Definition at line 370 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theCutsElectron

const std::vector<G4double>* G4VEmProcess::theCutsElectron = nullptr

privateinherited

Definition at line 372 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetElectronEnergyCut(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theCutsGamma

const std::vector<G4double>* G4VEmProcess::theCutsGamma = nullptr

privateinherited

Definition at line 371 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::GetGammaEnergyCut(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theCutsPositron

const std::vector<G4double>* G4VEmProcess::theCutsPositron = nullptr

privateinherited

Definition at line 373 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

theData

G4EmDataHandler* G4VEmProcess::theData = nullptr

privateinherited

Definition at line 360 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PreparePhysicsTable(), and G4VEmProcess::~G4VEmProcess().

theDensityFactor

const std::vector<G4double>* G4VEmProcess::theDensityFactor = nullptr

privateinherited

Definition at line 386 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DensityFactor(), and G4VEmProcess::G4VEmProcess().

theDensityIdx

const std::vector<G4int>* G4VEmProcess::theDensityIdx = nullptr

privateinherited

Definition at line 387 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::DensityIndex(), and G4VEmProcess::G4VEmProcess().

theElectron

const G4ParticleDefinition* G4eplusAnnihilation::theElectron

privateinherited

Definition at line 101 of file G4eplusAnnihilation.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4eplusAnnihilation::G4eplusAnnihilation().

theEnergyOfCrossSectionMax

std::vector<G4double>* G4VEmProcess::theEnergyOfCrossSectionMax = nullptr

protectedinherited

Definition at line 382 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::EnergyOfCrossSectionMax(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::SetEnergyOfCrossSectionMax(), and G4VEmProcess::~G4VEmProcess().

theGamma

const G4ParticleDefinition* G4eplusAnnihilation::theGamma

privateinherited

Definition at line 100 of file G4eplusAnnihilation.hh.

Referenced by G4eplusAnnihilation::AtRestDoIt(), and G4eplusAnnihilation::G4eplusAnnihilation().

theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

theLambdaTable

G4PhysicsTable* G4VEmProcess::theLambdaTable = nullptr

privateinherited

Definition at line 367 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetCurrentLambda(), G4VEmProcess::GetLambdaFromTable(), G4VEmProcess::LambdaTable(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

theLambdaTablePrim

G4PhysicsTable* G4VEmProcess::theLambdaTablePrim = nullptr

privateinherited

Definition at line 368 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::GetLambdaFromTablePrim(), G4VEmProcess::LambdaTablePrim(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEmProcess::StorePhysicsTable(), and G4VEmProcess::StreamInfo().

theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theParameters

G4EmParameters* G4VEmProcess::theParameters = nullptr

privateinherited

Definition at line 363 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::BuildLambdaTable(), G4VEmProcess::BuildPhysicsTable(), G4VEmProcess::FindLambdaMax(), G4VEmProcess::G4VEmProcess(), G4VEmProcess::PolarAngleLimit(), G4VEmProcess::PreparePhysicsTable(), G4VEmProcess::PrintWarning(), and G4VEmProcess::SetMinKinEnergyPrim().

thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

thePositron

const G4ParticleDefinition* G4VEmProcess::thePositron = nullptr

privateinherited

Definition at line 357 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::G4VEmProcess(), and G4VEmProcess::PostStepDoIt().

theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

tripletID

G4int G4VEmProcess::tripletID = _TripletElectron

protectedinherited

Definition at line 422 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::PostStepDoIt(), and G4VEmProcess::PreparePhysicsTable().

verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), G4Transportation::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), G4Transportation::SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), G4Transportation::SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

weightFlag

G4bool G4VEmProcess::weightFlag = false

privateinherited

Definition at line 442 of file G4VEmProcess.hh.

Referenced by G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::PostStepDoIt(), and G4VEmProcess::SetCrossSectionBiasingFactor().

---

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

• source/processes/electromagnetic/polarisation/include/G4PolarizedAnnihilation.hh
• source/processes/electromagnetic/polarisation/src/G4PolarizedAnnihilation.cc