#include <G4PhysListRegistry.hh>

Public Member Functions
	~G4PhysListRegistry ()

void	AddFactory (G4String name, G4VBasePhysListStamper *)

void	AddPhysicsExtension (G4String name, G4String procname)

G4VModularPhysicsList *	GetModularPhysicsList (const G4String &name)

G4VModularPhysicsList *	GetModularPhysicsListFromEnv ()

G4bool	IsReferencePhysList (G4String nam) const

const std::vector< G4String > &	AvailablePhysLists () const

const std::vector< G4String > &	AvailablePhysicsExtensions () const

const std::vector< G4String > &	AvailablePhysListsEM () const

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

void	SetVerbose (G4int val)

G4int	GetVerbose () const

void	SetUnknownFatal (G4int val)

G4int	GetUnknownFatal () const

void	SetUserDefaultPhysList (const G4String &name="")

G4String	GetUserDefaultPhysList () const

G4String	GetSystemDefaultPhysList () const

Static Public Member Functions
static G4PhysListRegistry *	Instance ()

Detailed Description

Definition at line 56 of file G4PhysListRegistry.hh.

Constructor & Destructor Documentation

◆ ~G4PhysListRegistry()

G4PhysListRegistry::~G4PhysListRegistry ( )

Definition at line 105 of file G4PhysListRegistry.cc.

106{

107}

Member Function Documentation

◆ AddFactory()

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

Definition at line 115 of file G4PhysListRegistry.cc.

{
  factories[name] = factory;
}

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

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

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

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

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

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

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

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

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

◆ GetSystemDefaultPhysList()

G4String G4PhysListRegistry::GetSystemDefaultPhysList ( ) const

inline

Definition at line 102 of file G4PhysListRegistry.hh.

102{ return systemDefault; }

◆ GetUnknownFatal()

G4int G4PhysListRegistry::GetUnknownFatal ( ) const

inline

Definition at line 95 of file G4PhysListRegistry.hh.

95{ return unknownFatal; }

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

◆ GetUserDefaultPhysList()

G4String G4PhysListRegistry::GetUserDefaultPhysList ( ) const

inline

Definition at line 98 of file G4PhysListRegistry.hh.

98{ return userDefault; }

◆ GetVerbose()

G4int G4PhysListRegistry::GetVerbose ( ) const

inline

Definition at line 92 of file G4PhysListRegistry.hh.

92{ return 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;
}

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

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

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

◆ SetUnknownFatal()

void G4PhysListRegistry::SetUnknownFatal ( G4int val )

inline

Definition at line 94 of file G4PhysListRegistry.hh.

94{ unknownFatal = val; }

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

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

◆ SetVerbose()

void G4PhysListRegistry::SetVerbose ( G4int val )

inline

Definition at line 91 of file G4PhysListRegistry.hh.

91{ verbose = val; }

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

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

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~G4PhysListRegistry()

Member Function Documentation

◆ AddFactory()

◆ AddPhysicsExtension()

◆ AvailablePhysicsExtensions()

◆ AvailablePhysLists()

◆ AvailablePhysListsEM()

◆ DeconstructPhysListName()

◆ FindLongestMatch()

◆ GetModularPhysicsList()

◆ GetModularPhysicsListFromEnv()

◆ GetSystemDefaultPhysList()

◆ GetUnknownFatal()

◆ GetUserDefaultPhysList()

◆ GetVerbose()

◆ Instance()

◆ IsReferencePhysList()

◆ PrintAvailablePhysLists()

◆ SetUnknownFatal()

◆ SetUserDefaultPhysList()

◆ SetVerbose()