G4GenericBiasingPhysics Class Reference

#include <G4GenericBiasingPhysics.hh>

Inheritance diagram for G4GenericBiasingPhysics:

Public Member Functions
	G4GenericBiasingPhysics (const G4String &name="BiasingP")
virtual	~G4GenericBiasingPhysics ()
void	PhysicsBias (const G4String &particleName)
void	PhysicsBias (const G4String &particleName, const std::vector< G4String > &processToBiasNames)
void	NonPhysicsBias (const G4String &particleName)
void	Bias (const G4String &particleName)
void	Bias (const G4String &particleName, const std::vector< G4String > &processToBiasNames)
void	PhysicsBiasAddPDGRange (G4int PDGlow, G4int PDGhigh, G4bool includeAntiParticle=true)
void	NonPhysicsBiasAddPDGRange (G4int PDGlow, G4int PDGhigh, G4bool includeAntiParticle=true)
void	BiasAddPDGRange (G4int PDGlow, G4int PDGhigh, G4bool includeAntiParticle=true)
void	PhysicsBiasAllCharged (G4bool includeShortLived=false)
void	NonPhysicsBiasAllCharged (G4bool includeShortLived=false)
void	BiasAllCharged (G4bool includeShortLived=false)
void	PhysicsBiasAllNeutral (G4bool includeShortLived=false)
void	NonPhysicsBiasAllNeutral (G4bool includeShortLived=false)
void	BiasAllNeutral (G4bool includeShortLived=false)
void	AddParallelGeometry (const G4String &particleName, const G4String &parallelGeometryName)
void	AddParallelGeometry (const G4String &particleName, const std::vector< G4String > &parallelGeometryNames)
void	AddParallelGeometry (G4int PDGlow, G4int PDGhigh, const G4String &parallelGeometryName, G4bool includeAntiParticle=true)
void	AddParallelGeometry (G4int PDGlow, G4int PDGhigh, const std::vector< G4String > &parallelGeometryNames, G4bool includeAntiParticle=true)
void	AddParallelGeometryAllCharged (const G4String &parallelGeometryName, G4bool includeShortLived=false)
void	AddParallelGeometryAllCharged (const std::vector< G4String > &parallelGeometryNames, G4bool includeShortLived=false)
void	AddParallelGeometryAllNeutral (const G4String &parallelGeometryName, G4bool includeShortLived=false)
void	AddParallelGeometryAllNeutral (const std::vector< G4String > &parallelGeometryNames, G4bool includeShortLived=false)
void	BeVerbose ()
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
Public Member Functions inherited from G4VPhysicsConstructor
	G4VPhysicsConstructor (const G4String &="")
	G4VPhysicsConstructor (const G4String &name, G4int physics_type)
virtual	~G4VPhysicsConstructor ()
void	SetPhysicsName (const G4String &="")
const G4String &	GetPhysicsName () const
void	SetPhysicsType (G4int)
G4int	GetPhysicsType () const
G4int	GetInstanceID () const
virtual void	TerminateWorker ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager &	GetSubInstanceManager ()
Protected Types inherited from G4VPhysicsConstructor
using	PhysicsBuilder_V = G4VPCData::PhysicsBuilders_V
Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const
PhysicsBuilder_V	GetBuilders () const
void	AddBuilder (G4PhysicsBuilderInterface *bld)
Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel = 0
G4String	namePhysics = ""
G4int	typePhysics = 0
G4ParticleTable *	theParticleTable = nullptr
G4int	g4vpcInstanceID = 0
Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager	subInstanceManager

Detailed Description

Definition at line 41 of file G4GenericBiasingPhysics.hh.

Constructor & Destructor Documentation

G4GenericBiasingPhysics()

G4GenericBiasingPhysics::G4GenericBiasingPhysics

(

const G4String &

name = "BiasingP"

)

Definition at line 59 of file G4GenericBiasingPhysics.cc.

:  G4VPhysicsConstructor(name),
  fPhysBiasAllCharged(false),    fNonPhysBiasAllCharged(false),
  fPhysBiasAllChargedISL(false), fNonPhysBiasAllChargedISL(false),
  fPhysBiasAllNeutral(false),    fNonPhysBiasAllNeutral(false),
  fPhysBiasAllNeutralISL(false), fNonPhysBiasAllNeutralISL(false),
  fVerbose(false)
{;}

~G4GenericBiasingPhysics()

G4GenericBiasingPhysics::~G4GenericBiasingPhysics ( )

virtual

Definition at line 70 of file G4GenericBiasingPhysics.cc.

{;}

Member Function Documentation

AddParallelGeometry() [1/4]

void G4GenericBiasingPhysics::AddParallelGeometry	(	const G4String &	particleName,
		const G4String &	parallelGeometryName )

Definition at line 186 of file G4GenericBiasingPhysics.cc.

{
  // -- add particle, caring of possible duplication:
  G4bool isKnown = false;
  for ( G4String knownParticle : fParticlesWithParallelGeometries )
    {
      if ( knownParticle == particleName )
    {
      isKnown = true;
      break;
    }
    }
 
  // -- add the geometry, caring for possible duplication of this geometry, for this particle:
  if ( !isKnown ) fParticlesWithParallelGeometries.push_back( particleName );
  std::vector< G4String >& geometries = fParallelGeometriesForParticle[particleName];
 
  isKnown = false;
  for ( G4String knownGeometry : geometries )
    {
      if ( knownGeometry == parallelGeometryName )
    {
      isKnown = true;
      break;
    }
    }
  if ( !isKnown ) geometries.push_back( parallelGeometryName );
  
}

Referenced by AddParallelGeometry(), and AddParallelGeometry().

AddParallelGeometry() [2/4]

void G4GenericBiasingPhysics::AddParallelGeometry	(	const G4String &	particleName,
		const std::vector< G4String > &	parallelGeometryNames )

Definition at line 216 of file G4GenericBiasingPhysics.cc.

{
  for ( G4String geometry : parallelGeometryNames ) AddParallelGeometry( particleName, geometry );
}

AddParallelGeometry() [3/4]

void G4GenericBiasingPhysics::AddParallelGeometry	(	G4int	PDGlow,
		G4int	PDGhigh,
		const G4String &	parallelGeometryName,
		G4bool	includeAntiParticle = true )

Definition at line 221 of file G4GenericBiasingPhysics.cc.

{
  if ( PDGlow > PDGhigh )
    {
      G4cout << "G4GenericBiasingPhysics::AddParallelGeometry( G4int PDGlow, G4int PDGhigh, const G4String& parallelGeometryName , G4bool includeAntiParticle = true ), PDGlow > PDGhigh : call ignored" << G4endl;
      return;
    }
  
  fPDGlowParallelGeometries .push_back( PDGlow );
  fPDGhighParallelGeometries.push_back( PDGhigh );
  G4int rangeIndex = G4int(fPDGlowParallelGeometries.size() - 1);
  fPDGrangeParallelGeometries[rangeIndex].push_back( parallelGeometryName );
 
  if ( includeAntiParticle )
    {
      fPDGlowParallelGeometries .push_back( -PDGhigh );
      fPDGhighParallelGeometries.push_back( -PDGlow  );
      rangeIndex = G4int(fPDGlowParallelGeometries.size() - 1);
      fPDGrangeParallelGeometries[rangeIndex].push_back( parallelGeometryName );
    }
  
}

AddParallelGeometry() [4/4]

void G4GenericBiasingPhysics::AddParallelGeometry	(	G4int	PDGlow,
		G4int	PDGhigh,
		const std::vector< G4String > &	parallelGeometryNames,
		G4bool	includeAntiParticle = true )

Definition at line 244 of file G4GenericBiasingPhysics.cc.

{
  if ( PDGlow > PDGhigh )
    {
      G4cout << "G4GenericBiasingPhysics::AddParallelGeometry( G4int PDGlow, G4int PDGhigh, const std::vector< G4String >& parallelGeometryNames, G4bool includeAntiParticle = true ), PDGlow > PDGhigh : call ignored" << G4endl;
      return;
    }
  
  for ( G4String geometry : parallelGeometryNames ) AddParallelGeometry( PDGlow, PDGhigh, geometry, includeAntiParticle );
}

AddParallelGeometryAllCharged() [1/2]

void G4GenericBiasingPhysics::AddParallelGeometryAllCharged	(	const G4String &	parallelGeometryName,
		G4bool	includeShortLived = false )

Definition at line 255 of file G4GenericBiasingPhysics.cc.

{
  G4bool isKnown = false;
  for ( G4String geometry : fParallelGeometriesForCharged )
    {
      if ( geometry == parallelGeometryName )
    {
      isKnown = true;
      break;
    }
    }
  if ( !isKnown )
    {
      fParallelGeometriesForCharged   .push_back( parallelGeometryName );
      fAllChargedParallelGeometriesISL.push_back( includeShortLived );
    }
}

Referenced by AddParallelGeometryAllCharged().

AddParallelGeometryAllCharged() [2/2]

void G4GenericBiasingPhysics::AddParallelGeometryAllCharged	(	const std::vector< G4String > &	parallelGeometryNames,
		G4bool	includeShortLived = false )

Definition at line 273 of file G4GenericBiasingPhysics.cc.

{
  for ( G4String geometry : parallelGeometryNames ) AddParallelGeometryAllCharged( geometry, includeShortLived );
}

AddParallelGeometryAllNeutral() [1/2]

void G4GenericBiasingPhysics::AddParallelGeometryAllNeutral	(	const G4String &	parallelGeometryName,
		G4bool	includeShortLived = false )

Definition at line 278 of file G4GenericBiasingPhysics.cc.

{
  G4bool isKnown = false;
  for ( G4String geometry : fParallelGeometriesForNeutral )
    {
      if ( geometry == parallelGeometryName )
    {
      isKnown = true;
      break;
    }
    }
  if ( !isKnown )
    {
      fParallelGeometriesForNeutral   .push_back( parallelGeometryName );
      fAllNeutralParallelGeometriesISL.push_back( includeShortLived );
    } 
}

Referenced by AddParallelGeometryAllNeutral().

AddParallelGeometryAllNeutral() [2/2]

void G4GenericBiasingPhysics::AddParallelGeometryAllNeutral	(	const std::vector< G4String > &	parallelGeometryNames,
		G4bool	includeShortLived = false )

Definition at line 296 of file G4GenericBiasingPhysics.cc.

{
  for ( G4String geometry : parallelGeometryNames ) AddParallelGeometryAllNeutral( geometry, includeShortLived ); 
}

BeVerbose()

void G4GenericBiasingPhysics::BeVerbose ( )

inline

Definition at line 106 of file G4GenericBiasingPhysics.hh.

{ fVerbose = true; }

Bias() [1/2]

void G4GenericBiasingPhysics::Bias

(

const G4String &

particleName

)

Definition at line 101 of file G4GenericBiasingPhysics.cc.

{
  PhysicsBias(particleName);
  NonPhysicsBias(particleName);
}

Bias() [2/2]

void G4GenericBiasingPhysics::Bias	(	const G4String &	particleName,
		const std::vector< G4String > &	processToBiasNames )

Definition at line 109 of file G4GenericBiasingPhysics.cc.

{
  PhysicsBias(particleName, processNames);
  NonPhysicsBias(particleName);
}

BiasAddPDGRange()

void G4GenericBiasingPhysics::BiasAddPDGRange	(	G4int	PDGlow,
		G4int	PDGhigh,
		G4bool	includeAntiParticle = true )

Definition at line 143 of file G4GenericBiasingPhysics.cc.

{
  if ( PDGlow > PDGhigh ) G4cout << " G4GenericBiasingPhysics::BiasAddPDGRange(...) :  PDGlow > PDGhigh, call ignored." << G4endl;
  PhysicsBiasAddPDGRange   ( PDGlow, PDGhigh, includeAntiParticle );
  NonPhysicsBiasAddPDGRange( PDGlow, PDGhigh, includeAntiParticle );
}

BiasAllCharged()

void G4GenericBiasingPhysics::BiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 160 of file G4GenericBiasingPhysics.cc.

{  
  fPhysBiasAllCharged       = true;
  fNonPhysBiasAllCharged    = true;
  fPhysBiasAllChargedISL    = includeShortLived;
  fNonPhysBiasAllChargedISL = includeShortLived;
}

BiasAllNeutral()

void G4GenericBiasingPhysics::BiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 177 of file G4GenericBiasingPhysics.cc.

{  
  fPhysBiasAllNeutral       = true;
  fNonPhysBiasAllNeutral    = true;
  fPhysBiasAllNeutralISL    = includeShortLived;
  fNonPhysBiasAllNeutralISL = includeShortLived;
}

ConstructParticle()

void G4GenericBiasingPhysics::ConstructParticle ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 305 of file G4GenericBiasingPhysics.cc.

{;}

ConstructProcess()

void G4GenericBiasingPhysics::ConstructProcess ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 310 of file G4GenericBiasingPhysics.cc.

{
  
  // -- bias setup per individual particle name:
  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  
  while( (*particleIterator)() )
    {
      G4ParticleDefinition*     particle = particleIterator->value();
      G4String              particleName = particle->GetParticleName();
      G4ProcessManager*         pmanager = particle->GetProcessManager();
      
      // -- include non physics process interface for biasing:
      if ( std::find(fNonPhysBiasedParticles.begin(),
             fNonPhysBiasedParticles.end(),
             particleName             )  != fNonPhysBiasedParticles.end() )
    {
      G4BiasingHelper::ActivateNonPhysicsBiasing(pmanager);
    }
      
      // -- wrap biased physics processes, all processes or only user selected:
      std::vector< G4String >::const_iterator particleIt =
    std::find(fBiasedParticles.begin(),
          fBiasedParticles.end(),
          particleName             );
      if ( particleIt == fBiasedParticles.end() ) continue;
      
      std::vector < G4String >& biasedProcesses = fBiasedProcesses [ particleIt - fBiasedParticles.begin() ];
      G4bool biasAll                            = fBiasAllProcesses[ particleIt - fBiasedParticles.begin() ];
      
      if ( biasAll )
    {
      G4ProcessVector*  vprocess = pmanager->GetProcessList();
      for (G4int ip = 0 ; ip < (G4int)vprocess->size() ; ++ip)
        {
          G4VProcess* process = (*vprocess)[ip];
          biasedProcesses.push_back( process->GetProcessName() );
        }
    }
      
      G4bool restartLoop(true);
      while ( restartLoop )
    {
      for (std::size_t ip = 0 ; ip < biasedProcesses.size() ; ++ip)
        {
          G4bool activ = G4BiasingHelper::ActivatePhysicsBiasing(pmanager, biasedProcesses[ip] );
          restartLoop = activ;
          if ( restartLoop ) break;
        }
    }
      
    }
 
  
  // -- bias setup per group:
  particleIterator->reset();
 
  while( (*particleIterator)() )
    {
      G4ParticleDefinition*     particle = particleIterator->value();
      G4String              particleName = particle->GetParticleName();
      G4ProcessManager*         pmanager = particle->GetProcessManager();
      
      // -- exclude particles invidually specified by name:
      if ( std::find( fNonPhysBiasedParticles.begin(),
              fNonPhysBiasedParticles.end(),
              particleName                    ) != fNonPhysBiasedParticles.end() ) continue;
      
      if ( std::find( fBiasedParticles.begin(),
              fBiasedParticles.end(),
              particleName                    ) != fBiasedParticles.end() ) continue;
 
 
      G4bool physBias(false), nonPhysBias(false);
      
      auto PDG = particle->GetPDGEncoding();
 
      // -- include particle if in right PDG range:
      for ( std::size_t i = 0 ; i < fPhysBiasByPDGRangeLow.size() ; i++ )
    if ( ( PDG >= fPhysBiasByPDGRangeLow[i] ) && ( PDG <= fPhysBiasByPDGRangeHigh[i] ) )
      {
        physBias = true;
        break;
      }
      for ( std::size_t i = 0 ; i < fNonPhysBiasByPDGRangeLow.size() ; i++ )
    if ( ( PDG >= fNonPhysBiasByPDGRangeLow[i] ) && ( PDG <= fNonPhysBiasByPDGRangeHigh[i] ) )
      {
        nonPhysBias = true;
        break;
      }
      
      // -- if particle has not yet any biasing, include it on charge criteria:
      if ( ( physBias == false ) && ( nonPhysBias == false ) )
    {
      if ( std::abs( particle->GetPDGCharge() ) > DBL_MIN )
        {
          if ( fPhysBiasAllCharged    ) if (    fPhysBiasAllChargedISL || !particle->IsShortLived() )    physBias = true;
          if ( fNonPhysBiasAllCharged ) if ( fNonPhysBiasAllChargedISL || !particle->IsShortLived() ) nonPhysBias = true;
        }
      else
        {
          if ( fPhysBiasAllNeutral    ) if (    fPhysBiasAllNeutralISL || !particle->IsShortLived() )    physBias = true;
          if ( fNonPhysBiasAllNeutral ) if ( fNonPhysBiasAllNeutralISL || !particle->IsShortLived() ) nonPhysBias = true;
        }
    }
      
      
      if ( nonPhysBias ) G4BiasingHelper::ActivateNonPhysicsBiasing(pmanager);
      
      if ( physBias )
    {
      std::vector < G4String > biasedProcesses;
      G4ProcessVector*  vprocess = pmanager->GetProcessList();
      for (G4int ip = 0 ; ip < (G4int)vprocess->size() ; ++ip)
        {
          G4VProcess* process = (*vprocess)[ip];
          biasedProcesses.push_back( process->GetProcessName() );
        }
      
      G4bool restartLoop(true);
      while ( restartLoop )
        {
          for (std::size_t ip = 0 ; ip < biasedProcesses.size() ; ++ip)
        {
          G4bool activ = G4BiasingHelper::ActivatePhysicsBiasing(pmanager, biasedProcesses[ip] );
          restartLoop = activ;
          if ( restartLoop ) break;
        }
        }
    }
      
    }
 
 
 
  // -- Associate parallel geometries:
  AssociateParallelGeometries();
  
 
  // -- tells what is done:
  if ( fVerbose )
    {
      // -- print:
      particleIterator->reset();
      
      while( (*particleIterator)() )
    {
      G4ParticleDefinition*     particle = particleIterator->value();
      G4String              particleName = particle->GetParticleName();
      G4ProcessManager*         pmanager = particle->GetProcessManager();
      
      G4bool isBiased(false);
      G4String processNames;
      G4int icount(0);
      
      G4ProcessVector*  vprocess = pmanager->GetProcessList();
      for (G4int ip = 0 ; ip < (G4int)vprocess->size() ; ++ip)
        {
          G4VProcess* process = (*vprocess)[ip];
          G4BiasingProcessInterface* pb = dynamic_cast< G4BiasingProcessInterface* >(process);
          if ( pb != nullptr )
        {
          isBiased = true;
          if ( icount < 3 )
            {
              processNames += pb->GetProcessName();
              processNames += " ";
            }
          else
            {
              processNames += "\n                     ";
              processNames += pb->GetProcessName();
              processNames += " ";
              icount = 0;
            }
          icount++;
        }
        }
      if ( isBiased )
        {
          if ( particle->IsShortLived() )
        G4cout << std::setw(14) << particleName << " **** : " << processNames << G4endl;
          else
        G4cout << std::setw(18) << particleName << " : " << processNames << G4endl;
        }
    }
    }
}

NonPhysicsBias()

void G4GenericBiasingPhysics::NonPhysicsBias

(

const G4String &

particleName

)

Definition at line 94 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasedParticles.push_back(particleName);
}

Referenced by Bias(), and Bias().

NonPhysicsBiasAddPDGRange()

void G4GenericBiasingPhysics::NonPhysicsBiasAddPDGRange	(	G4int	PDGlow,
		G4int	PDGhigh,
		G4bool	includeAntiParticle = true )

Definition at line 129 of file G4GenericBiasingPhysics.cc.

{
  if ( PDGlow > PDGhigh ) G4cout << " G4GenericBiasingPhysics::NonPhysicsBiasAddPDGRange(...) :  PDGlow > PDGhigh, call ignored." << G4endl;
  fNonPhysBiasByPDGRangeLow .push_back( PDGlow  );
  fNonPhysBiasByPDGRangeHigh.push_back( PDGhigh );
  if ( includeAntiParticle )
    {
      fNonPhysBiasByPDGRangeLow .push_back( -PDGhigh );
      fNonPhysBiasByPDGRangeHigh.push_back( -PDGlow  );
    }
}

Referenced by BiasAddPDGRange().

NonPhysicsBiasAllCharged()

void G4GenericBiasingPhysics::NonPhysicsBiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 155 of file G4GenericBiasingPhysics.cc.

{ 
  fNonPhysBiasAllCharged    = true; 
  fNonPhysBiasAllChargedISL = includeShortLived;
}

NonPhysicsBiasAllNeutral()

void G4GenericBiasingPhysics::NonPhysicsBiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 172 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasAllNeutral    = true;
  fNonPhysBiasAllNeutralISL = includeShortLived;
}

PhysicsBias() [1/2]

void G4GenericBiasingPhysics::PhysicsBias

(

const G4String &

particleName

)

Definition at line 76 of file G4GenericBiasingPhysics.cc.

{
  fBiasedParticles.push_back(particleName);
  fBiasedProcesses.emplace_back();
  fBiasAllProcesses.push_back(true);
}

Referenced by Bias(), and Bias().

PhysicsBias() [2/2]

void G4GenericBiasingPhysics::PhysicsBias	(	const G4String &	particleName,
		const std::vector< G4String > &	processToBiasNames )

Definition at line 85 of file G4GenericBiasingPhysics.cc.

{
  fBiasedParticles.push_back(particleName);
  fBiasedProcesses.push_back(processNames);
  fBiasAllProcesses.push_back(false); 
}

PhysicsBiasAddPDGRange()

void G4GenericBiasingPhysics::PhysicsBiasAddPDGRange	(	G4int	PDGlow,
		G4int	PDGhigh,
		G4bool	includeAntiParticle = true )

Definition at line 116 of file G4GenericBiasingPhysics.cc.

{
  if ( PDGlow > PDGhigh ) G4cout << " G4GenericBiasingPhysics::PhysicsBiasAddPDGRange(...) :  PDGlow > PDGhigh, call ignored." << G4endl;
  fPhysBiasByPDGRangeLow .push_back( PDGlow  );
  fPhysBiasByPDGRangeHigh.push_back( PDGhigh );
  if ( includeAntiParticle )
    {
      fPhysBiasByPDGRangeLow .push_back( -PDGhigh );
      fPhysBiasByPDGRangeHigh.push_back( -PDGlow  );
    }
}

Referenced by BiasAddPDGRange().

PhysicsBiasAllCharged()

void G4GenericBiasingPhysics::PhysicsBiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 150 of file G4GenericBiasingPhysics.cc.

{
  fPhysBiasAllCharged    = true; 
  fPhysBiasAllChargedISL = includeShortLived;
} 

PhysicsBiasAllNeutral()

void G4GenericBiasingPhysics::PhysicsBiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 167 of file G4GenericBiasingPhysics.cc.

{ 
  fPhysBiasAllNeutral    = true;  
  fPhysBiasAllNeutralISL = includeShortLived;
} 

---

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

• G4GenericBiasingPhysics.hh
• G4GenericBiasingPhysics.cc