G4PhysListRegistry Class Reference

#include <G4PhysListRegistry.hh>

Public Member Functions
void	AddFactory (G4String name, G4VBasePhysListStamper *)
void	AddPhysicsExtension (G4String name, G4String procname)
const std::vector< G4String > &	AvailablePhysicsExtensions () const
const std::vector< G4String > &	AvailablePhysLists () const
const std::vector< G4String > &	AvailablePhysListsEM () const
G4bool	DeconstructPhysListName (const G4String &name, G4String &plBase, std::vector< G4String > &physExt, std::vector< G4int > &replace, G4int verbose=0) const
G4bool	FindLongestMatch (const G4String &workName, const G4String &searchName, const std::vector< G4String > &validNames, G4String &bestMatch, G4int verbose=0) const
G4VModularPhysicsList *	GetModularPhysicsList (const G4String &name)
G4VModularPhysicsList *	GetModularPhysicsListFromEnv ()
G4String	GetSystemDefaultPhysList () const
G4int	GetUnknownFatal () const
G4String	GetUserDefaultPhysList () const
G4int	GetVerbose () const
G4bool	IsReferencePhysList (G4String nam) const
void	PrintAvailablePhysLists () const
void	SetUnknownFatal (G4int val)
void	SetUserDefaultPhysList (const G4String &name="")
void	SetVerbose (G4int val)
	~G4PhysListRegistry ()

Static Public Member Functions
static G4PhysListRegistry *	Instance ()

Private Member Functions
	G4PhysListRegistry ()

Private Attributes
std::vector< G4String >	availBasePhysLists
std::vector< G4String >	availExtensions
std::map< G4String, G4VBasePhysListStamper * >	factories
std::map< G4String, G4String >	physicsExtensions
G4String	systemDefault
	use this if $PHYSLIST isn't set More...
G4int	unknownFatal
G4String	userDefault
	throw an exception if unsatisfiable? More...
G4int	verbose

Static Private Attributes
static G4ThreadLocal G4PhysListRegistry *	theInstance = 0

Detailed Description

Definition at line 56 of file G4PhysListRegistry.hh.

Constructor & Destructor Documentation

~G4PhysListRegistry()

G4PhysListRegistry::~G4PhysListRegistry

(

)

Definition at line 105 of file G4PhysListRegistry.cc.

{
}

G4PhysListRegistry()

G4PhysListRegistry::G4PhysListRegistry ( )

private

Definition at line 97 of file G4PhysListRegistry.cc.

  : verbose(1)
  , unknownFatal(0)
  , systemDefault("FTFP_BERT")
{
  SetUserDefaultPhysList();
}

References SetUserDefaultPhysList().

Referenced by Instance().

Member Function Documentation

AddFactory()

void G4PhysListRegistry::AddFactory	(	G4String	name,
		G4VBasePhysListStamper *	factory
	)

Definition at line 115 of file G4PhysListRegistry.cc.

{
  factories[name] = factory;
}

References factories, test::factory, and G4InuclParticleNames::name().

Referenced by G4PhysListStamper< T >::G4PhysListStamper().

AddPhysicsExtension()

void G4PhysListRegistry::AddPhysicsExtension	(	G4String	name,
		G4String	procname
	)

Definition at line 120 of file G4PhysListRegistry.cc.

{
  // a mapping from short extension names to actual physics process constructors
  physicsExtensions[name] = procname;
}

References G4InuclParticleNames::name(), and physicsExtensions.

Referenced by Instance().

AvailablePhysicsExtensions()

const std::vector< G4String > & G4PhysListRegistry::AvailablePhysicsExtensions

(

)

const

Definition at line 394 of file G4PhysListRegistry.cc.

{
  availExtensions.clear();
  std::map<G4String,G4String>::const_iterator itr;
  for ( itr = physicsExtensions.begin(); itr != physicsExtensions.end(); ++itr ) {
    availExtensions.push_back(itr->first);
  }
 
  return availExtensions;
}

References availExtensions, and physicsExtensions.

Referenced by AvailablePhysListsEM(), and DeconstructPhysListName().

AvailablePhysLists()

const std::vector< G4String > & G4PhysListRegistry::AvailablePhysLists

(

)

const

Definition at line 383 of file G4PhysListRegistry.cc.

{
  availBasePhysLists.clear();
  std::map<G4String,G4VBasePhysListStamper*>::const_iterator itr;
  for ( itr = factories.begin(); itr != factories.end(); ++itr ) {
    availBasePhysLists.push_back(itr->first);
  }
 
  return availBasePhysLists;
}

References availBasePhysLists, and factories.

Referenced by g4alt::G4PhysListFactory::AvailablePhysLists(), DeconstructPhysListName(), and PrintAvailablePhysLists().

AvailablePhysListsEM()

const std::vector< G4String > & G4PhysListRegistry::AvailablePhysListsEM

(

)

const

Definition at line 405 of file G4PhysListRegistry.cc.

{
  // in principle this method could weed out all the extensions that aren't
  // EM replacements ... but for now just use it as a synonym for
  // AvailablePhysicsExtensions()
  return AvailablePhysicsExtensions();
}

References AvailablePhysicsExtensions().

Referenced by g4alt::G4PhysListFactory::AvailablePhysListsEM().

DeconstructPhysListName()

G4bool G4PhysListRegistry::DeconstructPhysListName	(	const G4String &	name,
		G4String &	plBase,
		std::vector< G4String > &	physExt,
		std::vector< G4int > &	replace,
		G4int	verbose = 0
	)		const

Definition at line 236 of file G4PhysListRegistry.cc.

{
  // Take apart a name given to us by the user
  // this name might be a base PhysList + unknown number of extensions
  // Extensions preceeded with a "_" should use
  //    ReplacePhysics()
  // those proceeded with a "+" should use
  //    RegisterPhysics()
  // the former is in line with previous behaviour, while the second allows
  // additional flexibility
  plBase = "";
  physExt.clear();
  replace.clear();
  bool allKnown = false;
 
  G4String workingName = name;
 
  const std::vector<G4String>& availBases  = AvailablePhysLists();
  const std::vector<G4String>& availExtras = AvailablePhysicsExtensions();
 
  G4PhysicsConstructorRegistry* physConstRegistry =
    G4PhysicsConstructorRegistry::Instance();
 
  const std::vector<G4String>& availPhysCtors  =
    physConstRegistry->AvailablePhysicsConstructors();
 
  // find the longest base list that is contained in the user supplied name
  // and starts at the beginning
  G4String bestBase = "";
  allKnown = FindLongestMatch(workingName,"base",availBases,plBase);
  if ( verb > 2 ) {
    G4cout << "  " << name << ", base known=" << ((allKnown)?"true":"false")
           << " chosen plBase \"" << plBase << "\"" << G4endl;
  }
  if ( ! allKnown ) {
    // didn't find any matching base physics list
    // no point of going on to the extensions
    return allKnown;
  }
  // remove base name for working name
  workingName.erase(0,plBase.size());
 
  // now start trying to match up extensions and/or physCtors
  // each should be preceeded by at "_" (replace) or "+" (register)
  // but don't freak if it isn't, just assume "_"
  while ( ! workingName.empty() ) {
    char c = workingName.data()[0];  // leading character
    if ( '_' == c || '+' == c ) workingName.erase(0,1);  // and remove it
    G4int    replaceExtra = (( c != '+' ) ? doReplace : 0 );
    G4String extraName = "";
    G4bool   extraKnown = false;
 
    extraKnown = FindLongestMatch(workingName,"extNames",availExtras,extraName);
    if ( extraKnown ) {
      // physics mapping name is known, but is it actually linked to physics?
      //const issue// G4String pcname = physicsExtensions[extraName];
      std::map<G4String,G4String>::const_iterator itr =
        physicsExtensions.find(extraName);
      G4String pcname = "";
      if ( itr != physicsExtensions.end() ) pcname = itr->second;
      bool realknown = physConstRegistry->IsKnownPhysicsConstructor(pcname);
      if ( ! realknown ) allKnown = false;
#ifdef G4VERBOSE
      if ( verb > 2 ) {
        G4cout << "  extraName \"" << extraName << "\" maps to physics ctor \""
               << pcname << "\" which is itself realknown " << realknown
               << G4endl;
      }
#endif
    } else {
      // perhaps it's an explicit physCtor name
      extraKnown =
        FindLongestMatch(workingName,"physCtors",availPhysCtors,extraName);
      if ( extraKnown ) replaceExtra |= isCtorName; // flag it
    }
#ifdef G4VERBOSE
    if ( verb > 2 ) {
      G4cout << "  physextra " << name << " [" << workingName << "]"
             <<", extra known " << extraKnown
             << " chosen extra \"" << extraName << "\""
             << " replace " << replaceExtra << G4endl;
    }
#endif
    if ( extraKnown ) {
      physExt.push_back(extraName);
      replace.push_back(replaceExtra);
      // and remove it so we can look for the next bit
      workingName.erase(0,extraName.size());
 
    } else {
#ifdef G4VERBOSE
      if ( verb > 2 ) {
        G4cout << "  workingName \"" << workingName << "\""
               << " couldn't be found in the extensions list"
               << G4endl;
      }
#endif
      allKnown = false;
      // found a pattern that we can't map
      return allKnown;
    }
  } // workingName not empty
 
  return allKnown;
}

References G4PhysicsConstructorRegistry::AvailablePhysicsConstructors(), AvailablePhysicsExtensions(), AvailablePhysLists(), doReplace, FindLongestMatch(), G4cout, G4endl, G4PhysicsConstructorRegistry::Instance(), isCtorName, G4PhysicsConstructorRegistry::IsKnownPhysicsConstructor(), G4InuclParticleNames::name(), and physicsExtensions.

Referenced by GetModularPhysicsList(), and IsReferencePhysList().

FindLongestMatch()

G4bool G4PhysListRegistry::FindLongestMatch	(	const G4String &	workName,
		const G4String &	searchName,
		const std::vector< G4String > &	validNames,
		G4String &	bestMatch,
		G4int	verbose = 0
	)		const

Definition at line 346 of file G4PhysListRegistry.cc.

{
  bestMatch = "";
  bool found = false;
 
  size_t n = validNames.size();
  for (size_t i=0;  i<n; ++i) {
    const G4String& testName = validNames[i];
    size_t ipos = workingName.find(testName);
    if ( ipos == 0 ) {
      if ( testName.size() > bestMatch.size() )  {
        bestMatch = testName;
        found     = true;
        if ( verb > 3 ) {
          G4cout << "  " << searchName << " current best guess: "
                 << testName << G4endl;
        }
      } else {
        if ( verb > 3 ) {
          G4cout << "  " << searchName << " match but shorter: "
                 << testName << G4endl;
        }
      }
    } else {
      if ( verb > 3 ) {
        G4cout << "  " << searchName << " reject: " << testName << G4endl;
      }
    }
  }
  return found;
}

References G4cout, G4endl, and CLHEP::detail::n.

Referenced by DeconstructPhysListName().

GetModularPhysicsList()

G4VModularPhysicsList * G4PhysListRegistry::GetModularPhysicsList

(

const G4String &

name

)

Definition at line 127 of file G4PhysListRegistry.cc.

{
  //
  //
  G4String plBase = "";
  std::vector<G4String> physExt;
  std::vector<G4int>    physReplace;
  G4bool allKnown =
    DeconstructPhysListName(name,plBase,physExt,physReplace,verbose);
 
  size_t npc = physExt.size();
  if ( verbose > 0 ) {
    G4cout << "G4PhysListRegistry::GetModularPhysicsList <"
           << name << ">"
           << ", as \"" << plBase << "\" with extensions \"";
    for ( size_t ipc = 0; ipc < npc; ++ipc )
      G4cout << ((physReplace[ipc]&doReplace)?"_":"+") << physExt[ipc];
    G4cout << "\"" << G4endl;
  }
 
  if ( ! allKnown ) {
    // couldn't match what the user wanted ...
    G4cout << "### G4PhysListRegistry WARNING: " << name
           << " is not known" << G4endl << G4endl;
    if ( ! unknownFatal ) return 0;
 
    G4ExceptionDescription ED;
    ED << "The factory for the physicslist ["<< name << "] does not exist!"
       << G4endl;
    if ( plBase == "" ) {
      ED << "Could determine no sensible base physics list" << G4endl;
    } else {
      ED << "One or more of the extensions does not exist [ ";
      for ( size_t ipc = 0; ipc < physExt.size(); ++ipc ) {
        ED << physExt[ipc] << " ";
      }
      ED << "]" << G4endl;
    }
    G4Exception("G4PhysListRegistry::GetModularPhysicsList",
                "PhysicsList002", FatalException, ED);
    return 0;
  }
 
  // if we want this method "const" then the next line becomes more complex
  // because there is no const version of [] (which adds an entry if the
  // key doesn't exist)
  G4VModularPhysicsList* pl = factories[plBase]->Instantiate(verbose);
  G4PhysicsConstructorRegistry* pcRegistry =
    G4PhysicsConstructorRegistry::Instance();
  G4int ver = pl->GetVerboseLevel();
  pl->SetVerboseLevel(0);
  for ( size_t ipc = 0; ipc < npc; ++ipc ) {
    // got back a list of short names, need to use the map to get the
    // full physics constructor name
    G4String extName = physExt[ipc];
    G4String pcname  =
      ((physReplace[ipc]&isCtorName)) ? extName : physicsExtensions[extName];
    // this doesn't have a verbose option ... it should
    // but G4PhysicsConstructorFactory doesn't support it
    G4VPhysicsConstructor* pctor = pcRegistry->GetPhysicsConstructor(pcname);
    G4String reporreg = "";
    if (( physReplace[ipc] & doReplace)) {
      pl->ReplacePhysics(pctor);
      reporreg = "ReplacePhysics ";
    } else {
      pl->RegisterPhysics(pctor);
      reporreg = "RegisterPhysics";
    }
    if ( verbose > 0 ) G4cout << "<<< " << reporreg << " with " << pcname
                              << " \"" << extName << "\"" << G4endl;
  }
  pl->SetVerboseLevel(ver);
  G4cout << "<<< Reference Physics List " << name << " is built" << G4endl;
  G4cout << G4endl; // old factory has this
 
  return pl;
}

References DeconstructPhysListName(), doReplace, factories, FatalException, G4cout, G4endl, G4Exception(), G4PhysicsConstructorRegistry::GetPhysicsConstructor(), G4VModularPhysicsList::GetVerboseLevel(), G4PhysicsConstructorRegistry::Instance(), isCtorName, G4InuclParticleNames::name(), physicsExtensions, G4VModularPhysicsList::RegisterPhysics(), G4VModularPhysicsList::ReplacePhysics(), G4VModularPhysicsList::SetVerboseLevel(), unknownFatal, and verbose.

Referenced by GetModularPhysicsListFromEnv(), and g4alt::G4PhysListFactory::GetReferencePhysList().

GetModularPhysicsListFromEnv()

G4VModularPhysicsList * G4PhysListRegistry::GetModularPhysicsListFromEnv

(

)

Definition at line 206 of file G4PhysListRegistry.cc.

{
  //
  // instantiate PhysList by environment variable "PHYSLIST"
  // if not set use default
  G4String name = "";
  char* path = std::getenv("PHYSLIST");
  if (path) {
    name = G4String(path);
  } else {
    name = userDefault;
    G4cout << "### G4PhysListRegistry WARNING: "
           << " environment variable PHYSLIST is not defined"
           << G4endl
           << "    Default Physics Lists " << name
           << " is instantiated"
           << G4endl;
  }
  return GetModularPhysicsList(name);
}

References G4cout, G4endl, GetModularPhysicsList(), G4InuclParticleNames::name(), and userDefault.

Referenced by g4alt::G4PhysListFactory::ReferencePhysList().

GetSystemDefaultPhysList()

G4String G4PhysListRegistry::GetSystemDefaultPhysList ( ) const

inline

Definition at line 102 of file G4PhysListRegistry.hh.

{ return systemDefault; }

References systemDefault.

GetUnknownFatal()

G4int G4PhysListRegistry::GetUnknownFatal ( ) const

inline

Definition at line 95 of file G4PhysListRegistry.hh.

{ return unknownFatal; }

References unknownFatal.

Referenced by g4alt::G4PhysListFactory::GetUnknownFatal().

GetUserDefaultPhysList()

G4String G4PhysListRegistry::GetUserDefaultPhysList ( ) const

inline

Definition at line 98 of file G4PhysListRegistry.hh.

{ return userDefault; }

References userDefault.

GetVerbose()

G4int G4PhysListRegistry::GetVerbose ( ) const

inline

Definition at line 92 of file G4PhysListRegistry.hh.

{ return verbose; }

References verbose.

Referenced by g4alt::G4PhysListFactory::GetVerbose().

Instance()

G4PhysListRegistry * G4PhysListRegistry::Instance ( )

static

Definition at line 64 of file G4PhysListRegistry.cc.

{
  if ( 0 == theInstance) {
    static G4ThreadLocal G4PhysListRegistry *manager_G4MT_TLS_ = 0;
    if (!manager_G4MT_TLS_) manager_G4MT_TLS_ = new G4PhysListRegistry;
    G4PhysListRegistry &manager = *manager_G4MT_TLS_;
    theInstance = &manager;
  }
 
  // common EM overrides
  theInstance->AddPhysicsExtension("EM0","G4EmStandardPhysics");
  theInstance->AddPhysicsExtension("EMV","G4EmStandardPhysics_option1");
  theInstance->AddPhysicsExtension("EMX","G4EmStandardPhysics_option2");
  theInstance->AddPhysicsExtension("EMY","G4EmStandardPhysics_option3");
  theInstance->AddPhysicsExtension("EMZ","G4EmStandardPhysics_option4");
  theInstance->AddPhysicsExtension("LIV","G4EmLivermorePhysics");
  theInstance->AddPhysicsExtension("PEN","G4EmPenelopePhysics");
  // the GS EM extension originally required double underscores
  // support either one or two as __GS is confusing to users
  // same for __SS
  theInstance->AddPhysicsExtension("GS" ,"G4EmStandardPhysicsGS");
  theInstance->AddPhysicsExtension("_GS","G4EmStandardPhysicsGS");
  theInstance->AddPhysicsExtension("SS" ,"G4EmStandardPhysicsSS");
  theInstance->AddPhysicsExtension("_SS","G4EmStandardPhysicsSS");
 
  theInstance->AddPhysicsExtension("EM0","G4EmStandardPhysics");
  theInstance->AddPhysicsExtension("WVI","G4EmStandardPhysicsWVI");
  theInstance->AddPhysicsExtension("LE" ,"G4EmLowEPPhysics");
  theInstance->AddPhysicsExtension("_LE","G4EmLowEPPhysics");
 
  return theInstance;
}

References AddPhysicsExtension(), G4PhysListRegistry(), G4ThreadLocal, and theInstance.

Referenced by g4alt::G4PhysListFactory::AvailablePhysLists(), g4alt::G4PhysListFactory::AvailablePhysListsEM(), G4PhysListStamper< T >::G4PhysListStamper(), g4alt::G4PhysListFactory::GetReferencePhysList(), g4alt::G4PhysListFactory::GetUnknownFatal(), g4alt::G4PhysListFactory::GetVerbose(), g4alt::G4PhysListFactory::IsReferencePhysList(), g4alt::G4PhysListFactory::PrintAvailablePhysLists(), g4alt::G4PhysListFactory::ReferencePhysList(), g4alt::G4PhysListFactory::SetDefaultReferencePhysList(), g4alt::G4PhysListFactory::SetUnknownFatal(), and g4alt::G4PhysListFactory::SetVerbose().

IsReferencePhysList()

G4bool G4PhysListRegistry::IsReferencePhysList

(

G4String

nam

)

const

Definition at line 227 of file G4PhysListRegistry.cc.

{
  G4String plBase = "";
  std::vector<G4String> physExt;
  std::vector<G4int>    physReplace;
  G4bool allKnown = DeconstructPhysListName(name,plBase,physExt,physReplace,1);
  return allKnown;
}

References DeconstructPhysListName(), and G4InuclParticleNames::name().

Referenced by g4alt::G4PhysListFactory::IsReferencePhysList().

PrintAvailablePhysLists()

void G4PhysListRegistry::PrintAvailablePhysLists

(

)

const

Definition at line 413 of file G4PhysListRegistry.cc.

{
  std::vector<G4String> avail = AvailablePhysLists();
  G4cout << "Base G4VModularPhysicsLists in G4PhysListRegistry are:"
         << G4endl;
  if ( avail.empty() ) G4cout << "... no registered lists" << G4endl;
  else {
    size_t n = avail.size();
    for (size_t i=0; i<n; ++i ) {
      G4cout << " [" << std::setw(3) << i << "] "
             << " \"" << avail[i] << "\"" << G4endl;
    }
  }
 
  G4PhysicsConstructorRegistry* physConstRegistry = G4PhysicsConstructorRegistry::Instance();
 
  std::map<G4String,G4String>::const_iterator itr;
  G4cout << "Replacement mappings in G4PhysListRegistry are:"
         << G4endl;
  for ( itr = physicsExtensions.begin(); itr != physicsExtensions.end(); ++itr ) {
    bool known = physConstRegistry->IsKnownPhysicsConstructor(itr->second);
 
    G4cout << "    " << std::setw(10) << itr->first << " => "
           << std::setw(30) << itr->second << " "
           << ( (known)?"":"[unregistered physics]")
           << G4endl;
  }
  G4cout << "Use these mapping to extend physics list; append with _EXT or +EXT" << G4endl
         << "   to use ReplacePhysics() (\"_\") or RegisterPhysics() (\"+\")."
         << G4endl;
}

References AvailablePhysLists(), G4cout, G4endl, G4PhysicsConstructorRegistry::Instance(), G4PhysicsConstructorRegistry::IsKnownPhysicsConstructor(), CLHEP::detail::n, and physicsExtensions.

Referenced by g4alt::G4PhysListFactory::PrintAvailablePhysLists().

SetUnknownFatal()

void G4PhysListRegistry::SetUnknownFatal ( G4int  val )

inline

Definition at line 94 of file G4PhysListRegistry.hh.

{ unknownFatal = val; }

References unknownFatal.

Referenced by g4alt::G4PhysListFactory::SetUnknownFatal().

SetUserDefaultPhysList()

void G4PhysListRegistry::SetUserDefaultPhysList

(

const G4String &

name = ""

)

Definition at line 109 of file G4PhysListRegistry.cc.

{
  if ( name == "" ) userDefault = systemDefault;
  else              userDefault = name;
}

References G4InuclParticleNames::name(), systemDefault, and userDefault.

Referenced by G4PhysListRegistry(), and g4alt::G4PhysListFactory::SetDefaultReferencePhysList().

SetVerbose()

void G4PhysListRegistry::SetVerbose ( G4int  val )

inline

Definition at line 91 of file G4PhysListRegistry.hh.

{ verbose = val; }

References verbose.

Referenced by g4alt::G4PhysListFactory::SetVerbose().

Field Documentation

availBasePhysLists

std::vector<G4String> G4PhysListRegistry::availBasePhysLists

mutableprivate

use this if user hasn't set userDefault or attempts to set the userDefault=""

Definition at line 124 of file G4PhysListRegistry.hh.

Referenced by AvailablePhysLists().

availExtensions

std::vector<G4String> G4PhysListRegistry::availExtensions

mutableprivate

Definition at line 125 of file G4PhysListRegistry.hh.

Referenced by AvailablePhysicsExtensions().

factories

std::map<G4String, G4VBasePhysListStamper*> G4PhysListRegistry::factories

private

Definition at line 110 of file G4PhysListRegistry.hh.

Referenced by AddFactory(), AvailablePhysLists(), and GetModularPhysicsList().

physicsExtensions

std::map<G4String, G4String> G4PhysListRegistry::physicsExtensions

private

Definition at line 111 of file G4PhysListRegistry.hh.

Referenced by AddPhysicsExtension(), AvailablePhysicsExtensions(), DeconstructPhysListName(), GetModularPhysicsList(), and PrintAvailablePhysLists().

systemDefault

G4String G4PhysListRegistry::systemDefault

private

use this if $PHYSLIST isn't set

Definition at line 116 of file G4PhysListRegistry.hh.

Referenced by GetSystemDefaultPhysList(), and SetUserDefaultPhysList().

theInstance

G4ThreadLocal G4PhysListRegistry * G4PhysListRegistry::theInstance = 0

staticprivate

Definition at line 108 of file G4PhysListRegistry.hh.

Referenced by Instance().

unknownFatal

G4int G4PhysListRegistry::unknownFatal

private

Definition at line 114 of file G4PhysListRegistry.hh.

Referenced by GetModularPhysicsList(), GetUnknownFatal(), and SetUnknownFatal().

userDefault

G4String G4PhysListRegistry::userDefault

private

throw an exception if unsatisfiable?

Definition at line 115 of file G4PhysListRegistry.hh.

Referenced by GetModularPhysicsListFromEnv(), GetUserDefaultPhysList(), and SetUserDefaultPhysList().

verbose

G4int G4PhysListRegistry::verbose

private

Definition at line 113 of file G4PhysListRegistry.hh.

Referenced by GetModularPhysicsList(), GetVerbose(), and SetVerbose().

---

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

• source/physics_lists/lists/include/G4PhysListRegistry.hh
• source/physics_lists/lists/src/G4PhysListRegistry.cc