G4PhysListRegistry.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4PhysListRegistry
//
// Author: R. Hatcher, 2014-10-15
// --------------------------------------------------------------------
 
#include <iomanip>
#include <algorithm>
 
#include "G4ios.hh"
#include "G4PhysListRegistry.hh"
#include "G4VModularPhysicsList.hh"
#include "G4PhysListStamper.hh"
 
#include "G4PhysicsConstructorRegistry.hh"
// include G4_REFERENCE_PHYSCONSTR_FACTORY() macros here to pull them in
// for static builds.   Would do this in  G4PhysicsConstructorRegistry
// but that causes a circular dependency when the phys_ctor libs
// are broken in a "granular" build.
#define REGREF PhysListReg // REGREF is used to make instances unique
#include "G4RegisterPhysicsConstructors.icc"
 
// include this with this compilation unit so static builds pull them in
#include "G4RegisterPhysLists.icc"
 
G4ThreadLocal G4PhysListRegistry* G4PhysListRegistry::theInstance = nullptr;
 
const G4int doReplace  = 0x01;  // _ (ReplacePhysics) vs. + (RegisterPhysics)
const G4int isCtorName = 0x02;  // true if actual physCtor name vs. ext name
 
G4PhysListRegistry* G4PhysListRegistry::Instance()
{
  if ( nullptr == theInstance) {
    theInstance = new G4PhysListRegistry;
 
    // 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");
 
    theInstance->AddPhysicsExtension("HPT","G4ThermalNeutrons");
  }
 
  return theInstance;
}
 
G4PhysListRegistry::G4PhysListRegistry()
  : verbose(1)
  , unknownFatal(0)
  , systemDefault("FTFP_BERT")
{
  SetUserDefaultPhysList();
}
 
G4PhysListRegistry::~G4PhysListRegistry()
{
}
 
void G4PhysListRegistry::SetUserDefaultPhysList(const G4String& name)
{
  if ( name == "" ) userDefault = systemDefault;
  else              userDefault = name;
}
 
void G4PhysListRegistry::AddFactory(G4String name, G4VBasePhysListStamper* factory)
{
  factories[name] = factory;
}
 
void G4PhysListRegistry::AddPhysicsExtension(G4String name, G4String procname)
{
  // a mapping from short extension names to actual physics process constructors
  physicsExtensions[name] = procname;
}
 
G4VModularPhysicsList*
G4PhysListRegistry::GetModularPhysicsList(const G4String& name)
{
  //
  //
  G4String plBase = "";
  std::vector<G4String> physExt;
  std::vector<G4int>    physReplace;
  G4bool allKnown =
    DeconstructPhysListName(name,plBase,physExt,physReplace,verbose);
 
  std::size_t npc = physExt.size();
  if ( verbose > 0 ) {
    G4cout << "G4PhysListRegistry::GetModularPhysicsList <"
           << name << ">"
           << ", as \"" << plBase << "\" with extensions \"";
    for ( std::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 nullptr;
 
    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 ( std::size_t ipc = 0; ipc < physExt.size(); ++ipc ) {
        ED << physExt[ipc] << " ";
      }
      ED << "]" << G4endl;
    }
    G4Exception("G4PhysListRegistry::GetModularPhysicsList",
                "PhysicsList002", FatalException, ED);
    return nullptr;
  }
 
  // 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 ( std::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;
}
 
G4VModularPhysicsList*
G4PhysListRegistry::GetModularPhysicsListFromEnv()
{
  //
  // 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);
}
 
G4bool G4PhysListRegistry::IsReferencePhysList(G4String name) const
{
  G4String plBase = "";
  std::vector<G4String> physExt;
  std::vector<G4int>    physReplace;
  G4bool allKnown = DeconstructPhysListName(name,plBase,physExt,physReplace,1);
  return allKnown;
}
 
G4bool G4PhysListRegistry::DeconstructPhysListName(const G4String& name,
                                                   G4String& plBase,
                                                   std::vector<G4String>& physExt,
                                                   std::vector<G4int>& replace,
                                                   G4int verb) const
{
  // 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();
  G4bool 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;
      G4bool 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;
}
 
G4bool G4PhysListRegistry::FindLongestMatch(const G4String& workingName,
                                            const G4String& searchName,
                                            const std::vector<G4String>& validNames,
                                            G4String& bestMatch,
                                            G4int verb) const
{
  bestMatch = "";
  G4bool found = false;
 
  std::size_t n = validNames.size();
  for (std::size_t i=0;  i<n; ++i) {
    const G4String& testName = validNames[i];
    std::size_t ipos = workingName.find(testName);
    if ( ipos == 0 ) {
      std::size_t testNameSize = testName.size();
      std::size_t workNameSize = workingName.size();
      G4bool match = true;
      if ( searchName == "base" ) {
        // if searching for a valid base impose extra restrictions
        // either must exactly match or the next character must be
        // one of the standard delimiters of "_" or "+"
        if (workNameSize > testNameSize) {
          char nextChar = workingName[(G4int)testNameSize];
          if ( nextChar != '_' && nextChar != '+' ) match = false;
          if ( verb > 3 ) {
            G4cout << "  " << searchName << " longer "
                   << testName << " nextChar " << nextChar << G4endl;
          }
        }
      }
      if ( verb > 3 ) {
        G4cout << "  " << searchName << " match " << (match?"yes":"no")
               << " " << testName << G4endl;
      }
      if ( match ) {
        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 than previous: "
                   << testName << G4endl;
          }
        }
      } else {
          if ( verb > 3 ) {
            G4cout << "  " << searchName << " ipos=0 but no match "
                   << testName << G4endl;
          }
      }
    } else {
      if ( verb > 3 ) {
        G4cout << "  " << searchName << " reject: " << testName << G4endl;
      }
    }
  }
  return found;
}
 
 
const std::vector<G4String>& G4PhysListRegistry::AvailablePhysLists() const
{
  availBasePhysLists.clear();
  std::map<G4String,G4VBasePhysListStamper*>::const_iterator itr;
  for ( itr = factories.begin(); itr != factories.end(); ++itr ) {
    availBasePhysLists.push_back(itr->first);
  }
 
  return availBasePhysLists;
}
 
const std::vector<G4String>& G4PhysListRegistry::AvailablePhysicsExtensions() const
{
  availExtensions.clear();
  std::map<G4String,G4String>::const_iterator itr;
  for ( itr = physicsExtensions.begin(); itr != physicsExtensions.end(); ++itr ) {
    availExtensions.push_back(itr->first);
  }
 
  return availExtensions;
}
 
const std::vector<G4String>& G4PhysListRegistry::AvailablePhysListsEM() const
{
  // 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();
}
 
void G4PhysListRegistry::PrintAvailablePhysLists() const
{
  std::vector<G4String> avail = AvailablePhysLists();
  G4cout << "Base G4VModularPhysicsLists in G4PhysListRegistry are:"
         << G4endl;
  if ( avail.empty() ) G4cout << "... no registered lists" << G4endl;
  else {
    std::size_t n = avail.size();
    for (std::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 ) {
    G4bool 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;
}