pyG4VModularPhysicsList::CB_G4VModularPhysicsList Struct Reference

Inheritance diagram for pyG4VModularPhysicsList::CB_G4VModularPhysicsList:

Public Member Functions
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=nullptr)
void	BuildPhysicsTable ()
void	BuildPhysicsTable (G4ParticleDefinition *)
void	CheckParticleList ()
void	Construct ()
virtual void	ConstructParticle () override
virtual void	ConstructProcess () override
void	DisableCheckParticleList ()
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	DumpList () const
G4bool	GetApplyCuts (const G4String &name) const
G4double	GetCutValue (const G4String &pname) const
G4double	GetDefaultCutValue () const
G4int	GetInstanceID () const
const G4VPhysicsConstructor *	GetPhysics (const G4String &name) const
const G4VPhysicsConstructor *	GetPhysics (G4int index) const
const G4String &	GetPhysicsTableDirectory () const
const G4VPhysicsConstructor *	GetPhysicsWithType (G4int physics_type) const
G4int	GetVerboseLevel () const
virtual void	InitializeWorker ()
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
void	PreparePhysicsTable (G4ParticleDefinition *)
void	RegisterPhysics (G4VPhysicsConstructor *)
void	RemovePhysics (const G4String &name)
void	RemovePhysics (G4int type)
void	RemovePhysics (G4VPhysicsConstructor *)
void	RemoveProcessManager ()
void	RemoveTrackingManager ()
void	ReplacePhysics (G4VPhysicsConstructor *)
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	SetApplyCuts (G4bool value, const G4String &name)
void	SetCuts ()
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetDefaultCutValue (G4double newCutValue)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=nullptr)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=nullptr)
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	SetVerboseLevel (G4int value)
G4bool	StorePhysicsTable (const G4String &directory=".")
virtual void	TerminateWorker () override
void	UseCoupledTransportation (G4bool vl=true)

Static Public Member Functions
static const G4VMPLManager &	GetSubInstanceManager ()

Protected Types
using	G4PhysConstVector = G4VMPLData::G4PhysConstVectorData

Protected Member Functions
void	AddTransportation ()
void	BuildIntegralPhysicsTable (G4VProcess *, G4ParticleDefinition *)
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const
void	InitializeProcessManager ()
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

Protected Attributes
G4double	defaultCutValue = 1.0
G4String	directoryPhysicsTable = "."
G4ProductionCutsTable *	fCutsTable = nullptr
G4bool	fDisableCheckParticleList = false
G4bool	fIsCheckedForRetrievePhysicsTable = false
G4bool	fIsRestoredCutValues = false
G4bool	fRetrievePhysicsTable = false
G4bool	fStoredInAscii = true
G4int	g4vmplInstanceID = 0
G4int	g4vuplInstanceID = 0
G4bool	isSetDefaultCutValue = false
G4ParticleTable *	theParticleTable = nullptr
G4int	verboseLevel = 0

Static Protected Attributes
static G4RUN_DLL G4VMPLManager	G4VMPLsubInstanceManager
static G4RUN_DLL G4VUPLManager	subInstanceManager

Private Types
enum	{ FixedStringLengthForStore = 32 }

Detailed Description

Definition at line 41 of file pyG4VModularPhysicsList.cc.

Member Typedef Documentation

G4PhysConstVector

using G4VModularPhysicsList::G4PhysConstVector = G4VMPLData::G4PhysConstVectorData

protectedinherited

Definition at line 139 of file G4VModularPhysicsList.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

privateinherited

Enumerator
FixedStringLengthForStore

Definition at line 311 of file G4VUserPhysicsList.hh.

    {
      FixedStringLengthForStore = 32
    };

Member Function Documentation

AddProcessManager()

void G4VUserPhysicsList::AddProcessManager ( G4ParticleDefinition *  newParticle, G4ProcessManager *  newManager = nullptr  )

inherited

Definition at line 207 of file G4VUserPhysicsList.cc.

{
  if(newParticle == nullptr)
    return;
  G4Exception("G4VUserPhysicsList::AddProcessManager", "Run0252",
              JustWarning, "This method is obsolete");
}

References G4Exception(), and JustWarning.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

AddTransportation()

void G4VUserPhysicsList::AddTransportation ( )

protectedinherited

Definition at line 1069 of file G4VUserPhysicsList.cc.

{
  G4MT_thePLHelper->AddTransportation();
}

References G4MT_thePLHelper.

Referenced by LBE::AddTransportation(), PhysicsList::ConstructProcess(), PhysicsListEMstd::ConstructProcess(), ExN01PhysicsList::ConstructProcess(), and G4VModularPhysicsList::ConstructProcess().

BuildIntegralPhysicsTable()

void G4VUserPhysicsList::BuildIntegralPhysicsTable ( G4VProcess *  process, G4ParticleDefinition *  particle  )

protectedinherited

Definition at line 864 of file G4VUserPhysicsList.cc.

{
  // TODO Should we change this function?
  //*******************************************************************
  // Temporary addition to make the integral schema of electromagnetic
  // processes work.
 
  if((process->GetProcessName() == "Imsc") ||
     (process->GetProcessName() == "IeIoni") ||
     (process->GetProcessName() == "IeBrems") ||
     (process->GetProcessName() == "Iannihil") ||
     (process->GetProcessName() == "IhIoni") ||
     (process->GetProcessName() == "IMuIoni") ||
     (process->GetProcessName() == "IMuBrems") ||
     (process->GetProcessName() == "IMuPairProd"))
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildIntegralPhysicsTable  "
             << " BuildPhysicsTable is invoked for "
             << process->GetProcessName() << "(" << particle->GetParticleName()
             << ")" << G4endl;
    }
#endif
    process->BuildPhysicsTable(*particle);
  }
}

References G4VProcess::BuildPhysicsTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::RetrievePhysicsTable().

BuildPhysicsTable() [1/2]

void G4VUserPhysicsList::BuildPhysicsTable ( )

inherited

Definition at line 562 of file G4VUserPhysicsList.cc.

{
  // Prepare Physics table for all particles
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    PreparePhysicsTable(particle);
  }
 
  // ask processes to prepare physics table
  if(fRetrievePhysicsTable)
  {
    fIsRestoredCutValues =
      fCutsTable->RetrieveCutsTable(directoryPhysicsTable, fStoredInAscii);
    // check if retrieve Cut Table successfully
    if(!fIsRestoredCutValues)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
               << " Retrieve Cut Table failed !!" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0255",
                  RunMustBeAborted, "Fail to retrieve Production Cut Table");
    }
    else
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
               << "  Retrieve Cut Table successfully " << G4endl;
      }
#endif
    }
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable"
             << " does not retrieve Cut Table but calculate " << G4endl;
    }
#endif
  }
 
  // Sets a value to particle
  // set cut values for gamma at first and for e- and e+
  G4String particleName;
  G4ParticleDefinition* GammaP = theParticleTable->FindParticle("gamma");
  if(GammaP)
    BuildPhysicsTable(GammaP);
  G4ParticleDefinition* EMinusP = theParticleTable->FindParticle("e-");
  if(EMinusP)
    BuildPhysicsTable(EMinusP);
  G4ParticleDefinition* EPlusP = theParticleTable->FindParticle("e+");
  if(EPlusP)
    BuildPhysicsTable(EPlusP);
  G4ParticleDefinition* ProtonP = theParticleTable->FindParticle("proton");
  if(ProtonP)
    BuildPhysicsTable(ProtonP);
 
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if(particle != GammaP && particle != EMinusP && particle != EPlusP &&
       particle != ProtonP)
    {
      BuildPhysicsTable(particle);
    }
  }
 
  // Set flag
  fIsPhysicsTableBuilt = true;
}

References G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fCutsTable, G4ParticleTable::FindParticle(), fIsPhysicsTableBuilt, G4VUserPhysicsList::fIsRestoredCutValues, G4VUserPhysicsList::fRetrievePhysicsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4VUserPhysicsList::PreparePhysicsTable(), G4ProductionCutsTable::RetrieveCutsTable(), RunMustBeAborted, theParticleIterator, G4VUserPhysicsList::theParticleTable, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4RunManagerKernel::BuildPhysicsTables(), and G4UserPhysicsListMessenger::SetNewValue().

BuildPhysicsTable() [2/2]

void G4VUserPhysicsList::BuildPhysicsTable ( G4ParticleDefinition *  particle )

inherited

Definition at line 644 of file G4VUserPhysicsList.cc.

{
  if (auto *trackingManager = particle->GetTrackingManager())
  {
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
             << "Calculate Physics Table for " << particle->GetParticleName()
             << " via custom TrackingManager" << G4endl;
    }
#endif
    trackingManager->BuildPhysicsTable(*particle);
    return;
  }
 
  // Change in order to share physics tables for two kind of process.
 
  if(particle->GetMasterProcessManager() == nullptr)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    { G4cout
      << "#### G4VUserPhysicsList::BuildPhysicsTable() - BuildPhysicsTable("
      << particle->GetParticleName() << ") skipped..." << G4endl; }
#endif
    return;
  }
  if(fRetrievePhysicsTable)
  {
    if(!fIsRestoredCutValues)
    {
      // fail to retrieve cut tables
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << "Physics table can not be retrieved and will be calculated "
               << G4endl;
      }
#endif
      fRetrievePhysicsTable = false;
    }
    else
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << " Retrieve Physics Table for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      //  Retrieve PhysicsTable from files for proccesses
      RetrievePhysicsTable(particle, directoryPhysicsTable, fStoredInAscii);
    }
  }
 
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
           << "Calculate Physics Table for " << particle->GetParticleName()
           << G4endl;
  }
#endif
  // Rebuild the physics tables for every process for this particle type
  // if particle is not ShortLived
  if(!particle->IsShortLived())
  {
    G4ProcessManager* pManager = particle->GetProcessManager();
    if(pManager == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable "
               << " : No Process Manager for " << particle->GetParticleName()
               << G4endl;
        G4cout << particle->GetParticleName()
               << " should be created in your PhysicsList" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0271",
                  FatalException, "No process manager");
      return;
    }
 
    // Get processes from master thread;
    G4ProcessManager* pManagerShadow = particle->GetMasterProcessManager();
 
    G4ProcessVector* pVector = pManager->GetProcessList();
    if(pVector == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::BuildPhysicsTable  "
               << " : No Process Vector for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::BuildPhysicsTable", "Run0272",
                  FatalException, "No process Vector");
      return;
    }
#ifdef G4VERBOSE
    if(verboseLevel > 2)
    {
      G4cout << "G4VUserPhysicsList::BuildPhysicsTable %%%%%% "
             << particle->GetParticleName() << G4endl;
      G4cout << " ProcessManager : " << pManager
             << " ProcessManagerShadow : " << pManagerShadow << G4endl;
      for(std::size_t iv1 = 0; iv1 < pVector->size(); ++iv1)
      {
        G4cout << "  " << iv1 << " - " << (*pVector)[iv1]->GetProcessName()
               << G4endl;
      }
      G4cout << "--------------------------------------------------------------"
             << G4endl;
      G4ProcessVector* pVectorShadow = pManagerShadow->GetProcessList();
 
      for(std::size_t iv2 = 0; iv2 < pVectorShadow->size(); ++iv2)
      {
        G4cout << "  " << iv2 << " - "
               << (*pVectorShadow)[iv2]->GetProcessName() << G4endl;
      }
    }
#endif
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      // Andrea July 16th 2013 : migration to new interface...
      // Infer if we are in a worker thread or master thread
      // Master thread is the one in which the process manager
      // and process manager shadow pointers are the same
      if(pManagerShadow == pManager)
      {
        (*pVector)[j]->BuildPhysicsTable(*particle);
      }
      else
      {
        (*pVector)[j]->BuildWorkerPhysicsTable(*particle);
      }
 
    }  // End loop on processes vector
  }    // End if short-lived
}

References G4VUserPhysicsList::directoryPhysicsTable, FatalException, G4VUserPhysicsList::fIsRestoredCutValues, G4VUserPhysicsList::fRetrievePhysicsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::IsShortLived(), G4VUserPhysicsList::RetrievePhysicsTable(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

CheckParticleList()

void G4VUserPhysicsList::CheckParticleList ( )

inherited

Definition at line 1060 of file G4VUserPhysicsList.cc.

{
  if(!fDisableCheckParticleList)
  {
    G4MT_thePLHelper->CheckParticleList();
  }
}

References G4VUserPhysicsList::fDisableCheckParticleList, and G4MT_thePLHelper.

Referenced by G4RunManagerKernel::InitializePhysics().

Construct()

void G4VUserPhysicsList::Construct ( )

inlineinherited

Definition at line 319 of file G4VUserPhysicsList.hh.

{
  #ifdef G4VERBOSE
    if(verboseLevel > 1)
      G4cout << "G4VUserPhysicsList::Construct()" << G4endl;
  #endif
 
  if ( G4Threading::IsMasterThread() ) G4PhysicsModelCatalog::Initialize();
  
  InitializeProcessManager();
 
  #ifdef G4VERBOSE
    if(verboseLevel > 1)
      G4cout << "Construct processes " << G4endl;
  #endif
  ConstructProcess();
}

References G4VUserPhysicsList::ConstructProcess(), G4cout, G4endl, G4PhysicsModelCatalog::Initialize(), G4VUserPhysicsList::InitializeProcessManager(), G4Threading::IsMasterThread(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4RunManagerKernel::InitializePhysics().

ConstructParticle()

void G4VModularPhysicsList::ConstructParticle ( )

overridevirtualinherited

Implements G4VUserPhysicsList.

Reimplemented in PhysicsList, and LBE.

Definition at line 113 of file G4VModularPhysicsList.cc.

{
  // create particles
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend(); ++itr)
  {
    (*itr)->ConstructParticle();
  }
}

References G4MT_physicsVector.

Referenced by export_G4VModularPhysicsList().

ConstructProcess()

void G4VModularPhysicsList::ConstructProcess ( )

overridevirtualinherited

Implements G4VUserPhysicsList.

Reimplemented in PhysicsList, and LBE.

Definition at line 137 of file G4VModularPhysicsList.cc.

{
  G4AutoLock l(&constructProcessMutex);  // Protection to be removed (A.Dotti)
  AddTransportation();
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend(); ++itr)
  {
    (*itr)->ConstructProcess();
  }
}

References G4VUserPhysicsList::AddTransportation(), anonymous_namespace{G4VModularPhysicsList.cc}::constructProcessMutex, and G4MT_physicsVector.

Referenced by export_G4VModularPhysicsList().

DisableCheckParticleList()

void G4VUserPhysicsList::DisableCheckParticleList ( )

inlineinherited

Definition at line 379 of file G4VUserPhysicsList.hh.

{
  fDisableCheckParticleList = true;
}

References G4VUserPhysicsList::fDisableCheckParticleList.

DumpCutValuesTable()

void G4VUserPhysicsList::DumpCutValuesTable ( G4int  flag = 1 )

inherited

Definition at line 916 of file G4VUserPhysicsList.cc.

{
  fDisplayThreshold = flag;
}

References fDisplayThreshold.

Referenced by G4RunManagerKernel::BuildPhysicsTables(), export_G4VUserPhysicsList(), PhysicsList::SetCuts(), LBE::SetCuts(), G4VUserPhysicsList::SetCuts(), and G4UserPhysicsListMessenger::SetNewValue().

DumpCutValuesTableIfRequested()

void G4VUserPhysicsList::DumpCutValuesTableIfRequested ( )

inherited

Definition at line 922 of file G4VUserPhysicsList.cc.

{
  if(fDisplayThreshold == 0)
    return;
  G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
  fDisplayThreshold = 0;
}

References G4ProductionCutsTable::DumpCouples(), fDisplayThreshold, and G4ProductionCutsTable::GetProductionCutsTable().

Referenced by G4RunManagerKernel::BuildPhysicsTables(), and export_G4VUserPhysicsList().

DumpList()

void G4VUserPhysicsList::DumpList ( ) const

inherited

Definition at line 895 of file G4VUserPhysicsList.cc.

{
  theParticleIterator->reset();
  G4int idx = 0;
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4cout << particle->GetParticleName();
    if((idx++ % 4) == 3)
    {
      G4cout << G4endl;
    }
    else
    {
      G4cout << ", ";
    }
  }
  G4cout << G4endl;
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), and theParticleIterator.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

GetApplyCuts()

G4bool G4VUserPhysicsList::GetApplyCuts ( const G4String &  name ) const

inherited

Definition at line 1054 of file G4VUserPhysicsList.cc.

{
  return theParticleTable->FindParticle(name)->GetApplyCutsFlag();
}

References G4ParticleTable::FindParticle(), G4ParticleDefinition::GetApplyCutsFlag(), G4InuclParticleNames::name(), and G4VUserPhysicsList::theParticleTable.

Referenced by export_G4VUserPhysicsList().

GetCutValue()

G4double G4VUserPhysicsList::GetCutValue ( const G4String &  pname ) const

inherited

Definition at line 421 of file G4VUserPhysicsList.cc.

{
  std::size_t nReg = (G4RegionStore::GetInstance())->size();
  if(nReg == 0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::GetCutValue "
             << " : No Default Region " << G4endl;
    }
#endif
    G4Exception("G4VUserPhysicsList::GetCutValue", "Run0253", FatalException,
                "No Default Region");
    return -1. * mm;
  }
  G4Region* region =
    G4RegionStore::GetInstance()->GetRegion("DefaultRegionForTheWorld", false);
  return region->GetProductionCuts()->GetProductionCut(name);
}

References FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4ProductionCuts::GetProductionCut(), G4Region::GetProductionCuts(), G4RegionStore::GetRegion(), mm, G4InuclParticleNames::name(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::SetCuts(), and G4UserPhysicsListMessenger::SetNewValue().

GetDefaultCutValue()

G4double G4VUserPhysicsList::GetDefaultCutValue ( ) const

inlineinherited

Definition at line 337 of file G4VUserPhysicsList.hh.

{
  return defaultCutValue;
}

References G4VUserPhysicsList::defaultCutValue.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

GetInstanceID()

G4int G4VModularPhysicsList::GetInstanceID ( ) const

inlineinherited

Definition at line 153 of file G4VModularPhysicsList.hh.

{
  return g4vmplInstanceID;
}

References G4VModularPhysicsList::g4vmplInstanceID.

Referenced by G4VModularPhysicsList::operator=().

GetParticleIterator()

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

protectedinherited

Definition at line 1089 of file G4VUserPhysicsList.cc.

{
  return (subInstanceManager.offset[g4vuplInstanceID])._theParticleIterator;
}

References G4VUserPhysicsList::g4vuplInstanceID, G4VUPLSplitter< T >::offset, and G4VUserPhysicsList::subInstanceManager.

Referenced by G4ErrorPhysicsList::ConstructEM(), and G4ErrorPhysicsList::ConstructProcess().

GetPhysics() [1/2]

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics ( const G4String &  name ) const

inherited

Definition at line 390 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(name == (*itr)->GetPhysicsName())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector, and G4InuclParticleNames::name().

GetPhysics() [2/2]

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysics ( G4int  index ) const

inherited

Definition at line 378 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(G4int i = 0; i < idx && itr != G4MT_physicsVector->cend(); ++i)
    ++itr;
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector.

GetPhysicsTableDirectory()

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory ( ) const

inlineinherited

Definition at line 357 of file G4VUserPhysicsList.hh.

{
  return directoryPhysicsTable;
}

References G4VUserPhysicsList::directoryPhysicsTable.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

GetPhysicsWithType()

const G4VPhysicsConstructor * G4VModularPhysicsList::GetPhysicsWithType ( G4int  physics_type ) const

inherited

Definition at line 406 of file G4VModularPhysicsList.cc.

{
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
    return (*itr);
  else
    return nullptr;
}

References G4MT_physicsVector.

GetSubInstanceManager()

const G4VMPLManager & G4VModularPhysicsList::GetSubInstanceManager ( )

inlinestaticinherited

Definition at line 158 of file G4VModularPhysicsList.hh.

{
  return G4VMPLsubInstanceManager;
}

References G4VModularPhysicsList::G4VMPLsubInstanceManager.

Referenced by G4PhysicsListWorkspace::G4PhysicsListWorkspace().

GetVerboseLevel()

G4int G4VModularPhysicsList::GetVerboseLevel ( ) const

inlineinherited

Definition at line 148 of file G4VModularPhysicsList.hh.

{
  return verboseLevel;
}

References G4VModularPhysicsList::verboseLevel.

Referenced by G4PhysListRegistry::GetModularPhysicsList(), and G4PhysListFactoryMessenger::SetNewValue().

InitializeProcessManager()

void G4VUserPhysicsList::InitializeProcessManager ( )

protectedinherited

Definition at line 217 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table access. Some changes are inside
  // this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex());
  G4ParticleTable::lockCount()++;
#endif
  G4ParticleDefinition* gion =
    G4ParticleTable::GetParticleTable()->GetGenericIon();
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4ProcessManager* pmanager     = particle->GetProcessManager();
 
    if(pmanager == nullptr)
    {
      // create process manager if the particle does not have its own.
      pmanager = new G4ProcessManager(particle);
      particle->SetProcessManager(pmanager);
      if(particle->GetMasterProcessManager() == nullptr)
        particle->SetMasterProcessManager(pmanager);
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::InitializeProcessManager: creating "
                  "ProcessManager to "
               << particle->GetParticleName() << G4endl;
      }
#endif
    }
  }
 
  if(gion != nullptr)
  {
    G4ProcessManager* gionPM = gion->GetProcessManager();
    // loop over all particles once again (this time, with all general ions)
    theParticleIterator->reset(false);
    while((*theParticleIterator)())
    {
      G4ParticleDefinition* particle = theParticleIterator->value();
      if(particle->IsGeneralIon())
      {
        particle->SetProcessManager(gionPM);
#ifdef G4VERBOSE
        if(verboseLevel > 2)
        {
          G4cout << "G4VUserPhysicsList::InitializeProcessManager: copying "
                    "ProcessManager to "
                 << particle->GetParticleName() << G4endl;
        }
#endif
      }
    }
  }
 
  // release lock for particle table access
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
}

References G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4ParticleTable::GetGenericIon(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::IsGeneralIon(), G4ParticleDefinition::SetMasterProcessManager(), G4ParticleDefinition::SetProcessManager(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::Construct().

InitializeWorker()

void G4VUserPhysicsList::InitializeWorker ( )

virtualinherited

Definition at line 117 of file G4VUserPhysicsList.cc.

{
  // Remember messengers are per-thread, so this needs to be done by each
  // worker and due to the presence of "this" cannot be done in
  // G4VUPLData::initialize()
  G4MT_theMessenger = new G4UserPhysicsListMessenger(this);
}

References G4MT_theMessenger.

Referenced by G4WorkerRunManager::SetUserInitialization().

IsPhysicsTableRetrieved()

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved ( ) const

inlineinherited

Definition at line 347 of file G4VUserPhysicsList.hh.

{
  return fRetrievePhysicsTable;
}

References G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

IsStoredInAscii()

G4bool G4VUserPhysicsList::IsStoredInAscii ( ) const

inlineinherited

Definition at line 352 of file G4VUserPhysicsList.hh.

{
  return fStoredInAscii;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::GetCurrentValue().

PreparePhysicsTable()

void G4VUserPhysicsList::PreparePhysicsTable ( G4ParticleDefinition *  particle )

inherited

Definition at line 793 of file G4VUserPhysicsList.cc.

{
  if (auto *trackingManager = particle->GetTrackingManager())
  {
    trackingManager->PreparePhysicsTable(*particle);
    return;
  }
 
  if(!(particle->GetMasterProcessManager()))
  {
    return;
  }
  // Prepare the physics tables for every process for this particle type
  // if particle is not ShortLived
  if(!particle->IsShortLived())
  {
    G4ProcessManager* pManager = particle->GetProcessManager();
    if(pManager == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::PreparePhysicsTable  "
               << ": No Process Manager for " << particle->GetParticleName()
               << G4endl;
        G4cout << particle->GetParticleName()
               << " should be created in your PhysicsList" << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::PreparePhysicsTable", "Run0273",
                  FatalException, "No process manager");
      return;
    }
 
    // Get processes from master thread
    G4ProcessManager* pManagerShadow = particle->GetMasterProcessManager();
 
    G4ProcessVector* pVector = pManager->GetProcessList();
    if(pVector == nullptr)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::PreparePhysicsTable  "
               << ": No Process Vector for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::PreparePhysicsTable", "Run0274",
                  FatalException, "No process Vector");
      return;
    }
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      // Andrea July 16th 2013 : migration to new interface...
      // Infer if we are in a worker thread or master thread
      // Master thread is the one in which the process manager
      // and process manager shadow pointers are the same
      if(pManagerShadow == pManager)
      {
        (*pVector)[j]->PreparePhysicsTable(*particle);
      }
      else
      {
        (*pVector)[j]->PrepareWorkerPhysicsTable(*particle);
      }
    }  // End loop on processes vector
  }    // End if pn ShortLived
}

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetMasterProcessManager(), G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::IsShortLived(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), and G4UserPhysicsListMessenger::SetNewValue().

RegisterPhysics()

void G4VModularPhysicsList::RegisterPhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 150 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0201",
                JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  G4String pName = fPhysics->GetPhysicsName();
  G4int pType    = fPhysics->GetPhysicsType();
  // If physics_type is equal to 0,
  // following duplication check is omitted
  // This is TEMPORAL treatment.
  if(pType == 0)
  {
    G4MT_physicsVector->push_back(fPhysics);
#ifdef G4VERBOSE
    if(verboseLevel > 1)
    {
      G4cout << "G4VModularPhysicsList::RegisterPhysics: " << pName
             << " with type : " << pType << " is added" << G4endl;
    }
#endif
    return;
  }
 
  // Check if physics with the physics_type same as one of given physics
  auto itr = G4MT_physicsVector->cbegin();
  for(; itr != G4MT_physicsVector->cend(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr != G4MT_physicsVector->cend())
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::RegisterPhysics: "
             << "a physics with given type already exists " << G4endl;
      G4cout << " Type = " << pType << " : "
             << "  existing physics is " << (*itr)->GetPhysicsName() << G4endl;
      G4cout << " New " << pName << " can not be registered " << G4endl;
    }
#endif
    G4String comment = "Duplicate type for ";
    comment += pName;
    G4Exception("G4VModularPhysicsList::RegisterPhysics", "Run0202",
                JustWarning, comment);
    return;
  }
 
  // register
  G4MT_physicsVector->push_back(fPhysics);
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4VPhysicsConstructor::GetPhysicsName(), G4VPhysicsConstructor::GetPhysicsType(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

Referenced by export_G4VModularPhysicsList(), FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4PhysListRegistry::GetModularPhysicsList(), NuBeam::NuBeam(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), G4PhysListFactoryMessenger::SetNewValue(), and Shielding::Shielding().

RegisterProcess()

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

protectedinherited

Definition at line 1081 of file G4VUserPhysicsList.cc.

{
  return G4MT_thePLHelper->RegisterProcess(process, particle);
}

References G4MT_thePLHelper.

RemovePhysics() [1/3]

void G4VModularPhysicsList::RemovePhysics ( const G4String &  name )

inherited

Definition at line 343 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0206", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    G4String pName = (*itr)->GetPhysicsName();
    if(name == pName)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, G4InuclParticleNames::name(), and G4VModularPhysicsList::verboseLevel.

RemovePhysics() [2/3]

void G4VModularPhysicsList::RemovePhysics ( G4int  type )

inherited

Definition at line 273 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0204", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    if(pType == (*itr)->GetPhysicsType())
    {
      G4String pName = (*itr)->GetPhysicsName();
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

RemovePhysics() [3/3]

void G4VModularPhysicsList::RemovePhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 308 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::RemovePhysics", "Run0205", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend();)
  {
    if(fPhysics == (*itr))
    {
      G4String pName = (*itr)->GetPhysicsName();
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VModularPhysicsList::RemovePhysics: " << pName
               << " is removed" << G4endl;
      }
#endif
      G4MT_physicsVector->erase(itr);
      break;
    }
    else
    {
      ++itr;
    }
  }
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

RemoveProcessManager()

void G4VUserPhysicsList::RemoveProcessManager ( )

inherited

Definition at line 283 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table access. Some changes are inside
  // this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex());
  G4ParticleTable::lockCount()++;
#endif
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if(particle->GetInstanceID() <
       G4ParticleDefinitionSubInstanceManager::slavetotalspace())
    {
      if(particle->GetParticleSubType() != "generic" ||
         particle->GetParticleName() == "GenericIon")
      {
        G4ProcessManager* pmanager = particle->GetProcessManager();
        if(pmanager != nullptr)
          delete pmanager;
#ifdef G4VERBOSE
        if(verboseLevel > 2)
        {
          G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
          G4cout << "remove ProcessManager from ";
          G4cout << particle->GetParticleName() << G4endl;
        }
#endif
      }
      particle->SetProcessManager(nullptr);
    }
  }
 
  // release lock for particle table access
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
}

References G4cout, G4endl, G4MUTEXLOCK, G4MUTEXUNLOCK, G4ParticleDefinition::GetInstanceID(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleSubType(), G4ParticleDefinition::GetProcessManager(), G4ParticleDefinition::SetProcessManager(), G4PDefManager::slavetotalspace(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::TerminateWorker(), and G4VUserPhysicsList::~G4VUserPhysicsList().

RemoveTrackingManager()

void G4VUserPhysicsList::RemoveTrackingManager ( )

inherited

Definition at line 326 of file G4VUserPhysicsList.cc.

{
  // One tracking manager may be registered for multiple particles, make sure
  // to delete every object only once.
  std::unordered_set<G4VTrackingManager *> trackingManagers;
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    if (auto *trackingManager = particle->GetTrackingManager())
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::RemoveTrackingManager: ";
        G4cout << "remove TrackingManager from ";
        G4cout << particle->GetParticleName() << G4endl;
      }
#endif
      trackingManagers.insert(trackingManager);
      particle->SetTrackingManager(nullptr);
    }
  }
 
  for (G4VTrackingManager *tm : trackingManagers)
  {
    delete tm;
  }
}

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetTrackingManager(), G4ParticleDefinition::SetTrackingManager(), theParticleIterator, G4InuclParticleNames::tm, and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::TerminateWorker(), and G4VUserPhysicsList::~G4VUserPhysicsList().

ReplacePhysics()

void G4VModularPhysicsList::ReplacePhysics ( G4VPhysicsConstructor *  fPhysics )

inherited

Definition at line 211 of file G4VModularPhysicsList.cc.

{
  G4StateManager* stateManager    = G4StateManager::GetStateManager();
  G4ApplicationState currentState = stateManager->GetCurrentState();
  if(!(currentState == G4State_PreInit))
  {
    G4Exception("G4VModularPhysicsList::ReplacePhysics", "Run0203", JustWarning,
                "Geant4 kernel is not PreInit state : Method ignored.");
    return;
  }
 
  G4String pName = fPhysics->GetPhysicsName();
  G4int pType    = fPhysics->GetPhysicsType();
  // If physics_type is equal to 0,
  // duplication check is omitted and just added.
  // This is TEMPORAL treatment.
  if(pType == 0)
  {
    // register
    G4MT_physicsVector->push_back(fPhysics);
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::ReplacePhysics: " << pName
             << " with type : " << pType << " is added" << G4endl;
    }
#endif
    return;
  }
 
  // Check if physics with the physics_type same as one of given physics
  auto itr = G4MT_physicsVector->begin();
  for(; itr != G4MT_physicsVector->end(); ++itr)
  {
    if(pType == (*itr)->GetPhysicsType())
      break;
  }
  if(itr == G4MT_physicsVector->end())
  {
    // register
    G4MT_physicsVector->push_back(fPhysics);
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VModularPhysicsList::ReplacePhysics: "
             << (*itr)->GetPhysicsName() << " with type : " << pType
             << " is replaced with " << pName << G4endl;
    }
#endif
 
    //  delete exsiting one
    delete(*itr);
    // replace with given one
    (*itr) = fPhysics;
  }
  return;
}

References G4cout, G4endl, G4Exception(), G4MT_physicsVector, G4State_PreInit, G4StateManager::GetCurrentState(), G4VPhysicsConstructor::GetPhysicsName(), G4VPhysicsConstructor::GetPhysicsType(), G4StateManager::GetStateManager(), JustWarning, and G4VModularPhysicsList::verboseLevel.

Referenced by G4PhysListRegistry::GetModularPhysicsList(), and G4PhysListFactory::GetReferencePhysList().

ResetPhysicsTableRetrieved()

void G4VUserPhysicsList::ResetPhysicsTableRetrieved ( )

inlineinherited

Definition at line 367 of file G4VUserPhysicsList.hh.

{
  fRetrievePhysicsTable             = false;
  fIsRestoredCutValues              = false;
  fIsCheckedForRetrievePhysicsTable = false;
}

References G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable, G4VUserPhysicsList::fIsRestoredCutValues, and G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

ResetStoredInAscii()

void G4VUserPhysicsList::ResetStoredInAscii ( )

inlineinherited

Definition at line 374 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = false;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

RetrievePhysicsTable()

void G4VUserPhysicsList::RetrievePhysicsTable ( G4ParticleDefinition *  particle, const G4String &  directory, G4bool  ascii = false  )

protectedvirtualinherited

Definition at line 996 of file G4VUserPhysicsList.cc.

{
  G4bool success[100];
  // Retrieve physics tables for every process for this particle type
  G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
  for(std::size_t j = 0; j < pVector->size(); ++j)
  {
    success[j] =
      (*pVector)[j]->RetrievePhysicsTable(particle, directory, ascii);
 
    if(!success[j])
    {
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::RetrievePhysicsTable   "
               << " Fail to retrieve Physics Table for "
               << (*pVector)[j]->GetProcessName() << G4endl;
        G4cout << "Calculate Physics Table for " << particle->GetParticleName()
               << G4endl;
      }
#endif
      (*pVector)[j]->BuildPhysicsTable(*particle);
    }
  }
  for(std::size_t j = 0; j < pVector->size(); ++j)
  {
    // temporary addition to make the integral schema
    if(!success[j])
      BuildIntegralPhysicsTable((*pVector)[j], particle);
  }
}

References G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), G4ProcessVector::size(), and G4VUserPhysicsList::verboseLevel.

Referenced by G4VUserPhysicsList::BuildPhysicsTable().

SetApplyCuts()

void G4VUserPhysicsList::SetApplyCuts ( G4bool  value, const G4String &  name  )

inherited

Definition at line 1032 of file G4VUserPhysicsList.cc.

{
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::SetApplyCuts for " << name << G4endl;
  }
#endif
  if(name == "all")
  {
    theParticleTable->FindParticle("gamma")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("e-")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("e+")->SetApplyCutsFlag(value);
    theParticleTable->FindParticle("proton")->SetApplyCutsFlag(value);
  }
  else
  {
    theParticleTable->FindParticle(name)->SetApplyCutsFlag(value);
  }
}

References G4ParticleTable::FindParticle(), G4cout, G4endl, G4InuclParticleNames::name(), G4ParticleDefinition::SetApplyCutsFlag(), G4VUserPhysicsList::theParticleTable, and G4VUserPhysicsList::verboseLevel.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCuts()

void pyG4VModularPhysicsList::CB_G4VModularPhysicsList::SetCuts ( )

inlinevirtual

Reimplemented from G4VUserPhysicsList.

Definition at line 44 of file pyG4VModularPhysicsList.cc.

                 {
    get_override("SetCuts")();
  }

SetCutsForRegion()

void G4VUserPhysicsList::SetCutsForRegion ( G4double  aCut, const G4String &  rname  )

inherited

Definition at line 478 of file G4VUserPhysicsList.cc.

{
  // set cut values for gamma at first and for e- and e+
  SetCutValue(aCut, "gamma", rname);
  SetCutValue(aCut, "e-", rname);
  SetCutValue(aCut, "e+", rname);
  SetCutValue(aCut, "proton", rname);
}

References G4VUserPhysicsList::SetCutValue().

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

SetCutsWithDefault()

void G4VUserPhysicsList::SetCutsWithDefault ( )

inherited

Definition at line 471 of file G4VUserPhysicsList.cc.

{
  SetDefaultCutValue(defaultCutValue);
  G4VUserPhysicsList::SetCuts();
}

References G4VUserPhysicsList::defaultCutValue, G4VUserPhysicsList::SetCuts(), and G4VUserPhysicsList::SetDefaultCutValue().

Referenced by export_G4VUserPhysicsList(), PhysicsListEMstd::SetCuts(), ExN01PhysicsList::SetCuts(), QPhysicsList::SetCuts(), G4ErrorPhysicsList::SetCuts(), FTFP_BERT_HP::SetCuts(), and QGSP_BERT_HP::SetCuts().

SetCutValue() [1/2]

void G4VUserPhysicsList::SetCutValue ( G4double  aCut, const G4String &  pname  )

inherited

Definition at line 443 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts(aCut, name);
}

References G4InuclParticleNames::name(), and G4VUserPhysicsList::SetParticleCuts().

Referenced by QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), PhysicsList::SetCuts(), FTFP_BERT_HP::SetCuts(), LBE::SetCuts(), QGSP_BERT_HP::SetCuts(), G4VUserPhysicsList::SetCutsForRegion(), G4VUserPhysicsList::SetDefaultCutValue(), G4UserPhysicsListMessenger::SetNewValue(), and Shielding::Shielding().

SetCutValue() [2/2]

void G4VUserPhysicsList::SetCutValue ( G4double  aCut, const G4String &  pname, const G4String &  rname  )

inherited

Definition at line 449 of file G4VUserPhysicsList.cc.

{
  G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
  if(region != nullptr)
  {
    // set cut value
    SetParticleCuts(aCut, pname, region);
  }
  else
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetCutValue "
             << " : No Region of " << rname << G4endl;
    }
#endif
  }
}

References G4cout, G4endl, G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), eplot::pname, G4VUserPhysicsList::SetParticleCuts(), and G4VUserPhysicsList::verboseLevel.

SetDefaultCutValue()

void G4VUserPhysicsList::SetDefaultCutValue ( G4double  newCutValue )

inherited

Definition at line 387 of file G4VUserPhysicsList.cc.

{
  if(value < 0.0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetDefaultCutValue: negative cut values"
             << "  :" << value / mm << "[mm]" << G4endl;
    }
#endif
    return;
  }
 
  defaultCutValue      = value;
  isSetDefaultCutValue = true;
 
  // set cut values for gamma at first and for e- and e+
  SetCutValue(defaultCutValue, "gamma");
  SetCutValue(defaultCutValue, "e-");
  SetCutValue(defaultCutValue, "e+");
  SetCutValue(defaultCutValue, "proton");
 
#ifdef G4VERBOSE
  if(verboseLevel > 1)
  {
    G4cout << "G4VUserPhysicsList::SetDefaultCutValue:"
           << "default cut value is changed to   :" << defaultCutValue / mm
           << "[mm]" << G4endl;
  }
#endif
}

References G4VUserPhysicsList::defaultCutValue, G4cout, G4endl, G4VUserPhysicsList::isSetDefaultCutValue, mm, G4VUserPhysicsList::SetCutValue(), and G4VUserPhysicsList::verboseLevel.

Referenced by export_G4VUserPhysicsList(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutsWithDefault(), G4UserPhysicsListMessenger::SetNewValue(), and G4VUserPhysicsList::SetParticleCuts().

SetParticleCuts() [1/2]

void G4VUserPhysicsList::SetParticleCuts ( G4double  cut, const G4String &  particleName, G4Region *  region = nullptr  )

inherited

Definition at line 496 of file G4VUserPhysicsList.cc.

{
  if(cut < 0.0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4VUserPhysicsList::SetParticleCuts: negative cut values"
             << "  :" << cut / mm << "[mm]"
             << " for " << particleName << G4endl;
    }
#endif
    return;
  }
 
  G4Region* world_region =
    G4RegionStore::GetInstance()->GetRegion("DefaultRegionForTheWorld", false);
  if(region == nullptr)
  {
    std::size_t nReg = G4RegionStore::GetInstance()->size();
    if(nReg == 0)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4VUserPhysicsList::SetParticleCuts "
               << " : No Default Region " << G4endl;
      }
#endif
      G4Exception("G4VUserPhysicsList::SetParticleCuts ", "Run0254",
                  FatalException, "No Default Region");
      return;
    }
    region = world_region;
  }
 
  if(!isSetDefaultCutValue)
  {
    SetDefaultCutValue(defaultCutValue);
  }
 
  G4ProductionCuts* pcuts = region->GetProductionCuts();
  if(region != world_region &&
     pcuts == G4ProductionCutsTable::GetProductionCutsTable()
                ->GetDefaultProductionCuts())
  {  // This region had no unique cuts yet but shares the default cuts.
     // Need to create a new object before setting the value.
    pcuts =
      new G4ProductionCuts(*(G4ProductionCutsTable::GetProductionCutsTable()
                               ->GetDefaultProductionCuts()));
    region->SetProductionCuts(pcuts);
  }
  pcuts->SetProductionCut(cut, particleName);
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::SetParticleCuts: "
           << "  :" << cut / mm << "[mm]"
           << " for " << particleName << G4endl;
  }
#endif
}

References G4VUserPhysicsList::defaultCutValue, FatalException, G4cout, G4endl, G4Exception(), G4RegionStore::GetInstance(), G4Region::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4RegionStore::GetRegion(), G4VUserPhysicsList::isSetDefaultCutValue, mm, G4VUserPhysicsList::SetDefaultCutValue(), G4ProductionCuts::SetProductionCut(), G4Region::SetProductionCuts(), and G4VUserPhysicsList::verboseLevel.

SetParticleCuts() [2/2]

void G4VUserPhysicsList::SetParticleCuts ( G4double  cut, G4ParticleDefinition *  particle, G4Region *  region = nullptr  )

inherited

Definition at line 488 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts(cut, particle->GetParticleName(), region);
}

References G4ParticleDefinition::GetParticleName(), and G4VUserPhysicsList::SetParticleCuts().

Referenced by PhysicsList::SetCutForElectron(), PhysicsList::SetCutForGamma(), PhysicsList::SetCutForPositron(), G4VUserPhysicsList::SetCutValue(), and G4VUserPhysicsList::SetParticleCuts().

SetPhysicsTableRetrieved()

void G4VUserPhysicsList::SetPhysicsTableRetrieved ( const G4String &  directory = "" )

inherited

Definition at line 984 of file G4VUserPhysicsList.cc.

{
  fRetrievePhysicsTable = true;
  if(!directory.empty())
  {
    directoryPhysicsTable = directory;
  }
  fIsCheckedForRetrievePhysicsTable = false;
  fIsRestoredCutValues              = false;
}

References G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable, G4VUserPhysicsList::fIsRestoredCutValues, and G4VUserPhysicsList::fRetrievePhysicsTable.

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetStoredInAscii()

void G4VUserPhysicsList::SetStoredInAscii ( )

inlineinherited

Definition at line 362 of file G4VUserPhysicsList.hh.

{
  fStoredInAscii = true;
}

References G4VUserPhysicsList::fStoredInAscii.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

SetVerboseLevel()

void G4VModularPhysicsList::SetVerboseLevel ( G4int  value )

inherited

Definition at line 422 of file G4VModularPhysicsList.cc.

{
  verboseLevel = value;
  // Loop over constructors
  for(auto itr = G4MT_physicsVector->cbegin();
           itr != G4MT_physicsVector->cend(); ++itr)
  {
    (*itr)->SetVerboseLevel(verboseLevel);
  }
}

References G4MT_physicsVector, and G4VModularPhysicsList::verboseLevel.

Referenced by FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4PhysListRegistry::GetModularPhysicsList(), LBE::LBE(), NuBeam::NuBeam(), PhysicsList::PhysicsList(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), and Shielding::Shielding().

StorePhysicsTable()

G4bool G4VUserPhysicsList::StorePhysicsTable ( const G4String &  directory = "." )

inherited

Definition at line 931 of file G4VUserPhysicsList.cc.

{
  G4bool ascii = fStoredInAscii;
  G4String dir = directory;
  if(dir.empty())
    dir = directoryPhysicsTable;
  else
    directoryPhysicsTable = dir;
 
  // store CutsTable info
  if(!fCutsTable->StoreCutsTable(dir, ascii))
  {
    G4Exception("G4VUserPhysicsList::StorePhysicsTable", "Run0281", JustWarning,
                "Fail to store Cut Table");
    return false;
  }
#ifdef G4VERBOSE
  if(verboseLevel > 2)
  {
    G4cout << "G4VUserPhysicsList::StorePhysicsTable   "
           << " Store material and cut values successfully" << G4endl;
  }
#endif
 
  G4bool success = true;
 
  // loop over all particles in G4ParticleTable
  theParticleIterator->reset();
  while((*theParticleIterator)())
  {
    G4ParticleDefinition* particle = theParticleIterator->value();
    // Store physics tables for every process for this particle type
    G4ProcessVector* pVector =
      (particle->GetProcessManager())->GetProcessList();
    for(std::size_t j = 0; j < pVector->size(); ++j)
    {
      if(!(*pVector)[j]->StorePhysicsTable(particle, dir, ascii))
      {
        G4String comment = "Fail to store physics table for ";
        comment += (*pVector)[j]->GetProcessName();
        comment += "(" + particle->GetParticleName() + ")";
        G4Exception("G4VUserPhysicsList::StorePhysicsTable", "Run0282",
                    JustWarning, comment);
        success = false;
      }
    }
    // end loop over processes
  }
  // end loop over particles
  return success;
}

References G4VUserPhysicsList::directoryPhysicsTable, G4VUserPhysicsList::fCutsTable, G4VUserPhysicsList::fStoredInAscii, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetProcessManager(), JustWarning, G4ProcessVector::size(), G4ProductionCutsTable::StoreCutsTable(), theParticleIterator, and G4VUserPhysicsList::verboseLevel.

Referenced by export_G4VUserPhysicsList(), and G4UserPhysicsListMessenger::SetNewValue().

TerminateWorker()

void G4VModularPhysicsList::TerminateWorker ( )

overridevirtualinherited

Reimplemented from G4VUserPhysicsList.

Definition at line 434 of file G4VModularPhysicsList.cc.

{
  // See https://jira-geant4.kek.jp/browse/DEV-284
  std::for_each(
    G4MT_physicsVector->cbegin(), G4MT_physicsVector->cend(),
    [](G4PhysConstVector::value_type el) { el->TerminateWorker(); });
  G4VUserPhysicsList::TerminateWorker();
}

References G4MT_physicsVector, and G4VUserPhysicsList::TerminateWorker().

UseCoupledTransportation()

void G4VUserPhysicsList::UseCoupledTransportation ( G4bool  vl = true )

inherited

Definition at line 1075 of file G4VUserPhysicsList.cc.

{
  G4MT_thePLHelper->UseCoupledTransportation(vl);
}

References G4MT_thePLHelper.

Referenced by G4RunManagerKernel::InitializePhysics().

Field Documentation

defaultCutValue

G4double G4VUserPhysicsList::defaultCutValue = 1.0

protectedinherited

Definition at line 285 of file G4VUserPhysicsList.hh.

Referenced by FTF_BIC::FTF_BIC(), FTFP_BERT::FTFP_BERT(), FTFP_BERT_ATL::FTFP_BERT_ATL(), FTFP_BERT_HP::FTFP_BERT_HP(), FTFP_BERT_TRV::FTFP_BERT_TRV(), FTFQGSP_BERT::FTFQGSP_BERT(), G4ErrorPhysicsList::G4ErrorPhysicsList(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetDefaultCutValue(), LBE::LBE(), NuBeam::NuBeam(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), PhysicsListEMstd::PhysicsListEMstd(), QBBC::QBBC(), QGS_BIC::QGS_BIC(), QGSP_BERT::QGSP_BERT(), QGSP_BERT_HP::QGSP_BERT_HP(), QGSP_BIC::QGSP_BIC(), QGSP_BIC_AllHP::QGSP_BIC_AllHP(), QGSP_BIC_HP::QGSP_BIC_HP(), QGSP_FTFP_BERT::QGSP_FTFP_BERT(), QPhysicsList::QPhysicsList(), LBE::SetCuts(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutsWithDefault(), G4VUserPhysicsList::SetDefaultCutValue(), G4VUserPhysicsList::SetParticleCuts(), and Shielding::Shielding().

directoryPhysicsTable

G4String G4VUserPhysicsList::directoryPhysicsTable = "."

protectedinherited

Definition at line 299 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::GetPhysicsTableDirectory(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::SetPhysicsTableRetrieved(), and G4VUserPhysicsList::StorePhysicsTable().

fCutsTable

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable = nullptr

protectedinherited

Definition at line 289 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::SetVerboseLevel(), and G4VUserPhysicsList::StorePhysicsTable().

fDisableCheckParticleList

G4bool G4VUserPhysicsList::fDisableCheckParticleList = false

protectedinherited

Definition at line 302 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::CheckParticleList(), G4VUserPhysicsList::DisableCheckParticleList(), G4VModularPhysicsList::operator=(), and G4VUserPhysicsList::operator=().

fIsCheckedForRetrievePhysicsTable

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable = false

protectedinherited

Definition at line 296 of file G4VUserPhysicsList.hh.

Referenced by G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fIsRestoredCutValues

G4bool G4VUserPhysicsList::fIsRestoredCutValues = false

protectedinherited

Definition at line 297 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fRetrievePhysicsTable

G4bool G4VUserPhysicsList::fRetrievePhysicsTable = false

protectedinherited

Definition at line 292 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::IsPhysicsTableRetrieved(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetPhysicsTableRetrieved(), and G4VUserPhysicsList::SetPhysicsTableRetrieved().

fStoredInAscii

G4bool G4VUserPhysicsList::fStoredInAscii = true

protectedinherited

Definition at line 294 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::IsStoredInAscii(), G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::ResetStoredInAscii(), G4VUserPhysicsList::SetStoredInAscii(), and G4VUserPhysicsList::StorePhysicsTable().

g4vmplInstanceID

G4int G4VModularPhysicsList::g4vmplInstanceID = 0

protectedinherited

Definition at line 142 of file G4VModularPhysicsList.hh.

Referenced by G4VModularPhysicsList::G4VModularPhysicsList(), G4VModularPhysicsList::GetInstanceID(), and G4VModularPhysicsList::operator=().

G4VMPLsubInstanceManager

G4VMPLManager G4VModularPhysicsList::G4VMPLsubInstanceManager

staticprotectedinherited

Definition at line 143 of file G4VModularPhysicsList.hh.

Referenced by G4VModularPhysicsList::G4VModularPhysicsList(), G4VModularPhysicsList::GetSubInstanceManager(), and G4VModularPhysicsList::operator=().

g4vuplInstanceID

G4int G4VUserPhysicsList::g4vuplInstanceID = 0

protectedinherited

Definition at line 305 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetInstanceID(), G4VUserPhysicsList::GetParticleIterator(), and G4VModularPhysicsList::operator=().

isSetDefaultCutValue

G4bool G4VUserPhysicsList::isSetDefaultCutValue = false

protectedinherited

Definition at line 287 of file G4VUserPhysicsList.hh.

Referenced by G4VModularPhysicsList::operator=(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetDefaultCutValue(), and G4VUserPhysicsList::SetParticleCuts().

subInstanceManager

G4VUPLManager G4VUserPhysicsList::subInstanceManager

staticprotectedinherited

Definition at line 306 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetParticleIterator(), G4VUserPhysicsList::GetSubInstanceManager(), and G4VModularPhysicsList::operator=().

theParticleTable

G4ParticleTable* G4VUserPhysicsList::theParticleTable = nullptr

protectedinherited

Definition at line 280 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetApplyCuts(), G4VUserPhysicsList::SetApplyCuts(), and G4VUserPhysicsList::~G4VUserPhysicsList().

verboseLevel

G4int G4VModularPhysicsList::verboseLevel = 0

protectedinherited

Definition at line 141 of file G4VModularPhysicsList.hh.

Referenced by PhysicsList::AddPhysicsList(), G4VModularPhysicsList::GetVerboseLevel(), G4VModularPhysicsList::operator=(), G4VModularPhysicsList::RegisterPhysics(), G4VModularPhysicsList::RemovePhysics(), G4VModularPhysicsList::ReplacePhysics(), FTFP_BERT_HP::SetCuts(), LBE::SetCuts(), QGSP_BERT_HP::SetCuts(), and G4VModularPhysicsList::SetVerboseLevel().

---

The documentation for this struct was generated from the following file:

• environments/g4py/source/run/pyG4VModularPhysicsList.cc