Function reference • exDE

Blood Feeding and Transmission

Methods to compute the transmission terms

Transmission(): Compute the mixing matrix and transmission terms

LocalFrac(): Compute the local fraction

AvailableBlood(): Update the availability of blood hosts

Transmision

Specialized methods to compute the transmission terms

Transmission(<static>): Compute transmission terms dynamically, no update required

Transmission(<dynamic>): Compute transmission terms, the dynamic case

Transmission(<setup>): Compute transmission terms, the dynamic case

F_beta(): Compute beta, the biting distribution matrix

compute_beta(): Compute beta

F_EIR(): Entomological inoculation rate on human strata

compute_EIR(): Compute EIR

compute_EIR_full(): Compute EIR for each vector-host pair

F_kappa(): Net infectiousness of human population to mosquitoes

compute_kappa(): Compute kappa

Blood Feeding

Method to set up the blood feeding model

setup_BFpar_static(): Set up the blood feeding model

setup_BloodFeeding(): Set up blood feeding

make_TaR(): Make TaR

Time Spent and Time at Risk

Method to set up time spent and time at risk (TaR) matrices

make_TimeSpent(): Make a time spent matrix, called TimeSpent

make_TimeSpent(<athome>): Make a mosquito dispersal matrix, called TimeSpent with a here / away

make_TimeSpent_athome(): Make a mosquito dispersal matrix, called TimeSpent

make_TimeSpent(<as_matrix>): Pass a pre-configured TimeSpent

make_TimeSpent(<xy>): Develop a mosquito dispersal matrix from a kernel and xy-coordinates

make_TimeSpent_xy(): Make a mosquito dispersal matrix, called TimeSpent

Availability of humans / hosts

Specialized methods to compute available humans / hosts

AvailableBlood(<static>): Compute availability of local humans for blood feeding

AvailableBlood(<setup>): Compute availability of local humans for blood feeding

AvailableBlood(<forced>): Compute availability of local humans for blood feeding

compute_AvailableHosts(): Compute availability blood hosts of the i^th species

Exposure

Methods to model the force of infection

Exposure(): Exposure and Infection

F_foi(): A model for daily FoI as a function of the daily EIR.

Poisson Exposure

Specialized methods the Poisson exposure model

F_foi(<pois>): A Poisson model for the daily local FoI as a function of the daily EIR.

setup_exposure_pois(): Make parameters for the null model of exposure

Negative Binomial Exposure

Specialized methods the Negative Binomial exposure model

F_foi(<nb>): The daily FoI as a function of the daily EIR under a negative binomial model of exposure.

setup_exposure_nb(): Make parameters for the null model of exposure

Local Fraction

Specialized methods for NULL dynamics: a funtion generates values of Z to force human infection dynamics

LocalFrac(<static>): Compute transmission terms dynamically, no update required

LocalFrac(<dynamic>): Compute transmission terms dynamically, no update required

compute_local_frac(): Compute the local fraction

setup_local_fraction_simple(): Set up the local_fraction for static models

Egg Laying & Emergence

Generic methods for the aquatic (immature) mosquito component.

Emergence(): Compute emerging adults

make_calN(): Make the habitat membership matrix, calN

EggLaying(): Compute eggs laid

EggLaying(<static>): Compute eggs laid

EggLaying(<dynamic>): Compute eggs laid

EggLaying(<simple>): Compute eggs laid

EggLaying(<setup>): Compute eggs laid

compute_calU(): Compute calU

compute_EggsLaid(): Compute eggs laid

make_calU(): Make the egg distribution matrix, calU

make_calU_s(): Make the egg distribution matrix, calU

setup_EggLaying_static(): Setup egg laying for most models

setup_EggLaying_simple(): Setup egg laying for most models

setup_EGGpar_static(): Setup the structures required for egg laying

Adult Mosquito Dynamics

Generic methods for the adult mosquito dynamics component.

MBionomics(): Set bloodfeeding and mortality rates to baseline

F_fqZ(): Blood feeding rate of the infective mosquito population

F_fqM(): Blood feeding rate of the mosquito population

F_tau(): Time spent host seeking/feeding and resting/ovipositing

F_eggs(): Number of eggs laid by adult mosquitoes

dMYZdt(): Derivatives for adult mosquitoes

setup_MYZpar(): A function to set up adult mosquito models

setup_MYZinits(): A function to set up adult mosquito models

make_indices_MYZ(): Add indices for adult mosquitoes to parameter list

parse_deout_MYZ(): Parse the output of deSolve and return the variables by name in a list

get_inits_MYZ(): Return initial values as a vector

update_inits_MYZ(): Set the initial values as a vector

make_Omega(): Make the mosquito demography matrix

dde2ode_MYZ(): Convert a model from dde to the corresponding ode

dde2ode_MYZ(<dde>): Convert a model from dde to the corresponding ode

dde2ode_MYZ(<ode>): Convert a model from dde to the corresponding ode

xde_plot_M(): Plot adult mosquito population density

xde_lines_M(): Add lines for adult mosquito population density

xde_plot_YZ(): Plot the density of infected and infective mosquitoes

xde_lines_YZ(): Add lines for the density of infected and infective mosquitoes

xde_plot_YZ_fracs(): Plot the fraction of infected and infective mosquitoes

xde_lines_YZ_fracs(): Add lines for the fraction of infected and infective mosquitoes

xde_plot_Z_fracs(): Plot the fraction of infected and infective mosquitoes

xde_lines_Z_fracs(): Add lines for the fraction of infected and infective mosquitoes

EIP

Specialized methods for NULL dynamics: a funtion generates values of Z to force human infection dynamics

EIP(): Compute the EIP

EIP(<static>): Modify parameters due to exogenous forcing by all kinds of control

dEIPdt(): Compute the derivative of the EIP as a function of time

dEIPdt(<static>): This function computes the negative derivative of the EIP as a function of time

setup_EIP(): Set up the static model for control forcing (do nothing)

setup_EIP(<static>): Set up a static model for the EIP

setup_eip_static(): Set up a static model for the EIP

Ztrace

Specialized methods for NULL dynamics: a funtion generates values of Z to force human infection dynamics

MBionomics(<Ztrace>): Compute bloodfeeding and mortality rates

F_fqZ(<Ztrace>): Blood feeding rate of the infective mosquito population

F_fqM(<Ztrace>): Blood feeding rate of the infective mosquito population

F_eggs(<Ztrace>): Number of eggs laid by adult mosquitoes

dMYZdt(<Ztrace>): Derivatives for aquatic stage mosquitoes

setup_MYZpar(<Ztrace>): Setup the Ztrace model

setup_MYZinits(<Ztrace>): Setup the Ztrace model

make_MYZpar_Ztrace(): Make parameters for Ztrace aquatic mosquito model

make_indices_MYZ(<Ztrace>): Add indices for aquatic stage mosquitoes to parameter list

parse_deout_MYZ(<Ztrace>): Parse the output of deSolve and return variables for the Ztrace model

make_inits_MYZ_Ztrace(): Make parameters for Ztrace aquatic mosquito model

get_inits_MYZ(<Ztrace>): Return initial values as a vector

update_inits_MYZ(<Ztrace>): Update inits for Ztrace

make_parameters_MYZ_Ztrace(): Make parameters for Ztrace aquatic mosquito model

Gtrace

Specialized methods for NULL dynamics: a funtion generates values for eggs laid to aquatic ecology

MBionomics(<Gtrace>): Compute bloodfeeding and mortality rates

F_fqZ(<Gtrace>): Blood feeding rate of the infective mosquito population

F_fqM(<Gtrace>): Blood feeding rate of the infective mosquito population

F_eggs(<Gtrace>): Number of eggs laid by adult mosquitoes

dMYZdt(<Gtrace>): Derivatives for aquatic stage mosquitoes

setup_MYZpar(<Gtrace>): Setup the Gtrace

setup_MYZinits(<Gtrace>): Setup the Gtrace model

make_MYZpar_Gtrace(): Make parameters for Gtrace aquatic mosquito model

make_indices_MYZ(<Gtrace>): Add indices for aquatic stage mosquitoes to parameter list

parse_deout_MYZ(<Gtrace>): Parse the output of deSolve and return variables for the Gtrace model

make_inits_MYZ_Gtrace(): Make parameters for Gtrace aquatic mosquito model

get_inits_MYZ(<Gtrace>): Return initial values as a vector

update_inits_MYZ(<Gtrace>): Update inits for Gtrace

make_parameters_MYZ_Gtrace(): Make parameters for Gtrace aquatic mosquito model

basicM

Specialized methods for basicM, a model of adult mosquito dynamics with no parasite infection dynamics.

MBionomics(<basicM>): Set bionomic parameters to baseline

F_fqZ(<basicM>): The net blood feeding rate of the infective mosquito population in a patch

F_fqM(<basicM>): The net blood feeding rate of the mosquito population in a patch

F_eggs(<basicM>): Number of eggs laid by adult mosquitoes

dMYZdt(<basicM>): Derivatives for adult mosquitoes

setup_MYZpar(<basicM>): Setup MYZpar for the basicM model

setup_MYZinits(<basicM>): Setup the basicM model

make_MYZpar_basicM(): Make parameters for basicM ODE adult mosquito model

make_MYZinits_basicM(): Make inits for basicM adult mosquito model

make_indices_MYZ(<basicM>): Add indices for adult mosquitoes to parameter list

parse_deout_MYZ(<basicM>): Parse the output of deSolve and return variables for the basicM model

make_inits_MYZ_basicM(): Make inits for basicM adult mosquito model

get_inits_MYZ(<basicM>): Return initial values as a vector

update_inits_MYZ(<basicM>): Make inits for RM adult mosquito model

make_parameters_MYZ_basicM(): Make parameters for a basic adult mosquito model

RM

Specialized methods for a Ross-Macdonald-style model of adult mosquito dynamics, modified slightly from a model published by Joan Aron & Robert May (1982).

MBionomics(<RM>): Reset bloodfeeding and mortality rates to baseline

F_fqZ(<RM>): The net blood feeding rate of the infective mosquito population in a patch

F_fqM(<RM>): The net blood feeding rate of the infective mosquito population in a patch

F_eggs(<RM>): Number of eggs laid by adult mosquitoes

dMYZdt(<RM_ode>): Derivatives for adult mosquitoes

dMYZdt(<RM_dde>): Derivatives for adult mosquitoes

setup_MYZpar(<RM>): Setup MYZpar for the RM model

setup_MYZinits(<RM>): Setup initial values for the RM model

make_MYZpar_RM(): Make parameters for RM ODE adult mosquito model

make_MYZinits_RM_ode(): Make inits for RM adult mosquito model

make_MYZinits_RM_dde(): Make inits for RM adult mosquito model

make_indices_MYZ(<RM_ode>): Add indices for adult mosquitoes to parameter list

make_indices_MYZ(<RM_dde>): Add indices for adult mosquitoes to parameter list

parse_deout_MYZ(<RM>): Parse the output of deSolve and return variables for the RM model

make_inits_MYZ_RM_ode(): Make inits for RM adult mosquito model

make_inits_MYZ_RM_dde(): Make inits for RM adult mosquito model

get_inits_MYZ(<RM_ode>): Return initial values as a vector

get_inits_MYZ(<RM_dde>): Return initial values as a vector

update_inits_MYZ(<RM_ode>): Make inits for RM adult mosquito model

update_inits_MYZ(<RM_dde>): Update inits for RM adult mosquito model

make_parameters_MYZ_RM(): Make parameters for RM ODE adult mosquito model

GeRM

Specialized methods for a generalized Ross-Macdonald model for adult mosquito ecology and parasite infection dynamics, first published by Sean L Wu, et al.(2023).

MBionomics(<GeRM>): Reset bloodfeeding and mortality rates to baseline

F_fqZ(<GeRM>): Blood feeding rate of the infective mosquito population

F_fqM(<GeRM>): Blood feeding rate of the infective mosquito population

F_eggs(<GeRM>): Number of eggs laid by adult mosquitoes

dMYZdt(<GeRM_ode>): Derivatives for adult mosquitoes

dMYZdt(<GeRM_dde>): Derivatives for adult mosquitoes

setup_MYZpar(<GeRM>): Setup MYZpar for the GeRM model

setup_MYZinits(<GeRM>): Setup the GeRM model

make_MYZpar_GeRM(): Make parameters for GeRM ODE adult mosquito model

make_MYZinits_GeRM_ode(): Make inits for GeRM adult mosquito model

make_MYZinits_GeRM_dde(): Make inits for GeRM adult mosquito model

make_indices_MYZ(<GeRM_ode>): Add indices for adult mosquitoes to parameter list

make_indices_MYZ(<GeRM_dde>): Add indices for adult mosquitoes to parameter list

parse_deout_MYZ(<GeRM>): Parse the output of deSolve and return variables for the GeRM model

make_inits_MYZ_GeRM_ode(): Make inits for GeRM adult mosquito model

make_inits_MYZ_GeRM_dde(): Make inits for GeRM adult mosquito model

get_inits_MYZ(<GeRM_ode>): Return initial values as a vector

get_inits_MYZ(<GeRM_dde>): Return initial values as a vector

update_inits_MYZ(<GeRM_ode>): Make inits for GeRM adult mosquito model

update_inits_MYZ(<GeRM_dde>): Update the initial values for GeRM adult mosquito model

make_parameters_MYZ_GeRM(): Make parameters for GeRM ODE adult mosquito model

Aquatic Mosquito Dynamics

Generic methods for the aquatic (immature) mosquito component.

LBionomics(): Set aquatic bionomic parameter rates relative to baseline

F_alpha(): Number of newly emerging adults from each larval habitat

dLdt(): Derivatives for aquatic stage mosquitoes

setup_Lpar(): A function to set up adult mosquito models

setup_Linits(): A function to set up adult mosquito models

make_indices_L(): Add indices for aquatic stage mosquitoes to parameter list

parse_deout_L(): Parse the output of deSolve and return the variables by name in a list

get_inits_L(): Return initial values as a vector

update_inits_L(): Set the initial values from a vector of model states

trace

Specialized methods for the exogeneously forced trace model of aquatic mosquito dynamics.

LBionomics(<trace>): Reset aquatic parameters to baseline

F_alpha(<trace>): Number of newly emerging adults from each larval habitat

dLdt(<trace>): Derivatives for aquatic stage mosquitoes

setup_Lpar(<trace>): Setup Lpar for the trace model

setup_Linits(<trace>): Setup the trace model

make_Lpar_trace(): Make parameters for trace aquatic mosquito model

make_indices_L(<trace>): Add indices for aquatic stage mosquitoes to parameter list

parse_deout_L(<trace>): Parse the variable names for the trace model

make_inits_L_trace(): Make parameters for trace aquatic mosquito model

get_inits_L(<trace>): Return initial values as a vector

update_inits_L(<trace>): Update inits for the basic aquatic mosquito competition model

make_parameters_L_trace(): Make parameters for trace aquatic mosquito model

basic

Specialized methods for a basic competition model of aquatic mosquito dynamics.

LBionomics(<basic>): Reset aquatic parameters to baseline

F_alpha(<basic>): Number of newly emerging adults from each larval habitat

dLdt(<basic>): Derivatives for aquatic stage mosquitoes

setup_Lpar(<basic>): Setup Lpar for the basic model

setup_Linits(<basic>): Setup the basic model

make_Lpar_basic(): Make parameters for basic competition aquatic mosquito model

make_Linits_basic(): Make inits for basic competition aquatic mosquito model

make_indices_L(<basic>): Add indices for aquatic stage mosquitoes to parameter list

parse_deout_L(<basic>): Parse the variable names for the basic model

make_inits_L_basic(): Make inits for basic competition aquatic mosquito model

get_inits_L(<basic>): Return initial values as a vector

update_inits_L(<basic>): Update inits for the basic aquatic mosquito competition model

make_parameters_L_basic(): Make parameters for basic competition aquatic mosquito model

Mosquito Bionomics

Methods to compute or update mosquito bionomic parameters

Bionomics(): Set bionomic parameter rates relative to baseline

Bionomics(<static>): Set bionomic parameter rates relative to baseline

Bionomics(<dynamic>): Set bionomic parameter rates relative to baseline

Bionomics(<Ldynamic>): Set bionomic parameter rates relative to baseline

Bionomics(<Mdynamic>): Set bionomic parameter rates relative to baseline

Bionomics(<setup>): Set bionomic parameter rates relative to baseline

setup_bionomics_static(): Make parameters for the static model bionomics

Functional Responses

Compute bionomic parameters as functional responses to resource availability

F_sigma(): Compute mosquito emigration rates

F_sigma(<static>): Static model for mosquito emigration

F_sigma(<BQS>): Model for mosquito emigration based on resource availability

F_nu(): Compute the egg laying rate

F_nu(<static>): Static model for the egg laying rate

F_nu(<type2>): Type 2 functional response for the blood feeding rate

F_f(): Compute the blood feeding rate, f

F_f(<static>): Static model for the blood feeding rate

F_f(<type2>): Type 2 functional response for the blood feeding rate

F_q(): Compute the human blood fraction

F_q(<static>): Static model for human blood fraction

F_q(<dynamic>): Static model for human blood fraction

F_g(): Compute mosguito survival

F_g(<static>): Static model for mosquito survival

Mosquito Dispersal

Specialized methods to set up mosquito dispersal matrices

make_calK(): Make a mosquito dispersal matrix, called calK

make_calK(<herethere>): Dispersal to every other patch, with equal probability

make_calK(<as_matrix>): Pass a pre-configured calK

make_calK(<xy>): Develop a mosquito dispersal matrix from a kernel and xy-coordinates

make_calK_xy(): Develop a mosquito dispersal matrix from a kernel and xy-coordinates

Human Infection Dynamics

Generic methods for the dynamical component that handles human infection dynamics, immunity, disease and transmission

F_X(): Size of effective infectious human population

F_H(): Size of human population denominators

F_pr(): Compute the "true" prevalence of infection / parasite rate

F_b(): Infection blocking pre-erythrocytic immunity

dXdt(): Derivatives for human population

setup_Xpar(): A function to set up Xpar

setup_Xinits(): A function to set up Xpar

make_indices_X(): Add indices for human population to parameter list

parse_deout_X(): Parse the output of deSolve and return the variables by name in a list

get_inits_X(): Return initial values as a vector

update_inits_X(): Set the initial values from a vector of states

HTC(): Compute the human transmitting capacity

xde_plot_X(): Basic plotting for epidemiological models

trace

Specialized methods for a human trace model to pass kappa as a parameter

F_X(<trace>): Size of effective infectious human population

F_H(<trace>): Size of the human population

F_pr(<trace>): Compute the "true" prevalence of infection / parasite rate

F_b(<trace>): Infection blocking pre-erythrocytic immunity

dXdt(<trace>): Derivatives for human population

setup_Xpar(<trace>): Setup Xpar.trace

setup_Xinits(<trace>): Setup Xinits.trace

make_Xpar_trace(): Make parameters for human null model

make_indices_X(<trace>): Add indices for human population to parameter list

parse_deout_X(<trace>): Parse the output of deSolve and return variables for the trace model

make_inits_X_trace(): Make inits for trace human model

get_inits_X(<trace>): Return initial values as a vector

update_inits_X(<trace>): Update inits for the trace human model from a vector of states

make_parameters_X_trace(): Make parameters for trace human model

hMoI

Specialized methods for a hybrid model of MoI (Multiplicity of Infection) for human infection dynamics.

F_X(<hMoI>): Size of effective infectious human population

F_H(<hMoI>): Size of the human population

F_pr(<hMoI>): Compute the "true" prevalence of infection / parasite rate

F_b(<hMoI>): Infection blocking pre-erythrocytic immunity

dXdt(<hMoI>): Derivatives for human population

setup_Xpar(<hMoI>): Setup Xpar.hMoI

setup_Xinits(<hMoI>): Setup Xinits.hMoI

make_Xpar_hMoI(): Make parameters for hybrid MoI human model

make_Xinits_hMoI(): Make inits for hybrid MoI human model

make_indices_X(<hMoI>): Add indices for human population to parameter list

parse_deout_X(<hMoI>): Parse the output of deSolve and return variables for the hMoI model

make_inits_X_hMoI(): Make inits for hybrid MoI human model

get_inits_X(<hMoI>): Return initial values as a vector

update_inits_X(<hMoI>): Update inits for hybrid MoI human model from a vector of states

make_parameters_X_hMoI(): Make parameters for hybrid MoI human model

HTC(<hMoI>): Compute the HTC for the hMoI model

SIS

Specialized methods for the SIS (Susceptible-Infected-Susceptible) model of human dynamics.

F_X(<SIS>): Size of effective infectious human population

F_H(<SIS>): Size of effective infectious human population

F_pr(<SIS>): Compute the "true" prevalence of infection / parasite rate

F_b(<SIS>): Infection blocking pre-erythrocytic immunity

dXdt(<SIS>): Derivatives for human population

setup_Xpar(<SIS>): Setup Xpar.SIS

setup_Xinits(<SIS>): Setup Xinits.SIS

make_Xpar_SIS(): Make parameters for SIS human model, with defaults

make_Xinits_SIS(): Make initial values for the SIS human model, with defaults

make_indices_X(<SIS>): Add indices for human population to parameter list

parse_deout_X(<SIS>): Parse the output of deSolve and return variables for the SIS model

make_inits_X_SIS(): Make inits for SIS human model

get_inits_X(<SIS>): Return initial values as a vector

update_inits_X(<SIS>): Update inits for the SIS human model from a vector of states

make_parameters_X_SIS(): Make parameters for SIS human model

HTC(<SIS>): Compute the HTC for the SIS model

xde_plot_X(<SIS>): Plot the density of infected individuals for the SIS model

xde_lines_X_SIS(): Add lines for the density of infected individuals for the SIS model

SIP

Specialized methods for the SIP (Susceptible-Infected-Prophylaxis) model of human dynamics.

F_X(<SIP>): Size of effective infectious human population

F_H(<SIP>): Size of effective infectious human population

F_pr(<SIP>): Compute the "true" prevalence of infection / parasite rate

F_b(<SIP>): Infection blocking pre-erythrocytic immunity

dXdt(<SIP>): Derivatives for human population

setup_Xpar(<SIP>): Setup Xpar.SIP

setup_Xinits(<SIP>): Setup Xinits.SIP

make_Xpar_SIP(): Make parameters for SIP human model, with defaults

make_Xinits_SIP(): Make initial values for the SIP human model, with defaults

make_indices_X(<SIP>): Add indices for human population to parameter list

parse_deout_X(<SIP>): Parse the output of deSolve and return variables for the SIP model

make_inits_X_SIP(): Make inits for SIP human model

get_inits_X(<SIP>): Return initial values as a vector

update_inits_X(<SIP>): Update inits for the SIP human model from a vector of states

make_parameters_X_SIP(): Make parameters for SIP human model

HTC(<SIP>): Compute the HTC for the SIP model

xde_plot_X(<SIP>): Plot the density of infected individuals for the SIP model

xde_lines_X_SIP(): Add lines for the density of infected individuals for the SIP model

Human Population Dynamics

Generic methods for the human demography and aging

dHdt(): Derivatives of demographic changes in human populations

setup_Hpar_static(): A utility to set up Hpar

Births(): A function that computes the birth rate for human populations

make_parameters_demography_null(): Make parameters for null human demography model

static

Specialized methods for the static (constant) demographic model

Births(<zero>): Derivatives of demographic changes in human populations

dHdt(<zero>): Derivatives of demographic changes in human populations

Human and Mosquito Behaviors

Methods to implement human and Mosquito Behaviorsbehaviors

Behavior(): Methods for dynamic human and mosquito behaviors

Behavior(<null>): Methods for dynamic human and mosquito behaviors

Behavior(<forced>): Methods for dynamic human and mosquito behaviors

setup_behavior_null(): Make parameters for the null model for resource availability (do nothing)

setup_behavior_forced(): Make parameters for the forced model for resource availability (do nothing)

setup_behavior(): Setup behavior

setup_behavior(<null>): Setup behavior

setup_behavior(<forced>): Setup behavior

Care Seeking

Methods to implement care seeking

CareSeeking(): Set the values of exogenous variables describing care seeking

CareSeeking(<null>): Set the values of exogenous variables describing care seeking

setup_care_seeking_null(): Make parameters for the null model for care seeking (do nothing)

Imported Malaria

Methods to implement imported malaria

travel_malaria(): Simulate travel malaria

Visitors(): Visitors

Travel Malaria

Specialized methods for travel malaria

travel_malaria(<static>): travel, a static model

setup_travel_static(): A function to set up malaria importation

travel_malaria(<foi>): A model for the travel FoI

setup_travel_foi(): Set up parameters and function for the FoI-based travel_malaria model

travel_malaria(<eir>): A model for travel malaria based on the eir in destinations

setup_travel_eir(): Set up parameters and function for an eir-based travel_malaria model

Visitors

Methods for the availability and infectiousness of a visitor population

Visitors(<static>): Visitors, a static model

setup_visitors_static(): Make parameters for the static model visitors (no visitors)

Visitors(<basic>): Visitors, the basic model

setup_visitors_basic(): Make parameters and functions for the basic model for visitors

Exogeneous Forcing

Methods to implement exogeneous forcing.

Abiotic(): Set up exogenous variables for abiotic forcing

Civil(): Set up exogenous variables for civil forcing

Shock(): Set up shocks

Control(): Modify parameters due to exogenous forcing by all kinds of control

Clinic(): Methods for distributing interventions during clinical visits

Development(): Set up developments

MassMedical(): Methods for mass medical interventions

Models

Specialized methods the null model (no exogenous forcing)

Abiotic(<null>): Set up exogenous variables for abiotic forcing

setup_abiotic_null(): Set up the null model for exogenous forcing (do nothing)

Civil(<null>): Set up exogenous variables for civil forcing

setup_civil_null(): Set up the null model for exogenous forcing (do nothing)

Shock(<null>): Set up shocks

setup_shock_null(): Set up the null model for shocks (do nothing)

Control(<null>): Modify parameters due to exogenous forcing by all kinds of control

Control(<static>): Modify parameters due to exogenous forcing by all kinds of control

setup_control(): Setup CONTROL with forcing

setup_control_null(): Set up the null model for control forcing (do nothing)

setup_control(<null>): Setup control

setup_control(<forced>): Setup control

Clinic(<null>): Methods for distributing interventions during clinical visits

setup_clinic_null(): Set up the null model for clinical distribution (do nothing)

setup_clinic_forced(): Set up a model for clinic

Development(<null>): Set up developments

setup_development_null(): Set up the null model for developments (do nothing)

MassMedical(<null>): Methods for mass medical

setup_mass_medical_null(): Set up the null model for mass medical (do nothing)

forced

Specialized methods to call forcing

Abiotic(<forced>): Set up exogenous variables for abiotic forcing

setup_abiotic_forced(): Make parameters for the null model of abiotic forcing (do nothing)

check_abiotic(): Check abiotic

check_abiotic(<null>): Check abiotic

check_abiotic(<forced>): Check abiotic

Civil(<forced>): Set up exogenous variables for civil forcing

setup_civil_forced(): Make parameters for the null model of civil forcing (do nothing)

check_civil(): Check civil

check_civil(<null>): Check civil

check_civil(<forced>): Check civil

Control(<forced>): Modify parameters due to exogenous forcing by all kinds of control

setup_control_forced(): Set up a model with some control

MassMedical(<forced>): Methods for mass medical

setup_mass_medical_forced(): Set up a model for mass medical

Weather

Specialized methods for weather

Weather(): Methods for exogenous variables describing weather

Weather(<null>): Methods for exogenous variables describing weather

Weather(<forced>): Methods for exogenous variables describing weather

setup_weather_null(): Set up the null model for weather

setup_weather_forced(): Set up the forced model for weather

setup_rainfall_null(): Set up the null model for RAINFALL

Rainfall(): Methods for exogenous variables describing rainfall

Rainfall(<null>): Methods for exogenous variables describing rainfall

setup_temperature_null(): Set up the null model for temperature

Temperature(): Methods for exogenous variables describing temperature

Temperature(<null>): Methods for exogenous variables describing temperature

setup_relative_humidity_null(): Set up the null model for HUMIDITY

Relative_Humidity(): Methods for exogenous variables describing relative humidity

Relative_Humidity(<null>): Methods for exogenous variables describing relative humidity

Hydrology

Specialized methods for hydrology

Hydrology(): Set the values of exogenous variables describing hydrology

Hydrology(<null>): Set the values of exogenous variables describing hydrology

setup_hydrology_null(): Make parameters for the null model for hydrology (do nothing)

Resource Dynamics

Methods to implement resource availability

Resources(): Set the values of exogenous variables describing available mosquito resources

Resources(<static>): Modify resources and resource availability

Resources(<setup>): Modify resources and resource availability

Resources(<forced>): Methods for resources

setup_resources_null(): Set up parameters for the null model for resource availability

setup_resources_static(): Set up parameters for the null model for resource availability

setup_resources_forced(): Set up a model for mass medical

Other Blood Hosts

Methods to simulate availability of other blood hosts

OtherBloodHosts(): Set the values of exogenous variables describing other blood hosts

OtherBloodHosts(<static>): Set the values of exogenous variables describing other blood hosts

setup_other_blood_hosts_static(): Make parameters for the static model for other blood hosts (do nothing)

Habitat Dynamics and Availability

Specialized methods for weather

AvailableHabitat(): Update the availability of aquatic habitats

AvailableHabitat(<static>): Compute total availability of aquatic habitats

AvailableHabitat(<simple>): Compute total availability of aquatic habitats

AvailableHabitat(<forced>): Compute total availability of aquatic habitats

compute_AvailableHabitat(): Compute total availability of aquatic habitats

HabitatDynamics(): Habitat Dynamics and Searching

HabitatDynamics(<static>): Set the values of habitat search weights and other exogenous variables describing habitat_dynamics

setup_habitat_dynamics_static(): Setup the egg laying object

Sugar

Methods to simulate availability of sugar

SugarDynamics(): Set the values of exogenous variables describing sugar

SugarDynamics(<static>): Set the values of exogenous variables describing sugar

setup_sugar_static(): Make parameters for the static model for sugar (do nothing)

AvailableSugar(): Update the availability of sugar

AvailableSugar(<static>): Compute total availability of sugar

AvailableSugar(<forced>): Compute total availability of sugar

Vector Control

Methods to implement vector control.

VectorControl(): Distribute vector control

VectorControlEffects(): Vector control: durability & effects

VectorControlEffectSizes(): Vector control effect sizes

null model

Specialized methods for the null model (no vector control)

VectorControl(<null>): Distribute vector control

VectorControlEffects(<null>): Vector control: durability & effects

VectorControlEffectSizes(<null>): Vector control effect sizes

setup_vc_null(): Distribute vector control, the null model

Implement Control

Specialized methods to implement vector control

VectorControl(<control>): Distribute vector control, the null model

VectorControlEffects(<control>): Vector control durability and effects

VectorControlEffectSizes(<control>): Distribute vector control, the null model

setup_vc_control(): Make parameters for the control model of vector control (do nothing)

Bed Nets

Methods to implement bed nets

DistributeBedNets(): Distribute bed nets, called from Control(VectorControl)

OwnBedNet(): Model bed net loss, called from Control(VectorControl)

UseBedNet(): Model bed net usage, called from Behavior

BedNetEffects(): Modify variables or parameters, called from VectorControlEffects

BedNetEffectSizes(): Modify baseline bionomic parameters, called from VectorControlEffectSizes

DistributeBedNets(<null>): Distribute bed nets

OwnBedNet(<null>): Bed net ownership

UseBedNet(<null>): Bed net ownership

BedNetEffects(<null>): Bed net ownership

BedNetEffectSizes(<null>): Bed net ownership

setup_itn_null(): Make parameters for the null model of bed nets (do nothing)

BedNetEffects(<lemenach>): Modify baseline values due to vector control

BedNetEffectSizes(<lemenach>): Modify baseline values due to vector control

setup_itn_lemenach(): Make parameters for Le Menach ITN model of vector control

Indoor Residual Spraying

Methods to implement IRS

SprayHouses(): Do mass house spraying (IRS)

IRS_Effects(): Model the effects of IRS

IRS_EffectSizes(): Model IRS effect sizes

SprayHouses(<null>): Do mass house spraying (IRS)

IRS_Effects(<null>): Model the effects of IRS

IRS_EffectSizes(<null>): Model IRS effect sizes

setup_irs_null(): Make parameters for the null model of IRS (do nothing)

Area Spraying

Methods to implement area spraying

AreaSpray(): Methods for mass spraying

AreaSprayEffects(): Methods for mass spraying

AreaSprayEffectSizes(): Methods for mass spraying

AreaSpray(<null>): Set up mass spraying

AreaSprayEffects(<null>): Set up mass spraying

AreaSprayEffectSizes(<null>): Set up mass spraying

setup_area_spray_null(): Set up the null model for area spraying (do nothing)

Sugar Baits

Methods to implement sugar baits

SugarBaits(): Methods for distributing sugar baits

SugarBaitEffects(): Methods for the durability and effects of the sugar baits

SugarBaitEffectSizes(): Methods for the effect sizes of the sugar baits

SugarBaits(<null>): Methods for sugar baits

SugarBaitEffects(<null>): Methods for the effects of the sugar baits

SugarBaitEffectSizes(<null>): Methods for the effect sizes of the sugar baits

setup_sugar_baits_null(): Set up the null model for sugar baits (do nothing)

Larval Source Management

Methods to implement LSM

TreatHabitats(): Modify values due to treat habitats as part of LSM, called by Control->VectorControl

LSM_Effects(): Modify effects of LSM

LSM_EffectSizes(): Compute effect sizes of LSM

TreatHabitats(<null>): Set up the null model for LSM

LSM_Effects(<null>): Modify effects of LSM, the null model

LSM_EffectSizes(<null>): Modify effects of LSM, the null model

setup_lsm_null(): Make parameters for the null model of LSM (do nothing)

Ovitraps

Specialized methods for ovitraps

OviTraps(): Methods for oviposition traps

OviTraps(<null>): Methods for oviposition traps

setup_ovitraps_null(): Set up the null model for oviposition traps (do nothing)

Setup

Basic setup for models

make_parameters_xde(): Make base parameters, assuming nVectors = nHosts = 1

make_indices(): Set indices for generalized spatial model

Setting Up

Methods to set up basic models

xde_setup(): Set up a model for xde_diffeqn

xde_setup_aquatic(): Set up a model for xde_diffeqn_aqua

xde_setup_mosy(): Set up a model for xde_diffeqn_mosy

xde_setup_human(): Set up a model for xde_diffeqn_human

xde_setup_cohort(): Set up a model for xde_diffeqn_cohort

Initial Values

Methods to set up basic models

get_inits(): Get the initial values as a vector

update_inits(): Set the initial values to the last values of the last simulation

last_to_inits(): Set the initial values to the last values of the last simulation

Solving

Methods to compute the derivatives and solve the equat

Derivatives

xDE_diffeqn(): Generalized spatial differential equation model

xDE_diffeqn_aquatic(): Differential equation models for aquatic mosquito populations

xDE_diffeqn_mosy(): Generalized spatial differential equation model (mosquito only)

xDE_diffeqn_human(): Differential equations isolating the humans, forced with Ztrace

xDE_diffeqn_cohort(): Differential equation models for human cohorts

Solving

Wrappers around the derivatives functions that handle time and parse outputs

xde_solve(): Solve a system of equations

xde_solve(<dde>): Solve a system of equations as a dde

xde_solve(<ode>): Solve a system of equations as an ode

xde_solve(<aqua>): Solve a system of equations for aquatic dynamics, forced by egg deposition, using xDE_diffeqn_aquatic

xde_solve(<aqua_dde>): Solve a system of delay equations for aquatic dynamics, forced by egg deposition, using xDE_diffeqn_aquatic

xde_solve(<mosy>): Solve a system of equations for mosquito ecology using xDE_diffeqn_mosy

xde_solve(<mosy_dde>): Solve a system of delay differential equations for mosquito ecology using xDE_diffeqn_mosy

xde_solve(<human>): Solve a system of equations with xDE_diffeqn_human

xde_solve(<cohort>): Solve a system of equations with xDE_diffeqn_cohort

xde_stable_orbit(): Solve for the steady state or stable orbit of a system of equations

xde_steady(): Solve for the steady state of a system of equations using rootSolve::steady

Analysis and Visualization

Methods to compute and output terms

Spatial metrics

metric_calV(): Parasite dispersal by mosquitoes

metric_calD(): Parasite dispersal by humans

metric_calR(): Parasite Dispersal through one Parasite Generation (Humans)

metric_calZ(): Parasite Dispersal through one Parasite Generation (Mosquitoes)

Compute terms

Methods to compute and transmission terms

parse_deout(): Parse the output of an object returned by deSolve

parse_deout_vec(): Parse the output of an object returned by deSolve

compute_terms(): Compute dynamical terms

compute_terms(<xde>): Compute dynamical terms

compute_terms(<cohort>): Compute dynamical terms

compute_terms(<human>): Compute dynamical terms

compute_terms(<na>): Compute dynamical terms

compute_terms_steady(): Compute dynamical terms

compute_NI(): Compute the NI

compute_NI_ix(): Compute NI once

compute_vars_full(): Compute other variables at time t

compute_vars_human(): Compute other variables at time t

compute_vars_aqua(): Differential equation models for aquatic mosquito populations

compute_vars_mosy(): Compute other variables at time t

compute_vars_cohort(): Differential equation models for human cohorts

Plot terms

Basic visualization of the transmission terms

xde_plot_EIR(): Plot the EIR vs. time

xde_lines_EIR(): Add lines for the EIR vs. time

xde_plot_aEIR(): Plot the annualized EIR vs. time

xde_lines_aEIR(): Add lines for the annualized EIR vs. t

xde_plot_PR(): Plot the prevalence / parasite rate (PR) from a model of human infection and immunity

xde_lines_PR(): Add lines for the prevalence / parasite rate (PR) from a model of human infection and immunity

Utilities

diag_inverse(): Invert a diagonal matrix

approx_equal(): Check if two numeric values are approximately equal

checkIt(): Check the length of an input value

shapeIt(): Check the shape and dimensions of an object