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

Private Member Functions
G4GenericBiasingPhysics &	operator= (const G4GenericBiasingPhysics &right)
	G4GenericBiasingPhysics (const G4GenericBiasingPhysics &)

Private Attributes
std::vector< G4String >	fBiasedParticles
std::vector< G4bool >	fBiasAllProcesses
std::vector< std::vector< G4String > >	fBiasedProcesses
std::vector< G4String >	fNonPhysBiasedParticles
std::vector< G4int >	fPhysBiasByPDGRangeLow
std::vector< G4int >	fPhysBiasByPDGRangeHigh
std::vector< G4int >	fNonPhysBiasByPDGRangeLow
std::vector< G4int >	fNonPhysBiasByPDGRangeHigh
G4bool	fPhysBiasAllCharged
G4bool	fNonPhysBiasAllCharged
G4bool	fPhysBiasAllChargedISL
G4bool	fNonPhysBiasAllChargedISL
G4bool	fPhysBiasAllNeutral
G4bool	fNonPhysBiasAllNeutral
G4bool	fPhysBiasAllNeutralISL
G4bool	fNonPhysBiasAllNeutralISL
G4bool	fVerbose

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() [1/2]

G4GenericBiasingPhysics::G4GenericBiasingPhysics

(

const G4String &

name = "BiasingP"

)

Definition at line 58 of file G4GenericBiasingPhysics.cc.

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

Here is the caller graph for this function:

~G4GenericBiasingPhysics()

G4GenericBiasingPhysics::~G4GenericBiasingPhysics ( )

virtual

Definition at line 69 of file G4GenericBiasingPhysics.cc.

{;}

G4GenericBiasingPhysics() [2/2]

G4GenericBiasingPhysics::G4GenericBiasingPhysics ( const G4GenericBiasingPhysics &  )

private

Member Function Documentation

BeVerbose()

void G4GenericBiasingPhysics::BeVerbose ( )

inline

Definition at line 82 of file G4GenericBiasingPhysics.hh.

{ fVerbose = true; }

Here is the call graph for this function:

Bias() [1/2]

void G4GenericBiasingPhysics::Bias

(

const G4String &

particleName

)

Definition at line 101 of file G4GenericBiasingPhysics.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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

virtual

Implements G4VPhysicsConstructor.

Definition at line 189 of file G4GenericBiasingPhysics.cc.

{;}

Here is the caller graph for this function:

ConstructProcess()

void G4GenericBiasingPhysics::ConstructProcess ( void  )

virtual

Implements G4VPhysicsConstructor.

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


  
  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:

Here is the caller graph for this function:

NonPhysicsBias()

void G4GenericBiasingPhysics::NonPhysicsBias

(

const G4String &

particleName

)

Definition at line 94 of file G4GenericBiasingPhysics.cc.

{
  fNonPhysBiasedParticles.push_back(particleName);
}

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

operator=()

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

private

Here is the caller graph for this function:

PhysicsBias() [1/2]

void G4GenericBiasingPhysics::PhysicsBias

(

const G4String &

particleName

)

Definition at line 75 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:

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

Here is the caller graph for this function:

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

Member Data Documentation

fBiasAllProcesses

std::vector< G4bool > G4GenericBiasingPhysics::fBiasAllProcesses

private

Definition at line 102 of file G4GenericBiasingPhysics.hh.

fBiasedParticles

std::vector< G4String > G4GenericBiasingPhysics::fBiasedParticles

private

Definition at line 101 of file G4GenericBiasingPhysics.hh.

fBiasedProcesses

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

private

Definition at line 104 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasAllCharged

G4bool G4GenericBiasingPhysics::fNonPhysBiasAllCharged

private

Definition at line 111 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasAllChargedISL

G4bool G4GenericBiasingPhysics::fNonPhysBiasAllChargedISL

private

Definition at line 112 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasAllNeutral

G4bool G4GenericBiasingPhysics::fNonPhysBiasAllNeutral

private

Definition at line 113 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasAllNeutralISL

G4bool G4GenericBiasingPhysics::fNonPhysBiasAllNeutralISL

private

Definition at line 114 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasByPDGRangeHigh

std::vector< G4int > G4GenericBiasingPhysics::fNonPhysBiasByPDGRangeHigh

private

Definition at line 110 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasByPDGRangeLow

std::vector< G4int > G4GenericBiasingPhysics::fNonPhysBiasByPDGRangeLow

private

Definition at line 110 of file G4GenericBiasingPhysics.hh.

fNonPhysBiasedParticles

std::vector< G4String > G4GenericBiasingPhysics::fNonPhysBiasedParticles

private

Definition at line 106 of file G4GenericBiasingPhysics.hh.

fPhysBiasAllCharged

G4bool G4GenericBiasingPhysics::fPhysBiasAllCharged

private

Definition at line 111 of file G4GenericBiasingPhysics.hh.

fPhysBiasAllChargedISL

G4bool G4GenericBiasingPhysics::fPhysBiasAllChargedISL

private

Definition at line 112 of file G4GenericBiasingPhysics.hh.

fPhysBiasAllNeutral

G4bool G4GenericBiasingPhysics::fPhysBiasAllNeutral

private

Definition at line 113 of file G4GenericBiasingPhysics.hh.

fPhysBiasAllNeutralISL

G4bool G4GenericBiasingPhysics::fPhysBiasAllNeutralISL

private

Definition at line 114 of file G4GenericBiasingPhysics.hh.

fPhysBiasByPDGRangeHigh

std::vector< G4int > G4GenericBiasingPhysics::fPhysBiasByPDGRangeHigh

private

Definition at line 109 of file G4GenericBiasingPhysics.hh.

fPhysBiasByPDGRangeLow

std::vector< G4int > G4GenericBiasingPhysics::fPhysBiasByPDGRangeLow

private

Definition at line 109 of file G4GenericBiasingPhysics.hh.

fVerbose

G4bool G4GenericBiasingPhysics::fVerbose

private

Definition at line 117 of file G4GenericBiasingPhysics.hh.

---

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

• G4GenericBiasingPhysics.hh
• G4GenericBiasingPhysics.cc