Gambit::Models::ModelFunctorClaw Class Reference

Models object that performs initialisation and checking operations on a primary_model_functor list. More...

#include <models.hpp>

Collaboration diagram for Gambit::Models::ModelFunctorClaw:

Public Member Functions
	ModelFunctorClaw ()
	Constructor. More...
	~ModelFunctorClaw ()
	Destructor. More...
primodel_vec	getPrimaryModelFunctorsToActivate (std::set< str >, const primodel_vec &)
	Model activation function. More...
void	checkPrimaryModelFunctorUsage (const activemodel_map &) const
	Active model functor "usefulness" checker. More...
void	declare_model (const str &, const str &)
	Add a new model to the model database. More...
void	add_friend (const str &model, const str &newfriend)
	Add a friend, and all its friends and ancestors, to a model's list of friends. More...
bool	model_exists (const str &) const
	Indicate whether a model is recognised by GAMBIT or not. More...
str	list_models () const
	List all the models recognised by GAMBIT. More...
void	verify_model (const str &) const
	Verify that a string matches a model recognised by GAMBIT, crash otherwise. More...
const std::set< str > &	get_allmodels () const
	Return set of all models recognised by GAMBIT. More...
std::set< str >	get_activemodels () const
	Return the set of active models;. More...
std::vector< str >	get_lineage (const str &) const
	Retrieve the lineage for a given model. More...
std::set< str >	get_friends (const str &model) const
	Retrieve the friends for a given model. More...
std::set< str >	get_best_friends (const str &model) const
	Retrieve the best friends for a given model. More...
std::vector< str >	get_descendants (const str &) const
	Retrieve the descendants for a given model. More...
str	get_parent (const str &) const
	Retrieve the parent model for a given model. More...
bool	descended_from (const str &, const str &) const
	Check if model 1 is descended from model 2. More...
bool	ancestor_of (const str &, const str &) const
	Check if model 1 is an ancestor of model 2. More...
bool	downstream_of (const str &, const str &) const
	Check if model 1 exists somewhere downstream of (and can be therefore be interpreted as a) model 2. More...
bool	upstream_of (const str &, const str &) const
	Check if model 1 exists somewhere upstream of model 2, allowing model 2 to be interpreted as model 1. More...

Private Types
typedef bool(*	LineageFunction) (const str, const ModelFunctorClaw *)
	Function pointer type. More...

Private Attributes
std::set< str >	activemodels
	Internal record of the active models. More...
Private lineage/ancestry/friends databases
std::set< str >	allmodelnames
std::map< str, str >	myParentsDB
std::map< str, std::vector< str > >	myLineageDB
std::map< str, std::vector< str > >	myDescendantsDB
std::map< str, LineageFunction >	myIsDescendantOfDB
std::map< str, std::set< str > >	myFriendsDB
std::map< str, std::set< str > >	myBestFriendsDB

Detailed Description

Models object that performs initialisation and checking operations on a primary_model_functor list.

Definition at line 55 of file models.hpp.

Member Typedef Documentation

LineageFunction

typedef bool(* Gambit::Models::ModelFunctorClaw::LineageFunction) (const str, const ModelFunctorClaw *)

private

Function pointer type.

Definition at line 61 of file models.hpp.

Constructor & Destructor Documentation

ModelFunctorClaw()

Gambit::Models::ModelFunctorClaw::ModelFunctorClaw ( )

inline

Constructor.

Definition at line 80 of file models.hpp.

{}

~ModelFunctorClaw()

Gambit::Models::ModelFunctorClaw::~ModelFunctorClaw ( )

inline

Destructor.

Definition at line 82 of file models.hpp.

References add_friend(), ancestor_of(), checkPrimaryModelFunctorUsage(), declare_model(), descended_from(), downstream_of(), get_activemodels(), get_allmodels(), get_best_friends(), get_descendants(), get_friends(), get_lineage(), get_parent(), getPrimaryModelFunctorsToActivate(), list_models(), model_exists(), upstream_of(), and verify_model().

{}

Here is the call graph for this function:

Member Function Documentation

add_friend()

void Gambit::Models::ModelFunctorClaw::add_friend	(	const str &	model,
		const str &	newfriend
	)

Add a friend, and all its friends and ancestors, to a model's list of friends.

Definition at line 189 of file models.cpp.

References Gambit::Models::PARENT::lineage, list_models(), LOCAL_INFO, Gambit::model_error(), model_exists(), myBestFriendsDB, myFriendsDB, and myLineageDB.

Referenced by Gambit::copy_parameters(), and ~ModelFunctorClaw().

    {
      // If the new friend actually doesn't exist yet, die.
      if (not model_exists(newfriend))
      {
        str errmsg = "Requested friend model \""+newfriend + "\" for model \""+model;
        errmsg += "\nis not in the GAMBIT database. Recognised models are:\n" + list_models();
        model_error().raise(LOCAL_INFO,errmsg);
      }
      // Add the new friend as a best friend.
      myBestFriendsDB[model].insert(newfriend);
      // Add the new friend's whole lineage vector as regular friends.
      std::set<str> temp1, temp2, lineage(myLineageDB[newfriend].begin(), myLineageDB[newfriend].end());
      set_union(myFriendsDB[model].begin(), myFriendsDB[model].end(), lineage.begin(), lineage.end(), inserter(temp1, temp1.begin()));
      // Also inherit the new friend's friends as regular friends.
      set_union(temp1.begin(), temp1.end(), myFriendsDB[newfriend].begin(), myFriendsDB[newfriend].end(), inserter(temp2, temp2.begin()));
      myFriendsDB[model] = temp2;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

ancestor_of()

bool Gambit::Models::ModelFunctorClaw::ancestor_of	(	const str &	model1,
		const str &	model2
	)		const

Check if model 1 is an ancestor of model 2.

Definition at line 280 of file models.cpp.

References descended_from().

Referenced by ~ModelFunctorClaw().

    {
      return descended_from(model2, model1);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

checkPrimaryModelFunctorUsage()

void Gambit::Models::ModelFunctorClaw::checkPrimaryModelFunctorUsage

(

const activemodel_map &

activeModelFunctors

)

const

Active model functor "usefulness" checker.

Checks that all the active primary model functors are actually used for something in the dependency tree. If not throws an error to warn the user.

Definition at line 113 of file models.cpp.

References LOCAL_INFO, Gambit::model_error(), and Gambit::functor::status().

Referenced by main(), and ~ModelFunctorClaw().

    {
      std::vector<std::string> unusedmodels;
      std::string modelname;
      primary_model_functor* functorPtr;
      // Loop through functor list and check that their statuses have all been
      // set to 2 ("active"). If not, it means that some of them were not
      // activated by the dependency resolver and thus are not used for
      // computing anything.
      for(activemodel_it it  = activeModelFunctors.begin();
                         it != activeModelFunctors.end(); it++)
      {
        modelname  = it->first;
        functorPtr = it->second;

        if ( functorPtr->status()!=2 )
        {
          unusedmodels.push_back( modelname );
        }
      }

      // If we found unused models throw an error
      if ( unusedmodels.size() > 0 )
      {
        str errmsg = "Some models selected for scanning are not required by any of\n";
        errmsg    += "the requested observables/likelihoods! Please switch these  \n";
        errmsg    += "off in the inifile or add a target that actually uses them. \n";
        errmsg    += "List of unused models:                                      \n";
        for (std::vector<std::string>::iterator it = unusedmodels.begin(); it != unusedmodels.end(); ++it)
        {
          errmsg  += (*it + "\n");
        }
        model_error().raise(LOCAL_INFO,errmsg);
      }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

declare_model()

void Gambit::Models::ModelFunctorClaw::declare_model	(	const str &	model,
		const str &	parent
	)

Add a new model to the model database.

Definition at line 151 of file models.cpp.

References allmodelnames, descended_from(), list_models(), LOCAL_INFO, Gambit::model_error(), model_exists(), myBestFriendsDB, myDescendantsDB, myFriendsDB, myLineageDB, and myParentsDB.

Referenced by Gambit::add_model(), and ~ModelFunctorClaw().

    {
      // Register the new model.
      allmodelnames.insert(model);
      if (parent != "PARENT")
      {
        // If the parent actually doesn't exist yet, die.
        if (not model_exists(parent))
        {
          str errmsg = "Requested parent model \""+parent+ "\" for model \""+model;
          errmsg += "\nis not in the GAMBIT database. Recognised models are:\n" + list_models();
          model_error().raise(LOCAL_INFO,errmsg);
        }
        // Add the parent to the parents database.
        myParentsDB[model] = parent;
        // Inherit friends from the model's parent.
        myFriendsDB[model] = myFriendsDB[parent];
        // Inherit lineage from the model's parent.
        myLineageDB[model] = myLineageDB[parent];
      }
      else
      {
        // Seed empty friend sets and inheritance vector.
        myFriendsDB[model] = std::set<str>();
        myBestFriendsDB[model] = std::set<str>();
        myLineageDB[model] = std::vector<str>();
      }
      // Add the new model to its own lineage vector.
      myLineageDB[model].push_back(model);
      // Register the model in each of its parents' descendents vectors.
      for (std::set<str>::iterator parent = allmodelnames.begin(); parent != allmodelnames.end(); ++parent)
      {
        // If this model descends from parent, add it to the parent's descendents vector
        if (descended_from(model,*parent)) myDescendantsDB[*parent].push_back(model);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

descended_from()

bool Gambit::Models::ModelFunctorClaw::descended_from	(	const str &	model1,
		const str &	model2
	)		const

Check if model 1 is descended from model 2.

Definition at line 268 of file models.cpp.

References Gambit::Models::PARENT::lineage, myLineageDB, and verify_model().

Referenced by ancestor_of(), declare_model(), downstream_of(), and ~ModelFunctorClaw().

    {
      verify_model(model1);
      auto lineage = myLineageDB.at(model1);
      for (std::vector<str>::const_iterator it = lineage.begin(); it != lineage.end(); ++it)
      {
        if (model2==*it) return true;
      }
      return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

downstream_of()

bool Gambit::Models::ModelFunctorClaw::downstream_of	(	const str &	model1,
		const str &	model2
	)		const

Check if model 1 exists somewhere downstream of (and can be therefore be interpreted as a) model 2.

Definition at line 286 of file models.cpp.

References descended_from(), and myFriendsDB.

Referenced by Gambit::functor::allowed_parent_or_friend_exists(), Gambit::functor::contains_anything_interpretable_as_member_of(), Gambit::functor::find_friend_or_parent_model_in_map(), Gambit::functor::in_allowed_combo(), Gambit::module_functor_common::notifyOfModel(), upstream_of(), and ~ModelFunctorClaw().

    {
      if (descended_from(model1, model2)) return true;
      if (myFriendsDB.find(model1) != myFriendsDB.end())
      {
        std::set<str> friends = myFriendsDB.at(model1);
        return friends.find(model2) != friends.end();
      }
      return false;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_activemodels()

std::set< str > Gambit::Models::ModelFunctorClaw::get_activemodels

(

)

const

Return the set of active models;.

Retrieve the internally stored vector of activated models.

Definition at line 106 of file models.cpp.

References activemodels.

Referenced by Gambit::DRes::DependencyResolver::closestCandidateForModel(), Gambit::DRes::DependencyResolver::makeFunctorsModelCompatible(), Gambit::DRes::DependencyResolver::resolveDependency(), Gambit::DRes::DependencyResolver::solveRequirement(), and ~ModelFunctorClaw().

{ return activemodels; }

Here is the caller graph for this function:

get_allmodels()

const std::set< str > & Gambit::Models::ModelFunctorClaw::get_allmodels

(

)

const

Return set of all models recognised by GAMBIT.

Definition at line 103 of file models.cpp.

References allmodelnames.

Referenced by ~ModelFunctorClaw().

{ return allmodelnames; }

Here is the caller graph for this function:

get_best_friends()

std::set< str > Gambit::Models::ModelFunctorClaw::get_best_friends

(

const str &

model

)

const

Retrieve the best friends for a given model.

Definition at line 262 of file models.cpp.

References myBestFriendsDB.

Referenced by Gambit::ModelHierarchy::makeGraph(), and ~ModelFunctorClaw().

    {
      return myBestFriendsDB.find(model) == myBestFriendsDB.end() ? std::set<str>() : myBestFriendsDB.at(model);
    }

Here is the caller graph for this function:

get_descendants()

std::vector< str > Gambit::Models::ModelFunctorClaw::get_descendants

(

const str &

model

)

const

Retrieve the descendants for a given model.

Definition at line 238 of file models.cpp.

References myDescendantsDB.

Referenced by Gambit::gambit_core::check_databases(), and ~ModelFunctorClaw().

    {
      return myDescendantsDB.find(model) == myDescendantsDB.end() ? std::vector<str>() : myDescendantsDB.at(model);
    }

Here is the caller graph for this function:

get_friends()

std::set< str > Gambit::Models::ModelFunctorClaw::get_friends

(

const str &

model

)

const

Retrieve the friends for a given model.

Definition at line 256 of file models.cpp.

References myFriendsDB.

Referenced by ~ModelFunctorClaw().

    {
      return myFriendsDB.find(model) == myFriendsDB.end() ? std::set<str>() : myFriendsDB.at(model);
    }

Here is the caller graph for this function:

get_lineage()

std::vector< str > Gambit::Models::ModelFunctorClaw::get_lineage

(

const str &

model

)

const

Retrieve the lineage for a given model.

Definition at line 250 of file models.cpp.

References myLineageDB.

Referenced by Gambit::gambit_core::check_databases(), and ~ModelFunctorClaw().

    {
      return myLineageDB.find(model) == myLineageDB.end() ? std::vector<str>() : myLineageDB.at(model);
    }

Here is the caller graph for this function:

get_parent()

str Gambit::Models::ModelFunctorClaw::get_parent

(

const str &

model

)

const

Retrieve the parent model for a given model.

Retrieve the parents for a given model.

Definition at line 244 of file models.cpp.

References myParentsDB.

Referenced by Gambit::gambit_core::check_databases(), Gambit::DRes::DependencyResolver::closestCandidateForModel(), Gambit::ModelHierarchy::makeGraph(), Gambit::gambit_core::model_diagnostic(), Gambit::DRes::DependencyResolver::resolveDependency(), Gambit::DRes::DependencyResolver::solveRequirement(), and ~ModelFunctorClaw().

    {
      return myParentsDB.find(model) == myParentsDB.end() ? "none" : myParentsDB.at(model);
    }

Here is the caller graph for this function:

getPrimaryModelFunctorsToActivate()

primodel_vec Gambit::Models::ModelFunctorClaw::getPrimaryModelFunctorsToActivate	(	std::set< str >	selectedmodels,
		const primodel_vec &	primaryModelFunctors
	)

Model activation function.

ModelFunctorClaw function definitions Models object the performs initialisation and checking operations on a primary_model_functor list.

Returns a vector of primary_model_functors to be activated, according to the model(s) being scanned

Model activation function Returns a vector of primary_model_functors to be activated, according to the model(s) being scanned

Definition at line 52 of file models.cpp.

References activemodels, LOCAL_INFO, and Gambit::model_error().

Referenced by ~ModelFunctorClaw().

    {
      // Holder for result
      primodel_vec result;
      // Iterator to elements of 'selectedmodels'
      std::set<str>::iterator el;

      // Loop through functor list and activate functor if it matches a member of 'selectedmodels'.
      for (primodel_vec::const_iterator
          it  = primaryModelFunctors.begin();
          it != primaryModelFunctors.end();
          ++it)
      {
        // Check if this functor originates from one of the selected models
        el = std::find(selectedmodels.begin(), selectedmodels.end(), (*it)->origin());
        if(el != selectedmodels.end())
        {
          // If yes, activate this functor.  Default is inactivated.
          (*it)->setStatus(1);               // 1 means "available".
          (*it)->setPrintRequirement(true);  // Tell printer to output this functor
          // Initialise ModelParameters object it contains
          (*it)->calculate();
          // Add it to the vector of primary model functors to make active (to be returned)
          result.push_back(*it);
          // Add it to the internal list of active models
          activemodels.insert(*el);
          // Remove it from the input 'selectedmodels' list
          selectedmodels.erase(el);
        }
      }

      // Check that all requested models have been activated
      if( selectedmodels.size() != 0 )
      {
        // Report error
        str errmsg = "Error! Some of the requested models could not be activated for \n";
        errmsg    += "scanning! Probably they have not been defined, or you spelled  \n";
        errmsg    += "their name wrong in the ini file.                              \n";
        errmsg    += "Models that cannot be activated:                               \n";
        for (std::set<str>::iterator m = selectedmodels.begin(); m != selectedmodels.end(); ++m)
        {
          errmsg    += ("  " + *m + "\n");
        }
        model_error().raise(LOCAL_INFO,errmsg);
      }

      return result;

    }

Here is the call graph for this function:

Here is the caller graph for this function:

list_models()

str Gambit::Models::ModelFunctorClaw::list_models

(

)

const

List all the models recognised by GAMBIT.

Definition at line 215 of file models.cpp.

References allmodelnames.

Referenced by add_friend(), declare_model(), verify_model(), and ~ModelFunctorClaw().

    {
      str temp = "";
      for (std::set<str>::iterator it = allmodelnames.begin(); it != allmodelnames.end(); ++it)
      {
        temp += "\n" + *it;
      }
      return temp;
    }

Here is the caller graph for this function:

model_exists()

bool Gambit::Models::ModelFunctorClaw::model_exists

(

const str &

model

)

const

Indicate whether a model is recognised by GAMBIT or not.

Definition at line 209 of file models.cpp.

References allmodelnames.

Referenced by add_friend(), Gambit::functor::allowed_parent_or_friend_exists(), Gambit::functor::contains_anything_interpretable_as_member_of(), declare_model(), Gambit::functor::find_friend_or_parent_model_in_map(), Gambit::functor::in_allowed_combo(), Gambit::module_functor_common::module_functor_common(), Gambit::module_functor_common::notifyOfModel(), verify_model(), and ~ModelFunctorClaw().

    {
      return allmodelnames.find(model) != allmodelnames.end();
    }

Here is the caller graph for this function:

upstream_of()

bool Gambit::Models::ModelFunctorClaw::upstream_of	(	const str &	model1,
		const str &	model2
	)		const

Check if model 1 exists somewhere upstream of model 2, allowing model 2 to be interpreted as model 1.

Definition at line 298 of file models.cpp.

References downstream_of().

Referenced by ~ModelFunctorClaw().

    {
      return downstream_of(model2, model1);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

verify_model()

void Gambit::Models::ModelFunctorClaw::verify_model

(

const str &

model

)

const

Verify that a string matches a model recognised by GAMBIT, crash otherwise.

Definition at line 226 of file models.cpp.

References list_models(), LOCAL_INFO, Gambit::model_error(), and model_exists().

Referenced by descended_from(), and ~ModelFunctorClaw().

    {
      if (not model_exists(model))
      {
        str errmsg = "Model \"";
        errmsg += model + "\" is not in the GAMBIT database.";
        errmsg += "\nRecognised models are:" + list_models();
        model_error().raise(LOCAL_INFO,errmsg);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activemodels

std::set<str> Gambit::Models::ModelFunctorClaw::activemodels

private

Internal record of the active models.

Definition at line 64 of file models.hpp.

Referenced by get_activemodels(), and getPrimaryModelFunctorsToActivate().

allmodelnames

std::set<str> Gambit::Models::ModelFunctorClaw::allmodelnames

private

Definition at line 68 of file models.hpp.

Referenced by declare_model(), get_allmodels(), list_models(), and model_exists().

myBestFriendsDB

std::map<str, std::set<str> > Gambit::Models::ModelFunctorClaw::myBestFriendsDB

private

Definition at line 74 of file models.hpp.

Referenced by add_friend(), declare_model(), and get_best_friends().

myDescendantsDB

std::map<str, std::vector<str> > Gambit::Models::ModelFunctorClaw::myDescendantsDB

private

Definition at line 71 of file models.hpp.

Referenced by declare_model(), and get_descendants().

myFriendsDB

std::map<str, std::set<str> > Gambit::Models::ModelFunctorClaw::myFriendsDB

private

Definition at line 73 of file models.hpp.

Referenced by add_friend(), declare_model(), downstream_of(), and get_friends().

myIsDescendantOfDB

std::map<str, LineageFunction > Gambit::Models::ModelFunctorClaw::myIsDescendantOfDB

private

Definition at line 72 of file models.hpp.

myLineageDB

std::map<str, std::vector<str> > Gambit::Models::ModelFunctorClaw::myLineageDB

private

Definition at line 70 of file models.hpp.

Referenced by add_friend(), declare_model(), descended_from(), and get_lineage().

myParentsDB

std::map<str, str> Gambit::Models::ModelFunctorClaw::myParentsDB

private

Definition at line 69 of file models.hpp.

Referenced by declare_model(), and get_parent().

---

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

• Models/include/gambit/Models/models.hpp
• Models/src/models.cpp