Class Model¶

template <typename TSeq>

Core class of epiworld. More...

#include <model-bones.hpp>

Inherited by the following classes: ModelDiffNet, ModelMeaslesMixing, ModelMeaslesMixingRiskQuarantine, ModelMeaslesSchool, ModelSEIR, ModelSEIRCONN, ModelSEIRD, ModelSEIRDCONN, ModelSEIRMixing, ModelSEIRMixingQuarantine, ModelSIR, ModelSIRCONN, ModelSIRD, ModelSIRDCONN, ModelSIRLogit, ModelSIRMixing, ModelSIS, ModelSISD, ModelSURV

Public Attributes¶

Type	Name
std::array< epiworld_double, 1024u *2u >	array_double_tmp
std::array< Virus< TSeq > , 1024u 2u >	array_virus_tmp

Public Functions¶

Type	Name
	Model ()
	Model (const Model< TSeq > & m)
	Model (Model< TSeq > && m)
void	add_entity (Entity< TSeq > e)
void	add_globalevent (std::function< void(Model< TSeq > )> fun, std::string name="A global action", int date=-99) Set a global action.*
void	add_globalevent (GlobalEvent< TSeq > & action)
epiworld_double	add_param (epiworld_double initial_val, std::string pname, bool overwrite=false)
epiworld_fast_int	add_state (std::string lab, UpdateFun< TSeq > fun=nullptr)
void	add_tool (Tool< TSeq > & t)
void	add_user_data (epiworld_fast_uint j, epiworld_double x)
void	add_user_data (std::vector< epiworld_double > x)
void	add_virus (Virus< TSeq > & v)
void	agents_empty_graph (epiworld_fast_uint n=1000)
void	agents_from_adjlist (std::string fn, int size, int skip=0, bool directed=false)
void	agents_from_adjlist (AdjList al)
void	agents_from_edgelist (const std::vector< int > & source, const std::vector< int > & target, int size, bool directed)
Model< TSeq > &	agents_smallworld (epiworld_fast_uint n=1000, epiworld_fast_uint k=5, bool d=false, epiworld_double p=.01)
void	clear_state_set ()
void	draw (DiagramType diagram_type=DiagramType::Mermaid, const std::string & fn_output="", bool self=false) Draws a mermaid diagram of the model.
void	events_run () Executes the stored action.
Agent< TSeq > &	get_agent (size_t i)
std::vector< Agent< TSeq > > &	get_agents () Returns a reference to the vector of agents.
double *	get_agents_data ()
size_t	get_agents_data_ncols () const
std::vector< epiworld_fast_uint >	get_agents_states () const Returns a vector with the states of the agents.
std::vector< Viruses_const< TSeq > >	get_agents_viruses () const Returns a const vector with the viruses of the agents.
std::vector< Viruses< TSeq > >	get_agents_viruses () Returns a vector with the viruses of the agents.
DataBase< TSeq > &	get_db ()
const DataBase< TSeq > &	get_db () const
void	get_elapsed (std::string unit="auto", epiworld_double * last_elapsed=nullptr, epiworld_double * total_elapsed=nullptr, std::string * unit_abbr=nullptr, bool print=true) const
std::vector< Entity< TSeq > > &	get_entities ()
Entity< TSeq > &	get_entity (size_t entity_id, int * entity_pos=nullptr)
const Entity< TSeq > &	get_entity (size_t entity_id, int * entity_pos=nullptr) const
GlobalEvent< TSeq > &	get_globalevent (std::string name) Retrieve a global action by name.
GlobalEvent< TSeq > &	get_globalevent (size_t i) Retrieve a global action by index.
void	get_hospitalizations (std::vector< int > & date, std::vector< int > & virus_id, std::vector< int > & tool_id, std::vector< int > & count, std::vector< double > & weight) const Get the full time series of hospitalization data.
size_t	get_n_entities () const
epiworld_fast_uint	get_n_replicates () const
size_t	get_n_states () const
size_t	get_n_tools () const Number of tools in the model.
size_t	get_n_viruses () const Number of viruses in the model.
std::string	get_name () const
epiworld_fast_uint	get_ndays () const
epiworld_double	get_param (std::string pname)
Queue< TSeq > &	get_queue () Retrieve the `Queue` object.
std::shared_ptr< epi_xoshiro256ss > &	get_rand_endgine ()
epiworld_double	get_rewire_prop () const
size_t	get_sim_id () const
const std::vector< UpdateFun< TSeq > > &	get_state_fun () const
const std::vector< std::string > &	get_states () const
Tool< TSeq > &	get_tool (size_t id)
Tool< TSeq > &	get_tool (std::string_view name)
const std::vector< ToolPtr< TSeq > > &	get_tools () const
UserData< TSeq > &	get_user_data ()
bool	get_verbose () const
Virus< TSeq > &	get_virus (size_t id)
Virus< TSeq > &	get_virus (std::string_view name)
const std::vector< VirusPtr< TSeq > > &	get_viruses () const
bool	has_tool (std::string_view name) const
bool	has_virus (std::string_view name) const
virtual Model< TSeq > &	initial_states (std::vector< double >, std::vector< int >)
bool	is_directed () const
bool	is_queuing_on () const Query if the queuing system is on.
void	load_agents_entities_ties (std::string fn, int skip) Associate agents-entities from a file.
void	load_agents_entities_ties (const std::vector< int > & agents_ids, const std::vector< int > & entities_ids) Associate agents-entities from data.
void	load_agents_entities_ties (const int * agents_id, const int * entities_id, size_t n)
void	mutate_virus ()
virtual void	next ()
bool	operator!= (const Model< TSeq > & other) const
epiworld_double	operator() (std::string pname)
Model< TSeq > &	operator= (const Model< TSeq > & m)
bool	operator== (const Model< TSeq > & other) const
epiworld_double	par (std::string pname) const
std::map< std::string, epiworld_double > &	params ()
const Model< TSeq > &	print (bool lite=false) const
void	print_state_codes () const
Model< TSeq > &	queuing_off () Deactivates the queuing system.
void	queuing_on () Activates the queuing system (default.)
int	rbinom ()
int	rbinom (int n, epiworld_double p)
Model< TSeq > &	read_params (std::string fn, bool overwrite=false)
void	record_hospitalization (Agent< TSeq > & agent) Record a hospitalization event for an agent.
virtual void	reset () Reset the model.
void	rewire ()
epiworld_double	rexp ()
epiworld_double	rexp (epiworld_double lambda)
epiworld_double	rgamma ()
epiworld_double	rgamma (epiworld_double alpha, epiworld_double beta)
int	rgeom ()
int	rgeom (epiworld_double p)
epiworld_double	rlognormal ()
epiworld_double	rlognormal (epiworld_double mean, epiworld_double shape)
void	rm_entity (size_t entity_id)
void	rm_globalevent (std::string name) Remove a global action by name.
void	rm_globalevent (size_t i) Remove a global action by index.
void	rm_tool (size_t tool_pos)
void	rm_virus (size_t virus_pos)
int	rnbinom ()
int	rnbinom (int n, epiworld_double p)
epiworld_double	rnorm ()
epiworld_double	rnorm (epiworld_double mean, epiworld_double sd)
int	rpoiss ()
int	rpoiss (epiworld_double lambda)
virtual Model< TSeq > &	run (epiworld_fast_uint ndays, int seed=-1) Runs the simulation (after initialization)
void	run_globalevents ()
Model< TSeq > &	run_multiple (epiworld_fast_uint ndays, epiworld_fast_uint nexperiments, int seed_=-1, std::function< void(size_t, Model< TSeq > )> fun=make_save_run*< TSeq >(), bool reset=true, bool verbose=true, int nthreads=1)
epiworld_double	runif ()
epiworld_double	runif (epiworld_double a, epiworld_double b)
int	runif_int (int a, int b)
size_t	sample_from_probs (size_t n) Sample from a set of probabilities stored in array_double_tmp.
void	seed (size_t s)
void	set_agents_data (double * data_, size_t ncols_) Set the agents data object.
void	set_backup ()
void	set_name (std::string name) Set the name object.
void	set_ndays (epiworld_fast_uint ndays)
void	set_param (std::string pname, epiworld_double val)
void	set_rand_binom (int n, epiworld_double p)
void	set_rand_engine (std::shared_ptr< epi_xoshiro256ss > & eng)
void	set_rand_exp (epiworld_double lambda)
void	set_rand_gamma (epiworld_double alpha, epiworld_double beta)
void	set_rand_geom (epiworld_double p)
void	set_rand_lognormal (epiworld_double mean, epiworld_double shape)
void	set_rand_nbinom (int n, epiworld_double p)
void	set_rand_norm (epiworld_double mean, epiworld_double sd)
void	set_rand_poiss (epiworld_double lambda)
void	set_rand_unif (epiworld_double a, epiworld_double b)
void	set_rewire_fun (std::function< void(std::vector< Agent< TSeq > > , Model< TSeq > , epiworld_double)> fun)
void	set_rewire_prop (epiworld_double prop)
void	set_user_data (std::vector< std::string > names) [@
size_t	size () const
epiworld_fast_int	state_of (std::string_view name)
int	today () const The current time of the model.
void	update_state ()
Model< TSeq > &	verbose_off ()
Model< TSeq > &	verbose_on ()
void	write_data (std::string fn_virus_info, std::string fn_virus_hist, std::string fn_tool_info, std::string fn_tool_hist, std::string fn_total_hist, std::string fn_transmission, std::string fn_transition, std::string fn_reproductive_number, std::string fn_generation_time, std::string fn_active_cases, std::string fn_outbreak_size, std::string fn_hospitalizations) const Wrapper of `DataBase::write_data` __
void	write_edgelist (std::string fn) const
void	write_edgelist (std::vector< int > & source, std::vector< int > & target) const
virtual	~Model ()

Protected Attributes¶

Type	Name
double *	agents_data = `nullptr`
size_t	agents_data_ncols = `0u`
int	current_date = `0`
DataBase< TSeq >	db = `[DataBase](classDataBase.md)<TSeq>(\*this)`
bool	directed = `false`
std::shared_ptr< epi_xoshiro256ss >	engine = `std::make\_shared< [epi\_xoshiro256ss](classepi__xoshiro256ss.md) >()`
std::vector< Entity< TSeq > >	entities = `{}`
std::vector< Event< TSeq > >	events = `{}` Variables used to keep track of the events to be made regarding viruses.
std::vector< GlobalEventPtr< TSeq > >	globalevents
std::function< void(Model< TSeq > *)>	initial_states_fun = `/* multi line expression */`
int	last_seed = `0`
epiworld_fast_uint	n_replicates = `0u`
epiworld_fast_uint	nactions = `0u`
std::string	name = `""` Name of the model.
epiworld_fast_uint	ndays = `0`
epiworld_fast_uint	nstates = `0u`
std::map< std::string, epiworld_double >	parameters
Progress	pb
std::vector< Agent< TSeq > >	population = `{}`
std::vector< Agent< TSeq > >	population_backup = `{}`
std::vector< size_t >	population_left
size_t	population_left_n = `0u`
Queue< TSeq >	queue
std::binomial_distribution	rbinomd = `/* multi line expression */`
std::function< void(std::vector< Agent< TSeq > > , Model< TSeq > , epiworld_double)>	rewire_fun
epiworld_double	rewire_prop = `0.0`
std::exponential_distribution	rexpd = `/* multi line expression */`
std::gamma_distribution	rgammad = `/* multi line expression */`
std::geometric_distribution	rgeomd = `/* multi line expression */`
std::lognormal_distribution	rlognormald = `/* multi line expression */`
std::negative_binomial_distribution	rnbinomd = `/* multi line expression */`
std::normal_distribution	rnormd = `/* multi line expression */`
std::poisson_distribution	rpoissd = `/* multi line expression */`
epiworld_double	runifd_a = `0.0`
epiworld_double	runifd_b = `1.0`
std::vector< Agent< TSeq > * >	sampled_population
size_t	sampled_population_n = `0u`
size_t	sim_id = `0u`
std::vector< UpdateFun< TSeq > >	state_fun = `{}` Functions to update states.
std::vector< std::string >	states_labels = `{}` Labels of the states.
std::chrono::duration< epiworld_double, std::micro >	time_elapsed = `/* multi line expression */`
std::chrono::time_point< std::chrono::steady_clock >	time_end
std::chrono::time_point< std::chrono::steady_clock >	time_start
std::vector< ToolPtr< TSeq > >	tools = `{}`
bool	use_queuing = `true`
bool	using_backup = `true`
bool	verbose = `true`
std::vector< VirusPtr< TSeq > >	viruses = `{}`

Protected Functions¶

Type	Name
void	_add_event (Agent< TSeq > * agent_, VirusPtr< TSeq > virus_, ToolPtr< TSeq > tool_, Entity< TSeq > * entity_, epiworld_fast_int new_state_, epiworld_fast_int queue_, EventAction action_) Construct a new Event object.
void	_event_add_entity (Event< TSeq > & a)
void	_event_add_tool (Event< TSeq > & a)
void	_event_add_virus (Event< TSeq > & a)
void	_event_change_state (Event< TSeq > & a)
void	_event_rm_entity (Event< TSeq > & a)
void	_event_rm_tool (Event< TSeq > & a)
void	_event_rm_virus (Event< TSeq > & a)
void	chrono_end ()
void	chrono_start ()
virtual std::unique_ptr< Model< TSeq > >	clone_ptr () Advanced usage: Makes a copy of data and returns it as undeleted pointer.
virtual epiworld_double	death_reduction_mixer (Agent< TSeq > * agent, VirusPtr< TSeq > & virus)
void	dist_entities ()
void	dist_tools ()
void	dist_virus ()
virtual epiworld_double	recovery_enhancer_mixer (Agent< TSeq > * agent, VirusPtr< TSeq > & virus)
void	set_sim_id (size_t id)
virtual epiworld_double	susceptibility_reduction_mixer (Agent< TSeq > * agent, VirusPtr< TSeq > & virus)
virtual epiworld_double	transmission_reduction_mixer (Agent< TSeq > * agent, VirusPtr< TSeq > & virus)

Detailed Description¶

The model class provides the wrapper that puts together Agent, Virus, and Tools.

Template parameters:

TSeq Type of sequence. In principle, users can build models in which virus and human sequence is represented as numeric vectors (if needed.)

Public Attributes Documentation¶

variable array_double_tmp¶

std::array<epiworld_double, 1024u * 2u> Model< TSeq >::array_double_tmp;

variable array_virus_tmp¶

std::array<Virus<TSeq> *, 1024u * 2u> Model< TSeq >::array_virus_tmp;

Public Functions Documentation¶

function Model [1/3]¶

inline Model::Model ()

function Model [2/3]¶

inline Model::Model (
    const Model < TSeq > & m
)

function Model [3/3]¶

inline Model::Model (
    Model < TSeq > && m
)

function add_entity¶

inline void Model::add_entity (
    Entity < TSeq > e
)

function add_globalevent [1/2]¶

Set a global action.

inline void Model::add_globalevent (
    std::function< void( Model < TSeq > *)> fun,
    std::string name="A global action",
    int date=-99
)

Parameters:

fun A function to be called on the prescribed date
name Name of the action.
date Integer indicating when the function is called (see details)

When date is less than zero, then the function is called at the end of every day. Otherwise, the function will be called only at the end of the indicated date.

function add_globalevent [2/2]¶

inline void Model::add_globalevent (
    GlobalEvent < TSeq > & action
)

function add_param¶

inline epiworld_double Model::add_param (
    epiworld_double initial_val,
    std::string pname,
    bool overwrite=false
)

function add_state¶

inline epiworld_fast_int Model::add_state (
    std::string lab,
    UpdateFun < TSeq > fun=nullptr
)

function add_tool¶

inline void Model::add_tool (
    Tool < TSeq > & t
)

function add_user_data [1/2]¶

inline void Model::add_user_data (
    epiworld_fast_uint j,
    epiworld_double x
)

function add_user_data [2/2]¶

inline void Model::add_user_data (
    std::vector< epiworld_double > x
)

function add_virus¶

inline void Model::add_virus (
    Virus < TSeq > & v
)

function agents_empty_graph¶

inline void Model::agents_empty_graph (
    epiworld_fast_uint n=1000
)

function agents_from_adjlist [1/2]¶

inline void Model::agents_from_adjlist (
    std::string fn,
    int size,
    int skip=0,
    bool directed=false
)

function agents_from_adjlist [2/2]¶

inline void Model::agents_from_adjlist (
    AdjList al
)

function agents_from_edgelist¶

inline void Model::agents_from_edgelist (
    const std::vector< int > & source,
    const std::vector< int > & target,
    int size,
    bool directed
)

function agents_smallworld¶

inline Model < TSeq > & Model::agents_smallworld (
    epiworld_fast_uint n=1000,
    epiworld_fast_uint k=5,
    bool d=false,
    epiworld_double p=.01
)

function clear_state_set¶

void Model::clear_state_set ()

function draw¶

Draws a mermaid diagram of the model.

inline void Model::draw (
    DiagramType diagram_type=DiagramType::Mermaid,
    const std::string & fn_output="",
    bool self=false
)

Parameters:

model The model to draw.
fn_output The name of the file to write the diagram. If empty, the diagram will be printed to the standard output.
self Whether to allow self-transitions.

function events_run¶

Executes the stored action.

inline void Model::events_run ()

Parameters:

model_ Model over which it will be executed.

function get_agent¶

inline Agent < TSeq > & Model::get_agent (
    size_t i
)

function get_agents¶

Returns a reference to the vector of agents.

inline std::vector< Agent < TSeq > > & Model::get_agents ()

function get_agents_data¶

inline double * Model::get_agents_data ()

function get_agents_data_ncols¶

inline size_t Model::get_agents_data_ncols () const

function get_agents_states¶

Returns a vector with the states of the agents.

inline std::vector< epiworld_fast_uint > Model::get_agents_states () const

function get_agents_viruses [1/2]¶

Returns a const vector with the viruses of the agents.

inline std::vector< Viruses_const < TSeq > > Model::get_agents_viruses () const

function get_agents_viruses [2/2]¶

Returns a vector with the viruses of the agents.

inline std::vector< Viruses < TSeq > > Model::get_agents_viruses ()

function get_db [1/2]¶

inline DataBase < TSeq > & Model::get_db ()

function get_db [2/2]¶

inline const DataBase < TSeq > & Model::get_db () const

function get_elapsed¶

inline void Model::get_elapsed (
    std::string unit="auto",
    epiworld_double * last_elapsed=nullptr,
    epiworld_double * total_elapsed=nullptr,
    std::string * unit_abbr=nullptr,
    bool print=true
) const

function get_entities¶

inline std::vector< Entity < TSeq > > & Model::get_entities ()

function get_entity [1/2]¶

inline Entity < TSeq > & Model::get_entity (
    size_t entity_id,
    int * entity_pos=nullptr
)

function get_entity [2/2]¶

inline const Entity < TSeq > & Model::get_entity (
    size_t entity_id,
    int * entity_pos=nullptr
) const

function get_globalevent [1/2]¶

Retrieve a global action by name.

GlobalEvent < TSeq > & Model::get_globalevent (
    std::string name
)

function get_globalevent [2/2]¶

Retrieve a global action by index.

GlobalEvent < TSeq > & Model::get_globalevent (
    size_t i
)

function get_hospitalizations¶

Get the full time series of hospitalization data.

inline void Model::get_hospitalizations (
    std::vector< int > & date,
    std::vector< int > & virus_id,
    std::vector< int > & tool_id,
    std::vector< int > & count,
    std::vector< double > & weight
) const

Parameters:

date Output vector for dates.
virus_id Output vector for virus IDs.
tool_id Output vector for tool IDs.
count Output vector for counts (number of hospitalized individuals).
weight Output vector for summed weights (fractional contribution based on tool distribution).

This is a wrapper for DataBase::get_hospitalizations(). Returns the full time series of hospitalization data. For each unique (virus_id, tool_id) combination observed, returns an entry for every day from 0 to ndays-1.

The count vector contains the actual number of individuals hospitalized for that (date, virus_id, tool_id) combination. This is useful for answering questions like "how many total people were hospitalized?" regardless of their tools.

The weight vector contains fractional contributions: if an agent has N tools, each tool gets weight = 1/N. Summing weights across all tool_ids for a given date and virus_id gives the total number of hospitalizations.

function get_n_entities¶

inline size_t Model::get_n_entities () const

function get_n_replicates¶

inline epiworld_fast_uint Model::get_n_replicates () const

function get_n_states¶

inline size_t Model::get_n_states () const

function get_n_tools¶

Number of tools in the model.

inline size_t Model::get_n_tools () const

function get_n_viruses¶

Number of viruses in the model.

inline size_t Model::get_n_viruses () const

function get_name¶

inline std::string Model::get_name () const

function get_ndays¶

inline epiworld_fast_uint Model::get_ndays () const

function get_param¶

inline epiworld_double Model::get_param (
    std::string pname
)

function get_queue¶

Retrieve the Queue object.

inline Queue < TSeq > & Model::get_queue ()

function get_rand_endgine¶

inline std::shared_ptr< epi_xoshiro256ss > & Model::get_rand_endgine ()

function get_rewire_prop¶

inline epiworld_double Model::get_rewire_prop () const

function get_sim_id¶

inline size_t Model::get_sim_id () const

function get_state_fun¶

inline const std::vector< UpdateFun < TSeq > > & Model::get_state_fun () const

function get_states¶

inline const std::vector< std::string > & Model::get_states () const

function get_tool [1/2]¶

inline Tool < TSeq > & Model::get_tool (
    size_t id
)

function get_tool [2/2]¶

inline Tool < TSeq > & Model::get_tool (
    std::string_view name
)

function get_tools¶

const std::vector< ToolPtr < TSeq > > & Model::get_tools () const

function get_user_data¶

inline UserData < TSeq > & Model::get_user_data ()

function get_verbose¶

inline bool Model::get_verbose () const

function get_virus [1/2]¶

inline Virus < TSeq > & Model::get_virus (
    size_t id
)

function get_virus [2/2]¶

inline Virus < TSeq > & Model::get_virus (
    std::string_view name
)

function get_viruses¶

inline const std::vector< VirusPtr < TSeq > > & Model::get_viruses () const

function has_tool¶

inline bool Model::has_tool (
    std::string_view name
) const

function has_virus¶

inline bool Model::has_virus (
    std::string_view name
) const

function initial_states¶

inline virtual Model < TSeq > & Model::initial_states (
    std::vector< double >,
    std::vector< int >
)

function is_directed¶

inline bool Model::is_directed () const

function is_queuing_on¶

Query if the queuing system is on.

inline bool Model::is_queuing_on () const

function load_agents_entities_ties [1/3]¶

Associate agents-entities from a file.

inline void Model::load_agents_entities_ties (
    std::string fn,
    int skip
)

The structure of the file should be two columns separated by space. The first column indexing between 0 and nagents-1, and the second column between 0 and nentities - 1.

Parameters:

fn Path to the file.
skip How many rows to skip.

function load_agents_entities_ties [2/3]¶

Associate agents-entities from data.

inline void Model::load_agents_entities_ties (
    const std::vector< int > & agents_ids,
    const std::vector< int > & entities_ids
)

function load_agents_entities_ties [3/3]¶

inline void Model::load_agents_entities_ties (
    const int * agents_id,
    const int * entities_id,
    size_t n
)

function mutate_virus¶

inline void Model::mutate_virus ()

function next¶

inline virtual void Model::next ()

function operator!=¶

inline bool Model::operator!= (
    const Model < TSeq > & other
) const

function operator()¶

inline epiworld_double Model::operator() (
    std::string pname
)

function operator=¶

inline Model < TSeq > & Model::operator= (
    const Model < TSeq > & m
)

function operator==¶

inline bool Model::operator== (
    const Model < TSeq > & other
) const

function par¶

inline epiworld_double Model::par (
    std::string pname
) const

function params¶

inline std::map< std::string, epiworld_double > & Model::params ()

function print¶

inline const Model < TSeq > & Model::print (
    bool lite=false
) const

function print_state_codes¶

inline void Model::print_state_codes () const

function queuing_off¶

Deactivates the queuing system.

inline Model < TSeq > & Model::queuing_off ()

function queuing_on¶

Activates the queuing system (default.)

inline void Model::queuing_on ()

function rbinom [1/2]¶

inline int Model::rbinom ()

function rbinom [2/2]¶

inline int Model::rbinom (
    int n,
    epiworld_double p
)

function read_params¶

inline Model < TSeq > & Model::read_params (
    std::string fn,
    bool overwrite=false
)

function record_hospitalization¶

Record a hospitalization event for an agent.

inline void Model::record_hospitalization (
    Agent < TSeq > & agent
)

Parameters:

agent Reference to the agent being hospitalized.

This is a wrapper for DataBase::record_hospitalization(). For each hospitalization, the method records: * The current date from the model * The virus ID from the agent's virus * For each tool the agent has, a separate record with weight = 1/N where N is the number of tools * If the agent has no tools, a single record with tool_id = -1 and weight = 1.0

function reset¶

Reset the model.

inline virtual void Model::reset ()

Resetting the model will: * clear the database * restore the population (if set_backup() was called before) * re-distribute tools * re-distribute viruses * set the date to 0

function rewire¶

inline void Model::rewire ()

function rexp [1/2]¶

inline epiworld_double Model::rexp ()

function rexp [2/2]¶

inline epiworld_double Model::rexp (
    epiworld_double lambda
)

function rgamma [1/2]¶

inline epiworld_double Model::rgamma ()

function rgamma [2/2]¶

inline epiworld_double Model::rgamma (
    epiworld_double alpha,
    epiworld_double beta
)

function rgeom [1/2]¶

inline int Model::rgeom ()

function rgeom [2/2]¶

inline int Model::rgeom (
    epiworld_double p
)

function rlognormal [1/2]¶

inline epiworld_double Model::rlognormal ()

function rlognormal [2/2]¶

inline epiworld_double Model::rlognormal (
    epiworld_double mean,
    epiworld_double shape
)

function rm_entity¶

inline void Model::rm_entity (
    size_t entity_id
)

function rm_globalevent [1/2]¶

Remove a global action by name.

inline void Model::rm_globalevent (
    std::string name
)

function rm_globalevent [2/2]¶

Remove a global action by index.

inline void Model::rm_globalevent (
    size_t i
)

function rm_tool¶

inline void Model::rm_tool (
    size_t tool_pos
)

function rm_virus¶

inline void Model::rm_virus (
    size_t virus_pos
)

function rnbinom [1/2]¶

inline int Model::rnbinom ()

function rnbinom [2/2]¶

inline int Model::rnbinom (
    int n,
    epiworld_double p
)

function rnorm [1/2]¶

inline epiworld_double Model::rnorm ()

function rnorm [2/2]¶

inline epiworld_double Model::rnorm (
    epiworld_double mean,
    epiworld_double sd
)

function rpoiss [1/2]¶

inline int Model::rpoiss ()

function rpoiss [2/2]¶

inline int Model::rpoiss (
    epiworld_double lambda
)

function run¶

Runs the simulation (after initialization)

inline virtual Model < TSeq > & Model::run (
    epiworld_fast_uint ndays,
    int seed=-1
)

function run_globalevents¶

inline void Model::run_globalevents ()

function run_multiple¶

inline Model < TSeq > & Model::run_multiple (
    epiworld_fast_uint ndays,
    epiworld_fast_uint nexperiments,
    int seed_=-1,
    std::function< void(size_t, Model < TSeq > *)> fun=make_save_run < TSeq >(),
    bool reset=true,
    bool verbose=true,
    int nthreads=1
)

function runif [1/2]¶

inline epiworld_double Model::runif ()

function runif [2/2]¶

inline epiworld_double Model::runif (
    epiworld_double a,
    epiworld_double b
)

function runif_int¶

inline int Model::runif_int (
    int a,
    int b
)

function sample_from_probs¶

Sample from a set of probabilities stored in array_double_tmp.

inline size_t Model::sample_from_probs (
    size_t n
)

Uses a cumulative probability approach: draws a uniform random number and walks through array_double_tmp[0..n-1], accumulating probabilities until the draw is exceeded. If no event fires, returns n (meaning "none of the above").

Parameters:

n Number of probability entries in array_double_tmp to consider.

Returns:

Index in [0, n] of the sampled event (n = no event).

function seed¶

inline void Model::seed (
    size_t s
)

function set_agents_data¶

Set the agents data object.

inline void Model::set_agents_data (
    double * data_,
    size_t ncols_
)

The data should be an array with the data stored in a column major order, i.e., by column.

Parameters:

data_ Pointer to the first element of an array of size size() * ncols_.
ncols_ Number of features included in the data.

function set_backup¶

inline void Model::set_backup ()

function set_name¶

Set the name object.

inline void Model::set_name (
    std::string name
)

Parameters:

name

function set_ndays¶

inline void Model::set_ndays (
    epiworld_fast_uint ndays
)

function set_param¶

inline void Model::set_param (
    std::string pname,
    epiworld_double val
)

function set_rand_binom¶

inline void Model::set_rand_binom (
    int n,
    epiworld_double p
)

function set_rand_engine¶

inline void Model::set_rand_engine (
    std::shared_ptr< epi_xoshiro256ss > & eng
)

function set_rand_exp¶

inline void Model::set_rand_exp (
    epiworld_double lambda
)

function set_rand_gamma¶

inline void Model::set_rand_gamma (
    epiworld_double alpha,
    epiworld_double beta
)

function set_rand_geom¶

inline void Model::set_rand_geom (
    epiworld_double p
)

function set_rand_lognormal¶

inline void Model::set_rand_lognormal (
    epiworld_double mean,
    epiworld_double shape
)

function set_rand_nbinom¶

inline void Model::set_rand_nbinom (
    int n,
    epiworld_double p
)

function set_rand_norm¶

inline void Model::set_rand_norm (
    epiworld_double mean,
    epiworld_double sd
)

function set_rand_poiss¶

inline void Model::set_rand_poiss (
    epiworld_double lambda
)

function set_rand_unif¶

inline void Model::set_rand_unif (
    epiworld_double a,
    epiworld_double b
)

function set_rewire_fun¶

inline void Model::set_rewire_fun (
    std::function< void(std::vector< Agent < TSeq > > *, Model < TSeq > *, epiworld_double )> fun
)

function set_rewire_prop¶

inline void Model::set_rewire_prop (
    epiworld_double prop
)

function set_user_data¶

[@

inline void Model::set_user_data (
    std::vector< std::string > names
)

function size¶

inline size_t Model::size () const

function state_of¶

inline epiworld_fast_int Model::state_of (
    std::string_view name
)

function today¶

The current time of the model.

inline int Model::today () const

function update_state¶

inline void Model::update_state ()

function verbose_off¶

inline Model < TSeq > & Model::verbose_off ()

function verbose_on¶

inline Model < TSeq > & Model::verbose_on ()

function write_data¶

Wrapper of DataBase::write_data __

inline void Model::write_data (
    std::string fn_virus_info,
    std::string fn_virus_hist,
    std::string fn_tool_info,
    std::string fn_tool_hist,
    std::string fn_total_hist,
    std::string fn_transmission,
    std::string fn_transition,
    std::string fn_reproductive_number,
    std::string fn_generation_time,
    std::string fn_active_cases,
    std::string fn_outbreak_size,
    std::string fn_hospitalizations
) const

Parameters:

fn_virus_info Filename. Information about the virus.
fn_virus_hist Filename. History of the virus.
fn_tool_info Filename. Information about the tool.
fn_tool_hist Filename. History of the tool.
fn_total_hist Filename. Aggregated history (state)
fn_transmission Filename. Transmission history.
fn_transition Filename. Markov transition history.
fn_reproductive_number Filename. Case by case reproductive number
fn_generation_time Filename. Generation time data.
fn_active_cases Filename. Active cases data.
fn_outbreak_size Filename. Outbreak size data.
fn_hospitalizations Filename. Hospitalization data.

function write_edgelist [1/2]¶

inline void Model::write_edgelist (
    std::string fn
) const

function write_edgelist [2/2]¶

inline void Model::write_edgelist (
    std::vector< int > & source,
    std::vector< int > & target
) const

function ~Model¶

inline virtual Model::~Model ()

Protected Attributes Documentation¶

variable agents_data¶

double* Model< TSeq >::agents_data;

variable agents_data_ncols¶

size_t Model< TSeq >::agents_data_ncols;

variable current_date¶

int Model< TSeq >::current_date;

variable db¶

DataBase<TSeq> Model< TSeq >::db;

variable directed¶

bool Model< TSeq >::directed;

variable engine¶

std::shared_ptr< epi_xoshiro256ss > Model< TSeq >::engine;

variable entities¶

std::vector< Entity<TSeq> > Model< TSeq >::entities;

variable events¶

Variables used to keep track of the events to be made regarding viruses.

std::vector< Event<TSeq> > Model< TSeq >::events;

variable globalevents¶

std::vector<GlobalEventPtr<TSeq> > Model< TSeq >::globalevents;

variable initial_states_fun¶

std::function<void(Model<TSeq>*)> Model< TSeq >::initial_states_fun;

Function to distribute states. Goes along with the function

variable last_seed¶

int Model< TSeq >::last_seed;

variable n_replicates¶

epiworld_fast_uint Model< TSeq >::n_replicates;

variable nactions¶

epiworld_fast_uint Model< TSeq >::nactions;

variable name¶

Name of the model.

std::string Model< TSeq >::name;

variable ndays¶

epiworld_fast_uint Model< TSeq >::ndays;

variable nstates¶

epiworld_fast_uint Model< TSeq >::nstates;

variable parameters¶

std::map<std::string, epiworld_double > Model< TSeq >::parameters;

variable pb¶

Progress Model< TSeq >::pb;

variable population¶

std::vector< Agent<TSeq> > Model< TSeq >::population;

variable population_backup¶

std::vector< Agent<TSeq> > Model< TSeq >::population_backup;

variable population_left¶

std::vector< size_t > Model< TSeq >::population_left;

variable population_left_n¶

size_t Model< TSeq >::population_left_n;

variable queue¶

Queue<TSeq> Model< TSeq >::queue;

variable rbinomd¶

std::binomial_distribution Model< TSeq >::rbinomd;

variable rewire_fun¶

std::function<void(std::vector<Agent<TSeq>>*,Model<TSeq>*,epiworld_double)> Model< TSeq >::rewire_fun;

variable rewire_prop¶

epiworld_double Model< TSeq >::rewire_prop;

variable rexpd¶

std::exponential_distribution Model< TSeq >::rexpd;

variable rgammad¶

std::gamma_distribution Model< TSeq >::rgammad;

variable rgeomd¶

std::geometric_distribution Model< TSeq >::rgeomd;

variable rlognormald¶

std::lognormal_distribution Model< TSeq >::rlognormald;

variable rnbinomd¶

std::negative_binomial_distribution Model< TSeq >::rnbinomd;

variable rnormd¶

std::normal_distribution Model< TSeq >::rnormd;

variable rpoissd¶

std::poisson_distribution Model< TSeq >::rpoissd;

variable runifd_a¶

epiworld_double Model< TSeq >::runifd_a;

variable runifd_b¶

epiworld_double Model< TSeq >::runifd_b;

variable sampled_population¶

std::vector< Agent<TSeq> * > Model< TSeq >::sampled_population;

variable sampled_population_n¶

size_t Model< TSeq >::sampled_population_n;

variable sim_id¶

size_t Model< TSeq >::sim_id;

variable state_fun¶

Functions to update states.

std::vector< UpdateFun<TSeq> > Model< TSeq >::state_fun;

variable states_labels¶

Labels of the states.

std::vector< std::string > Model< TSeq >::states_labels;

variable time_elapsed¶

std::chrono::duration<epiworld_double,std::micro> Model< TSeq >::time_elapsed;

variable time_end¶

std::chrono::time_point<std::chrono::steady_clock> Model< TSeq >::time_end;

variable time_start¶

std::chrono::time_point<std::chrono::steady_clock> Model< TSeq >::time_start;

variable tools¶

std::vector< ToolPtr<TSeq> > Model< TSeq >::tools;

variable use_queuing¶

bool Model< TSeq >::use_queuing;

variable using_backup¶

bool Model< TSeq >::using_backup;

variable verbose¶

bool Model< TSeq >::verbose;

variable viruses¶

std::vector< VirusPtr<TSeq> > Model< TSeq >::viruses;

Protected Functions Documentation¶

function _add_event¶

Construct a new Event object.

inline void Model::_add_event (
    Agent < TSeq > * agent_,
    VirusPtr < TSeq > virus_,
    ToolPtr < TSeq > tool_,
    Entity < TSeq > * entity_,
    epiworld_fast_int new_state_,
    epiworld_fast_int queue_,
    EventAction action_
)

Parameters:

agent_ Agent over which the action will be called
virus_ Virus pointer included in the action
tool_ Tool pointer included in the action
entity_ Entity pointer included in the action
new_state_ New state of the agent
queue_ Change in the queue
action_ Action to execute when processing the event

function _event_add_entity¶

inline void Model::_event_add_entity (
    Event < TSeq > & a
)

function _event_add_tool¶

inline void Model::_event_add_tool (
    Event < TSeq > & a
)

function _event_add_virus¶

inline void Model::_event_add_virus (
    Event < TSeq > & a
)

function _event_change_state¶

inline void Model::_event_change_state (
    Event < TSeq > & a
)

function _event_rm_entity¶

inline void Model::_event_rm_entity (
    Event < TSeq > & a
)

function _event_rm_tool¶

inline void Model::_event_rm_tool (
    Event < TSeq > & a
)

function _event_rm_virus¶

inline void Model::_event_rm_virus (
    Event < TSeq > & a
)

function chrono_end¶

inline void Model::chrono_end ()

function chrono_start¶

inline void Model::chrono_start ()

function clone_ptr¶

Advanced usage: Makes a copy of data and returns it as undeleted pointer.

inline virtual std::unique_ptr< Model < TSeq > > Model::clone_ptr ()

Parameters:

copy

function death_reduction_mixer¶

inline virtual epiworld_double Model::death_reduction_mixer (
    Agent < TSeq > * agent,
    VirusPtr < TSeq > & virus
)

function dist_entities¶

inline void Model::dist_entities ()

function dist_tools¶

inline void Model::dist_tools ()

function dist_virus¶

inline void Model::dist_virus ()

function recovery_enhancer_mixer¶

inline virtual epiworld_double Model::recovery_enhancer_mixer (
    Agent < TSeq > * agent,
    VirusPtr < TSeq > & virus
)

function set_sim_id¶

inline void Model::set_sim_id (
    size_t id
)

function susceptibility_reduction_mixer¶

inline virtual epiworld_double Model::susceptibility_reduction_mixer (
    Agent < TSeq > * agent,
    VirusPtr < TSeq > & virus
)

function transmission_reduction_mixer¶

inline virtual epiworld_double Model::transmission_reduction_mixer (
    Agent < TSeq > * agent,
    VirusPtr < TSeq > & virus
)

The documentation for this class was generated from the following file epiworld-src/include/epiworld/model-bones.hpp