Package index • ramp.xds

Model Building & Analysis

Methods to support nimble model building and analysis

Basic Setup

Methods to set up an xds object with basic features

xds_setup(): Build a Model with All Components

xds_setup_mosy(): Build a Model of Mosquito Ecology

xds_setup_aquatic(): Build a Model of Immature Mosquito Ecology

xds_setup_human(): Build a Model of Human / Host Epidemiology

xds_setup_cohort(): Build a Model of Human / Host Cohort Dynamics

xds_setup_eir(): Build a Model for a single Human / Host Epidemiology forced by the EIR

make_xds_object_template(): Make an xds model object Template

print(<xds_obj>): Print for xds_objects

Get, Set, and Show Forcing

For models that are forced, get, set, and show aspects of the forcing assumption

get_mean_forcing(): Get mean forcing

set_mean_forcing(): Set mean forcing

show_season(): Plot the seasonal pattern

get_season(): Get seasonal pattern

set_season(): Get seasonal pattern

show_trend(): Plot the temporal trend

get_trend(): Get the trend parameters

set_trend(): Set the interpolating points

Solving and Analysis

Methods to solve or analyze equations

xds_solve(): Solve a system of differential equations

xde_stable_orbit(): Compute the stable orbit for a system of differential equations

xds_solve_cohort(): Cohort dynamics for a human / host model

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

dts_steady(): Solve for the steady state of a system of equations

xde_steady_state_X(): Compute Steady States for an X-Component Module

xde_steady_state_MYZ(): Compute steady states for MYZ Modules

xde_steady_state_L(): Compute steady states for L Component Modules

burnin(): Burn-in

XH Modules - Human / Host Epidemiology

Models available in ramp.xds for human/host infection and immunity

dXdt(<trivial>): Handle Derivatives for the trivial X-Module

dXdt(<SIS>): Compute Derivatives for the SIS X-Model

MYZ Modules - Adult Mosquitoes

Models available in ramp.xds for adult mosquito ecology and infection dynamics

dMYZdt(<trivial>): Handle derivatives for the trivial MYZ module

dMYZdt(<macdonald>): Compute derivatives for the MYZ module macdonald

dMYZdt(<GeRM>): MYZ Component Derivatives for the GeRM model

dMYZdt(<basicM>): MYZ Component Derivatives for basicM

L Modules - Immature Mosquitoes

Models available in ramp.xds for the ecology of immature mosquitoes in aquatic habitats

dLdt(<trivial>): Handle derivatives for the trivial L module

dLdt(<basicL>): Derivatives for basicL (L Component)

Other Variables

Compute the derivatives for other variables

dVdt(): Compute Other Variables

dVdt(<setup>): Compute Other Variables

setup_Vix(): Compute Other Variables

setup_other_variables(): Set Up the first (null) other variable

add_variable(): Add a new variable

Ports and Junctions

Functions that compute dynamical terms and exogenous variables

Forcing(): Set the values of exogenous variables

Health(): Set the values variables for health-based malaria control

VectorControl(): Implement Vector Control

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

BloodFeeding(): Blood feeding

EggLaying(): Compute eggs laid

BaselineBionomics(): Set bionomic parameter rates relative to baseline

Bionomics(): Set bionomic parameter rates relative to baseline

Transmission(): Compute the mixing matrix and transmission terms

Exposure(): Compute Infection Rates

Change Parameters & Initial Values

Methods to set up basic models

set_H(): Change human population density

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

parse_orbits(): Parse the outputs of an object created by xde_solve or dts_solve

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

get_inits(): Get the stored initial values, \(y_0\)

get_H(): Get the initial values as a vector

get_XH(): Get XH outputs

get_PR(): Get the PfPR from a Malaria Model

get_PR(<true>): Get the PfPR from a Malaria Model

get_PR(<lm>): Get the PfPR from a Malaria Model

get_PR(<rdt>): Get the PfPR from a Malaria Model

get_PR(<pcr>): Get the PfPR from a MalariasModel

get_MYZ(): Get MYZ outputs

make_indices(): Make indices for all the model variables

trigger_setup(): Trigger setup

Examine

Methods to

get_inits(): Get the stored initial values, \(y_0\)

get_last(): Get the last state

parse_orbits(): Parse the outputs of an object created by xde_solve or dts_solve

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

Blood Feeding and Transmission

Methods to compute terms describing blood feeding and transmission

setup_BLOOD_FEEDING(): Set up Blood Feeding

BloodFeeding(): Blood feeding

BloodFeeding(<static>): Compute blood feeding objects: static models

BloodFeeding(<dynamic>): Compute blood feeding objects dynamically

BloodFeeding(<setup>): Compute blood feeding objects: setup for static models

setup_TRANSMISSION(): Setup the interface for parasite / pathogen transmission

Transmission(): Compute the mixing matrix and transmission terms

Transmission(<static>): Compute transmission terms with a static mixing matrix

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

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

create_residence_matrix(): Create the Residency Matrix

view_residence_matrix(): View residence membership

Blood Feeding

Methods for time at risk & blood host availability

change_blood_weights(): Set static blood feeding search weights

compute_W(): Compute Host Availability for Blood Feeding

compute_B(): Compute Vertebrate Host Availability for Blood Feeding

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

compute_RBR(): Compute relative biting rates

make_RBR(): Compute and attach the relative biting rates

compute_TaR(): Compute blood feeding availability of all vertebrate hosts

make_TaR(): Make TaR

Transmision

Compute beta - EIR - kappa - & local_frac

compute_beta(): Compute beta, the biting distribution matrix

make_beta(): Compute beta

compute_EIR(): Compute the daily Entomological Inoculation Rate (EIR)

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

make_EIR(): Compute EIR

compute_kappa(): Net infectiousness of human population to mosquitoes

make_kappa(): Compute kappa

compute_local_frac(): Compute the local fraction

make_local_frac(): Compute the local fraction

Time Spent

Set up Time Spent Matrices

change_TimeSpent(): Change the time spent matrix

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

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

create_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

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

Egg Laying & Emergence

Generic methods for egg laying

setup_EGG_LAYING(): Setup Egg Laying

Emergence(): Compute emerging adults

EggLaying(): Compute eggs laid

EggLaying(<setup>): Compute eggs laid, the first time

EggLaying(<static>): Compute eggs laid

EggLaying(<dynamic>): Compute eggs laid

Habitat Availability

Habitat search weights - availability

create_habitat_matrix(): Create the habitat membership matrix, \(N\)

change_habitat_weights(): Change the habitat search weights

compute_Q(): Compute the total availability of egg-laying habitats, \(Q\)

compute_Qtot(): Compute the total availability of egg-laying habitats, \(Q\)

make_Q(): Compute and store availability of egg-laying habitats

compute_Umatrix(): Compute the egg distribution matrix - \(U\)

make_Umatrix(): Compute and store \(U\)

compute_eggs_laid(): Compute eggs laid

make_eggs_laid(): Compute eggs laid

view_habitat_matrix(): View habitat membership, \(N\)

Exposure

Methods for Exposure

Exposure(): Compute Infection Rates

Exposure(<xde>): Compute the FoI

Exposure(<dts>): Compute Attack Rates

Exposure(<multiday>): Exposure and Infection

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

F_foi(): Compute the Local FoI

foi2eir(): Convert FoI to EIR

F_ar(): Compute Local Attack Rates

ar2eir(): Convert AR to EIR

Poisson Exposure

Specialized methods the Poisson exposure model

F_foi(<pois>): Poisson Force of Infection

F_ar(<pois>): Poisson Attack Rates

foi2eir(<pois>): Convert FoI to EIR under a Poisson model for Exposure

ar2eir(<pois>): Convert AR to EIR under a Poisson model for Exposure

setup_exposure_pois(): Set up a Poisson model for Exposure and Infection

setup_exposure_pois(<xde>): Set up Poisson Exposure and Infection for xde

setup_exposure_pois(<dts>): Set up Poisson Exposure and Infection for dts

Negative Binomial Exposure

Specialized methods the Negative Binomial exposure model

F_foi(<nb>): Negative Binomial Force of Infection

F_ar(<nb>): Negative Binomial Attack Rates

foi2eir(<nb>): A negative binomial model for the daily FoI as a function of the daily EIR.

ar2eir(<nb>): A negative binomial model for the daily EIR. as a function of the daily attack rate

setup_exposure_nb(): Set up the negative binomial model of exposure

setup_exposure_nb(<xde>): Set up the negative binomial model of exposure for continuous time models

setup_exposure_nb(<dts>): Set up the negative binomial model for exposure for discrete time models

Adult Mosquito Modules

Generic methods for the adult mosquito dynamics component.

dMYZdt(): Compute Derivatives for an Adult Mosquito Model

MBaseline(): Adult Mosquito Bionomics - Baseline

MBionomics(): Adult Mosquito Bionomics - Modified by Control

xde_steady_state_MYZ(): Compute steady states for MYZ Modules

xde_steady_state_M(): Compute the steady states as a function of the daily EIR

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

Update_MYZt(): Update States for a Adult Mosquito Model

MYZ_rates2probs(): Compute probabilities from rates

dts_steady_state_MYZ(): Compute the steady states as a function of the daily EIR

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

F_fqM(): Blood feeding rate of the mosquito population

F_eggs(): Number of eggs laid by adult mosquitoes

list_MYZvars(): Return the variables as a list

get_MYZpars(): Return the parameters as a list

set_MYZpars(): Set new MYZ parameter values

put_MYZvars(): Put MYZvars in place of the MYZ variables in y

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

get_MYZinits(): Return initial values as a vector

set_MYZinits(): Set new MYZ parameter values

update_MYZinits(): Set the initial values as a vector

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

parse_MYZorbits(): Parse the outputs and return the variables by name in a list

Visualization for Adult Mosquito

Basic Plotting

xds_plot_M(): Plot adult mosquito population density

xds_lines_M(): Add lines for adult mosquito population density

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

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

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

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

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

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

xds_plot_Z_fracs(): Plot the fraction infective

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

Mosquito Demography

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

compute_Omega_xde(): Make the mosquito demography matrix for spatial RM model in continuous time

compute_Omega_dts(): Make the mosquito demography matrix for spatial RM model in discrete time

compute_Omega(): Make the mosquito demography matrix for spatial RM model in continuous time

compute_Omega(<xde>): Make the mosquito demography matrix for spatial RM model in continuous time

compute_Omega(<dts>): Make the mosquito demography matrix for spatial RM model in continuous time

compute_Upsilon(): Make the mosquito demography matrix for spatial RM model in continuous time

compute_Upsilon(<xde>): Make the mosquito demography matrix for spatial RM model in continuous time

make_Omega(): Make the mosquito demography matrix

make_Omega(<xde>): Make the mosquito demography matrix

make_Omega(<dts>): Make the mosquito demography matrix

get_Omega(): Make the mosquito demography matrix

get_Upsilon(): Make the mosquito demography matrix

EIP

Methods for the extrinsic incubation period

F_eip(): Compute the EIP

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

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

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

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

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

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

setup_eip_fixedlag_dts(): Set up a fixedlag_dts model for the EIP

trivial

The trivial model for adult mosquitoes

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

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

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

dMYZdt(<trivial>): Handle derivatives for the trivial MYZ module

MBaseline(<trivial>): Macdonald-style adult mosquito bionomics

MBionomics(<trivial>): Macdonald-style adult mosquito bionomics

Update_MYZt(<trivial>): Handle state updates for the trivial MYZ module

setup_MYZpar(<trivial>): Setup the trivial model for an adult mosquito model

get_MYZpars(<trivial>): Return the parameters as a list

set_MYZpars(<trivial>): Return the parameters as a list

set_MYZinits(<trivial>): Set new MYZ parameter values

make_MYZpar_trivial(): Make parameters for trivial aquatic mosquito model

xde_steady_state_MYZ(<trivial>): Steady States: MYZ-trivial

setup_MYZinits(<trivial>): Setup the trivial model

setup_MYZix(<trivial>): Add indices for aquatic stage mosquitoes to parameter list

parse_MYZorbits(<trivial>): Parse the output of deSolve and return variables for the trivial model

get_MYZinits(<trivial>): Return initial values as a vector

update_MYZinits(<trivial>): Update inits for trivial

basicM

Methods for basicM - adult mosquito ecology without infection dynamics.

dMYZdt(<basicM>): MYZ Component Derivatives for basicM

MBaseline(<basicM>): Set mosquito bionomics to baseline

MBionomics(<basicM>): Set mosquito bionomics to baseline

xde_steady_state_M(<basicM>): Compute the steady states as a function of the daily EIR

Update_MYZt(<basicM>): Derivatives for adult mosquitoes

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

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

setup_MYZinits(<basicM>): Setup the basicM model

make_MYZinits_basicM(): Make inits for basicM adult mosquito model

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

list_MYZvars(<basicM>): Return the variables as a list

get_MYZpars(<basicM>): Return the parameters as a list

set_MYZpars(<basicM>): Return the parameters as a list

set_MYZinits(<basicM>): Set new MYZ parameter values

parse_MYZorbits(<basicM>): Parse outputs for basicM

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

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

The “SI” model for infection

Specialized methods for simple infection dynamics for an adult mosquito population

dMYZdt(<SI>): MYZ Component Derivatives for the SI Mosquito Module

MBaseline(<SI>): Macdonald-style adult mosquito bionomics

MBionomics(<SI>): Macdonald-style adult mosquito bionomics

xde_steady_state_MYZ(<SI>): Steady States: MYZ-SI

Update_MYZt(<SI>): Derivatives for adult mosquitoes

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

make_MYZpar_SI(): Make parameters for SI ODE adult mosquito model

F_fqZ(<SI>): Net Blood Feeding by Infectious Mosquitoes - SI Mosquito Model

F_fqM(<SI>): Compute Net Blood Feeding by Mosquitoes for SI

F_eggs(<SI>): Compute Component Egg Laying Rates for SI

list_MYZvars(<SI>): Return the variables as a list

get_MYZpars(<SI>): Return the parameters as a list

set_MYZpars(<SI>): Return the parameters as a list

set_MYZinits(<SI>): Set new MYZ parameter values

put_MYZvars(<SI>): Return the variables as a list

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

make_MYZinits_SI(): Make inits for SI adult mosquito model

setup_MYZix(<SI>): Add indices for adult mosquitoes to parameter list

parse_MYZorbits(<SI>): Parse the output of deSolve and return variables for the SI model

get_MYZinits(<SI>): Return initial values as a vector

update_MYZinits(<SI>): Make inits for SI adult mosquito model

get_f(<SI>): Get the feeding rate

get_q(<SI>): Get the feeding rate

get_g(<SI>): Get the feeding rate

get_sigma(<SI>): Get the feeding rate

macdonald

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

dMYZdt(<macdonald>): Compute derivatives for the MYZ module macdonald

MBaseline(<macdonald>): macdonald-style adult mosquito bionomics

MBionomics(<macdonald>): macdonald-style adult mosquito bionomics

xde_steady_state_MYZ(<macdonald>): Compute the steady states as a function of the daily EIR

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

make_MYZpar_macdonald(): Make parameters for macdonald ODE adult mosquito model

list_MYZvars(<macdonald>): Return the variables as a list

get_MYZpars(<macdonald>): Return the parameters as a list

set_MYZpars(<macdonald>): Return the parameters as a list

set_MYZinits(<macdonald>): Set new MYZ parameter values

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

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

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

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

make_MYZinits_macdonald(): Make inits for macdonald adult mosquito model

get_MYZinits(<macdonald>): Return initial values as a list

update_MYZinits(<macdonald>): Update inits for macdonald adult mosquito model

setup_MYZix(<macdonald>): Add indices for adult mosquitoes to parameter list

parse_MYZorbits(<macdonald>): Parse the output of deSolve and return variables for the macdonald model

get_f(<macdonald>): Get the feeding rate

get_q(<macdonald>): Get the feeding rate

get_g(<macdonald>): Get the feeding rate

get_sigma(<macdonald>): Get the feeding rate

GeRM

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

dMYZdt(<GeRM>): MYZ Component Derivatives for the GeRM model

MBaseline(<GeRM>): Set mosquito bionomics to baseline

MBionomics(<GeRM>): Set mosquito bionomics to baseline

Update_MYZt(<GeRM>): Derivatives for adult mosquitoes

xde_steady_state_MYZ(<GeRM>): Compute the steady states as a function of the daily EIR

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

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

list_MYZvars(<GeRM>): Return the variables as a list

get_MYZpars(<GeRM>): Return the parameters as a list

set_MYZpars(<GeRM>): Return the parameters as a list

set_MYZinits(<GeRM>): Set new MYZ parameter values

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

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

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

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

make_MYZinits_GeRM(): Make inits for GeRM adult mosquito model

get_MYZinits(<GeRM>): Return initial values as a list

update_MYZinits(<GeRM>): Update inits for GeRM adult mosquito model

setup_MYZix(<GeRM>): Add indices for adult mosquitoes to parameter list

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

get_f(<GeRM>): Get the feeding rate

get_q(<GeRM>): Get the feeding rate

get_g(<GeRM>): Get the feeding rate

get_sigma(<GeRM>): Get the feeding rate

RM-Mosquito in discrete-time

Specialized methods for a Ross-Macdonald-style model of adult mosquito dynamics - in discrete time.

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

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

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

Update_MYZt(<RM_dts>): Derivatives for adult mosquitoes

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

list_MYZvars(<RM_dts>): Return the variables as a list

put_MYZvars(<RM_dts>): Return the variables as a list

make_MYZinits_RM_dts(): Make inits for RM_dts adult mosquito model

setup_MYZix(<RM_dts>): Add indices for adult mosquitoes to parameter list

parse_MYZorbits(<RM_dts>): Parse the output of deSolve and return variables for the RM_dts model

get_MYZinits(<RM_dts>): Return initial values as a vector

update_MYZinits(<RM_dts>): Make inits for RM_dts adult mosquito model

Aquatic Mosquito Modules

Generic methods for the aquatic (immature) mosquito component.

dLdt(): Derivatives for an L Component Module

Update_Lt(): Update State Variables for an L Component Module

F_emerge(): Compute Emergent Adults

LBionomics(): Bionomics for an L Component Module

LBaseline(): Baseline Bionomics for an L Component Module

setup_Lpar(): Set up Lpar for L Component modules

get_Lpars(): Get parameters for the L Component module

set_Lpars(): Set L Component Parameters

setup_Linits(): Setup Initial Values for the L Component

list_Lvars(): List L Component Variables

update_Linits(): Update L Component Initial Values

set_Linits(): Set L Component Initial Values

get_Linits(): Get Initial Values for the L Component

setup_Lix(): Set the Values of the Indices for L Component Modules

parse_Lorbits(): Parse L Component Outputs

xde_steady_state_L(): Compute steady states for L Component Modules

dts_steady_state_L(): Compute steady States for L Component Modules

trivial

The trivial model for aquatic dynamics

dLdt(<trivial>): Handle derivatives for the trivial L module

Update_Lt(<trivial>): Update State Variables for trivial (L Component)

F_emerge(<trivial>): Compute Emergent Adults for trivial (L Component)

LBionomics(<trivial>): Bionomics for trivial (L Component)

LBaseline(<trivial>): Baseline Bionomics for trivial (L Component)

setup_Lpar(<trivial>): Setup Lpar for the trivial module

make_Lpar_trivial(): Make Lpar for trivial (L Component)

get_Lpars(<trivial>): Get L Component Parameters for trivial

set_Lpars(<trivial>): Set L Component parameters for trivial

setup_Linits(<trivial>): Setup Initial Values for the L Component trivial Module

list_Lvars(<trivial>): List L Component Variables for trivial

set_Linits(<trivial>): Set the Initial Values for trivial (L Component)

update_Linits(<trivial>): Update Initial Values for basicL from a state vector y

setup_Lix(<trivial>): Setup Variable Indices for trivial (L Component)

parse_Lorbits(<trivial>): Parse L Component Variables for basicL

xde_steady_state_L(<trivial>): Compute the Steady State of dLdt.trivial (L Component)

basicL

A basic model for aquatic mosquito dynamics

dLdt(<basicL>): Derivatives for basicL (L Component)

Update_Lt(<basicL>): Update State Variables for basicL (L Component)

setup_Lpar(<basicL>): Setup Lpar for basicL (L Component)

make_Lpar_basicL(): Make Lpar for basicL (L Component)

LBionomics(<basicL>): Bionomics for basicL (L Component)

LBaseline(<basicL>): Baseline Bionomics for basicL (L Component)

F_emerge(<basicL>): Compute Emergent Adults for basicL (L Component)

setup_Linits(<basicL>): Setup Initial Values for basicL (L Component)

make_Linits_basicL(): Make Initial Values for basicL (L Component)

list_Lvars(<basicL>): List L Component Variables for basicL

get_Lpars(<basicL>): Get L Component Parameters for basicL

set_Lpars(<basicL>): Set L Component parameters for basicL

set_Linits(<basicL>): Set the Initial Values for basicL (L Component)

setup_Lix(<basicL>): Setup Variable Indices for basicL (L Component)

parse_Lorbits(<basicL>): Parse L Component Variables for basicL

update_Linits(<basicL>): Update Initial Values for basicL from a state vector y

xde_steady_state_L(<basicL>): Compute the Steady State of dLdt.basicL (L Component)

Mosquito Bionomics

Methods to compute or update mosquito bionomic parameters

Bionomics(): Set bionomic parameter rates relative to baseline

Functional Responses

Compute bionomic parameters as functional responses to resource availability

F_f(): Compute the blood feeding rate, f

F_q(): Compute the human blood fraction

F_g(): Compute mosguito survival

F_p(): Compute the human blood fraction

F_sigma(): Compute mosquito emigration rates

F_mu(): Compute the emigration loss

F_nu(): Compute the egg laying rate

F_calK(): Compute the egg laying rate

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

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

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

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

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

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

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

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

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

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

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

Mosquito Dispersal

Specialized methods to set up mosquito dispersal matrices

change_calK(): Change the time spent matrix

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

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

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

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

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

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

Human Infection Dynamics

Generic methods for models of human/host infection dynamics - immunity - disease and transmission

dXdt(): Compute Derivatives for the X Component

Update_Xt(): Update X states for a discrete time system

setup_Xinits(): A function to set up Xpar

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

list_Xvars(): Return the variables as a list

get_Xpars(): Return the parameters as a list

set_Xpars(): Set new X parameter values

put_Xvars(): Put Xvars in place of the X variables in y

setup_Xpar(): Setup an X Module

F_X(): Size of effective infectious human population

F_H(): Size of human population denominators

F_b(): Infection blocking pre-erythrocytic immunity

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

get_Xinits(): Return initial values as a vector

set_Xinits(): Set new X parameter values

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

HTC(): Compute the human transmitting capacity

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

F_pfpr_by_lm(): Compute the prevalence of infection by light microscopy

F_pfpr_by_rdt(): Compute the prevalence of infection by RDT

F_pfpr_by_pcr(): Compute infection prevalence by PCR

xds_plot_X(): Basic plotting for epidemiological models

xde_steady_state_X(): Compute Steady States for an X-Component Module

xde_steady_state_XH(): Compute Steady States for an XH-Component Module

dts_steady_state_X(): Compute the steady states as a function of the daily EIR

trivial

Specialized methods the trivial human model

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

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

F_prevalence(<trivial>): Compute the "true" prevalence of infection / parasite rate

xde_steady_state_X(<trivial>): Compute the steady states for the trivial model as a function of the daily EIR

F_pfpr_by_lm(<trivial>): Compute the prevalence of infection by light microscopy

F_pfpr_by_rdt(<trivial>): Compute the prevalence of infection by RDT

F_pfpr_by_pcr(<trivial>): Compute the prevalence of infection by PCR

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

dXdt(<trivial>): Handle Derivatives for the trivial X-Module

Update_Xt(<trivial>): Handle State Updating for the trivial X-Module

setup_Xpar(<trivial>): xde_setup Xpar.trivial

make_Xpar_trivial(): Make parameters for trivial human model

setup_Xinits(<trivial>): Setup Xinits.trivial

setup_Xix(<trivial>): Add indices for human population to parameter list

parse_Xorbits(<trivial>): Parse the output of deSolve and return variables for the trivial model

get_Xinits(<trivial>): Return initial values as a vector

set_Xinits(<trivial>): Return the parameters as a list

get_Xpars(<trivial>): Return the parameters as a list

set_Xpars(<trivial>): Return the parameters as a list

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

hMoI

A hybrid model of MoI (Multiplicity of Infection) for human infection dynamics.

dXdt(<hMoI>): Compute Derivatives for the hMoI (X-Model)

setup_Xpar(<hMoI>): Setup Xpar.hMoI

make_Xpar_hMoI(): Make parameters for hybrid MoI human model

xde_steady_state_X(<hMoI>): Compute Steady States for hMoI (X-Model)

setup_Xinits(<hMoI>): Setup Xinits.hMoI

make_Xinits_hMoI(): Make inits for hybrid MoI human model

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

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

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

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

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

F_pfpr_by_lm(<hMoI>): Compute the prevalence of infection by light microscopy

F_pfpr_by_rdt(<hMoI>): Compute the prevalence of infection by RDT

F_pfpr_by_pcr(<hMoI>): Compute the prevalence of infection by PCR

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

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

set_Xinits(<hMoI>): Return the parameters as a list

get_Xpars(<hMoI>): Return the parameters as a list

set_Xpars(<hMoI>): Return the parameters as a list

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

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

SIS

The SIS (Susceptible-Infected-Susceptible) model of human dynamics.

dXdt(<SIS>): Compute Derivatives for the SIS X-Model

Update_Xt(<SIS>): DTS updating for the SIS model for human / vertebrate host infections

setup_Xpar(<SIS>): Setup Xpar.SIS

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

setup_Xinits(<SIS>): Setup Xinits.SIS

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

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

list_Xvars(<SIS>): Return the variables as a list

get_Xpars(<SIS>): Return the parameters as a list

set_Xpars(<SIS>): Return the parameters as a list

put_Xvars(<SIS>): Return the SIS model variables as a list, returned from Update_Xt.SIS

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

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

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

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

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

set_Xinits(<SIS>): Return the parameters as a list

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

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

F_prevalence(<SIS>): Compute the prevalence of infection

F_pfpr_by_lm(<SIS>): Compute PfPR by light microscopy

F_pfpr_by_rdt(<SIS>): Compute PfPR by RDT

F_pfpr_by_pcr(<SIS>): Compute PfPR by PCR

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

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

xde_steady_state_X(<SIS>): Compute the steady states for the SIS model as a function of the daily EIR

dts_steady_state_X(<SIS>): Compute the steady states for the dts SIS model as a function of the daily EIR

Human Population Dynamics

Methods for the human demography and aging

dHdt(): Derivatives of demographic changes in human populations

dAdt(): An Aging Matrix

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

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

dHdt(<zero>): Compute Demographic Changes

dAdt(<zero>): Compute Demographic Changes

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

setup_births_static(): Setup a static birth_rate

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

dAdt(<matrix>): Derivatives of demographic changes in human populations

setup_Hmatrix(): Setup a matrix for dHdt

Imported Malaria

Methods to implement time spent traveling

traveling(): Time Spent Traveling

traveling(<static>): Time Spent Traveling

traveling(<setup>): Time Spent Traveling

traveling(<dynamic>): Time Spent Traveling

setup_no_travel(): Set up no travel

setup_static_travel(): Set up static travel

setup_dynamic_travel(): Set up a dynamic model for travel

Travel Malaria

Model the EIR while traveling

travel_eir(): Travel EIR

setup_travel_eir(): Setup Travel EIR

Exogeneous Forcing

Methods to implement exogeneous forcing.

Exogenous(): Compute Derivatives

Exogenous(<full>): Generalized spatial differential equation model

Exogenous(<aquatic>): Differential equation models for aquatic mosquito populations

Exogenous(<mosy>): Generalized spatial differential equation model (mosquito only)

Exogenous(<human>): Differential equations isolating the humans, forced with Ztrace

Forcing

The port for exogenous forcing

Forcing(): Set the values of exogenous variables

Forcing(<none>): Set the values of exogenous variables

setup_no_forcing(): none set up for exogenous forcing

Resource Dynamics

The port for resource dynamics

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

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

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

Vector Control

The ports for vector control

VectorControl(): Implement Vector Control

VectorControl(<none>): Implement No Vector Control

VectorControlEffectSizes(): Vector control effect sizes

VectorControlEffectSizes(<none>): Set the values of exogenous variables

setup_no_vector_control(): Setup Function for No Vector Control (default)

Health

The ports for malaria control

Health(): Set the values variables for health-based malaria control

Health(<none>): Set no exogenous health variables

setup_no_health(): none set up for exogenous health

Solving

Methods to compute the derivatives and dynamical systems

Derivatives

xde_derivatives(): Compute Derivatives

xde_derivatives(<full>): Generalized spatial differential equation model

xde_derivatives(<aquatic>): Differential equation models for aquatic mosquito populations

xde_derivatives(<mosy>): Generalized spatial differential equation model (mosquito only)

xde_derivatives(<human>): Differential equations isolating the humans, forced with Ztrace

xde_derivatives(<eir>): Differential equation models for aquatic mosquito populations

Cohort Dynamics

xds_solve_cohort(): Cohort dynamics for a human / host model

xde_cohort_derivatives(): Differential equation models for human cohorts

xde_cohort_desolve(): Solve a system of equations as an ode

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

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

Update

dts_update(): dts_update_ States for Discrete-Time Systems

dts_update(<full>): Generalized spatial differential equation model

dts_update(<aquatic>): Difference equation models for aquatic mosquito populations

dts_update(<mosy>): Generalized spatial differential equation model (mosquito only)

dts_update(<human>): Difference equations isolating the humans, forced with Ztrace

dts_update(<cohort>): Difference equation models for human cohorts

dts_update(<eir>): Difference equation models for aquatic mosquito populations

dts_update_Lt(): Difference equations isolating the humans, forced with Ztrace

dts_update_MYZt(): Difference equations isolating the humans, forced with Ztrace

dts_update_Xt(): Difference equations isolating the humans, forced with Ztrace

Update_Xt(): Update X states for a discrete time system

Update_MYZt(): Update States for a Adult Mosquito Model

Update_Lt(): Update State Variables for an L Component Module

Solving

Wrappers around the derivatives functions that handle time and parse outputs

xds_solve(): Solve a system of differential equations

xds_solve(<dde>): Solve a system of equations using deSolve::dede

xds_solve(<ode>): Solve a system of equations using deSolve::ode

xds_solve(<dts>): Solve a discrete-time system

xde_stable_orbit(): Compute the stable orbit for a system of differential equations

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

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

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

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

dts_steady(): Solve for the steady state of a system of equations

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)

Metric Conversions

fqZ2eir(): Convert a vector describing infective biting density into the EIR, \(E\)

eir2fqZ(): Convert the EIR into a vector describing infective biting density

Compute terms

Methods to compute and transmission terms

average_PR_true(): Compute the average True PR

average_EIR(): Compute the average EIR

parse_orbits(): Parse the outputs of an object created by xde_solve or dts_solve

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

reset_state_i(): Compute other variables at time t

reset_state(): Compute other variables at time t

reset_state(<full>): Compute other variables at time t

reset_state(<aquatic>): Compute other variables at time t

reset_state(<mosy>): Compute other variables at time t

reset_state(<cohort>): Compute other variables at time t

reset_state(<human>): Compute other variables at time t

Plot terms

Basic visualization of the transmission terms

xds_plot_EIR(): Plot the EIR vs. time

xds_plot_aEIR(): Plot the annualized EIR vs. time

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

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

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

Functions and Utilities

stuff that is generally useful

Runtime

Basic visualization of the transmission terms

runt(): A run-time switch function for mismatched dynamical component run-times

set_Dday(): Set up a model for dts_diffeqn

make_runtime(): Set up run-time time step support for dts models

make_runtime(<dts>): Set up run-time time step support for dts models

make_runtime(<xde>): Set up run-time time step support for xde models

Utilities

trigger_setup(): Trigger setup

trigger_setup(<static>): Trigger setup

trigger_setup(<setup>): Trigger setup

trigger_setup(<dynamic>): Trigger setup

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

xds_shrink(): Shrink an xds model object

xds_shrink(<cohort>): Shrink an xds model object

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

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

xds_dde(): Set xds to dde

xds_dde(<ode>): Set xds to dde

xds_dde(<dde>): Set xds for dde

xds_dde(<dts>): Set xds for dts

Functions

Basic visualization of the transmission terms

F_zero(): The trivial function

make_function(<zero>): Make a Function that is the sum of Two other Functions

makepar_F_zero(): parameters for make_function

F_one(): The trivial function

make_function(<one>): Make a Function that is the sum of Two other Functions

makepar_F_one(): parameters for make_function

make_function(<val>): Make a Function that is the sum of Two other Functions

makepar_F_val(): parameters for make_function

F_flat(): The trivial function

make_function(): Make a Function

make_function(<sin>): Make a Sine-based Seasonality Function

makepar_F_sin(): parameters for make_function

make_function(<sum>): Make a Function that is the sum of Two other Functions

makepar_F_sum(): parameters for make_function

make_function(<product>): Make a Sinusoidal Function

makepar_F_product(): parameters for make_function

make_function(<nproduct>): Make a Sinusoidal Function

makepar_F_nproduct(): parameters for make_function

make_function(<sigmoid>): Make a Sigmoidal Function

makepar_F_sigmoid(): Make Parameters for a Sigmoidal Function

make_function(<sharkfin>): Make a Sharkfin Function

makepar_F_sharkfin(): Make Parameters for a Sharkfin Function

make_function(<type2>): Make a type2 function for age

makepar_F_type2(): parameters for make_function

make_function(<splinef>): Make a spline function

make_function(<splineX>): Make a spline function

make_function(<spline2>): Make a spline function

makepar_F_spline(): Make Parameters for a Spline

New

Basic visualization of the transmission terms

F_ni(): Compute Net Infectiousness (NI)

F_ni(<SIS>): Compute the net infectiousness

F_ni(<hMoI>): Compute the "true" nievalence of infection / parasite rate

get_bionomics(): Compute dynamical terms

get_bionomics_s(): Compute dynamical terms

get_bionomics_s_t(): Compute dynamical terms

get_ft(): Get the feeding rate

get_qt(): Get the human fraction

get_gt(): Get the mosquito mortality rate

get_sigmat(): Get the mosquito emigration rate

get_f(): Get the feeding rate

get_f(<GeRM>): Get the feeding rate

get_f(<trivial>): Get the feeding rate

get_q(): Get the feeding rate

get_q(<GeRM>): Get the feeding rate

get_q(<trivial>): Get the feeding rate

get_g(): Get the feeding rate

get_g(<GeRM>): Get the feeding rate

get_g(<trivial>): Get the feeding rate

get_sigma(): Get the feeding rate

get_sigma(<GeRM>): Get the feeding rate

get_sigma(<trivial>): Get the feeding rate

make_outputs(): Make Outputs

make_outputs(<full>): Make Outputs

make_outputs(<mosy>): Make Outputs

make_outputs(<aquatic>): Make Outputs

make_outputs(<human>): Make Outputs

make_outputs(<eir>): Make Outputs

get_terms(): Compute dynamical terms

get_EIR(): Get the feeding rate

Update Forcing

Methods to get, set, and update forcing functions

update_F_season(<Lambda>): Update the seasonality function

update_F_season(): Update the seasonality function

update_F_season(<cohort>): Update the seasonality function

update_F_season(<eir>): Update the seasonality function

update_F_trend(<Lambda>): Update the trend function

update_F_trend(): Update the trend function

update_F_trend(<cohort>): Update the trend function

update_F_trend(<eir>): Update the trend function

show_season(): Plot the seasonal pattern

show_season(<Lambda>): Plot the seasonal pattern

show_season(<none>): Plot the seasonal pattern

show_season(<eir>): Plot the seasonal pattern

show_trend(): Plot the temporal trend

show_trend(<Lambda>): Plot the temporal trend

show_trend(<eir>): Plot the temporal trend

show_trend(<none>): Plot the temporal trend

Get and Set for Mean Forcing

Functions to change Forcing

get_mean_forcing(): Get mean forcing

get_mean_forcing(<none>): Get mean forcing

get_mean_forcing(<Lambda>): Get mean forcing

get_mean_forcing(<eir>): Get mean forcing

get_mean_forcing(<cohort>): Get mean forcing

set_mean_forcing(): Set mean forcing

set_mean_forcing(<none>): Set mean forcing

set_mean_forcing(<Lambda>): Set mean forcing

set_mean_forcing(<eir>): Set mean forcing

set_mean_forcing(<cohort>): set mean forcing

Get and Set for Seasonality

Utilities to change

get_season(): Get seasonal pattern

get_season(<none>): Get seasonal pattern

get_season(<Lambda>): Get seasonal pattern

get_season(<eir>): Get seasonal pattern

get_season(<cohort>): Get seasonal pattern

get_season_phase(): Get phase

get_season_bottom(): Get phase

get_season_pw(): Get pw for seasonality

set_season(): Get seasonal pattern

set_season_phase(): Set phase

set_season_phase(<none>): Set phase

set_season_phase(<Lambda>): Set phase

set_season_phase(<eir>): Set phase

set_season_phase(<cohort>): set phase

set_season_bottom(): Set bottom

set_season_bottom(<none>): Set bottom

set_season_bottom(<Lambda>): Set bottom

set_season_bottom(<eir>): Set bottom

set_season_bottom(<cohort>): set bottom

set_season_pw(): Set pw, a seasonality shape parameter

set_season_pw(<none>): Set pw, a seasonality shape parameter

set_season_pw(<Lambda>): Set pw, a seasonality shape parameter

set_season_pw(<eir>): Set pw, a seasonality shape parameter

set_season_pw(<cohort>): Set pw, a seasonality shape parameter

Get and Set for Spline Trend Functions

Utilities to change the interpolation points

get_trend(): Get the trend parameters

get_trend(<none>): Get the trend parameters

get_trend(<Lambda>): Get the trend parameters

get_trend(<eir>): Get the trend parameters

get_trend(<cohort>): Get the trend parameters

get_spline(): Get spline interpolation points

get_spline_s(): Get spline interpolation points

get_spline_s(<none>): Get spline interpolation points

get_spline_s(<Lambda>): Get spline interpolation points

get_spline_s(<eir>): Get spline interpolation points

get_spline_s(<cohort>): Get spline interpolation points

set_spline(): Set the interpolating points

set_spline(<none>): Set yy

set_spline(<Lambda>): Set the \(y\) value for interpolating points

set_spline(<eir>): Set yy

set_spline(<cohort>): set yy

set_spline_y(): Set yy

set_spline_y(<none>): Set yy

set_spline_y(<Lambda>): Set the \(y\) value for interpolating points

set_spline_y(<eir>): Set yy

set_spline_y(<cohort>): set yy