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

Detailed Description

Definition at line 67 of file G4EmBiasingManager.hh.

Constructor & Destructor Documentation

G4EmBiasingManager::G4EmBiasingManager

(

)

Definition at line 65 of file G4EmBiasingManager.cc.

References G4Electron::Electron(), and python.hepunit::mm.

  : nForcedRegions(0),nSecBiasedRegions(0),eIonisation(0),
    currentStepLimit(0.0),startTracking(true)
{
  fSafetyMin = 1.e-6*mm;
  theElectron = G4Electron::Electron();
}

G4EmBiasingManager::~G4EmBiasingManager

(

)

Definition at line 75 of file G4EmBiasingManager.cc.

{}

Member Function Documentation

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

Definition at line 146 of file G4EmBiasingManager.cc.

References G4cout, G4endl, G4RegionStore::GetInstance(), and G4RegionStore::GetRegion().

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

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

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

Definition at line 187 of file G4EmBiasingManager.cc.

References G4cout, G4endl, G4lrint(), G4RegionStore::GetInstance(), and G4RegionStore::GetRegion().

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

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

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

References G4ParticleChangeForGamma::GetProposedKineticEnergy(), G4ParticleChangeForGamma::GetProposedMomentumDirection(), n, G4ParticleChangeForGamma::ProposeMomentumDirection(), and G4ParticleChangeForGamma::SetProposedKineticEnergy().

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

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.0;
  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]) {

      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 {
    G4double tmpEnergy = pPartChange->GetProposedKineticEnergy();
    G4ThreeVector tmpMomDir = pPartChange->GetProposedMomentumDirection();

    weight = ApplySplitting(vd, track, currentModel, index, tcut);

    pPartChange->SetProposedKineticEnergy(tmpEnergy);
    pPartChange->ProposeMomentumDirection(tmpMomDir);
      }
    }
  }
  return weight;
}

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

References G4ParticleChangeForLoss::GetProposedKineticEnergy(), G4ParticleChangeForLoss::GetProposedMomentumDirection(), n, G4ParticleChangeForLoss::ProposeMomentumDirection(), and G4ParticleChangeForLoss::SetProposedKineticEnergy().

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.0;
  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]) {

      G4int nsplit = nBremSplitting[index];

      // Range cut
      if(0 == nsplit) { 
    if(safety > fSafetyMin) { ApplyRangeCut(vd, track, eloss, safety); }

    // Russian Roulette
      } if(1 == nsplit) { 
    weight = ApplyRussianRoulette(vd, index);

    // Splitting
      } else {
    G4double tmpEnergy = pPartChange->GetProposedKineticEnergy();
    G4ThreeVector tmpMomDir = pPartChange->GetProposedMomentumDirection();

    weight = ApplySplitting(vd, track, currentModel, index, tcut);

    pPartChange->SetProposedKineticEnergy(tmpEnergy);
    pPartChange->ProposeMomentumDirection(tmpMomDir);
      }
    }
  }
  return weight;
}

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

Definition at line 368 of file G4EmBiasingManager.cc.

References G4UniformRand, and n.

{
  G4int index = idxSecBiasedCouple[coupleIdx];
  G4double weight = 1.0;
  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;
}

G4bool G4EmBiasingManager::ForcedInteractionRegion ( G4int  coupleIdx )

inline

Definition at line 177 of file G4EmBiasingManager.hh.

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

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

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

Definition at line 250 of file G4EmBiasingManager.cc.

References DBL_MAX, and G4UniformRand.

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

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

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

Definition at line 80 of file G4EmBiasingManager.cc.

References G4cout, G4endl, G4ProductionCutsTable::GetMaterialCutsCouple(), G4Region::GetName(), G4ParticleDefinition::GetParticleName(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), and G4ProductionCutsTable::GetTableSize().

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

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

void G4EmBiasingManager::ResetForcedInteraction ( )

inline

Definition at line 186 of file G4EmBiasingManager.hh.

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

{
  startTracking = true;
}

G4bool G4EmBiasingManager::SecondaryBiasingRegion ( G4int  coupleIdx )

inline

Definition at line 168 of file G4EmBiasingManager.hh.

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

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

---

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

• G4EmBiasingManager.hh
• G4EmBiasingManager.cc