G4PhysListFactorySingleton Class Reference

#include <G4PhysListFactorySingleton.hh>

Classes
struct	Cleaner

Public Member Functions
G4VModularPhysicsList *	GetReferencePhysList (const G4String &)
G4VModularPhysicsList *	ReferencePhysList ()
G4bool	IsReferencePhysList (const G4String &)
const std::vector< G4String > &	AvailablePhysLists () const
void	PrintAvailablePhysLists () const
G4bool	RegisterCreator (G4String name, PhysListCtorFuncPtr_t ctorptr, G4bool *ptr)
G4bool	RegisterPhysicsReplacement (G4String key, G4String physics)
void	SetDefaultName (const G4String &defname)
const G4String &	GetDefaultName () const

Static Public Member Functions
static G4PhysListFactorySingleton &	Instance ()

Private Member Functions
	G4PhysListFactorySingleton ()
G4String	GetBaseName (G4String name, std::vector< G4String > &physicsReplacements, G4bool &allKnown)
virtual	~G4PhysListFactorySingleton ()
	G4PhysListFactorySingleton (const G4PhysListFactorySingleton &)
void	operator= (const G4PhysListFactorySingleton &)

Private Attributes
std::map< G4String, PhysListCtorFuncPtr_t >	fFunctionMap
std::map< G4String, G4bool * >	fBoolPtrMap
std::map< G4String, G4String >	fPhysicsReplaceList
G4String	defName
std::vector< G4String >	listnames

Static Private Attributes
static G4PhysListFactorySingleton *	fgTheInstance

Friends
struct	Cleaner

Detailed Description

Definition at line 65 of file G4PhysListFactorySingleton.hh.

Constructor & Destructor Documentation

G4PhysListFactorySingleton::G4PhysListFactorySingleton ( )

private

Definition at line 48 of file G4PhysListFactorySingleton.cc.

{
  defName = "QGSP_BERT";  // default list to use if no PHYSLIST defined
  fgTheInstance = this;   // record created self in static pointer
}

G4PhysListFactorySingleton::~G4PhysListFactorySingleton ( )

privatevirtual

Definition at line 54 of file G4PhysListFactorySingleton.cc.

{
  fgTheInstance = 0;
}

G4PhysListFactorySingleton::G4PhysListFactorySingleton ( const G4PhysListFactorySingleton &  )

private

Member Function Documentation

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

(

)

const

Definition at line 192 of file G4PhysListFactorySingleton.cc.

{
  // list of names might be out of date due to new registrations
  // rescan the std::map on each call (which won't be frequent)
  listnames.clear();

  // scan map for registered names
  std::map<G4String, PhysListCtorFuncPtr_t>::const_iterator itr;
  for ( itr = fFunctionMap.begin(); itr != fFunctionMap.end(); ++itr )
    listnames.push_back(itr->first);

  return listnames;
}

G4String G4PhysListFactorySingleton::GetBaseName ( G4String  name, std::vector< G4String > &  physicsReplacements, G4bool &  allKnown  )

private

Definition at line 260 of file G4PhysListFactorySingleton.cc.

{
  allKnown = true;
  G4String nameNoReplace = name;
  physicsReplace.clear();
  G4PhysicsProcessFactorySingleton& procFactory =
    G4PhysicsProcessFactorySingleton::Instance();

  std::map<G4String, G4String>::iterator repitr = fPhysicsReplaceList.begin();
  for ( ; repitr != fPhysicsReplaceList.end(); ++repitr ) {
    G4String key = repitr->first;
    size_t i = nameNoReplace.find(key);
    if ( i != std::string::npos ) {
      // remove key from base physics list name
      nameNoReplace.erase(i,key.size());

      // add to list of things needing replacement
      G4String procName = repitr->second;
      physicsReplace.push_back(procName);
      if ( ! procFactory.IsKnownPhysicsProcess(procName) ) {
        G4cout << "G4PhysListFactorySingleton::GetBaseName "
               << "\"" << key << "\" ==> \"" << procName << "\" not found"
               << G4endl;
        //procFactory.PrintAvailablePhysicsProcesses();
        allKnown = false;
      }
    }
  }

  std::map<G4String, PhysListCtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(nameNoReplace);
  if ( fFunctionMap.end() == itr ) allKnown = false;

  return nameNoReplace;
}

const G4String& G4PhysListFactorySingleton::GetDefaultName ( ) const

inline

Definition at line 95 of file G4PhysListFactorySingleton.hh.

{ return defName; }

G4VModularPhysicsList * G4PhysListFactorySingleton::GetReferencePhysList

(

const G4String &

name

)

Definition at line 102 of file G4PhysListFactorySingleton.cc.

{
  G4VModularPhysicsList* p = 0;
  
  // Replacing the very fixed list of if/else with a std::map lookup
  /*
  if(name == "CHIPS")              {p = new CHIPS();}
  else if(name == "FTFP_BERT")     {p = new FTFP_BERT();}
  else if(name == "FTFP_BERT_EMV") {p = new FTFP_BERT_EMV();}
  else if(name == "FTFP_BERT_EMX") {p = new FTFP_BERT_EMX();}
  else if(name == "FTFP_BERT_TRV") {p = new FTFP_BERT_TRV();}
  else if(name == "FTF_BIC")       {p = new FTF_BIC();}
  else if(name == "LBE")           {p = new LBE();}
  else if(name == "LHEP")          {p = new LHEP();}
  else if(name == "LHEP_EMV")      {p = new LHEP_EMV();}
  else if(name == "QBBC")          {p = new QBBC();}
  else if(name == "QGSC_BERT")     {p = new QGSC_BERT();}
  else if(name == "QGSP")          {p = new QGSP();}
  else if(name == "QGSP_BERT")     {p = new QGSP_BERT();}
  else if(name == "QGSP_BERT_EMV") {p = new QGSP_BERT_EMV();}
  else if(name == "QGSP_BERT_EMX") {p = new QGSP_BERT_EMX();}
  else if(name == "QGSP_BERT_HP")  {p = new QGSP_BERT_HP();}
  else if(name == "QGSP_BERT_NOLEP") {p = new QGSP_BERT_NOLEP();}
  else if(name == "QGSP_BERT_TRV") {p = new QGSP_BERT_TRV();}
  else if(name == "QGSP_BERT_CHIPS") {p = new QGSP_BERT_CHIPS();}
  else if(name == "QGSP_BIC")      {p = new QGSP_BIC();}
  else if(name == "QGSP_BIC_EMY")  {p = new QGSP_BIC_EMY();}
  else if(name == "QGSP_BIC_HP")   {p = new QGSP_BIC_HP();}
  else if(name == "QGSP_FTFP_BERT"){p = new QGSP_FTFP_BERT();}
  else if(name == "QGS_BIC")       {p = new QGS_BIC();}
  else if(name == "QGSP_INCL_ABLA"){p = new QGSP_INCL_ABLA();}
  else if(name == "Shielding")     {p = new Shielding();}
  */

  // look for key bits that indicate physics to be replaced in a 
  // base physics list; remove those keys from the physics list name
  std::vector<G4String> physicsReplacements;
  G4bool allKnown;
  G4String nameNoReplace = GetBaseName(name,physicsReplacements,allKnown);

  // we don't want map creating an entry if it doesn't exist
  // so use map::find() not map::operator[]
  std::map<G4String, PhysListCtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(nameNoReplace);
  if ( fFunctionMap.end() != itr ) { 
    // found an appropriate entry in the list
    PhysListCtorFuncPtr_t foo = itr->second;  // this is the function
    p = (*foo)();  // use function to create the physics list
  }
  if ( ! p ) {
    G4cout << "### G4PhysListFactorySingleton WARNING: "
           << "PhysicsList " << nameNoReplace 
           << "(originally=\"" << name << "\")"
           << " is not known"
           << G4endl;
  } else if ( physicsReplacements.size() != 0 ) {
    //
    // if there is physics to be replaced, do so now
    //
    G4PhysicsProcessFactorySingleton& procFactory =
      G4PhysicsProcessFactorySingleton::Instance();
    for (size_t k=0; k<physicsReplacements.size(); ++k) {
      G4String procName = physicsReplacements[k];
      if ( ! procFactory.IsKnownPhysicsProcess(procName) ) {
        G4cout << "### G4PhysListFactorySingleton WARNING: "
               << "G4PhysicsProcesFactorySingleton had no process \""
               << procName << "\" registered" << G4endl;        
      } else {
        G4cout << "### G4PhysListFactorySingleton: ReplacePhysics("
               << procName << ")" << G4endl;
        G4VPhysicsConstructor* pctor = procFactory.GetPhysicsProcess(procName);
        p->ReplacePhysics(pctor);
      }
    }
  }

  return p;
}

G4PhysListFactorySingleton & G4PhysListFactorySingleton::Instance ( void  )

static

Definition at line 59 of file G4PhysListFactorySingleton.cc.

{
  // Cleaner dtor calls G4PhysListFactorySingleton dtor at job end
  static Cleaner cleaner;

  if ( ! fgTheInstance ) {
    // need to create one
    cleaner.UseMe();   // dummy call to quiet compiler warnings
    fgTheInstance = new G4PhysListFactorySingleton();

    // special pre-register some physics overrides (common EM overrides)
    fgTheInstance->RegisterPhysicsReplacement("_EMV","G4EmStandardPhysics_option1");
    fgTheInstance->RegisterPhysicsReplacement("_EMX","G4EmStandardPhysics_option2");
    fgTheInstance->RegisterPhysicsReplacement("_EMY","G4EmStandardPhysics_option3");
    fgTheInstance->RegisterPhysicsReplacement("_LIV","G4EmLivermorePhysics");
    fgTheInstance->RegisterPhysicsReplacement("_PEN","G4EmPenelopePhysics");


  }
  
  return *fgTheInstance;
}

G4bool G4PhysListFactorySingleton::IsReferencePhysList

(

const G4String &

name

)

Definition at line 181 of file G4PhysListFactorySingleton.cc.

{
  //  check if we know the name (after stripping off replacement keys)
  std::vector<G4String> physicsReplacements;
  G4bool allKnown;
  G4String nameNoReplace = GetBaseName(name,physicsReplacements,allKnown);

  return allKnown;
}

void G4PhysListFactorySingleton::operator= ( const G4PhysListFactorySingleton &  )

private

void G4PhysListFactorySingleton::PrintAvailablePhysLists

(

)

const

Definition at line 206 of file G4PhysListFactorySingleton.cc.

{
  const std::vector<G4String>& list = AvailablePhysLists();
  G4cout << "G4VModularPhysicsLists in "
         << "G4PhysicsProcessFactorySingleton are: " 
         << G4endl;
  if ( list.empty() ) G4cout << " ... no registered lists" << G4endl;
  else {
    for (size_t indx=0; indx < list.size(); ++indx ) {
      G4cout << " [" << std::setw(2) << indx << "] " 
             << "\"" << list[indx] << "\"" << G4endl;
    }
  }
  G4cout << "G4PhysicsProcessFactorySingleton supports variants of the above"
         << G4endl << "with physics process replacements:" << G4endl;
  if ( fPhysicsReplaceList.empty() ) {
    G4cout << " ... no registered replacements" << G4endl;
  } else {
    G4bool printPhysicsProcesses = false;
    G4PhysicsProcessFactorySingleton& procFactory =
      G4PhysicsProcessFactorySingleton::Instance();
    std::map<G4String, G4String>::const_iterator repitr = 
      fPhysicsReplaceList.begin();
    for ( ; repitr != fPhysicsReplaceList.end(); ++repitr ) {
      G4String key = repitr->first;
      G4String procName = repitr->second;
      G4bool known = procFactory.IsKnownPhysicsProcess(procName);
      if ( ! known ) printPhysicsProcesses = true;
      G4cout << "  " << std::setw(10) << key << "  ==> "
             << std::setw(30) << procName << "  "
             << ( (known)?"known":"*** unknown ***" ) << G4endl;
    }
    if ( printPhysicsProcesses ) procFactory.PrintAvailablePhysicsProcesses();
  }
}

G4VModularPhysicsList * G4PhysListFactorySingleton::ReferencePhysList

(

)

Definition at line 82 of file G4PhysListFactorySingleton.cc.

{
  // instantiate PhysList by environment variable "PHYSLIST"
  G4String name = "";
  char* path = getenv("PHYSLIST");
  if (path) {
    name = G4String(path);
  } else {
    name = defName;
    G4cout << "### G4PhysListFactorySingleton WARNING: "
           << " environment variable PHYSLIST is not defined"
           << G4endl
           << "    Default Physics Lists " << name 
           << " is instantiated" 
           << G4endl;
  }
  return GetReferencePhysList(name);
}

G4bool G4PhysListFactorySingleton::RegisterCreator	(	G4String	name,
		PhysListCtorFuncPtr_t	ctorptr,
		G4bool *	ptr
	)

Definition at line 242 of file G4PhysListFactorySingleton.cc.

{
  // record new functions for creating lists
  fFunctionMap[name] = foo;
  fBoolPtrMap[name]  = boolptr;
  return true;
}

G4bool G4PhysListFactorySingleton::RegisterPhysicsReplacement	(	G4String	key,
		G4String	physics
	)

Definition at line 252 of file G4PhysListFactorySingleton.cc.

{
  fPhysicsReplaceList[key] = physics;
  return true;
}

void G4PhysListFactorySingleton::SetDefaultName ( const G4String &  defname )

inline

Definition at line 94 of file G4PhysListFactorySingleton.hh.

{ defName = defname; }

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 144 of file G4PhysListFactorySingleton.hh.

Member Data Documentation

G4String G4PhysListFactorySingleton::defName

private

Definition at line 111 of file G4PhysListFactorySingleton.hh.

std::map<G4String, G4bool*> G4PhysListFactorySingleton::fBoolPtrMap

private

Definition at line 104 of file G4PhysListFactorySingleton.hh.

std::map<G4String, PhysListCtorFuncPtr_t> G4PhysListFactorySingleton::fFunctionMap

private

Definition at line 101 of file G4PhysListFactorySingleton.hh.

G4PhysListFactorySingleton * G4PhysListFactorySingleton::fgTheInstance

staticprivate

Definition at line 98 of file G4PhysListFactorySingleton.hh.

std::map<G4String, G4String> G4PhysListFactorySingleton::fPhysicsReplaceList

private

Definition at line 106 of file G4PhysListFactorySingleton.hh.

std::vector<G4String> G4PhysListFactorySingleton::listnames

mutableprivate

Definition at line 114 of file G4PhysListFactorySingleton.hh.

---

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

• nutools/old/G4Base/G4PhysListFactorySingleton.hh
• nutools/old/G4Base/G4PhysListFactorySingleton.cc