#include <G4GenericBiasingPhysics.hh>

Inheritance diagram for G4GenericBiasingPhysics:

Public Member Functions
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 ()

void	Bias (const G4String &particleName)

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

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

void	BiasAllCharged (G4bool includeShortLived=false)

void	BiasAllNeutral (G4bool includeShortLived=false)

virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

	G4GenericBiasingPhysics (const G4String &name="BiasingP")

G4int	GetInstanceID () const

const G4String &	GetPhysicsName () const

G4int	GetPhysicsType () const

G4int	GetVerboseLevel () const

void	NonPhysicsBias (const G4String &particleName)

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

void	NonPhysicsBiasAllCharged (G4bool includeShortLived=false)

void	NonPhysicsBiasAllNeutral (G4bool includeShortLived=false)

void	PhysicsBias (const G4String &particleName)

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

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

void	PhysicsBiasAllCharged (G4bool includeShortLived=false)

void	PhysicsBiasAllNeutral (G4bool includeShortLived=false)

void	SetPhysicsName (const G4String &="")

void	SetPhysicsType (G4int)

void	SetVerboseLevel (G4int value)

virtual void	TerminateWorker ()

virtual	~G4GenericBiasingPhysics ()

Static Public Member Functions
static const G4VPCManager &	GetSubInstanceManager ()

Protected Types
using	PhysicsBuilder_V = G4VPCData::PhysicsBuilders_V

Protected Member Functions
void	AddBuilder (G4PhysicsBuilderInterface *bld)

PhysicsBuilder_V	GetBuilders () const

G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

G4bool	RegisterProcess (G4VProcess process, G4ParticleDefinition particle)

Protected Attributes
G4int	g4vpcInstanceID = 0

G4String	namePhysics = ""

G4ParticleTable *	theParticleTable = nullptr

G4int	typePhysics = 0

G4int	verboseLevel = 0

Static Protected Attributes
static G4RUN_DLL G4VPCManager	subInstanceManager

Private Member Functions
void	AssociateParallelGeometries ()

	G4GenericBiasingPhysics (const G4GenericBiasingPhysics &)

G4GenericBiasingPhysics &	operator= (const G4GenericBiasingPhysics &right)

Private Attributes
std::vector< G4bool >	fAllChargedParallelGeometriesISL

std::vector< G4bool >	fAllNeutralParallelGeometriesISL

std::vector< G4bool >	fBiasAllProcesses

std::vector< G4String >	fBiasedParticles

std::vector< std::vector< G4String > >	fBiasedProcesses

G4bool	fNonPhysBiasAllCharged

G4bool	fNonPhysBiasAllChargedISL

G4bool	fNonPhysBiasAllNeutral

G4bool	fNonPhysBiasAllNeutralISL

std::vector< G4int >	fNonPhysBiasByPDGRangeHigh

std::vector< G4int >	fNonPhysBiasByPDGRangeLow

std::vector< G4String >	fNonPhysBiasedParticles

std::vector< G4String >	fParallelGeometriesForCharged

std::vector< G4String >	fParallelGeometriesForNeutral

std::map< G4String, std::vector< G4String > >	fParallelGeometriesForParticle

std::vector< G4String >	fParticlesWithParallelGeometries

std::vector< G4int >	fPDGhighParallelGeometries

std::vector< G4int >	fPDGlowParallelGeometries

std::map< G4int, std::vector< G4String > >	fPDGrangeParallelGeometries

G4bool	fPhysBiasAllCharged

G4bool	fPhysBiasAllChargedISL

G4bool	fPhysBiasAllNeutral

G4bool	fPhysBiasAllNeutralISL

std::vector< G4int >	fPhysBiasByPDGRangeHigh

std::vector< G4int >	fPhysBiasByPDGRangeLow

G4bool	fVerbose

Detailed Description

Definition at line 41 of file G4GenericBiasingPhysics.hh.

Member Typedef Documentation

◆ PhysicsBuilder_V

using G4VPhysicsConstructor::PhysicsBuilder_V = G4VPCData::PhysicsBuilders_V

protectedinherited

Definition at line 149 of file G4VPhysicsConstructor.hh.

Constructor & Destructor Documentation

◆ G4GenericBiasingPhysics() [1/2]

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.

71{;}

◆ G4GenericBiasingPhysics() [2/2]

G4GenericBiasingPhysics::G4GenericBiasingPhysics ( const G4GenericBiasingPhysics & )

private

Member Function Documentation

◆ AddBuilder()

void G4VPhysicsConstructor::AddBuilder ( G4PhysicsBuilderInterface * bld )

protectedinherited

Definition at line 99 of file G4VPhysicsConstructor.cc.

{
  (subInstanceManager.offset[g4vpcInstanceID])._builders->push_back(bld);
}

References G4VPhysicsConstructor::g4vpcInstanceID, G4VUPLSplitter< T >::offset, and G4VPhysicsConstructor::subInstanceManager.

◆ AddParallelGeometry() [1/4]

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

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

References fParallelGeometriesForParticle, and fParticlesWithParallelGeometries.

Referenced by AddParallelGeometry().

◆ AddParallelGeometry() [2/4]

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

Definition at line 217 of file G4GenericBiasingPhysics.cc.

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

References AddParallelGeometry().

◆ AddParallelGeometry() [3/4]

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

Definition at line 222 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 = fPDGlowParallelGeometries.size() - 1;
  fPDGrangeParallelGeometries[rangeIndex].push_back( parallelGeometryName );
 
  if ( includeAntiParticle )
    {
      fPDGlowParallelGeometries .push_back( -PDGhigh );
      fPDGhighParallelGeometries.push_back( -PDGlow  );
      rangeIndex = fPDGlowParallelGeometries.size() - 1;
      fPDGrangeParallelGeometries[rangeIndex].push_back( parallelGeometryName );
    }
  
}

References fPDGhighParallelGeometries, fPDGlowParallelGeometries, fPDGrangeParallelGeometries, G4cout, and G4endl.

◆ AddParallelGeometry() [4/4]

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

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

References AddParallelGeometry(), G4cout, and G4endl.

◆ AddParallelGeometryAllCharged() [1/2]

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

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

References fAllChargedParallelGeometriesISL, and fParallelGeometriesForCharged.

Referenced by AddParallelGeometryAllCharged().

◆ AddParallelGeometryAllCharged() [2/2]

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

Definition at line 274 of file G4GenericBiasingPhysics.cc.

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

References AddParallelGeometryAllCharged().

◆ AddParallelGeometryAllNeutral() [1/2]

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

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

References fAllNeutralParallelGeometriesISL, and fParallelGeometriesForNeutral.

Referenced by AddParallelGeometryAllNeutral().

◆ AddParallelGeometryAllNeutral() [2/2]

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

Definition at line 297 of file G4GenericBiasingPhysics.cc.

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

References AddParallelGeometryAllNeutral().

◆ AssociateParallelGeometries()

void G4GenericBiasingPhysics::AssociateParallelGeometries ( )

private

Definition at line 503 of file G4GenericBiasingPhysics.cc.

{
  
  // -- parallel geometries for individual particles:
    auto particleIterator=GetParticleIterator();
    particleIterator->reset();
  
  while( (*particleIterator)() )
    {
      G4ParticleDefinition*     particle = particleIterator->value();
      G4String              particleName = particle->GetParticleName();
      G4ProcessManager*         pmanager = particle->GetProcessManager();
 
      G4bool requested = false;
      for ( G4String requestedParticles : fParticlesWithParallelGeometries )
    {
      if ( requestedParticles == particleName )
        {
          requested = true;
          break;
        }
    }
      if ( requested )
    {
      // -- insert biasing process for handling parallel geometries:
      G4ParallelGeometriesLimiterProcess* limiter = G4BiasingHelper::AddLimiterProcess(pmanager);
 
      // -- attach the requested worlds to this process:
      std::vector< G4String >& parallelWorlds = fParallelGeometriesForParticle[ particleName ];
      for ( G4String world : parallelWorlds ) limiter->AddParallelWorld( world );
    }
      
    }
 
  
  // -- parallel geometries for particles in PDG ranges:
  G4int i = 0; // -- index for PDG range
  for ( G4int PDGlow : fPDGlowParallelGeometries )
    {
      G4int PDGhigh     = fPDGhighParallelGeometries[i];
      auto & geometries = fPDGrangeParallelGeometries[i];
      
      particleIterator->reset();
 
      while( (*particleIterator)() )
    {
      G4ParticleDefinition*    particle = particleIterator->value();
      G4int                 particlePDG = particle->GetPDGEncoding();
      G4ProcessManager*        pmanager = particle->GetProcessManager();
 
      if ( ( particlePDG >= PDGlow ) && ( particlePDG <= PDGhigh ) )
        {
          // -- §§ exclude particles from individual list ?
          // -- insert biasing process for handling parallel geometries:
          G4ParallelGeometriesLimiterProcess* limiter = G4BiasingHelper::AddLimiterProcess(pmanager);
 
          // -- attached the requested worlds to this process:
          for ( auto geometry : geometries ) limiter->AddParallelWorld( geometry );
        }
    }
      // -- increment index for next PDG range:
      i++;
    }
 
 
  // -- parallel geometries for all neutral / charged particles:
  particleIterator->reset();
  G4bool islAllNeutral = false;
  for(auto isln : fAllNeutralParallelGeometriesISL)
  { islAllNeutral |= isln; }
  G4bool islAllCharged = false;
  for(auto islc : fAllChargedParallelGeometriesISL)
  { islAllCharged |= islc; }
 
  while((*particleIterator)())
  {
    G4ParticleDefinition*    particle = particleIterator->value();
    G4ProcessManager*        pmanager = particle->GetProcessManager();
    if(particle->GetPDGCharge() == 0.)
    {
      // Neutral particle
      if(particle->IsShortLived() && !islAllNeutral) continue;
      G4ParallelGeometriesLimiterProcess* limiter = G4BiasingHelper::AddLimiterProcess(pmanager);
      G4int j = 0;
      for(G4String wNameN : fParallelGeometriesForCharged)
      {
        if(!(particle->IsShortLived()) || fAllNeutralParallelGeometriesISL[j])
        { limiter->AddParallelWorld(wNameN); }
        j++;
      }
    }
    else
    {
      // charged
      if(particle->IsShortLived() && !islAllCharged) continue;
      G4ParallelGeometriesLimiterProcess* limiter = G4BiasingHelper::AddLimiterProcess(pmanager);
      G4int j = 0;
      for(G4String wNameC : fParallelGeometriesForCharged)
      {
        if(!(particle->IsShortLived()) || fAllChargedParallelGeometriesISL[j])
        { limiter->AddParallelWorld(wNameC); }
        j++;
      }
    }
  }
  
}

References G4BiasingHelper::AddLimiterProcess(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), fAllChargedParallelGeometriesISL, fAllNeutralParallelGeometriesISL, fParallelGeometriesForCharged, fParallelGeometriesForParticle, fParticlesWithParallelGeometries, fPDGhighParallelGeometries, fPDGlowParallelGeometries, fPDGrangeParallelGeometries, G4VPhysicsConstructor::GetParticleIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), G4ParticleDefinition::GetProcessManager(), and G4ParticleDefinition::IsShortLived().

Referenced by ConstructProcess().

◆ BeVerbose()

void G4GenericBiasingPhysics::BeVerbose ( )

inline

Definition at line 106 of file G4GenericBiasingPhysics.hh.

106{ fVerbose = true; }

References fVerbose.

◆ Bias() [1/2]

void G4GenericBiasingPhysics::Bias ( const G4String & particleName )

Definition at line 102 of file G4GenericBiasingPhysics.cc.

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

References NonPhysicsBias(), and PhysicsBias().

◆ Bias() [2/2]

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

Definition at line 110 of file G4GenericBiasingPhysics.cc.

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

References NonPhysicsBias(), and PhysicsBias().

◆ BiasAddPDGRange()

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

Definition at line 144 of file G4GenericBiasingPhysics.cc.

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

References G4cout, G4endl, NonPhysicsBiasAddPDGRange(), and PhysicsBiasAddPDGRange().

◆ BiasAllCharged()

void G4GenericBiasingPhysics::BiasAllCharged ( G4bool includeShortLived = false )

Definition at line 161 of file G4GenericBiasingPhysics.cc.

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

References fNonPhysBiasAllCharged, fNonPhysBiasAllChargedISL, fPhysBiasAllCharged, and fPhysBiasAllChargedISL.

◆ BiasAllNeutral()

void G4GenericBiasingPhysics::BiasAllNeutral ( G4bool includeShortLived = false )

Definition at line 178 of file G4GenericBiasingPhysics.cc.

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

References fNonPhysBiasAllNeutral, fNonPhysBiasAllNeutralISL, fPhysBiasAllNeutral, and fPhysBiasAllNeutralISL.

◆ ConstructParticle()

void G4GenericBiasingPhysics::ConstructParticle ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 306 of file G4GenericBiasingPhysics.cc.

307{;}

◆ ConstructProcess()

void G4GenericBiasingPhysics::ConstructProcess ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 311 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 (std::size_t ip = 0 ; ip < 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 ( size_t i = 0 ; i < fPhysBiasByPDGRangeLow.size() ; i++ )
    if ( ( PDG >= fPhysBiasByPDGRangeLow[i] ) && ( PDG <= fPhysBiasByPDGRangeHigh[i] ) )
      {
        physBias = true;
        break;
      }
      for ( 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 (std::size_t ip = 0 ; ip < 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 (std::size_t ip = 0 ; ip < 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;
        }
    }
    }
}

References G4BiasingHelper::ActivateNonPhysicsBiasing(), G4BiasingHelper::ActivatePhysicsBiasing(), AssociateParallelGeometries(), DBL_MIN, fBiasAllProcesses, fBiasedParticles, fBiasedProcesses, fNonPhysBiasAllCharged, fNonPhysBiasAllChargedISL, fNonPhysBiasAllNeutral, fNonPhysBiasAllNeutralISL, fNonPhysBiasByPDGRangeHigh, fNonPhysBiasByPDGRangeLow, fNonPhysBiasedParticles, fPhysBiasAllCharged, fPhysBiasAllChargedISL, fPhysBiasAllNeutral, fPhysBiasAllNeutralISL, fPhysBiasByPDGRangeHigh, fPhysBiasByPDGRangeLow, fVerbose, G4cout, G4endl, G4VPhysicsConstructor::GetParticleIterator(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGEncoding(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4ParticleDefinition::IsShortLived(), and G4ProcessVector::size().

◆ GetBuilders()

G4VPhysicsConstructor::PhysicsBuilder_V G4VPhysicsConstructor::GetBuilders ( ) const

protectedinherited

Definition at line 86 of file G4VPhysicsConstructor.cc.

{
  const auto& tls = *((subInstanceManager.offset[g4vpcInstanceID])._builders);
  PhysicsBuilder_V copy(tls.size());
  G4int i = 0;
  for(const auto& el : tls)
  {
    copy[i++] = el;
  }
  return copy;
}

References field_utils::copy(), G4VPhysicsConstructor::g4vpcInstanceID, G4VUPLSplitter< T >::offset, and G4VPhysicsConstructor::subInstanceManager.

◆ GetInstanceID()

G4int G4VPhysicsConstructor::GetInstanceID ( ) const

inlineinherited

◆ GetParticleIterator()

G4ParticleTable::G4PTblDicIterator * G4VPhysicsConstructor::GetParticleIterator ( ) const

protectedinherited

Definition at line 79 of file G4VPhysicsConstructor.cc.

{
  return (subInstanceManager.offset[g4vpcInstanceID])._aParticleIterator;
}

References G4VPhysicsConstructor::g4vpcInstanceID, G4VUPLSplitter< T >::offset, and G4VPhysicsConstructor::subInstanceManager.

◆ GetPhysicsName()

const G4String & G4VPhysicsConstructor::GetPhysicsName ( ) const

inlineinherited

Definition at line 191 of file G4VPhysicsConstructor.hh.

{
  return namePhysics;
}

References G4VPhysicsConstructor::namePhysics.

◆ GetPhysicsType()

G4int G4VPhysicsConstructor::GetPhysicsType ( ) const

inlineinherited

Definition at line 201 of file G4VPhysicsConstructor.hh.

{
  return typePhysics;
}

References G4VPhysicsConstructor::typePhysics.

Referenced by G4VModularPhysicsList::RegisterPhysics(), and G4VModularPhysicsList::ReplacePhysics().

◆ GetSubInstanceManager()

const G4VPCManager & G4VPhysicsConstructor::GetSubInstanceManager ( )

inlinestaticinherited

Definition at line 213 of file G4VPhysicsConstructor.hh.

{
  return subInstanceManager;
}

References G4VPhysicsConstructor::subInstanceManager.

Referenced by G4PhysicsListWorkspace::G4PhysicsListWorkspace().

◆ GetVerboseLevel()

G4int G4VPhysicsConstructor::GetVerboseLevel ( ) const

inlineinherited

Definition at line 181 of file G4VPhysicsConstructor.hh.

{
  return verboseLevel;
}

References G4VPhysicsConstructor::verboseLevel.

◆ NonPhysicsBias()

void G4GenericBiasingPhysics::NonPhysicsBias ( const G4String & particleName )

Definition at line 95 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasedParticles.push_back(particleName);
}

References fNonPhysBiasedParticles.

Referenced by Bias().

◆ NonPhysicsBiasAddPDGRange()

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

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

References fNonPhysBiasByPDGRangeHigh, fNonPhysBiasByPDGRangeLow, G4cout, and G4endl.

Referenced by BiasAddPDGRange().

◆ NonPhysicsBiasAllCharged()

void G4GenericBiasingPhysics::NonPhysicsBiasAllCharged ( G4bool includeShortLived = false )

Definition at line 156 of file G4GenericBiasingPhysics.cc.

{ 
  fNonPhysBiasAllCharged    = true; 
  fNonPhysBiasAllChargedISL = includeShortLived;
}

References fNonPhysBiasAllCharged, and fNonPhysBiasAllChargedISL.

◆ NonPhysicsBiasAllNeutral()

void G4GenericBiasingPhysics::NonPhysicsBiasAllNeutral ( G4bool includeShortLived = false )

Definition at line 173 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasAllNeutral    = true;
  fNonPhysBiasAllNeutralISL = includeShortLived;
}

References fNonPhysBiasAllNeutral, and fNonPhysBiasAllNeutralISL.

◆ operator=()

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

private

◆ PhysicsBias() [1/2]

void G4GenericBiasingPhysics::PhysicsBias ( const G4String & particleName )

Definition at line 76 of file G4GenericBiasingPhysics.cc.

{
  fBiasedParticles.push_back(particleName);
  std::vector< G4String > dummy;
  fBiasedProcesses.push_back(dummy);
  fBiasAllProcesses.push_back(true);
}

References fBiasAllProcesses, fBiasedParticles, and fBiasedProcesses.

Referenced by Bias().

◆ PhysicsBias() [2/2]

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

Definition at line 86 of file G4GenericBiasingPhysics.cc.

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

References fBiasAllProcesses, fBiasedParticles, and fBiasedProcesses.

◆ PhysicsBiasAddPDGRange()

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

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

References fPhysBiasByPDGRangeHigh, fPhysBiasByPDGRangeLow, G4cout, and G4endl.

Referenced by BiasAddPDGRange().

◆ PhysicsBiasAllCharged()

void G4GenericBiasingPhysics::PhysicsBiasAllCharged ( G4bool includeShortLived = false )

Definition at line 151 of file G4GenericBiasingPhysics.cc.

{
  fPhysBiasAllCharged    = true; 
  fPhysBiasAllChargedISL = includeShortLived;
} 

References fPhysBiasAllCharged, and fPhysBiasAllChargedISL.

◆ PhysicsBiasAllNeutral()

void G4GenericBiasingPhysics::PhysicsBiasAllNeutral ( G4bool includeShortLived = false )

Definition at line 168 of file G4GenericBiasingPhysics.cc.

{ 
  fPhysBiasAllNeutral    = true;  
  fPhysBiasAllNeutralISL = includeShortLived;
} 

References fPhysBiasAllNeutral, and fPhysBiasAllNeutralISL.

◆ RegisterProcess()

G4bool G4VPhysicsConstructor::RegisterProcess	(	G4VProcess *	process,
		G4ParticleDefinition *	particle
	)

inlineprotectedinherited

Definition at line 206 of file G4VPhysicsConstructor.hh.

{
  return G4PhysicsListHelper::GetPhysicsListHelper()
         ->RegisterProcess(process, particle);
}

References G4PhysicsListHelper::GetPhysicsListHelper(), and G4PhysicsListHelper::RegisterProcess().

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess(), G4RadioactiveDecayPhysics::ConstructProcess(), and G4EmDNAChemistry_option2::ConstructProcess().

◆ SetPhysicsName()

void G4VPhysicsConstructor::SetPhysicsName ( const G4String & name = "" )

inlineinherited

Definition at line 186 of file G4VPhysicsConstructor.hh.

{
  namePhysics = name;
}

References G4InuclParticleNames::name(), and G4VPhysicsConstructor::namePhysics.

Referenced by export_G4VPhysicsConstructor().

◆ SetPhysicsType()

void G4VPhysicsConstructor::SetPhysicsType ( G4int val )

inlineinherited

Definition at line 196 of file G4VPhysicsConstructor.hh.

{
  if(val > 0)  { typePhysics = val; }
}

References G4VPhysicsConstructor::typePhysics.

◆ SetVerboseLevel()

void G4VPhysicsConstructor::SetVerboseLevel ( G4int value )

inlineinherited

Definition at line 176 of file G4VPhysicsConstructor.hh.

{
  verboseLevel = value;
}

References G4VPhysicsConstructor::verboseLevel.

Referenced by export_G4VPhysicsConstructor(), G4EmDNAPhysics::G4EmDNAPhysics(), G4EmLivermorePhysics::G4EmLivermorePhysics(), G4EmLowEPPhysics::G4EmLowEPPhysics(), G4EmPenelopePhysics::G4EmPenelopePhysics(), G4EmStandardPhysics::G4EmStandardPhysics(), G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(), G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(), G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(), G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(), G4EmStandardPhysicsGS::G4EmStandardPhysicsGS(), G4EmStandardPhysicsSS::G4EmStandardPhysicsSS(), G4MuonicAtomDecayPhysics::G4MuonicAtomDecayPhysics(), G4VHadronPhysics::G4VHadronPhysics(), and PhysicsListEMstd::PhysicsListEMstd().

◆ TerminateWorker()

void G4VPhysicsConstructor::TerminateWorker ( )

virtualinherited

Definition at line 105 of file G4VPhysicsConstructor.cc.

{
  if(subInstanceManager.offset[g4vpcInstanceID]._builders != nullptr)
  {
    std::for_each(subInstanceManager.offset[g4vpcInstanceID]._builders->begin(),
                  subInstanceManager.offset[g4vpcInstanceID]._builders->end(),
                  [](PhysicsBuilder_V::value_type bld) { delete bld; });
    subInstanceManager.offset[g4vpcInstanceID]._builders->clear();
  }
}