A singleton class holding all configuration registries built while parsing all loaded XML configuration files. More...

#include <AlgConfigPool.h>

Collaboration diagram for genie::AlgConfigPool:

Classes
struct	Cleaner

Public Member Functions
Registry *	FindRegistry (string key) const

Registry *	FindRegistry (string alg_name, string param_set) const

Registry *	FindRegistry (const Algorithm *algorithm) const

Registry *	FindRegistry (const AlgId &algid) const

Registry *	GlobalParameterList (void) const

Registry *	CommonList (const string &file_id, const string &set_name) const

Registry *	TuneGeneratorList (void) const

const vector< string > &	ConfigKeyList (void) const

void	Print (ostream &stream) const

Static Public Member Functions
static AlgConfigPool *	Instance ()

Private Member Functions
	AlgConfigPool ()

	AlgConfigPool (const AlgConfigPool &config_pool)

virtual	~AlgConfigPool ()

string	BuildConfigKey (string alg_name, string param_set) const

string	BuildConfigKey (const Algorithm *algorithm) const

bool	LoadAlgConfig (void)

bool	LoadMasterConfig (std::string configname)

bool	LoadMasterConfigs (void)

bool	LoadGlobalParamLists (void)

bool	LoadCommonLists (const string &file_id)

bool	LoadTuneGeneratorList (void)

bool	LoadSingleAlgConfig (string alg_name, string file_name)

bool	LoadRegistries (string key_base, string file_name, string root)

int	AddParameterVector (Registry *r, string pt, string pn, string pv, const string &delim=";")

int	AddParameterMatrix (Registry *r, string pt, string pn, string pv, const string &rowdelim, const string &coldelim)

int	AddParameterMatrix (Registry *r, string pt, string pn, string pv)

void	AddConfigParameter (Registry *r, string pt, string pn, string pv)

void	AddBasicParameter (Registry *r, string pt, string pn, string pv)

void	AddRootObjParameter (Registry *r, string pt, string pn, string pv)

Private Attributes
map< string, Registry * >	fRegistryPool
	algorithm/param_set -> Registry More...

map< string, string >	fConfigFiles
	algorithm -> XML config file More...

vector< string >	fConfigKeyList
	list of all available configuration keys More...

string	fMasterConfig
	lists config files for all algorithms More...

Static Private Attributes
static AlgConfigPool *	fInstance = 0

Friends
struct	Cleaner

ostream &	operator<< (ostream &stream, const AlgConfigPool &cp)

Detailed Description

A singleton class holding all configuration registries built while parsing all loaded XML configuration files.

Author: Costas Andreopoulos <c.andreopoulos cern.ch> University of Liverpool

Created:: May 06, 2004

License:: Copyright (c) 2003-2024, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 40 of file AlgConfigPool.h.

Constructor & Destructor Documentation

AlgConfigPool::AlgConfigPool ( )

private

Definition at line 52 of file AlgConfigPool.cxx.

References fInstance, LoadAlgConfig(), LOG, and pERROR.

Referenced by Instance().

 {
   if( ! this->LoadAlgConfig() )
   LOG("AlgConfigPool", pERROR) << "Could not load XML config file";
   fInstance =  0;
 }

genie::AlgConfigPool::AlgConfigPool ( const AlgConfigPool & config_pool )

private

AlgConfigPool::~AlgConfigPool ( )

privatevirtual

Definition at line 59 of file AlgConfigPool.cxx.

References fConfigFiles, fConfigKeyList, fInstance, fRegistryPool, and genie::gAbortingInErr.

 {
 // Clean up and report the most important physics params used in this instance.
 // Don't clutter output if exiting in err.
 
   if(!gAbortingInErr) {
 /*
     cout << "AlgConfigPool singleton dtor: "
          << "Deleting all owned algorithm configurations" << endl;
 */
   }
   map<string, Registry *>::iterator citer;
   for(citer = fRegistryPool.begin(); citer != fRegistryPool.end(); ++citer) {
     string key = citer->first;
     Registry * config = citer->second;
     if(config) {
       delete config;
       config = 0;
     }
   }
   fRegistryPool.clear();
   fConfigFiles.clear();
   fConfigKeyList.clear();
   fInstance = 0;
 }

Member Function Documentation

void AlgConfigPool::AddBasicParameter	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv
	)

private

Definition at line 591 of file AlgConfigPool.cxx.

References LOG, pERROR, pFATAL, genie::Registry::Set(), and genie::utils::str::Split().

Referenced by AddConfigParameter().

 {
   RgKey key = pname;
 
   if (ptype=="double") {
     RgDbl item = (double) atof(pvalue.c_str());
     r->Set(key, item);
   }
   else if (ptype=="int") {
     RgInt item = (int) atoi(pvalue.c_str());
     r->Set(key, item);
   }
   else if (ptype=="bool") {
     if      (pvalue=="true" ) r->Set(key, true );
     else if (pvalue=="TRUE" ) r->Set(key, true );
     else if (pvalue=="1"    ) r->Set(key, true );
     else if (pvalue=="false") r->Set(key, false);
     else if (pvalue=="FALSE") r->Set(key, false);
     else if (pvalue=="0"    ) r->Set(key, false);
     else {
       LOG("AlgConfigPool", pERROR)
         << "Could not set bool param: " << key;
     }
   }
   else if (ptype=="string") {
     RgStr item = pvalue;
     r->Set(key, item);
   }
   else if (ptype=="alg") {
     string name, config;
     vector<string> algv = utils::str::Split(pvalue, "/");
     if (algv.size()==2) {
       name   = algv[0];
       config = algv[1];
     }
     else if (algv.size()==1) {
       name   = algv[0];
       config = "Default";
     } else {
        LOG("AlgConfigPool", pFATAL)
              << "Unrecognized algorithm id: " << pvalue;
        exit(1);
     }
     RgAlg item(name,config);
     r->Set(key, item);
   }
   else {
    LOG("AlgConfigPool", pERROR)
         << "Config. parameter: " << key
                  << "has unrecognized type: " << ptype;
   }
 }

void AlgConfigPool::AddConfigParameter	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv
	)

private

Definition at line 561 of file AlgConfigPool.cxx.

References AddBasicParameter(), AddRootObjParameter(), pDEBUG, pERROR, and SLOG.

Referenced by AddParameterMatrix(), AddParameterVector(), and LoadRegistries().

 {
 // Adds a configuration parameter with type = ptype, key = pname and value =
 // pvalue at the input configuration registry r
 
   SLOG("AlgConfigPool", pDEBUG)
     << "Adding Parameter [" << ptype << "]: Key = "
     << pname << " -> Value = " << pvalue;
 
   bool isRootObjParam = (strcmp(ptype.c_str(), "h1f")    == 0) ||
                         (strcmp(ptype.c_str(), "Th2f")   == 0) ||
                         (strcmp(ptype.c_str(), "tree")   == 0);
   bool isBasicParam   = (strcmp(ptype.c_str(), "int")    == 0) ||
                         (strcmp(ptype.c_str(), "bool")   == 0) ||
                         (strcmp(ptype.c_str(), "double") == 0) ||
                         (strcmp(ptype.c_str(), "string") == 0) ||
                         (strcmp(ptype.c_str(), "alg")    == 0);
 
 
   if     (isBasicParam)   this->AddBasicParameter  (r, ptype, pname, pvalue);
   else if(isRootObjParam) this->AddRootObjParameter(r, ptype, pname, pvalue);
   else {
     SLOG("AlgConfigPool", pERROR)
       << "Parameter [" << ptype << "]: Key = " << pname
       << " -> Value = " << pvalue << " could not be added";
   }
 
 }

int AlgConfigPool::AddParameterMatrix	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv,
		const string &	rowdelim,
		const string &	coldelim
	)

private

Definition at line 441 of file AlgConfigPool.cxx.

References AddConfigParameter(), genie::Algorithm::BuildParamMatColSizeKey(), genie::Algorithm::BuildParamMatKey(), genie::Algorithm::BuildParamMatRowSizeKey(), LOG, pDEBUG, pFATAL, SLOG, genie::utils::str::Split(), and genie::utils::str::TrimSpaces().

Referenced by LoadRegistries().

                                                                                             {
 
   // Adds a configuration parameter matrix
   // It is simply add a number of entries in the Registy
   // The name scheme starts from the name and it goes like
   // 'Nrow'+pn+'s' for the size of rows and 
   // 'Ncol'+pn+'s' for the size of columns
   // that will be an integer with the number of entries.
   // Each entry will be named pn+"-i"+"-j" where i and j are 
   // index of row and column and replaced by the number
 
   if(!rowdelim.compare(coldelim) || rowdelim.empty() || coldelim.empty()) {
     LOG("AlgConfigPool", pFATAL) << "row and column have wrong delims: " << rowdelim << "  " << coldelim ;
     exit(1);
   }
   SLOG("AlgConfigPool", pDEBUG)
     << "Adding Parameter Matrix [" << pt << "]: Key = "
     << pn << " -> Value = " << pv;
 
   vector<string> mat_row = utils::str::Split( pv, rowdelim ) ;
 
   string r_name = Algorithm::BuildParamMatRowSizeKey( pn ) ;
 
 
   unsigned int n_row = 0, n_col = 0;
   std::stringstream r_value ;
   r_value << mat_row.size() ;
   n_row = mat_row.size() ;
 
   this->AddConfigParameter(r, "int", r_name, r_value.str() );
 
   for ( unsigned int i = 0 ; i < mat_row.size() ; ++i ) {
     vector<string> bits = utils::str::Split( mat_row[i], coldelim ) ;
     if(i == 0){
       string c_name = Algorithm::BuildParamMatColSizeKey( pn ) ;
       std::stringstream c_value ;
       c_value << bits.size();
       n_col = bits.size();
       this->AddConfigParameter(r, "int", c_name, c_value.str() );
     }
     else{
       if(n_col != bits.size()){
         LOG("AlgConfigPool", pFATAL) << "wrong size of matrix in row: " << i;
         exit(1);
       }
     }
 
     for ( unsigned int j = 0 ; j < bits.size() ; ++j ) {
 
       std::string name = Algorithm::BuildParamMatKey( pn, i, j ) ;
 
       this -> AddConfigParameter( r, pt, name, utils::str::TrimSpaces( bits[j] ) );
 
     }
   }
   return n_row * n_col;
 
 }

int AlgConfigPool::AddParameterMatrix	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv
	)

private

Definition at line 501 of file AlgConfigPool.cxx.

References AddConfigParameter(), genie::Algorithm::BuildParamMatColSizeKey(), genie::Algorithm::BuildParamMatKey(), genie::Algorithm::BuildParamMatRowSizeKey(), LOG, pFATAL, and genie::utils::str::TrimSpaces().

                                                                                        {
 
   // Adds a configuration parameter matrix
   // It is simply add a number of entries in the Registy
   // The name scheme starts from the name and it goes like
   // 'Nrow'+pn+'s' for the size of rows and 
   // 'Ncol'+pn+'s' for the size of columns
   // that will be an integer with the number of entries.
   // Each entry will be named pn+"-i"+"-j" where i and j are 
   // index of row and column and replaced by the number
 
   char * GENIE_PATH = std::getenv("GENIE");
   string filepath = std::string(GENIE_PATH) + "/" + pv;
   std::ifstream file(filepath);
   if (!file.is_open()) {
     throw std::runtime_error("Could not open file");
   }
 
   std::string line;
   int n_row = 0, n_col = 0;
   int i_row = 0;
   while (getline(file, line)) {
     size_t start = line.find_first_not_of(" \t");
     std::string trimmedLine = (start == std::string::npos) ? "" : line.substr(start);
     if(trimmedLine.empty()) continue;
     if(!trimmedLine.empty() && trimmedLine[0] == '%') continue;
 
     std::istringstream iss(line);
     double value;
     int i_col = 0;
     while (iss >> value) {
       std::string name = Algorithm::BuildParamMatKey( pn, i_row, i_col ) ;
       this -> AddConfigParameter( r, pt, name, utils::str::TrimSpaces( std::to_string(value) ) );
       i_col++;
     }
     if(i_row == 0)
       n_col = i_col;
     else{
       if(n_col != i_col){
          LOG("AlgConfigPool", pFATAL) << "wrong size of matrix in row: " << i_row;
          exit(1);
       }
     }
     i_row++;
   }
   n_row = i_row;
   std::stringstream r_value ;
   r_value << n_row ;
   string r_name = Algorithm::BuildParamMatRowSizeKey( pn ) ;
   this->AddConfigParameter(r, "int", r_name, r_value.str() );
   std::stringstream c_value ;
   c_value << n_col ;
   string c_name = Algorithm::BuildParamMatColSizeKey( pn ) ;
   this->AddConfigParameter(r, "int", c_name, c_value.str() );
   return n_row*n_col;
 }

int AlgConfigPool::AddParameterVector	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv,
		const string &	delim = `";"`
	)

private

Definition at line 406 of file AlgConfigPool.cxx.

References AddConfigParameter(), genie::Algorithm::BuildParamVectKey(), genie::Algorithm::BuildParamVectSizeKey(), pDEBUG, SLOG, genie::utils::str::Split(), and genie::utils::str::TrimSpaces().

Referenced by LoadRegistries().

                                                                 {
 
   // Adds a configuration parameter vector
   // It is simply add a number of entries in the Registy
   // The name scheme starts from the name and it goes like
   // 'N'+pn+'s' that will be an integer with the number of entries.
   // Each entry will be named pn+"-i" where i is replaced by the number
 
   SLOG("AlgConfigPool", pDEBUG)
     << "Adding Parameter Vector [" << pt << "]: Key = "
     << pn << " -> Value = " << pv;
 
   vector<string> bits = utils::str::Split( pv, delim ) ;
 
   string n_name = Algorithm::BuildParamVectSizeKey( pn ) ;
 
   std::stringstream n_value ;
   n_value << bits.size() ;
 
   this->AddConfigParameter(r, "int", n_name, n_value.str() );
 
   for ( unsigned int i = 0 ; i < bits.size() ; ++i ) {
 
     std::string name = Algorithm::BuildParamVectKey( pn, i ) ;
 
     this -> AddConfigParameter( r, pt, name, utils::str::TrimSpaces( bits[i] ) );
 
   }
 
   return bits.size() ;
 
 }

void AlgConfigPool::AddRootObjParameter	(	Registry *	r,
		string	pt,
		string	pn,
		string	pv
	)

private

Definition at line 645 of file AlgConfigPool.cxx.

References pERROR, pWARN, genie::Registry::Set(), SLOG, and genie::utils::str::Split().

Referenced by AddConfigParameter().

 {
   // the ROOT object is given in the XML config file as
   // <param> object_name@root_file_name </param>
   vector<string> rootobjv = utils::str::Split(pvalue, "@");
 
   if(rootobjv.size() != 2) {
     SLOG("AlgConfigPool", pWARN)
         << "ROOT objects are added in XML config files as: "
              << "object-name@file-name. Wrong syntax in: [" << pvalue << "]";
     SLOG("AlgConfigPool", pERROR)
             << "Parameter [" << ptype << "]: Key = " << pname
                         << " -> Value = " << pvalue << " could not be added";
   }
 
   string rootobj  = rootobjv[0];
   string rootfile = rootobjv[1];
 
   TFile f(rootfile.c_str(), "read");
 
   if (ptype=="h1f") {
     TH1F * h  = (TH1F*) f.Get(rootobj.c_str());
     if(h) {
       TH1F * ch = new TH1F(*h); // clone
                 ch->SetDirectory(0);
       r->Set(pname,ch);
     } else {
       SLOG("AlgConfigPool", pERROR)
          << "No TH1F named = " << rootobj << " in ROOT file = " << rootfile;
     }
   } else if (ptype=="h2f") {
     TH2F * h2  = (TH2F*) f.Get(rootobj.c_str());
     if(h2) {
       TH2F * ch2 = new TH2F(*h2); // clone
                 ch2->SetDirectory(0);
       r->Set(pname,ch2);
     } else {
       SLOG("AlgConfigPool", pERROR)
          << "No TH2F named = " << rootobj << " in ROOT file = " << rootfile;
     }
   } else if (ptype=="tree") {
     TTree * t  = (TTree*) f.Get(rootobj.c_str());
     if(t) {
       //TTree * ct = new TTree(*t); // clone
       TTree * ct = t->CopyTree("1");
       r->Set(pname,ct);
     } else {
       SLOG("AlgConfigPool", pERROR)
         << "No TTree named = " << rootobj << " in ROOT file = " << rootfile;
     }
   }
   else {}
 }

string genie::AlgConfigPool::BuildConfigKey	(	string	alg_name,
		string	param_set
	)		const

private

string genie::AlgConfigPool::BuildConfigKey ( const Algorithm * algorithm ) const

private

Registry * AlgConfigPool::CommonList	(	const string &	file_id,
		const string &	set_name
	)		const

Definition at line 744 of file AlgConfigPool.cxx.

References FindRegistry(), and LoadCommonLists().

Referenced by genie::PDGLibrary::AddDarkSector(), genie::PDGLibrary::AddHNL(), CheckUnitarityLimit(), genie::GVldContext::Decode(), genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta_rosenbluth(), genie::KPhaseSpace::GetTMaxDFR(), genie::PDGLibrary::LoadDBase(), and main().

 {
 
   ostringstream key;
   key << "Common" << file_id << "List/" << set_name;
 
   if ( ! this->FindRegistry(key.str()) ) {
         const_cast<AlgConfigPool*>( this ) -> LoadCommonLists( file_id ) ;
   }
 
   return this->FindRegistry(key.str()) ;
 }

const vector< string > & AlgConfigPool::ConfigKeyList ( void ) const

Definition at line 766 of file AlgConfigPool.cxx.

References fConfigKeyList.

Referenced by genie::NtpMCJobConfig::Load(), and main().

 {
   return fConfigKeyList;
 }

Registry * AlgConfigPool::FindRegistry ( string key ) const

Definition at line 719 of file AlgConfigPool.cxx.

References fRegistryPool, LOG, and pDEBUG.

Referenced by CommonList(), genie::Algorithm::FindConfig(), FindRegistry(), GlobalParameterList(), genie::NtpMCJobConfig::Load(), main(), testReconfigInCommonPool(), and TuneGeneratorList().

 {
   LOG("AlgConfigPool", pDEBUG) << "Searching for registry with key " << key;
 
   if( fRegistryPool.count(key) == 1 ) {
      map<string, Registry *>::const_iterator config_entry =
                                                    fRegistryPool.find(key);
      return config_entry->second;
   } else {
      LOG("AlgConfigPool", pDEBUG) << "No config registry for key " << key;
      return 0;
   }
   return 0;
 }

Registry * AlgConfigPool::FindRegistry	(	string	alg_name,
		string	param_set
	)		const

Definition at line 712 of file AlgConfigPool.cxx.

References FindRegistry().

 {
   AlgId id(alg_name,param_set);
   string key = id.Key();
   return this->FindRegistry(key);
 }

Registry * AlgConfigPool::FindRegistry ( const Algorithm * algorithm ) const

Definition at line 700 of file AlgConfigPool.cxx.

References FindRegistry(), genie::Algorithm::Id(), and genie::AlgId::Key().

 {
   string key = algorithm->Id().Key();
   return this->FindRegistry(key);
 }

Registry * AlgConfigPool::FindRegistry ( const AlgId & algid ) const

Definition at line 706 of file AlgConfigPool.cxx.

References FindRegistry(), and genie::AlgId::Key().

 {
   string key = algid.Key();
   return this->FindRegistry(key);
 }

Registry * AlgConfigPool::GlobalParameterList ( void ) const

Definition at line 734 of file AlgConfigPool.cxx.

References FindRegistry().

Referenced by genie::PauliBlocker::LoadModelType(), main(), genie::utils::nuclear::NuclQELXSecSuppression(), and genie::AlgFactory::Print().

 {
   string glob_param_set = (gSystem->Getenv("GUSERPHYSOPT")) ?
                         string(gSystem->Getenv("GUSERPHYSOPT")) : "Default";
   ostringstream key;
   key << "GlobalParameterList/" << glob_param_set;
 
   return this->FindRegistry(key.str());
 }

AlgConfigPool * AlgConfigPool::Instance ( )

static

Definition at line 85 of file AlgConfigPool.cxx.

References AlgConfigPool(), genie::AlgConfigPool::Cleaner::DummyMethodAndSilentCompiler(), and fInstance.

Referenced by genie::PDGLibrary::AddDarkSector(), genie::PDGLibrary::AddHNL(), genie::EventGeneratorListAssembler::AssembleGeneratorList(), CheckUnitarityLimit(), genie::HadronTransporter::Configure(), genie::EmpiricalMECPXSec2015::Configure(), genie::QPMDISPXSec::Configure(), genie::QPMDMDISPXSec::Configure(), genie::EventGenerator::Configure(), genie::NuclearModelMap::Configure(), genie::GVldContext::Decode(), genie::TabulatedLabFrameHadronTensor::dSigma_dT_dCosTheta_rosenbluth(), genie::Algorithm::FindConfig(), genie::KPhaseSpace::GetTMaxDFR(), genie::GMCJDriver::InitJob(), genie::NtpMCJobConfig::Load(), genie::NuclearModelI::LoadConfig(), genie::PDGLibrary::LoadDBase(), genie::PauliBlocker::LoadModelType(), main(), genie::utils::nuclear::NuclQELXSecSuppression(), genie::AlgFactory::Print(), and testReconfigInCommonPool().

 {
   if(fInstance == 0) {
     static AlgConfigPool::Cleaner cleaner;
     cleaner.DummyMethodAndSilentCompiler();
     fInstance = new AlgConfigPool;
   }
   return fInstance;
 }

bool AlgConfigPool::LoadAlgConfig ( void )

private

Definition at line 95 of file AlgConfigPool.cxx.

References fConfigFiles, genie::utils::xml::GetXMLFilePath(), LoadGlobalParamLists(), LoadMasterConfigs(), LoadSingleAlgConfig(), LoadTuneGeneratorList(), pERROR, pINFO, pNOTICE, pWARN, and SLOG.

Referenced by AlgConfigPool().

 {
 // Loads all algorithm XML configurations and creates a map with all loaded
 // configuration registries
 
   SLOG("AlgConfigPool", pINFO)
         << "AlgConfigPool late initialization: Loading all XML config. files";
 
   //-- read the global parameter lists
   if(!this->LoadGlobalParamLists()) 
   {
     SLOG("AlgConfigPool", pERROR)
       << "Global parameter lists not available "
       "This can be normal if you are running "
       "Comparisons/Reweight in some cases";
   }
 
   //-- read the MASTER_CONFIG XML file
   if(!this->LoadMasterConfigs()) 
   {
     SLOG("AlgConfigPool", pERROR)
       << "Master config file not available";
   }
 
   //-- read Tune Generator List for the tune, if available
   if( ! LoadTuneGeneratorList() ) {
     SLOG( "AlgConfigPool", pWARN ) << "Tune generator List not available" ;
   }
 
   //-- loop over all XML config files and read all named configuration
   //   sets for each algorithm
   map<string, string>::const_iterator conf_file_iter;
 
   for(conf_file_iter = fConfigFiles.begin();
                   conf_file_iter != fConfigFiles.end(); ++conf_file_iter) {
 
     string alg_name    = conf_file_iter->first;
     string file_name   = conf_file_iter->second;
 
     SLOG("AlgConfigPool", pINFO)
          << setfill('.') << setw(40) << alg_name << " -> " << file_name;
 
     string full_path = utils::xml::GetXMLFilePath(file_name);
     SLOG("AlgConfigPool", pNOTICE)
       << "*** GENIE XML config file " << full_path;
     bool ok = this->LoadSingleAlgConfig(alg_name, full_path);
     if(!ok) {
       SLOG("AlgConfigPool", pERROR)
            << "Error in loading config sets for algorithm = " << alg_name;
     }
   }
   return true;
 };

bool AlgConfigPool::LoadCommonLists ( const string & file_id )

private

Definition at line 235 of file AlgConfigPool.cxx.

References genie::utils::xml::GetXMLFilePath(), LoadRegistries(), pERROR, pINFO, and SLOG.

Referenced by CommonList().

 {
 // Load the common parameter list
 //
   SLOG("AlgConfigPool", pINFO) << "Loading Common " << file_id << " lists";
 
   // -- get the user config XML file using GXMLPATH + default locations
   std::string xml_name = "Common" + file_id + ".xml" ;
   string full_path = utils::xml::GetXMLFilePath( xml_name );
 
   // fixed key prefix
   string key_prefix = "Common" + file_id + "List";
 
   // load and report status
   if ( ! this->LoadRegistries(key_prefix, full_path, "common_"+file_id+"_list") ) {
 
           SLOG("AlgConfigPool", pERROR) << "Failed to load Common " << file_id ;
           return false ;
   }
 
   return true ;
 }

bool AlgConfigPool::LoadGlobalParamLists ( void )

private

Definition at line 218 of file AlgConfigPool.cxx.

References genie::utils::xml::GetXMLFilePath(), LoadRegistries(), pINFO, and SLOG.

Referenced by LoadAlgConfig().

 {
 // Load the global parameter list (a list of physics constants at a given MC
 // job, that is allowed to be modified to fine tune the generator output)
 //
   SLOG("AlgConfigPool", pINFO) << "Loading global parameter lists";
 
   // -- get the user config XML file using GXMLPATH + default locations
   string glob_params = utils::xml::GetXMLFilePath("ModelConfiguration.xml");
 
   // fixed key prefix
   string key_prefix = "GlobalParameterList";
 
   // load and report status
   return this->LoadRegistries(key_prefix, glob_params, "global_param_list");
 }

bool AlgConfigPool::LoadMasterConfig ( std::string configname )

private

Definition at line 149 of file AlgConfigPool.cxx.

References fConfigFiles, fMasterConfig, genie::utils::xml::GetAttribute(), genie::utils::xml::GetXMLFilePath(), pERROR, SLOG, genie::utils::str::TrimSpaces(), and genie::utils::xml::TrimSpaces().

Referenced by LoadMasterConfigs().

 {
 // Loads the master config XML file: the file that specifies which XML config
 // file to load for each algorithm
 
   //-- get the master config XML file using GXMLPATH + default locations
   // fMasterConfig = utils::xml::GetXMLFilePath("master_config.xml");
   fMasterConfig = utils::xml::GetXMLFilePath(configname);
 
   bool is_accessible = ! (gSystem->AccessPathName( fMasterConfig.c_str() ));
   if (!is_accessible) {
      SLOG("AlgConfigPool", pERROR)
        << "The XML doc doesn't exist! (filename : " << fMasterConfig << ")";
      return false;
   }
 
   xmlDocPtr xml_doc = xmlParseFile(fMasterConfig.c_str());
   if(xml_doc==NULL) {
      SLOG("AlgConfigPool", pERROR)
       << "The XML doc can't be parsed! (filename : " << fMasterConfig << ")";
      return false;
   }
 
   xmlNodePtr xml_root = xmlDocGetRootElement(xml_doc);
   if(xml_root==NULL) {
      SLOG("AlgConfigPool", pERROR)
              << "The XML doc is empty! (filename : " << fMasterConfig << ")";
      xmlFreeDoc(xml_doc);
      return false;
   }
 
   if( xmlStrcmp(xml_root->name, (const xmlChar *) "genie_config") ) {
      SLOG("AlgConfigPool", pERROR)
               << "The XML doc has invalid root element! "
                                    << "(filename : " << fMasterConfig << ")";
      xmlFreeDoc(xml_doc);
      return false;
   }
 
   // loop over all xml tree nodes (<alg_config>) that are children of the
   // root node and read the config file name for each registered algorithm
   xmlNodePtr xml_ac = xml_root->xmlChildrenNode;
   while (xml_ac != NULL) {
     if( (!xmlStrcmp(xml_ac->name, (const xmlChar *) "config")) ) {
 
        string alg_name  = utils::str::TrimSpaces(
                      utils::xml::GetAttribute(xml_ac, "alg"));
        string config_file = utils::xml::TrimSpaces(
                 xmlNodeListGetString(xml_doc, xml_ac->xmlChildrenNode, 1));
 
        pair<string, string> alg_conf(alg_name, config_file);
        fConfigFiles.insert(alg_conf);
     }
     xml_ac = xml_ac->next;
   }
   xmlFreeNode(xml_ac);
   xmlFreeDoc(xml_doc);
   return true;
 }

bool AlgConfigPool::LoadMasterConfigs ( void )

private

Definition at line 209 of file AlgConfigPool.cxx.

References LoadMasterConfig(), and main().

Referenced by LoadAlgConfig().

                                           {
   auto main = LoadMasterConfig("master_config.xml");
   if (std::getenv("GENIE_REWEIGHT")) {
     auto rew_main = LoadMasterConfig("reweight_master_config.xml");
     return main && rew_main;
   } else
     return main;
 }

bool AlgConfigPool::LoadRegistries	(	string	key_base,
		string	file_name,
		string	root
	)

private

Definition at line 287 of file AlgConfigPool.cxx.

References AddConfigParameter(), AddParameterMatrix(), AddParameterVector(), fConfigKeyList, fRegistryPool, genie::utils::xml::GetAttribute(), genie::Registry::Lock(), LOG, pDEBUG, pERROR, pNOTICE, genie::Registry::SetName(), SLOG, genie::utils::str::TrimSpaces(), and genie::utils::xml::TrimSpaces().

Referenced by LoadCommonLists(), LoadGlobalParamLists(), LoadSingleAlgConfig(), and LoadTuneGeneratorList().

 {
 // Loads all the configuration registries from the input XML file
 
   SLOG("AlgConfigPool", pDEBUG) << "[-] Loading registries:";
 
   bool is_accessible = ! (gSystem->AccessPathName(file_name.c_str()));
   if (!is_accessible) {
      SLOG("AlgConfigPool", pERROR)
        << "The XML doc doesn't exist! (filename : " << file_name << ")";
      return false;
   }
 
   xmlDocPtr xml_doc = xmlParseFile( file_name.c_str() );
   if(xml_doc==NULL) {
      SLOG("AlgConfigPool", pERROR)
       << "The XML document can't be parsed! (filename : " << file_name << ")";
      return false;
   }
 
   xmlNodePtr xml_cur = xmlDocGetRootElement( xml_doc );
   if(xml_cur==NULL) {
      SLOG("AlgConfigPool", pERROR)
              << "The XML document is empty! (filename : " << file_name << ")";
      xmlFreeDoc(xml_doc);
      return false;
   }
   if( xmlStrcmp(xml_cur->name, (const xmlChar *) root.c_str()) ) {
      SLOG("AlgConfigPool", pERROR)
               << "The XML document has invalid root element! "
                                         << "(filename : " << file_name << ")";
      xmlFreeNode(xml_cur);
      xmlFreeDoc(xml_doc);
      return false;
   }
 
   // loop over all xml tree nodes that are children of the root node
   xml_cur = xml_cur->xmlChildrenNode;
   while (xml_cur != NULL) {
     // enter everytime you find an 'param_set' tag
     if( (!xmlStrcmp(xml_cur->name, (const xmlChar *) "param_set")) ) {
 
       string param_set  = utils::str::TrimSpaces(
                            utils::xml::GetAttribute(xml_cur, "name"));
 
       // build the registry key
       ostringstream key;
       key << key_prefix << "/" << param_set;
 
       // store the key in the key list
       fConfigKeyList.push_back(key.str());
 
       // create a new Registry and fill it with the configuration params
       Registry * config = new Registry(param_set,false);
 
       xmlNodePtr xml_param = xml_cur->xmlChildrenNode;
       while (xml_param != NULL) {
         if( (!xmlStrcmp(xml_param->name, (const xmlChar *) "param")) ) {
 
             string param_type =
                    utils::str::TrimSpaces(
                        utils::xml::GetAttribute(xml_param, "type"));
             string param_name =
                    utils::str::TrimSpaces(
                        utils::xml::GetAttribute(xml_param, "name"));
             string param_value =
                     utils::xml::TrimSpaces(
                                xmlNodeListGetString(
                                  xml_doc, xml_param->xmlChildrenNode, 1));
 
 
             if ( param_type.find( "vec-" ) == 0 ) {
 
               param_type = param_type.substr( 4 ) ;
 
               string delim = utils::str::TrimSpaces( utils::xml::GetAttribute(xml_param, "delim"));
 
               this -> AddParameterVector( config, param_type, param_name, param_value, delim ) ;
             }
             else if (param_type.find( "mat-" ) == 0) {
               param_type = param_type.substr( 4 ) ;
               LOG("AlgConfigPool", pNOTICE) << "Liang Liu" << param_type ;
                 string importfile = utils::str::TrimSpaces( utils::xml::GetAttribute(xml_param, "importfile"));
                 if(!importfile.compare("false")){
                   string rowdelim = utils::str::TrimSpaces( utils::xml::GetAttribute(xml_param, "rowdelim"));
                   string coldelim = utils::str::TrimSpaces( utils::xml::GetAttribute(xml_param, "coldelim"));
                   this -> AddParameterMatrix(config, param_type, param_name, param_value, rowdelim, coldelim);
                 }
                 else if(!importfile.compare("true")){
                   this -> AddParameterMatrix(config, param_type, param_name, param_value );
                 }
             }
             else this->AddConfigParameter( config,
                                            param_type, param_name,
                                            param_value);
         }
         xml_param = xml_param->next;
       }
       //xmlFree(xml_param);
       xmlFreeNode(xml_param);
       config->SetName(param_set);
       config->Lock();
 
       pair<string, Registry *> single_reg(key.str(), config);
       fRegistryPool.insert(single_reg);
 
       SLOG("AlgConfigPool", pDEBUG) << " |---o " << key.str();
     }
     xml_cur = xml_cur->next;
   }
   //xmlFree(xml_cur);
   xmlFreeNode(xml_cur);
   //xmlFree(xml_doc);
   xmlFreeDoc(xml_doc);
 
   return true;
 }

bool AlgConfigPool::LoadSingleAlgConfig	(	string	alg_name,
		string	file_name
	)

private

Definition at line 275 of file AlgConfigPool.cxx.

References LoadRegistries().

Referenced by LoadAlgConfig().

 {
 // Loads all configuration sets for the input algorithm that can be found in
 // the input XML file
 
   // use the algorithm name as the key prefix
   string key_prefix = alg_name;
 
   // load and report status
   return this->LoadRegistries(key_prefix, file_name, "alg_conf");
 }

bool AlgConfigPool::LoadTuneGeneratorList ( void )

private

Definition at line 258 of file AlgConfigPool.cxx.

References genie::utils::xml::GetXMLFilePath(), LoadRegistries(), pINFO, and SLOG.

Referenced by LoadAlgConfig().

 {
 // Load the common parameter list
 //
   SLOG("AlgConfigPool", pINFO) << "Loading Tune Gerator List";
 
   // -- get the user config XML file using GXMLPATH + default locations
   string generator_list_file = utils::xml::GetXMLFilePath("TuneGeneratorList.xml");
 
   // fixed key prefix
   string key_prefix = "TuneGeneratorList";
 
   // load and report status
   return this->LoadRegistries(key_prefix, generator_list_file, "tune_generator_list");
 }

void AlgConfigPool::Print ( ostream & stream ) const

Definition at line 771 of file AlgConfigPool.cxx.

References fRegistryPool.

Referenced by genie::operator<<().

 {
   string frame(100,'~');
 
   typedef map<string, Registry *>::const_iterator  sregIter;
   typedef map<string, Registry *>::size_type       sregSize;
 
   sregSize size = fRegistryPool.size();
 
   stream << frame
          << endl << "Algorithm Configuration Pool ("
          << size << " configuration sets found)"
          << endl << frame << endl;
 
   sregIter iter = fRegistryPool.begin();
   for( ; iter != fRegistryPool.end(); iter++) {
      const Registry & reg = *(iter->second);
      stream << iter->first;
      stream << reg;
      stream << frame << endl;
   }
 }

Registry * AlgConfigPool::TuneGeneratorList ( void ) const

Definition at line 757 of file AlgConfigPool.cxx.

References FindRegistry().

 {
 
   ostringstream key;
   key << "TuneGeneratorList/Default";
 
   return this->FindRegistry(key.str());
 }

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 100 of file AlgConfigPool.h.

ostream& operator<<	(	ostream &	stream,
		const AlgConfigPool &	cp
	)

friend

Definition at line 43 of file AlgConfigPool.cxx.

   {
     config_pool.Print(stream);
     return stream;
   }

Member Data Documentation

map<string, string> genie::AlgConfigPool::fConfigFiles

private

algorithm -> XML config file

Definition at line 87 of file AlgConfigPool.h.

Referenced by LoadAlgConfig(), LoadMasterConfig(), and ~AlgConfigPool().

vector<string> genie::AlgConfigPool::fConfigKeyList

private

list of all available configuration keys

Definition at line 88 of file AlgConfigPool.h.

Referenced by ConfigKeyList(), LoadRegistries(), and ~AlgConfigPool().

AlgConfigPool * AlgConfigPool::fInstance = 0

staticprivate

Definition at line 84 of file AlgConfigPool.h.

Referenced by AlgConfigPool(), Instance(), ~AlgConfigPool(), and genie::AlgConfigPool::Cleaner::~Cleaner().

string genie::AlgConfigPool::fMasterConfig

private

lists config files for all algorithms

Definition at line 89 of file AlgConfigPool.h.

Referenced by LoadMasterConfig().

map<string, Registry *> genie::AlgConfigPool::fRegistryPool

private

algorithm/param_set -> Registry

Definition at line 86 of file AlgConfigPool.h.

Referenced by FindRegistry(), LoadRegistries(), Print(), and ~AlgConfigPool().

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

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation