G4EmBiasingManager Class Reference

#include <G4EmBiasingManager.hh>

Public Member Functions
	G4EmBiasingManager ()
	~G4EmBiasingManager ()
void	Initialise (const G4ParticleDefinition &part, const G4String &procName, G4int verbose)
void	ActivateForcedInteraction (G4double length=0.0, const G4String &r="")
void	ActivateSecondaryBiasing (const G4String &region, G4double factor, G4double energyLimit)
G4double	GetStepLimit (G4int coupleIdx, G4double previousStep)
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	SecondaryBiasingRegion (G4int coupleIdx)
G4bool	ForcedInteractionRegion (G4int coupleIdx)
void	ResetForcedInteraction ()
G4bool	CheckDirection (G4ThreeVector pos, G4ThreeVector momdir) const
G4bool	GetDirectionalSplitting ()
void	SetDirectionalSplitting (G4bool v)
void	SetDirectionalSplittingTarget (G4ThreeVector v)
void	SetDirectionalSplittingRadius (G4double r)
G4double	GetWeight (G4int i)
	G4EmBiasingManager (G4EmBiasingManager &)=delete
G4EmBiasingManager &	operator= (const G4EmBiasingManager &right)=delete

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();
}

~G4EmBiasingManager()

G4EmBiasingManager::~G4EmBiasingManager ( )

default

G4EmBiasingManager() [2/2]

G4EmBiasingManager::G4EmBiasingManager ( G4EmBiasingManager &  )

delete

Member Function Documentation

ActivateForcedInteraction()

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

Definition at line 162 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;
}

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

ActivateSecondaryBiasing()

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

Definition at line 203 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;
}

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

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 341 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    std::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;
}

Referenced by G4eplusAnnihilation::AtRestDoIt(), 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 288 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    std::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;
}

ApplySecondaryBiasing() [3/3]

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

Definition at line 395 of file G4EmBiasingManager.cc.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.;
  if(0 <= index) {
    std::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(std::size_t k=0; k<n; ++k) {
          if(G4UniformRand()*weight > 1.0) {
            const G4Track* t = track[k];
            delete t;
            track[k] = nullptr;
          }
        }
      }
    }
  }
  return weight;
}

CheckDirection()

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

Definition at line 455 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;
}

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;
}

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

GetDirectionalSplitting()

G4bool G4EmBiasingManager::GetDirectionalSplitting ( )

inline

Definition at line 125 of file G4EmBiasingManager.hh.

{ return fDirectionalSplitting; }

GetStepLimit()

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

Definition at line 266 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;
}

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

GetWeight()

G4double G4EmBiasingManager::GetWeight

(

G4int

i

)

Definition at line 628 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.;
  }
}

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

Initialise()

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

Definition at line 81 of file G4EmBiasingManager.cc.

{
  //G4cout << "G4EmBiasingManager::Initialise for "
  //         << part.GetParticleName()
  //         << " and " << procName << G4endl;
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = (G4int)theCoupleTable->GetTableSize();
 
  if(0 < nForcedRegions) { idxForcedCouple.resize(numOfCouples, -1); }
  if(0 < nSecBiasedRegions) { idxSecBiasedCouple.resize(numOfCouples, -1); }
 
  // Deexcitation
  for (G4int 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;
    }
  }
}

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;
}

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;
}

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

SetDirectionalSplitting()

void G4EmBiasingManager::SetDirectionalSplitting ( G4bool  v )

inline

Definition at line 126 of file G4EmBiasingManager.hh.

{ fDirectionalSplitting = v; }

Referenced by Initialise().

SetDirectionalSplittingRadius()

void G4EmBiasingManager::SetDirectionalSplittingRadius ( G4double  r )

inline

Definition at line 130 of file G4EmBiasingManager.hh.

    { fDirectionalSplittingRadius = r; }

Referenced by Initialise().

SetDirectionalSplittingTarget()

void G4EmBiasingManager::SetDirectionalSplittingTarget ( G4ThreeVector  v )

inline

Definition at line 128 of file G4EmBiasingManager.hh.

    { fDirectionalSplittingTarget = v; }

Referenced by Initialise().

---

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

• G4EmBiasingManager.hh
• G4EmBiasingManager.cc