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 \(\cal L\) models
Models – Human / Host Models available in `ramp.xds` for human/host infection and immunity
`dXdt(<trivial>)`	\(\cal X\) Component Derivatives for the `trivial` model
`dXdt(<SIS>)`	\(\cal X\) Component Derivatives for the `SIS` Model
`dXdt(<SIP>)`	\(\cal X\) Component Derivatives for the `SIP` Model
`dXdt(<SEIS>)`	\(\cal X\) Component Derivatives for the `SEIS` Model
`dXdt(<SEISd>)`	\(\cal X\) Component Derivatives for the `SEISd` Model
Models – Adult Mosquito Models available in `ramp.xds` for adult mosquito ecology and infection dynamics
`dMYZdt(<trivial>)`	\(\cal MYZ\) Component Derivatives for the `trivial` model
`dMYZdt(<SI>)`	\(\cal MYZ\) Component Derivatives for the `SI` Mosquito Model
`dMYZdt(<macdonald>)`	Derivatives for adult mosquitoes
`dMYZdt(<SEI>)`	\(\cal MYZ\) Component Derivatives for the `SEI` Mosquito Model
`dMYZdt(<GeRM>)`	\(\cal MYZ\) Component Derivatives for the `GeRM` model
`dMYZdt(<basicM>)`	\(\cal MYZ\) Component Derivatives for `basicM`
Models – Aquatic Mosquito Models available in `ramp.xds` for the ecology of immature mosquitoes in aquatic habitats
`dLdt(<trivial>)`	\(\cal L\) Component Derivatives for the `trivial` model
`dLdt(<basicL>)`	\(\cal L\) Component Derivatives for a `basicL`
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()`	Set the values of exogenous variables
`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
`change_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
`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
`make_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
`put_MYZvars()`	Put MYZvars in place of the MYZ variables in y
`make_MYZinits()`	A function to set up adult mosquito models
`get_MYZinits()`	Return initial values as a vector
`update_MYZinits()`	Set the initial values as a vector
`make_indices_MYZ()`	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>)`	\(\cal 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
`make_MYZpar(<trivial>)`	Setup the trivial
`create_MYZpar_trivial()`	Make parameters for trivial aquatic mosquito model
`xde_steady_state_MYZ(<trivial>)`	Steady States: MYZ-trivial
`make_MYZinits(<trivial>)`	Setup the trivial model
`make_indices_MYZ(<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>)`	\(\cal 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
`make_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
`make_MYZinits(<basicM>)`	Setup the basicM model
`create_MYZinits_basicM()`	Make inits for basicM adult mosquito model
`make_indices_MYZ(<basicM>)`	Add indices for adult mosquitoes to parameter list
`list_MYZvars(<basicM>)`	Return the variables as a list
`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>)`	\(\cal MYZ\) Component Derivatives for the `SI` Mosquito Model
`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
`make_MYZpar(<SI>)`	Setup MYZpar for the SI model
`create_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
`put_MYZvars(<SI>)`	Return the variables as a list
`make_MYZinits(<SI>)`	Setup initial values for the `SI` model
`create_MYZinits_SI()`	Make inits for `SI` adult mosquito model
`make_indices_MYZ(<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
The “SEI” compartment model for infection Specialized methods for simple infection dynamics for an adult mosquito population
`dMYZdt(<SEI>)`	\(\cal MYZ\) Component Derivatives for the `SEI` Mosquito Model
`MBaseline(<SEI>)`	Set mosquito bionomics to baseline
`MBionomics(<SEI>)`	Set mosquito bionomics to baseline
`xde_steady_state_MYZ(<SEI>)`	Steady States: MYZ-SEI
`Update_MYZt(<SEI>)`	Derivatives for adult mosquitoes
`make_MYZpar(<SEI>)`	Setup MYZpar for the SEI model
`create_MYZpar_SEI()`	Make parameters for SEI ODE adult mosquito model
`F_fqZ(<SEI>)`	The net blood feeding rate of the infective mosquito population in a patch
`F_fqM(<SEI>)`	The net blood feeding rate of the infective mosquito population in a patch
`F_eggs(<SEI>)`	Number of eggs laid by adult mosquitoes
`list_MYZvars(<SEI>)`	Return the variables as a list
`put_MYZvars(<SEI>)`	Return the variables as a list
`make_MYZinits(<SEI>)`	Setup initial values for the SEI model
`create_MYZinits_SEI()`	Make inits for SEI adult mosquito model
`make_indices_MYZ(<SEI>)`	Add indices for adult mosquitoes to parameter list
`parse_MYZorbits(<SEI>)`	Parse the output of deSolve and return variables for the SEI model
`get_MYZinits(<SEI>)`	Return initial values as a vector
`update_MYZinits(<SEI>)`	Make inits for SEI adult mosquito model
`get_f(<SEI>)`	Get the feeding rate
`get_q(<SEI>)`	Get the feeding rate
`get_g(<SEI>)`	Get the feeding rate
`get_sigma(<SEI>)`	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>)`	Derivatives for adult mosquitoes
`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
`make_MYZpar(<macdonald>)`	Setup MYZpar for the macdonald model
`create_MYZpar_macdonald()`	Make parameters for macdonald ODE adult mosquito model
`list_MYZvars(<macdonald>)`	Return the variables as a list
`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
`make_MYZinits(<macdonald>)`	Setup initial values for the macdonald model
`create_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
`make_indices_MYZ(<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>)`	\(\cal 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
`make_MYZpar(<GeRM>)`	Setup MYZpar for the GeRM model
`create_MYZpar_GeRM()`	Make parameters for GeRM ODE adult mosquito model
`list_MYZvars(<GeRM>)`	Return the variables as a list
`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
`make_MYZinits(<GeRM>)`	Setup initial values for the GeRM model
`create_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
`make_indices_MYZ(<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
`make_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
`create_MYZinits_RM_dts()`	Make inits for RM_dts adult mosquito model
`make_indices_MYZ(<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()`	\(\cal L\) Component Derivatives
`xde_steady_state_L()`	Compute steady states for \(\cal L\) models
`make_Lpar()`	Create and configure `Lpar` for \(\cal L\)-Models
`Update_Lt()`	Update States for \(\cal L\)
`dts_steady_state_L()`	Compute steady States for \(\cal L\)-Models
`LBionomics()`	Larval and Aquatic Stage Bionomics
`LBaseline()`	Larval and Aquatic Stage Baseline
`LBionomics(<static>)`	Set mosquito bionomics to baseline
`F_emerge()`	Emerging adults
`make_Linits()`	A function to set up adult mosquito models
`list_Lvars()`	Return \(\cal L\) variables as a list
`put_Lvars()`	Put Lvars in place of the L variables in y
`make_indices_L()`	Add indices for aquatic stage mosquitoes to parameter list
`parse_Lorbits()`	Parse \(\cal L\) Outputs
`get_Linits()`	Get the stored initial values
`update_Linits()`	Set the initial values from a vector of model states
trivial Specialized methods for the exogeneously forced trivial model of aquatic mosquito dynamics.
`LBionomics(<trivial>)`	Reset aquatic parameters to baseline
`LBaseline(<trivial>)`	Reset aquatic parameters to baseline
`xde_steady_state_L(<trivial>)`	Compute the steady state as a function of the egg deposition rate eta
`F_emerge(<trivial>)`	Number of newly emerging adults from each larval habitat
`dLdt(<trivial>)`	\(\cal L\) Component Derivatives for the `trivial` model
`Update_Lt(<trivial>)`	Derivatives for aquatic stage mosquitoes
`make_Lpar(<trivial>)`	xde_setup Lpar for the trivial model
`create_Lpar_trivial()`	Make parameters for trivial aquatic mosquito model
`make_Linits(<trivial>)`	Setup \(\cal L\)-trivial
`list_Lvars(<trivial>)`	Return the variables as a list
`put_Lvars(<trivial>)`	Return the variables as a list
`make_indices_L(<trivial>)`	Add indices for aquatic stage mosquitoes to parameter list
`parse_Lorbits(<trivial>)`	Parse the variable names for the trivial model
`update_Linits(<trivial>)`	Update inits for the basic aquatic mosquito competition model
basicL Specialized methods for a basicL competition model of aquatic mosquito dynamics.
`dLdt(<basicL>)`	\(\cal L\) Component Derivatives for a `basicL`
`Update_Lt(<basicL>)`	Derivatives for aquatic stage mosquitoes
`xde_steady_state_L(<basicL>)`	Compute the steady state as a function of the egg deposition rate eta
`make_Lpar(<basicL>)`	xde_setup Lpar for the basicL model
`create_Lpar_basicL()`	Make parameters for basicL competition aquatic mosquito model
`LBionomics(<basicL>)`	Reset aquatic parameters to baseline
`LBaseline(<basicL>)`	Reset aquatic parameters to baseline
`F_emerge(<basicL>)`	Number of newly emerging adults from each larval habitat
`make_Linits(<basicL>)`	Setup the basicL model
`create_Linits_basicL()`	Make inits for basicL competition aquatic mosquito model
`list_Lvars(<basicL>)`	Return the variables as a list
`make_indices_L(<basicL>)`	Add indices for aquatic mosquitoes to parameter list
`parse_Lorbits(<basicL>)`	Parse the variable names for the basicL model
`update_Linits(<basicL>)`	Update inits for the basicL aquatic mosquito competition model
Mosquito Bionomics Methods to compute or update mosquito bionomic parameters
`Bionomics()`	Set bionomic parameter rates relative to baseline
`MBionomics(<static>)`	Set mosquito bionomics 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
`make_Xinits()`	A function to set up Xpar
`make_X_indices()`	Add indices for human population to parameter list
`list_Xvars()`	Return the variables as a list
`put_Xvars()`	Put Xvars in place of the X variables in y
`make_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
`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>)`	\(\cal X\) Component Derivatives for the `trivial` model
`Update_Xt(<trivial>)`	Update States for the `trivial` \(\cal X\) Model
`make_Xpar(<trivial>)`	xde_setup Xpar.trivial
`create_Xpar_trivial()`	Make parameters for trivial human model
`make_Xinits(<trivial>)`	Setup Xinits.trivial
`make_X_indices(<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
`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>)`	`\eqn{\cal X}` Component Derivatives for the `hMoI` model
`make_Xpar(<hMoI>)`	Setup Xpar.hMoI
`create_Xpar_hMoI()`	Make parameters for hybrid MoI human model
`xde_steady_state_X(<hMoI>)`	Steady States: hMoI
`make_Xinits(<hMoI>)`	Setup Xinits.hMoI
`create_Xinits_hMoI()`	Make inits for hybrid MoI human model
`make_X_indices(<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
`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>)`	\(\cal X\) Component Derivatives for the `SIS` Model
`Update_Xt(<SIS>)`	DTS updating for the SIS model for human / vertebrate host infections
`make_Xpar(<SIS>)`	Setup Xpar.SIS
`create_Xpar_SIS()`	Make parameters for SIS xde human model, with defaults
`make_Xinits(<SIS>)`	Setup Xinits.SIS
`create_Xinits_SIS()`	Make initial values for the SIS xde human model, with defaults
`make_X_indices(<SIS>)`	Add indices for human population to parameter list
`list_Xvars(<SIS>)`	Return the variables 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
`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
SEIS Specialized methods for the SEIS (Susceptible-Infected-Susceptible) model of human dynamics.
`dXdt(<SEIS>)`	\(\cal X\) Component Derivatives for the `SEIS` Model
`Update_Xt(<SEIS>)`	DTS updating for the SEIS model for human / vertebrate host infections
`make_Xpar(<SEIS>)`	Setup Xpar.SEIS
`create_Xpar_SEIS()`	Make parameters for SEIS xde human model, with defaults
`make_Xinits(<SEIS>)`	Setup Xinits.SEIS
`create_Xinits_SEIS()`	Make initial values for the SEIS xde human model, with defaults
`make_X_indices(<SEIS>)`	Add indices for human population to parameter list
`list_Xvars(<SEIS>)`	Return the variables as a list
`put_Xvars(<SEIS>)`	Return the SEIS model variables as a list, returned from Update_Xt.SISd
`F_X(<SEIS>)`	Size of effective infectious human population
`F_H(<SEIS>)`	Size of effective infectious human population
`F_pr(<SEIS>)`	Compute the "true" prevalence of infection / parasite rate
`F_pr_by_lm(<SEIS>)`	Compute the prevalence of infection by light microscopy
`F_pr_by_rdt(<SEIS>)`	Compute the prevalence of infection by RDT
`F_pr_by_pcr(<SEIS>)`	Compute the prevalence of infection by pcr
`F_b(<SEIS>)`	Infection blocking pre-erythrocytic immunity
`parse_Xorbits(<SEIS>)`	Parse the output of deSolve and return variables for the SEIS model
`get_Xinits(<SEIS>)`	Return initial values as a vector
`update_Xinits(<SEIS>)`	Update inits for the SEIS xde human model from a vector of states
`HTC(<SEIS>)`	Compute the HTC for the SEIS model
`xds_plot_X(<SEIS>)`	Plot the density of infected individuals for the SEIS model
`add_lines_X_SEIS()`	Add lines for the density of infected individuals for the SEIS model
`xde_steady_state_X(<SEIS>)`	Compute the steady states for the SEIS model as a function of the daily EIR
`dts_steady_state_X(<SEIS>)`	Compute the steady states for the dts SEIS model as a function of the daily EIR
SEISd Specialized methods for the SEISd (Susceptible-Infected-Susceptible) model of human dynamics.
`dXdt(<SEISd>)`	\(\cal X\) Component Derivatives for the `SEISd` Model
`Update_Xt(<SEISd>)`	DTS updating for the SEISd model for human / vertebrate host infections
`make_Xpar(<SEISd>)`	Setup Xpar.SEISd
`create_Xpar_SEISd()`	Make parameters for SEISd xde human model, with defaults
`xde_steady_state_X(<SEISd>)`	Compute the steady states for the SEISd model as a function of the daily EIR
`make_Xinits(<SEISd>)`	Setup Xinits.SEISd
`create_Xinits_SEISd()`	Make initial values for the SEISd xde human model, with defaults
`make_X_indices(<SEISd>)`	Add indices for human population to parameter list
`list_Xvars(<SEISd>)`	Return the variables as a list
`put_Xvars(<SEISd>)`	Return the SEISd model variables as a list, returned from Update_Xt.SISd
`F_X(<SEISd>)`	Size of effective infectious human population
`F_H(<SEISd>)`	Size of effective infectious human population
`F_b(<SEISd>)`	Infection blocking pre-erythrocytic immunity
`parse_Xorbits(<SEISd>)`	Parse the output of deSolve and return variables for the SEISd model
`get_Xinits(<SEISd>)`	Return initial values as a vector
`update_Xinits(<SEISd>)`	Update inits for the SEISd xde human model from a vector of states
`HTC(<SEISd>)`	Compute the HTC for the SEISd model
`F_pr(<SEISd>)`	Compute the "true" prevalence of infection / parasite rate
`F_pr_by_lm(<SEISd>)`	Compute the prevalence of infection by light microscopy
`F_pr_by_rdt(<SEISd>)`	Compute the prevalence of infection by RDT
`F_pr_by_pcr(<SEISd>)`	Compute the prevalence of infection by pcr
`xds_plot_X(<SEISd>)`	Plot the density of infected individuals for the SEISd model
`add_lines_X_SEISd()`	Add lines for the density of infected individuals for the SEISd model
SIP Specialized methods for the SIP (Susceptible-Infected-Prophylaxis) model of human dynamics.
`dXdt(<SIP>)`	\(\cal X\) Component Derivatives for the `SIP` Model
`Update_Xt(<SIP>)`	Derivatives for human population
`make_Xpar(<SIP>)`	Setup `Xpar` for an `SIP`
`create_Xpar_SIP()`	Make parameters for SIP human model, with defaults
`xde_steady_state_X(<SIP>)`	Compute the steady states for the SIP model as a function of the daily foi
`dts_steady_state_X(<SIP>)`	Compute the steady states for the dts SIP model as a function of the daily EIR
`make_Xinits(<SIP>)`	Setup Xinits.SIP
`create_Xinits_SIP()`	Make initial values for the SIP human model, with defaults
`make_X_indices(<SIP>)`	Add indices for human population to parameter list
`list_Xvars(<SIP>)`	Return the variables as a list
`F_X(<SIP>)`	Size of effective infectious human population
`F_H(<SIP>)`	Size of effective infectious human population
`F_b(<SIP>)`	Infection blocking pre-erythrocytic immunity
`parse_Xorbits(<SIP>)`	Parse the output of deSolve and return variables for the SIP model
`get_Xinits(<SIP>)`	Return initial values as a vector
`update_Xinits(<SIP>)`	Update inits for the SIP human model from a vector of states
`HTC(<SIP>)`	Compute the HTC for the SIP model
`F_pr(<SIP>)`	Compute the "true" prevalence of infection / parasite rate
`F_pr_by_lm(<SIP>)`	Compute the prevalence of infection by light microscopy
`F_pr_by_rdt(<SIP>)`	Compute the prevalence of infection by RDT
`F_pr_by_pcr(<SIP>)`	Compute the prevalence of infection by pcr
`xds_plot_X(<SIP>)`	Plot the density of infected individuals for the SIP model
`add_lines_X_SIP()`	Add lines for the density of infected individuals for the SIP model
SIPd Specialized methods for the SIPd (Susceptible-Infected-Prophylaxis) model of human dynamics.
`dXdt(<SIPd>)`	\(\cal X\) Component Derivatives for the `SIPd` Model
`Update_Xt(<SIPd>)`	Derivatives for human population
`make_Xpar(<SIPd>)`	Setup `Xpar` for an `SIPd`
`create_Xpar_SIPd()`	Make parameters for SIPd human model, with defaults
`xde_steady_state_X(<SIPd>)`	Compute the steady states for the SIPd model as a function of the daily foi
`dts_steady_state_X(<SIPd>)`	Compute the steady states for the dts SIPd model as a function of the daily EIR
`make_Xinits(<SIPd>)`	Setup Xinits.SIPd
`create_Xinits_SIPd()`	Make initial values for the SIPd human model, with defaults
`make_X_indices(<SIPd>)`	Add indices for human population to parameter list
`list_Xvars(<SIPd>)`	Return the variables as a list
`F_X(<SIPd>)`	Size of effective infectious human population
`F_H(<SIPd>)`	Size of effective infectious human population
`F_b(<SIPd>)`	Infection blocking pre-erythrocytic immunity
`parse_Xorbits(<SIPd>)`	Parse the output of deSolve and return variables for the SIPd model
`get_Xinits(<SIPd>)`	Return initial values as a vector
`update_Xinits(<SIPd>)`	Update inits for the SIPd human model from a vector of states
`HTC(<SIPd>)`	Compute the HTC for the SIPd model
`F_pr(<SIPd>)`	Compute the "true" prevalence of infection / parasite rate
`F_pr_by_lm(<SIPd>)`	Compute the prevalence of infection by light microscopy
`F_pr_by_rdt(<SIPd>)`	Compute the prevalence of infection by RDT
`F_pr_by_pcr(<SIPd>)`	Compute the prevalence of infection by pcr
`xds_plot_X(<SIPd>)`	Plot the density of infected individuals for the SIPd model
`add_lines_X_SIPd()`	Add lines for the density of infected individuals for the SIPd model
Human Population Dynamics Generic methods for the human demography and aging
`dHdt()`	Derivatives of demographic changes in human populations
`setup_Hpar_static()`	A utility to set up Hpar
`Births()`	A function that computes the birth rate for human populations
`make_parameters_demography_null()`	Make parameters for null human demography model
static Specialized methods for the static (constant) demographic model
`Births(<zero>)`	Derivatives of demographic changes in human populations
`dHdt(<zero>)`	Derivatives of demographic changes in human populations
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 imported malaria
`travel_malaria()`	Simulate travel malaria
`Visiting()`	Visiting
Travel Malaria Specialized methods for travel malaria
`travel_malaria(<xde>)`	A model for the travel FoI
`travel_malaria(<dts>)`	A model for the travel FoI
`setup_travel_static()`	A function to set up malaria importation
`setup_travel_static(<xde>)`	A function to set up malaria importation
`setup_travel_static(<dts>)`	A function to set up malaria importation
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()`	Set the values of exogenous variables
`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()`	Set the values of exogenous variables
`VectorControl(<none>)`	Set the values of exogenous variables
`VectorControl(<setup>)`	The `setup` case for exogenous vector_control
`VectorControl(<dynamic>)`	Distribute vector control, the null model
`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()`	none set up for exogenous vector_control
`dynamic_vector_control()`	Set up dynamic vector_control
`dynamic_vector_control(<none>)`	Set up dynamic vector_control
`dynamic_vector_control(<setup>)`	Set up dynamic vector_control
`dynamic_vector_control(<dynamic>)`	Set up dynamic vector_control
Bed Nets Specialized methods to implement Bed Nets
`BedNet()`	Set the bednet
`BedNet(<none>)`	Set no bednet
`setup_no_bednets()`	Set up "no bednet"
`BedNet(<dynamic>)`	Set no bednet
`xds_setup_bednets()`	Set up dynamic forcing
`DistributeBedNets()`	Set the distribute_bednets
`setup_distribute_bednets()`	Set up dynamic bednets
`DistributeBedNets(<none>)`	Set no distribute_bednets
`setup_distribute_bednets(<none>)`	Set up "no distribute_bednets"
`DistributeBedNets(<func>)`	Set no distribute_bednets
`setup_distribute_bednets(<func>)`	Set up dynamic bednets
`setup_distribute_bednets_func()`	Set up dynamic bednets
`OwnBedNets()`	Set the own_bednets
`setup_own_bednets()`	Set up dynamic bednets
`OwnBedNets(<none>)`	Set no own_bednets
`setup_own_bednets(<none>)`	Set up "no own_bednets"
`OwnBedNets(<func>)`	Set no own_bednets
`setup_own_bednets(<func>)`	Set up dynamic forcing
`setup_own_bednets_func()`	Set up dynamic forcing
`UseBedNets()`	Set the use_bednets
`setup_use_bednets()`	Set up dynamic bednets
`UseBedNets(<none>)`	Set no use_bednets
`setup_use_bednets(<none>)`	Set up "no use_bednets"
`UseBedNets(<func>)`	Set no use_bednets
`setup_use_bednets(<func>)`	Set up dynamic forcing
`setup_use_bednets_func()`	Set up dynamic forcing
`BedNetEffects()`	Set the bednet_effects
`setup_bednet_effects()`	Set up dynamic forcing
`BedNetEffects(<none>)`	Set no bednet_effects
`setup_bednet_effects(<none>)`	Set up "no bednet_effects"
`BedNetCoverage()`	Set the bednet_coverage
`setup_bednet_coverage()`	Set up dynamic forcing
`BedNetCoverage(<none>)`	Set no bednet_coverage
`setup_bednet_coverage(<none>)`	Set up "no bednet_coverage"
`BedNetCoverage(<func>)`	Set no bednet_coverage
`setup_bednet_coverage(<func>)`	Set up dynamic forcing
`setup_bednet_coverage_func()`	Set up dynamic forcing
`BedNetEffectSizes()`	Set the bednet_effectsizes
`setup_bednet_effectsizes()`	Set up dynamic forcing
`BedNetEffectSizes(<none>)`	Set no bednet_effectsizes
`setup_bednet_effectsizes(<none>)`	Set up "no bednet_effectsizes"
`BedNetEffectSizes(<func>)`	Set no bednet
`setup_bednet_effectsizes(<func>)`	Set up dynamic forcing
`setup_bednet_effectsizes_func()`	Set no bednet
`BedNetEffectSizes(<lemenach>)`	Modify baseline values due to vector control
`setup_bednet_effectsizes(<lemenach>)`	Set up dynamic forcing
`setup_bednet_effectsizes_lemenach()`	Set up dynamic forcing
`compute_bednet_effect_sizes_lemenach()`	Modify baseline values due to vector control
Indoor Residual Spraying Methods to implement IRS
`IRS()`	Implement IRS
`IRS(<none>)`	Set no irs
`setup_no_irs()`	Set up "no irs"
`IRS(<dynamic>)`	Set no irs
`xds_setup_irs()`	Set up dynamic forcing
`SprayHouses()`	Set the spray_houses_irs
`setup_spray_houses()`	Set up dynamic irs
`SprayHouses(<none>)`	Set no spray_houses
`setup_spray_houses(<none>)`	Set up "no spray_houses"
`IRSEffects()`	Set the irs_effects_irs
`setup_irs_effects()`	Set up dynamic irs
`IRSEffects(<none>)`	Set no irs_effects
`setup_irs_effects(<none>)`	Set up "no irs_effects"
`IRSCoverage()`	Set the irs_coverage
`setup_irs_coverage()`	Set up dynamic forcing
`IRSCoverage(<none>)`	Set no irs_coverage
`setup_irs_coverage(<none>)`	Set up "no irs_coverage"
`IRSCoverage(<func>)`	Set no irs_coverage
`setup_irs_coverage(<func>)`	Set up dynamic forcing
`setup_irs_coverage_func()`	Set up dynamic forcing
`IRSEffectSizes()`	Set the irs_effectsizes
`setup_irs_effectsizes()`	Set up dynamic forcing
`IRSEffectSizes(<none>)`	Set no irs_effectsizes
`setup_irs_effectsizes(<none>)`	Set up "no irs_effectsizes"
Larval Source Management (LSM) Methods to implement LSM
`LSM()`	Set the LSM
`LSM(<none>)`	Set no LSM
`setup_no_lsm()`	Set up "no LSM"
`LSM(<dynamic>)`	Set no LSM
`xds_setup_lsm()`	Set up dynamic forcing
`TreatHabitats()`	Set the treat_habitats_lsm
`setup_treat_habitats()`	Set up dynamic lsm
`TreatHabitats(<none>)`	Set no treat_habitats
`setup_treat_habitats(<none>)`	Set up "no treat_habitats"
`LSMEffects()`	Set the lsm_effects_lsm
`setup_lsm_effects()`	Set up dynamic lsm
`LSMEffects(<none>)`	Set no lsm_effects
`setup_lsm_effects(<none>)`	Set up "no lsm_effects"
`LSMCoverage()`	Set the lsm_coverage
`setup_lsm_coverage()`	Set up dynamic forcing
`LSMCoverage(<none>)`	Set no lsm_coverage
`setup_lsm_coverage(<none>)`	Set up "no lsm_coverage"
`LSMCoverage(<func>)`	Set no lsm_coverage
`setup_lsm_coverage(<func>)`	Set up dynamic forcing
`setup_lsm_coverage_func()`	Set up dynamic forcing
`LSMEffectSizes()`	Set the lsm_effectsizes
`setup_lsm_effectsizes()`	Set up dynamic forcing
`LSMEffectSizes(<none>)`	Set no lsm_effectsizes
`setup_lsm_effectsizes(<none>)`	Set up "no lsm_effectsizes"
Area Spraying Methods to implement area spraying
`AreaSpray()`	Set the AreaSpray
`AreaSpray(<none>)`	Set no AreaSpray
`setup_no_area_spray()`	Set up "no AreaSpray"
`AreaSpray(<dynamic>)`	Set no AreaSpray
`xds_setup_area_spray()`	Set up dynamic forcing
`SprayArea()`	Set the spray_area_lsm
`setup_spray_area()`	Set up dynamic lsm
`SprayArea(<none>)`	Set no spray_area
`setup_spray_area(<none>)`	Set up "no spray_area"
`AreaSprayEffects()`	Set the area spray effects area spray
`setup_area_spray_effects()`	Set up dynamic area spray
`AreaSprayEffects(<none>)`	Set no area spray effects
`setup_area_spray_effects(<none>)`	Set up no area spray effects
`AreaSprayCoverage()`	Set the area spray coverage
`setup_area_spray_coverage()`	Set up dynamic forcing
`AreaSprayCoverage(<none>)`	Set no area spray coverage
`setup_area_spray_coverage(<none>)`	Set up no area spray
`AreaSprayCoverage(<func>)`	Set no area_spray_coverage
`setup_area_spray_coverage(<func>)`	Set up dynamic forcing
`setup_area_spray_coverage_func()`	Set up dynamic forcing
`AreaSprayEffectSizes()`	Set the area spray effectsizes
`setup_area_spray_effectsizes()`	Set up dynamic forcing
`AreaSprayEffectSizes(<none>)`	Set no area_spray_effectsizes
`setup_area_spray_effectsizes(<none>)`	Set up no area spray effectsizes
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
`SugarBaits(<dynamic>)`	Set no sugar baits
`xds_setup_sugar_baits()`	Set up dynamic forcing
`DistributeSugarBaits()`	Set the distribute_sugar_baits_sugar_baits
`setup_distribute_sugar_baits()`	Set up dynamic sugar_baits
`DistributeSugarBaits(<none>)`	Distribute no sugar baits
`setup_distribute_sugar_baits(<none>)`	Set up distribution for the no sugar baits model
`SugarBaitEffects()`	Compute sugar bait effects
`setup_sugar_bait_effects()`	Set up a sugar bait effects model
`SugarBaitEffects(<none>)`	Set up no sugar bait effects
`setup_sugar_bait_effects(<none>)`	Set up no sugar bait effects
`SugarBaitCoverage()`	Set the sugar bait coverage
`setup_sugar_bait_coverage()`	Set up dynamic forcing
`SugarBaitCoverage(<none>)`	Set no sugar bait coverage
`setup_sugar_bait_coverage(<none>)`	Set up no sugar bait coverage
`SugarBaitCoverage(<func>)`	Set up sugar bait coverage function
`setup_sugar_bait_coverage(<func>)`	Set up dynamic sugar bait coverage function
`setup_sugar_bait_coverage_func()`	Set up dynamic sugar bait coverage function
`SugarBaitEffectSizes()`	Compute sugar bait effect sizes
`setup_sugar_bait_effectsizes()`	Set up sugar baits effect sizes
`SugarBaitEffectSizes(<none>)`	No sugar bait effect sizes
`setup_sugar_bait_effectsizes(<none>)`	Set up sugar bait effect sizes for 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 States for \(\cal L\)
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
`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
Rutime 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 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_flat()`	A trivial function F_flat
New Basic visualization of the transmission terms
`F_ni()`	Compute Net Infectiousness (NI)
`F_ni(<SEIS>)`	Compute the NI
`F_ni(<SEISd>)`	Compute the NI
`F_ni(<SIP>)`	Compute the "true" prevalence of infection / parasite rate
`F_ni(<SIPd>)`	Compute the "true" prevalence of infection / parasite rate
`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

Reference

Model Building & Analysis

Build / Setup

Solve and Analyze

Models – Human / Host

Models – Adult Mosquito

Models – Aquatic Mosquito

Interface

Change Parameters & Initial Values

Examine

Blood Feeding and Transmission

Blood Feeding

Transmision

Time Spent

Egg Laying & Emergence

Exposure

Poisson Exposure

Negative Binomial Exposure

Adult Mosquito Dynamics

Visualization for Adult Mosquito

Mosquito Demography

EIP

trivial

basicM

The “SI” model for infection

The “SEI” compartment model for infection

macdonald

GeRM

RM-Mosquito in discrete-time

Aquatic Mosquito Dynamics

trivial

basicL

Mosquito Bionomics

Functional Responses

Mosquito Dispersal

Human Infection Dynamics

trivial

hMoI

SIS

SEIS

SEISd

SIP

SIPd

Human Population Dynamics

static

Care Seeking

Imported Malaria

Travel Malaria

Visiting

Exogeneous Forcing

Forcing

Models

Weather

Temperature

Rainfall

Humidity

Hydrology

Shock

Development

Resource Dynamics

Other Blood Hosts

Habitat Dynamics and Availability

Sugar

Vector Control

Bed Nets

Indoor Residual Spraying

Larval Source Management (LSM)

Area Spraying

Sugar Baits

Ovitraps

Health

Clinic

School

MassHealth

ActiveCaseDetection

Solving

Derivatives

Cohort Dynamics

Update

Exogenous Forcing