Class ModelSIRLogit

template <typename TSeq>

ClassList > ModelSIRLogit

Template for a Susceptible-Infected-Removed (SIR) model. More...

• #include <sirlogit.hpp>

Inherits the following classes: Model

Public Attributes

Type	Name
std::vector< size_t >	coef_infect_cols
std::vector< size_t >	coef_recover_cols
std::vector< double >	coefs_infect
std::vector< double >	coefs_recover

Public Attributes inherited from Model

See Model

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

Public Functions

Type	Name
	ModelSIRLogit ()
	ModelSIRLogit (const std::string & vname, double * data, size_t ncols, std::vector< double > coefs_infect, std::vector< double > coefs_recover, std::vector< size_t > coef_infect_cols, std::vector< size_t > coef_recover_cols, epiworld_double transmission_rate, epiworld_double recovery_rate, epiworld_double prevalence) Template for a Susceptible-Infected-Removed (SIR) model.
virtual std::unique_ptr< Model< TSeq > >	clone_ptr () override Advanced usage: Makes a copy of data and returns it as undeleted pointer.
virtual void	reset () override Reset the model.

Public Functions inherited from Model

See Model

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 inherited from Model

See Model

Type	Name
double *	agents_data = nullptr
size_t	agents_data_ncols = 0u
int	current_date = 0
DataBase< TSeq >	db = [**DataBase**](classDataBase.md)&lt;TSeq&gt;(\*this)
bool	directed = false
std::shared_ptr< epi_xoshiro256ss >	engine = std::make\_shared&lt; [**epi\_xoshiro256ss**](classepi__xoshiro256ss.md) &gt;()
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 inherited from Model

See Model

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

In this model, infection and recoveru probabilities are computed using a logit model. Particularly, the probability of infection is computed as:

[[ \frac{1}{1 + \exp\left(-\left(\beta_0 E_i + \sum_{i=1}^{n} \beta_i x_i\right)\right)} ]]

where \(\beta_0\) is the exposure coefficient and \(E_i\) is the exposure number, \(\beta_i\) are the coefficients for the features \(x_i\) of the agents, and \(n\) is the number of features. The probability of recovery is computed as:

[[ \frac{1}{1 + \exp\left(-\left(\sum_{i=1}^{n} \beta_i x_i\right)\right)} ]]

where \(\beta_i\) are the coefficients for the features \(x_i\) of the agents, and \(n\) is the number of features.

Parameters:

• TSeq Type of the sequence (e.g. std::vector, std::deque)

Public Attributes Documentation

variable coef_infect_cols

std::vector< size_t > ModelSIRLogit< TSeq >::coef_infect_cols;

---

variable coef_recover_cols

std::vector< size_t > ModelSIRLogit< TSeq >::coef_recover_cols;

---

variable coefs_infect

std::vector< double > ModelSIRLogit< TSeq >::coefs_infect;

---

variable coefs_recover

std::vector< double > ModelSIRLogit< TSeq >::coefs_recover;

---

Public Functions Documentation

function ModelSIRLogit [1/2]

inline ModelSIRLogit::ModelSIRLogit () 

---

function ModelSIRLogit [2/2]

Template for a Susceptible-Infected-Removed (SIR) model.

inline ModelSIRLogit::ModelSIRLogit (
    const std::string & vname,
    double * data,
    size_t ncols,
    std::vector< double > coefs_infect,
    std::vector< double > coefs_recover,
    std::vector< size_t > coef_infect_cols,
    std::vector< size_t > coef_recover_cols,
    epiworld_double transmission_rate,
    epiworld_double recovery_rate,
    epiworld_double prevalence
) 

Parameters:

• vname Name of the virus.
• coefs_infect Double ptr. Infection coefficients.
• coefs_recover Double ptr. Recovery coefficients.
• ncoef_infect Unsigned int. Number of infection coefficients.
• ncoef_recover Unsigned int. Number of recovery coefficients.
• coef_infect_cols Vector<unsigned int>. Ids of infection vars.
• coef_recover_cols Vector<unsigned int>. Ids of recover vars.
• model A Model<TSeq> object where to set up the SIR.
• vname std::string Name of the virus
• prevalence Initial prevalence (proportion)
• contact_rate Average number of contacts (interactions) per step.
• prob_transmission Probability of transmission
• prob_recovery Probability of recovery

---

function clone_ptr

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

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

Parameters:

• copy

Implements Model::clone_ptr

---

function reset

Reset the model.

inline virtual void ModelSIRLogit::reset () override

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

Implements Model::reset

---

---

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