CMA_polypharmacy() crash due to not properly handling the new internal suppress.special.argument.checks argument (now there's also a unit test for CMA_polypharmacy to avoid such bugs in the future).now plot() respects the order of patients given through the patients.to.plot argument.
plotting sliding windows and per episodes can now show the events and gaps (as for simple plots, but things are a bit more complicated as different windows/events might result in different estimates).
plot() has an "advanced" parameter do.not.draw.plot which, when TRUE, does not draw the plot but only the legend, allowing its display separate from (or next to) the plot.
AdhereR is compatible with the pipe operator (%>% or |>), the overview vignette now shows several examples.
the overview vignette now shows an example of modifying an AdhereR plot a posteriori by adding various elements (lines, symbols and text) to a CMA plot.
the Python 3 wrapper (bridge) was updated, as was the associated vignette; AdhereR can now be used transparently from Junyper Notebooks (and even through rpy2) and two example notebooks have been included.
the event.info table returned by the simple CMAs (CMA1..CMA9) now includes an extra column, .EVENT.USED.IN.CMA, which is TRUE if and only if the event on that row was actually used to estimate the CMA; this info can be used by itself, but is aimed at finding out which event is included in which episode or sliding window (see below).
CMA_per_episode and CMA_sliding_window can now return the mapping between events and episodes or sliding windows, if the parameter return.mapping.events.episodes or return.mapping.events.sliding.window (respectively) is set to TRUE; in this case, there is an extra component of the constructed object, called mapping.episodes.to.events or mapping.windows.to.events respectively, which give, for each event or sliding window, the row number (in the data) of the event(s) that participate in it.
plotting a CMA_per_episode or CMA_sliding_window object with a mapping.episodes.to.events or mapping.windows.to.events component, respectively, can how which events belong to which episode or sliding window visually, if the parameter print.episode.or.sliding.window is set to TRUE.
plot()'s align.all.patients and align.first.event.at.zero did not work as intended.
the unneeded columns of the data argument to the CMA functions are now ignored, avoiding cases where "reserved" column names might be used (moreover, there is now an explicit check against using such reserved column names).
various other enhancements and bugfixes.
CMA_polypharmacyremove option to supply medication class as list after .check.medication.class was suppressed from AdhereR.
specify columns to merge by.
this introduces the concept of "medication groups" which represent subsets of observations for which CMAs can be computed and which are grouped together in the plots; this prompted massive changes in the output of the various CMA functions and in the plotting when medication groups are defined, but is full backward-compatible when no medication groups are defined (the default).
compute.treatment.episodes() and, in consequence, CMA_per_episode(), have a new argument, maximum.permissible.gap.append.to.episode, which specifies if the maximum permissible gap is to be appended to the episodes (FALSE by default).
the Shiny (>= 0.2) interactive interface is aware of medication groups and maximum.permissible.gap.append.to.episode.
better and faster SVG plotting, better semi-interactive HTML+SVG+JavaScript+CSS output, which can be used for display in any standard modern web browser without online R processing (i.e., overnight batch-mode generation of the plots and CMA estimates for later display and further processing).
various enhancements and bugfixes.
this release splits the old AdhereR package into two packages: AdhereR, which continues to implement all the computations and plotting, and AdhereRViz, which implements all the interactive plotting and GUI (using either RStudio's manipulate and Shiny); while AdhereRViz requires AdhereR, AdhereR only suggests AdhereRViz.
the plotting can be done either using R plotting and/or by generating SVG images (which can be further exported to different formats, such as JPG and PNG and can be embedded in HTML/CSS/JavaScript pages with limited interactivity).
new subtype of plot where the events are shown on the same row (i.e., without vertical separation): useful for cases where not many events overlap in time and vertical space is at a premium.
other enhancements and bugfixes.
major improvements to compute_event_durations, with a complete makeover of the handling for special periods like hospitalization and restructuring of the output.
New function prune_event_durations to remove leftover supply from previous dispensing events in case of new dispensing events within a user-specified time after dosage changes, special periods, or treatment interruptions.
New function cover_special_periods to identify special periods that are in proximity to already covered durations and add an additional event for these durations.
New option treat.epi in function CMA_per_episode to specify precomputed treatment episodes for the computation of CMA per episode.
New vignette Data preparation for computing adherence to medication in AdhereR added to explain the functions compute_event_durations, prune_event_durations, cover_special_periods, and time_to_initiation.
compute_event_durationsfixed a few instances where colnames were hardcoded to colnames in example dataset
throw errors when disp.date, presc.date, total.dose, or presc.daily.dose contain NAs
fix error when visit.colname is not in presc.data
fix progress bar when ID's are not sequentially starting from 1
Shiny App: don't show print and plot dose UI for CMA1-CMA4 (these don't care about dose)
Shiny App: refactor it so it can be started independently from outside the package (allowing it, for example, to be hosted on https://www.shinyapps.io/)
plotting CMA1+ and complex: fix crash when no treatment column was defined but there was a dose column
major improvements to the interactive Shiny plotting, now a fully self-contained point-and-click user interface/App for plotting and estimating CMA from a variety of data sources
new vignette AdhereR: Interactive plotting (and more) with Shiny added for explaining the new Shiny App
now can plot dose as text and/or line width
show a warning if the user calls CMA functions with arguments that are ignored by that particular CMA (useful to make the user aware that, for example, carry-over will not be considered by CMA1 and then wonder why asking for it didn't change anything)
various plotting improvements (axis lables, vertical lines, legend customisation, font sizes, customisable OW transparency, better computation of minimum size requirements)
plot.CMA0 ignored grascale plotting for OW and FUW
legend now is resized depending on the various legend font sizes and not on the global font sized
better handling of font sizes of 0 (now forced transparently to 0.01)
better handling of 0% for the CMA estimate plot for CMA1+, per episode and sliding windows
small bugs fixed in compute_event_durations()
better handling of messages, warnings and error during plotting
uniformisation of plotting between all types of CMA
error when passing a data.table to interactive plotting;
in plot.CMA0, align.all.patients=TRUE didn't work anymore (regression);
time_to_initiation() was not exported;
the examples for time_to_initiation() and compute_event_durations() were wrongly formatted.
removed margins when plotting CMA0 (they could become too large when plotting many patients);
now allows the custom placement of legend when plotting CMA0;
the plots for CMA0-9 can now also show the daily dose as text and/or line thickness.
AdhereR can access data (read and write) stored in various types of databases, ranging from "classic" relational databases (such as MySQL and SQLite) to new approaches (such as Apache's Hadoop).
This allows the seamless processing of very large datasets across many types of architectures, ranging from a consumer-grade laptop to large heterogeneous computer clusers, without loading the dataset in memory.
Even interactive plotting is now capable of accessing data stored using various engines in real-time by allowing the user to define accessor functions that implement the details of this access (e.g., use SQL queries for accessing data stored in a classic relational database).
A new vignette (Using AdhereR with various database technologies for processing very large datasets) gives all the needed details, including actual code, for running AdhereR on relational databases (using either explicit SQL or implicitely through dbplyr) and on Apache Hadoop (using RHadoop for access to HDFS and MapReduce).
(Please note that this vignette is pre-compiled due to its requirements in terms of thrid-party software such as MySQL and Apache Hadoop.)
Computation of CMAs requires a supply duration for medications dispensed to patients.
If medications are not supplied for fixed durations but as a quantity that may last for various durations based on the prescribed dose, the supply duration has to be calculated based on dispensed and prescribed doses.
Treatments may be interrupted and resumed at later times, for which existing supplies may or may not be taken into account.
Patients may be hospitalized or incarcerated, and may not use their own supplies during these periods.
The new function compute_event_durations calculates the supply durations, taking into account the aforementioned situations and offering parameters for flexible adjustments.
The period between the first prescription event and the first dose administration may impact health outcomes differently than omitting doses once on treatment or interrupting medication for longer periods of time.
Primary non-adherence (not acquiring the first prescription) or delayed initiation may have a negative impact on health outcomes.
The new function time_to_initiation calculates the time between the first prescription and the first dispensing event, taking into account multiple variables to differentiate between treatments.
overall optimisation of the workhorse functioncompute.event.int.gaps(), resulting in sizeable speed-ups in some scenarios;
replacing the direct use of snow by parallel, dropping thus this explicit dependency;
initial introduction of unit testing (testthat; currently not on CRAN but only during development);
distributing computations across multiple computers over a network;
small bug fixes in plotting and cma computation.
While the original interactive plotting using RStudio's manipulate() function was useful, it had several limitations (dependence on RStudio, interface design, etc.), prompting a massive rewritting of the interactive plotting system using Shiny.
The old manipulate() method is still available, but the new one based on Shiny offers multiple advantages, such as running in any modern web browser and even on a remote machine.
AdhereR is now tansparently callable from other programs/platforms than R using a very simple, transparent and portable mechanism.
To illustrate the full process, we implemented a fully functional reference implementation allowing AdhereR to be transparently used from Python 3, implementation consisting of a Python module adherer included with the AhdereR package (thus it does not need separate installation through pip or similar mechanisms) that automatically detects where R is installed and exposes a class hierarchy that can be used in Python scripts or programs.
Full details are available in the new calling-AdhereR-from-python3 vignette.
This is the initial release. Please see ReadMe.md and the accompanying paper for details: