G4GenericBiasingPhysics Class Reference

#include <G4GenericBiasingPhysics.hh>

Inheritance diagram for G4GenericBiasingPhysics:

Collaboration 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
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
G4int	GetInstanceID () const

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager &	GetSubInstanceManager ()
Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const
Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel
G4String	namePhysics
G4int	typePhysics
G4ParticleTable *	theParticleTable
G4int	g4vpcInstanceID
Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager	subInstanceManager

Detailed Description

Definition at line 42 of file G4GenericBiasingPhysics.hh.

Constructor & Destructor Documentation

G4GenericBiasingPhysics::G4GenericBiasingPhysics

(

const G4String &

name = "BiasingP"

)

Definition at line 60 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 ( )

virtual

Definition at line 71 of file G4GenericBiasingPhysics.cc.

{;}

Member Function Documentation

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

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

Here is the caller graph for this function:

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

Definition at line 218 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

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

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

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

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

Here is the call graph for this function:

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

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

Here is the caller graph for this function:

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

Definition at line 275 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

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

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

Here is the caller graph for this function:

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

Definition at line 298 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

void G4GenericBiasingPhysics::BeVerbose ( )

inline

Definition at line 107 of file G4GenericBiasingPhysics.hh.

{ fVerbose = true; }

Here is the caller graph for this function:

void G4GenericBiasingPhysics::Bias

(

const G4String &

particleName

)

Definition at line 103 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 111 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

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

Definition at line 145 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

void G4GenericBiasingPhysics::BiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 162 of file G4GenericBiasingPhysics.cc.

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

void G4GenericBiasingPhysics::BiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 179 of file G4GenericBiasingPhysics.cc.

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

void G4GenericBiasingPhysics::ConstructParticle ( void  )

virtual

Implements G4VPhysicsConstructor.

Definition at line 307 of file G4GenericBiasingPhysics.cc.

{;}

void G4GenericBiasingPhysics::ConstructProcess ( void  )

virtual

Implements G4VPhysicsConstructor.

Definition at line 312 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 < 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 (G4int 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 (G4int 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;
        }
    }
    }
}

Here is the call graph for this function:

void G4GenericBiasingPhysics::NonPhysicsBias

(

const G4String &

particleName

)

Definition at line 96 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasedParticles.push_back(particleName);
}

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

void G4GenericBiasingPhysics::NonPhysicsBiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 157 of file G4GenericBiasingPhysics.cc.

{ 
  fNonPhysBiasAllCharged    = true; 
  fNonPhysBiasAllChargedISL = includeShortLived;
}

void G4GenericBiasingPhysics::NonPhysicsBiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 174 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasAllNeutral    = true;
  fNonPhysBiasAllNeutralISL = includeShortLived;
}

void G4GenericBiasingPhysics::PhysicsBias

(

const G4String &

particleName

)

Definition at line 77 of file G4GenericBiasingPhysics.cc.

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

Here is the caller graph for this function:

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

Definition at line 87 of file G4GenericBiasingPhysics.cc.

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

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

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

Here is the caller graph for this function:

void G4GenericBiasingPhysics::PhysicsBiasAllCharged

(

G4bool

includeShortLived = false

)

Definition at line 152 of file G4GenericBiasingPhysics.cc.

{
  fPhysBiasAllCharged    = true; 
  fPhysBiasAllChargedISL = includeShortLived;
} 

void G4GenericBiasingPhysics::PhysicsBiasAllNeutral

(

G4bool

includeShortLived = false

)

Definition at line 169 of file G4GenericBiasingPhysics.cc.

{ 
  fPhysBiasAllNeutral    = true;  
  fPhysBiasAllNeutralISL = includeShortLived;
} 

---

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

• source/geant4.10.03.p03/source/physics_lists/constructors/limiters/include/G4GenericBiasingPhysics.hh
• source/geant4.10.03.p03/source/physics_lists/constructors/limiters/src/G4GenericBiasingPhysics.cc