class Gambit::primary_model_functor

[No description available] More…

#include <functors.hpp>

Inherits from Gambit::model_functor, Gambit::module_functor< ModelParameters >, Gambit::module_functor_common, Gambit::functor

Public Functions

	Name
	primary_model_functor(void(*)(ModelParameters &) inputFunction, str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
ModelParameters *	getcontentsPtr()
virtual	~primary_model_functor() Destructor.

Additional inherited members

Public Functions inherited from Gambit::model_functor

	Name
	model_functor(void(*)(ModelParameters &) inputFunction, str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
void	setModelName(str model_name) Function for setting the model name for a ModelParameters object. Mainly for better error messages.
void	addParameter(str parname) Function for adding a new parameter to the map inside the ModelParameters object.
void	donateParameters(model_functor & receiver) Function for handing over parameter identities to another model_functor.
virtual	~model_functor() Destructor.

Public Functions inherited from Gambit::module_functor< ModelParameters >

	Name
	module_functor(void(*)(TYPE &) inputFunction, str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
virtual	~module_functor() Destructor.
virtual void	setPrintRequirement(bool flag) Setter for indicating if the wrapped function’s result should to be printed.
virtual bool	requiresPrinting() const Getter indicating if the wrapped function’s result should to be printed.
virtual void	calculate() Calculate method.
const TYPE &	operator()(int index) Operation (return value)
safe_ptr< TYPE >	valuePtr() Alternative to operation (returns a safe pointer to value)
virtual void	print(Printers::BasePrinter * printer, const int pointID, int index) Printer function.
virtual void	print(Printers::BasePrinter * printer, const int pointID) Printer function (no-thread-index short-circuit)

Protected Functions inherited from Gambit::module_functor< ModelParameters >

	Name
virtual void	init_memory() Initialise the memory of this functor.

Protected Attributes inherited from Gambit::module_functor< ModelParameters >

	Name
void(*)(TYPE &)	myFunction Internal storage of function pointer.
TYPE *	myValue Internal pointer to storage location of function value.
bool	myPrintFlag Flag to select whether or not the results of this functor should be sent to the printer object.

Public Functions inherited from Gambit::module_functor_common

	Name
	module_functor_common(str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
virtual	~module_functor_common() Destructor.
virtual double	getRuntimeAverage() Getter for averaged runtime.
virtual void	reset() Reset functor.
virtual void	notifyOfInvalidation(const str & msg) Tell the functor that it invalidated the current point in model space, pass a message explaining why, and throw an exception.
virtual double	getInvalidationRate() Getter for invalidation rate.
virtual void	setFadeRate(double new_rate) Setter for the fade rate.
virtual void	setTimingPrintRequirement(bool flag) Setter for indicating if the timing data for this function’s execution should be printed.
virtual bool	requiresTimingPrinting() const Getter indicating if the timing data for this function’s execution should be printed.
bool	getActiveModelFlag(str model) Indicate whether or not a known model is activated or not.
safe_ptr< str >	getChosenReqFromGroup(str group) Return a safe pointer to a string indicating which backend requirement has been activated for a given backend group.
virtual void	iterate(long long iteration) Execute a single iteration in the loop managed by this functor.
virtual void	init_myCurrentIteration_if_NULL() Initialise the array holding the current iteration(s) of this functor.
virtual void	setIteration(long long iteration) Setter for setting the iteration number in the loop in which this functor runs.
virtual omp_safe_ptr< long long >	iterationPtr() Return a safe pointer to the iteration number in the loop in which this functor runs.
virtual void	setCanBeLoopManager(bool canManage) Setter for specifying whether this is permitted to be a manager functor, which runs other functors nested in a loop.
virtual bool	canBeLoopManager() Getter for revealing whether this is permitted to be a manager functor.
virtual void	setLoopManagerCapType(str cap, str t) Setter for specifying the capability required of a manager functor, if it is to run this functor nested in a loop.
virtual str	loopManagerCapability() Getter for revealing the required capability of the wrapped function’s loop manager.
virtual str	loopManagerType() Getter for revealing the required type of the wrapped function’s loop manager.
virtual str	loopManagerName() Getter for revealing the name of the wrapped function’s assigned loop manager.
virtual str	loopManagerOrigin() Getter for revealing the module of the wrapped function’s assigned loop manager.
virtual void	breakLoopFromManagedFunctor() Tell the manager of the loop in which this functor runs that it is time to break the loop.
virtual safe_ptr< bool >	loopIsDone() Return a safe pointer to the flag indicating that a loop managed by this functor should break now.
virtual void	resetLoop() Provide a way to reset the flag indicating that a loop managed by this functor should break.
virtual void	breakLoop() Tell the functor that the loop it manages should break now.
virtual std::set< sspair >	dependencies() Getter for listing currently activated dependencies.
virtual std::set< sspair >	backendclassloading() Getter for listing backends that require class loading.
virtual std::set< str >	backendgroups() Getter for listing backend requirement groups.
virtual std::set< sspair >	backendreqs() Getter for listing all backend requirements.
virtual std::set< sspair >	backendreqs(str group) Getter for listing backend requirements from a specific group.
virtual std::set< sspair >	backendspermitted(sspair quant) Getter for listing permitted backends.
virtual std::set< str >	backendreq_tags(sspair quant) Getter for listing tags associated with backend requirements.
virtual std::set< sspair >	forcematchingbackend(str tag) Getter for listing backend requirements that must be resolved from the same backend.
virtual std::set< sspair >	backend_conditional_dependencies(str req, str type, str be, str ver) Getter for listing backend-specific conditional dependencies (4-string version)
virtual std::set< sspair >	backend_conditional_dependencies(str req, str type, str be) Getter for backend-specific conditional dependencies (3-string version)
virtual std::set< sspair >	backend_conditional_dependencies(functor * be_functor) Getter for backend-specific conditional dependencies (backend functor pointer version)
virtual std::set< sspair >	model_conditional_dependencies(str model) Getter for listing model-specific conditional dependencies.
virtual std::set< sspair >	model_conditional_backend_reqs(str model) Getter for listing model-specific conditional backend requirements.
void	setDependency(str dep, str dep_type, void()(functor , module_functor_common *) resolver, str purpose ="") Add and activate unconditional dependencies.
void	setConditionalDependency(str dep, str dep_type) Add conditional dependency-type pairs in advance of later conditions.
void	setBackendConditionalDependency(str req, str be, str ver, str dep, void()(functor , module_functor_common *) resolver) Add a backend conditional dependency for multiple backend versions.
void	setBackendConditionalDependencySingular(str req, str be, str ver, str dep, void()(functor , module_functor_common *) resolver) Add a backend conditional dependency for a single backend version.
void	setModelConditionalDependency(str model, str dep, void()(functor , module_functor_common *) resolver) Add a model conditional dependency for multiple models.
void	setModelConditionalDependencySingular(str model, str dep, void()(functor , module_functor_common *) resolver) Add a model conditional dependency for a single model.
void	makeBackendRuleForModel(str model, str tag) Add a rule for activating backend requirements according to the model being scanned.
void	setBackendReq(str group, str req, str tags, str type, void()(functor ) resolver)
void	setModelConditionalBackendReq(str model, str req, str type) Add a model conditional backend requirement for multiple models.
void	setModelConditionalBackendReqSingular(str model, str req, str type) Add a model conditional backend requirement for a single model.
void	makeBackendOptionRule(str be_and_ver, str tag) Add a rule for dictating which backends can be used to fulfill which backend requirements.
void	setPermittedBackend(str req, str be, str ver) Add a single permitted backend version.
void	makeBackendMatchingRule(str tag) Add one or more rules for forcing backends reqs with the same tags to always be resolved from the same backend.
void	setRequiredClassloader(str be, str ver, str safe_ver) Add a rule indicating that classes from a given backend must be available.
virtual void	notifyOfBackends(std::map< str, std::set< str > > be_ver_map) Indicate to the functor which backends are actually loaded and working.
virtual void	setNestedList(std::vector< functor * > & newNestedList) Set the ordered list of pointers to other functors that should run nested in a loop managed by this one.
virtual void	resolveDependency(functor * dep_functor) Resolve a dependency using a pointer to another functor object.
virtual void	resolveLoopManager(functor * dep_functor) Set this functor’s loop manager (if it has one)
virtual void	resolveBackendReq(functor * be_functor) Resolve a backend requirement using a pointer to another functor object.
virtual void	notifyOfModel(str model) Notify the functor that a certain model is being scanned, so that it can activate its dependencies and backend reqs accordingly.
virtual void	notifyOfDependee(functor * dependent_functor) Notify the functor that another functor depends on it.
virtual invalid_point_exception *	retrieve_invalid_point_exception() Retrieve the previously saved exception generated when this functor invalidated the current point in model space.

Protected Functions inherited from Gambit::module_functor_common

	Name
virtual void	reset(int thread_num) Reset functor for one thread only.
virtual void	acknowledgeInvalidation(invalid_point_exception & e, functor * f =NULL) Acknowledge that this functor invalidated the current point in model space.
virtual void	startTiming(int thread_num) Do pre-calculate timing things.
virtual void	finishTiming(int thread_num) Do post-calculate timing things.
virtual void	init_memory() Initialise the memory of this functor.
void	fill_activeModelFlags() Construct the list of known models only if it doesn’t yet exist.
sspair	retrieve_conditional_dep_type_pair(str dep) Retrieve full conditional dependency-type pair from conditional dependency only.
void	check_missing_LogTag() Check if an appropriate LogTag for this functor is missing from the logging system.
void	entering_multithreaded_region()
void	leaving_multithreaded_region()

Protected Attributes inherited from Gambit::module_functor_common

	Name
bool	myTimingPrintFlag Flag to select whether or not the timing data for this function’s execution should be printed;.
std::chrono::time_point< std::chrono::system_clock > *	start Beginning and end timing points.
std::chrono::time_point< std::chrono::system_clock > *	end
bool	point_exception_raised A flag indicating whether or not this functor has invalidated the current point.
invalid_point_exception	raised_point_exception An exception raised because this functor has invalidated the current point.
double	runtime_average Averaged runtime in ns.
double	fadeRate Fade rate for average runtime.
double	pInvalidation Probability that functors invalidates point in model parameter space.
bool *	needs_recalculating Needs recalculating or not?
bool *	already_printed Has result already been sent to the printer?
bool *	already_printed_timing Has timing data already been sent to the printer?
bool	iCanManageLoops Flag indicating whether this function can manage a loop over other functions.
bool	myLoopIsDone Flag indicating whether this function is ready to finish its loop (only relevant if iCanManageLoops = true)
bool	iRunNested Flag indicating whether this function can run nested in a loop over functions.
str	myLoopManagerCapability Capability of a function that mangages a loop that this function can run inside of.
str	myLoopManagerType Capability of a function that mangages a loop that this function can run inside of.
functor *	myLoopManager Pointer to the functor that mangages the loop that this function runs inside of.
std::vector< functor * >	myNestedFunctorList Vector of functors that have been set up to run nested within this one.
long long *	myCurrentIteration Pointer to counters for iterations of nested functor loop.
const int	globlMaxThreads Maximum number of OpenMP threads this MPI process is permitted to launch in total.
std::set< str >	myGroups Internal list of backend groups that this functor’s requirements fall into.
std::map< str, str >	chosenReqsFromGroups Map from groups to backend reqs, indicating which backend req has been activated for which backend group.
std::set< sspair >	myBackendReqs Set of all backend requirement-type string pairs.
std::set< sspair >	myResolvableBackendReqs Set of all backend requirement-type string pairs currently available for resolution.
std::map< str, std::set< sspair > >	myGroupedBackendReqs Set of backend requirement-type string pairs for specific backend groups.
std::set< sspair >	myDependencies Vector of dependency-type string pairs.
std::map< str, str >	myConditionalDependencies Map of conditional dependencies to their types.
std::map< std::vector< str >, std::set< sspair > >	myBackendConditionalDependencies Map from (vector with 4 strings: backend req, type, backend, version) to (set of {conditional dependency-type} pairs)
std::map< str, std::set< sspair > >	myModelConditionalDependencies Map from models to (set of {conditional dependency-type} pairs)
std::map< str, std::set< sspair > >	myModelConditionalBackendReqs Map from models to (set of {conditional backend requirement-type} pairs)
std::map< str, bool >	activeModelFlags Map from known models to flags indicating if they are activated or not (known = allowed, in allowed groups or conditions for conditional dependencies)
std::map< sspair, void()(functor , module_functor_common *)>	dependency_map
std::map< sspair, functor * >	dependency_functor_map
std::map< str, str >	backendreq_types Map from backend requirements to their required types.
std::map< sspair, str >	backendreq_groups Map from backend requirements to their designated groups.
std::map< sspair, std::set< str > >	backendreq_tagmap Map from backend requirements to their rule tags.
std::map< sspair, void()(functor )>	backendreq_map
std::map< sspair, std::set< sspair > >	permitted_map Map from (backend requirement-type pairs) to (set of permitted {backend-version} pairs)
std::map< str, std::set< sspair > >	myForcedMatches Map from tags to sets of matching (backend requirement-type pairs) that are forced to use the same backend.
std::map< str, std::set< str > >	required_classloading_backends Map from required classloading backends to their versions.
std::vector< str >	missing_backends Vector of required backends currently missing.
timespec	tp Internal timespec object.
int	myLogTag Integer LogTag, for tagging log messages.
bool	signal_mode_locked

Friends inherited from Gambit::module_functor_common

	Name
void	FunctorHelp::entering_multithreaded_region(module_functor_common & ) Connectors to external helper functions (to decouple signal handling from this class)
void	FunctorHelp::leaving_multithreaded_region(module_functor_common & )

Public Functions inherited from Gambit::functor

	Name
virtual double	getRuntimeAverage()
virtual double	getInvalidationRate()
virtual void	setFadeRate(double )
virtual void	notifyOfInvalidation(const str & )
virtual void	reset()
	functor(str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
virtual	~functor()
virtual void	calculate() Virtual calculate(); needs to be redefined in daughters.
virtual void	reset_and_calculate() Reset-then-recalculate method.
void	setStatus(int stat)
virtual void	setInUse(bool ) Set the inUse flag (must be overridden in derived class to have any effect).
void	setPurpose(str purpose) Setter for purpose (relevant only for next-to-output functors)
void	setVertexID(int ID) Setter for vertex ID (used in printer system)
void	setTimingVertexID(int ID) Set ID for timing ‘vertex’ (used in printer system)
str	name() const Getter for the wrapped function’s name.
str	capability() const Getter for the wrapped function’s reported capability.
str	type() const Getter for the wrapped function’s reported return type.
str	origin() const Getter for the wrapped function’s origin (module or backend name)
str	version() const Getter for the version of the wrapped function’s origin (module or backend)
virtual str	safe_version() const Getter for the ‘safe’ incarnation of the version of the wrapped function’s origin (module or backend)
int	status() const
sspair	quantity() const Getter for the overall quantity provided by the wrapped function (capability-type pair)
str	purpose() const Getter for purpose (relevant for output nodes, aka helper structures for the dep. resolution)
str	citationKey() const Getter for the citation key.
int	vertexID() const Getter for vertex ID.
int	timingVertexID() const Getter for timing vertex ID.
str	label() const Getter for string label.
str	timingLabel() const Getter for the printer timing label.
virtual bool	requiresPrinting() const Getter indicating if the wrapped function’s result should to be printed.
virtual bool	requiresTimingPrinting() const Getter indicating if the timing data for this function’s execution should be printed.
virtual void	setPrintRequirement(bool flag) Setter for indicating if the wrapped function’s result should to be printed.
virtual void	setTimingPrintRequirement(bool flag) Setter for indicating if the timing data for this function’s execution should be printed.
virtual void	setNestedList(std::vector< functor * > & ) Set the ordered list of pointers to other functors that should run nested in a loop managed by this one.
virtual void	setIteration(long long ) Set the iteration number in a loop in which this functor runs.
virtual bool	canBeLoopManager() Getter for revealing whether this is permitted to be a manager functor.
virtual str	loopManagerCapability() Getter for revealing the required capability of the wrapped function’s loop manager.
virtual str	loopManagerType() Getter for revealing the required type of the wrapped function’s loop manager.
virtual str	loopManagerName() Getter for revealing the name of the wrapped function’s assigned loop manager.
virtual str	loopManagerOrigin() Getter for revealing the module of the wrapped function’s assigned loop manager.
virtual void	breakLoop() Tell the functor that the loop it manages should break now.
virtual std::set< sspair >	dependencies() Getter for listing currently activated dependencies.
virtual std::set< sspair >	backendclassloading() Getter for listing backends that require class loading.
virtual std::set< str >	backendgroups() Getter for listing backend requirement groups.
virtual std::set< sspair >	backendreqs() Getter for listing all backend requirements.
virtual std::set< sspair >	backendreqs(str ) Getter for listing backend requirements from a specific group.
virtual std::set< sspair >	backendspermitted(sspair ) Getter for listing permitted backends.
virtual std::set< str >	backendreq_tags(sspair ) Getter for listing tags associated with backend requirements.
virtual std::set< sspair >	forcematchingbackend(str ) Getter for listing backend requirements that must be resolved from the same backend.
virtual std::set< sspair >	backend_conditional_dependencies(str , str , str , str ) Getter for listing backend-specific conditional dependencies (4-string version)
virtual std::set< sspair >	backend_conditional_dependencies(str req, str type, str be) Getter for backend-specific conditional dependencies (3-string version)
virtual std::set< sspair >	backend_conditional_dependencies(functor * be_functor) Getter for backend-specific conditional dependencies (backend functor pointer version)
virtual std::set< sspair >	model_conditional_dependencies(str ) Getter for listing model-specific conditional dependencies.
virtual std::set< sspair >	model_conditional_backend_reqs(str ) Getter for listing model-specific conditional backend requirements.
virtual void	resolveDependency(functor * ) Resolve a dependency using a pointer to another functor object.
virtual void	resolveLoopManager(functor * ) Set this functor’s loop manager (if it has one)
virtual void	resolveBackendReq(functor * ) Resolve a backend requirement using a pointer to another functor object.
virtual void	notifyOfModel(str ) Notify the functor that a certain model is being scanned, so that it can activate itself accordingly.
virtual void	notifyOfDependee(functor * ) Notify the functor that it is being used to fill a dependency of another functor.
virtual void	notifyOfBackends(std::map< str, std::set< str > > ) Indicate to the functor which backends are actually loaded and working.
virtual void	print(Printers::BasePrinter * printer, const int pointID, int thread_num) Printer function.
virtual void	print(Printers::BasePrinter * printer, const int pointID) Printer function (no-thread-index short-circuit)
virtual invalid_point_exception *	retrieve_invalid_point_exception() Retrieve the previously saved exception generated when this functor invalidated the current point in model space.
void	notifyOfIniOptions(const Options & opt)
template <typename TYPE > void	setOption(const str & key, const TYPE val) Set an option for the functor directly (for use in standalone executables).
safe_ptr< Options >	getOptions() Return a safe pointer to the options that this functor is supposed to run with (e.g. from the ini file).
void	notifyOfSubCaps(const str & subcap_string) Notify the functor about a string in YAML that contains the sub-capability information (for use in standalones)
void	notifyOfSubCaps(const Options & subcaps) Notify the functor about an instance of the options class that contains sub-capability information.
template <typename TYPE > void	setSubCap(const str & key, const TYPE val) Set a sub-capability (subcap)for the functor directly (for use in standalone executables).
safe_ptr< Options >	getSubCaps() Return a safe pointer to the subcaps that this functor realises it is supposed to facilitate downstream calculation of.
safe_ptr< std::set< sspair > >	getDependees() Return a safe pointer to the vector of all capability,type pairs of functors arranged downstream of this one in the dependency tree.
bool	allModelsAllowed() Test whether the functor is allowed to be used with all models.
bool	modelAllowed(str model) Test whether the functor is always allowed (either explicitly or implicitly) to be used with a given model.
bool	modelExplicitlyAllowed(str model) Test whether the functor is explictly always allowed to be used with a given model.
void	setAllowedModel(str model) Add a model to the internal list of models for which this functor is allowed to be used.
bool	modelComboAllowed(std::set< str > combo) Test whether the functor is allowed (either explicitly or implicitly) to be used with a given combination of models.
bool	modelComboExplicitlyAllowed(std::set< str > combo) Test whether the functor has been explictly allowed to be used with a given combination of models.
void	setModelGroup(str group, str contents) Add a model group definition to the internal list of model groups.
void	setAllowedModelGroupCombo(str groups) Add a combination of model groups to the internal list of combinations for which this functor is allowed to be used.

Protected Functions inherited from Gambit::functor

	Name
virtual void	reset(int ) Reset functor for one thread only.
void	failBigTime(str method) Attempt to retrieve a dependency or model parameter that has not been resolved.
bool	allowed_parent_or_friend_exists(str model) Test if there is a model in the functor’s allowedModels list as which this model can be interpreted.
bool	in_allowed_combo(str model) Check that a model is actually part of a combination that is allowed to be used with this functor.
bool	contains_anything_interpretable_as_member_of(std::set< str > combo, str group) Test whether any of the entries in a given model group is a valid interpretation of any members in a given combination.
bool	has_common_elements(std::set< str > combo, str group) Work out whether a given combination of models and a model group have any elements in common.
str	find_friend_or_parent_model_in_map(str model, std::map< str, std::set< sspair > > karta) Try to find a parent or friend model in some user-supplied map from models to sspair vectors.

Protected Attributes inherited from Gambit::functor

	Name
str	myName Internal storage of the function name.
str	myCapability Internal storage of exactly what the function calculates.
str	myType Internal storage of the type of what the function calculates.
str	myOrigin Internal storage of the name of the module or backend to which the function belongs.
str	myVersion Internal storage of the version of the module or backend to which the function belongs.
str	myPurpose Purpose of the function (relevant for output and next-to-output functors)
str	myCitationKey Citation key: BibTex key of the reference.
const Models::ModelFunctorClaw *	myClaw Bound model functor claw, for checking relationships between models.
const str	myLabel String label, used to label functor results for printer system.
const str	myTimingLabel String label, used to label functor timing data for printer system.
int	myStatus
int	myVertexID Internal storage of the vertex ID number used by the printer system to identify functors.
int	myTimingVertexID ID assigned by printers to the timing data output stream.
bool	verbose Debug flag.
Options	myOptions Internal storage of function options, as a YAML node.
Options	mySubCaps Internal storage of function sub-capabilities, as a YAML node.
std::set< sspair >	myDependees List of all capability,type pairs of functors downstream of this one in the dependency tree.
std::set< str >	allowedModels List of allowed models.
std::set< std::set< str > >	allowedGroupCombos List of allowed model group combinations.
std::map< str, std::set< str > >	modelGroups Map from model group names to group contents.

Detailed Description

class Gambit::primary_model_functor;

Functors specific to primary ModelParameters objects

These allow direct access to the functor contents via a raw pointer, so that the parameter values can be set (not allowed via safe pointers).

Public Functions Documentation

function primary_model_functor

primary_model_functor(
    void(*)(ModelParameters &) inputFunction,
    str func_name,
    str func_capability,
    str result_type,
    str origin_name,
    Models::ModelFunctorClaw & claw
)

Constructor.

Primary model functor class method definitions.

Constructor

function getcontentsPtr

ModelParameters * getcontentsPtr()

Functor contents raw pointer “get” function Returns a raw pointer to myValue, so that the contents may be modified (intended for setting parameter values in primary ModelParameters objects)

function ~primary_model_functor

inline virtual ~primary_model_functor()

Destructor.

Updated on 2023-06-26 at 21:36:51 +0000

class Gambit::primary_model_functor #

Public Functions #

Additional inherited members #

Detailed Description #

Public Functions Documentation #

function primary_model_functor #

function getcontentsPtr #

function ~primary_model_functor #