Gambit::gambit_core Class Reference

Master driver class for a GAMBIT scan. More...

#include <core.hpp>

Collaboration diagram for Gambit::gambit_core:

Public Member Functions
	gambit_core (const Models::ModelFunctorClaw &, const Backends::backend_info &)
	Constructor. More...
	~gambit_core ()
	Destructor. More...
void	bail (int mpirank=-1)
	Command-line info function. More...
str	process_primary_options (int, char **)
	Process default command line options. More...
str	run_diagnostic (int, char **)
	Diagnostics function. More...
void	registerModule (str)
	Add a new module to modules list. More...
void	registerBackend (str, str)
	Register a new backend. More...
void	registerModuleFunctor (functor &)
	Add a new module functor to functorList. More...
void	registerNestedModuleFunctor (functor &)
	Add a new module functor to nestFunctorList. More...
void	registerBackendFunctor (functor &)
	Add a new backend functor to backendFunctorList. More...
void	registerPrimaryModelFunctor (primary_model_functor &)
	Add a new primary model functor to primaryModelFunctorList. More...
void	registerActiveModelFunctors (const pmfVec &)
	Add entries to the map of activated primary model functors. More...
const std::map< str, std::set< str > >	getBackends () const
	Get a reference to the map of all registered backends. More...
const fVec &	getModuleFunctors () const
	Get a reference to the list of module functors. More...
const fVec &	getNestedModuleFunctors () const
	Get a reference to the list of nested module functors. More...
const fVec &	getBackendFunctors () const
	Get a reference to the list of backend model functors. More...
const pmfVec &	getPrimaryModelFunctors () const
	Get a reference to the list of primary model functors. More...
const pmfMap &	getActiveModelFunctors () const
	Get a reference to the map of all user-activated primary model functors. More...
void	accountForMissingClasses () const
	Tell the module functors which backends are actually present. More...
const capability_info	get_capability_info (const str &) const
	Get the description (and other info) of the named item from the capability database. More...
const model_info	get_model_info (const str &) const
	Get the description (and other info) of the named item from the model database. More...
int	get_outprec () const
	Getter for precision to use for cout. More...
void	check_databases ()
	Check the named database for conflicts and missing descriptions. More...
void	check_capability_descriptions ()
	Check for missing capability descriptions (after reading in runtime flags) More...

Public Attributes
int	show_runorder
	Flags set by command line options Flag to trigger dependency resolver to report functor run order. More...
bool	resume
	Flag to trigger "resume" mode. More...
bool	verbose_flag
	Verbosity mode. More...
bool	found_inifile
	Flag recording whether an inifile has been supplied. More...
bool	developer_mode
	Developer mode (ignore missing capability descriptions) More...
bool	missing_capability_description
	set to true if capability descriptions missing More...
std::vector< capability_info >	capability_dbase
	Vector of all capability_info objects. More...
std::vector< model_info >	model_dbase
	Vector of all model_info objects. More...

Private Types
typedef std::vector< functor * >	fVec
	Internal typedefs to keep things readable. More...
typedef std::vector< primary_model_functor * >	pmfVec
typedef std::map< str, primary_model_functor * >	pmfMap

Private Member Functions
str	backend_status (str, str, bool &)
	Compute the status of a given backend. More...
int	launch_diagnostic_MPI ()
	Launch MPI and return the rank, for limiting diagnostic output to master node. More...
void	quit_diagnostic_MPI ()
	Quit MPI used for diagnostic mode. More...
void	module_diagnostic ()
	Basic diagnostic functions. More...
void	backend_diagnostic ()
	Basic backend diagnostic function. More...
void	capability_diagnostic ()
	Basic capability diagnostic function. More...
void	model_diagnostic ()
	Basic model diagnostic function. More...
void	scanner_diagnostic ()
	Basic scanner diagnostic function. More...
void	test_function_diagnostic ()
	Basic test function diagnostic function. More...
void	prior_diagnostic ()
void	ff_module_diagnostic (str &)
	Free-form diagnostic functions. More...
void	ff_backend_diagnostic (str &)
	Free-form backend diagnostic function. More...
void	ff_capability_diagnostic (str &)
	Free-form capability diagnostic function. More...
void	ff_model_diagnostic (str &)
	Free-form model diagnostic function. More...
void	ff_scanner_diagnostic (str &)
	Free-form scanner diagnostic function. More...
void	ff_test_function_diagnostic (str &)
	Free-form test function diagnostic function. More...
void	ff_prior_diagnostic (str &)

Private Attributes
const Models::ModelFunctorClaw *	modelInfo
	Internal model claw pointer. More...
const Backends::backend_info *	backendData
	Internal backend info pointer. More...
std::set< str >	modules
	Set of all declared modules. More...
std::map< str, std::set< str > >	backend_versions
	Map from backend names to a list of all registered versions of the backend. More...
std::set< str >	capabilities
	List of all declared capabilities. More...
std::set< str >	models
	List of all declared models. More...
fVec	functorList
	List of all declared module functors. More...
fVec	nestedFunctorList
	List of all module functors that are declared as nested (i.e. require loop managers) More...
fVec	backendFunctorList
	List of all declared backend functors. More...
pmfVec	primaryModelFunctorList
	List of all declared primary model functors. More...
pmfMap	activeModelFunctorList
	A map of all user-activated primary model functors. More...
const str	input_capability_descriptions
	Filename of the file from which to harvest capability descriptions. More...
const str	input_model_descriptions
	Filename of the file from which to harvest model descriptions. More...
const int	outprec
	Precision to use for cout. More...
bool	processed_options
	Flag specifying whether command line options have been processed yet. More...

Detailed Description

Master driver class for a GAMBIT scan.

Definition at line 35 of file core.hpp.

Member Typedef Documentation

fVec

typedef std::vector<functor*> Gambit::gambit_core::fVec

private

Internal typedefs to keep things readable.

Definition at line 42 of file core.hpp.

pmfMap

typedef std::map<str, primary_model_functor*> Gambit::gambit_core::pmfMap

private

Definition at line 44 of file core.hpp.

pmfVec

typedef std::vector<primary_model_functor*> Gambit::gambit_core::pmfVec

private

Definition at line 43 of file core.hpp.

Constructor & Destructor Documentation

gambit_core()

Gambit::gambit_core::gambit_core	(	const Models::ModelFunctorClaw &	claw,
		const Backends::backend_info &	beinfo
	)

Constructor.

Definitions of public methods in GAMBIT core class.

Constructor

Definition at line 60 of file core.cpp.

     : modelInfo(&claw)
     , backendData(&beinfo)
     , input_capability_descriptions(GAMBIT_DIR "/config/capabilities.dat")
     , input_model_descriptions(GAMBIT_DIR "/config/models.dat")
     , outprec(8)
     /* command line flags */
     , processed_options(false)
     , show_runorder(false)
     , resume(true)
     , verbose_flag(false)
     , found_inifile(false)
     , developer_mode(false)
    {}

~gambit_core()

Gambit::gambit_core::~gambit_core ( )

inline

Destructor.

Definition at line 128 of file core.hpp.

{}

Member Function Documentation

accountForMissingClasses()

void Gambit::gambit_core::accountForMissingClasses

(

)

const

Tell the module functors which backends are actually present.

Tell the module functors which backends are actually present, so that they can deactivate themselves if they require a class that is supposed to be provided by a backend that is AWOL.

Definition at line 258 of file core.cpp.

References backend_versions, backendData, and functorList.

Referenced by main().

    {
      // Create a map of all the registered backends that are connected and fully functional (including factories for classloading)
      std::map<str, std::set<str> > working_bes;
      // Start by looping over all registered backends
      for (std::map<str, std::set<str> >::const_iterator it = backend_versions.begin(); it != backend_versions.end(); ++it)
      {
        // Then loop over all registered versions of this backend
        for (std::set<str>::const_iterator jt = it->second.begin(); jt != it->second.end(); ++jt)
        {
          const str be_ver = it->first+*jt;
          if (backendData->works.at(be_ver))
          {
            if (backendData->classloader.at(be_ver))
            {
              if (backendData->classes_OK.at(be_ver)) working_bes[it->first].insert(*jt);
            }
            else
            {
              working_bes[it->first].insert(*jt);
            }
          }
        }
      }
      // Feed the new map to each of the module functors.
      for (fVec::const_iterator it = functorList.begin(); it != functorList.end(); ++it)
      {
        (*it)->notifyOfBackends(working_bes);
      }
    }

Here is the caller graph for this function:

backend_diagnostic()

void Gambit::gambit_core::backend_diagnostic ( )

private

Basic backend diagnostic function.

Definition at line 56 of file diagnostics.cpp.

References backend_status(), backend_versions, backendData, backendFunctorList, Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), Gambit::table_formatter::green(), Gambit::table_formatter::padding(), Gambit::print_to_screen(), Gambit::table_formatter::red(), and Gambit::table_formatter::str().

Referenced by run_diagnostic().

  {
    bool all_good = true;
    table_formatter table("Backends", "Version", "Path to lib", "Status ", " #func ", "#types ", "#ctors");
    table.padding(1);
    table.capitalize_title();
    table.default_widths(18, 7, 70, 13, 3, 3);

    // Loop over all registered backends
    for (std::map<str, std::set<str> >::const_iterator it = backend_versions.begin(); it != backend_versions.end(); ++it)
    {
      // Loop over all registered versions of this backend
      for (std::set<str>::const_iterator jt = it->second.begin(); jt != it->second.end(); ++jt)
      {
        int nfuncs = 0;
        int ntypes = 0;
        int nctors = 0;

        // Retrieve the status and path info.
        const str path = backendData->path(it->first,*jt);                              // Get the path of this backend
        const str status = backend_status(it->first, *jt, all_good);                    // Save the status of this backend

        // Count up the number of functions in this version of the backend, using the registered functors.
        for (fVec::const_iterator kt = backendFunctorList.begin(); kt != backendFunctorList.end(); ++kt)
        {
          if ((*kt)->origin() == it->first and (*kt)->version() == *jt) nfuncs++; // If backend matches, increment the count of the functions in this version
        }

        // Do things specific to versions that provide classes
        if (backendData->classloader.at(it->first+*jt))
        {
          std::set<str> classes = backendData->classes.at(it->first+*jt);     // Retrieve classes loaded by this version
          ntypes = classes.size();                                            // Get the number of classes loaded by this backend
          for (std::set<str>::const_iterator kt = classes.begin(); kt != classes.end(); ++kt)
          {
            nctors += backendData->factory_args.at(it->first+*jt+*kt).size(); // Add the number of factories for this class to the total
          }
        }

        // Print the info
        std::ostringstream ss1, ss2;
        str ss1a, ss2a;
        const str firstentry = (jt == it->second.begin() ? it->first : "");
        ss1 << nfuncs;
        ss2 << ntypes;
        table << firstentry << *jt << path;
        if (status == "OK")
            table.green() << status;
        else
            table.red() << status;
        table << " " + ss1.str() << ss2.str() << nctors;
      }
    }

    std::stringstream out;
    out << "All relative paths are given with reference to " << GAMBIT_DIR << ".";
    if (all_good) out << endl << endl << "\033[032m" << "All your backend are belong to us." << "\033[0m" << endl;
    out << endl;
    out << table.str();
    if (out.str().size() > 0)
        print_to_screen(out.str(), "backend");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

backend_status()

str Gambit::gambit_core::backend_status ( str  be, str  version, bool &  no_failures  )

private

Compute the status of a given backend.

Definition at line 553 of file core.cpp.

References backendData.

Referenced by backend_diagnostic(), and ff_backend_diagnostic().

    {
      const str OK = "OK";
      const str bad = "absent/broken";
      const str badclass = "bad types";
      const str missingMath = "Mathematica absent";
      str status;
      if (backendData->works.at(be+version))
      {
        if (backendData->classloader.at(be+version))
        {
          status = (backendData->classes_OK.at(be+version) ? OK : badclass);
        }
        else { status = OK; }
      }
      else if (backendData->needsMathematica.at(be+version))
      {
        #ifdef HAVE_MATHEMATICA
          status = bad;
        #else
          status = missingMath;
        #endif
      }
      else if (backendData->missingPythonVersion.at(be+version) > 0)
      {
        std::ostringstream status_stream;
        status_stream << "needs Python " << backendData->missingPythonVersion.at(be+version);
        status = status_stream.str();
      }
      else { status = bad; }
      if (status == bad or status == badclass) no_failures = false;
      return status;
    }

Here is the caller graph for this function:

bail()

void Gambit::gambit_core::bail

(

int

mpirank = -1

)

Command-line info function.

Inform the user of the ways to invoke GAMBIT, then die.

Definition at line 79 of file core.cpp.

References Gambit::Logging::LogMaster::disable(), GET_RANK, and Gambit::logger().

Referenced by process_primary_options(), and run_diagnostic().

    {
      if (mpirank < 0) mpirank = GET_RANK;
      if (mpirank == 0)
      {
        cout << "\nusage: gambit [options] [<command>]                                        "
                "\n                                                                           "
                "\nRun scan:                                                                  "
                "\n   gambit -f <inifile>   Start a scan using instructions from inifile      "
                "\n                           e.g.: gambit -f gambit.yaml                     "
                "\n                                                                           "
                "\nAvailable commands:                                                        "
                "\n   modules               List registered modules                           "
                "\n   backends              List registered backends and their status         "
                "\n   models                List registered models and output model graph     "
                "\n   capabilities          List all registered function capabilities         "
                "\n   scanners              List registered scanners                          "
                "\n   test-functions        List registered scanner test objective functions  "
                "\n   <name>                Give info on a specific module, backend, model,   "
                "\n                           capability or scanner                           "
                "\n                           e.g.: gambit DarkBit                            "
                "\n                                 gambit Pythia                             "
                "\n                                 gambit MSSM                               "
                "\n                                 gambit IC79WL_loglike                     "
                "\n                                 gambit MultiNest                          "
                "\n                                                                           "
                "\nBasic options:                                                             "
                "\n   --version             Display GAMBIT version information                "
                "\n   --developer           Run in developer mode (suppress database errors)  "
                "\n   -h/--help             Display this usage information                    "
                "\n   -f <inifile>          Start scan using <inifile>                        "
                "\n   -v/--verbose          Turn on verbose mode                              "
                "\n   -d/--dryrun           List the function evaluation order computed based "
                "\n                           on inifile                                      "
                "\n   -r/--restart          Restart the scan defined by <inifile>. Existing   "
                "\n                         output files for the run will be overwritten.     "
                "\n                         Default behaviour in the absence of this option is"
                "\n                         to attempt to resume the scan from any existing   "
                "\n                         output.                                           "
                "\n" << endl << endl;
      }
      logger().disable();
      throw SilentShutdownException();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

capability_diagnostic()

void Gambit::gambit_core::capability_diagnostic ( )

private

Basic capability diagnostic function.

Definition at line 150 of file diagnostics.cpp.

References backendFunctorList, capabilities, Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), functorList, Gambit::table_formatter::padding(), Gambit::print_to_screen(), and Gambit::table_formatter::str().

Referenced by run_diagnostic().

  {

    // Default, list-format output header
    table_formatter table("Capabilities", "Available in (modules/models)", "Available in (backends)");
    table.padding(1);
    table.capitalize_title();
    table.default_widths(35, 25);
    for (std::set<str>::const_iterator it = capabilities.begin(); it != capabilities.end(); ++it)
    {
      std::set<str> modset, beset;
      str mods, bes, description;

      // Make sets of matching modules and backends
      for (fVec::const_iterator jt = functorList.begin(); jt != functorList.end(); ++jt)
      {
        if ((*jt)->capability() == *it) modset.insert((*jt)->origin());
      }
      for (fVec::const_iterator jt = backendFunctorList.begin(); jt != backendFunctorList.end(); ++jt)
      {
        if ((*jt)->capability() == *it) beset.insert((*jt)->origin());
      }

      // Make strings out of the sets
      for (std::set<str>::const_iterator jt = modset.begin(); jt != modset.end(); ++jt)
      {
        if (jt != modset.begin()) mods += ", ";
        mods += *jt;
      }
      for (std::set<str>::const_iterator jt = beset.begin(); jt != beset.end(); ++jt)
      {
        if (jt != beset.begin()) bes += ", ";
        bes += *jt;
      }

      // Identify the primary model parameters with their models.
      if (mods.length() == 0 and bes.length() == 0) mods = it->substr(0,it->length()-11);

      // Print the entry in the table (list format)
      table << *it << mods << bes;
    }
    std::stringstream out;
    out << table.str();
    if (out.str().size() > 0)
        print_to_screen(out.str(), "capability");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

check_capability_descriptions()

void Gambit::gambit_core::check_capability_descriptions

(

)

Check for missing capability descriptions (after reading in runtime flags)

Definition at line 495 of file core.cpp.

References capability_dbase, input_capability_descriptions, and missing_capability_description.

Referenced by run_diagnostic().

    {

      if (missing_capability_description)
      {
        cout << "Descriptions are missing for the following capabilities:" << endl;
        for (std::vector<capability_info>::const_iterator it = capability_dbase.begin(); it != capability_dbase.end(); ++it)
        {
          if(not it->has_description)
          {
            cout << "   " << it->name << endl;
          }
        }
        cout << "Please add descriptions of these to "<< input_capability_descriptions << endl;
      }
    }

Here is the caller graph for this function:

check_databases()

void Gambit::gambit_core::check_databases

(

)

Check the named database for conflicts and missing descriptions.

Check the capability and model databases for conflicts and missing descriptions.

Definition at line 292 of file core.cpp.

References backendFunctorList, Gambit::capability_info::beset, capabilities, capability_dbase, Gambit::DescriptionDatabase::check_for_duplicates(), Gambit::core_error(), Gambit::model_info::descendants, Gambit::capability_info::description, Gambit::model_info::description, functorList, Gambit::DescriptionDatabase::get_all_values(), Gambit::Models::ModelFunctorClaw::get_descendants(), Gambit::Models::ModelFunctorClaw::get_lineage(), Gambit::Models::ModelFunctorClaw::get_parent(), Gambit::DescriptionDatabase::getValue(), Gambit::capability_info::has_description, Gambit::model_info::has_description, Gambit::DescriptionDatabase::hasKey(), input_capability_descriptions, input_model_descriptions, Gambit::model_info::lineage, LOCAL_INFO, missing_capability_description, model_dbase, modelInfo, Gambit::capability_info::modset, Gambit::capability_info::name, Gambit::model_info::name, Gambit::model_info::nparams, Gambit::model_info::parameters, Gambit::model_info::parent, primaryModelFunctorList, and Gambit::Utils::runtime_scratch().

Referenced by run_diagnostic().

    {
      // Loop through registered capabilities and try to find their descriptions (potentially from many files, but for now just checking one)
      DescriptionDatabase description_file(input_capability_descriptions); // Load descriptions file
      //std::set<str> parsed_descriptions; // Set of capabilities whose description we have parsed
      bool missing_flag = false; // Lets us know if any missing descriptions identified

      // Check for duplicate description keys
      std::map<str,int> duplicates = description_file.check_for_duplicates();

      // Search through GAMBIT for information about registered capabilities to match to the descriptions
      for (std::set<str>::const_iterator it = capabilities.begin(); it != capabilities.end(); ++it)
      {
        capability_info capinfo;
        capinfo.name = *it;

        // Make sets of matching module and backend functions
        for (fVec::const_iterator jt = functorList.begin(); jt != functorList.end(); ++jt)
        {
          if ((*jt)->capability() == *it)
          {
            str origin((*jt)->origin());
            std::pair<str,str> name_type((*jt)->name(), (*jt)->type());
            if (capinfo.modset.find(origin) == capinfo.modset.end()) capinfo.modset[origin] = std::set<std::pair<str,str> >();
            capinfo.modset[origin].insert(name_type);
          }
        }
        for (fVec::const_iterator jt = backendFunctorList.begin(); jt != backendFunctorList.end(); ++jt)
        {
          if ((*jt)->capability() == *it)
          {
            str origin((*jt)->origin() + " v" + (*jt)->version());
            std::pair<str,str> name_type((*jt)->name(), (*jt)->type());
            if (capinfo.beset.find(origin) == capinfo.beset.end()) capinfo.beset[origin] = std::set<std::pair<str,str> >();
            capinfo.beset[origin].insert(name_type);
          }
        }

        // Check original description files for descriptions matching this capability
        if( description_file.hasKey(*it) )
        {
          // Check whether there are duplicates of this key
          if ( duplicates[*it] > 0 )
          {
            std::vector<str> dups = description_file.get_all_values(*it);
            std::ostringstream errmsg;
            errmsg << "Error! Duplicate capability descriptions found for capability \""<<*it<<
             "\"! Only one description is permitted, since all capabilities going by the same name "
             "must provide the same information. Please rename a capability or delete one of the descriptions."<<endl;
            errmsg << "The duplicate descriptions are:" <<endl;
            errmsg << "---------------------" <<endl;
            int dup_num = 0;
            for(std::vector<str>::iterator kt = dups.begin(); kt != dups.end(); ++kt)
            {
              errmsg << dup_num << ":" <<endl;
              errmsg << *kt;
              errmsg << "----------------------" <<endl;
              dup_num++;
            }
            core_error().raise(LOCAL_INFO,errmsg.str());
          }
          else
          {
            capinfo.description = description_file.getValue<str>(*it);
            capinfo.has_description = true;
          }
        }
        else
        {
          // Record that this description is missing
          capinfo.description = "Missing!";
          capinfo.has_description = false;
          missing_flag = true;
        }
        capability_dbase.push_back(capinfo);
      }

      missing_capability_description = false;

      if(missing_flag)
      {
        // Warn user of missing descriptions
        missing_capability_description = true;
      }

      // Write out the centralised database file containing all this information
      // (we could also keep this in memory for other functions to use; it's probably not that large)
      // Should probably sort it by module or something.

      // Could have built this directly in the other loop, but for now it is separate.
      YAML::Emitter out;
      out << YAML::BeginSeq;
      for (std::vector<capability_info>::iterator it = capability_dbase.begin(); it != capability_dbase.end(); ++it)
      {
        //capability_info tmp = *it;
        out << *it; //custom emitter to do this is in yaml_description_database.hpp
      }
      out << YAML::EndSeq;
      // Create file and write YAML output there
      std::ofstream outfile;
      outfile.open(Utils::runtime_scratch()+"central_capabilities.dat");
      outfile << "# Auto-generated capability description library. Edits will be erased." << endl;;
      outfile << "# Edit \"" << input_capability_descriptions << "\" instead." << endl << endl << out.c_str();


      // Now the models
      // This is distressingly similar to the capabilities case, but it doesn't seem so straightforward to modularise any further...

      // Loop through registered models and try to find their descriptions (potentially from many files, but for now just checking one)
      DescriptionDatabase model_description_file(input_model_descriptions); // Load descriptions file
      missing_flag = false; // reset this flag

      // Check for duplicate description keys
      duplicates = description_file.check_for_duplicates();

      // Search through GAMBIT for information about registered models to match to the descriptions
      for (pmfVec::const_iterator it = primaryModelFunctorList.begin(); it != primaryModelFunctorList.end(); ++it)
      {
        model_info model;
        model.name = (*it)->origin();

        // Check original description files for descriptions matching this capability
        if( model_description_file.hasKey(model.name) )
        {
          // Check whether there are duplicates of this key
          if (duplicates[model.name] > 0)
          {
            std::vector<str> dups = model_description_file.get_all_values(model.name);
            std::ostringstream errmsg;
            errmsg << "Error! Duplicate model descriptions found for model \""<<model.name<<
             "\"! Only one description is permitted, since model names must be unique. "
             "Please rename a model or delete one of the descriptions."<<endl;
            errmsg << "The duplicate descriptions are:" <<endl;
            errmsg << "---------------------" <<endl;
            int dup_num = 0;
            for(std::vector<str>::iterator kt = dups.begin(); kt != dups.end(); ++kt)
            {
              errmsg << dup_num << ":" <<endl;
              errmsg << *kt;
              errmsg << "----------------------" <<endl;
              dup_num++;
            }
            core_error().raise(LOCAL_INFO,errmsg.str());
          }
          else
          {
            model.description = model_description_file.getValue<str>(model.name);
            model.has_description = true;
          }
        }
        else
        {
          // Record that this description is missing
          model.description = "Missing!";
          model.has_description = false;
          missing_flag = true;
        }

        // Get the rest of the info
        model.nparams = (*it)->valuePtr()->getNumberOfPars();
        model.parameters = (*it)->valuePtr()->getKeys();
        model.parent = modelInfo->get_parent(model.name);
        model.lineage = modelInfo->get_lineage(model.name);
        model.descendants = modelInfo->get_descendants(model.name);

        model_dbase.push_back(model);
      }

      if(missing_flag)
      {
        // Warn user of missing descriptions
        cout << "Descriptions are missing for the following models:" << endl;
        for (std::vector<model_info>::const_iterator it = model_dbase.begin(); it != model_dbase.end(); ++it)
        {
          if(not it->has_description)
          {
            cout << "   " << it->name << endl;
          }
        }
        cout << "Please add descriptions of these to "<< input_model_descriptions << endl;
      }

      // Write out the centralised database file containing all this information
      // (we could also keep this in memory for other functions to use; it's probably not that large)
      // Should probably sort it by module or something.

      // Could have built this directly in the other loop, but for now it is separate.
      YAML::Emitter out2;
      out2 << YAML::BeginSeq;
      for (std::vector<model_info>::const_iterator it = model_dbase.begin(); it != model_dbase.end(); ++it)
      {
        out2 << *it; //custom emitter to do this is in yaml_description_database.hpp
      }
      out2 << YAML::EndSeq;
      // Create file and write YAML output there
      std::ofstream outfile2;
      outfile2.open(Utils::runtime_scratch()+"central_models.dat");
      outfile2 << "# Auto-generated model description library. Edits will be erased." << endl;;
      outfile2 << "# Edit \"" << input_model_descriptions << "\" instead." << endl << endl << out2.c_str();

    }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_backend_diagnostic()

void Gambit::gambit_core::ff_backend_diagnostic ( str &  command )

private

Free-form backend diagnostic function.

Definition at line 292 of file diagnostics.cpp.

References backend_status(), backend_versions, backendData, backendFunctorList, Gambit::table_formatter::bottom_line(), Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), combine_hdf5::f, Gambit::table_formatter::green(), Gambit::table_formatter::padding(), Gambit::print_to_screen(), Gambit::table_formatter::red(), Gambit::table_formatter::rows(), Gambit::table_formatter::str(), and Gambit::table_formatter::top_line().

Referenced by run_diagnostic().

  {
    std::stringstream out;
    //Iterate over all backends to see if command matches one of them
    for (std::map<str, std::set<str> >::const_iterator it = backend_versions.begin(); it != backend_versions.end(); ++it)
    {
      if (command == it->first)
      {
        const std::set<str> versions = it->second;
        bool has_classloader = false;
        out << "Information for backend " << it->first << "." << std::endl << std::endl;

        // Loop over all registered versions of this backend
        for (std::set<str>::const_iterator jt = versions.begin(); jt != versions.end(); ++jt)
        {
          bool who_cares;
          const str path = backendData->corrected_path(it->first,*jt);  // Save the path of this backend
          const str status = backend_status(it->first, *jt, who_cares); // Save the status of this backend
          out << "Version: " << *jt << std::endl;
          out << "Path to library: " << path << std::endl;
          out << "Library status: " << status << std::endl;
          //bool first = true;

          table_formatter back_table("  Function/Variable", "Capability", "Type", "Status");
          back_table.capitalize_title();
          back_table.default_widths(27, 35, 40, 40);
          back_table.padding(1);
          back_table.top_line(true);
          back_table.bottom_line(true);
          // Loop over all the backend functions and variables
          for (fVec::const_iterator kt = backendFunctorList.begin(); kt != backendFunctorList.end(); ++kt)
          {
            if (((*kt)->origin() == it->first) and ((*kt)->version() == (*jt)))
            {
              const str f = (*kt)->name();
              const str c = (*kt)->capability();
              const str t = (*kt)->type();
              const int s = (*kt)->status();
              back_table << ("  " + f) << c << t;
              if(s == -5) back_table.red() << "Mathematica absent";
              else if (s == -2) back_table.red() << "Function absent";//ss = "Function absent";
              else if (s == -1) back_table.red() << "Backend absent";//ss = "Backend absent";
              else if (s >= 0)  back_table.green() << "Available";//ss = "Available";
              else back_table << "";
            }
          }
          if (back_table.rows() > 0)
            out << back_table.str();
          table_formatter class_table("  Class", "Constructor overload", "Status");
          class_table.capitalize_title();
          class_table.default_widths(46, 60, 60);
          class_table.padding(1);
          class_table.top_line(true);
          class_table.bottom_line(true);
          // If this version has classes to offer, print out info on them too
          if (backendData->classloader.at(it->first+*jt))
          {
            std::set<str> classes;
            if (backendData->classes.find(it->first+*jt) != backendData->classes.end()) classes = backendData->classes.at(it->first+*jt);
            has_classloader = true;
            // Loop over the classes
            for (std::set<str>::const_iterator kt = classes.begin(); kt != classes.end(); ++kt)
            {
              const std::set<str> ctors = backendData->factory_args.at(it->first+*jt+*kt);
              // Loop over the constructors in each class
              for (std::set<str>::const_iterator lt = ctors.begin(); lt != ctors.end(); ++lt)
              {
                str args = *lt;
                boost::replace_all(args, "my_ns::", "");
                const str ss = backendData->constructor_status.at(it->first+*jt+*kt+args);
                const str firstentry = (lt == ctors.begin() ? *kt : "");
                class_table << ("  " + firstentry) << args;
                if (ss == "OK")
                    class_table.green() << status;
                else
                    class_table.red() << status;
              }
            }
          }
          if (class_table.rows() > 0)
              out << class_table.str();
        }
        // Tell the user what the default version is for classes of this backend (if there are any).
        if (has_classloader)
        {
          const std::map<str, str> defs = backendData->default_safe_versions;
          const str my_def = (defs.find(it->first) != defs.end() ? backendData->version_from_safe_version(it->first,defs.at(it->first)) : "none");
          out << std::endl << "Default version for loaded classes: "  << my_def << std::endl << std::endl;
        }
        break;
      }
    }
    if (out.str().size() > 0)
        print_to_screen(out.str(), command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_capability_diagnostic()

void Gambit::gambit_core::ff_capability_diagnostic ( str &  command )

private

Free-form capability diagnostic function.

Definition at line 426 of file diagnostics.cpp.

References Gambit::capability_info::beset, capabilities, Gambit::capability_info::description, get_capability_info(), Gambit::capability_info::modset, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::stringstream out;
    //Iterate over all capabilities to see if command matches one of them
    for (std::set<str>::const_iterator it = capabilities.begin(); it != capabilities.end(); ++it)
    {
      if (command == *it)
      {
        out << "Information for capability " << *it << "." << std::endl << std::endl;

        // Retrieve info on this capability from the database file
        const capability_info cap = get_capability_info(*it);
        std::vector< std::pair<str, std::map<str, std::set<std::pair<str,str> > > > > origins;
        origins.push_back(std::pair<str, std::map<str, std::set<std::pair<str,str> > > >("modules", cap.modset));
        origins.push_back(std::pair<str, std::map<str, std::set<std::pair<str,str> > > >("backends", cap.beset));
        // Loop over {modules, backends}
        for (std::vector< std::pair<str, std::map<str, std::set<std::pair<str,str> > > > >::const_iterator it = origins.begin(); it != origins.end(); ++it)
        {
          if (not it->second.empty())
          {
            out << "  Available in " << it->first << ": " << std::endl;
            // Loop over modules or backends
            for (std::map<str, std::set<std::pair<str,str> > >::const_iterator jt = it->second.begin(); jt != it->second.end(); ++jt)
            {
              out << "    " << jt->first << ": " << std::endl;
              // Loop over matching module/backend functions
              for (std::set<std::pair<str,str> >::const_iterator kt = jt->second.begin(); kt != jt->second.end(); ++kt)
              {
                // Spit out: function name [function type]
                out << "      function " << kt->first << " [type " << kt->second << "]" << std::endl;
              }
            }
            out << std::endl;
          }
        }
        out << "  Description: " << std::endl << cap.description << std::endl;
        break;
      }
    }
    if (out.str().size() > 0)
        print_to_screen(out.str(), command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_model_diagnostic()

void Gambit::gambit_core::ff_model_diagnostic ( str &  command )

private

Free-form model diagnostic function.

Definition at line 389 of file diagnostics.cpp.

References Gambit::model_info::descendants, Gambit::model_info::description, get_model_info(), Gambit::model_info::lineage, Gambit::model_info::name, Gambit::model_info::nparams, Gambit::model_info::parameters, Gambit::model_info::parent, primaryModelFunctorList, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::stringstream out;
    //Iterate over all models to see if command matches one of them
    for (pmfVec::const_iterator it = primaryModelFunctorList.begin(); it != primaryModelFunctorList.end(); ++it)
    {
      str model = (*it)->origin();
      if (command == model)
      {
        out << "Information for model " << model << "." << endl << endl;;

        // Retrieve info on this capability from the database file
        model_info mod = get_model_info(model);

        // Need copies of lineage and descendant vectors with self-reference removed
        std::vector<str> lin_X = mod.lineage;
        std::vector<str> des_X = mod.descendants;

        // Erase element matching name
        lin_X.erase(std::remove(lin_X.begin(), lin_X.end(), mod.name), lin_X.end());
        des_X.erase(std::remove(des_X.begin(), des_X.end(), mod.name), des_X.end());

        out << "  Parent Model: " << mod.parent << std::endl;
        out << "  Number of parameters: " << mod.nparams << std::endl;
        out << "  Parameter names:" << mod.parameters << std::endl;
        out << "  'Ancestor' models:" << lin_X << std::endl;
        out << "  'Descendant' models:" << des_X << std::endl;
        out << "  Description: " << endl << mod.description << std::endl;

        break;
      }
    }
    if (out.str().size() > 0)
        print_to_screen(out.str(), command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_module_diagnostic()

void Gambit::gambit_core::ff_module_diagnostic ( str &  command )

private

Free-form diagnostic functions.

Free-form module diagnostic function.

Definition at line 232 of file diagnostics.cpp.

References Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), combine_hdf5::f, functorList, modules, Gambit::table_formatter::new_titles(), Gambit::table_formatter::newline(), Gambit::table_formatter::no_newline(), Gambit::table_formatter::padding(), Gambit::print_to_screen(), Gambit::table_formatter::row_pos(), and Gambit::table_formatter::str().

Referenced by run_diagnostic().

  {
    std::stringstream out; //added this!  not 'cout' but 'out'
    for (std::set<str>::const_iterator it = modules.begin(); it != modules.end(); ++it)
    {
      if (command == *it)
      {
        out << "Information for module " << *it << "." << std::endl << std::endl;
        table_formatter table("", "", "", "LOOP MANAGER:", "DEPENDENCIES / BACKEND REQUIREMENTS");
        table.new_titles("Function", "Capability", "Result Type", " IS  NEEDS", "[type]         {type}");
        table.padding(1);
        table.capitalize_title();
        table.default_widths(30, 35, 35, 19, 27);

        for (fVec::const_iterator jt = functorList.begin(); jt != functorList.end(); ++jt)
        {
          if ((*jt)->origin() == *it)              // Module matches
          {
            str f = (*jt)->name();
            str c = (*jt)->capability();
            str t = (*jt)->type();
            str islm = (*jt)->canBeLoopManager() ? "Yes" : "No ";
            str nlm  = (*jt)->loopManagerCapability();
            std::set<sspair> deps = (*jt)->dependencies();
            std::set<sspair> reqs = (*jt)->backendreqs();
            table.no_newline() << f << c << t << (" " + islm + " " + nlm);

            if (not deps.empty())
            {
              for (std::set<sspair>::const_iterator kt = deps.begin(); kt != deps.end(); ++kt)
              {
                if (kt != deps.begin())
                    table.no_newline() << "" << "" << "" << "" << kt->first + " [" + kt->second + "]";
                else
                    table << kt->first + " [" + kt->second + "]";
              }
            }
            if (not reqs.empty())
            {
              for (std::set<sspair>::const_iterator kt = reqs.begin(); kt != reqs.end(); ++kt)
              {
                if (kt != reqs.begin() or not deps.empty())
                    table.no_newline() << "" << "" << "" << "" << kt->first + " {" + kt->second + "}";
                else
                    table << kt->first + " {" + kt->second + "}";
              }
            }
            if (reqs.empty() and deps.empty()) table << "";
            table.newline(table.row_pos()-1);
          }
        }
        out << table.str();
        break;
      }
    }
    if (out.str().size() > 0)
        print_to_screen(out.str(), command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_prior_diagnostic()

void Gambit::gambit_core::ff_prior_diagnostic ( str &  command )

private

Definition at line 221 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    if (command != "priors")
    {
        std::string output = Scanner::Plugins::plugin_info().print_priors(command);
        if (output.length() > 0)
            print_to_screen(output, command);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_scanner_diagnostic()

void Gambit::gambit_core::ff_scanner_diagnostic ( str &  command )

private

Free-form scanner diagnostic function.

Definition at line 470 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::string output = Scanner::Plugins::plugin_info().print_plugin("scanner", command);
    if (output.length() > 0)
        print_to_screen(output, command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ff_test_function_diagnostic()

void Gambit::gambit_core::ff_test_function_diagnostic ( str &  command )

private

Free-form test function diagnostic function.

Definition at line 478 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::string output = Scanner::Plugins::plugin_info().print_plugin("objective", command);
    if (output.length() > 0)
        print_to_screen(output, command);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_capability_info()

const capability_info Gambit::gambit_core::get_capability_info

(

const str &

name

)

const

Get the description (and other info) of the named item from the capability database.

Get the description of the named capability from the description database.

Definition at line 513 of file core.cpp.

References capability_dbase, Gambit::core_error(), and LOCAL_INFO.

Referenced by ff_capability_diagnostic().

    {

      for(std::vector<capability_info>::const_iterator it=capability_dbase.begin();
           it!=capability_dbase.end();++it)
      {
         if(it->name==name)
         {
           return *it; //Should only be one match possible after database check
         }
      }
      // if no match...
      std::ostringstream errmsg;
      errmsg << "No capability with the name \""<<name<< "\" could be found in the capability database. "
       "This function should not run when we don't know if the capability exists! Either there is a bug "
       "in the calling code, or something went wrong creating the capability database.";
      core_error().raise(LOCAL_INFO,errmsg.str());
      return capability_info();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_model_info()

const model_info Gambit::gambit_core::get_model_info

(

const str &

name

)

const

Get the description (and other info) of the named item from the model database.

Definition at line 533 of file core.cpp.

References Gambit::core_error(), LOCAL_INFO, and model_dbase.

Referenced by ff_model_diagnostic().

    {
      for(std::vector<model_info>::const_iterator it=model_dbase.begin();
           it!=model_dbase.end();++it)
      {
         if(it->name==name)
         {
           return *it; //Should only be one match possible after database check
         }
      }
      // if no match...
      std::ostringstream errmsg;
      errmsg << "No model with the name \""<<name<< "\" could be found in the model database. This function "
       "should not run when we don't know if the model exists! Either there is a bug in the calling code, or "
       "something went wrong creating the model database.";
      core_error().raise(LOCAL_INFO,errmsg.str());
      return model_info();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

get_outprec()

int Gambit::gambit_core::get_outprec

(

)

const

Getter for precision to use for cout.

Definition at line 76 of file core.cpp.

References outprec.

Referenced by Gambit::DRes::DependencyResolver::calcObsLike().

{ return outprec; }

Here is the caller graph for this function:

getActiveModelFunctors()

const gambit_core::pmfMap & Gambit::gambit_core::getActiveModelFunctors

(

)

const

Get a reference to the map of all user-activated primary model functors.

Definition at line 253 of file core.cpp.

References activeModelFunctorList.

Referenced by Gambit::Likelihood_Container_Factory::Likelihood_Container_Factory().

{ return activeModelFunctorList; }

Here is the caller graph for this function:

getBackendFunctors()

const gambit_core::fVec & Gambit::gambit_core::getBackendFunctors

(

)

const

Get a reference to the list of backend model functors.

Get a reference to the list of backend functors.

Definition at line 247 of file core.cpp.

References backendFunctorList.

Referenced by main(), Gambit::DRes::DependencyResolver::makeFunctorsModelCompatible(), Gambit::DRes::DependencyResolver::printFunctorList(), and Gambit::DRes::DependencyResolver::solveRequirement().

{ return backendFunctorList; }

Here is the caller graph for this function:

getBackends()

const std::map<str, std::set<str> > Gambit::gambit_core::getBackends

(

)

const

Get a reference to the map of all registered backends.

getModuleFunctors()

const gambit_core::fVec & Gambit::gambit_core::getModuleFunctors

(

)

const

Get a reference to the list of module functors.

Definition at line 241 of file core.cpp.

References functorList.

Referenced by Gambit::DRes::DependencyResolver::addFunctors(), and main().

{ return functorList; }

Here is the caller graph for this function:

getNestedModuleFunctors()

const gambit_core::fVec & Gambit::gambit_core::getNestedModuleFunctors

(

)

const

Get a reference to the list of nested module functors.

Definition at line 244 of file core.cpp.

References nestedFunctorList.

{ return nestedFunctorList; }

getPrimaryModelFunctors()

const gambit_core::pmfVec & Gambit::gambit_core::getPrimaryModelFunctors

(

)

const

Get a reference to the list of primary model functors.

Definition at line 250 of file core.cpp.

References primaryModelFunctorList.

Referenced by Gambit::DRes::DependencyResolver::addFunctors().

{ return primaryModelFunctorList; }

Here is the caller graph for this function:

launch_diagnostic_MPI()

int Gambit::gambit_core::launch_diagnostic_MPI ( )

private

Launch MPI and return the rank, for limiting diagnostic output to master node.

model_diagnostic()

void Gambit::gambit_core::model_diagnostic ( )

private

Basic model diagnostic function.

Definition at line 120 of file diagnostics.cpp.

References Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), Gambit::Models::ModelFunctorClaw::get_parent(), modelInfo, Gambit::table_formatter::padding(), primaryModelFunctorList, Gambit::print_to_screen(), Gambit::Utils::runtime_scratch(), and Gambit::table_formatter::str().

Referenced by run_diagnostic().

  {
    std::stringstream out;
    table_formatter table("Model", "Parent", "Parameters");
    table.default_widths(35);
    table.padding(1);
    table.capitalize_title();
    for (pmfVec::const_iterator it = primaryModelFunctorList.begin(); it != primaryModelFunctorList.end(); ++it)
    {
      str model = (*it)->origin();
      str parentof = modelInfo->get_parent(model);
      int nparams = (*it)->valuePtr()->getNumberOfPars();
      table << model << parentof << nparams;
    }
    #ifdef HAVE_GRAPHVIZ
        // Create and spit out graph of the model hierarchy.
        str graphfile = Utils::runtime_scratch() + "GAMBIT_model_hierarchy.gv";
        ModelHierarchy modelGraph(*modelInfo,primaryModelFunctorList,graphfile,false);
        out << endl << "Created graphviz model hierarchy graph in "+graphfile+"." << endl;
        out << endl << "To get postscript plot of model hierarchy, please run: " << endl;
        out << GAMBIT_DIR << "/Core/scripts/./graphviz.sh "+graphfile << endl;
    #else
        out << endl << "To get postscript plot of model hierarchy, please install graphviz, rerun cmake and remake GAMBIT." << endl;
    #endif
      out << table.str();
    if (out.str().size() > 0)
    print_to_screen(out.str(), "model");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

module_diagnostic()

void Gambit::gambit_core::module_diagnostic ( )

private

Basic diagnostic functions.

Basic module diagnostic function.

Definition at line 34 of file diagnostics.cpp.

References Gambit::table_formatter::capitalize_title(), Gambit::table_formatter::default_widths(), functorList, modules, Gambit::table_formatter::padding(), Gambit::print_to_screen(), and Gambit::table_formatter::str().

Referenced by run_diagnostic().

  {
    table_formatter table("Modules", "#functions");
    table.padding(1);
    table.capitalize_title();
    table.default_widths(25);
    for (std::set<str>::const_iterator it = modules.begin(); it != modules.end(); ++it)
    {
      int nf = 0;
      for (fVec::const_iterator jt = functorList.begin(); jt != functorList.end(); ++jt)
      {
        if ((*jt)->origin() == *it) nf++;
      }
      table << *it << nf;
    }
    std::stringstream out;
    out << table.str();
    if (out.str().size() > 0)
        print_to_screen(out.str(), "module");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

prior_diagnostic()

void Gambit::gambit_core::prior_diagnostic ( )

private

Definition at line 214 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::string output = Scanner::Plugins::plugin_info().print_priors("priors");
    if (output.length() > 0)
        print_to_screen(output, "priors");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

process_primary_options()

str Gambit::gambit_core::process_primary_options	(	int	argc,
		char **	argv
	)

Process default command line options.

Process default mode command line options and return filename.

Gambit 'standard mode' command line option definitions (needed by getopt)

Definition at line 125 of file core.cpp.

References bail(), developer_mode, Gambit::Logging::LogMaster::disable(), found_inifile, GET_SIZE, combine_hdf5::index, Gambit::logger(), processed_options, resume, show_runorder, and verbose_flag.

Referenced by run_diagnostic().

    {
      int index;
      int iarg=0;
      str filename;

      // Basically this is a clone of the example in the getopt_long documentation
      // (http://www.gnu.org/savannah-checkouts/gnu/libc/manual/html_node/Getopt-Long-Option-Example.html#Getopt-Long-Option-Example)
      //
      // Note that specialised versions of this structure exist for some of the special run modes.
      const struct option primary_options[] =
      {
        {"version", no_argument, 0, 1}, /*1 is just a unique integer key to identify this argument*/
        {"developer", no_argument, 0, 2},
        {"verbose", no_argument, 0, 'v'},
        {"help",    no_argument, 0, 'h'},
        {"dryrun",  no_argument, 0, 'd'},
        {"restart", no_argument, 0, 'r'},
        {0,0,0,0},
      };

      // Must at least have one argument.
      if (argc < 2) bail();

      while(iarg != -1)
      {
        iarg = getopt_long(argc, argv, "vhdrf:", primary_options, &index);
        switch (iarg)
        {
          case 1:
          {
            // Shut down.
            logger().disable();
            throw SilentShutdownException();
          }
          case 'v':
            // Turn on verbose mode
            verbose_flag = true;
            break;
          case 2:
          // Turn on developer mode
            developer_mode = true;
            break;
          case 'h':
          case '?':
            // display usage message and quit (also happens on unrecognised options)
            bail();
            break;
          case 'd':
            // Display proposed functor evaluation order and quit
            show_runorder = true; // Sorted out in dependency resolver
            // Should not allow this on multiple processes, just produces
            // mixed up junk output.
            if(GET_SIZE>1)
            {
               cout << "Tried to run GAMBIT dry-run mode in parallel! This is not allowed, please use only one process when performing dry-runs." << endl;
               logger().disable();
               throw SilentShutdownException();
            }
            break;
          case 'r':
            // Restart scan (turn off "resume" mode, activate output overwrite)
            resume = false;
            break;
          case 'f':
            // Argument must contain the ini-filename
            filename = optarg;
            found_inifile = true;
        }
      }
      // Set flag telling core object that command line option processing is complete
      processed_options = true;
      return filename;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

quit_diagnostic_MPI()

void Gambit::gambit_core::quit_diagnostic_MPI ( )

private

Quit MPI used for diagnostic mode.

registerActiveModelFunctors()

void Gambit::gambit_core::registerActiveModelFunctors

(

const pmfVec &

fvec

)

Add entries to the map of activated primary model functors.

Definition at line 232 of file core.cpp.

References activeModelFunctorList.

Referenced by main().

    {
      for (gambit_core::pmfVec::const_iterator it = fvec.begin(); it != fvec.end(); ++it)
      {
        activeModelFunctorList[(*it)->origin()] = *it;
      }
    }

Here is the caller graph for this function:

registerBackend()

void Gambit::gambit_core::registerBackend	(	str	be,
		str	version
	)

Register a new backend.

Definition at line 222 of file core.cpp.

References backend_versions.

Referenced by Gambit::register_backend().

{ backend_versions[be].insert(version); }

Here is the caller graph for this function:

registerBackendFunctor()

void Gambit::gambit_core::registerBackendFunctor

(

functor &

f

)

Add a new backend functor to backendFunctorList.

Definition at line 215 of file core.cpp.

References backendFunctorList, capabilities, and Gambit::functor::capability().

Referenced by Gambit::register_backend_functor().

    {
      backendFunctorList.push_back(&f);
      capabilities.insert(f.capability());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

registerModule()

void Gambit::gambit_core::registerModule

(

str

module

)

Add a new module to modules list.

Definition at line 202 of file core.cpp.

References modules.

Referenced by Gambit::register_module().

{ modules.insert(module); }

Here is the caller graph for this function:

registerModuleFunctor()

void Gambit::gambit_core::registerModuleFunctor

(

functor &

f

)

Add a new module functor to functorList.

Definition at line 205 of file core.cpp.

References capabilities, Gambit::functor::capability(), and functorList.

Referenced by Gambit::register_module_functor_core().

    {
      functorList.push_back(&f);
      capabilities.insert(f.capability());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

registerNestedModuleFunctor()

void Gambit::gambit_core::registerNestedModuleFunctor

(

functor &

f

)

Add a new module functor to nestFunctorList.

Definition at line 212 of file core.cpp.

References nestedFunctorList.

Referenced by Gambit::register_management_req().

{ nestedFunctorList.push_back(&f); }

Here is the caller graph for this function:

registerPrimaryModelFunctor()

void Gambit::gambit_core::registerPrimaryModelFunctor

(

primary_model_functor &

f

)

Add a new primary model functor to primaryModelFunctorList.

Definition at line 225 of file core.cpp.

References capabilities, Gambit::functor::capability(), and primaryModelFunctorList.

Referenced by Gambit::register_model_functor_core().

    {
      primaryModelFunctorList.push_back(&f);
      capabilities.insert(f.capability());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

run_diagnostic()

str Gambit::gambit_core::run_diagnostic	(	int	argc,
		char **	argv
	)

Diagnostics function.

Launch non-interactive command-line diagnostic mode, for printing info about current GAMBIT configuration.

Definition at line 588 of file core.cpp.

References Gambit::Utils::are_similar(), backend_diagnostic(), backend_versions, bail(), capabilities, capability_diagnostic(), check_capability_descriptions(), check_databases(), Gambit::Logging::LogMaster::disable(), Gambit::Logging::LogMaster::emit_backlog(), ff_backend_diagnostic(), ff_capability_diagnostic(), ff_model_diagnostic(), ff_module_diagnostic(), ff_prior_diagnostic(), ff_scanner_diagnostic(), ff_test_function_diagnostic(), found_inifile, GET_RANK, Gambit::logger(), model_diagnostic(), module_diagnostic(), modules, Gambit::Scanner::Plugins::plugin_info, primaryModelFunctorList, prior_diagnostic(), process_primary_options(), processed_options, scanner_diagnostic(), and test_function_diagnostic().

Referenced by main().

    {

      str filename;
      str command = "none";
      std::vector<std::string> didyoumean;

      // Parse the arguments, ignoring everything before gambit executable
      if (argc > 1)
      {
        for (int i = 0; i < argc-1; i++)
        {
          str arg = argv[i];
          str x(GAMBIT_EXECUTABLE);
          int len = arg.length();
          int xlen = x.length();
          if (len >= xlen and arg.substr(len-xlen,xlen) == x)
          {
            command = argv[i+1];
            break;
          }
        }
      }

      // Initial list of valid diagnostic commands
      std::vector<str> valid_commands = initVector<str>
      (
        "modules",
        "backends",
        "models",
        "capabilities",
        "scanners",
        "test-functions"
      );

      // Test if the user has requested one of the basic diagnostics
      if (std::find(valid_commands.begin(), valid_commands.end(), command) == valid_commands.end())
      {
        // If we aren't just checking what stuff is registered, we could end up running a scan, or needing the descriptions of things.
        // Therefore we must construct the description databases and make sure there are no naming conflicts etc.
        check_databases();

        // Add other valid diagnostic commands
        valid_commands.insert(valid_commands.end(), modules.begin(), modules.end());
        valid_commands.insert(valid_commands.end(), capabilities.begin(), capabilities.end());
        for (auto it = backend_versions.begin(); it != backend_versions.end(); ++it) valid_commands.push_back(it->first);
        for (auto it = primaryModelFunctorList.begin(); it != primaryModelFunctorList.end(); ++it) valid_commands.push_back((*it)->origin());
        std::vector<std::string> scanner_names = Scanner::Plugins::plugin_info().print_plugin_names("scanner");
        std::vector<std::string> objective_names = Scanner::Plugins::plugin_info().print_plugin_names("objective");
        std::vector<std::string> prior_groups = Scanner::Plugins::plugin_info().list_prior_groups();
        valid_commands.insert(valid_commands.end(), scanner_names.begin(), scanner_names.end());
        valid_commands.insert(valid_commands.end(), objective_names.begin(), objective_names.end());
        valid_commands.insert(valid_commands.end(), prior_groups.begin(), prior_groups.end());
        //valid_commands.push_back("priors");

        // If the user hasn't asked for a diagnostic at all, process the command line options for the standard run mode and get out.
        if (std::find(valid_commands.begin(), valid_commands.end(), command) == valid_commands.end())
        {
          if (not processed_options)
          {
            filename = process_primary_options(argc,argv);
            check_capability_descriptions();
            // Check if we indeed received a valid filename (needs the -f option)
            if (found_inifile) return filename;
            // Ok then, report an unrecognised command and bail
            int mpirank = GET_RANK;
            if (mpirank == 0) cout << "Unrecognised command received!" << endl;
            // Give a list of valid commands that user might have mistyped
            for (std::vector<str>::iterator it = valid_commands.begin(); it != valid_commands.end(); ++it)
            {
              if (Utils::are_similar(command,*it)){ didyoumean.push_back(*it); }
            }
            if (didyoumean.size() > 0)
            {
              if (mpirank == 0)
              {
                cout<<"Did you mean one of the following?"<<endl;
                for (std::vector<str>::iterator it = didyoumean.begin(); it != didyoumean.end(); ++it)
                {
                  if(Utils::are_similar(command,*it)){ cout<<"  "<<*it<<endl; }
                }
                cout<<endl;
                cout<<"Run \"gambit --help\" for a full list of options and usage instructions"<<endl;
              }
              logger().disable();
              throw SilentShutdownException();
            }
            else
            {
              bail(mpirank);
            }

          }
          else
          {
            int mpirank = GET_RANK;
            if (mpirank == 0) cout << "Command line options have already been "
             "processed in a special run mode... GAMBIT should not reach this "
             "point. Quitting..." << endl;
            logger().disable();
            throw SilentShutdownException();
          }
        }
      }



      // Guaranteed from this point that no scans (nor scanners) will be invoked.

      // Get MPI rank (assume MPI already initialised)
      int mpirank = GET_RANK;

      // Disable all but the master MPI node
      if (mpirank == 0)
      {
        if (command == "modules") module_diagnostic();
        if (command == "backends") backend_diagnostic();
        if (command == "models") model_diagnostic();
        if (command == "capabilities") capability_diagnostic();
        if (command == "scanners") scanner_diagnostic();
        if (command == "test-functions") test_function_diagnostic();
        if (command == "priors") prior_diagnostic();
        ff_module_diagnostic(command);
        ff_backend_diagnostic(command);
        ff_model_diagnostic(command);
        ff_capability_diagnostic(command);
        ff_scanner_diagnostic(command);
        ff_test_function_diagnostic(command);
        ff_prior_diagnostic(command);
        cout << endl;
      }

      // Silently print the logs to scratch/run_time/<processID>/default.log
      logger().emit_backlog(false);
      // Split.
      logger().disable();
      throw SilentShutdownException();
      return "";

    }

Here is the call graph for this function:

Here is the caller graph for this function:

scanner_diagnostic()

void Gambit::gambit_core::scanner_diagnostic ( )

private

Basic scanner diagnostic function.

Definition at line 198 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    // Import scanner plugin info from ScannerBit
    std::string output = Scanner::Plugins::plugin_info().print_all("scanner");
    if (output.length() > 0)
        print_to_screen(output, "scanners");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

test_function_diagnostic()

void Gambit::gambit_core::test_function_diagnostic ( )

private

Basic test function diagnostic function.

Definition at line 207 of file diagnostics.cpp.

References Gambit::Scanner::Plugins::plugin_info, and Gambit::print_to_screen().

Referenced by run_diagnostic().

  {
    std::string output = Scanner::Plugins::plugin_info().print_all("objective");
    if (output.length() > 0)
        print_to_screen(output, "objectives");
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

activeModelFunctorList

pmfMap Gambit::gambit_core::activeModelFunctorList

private

A map of all user-activated primary model functors.

Definition at line 78 of file core.hpp.

Referenced by getActiveModelFunctors(), and registerActiveModelFunctors().

backend_versions

std::map<str, std::set<str> > Gambit::gambit_core::backend_versions

private

Map from backend names to a list of all registered versions of the backend.

Definition at line 57 of file core.hpp.

Referenced by accountForMissingClasses(), backend_diagnostic(), ff_backend_diagnostic(), registerBackend(), and run_diagnostic().

backendData

const Backends::backend_info* Gambit::gambit_core::backendData

private

Internal backend info pointer.

Definition at line 51 of file core.hpp.

Referenced by accountForMissingClasses(), backend_diagnostic(), backend_status(), and ff_backend_diagnostic().

backendFunctorList

fVec Gambit::gambit_core::backendFunctorList

private

List of all declared backend functors.

Definition at line 72 of file core.hpp.

Referenced by backend_diagnostic(), capability_diagnostic(), check_databases(), ff_backend_diagnostic(), getBackendFunctors(), and registerBackendFunctor().

capabilities

std::set<str> Gambit::gambit_core::capabilities

private

List of all declared capabilities.

Definition at line 60 of file core.hpp.

Referenced by capability_diagnostic(), check_databases(), ff_capability_diagnostic(), registerBackendFunctor(), registerModuleFunctor(), registerPrimaryModelFunctor(), and run_diagnostic().

capability_dbase

std::vector<capability_info> Gambit::gambit_core::capability_dbase

Vector of all capability_info objects.

Definition at line 217 of file core.hpp.

Referenced by check_capability_descriptions(), check_databases(), and get_capability_info().

developer_mode

bool Gambit::gambit_core::developer_mode

Developer mode (ignore missing capability descriptions)

Definition at line 145 of file core.hpp.

Referenced by process_primary_options().

found_inifile

bool Gambit::gambit_core::found_inifile

Flag recording whether an inifile has been supplied.

Definition at line 142 of file core.hpp.

Referenced by process_primary_options(), and run_diagnostic().

functorList

fVec Gambit::gambit_core::functorList

private

List of all declared module functors.

Definition at line 66 of file core.hpp.

Referenced by accountForMissingClasses(), capability_diagnostic(), check_databases(), ff_module_diagnostic(), getModuleFunctors(), module_diagnostic(), and registerModuleFunctor().

input_capability_descriptions

const str Gambit::gambit_core::input_capability_descriptions

private

Filename of the file from which to harvest capability descriptions.

Definition at line 81 of file core.hpp.

Referenced by check_capability_descriptions(), and check_databases().

input_model_descriptions

const str Gambit::gambit_core::input_model_descriptions

private

Filename of the file from which to harvest model descriptions.

Definition at line 83 of file core.hpp.

Referenced by check_databases().

missing_capability_description

bool Gambit::gambit_core::missing_capability_description

set to true if capability descriptions missing

Definition at line 211 of file core.hpp.

Referenced by check_capability_descriptions(), and check_databases().

model_dbase

std::vector<model_info> Gambit::gambit_core::model_dbase

Vector of all model_info objects.

Definition at line 220 of file core.hpp.

Referenced by check_databases(), and get_model_info().

modelInfo

const Models::ModelFunctorClaw* Gambit::gambit_core::modelInfo

private

Internal model claw pointer.

Definition at line 48 of file core.hpp.

Referenced by check_databases(), and model_diagnostic().

models

std::set<str> Gambit::gambit_core::models

private

List of all declared models.

Definition at line 63 of file core.hpp.

modules

std::set<str> Gambit::gambit_core::modules

private

Set of all declared modules.

Definition at line 54 of file core.hpp.

Referenced by ff_module_diagnostic(), module_diagnostic(), registerModule(), and run_diagnostic().

nestedFunctorList

fVec Gambit::gambit_core::nestedFunctorList

private

List of all module functors that are declared as nested (i.e. require loop managers)

Definition at line 69 of file core.hpp.

Referenced by getNestedModuleFunctors(), and registerNestedModuleFunctor().

outprec

const int Gambit::gambit_core::outprec

private

Precision to use for cout.

Definition at line 86 of file core.hpp.

Referenced by get_outprec().

primaryModelFunctorList

pmfVec Gambit::gambit_core::primaryModelFunctorList

private

List of all declared primary model functors.

Definition at line 75 of file core.hpp.

Referenced by check_databases(), ff_model_diagnostic(), getPrimaryModelFunctors(), model_diagnostic(), registerPrimaryModelFunctor(), and run_diagnostic().

processed_options

bool Gambit::gambit_core::processed_options

private

Flag specifying whether command line options have been processed yet.

Definition at line 89 of file core.hpp.

Referenced by process_primary_options(), and run_diagnostic().

resume

bool Gambit::gambit_core::resume

Flag to trigger "resume" mode.

Definition at line 135 of file core.hpp.

Referenced by main(), and process_primary_options().

show_runorder

int Gambit::gambit_core::show_runorder

Flags set by command line options Flag to trigger dependency resolver to report functor run order.

Definition at line 132 of file core.hpp.

Referenced by Gambit::DRes::DependencyResolver::doResolution(), Gambit::DRes::DependencyResolver::generateTree(), and process_primary_options().

verbose_flag

bool Gambit::gambit_core::verbose_flag

Verbosity mode.

Definition at line 139 of file core.hpp.

Referenced by process_primary_options().

---

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

• Core/include/gambit/Core/core.hpp
• Core/src/core.cpp
• Core/src/diagnostics.cpp