G4VUserPhysicsList Class Reference

#include <G4VUserPhysicsList.hh>

Inheritance diagram for G4VUserPhysicsList:

Public Member Functions
	G4VUserPhysicsList ()
virtual	~G4VUserPhysicsList ()
	G4VUserPhysicsList (const G4VUserPhysicsList &)
G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)
virtual void	ConstructParticle ()=0
void	Construct ()
virtual void	ConstructProcess ()=0
void	UseCoupledTransportation (G4bool vl=true)
virtual void	SetCuts ()
void	SetDefaultCutValue (G4double newCutValue)
G4double	GetDefaultCutValue () const
void	BuildPhysicsTable ()
void	PreparePhysicsTable (G4ParticleDefinition *)
void	BuildPhysicsTable (G4ParticleDefinition *)
G4bool	StorePhysicsTable (const G4String &directory=".")
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
const G4String &	GetPhysicsTableDirectory () const
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	DumpList () const
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
G4double	GetCutValue (const G4String &pname) const
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=0)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=0)
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	ResetCuts ()
	obsolete methods
void	SetApplyCuts (G4bool value, const G4String &name)
G4bool	GetApplyCuts (const G4String &name) const
void	RemoveProcessManager ()
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=0)
void	CheckParticleList ()
void	DisableCheckParticleList ()
G4int	GetInstanceID () const
virtual void	InitializeWorker ()
virtual void	TerminateWorker ()

Static Public Member Functions
static const G4VUPLManager &	GetSubInstanceManager ()

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

Protected Attributes
G4ParticleTable *	theParticleTable
G4int	verboseLevel
G4double	defaultCutValue
G4bool	isSetDefaultCutValue
G4ProductionCutsTable *	fCutsTable
G4bool	fRetrievePhysicsTable
G4bool	fStoredInAscii
G4bool	fIsCheckedForRetrievePhysicsTable
G4bool	fIsRestoredCutValues
G4String	directoryPhysicsTable
G4bool	fDisableCheckParticleList
G4int	g4vuplInstanceID

Static Protected Attributes
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 157 of file G4VUserPhysicsList.hh.

Constructor & Destructor Documentation

G4VUserPhysicsList() [1/2]

G4VUserPhysicsList::G4VUserPhysicsList

(

)

Definition at line 108 of file G4VUserPhysicsList.cc.

  : verboseLevel(1)
  , defaultCutValue(1.0 * mm)
  , isSetDefaultCutValue(false)
  , fRetrievePhysicsTable(false)
  , fStoredInAscii(true)
  , fIsCheckedForRetrievePhysicsTable(false)
  , fIsRestoredCutValues(false)
  , directoryPhysicsTable(".")
  ,
  // fDisplayThreshold(0),
  // fIsPhysicsTableBuilt(false),
  fDisableCheckParticleList(false)
{
  g4vuplInstanceID = subInstanceManager.CreateSubInstance();  // AND
  // default cut value  (1.0mm)
  defaultCutValue = 1.0 * mm;
 
  // pointer to the particle table
  theParticleTable = G4ParticleTable::GetParticleTable();
  // theParticleIterator = theParticleTable->GetIterator();
 
  // pointer to the cuts table
  fCutsTable = G4ProductionCutsTable::GetProductionCutsTable();
 
  // set energy range for SetCut calcuration
  fCutsTable->SetEnergyRange(0.99 * keV, 100 * TeV);
 
  // UI Messenger
  // theMessenger = new G4UserPhysicsListMessenger(this);
  G4MT_theMessenger = new G4UserPhysicsListMessenger(this);  // AND
 
  // PhysicsListHelper
  // thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  // thePLHelper->SetVerboseLevel(verboseLevel);
  // G4MT_thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper(); //AND
  G4MT_thePLHelper->SetVerboseLevel(verboseLevel);  // AND
 
  fIsPhysicsTableBuilt = false;
  fDisplayThreshold    = 0;
}

~G4VUserPhysicsList()

G4VUserPhysicsList::~G4VUserPhysicsList ( )

virtual

Definition at line 165 of file G4VUserPhysicsList.cc.

{
  if(G4MT_theMessenger != 0)
  {
    delete G4MT_theMessenger;
    G4MT_theMessenger = 0;
  }
  RemoveProcessManager();
 
  // invoke DeleteAllParticle
  theParticleTable->DeleteAllParticles();
}

G4VUserPhysicsList() [2/2]

G4VUserPhysicsList::G4VUserPhysicsList

(

const G4VUserPhysicsList &

right

)

Definition at line 179 of file G4VUserPhysicsList.cc.

  : verboseLevel(right.verboseLevel)
  , defaultCutValue(right.defaultCutValue)
  , isSetDefaultCutValue(right.isSetDefaultCutValue)
  , fRetrievePhysicsTable(right.fRetrievePhysicsTable)
  , fStoredInAscii(right.fStoredInAscii)
  , fIsCheckedForRetrievePhysicsTable(right.fIsCheckedForRetrievePhysicsTable)
  , fIsRestoredCutValues(right.fIsRestoredCutValues)
  , directoryPhysicsTable(right.directoryPhysicsTable)
  ,
  // fDisplayThreshold(right.fDisplayThreshold),
  // fIsPhysicsTableBuilt(right.fIsPhysicsTableBuilt),
  fDisableCheckParticleList(right.fDisableCheckParticleList)
{
  g4vuplInstanceID = subInstanceManager.CreateSubInstance();  // AND
  // pointer to the particle table
  theParticleTable    = G4ParticleTable::GetParticleTable();
  theParticleIterator = theParticleTable->GetIterator();
  // pointer to the cuts table
  fCutsTable = G4ProductionCutsTable::GetProductionCutsTable();
 
  // UI Messenger
  // theMessenger = new G4UserPhysicsListMessenger(this);
  G4MT_theMessenger = new G4UserPhysicsListMessenger(this);  // AND
 
  // PhysicsListHelper
  // thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();
  // thePLHelper->SetVerboseLevel(verboseLevel);
  G4MT_thePLHelper = G4PhysicsListHelper::GetPhysicsListHelper();  // AND
  G4MT_thePLHelper->SetVerboseLevel(verboseLevel);                 // AND
 
  fIsPhysicsTableBuilt = right.GetSubInstanceManager()
                           .offset[right.GetInstanceID()]
                           ._fIsPhysicsTableBuilt;
  fDisplayThreshold = right.GetSubInstanceManager()
                        .offset[right.GetInstanceID()]
                        ._fDisplayThreshold;
}

Member Function Documentation

AddProcessManager()

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

Definition at line 246 of file G4VUserPhysicsList.cc.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

AddTransportation()

void G4VUserPhysicsList::AddTransportation ( )

protected

Definition at line 1063 of file G4VUserPhysicsList.cc.

{
  G4MT_thePLHelper->AddTransportation();
}

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

BuildIntegralPhysicsTable()

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

protected

Definition at line 858 of file G4VUserPhysicsList.cc.

{
  //*********************************************************************
  // 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);
  }
}

Referenced by RetrievePhysicsTable().

BuildPhysicsTable() [1/2]

void G4VUserPhysicsList::BuildPhysicsTable

(

)

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

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

BuildPhysicsTable() [2/2]

void G4VUserPhysicsList::BuildPhysicsTable

(

G4ParticleDefinition *

particle

)

Definition at line 657 of file G4VUserPhysicsList.cc.

{
  if(!(particle->GetMasterProcessManager()))
  {
    G4cout
      << "#### G4VUserPhysicsList::BuildPhysicsTable() - BuildPhysicsTable("
      << particle->GetParticleName() << ") skipped..." << G4endl;
    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)
    {
#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)
    {
#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
}

CheckParticleList()

void G4VUserPhysicsList::CheckParticleList

(

)

Definition at line 1054 of file G4VUserPhysicsList.cc.

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

Referenced by G4RunManagerKernel::InitializePhysics().

Construct()

void G4VUserPhysicsList::Construct ( )

inline

Definition at line 412 of file G4VUserPhysicsList.hh.

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

Referenced by G4RunManagerKernel::InitializePhysics().

ConstructParticle()

virtual void G4VUserPhysicsList::ConstructParticle ( )

pure virtual

Implemented in G4ErrorPhysicsList, LBE, and G4VModularPhysicsList.

Referenced by G4RunManagerKernel::SetupPhysics().

ConstructProcess()

virtual void G4VUserPhysicsList::ConstructProcess ( )

pure virtual

Implemented in G4ErrorPhysicsList, LBE, and G4VModularPhysicsList.

Referenced by Construct().

DisableCheckParticleList()

void G4VUserPhysicsList::DisableCheckParticleList ( )

inline

Definition at line 464 of file G4VUserPhysicsList.hh.

{
  fDisableCheckParticleList = true;
}

DumpCutValuesTable()

void G4VUserPhysicsList::DumpCutValuesTable

(

G4int

flag = 1

)

Definition at line 910 of file G4VUserPhysicsList.cc.

{
  fDisplayThreshold = flag;
}

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

DumpCutValuesTableIfRequested()

void G4VUserPhysicsList::DumpCutValuesTableIfRequested

(

)

Definition at line 916 of file G4VUserPhysicsList.cc.

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

Referenced by G4RunManagerKernel::BuildPhysicsTables().

DumpList()

void G4VUserPhysicsList::DumpList

(

)

const

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

GetApplyCuts()

G4bool G4VUserPhysicsList::GetApplyCuts

(

const G4String &

name

)

const

Definition at line 1048 of file G4VUserPhysicsList.cc.

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

GetCutValue()

G4double G4VUserPhysicsList::GetCutValue

(

const G4String &

pname

)

const

Definition at line 434 of file G4VUserPhysicsList.cc.

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

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

GetDefaultCutValue()

G4double G4VUserPhysicsList::GetDefaultCutValue ( ) const

inline

Definition at line 428 of file G4VUserPhysicsList.hh.

{
  return defaultCutValue;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

GetInstanceID()

G4int G4VUserPhysicsList::GetInstanceID ( ) const

inline

Definition at line 469 of file G4VUserPhysicsList.hh.

{
  return g4vuplInstanceID;
}

Referenced by G4VUserPhysicsList(), and operator=().

GetParticleIterator()

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

protected

Definition at line 1082 of file G4VUserPhysicsList.cc.

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

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

GetPhysicsTableDirectory()

const G4String & G4VUserPhysicsList::GetPhysicsTableDirectory ( ) const

inline

Definition at line 448 of file G4VUserPhysicsList.hh.

{
  return directoryPhysicsTable;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

GetSubInstanceManager()

const G4VUPLManager & G4VUserPhysicsList::GetSubInstanceManager ( )

inlinestatic

Definition at line 474 of file G4VUserPhysicsList.hh.

{
  return subInstanceManager;
}

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

GetVerboseLevel()

G4int G4VUserPhysicsList::GetVerboseLevel ( ) const

inline

Definition at line 433 of file G4VUserPhysicsList.hh.

{
  return verboseLevel;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

InitializeProcessManager()

void G4VUserPhysicsList::InitializeProcessManager ( )

protected

Definition at line 256 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table accesses. 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 == 0)
    {
      // create process manager if the particle does not have its own.
      pmanager = new G4ProcessManager(particle);
      particle->SetProcessManager(pmanager);
      if(particle->GetMasterProcessManager() == 0)
        particle->SetMasterProcessManager(pmanager);
#ifdef G4VERBOSE
      if(verboseLevel > 2)
      {
        G4cout << "G4VUserPhysicsList::InitializeProcessManager: creating "
                  "ProcessManager to "
               << particle->GetParticleName() << G4endl;
      }
#endif
    }
  }
 
  if(gion)
  {
    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 accesses.
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
  //  G4cout << "Particle table is released by
  //  G4VUserPhysicsList::InitializeProcessManager" << G4endl;
}

Referenced by Construct().

InitializeWorker()

void G4VUserPhysicsList::InitializeWorker ( )

virtual

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

Referenced by G4WorkerRunManager::SetUserInitialization().

IsPhysicsTableRetrieved()

G4bool G4VUserPhysicsList::IsPhysicsTableRetrieved ( ) const

inline

Definition at line 438 of file G4VUserPhysicsList.hh.

{
  return fRetrievePhysicsTable;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

IsStoredInAscii()

G4bool G4VUserPhysicsList::IsStoredInAscii ( ) const

inline

Definition at line 443 of file G4VUserPhysicsList.hh.

{
  return fStoredInAscii;
}

Referenced by G4UserPhysicsListMessenger::GetCurrentValue().

operator=()

G4VUserPhysicsList & G4VUserPhysicsList::operator=

(

const G4VUserPhysicsList &

right

)

Definition at line 219 of file G4VUserPhysicsList.cc.

{
  if(this != &right)
  {
    verboseLevel                      = right.verboseLevel;
    defaultCutValue                   = right.defaultCutValue;
    isSetDefaultCutValue              = right.isSetDefaultCutValue;
    fRetrievePhysicsTable             = right.fRetrievePhysicsTable;
    fStoredInAscii                    = right.fStoredInAscii;
    fIsCheckedForRetrievePhysicsTable = right.fIsCheckedForRetrievePhysicsTable;
    fIsRestoredCutValues              = right.fIsRestoredCutValues;
    directoryPhysicsTable             = right.directoryPhysicsTable;
    // fDisplayThreshold = right.fDisplayThreshold;
    fIsPhysicsTableBuilt = right.GetSubInstanceManager()
                             .offset[right.GetInstanceID()]
                             ._fIsPhysicsTableBuilt;
    fDisplayThreshold = right.GetSubInstanceManager()
                          .offset[right.GetInstanceID()]
                          ._fDisplayThreshold;
    // fIsPhysicsTableBuilt = right.fIsPhysicsTableBuilt;
    fDisableCheckParticleList = right.fDisableCheckParticleList;
  }
  return *this;
}

PreparePhysicsTable()

void G4VUserPhysicsList::PreparePhysicsTable

(

G4ParticleDefinition *

particle

)

G4cout << "#### G4VUserPhysicsList::BuildPhysicsTable() - BuildPhysicsTable(" / << particle->GetParticleName() << ") skipped..." << G4endl;

Definition at line 787 of file G4VUserPhysicsList.cc.

{
  if(!(particle->GetMasterProcessManager()))
  {
    ////    G4cout << "#### G4VUserPhysicsList::BuildPhysicsTable() -
    /// BuildPhysicsTable(" /           << particle->GetParticleName() << ")
    /// skipped..." << G4endl;
    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)
    {
#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();
    // Andrea Dotti 15 Jan 2013: Change of interface of MSC
    // G4ProcessVector* pVectorShadow = pManagerShadow->GetProcessList();
 
    G4ProcessVector* pVector = pManager->GetProcessList();
    if(!pVector)
    {
#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
}

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

RegisterProcess()

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

protected

Definition at line 1075 of file G4VUserPhysicsList.cc.

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

RemoveProcessManager()

void G4VUserPhysicsList::RemoveProcessManager

(

)

Definition at line 324 of file G4VUserPhysicsList.cc.

{
  // Request lock for particle table accesses. Some changes are inside
  // this critical region.
#ifdef G4MULTITHREADED
  G4MUTEXLOCK(&G4ParticleTable::particleTableMutex());
  G4ParticleTable::lockCount()++;
#endif
  //  G4cout << "Particle table is held by
  //  G4VUserPhysicsList::InitializeProcessManager"
  //  << G4endl;
 
  // 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 != 0)
          delete pmanager;
#ifdef G4VERBOSE
        if(verboseLevel > 2)
        {
          G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
          G4cout << "remove ProcessManager from ";
          G4cout << particle->GetParticleName() << G4endl;
        }
#endif
      }
      particle->SetProcessManager(0);
    }
  }
 
  // release lock for particle table accesses.
#ifdef G4MULTITHREADED
  G4MUTEXUNLOCK(&G4ParticleTable::particleTableMutex());
#endif
  //  G4cout << "Particle table is released by
  //  G4VUserPhysicsList::InitializeProcessManager" << G4endl;
}

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

ResetCuts()

void G4VUserPhysicsList::ResetCuts

(

)

obsolete methods

Definition at line 1111 of file G4VUserPhysicsList.cc.

{
#ifdef G4VERBOSE
  if(verboseLevel > 0)
  {
    G4cout << "G4VUserPhysicsList::ResetCuts() is obsolete."
           << " This method gives no effect and you can remove it. " << G4endl;
  }
#endif
}

ResetPhysicsTableRetrieved()

void G4VUserPhysicsList::ResetPhysicsTableRetrieved ( )

inline

Definition at line 455 of file G4VUserPhysicsList.hh.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

ResetStoredInAscii()

void G4VUserPhysicsList::ResetStoredInAscii ( )

inline

Definition at line 462 of file G4VUserPhysicsList.hh.

{ fStoredInAscii = false; }

Referenced by G4UserPhysicsListMessenger::SetNewValue().

RetrievePhysicsTable()

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

protectedvirtual

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

Referenced by BuildPhysicsTable().

SetApplyCuts()

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

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCuts()

void G4VUserPhysicsList::SetCuts ( )

virtual

Reimplemented in G4ErrorPhysicsList, FTFP_BERT_HP, LBE, and QGSP_BERT_HP.

Definition at line 372 of file G4VUserPhysicsList.cc.

{
  if(!isSetDefaultCutValue)
  {
    SetDefaultCutValue(defaultCutValue);
  }
 
#ifdef G4VERBOSE
  if(verboseLevel > 1)
  {
    G4cout << "G4VUserPhysicsList::SetCuts:   " << G4endl;
    G4cout << "Cut for gamma: " << GetCutValue("gamma") / mm << "[mm]"
           << G4endl;
    G4cout << "Cut  for e-: " << GetCutValue("e-") / mm << "[mm]" << G4endl;
    G4cout << "Cut  for e+: " << GetCutValue("e+") / mm << "[mm]" << G4endl;
    G4cout << "Cut  for proton: " << GetCutValue("proton") / mm << "[mm]"
           << G4endl;
  }
#endif
 
  // dump Cut values if verboseLevel==3
  if(verboseLevel > 2)
  {
    DumpCutValuesTable();
  }
}

Referenced by G4RunManagerKernel::InitializePhysics(), SetCutsWithDefault(), and G4UserPhysicsListMessenger::SetNewValue().

SetCutsForRegion()

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

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetCutsWithDefault()

void G4VUserPhysicsList::SetCutsWithDefault

(

)

Definition at line 484 of file G4VUserPhysicsList.cc.

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

Referenced by G4ErrorPhysicsList::SetCuts(), FTFP_BERT_HP::SetCuts(), and QGSP_BERT_HP::SetCuts().

SetCutValue() [1/2]

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

Definition at line 456 of file G4VUserPhysicsList.cc.

{
  SetParticleCuts(aCut, name);
}

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

SetCutValue() [2/2]

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

Definition at line 462 of file G4VUserPhysicsList.cc.

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

SetDefaultCutValue()

void G4VUserPhysicsList::SetDefaultCutValue

(

G4double

newCutValue

)

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

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

SetParticleCuts() [1/2]

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

Definition at line 509 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)
  {
    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
}

SetParticleCuts() [2/2]

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

Definition at line 501 of file G4VUserPhysicsList.cc.

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

Referenced by SetCutValue(), and SetParticleCuts().

SetPhysicsTableRetrieved()

void G4VUserPhysicsList::SetPhysicsTableRetrieved

(

const G4String &

directory = ""

)

Definition at line 978 of file G4VUserPhysicsList.cc.

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetStoredInAscii()

void G4VUserPhysicsList::SetStoredInAscii ( )

inline

Definition at line 453 of file G4VUserPhysicsList.hh.

{ fStoredInAscii = true; }

Referenced by G4UserPhysicsListMessenger::SetNewValue().

SetVerboseLevel()

void G4VUserPhysicsList::SetVerboseLevel

(

G4int

value

)

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

Referenced by G4UserPhysicsListMessenger::SetNewValue().

StorePhysicsTable()

G4bool G4VUserPhysicsList::StorePhysicsTable

(

const G4String &

directory = "."

)

Definition at line 925 of file G4VUserPhysicsList.cc.

{
  G4bool ascii = fStoredInAscii;
  G4String dir = directory;
  if(dir.isNull())
    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;
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

TerminateWorker()

void G4VUserPhysicsList::TerminateWorker ( )

virtual

Reimplemented in G4VModularPhysicsList.

Definition at line 158 of file G4VUserPhysicsList.cc.

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

Referenced by G4VModularPhysicsList::TerminateWorker(), and G4WorkerRunManager::~G4WorkerRunManager().

UseCoupledTransportation()

void G4VUserPhysicsList::UseCoupledTransportation

(

G4bool

vl = true

)

Definition at line 1069 of file G4VUserPhysicsList.cc.

{
  G4MT_thePLHelper->UseCoupledTransportation(vl);
}

Referenced by G4RunManagerKernel::InitializePhysics().

Member Data Documentation

defaultCutValue

G4double G4VUserPhysicsList::defaultCutValue

protected

Definition at line 359 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(), GetDefaultCutValue(), LBE::LBE(), NuBeam::NuBeam(), G4VModularPhysicsList::operator=(), operator=(), 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(), LBE::SetCuts(), SetCuts(), SetCutsWithDefault(), SetDefaultCutValue(), SetParticleCuts(), and Shielding::Shielding().

directoryPhysicsTable

G4String G4VUserPhysicsList::directoryPhysicsTable

protected

Definition at line 374 of file G4VUserPhysicsList.hh.

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

fCutsTable

G4ProductionCutsTable* G4VUserPhysicsList::fCutsTable

protected

Definition at line 364 of file G4VUserPhysicsList.hh.

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

fDisableCheckParticleList

G4bool G4VUserPhysicsList::fDisableCheckParticleList

protected

Definition at line 383 of file G4VUserPhysicsList.hh.

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

fIsCheckedForRetrievePhysicsTable

G4bool G4VUserPhysicsList::fIsCheckedForRetrievePhysicsTable

protected

Definition at line 370 of file G4VUserPhysicsList.hh.

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

fIsRestoredCutValues

G4bool G4VUserPhysicsList::fIsRestoredCutValues

protected

Definition at line 371 of file G4VUserPhysicsList.hh.

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

fRetrievePhysicsTable

G4bool G4VUserPhysicsList::fRetrievePhysicsTable

protected

Definition at line 367 of file G4VUserPhysicsList.hh.

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

fStoredInAscii

G4bool G4VUserPhysicsList::fStoredInAscii

protected

Definition at line 368 of file G4VUserPhysicsList.hh.

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

g4vuplInstanceID

G4int G4VUserPhysicsList::g4vuplInstanceID

protected

Definition at line 396 of file G4VUserPhysicsList.hh.

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

isSetDefaultCutValue

G4bool G4VUserPhysicsList::isSetDefaultCutValue

protected

Definition at line 360 of file G4VUserPhysicsList.hh.

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

subInstanceManager

G4VUPLManager G4VUserPhysicsList::subInstanceManager

staticprotected

Definition at line 397 of file G4VUserPhysicsList.hh.

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

theParticleTable

G4ParticleTable* G4VUserPhysicsList::theParticleTable

protected

Definition at line 347 of file G4VUserPhysicsList.hh.

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

verboseLevel

G4int G4VUserPhysicsList::verboseLevel

protected

Definition at line 355 of file G4VUserPhysicsList.hh.

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

---

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

• G4VUserPhysicsList.hh
• G4VUserPhysicsList.cc