G4EmBiasingManager.hh

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class header file
//
//
// File name:     G4EmBiasingManager
//
// Author:        Vladimir Ivanchenko
//
// Creation date: 28.07.2011
//
// Modifications:
//
// Class Description:
//
// It is a class providing step limit for forced process biasing
 
// -------------------------------------------------------------------
//
 
#ifndef G4EmBiasingManager_h
#define G4EmBiasingManager_h 1
 
#include "globals.hh"
#include "G4ParticleDefinition.hh"
#include "G4DynamicParticle.hh"
#include "Randomize.hh"
#include <vector>
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
class G4Region;
class G4Track;
class G4VEnergyLossProcess;
class G4VEmModel;
class G4MaterialCutsCouple;
class G4ParticleChangeForLoss;
class G4ParticleChangeForGamma;
 
class G4EmBiasingManager 
{
public:
 
  G4EmBiasingManager();
 
  ~G4EmBiasingManager();
 
  void Initialise(const G4ParticleDefinition& part,
          const G4String& procName, G4int verbose);
 
  // default parameters are possible
  void ActivateForcedInteraction(G4double length = 0.0, 
                 const G4String& r = "");
 
  // no default parameters
  void ActivateSecondaryBiasing(const G4String& region, G4double factor,
                G4double energyLimit);
 
  // return forced step limit
  G4double GetStepLimit(G4int coupleIdx, G4double previousStep);
 
  // return weight of splitting or Russian roulette
  // G4DynamicParticle may be deleted
  // two functions are required because of the different ParticleChange
  // ApplySecondaryBiasing() are wrappers
 
  // for G4VEmProcess 
  G4double ApplySecondaryBiasing(std::vector<G4DynamicParticle*>&, 
                 const G4Track& track,
                 G4VEmModel* currentModel,
                 G4ParticleChangeForGamma* pParticleChange,
                 G4double& eloss,
                 G4int coupleIdx,
                 G4double tcut,
                 G4double safety = 0.0);
 
  // for G4VEnergyLossProcess 
  G4double ApplySecondaryBiasing(std::vector<G4DynamicParticle*>&,
                 const G4Track& track,
                 G4VEmModel* currentModel,
                 G4ParticleChangeForLoss* pParticleChange,
                 G4double& eloss, 
             G4int coupleIdx,  
                 G4double tcut, 
                 G4double safety = 0.0);
 
  // for G4VEnergyLossProcess 
  G4double ApplySecondaryBiasing(std::vector<G4Track*>&,
                 G4int coupleIdx);
 
  inline G4bool SecondaryBiasingRegion(G4int coupleIdx);
 
  inline G4bool ForcedInteractionRegion(G4int coupleIdx);
 
  inline void ResetForcedInteraction();
 
  G4bool CheckDirection(G4ThreeVector pos, G4ThreeVector momdir) const;
 
  G4bool  GetDirectionalSplitting() { return fDirectionalSplitting; }
  void    SetDirectionalSplitting(G4bool v) { fDirectionalSplitting = v; }
 
  void SetDirectionalSplittingTarget(G4ThreeVector v) 
    { fDirectionalSplittingTarget = v; }
  void SetDirectionalSplittingRadius(G4double r) 
    { fDirectionalSplittingRadius = r; }
  G4double GetWeight(G4int i);
 
  // hide copy constructor and assignment operator
  G4EmBiasingManager(G4EmBiasingManager &) = delete;
  G4EmBiasingManager & operator=(const G4EmBiasingManager &right) = delete;
 
private:
 
  void ApplyRangeCut(std::vector<G4DynamicParticle*>& vd,
             const G4Track& track,
             G4double& eloss, 
             G4double safety);
 
  G4double ApplySplitting(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);
 
  G4double ApplyDirectionalSplitting(std::vector<G4DynamicParticle*>& vd,
        const G4Track& track,
        G4VEmModel* currentModel, 
        G4int index,
        G4double tcut);
 
  inline G4double ApplyRussianRoulette(std::vector<G4DynamicParticle*>& vd,
                       G4int index); 
 
  G4VEnergyLossProcess* eIonisation = nullptr;
 
  const G4ParticleDefinition* theElectron;
  const G4ParticleDefinition* theGamma;
 
  G4double fSafetyMin;
  G4double currentStepLimit = 0.0;
  G4double fDirectionalSplittingRadius = 0.0;
 
  G4int nForcedRegions = 0;
  G4int nSecBiasedRegions = 0;
 
  G4bool startTracking = true;
  G4bool fDirectionalSplitting = false;
 
  G4ThreeVector fDirectionalSplittingTarget;
  std::vector<G4double> fDirectionalSplittingWeights;
 
  std::vector<G4double>        lengthForRegion;
  std::vector<G4double>        secBiasedWeight;
  std::vector<G4double>        secBiasedEnegryLimit;
 
  std::vector<const G4Region*> forcedRegions;
  std::vector<const G4Region*> secBiasedRegions;
 
  std::vector<G4int>           nBremSplitting;
  std::vector<G4int>           idxForcedCouple;
  std::vector<G4int>           idxSecBiasedCouple;
 
  std::vector<G4DynamicParticle*> tmpSecondaries;
};
 
inline G4bool 
G4EmBiasingManager::SecondaryBiasingRegion(G4int coupleIdx)
{
  G4bool res = false;
  if(nSecBiasedRegions > 0) {
    if(idxSecBiasedCouple[coupleIdx] >= 0) { res = true; }
  }
  return res;
}
 
inline G4bool G4EmBiasingManager::ForcedInteractionRegion(G4int coupleIdx)
{
  G4bool res = false;
  if(nForcedRegions > 0) {
    if(idxForcedCouple[coupleIdx] >= 0) { res = true; }
  }
  return res;
}
 
inline void G4EmBiasingManager::ResetForcedInteraction()
{
  startTracking = true;
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
inline G4double
G4EmBiasingManager::ApplyRussianRoulette(std::vector<G4DynamicParticle*>& vd,
                     G4int index)
{
  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;
}
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 
#endif