ExN01PhysicsList Class Reference

#include <ExN01PhysicsList.hh>

Inheritance diagram for ExN01PhysicsList:

Public Member Functions
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=nullptr)
void	BuildPhysicsTable ()
void	BuildPhysicsTable (G4ParticleDefinition *)
void	CheckParticleList ()
void	Construct ()
void	DisableCheckParticleList ()
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	DumpList () const
	ExN01PhysicsList ()
G4bool	GetApplyCuts (const G4String &name) const
G4double	GetCutValue (const G4String &pname) const
G4double	GetDefaultCutValue () const
G4int	GetInstanceID () const
const G4String &	GetPhysicsTableDirectory () const
G4int	GetVerboseLevel () const
virtual void	InitializeWorker ()
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
void	PreparePhysicsTable (G4ParticleDefinition *)
void	RemoveProcessManager ()
void	RemoveTrackingManager ()
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	SetApplyCuts (G4bool value, const G4String &name)
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 ()
void	UseCoupledTransportation (G4bool vl=true)
	~ExN01PhysicsList ()

Static Public Member Functions
static const G4VUPLManager &	GetSubInstanceManager ()

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

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	g4vuplInstanceID = 0
G4bool	isSetDefaultCutValue = false
G4ParticleTable *	theParticleTable = nullptr
G4int	verboseLevel = 1

Static Protected Attributes
static G4RUN_DLL G4VUPLManager	subInstanceManager

Private Types
enum	{ FixedStringLengthForStore = 32 }

Detailed Description

Definition at line 43 of file ExN01PhysicsList.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

privateinherited

Enumerator
FixedStringLengthForStore

Definition at line 311 of file G4VUserPhysicsList.hh.

    {
      FixedStringLengthForStore = 32
    };

Constructor & Destructor Documentation

ExN01PhysicsList()

ExN01PhysicsList::ExN01PhysicsList

(

)

Definition at line 41 of file ExN01PhysicsList.cc.

{
}

~ExN01PhysicsList()

ExN01PhysicsList::~ExN01PhysicsList

(

)

Definition at line 47 of file ExN01PhysicsList.cc.

{
}

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(), 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 ExN01PhysicsList::ConstructParticle ( )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 53 of file ExN01PhysicsList.cc.

{
  G4Geantino::GeantinoDefinition();
}

References G4Geantino::GeantinoDefinition().

ConstructProcess()

void ExN01PhysicsList::ConstructProcess ( )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 60 of file ExN01PhysicsList.cc.

{
  AddTransportation();
}

References G4VUserPhysicsList::AddTransportation().

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 G4VUserPhysicsList::GetInstanceID ( ) const

inlineinherited

Definition at line 384 of file G4VUserPhysicsList.hh.

{
  return g4vuplInstanceID;
}

References G4VUserPhysicsList::g4vuplInstanceID.

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), and G4VUserPhysicsList::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().

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

GetSubInstanceManager()

const G4VUPLManager & G4VUserPhysicsList::GetSubInstanceManager ( )

inlinestaticinherited

Definition at line 389 of file G4VUserPhysicsList.hh.

{
  return subInstanceManager;
}

References G4VUserPhysicsList::subInstanceManager.

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

GetVerboseLevel()

G4int G4VUserPhysicsList::GetVerboseLevel ( ) const

inlineinherited

Definition at line 342 of file G4VUserPhysicsList.hh.

{
  return verboseLevel;
}

References G4VUserPhysicsList::verboseLevel.

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

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

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.

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

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 ExN01PhysicsList::SetCuts ( )

protectedvirtual

Reimplemented from G4VUserPhysicsList.

Definition at line 67 of file ExN01PhysicsList.cc.

{
  G4int temp = GetVerboseLevel();
  SetVerboseLevel(0);
 
  SetCutsWithDefault();   
 
  SetVerboseLevel(temp);  
}

References G4VUserPhysicsList::GetVerboseLevel(), G4VUserPhysicsList::SetCutsWithDefault(), and G4VUserPhysicsList::SetVerboseLevel().

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(), 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 G4VUserPhysicsList::SetVerboseLevel ( G4int  value )

inherited

Definition at line 1095 of file G4VUserPhysicsList.cc.

{
  verboseLevel = value;
  // set verboseLevel for G4ProductionCutsTable same as one for
  // G4VUserPhysicsList:
  fCutsTable->SetVerboseLevel(verboseLevel);
 
  G4MT_thePLHelper->SetVerboseLevel(verboseLevel);
 
#ifdef G4VERBOSE
  if(verboseLevel > 1)
  {
    G4cout << "G4VUserPhysicsList::SetVerboseLevel  :"
           << " Verbose level is set to " << verboseLevel << G4endl;
  }
#endif
}

References G4VUserPhysicsList::fCutsTable, G4cout, G4endl, G4MT_thePLHelper, G4ProductionCutsTable::SetVerboseLevel(), and G4VUserPhysicsList::verboseLevel.

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

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 G4VUserPhysicsList::TerminateWorker ( )

virtualinherited

Reimplemented in G4VModularPhysicsList.

Definition at line 126 of file G4VUserPhysicsList.cc.

{
  RemoveProcessManager();
  RemoveTrackingManager();
  delete G4MT_theMessenger;
  G4MT_theMessenger = nullptr;
}

References G4MT_theMessenger, G4VUserPhysicsList::RemoveProcessManager(), and G4VUserPhysicsList::RemoveTrackingManager().

Referenced by G4VModularPhysicsList::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().

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 G4VUserPhysicsList::verboseLevel = 1

protectedinherited

Definition at line 283 of file G4VUserPhysicsList.hh.

Referenced by G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VUserPhysicsList::BuildPhysicsTable(), G4VUserPhysicsList::Construct(), G4ErrorPhysicsList::ConstructProcess(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUserPhysicsList::GetCutValue(), G4VUserPhysicsList::GetVerboseLevel(), G4VUserPhysicsList::InitializeProcessManager(), G4VUserPhysicsList::operator=(), G4VUserPhysicsList::PreparePhysicsTable(), G4VUserPhysicsList::RemoveProcessManager(), G4VUserPhysicsList::RemoveTrackingManager(), G4VUserPhysicsList::RetrievePhysicsTable(), G4VUserPhysicsList::SetApplyCuts(), G4VUserPhysicsList::SetCuts(), G4VUserPhysicsList::SetCutValue(), G4VUserPhysicsList::SetDefaultCutValue(), G4VUserPhysicsList::SetParticleCuts(), G4VUserPhysicsList::SetVerboseLevel(), and G4VUserPhysicsList::StorePhysicsTable().

---

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

• environments/g4py/tests/g4pytest/ExN01pl/ExN01PhysicsList.hh
• environments/g4py/tests/g4pytest/ExN01pl/ExN01PhysicsList.cc