genie::AlgFactory Class Reference

The GENIE Algorithm Factory. More...

#include <AlgFactory.h>

Classes
struct	Cleaner
	singleton cleaner More...

Public Member Functions
const Algorithm *	GetAlgorithm (const AlgId &algid)
const Algorithm *	GetAlgorithm (string name, string conf="Default")
Algorithm *	AdoptAlgorithm (const AlgId &algid) const
Algorithm *	AdoptAlgorithm (string name, string conf="Default") const
void	ForceReconfiguration (bool ignore_alg_opt_out=false)
void	Print (ostream &stream) const
	print algorithm factory More...

Static Public Member Functions
static AlgFactory *	Instance ()

Private Member Functions
	AlgFactory ()
	AlgFactory (const AlgFactory &alg_factory)
virtual	~AlgFactory ()
Algorithm *	InstantiateAlgorithm (string name, string config) const

Private Attributes
map< string, Algorithm * >	fAlgPool
	'algorithm key' (namespace::name/config) -> 'algorithmic object' map More...

Static Private Attributes
static AlgFactory *	fInstance = 0
	sinleton's self More...

Friends
struct	Cleaner
ostream &	operator<< (ostream &stream, const AlgFactory &algf)

Detailed Description

The GENIE Algorithm Factory.

Author

Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

May 12, 2004

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

Definition at line 39 of file AlgFactory.h.

Constructor & Destructor Documentation

AlgFactory::AlgFactory ( )

private

Definition at line 37 of file AlgFactory.cxx.

{
  fInstance =  0;
}

genie::AlgFactory::AlgFactory ( const AlgFactory &  alg_factory )

private

AlgFactory::~AlgFactory ( )

privatevirtual

Definition at line 42 of file AlgFactory.cxx.

{
// Clean up and report on the concrete algorithms  used in this instance.
// Don't clutter output if exiting in err.

  map<string, Algorithm *>::iterator alg_iter;
  for(alg_iter = fAlgPool.begin(); alg_iter != fAlgPool.end(); ++alg_iter) {
    Algorithm * alg = alg_iter->second;
    if(alg) {
/*
      if(!gAbortingInErr) {
        cout << "- Deleting algorithm: " << alg->Id() << endl;
      }
*/
      delete alg;
      alg = 0;
    }
  }
  fAlgPool.clear();
  fInstance = 0;
}

Member Function Documentation

Algorithm * AlgFactory::AdoptAlgorithm

(

const AlgId &

algid

)

const

Like GetAlgorithm() but the algorithm is not placed at the AlgFactory pool and its ownership is transfered to the caller

Hands over an algorithm instance that is owned by the client. The client can alter this object (eg. reconfigure) but the AlgFactory does not keep track of it and the client is responsible for deleting it.

Definition at line 116 of file AlgFactory.cxx.

{
//! Hands over an algorithm instance that is owned by the client.
//! The client can alter this object (eg. reconfigure) but the AlgFactory does
//! not keep track of it and the client is responsible for deleting it.

  return this->AdoptAlgorithm(algid.Name(), algid.Config());
}

Algorithm * AlgFactory::AdoptAlgorithm	(	string	name,
		string	conf = "Default"
	)		const

Definition at line 125 of file AlgFactory.cxx.

{
   Algorithm * alg_base = InstantiateAlgorithm(name, config);
   return alg_base;
}

void AlgFactory::ForceReconfiguration

(

bool

ignore_alg_opt_out = false

)

Forces a reconfiguration of all algorithms kept at the factory pool. The algorithms look up their nominal configuration from the config pool. Use that to propagate modifications made directly at the config pool.

Definition at line 131 of file AlgFactory.cxx.

{
  LOG("AlgFactory", pNOTICE)
       << " ** Forcing algorithm re-configuration";

  map<string, Algorithm *>::iterator alg_iter = fAlgPool.begin();
  for( ; alg_iter != fAlgPool.end(); ++alg_iter) {
    Algorithm * alg = alg_iter->second;
    bool reconfig = (ignore_alg_opt_out) ? true : alg->AllowReconfig();
    if(reconfig) {
       string config = alg->Id().Config();
       bool skip_conf = (config=="NoConfig" || config=="");
       if(!skip_conf) {
//         LOG("AlgFactory", pINFO) << "Reconfiguring: " << alg->Id().Key();
           alg->Configure(config);
       }
    }//allow?
  }
}

const Algorithm * AlgFactory::GetAlgorithm

(

const AlgId &

algid

)

Instantiates, configures and returns a pointer to the specified algorithm. The algorithm is placed at the AlgFactory pool (is owned by the factory) from where it will be looked up at subsequent calls.

Manages the instantiation and "storage/retrieval" of algorithms. These algorithms are owned by the factory and it hands over (to the client) a "const Algorithm *" that can be dynamically casted to the requested Algorithm Interface (eg. XSecAlgorithmI, Decayer, PdfModelI, etc...)

Definition at line 75 of file AlgFactory.cxx.

{
//! Manages the instantiation and "storage/retrieval" of algorithms.
//! These algorithms are owned by the factory and it hands over (to the client)
//! a "const Algorithm *" that can be dynamically casted to the requested
//! Algorithm Interface (eg. XSecAlgorithmI, Decayer, PdfModelI, etc...)

  return this->GetAlgorithm(algid.Name(), algid.Config());
}

const Algorithm * AlgFactory::GetAlgorithm	(	string	name,
		string	conf = "Default"
	)

Definition at line 85 of file AlgFactory.cxx.

{
  string key = name + "/" + config;

  SLOG("AlgFactory", pDEBUG)
      << "Algorithm: " << key << " requested from AlgFactory";

  map<string, Algorithm *>::const_iterator alg_iter = fAlgPool.find(key);
  bool found = (alg_iter != fAlgPool.end());

  if(found) {
     LOG("AlgFactory", pDEBUG) << key << " algorithm found in memory";
     return alg_iter->second;
  } else {
     //-- instantiate the factory
     Algorithm * alg_base = this->InstantiateAlgorithm(name,config);

     //-- cache the algorithm for future use
     if(alg_base) {
        pair<string, Algorithm *> key_alg_pair(key, alg_base);
        fAlgPool.insert(key_alg_pair);
     } else {
        LOG("AlgFactory", pFATAL)
            << "Algorithm: " << key << " could not be instantiated";
        exit(1);
     }
     return alg_base;
  }
  return 0;
}

AlgFactory * AlgFactory::Instance ( )

static

Definition at line 64 of file AlgFactory.cxx.

{
  if(fInstance == 0) {
    static AlgFactory::Cleaner cleaner;
    cleaner.DummyMethodAndSilentCompiler();

    fInstance = new AlgFactory;
  }
  return fInstance;
}

Algorithm * AlgFactory::InstantiateAlgorithm ( string  name, string  config  ) const

private

method instantiating (based on TClass * TROOT::GetClass(name)) & configuring algorithmic objects

Instantiate the requested object based on the registration of its TClass through the generated ROOT dictionaries The class of any object instantiated here must have a LinkDef entry.

Definition at line 151 of file AlgFactory.cxx.

{
//! Instantiate the requested object based on the registration of its TClass
//! through the generated ROOT dictionaries
//! The class of any object instantiated here must have a LinkDef entry.

  // Get object through ROOT's TROOT::GetClass() mechanism
  LOG("AlgFactory", pDEBUG) << "Instantiating algorithm = " << name;

  TClass * tclass = gROOT->GetClass(name.c_str());
  if(!tclass) {
     LOG("AlgFactory", pERROR)
         << "Failed instantiating algorithm = " << name;
     return 0;
  }
  void * vd_base = tclass->New();
  Algorithm * alg_base = (Algorithm *) (vd_base);

  // Configure the instantiated algorithm

  LOG("AlgFactory", pDEBUG) << "Setting Configuration Set = " << config;

  bool skip_conf = (config=="NoConfig" || config=="");
  if ( skip_conf ) {
    LOG("AlgFactory", pDEBUG) << "Skipping algorithm configuration step!";
  } else {
    alg_base->Configure(config);
  }

  return alg_base;
}

void AlgFactory::Print

(

ostream &

stream

)

const

print algorithm factory

Definition at line 183 of file AlgFactory.cxx.

{
  string frame(100,'.');

  stream << endl;
  map<string, Algorithm *>::const_iterator alg_iter;
  for(alg_iter = fAlgPool.begin(); alg_iter != fAlgPool.end(); ++alg_iter) {
    const Algorithm * alg = alg_iter->second;
    stream << frame << endl;
    stream << "Used algorithm: " << alg->Id() << endl;
    stream << "Printing config:";
    stream << alg->GetConfig();
  }

  AlgConfigPool * confp = AlgConfigPool::Instance();
  const Registry & gc = *(confp->GlobalParameterList());

  stream << frame << endl;
  stream << "Printing global parameters list:";
  stream << gc;
}

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 89 of file AlgFactory.h.

ostream& operator<< ( ostream &  stream, const AlgFactory &  algf  )

friend

Definition at line 28 of file AlgFactory.cxx.

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

Member Data Documentation

map<string, Algorithm *> genie::AlgFactory::fAlgPool

private

'algorithm key' (namespace::name/config) -> 'algorithmic object' map

Definition at line 77 of file AlgFactory.h.

AlgFactory * AlgFactory::fInstance = 0

staticprivate

sinleton's self

Definition at line 74 of file AlgFactory.h.

---

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

• Generator/src/Framework/Algorithm/AlgFactory.h
• Generator/src/Framework/Algorithm/AlgFactory.cxx