Package index • ramp.xds

Model Building & Analysis

Methods to support nimble model building and analysis

Build / Setup

Methods to set up an xds object with basic features

xds_setup(): Basic Setup: Make a Fully Defined xds Object

xds_setup_mosy(): Make an xds Object to Study Mosquito Ecology

xds_setup_aquatic(): Make an xds Object to Study Aquatic Mosquito Ecology

xds_setup_human(): Make an xds Object to Study Human / Host Epidemiology

xds_setup_cohort(): Make an xds Object to Study Human / Host Cohort Dynamics

make_xds_template(): Make an xds Object Template

Solve and Analyze

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(): Steady States for \(\cal X\)-Models

xde_steady_state_MYZ(): Compute steady states for \(\cal MYZ\) models

xde_steady_state_L(): Compute steady states for L Component Modules

Models – Human / Host

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

dXdt(<trivial>): X Component Derivatives for the trivial model

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

Models – Adult Mosquito

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

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

dMYZdt(<macdonald>): MYZ Component for the macdonald Adult Mosquito Module

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

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

Models – Aquatic Mosquito

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

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

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

Interface

Functions that compute dynamical terms and exogenous variables

Forcing(): Set the values of exogenous variables

Health(): Set the values variables for health interventions

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

set_eir(): Reset the mean daily EIR

set_eir(<cohort>): Reset the mean daily EIR

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_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

create_residence_matrix(): Create the residence matrix, \(\cal J\)

view_residence_matrix(): View residence membership

Blood Feeding

Methods to compute vertebrate host availibility and time at risk

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

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

Specialized methods to compute the transmission terms

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

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

Method to 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 the aquatic (immature) mosquito component.

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

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

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_calU(): Compute the egg distribution matrix - \(\cal U\)

make_calU(): Compute and store \(\cal U\)

compute_eggs_laid(): Compute eggs laid

make_eggs_laid(): Compute eggs laid

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

Exposure

Methods for environmental heterogeneity

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 Dynamics

Generic methods for the adult mosquito dynamics component.

dMYZdt(): \(\cal MYZ\) Component Derivatives for the GeRM model

MBaseline(): Adult Mosquito - Baseline Bionomics

MBionomics(): Adult Mosquito - Bionomics

xde_steady_state_MYZ(): Compute steady states for \(\cal MYZ\) models

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(): Derivatives for adult mosquitoes

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

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

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

Specialized methods for NULL dynamics: a funtion generates values for F_eggs or F_fqZ or F_fqM

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>): MYZ Component Derivatives for the trivial model

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

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

Update_MYZt(<trivial>): Derivatives for aquatic stage mosquitoes

setup_MYZpar(<trivial>): Setup the trivial

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

Specialized methods for basicM, a model of adult mosquito dynamics with no parasite 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>): \(\cal MYZ\) Component Net Blood Feeding by Mosquitoes for the SI Mosquito Model

F_eggs(<SI>): \(\cal MYZ\) Component Egg Laying for the SI Mosquito Model

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>): MYZ Component for the macdonald Adult Mosquito Module

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 Dynamics

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

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

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

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

Specialized methods for a basicL competition model of 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 the dynamical component that handles human infection dynamics, immunity, disease and transmission

dXdt(): Compute Derivatives for an \(\cal X\) - Component Model

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(): Make Parameters for a \(cal X\) - Component Model

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_pr(): Compute the true prevalence of infection / parasite rate

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

F_pr_by_rdt(): Compute the prevalence of infection by RDT

F_pr_by_pcr(): Compute infection prevalence by PCR

xds_plot_X(): Basic plotting for epidemiological models

xde_steady_state_X(): Steady States for \(\cal X\)-Models

xde_steady_state_XH(): Steady States for \(\cal XH\)-Models

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

trivial

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

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

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

F_pr(<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_pr_by_lm(<trivial>): Compute the prevalence of infection by light microscopy

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

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

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

dXdt(<trivial>): X Component Derivatives for the trivial model

Update_Xt(<trivial>): Update States for the trivial \(\cal X\) Model

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

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

dXdt(<hMoI>): X Component Derivatives for the hMoI module

setup_Xpar(<hMoI>): Setup Xpar.hMoI

make_Xpar_hMoI(): Make parameters for hybrid MoI human model

xde_steady_state_X(<hMoI>): Steady States: hMoI

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_pr(<hMoI>): Compute the "true" prevalence of infection / parasite rate

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

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

F_pr_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

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

dXdt(<SIS>): X Component Derivatives for the SIS 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_pr(<SIS>): Compute the "true" prevalence of infection / parasite rate

F_pr_by_lm(<SIS>): Compute the prevalence of infection by light microscopy

F_pr_by_rdt(<SIS>): Compute the prevalence of infection by RDT

F_pr_by_pcr(<SIS>): Compute the prevalence of infection 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

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

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

setup_Hmatrix(): Setup a matrix for dHdt

Care Seeking

Methods to implement care seeking

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

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

setup_care_seeking_no_behavior(): Make parameters for the no_behavior model for care seeking (do nothing)

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

Visiting(): Visiting

Travel Malaria

Model the EIR while traveling

travel_eir(): Travel EIR

setup_travel_eir(): Setup Travel EIR

Visiting

Methods for the availability and infectiousness of a visitor population

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

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

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

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

Exogeneous Forcing

Methods to implement exogeneous forcing.

Exogenous(): Compute Derivatives

Forcing(): Set the values of exogenous variables

Weather(): Set the values of exogenous variables describing weather

Rainfall(): Set the rainfall

Shock(): System Shocks

Health(): Set the values variables for health interventions

VectorControl(): Implement Vector Control

Clinic(): Methods for distributing interventions during clinical visits

Development(): Set the development

MassHealth(): Methods for mass distributing health interventions

Forcing

Specialized methods the null model (no 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

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

Forcing(<setup>): The setup case for exogenous forcing

dynamic_forcing(): Set up dynamic forcing

dynamic_forcing(<none>): Set up dynamic forcing

dynamic_forcing(<setup>): Set up dynamic forcing

dynamic_forcing(<dynamic>): Set up dynamic forcing

Models

Specialized methods the null model (no exogenous forcing)

Shock(<none>): Set no shock

setup_no_shock(): Set up "no shock"

Development(<none>): Set no development

Development(<func>): Set no development

setup_no_development(): Set up "no development"

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

setup_no_health(): none set up for exogenous health

Weather

Specialized methods for weather

Weather(): Set the values of exogenous variables describing weather

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

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

setup_no_weather(): Set up the no_forcing model for weather

dynamic_weather(): Set up dynamic weather

dynamic_weather(<none>): Set up dynamic weather

dynamic_weather(<setup>): Set up dynamic weather

dynamic_weather(<dynamic>): Set up dynamic weather

Temperature

Specialized methods for temperature

Temperature(): Set the temperature

Temperature(<none>): Set no temperature

setup_no_temperature(): Set up "no temperature"

setup_temperature(): Set up dynamic forcing

Temperature(<func>): Set no temperature

setup_temperature(<func>): Set up dynamic forcing

setup_temperature_func(): Set up dynamic forcing

Rainfall

Specialized methods for rainfall

Rainfall(): Set the rainfall

Rainfall(<none>): Set no rainfall

setup_no_rainfall(): Set up "no rainfall"

setup_rainfall(): Set up dynamic forcing

Rainfall(<func>): Set no rainfall

setup_rainfall(<func>): Set up dynamic forcing

setup_rainfall_func(): Set up dynamic forcing

Humidity

Specialized methods for humidity

Humidity(): Set the humidity

Humidity(<none>): Set no humidity

setup_no_humidity(): Set up "no humidity"

setup_humidity(): Set up dynamic forcing

Humidity(<func>): Set no humidity

setup_humidity(<func>): Set up dynamic forcing

setup_humidity_func(): Set up dynamic forcing

Hydrology

Specialized methods for hydrology

Hydrology(): Set the hydrology

Hydrology(<none>): Set no hydrology

setup_no_hydrology(): Set up "no hydrology"

Hydrology(<func>): Set no hydrology

setup_hydrology(): Set up dynamic forcing

setup_hydrology(<func>): Set up dynamic forcing

setup_hydrology_func(): Set up dynamic forcing

Shock

Specialized methods for hydrology

Shock(): System Shocks

Shock(<none>): Set no shock

setup_no_shock(): Set up "no shock"

setup_shock(): Set up dynamic forcing

Shock(<func>): Set no shock

setup_shock(<func>): Set up dynamic forcing

setup_shock_func(): Set up dynamic forcing

Development

Specialized methods for hydrology

Development(): Set the development

Development(<none>): Set no development

setup_no_development(): Set up "no development"

setup_development(): Set up dynamic forcing

Development(<func>): Set no development

setup_development(<func>): Set up dynamic forcing

setup_development_func(): Set up dynamic forcing

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_static(): Set up parameters for the static 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

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(): Implement Vector Control

VectorControl(<none>): Implement No Vector Control

VectorControl(<dynamic>): Implement Some Vector Control

VectorControl(<setup>): Vector Control for Static Vector Control

VectorControlEffectSizes(): Vector control effect sizes

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

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

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

dynamic_vector_control(): Turn On Vector Control

dynamic_vector_control(<none>): Turn On Vector Control

dynamic_vector_control(<setup>): Vector Control is Turned On

dynamic_vector_control(<dynamic>): Vector Control is Turned On

Bed Nets

Specialized methods to implement Bed Nets

BedNet(): Set the bednet

BedNet(<none>): Set no bednet

BedNetEffectSizes(): Set the bednet_effectsizes

BedNetEffectSizes(<none>): Set no bednet_effectsizes

setup_no_bednets(): Set up "no bednet"

Indoor Residual Spraying

Methods to implement IRS

IRS(): Implement IRS

IRS(<none>): Set no irs

IRSEffectSizes(): Set the irs_effectsizes

IRSEffectSizes(<none>): Set no irs_effectsizes

setup_no_irs(): Set up "no irs"

Larval Source Management (LSM)

Methods to implement LSM

LSM(): Set the LSM

LSM(<none>): Set no LSM

setup_no_lsm(): Set up "no LSM"

Area Spraying

Methods to implement area spraying

AreaSpray(): Set the AreaSpray

AreaSpray(<none>): Set no AreaSpray

setup_no_area_spray(): Set up "no AreaSpray"

Sugar Baits

Methods to implement sugar baits

SugarBaits(): Set the SugarBaits

SugarBaits(<none>): No sugar baits

setup_no_sugar_baits(): Set up no sugar baits

Ovitraps

Specialized methods for ovitraps

OviTraps(): Methods for oviposition traps

OviTraps(<none>): Methods for oviposition traps

setup_no_ovitraps(): Set up the none model for oviposition traps (do nothing)

Health

Methods to implement health-based Interventions

Health(): Set the values variables for health interventions

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

setup_no_health(): none set up for exogenous health

Health(<dynamic>): Set the values of exogenous variables

Health(<setup>): The setup case for health variables

dynamic_health(): Set up dynamic health

dynamic_health(<none>): Set up dynamic health

dynamic_health(<setup>): Set up dynamic health

dynamic_health(<dynamic>): Set up dynamic health

Clinic

Methods to implement clinic-based interventions

Clinic(): Methods for distributing interventions during clinical visits

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

setup_no_clinic(): Set up the none model for clinical distribution (do nothing)

School

Methods to implement school-based interventions

School(): Methods for distributing interventions during schoolal visits

School(<none>): Methods for distributing interventions during schoolal visits

setup_no_school(): Set up the none model for schoolal distribution (do nothing)

MassHealth

Methods to implement clinic-based interventions

MassHealth(): Methods for mass distributing health interventions

MassHealth(<none>): Methods for distributing interventions during mass_healthal visits

setup_no_mass_health(): Set up the none model for mass_healthal distribution (do nothing)

ActiveCaseDetection

Methods to implement clinic-based interventions

ActiveCaseDetection(): Methods for mass distributing health interventions

ActiveCaseDetection(<none>): Methods for distributing interventions during active_case_detectional visits

setup_no_active_case_detection(): Set up the none model for active_case_detectional distribution (do nothing)

Solving

Methods to compute the derivatives and solve the equat

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

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_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(): Derivatives for adult mosquitoes

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

Exogenous 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

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

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

F_one(): The trivial 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(<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

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

get_terms(): Compute dynamical terms

get_EIR(): Get the feeding rate