#include <G4GammaGeneralProcess.hh>

Inheritance diagram for G4GammaGeneralProcess:

Public Member Functions
	G4GammaGeneralProcess ()

virtual	~G4GammaGeneralProcess ()

G4bool	IsApplicable (const G4ParticleDefinition &) override

void	AddEmProcess (G4VEmProcess *)

void	AddMMProcess (G4GammaConversionToMuons *)

void	AddHadProcess (G4HadronicProcess *)

void	ProcessDescription (std::ostream &outFile) const override

void	PreparePhysicsTable (const G4ParticleDefinition &) override

void	BuildPhysicsTable (const G4ParticleDefinition &) override

void	StartTracking (G4Track *) override

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

G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override

G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override

G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override

const G4String &	GetProcessName () const

G4int	GetProcessSubType () const

G4VEmProcess *	GetEmProcess (const G4String &name) override

	G4GammaGeneralProcess (G4GammaGeneralProcess &)=delete

G4GammaGeneralProcess &	operator= (const G4GammaGeneralProcess &right)=delete

Public Member Functions inherited from G4VEmProcess
	G4VEmProcess (const G4String &name, G4ProcessType type=fElectromagnetic)

virtual	~G4VEmProcess ()

virtual G4bool	IsApplicable (const G4ParticleDefinition &p) override=0

virtual void	PrintInfo ()

virtual void	ProcessDescription (std::ostream &outFile) const override

virtual void	PreparePhysicsTable (const G4ParticleDefinition &) override

virtual void	BuildPhysicsTable (const G4ParticleDefinition &) override

virtual void	StartTracking (G4Track *) override

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override

virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override

virtual G4VEmProcess *	GetEmProcess (const G4String &name)

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

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

G4double	MeanFreePath (const G4Track &track)

G4double	GetLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)

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

void	SetLambdaBinning (G4int nbins)

void	SetMinKinEnergy (G4double e)

void	SetMinKinEnergyPrim (G4double e)

void	SetMaxKinEnergy (G4double e)

G4PhysicsTable *	LambdaTable () const

G4PhysicsTable *	LambdaTablePrim () const

const G4ParticleDefinition *	Particle () const

const G4ParticleDefinition *	SecondaryParticle () const

G4VEmModel *	SelectModelForMaterial (G4double kinEnergy, size_t idxRegion) const

void	AddEmModel (G4int, G4VEmModel , const G4Region region=nullptr)

void	SetEmModel (G4VEmModel *, G4int index=0)

G4VEmModel *	EmModel (size_t index=0) const

void	UpdateEmModel (const G4String &, G4double, G4double)

G4int	GetNumberOfModels () const

G4int	GetNumberOfRegionModels (size_t couple_index) const

G4VEmModel *	GetRegionModel (G4int idx, size_t couple_index) const

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

const G4VEmModel *	GetCurrentModel () const

const G4Element *	GetCurrentElement () const

void	SetCrossSectionBiasingFactor (G4double f, G4bool flag=true)

G4double	CrossSectionBiasingFactor () const

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

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

void	SetEmMasterProcess (const G4VEmProcess *)

void	SetIntegral (G4bool val)

void	SetBuildTableFlag (G4bool val)

void	CurrentSetup (const G4MaterialCutsCouple *, G4double energy)

Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &aName, G4ProcessType aType=fNotDefined)

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

G4VDiscreteProcess &	operator= (const G4VDiscreteProcess &)=delete

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

virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

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

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4VProcess &	operator= (const G4VProcess &)=delete

G4bool	operator== (const G4VProcess &right) const

G4bool	operator!= (const G4VProcess &right) const

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

virtual void	ProcessDescription (std::ostream &outfile) const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
void	InitialiseProcess (const G4ParticleDefinition *) override

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

G4double	ComputeGeneralLambda (size_t idxe, size_t idxt)

G4double	GetProbability (size_t idxt)

void	SelectedProcess (const G4Step &track, const G4VProcess *ptr)

G4VParticleChange *	SampleEmSecondaries (const G4Track &, const G4Step &, G4VEmProcess *)

G4VParticleChange *	SampleHadSecondaries (const G4Track &, const G4Step &, G4HadronicProcess *)

Protected Member Functions inherited from G4VEmProcess
virtual void	StreamProcessInfo (std::ostream &) const

virtual void	InitialiseProcess (const G4ParticleDefinition *)=0

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material )

G4VEmModel *	SelectModel (G4double kinEnergy, size_t index)

virtual G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition) override

G4PhysicsVector *	LambdaPhysicsVector (const G4MaterialCutsCouple *)

void	DefineMaterial (const G4MaterialCutsCouple *couple)

G4int	LambdaBinning () const

G4double	MinKinEnergy () const

G4double	MaxKinEnergy () const

G4double	PolarAngleLimit () const

G4bool	IsIntegral () const

G4double	RecalculateLambda (G4double kinEnergy, const G4MaterialCutsCouple *couple)

G4ParticleChangeForGamma *	GetParticleChange ()

void	SetParticle (const G4ParticleDefinition *p)

void	SetSecondaryParticle (const G4ParticleDefinition *p)

size_t	CurrentMaterialCutsCoupleIndex () const

const G4MaterialCutsCouple *	MaterialCutsCouple () const

G4bool	ApplyCuts () const

G4double	GetGammaEnergyCut ()

G4double	GetElectronEnergyCut ()

void	SetStartFromNullFlag (G4bool val)

void	SetSplineFlag (G4bool val)

const G4Element *	GetTargetElement () const

const G4Isotope *	GetTargetIsotope () const

virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4HadronicProcess *	theGammaNuclear

const G4VProcess *	selectedProc

Protected Attributes inherited from G4VEmProcess
G4LossTableManager *	lManager

G4EmParameters *	theParameters

G4EmBiasingManager *	biasManager

const G4ParticleDefinition *	theGamma

const G4ParticleDefinition *	theElectron

G4ParticleChangeForGamma	fParticleChange

std::vector< G4DynamicParticle * >	secParticles

const G4MaterialCutsCouple *	currentCouple

const G4Material *	currentMaterial

const std::vector< G4double > *	theDensityFactor

const std::vector< G4int > *	theDensityIdx

size_t	currentCoupleIndex

size_t	basedCoupleIndex

G4int	mainSecondaries

G4int	secID

G4int	fluoID

G4int	augerID

G4int	biasID

G4bool	isTheMaster

G4double	mfpKinEnergy

G4double	preStepKinEnergy

G4double	preStepLogKinEnergy

G4double	preStepLambda

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr

G4VParticleChange *	pParticleChange = nullptr

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft = -1.0

G4double	currentInteractionLength = -1.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType = fNotDefined

G4int	theProcessSubType = -1

G4double	thePILfactor = 1.0

G4int	verboseLevel = 0

G4bool	enableAtRestDoIt = true

G4bool	enableAlongStepDoIt = true

G4bool	enablePostStepDoIt = true

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 66 of file G4GammaGeneralProcess.hh.

Constructor & Destructor Documentation

◆ G4GammaGeneralProcess() [1/2]

G4GammaGeneralProcess::G4GammaGeneralProcess ( )

explicit

Definition at line 85 of file G4GammaGeneralProcess.cc.

                                            :
  G4VEmProcess("GammaGeneralProc", fElectromagnetic),
  minPEEnergy(50*CLHEP::keV),
  minEEEnergy(2*CLHEP::electron_mass_c2),
  minMMEnergy(100*CLHEP::MeV),
  peLambda(0.0),
  nLowE(40),
  nHighE(50),
  splineFlag(false)
{
  thePhotoElectric = theCompton = theConversionEE = theRayleigh = nullptr;
  theGammaNuclear = nullptr;
  theConversionMM = nullptr;
  selectedProc = nullptr;
 
  idxEnergy = 0;
  preStepLogE = factor = 1.0;
 
  SetVerboseLevel(1);
  SetParticle(theGamma);
  SetProcessSubType(fGammaGeneralProcess);
}

◆ ~G4GammaGeneralProcess()

G4GammaGeneralProcess::~G4GammaGeneralProcess ( )

virtual

Definition at line 110 of file G4GammaGeneralProcess.cc.

{
  //std::cout << "G4GammaGeneralProcess::~G4GammaGeneralProcess " << isTheMaster
  //        << "  " << theHandler << G4endl;
  if(isTheMaster) {
    delete theHandler;
    theHandler = nullptr;
  }
}

◆ G4GammaGeneralProcess() [2/2]

G4GammaGeneralProcess::G4GammaGeneralProcess ( G4GammaGeneralProcess & )

delete

Member Function Documentation

◆ AddEmProcess()

void G4GammaGeneralProcess::AddEmProcess ( G4VEmProcess * ptr )

Definition at line 129 of file G4GammaGeneralProcess.cc.

{
  if(!ptr) { return; }
  G4int stype = ptr->GetProcessSubType();
  if(stype == fRayleigh)                 { theRayleigh = ptr; }
  else if(stype == fPhotoElectricEffect) { thePhotoElectric = ptr; }
  else if(stype == fComptonScattering)   { theCompton = ptr; }
  else if(stype == fGammaConversion)     { theConversionEE = ptr; }
}

◆ AddHadProcess()

void G4GammaGeneralProcess::AddHadProcess ( G4HadronicProcess * ptr )

Definition at line 148 of file G4GammaGeneralProcess.cc.

{
  theGammaNuclear = ptr;
}

◆ AddMMProcess()

void G4GammaGeneralProcess::AddMMProcess ( G4GammaConversionToMuons * ptr )

Definition at line 141 of file G4GammaGeneralProcess.cc.

{
  theConversionMM = ptr;
}

◆ BuildPhysicsTable()

void G4GammaGeneralProcess::BuildPhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 254 of file G4GammaGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
  if(thePhotoElectric != nullptr) { 
    if(!isTheMaster) { 
      thePhotoElectric->SetEmMasterProcess(theHandler->GetMasterProcess(0)); 
    }
    thePhotoElectric->BuildPhysicsTable(part); 
  }
  if(theCompton != nullptr) { 
    if(!isTheMaster) { 
      theCompton->SetEmMasterProcess(theHandler->GetMasterProcess(1)); 
    }
    theCompton->BuildPhysicsTable(part); 
  }
  if(theConversionEE != nullptr) { 
    if(!isTheMaster) { 
      theConversionEE->SetEmMasterProcess(theHandler->GetMasterProcess(2)); 
    }
    theConversionEE->BuildPhysicsTable(part); 
  }
  if(theRayleigh != nullptr) { 
    if(!isTheMaster) { 
      theRayleigh->SetEmMasterProcess(theHandler->GetMasterProcess(3)); 
    }
    theRayleigh->BuildPhysicsTable(part); 
  }
  if(theGammaNuclear != nullptr)  { theGammaNuclear->BuildPhysicsTable(part); }
  if(theConversionMM != nullptr)  { theConversionMM->BuildPhysicsTable(part); }
 
  if(isTheMaster) {
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    size_t numOfCouples = theCoupleTable->GetTableSize();
 
    G4LossTableBuilder* bld = lManager->GetTableBuilder();
    const std::vector<G4PhysicsTable*>& tables = theHandler->GetTables();
 
    G4CrossSectionDataStore* gn = (theGammaNuclear) 
      ? theGammaNuclear->GetCrossSectionDataStore() : nullptr;
    G4DynamicParticle* dynParticle = 
      new G4DynamicParticle(G4Gamma::Gamma(),G4ThreeVector(1,0,0),1.0);
 
    G4double sigComp(0.), sigPE(0.), sigConv(0.), sigR(0.),
      sigN(0.), sigM(0.), val(0.);
 
    for(size_t i=0; i<numOfCouples; ++i) {
 
      if (bld->GetFlag(i)) {
 
        G4int idx = (*theDensityIdx)[i]; 
    const G4MaterialCutsCouple* couple = 
      theCoupleTable->GetMaterialCutsCouple(i);
    const G4Material* material = couple->GetMaterial();
 
    // energy interval 0
        size_t nn = (*(tables[0]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 0 ======= N= " << nn 
         << " for " << material->GetName() << G4endl; 
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[0]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = (theCompton) ? theCompton->GetLambda(e, couple, loge) : 0.0;
          sigR = (theRayleigh) ? theRayleigh->GetLambda(e, couple, loge) : 0.0;
          G4double sum = sigComp + sigR;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum 
           << " compt= " << sigComp << " Rayl= " << sigR << G4endl; 
      }
          (*(tables[0]))[idx]->PutValue(j, sum);
      if(theT[1]) {
            val = (sum > 0.0) ? sigComp/sum : 0.0;
        (*(tables[1]))[idx]->PutValue(j, val);
      } 
    }
 
    // energy interval 1
        nn = (*(tables[2]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 1 ======= N= " << nn << G4endl; 
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[2]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = (theCompton) ? theCompton->GetLambda(e, couple, loge) : 0.0;
          sigR = (theRayleigh) ? theRayleigh->GetLambda(e, couple, loge) : 0.0;
          sigPE = (thePhotoElectric) 
        ? thePhotoElectric->GetLambda(e, couple, loge) : 0.0;
          sigN = 0.0;
          if(gn) {
        dynParticle->SetKineticEnergy(e);
        sigN = gn->ComputeCrossSection(dynParticle, material);
      }
          G4double sum = sigComp + sigR + sigPE + sigN;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum 
           << " compt= " << sigComp << " conv= " << sigConv 
           << " PE= " << sigPE << " Rayl= " << sigR
           << " GN= " << sigN << G4endl; 
      }
          (*(tables[2]))[idx]->PutValue(j, sum);
          val = (sum > 0.0) ? sigPE/sum : 0.0;
      (*(tables[3]))[idx]->PutValue(j, val);
      if(theT[4]) {
            val = (sum > 0.0) ? (sigComp + sigPE)/sum : 0.0;
        (*(tables[4]))[idx]->PutValue(j, val);
      } 
      if(theT[5]) {
            val = (sum > 0.0) ? (sigComp + sigPE + sigR)/sum : 0.0;
        (*(tables[5]))[idx]->PutValue(j, val);
      } 
    }
 
    // energy interval 2
        nn = (*(tables[6]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 2 ======= N= " << nn << G4endl; 
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[6]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = (theCompton) ? theCompton->GetLambda(e, couple, loge) : 0.0;
          sigConv = (theConversionEE) 
        ? theConversionEE->GetLambda(e, couple, loge) : 0.0;
          sigPE = (thePhotoElectric) 
        ? thePhotoElectric->GetLambda(e, couple, loge) : 0.0;
          sigN = 0.0;
          if(gn) {
        dynParticle->SetKineticEnergy(e);
        sigN = gn->ComputeCrossSection(dynParticle, material);
      }
          G4double sum = sigComp + sigConv + sigPE + sigN;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum 
           << " compt= " << sigComp << " conv= " << sigConv 
           << " PE= " << sigPE
           << " GN= " << sigN << G4endl;
      } 
          (*(tables[6]))[idx]->PutValue(j, sum);
          val = (sum > 0.0) ? sigConv/sum : 0.0;
      (*(tables[7]))[idx]->PutValue(j, val);
          val = (sum > 0.0) ? (sigConv + sigComp)/sum : 0.0;
      (*(tables[8]))[idx]->PutValue(j, val);
      if(theT[9]) {
            val = (sum > 0.0) ? (sigConv + sigComp + sigPE)/sum : 0.0;
        (*(tables[9]))[idx]->PutValue(j, val);
      } 
    }
 
    // energy interval 3
        nn = (*(tables[10]))[idx]->GetVectorLength();
    if(1 < verboseLevel) {
      G4cout << "======= Zone 3 ======= N= " << nn  
         << " for " << material->GetName() << G4endl; 
    }
        for(size_t j=0; j<nn; ++j) {
          G4double e = (*(tables[10]))[idx]->Energy(j);
          G4double loge = G4Log(e);
          sigComp = (theCompton) ? theCompton->GetLambda(e, couple, loge) : 0.0;
          sigConv = (theConversionEE) 
        ? theConversionEE->GetLambda(e, couple, loge) : 0.0;
          sigPE = (thePhotoElectric) 
        ? thePhotoElectric->GetLambda(e, couple, loge) : 0.0;
          sigN = 0.0;
          if(gn) {
        dynParticle->SetKineticEnergy(e);
        sigN = gn->ComputeCrossSection(dynParticle, material);
      }
          sigM = 0.0;
          if(theConversionMM) {
        val = theConversionMM->ComputeMeanFreePath(e, material);
        sigM = (val < DBL_MAX) ? 1./val : 0.0;
      }
          G4double sum = sigComp + sigConv + sigPE + sigN + sigM;
      if(1 < verboseLevel) {
        G4cout << j << ". E= " << e << " xs= " << sum 
           << " compt= " << sigComp << " conv= " << sigConv 
           << " PE= " << sigPE
           << " GN= " << sigN << G4endl;
      } 
          (*(tables[10]))[idx]->PutValue(j, sum);
          val = (sum > 0.0) ? 1.0 - sigConv/sum : 1.0;
      (*(tables[11]))[idx]->PutValue(j, val);
          val = (sum > 0.0) ? 1.0 - (sigConv + sigComp)/sum : 1.0;
      (*(tables[12]))[idx]->PutValue(j, val);
      if(theT[13]) {
            val = (sum > 0.0) ? 1.0 - (sigConv + sigComp + sigPE)/sum : 1.0;
        (*(tables[13]))[idx]->PutValue(j, val);
      } 
      if(theT[14]) {
            val = (sum > 0.0) 
          ? 1.0 - (sigConv + sigComp + sigPE + sigN)/sum : 1.0;
        (*(tables[14]))[idx]->PutValue(j, val);
      } 
    }
    for(size_t k=0; k<nTables; ++k) {
      if(theT[k] && splineFlag) { 
        (*(tables[k]))[idx]->FillSecondDerivatives(); 
      } 
    }
      }
    }
    delete dynParticle;
  }
 
  if(1 < verboseLevel) {
    G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
}

◆ ComputeGeneralLambda()

G4double G4GammaGeneralProcess::ComputeGeneralLambda	(	size_t	idxe,
		size_t	idxt
	)

inlineprotected

Definition at line 189 of file G4GammaGeneralProcess.hh.

{
  idxEnergy = idxe;
  return factor*theHandler->GetVector(idxt, basedCoupleIndex)
    ->LogVectorValue(preStepKinEnergy, preStepLogE);
}

◆ GetEmProcess()

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

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 797 of file G4GammaGeneralProcess.cc.

{
  G4VEmProcess* proc = nullptr;
  if(thePhotoElectric != nullptr && name == thePhotoElectric->GetProcessName()) {
    proc = thePhotoElectric;
  } else if(theCompton != nullptr && name == theCompton->GetProcessName()) {
    proc = theCompton;
  } else if(theConversionEE != nullptr && name == theConversionEE->GetProcessName()) {
    proc = theConversionEE;
  } else if(theRayleigh != nullptr && name == theRayleigh->GetProcessName()) {
    proc = theRayleigh;
  }
  return proc;
}

◆ GetMeanFreePath()

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

overrideprotectedvirtual

Reimplemented from G4VEmProcess.

Definition at line 758 of file G4GammaGeneralProcess.cc.

{
  *condition = NotForced;
  return MeanFreePath(track);
}

◆ GetProbability()

G4double G4GammaGeneralProcess::GetProbability ( size_t idxt )

inlineprotected

Definition at line 198 of file G4GammaGeneralProcess.hh.

{
  return (theT[idxt]) ? theHandler->GetVector(idxt, basedCoupleIndex)
    ->LogVectorValue(preStepKinEnergy, preStepLogE) : 1.0;
}

Referenced by PostStepDoIt().

◆ GetProcessName()

const G4String & G4GammaGeneralProcess::GetProcessName ( ) const

Definition at line 780 of file G4GammaGeneralProcess.cc.

{
  //G4cout << "GetProcessName(): " << selectedProc << G4endl;
  return (selectedProc) ? selectedProc->GetProcessName() 
    : G4VProcess::GetProcessName();
}

Referenced by BuildPhysicsTable(), PreparePhysicsTable(), and RetrievePhysicsTable().

◆ GetProcessSubType()

G4int G4GammaGeneralProcess::GetProcessSubType ( ) const

Definition at line 789 of file G4GammaGeneralProcess.cc.

{
  return (selectedProc) ? selectedProc->GetProcessSubType() 
    : fGammaGeneralProcess; 
}

◆ InitialiseProcess()

void G4GammaGeneralProcess::InitialiseProcess ( const G4ParticleDefinition * )

overrideprotectedvirtual

Implements G4VEmProcess.

Definition at line 186 of file G4GammaGeneralProcess.cc.

{
  if(isTheMaster) { 
 
    // tables are created and its size is defined only once
    if(!theHandler) { 
      theHandler = new G4EmDataHandler(nTables);  
      if(theRayleigh) { theT[1] = theT[4] = true; } 
      if(theGammaNuclear) { theT[9] = theT[13] = true; } 
      if(theConversionMM) { theT[14] = true; } 
 
      theHandler->SetMasterProcess(thePhotoElectric);
      theHandler->SetMasterProcess(theCompton);
      theHandler->SetMasterProcess(theConversionEE);
      theHandler->SetMasterProcess(theRayleigh);
    }
    auto bld = lManager->GetTableBuilder();
     
    const G4ProductionCutsTable* theCoupleTable=
      G4ProductionCutsTable::GetProductionCutsTable();
    size_t numOfCouples = theCoupleTable->GetTableSize();
 
    G4double mine = theParameters->MinKinEnergy();
    G4double maxe = theParameters->MaxKinEnergy();
    G4int nd = theParameters->NumberOfBinsPerDecade();
    size_t nbin1 = std::max(5, nd*G4lrint(std::log10(minPEEnergy/mine)));
    size_t nbin2 = std::max(5, nd*G4lrint(std::log10(maxe/minMMEnergy)));
 
    G4PhysicsVector* vec = nullptr;
    G4PhysicsLogVector aVector(mine,minPEEnergy,nbin1);
    G4PhysicsLogVector bVector(minPEEnergy,minEEEnergy,nLowE);
    G4PhysicsLogVector cVector(minEEEnergy,minMMEnergy,nHighE);
    G4PhysicsLogVector dVector(minMMEnergy,maxe,nbin2);
    if(splineFlag) { 
      aVector.SetSpline(splineFlag);
      bVector.SetSpline(splineFlag);
      cVector.SetSpline(splineFlag);
      dVector.SetSpline(splineFlag);
    }
 
    for(size_t i=0; i<nTables; ++i) { 
      //G4cout << "## PreparePhysTable " << i << "." << G4endl;
      if(theT[i]) { 
    G4PhysicsTable* table = theHandler->MakeTable(i);        
    //G4cout << "   make table " << table << G4endl;
    for(size_t j=0; j<numOfCouples; ++j) {
          vec = (*table)[j];
      if (bld->GetFlag(j) && !vec) {
        //G4cout << " i= " << i << " j= " << j << " make new vector" << G4endl;
        if(i<=1) { 
          vec = new G4PhysicsVector(aVector);
        } else if(i<=5) {
          vec = new G4PhysicsVector(bVector);
        } else if(i<=9) {
          vec = new G4PhysicsVector(cVector);
        } else { 
          vec = new G4PhysicsVector(dVector);
        }
        G4PhysicsTableHelper::SetPhysicsVector(table, j, vec);
      }
    }
      }
    }
  }
}

Referenced by PreparePhysicsTable().

◆ IsApplicable()

G4bool G4GammaGeneralProcess::IsApplicable ( const G4ParticleDefinition & )

overridevirtual

Implements G4VEmProcess.

Definition at line 122 of file G4GammaGeneralProcess.cc.

{
  return true;
}

◆ operator=()

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

delete

◆ PostStepDoIt()

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

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 583 of file G4GammaGeneralProcess.cc.

{
  // In all cases clear number of interaction lengths
  theNumberOfInteractionLengthLeft = -1.0;
  G4double q = G4UniformRand(); 
  G4double x = preStepLambda*G4UniformRand(); 
  G4double p;
  /*  
  G4cout << "PostStep: preStepLambda= " << preStepLambda << " x= " << x 
         << " PE= " << peLambda << " q= " << q << " idxE= " << idxEnergy 
         << G4endl;
  */
  switch (idxEnergy) {
  case 0:
    if(x <= peLambda) { 
      return SampleEmSecondaries(track, step, thePhotoElectric);
    } else {
      p = GetProbability(1);
      if(x <= peLambda + (preStepLambda - peLambda)*p) {
    return SampleEmSecondaries(track, step, theCompton);
      } else if(theRayleigh != nullptr) {
    return SampleEmSecondaries(track, step, theRayleigh);
      }
    }
    break;
 
  case 1:  
    p = GetProbability(3);
    if(q <= p) {
      return SampleEmSecondaries(track, step, thePhotoElectric);
    }
    p = GetProbability(4);
    if(q <= p) {
      return SampleEmSecondaries(track, step, theCompton);
    }
    p = GetProbability(5);
    if(q <= p) {
      if(theRayleigh != nullptr) {
    return SampleEmSecondaries(track, step, theRayleigh);
      }
    } else if(theGammaNuclear != nullptr) {
      return SampleHadSecondaries(track, step, theGammaNuclear);
    }
    break;
 
  case 2:  
    p = GetProbability(7);
    if(q <= p) {
      return SampleEmSecondaries(track, step, theConversionEE);
    }
    p = GetProbability(8);
    if(q <= p) {
      return SampleEmSecondaries(track, step, theCompton);
    }
    p = GetProbability(9);
    if(q <= p) {
      return SampleEmSecondaries(track, step, thePhotoElectric);
    } else if(theGammaNuclear != nullptr) {
      return SampleHadSecondaries(track, step, theGammaNuclear);
    }
    break;
 
  case 3:  
    p = 1.0 - GetProbability(11);
    if(q <= p) {
      return SampleEmSecondaries(track, step, theConversionEE);
    }
    p = 1.0 - GetProbability(12);
    if(q <= p) {
      return SampleEmSecondaries(track, step, theCompton);
    }
    p = 1.0 - GetProbability(13);
    if(q <= p) {
      return SampleEmSecondaries(track, step, thePhotoElectric);
    } 
    p = 1.0 - GetProbability(14);
    if(q <= p) {
      if(theGammaNuclear != nullptr) {
    return SampleHadSecondaries(track, step, theGammaNuclear);
      }
    } else if(theConversionMM != nullptr) {
      SelectedProcess(step, theConversionMM);
      return theConversionMM->PostStepDoIt(track, step);
    }
    break;
  }
  // no interaction
  fParticleChange.InitializeForPostStep(track);
  return &fParticleChange;
}

◆ PostStepGetPhysicalInteractionLength()

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

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 484 of file G4GammaGeneralProcess.cc.

{
  *condition = NotForced;
  G4double x = DBL_MAX;
 
  G4double energy = track.GetKineticEnergy();
  currentCouple = track.GetMaterialCutsCouple();
  const G4Material* mat = currentCouple->GetMaterial();
 
  // compute mean free path
  if(mat != currentMaterial || energy != preStepKinEnergy) {
    currentCoupleIndex = currentCouple->GetIndex();
    basedCoupleIndex = (*theDensityIdx)[currentCoupleIndex];
    factor = (*theDensityFactor)[currentCoupleIndex];
    currentMaterial = mat;
    preStepKinEnergy = energy;
    preStepLogE = track.GetDynamicParticle()->GetLogKineticEnergy();
    preStepLambda = TotalCrossSectionPerVolume();
 
    // zero cross section
    if(preStepLambda <= 0.0) { 
      theNumberOfInteractionLengthLeft = -1.0;
      currentInteractionLength = DBL_MAX;
    }
  }
 
  // non-zero cross section
  if(preStepLambda > 0.0) { 
 
    if (theNumberOfInteractionLengthLeft < 0.0) {
 
      // beggining of tracking (or just after DoIt of this process)
      theNumberOfInteractionLengthLeft =  -G4Log( G4UniformRand() );
      theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
 
    } else if(currentInteractionLength < DBL_MAX) {
 
      theNumberOfInteractionLengthLeft -= 
        previousStepSize/currentInteractionLength;
      theNumberOfInteractionLengthLeft = 
        std::max(theNumberOfInteractionLengthLeft, 0.0);
    }
 
    // new mean free path and step limit for the next step
    currentInteractionLength = 1.0/preStepLambda;
    x = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  /*
  G4cout << "PostStepGetPhysicalInteractionLength: e= " << energy 
     << " idxe= " << idxEnergy << "  xs= " << preStepLambda 
     << " x= " << x << G4endl;
  */
  return x;
}

◆ PreparePhysicsTable()

void G4GammaGeneralProcess::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 155 of file G4GammaGeneralProcess.cc.

{
  SetParticle(&part);
  currentCouple = nullptr;
  currentMaterial = nullptr;
  preStepLambda = 0.0;
  idxEnergy = 0;
 
  isTheMaster = lManager->IsMaster(); 
  if(isTheMaster) { SetVerboseLevel(theParameters->Verbose()); }
  else { SetVerboseLevel(theParameters->WorkerVerbose()); }
 
  if(1 < verboseLevel) {
    G4cout << "G4GammaGeneralProcess::PreparePhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
       << " isMaster: " << isTheMaster << G4endl;
  }
 
  if(thePhotoElectric) { thePhotoElectric->PreparePhysicsTable(part); }
  if(theCompton)       { theCompton->PreparePhysicsTable(part); }
  if(theConversionEE)  { theConversionEE->PreparePhysicsTable(part); }
  if(theRayleigh)      { theRayleigh->PreparePhysicsTable(part); }
  if(theGammaNuclear)  { theGammaNuclear->PreparePhysicsTable(part); }
  if(theConversionMM)  { theConversionMM->PreparePhysicsTable(part); }
 
  InitialiseProcess(&part);
}

◆ ProcessDescription()

void G4GammaGeneralProcess::ProcessDescription ( std::ostream & outFile ) const

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 768 of file G4GammaGeneralProcess.cc.

{
  if(thePhotoElectric) { thePhotoElectric->ProcessDescription(out); }
  if(theCompton)       { theCompton->ProcessDescription(out); }
  if(theConversionEE)  { theConversionEE->ProcessDescription(out); }
  if(theRayleigh)      { theRayleigh->ProcessDescription(out); }
  if(theGammaNuclear)  { theGammaNuclear->ProcessDescription(out); }
  if(theConversionMM)  { theConversionMM->ProcessDescription(out); }
}

◆ RetrievePhysicsTable()

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

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 721 of file G4GammaGeneralProcess.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4GammaGeneralProcess::RetrievePhysicsTable() for "
           << part->GetParticleName() << " and process "
           << GetProcessName() << G4endl;
  }
  G4bool yes = true;
  if(thePhotoElectric != nullptr &&
     !thePhotoElectric->RetrievePhysicsTable(part, directory, ascii)) 
    { yes = false; }
  if(theCompton != nullptr && 
     !theCompton->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theConversionEE != nullptr && 
     !theConversionEE->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theRayleigh != nullptr &&
     !theRayleigh->RetrievePhysicsTable(part, directory, ascii))
    { yes = false; }
 
  for(size_t i=0; i<nTables; ++i) {
    if(theT[i]) {
      G4String nam = (0==i || 2==i || 6==i || 10==i) 
    ? "LambdaGeneral" + nameT[i] : "ProbGeneral" + nameT[i];
      G4String fnam =  GetPhysicsTableFileName(part,directory,nam,ascii);
      if(!theHandler->RetrievePhysicsTable(i, part, fnam, ascii)) 
    { yes = false; }
    }
  }
  return yes;
}

◆ SampleEmSecondaries()

G4VParticleChange * G4GammaGeneralProcess::SampleEmSecondaries	(	const G4Track &	track,
		const G4Step &	step,
		G4VEmProcess *	proc
	)

inlineprotected

Definition at line 215 of file G4GammaGeneralProcess.hh.

{
  proc->CurrentSetup(currentCouple,preStepKinEnergy);
  SelectedProcess(step, proc);
  return proc->PostStepDoIt(track, step);
}

Referenced by PostStepDoIt().

◆ SampleHadSecondaries()

G4VParticleChange * G4GammaGeneralProcess::SampleHadSecondaries	(	const G4Track &	track,
		const G4Step &	step,
		G4HadronicProcess *	proc
	)

protected

Definition at line 677 of file G4GammaGeneralProcess.cc.

{
  SelectedProcess(step, proc);
  proc->GetCrossSectionDataStore()->ComputeCrossSection(track.GetDynamicParticle(),
                                                        track.GetMaterial());
  return proc->PostStepDoIt(track, step);
}

Referenced by PostStepDoIt().

◆ SelectedProcess()

void G4GammaGeneralProcess::SelectedProcess	(	const G4Step &	track,
		const G4VProcess *	ptr
	)

inlineprotected

Definition at line 207 of file G4GammaGeneralProcess.hh.

{
  selectedProc = ptr;
  step.GetPostStepPoint()->SetProcessDefinedStep(ptr);
}

Referenced by PostStepDoIt(), SampleEmSecondaries(), and SampleHadSecondaries().

◆ StartTracking()

void G4GammaGeneralProcess::StartTracking ( G4Track * )

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 476 of file G4GammaGeneralProcess.cc.

{
  theNumberOfInteractionLengthLeft = -1.0;
  currentMaterial = nullptr;
}

◆ StorePhysicsTable()

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

overridevirtual

Reimplemented from G4VEmProcess.

Definition at line 688 of file G4GammaGeneralProcess.cc.

{
  G4bool yes = true;
  if(!isTheMaster) { return yes; }
  if(thePhotoElectric != nullptr &&
     !thePhotoElectric->StorePhysicsTable(part, directory, ascii)) 
    { yes = false; }
  if(theCompton != nullptr && 
     !theCompton->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theConversionEE != nullptr && 
     !theConversionEE->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
  if(theRayleigh != nullptr &&
     !theRayleigh->StorePhysicsTable(part, directory, ascii))
    { yes = false; }
 
  for(size_t i=0; i<nTables; ++i) {
    if(theT[i]) {
      G4String nam = (0==i || 2==i || 6==i || 10==i) 
    ? "LambdaGeneral" + nameT[i] : "ProbGeneral" + nameT[i];
      G4String fnam =  GetPhysicsTableFileName(part,directory,nam,ascii);
      if(!theHandler->StorePhysicsTable(i, part, fnam, ascii)) { yes = false; }
    }
  }
  return yes;
}

Member Data Documentation

◆ selectedProc

const G4VProcess* G4GammaGeneralProcess::selectedProc

protected

Definition at line 159 of file G4GammaGeneralProcess.hh.

Referenced by G4GammaGeneralProcess(), GetProcessName(), GetProcessSubType(), and SelectedProcess().

◆ theGammaNuclear

G4HadronicProcess* G4GammaGeneralProcess::theGammaNuclear

protected

Definition at line 158 of file G4GammaGeneralProcess.hh.

Referenced by AddHadProcess(), BuildPhysicsTable(), G4GammaGeneralProcess(), InitialiseProcess(), PostStepDoIt(), PreparePhysicsTable(), and ProcessDescription().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4GammaGeneralProcess() [1/2]

◆ ~G4GammaGeneralProcess()

◆ G4GammaGeneralProcess() [2/2]

Member Function Documentation

◆ AddEmProcess()

◆ AddHadProcess()

◆ AddMMProcess()

◆ BuildPhysicsTable()

◆ ComputeGeneralLambda()

◆ GetEmProcess()

◆ GetMeanFreePath()

◆ GetProbability()

◆ GetProcessName()

◆ GetProcessSubType()

◆ InitialiseProcess()

◆ IsApplicable()

◆ operator=()

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PreparePhysicsTable()

◆ ProcessDescription()

◆ RetrievePhysicsTable()

◆ SampleEmSecondaries()

◆ SampleHadSecondaries()

◆ SelectedProcess()

◆ StartTracking()

◆ StorePhysicsTable()

Member Data Documentation

◆ selectedProc

◆ theGammaNuclear