This patch version overhauls aspects of the NPI and contacts system.
All contacts including workplace contacts are represented in a single array (R) or rank 3 Eigen tensor (C++).
NPI effects on contact matrices are pre-calculated and stored in shared_state and accessed in the ODE RHS rather than being calculated on the fly.
ODE RHS calculations combine FOI calculations into a single step as workplace transmission is rolled into overall transmission.
All <daedalus_country> objects have a minimum of 2 settings, "community" and "workplace".
Community contacts are now scaled by default when an NPI is passed, which substantially reduces the epidemic size, hospitalisations, and deaths. The default scaling of community contacts is the mean of the workplace scaling specified. See the vignette vignettes/multiple_contact_settings.Rmd for more information.
Class <daedalus_npi> constructor also allows a numeric matrix for custom openness coefficients for all age-economic-setting combinations. Community contacts can be scaled per user-specified values, overriding the default behaviour.
Removed header constant for number of contact settings, this is taken from <daedalus_country> when passed to daedalus().
Effective R calculation now uses proportion of susceptible and $R_0$ over NGM eigenvalue calculation for speed.
Tests and documentation has been updated to reflect changes to NPI and contact mechanisms.
Added tests to check that daedalus() works with multiple contact settings.
Added scripts to the Make system to format and lint code.
This patch version fixes an issue with the event generation functionality where state-dependent triggers (state_test) were reading the same root-type (increasing) for both on- and off-triggers. This has been fixed in /inst/include/daedalus_events.h along with a hygiene fix.
Infection parameter hfr is treated more explicitly as a proportion of hospitalised individuals who will die; $I_s \rightarrow H_r$ is calculated as $\eta I_s \times (1.0 - \text{HFR})$. $Is \rightarrow H_d$ remains unchanged.
$\text{HFR}$ is calculated as $\text{min}(\omega_e \text{HFR}_i, 1.0)$ to prevent values > 1.0 when the excess-mortality modifier $\omega_e$ is applied.
The excess mortality modifier $\omega_e$ has been increased from 1.6 to 5.0 in /inst/include/daedalus_constants.h.
There is an array access warning on Windows builds which has not been pinned down and is logged as issue #158.
There are potentially breaking changes to the <daedalus_output> class which now provides the raw ODE solution and events data from daedalus_internal() (indirectly from dust2) as ode_soln and ode_events.
Class elements previously named *_parameters and provided as an unclassed list are now provided as classed types and named * (e.g. "country" provided as <daedalus_country>).
The increase in the excess mortality scaling factor will lead to higher death counts and epidemic costs in most scenarios where hospital capacity is exceeded.
Helper function prepare_output() has been pruned to only work on single-group ODE solutions. The new helper function split_multi_soln() handles grouped ODE solutions for use in a <daedalus_output> object.
Updates to tests and documentation.
This patch version adds the ability pass multiple contact matrices associated with a <daedalus_country>, as a list argument to daedalus_country(name, contact_matrix = list(...)).
The dust2 system shared state and internals have been updated for this functionality.
Some initial scaffolding for scaling each setting separately is in place on the C++ side.
The new functionality is documented in the vignette multiple_contact_settings.Rmd.
The ability to pass additional parameters to a country object during construction are removed, and these modifications should be made after the object is created using $<- as with any list.
The set_data.daedalus_country() method has been removed.
This patch version allows users to define custom names for <daedalus_vaccination> scenarios. daedalus_vaccination() treats all optional parameters as compulsory if a custom name is passed.
This patch version adds some extra GitHub Actions workflows: to auto-generate README.md from README.Rmd, to auto-update the copyright year in license files, and to track dependency changes.
This patch version corrects the expansion of age-stratified contact matrices by correctly distributing the outgoing contacts of working age individuals, preserving the total incoming contacts of all age groups (PR #140). Tests check that contact matrix expansion works as expected.
This patch version makes downstream cost calculations an S3 generic with methods for <daedalus_output> and <data.frame> classes (PR #138).
This is a minor version release for use in the Jameel Institute Symposium Daedalus preview event.
Updates to what information about NPI closures is returned from get_data.daedalus_npi(x, "openness").
Updates to an epidemic size test to avoid potentially spurious failures where 'school closures' seems to be worse than 'none'.
Updates to vignettes to fix formatting and table and section linking.
Updates to Readme to make information easier to find.
This development version splits H into two compartments and uses HFR as the probability of death conditional on hospitalisation (PR #109).
Hospital compartments are now named Hr and Hd, for those hospitalised leading to recovery and death, respectively.
On the C++ code, people in Is enter Hd given
This change will affect the downstream packages daedalus.api and daedalus.compare, but has no effect on daedalus.data. So the daedalus user experience remains unchanged.
This patch version:
Implements a new mechanism to modify the infection transmission rate $\beta$ due to population-level behaviour (via @kunph7);
Adds the header daedalus_behaviour.h with new behavioural scaling functions, and adds helper functions to capture behavioural parameters from R for use in the ODE RHS using lambdas;
Implements constructors for the <daedalus_behaviour> class which inherits from <daedalus_response>: this is currently a simple parameter list, but can be extended to full-fledged daedalus::events::response if needed.
Implements constructors for the 'old' and 'new' behavioural mechanisms as daedalus_old_behaviour() and daedalus_new_behaviour() --- both create the same class of object but with different parameters;
auto_social_distancing argument from daedalus() and daedalus_multi_infection() and replaces it with a behaviour argument.This patch version allows NPIs to end in reaction to an epidemic signal (PR #122).
Converts the daedalus_ode class to a mixed-time ODE system and uses the update functionality to access dy and end NPIs based on the instantaneous value of $R_t$;
Adds functionality to calculate $R_t$ in the ODE model; adds functionality to easily get the next-generation matrix in R;
Updates the function get_beta() to include workplace contacts in the age-specific contact matrix;
Allows an $R_t$ time-series to be returned from model runs;
Updates how event times are inferred as event_data is no longer returned as part of <daedalus_output>; the manual NPI ending using update is not picked up as an event;
Updates the costs functions and tests for renamed output elements;
Updates a number of snapshot tests due to reduction in the transmission rate $\beta$ from updates to get_beta();
Updates daedalus::events to make event generation logic for a daedalus::events::response clearer.
This patch version fixes how closures scale within-sector worker-worker contact rates to be quadratic rather than linear, which increases the impact of applying a response strategy in a model run (PR #126 by @patcatgit).
This patch modifies the costs and fiscal costs calculation by changing how absences due to illness are calculated in get_costs() and get_fiscal_costs() (PR #115 reviewed by @robj411).
Only $H$ and $D$ are counted as fully absent;
$I_a$ were previously counted but are no longer counted as absent;
$I_s$ are counted as present at work when calculating new workplace infections, but also as having complete productivity loss. The level of productivity loss can be changed in get_costs() and get_fiscal_costs() using the argument productivity_loss_infection.
Snapshot tests are updated to reflect that all costs are reduced due to no longer counting $I_a$.
get_fiscal_costs() is updated:
Labour availability match the multiplicative implementation in get_costs();
Interest rate, spending rate, and tax rate have been corrected to be rates rather than percentages, and the interest rate is converted from an annual to a daily rate;
GVA gap now accounts for government support.
This patch version allows multiple, sequential, time-limited NPIs with varying effects (PR #117).
Added the function daedalus_timed_npi() to create time-limited NPIs which are not responsive to model state, and which accept multiple start and end times (with non-overlapping intervals), with corresponding openness coefficients.
Changes to <daedalus_npi> to accommodate timed NPIs.
Changes to C++ daedalus::events::response class to log the index of any timed events: this allows indexing NPI coefficients, and retains boolean flag for other responses.
Function daedalus_npi() no longer specifies a default end time, and does not allow multiple start and end times (this is moved to daedalus_timed_npi()).
Updated vignette on timed NPIs to show multiple timed-NPI functionality with different openness coefficients.
This patch version demotes auto_social_distancing from a full daedalus::events::response while retaining the mechanism of behavioural effects (PR #113).
The mechanism options are mostly handled on the R side (options "off" and "independent", by setting initial flag values), with only "npi_linked" handled on the C++ side (by setting the reference flag index to the same as i_npi_flag).
This allows the mechanism to remain NPI-linked when necessary without needing to specify time- and state-dependence rules separately.
The internal function daedalus::events::switch_by_flag converts flag values > 1.0 to 1.0 internally to account for changes to the NPI flag to an implicit index in PR #117.
This patch version adds functionality to allow multiple, sequential, time-limited NPIs (PR #111 reviewed by @pabloperguz).
<daedalus_response> and sub-classes have separate time_off and max_duration members; time_off may be a vector while max_duration is a single number defaulting to 365 for <daedalus_npi> only. <daedalus_vaccination> has no default value allowing events to continue indefinitely.
Events returned from daedalus() now differentiate between time-limitation and maximum-duration events; the internal function get_daedalus_response_times() handles these different names.
C++ class daedalus::events::response now expects members time_on and time_off to be vectors; this is handled for <daedalus_npi> and <daedalus_vaccination> via daedalus::inputs::read_response but is manually set for other events.
C++ class daedalus::events::response member function make_time_test now checks for start and end time with an expected_value argument for the expected value of the flag. Function make_duration_test only handles the condition that the maximum duration is reached.
A new vignette timed_response.Rmd shows how to use the time-limitation functionality in <daedalus_npi>.
General tests for events in test-daedalus_events.R have been moved to either NPI or vaccination test files.
duration argument to a response object to implement time-limits will fail.npi_linked is not fully compatible with the new changes to <daedalus_npi>, and auto social-distancing will only launch during the first interval that an NPI is active; this will be fixed in PR #113.This patch version:
Introduces the <daedalus_hosp_overflow> class for internal use;
Fixes issues related to vaccination 'pulling along' other state-dependent events by correcting the R and C++ functions get_state_indices() and daedalus::helpers::get_state_idx;
Fixes flag checking in the daedalus::response class event factories (previous indexing used the absolute indices of flags in state which worked for the wrong reason).
This patch version implements a request from UKHSA to allow modelling pre-existing immunity by placing some proportion of the model population in the vaccinated stratum during model initialisation, by specifying p_immune in initial_state_manual in daedalus() and daedalus_multi_infection(). See function documentation details for more (PR #118 reviewed by @OliverPolhillUKHSA).
This patch makes a small fix to the internal function prepare_data() to make it robust to user-created country demography vectors when the vector names are stripped. Timesteps are now taken from the parent function daedalus() and daedalus_multi_infection().
IPR is calculated using the transmission rate $\beta$ in the absence of modifiers from an NPI or spontaneous behavioural changes.
This patch adds the <daedalus_npi> class which is used to store NPI response parameters. daedalus() now accepts these objects as inputs to response_strategy.
Changes to the <daedalus_response> super-class to add an optional string identifier to identify pre-defined scenarios.
Helper functions added for the new NPI class;
Minor edits to the <daedalus_response> super-class to accommodate the NPI class;
Minor edits to <daedalus_vaccination>;
C++ daedalus::inputs::read_response now reads <daedalus_response> class member name.
From this version onwards, daedalus requires daedalus.data >= v0.0.3 to provide the data closure_strategy_names and closure_strategy_data.
This patch version adds the use of HFR and hospital transition rates to calculate competing rates within the C++ code, which was previously handled in daedalus.data.
A next step will be to implement transitions out of the H compartment as conditional probabilities, rather than competing rates.
Previous versions of daedalus which rely on daedalus.data and the old parameter sets are now superseded. Please update daedalus.data to version 0.0.2 if you intend to continue working with this new version of daedalus.
This patch version implements changes to the <daedalus_response> super-class that allows events to end on increasing or decreasing roots on state. This is mostly (and currently only) to help end vaccination after a specific number of doses have been given out. This patch currently only applies to vaccination, with other events being updated later.
This patch version adds the function get_fiscal_costs() to calculate the costs to governments of pandemic response. These are calculated as post-processing on a model run, given some user-specified assumptions about public spending, interest rates, and tax rates.
This patch version overhauls how events are represented and handled in R.
<daedalus_vaccination> now requires a country to be specified so that the uptake-limit can be respected by the event (but it does not yet, see Notes and PR #91).Adds the <daedalus_response> S3 super-class in R from which event sub-classes should inherit;
Adds the daedalus::inputs namespace to C++ with a function to read the response class from R and generate a daedalus::events::response;
Implements <daedalus_vaccination> inheriting from <daedalus_response> and passing to C++ using read_response. Also changes how <daedalus_vaccination> is initialised to account for state-based event-ending.
<daedalus_vaccination>s require changes to daedalus::events::response to allow for the event to end on an increasing root (the uptake-limit); for now a pre-existing mechanism is used to ensure that the uptake-limit is respected.
This patch version logs the realised times of all events. When events are launched multiple times, the start time is updated. All start times are held as special variables in state. The NPI start time is used to determine the realised NPI end time by testing for a duration, and enables time-limitation for state-triggered events. Other events do not have a fixed end time (other than NPI-linked social distancing).
make_duration_test to class daedalus::events::response. Events are now treated as having a start time and a duration, rather than an end time.Note that this change makes it more likely that short-duration state-triggered events will be launched multiple times in a single simulation run of 600 days. This will result in unpredictable closure durations in most cases, as closures can be launched by breaching hospital capacity.
Added class member function make_duration_test to class daedalus::events::response.
Updated get_daedalus_response_times() and get_costs() to correctly accommodate multiple closures.
Updates to input checking, output handling, tests, and documentation for time-limitations on state-triggered events.
Event data are now included in <daedalus_output> from daedalus() and daedalus_multi_infection().
daedalus::events::response member functions for event condition checks now include a check on expected flag status to prevent events which would not change flag status.
Most tests account for new closure duration calculations due to multiple epidemic peaks and event launches.
Restored model functionality where mortality is increased when hospital capacity is exceeded.
Added a new flag to the state which indicates whether hospital capacity is exceeded or not;
Promoted the hospital-capacity-exceeded mechanism to a full event that is launched and ended only on a state trigger;
Updated some daedalus::events::response class to accept a vector of states to sum for state-off triggers;
Updated daedalus::events::response to generate only events with a known time or state trigger;
Fixed an issue first seen in PR #91 where using 0.0 as a dummy or null state values caused events to trigger unexpectedly, now using R provided NA_REAL in inst/dust/daedalus.cpp.
Implements a new vignette with a technical description of the model.
Patch version to correct erroneous book-keeping of costs due to absences and closures; tests added to check that absence costs are not very low.
Splits off spontaneous social distancing from being linked with NPIs, and fixes a bug where specifying response = "none" left social distancing on by default.
New argument auto_social_distancing in both daedalus() and daedalus_multi_infection() allows this feature to be off, independent and on all the time, or linked to NPIs and on only when NPIs are active.
Patch version to allow passing a list of infection objects to the Daedalus model using the new function daedalus_multi_infection(). This helps model multiple different pandemics on the same population, or to model uncertainty in outcomes due to uncertainty in infection parameters for a single pandemic pathogen.daedalus_multi_infection() returns a list of output objects.
Added a vignette showing how to use daedalus_multi_infection();
Added functions to more cleanly handle inputs to daedalus() and daedalus_multi_infection();
Some functions used in v0.1.0 have been removed.
Fixes to construction of initial model state.
This patch renames daedalus2() to daedalus(). All references and helper functions for daedalus2() have replaced their daedalus() equivalents, if any.
This patch version replaces all calls to daedalus() with daedalus2(); this excludes equivalence tests. Some tests have been updated to conform to the function signature of daedalus2(); this is mostly related to how the NPI triggering hospital threshold is passed to the function.
This patch version adds a response_duration argument to daedalus2(), and tests for time-limited responses.
This patch version adds logging of new vaccinations in each age and economic group.
daedalus2() now returns data on new vaccinations and is compatible with get_new_vaccinations(); new vaccinations are stored as a vector of the size of age + economic groups after the main state but before the model flags;
daedalus_ode does not zero new vaccinations - this is handled by get_new_vaccinations();
daedalus2() accepts optional ODE control arguments for dust2 via ...;
Internal function prepare_output_cpp() accommodates new vaccination data in output.
daedalus_ode class no longer zeroes data compartments for new infections and new hospitalisations --- this is handled by the pre-existing get_incidence() function. This change will be reversed in a future rewrite of get_incidence();
<daedalus_country> class takes argument group_working_age for the index of the working age group;
<daedalus_output> class prints information on country, epidemic, and response;
Added FLAG_NAMES for variables in dust2 output to remove;
Added internal function get_daedalus2_response_times() to extract event data from daedalus2_internal() for <daedalus_output> class;
daedalus2() returns <daedalus_output> class object similar to daedalus();
Removed some constants associated with now-removed daedalus_rtm() function;
Function prepare_output_cpp() rewritten to handle output from daedalus2_internal();
Updated tests for classed output from daedalus2();
<daedalus_output>; these will be switched on in future.Added continuous benchmarking for daedalus2();
Updated vignette on daedalus2() for classed output.
Added public-concern social distancing to daedalus2(), and re-added it to daedalus(); this reverses the removal in v0.2.3. The functions are equivalent: social-distancing is active only when an NPI is active.
Added a filter on NULL to daedalus2() parameter collection step - this helps remove parameters and allows treating missing values as a meaningful indicator in the C++ code (as 0.0 can be a valid value in many cases).
Removed default response duration of 60 days in daedalus2() as this is not present in daedalus() leading to non-equivalence in tests.
daedalus2() output type is now a two-element list with event data included. Time-series data are in data. This output type will be converted to <daedalus_output> in future versions.
This patch version implements a response class to better organise event handling. All events can be launched and ended at specific times, or by specific state variables crossing threshold values. Only some of these triggers can be controlled by the user from R; others are hard-coded in C++:
NPI response start time is added as an argument to daedalus2() similar to daedalus();
NPI response starts on hospital_threshold (a country parameters) being crossed;
NPI response is intended to end when the incidence-prevalence ratio reaches the recovery rate (for asymptomatic infections); this does not appear to work as the solver jumps over this root.
Vaccination start time can be specified by the user in the vaccination object or strategy; no specific end triggers are specified as vaccination rate $\nu$ is scaled within the ODE RHS to decline as the uptake limit is reached.
Added class response under namespace daedalus::events to be a general data structure and lambda generator for NPI and vaccination events.
Added response objects to shared state to hold event parameters that were previously floating around; reorganised parameter reading.
Replaced contents of events struct in daedalus_ode class with response member functions for NPI and vaccination objects.
Removed state variables logging response start and end times.
Added a mechanism to have vaccination switched on from model start time if specified by users in a <daedalus_vaccination> object passed to the vaccine_investment argument; this is because {dust2} events cannot root-find on time at t = 0 --- see linked PR.
dummy_vaccination() allows creation of a <daedalus_vaccination> with start time = 0 using internal class constructor. Vaccination class validator now accepts "dummy" as a valid vaccination strategy name. This is not affected by the changes to the initial vaccination flag (all other parameters are also set to 0.0).This version adds the response strategy functionality, with response start and end implemented as {dust2} events.
mrc-6531;Country class returns hospital capacity and population size;
Vaccination class returns uptake limit and start time.
Added N_FLAGS constant and initial_flags().
Flags are implemented as state variables.
Flag relative positions in state added to constants header.
Renamed helper function daedalus::helpers::zero_which to get_state_idx;
Helper function daedalus::interventions::switch_by_flag added to interventions helpers header; used to switch vaccination rate and implement NPIs.
growth_flag.Added tests for events;
NOTE: Skipping test for response ended by epidemic shrinking as solver jumps over root; awaiting fix for this.
Adds a correction for reducing eligibles to vaccination in daedalus2() by re-implementing scale_nu() in C++. Adds a simple test for vaccination uptake limit.
Adds C++ headers for types and dimensions.
The vaccination class <daedalus_vaccination> has renamed invariants. Workflows using custom vaccination regimes will break. No issues are expected for the dashboard.
daedalus now requires R > v3.5 (due to use of package data) --- this is a belated update.
daedalus2() supports infections for the vaccinated stratum similar to daedalus(); vaccination is now leaky. The default is absolutely no vaccination, which differs from daedalus() where 'none' refers to advance investment;
daedalus() takes vaccine efficacy and waning period from the vaccine_investment argument, see below;
<daedalus_vaccination> has been updated with shorter invariants that drop prefix vax from names;
<daedalus_vaccination>s now hold information on the vaccine efficacy (single value) and waning period (single value); these can be modified using the construction helper daedalus_vaccination() or the set_data() method;
A new prepare_parameters2() method for the vaccination class to satisfy daedalus2();
Tests for vaccination working in daedalus2();
Updated to function documentation for changes to vaccination class.
Code formatting using Air, added air.toml and disabled commas_linter as it conflicts with Air.
daedalus() no longer includes auto-social distancing; this is to check for equivalence with daedalus2(). This will be re-added once the event-trigger mapping feature is developed.
daedalus2() implementation of vaccination is very basic: vaccination begins at model start time and does not end, vaccination does not correct for reducing eligible population, vaccination is non-leaky
Added full DAEDALUS ODE structure to daedalus_ode class for daedalus2() -- except events, auto-social distancing, and excess mortality; daedalus2() accepts country and infection similar to daedalus().
daedalus2() takes vaccination arguments for vaccination rate and waning rate.Fixes consumer-worker contact scaling in daedalus2().
daedalus_ode class uses Eigen::Tensor over Eigen::Matrix for numerical operations.
Added inst/include/daedalus_constants.h for model related constants;
Added inst/include/daedalus_helpers.h with function zero_which() to return compartments to zero.
prepare_parameters2() and make_initial_state2() for use with daedalus2().Added more tests for output expectations and fixed population size for daedalus2().
Added tests for equivalence between daedalus() and daedalus2().
Added function documentation and updated replacement DAEDALUS vignette.
Update .lintr for lintr v3.2.0.
This version adds support for including contact matrices in the daedalus class object and using them in the FOI calculation.
This is a patch version of {daedalus} that builds up to combining daedalus::daedalus() with daedalus::daedalus_rtm().
Breaking changes
daedalus_rtm() has been removed; please see installation instructions in the Readme for how install a {daedalus} version that provides it;
{Rcpp} and {RcppEigen} have been replaced with {cpp11} and {cpp11eigen};
Tests using daedalus_rtm() have been removed;
Continuous benchmarking removed for daedalus_rtm().
Changes for dust2 implementation
Dependencies {dust2} and {monty} added;
Added successor function daedalus2() which will replace daedalus();
Toy SEIR model with flexible number of demographic strata added in inst/dust/daedalus.cpp; this will build up to the full model;
Infrastructure files updated for changes above;
Added small vignette to check functionality;
Added small header and package header with a helper function zero_which() in daedalus::helpers namespace to identify which compartments in the state to zero with zero_every().
This is a minor version release of {daedalus} that adds real-time epidemic modelling functionality while removing the implementation of vaccination and vaccination-group infection pathways. There are no intervening versions between this and v0.1.0.
NOTE: This version has the following identified errors:
Consumer-to-worker infections are not correctly handled leading to later and lower epidemic peaks than expected.
The number of recovered does not include recoveries from hospitalisation.
Changes
Added new function daedalus_rtm() (for real-time modelling) which returns either a <daedalus_output> object or a list of these.
Has an Rcpp backed using RcppEigen and Boost Headers {BH} for Boost odeint solvers; added Rcpp, RcppEigen, and BH as dependencies;
Removes reactive intervention implementation and lifting; instead a single intervention on economic sectors can be passed for implementation in a user-specified time-frame ;
Allows NPI on social contacts (basic scaling of transmission rate $\beta$) when economic sector NPI is active (default is 1.0 for no distancing); see arg social_distancing_mandate;
Allows spontaneous social distancing mediated by daily deaths to be turned on (off by default); see arg auto_social_distancing;
Allows passing a 45-element numeric vector specifying sector-wise openness coefficients;
Allows passing a list of <daedalus_infection> objects to infection to accommodate parameter uncertainty (in this case it returns a list of <daedalus_output>);
Hosptial capacity only determines when excess mortality is activated;
Initial state asumes 1 in 10 million infected.
Added C++ code in src/daedalus.cpp to help with ODE RHS, observer for ODE system, looping over parameter combinations, and exposing C++ code to R.
Added functions to help with daedalus_rtm():
prepare_output_cpp() to handle output from Rcpp fn (returned as list of matrices);
make_conmat_large() prepares a 49 $\times$ 49 contact matrix for C++ ODE RHS;
make_work_contacts() and make_consumer_contacts() scale contacts by workers in economic sectors -- $N$ in $\beta SI \text{CM} / N$.
Package classes:
<daedalus_country> now returns life expectancy vector;Package data:
Exporting economic sector names;
Exporting country-wise life-expectancy data;
Added C++-model compartment names as a constant.
Downstream functions:
get_costs() returns life-years lost; values of lives lost vector is renamed to life_value_lost
get_life_years_lost() calculates life-years lost from total deaths and life-expectancy.
Package infrastructure:
Updated .Rbuildignore, .gitignore, .lintr, _pkgdown.yml, WORDLIST for C++ code;
Updated Readmes to reflect package title and scope;
Added basic tests for daedalus_rtm().
This is a minor version release of {daedalus} for use in the IDM conference in 2024.
NOTE: This version has been found to have the following identified errors:
This patch version adds a vignette on exploring the effect of parameter uncertainty on overall pandemic costs, and updates other vignettes and improves documentation.
This patch corrects epidemic dynamics:
Replaces $R_0$ in force of infection calculations with transmission parameter $\beta$;
Adds a new function get_beta() to calculate model $\beta$ for a country and infection (thanks @patcatgit);
Corrects the implementation of r_eff() to use model $\beta$;
Corrects prepare_parameters.daedalus_country() to provide appropriate contact matrix values;
Adds tests to check newly added functions.
There is a noticeable speed loss due to repeated calls to base::eigen() and base::solve() in r_eff().
This patch makes the infection IFR values available for the DAEDALUS-relevant age group in infection_data and in <daedalus_infection> objects under the name "ifr".
This patch updates and corrects the cost of school closures by adding lost earnings, with simplifying assumptions of a single school-age cohort, that all school age children are in school, a single value of the number of expected work years, and a constant global value of the effectiveness of remote education.
Educational losses are now a function of number of school days lost to closures, the country per-capita GNI, the number of school-age children, the effectiveness of remote education, and a coefficient of lost earnings.
This calculation replaces the previous value of educational losses, which was the education sector GVA loss over the closure period. The education sector GVA loss is now added to the overall economic losses.
Educational losses due to absences are still calculated as GVA losses due to worker absences, and not in terms of lost earnings for students due to student illness and absence.
Added internal function get_value_lost_earnings() to get a (constant) coefficient for the value of earnings lost due to lost education;
Added internal function get_value_school_year() to get the value of a school year for any country GNI (gross national income per capita).
Added package constants i_SCHOOL_AGE, edu_effectiveness_remote (0.33), edu_annual_ror (0.08), and earnings_loss_discount (0.03)
This patch updates the state variable in daedalus() to substantially reduce the number of compartments; all empty compartments have been removed. This improves the speed of model runs as there are fewer derivatives to calculate.
State variable is a 3D array with the dimensions: c(49, 9, 3). The working-age economic sectors are added on as rows after the age-groups. Epidemiological compartments are unchanged. The third dimension holds data on vaccination status, including new vaccinations.
Helper functions are updated to support the new state dimensions.
$R_t$ calculation in r_eff() has been simplified to the proportional susceptible times $R_0$, pending a more accurate calculation.
The internal helper function prepare_output() has been refactored to avoid use of base::array2DF() to remove the dependency on newer versions of R.
Removes unused between-sector contacts in force-of-infection calculations.
Moves some contact scaling to the parameter preparation stage to reduce operations during the model run.
Correctly sums the total number of infectious individuals in the community; previously, the implementation resulted in segregation by economic sector.
This patch adds functionality to run daedalus() with the country argument passed as one of country_codes_iso2c or country_codes_iso3c for 2 and 3 letter ISO country codes.
This patch adds logging of daily new vaccinations and provides an output helper function, get_new_vaccinations(), to get daily new vaccinations.
Adds a third layer to the fourth dimension to the state array to hold new vaccinations;
Adds a new helper function values_to_state() to convert a vector to the state array;
Updates a number of indexing operations to disregard the new data layer of new vaccinations;
Updates daedalus(), prepare_output() and make_initial_state() to account for the new vaccinations layer;
Updates tests for newly added functionality.
This patch removes dual implementation levels for response strategies. The "elimination" strategy has a "high" implementation level, while all other strategies keep their "light" implementation level.
The daedalus() argument implementation_level has been removed.
Tests and documentation have been updated to remove references to implementation levels.
This patch fixes an issue where vaccination start was tied to the response_time; it is now correctly controlled by the vaccine investment level passed to daedalus().
Added a vax_switch which is manually turned on in stage 03 of the model (never turned off);
Added test to check that there is no vaccination before scenario-defined start times;
Added tests to check that vaccine investment levels control epidemic deaths.
This patch fixes an issue where closures were not ended in model runs where the closure began after the epidemic had stopped growing. This mostly affected edge cases of countries with large spare hospital capacity, and relatively late response_times. In such cases the closure end time was assigned as the simulation end time, inflating costs related to closures. The fix:
Prevents closures from being activated by the hospital_capacity trigger if the epidemic is not growing, even if the hospital capacity threshold is crossed;
Prevents closures from being activated by the response_time trigger if the epidemic is not growing between stage 01 and stage 02. Closures are manually turned off if the epidemic is not growing ($R_t < 1.0$).
Tests for different response times check that the model behaves as expected.
The package now requires a minimum R version >= v4.3 due to the use of the new function array2DF();
prepare_parameters.daedalus_country() now provides a contact matrix scaled by the leading eigenvalue but not the demography for use in r_eff().
This patch adds vaccine investment scenarios to daedalus. All model runs must now include an assumption about the level of advance vaccine investment, defaulting to "none".
Added vaccine investment scenario related data: vaccination_scenario_data for vaccination parameters, vaccination_scenario_names, and vaccination_parameter_names.
Added the <daedalus_vaccination> S3 class to hold vaccination parameters, along with class infrastructure (print, get/set, and prepare_parameters() methods).
Added helper function daedalus_vaccination() to return vaccination object corresponding to four vaccine investment scenarios.
Added tests for vaccination class, model runs with vaccination, and updated documentation.
This patch version adds ISO 3166 2- and 3- character country codes for the countries in country_names, as the package data country_codes_iso2c and country_codes_iso3c.
This patch version adds functions to summarise model outputs (#30):
get_incidence() provides per-timestep (daily) values of one or more of infections (symptomatic and asymptomatic), hospitalisations (or the demand), and deaths, disaggregated by one or more of the following groups: age group, economic sector, and vaccination status.
get_epidemic_summary() provides the total number of individuals infected, hospitalised, and dead, in one or more groups, while defaulting to providing an overall summary.
The model state variable now includes values tracking daily infections (susceptible to exposed) and daily hospitalisations.
Basic tests added for these functions.
Package data.table imported to help with model data output processing.
This patch version corrects spare hospital capacity data by using corrected versions of the raw hospital capacity data (#31).
The country_data and country_names package data has also been updated. Thailand is now available as a country.
This patch version adds a basic vaccination functionality, which is controlled by the newly added vaccination_rate parameter to daedalus()
Vaccination starts when a response is triggered, and is active even in the 'no closures' scenario;
Vaccination rate and start time is uniform across age groups;
Vaccine-derived protection (reduced susceptibility) is represented by hard-coded parameter tau, and the waning of this protection is also hard-coded and represented by parameter psi. Default values are 0.5 and 1 / 270, respectively;
$R_t$ calculation in r_eff() includes reduced susceptibility for vaccinated individuals.
Internal changes include:
The system state is now represented as a 4-dimensional array, with the vaccination groups/strata on the 4th dimension (see package constant DIM_VACCINE_STRATA);
ODE system has been updated to include reduced susceptibility and movements between vaccination strata;
Vaccination rate nu is represented in terms of the proportion of the total population, and the internal function scale_nu() increases nu as the number of individuals eligible for vaccination decreases.
Added tests for vaccination functionality.
This patch version adds a spontaneous social distancing mechanism to the model in the internal function get_distancing_coefficient(), which modifies the infection transmission rate based on the number of new deaths. The intention is to model public concern that leads to a spontaneous reduction in community social contacts.
lower_limit (arbitrary value of 0.2) using an exponential decay function.This patch adds hospital capacity data and two downstream effects.
Spare hospital capacity data raw data file has been added to inst/extdata. A processing script to generate an intermediate dataset has been added to data-raw/. The number of countries with available data has been reduced to 41.
<daedalus_country> class objects now provide spare capacity data.
A call to daedalus() now takes the response_threshold from the country-specific hospital capacity by default. Users can still pass a custom value to override the package data.
The model's mortality rate omega is increased by 1.6x when the total number of hospitalisations exceed the spare hospital capacity. This is implemented using a switch hosp_switch mutable parameter, and the switch activation and termination is rolled into the event functions that control closures.
Added tests to check that hospital capacity has expected effect.
This patch adds functionality to calculate pandemic costs using the newly added function get_costs().
This patch also adds life_value, a list of country-wise, age-specific values of statistical life lost as package data.
Other changes:
Data preparation scripts and raw data that are used to generate the life_value data. Subsetting the countries to those for which this data is available leaves 67 countries; Taiwan and Hong Kong are removed due to lack of life value data.
<daedalus_output> now includes a measure of the total simulation time which could be useful for future calculations of percentage GDP loss.
<daedalus_output> also returns the openness coefficient vector associated with the model response strategy.
Tests and documentation for all changes in the form of function docs and vignette updates.
Package data.table now imported for use in cost calculations.
Package DESCRIPTION updated to reflect scenario modelling rather than optimisation.
This patch adds the <daedalus_infection> class to represent and hold infection parameter data for daedalus(). Access, assignment, and print methods are also added, in addition to internal helpers such as as_country(). The class is tested with newly added tests.
Other changes:
The get_data(), set_data() and prepare_parameters() generics now have methods for <daedalus_infection>s.
Removes make_infection_parameters() in favour of prepare_parameters.infection().
daedalus() argument epidemic accepting epidemic name string is changed to argument infection accepting <daedalus_infection> objects or epidemic names.
Vignettes have been updated to use <daedalus_infection> objects.
Website reference page updated to have sections.
This patch adds the <daedalus_country> class to represent country and territory data for daedalus(). Access, assignment, and print methods are also added, in addition to internal helpers such as as_daedalus_country(). The class is tested with newly added tests.
Other changes:
Adds the generic functions get_data(), set_data() and prepare_parameters(), with methods for <daedalus_country> objects. Methods for infection data are also anticipated.
Removes make_country_parameters() in favour of prepare_parameters.daedalus_country().
daedalus() accepts its first argument as either a country name or a <daedalus_country>, and no longer accepts a country_params_manual argument; all changes to country parameters should be made via the class.
make_initial_state() works on <daedalus_country> objects instead of country names. Since this is an internal function it does not support passing a country string name.
Vignettes have been updated to show how to use <daedalus_country> objects.
This patch adds some basic pandemic response functionality (#15). This functionality is shown in a new vignette thresholded_interventions.Rmd.
The function signature for daedalus() has been changed to accept response_strategy, implementation_level, response_time, and response_threshold arguments which specify these parameters. Sensible defaults for the strategy are "none", and a "light" implementation level for other strategies.
The model supports the "none", "economic closures", "school closures", and "elimination" strategies, with economic sector openness coefficients for the "light" and "heavy" implementation of these strategies stored in the package data object closure_data. The data-raw/closure_data.R file shows how this data is generated from raw data files provided by EPPI and added in inst/extdata.
Closures are triggered by the response time being reached, or the total hospitalisation reaching the response threshold. The state variable has been expanded by one to accommodate a switch that is initially zero, is changed to one (for on) when the response is activated, and back to zero when the response ends. Responses currently end on the same trigger of the effective R being less than 1.0.
The make_parameters() function has been split into make_infect_parameters() and make_country_parameters() to be clearer and more manageable. daedalus()-level override for parameters which was originally implemented as ... has been replaced with three separate overrides: country_params_manual, infect_params_manual, and initial_state_manual, for users to pass custom values.
prepare_output() has been made internal; it omits data for non-working age groups in economic sectors (as these are always 0), and pads all sector numbers to fit the format sector_XX.
Internal functions for R effective calculations and getting the total hospitalisations, r_eff() and get_hospitalisations() have been added.
Closures are implemented as deSolve::events triggered by a rootfinding function, with separate functions for activation and termination, which are implemented as make_response_threshold_event() and make_rt_end_event().
contacts_between_sectors is now set to 0.0, it was previously 1e-6.
Added tests for closure triggers having expected effects; but closure end points are not specifically tested.
This patch version adds workplace infections to the epidemiological model, and adds country demography data.
Added worker-to-worker infections within and between sectors, and consumer to worker contacts (#9).
Added package data: country_data (country demography data) and economic_contacts (sector-wise contacts data). Note that worker-to-worker contacts between sectors currently takes a dummy value as it is not expected to be used in the near future (#11).
Modified daedalus::daedalus() to take a single required argument for country name to run the model with package data for country contact matrices and economic and demographic data (#11). Users can still pass infection parameters via ....
Made package function default_parameters() internal and renamed to make_parameters(); added the internal helper function make_initial_state() to quickly generate country-appropriate initial states.
Added documentation and tests for modified function calls.
This patch version adds a basic epidemiological model (#7).
Added the model functions daedalus() (user-facing) and .daedalus_ode() (internal) to run a simple age-stratified (4 age groups) SEIR-HD epidemiological model taken from @robj411 https://github.com/robj411/p2_drivers,
Added default model parameters in default_parameters() which correspond roughly to pandemic influenza,
Added prepare_output() to prepare daedalus() output,
Added tests for all functions,
Updated the package infrastructure: DESCRIPTION, NAMESPACE, WORDLIST, .Rbuildignore, and _pkgdown.yml reference.
Disabled the undesirable_function_linter in the vignettes as it flags library() calls.
Updated the Readme and added content to the 'Get started' vignette.
Initial package setup including GitHub Actions workflows and code quality checks.
Updated GH Actions workflows for R CMD check (fails on 'NOTE') and code test coverage;
Added linting, citation update, Readme rendering, and license year update workflows;
Added spellchecking and a known words list.