Package 'cd2030.core'

Description

add_mad_med_columns calculates and appends the median and Median Absolute Deviation (MAD) for specified indicators in a dataset. These statistics are calculated per group, allowing the user to dynamically group data (e.g., by district) and exclude data from the most recent year in the dataset.

Usage

add_mad_med_columns(.data, indicators, group_by = "district")

Arguments

Details

• The median and MAD are calculated for each group specified by group_by.

• Only data from years prior to the most recent year in the dataset are considered.

• Missing values in the calculated statistics are replaced using robust_max(), ensuring that meaningful fallback values are provided.

Value

A tibble with additional columns for each indicator, named ⁠{indicator}_med⁠ and ⁠{indicator}_mad⁠, containing the calculated median and MAD, respectively.

See Also

• add_outlier5std_column() for generating outlier flags based on these columns.

• robust_max() for calculating max value

Examples

## Not run: 
# Add median and MAD columns for 'indicator1'
add_mad_med_columns(data,
  indicators = "indicator1",
  group_by = "district"
)

## End(Not run)

Description

add_missing_column assesses data quality by identifying missing values for specified health indicators. It generates new columns for each indicator, flagging values as 'Missing' (1) or 'Non-Missing' (0) to support downstream quality control and analysis.

Usage

add_missing_column(.data, indicators)

Arguments

Details

• Missingness Assessment: Each indicator is processed to flag missing values (NA) with 1 (missing) or 0 (non-missing). The resulting columns are prefixed with mis_ followed by the original indicator name (e.g., mis_indicator1).

• Group Preservation: The output retains the district and year columns to ensure grouping information remains intact.

Value

A data frame containing:

• Missingness Flags: For each indicator, a column prefixed with mis_ indicating missingness (1 for missing, 0 otherwise).

• district and year columns to maintain grouping information.

Examples

## Not run: 
# dd missing value flags for all indicators
add_missing_column(data)

## End(Not run)

Description

add_outlier5std_column calculates and appends outlier flags for specified indicators in a dataset. An outlier is defined as a value falling outside the range defined by the median ± 5 times the Median Absolute Deviation (MAD). This method is applied on a per-group basis, allowing flexibility for grouping by columns like district.

Usage

add_outlier5std_column(.data, indicators, group_by = "district")

Arguments

Details

• Median and MAD Calculation: For each indicator, the median and MAD are calculated using data from years prior to the most recent year in the dataset. The last year is excluded to prevent potential contamination of the baseline statistics.

• Outlier Definition: A value is flagged as an outlier if it falls outside the range: Lower Bound = median - 5 * MAD Lower Bound = median + 5 * MAD

• Grouping: Calculations are performed separately for each group specified by the group_by parameter.

• Generated Columns: For each indicator, the function generates an outlier flag column named ⁠{indicator}_outlier5std⁠. The column contains 1 if the value is an outlier and 0 otherwise.

Value

A tibble with additional columns for each indicator, named ⁠{indicator}_outlier5std⁠, containing a value of 1 if the observation is an outlier and 0 otherwise.

See Also

add_mad_med_columns() for computing and appending the median and MAD columns.

Examples

## Not run: 
# Add missing value flags for all indicators
add_outlier5std_column(data,
  indicators = "indicator1",
  group_by = "district"
)

## End(Not run)

Description

The adjust_service_data function processes DHIS-2 health service data, correcting for incomplete reporting, applying k-factor adjustments for accurate scaling, and managing outliers for consistency in data analysis. This standardization supports reliable comparisons in immunization coverage and health service utilization studies.

Usage

adjust_service_data(
  .data,
  adjustment = c("default", "custom", "none"),
  k_factors = NULL,
  settings = NULL,
  steps = FALSE
)

Arguments

Details

Prepares service data through a series of steps to ensure data quality and consistency:

1. Validation: Checks the structure of .data and ensures that the adjustment argument is valid. For custom adjustments, k_factors must be specified and contain valid values.

2. k-Factor Defaults: Default k-factor values are set to 0.25 for each indicator group, unless overridden by user-provided values in k_factors.

3. Reporting Completeness: Flags any district-year reporting rates below 75% and imputes missing data using district-level medians to account for reporting inconsistencies.

4. k-Factor Scaling: Adjusts service counts based on the k-factor and reporting rate using the following scaling formula:

   $AdjustedValue = Value \times \left(1 + \left(\frac{1}{ReportingRate/100} - 1\right) \times k\right)$

   where ReportingRate is the reporting rate in percent, and k is the k-factor for the indicator group.

5. Outlier Detection: Identifies and flags extreme outliers using Hampel's X84 method, marking values that exceed 5 Median Absolute Deviations (MAD) from the median.

6. Data Imputation: Replaces remaining missing values with district-level medians to ensure data completeness.

Value

A cd_adjusted_data object containing adjusted service data, where outliers are flagged and managed, and missing values are imputed.

See Also

new_countdown() for creating cd_data objects and generate_adjustment_values() for generating adjustment summaries.

Examples

## Not run: 
# Default adjustment
adjusted_data <- adjust_service_data(data, adjustment = "default")

# Custom adjustment with specific k-factors
custom_k <- c(
  anc = 0.3, idelv = 0.2, pnc = 0.35, vacc = 0.4,
  opd = 0.3, ipd = 0.25
)
adjusted_data_custom <- adjust_service_data(data,
  adjustment = "custom",
  k_factors = custom_k
)

# No adjustment
unadjusted_data <- adjust_service_data(data, adjustment = "none")

## End(Not run)

Description

The page that shows what the adjustment changed, one indicator at a time. A chart sets each year's reported count beside the adjusted count, which is made of its parts (completeness, outliers and missing values), and a table gives the same numbers with the change in percent. A step the indicator does not get is marked "Off". Above the chart, the page lists the adjustment's rules as the reports' footnote gives them (adjustment_settings_footnote()) and says whether the data has been adjusted.

Usage

adjustment_changes_ui(id, i18n)

adjustment_changes_server(id, cache, i18n, active = reactive(TRUE))

Arguments

Details

The indicator is chosen with the card's tabs (the app's adjustment_indicators setting) or with the filter for the other indicators, which wins while it has a value. The area filter is every area, one region or one district. The page reads data_with_excluded_years, adjustment_settings, countdown_data and adjusted_flag from the dataset, and works the numbers out with generate_adjustment_values().

Value

adjustment_changes_ui() returns the page's UI as Shiny tags. adjustment_changes_server() is called for its side effects.

Examples

## Not run: 
# the page's entry in an app's page registry
cd_page_def(
  id = "data_adjustment_changes",
  ui = adjustment_changes_ui,
  server = adjustment_changes_server,
  title = "title_adjust_changes",
  section = "lbl_nav_section_quality",
  subtitle = "sub_adjust_changes"
)

## End(Not run)

Description

The numbers the Data Adjustment page shows beside its settings, from the same computations as the check pages (Reporting rate, Outlier detection, Data completeness): each indicator group's national reporting rate in year and how many districts report below threshold; each indicator's outlier months (more than 5 x MAD from the district's median) and empty months; each region's and district's lowest group reporting rate in year.

Usage

adjustment_evidence(
  .data,
  threshold = .cd_method$data_quality$reporting_threshold,
  year = NULL
)

Arguments

Value

A list: year, threshold, groups (named by group: rr, below), indicators (named by indicator: outliers, missing, months), areas (a list of list(region, rr, districts = list(list(name, rr)))).

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
data <- load_data(path)
evidence <- adjustment_evidence(data)
str(evidence$groups$opd)
str(evidence$indicators$penta3)

# Against a stricter threshold, for an earlier year
adjustment_evidence(data, threshold = 95, year = 2021)$groups$opd

Description

Validates settings as the Data Adjustment page sends them (JSON read with simplifyVector = FALSE) and returns them in one shape: numbers as numbers, flags as logicals, empty maps as empty lists, unknown groups, indicators and levels refused.

Usage

adjustment_settings_check(settings)

Arguments

Value

The settings, tidied. An error says what is wrong.

Examples

# Settings as they arrive from JSON: numbers and flags inside lists
settings <- list(
  removed_years = list(2020, 2021),
  everywhere = list(group_k = list(anc = 0.1), outliers = list(penta3 = list(FALSE))),
  areas = list(list(area = "Coast", level = "adminlevel_1", all_missing = list(FALSE)))
)
str(adjustment_settings_check(settings))

# What is wrong is refused with an error
try(adjustment_settings_check(list(everywhere = list(group_k = list(anc = 2)))))

Description

Every indicator group adjusted for completeness with the method's k (0.25), outliers corrected and missing values filled everywhere, no year or area removed.

Usage

adjustment_settings_default(k = .cd_method$adjustment$k, groups = NULL)

Arguments

Value

The settings list (see adjust_service_data()).

Examples

settings <- adjustment_settings_default()
str(settings)

# No completeness adjustment for any group
adjustment_settings_default(k = 0)$everywhere$group_k

Description

Writes the adjustment settings out in sentences, for the footnote of a report: the years and areas removed, then the rules that apply everywhere and those of each area (k factors, and whether outliers are corrected and missing values filled).

Usage

adjustment_settings_footnote(
  settings,
  group_labels = NULL,
  indicator_labels = NULL
)

Arguments

Value

A character vector, one sentence per rule. The Countdown default is one rule (each group's k, everywhere); settings that change nothing give none.

Examples

settings <- adjustment_settings_default(k = 0.1, groups = c("anc", "vacc"))
settings$removed_years <- 2020
settings$everywhere$outliers <- list(penta3 = FALSE)
settings$areas <- list(list(area = "Coast", level = "adminlevel_1", all_missing = FALSE))
adjustment_settings_footnote(settings)

# With the names a report uses
adjustment_settings_footnote(
  settings,
  group_labels = c(anc = "Antenatal care", vacc = "Immunization"),
  indicator_labels = c(penta3 = "Penta 3")
)

Description

A dataset saved before the settings existed has only its k per group and its removed years: they become the settings, everything else as the default.

Usage

adjustment_settings_from_k(k_factors = NULL, excluded_years = numeric())

Arguments

Value

The settings list.

Examples

settings <- adjustment_settings_from_k(c(anc = 0.1, vacc = 0), excluded_years = 2020)
settings$everywhere$group_k
settings$removed_years

Description

Whether completeness (a k above 0), outlier correction and filling missing values apply to an indicator in at least one district of the data (or of one area), with the settings: a step no district gets is off.

Usage

adjustment_steps_used(
  settings,
  .data,
  indicator,
  area = NULL,
  level = c("adminlevel_1", "district")
)

Arguments

Value

A named logical: completeness, outliers, missing.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
data <- load_data(path)
settings <- adjustment_settings_default()
adjustment_steps_used(settings, data, "penta3")

# A region with its own settings: no completeness adjustment, outliers left as they are
settings$areas <- list(
  list(area = "Coast", level = "adminlevel_1", group_k = list(vacc = 0), all_outliers = FALSE)
)
adjustment_steps_used(settings, data, "penta3", area = "Coast")
adjustment_steps_used(settings, data, "penta3")

Description

The fitted coverage by year (2010 to 2030), in percent like the other coverage tables: the median with its 95% and 80% intervals. A sub-national model gives a row per region and year.

Usage

bayes_model_estimates(model)

Arguments

Value

A tibble: indicator, adminlevel_1 (a sub-national model only), year, estimate, lower and upper (95%), lower_80 and upper_80.

Examples

## Not run: 
# `cache` is a dataset with adjusted data; fitting needs the Bayesian model packages
model <- cache$get_bayes_model("national", "penta3")
estimates <- bayes_model_estimates(model)
estimates[estimates$year >= 2020, c("year", "estimate", "lower", "upper")]

# a sub-national model has a row per region and year
regions <- bayes_model_estimates(cache$get_bayes_model("adminlevel_1", "penta3"))
regions[regions$year == 2023, ]

## End(Not run)

Description

The server an app lists for its Bayesian pages in its page registry. It calls bayesian_server() with an active that also starts the background workers (cd_start_bayes_workers()) each time it is read as TRUE, which happens first when the page is opened with data loaded. Starting them a second time does nothing, so the workers are started once and only for sessions that open the page.

Usage

bayesian_page_server(id, cache, i18n, admin_level, active = reactive(TRUE))

Arguments

Value

What bayesian_server() returns: a reactive that holds the key of the tab shown (an indicator's name, or "custom").

Examples

## Not run: 
# the page's entry in an app's page registry; server_args gives the admin level
cd_page_def(
  id = "bayesian_national",
  ui = bayesian_ui,
  server = bayesian_page_server,
  title = "title_bayesian_analysis",
  section = "title_bayesian_analysis",
  subtitle = "sub_bayesian",
  server_args = list("national")
)

# the same page at admin level 1 is a second entry: id = "bayesian_subnational" and
# server_args = list("adminlevel_1")

## End(Not run)

Description

The Bayesian coverage model page, shared by the apps and used at national level and at admin level 1. It has one card of charts with a tab for each indicator the app lists (cd_cfg("bayes_indicators"), by default cd_bayes_indicators), the only ones the model takes; each tab plots the model's coverage estimates by year. A model takes minutes to fit, so the fit runs in a background worker (cd_bayes_fit_task()) and the chart shows its loader meanwhile. A fit starts only when its tab is shown, from the dataset's bayes_model_inputs(); the result is kept in the dataset (keep_bayes_model()) and read back with bayes_model_cached(), so it is fitted once for an admin level, indicator and denominator. While the model's packages are missing (cd_bayes_packages_missing()) the page shows a notice and fits nothing: inside DataSuite the notice has a button that asks it to install them, elsewhere it shows the R command to run.

Usage

bayesian_ui(id, i18n, label)

bayesian_server(id, cache, i18n, admin_level, active = reactive(TRUE))

Arguments

Details

At admin level 1 the page has two filters: the region (every region compared in one year, each with its model estimate and its facility-data value, or one region followed over the years as the national page follows the country) and the year the regions are compared in. The national page has none. Apps register the page with bayesian_page_server(), which also starts the workers.

Value

bayesian_ui() returns the page's UI as Shiny tags. bayesian_server() returns a reactive that holds the key of the tab shown: an indicator's name, or "custom".

Examples

## Not run: 
# a page of your own with the same charts: start the workers, then call the server.
# The id must be a page in the app's page registry.
my_bayes_ui <- function(id, i18n) bayesian_ui(id, i18n)
my_bayes_server <- function(id, cache, i18n, active = reactive(TRUE)) {
  cd_start_bayes_workers()
  bayesian_server(id, cache, i18n, "adminlevel_1", active = active)
}

## End(Not run)

Description

The definition of one public member of CacheConnection: what it holds or returns in the methodology's terms, its kind (data, setting, reference, mapping, check, value, store, state, method, action), its grain (what one row is) and key columns, its unit, where the user sets it in the app (set_on) and which pages show it (shown_on), the methodology docs section it comes from (method), the defaults it follows (ids of cd_methodology_defaults()), and what it is computed from (depends_on). Columns are described from their names by the data dictionary, not here. status is "draft" (with a note) where the definition is not certain. cache_manifest() includes every member's definition.

Usage

cache_definition(name = NULL)

Arguments

Value

A list (one definition), a named list of all of them, or NULL when name is not a public member.

Examples

cache_definition("adjusted_data")$what

Description

Every public member of CacheConnection – method or active binding – with its arguments (defaults, and the values an argument may take when the code says), its documentation, whether it writes to the dataset, whether a custom chart may draw from it, and its definition (what the data point is, see cache_definition()); plus the report kinds. Read from the installed package, so it always matches the code; countdown-analytics builds its guide for the AI from it.

Usage

cache_manifest()

Value

A list (JSON-able with jsonlite::toJSON(auto_unbox = TRUE)): package, version, generatedAt, members and reportKinds.

Examples

m <- cache_manifest()
length(m$members)

Description

calculate_average_reporting_rate() computes the average reporting rate for each indicator by year and administrative level. For adminlevel_1, you can limit the results to a single region.

Usage

calculate_average_reporting_rate(
  .data,
  admin_level = c("national", "adminlevel_1", "district"),
  region = NULL
)

Arguments

Value

A tibble of class cd_average_reporting_rate.

Examples

## Not run: 
calculate_average_reporting_rate(data, admin_level = "adminlevel_1")
calculate_average_reporting_rate(data, admin_level = "adminlevel_1", region = "Nairobi")

## End(Not run)

Description

Computes yearly percentage of non-missing values for each indicator, along with overall completeness summaries.

Usage

calculate_completeness_summary(
  .data,
  admin_level = c("national", "adminlevel_1", "district"),
  threshold = .cd_method$data_quality$reporting_threshold,
  region = NULL
)

Arguments

Value

A cd_completeness_summary tibble:

• One row per year and group

• ⁠mis_<indicator>⁠ columns with % non-missing values

• mean_mis_all summarizing all indicators

Examples

## Not run: 
calculate_completeness_summary(data)

## End(Not run)

Description

calculate_coverage integrates immunization coverage data from three sources: DHIS2 (District Health Information Software), survey-based estimates, and WUENIC (WHO-UNICEF estimates). The combined dataset is prepared for analysis at various administrative levels.

Usage

calculate_coverage(.data, survey_data, wuenic_data, subnational_map = NULL)

Arguments

Value

A cd_coverage data frame containing harmonized coverage estimates for each year from DHIS2, WUENIC, and survey data. Includes metadata for administrative levels, regions, and denominators.

Examples

## Not run: 
calculate_coverage(precomputed_data, survey_df, wuenic_df)

## End(Not run)

Description

Calculates trend-adjusted and subnationally-redistributed coverage estimates using the DTP1-derived denominator logic described in CD2030. It estimates coverage over time based on changes in DHIS2 population counts, while preserving subnational proportions from the base year.

Usage

calculate_derived_coverage(.data, indicator)

Arguments

Details

This allows estimating:

• Trends over time in coverage

• Subnational inequities

Value

A cd_derived_coverage tibble with columns for old and new coverage estimates.

Examples

## Not run: 
calculate_derived_coverage(population_metrics, "penta1")

## End(Not run)

Description

Calculates yearly % of districts with complete data for each indicator.

Usage

calculate_district_completeness_summary(.data, region = NULL)

Arguments

Value

A cd_missing_district tibble:

• One row per year

• ⁠% non-missing⁠ per indicator

• mean_mis_all, mean_mis_four summaries

Examples

## Not run: 
calculate_district_completeness_summary(data)

## End(Not run)

Description

Calculates the yearly percentage of districts without extreme outliers for each health indicator. Flags are based on the Hampel X84 method (beyond 5 MAD from median).

Usage

calculate_district_outlier_summary(.data, region = NULL)

Arguments

Details

• Aggregates by district and year, using the max flag per group.

• Computes percent of non-outliers per indicator.

• Returns yearly summaries including:

  • Per-indicator non-outlier rates

  • mean_out_all: all indicators

  • mean_out_four: excludes IPD

All results are rounded to two decimals.

Value

A cd_district_outliers_summary tibble.

Examples

## Not run: 
calculate_district_outlier_summary(data)

## End(Not run)

Description

Calculates and summarizes the adequacy of specified indicator ratios by year, evaluating the consistency of key health indicators across districts. It computes the percentage of districts meeting the adequacy criteria for each indicator ratio, based on the specified range.

Usage

calculate_district_ratios_summary(.data)

Arguments

Details

• The function dynamically calculates ratios between the specified indicator pairs.

• For each year, it computes the percentage of districts where the calculated ratio for each indicator pair falls within the adequate range.

• The summary table aids in monitoring indicator consistency across districts and over time, providing insights into areas where health service delivery may vary.

Value

A tibble of class cd_district_ratios_summary, containing the summary of adequacy checks by year. Each column represents the percentage of districts meeting the adequacy criteria for the specified ratio, with overall metrics included for data interpretation and quality monitoring.

Examples

## Not run: 
# Calculate adequacy summary for ANC1/Penta1 and other indicator ratios
calculate_district_ratios_summary(cd_data)

## End(Not run)

Description

calculate_district_reporting_rate Calculates the percentage of districts that meet or exceed a specified reporting rate threshold for each indicator, by year. Also computes a yearly average across all indicators.

Usage

calculate_district_reporting_rate(
  .data,
  threshold = .cd_method$data_quality$reporting_threshold,
  region = NULL
)

Arguments

Value

A tibble of class cd_district_reporting_rate.

Examples

## Not run: 
calculate_district_reporting_rate(data, threshold = 90)
calculate_district_reporting_rate(data, threshold = 85, region = "Eastern")

## End(Not run)

Description

Returns a merged dataset of health coverage and system metrics at district and admin level 1 for the latest year.

Usage

calculate_health_system_comparison(
  .data,
  admin1_coverage_data,
  admin2_coverage_data
)

Arguments

Value

A data frame with admin level 1 and district metrics joined side by side for comparison.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)
cache$set_national_estimates(list(sbr = 0.02))
cache$adjust_data()

comparison <- calculate_health_system_comparison(
  cache$adjusted_data,
  admin1_coverage_data = cache$indicator_coverage_admin1,
  admin2_coverage_data = cache$indicator_coverage_district
)
comparison[c("adminlevel_1", "district", "ad1_ratio_fac_pop", "dis_ratio_fac_pop")]

Description

Aggregates data at national, admin level 1, or district level and computes ratios and performance scores.

Usage

calculate_health_system_metrics(
  .data,
  admin_level = c("national", "adminlevel_1", "district")
)

Arguments

Value

A summarized data frame with calculated metrics: ratios (facility, beds, workforce, service use) and performance scores.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
data <- load_data(path)

national <- calculate_health_system_metrics(data, admin_level = "national")
national[c("year", "ratio_fac_pop", "ratio_bed_pop", "ratio_hstaff_pop", "score_total")]

regions <- calculate_health_system_metrics(data, admin_level = "adminlevel_1")
regions[c("adminlevel_1", "ratio_fac_pop", "ratio_hstaff_pop", "score_total")]

Description

calculate_indicator_coverage computes key health coverage indicators across specified administrative levels (national, adminlevel_1, and district). The function integrates data from multiple sources, including DHIS-2, UN estimates, ANC-1, and Penta-1 survey data. It calculates coverage rates for a variety of vaccinations and health metrics based on projected, survey-derived, and estimated denominators.

Usage

calculate_indicator_coverage(
  .data,
  admin_level = c("national", "adminlevel_1", "district"),
  derivation_population = c("totbirths_dhis2", "totlivebirths_dhis2", "totunder1_dhis2",
    "totpop_dhis2", "un_population", "un_births", "un_under1"),
  un_estimates = NULL,
  survey_estimates = NULL,
  subnational_map = NULL,
  anc1survey = .cd_method$denominators$anc1survey,
  dpt1survey = .cd_method$denominators$dpt1survey,
  survey_year = .cd_method$denominators$survey_year,
  region = NULL,
  show_district = TRUE,
  sbr = .cd_method$denominators$sbr,
  nmr = .cd_method$denominators$nmr,
  pnmr = .cd_method$denominators$pnmr,
  twin = .cd_method$denominators$twin,
  preg_loss = .cd_method$denominators$preg_loss
)

Arguments

Value

A tibble of class cd_indicator_coverage containing calculated coverage indicators for the specified administrative level.

Examples

## Not run: 
# Calculate coverage indicators at the national level
coverage_data <- calculate_indicator_coverage(
  .data = dhis2_data,
  admin_level = "national",
  un_estimates = un_data
)

# Calculate coverage indicators at the district level
coverage_data <- calculate_indicator_coverage(
  .data = dhis2_data,
  admin_level = "district"
)

## End(Not run)

Description

calculate_inequality computes subnational health coverage metrics and evaluates disparities compared to reference averages (either national or regional).

Usage

calculate_inequality(subnational_data, reference_data)

Arguments

Value

A tibble (cd_inequality object) containing:

• Subnational health coverage metrics.

• Population shares.

• MADM, MRDM, and related disparity metrics.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)
cache$set_national_estimates(list(sbr = 0.02))
cache$adjust_data()

# regions against the national coverage
inequality <- calculate_inequality(
  subnational_data = cache$indicator_coverage_admin1,
  reference_data = cache$indicator_coverage_national
)
select_inequality(inequality, indicator = "instlivebirths", denominator = "dhis2")

Description

calculate_outliers_summary computes yearly percentages of non-outlier values for each health indicator, based on precomputed 5-MAD outlier flags. Summarizes data quality by administrative level and year.

Usage

calculate_outliers_summary(
  .data,
  admin_level = c("national", "adminlevel_1", "district"),
  region = NULL
)

Arguments

Details

Outliers are defined using a Hampel filter with a 5-MAD threshold.

Aggregates the outlier flags by year and administrative level and computes the share of valid (non-outlier) values per indicator. The IPD indicators are left out. Adds mean_out_all, the average non-outlier rate across the indicators summarised.

Values are expressed as percentages (0-100).

Value

A tibble of class cd_outlier.

Examples

## Not run: 
calculate_outliers_summary(data, admin_level = "district")

## End(Not run)

Description

Calculates an overall quality score based on various data quality metrics. It summarizes completeness, outlier presence, and consistency of reporting in immunization health facility data.

Usage

calculate_overall_score(
  .data,
  threshold,
  ratio_pairs = NULL,
  region = NULL,
  labels = NULL
)

Arguments

Details

calculate_overall_score processes multiple data quality indicators:

• Completeness metrics: Percentage of expected reports, districts with complete reporting, and districts with no missing values.

• Outlier metrics: Percentage of monthly values and districts without extreme outliers.

• Consistency ratios: Ratios between different immunization indicators to ensure internal consistency.

The function calculates averages for the selected metrics and includes a row summarizing the annual data quality score.

Value

A tibble with calculated scores for each metric, including a summary row for the annual quality score. The result is ordered by metric codes and ready for reporting in tabular or graphical form.

Examples

## Not run: 
calculate_overall_score(.data = my_data)

## End(Not run)

Description

Builds the same score table as calculate_overall_score(), but from summaries that have already been calculated.

Usage

calculate_overall_score1(
  average_reporting_rate,
  district_reporting_rate,
  district_completeness,
  outliers_summary,
  district_outliers_summary,
  ratios_summary,
  labels = NULL,
  threshold = .cd_method$data_quality$reporting_threshold
)

Arguments

Value

A tibble with calculated scores for each metric, including a summary row for the annual quality score.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
data <- load_data(path)
calculate_overall_score1(
  average_reporting_rate = calculate_average_reporting_rate(data),
  district_reporting_rate = calculate_district_reporting_rate(data, threshold = 90),
  district_completeness = calculate_district_completeness_summary(data),
  outliers_summary = calculate_outliers_summary(data),
  district_outliers_summary = calculate_district_outlier_summary(data),
  ratios_summary = calculate_ratios_and_adequacy(data),
  threshold = 90
)

Description

Computes ratios for specified pairs of indicators dynamically and flags whether each calculated ratio falls within an adequate range, per district and year. This function is an intermediate utility used to standardize ratio calculations and adequacy checks across indicator pairs.

Usage

calculate_ratios_and_adequacy(
  .data,
  ratio_pairs = NULL,
  adequate_range = .cd_method$data_quality$ratio_adequate_range,
  region = NULL
)

Arguments

Details

This function standardizes ratio calculations by dynamically computing ratios and adequacy flags for specified pairs of indicators. It operates in three main stages:

1. Summing Indicators: Calculates the sum of each indicator by district and year.

2. Calculating Ratios: Divides the summed numerator by the summed denominator for each pair in ratio_pairs, creating a column for each ratio.

3. Checking Adequacy: Flags each ratio as adequate if it falls within the specified adequate_range, returning 1 for adequate and 0 otherwise.

Value

A data frame with columns for:

• Summed indicators by district and year: Summed values for each indicator across districts within the specified year, based on input in ratio_pairs.

• Ratios: Each ratio is calculated as the sum of the specified numerator divided by the sum of the specified denominator for each pair.

• Adequacy flags: For each ratio, an adequacy flag (e.g., adeq_ratioAP) is generated, set to 1 if the ratio falls within the adequate_range, and 0 otherwise.

• The output is aggregated by year and includes means of ratios and adequacy flags.

See Also

calculate_ratios_summary() and calculate_district_ratios_summary(), which summarise the result.

Examples

## Not run: 
# Calculate ratios and adequacy checks using custom ranges
calculate_ratios_and_adequacy(data,
  ratio_pairs = list(
    "ratioAP" = c("anc1", "penta1"),
    "ratioPP" = c("penta1", "penta3")
  ),
  adequate_range = c(1, 1.5)
)

## End(Not run)

Description

Computes yearly summaries for specified indicator ratios, assessing trends across years and providing both actual and expected ratios for each indicator. It evaluates specified indicator pairs to calculate ratios and compares actual values with expected ratios, based on predefined survey coverage values. The summary facilitates monitoring consistency of key health indicators over time.

Usage

calculate_ratios_summary(
  .data,
  survey_coverage = .cd_method$data_quality$ratio_expected_coverage,
  anc1_penta1_mortality = .cd_method$data_quality$ratio_anc1_penta1_mortality
)

Arguments

Details

The function provides insights into indicator relationships over time and evaluates deviations from expected values. It enables data quality checks and trend analysis by summarizing ratios yearly and including expected values for comparison. The "Expected Ratio" row incorporates predefined survey coverage and serves as a reference for assessing the adequacy of each indicator's ratio.

Value

A cd_ratios_summary object, a data frame containing:

• year: Year of each calculated ratio, with an additional row "Expected Ratio" to represent expected values for each indicator ratio based on survey_coverage.

• Indicator Ratios: Columns for each ratio, showing actual yearly values and an expected value row based on survey_coverage.

• Additional Columns: Health indicator values for each year.

Examples

## Not run: 
# Basic usage with default parameters
calculate_ratios_summary(cd_data)

# Custom survey coverage and mortality adjustments for "ratioAP"
calculate_ratios_summary(cd_data,
  survey_coverage = c(anc1 = 0.95, penta1 = 0.92, penta3 = 0.85),
  anc1_penta1_mortality = 1.05
)

## End(Not run)

Description

A card with one chart of the ratios between related indicators (ANC1 to Penta1, OPV1 to OPV3 and Penta1 to Penta3 have translated labels). It is the first card of the Internal consistency page (internal_consistency_ui()) and has no filters. It reads ratios_summary from the dataset.

Usage

calculate_ratios_ui(id, i18n)

calculate_ratios_server(id, cache, i18n, active = reactive(TRUE))

Arguments

Value

calculate_ratios_ui() returns the card's UI as Shiny tags. calculate_ratios_server() is called for its side effects.

Examples

## Not run: 
# the card in a page module, as the Internal consistency page uses it
my_page_ui <- function(id, i18n) {
  ns <- NS(id)
  cd_page_ui(id, i18n, calculate_ratios_ui(ns("ratios"), i18n))
}
my_page_server <- function(id, cache, i18n, active = reactive(TRUE)) {
  moduleServer(id, function(input, output, session) {
    calculate_ratios_server("ratios", cache, i18n, active = active)
  })
}

## End(Not run)

Description

Evaluates administrative regions to determine the percentage that meet specific coverage targets or fall below specific dropout thresholds for a given year.

Usage

calculate_threshold(
  .data,
  denominator = c("dhis2", "anc1", "penta1", "penta1derived", "anc1derived"),
  indicator = c("anc4", "instlivebirths", "vaccine", "dropout")
)

Arguments

Value

A cd_threshold object summarizing the percentage of regions meeting the criteria by year.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)
cache$set_national_estimates(list(sbr = 0.02))
cache$adjust_data()
coverage <- cache$indicator_coverage_admin1

# the percentage of regions that reach the target for institutional live births, by year
calculate_threshold(coverage, denominator = "dhis2", indicator = "instlivebirths")

# for the three tracer vaccines, with the penta1 denominator
calculate_threshold(coverage, denominator = "penta1", indicator = "vaccine")

Description

The admin levels a page can be shown at, in the form a filter chip takes them. cd_admin_level_ui() builds its level chip from this, and a page can use it to offer the same levels in a control of its own.

Usage

cd_admin_level_choices(include_national = FALSE)

Arguments

Value

A named character vector. The values are the levels ("national" when asked for, "adminlevel_1", "district") and the names are the translation keys of their labels.

Examples

cd_admin_level_choices()
cd_admin_level_choices(include_national = TRUE)

Description

Two filter chips for a page's filter bar: one chooses the admin level (admin level 1 or district, and national when asked for), the other a single area at that level. A page puts cd_admin_level_ui() in its filter bar, calls cd_admin_level_server() in its server, and reads the chosen level and area from the reactive the server returns. cd_admin_parts() splits that reactive into one reactive for the level and one for the area.

Usage

cd_admin_level_ui(id, i18n, include_national = FALSE, show_admin_level = TRUE)

cd_admin_level_server(
  id,
  cache,
  i18n,
  allow_select_all = FALSE,
  show_district = TRUE,
  show_region = TRUE,
  show_admin_level = TRUE,
  selected_admin1 = reactive(NULL)
)

Arguments

Details

The region chip is drawn by the server, so it appears only where there are areas to choose from: never at the national level, never when show_region is FALSE, and at the district level only when show_district is TRUE. Its options are the areas of cache()$subnational_regions at the chosen level, and districts are listed under the admin level 1 area they belong to. Changing the level draws a new region chip, so an area of the old level is never kept. The list of areas is debounced by 300 milliseconds.

With allow_select_all = TRUE the region chip starts on an "all" option, which the server reports as a NULL region. Without it the chip starts on the first area in the list.

When show_admin_level is FALSE there is no level chip, and the level is fixed: "district" when show_district is TRUE (the default), "adminlevel_1" otherwise. Give show_admin_level the same value in the ui and the server call.

Value

cd_admin_level_ui() returns the UI as Shiny tags: the level chip (when shown) and the place where the server draws the region chip.

cd_admin_level_server() returns a reactive holding a list with two elements:

• admin_level: "national", "adminlevel_1" or "district".

• region: the name of the chosen area, or NULL when the region chip is not shown or "all" is chosen.

While the region chip is shown but has not yet reported a value, the reactive stops quietly (as shiny::req() does), so what depends on it waits.

Examples

## Not run: 
# in a page's ui
cd_filter_bar(cd_admin_level_ui(ns("admin_level"), i18n))

# in the page's server
admin <- cd_admin_level_server("admin_level", cache, i18n, allow_select_all = TRUE)
observe({
  admin()$admin_level
  admin()$region
})

## End(Not run)

Description

cd_admin_level_server() returns one reactive holding both the admin level and the region. Pages usually hand the two to their charts and tables as separate reactives, and this gives one reactive for each.

Usage

cd_admin_parts(admin)

Arguments

Value

A list of two reactives:

• admin_level: the chosen admin level.

• region: the chosen area's name, or NULL when the region chip is not shown or "all" is chosen.

Both wait (as shiny::req() does) until admin() has a value.

Examples

## Not run: 
admin <- cd_admin_level_server("admin_level", cache, i18n)
parts <- cd_admin_parts(admin)
parts$admin_level()
parts$region()

## End(Not run)

Description

Puts a whole Countdown app together and returns it as a Shiny app: the frame every app shares (header, sidebar, language picker), the Introduction and Load Data screens, and the app's own pages. An app's run_app() sets its options, builds its translator, lists its pages and its nav tree, and then calls cd_app(). See cd2030.rmncah::run_app() for a complete one.

Usage

cd_app(
  app_name,
  app_version,
  theme,
  nav_sections,
  registry,
  i18n,
  language,
  selected_file,
  upload_ui = get0("upload_data_ui", envir = parent.frame()) %||% cd_upload_data_ui,
  upload_server = get0("upload_data_server", envir = parent.frame()) %||%
    cd_upload_data_server
)

Arguments

Details

cd_app() calls the kit's datasuite.ui::app_frame() and adds what is the same in every Countdown app:

• The Introduction screen and the Load Data screen. The app opens on Load Data, and these two screens are never locked.

• The dataset. It is the reactive the Load Data screen returns, and every page receives it as cache. The pages unlock once the dataset holds Countdown data. The nav items marked requires_adjustment = TRUE unlock once the data is also adjusted.

• The row naming the denominators in use, in every page header (cd_denominator_header()).

• The language. A dataset that has just been uploaded takes the language on screen, and a dataset that is opened again shows the language it was saved with.

• The reports' colours, which follow theme.

• What DataSuite's chat can read and do in the app: the filters of the page on show, the dataset, and actions that set filters and save, read, change and write reports.

Before calling it, the app registers its translator with cd_use_i18n() and its pages with cd_use_pages().

Value

A Shiny app object. Printing it, or passing it to shiny::runApp(), runs the app.

Examples

## Not run: 
i18n <- shiny.i18n::init_i18n(translation_json_path = cd_translations("translation.json"))
cd_use_i18n(i18n)

pages <- my_pages()
cd_use_pages(pages)

cd_app(
  app_name = "My Countdown app", app_version = "1.0.0", theme = "vaccine",
  nav_sections = list(cd_nav_start(), cd_nav_quality(), cd_nav_denominators()),
  registry = pages, i18n = i18n, language = "en", selected_file = NA
)

## End(Not run)

Description

Hands one fit to a future worker and returns at once. The worker runs generate_bayes_model() on the coverage data, overall score, indicator and denominator in inputs, with cd2030.core attached and a parallel-safe random seed. The Bayesian page uses this function as the task of its shiny::ExtendedTask. With the default sequential plan the fit runs in the calling process; see cd_start_bayes_workers().

Usage

cd_bayes_fit_task(inputs)

Arguments

Value

A promise of a list with two elements: key, which is inputs$key unchanged, and model, the fitted model. The key lets the caller keep the model for the request it was fitted for.

Examples

## Not run: 
cache <- load_cache_data(system.file("extdata", "kenya.xlsx", package = "cd2030.core"))
cache$set_national_estimates(list(sbr = 0.02))
cache$adjust_data()

# one fit, kept in the dataset when it ends (it takes minutes)
inputs <- cache$bayes_model_inputs("national", "penta3")
promises::then(cd_bayes_fit_task(inputs), function(out) cache$keep_bayes_model(out$key, out$model))

# in a Shiny server: the task of an ExtendedTask
fit <- ExtendedTask$new(cd_bayes_fit_task)
fit$invoke(inputs)

## End(Not run)

Description

The indicators the Bayesian coverage model has a survey series for. They are the default tabs of the Bayesian page (bayesian_ui()). An app shows only the ones its data has by setting bayes_indicators in options(cd2030.config = ), which the page reads with cd_cfg("bayes_indicators") (the vaccine app: penta3 and measles1).

Usage

cd_bayes_indicators

Format

A character vector of five indicator names: "anc4", "anc_1trimester", "ideliv", "measles1" and "penta3".

Examples

cd_bayes_indicators

# the tabs an app shows: its own setting, or these
cd_cfg("bayes_indicators", cd_bayes_indicators)

Description

For R outside DataSuite.

Usage

cd_bayes_install_command(packages = cd_bayes_packages_missing())

Arguments

Value

The command, as a string.

Examples

cd_bayes_install_command(c("bayescoveragemodel", "bayescoveragedeploy"))

# only what is missing
missing <- cd_bayes_packages_missing()
if (length(missing) > 0) cd_bayes_install_command(missing)

Description

Checks without loading them (loading brings in Stan).

Usage

cd_bayes_packages_missing()

Value

A character vector: the packages generate_bayes_model() needs and that are not installed, empty when the model can run.

Examples

cd_bayes_packages_missing()

if (length(cd_bayes_packages_missing()) == 0) {
  message("The Bayesian model can run.")
}

Description

The shared pages are the same in every Countdown app, and what differs between apps is kept in one list of settings. An app sets the list once, in its run_app(), with options(cd2030.config = list(...)), and the pages read the setting they need with cd_cfg(). This way an app (RMNCAH, vaccine, or one for a custom indicator group) says what is particular to it, and no shared page depends on a group's name.

Usage

cd_cfg(key, default = NULL)

Arguments

Details

A setting may be a value or a function with no arguments that returns one. A function is called each time the setting is read, so its answer can follow something that is only known later, such as the indicator group.

The settings the shared pages read (each page gives its own default):

• nat_cov_indicators: the tabs of the national and sub-national coverage pages. It may include "fpet", which adds the family planning chart.

• bayes_indicators: the tabs of the Bayesian coverage model pages.

• target_indicators: the tabs of the coverage target pages.

• equity_indicators: the tabs of the Equity Assessment page. equity_custom_exclude: the indicators its Custom tab leaves out.

• cov_trend_indicators, sub_derived_indicators, survey_comp_indicators: the tabs of the three cards of the Denominator Selection page.

• adjustment_indicators: the tabs of the Data Adjustment Changes page.

• k_factors: the adjustment factors, as list(name = list(id, label)).

• reporting_rate_indicators, reporting_rate_facet_ncol: the Reporting Rate page's service chips and the number of columns of its national chart.

• consistency_pairs: a list of c(x, y) pairs of indicators, one tab of the Consistency Checks card each.

• has_maternal: whether the indicator group has a maternal denominator (see cd_has_maternal()).

Value

The setting's value. When the setting is a function, the value that function returns. When the setting is not set, default.

Examples

old <- options(cd2030.config = list(
  target_indicators = c("penta3", "measles1"),
  equity_indicators = function() c("anc4", "penta3")
))

cd_cfg("target_indicators")
cd_cfg("equity_indicators")
cd_cfg("consistency_pairs", default = list())

options(old)

Description

A table of every chart with options saved in a dataset's cache: which chart (its cd_chart_id(), or for the screen the chart's place in the app), whether they are for the screen or for reports, how many options are set, and the group it belongs to (the first two parts of its id, e.g. coverage_filtered.national). Use it to see which chart ids a report will pick options up for.

Usage

cd_chart_catalog(cache)

Arguments

Value

A tibble with id, target ("screen", "report" or "dataset"), group, n_options and options (a one-line summary).

Examples

cache <- load_cache_data(system.file("extdata", "kenya.xlsx", package = "cd2030.core"))
cache$set_chart_options("default", cd_chart_options(legend_position = "bottom"))
cache$set_chart_options(
  "report/coverage_filtered.national.penta3",
  cd_chart_options(title = "Penta3 coverage")
)

cd_chart_catalog(cache)

Description

A stable, readable name for the chart a plot draws, made from the data it is drawn from: the kind of data, the admin level and the indicator ("coverage_filtered.national.anc4"). The app's customize panel and the reports build it the same way, so options saved for a chart in the app ("report/<id>") reach the same chart in a generated report. Ids are grouped by their parts: everything under coverage_filtered.national is the national coverage charts.

Usage

cd_chart_id(x)

Arguments

Value

A string, or NULL when the data does not say what it is.

Examples

data <- load_data(system.file("extdata", "kenya.xlsx", package = "cd2030.core"))
cd_chart_id(calculate_average_reporting_rate(data))

# plain data does not say what it is
cd_chart_id(mtcars)

Description

Members that return a table: the precomputed results (active bindings such as reporting_rate_district) and the methods that compute one (calculate_coverage(), get_filtered_coverage(), decompose_change()...). Raw data (countdown_data, adjusted_data) and settings are left out.

Usage

cd_chartable_members()

Value

A character vector of member names.

Examples

head(cd_chartable_members())

Description

One chart with the tools every Countdown chart has: a panel to customize how it looks, a download of the chart as a picture, and a download of its data as an Excel workbook. The page gives the data and says how to draw it, and this module does the rest. It is the chart that goes in the tabs of cd_tabbed_charts_ui(), and it works as well on its own in a card.

Usage

cd_coverage_plot_ui(id, toolbar_inline = FALSE)

cd_coverage_plot_toolbar_ui(id)

cd_coverage_plot_server(
  id,
  filename,
  data_fn,
  ...,
  sheet_name,
  i18n,
  plot_fun = NULL,
  about = NULL
)

Arguments

Details

The chart is drawn with plot_fun(data_fn()) once data_fn() has a value. When plot_fun is NULL it is drawn with plot(data_fn(), ...), so the data must then have a plot() method.

The Excel download holds data_fn() on one sheet named sheet_name(). The picture is the chart as it is on screen, as a PNG file. Both files are named filename() followed by the date and time.

In an app made with cd_app(), what the reader changes in the customize panel is kept in the dataset. The chart is also registered with the app's AI bridge, which can then list it and read its data.

By default the tools sit over a corner of the chart. With toolbar_inline = TRUE, cd_coverage_plot_ui() leaves them out, and the page puts them somewhere else (a card's header, for example) with cd_coverage_plot_toolbar_ui(), called with the same id.

Value

cd_coverage_plot_ui() returns the UI as Shiny tags: the chart, with its tools unless toolbar_inline is TRUE.

cd_coverage_plot_toolbar_ui() returns the chart's tools alone, as Shiny tags.

cd_coverage_plot_server() returns nothing useful. It is called for what it does.

Examples

## Not run: 
# in a page's ui
cd_coverage_plot_ui(ns("coverage"))

# in the page's server
cd_coverage_plot_server("coverage",
  filename = reactive("penta3_coverage"),
  data_fn = reactive(my_coverage_data(cache())),
  sheet_name = reactive(i18n$t("opt_penta3")),
  i18n = i18n,
  plot_fun = function(d) plot(d, title = "Penta3 coverage")
)

## End(Not run)

Description

Checks a custom chart description, reads the data of the dataset member it names and applies the transforms it lists. The result is the table the chart is drawn from.

Usage

cd_custom_chart_data(cache, spec)

Arguments

Value

The data frame after the spec's transforms.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)

spec <- list(
  title = "Antenatal care reporting rate by region, 2023",
  data = list(member = "reporting_rate_admin1"),
  transform = list(
    list(filter = list(year = 2023)),
    list(select = c("adminlevel_1", "anc_rr"))
  ),
  plot = list(geom = "col", x = "adminlevel_1", y = "anc_rr")
)
cd_custom_chart_data(cache, spec)

Description

The indicators a tabbed chart card (cd_tabbed_charts_ui()) gives a tab each when the page names none.

Usage

cd_default_indicator_set()

Details

Reads options(cd2030.default_indicators = ). An app sets it to a character vector of indicator codes, or to a function with no arguments that returns one. A function is called each time, so its answer can follow something that is only known later, such as the indicator group. When the option is not set, the result is cd_default_indicators.

Value

A character vector of indicator codes.

Examples

cd_default_indicator_set()

old <- options(cd2030.default_indicators = function() c("penta3", "measles1"))
cd_default_indicator_set()
options(old)

Description

The indicators a tabbed chart card (cd_tabbed_charts_ui()) gives a tab each when the page names none and the app has not set its own. This is the RMNCAH app's set. Read the indicators in use with cd_default_indicator_set(), which also takes the app's option into account.

Usage

cd_default_indicators

Format

A character vector of five indicator codes: "anc4", "instlivebirths", "low_bweight", "penta3" and "measles1".

Examples

cd_default_indicators

Description

The translation keys of the label and of the hint a denominator chip shows. cd_denominator_ui() uses them, and a page that draws a denominator chip of its own can use them to match it.

Usage

cd_denominator_chip_keys(is_maternal)

Arguments

Value

A list of two translation keys, label and hint.

Examples

cd_denominator_chip_keys(is_maternal = TRUE)
cd_denominator_chip_keys(is_maternal = FALSE)

Description

Every denominator the denominator chip can offer, in the form a filter chip takes them. This is the full set, which the RMNCAH app uses. An app with fewer denominators sets its own (see cd_denominator_options()).

Usage

cd_denominator_choices

Format

A named character vector of length 5. The values are the denominator ids and the names are the translation keys of their labels:

• "dhis2": the DHIS2 population projection.

• "anc1" and "penta1": the denominators derived from ANC1 and from Penta1.

• "penta1derived" and "anc1derived": the growth-projected denominators (Penta1 and ANC1 population growth).

Examples

cd_denominator_choices

Description

What a Countdown app adds to the server of every page header: it fills the header's denominator output with cd_denominator_row() for the denominators the dataset uses. cd_app() passes it to the app frame (app_frame(page_header_extra = )), which runs it inside each page header's module, so a page never calls it itself.

Usage

cd_denominator_header(input, output, session, cache, i18n)

Arguments

Details

It reads cache()$denominator and, when the app has a maternal denominator (cd_has_maternal()), cache()$maternal_denominator. The row is drawn once the values it needs are set, and again when one of them changes.

Value

Nothing useful. It is called for what it does.

Examples

## Not run: 
# cd_app() gives it to the app frame, which calls it in each page header's module
app_frame(app_name, app_version, theme, nav_sections, registry, i18n, language, selected_file,
  data_server = data_server, page_header_extra = cd_denominator_header
)

# the call the frame makes, where the header has uiOutput(ns("denominator"))
moduleServer("header", function(input, output, session) {
  cd_denominator_header(input, output, session, cache = cache, i18n = i18n)
})

## End(Not run)

Description

Gives the display label of each denominator option, keyed by its id. With a translator the labels are translated; a label that has no translation stays in English.

Usage

cd_denominator_labels(i18n = NULL, ids = .cd_dict_denominators$id)

Arguments

Value

A named character vector, id -> label.

Examples

cd_denominator_labels()

Description

The choices the denominator chip shows in the running app. Use it wherever a page must list or check the app's denominators, so that a page shared between apps never shows one the app does not have.

Usage

cd_denominator_options()

Details

Reads options(cd2030.denominator_choices = ). An app whose indicator group has fewer denominators sets that option to its own named vector (the vaccine app leaves out "anc1derived"). When the option is not set, the result is cd_denominator_choices.

Value

A named character vector: the values are the denominator ids and the names are the translation keys of their labels.

Examples

cd_denominator_options()

old <- options(cd2030.denominator_choices = c("lbl_denom_dhis2_proj" = "dhis2"))
cd_denominator_options()
options(old)

Description

The row a Countdown page header shows under its title: a label, one chip naming the vaccination denominator, one naming the maternal denominator when there is one, and a note saying where the denominators are set. cd_denominator_header() draws it on every page. Call it directly to show the same row somewhere else.

Usage

cd_denominator_row(vaccination, maternal = NULL, i18n)

Arguments

Value

The UI as Shiny tags (a div).

Examples

## Not run: 
cd_denominator_row("penta1", "anc1", i18n)
cd_denominator_row("penta1", i18n = i18n)

## End(Not run)

Description

A filter chip that chooses the denominator the dataset uses, either the vaccination denominator or the maternal one. The choice is kept in the dataset, so every page that reads the denominator follows it. The Denominator Selection page uses one chip for each.

Usage

cd_denominator_ui(id, i18n, allow_input = FALSE, is_maternal = FALSE)

cd_denominator_server(
  id,
  cache,
  i18n,
  label = "title_denom_select_best",
  allowInput = FALSE,
  is_maternal = FALSE,
  display_mode = "combined"
)

Arguments

Details

The chip starts empty and the server fills it from the dataset once the chip is on the page: cache()$denominator, or cache()$maternal_denominator when is_maternal is TRUE. When the value changes in the dataset, the chip follows. When the reader chooses a denominator, the server saves it with the dataset's set_denominator() or set_maternal_denominator(). An empty chip saves nothing.

The chip is drawn, and the dataset kept in step, only when asked for: pass allow_input = TRUE to the ui and allowInput = TRUE to the server (the two arguments are spelled differently). With the defaults the ui is NULL and the server does nothing.

The chip's choices are cd_denominator_options().

Value

cd_denominator_ui() returns the UI as Shiny tags (the chip), or NULL when allow_input is FALSE.

cd_denominator_server() returns nothing useful. It is called for what it does.

Examples

## Not run: 
# in a page's ui
cd_denominator_ui(ns("vaxx_denominator"), i18n, allow_input = TRUE)

# in the page's server
cd_denominator_server("vaxx_denominator", cache, i18n, allowInput = TRUE)

## End(Not run)

Description

Splits each name into its parts (cd_dictionary()) and says in plain words what the column holds – e.g. cov_penta3_penta1derived: "Coverage of Pentavalent 3 (%), denominator: Penta1 population growth". A name it cannot read gets type "unknown" and no description: it never guesses.

Usage

cd_describe_columns(names)

Arguments

Value

A data frame, one row per name: column, type (count, coverage, population, population_growth, survey, survey_upper, survey_lower, reporting_rate, fixed, unknown), indicator, denominator, population (the parts' ids, or NA) and description.

Examples

cd_describe_columns(c("cov_penta3_penta1derived", "totinftpenta_anc1", "r_penta1",
                      "vacc_rr", "year", "xyz"))

Description

The package names its data from a few parts: an indicator (penta1), a denominator option (anc1derived), a target population (totinftpenta) and prefixes such as cov_ (coverage) or r_ (survey estimate). This is what each part means, and how they combine. Read meanings from here, not from the spelling: anc1 and penta1 are the ANC1-derived and Penta1-derived denominators, while anc1derived and penta1derived are the population growth ones.

Usage

cd_dictionary()

Value

A list of data frames: denominators (id, label, meaning, levels, key – the label's translation key), indicators (id, label, group, computed), populations (id, label, meaning, unit), reporting_rates (id, meaning), columns (fixed column names: id, meaning) and grammar (pattern, meaning, example).

See Also

cd_describe_columns() to read column names with it.

Examples

cd_dictionary()$denominators[, c("id", "label")]

Description

The last step of every plot method: resolve_chart_options() then apply_chart_options(). While a report renders (export_report()) the report's saved options sit underneath: the dataset-wide ones, then those saved for this type of graph (cd_chart_type()), then those saved for this very chart (cd_chart_id()); what the plot method or the template passes wins over all of them.

Usage

cd_finish_plot(p, options = NULL, ..., .source = NULL)

Arguments

Value

The ggplot with the options applied.

Examples

p <- ggplot2::ggplot(mtcars, ggplot2::aes(wt, mpg)) + ggplot2::geom_point()
cd_finish_plot(p, title = "Weight and fuel use", x_title = "Weight", y_title = "Miles per gallon")

# the same as one options object, the way a plot method receives it
cd_finish_plot(p, cd_chart_options(title = "Weight and fuel use", legend_position = "bottom"))

Description

Tells a shared page whether to show what belongs to the maternal denominator: its chip on the Denominator Selection page and its entry in the page header's denominator row.

Usage

cd_has_maternal()

Details

The answer is the app's has_maternal setting (see cd_cfg()). When the app does not set it, the answer is TRUE unless getOption("cd2030.selected_group") is "vaccine".

Value

TRUE or FALSE.

Examples

old <- options(cd2030.config = list(has_maternal = FALSE))
cd_has_maternal()
options(old)

Description

Gives the display label of each indicator, keyed by its code (anc1 -> "ANC 1"). Charts use it to name indicators on an axis, in place of the column names. With a translator the labels are translated (the key of an indicator is ⁠opt_<code>⁠); a label that has no translation stays in English, and a code the package does not know is returned as it is.

Usage

cd_indicator_labels(i18n = NULL, indicators = names(.cd_dict_indicator_labels))

Arguments

Value

A named character vector, code -> label.

Examples

cd_indicator_labels(indicators = c("anc1", "penta3", "instlivebirths"))

Description

A filter chip that chooses one indicator. A page puts cd_indicator_ui() in its filter bar or in a card, calls cd_indicator_server() in its server, and reads the chosen indicator from the reactive the server returns. The chip starts on its first choice.

Usage

cd_indicator_ui(
  id,
  i18n,
  label = NULL,
  tooltip = NULL,
  indicators = NULL,
  select_all = FALSE
)

cd_indicator_server(id)

Arguments

Value

cd_indicator_ui() returns the UI as Shiny tags (the chip).

cd_indicator_server() returns a reactive holding the chosen indicator's code as a string. It holds "" when "all" is chosen, and NULL until the chip has reported its first value.

Examples

## Not run: 
# in a page's ui
cd_indicator_ui(ns("indicator"), i18n, indicators = c("penta3", "measles1"), select_all = TRUE)

# in the page's server
indicator <- cd_indicator_server("indicator")
observe(print(indicator()))

## End(Not run)

Description

Reads an active binding, or calls a method with args (arguments it doesn't take are left out), and returns the result as a plain data frame (a map's geometry dropped).

Usage

cd_member_data(cache, member, args = list())

Arguments

Value

A data frame.

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)

# a precomputed result
cd_member_data(cache, "reporting_rate_national")

# a method, with its arguments
rates <- cd_member_data(cache, "calculate_reporting_rate", args = list(admin_level = "adminlevel_1"))
head(rates)

Description

Lists the constants the package's methodology uses (cutoffs, thresholds, default rates and targets) with the values the code runs with, so the documentation can be generated from them.

Usage

cd_methodology_defaults(group = c("all", "rmncah", "vaccine"))

Arguments

Value

A tibble with one row per constant and the columns:

• id: a stable snake_case identifier.

• step: one of "data_quality", "adjustment", "denominators", "coverage", "subnational", "mortality".

• group: "both", "rmncah" or "vaccine".

• value: a list column; each element is a number, a string or a vector.

• unit: for example "%", "x MAD", "ratio", "proportion", or "".

• label: a short English label.

• note: one English sentence on how the app uses it.

• source: the file of the package (within ⁠R/⁠) that uses it.

Examples

cd_methodology_defaults()
cd_methodology_defaults("vaccine")

Description

ggplot2::theme_minimal() with a choice of grid lines, for the apps' light charts (cd2030.pooled's charts, the subnational coverage dot plot and heat map).

Usage

cd_minimal_theme(
  base_size = 11,
  grid = c("all", "major", "x", "y", "none"),
  grid_colour = NULL
)

Arguments

Value

A ggplot2 theme.

Examples

library(ggplot2)
ggplot(mtcars, aes(mpg, factor(cyl))) +
  geom_point() +
  cd_minimal_theme(grid = "x")

Description

The parts of the sidebar every Countdown app shares. An app builds its nav tree from them, adds its own groups, and passes the list to cd_app() as nav_sections. Each link opens the screen whose id is the link's tab name (the names are listed below), so the app must have a page with that id.

Usage

cd_nav_start()

cd_nav_quality()

cd_nav_denominators()

cd_nav_national(extra = list())

cd_nav_subnational()

Arguments

Details

• cd_nav_start(): the "start" section, with the Introduction (introduction) and Load Data (upload_data) screens.

• cd_nav_quality(): the data quality section. One group holds reporting_rate, outlier_detection, data_completeness, internal_consistency and overall_score. A second group holds data_adjustment and data_adjustment_changes.

• cd_nav_denominators(): the denominators section, with denominator_assessment and denominator_selection.

• cd_nav_national(): the National Analysis group, with national_coverage, national_target, the items in extra, and a group for inequality holding national_inequality and equity_assessment.

• cd_nav_subnational(): the Sub-National Analysis group, with subnational_coverage, subnational_inequality and subnational_target.

The first three are whole sections. The last two are groups of links: put them inside a section of the app's own, made with cd_nav_section().

Everything from the denominators down is marked requires_adjustment = TRUE: those links stay locked until the data is adjusted.

The labels are translated with the translator the app registered with cd_use_i18n(), so call these after it.

Value

cd_nav_start(), cd_nav_quality() and cd_nav_denominators() each return a nav section, as cd_nav_section() makes one: a list with the section's label and its items.

cd_nav_national() and cd_nav_subnational() each return a nav item, as cd_nav_item() makes one: a group whose children are the links.

Examples

## Not run: 
nav <- list(
  cd_nav_start(),
  cd_nav_quality(),
  cd_nav_denominators(),
  cd_nav_section("lbl_nav_section_analysis", cd_nav_national(), cd_nav_subnational())
)

## End(Not run)

Description

Filters a named list or vector, such as a chart's legend labels or category labels, down to the entries named after a denominator the app offers. Labels are usually written for every denominator, and one the app does not offer must not appear in a chart.

Usage

cd_only_denominators(x)

Arguments

Value

x without the entries whose name is neither "un" (the UN projection, always kept) nor one of the ids in cd_denominator_options(). The order and the type of x are kept.

Examples

labels <- c(un = "UN projection", dhis2 = "DHIS2 projection", other = "Not a denominator")
cd_only_denominators(labels)

Description

A filter chip that chooses the colour palette of the maps on a page. It belongs in the bar of map options above the maps (cd_map_options()). The page reads the choice as ⁠input$<inputId>⁠ and passes it to the map plots, which accept these palette names.

Usage

cd_palette_chip(inputId, i18n, first = "Greens")

Arguments

Details

The choices are four sequential RColorBrewer palettes: "Greens", "Blues", "Reds" and "Purples". The chip starts on its first choice, so first decides which palette a page opens with. This is a plain input, not a module, so there is no server function to call.

Value

The UI as Shiny tags (the chip). Its value, ⁠input$<inputId>⁠, is the chosen palette's name.

Examples

## Not run: 
cd_map_options(cd_palette_chip(ns("palette"), i18n, first = "Blues"))

## End(Not run)

Description

Every chart in the package (each plot() method, the equiplots and plot_comparison()) changes its text and its look in the same way, with the arguments below. They come after the arguments that say what to draw, and they have the same names as the chart options (cd_chart_options()), so what is given for one chart can be given for any other.

Arguments

Text

title, subtitle, caption, x_title, y_title and legend_title replace a chart's own text. NULL, the default, keeps the text the chart writes itself. To remove a text, hide it: show_title = FALSE, show_x_title = FALSE, show_legend_title = FALSE.

Look

Everything else is a chart option, given by name in ...: the background (background_color, panel_color), fonts and sizes (font_family, text_scale, title_size, axis_text_size), the axes (x_limits, y_limits, x_text_angle, flip), the grid (grid, grid_color), the legend (legend_position, legend_labels, show_legend) and the colours (colors). cd_chart_options() lists them all.

One look for several charts

Make the options once and give them to each chart as options. A chart option named in the call wins over options.

Which text is used

The six text arguments say what the chart should read; options holds what someone changed afterwards (in the apps, with the chart's customize panel), so a text in options wins over the text argument. From least to most: the chart's own text, the text arguments, options, and a chart option named in ....

Names that are gone

x_axis and x_label were other names for x_title, y_axis and y_label for y_title, and legend and fill_label for legend_title. They are no longer accepted: a chart given one stops and names the argument to use.

Examples

## Not run: 
rates <- calculate_average_reporting_rate(data, admin_level = "adminlevel_1")

# the same arguments on any chart
plot(rates, title = "Reporting by region", y_title = "Region", legend_title = "Rate")
plot(calculate_district_reporting_rate(data, 90), title = "Districts reporting", y_title = "Percent")

# background and fonts
plot(rates, background_color = "grey95", font_family = "serif", text_scale = 1.2)

# one look for several charts
look <- cd_chart_options(font_family = "serif", background_color = "grey95", legend_position = "right")
plot(rates, options = look)
plot(calculate_district_reporting_rate(data, 90), options = look)

## End(Not run)

Description

A filter chip that chooses the DHIS2 population the growth-projected denominators (ANC1 and Penta1 population growth) are built from. The choice is kept in the dataset.

Usage

cd_population_ui(id)

cd_population_server(id, cache)

Arguments

Details

The choices are "totlivebirths_dhis2" (live births), "totbirths_dhis2" (total births), "totpop_dhis2" (total population) and "totunder1_dhis2" (population under one year).

Once the chip is on the page, the server sets it to the dataset's value, cache()$derivation_population, when there is one, and does so again whenever cache() changes. Each choice the chip reports is saved with the dataset's set_derivation_population().

The ui takes no translator: its labels are translated with the translator the app registered with cd_use_i18n().

Value

cd_population_ui() returns the UI as Shiny tags (the chip).

cd_population_server() returns a reactive holding the chosen population's id as a string (NULL until the chip has reported a value).

Examples

## Not run: 
# in a page's ui
cd_population_ui(ns("population"))

# in the page's server
population <- cd_population_server("population", cache)

## End(Not run)

Description

Draws one cell of a table of rates, such as reporting rates: a small coloured shape that says how good the rate is, followed by the rate rounded to a whole number. The shape differs with the status as well as the colour, so the status never depends on colour alone. Use it as the cell of a reactable::colDef(), for example in the columns of cd_table_server().

Usage

cd_rate_status_cell(value)

Arguments

Details

The status has fixed limits: a red triangle below 70, an amber diamond from 70 to below 90, and a green circle from 90.

Value

The cell as a Shiny tag (a span holding the shape and the number), or "" when value is NULL or NA.

Examples

cd_rate_status_cell(64.2)
cd_rate_status_cell(95)
cd_rate_status_cell(NA)

# as the cell of a table column
reactable::colDef(cell = cd_rate_status_cell)

Description

What the report builder (datasuite.ui) needs from a Countdown dataset: its charts and tables drawn in the report's look, the pictures and templates kept in it, its saved chart options, its fields (country, coverage values), years, regions and flag. Every report function accepts the dataset itself too (datasuite.ui::as_report_context()).

Usage

cd_report_context(cache)

Arguments

Value

A report context (datasuite.ui::report_context()).

Examples

path <- system.file("extdata", "kenya.xlsx", package = "cd2030.core")
cache <- load_cache_data(path)

context <- cd_report_context(cache)
context$years()
context$fields(NULL, "en")$country

Description

Inside DataSuite (an app it started), asks it to install them: it shows the progress in its status bar and then offers to restart the app. Outside DataSuite it does nothing; install them with cd_bayes_install_command().

Usage

cd_request_bayes_packages(packages = cd_bayes_packages_missing())

Arguments

Value

TRUE when DataSuite was asked, invisibly.

Examples

## Not run: 
# in an app DataSuite started, before the model is first used
if (length(cd_bayes_packages_missing()) > 0) {
  cd_request_bayes_packages()
}

# one package only
cd_request_bayes_packages("bayescoveragedeploy")

## End(Not run)

Description

Builds the name of the .rds file a finished dataset is saved to: ⁠<stem>_<group>.rds⁠, for example Benin_rmncah.rds or Benin_vaccine.rds. One source file can be loaded by more than one app, and the group in the name keeps each app's finished copy apart.

Usage

cd_saved_copy_name(stem)

Arguments

Value

The file name (not a full path), a string. The group is the one cd_wizard_indicator_group() returns.

Examples

old <- options(cd2030.app_group = "rmncah")
cd_saved_copy_name("Kenya")
cd_saved_copy_name(tools::file_path_sans_ext(basename("C:/data/Kenya_2024.xlsx")))
options(old)

Description

A scope says at which geography a page runs its analysis: which admin level and region filters the page shows, and what admin level and region it hands to the analysis. Pages that run the same analysis at a different geography (national coverage and sub-national coverage, for example) differ only in their scope. Pass the result to cd_scoped_page_ui() and cd_scoped_page_server(), or to cd_scope_filters() and cd_scope_server().

Usage

cd_scope(
  kind = c("national", "level", "region", "level_region"),
  fixed_level = NULL,
  show_district = FALSE
)

Arguments

Details

The kinds of scope:

• "national": no filters. The analysis gets the admin level "national" and no region.

• "level": an admin level chip only (admin level 1 or district). The analysis gets the chosen level and no region.

• "region": a region chip only, listing the admin level 1 areas. The analysis gets the chosen area and the admin level "adminlevel_1", or fixed_level when it is given.

• "level_region": an admin level chip and a region chip. The region chip is shown at admin level 1, and also at the district level when show_district is TRUE.

Value

A list with the elements kind, fixed_level and show_district, as given.

Examples

cd_scope()
cd_scope("region", fixed_level = "district")
cd_scope("level_region", show_district = TRUE)

Description

The filter bar holding the admin level and region chips a scope asks for. cd_scoped_page_ui() uses it. Call it yourself in a page that lays out its own body but still takes its geography from a scope, and pair it with cd_scope_server().

Usage

cd_scope_filters(ns, i18n, scope)

Arguments

Details

The chips are an admin level filter (cd_admin_level_ui()) with the id ns("scope"). So in the page's module server, call cd_scope_server("scope", ...) with the same scope.

Value

The UI as Shiny tags (a filter bar), or NULL for a "national" scope, which has no filters.

Examples

## Not run: 
scope <- cd_scope("level_region")

my_page_ui <- function(id, i18n) {
  ns <- NS(id)
  cd_page_ui(id, i18n, filters = cd_scope_filters(ns, i18n, scope), my_cards(ns))
}

## End(Not run)

Description

The server half of cd_scope_filters(): it gives the admin level and the region a scope resolves to, as two reactives ready to hand to an analysis. Call it inside the page's module server. cd_scoped_page_server() does this for a whole scoped page.

Usage

cd_scope_server(id, cache, i18n, scope)

Arguments

Details

For a "national" scope nothing is read from the page. For the other kinds it runs the admin level filter (cd_admin_level_server()) with the settings the scope asks for, so the two reactives wait until that filter has a value.

Value

A list of two reactives:

• admin_level: "national" for a national scope. Otherwise the scope's fixed_level when it has one, else the level of the filter ("adminlevel_1" or "district").

• region: the name of the chosen area, or NULL when the scope has no region chip.

Examples

## Not run: 
my_page_server <- function(id, cache, i18n) {
  moduleServer(id, function(input, output, session) {
    geo <- cd_scope_server("scope", cache, i18n, cd_scope("level_region"))
    observe(print(list(geo$admin_level(), geo$region())))
  })
}

## End(Not run)

Description

Builds a page from an analysis module and a scope: the page's header and body, the scope's filter bar, and the analysis module inside. Pages that run the same analysis at a different geography then differ only in the scope they pass (see cd_scope()), and the filter bar and its wiring are written once.

Usage

cd_scoped_page_ui(id, i18n, scope, inner_ui, ...)

cd_scoped_page_server(
  id,
  cache,
  i18n,
  scope,
  inner_server,
  active = reactive(TRUE)
)

Arguments

Details

The analysis module is the app's own pair of functions:

• inner_ui(id, i18n, ...) returns the page's cards.

• inner_server(id, cache, i18n, admin_level, region, active = ) takes the admin level and the region as two reactives (see cd_scope_server() for what they hold).

Both are called with the id "body" inside the page's namespace. The page's title, section and subtitle come from the app's page registry, so id must be the id of a registered page.

Value

cd_scoped_page_ui() returns the page's UI as Shiny tags.

cd_scoped_page_server() returns what inner_server returns.

Examples

## Not run: 
scope <- cd_scope("region", fixed_level = "district")

subnational_target_ui <- function(id, i18n) {
  cd_scoped_page_ui(id, i18n, scope, target_ui)
}
subnational_target_server <- function(id, cache, i18n, active = reactive(TRUE)) {
  cd_scoped_page_server(id, cache, i18n, scope, target_server, active)
}

## End(Not run)

Description

Sets the R session's future plan to multisession, so that the Bayesian page fits its models in other R processes and the app stays usable meanwhile. It changes the plan only while the plan is the default (sequential): a session that already has a plan of its own keeps it, and a second call does nothing. There is one worker by default, so a fit asked for while another runs waits its turn. options(cd2030.bayes_workers = ) sets another number (at least one is always used).

Usage

cd_start_bayes_workers()

Value

The session's future plan, invisibly.

Examples

## Not run: 
cd_start_bayes_workers()
future::nbrOfWorkers()

# two fits at a time: set the option before the first call
options(cd2030.bayes_workers = 2)
cd_start_bayes_workers()

## End(Not run)

Description

The serverInput function given to cd_tabbed_charts_server() receives the indicator of its tab as a string, and for the Custom tab as a reactive that returns the indicator the reader chose. cd_tab_indicator() gives one way to read both.

Usage

cd_tab_indicator(indicator)

Arguments

Value

A function with no arguments that returns the indicator's code. For the Custom tab it must be called where a reactive can be read (in a reactive(), a render function or a plot_fun).

Examples

ind <- cd_tab_indicator("penta3")
ind()

## Not run: 
# in a page's server: one serverInput for the indicators' tabs and the Custom tab
cd_tabbed_charts_server("panel",
  serverInput = function(id, current_indicator) {
    ind <- cd_tab_indicator(current_indicator)
    cd_coverage_plot_server(
      id = id,
      filename = reactive(paste0(ind(), "_coverage")),
      data_fn = reactive(cache()$get_filtered_coverage(ind(), "national")),
      sheet_name = reactive(i18n$t(paste0("opt_", ind()))),
      i18n = i18n
    )
  }
)

## End(Not run)

Description

A card that shows the same chart for several indicators, one tab each, with a "Custom" tab where the reader chooses any other indicator. The page says how one chart is drawn (uiInput and serverInput), and this module makes the tabs, switches between them and puts the chart tools of the tab on show in the card's header. Many analysis pages are built from it.

Usage

cd_tabbed_charts_ui(
  id,
  i18n,
  title_key,
  uiInput,
  indicators = NULL,
  customIndicators = get_analysis_indicators(),
  showCustom = TRUE,
  width = 12
)

cd_tabbed_charts_server(
  id,
  serverInput,
  indicators = NULL,
  customIndicators = get_analysis_indicators(),
  showCustom = TRUE,
  selected_tab = reactive(NULL),
  i18n = cd_i18n()
)

Arguments

Details

uiInput and serverInput are the two halves of one chart, usually cd_coverage_plot_ui() and a function that calls cd_coverage_plot_server():

• uiInput(id, toolbar_inline = TRUE) is called once for each tab and returns that tab's chart. It must leave the chart's tools out when toolbar_inline is TRUE, because the card's header shows them. The header draws the tools with cd_coverage_plot_toolbar_ui(), so the chart must be a cd_coverage_plot_ui() or use the same ids.

• serverInput(id, indicator) starts the chart of one tab. It is called once for each indicator, with the indicator's code as both arguments. For the Custom tab it is called once, with the id "custom" and a reactive that returns the indicator the reader chose; read either with cd_tab_indicator(). It runs inside this module, so id is used as it is, without ns().

A tab's label is the translation of opt_ followed by the indicator's code. The tabs that are not on show are hidden, and Shiny does not draw a hidden chart.

Give indicators and showCustom the same values in the ui and the server call.

Value

cd_tabbed_charts_ui() returns the UI as Shiny tags (the card).

cd_tabbed_charts_server() returns a reactive holding the key of the tab on show: an indicator's code, or "custom".

Examples

## Not run: 
# in a page's ui
cd_tabbed_charts_ui(ns("panel"), i18n, "title_coverage_national", cd_coverage_plot_ui,
  indicators = c("penta3", "measles1")
)

# in the page's server
cd_tabbed_charts_server("panel",
  serverInput = function(id, indicator) {
    cd_coverage_plot_server(
      id = id,
      filename = reactive(paste0(indicator, "_coverage")),
      data_fn = reactive(my_coverage_data(cache(), indicator)),
      sheet_name = reactive(i18n$t(paste0("opt_", indicator))),
      i18n = i18n
    )
  },
  indicators = c("penta3", "measles1")
)

## End(Not run)

Description

A card that shows a formatted table (a flextable) on screen, with two downloads in the card's header: the table as a picture and its data as an Excel workbook. Use it for a table whose layout matters, such as a scorecard. The Overall Score page uses it. For a plain table of data, use cd_table_ui().

Usage

cd_table_card_ui(id, i18n, title, ..., width = 12)

cd_table_card_server(
  id,
  i18n,
  data,
  table_fun,
  filename,
  sheet = "lbl_score_metric_header",
  about = NULL
)

Arguments

Details

The page gives the data and one function that turns it into a flextable. The table on screen and the picture are drawn with the same function, so they always match. The picture is a PNG file. The workbook holds data() on one sheet. Both files are named filename() followed by the date and time.

The table is drawn once data() has a value. It is also registered with the app's AI bridge, which can then list it and read its data.

Value

cd_table_card_ui() returns the UI as Shiny tags (the card).

cd_table_card_server() returns nothing useful. It is called for what it does.

Examples

## Not run: 
# in a page's ui
cd_table_card_ui(ns("score"), i18n, i18n$t("title_score_main"), status = "success")

# in the page's server
cd_table_card_server("score", i18n,
  data = reactive(my_scores(cache())),
  table_fun = function(d) flextable::flextable(d),
  filename = reactive("overall_score")
)

## End(Not run)

Description

A card that shows a data frame as a table, with a control above it (a year chip or an indicator chip) and a download of the data as an Excel workbook in the card's header. The module translates the column headings it knows, rounds the numbers and aligns them. Use it for the table that goes with a page's charts. For a formatted table (a flextable), use cd_table_card_ui().

Usage

cd_table_ui(
  id,
  i18n,
  title_key,
  control_type = c("year", "indicator"),
  width = 6
)

cd_table_server(
  id,
  cache,
  i18n,
  data,
  columns = NULL,
  control_type = c("year", "indicator"),
  filename = reactive("download"),
  label_key = "btn_global_download_data",
  extension = reactive("xlsx"),
  data_transform = NULL,
  excel_write_fun = NULL,
  excel_sheet = NULL,
  excel_title = NULL,
  about = NULL
)

Arguments