#include <G4EmBiasingManager.hh>

Public Member Functions
void	ActivateForcedInteraction (G4double length=0.0, const G4String &r="")

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

G4double	ApplySecondaryBiasing (std::vector< G4DynamicParticle * > &, const G4Track &track, G4VEmModel currentModel, G4ParticleChangeForGamma pParticleChange, G4double &eloss, G4int coupleIdx, G4double tcut, G4double safety=0.0)

G4double	ApplySecondaryBiasing (std::vector< G4DynamicParticle * > &, const G4Track &track, G4VEmModel currentModel, G4ParticleChangeForLoss pParticleChange, G4double &eloss, G4int coupleIdx, G4double tcut, G4double safety=0.0)

G4double	ApplySecondaryBiasing (std::vector< G4Track * > &, G4int coupleIdx)

G4bool	CheckDirection (G4ThreeVector pos, G4ThreeVector momdir) const

G4bool	ForcedInteractionRegion (G4int coupleIdx)

	G4EmBiasingManager ()

	G4EmBiasingManager (G4EmBiasingManager &)=delete

G4bool	GetDirectionalSplitting ()

G4double	GetStepLimit (G4int coupleIdx, G4double previousStep)

G4double	GetWeight (G4int i)

void	Initialise (const G4ParticleDefinition &part, const G4String &procName, G4int verbose)

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

void	ResetForcedInteraction ()

G4bool	SecondaryBiasingRegion (G4int coupleIdx)

void	SetDirectionalSplitting (G4bool v)

void	SetDirectionalSplittingRadius (G4double r)

void	SetDirectionalSplittingTarget (G4ThreeVector v)

	~G4EmBiasingManager ()

Private Member Functions
G4double	ApplyDirectionalSplitting (std::vector< G4DynamicParticle * > &vd, const G4Track &track, G4VEmModel *currentModel, G4int index, G4double tcut)

G4double	ApplyDirectionalSplitting (std::vector< G4DynamicParticle * > &vd, const G4Track &track, G4VEmModel currentModel, G4int index, G4double tcut, G4ParticleChangeForGamma partChange)

void	ApplyRangeCut (std::vector< G4DynamicParticle * > &vd, const G4Track &track, G4double &eloss, G4double safety)

G4double	ApplyRussianRoulette (std::vector< G4DynamicParticle * > &vd, G4int index)

G4double	ApplySplitting (std::vector< G4DynamicParticle * > &vd, const G4Track &track, G4VEmModel *currentModel, G4int index, G4double tcut)

Private Attributes
G4double	currentStepLimit = 0.0

G4VEnergyLossProcess *	eIonisation = nullptr

G4bool	fDirectionalSplitting = false

G4double	fDirectionalSplittingRadius = 0.0

G4ThreeVector	fDirectionalSplittingTarget

std::vector< G4double >	fDirectionalSplittingWeights

std::vector< const G4Region * >	forcedRegions

G4double	fSafetyMin

std::vector< G4int >	idxForcedCouple

std::vector< G4int >	idxSecBiasedCouple

std::vector< G4double >	lengthForRegion

std::vector< G4int >	nBremSplitting

G4int	nForcedRegions = 0

G4int	nSecBiasedRegions = 0

std::vector< G4double >	secBiasedEnegryLimit

std::vector< const G4Region * >	secBiasedRegions

std::vector< G4double >	secBiasedWeight

G4bool	startTracking = true

const G4ParticleDefinition *	theElectron

const G4ParticleDefinition *	theGamma

std::vector< G4DynamicParticle * >	tmpSecondaries

Detailed Description

Definition at line 66 of file G4EmBiasingManager.hh.

Constructor & Destructor Documentation

◆ G4EmBiasingManager() [1/2]

G4EmBiasingManager::G4EmBiasingManager ( )

Definition at line 67 of file G4EmBiasingManager.cc.

  : fDirectionalSplittingTarget(0.0,0.0,0.0)
{
  fSafetyMin = 1.e-6*mm;
  theElectron = G4Electron::Electron();
  theGamma    = G4Gamma::Gamma();
}

References G4Electron::Electron(), fSafetyMin, G4Gamma::Gamma(), mm, theElectron, and theGamma.

◆ ~G4EmBiasingManager()

G4EmBiasingManager::~G4EmBiasingManager ( )

Definition at line 77 of file G4EmBiasingManager.cc.

78{}

◆ G4EmBiasingManager() [2/2]

G4EmBiasingManager::G4EmBiasingManager ( G4EmBiasingManager & )

delete

Member Function Documentation

◆ ActivateForcedInteraction()

void G4EmBiasingManager::ActivateForcedInteraction	(	G4double	length = `0.0`,
		const G4String &	r = `""`
	)

Definition at line 163 of file G4EmBiasingManager.cc.

{
  G4RegionStore* regionStore = G4RegionStore::GetInstance();
  G4String name = rname;
  if(name == "" || name == "world" || name == "World") {
    name = "DefaultRegionForTheWorld";
  }
  const G4Region* reg = regionStore->GetRegion(name, false);
  if(!reg) { 
    G4cout << "### G4EmBiasingManager::ForcedInteraction WARNING: "
           << " G4Region <"
           << rname << "> is unknown" << G4endl;
    return; 
  }
 
  // the region is in the list
  if (0 < nForcedRegions) {
    for (G4int i=0; i<nForcedRegions; ++i) {
      if (reg == forcedRegions[i]) {
        lengthForRegion[i] = val; 
        return;
      }
    }
  }
  if(val < 0.0) { 
    G4cout << "### G4EmBiasingManager::ForcedInteraction WARNING: "
           << val << " < 0.0, so no activation for the G4Region <"
           << rname << ">" << G4endl;
    return; 
  }
 
  // new region 
  forcedRegions.push_back(reg);
  lengthForRegion.push_back(val);
  ++nForcedRegions;
}

References forcedRegions, G4cout, G4endl, G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), lengthForRegion, G4InuclParticleNames::name(), nForcedRegions, and reg.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), and G4VEmProcess::ActivateForcedInteraction().

◆ ActivateSecondaryBiasing()

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

Definition at line 204 of file G4EmBiasingManager.cc.

{
  //G4cout << "G4EmBiasingManager::ActivateSecondaryBiasing: "
  //         << rname << " F= " << factor << " E(MeV)= " << energyLimit/MeV
  //         << G4endl; 
  G4RegionStore* regionStore = G4RegionStore::GetInstance();
  G4String name = rname;
  if(name == "" || name == "world" || name == "World") {
    name = "DefaultRegionForTheWorld";
  }
  const G4Region* reg = regionStore->GetRegion(name, false);
  if(!reg) { 
    G4cout << "### G4EmBiasingManager::ActivateBremsstrahlungSplitting "
           << "WARNING: G4Region <"
           << rname << "> is unknown" << G4endl;
    return; 
  }
 
  // Range cut
  G4int nsplit = 0;
  G4double w = factor;
 
  // splitting
  if(factor >= 1.0) {
    nsplit = G4lrint(factor);
    w = 1.0/G4double(nsplit);
 
    // Russian roulette 
  } else if(0.0 < factor) { 
    nsplit = 1;
    w = 1.0/factor;
  }
 
  // the region is in the list - overwrite parameters
  if (0 < nSecBiasedRegions) {
    for (G4int i=0; i<nSecBiasedRegions; ++i) {
      if (reg == secBiasedRegions[i]) {
        secBiasedWeight[i] = w;
        nBremSplitting[i]  = nsplit; 
        secBiasedEnegryLimit[i] = energyLimit;
        return;
      }
    }
  }
  /*
    G4cout << "### G4EmBiasingManager::ActivateSecondaryBiasing: "
           << " nsplit= " << nsplit << " for the G4Region <"
           << rname << ">" << G4endl; 
  */
 
  // new region 
  secBiasedRegions.push_back(reg);
  secBiasedWeight.push_back(w);
  nBremSplitting.push_back(nsplit);
  secBiasedEnegryLimit.push_back(energyLimit);
  ++nSecBiasedRegions;
  //G4cout << "nSecBiasedRegions= " << nSecBiasedRegions << G4endl;
}

References G4cout, G4endl, G4lrint(), G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), G4InuclParticleNames::name(), nBremSplitting, nSecBiasedRegions, reg, secBiasedEnegryLimit, secBiasedRegions, and secBiasedWeight.

Referenced by G4VEmProcess::ActivateSecondaryBiasing(), and G4VEnergyLossProcess::ActivateSecondaryBiasing().

◆ ApplyDirectionalSplitting() [1/2]

G4double G4EmBiasingManager::ApplyDirectionalSplitting	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4VEmModel *	currentModel,
		G4int	index,
		G4double	tcut
	)

private

Definition at line 643 of file G4EmBiasingManager.cc.

{
  // primary is not a gamma. Do nothing with primary
 
  G4double weight = 1.0;
  G4double w = secBiasedWeight[index];
 
  fDirectionalSplittingWeights.clear();
  if(1.0 <= w) {
    fDirectionalSplittingWeights.push_back(weight);
    return weight;
  }
 
  G4double trackWeight = track.GetWeight();
  G4int nsplit = nBremSplitting[index];
 
  // double splitting is suppressed
  if(1 < nsplit && trackWeight>w) {
 
    weight = w;
    const G4ThreeVector pos = track.GetPosition();
 
    tmpSecondaries = vd;
    vd.clear();
    vd.reserve(nsplit);
    for (G4int k=0; k<nsplit; ++k) {
      if (k>0) {
        tmpSecondaries.clear();
        currentModel->SampleSecondaries(&tmpSecondaries,
                                        track.GetMaterialCutsCouple(),
                                        track.GetDynamicParticle(), tcut);
      }
      //for (auto sec : tmpSecondaries) {
      for (size_t kk=0; kk < tmpSecondaries.size(); ++kk) {
        if (CheckDirection(pos, tmpSecondaries[kk]->GetMomentumDirection())) {
          vd.push_back(tmpSecondaries[kk]);
          fDirectionalSplittingWeights.push_back(1.);
        } else if (G4UniformRand()<w) {
          vd.push_back(tmpSecondaries[kk]);
          fDirectionalSplittingWeights.push_back(1./weight);
        } else {
          delete tmpSecondaries[kk];
          tmpSecondaries[kk] = nullptr;
        }
      }
    }  // end of loop over nsplit
  } else { // no splitting was done; still need weights
    for (size_t i = 0; i < vd.size(); ++i) {
      fDirectionalSplittingWeights.push_back(1.0);
    }
  }
  return weight;
}

References CheckDirection(), fDirectionalSplittingWeights, G4UniformRand, G4Track::GetDynamicParticle(), G4Track::GetMaterialCutsCouple(), G4Track::GetPosition(), G4Track::GetWeight(), nBremSplitting, pos, G4VEmModel::SampleSecondaries(), secBiasedWeight, and tmpSecondaries.

◆ ApplyDirectionalSplitting() [2/2]

G4double G4EmBiasingManager::ApplyDirectionalSplitting	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4VEmModel *	currentModel,
		G4int	index,
		G4double	tcut,
		G4ParticleChangeForGamma *	partChange
	)

private

Definition at line 514 of file G4EmBiasingManager.cc.

{
  // primary is gamma. do splitting/RR as appropriate
  // method applied for any number of secondaries
 
  G4double weight = 1.0;
  G4double w = secBiasedWeight[index];
 
  fDirectionalSplittingWeights.clear();
  if(1.0 <= w) {
    fDirectionalSplittingWeights.push_back(weight);
    return weight;
  }
 
  G4double trackWeight = track.GetWeight();
  G4int nsplit = nBremSplitting[index];
 
  // double splitting is suppressed
  if(1 < nsplit && trackWeight>w) {
 
    weight = w;
    const G4ThreeVector pos = track.GetPosition();
 
    G4bool foundPrimaryParticle = false;
    G4double primaryEnergy = 0.;
    G4ThreeVector primaryMomdir(0.,0.,0.);
    G4double primaryWeight = trackWeight;
 
    tmpSecondaries = vd;
    vd.clear();
    vd.reserve(nsplit);
    for (G4int k=0; k<nsplit; ++k) {
      if (k>0) {  // for k==0, SampleSecondaries has already been called
        tmpSecondaries.clear();
        // SampleSecondaries modifies primary info stored in partChange
        currentModel->SampleSecondaries(&tmpSecondaries,
                                        track.GetMaterialCutsCouple(),
                                        track.GetDynamicParticle(), tcut);
      }
      for (size_t kk=0; kk<tmpSecondaries.size(); ++kk) {
        if (tmpSecondaries[kk]->GetParticleDefinition() == theGamma) {
          if (CheckDirection(pos, tmpSecondaries[kk]->GetMomentumDirection())){
            vd.push_back(tmpSecondaries[kk]);
            fDirectionalSplittingWeights.push_back(1.);
          } else if (G4UniformRand() < w) {
            vd.push_back(tmpSecondaries[kk]);
            fDirectionalSplittingWeights.push_back(1./weight);
          } else {
            delete tmpSecondaries[kk];
            tmpSecondaries[kk] = nullptr;
          }
        } else if (k==0) { // keep charged 2ry from first splitting
          vd.push_back(tmpSecondaries[kk]);
          fDirectionalSplittingWeights.push_back(1./weight);
        } else {
          delete tmpSecondaries[kk];
          tmpSecondaries[kk] = nullptr;
        }
      }
 
      // primary
      G4double en = partChange->GetProposedKineticEnergy();
      if (en>0.) { // don't add if kinetic energy = 0
        G4ThreeVector momdir = partChange->GetProposedMomentumDirection();
        if (CheckDirection(pos,momdir)) {
          // keep only one primary; others are secondaries
          if (!foundPrimaryParticle) {
            primaryEnergy = en;
            primaryMomdir = momdir;
            foundPrimaryParticle = true;
            primaryWeight = weight;
          } else {
            G4DynamicParticle* dp = new G4DynamicParticle(theGamma,
                                    partChange->GetProposedMomentumDirection(),
                                    partChange->GetProposedKineticEnergy());
            vd.push_back(dp);
            fDirectionalSplittingWeights.push_back(1.);
          }
        } else if (G4UniformRand()<w) { // not going to target. play RR.
          if (!foundPrimaryParticle) {
            foundPrimaryParticle = true;
            primaryEnergy = en;
            primaryMomdir = momdir;
            primaryWeight = 1.;
          } else {
            G4DynamicParticle* dp = new G4DynamicParticle(theGamma,
                                    partChange->GetProposedMomentumDirection(),
                                    partChange->GetProposedKineticEnergy());
            vd.push_back(dp);
            fDirectionalSplittingWeights.push_back(1./weight);
          }
        }
      }
    }  // end of loop over nsplit
 
    partChange->ProposeWeight(primaryWeight);
    partChange->SetProposedKineticEnergy(primaryEnergy);
    partChange->ProposeMomentumDirection(primaryMomdir);
  } else {
    for (size_t i = 0; i < vd.size(); ++i) {
      fDirectionalSplittingWeights.push_back(1.);
    }
  }
 
  return weight;
}

References CheckDirection(), fDirectionalSplittingWeights, G4UniformRand, G4Track::GetDynamicParticle(), G4Track::GetMaterialCutsCouple(), G4Track::GetPosition(), G4ParticleChangeForGamma::GetProposedKineticEnergy(), G4ParticleChangeForGamma::GetProposedMomentumDirection(), G4Track::GetWeight(), nBremSplitting, pos, G4ParticleChangeForGamma::ProposeMomentumDirection(), G4VParticleChange::ProposeWeight(), G4VEmModel::SampleSecondaries(), secBiasedWeight, G4ParticleChangeForGamma::SetProposedKineticEnergy(), theGamma, and tmpSecondaries.

Referenced by ApplySecondaryBiasing().

◆ ApplyRangeCut()

void G4EmBiasingManager::ApplyRangeCut	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4double &	eloss,
		G4double	safety
	)

private

Definition at line 430 of file G4EmBiasingManager.cc.

{
  size_t n = vd.size();
  if(!eIonisation) { 
    eIonisation = 
      G4LossTableManager::Instance()->GetEnergyLossProcess(theElectron);
  }
  if(eIonisation) { 
    for(size_t k=0; k<n; ++k) {
      const G4DynamicParticle* dp = vd[k];
      if(dp->GetDefinition() == theElectron) {
        G4double e = dp->GetKineticEnergy();
        if(eIonisation->GetRange(e, track.GetMaterialCutsCouple()) < safety) {
          eloss += e;
          delete dp;
          vd[k] = 0;
        }
      }
    }
  }
}

References eIonisation, G4DynamicParticle::GetDefinition(), G4LossTableManager::GetEnergyLossProcess(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4VEnergyLossProcess::GetRange(), G4LossTableManager::Instance(), CLHEP::detail::n, and theElectron.

Referenced by ApplySecondaryBiasing().

◆ ApplyRussianRoulette()

G4double G4EmBiasingManager::ApplyRussianRoulette	(	std::vector< G4DynamicParticle * > &	vd,
		G4int	index
	)

inlineprivate

Definition at line 226 of file G4EmBiasingManager.hh.

{
  size_t n = vd.size();
  G4double weight = secBiasedWeight[index];
  for(size_t k=0; k<n; ++k) {
    if(G4UniformRand()*weight > 1.0) {
      const G4DynamicParticle* dp = vd[k];
      delete dp;
      vd[k] = nullptr;
    }
  }
  return weight;
}

References G4UniformRand, CLHEP::detail::n, and secBiasedWeight.

Referenced by ApplySecondaryBiasing().

◆ ApplySecondaryBiasing() [1/3]

G4double G4EmBiasingManager::ApplySecondaryBiasing	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4VEmModel *	currentModel,
		G4ParticleChangeForGamma *	pParticleChange,
		G4double &	eloss,
		G4int	coupleIdx,
		G4double	tcut,
		G4double	safety = `0.0`
	)

Definition at line 342 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    size_t n = vd.size();
 
    // the check cannot be applied per secondary particle
    // because weight correction is common, so the first
    // secondary is checked
    if((0 < n && vd[0]->GetKineticEnergy() < secBiasedEnegryLimit[index])
          || fDirectionalSplitting) {
 
      G4int nsplit = nBremSplitting[index];
 
      // Range cut
      if(0 == nsplit) { 
        if(safety > fSafetyMin) { ApplyRangeCut(vd, track, eloss, safety); }
 
        // Russian Roulette
      } else if(1 == nsplit) { 
        weight = ApplyRussianRoulette(vd, index);
 
        // Splitting
      } else {
        if (fDirectionalSplitting) {
          weight = ApplyDirectionalSplitting(vd, track, currentModel,
                                    index, tcut, pPartChange);
        } else {
          G4double tmpEnergy = pPartChange->GetProposedKineticEnergy();
          G4ThreeVector tmpMomDir = pPartChange->GetProposedMomentumDirection();
 
          weight = ApplySplitting(vd, track, currentModel, index, tcut);
 
          pPartChange->SetProposedKineticEnergy(tmpEnergy);
          pPartChange->ProposeMomentumDirection(tmpMomDir);
        }
      }
    }
  }
  return weight;
}

References ApplyDirectionalSplitting(), ApplyRangeCut(), ApplyRussianRoulette(), ApplySplitting(), fDirectionalSplitting, fSafetyMin, G4ParticleChangeForGamma::GetProposedKineticEnergy(), G4ParticleChangeForGamma::GetProposedMomentumDirection(), idxSecBiasedCouple, CLHEP::detail::n, nBremSplitting, G4ParticleChangeForGamma::ProposeMomentumDirection(), secBiasedEnegryLimit, and G4ParticleChangeForGamma::SetProposedKineticEnergy().

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

◆ ApplySecondaryBiasing() [2/3]

G4double G4EmBiasingManager::ApplySecondaryBiasing	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4VEmModel *	currentModel,
		G4ParticleChangeForLoss *	pParticleChange,
		G4double &	eloss,
		G4int	coupleIdx,
		G4double	tcut,
		G4double	safety = `0.0`
	)

Definition at line 289 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    size_t n = vd.size();
 
    // the check cannot be applied per secondary particle
    // because weight correction is common, so the first
    // secondary is checked
    if((0 < n && vd[0]->GetKineticEnergy() < secBiasedEnegryLimit[index])
          || fDirectionalSplitting) {
 
      G4int nsplit = nBremSplitting[index];
 
      // Range cut
      if(0 == nsplit) { 
        if(safety > fSafetyMin) { ApplyRangeCut(vd, track, eloss, safety); }
 
        // Russian Roulette
      } else if(1 == nsplit) { 
        weight = ApplyRussianRoulette(vd, index);
 
        // Splitting
      } else {
        if (fDirectionalSplitting) {
          weight = ApplyDirectionalSplitting(vd, track, currentModel, index, tcut);
        } else {
          G4double tmpEnergy = pPartChange->GetProposedKineticEnergy();
          G4ThreeVector tmpMomDir = pPartChange->GetProposedMomentumDirection();
 
          weight = ApplySplitting(vd, track, currentModel, index, tcut);
 
          pPartChange->SetProposedKineticEnergy(tmpEnergy);
          pPartChange->ProposeMomentumDirection(tmpMomDir);
        }
      }
    }
  }
  return weight;
}

References ApplyDirectionalSplitting(), ApplyRangeCut(), ApplyRussianRoulette(), ApplySplitting(), fDirectionalSplitting, fSafetyMin, G4ParticleChangeForLoss::GetProposedKineticEnergy(), G4ParticleChangeForLoss::GetProposedMomentumDirection(), idxSecBiasedCouple, CLHEP::detail::n, nBremSplitting, G4ParticleChangeForLoss::ProposeMomentumDirection(), secBiasedEnegryLimit, and G4ParticleChangeForLoss::SetProposedKineticEnergy().

◆ ApplySecondaryBiasing() [3/3]

G4double G4EmBiasingManager::ApplySecondaryBiasing	(	std::vector< G4Track * > &	track,
		G4int	coupleIdx
	)

Definition at line 396 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    size_t n = track.size();
 
    // the check cannot be applied per secondary particle
    // because weight correction is common, so the first
    // secondary is checked
    if(0 < n && track[0]->GetKineticEnergy() < secBiasedEnegryLimit[index]) {
 
      G4int nsplit = nBremSplitting[index];
 
        // Russian Roulette only
      if(1 == nsplit) { 
        weight = secBiasedWeight[index];
        for(size_t k=0; k<n; ++k) {
          if(G4UniformRand()*weight > 1.0) {
            const G4Track* t = track[k];
            delete t;
            track[k] = 0;
          }
        }
      }
    }
  }
  return weight;
}

References G4UniformRand, idxSecBiasedCouple, CLHEP::detail::n, nBremSplitting, secBiasedEnegryLimit, and secBiasedWeight.

◆ ApplySplitting()

G4double G4EmBiasingManager::ApplySplitting	(	std::vector< G4DynamicParticle * > &	vd,
		const G4Track &	track,
		G4VEmModel *	currentModel,
		G4int	index,
		G4double	tcut
	)

private

Definition at line 471 of file G4EmBiasingManager.cc.

{
  // method is applied only if 1 secondary created PostStep 
  // in the case of many secondaries there is a contradiction
  G4double weight = 1.;
  size_t n = vd.size();
  G4double w = secBiasedWeight[index];
 
  if(1 != n || 1.0 <= w) { return weight; }
 
  G4double trackWeight = track.GetWeight();
  const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
 
  G4int nsplit = nBremSplitting[index];
 
  // double splitting is suppressed 
  if(1 < nsplit && trackWeight>w) {
 
    weight = w;
    if(nsplit > (G4int)tmpSecondaries.size()) { 
      tmpSecondaries.reserve(nsplit);
    }
    const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
    // start from 1, because already one secondary created
    for(G4int k=1; k<nsplit; ++k) {
      tmpSecondaries.clear();
      currentModel->SampleSecondaries(&tmpSecondaries, couple, dynParticle, 
                                      tcut);
      for (size_t kk=0; kk<tmpSecondaries.size(); ++kk) {
        vd.push_back(tmpSecondaries[kk]);
      }
    }
  }
  return weight;
}

References G4Track::GetDynamicParticle(), G4Track::GetMaterialCutsCouple(), G4Track::GetWeight(), CLHEP::detail::n, nBremSplitting, G4VEmModel::SampleSecondaries(), secBiasedWeight, and tmpSecondaries.

Referenced by ApplySecondaryBiasing().

◆ CheckDirection()

G4bool G4EmBiasingManager::CheckDirection	(	G4ThreeVector	pos,
		G4ThreeVector	momdir
	)		const

Definition at line 456 of file G4EmBiasingManager.cc.

{
  G4ThreeVector delta = fDirectionalSplittingTarget - pos;
  G4double angle = momdir.angle(delta);
  G4double dist = delta.cross(momdir).mag();
  if (dist <= fDirectionalSplittingRadius && angle < halfpi) {
    return true;
  }
  return false;
}

References CLHEP::Hep3Vector::angle(), angle, CLHEP::Hep3Vector::cross(), fDirectionalSplittingRadius, fDirectionalSplittingTarget, halfpi, CLHEP::Hep3Vector::mag(), and pos.

Referenced by ApplyDirectionalSplitting().

◆ ForcedInteractionRegion()

G4bool G4EmBiasingManager::ForcedInteractionRegion ( G4int coupleIdx )

inline

Definition at line 209 of file G4EmBiasingManager.hh.

{
  G4bool res = false;
  if(nForcedRegions > 0) {
    if(idxForcedCouple[coupleIdx] >= 0) { res = true; }
  }
  return res;
}

References idxForcedCouple, and nForcedRegions.

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

◆ GetDirectionalSplitting()

G4bool G4EmBiasingManager::GetDirectionalSplitting ( )

inline

Definition at line 125 of file G4EmBiasingManager.hh.

125{ return fDirectionalSplitting; }

References fDirectionalSplitting.

◆ GetStepLimit()

G4double G4EmBiasingManager::GetStepLimit	(	G4int	coupleIdx,
		G4double	previousStep
	)

Definition at line 267 of file G4EmBiasingManager.cc.

{
  if(startTracking) {
    startTracking = false;
    G4int i = idxForcedCouple[coupleIdx];
    if(i < 0) {
      currentStepLimit = DBL_MAX;
    } else {
      currentStepLimit = lengthForRegion[i];
      if(currentStepLimit > 0.0) { currentStepLimit *= G4UniformRand(); }
    }
  } else {
    currentStepLimit -= previousStep;
  }
  if(currentStepLimit < 0.0) { currentStepLimit = 0.0; }
  return currentStepLimit;
}

References currentStepLimit, DBL_MAX, G4UniformRand, idxForcedCouple, lengthForRegion, and startTracking.

Referenced by G4VEmProcess::PostStepGetPhysicalInteractionLength(), and G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength().

◆ GetWeight()

G4double G4EmBiasingManager::GetWeight ( G4int i )

Definition at line 629 of file G4EmBiasingManager.cc.

{
  // normally return 1. If a directionally split particle survives RR,
  //  return 1./(splitting factor)
  if (fDirectionalSplittingWeights.size() >= (unsigned int)(i+1) ) {
    G4double w = fDirectionalSplittingWeights[i];
    fDirectionalSplittingWeights[i] = 1.; // ensure it's not used again
    return w;
  } else {
    return 1.;
  }
}

References fDirectionalSplittingWeights.

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

◆ Initialise()

void G4EmBiasingManager::Initialise	(	const G4ParticleDefinition &	part,
		const G4String &	procName,
		G4int	verbose
	)

Definition at line 82 of file G4EmBiasingManager.cc.

{
  //G4cout << "G4EmBiasingManager::Initialise for "
  //         << part.GetParticleName()
  //         << " and " << procName << G4endl;
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if(0 < nForcedRegions) { idxForcedCouple.resize(numOfCouples, -1); }
  if(0 < nSecBiasedRegions) { idxSecBiasedCouple.resize(numOfCouples, -1); }
 
  // Deexcitation
  for (size_t j=0; j<numOfCouples; ++j) {
    const G4MaterialCutsCouple* couple =
      theCoupleTable->GetMaterialCutsCouple(j);
    const G4ProductionCuts* pcuts = couple->GetProductionCuts();
    if(0 <  nForcedRegions) {
      for(G4int i=0; i<nForcedRegions; ++i) {
        if(forcedRegions[i]) {
          if(pcuts == forcedRegions[i]->GetProductionCuts()) { 
            idxForcedCouple[j] = i;
            break; 
          }
        }
      }
    }
    if(0 < nSecBiasedRegions) { 
      for(G4int i=0; i<nSecBiasedRegions; ++i) {
        if(secBiasedRegions[i]) {
          if(pcuts == secBiasedRegions[i]->GetProductionCuts()) { 
            idxSecBiasedCouple[j] = i;
            break; 
          }
        }
      }
    }
  }
 
  G4EmParameters* param = G4EmParameters::Instance();
  SetDirectionalSplitting(param->GetDirectionalSplitting());
  if (fDirectionalSplitting) {
    SetDirectionalSplittingTarget(param->GetDirectionalSplittingTarget());
    SetDirectionalSplittingRadius(param->GetDirectionalSplittingRadius());
  }
 
  if (nForcedRegions > 0 && 0 < verbose) {
    G4cout << " Forced Interaction is activated for "
           << part.GetParticleName() << " and " 
           << procName 
           << " inside G4Regions: " << G4endl;
    for (G4int i=0; i<nForcedRegions; ++i) {
      const G4Region* r = forcedRegions[i];
      if(r) { G4cout << "           " << r->GetName() << G4endl; }
    }
  }
  if (nSecBiasedRegions > 0 && 0 < verbose) {
    G4cout << " Secondary biasing is activated for " 
           << part.GetParticleName() << " and " 
           << procName 
           << " inside G4Regions: " << G4endl;
    for (G4int i=0; i<nSecBiasedRegions; ++i) {
      const G4Region* r = secBiasedRegions[i];
      if(r) { 
        G4cout << "           " << r->GetName() 
               << "  BiasingWeight= " << secBiasedWeight[i] << G4endl; 
      }
    }
    if (fDirectionalSplitting) {
      G4cout << "     Directional splitting activated, with target position: "
             << fDirectionalSplittingTarget/cm
             << " cm; radius: "
             << fDirectionalSplittingRadius/cm
             << "cm." << G4endl;
    }
  }
}

References cm, fDirectionalSplitting, fDirectionalSplittingRadius, fDirectionalSplittingTarget, forcedRegions, G4cout, G4endl, G4EmParameters::GetDirectionalSplitting(), G4EmParameters::GetDirectionalSplittingRadius(), G4EmParameters::GetDirectionalSplittingTarget(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Region::GetName(), G4ParticleDefinition::GetParticleName(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), idxForcedCouple, idxSecBiasedCouple, G4EmParameters::Instance(), nForcedRegions, nSecBiasedRegions, secBiasedRegions, secBiasedWeight, SetDirectionalSplitting(), SetDirectionalSplittingRadius(), and SetDirectionalSplittingTarget().

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

◆ operator=()

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

delete

◆ ResetForcedInteraction()

void G4EmBiasingManager::ResetForcedInteraction ( )

inline

Definition at line 218 of file G4EmBiasingManager.hh.

{
  startTracking = true;
}

References startTracking.

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

◆ SecondaryBiasingRegion()

G4bool G4EmBiasingManager::SecondaryBiasingRegion ( G4int coupleIdx )

inline

Definition at line 200 of file G4EmBiasingManager.hh.

{
  G4bool res = false;
  if(nSecBiasedRegions > 0) {
    if(idxSecBiasedCouple[coupleIdx] >= 0) { res = true; }
  }
  return res;
}

References idxSecBiasedCouple, and nSecBiasedRegions.

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

◆ SetDirectionalSplitting()

void G4EmBiasingManager::SetDirectionalSplitting ( G4bool v )

inline

Definition at line 126 of file G4EmBiasingManager.hh.

126{ fDirectionalSplitting = v; }

References fDirectionalSplitting.

Referenced by Initialise().

◆ SetDirectionalSplittingRadius()

void G4EmBiasingManager::SetDirectionalSplittingRadius ( G4double r )

inline

Definition at line 130 of file G4EmBiasingManager.hh.

131 { fDirectionalSplittingRadius = r; }

References fDirectionalSplittingRadius.

Referenced by Initialise().

◆ SetDirectionalSplittingTarget()

void G4EmBiasingManager::SetDirectionalSplittingTarget ( G4ThreeVector v )

inline

Definition at line 128 of file G4EmBiasingManager.hh.

129 { fDirectionalSplittingTarget = v; }

References fDirectionalSplittingTarget.

Referenced by Initialise().

Field Documentation

◆ currentStepLimit

G4double G4EmBiasingManager::currentStepLimit = 0.0

private

Definition at line 173 of file G4EmBiasingManager.hh.

Referenced by GetStepLimit().

◆ eIonisation

G4VEnergyLossProcess* G4EmBiasingManager::eIonisation = nullptr

private

Definition at line 167 of file G4EmBiasingManager.hh.

Referenced by ApplyRangeCut().

◆ fDirectionalSplitting

G4bool G4EmBiasingManager::fDirectionalSplitting = false

private

Definition at line 180 of file G4EmBiasingManager.hh.

Referenced by ApplySecondaryBiasing(), GetDirectionalSplitting(), Initialise(), and SetDirectionalSplitting().

◆ fDirectionalSplittingRadius

G4double G4EmBiasingManager::fDirectionalSplittingRadius = 0.0

private

Definition at line 174 of file G4EmBiasingManager.hh.

Referenced by CheckDirection(), Initialise(), and SetDirectionalSplittingRadius().

◆ fDirectionalSplittingTarget

G4ThreeVector G4EmBiasingManager::fDirectionalSplittingTarget

private

Definition at line 182 of file G4EmBiasingManager.hh.

Referenced by CheckDirection(), Initialise(), and SetDirectionalSplittingTarget().

◆ fDirectionalSplittingWeights

std::vector<G4double> G4EmBiasingManager::fDirectionalSplittingWeights

private

Definition at line 183 of file G4EmBiasingManager.hh.

Referenced by ApplyDirectionalSplitting(), and GetWeight().

◆ forcedRegions

std::vector<const G4Region*> G4EmBiasingManager::forcedRegions

private

Definition at line 189 of file G4EmBiasingManager.hh.

Referenced by ActivateForcedInteraction(), and Initialise().

◆ fSafetyMin

G4double G4EmBiasingManager::fSafetyMin

private

Definition at line 172 of file G4EmBiasingManager.hh.

Referenced by ApplySecondaryBiasing(), and G4EmBiasingManager().

◆ idxForcedCouple

std::vector<G4int> G4EmBiasingManager::idxForcedCouple

private

Definition at line 193 of file G4EmBiasingManager.hh.

Referenced by ForcedInteractionRegion(), GetStepLimit(), and Initialise().

◆ idxSecBiasedCouple

std::vector<G4int> G4EmBiasingManager::idxSecBiasedCouple

private

Definition at line 194 of file G4EmBiasingManager.hh.

Referenced by ApplySecondaryBiasing(), Initialise(), and SecondaryBiasingRegion().

◆ lengthForRegion

std::vector<G4double> G4EmBiasingManager::lengthForRegion

private

Definition at line 185 of file G4EmBiasingManager.hh.

Referenced by ActivateForcedInteraction(), and GetStepLimit().

◆ nBremSplitting

std::vector<G4int> G4EmBiasingManager::nBremSplitting

private

Definition at line 192 of file G4EmBiasingManager.hh.

Referenced by ActivateSecondaryBiasing(), ApplyDirectionalSplitting(), ApplySecondaryBiasing(), and ApplySplitting().

◆ nForcedRegions

G4int G4EmBiasingManager::nForcedRegions = 0

private

Definition at line 176 of file G4EmBiasingManager.hh.

Referenced by ActivateForcedInteraction(), ForcedInteractionRegion(), and Initialise().

◆ nSecBiasedRegions

G4int G4EmBiasingManager::nSecBiasedRegions = 0

private

Definition at line 177 of file G4EmBiasingManager.hh.

Referenced by ActivateSecondaryBiasing(), Initialise(), and SecondaryBiasingRegion().

◆ secBiasedEnegryLimit

std::vector<G4double> G4EmBiasingManager::secBiasedEnegryLimit

private

Definition at line 187 of file G4EmBiasingManager.hh.

Referenced by ActivateSecondaryBiasing(), and ApplySecondaryBiasing().

◆ secBiasedRegions

std::vector<const G4Region*> G4EmBiasingManager::secBiasedRegions

private

Definition at line 190 of file G4EmBiasingManager.hh.

Referenced by ActivateSecondaryBiasing(), and Initialise().

◆ secBiasedWeight

std::vector<G4double> G4EmBiasingManager::secBiasedWeight

private

Definition at line 186 of file G4EmBiasingManager.hh.

Referenced by ActivateSecondaryBiasing(), ApplyDirectionalSplitting(), ApplyRussianRoulette(), ApplySecondaryBiasing(), ApplySplitting(), and Initialise().

◆ startTracking

G4bool G4EmBiasingManager::startTracking = true

private

Definition at line 179 of file G4EmBiasingManager.hh.

Referenced by GetStepLimit(), and ResetForcedInteraction().

◆ theElectron

const G4ParticleDefinition* G4EmBiasingManager::theElectron

private

Definition at line 169 of file G4EmBiasingManager.hh.

Referenced by ApplyRangeCut(), and G4EmBiasingManager().

◆ theGamma

const G4ParticleDefinition* G4EmBiasingManager::theGamma

private

Definition at line 170 of file G4EmBiasingManager.hh.

Referenced by ApplyDirectionalSplitting(), and G4EmBiasingManager().

◆ tmpSecondaries

std::vector<G4DynamicParticle*> G4EmBiasingManager::tmpSecondaries

private

Definition at line 196 of file G4EmBiasingManager.hh.

Referenced by ApplyDirectionalSplitting(), and ApplySplitting().

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

source/processes/electromagnetic/utils/include/G4EmBiasingManager.hh
source/processes/electromagnetic/utils/src/G4EmBiasingManager.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4EmBiasingManager() [1/2]

◆ ~G4EmBiasingManager()

◆ G4EmBiasingManager() [2/2]

Member Function Documentation

◆ ActivateForcedInteraction()

◆ ActivateSecondaryBiasing()

◆ ApplyDirectionalSplitting() [1/2]

◆ ApplyDirectionalSplitting() [2/2]

◆ ApplyRangeCut()

◆ ApplyRussianRoulette()

◆ ApplySecondaryBiasing() [1/3]

◆ ApplySecondaryBiasing() [2/3]

◆ ApplySecondaryBiasing() [3/3]

◆ ApplySplitting()

◆ CheckDirection()

◆ ForcedInteractionRegion()

◆ GetDirectionalSplitting()

◆ GetStepLimit()

◆ GetWeight()

◆ Initialise()

◆ operator=()

◆ ResetForcedInteraction()

◆ SecondaryBiasingRegion()

◆ SetDirectionalSplitting()

◆ SetDirectionalSplittingRadius()

◆ SetDirectionalSplittingTarget()

Field Documentation

◆ currentStepLimit

◆ eIonisation

◆ fDirectionalSplitting

◆ fDirectionalSplittingRadius

◆ fDirectionalSplittingTarget

◆ fDirectionalSplittingWeights

◆ forcedRegions

◆ fSafetyMin

◆ idxForcedCouple

◆ idxSecBiasedCouple

◆ lengthForRegion

◆ nBremSplitting

◆ nForcedRegions

◆ nSecBiasedRegions

◆ secBiasedEnegryLimit

◆ secBiasedRegions

◆ secBiasedWeight

◆ startTracking

◆ theElectron

◆ theGamma

◆ tmpSecondaries