Charité Outcomes Research Repository

Real-world data, made usable.

More than 4,000 clinician-validated concepts turn 255,878 ICU stays and 544,227 procedures into analysis-ready cohorts (as of June 2026).

Explore the data See the demos

4,725 computable clinical concepts by data category, as of June 2026.

ICU stays

CORR-ICU

surgical procedures

CORR-OR

computable clinical concepts

consensus-defined, clinician-validated

ICUs, IMCs and PACUs

350+ beds, 3 sites

Counts as of June 2026. Routine data since 2001 (COPRA) and 2006 (hospital information system); Philips monitoring at up to 500 Hz since 2025.

Why a raw EHR value is not a clinical concept

Take the PF-ratio, one of the most common variables in ICU research. Some blood-gas analyzers calculates a PF-ratio for every arterial sample, assuming an FiO₂ of 21% unless someone types in the real value. Clinicians do not use this stored value for patient care, but anyone who pulls this data for research gets values that are systematically inflated. CORR identified this error and created a consensus-based, clinically-curated concept. It was defined and validated once. Now, every CORR project can use it, without re-coding and inconsistencies across projects.

Try it: one blood gas, two answers

Move the sliders. The EHR ratio ignores the FiO₂ actually delivered.

paO₂ 80 mmHg Delivered FiO₂ 60 %

Stored in EHR
FiO₂ assumed 21%

381

No ARDS band

CORR concept pf_ratio
matched FiO₂

133

Moderate band

Berlin bands are shown for illustration only; formal ARDS classification also requires PEEP, timing and radiographic criteria.

Calibration density of PF-ratio stored in the EHR against the CORR-derived PF-ratio. Discrete diagonal bands correspond to specific FiO2 settings. — Calibration density, EHR-stored versus CORR-derived PF-ratio. Each diagonal band is one FiO₂ setting that the EHR silently replaced with 21%.

How the repository is structured

Two repositories share one concept layer. CORR-ICU is keyed by ICU stay, CORR-OR by surgical procedure, and both roll up to hospital case and patient. Because the identifiers link, a patient can be followed from the operating room to the ICU to the ward.

Observation levels

Click a level to see what it contains. One patient, two hospital cases, five ICU stays and five procedures, as in the manuscript's Figure 1B.

patient_id

The person. Every CORR concept can be extracted at this level, or segmented into the levels below.

patient_id: One person, stable across all admissions.
case_id: One hospital case, from admission to discharge.
icu_stay_id: One continuous ICU stay; the default unit of CORR-ICU.
procedure_id: One surgical procedure; the default unit of CORR-OR.

Sample size and overlap

Counted in hospital stays, as of June 2026. Procedures and ICU stays overlap where surgery precedes or follows intensive care, which makes perioperative-to-ICU studies possible without record linkage.

CORR-OR: 544,227 procedures; across 455,415 hospital stays, about 50,000 per year in 60+ operating rooms
CORR-ICU: 255,878 ICU stays; across 231,605 hospital stays, about 27,000 per year in ~30 units

The concept library

A computable clinical concept (CCC) is a consensus-defined, clinician-validated, version-controlled and machine-executable specification. Each is a dedicated extraction and transformation pipeline, documented with provenance, derivation logic, validation status and known caveats, and mapped to OMOP, SNOMED CT and ATC.

Composition by category

Number of concepts, log scale. Hover a bar.

Interoperability coverage

Share of concepts per category with a mapping to each standard. Overall: OMOP 99%, SNOMED CT 19%, ATC 78% of medications.

Four kinds of concept

Concepts are raw or derived, and static or dynamic. Static concepts come as one row per case (wide format); dynamic concepts as many rows per case over time (long format).

Raw, static

icu_admission_time

One value read directly from the record per observation level.

Raw, dynamic

paO₂, FiO₂

Each blood-gas or ventilator reading, with its timestamp.

Derived, static

first_pf_ratio

One computed value per case, e.g. the first PF-ratio after admission.

Derived, dynamic

pf_ratio

paO₂ divided by the temporally matched FiO₂, per measurement.

Concepts Browser Taxonomy CORR (v1)

Search concepts

No concept matches. Try a name such as sofa or a domain such as ventilation.

38 of 38 shown

`age_on_admission`

v1 in corr_v1

charite_demo Type derived_static Demographics CORR-ICU and CORR-OR Static years

Definition

Type: derived_static
Requires: birthdate
hospital_admission
Expression: (EXTRACT(EPOCH FROM hospital_admission) - EXTRACT(EPOCH FROM birthdate)) // (24 * 60 * 60) / 365.25

{
  "type": "derived_static",
  "requires": [
    "birthdate",
    "hospital_admission"
  ],
  "expression": "(EXTRACT(EPOCH FROM hospital_admission) - EXTRACT(EPOCH FROM birthdate)) // (24 * 60 * 60) / 365.25"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

`airway_device`

v1 in corr_v1

charite_demo Type co6_hierarchy Airway CORR-ICU and CORR-OR Dynamic, interval device type

Definition

Type: co6_hierarchy
Dynamic: true
Parent name: Fall_AWZ
Suffixes: {"_Typ":"raw_typ","_Applika":"raw_applika","_Anlageart":"raw_anlageart","_Anlage":"recordtime","_Entfernung":"recordtime_end"}
Not strict: ["_Entfernung","_Anlageart","_Applika"]

{
  "type": "co6_hierarchy",
  "dynamic": true,
  "parent_name": "Fall_AWZ",
  "suffixes": {
    "_Typ": "raw_typ",
    "_Applika": "raw_applika",
    "_Anlageart": "raw_anlageart",
    "_Anlage": "recordtime",
    "_Entfernung": "recordtime_end"
  },
  "not_strict": [
    "_Entfernung",
    "_Anlageart",
    "_Applika"
  ]
}

Python

first 60 of 118 lines

1def airway_device(var: VariableContext, cohort: Cohort) -> pl.DataFrame:
2    df = classify_airway_devices(
3        var.data, typ_col="raw_typ", app_col="raw_applika", anl_col="raw_anlageart"
4    )
5
6    df = df.rename(
7        {
8            "auto_class": "value",
9            "auto_conf": "certainty_classification",
10            "auto_rule": "regex_rule",
11            "auto_subtype": "subtype",
12        }
13    )
14
15    # Extraction is scoped to the screened obs level, so the primary key is not yet
16    # present; the pipeline only adds it after this function runs.
17    df = helpers.attach_obs_ids(df, cohort)
18
19    # --------------------------------------------
20    # 1) Join death + discharge info
21    # --------------------------------------------
22    time_of_death = cohort.obs.select(
23        cohort.primary_key,
24        "death_timestamp",
25        cohort.t_max,  # <-- keep exact name: cohort.t_max
26    )
27
28    df = df.join(time_of_death, on=cohort.primary_key, how="left")
29
30    # --------------------------------------------
31    # 2) Identify LAST row per cohort.primary_key
32    # --------------------------------------------
33    last_rows = (
34        df.sort("recordtime")
35        .group_by(cohort.primary_key)
36        .tail(1)
37        .select(cohort.primary_key, "recordtime")
38        .rename({"recordtime": "last_recordtime"})
39    )
40
41    df = df.join(last_rows, on=cohort.primary_key, how="left")
42
43    df = df.with_columns(
44        pl.col("recordtime").eq(pl.col("last_recordtime")).alias("is_last_row")
45    )
46
47    # --------------------------------------------
48    # 3) Imputation logic WITH time-order condition
49    # --------------------------------------------
50    df = df.with_columns(
51        # ---- imputed recordtime_end ----
52        pl.when(
53            pl.all_horizontal(
54                "is_last_row",
55                pl.col("recordtime_end").is_null(),
56                pl.col("death_timestamp").is_not_null(),
57                pl.col("recordtime") <= pl.col("death_timestamp"),
58            )
59        )
60        .then(pl.col("death_timestamp"))

Documentation Publication ready

Caveats. • t_max must be icu_discharge in ICU cohorts. Otherwise, open-ended devices are imputed to the wrong end time. • Airway devices are stored per case. COPRA records them at the hospital-case level. They are assigned to an ICU stay artificially, by comparing ICU admission and discharge with insertion (Fall_AWZ_Anlage) and removal (Fall_AWZ_Entfernung). • Removal time is often missing. Removal times are frequently missing, particularly in patients who died in the ICU or were discharged without documented device removal. • Only the last device per stay is imputed. Earlier devices without a removal time stay open-ended. • Death after ICU discharge. The time of death takes priority over t_max (see Step 4). If a patient died after ICU discharge (e.g. on a normal ward), a device without a removal time is therefore imputed with the time of death, not with ICU discharge, and can extend beyond the ICU stay. • Automatic classification. The device type comes from a rule-based classification of free-text and ambiguous COPRA entries. attributes gives the confidence and the rule used for each row. More than 5,000 distinct free-text values were mapped to predefined device types (> 99 % of free-text entries). New free-text entries require regular re-assessment of the mapping.

Clinical

All airway devices (e.g. endotracheal tube, laryngeal mask, tracheal tube), with insertion and removal time. Missing removal times are partly imputed.

Airway devices secure the airway and allow respiratory support. Each row is one device, with its insertion time (recordtime), its removal time (recordtime_end) and its classified device type (value).

Implementation

1. Extraction. COPRA6 object Fall_AWZ (one object ID per device). Its child entries are merged per parent ID: ◦ Fall_AWZ_Anlage: recordtime ◦ Fall_AWZ_Entfernung: recordtime_end ◦ Fall_AWZ_Typ, Fall_AWZ_Applika, Fall_AWZ_Anlageart: Raw inputs for the classification 2. Classification. classify_airway_devices assigns a device class from the combination of type, application route and insertion type. It returns: ◦ value = device class ◦ certainty_classification = confidence ◦ regex_rule = the rule that matched ◦ subtype 3. Assign to cohort stays. attach_obs_ids adds the cohort primary key (stay ID). 4. Impute a missing removal time on the latest device of each stay (max recordtime): ◦ death_timestamp if the patient died and the device was inserted before death; ◦ otherwise t_max, if the device was inserted before t_max; ◦ otherwise the removal time is left empty.

Output: recordtime: Insertion time recordtime_end: Removal time, imputed where possible (see Step 4) value: Classified device type, e.g. Endotracheal tube, Tracheal tube attributes: certainty_classification, subtype, regex_rule, imputed_from (death, the t_max column name, or none), and the raw COPRA fields (raw_*)

`aki_crea_based`

v1 in corr_v1

charite_demo Type derived_dynamic Outcomes CORR-ICU and CORR-OR Dynamic, per stay stage 0-3

Definition

Type: derived_dynamic
Dynamic: true
Requires: blood_creatinine_all
hemodialysis_icu_all
hospital_admission
hospital_discharge

{
  "type": "derived_dynamic",
  "dynamic": true,
  "requires": {
    "blood_creatinine_all": {
      "template": "blood_creatinine",
      "tmin": null,
      "tmax": null,
      "screened_obs_level": "patient"
    },
    "hemodialysis_icu_all": {
      "template": "hemodialysis_icu",
      "tmin": null,
      "tmax": null,
      "screened_obs_level": "patient"
    },
    "dx_ckd_dialysis": {
      "template": "dx_ckd_dialysis",
      "tmin": "inherit",
      "tmax": "inherit"
    },
    "hospital_admission": {
      "template": "hospital_admission",
      "tmin": "inherit",
      "tmax": "inherit"
    },
    "hospital_discharge": {
      "template": "hospital_discharge",
      "tmin": "inherit",
      "tmax": "inherit"
    }
  }
}

Python

first 60 of 316 lines

1def aki_crea_based(var: VariableContext, cohort: Cohort) -> pl.DataFrame:
2    # Extract creatinine data and sort
3    crea_data_all = var.required_vars["blood_creatinine_all"].data.lazy()
4
5    # Select case admission and discharge timestamp from cohort
6    obs_with_times = utils.add_time_window_expr(cohort.obs, time_window=var.time_window)
7    case_bounds: pl.LazyFrame = obs_with_times.lazy().select(
8        "patient_id",
9        *set(["case_id", cohort.primary_key]),
10        "hospital_admission",
11        "case_tmin",
12        "hospital_discharge",
13        "case_tmax",
14    )
15
16    # Merge admission info into creatinine data on hospital level
17    # Also compute date bounds
18    # NOTE: Change for experimental join_where if to slow
19    crea_merged = (
20        crea_data_all.drop("case_id")
21        .join(
22            case_bounds.select(
23                "patient_id", "case_id", "hospital_admission", "hospital_discharge"
24            ),
25            on="patient_id",
26        )
27        .drop("patient_id")
28        .with_columns(
29            (pl.col("hospital_admission") - pl.duration(days=7)).alias(
30                "admission_sub_7d"
31            ),
32            (pl.col("hospital_admission") - pl.duration(days=365)).alias(
33                "admission_sub_365d"
34            ),
35        )
36    )
37
38    # 1. admission crea
39    crea_admission = (
40        crea_merged.filter(pl.col("recordtime") >= pl.col("hospital_admission"))
41        .sort("case_id", "recordtime")
42        .group_by("case_id", "hospital_admission", "hospital_discharge")
43        .agg(
44            pl.col("value").first().alias("crea_admission"),
45            # pl.col("recordtime").first().alias("crea_admission_time"),
46        )
47    )
48
49    # 2. Filter for 7–365 days before admission and extract
50    # 2a. Most recent creatinine 7–365d pre-admission (unused)
51    # 2b. Mean creatinine 7–365d pre-admission (used as baseline if not null)
52    crea_recent_mean_pre = (
53        crea_merged.filter(
54            pl.col("recordtime").is_between(
55                "admission_sub_365d", "admission_sub_7d", closed="left"
56            )
57        )
58        .sort("case_id", "recordtime")
59        .group_by("case_id")
60        .agg(

Documentation Publication ready

Caveats. • Sensitive to the baseline. AKI incidence depends strongly on how the baseline SCr is defined (see Step 2). • No KDIGO time windows. Each value is compared with the fixed baseline. The 48-h window (for +0.3 mg/dL) and the 7-day window (for 1.5 ×) are not applied. • SCr ≥ 4.0 mg/dL is always Stage 3, even without an acute rise. • Not one value per case. The output is a time series with one stage per creatinine measurement. To get the worst stage and its time, aggregate downstream. • No baseline, no creatinine staging. Cases without a baseline get only the KRT row (Stage 3) or the CKD row, if either applies.

Clinical

AKI stage (KDIGO, creatinine and kidney replacement therapy criteria) for every creatinine measurement during the hospital stay.

KDIGO stages acute kidney injury (AKI) by the rise in serum creatinine (SCr) relative to a baseline:

• Stage 1: SCr ≥ 0.3 mg/dL above baseline, or 1.5–1.9 × baseline • Stage 2: 2.0–2.9 × baseline • Stage 3: ≥ 3.0 × baseline, SCr ≥ 4.0 mg/dL, or start of kidney replacement therapy (KRT)

The creatinine criteria do not apply after KRT has started, or to patients with dialysis-dependent chronic kidney disease (CKD).

Implementation

Based on blood_creatinine_all, hemodialysis_icu_all and dx_ckd_dialysis.

1. Dialysis-dependent CKD. Cases flagged in dx_ckd_dialysis get -1 for every row, plus one row at hospital admission. 2. Baseline SCr. ◦ The mean of all of the patient's SCr values from 365 to 7 days before hospital admission, from any previous case. ◦ If there are none, the first SCr at or after hospital admission. 3. KRT start. The first dialysis in hemodialysis_icu_all that overlaps the hospital stay, with its start clipped to hospital admission. 4. Staging. Every SCr value between hospital admission and discharge is staged in this order: a) CKD flag → -1 b) measured at or after KRT start → 3 c) ratio to baseline ≥ 3 or SCr ≥ 4 → 3 d) ratio ≥ 2 → 2 e) ratio ≥ 1.5 or SCr ≥ baseline + 0.3 → 1 f) otherwise → 0 The KRT start is also added as a Stage 3 row, in case no SCr was measured after it.

Output: recordtime: Time of the SCr measurement, or the KRT start / admission for the added rows (clipped to the stay start) value: AKI stage: 0–3, or -1 for dialysis-dependent CKD value_unit: Stage, or Dialysis dependent CKD Flag attributes: aki_stage: No AKI, Stage 1–Stage 3, Dialysis dependent CKD Patient

`aki_urine_output`

v1 in corr_v1

charite_demo Type derived_dynamic Outcomes CORR-ICU Derived, dynamic mL/kg/h

Definition

Type: derived_dynamic
Dynamic: true
Requires

{
  "type": "derived_dynamic",
  "dynamic": true,
  "requires": [
    "body_weight",
    "urine_output"
  ]
}

Python

first 60 of 217 lines

1def aki_urine_output(var, cohort):
2    """Derive hourly KDIGO urine-output AKI stages per patient.
3
4    Urine output charted over irregular collection intervals is redistributed
5    to full clock hours in proportion to time overlap, normalized to body
6    weight (mL/kg/h) and staged with rolling 6, 12 and 24 h windows.
7
8    Example:
9        50 mL charted 05:00-05:30 and 200 mL charted 05:30-07:30 yield
10        05:00 -> 100 mL, 06:00 -> 100 mL, 07:00 -> 50 mL.
11
12    Args:
13        var: Concept being derived. Provides ``required_vars["urine_output"]``
14            and ``required_vars["body_weight"]``.
15        cohort: Cohort definition. ``cohort.primary_key`` names the patient
16            identifier column.
17
18    Returns:
19        One row per patient-hour with the primary key, ``recordtime`` (start
20        of the hour), ``value`` (AKI stage 0-3), ``value_unit`` ("Stage") and
21        ``attributes`` (struct of ``aki_window`` and ``aki_stage``).
22
23    Note:
24        ``pl`` (Polars) is not imported here: the CORR runtime injects it into
25        the namespace when the CCC is retrieved via the concept API. The
26        concept browser editor resolves it for autocompletion.
27    """
28    patient_id: str = cohort.primary_key
29    urine_output: pl.LazyFrame = var.required_vars["urine_output"].data.lazy()
30
31    # 1. Reconstruct collection intervals: each charting closes the interval
32    #    that opened with the previous charting of the same patient.
33    collection_intervals: pl.LazyFrame = (
34        urine_output.select(patient_id, "recordtime", "value")
35        .rename({"recordtime": "end_time"})
36        .sort(patient_id, "end_time")
37        .with_columns(
38            pl.col("end_time").shift(1).over(patient_id).alias("start_time")
39        )
40        .with_columns(
41            (pl.col("end_time") - pl.col("start_time"))
42            .dt.total_seconds()
43            .alias("collection_duration_s")
44        )
45        .with_columns(
46            (pl.col("collection_duration_s") / 3600).alias("collection_duration_h"),
47            # closed="left": an interval ending exactly on the hour does not
48            # spill into that hour as a spurious 0 mL row.
49            pl.datetime_ranges(
50                pl.col("start_time").dt.truncate("1h"), "end_time", "1h", closed="left"
51            ).alias("overlapped_hours"),
52        )
53        .filter(pl.col("collection_duration_s") > 0)
54        .with_columns(pl.col("collection_duration_h").gt(24).alias("exceeds_24h"))
55        .filter(pl.col("start_time").is_not_null())  # first charting has no interval
56    )
57
58    # 2. Distribute each interval's volume to the clock hours it overlaps,
59    #    exclude intervals > 24 h and sum shares per patient-hour.
60    hourly_urine: pl.LazyFrame = (

Documentation Publication ready

Caveats. • Chronic dialysis is not excluded. Patients on chronic dialysis cannot have AKI, but dx_ckd_dialysis is not applied here. Apply it as an exclusion criterion downstream. • Gaps are not zeros. Collection intervals > 24 h are excluded. They often mean the patient was away from the ICU, but may also reflect no urine output. Missing hours are left out of the windows; they are not counted as 0 mL. • Bladder irrigation. Whole calendar days with bladder irrigation are excluded, because urine output is unreliable on those days. • Not one value per stay. The output is a time series with one stage per hour. To get the worst stage and its time, aggregate downstream. • Too little data counts as "No AKI". Hours whose window covers less than 6 h of data get stage 0, not an empty value. • Missing body weight can create false Stage 3. Before the first body weight (or if there is none), the rate is empty, but the 12-h sum then evaluates to 0 and is classified as anuria (Stage 3).

Clinical

AKI stage (KDIGO urine output criterion) for every hour of the stay.

KDIGO stages acute kidney injury (AKI) by urine output (UO) relative to body weight:

• Stage 1: UO < 0.5 mL/kg/h for 6–12 h • Stage 2: UO < 0.5 mL/kg/h for ≥ 12 h • Stage 3: UO < 0.3 mL/kg/h for ≥ 24 h, or anuria for ≥ 12 h

Implementation

Based on urine_output and body_weight, per cohort stay.

1. Collection intervals. Each urine charting closes the interval that opened with the previous charting. The first charting of a stay has no interval and is dropped. 2. Hourly redistribution. Each volume is split across the clock hours it overlaps, in proportion to the overlap time, and then summed per hour. For example, 50 mL charted 05:00–05:30 and 200 mL charted 05:30–07:30 give 100 mL at 05:00, 100 mL at 06:00 and 50 mL at 07:00. Intervals > 24 h are excluded. 3. Bladder irrigation. Hours on any calendar day with a urine record flagged bladder_irrigation are removed. 4. Normalization. Hourly UO is divided by the most recent body weight (carried forward) to give mL/kg/h. 5. Staging. For each hour, trailing windows of 6, 12 and 24 h are evaluated. A window counts only if it covers its full length. Stages are assigned in this order: a) mean over 24 h < 0.3 mL/kg/h → 3 b) sum over 12 h = 0 (anuria) → 3 c) mean over 12 h < 0.5 mL/kg/h → 2 d) mean over 6 h < 0.5 mL/kg/h → 1 e) otherwise → 0

Output: recordtime: Start of the hour value: AKI stage: 0–3 value_unit: Stage attributes: aki_stage: No AKI, Stage 1–Stage 3; aki_window: ≤24h (maximum collection interval included)

`any_surgery_ops`

v1 in corr_v1

charite_demo Type native_static Perioperative CORR-ICU and CORR-OR Static boolean

Definition

Type: native_static
Select: !any
Variable: surgery_ops

{
  "type": "native_static",
  "select": "!any",
  "variable": "surgery_ops"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

`asa_physical_status`

v1 in corr_v1

charite_demo Type native_dynamic Perioperative CORR-OR Dynamic, per assessment class 1-6

Definition

Type: native_dynamic
Cleaning: value 1 to 6
Table: it_copra6_hierarchy_v2
Where: c_var_name IN ('BEH_ANAE_ASA_STATUS', 'Praemedikation_ASA_Status')

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name IN ('BEH_ANAE_ASA_STATUS', 'Praemedikation_ASA_Status')",
  "cleaning": {
    "value": {
      "low": 1,
      "high": 6
    }
  }
}

Python

1def asa_physical_status(var, cohort):
2    var.data["value"] = var.data["value"].str.strip().str[0]
3    var.data["value"] = pd.to_numeric(var.data["value"], errors="coerce")
4    var.data.drop_duplicates(inplace=True)
5    return var.data

Documentation Publication ready

Caveats. • Only the first character is read. A value counts only if it starts with the digit (e.g. 3 or 3E). Values such as ASA 3 or Roman numerals (III) become empty and are dropped. • All chartings are returned. There is no selection of the last value before surgery and no link to a procedure in this concept.

Clinical

ASA physical status (1–6) as charted in COPRA6, without the emergency suffix.

The ASA physical status classification, from 1 (healthy) to 6 (brain-dead organ donor), as documented in the anesthesia and premedication records. The emergency suffix ("E") is removed; emergency status is covered by a separate concept.

Implementation

Type native_dynamic, read directly from table it_copra6_hierarchy_v2 where c_var_name IN ('BEH_ANAE_ASA_STATUS', 'Praemedikation_ASA_Status').

1. Parse. Whitespace is trimmed, the first character is taken and converted to a number (non-numeric → empty). This also drops the E suffix. 2. De-duplicate. Exact duplicate rows are removed (0 % in the data). 3. Clean. Only values from 1 to 6 are kept.

Output: recordtime: Time of charting value: ASA class (1–6)

`blood_creatinine`

v1 in corr_v1

charite_demo Type native_dynamic Laboratory CORR-ICU and CORR-OR Dynamic, per measurement mg/dL

Definition

Type: native_dynamic
Cleaning: value 0 to 40
Table: it_ishmed_labor
Where: (c_katalog_leistungtext IN ('Kreatinin (Jaffé) HP','Kreatinin (Jaffé)','Kreatinin (Jaffé) (HP)','Kreatinin (enzym.) HP','Kreatinin (enzym.)','Kreatinin (enzym.) (HP)','Creatinin') OR c_leistungnr IN ('C_KREA','LD_00156','C_KREAY') OR (c_leistungnr = 'N_101600' AND c_katalog_leistungtext = 'Kreatinin')) AND NOT (c_leistungnr = 'KS4090')
Value dtype: DOUBLE

{
  "type": "native_dynamic",
  "table": "it_ishmed_labor",
  "where": "(c_katalog_leistungtext IN ('Kreatinin (Jaffé) HP','Kreatinin (Jaffé)','Kreatinin (Jaffé) (HP)','Kreatinin (enzym.) HP','Kreatinin (enzym.)','Kreatinin (enzym.) (HP)','Creatinin') OR c_leistungnr IN ('C_KREA','LD_00156','C_KREAY') OR (c_leistungnr = 'N_101600' AND c_katalog_leistungtext = 'Kreatinin')) AND NOT (c_leistungnr = 'KS4090')",
  "value_dtype": "DOUBLE",
  "cleaning": {
    "value": {
      "low": 0,
      "high": 40
    }
  }
}

Python

1def blood_creatinine(var, cohort):
2    # Ensure "value" exists in var.data
3    if "value" in var.data.columns:
4        var.data = var.data.with_columns(
5            # Convert to string (Utf8 type)
6            pl.col("value").cast(pl.Utf8)
7            # Replace commas with dots for consistent decimal formatting
8            .str.replace(",", ".")
9            # Extract the first decimal number
10            .str.extract(r"(\d+\.?\d*)", group_index=1)
11            # Convert to a float (f64)
12            .cast(pl.Float64)
13            # Overwrite the original 'value' column
14            .alias("value")
15        )
16
17    # Unit conversion: µmol/l to mg/dl
18    if "value_unit" in var.data.columns:
19        var.data = var.data.with_columns(
20            [
21                pl.when(pl.col("value_unit") == "µmol/l")
22                .then(pl.col("value") * 0.011312)
23                .otherwise(pl.col("value"))
24                .alias("value"),
25                pl.when(pl.col("value_unit") == "µmol/l")
26                .then(pl.lit("mg/dl"))
27                .otherwise(pl.col("value_unit"))
28                .alias("value_unit"),
29            ]
30        )
31    return var.data

Documentation Publication ready

Caveats. • Methods are mixed. Jaffé and enzymatic values are combined without distinction.

Clinical

Serum/plasma creatinine from ISH-MED lab data, in mg/dL.

Creatinine measured in blood (serum or plasma), using either the Jaffé or the enzymatic method. Creatinine from other materials, e.g. urine, is excluded.

Implementation

Type native_dynamic, read from table it_ishmed_labor. A row is included if any of these holds:

• c_katalog_leistungtext is one of: Kreatinin (Jaffé), Kreatinin (Jaffé) HP, Kreatinin (Jaffé) (HP), Kreatinin (enzym.), Kreatinin (enzym.) HP, Kreatinin (enzym.) (HP), Creatinin • c_leistungnr is one of: C_KREA, LD_00156, C_KREAY • c_leistungnr = 'N_101600' and c_katalog_leistungtext = 'Kreatinin'

Rows with c_leistungnr = 'KS4090' (values in mmol/l) are always excluded.

1. Parse. Commas are replaced with dots, and the first number in the value is extracted. 2. Convert. Values with unit µmol/l are multiplied by 0.011312 and their unit is set to mg/dl. 3. Clean. Values below 0 or above 40 are removed.

Output: recordtime: Time of the lab measurement value: Creatinine value_unit: mg/dl (or the original unit if not converted)

`blood_gas`

v1 in corr_v1

charite_demo Type complex Laboratory CORR-ICU and CORR-OR Dynamic, per sample multiple

Definition

Type: complex
Dynamic: true

{
  "type": "complex",
  "dynamic": true
}

Python

first 60 of 104 lines

1def blood_gas(var, cohort):
2    df = utils.add_time_window_expr(cohort._obs, time_window=var.time_window)
3    cb = utils.get_cb(df, primary_key=cohort.primary_key)
4    dbs = helpers.get_databases(cohort)
5
6    with helpers.temporary_table(cohort) as temp_tbl:
7        # BGA measurement label (in it_ishmed_labor) -> output column name.
8        bga_columns = {
9            "abnahmeort": "Abnahmeort",
10            "thb": "tHb",
11            "fio2": "FIO2",
12            "po2": "pO2",
13            "so2": "sO2",
14            "ph": "pH",
15            "pco2": "pCO2",
16            "lac": "Lac",
17            "glu": "Glu",
18            "ca++": "Ca++",
19            "na+": "Na+",
20            "k+": "K+",
21            "cl-": "Cl-",
22            "hct": "Hct",
23            "tbil": "tBil",
24            "hco3-": "HCO3-",
25            "abe": "ABE",
26            "ca(7.4)": "Ca(7.4)",
27            "p50(act)": "p50(act)",
28        }
29
30        conn = helpers.reinit_conn(cohort)
31        labor = conn.conn.table("it_ishmed_labor", database=dbs["prepared"])
32        tmp = conn.conn.table(temp_tbl, database=dbs["workbench"])
33
34        # Pivot the BGA labels into one column each, per (case, document time).
35        bga_src = labor.filter(
36            labor.c_katalog_leistungtext.isin(list(bga_columns.values()))
37            & labor.c_falnr.isin(tmp.case_id)
38        )
39        bga_pivot = bga_src.group_by("c_falnr", "c_dokument_timestamp").aggregate(
40            [
41                bga_src.c_wert.max(where=bga_src.c_katalog_leistungtext == label).name(
42                    out
43                )
44                for out, label in bga_columns.items()
45            ]
46        )
47
48        # Drop post-filter samples: timepoints whose minimum calcium (< 0.5)
49        # marks the sample as taken behind a filter.
50        calcium = labor.filter(labor.c_katalog_leistungtext.isin(["Ca++", "Ca(7.4)"]))
51        calcium_check = calcium.group_by("c_falnr", "c_dokument_timestamp").aggregate(
52            is_postfilter=calcium.c_wert.try_cast("float64").min() < 0.5
53        )
54
55        keep_cols = ["c_falnr", "c_dokument_timestamp"] + list(bga_columns.keys())
56        joined = bga_pivot.join(
57            calcium_check, ["c_falnr", "c_dokument_timestamp"], how="left"
58        )
59        bga_expr = joined.filter(~joined.is_postfilter.fill_null(False)).select(
60            keep_cols

Documentation Publication ready

Caveats. • Sample type must be filtered. Arterial, venous and capillary samples are mixed. Filter on attributes.abnahmeort before use. • Do not use attributes.fio2. It is the FiO₂ entered on the blood gas analyzer, which may be left at the default value of 0.21. Use vent_fio2 instead. • No temperature-corrected values. Only non-temperature-corrected blood gas values (e.g. pO2) are extracted, as the patient temperature may be left at the analyzer's default setting rather than being entered to reflect the patient's actual body temperature. • Post-filter samples are excluded. Samples with ionized calcium < 0.5 (Ca++ or Ca(7.4)) are treated as taken behind a filter (e.g. during citrate dialysis) and removed completely.

Clinical

All blood gas analyses (arterial, venous and capillary), one row per sample, with all measured values in attributes.

All blood gas analyses (BG): arterial, venous and capillary. Each row is one sample, with its sample type ("Abnahmeort") and all measured values. This is the base concept for every derived blood gas concept, e.g. blood_pao2_arterial.

Implementation

1. Source. Table it_ishmed_labor, restricted to the cases of the cohort and to the blood gas parameters below (c_katalog_leistungtext). 2. Sample grouping. All blood gas parameters recorded for the same hospital case at an identical documentation timestamp (c_dokument_timestamp) are grouped into a single sample, linking the sample type with its corresponding measurements. 3. Remove post-filter samples. Time points whose minimum Ca++ or Ca(7.4) is < 0.5 are dropped. 4. Assign to cohort stays by case ID. All measured values are converted to numbers and stored in attributes.

abnahmeort: Abnahmeort (sample type, text) po2, pco2, so2, ph: pO2, pCO2, sO2, pH hco3-, abe, p50(act): HCO3-, ABE, p50(act) lac, glu, tbil: Lac, Glu, tBil na+, k+, cl-, ca++, ca(7.4): Na+, K+, Cl-, Ca++, Ca(7.4) thb, hct: tHb, Hct fio2: FiO₂ (entered on the analyzer)

Output: recordtime: Document time of the sample attributes: Sample type and all measured values (see table above)

`blood_pao2_arterial`

v1 in corr_v1

charite_demo Type derived_dynamic Laboratory CORR-ICU and CORR-OR Dynamic, per measurement mmHg

Definition

Type: derived_dynamic
Requires
Cleaning: value 0 to 1000

{
  "type": "derived_dynamic",
  "requires": [
    "blood_gas"
  ],
  "cleaning": {
    "value": {
      "low": 0,
      "high": 1000
    }
  }
}

Python

1def blood_pao2_arterial(var, cohort):
2    df = var.required_vars["blood_gas"].data
3
4    out = (
5        df.filter(pl.col("attributes").struct.field("abnahmeort") == "Arterial")
6        .with_columns(
7            [
8                pl.col("attributes")
9                .struct.field("po2")
10                .cast(pl.Float64, strict=False)
11                .alias("value")
12            ]
13        )
14        .select([cohort.primary_key, "recordtime", "value"])
15    )
16    return out

Documentation Publication ready

Caveats. • Temperature-corrected values are excluded. The patient temperature may be left at the analyzer's default setting rather than being entered to reflect the actual body temperature, so temperature-corrected PaO₂ may be wrong. Only non-temperature-corrected PaO₂ is used. • Sample type depends on charting. Only samples labeled Arterial (field abnahmeort) are included. Samples with a missing or differently spelled label are excluded.

Clinical

Arterial partial pressure of oxygen (PaO₂) from point-of-care blood gas analysis.

PaO₂ (mmHg) from arterial blood gases (ABG) measured on point-of-care blood gas analyzers. Capillary and venous samples are excluded.

Implementation

Type derived_dynamic, based on blood_gas (source table it_ishmed_labor).

1. Select arterial samples. Only rows where attributes.abnahmeort = Arterial are kept. In the source data, the sample type ("Abnahmeort") and PaO₂ are linked through their timestamp. 2. Extract PaO₂. value = attributes.po2, converted to a number (values that cannot be converted become empty). 3. Clean. Values below 0 or above 1000 are removed.

Output: recordtime: Time of the blood gas value: PaO₂ (mmHg)

`blood_pressure_invasive`

v1 in corr_v1

charite_demo Type native_dynamic Hemodynamics CORR-ICU and CORR-OR Dynamic, continuous mmHg

Definition

Type: native_dynamic
Cleaning: value 0 to 300
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'vital_IBP'
Value dtype: float
Columns: {"value":"c_mean","attributes":{"systolic":"CAST(c_systolic AS float)","diastolic":"CAST(c_diastolic AS float)"}}

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'vital_IBP'",
  "value_dtype": "float",
  "columns": {
    "value": "c_mean",
    "attributes": {
      "systolic": "CAST(c_systolic AS float)",
      "diastolic": "CAST(c_diastolic AS float)"
    }
  },
  "cleaning": {
    "value": {
      "low": 0,
      "high": 300
    }
  }
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Only MAP is cleaned. Systolic and diastolic values are passed through without plausibility checks. • Zero values are kept. The lower limit of 0 keeps MAP = 0, which typically comes from flushing the line or a disconnected transducer.

Clinical

Invasive mean arterial pressure (MAP) from the arterial line, with systolic and diastolic pressure.

A dynamic concept with all MAP values measured invasively via an arterial line, as charted in COPRA6. Systolic and diastolic pressures are given alongside. Clinically impossible values are removed.

Implementation

Type native_dynamic, read directly from table it_copra6_hierarchy_v2 where c_var_name = 'vital_IBP'.

1. Value. value = c_mean (MAP). 2. Attributes. systolic = c_systolic, diastolic = c_diastolic (both converted to float). 3. Clean. MAP values outside 0–300 mmHg are removed.

Output: recordtime: Time of measurement value: MAP (mmHg) attributes: systolic, diastolic (mmHg)

`blood_pressure_mean`

v1 in corr_v1

charite_demo Type derived_dynamic Hemodynamics CORR-ICU and CORR-OR Dynamic, continuous mmHg

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "blood_pressure_noninvasive",
    "blood_pressure_invasive"
  ]
}

Python

1def blood_pressure_mean(var, cohort):
2    """Mean arterial pressure from invasive and non-invasive measurements.
3 
4    ``value`` holds the mean pressure. ``attributes`` keeps every source's
5    ``systolic`` and ``diastolic`` fields and gains a ``source`` field naming
6    the variable each measurement came from.
7    """ 
8    frames: list[pl.DataFrame] = []
9    for name, source in var.required_vars.items():
10        frames.append(
11            source.data.select(
12                cohort.primary_key,
13                "recordtime",
14                "value",
15                "value_unit",
16                # Add the source instead of replacing systolic/diastolic.
17                pl.col("attributes").struct.with_fields(pl.lit(name).alias("source")),
18            )
19        )
20 
21    df = pl.concat(frames).sort("recordtime")
22    return df

Documentation Publication ready

Caveats. • Invasive and non-invasive values are mixed. At the same time point there can be both an invasive and a non-invasive value. Use attributes.source to choose or prioritize. • Cleaning is done in the source variables. Values outside 0–300 mmHg are removed there; this concept applies no further cleaning.

Clinical

Mean arterial pressure (MAP) from invasive (arterial line) and non-invasive (cuff) measurements, with systolic and diastolic pressure.

A dynamic concept that combines all measured MAP values from arterial lines and blood pressure cuffs into one vital sign. Each row is one measurement. The matching systolic and diastolic pressures are given alongside, and the source shows whether it was invasive or non-invasive.

Implementation

Based on blood_pressure_invasive (arterial line) and blood_pressure_noninvasive (cuff).

1. Combine. All required variables are stacked. The name of each source variable is added to attributes as source; systolic and diastolic are kept. 2. Sort by charting time.

Output: recordtime: Time of measurement value: MAP (mmHg) value_unit: Unit from the source variable attributes: systolic, diastolic, source (blood_pressure_invasive or blood_pressure_noninvasive)

`blood_pressure_noninvasive`

v1 in corr_v1

charite_demo Type native_dynamic Hemodynamics CORR-ICU and CORR-OR Dynamic, per measurement mmHg

Definition

Type: native_dynamic
Cleaning: value 0 to 300
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'vital_NBP'
Value dtype: float
Columns: {"value":"c_mean","attributes":{"systolic":"CAST(c_systolic AS float)","diastolic":"CAST(c_diastolic AS float)"}}

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'vital_NBP'",
  "value_dtype": "float",
  "columns": {
    "value": "c_mean",
    "attributes": {
      "systolic": "CAST(c_systolic AS float)",
      "diastolic": "CAST(c_diastolic AS float)"
    }
  },
  "cleaning": {
    "value": {
      "low": 0,
      "high": 300
    }
  }
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Only MAP is cleaned. Systolic and diastolic values are passed through without plausibility checks.

Clinical

Non-invasive mean arterial pressure (MAP) from the blood pressure cuff, with systolic and diastolic pressure.

A dynamic concept with all MAP values measured non-invasively (cuff), as charted in COPRA6. Systolic and diastolic pressures are given alongside. Clinically impossible values are removed.

Implementation

Type native_dynamic, read directly from table it_copra6_hierarchy_v2 where c_var_name = 'vital_NBP'.

1. Value. value = c_mean (MAP). 2. Attributes. systolic = c_systolic, diastolic = c_diastolic (both converted to float). 3. Clean. MAP values outside 0–300 mmHg are removed.

Output: recordtime: Time of measurement value: MAP (mmHg) attributes: systolic, diastolic (mmHg)

`body_weight`

v1 in corr_v1

charite_demo Type complex Demographics CORR-ICU and CORR-OR Dynamic, per measurement kg

Definition

Type: complex
Dynamic: true

{
  "type": "complex",
  "dynamic": true
}

Python

first 60 of 157 lines

1def body_weight(var, cohort) -> pl.DataFrame:
2    """
3    Returns the most relevant body weight value per patient (static) based on
4    the dynamic history from Copra > SAP > Labor.
5    """
6
7    conn = helpers.reinit_conn(cohort)
8    dbs = helpers.get_databases(cohort)
9
10    with helpers.temporary_table(cohort, id_column="patient_id") as temp_tbl:
11        tmp = conn.conn.table(temp_tbl, database=dbs["workbench"])
12
13        # COPRA hierarchy weights.
14        copra = conn.conn.table("it_copra6_hierarchy_v2", database=dbs["prepared"])
15        copra_weight = copra.filter(
16            copra.c_var_name.isin(
17                [
18                    "Patient_Gewicht",
19                    "Behandlung_Gewicht_Aufnahme",
20                    "Praemedikation_Gewicht",
21                    "CO_klinStatus_Behandlung_Patient_Aufnahme_Gewicht_",
22                    "CO_Patient_Aufnahme_Gewicht",
23                ]
24            )
25            & copra.c_patnr.isin(tmp.patient_id)
26            & copra.c_value.try_cast("float64").between(25, 900)
27        ).select(
28            patient_id=copra.c_patnr,
29            recordtime=copra.c_var_timestamp,
30            body_weight=copra.c_value.try_cast("float64"),
31            source=ibis.literal("copra"),
32        )
33
34        # SAP observations.
35        obs = conn.conn.table("it_ishmed_observation", database=dbs["prepared"])
36        sap_weight = obs.filter(
37            (obs.c_type == "body_weight")
38            & obs.c_patnr.isin(tmp.patient_id)
39            & obs.c_value.try_cast("float64").between(25, 900)
40        ).select(
41            patient_id=obs.c_patnr,
42            recordtime=obs.c_valtimestamp,
43            body_weight=obs.c_value.try_cast("float64"),
44            source=ibis.literal("sap"),
45        )
46
47        # Laboratory measurements.
48        labor = conn.conn.table("it_ishmed_labor", database=dbs["prepared"])
49        labor_weight = labor.filter(
50            labor.c_katalog_leistungtext.like("%örpergewich%")
51            & labor.c_patnr.isin(tmp.patient_id)
52            & labor.c_wert.try_cast("float64").between(25, 900)
53        ).select(
54            patient_id=labor.c_patnr,
55            recordtime=labor.c_wert_timestamp,
56            body_weight=labor.c_wert.try_cast("float64"),
57            source=ibis.literal("labor"),
58        )
59
60        lf_all_weight = conn.lf_from_expr(

Documentation Publication ready

Caveats. • Weights are not limited to the stay. The first stay of a patient also receives all weights recorded before it, and the last stay all weights recorded after it. Weights recorded between two stays are assigned to neither. • Children's weights are flagged, not removed. adult_at_measurement marks whether the patient was ≥ 18 years old when the weight was recorded. Filter on it if needed. • The source is not kept. The output does not show whether a value came from COPRA, SAP or the lab. • Wide plausibility range. Only values outside 25–900 kg are removed. Implausible values within this range (e.g. 400 kg in an adult) are kept, so apply study-specific limits where needed.

Clinical

All body weight records of a patient (kg), from COPRA, SAP and lab data, assigned to the cohort stays.

Body weight in kg as a dynamic concept. It collects all weight records of the patient, including those outside the current hospital or ICU stay, from several sources (COPRA, SAP observations, lab) to improve completeness.

Implementation

1. Sources (patient level, all time; values outside 25–900 kg removed): ◦ COPRA (it_copra6_hierarchy_v2): Patient_Gewicht, Behandlung_Gewicht_Aufnahme, Praemedikation_Gewicht, CO_klinStatus_Behandlung_Patient_Aufnahme_Gewicht_, CO_Patient_Aufnahme_Gewicht ◦ SAP (it_ishmed_observation): c_type = 'body_weight' ◦ Lab (it_ishmed_labor): c_katalog_leistungtext LIKE '%örpergewich%' 2. Priority COPRA > SAP > lab. A SAP value is removed if a COPRA value exists within ±3 weeks. A lab value is removed if a COPRA or (remaining) SAP value exists within ±3 weeks. 3. De-duplicate. One value per patient and timestamp, preferring the higher-priority source. 4. Adult flag. adult_at_measurement = time from birth date to measurement ≥ 18 × 365 days. 5. Assign to stays. Each weight is assigned to the stay whose time window contains it. The window of the patient's first stay is extended to the past, and that of the last stay to the future.

Output: recordtime: Time of the weight record value: Body weight (kg) attributes: adult_at_measurement (true / false)

`diagnoses_all`

v1 in corr_v1

charite_demo Type native_dynamic Comorbidities CORR-ICU and CORR-OR Dynamic, per diagnosis ICD-10 code

Definition

Type: native_dynamic
Table: it_ishmed_diagnose
Where: c_gewissheit NOT IN ('V', 'A', 'VW')

{
  "type": "native_dynamic",
  "table": "it_ishmed_diagnose",
  "where": "c_gewissheit NOT IN ('V', 'A', 'VW')"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • The timestamp is the documentation time. recordtime is the ISH-MED charting time, not the time the condition began. It does not reflect the onset of the condition and should not be used to determine the timing of disease occurrence. • Status-post diagnoses are included. Only certainty codes V (suspected), A (excluded) and VW are removed, so Z (status post) diagnoses remain. • Missing certainty codes are removed. Because NOT IN in SQL never matches NULL, diagnoses without a c_gewissheit value are dropped as well.

Clinical

All ICD diagnoses charted in ISH-MED, excluding suspected and excluded diagnoses.

All ICD diagnoses documented for a hospital case in ISH-MED. Suspected and excluded diagnoses are removed. The concept is the base for diagnosis-based scores, e.g. elix_total_vw.

Implementation

Type native_dynamic, read directly from table it_ishmed_diagnose where c_gewissheit NOT IN ('V', 'A', 'VW').

Output: recordtime: ISH-MED charting time value: ICD code

`dx_ckd_dialysis`

v1 in corr_v1

charite_demo Type complex Comorbidities CORR-ICU and CORR-OR Static boolean

Definition

Type: complex
Dynamic: false

{
  "type": "complex",
  "dynamic": false
}

Python

first 60 of 126 lines

1def dx_ckd_dialysis(var, cohort):
2    """
3    Diese Funktion identifiziert Patienten mit chronischer Niereninsuffizienz mit Dialysebezug (dx_ckd_dialysis).
4    Es werden Diagnosen im Indexfall sowie im Rückblick von 365 Tagen vor stationärer Aufnahme geprüft.
5    """
6
7    conn = helpers.reinit_conn(cohort)
8
9    diag = conn.conn.table(
10        "it_ishmed_diagnose", database=cohort.sources["charite_demo"]["database"]
11    )
12    diagnoses_expr = diag.filter(
13        diag.c_diagnose_1.isin(["Z49.1", "N18.5", "Z99.2"])
14    ).select(
15        case_id=diag.c_falnr,
16        patient_id=diag.c_patnr,
17        # recordtime is kept as a string here and parsed to Datetime below.
18        recordtime=diag.c_diagnose_timestamp,
19        diagnose=diag.c_diagnose_1,
20    )
21
22    # --- Step 1: Lade Admissions (Indexfälle) ---
23    admission = cohort.obs.select("patient_id", "case_id", "hospital_admission")
24    diagnoses_orig = conn.df_from_expr(diagnoses_expr, datetime_cols=["recordtime"])
25
26    admission_cases = admission.unique()
27
28    # --- Step 3: Diagnosen mit Indexfällen verbinden ---
29    dx = diagnoses_orig.join(admission_cases, on="case_id", how="inner")
30
31    # --- Step 4: Flags im Indexfall setzen ---
32    index_flags = dx.filter(
33        pl.col("recordtime") >= pl.col("hospital_admission")
34    ).with_columns(
35        (pl.col("diagnose") == "Z99.2").alias("has_Z99_2"),
36        (pl.col("diagnose") == "Z49.1").alias("has_Z49_1"),
37        (pl.col("diagnose") == "N18.5").alias("has_N18_5"),
38    )
39
40    index_case_flags = (
41        index_flags.group_by("patient_id")
42        .agg(
43            pl.col("has_Z99_2").max().alias("has_Z99_2"),
44            pl.col("has_Z49_1").max().alias("has_Z49_1"),
45            pl.col("has_N18_5").max().alias("has_N18_5"),
46        )
47        .with_columns(
48            (pl.col("has_Z49_1") & pl.col("has_N18_5")).alias("has_N18_5_and_Z49_1")
49        )
50        .with_columns(
51            (pl.col("has_Z99_2") | pl.col("has_N18_5_and_Z49_1")).alias(
52                "dx_ckd_dialysis_index"
53            )
54        )
55        .select("patient_id", "dx_ckd_dialysis_index")
56    )
57    # --- Step 5: Diagnosen im Rückblick auf 365 Tage ---
58    all_dx = diagnoses_orig.join(admission_cases, on="patient_id", how="inner").filter(
59        pl.col("case_id") != pl.col("case_id_right")
60    )  # Indexfall ausschließen

Documentation Publication ready

Caveats. • Flag is per patient, not per case. Codes found for any of a patient's cohort cases, or in the 365 days before any of them, flag all of that patient's stays, including earlier ones. • Diagnosis certainty is ignored. The table is read directly without the certainty filter used in diagnoses_all, so suspected (V) and excluded (A) diagnoses also count. • Z49.1 and N18.5 must be found in the same window (the index case, or the 365-day lookback), but may come from different cases.

Clinical

Flag per stay: dialysis-dependent chronic kidney disease (CKD), based on ICD codes.

Identifies patients with dialysis-dependent CKD. This separates new (de novo) dialysis for acute kidney injury from chronic dialysis, e.g. in aki_crea_based. Dialysis dependence is coded as:

• Z99.2 (dependence on dialysis), or • Z49.1 (extracorporeal dialysis) together with N18.5 (CKD stage 5)

Implementation

Diagnoses are read from table it_ishmed_diagnose where c_diagnose_1 is exactly Z49.1, N18.5 or Z99.2.

1. Index case. Diagnoses of the cohort cases, charted at or after hospital admission. 2. Lookback. Diagnoses from the patient's other cases, charted in the 365 days before hospital admission. 3. Flag. In each window, Z99.2, or Z49.1 together with N18.5, gives true. The patient is flagged if either window is true. 4. Assign to stays. The flag is joined to all cohort stays of the patient via the case number. Stays without a flag are set to false.

Output: dx_ckd_dialysis: true / false

`dx_diabetes_mellitus_any`

v1 in corr_v1

charite_demo Type native_dynamic Comorbidities CORR-ICU and CORR-OR Dynamic, per diagnosis ICD-10 code

Definition

Type: native_dynamic
Table: it_ishmed_diagnose
Where: (c_diagnose_1 LIKE 'E10.%' OR c_diagnose_1 LIKE 'E11.%' OR c_diagnose_1 LIKE 'E12.%' OR c_diagnose_1 LIKE 'E13.%' OR c_diagnose_1 LIKE 'E14.%') AND c_gewissheit NOT IN ('V', 'A', 'VW')
Value dtype: VARCHAR

{
  "type": "native_dynamic",
  "table": "it_ishmed_diagnose",
  "where": "(c_diagnose_1 LIKE 'E10.%' OR c_diagnose_1 LIKE 'E11.%' OR c_diagnose_1 LIKE 'E12.%' OR c_diagnose_1 LIKE 'E13.%' OR c_diagnose_1 LIKE 'E14.%') AND c_gewissheit NOT IN ('V', 'A', 'VW')",
  "value_dtype": "VARCHAR"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • One row per diagnosis, not per patient. A case can have several diabetes codes. To get a yes/no flag per stay, aggregate downstream. • Missing certainty codes are removed. Because NOT IN in SQL never matches NULL, diagnoses without a c_gewissheit value are dropped (as in diagnoses_all). • Codes without a subcode are not captured. Only codes with a dot and a subcode match (e.g. E11.9, E11.90); a bare E11 does not.

Clinical

All charted ICD codes for diabetes mellitus (E10–E14), excluding suspected and excluded diagnoses.

Identifies patients with diabetes mellitus from charted ICD diagnoses:

• E10: type 1 diabetes mellitus • E11: type 2 diabetes mellitus • E12: malnutrition-related diabetes mellitus • E13 / E14: other specified / unspecified diabetes mellitus

Implementation

Type native_dynamic, read directly from table it_ishmed_diagnose where:

• c_diagnose_1 starts with E10., E11., E12., E13. or E14. (LIKE 'E1x.%'), which includes all 4- and 5-digit subcodes, and • c_gewissheit NOT IN ('V', 'A', 'VW'), which removes suspected and excluded diagnoses.

Output: recordtime: ISH-MED charting time value: ICD code (text)

`elix_total_vw`

v1 in corr_v1

charite_demo Type derived_static Comorbidities CORR-ICU and CORR-OR Static score

Definition

Type: derived_static
Requires

{
  "type": "derived_static",
  "requires": [
    "diagnoses_all",
    "age_on_admission"
  ]
}

Python

1def elix_total_vw(var, cohort):
2    dx_all = (
3        var.required_vars["diagnoses_all"]
4        .data.join(
5            cohort.obs.select(
6                [cohort.primary_key, "age_on_admission", "hospital_discharge"]
7            ),
8            on=cohort.primary_key,
9            how="left",
10        )
11        .with_columns(
12            pl.col("value").cast(pl.Utf8).str.replace_all(r"\.", "").alias("value_c"),
13            pl.col("hospital_discharge").dt.year().alias("discharge_year"),
14        )
15    )
16
17    elix = comorbidity(
18        score="elixhauser",
19        df=dx_all,
20        id_col=cohort.primary_key,
21        code_col="value_c",
22        age_col="age_on_admission",
23        year_col="discharge_year",
24        # icd_modification="icd10gm", # Uncomment as soon as PR#1 is merged @Finn
25        weights="van_walraven",
26        return_categories=True,
27    )
28    # pycomorb >= 1.0 names the score column "Elixhauser Comorbidity Index"
29    elix = elix.rename(
30        {
31            col: "elix_total_vw"
32            for col in ("Elixhauser van Walraven Score", "Elixhauser Comorbidity Index")
33            if col in elix.columns
34        }
35    )
36
37    elix = elix.with_columns(
38        pl.struct(
39            [
40                col
41                for col in elix.columns
42                if col not in ["elix_total_vw", cohort.primary_key]
43            ]
44        ).alias("elix_total_vw_detail")
45    )
46    elix = elix.select([cohort.primary_key, "elix_total_vw", "elix_total_vw_detail"])
47    return elix

Documentation Publication ready

Caveats. • ICD-10-GM is not yet used. The icd10gm option is still commented out in the code (pending pycomorb PR #1), so codes are mapped with the package default. The discharge year is passed along to account for code changes over time. • All charted diagnoses count. There is no distinction between pre-existing comorbidities and diagnoses acquired during the stay. • No diagnoses, no score. Stays without any charted diagnosis do not appear in the output and are not set to 0.

Clinical

Elixhauser Comorbidity Index (van Walraven weights) per stay, based on charted ICD diagnoses.

The Elixhauser Comorbidity Index summarizes a patient's comorbidity burden from ICD diagnosis codes. It uses the van Walraven weights, so the total can be negative. The individual Elixhauser categories are returned as elix_total_vw_detail.

Implementation

Based on diagnoses_all, using the pycomorb (https://github.com/CUB-CORR/pycomorb) package.

1. Prepare codes. Dots are removed from the ICD codes (e.g. E11.9 → E119). Age on admission and the year of hospital discharge are added per stay. 2. Calculate. comorbidity(score="elixhauser", weights="van_walraven", return_categories=True) is run per stay. 3. Output. The total score is stored as elix_total_vw. All category columns are combined into the struct elix_total_vw_detail.

Output: elix_total_vw: Elixhauser index, van Walraven weighted (one value per stay) elix_total_vw_detail: Individual Elixhauser categories

`elixhauser_icd10_chf`

v1 in corr_v1

charite_demo Type native_static Comorbidities CORR-ICU and CORR-OR Static boolean

Definition

Type: native_static
Select: !any
Variable: diagnoses_all
Where: !startswith(value, ['I09.9', 'I11.0', 'I13.0', 'I13.2', 'I25.5', 'I42.0', 'I42.5', 'I42.6', 'I42.7', 'I42.8', 'I42.9', 'I43', 'I50', 'P29.0'])

{
  "type": "native_static",
  "select": "!any",
  "variable": "diagnoses_all",
  "where": "!startswith(value, ['I09.9', 'I11.0', 'I13.0', 'I13.2', 'I25.5', 'I42.0', 'I42.5', 'I42.6', 'I42.7', 'I42.8', 'I42.9', 'I43', 'I50', 'P29.0'])"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Timing is not checked. All diagnoses from diagnoses_all count, including those charted later in the stay. Pre-existing CHF cannot be told apart from CHF that developed during the stay. • Diagnosis certainty is filtered as in diagnoses_all (suspected and excluded diagnoses removed; status-post diagnoses kept). • Separate from elix_total_vw. The CHF category in elix_total_vw comes from the pycomorb mapping and may differ slightly.

Clinical

Flag per stay: Elixhauser category congestive heart failure (CHF), based on ICD codes.

The Elixhauser comorbidity category congestive heart failure (CHF), identified from charted ICD-10 diagnoses.

Implementation

Type native_static, based on diagnoses_all. The flag is true if any diagnosis of the stay starts with one of these codes:

I09.9, I11.0, I13.0, I13.2, I25.5, I42.0, I42.5, I42.6, I42.7, I42.8, I42.9, I43, I50, P29.0

Matching is by prefix, so all subcodes are included (e.g. I50.01, I43.1).

Output: value: true / false (one value per stay)

`endotracheal_tube`

v1 in corr_v1

charite_demo Type derived_dynamic Airway CORR-ICU and CORR-OR Dynamic, event datetime

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "airway_device"
  ]
}

Python

1def endotracheal_tube(var, cohort):
2    df = var.required_vars["airway_device"].data
3    tube_types = [
4        "Endotracheal tube",
5        "Laryngektomietubus",
6        "Microcuff Endotracheal tube",
7    ]
8
9    out = df.filter(pl.col("value").is_in(tube_types)).select(
10        [cohort.primary_key, "recordtime", "recordtime_end", "value", "attributes"]
11    )
12    return out

Documentation Publication ready

Caveats. • Removal time is missing for about 10 % of tubes, mostly because the patient died (removal not charted) or because a tracheal tube was inserted (tracheostomy). airway_device imputes the end only for the last device of a stay. A tube followed by a tracheostomy therefore keeps an empty end time. • Consecutive tubes are not merged. A reintubation or tube change often appears as several rows, where the next tube starts shortly after, or exactly at, the end of the previous one. invasive_vent merges these; this concept does not. • Laryngectomy tubes are included, although they are not endotracheal tubes in the strict sense.

Clinical

Insertion and removal times of endotracheal tubes, filtered from airway_device.

Time of endotracheal intubation and time of removal of the endotracheal tube. Each row is one documented tube.

Implementation

Based on airway_device (see there for extraction, classification and imputation). Only rows with value = Endotracheal tube, Microcuff Endotracheal tube or Laryngektomietubus are kept.

Output: recordtime: Insertion time recordtime_end: Removal time (imputed where possible, see airway_device) value: Device type attributes: As in airway_device (incl. imputed_from)

`fio2_observed`

v1 in corr_v1

charite_demo Type native_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, continuous %

Definition

Type: native_dynamic
Cleaning: value 0 to 100
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'beat_mess_FiO2'
Value dtype: DOUBLE

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'beat_mess_FiO2'",
  "value_dtype": "DOUBLE",
  "cleaning": {
    "value": {
      "low": 0,
      "high": 100
    }
  }
}

Python

No Python: corr-vars reads this concept directly from the definition above.

`fio2_set`

v1 in corr_v1

charite_demo Type derived_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, continuous %

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "fio2_set_helper",
    "ventilator_mode_automatic_standby"
  ]
}

Python

1def fio2_set(var, cohort):
2    unfiltered: pl.LazyFrame = var.required_vars["fio2_set_helper"].data.lazy()
3    intervals: pl.LazyFrame = var.required_vars[
4        "ventilator_mode_automatic_standby"
5    ].data.lazy()
6
7    with tempfile.TemporaryDirectory() as tmpdir:
8        val_on_standby = (
9            unfiltered.select(cohort.primary_key, "recordtime", "value", "value_unit")
10            .join_where(
11                intervals.select(
12                    pl.col(cohort.primary_key).alias("pk"),
13                    pl.col("recordtime").alias("start"),
14                    pl.col("recordtime_end").alias("end"),
15                ),
16                pl.col(cohort.primary_key) == pl.col("pk"),
17                pl.col("recordtime").is_between("start", "end", closed="none"),
18            )
19            .select(cohort.primary_key, "recordtime", "value", "value_unit")
20        )
21
22        (
23            unfiltered.join(
24                val_on_standby, on=[cohort.primary_key, "recordtime"], how="anti"
25            ).sink_parquet(os.path.join(tmpdir, f"{var.var_name}.parquet"))
26        )
27
28        result = pl.read_parquet(os.path.join(tmpdir, f"{var.var_name}.parquet"))
29
30    return result

Documentation Publication ready

Caveats. • Helper concept, do not use directly. Use vent_fio2, which combines set and observed FiO₂ and converts them to a fraction. • Standby boundaries are kept. Values documented exactly at the start or end of a standby interval are not removed.

Clinical

Set FiO₂ from the ventilator, excluding values documented during ventilator standby.

The FiO₂ set on the ventilator (in %), as documented in COPRA6. Values documented while the ventilator was in standby are removed, because no gas was being delivered to the patient.

Implementation

Type derived_dynamic, based on fio2_set_helper and ventilator_mode_automatic_standby.

1. Find standby values. Values from fio2_set_helper that lie strictly within a standby interval of the same stay (start < recordtime < end) are identified. 2. Remove them. All rows with the same stay and time as a standby value are removed. All other rows are kept unchanged.

Output: recordtime: Time of documentation value: Set FiO₂ (%) value_unit: Unit from fio2_set_helper

`fio2_set_helper`

v1 in corr_v1

charite_demo Type native_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, continuous %

Definition

Type: native_dynamic
Cleaning: value 0 to 100
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'beat_einstell_FiO2'
Value dtype: DOUBLE

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'beat_einstell_FiO2'",
  "value_dtype": "DOUBLE",
  "cleaning": {
    "value": {
      "low": 0,
      "high": 100
    }
  }
}

Python

No Python: corr-vars reads this concept directly from the definition above.

`hemodialysis_icu`

v1 in corr_v1

charite_demo Type native_dynamic Kidney CORR-ICU Dynamic, interval RRT mode

Definition

Type: native_dynamic
Table: it_copra6_therapy
Where: c_apparat_mode IN ('C-HD','CVVHD','CVVHD Citrat','CVVHD citrat','CVVHD citrat Cytosorb','CVVHD Citrat Cytosorb','CVVHD Cytosorb', 'CVVHD Heparin', 'CVVHD Heparin Cytosorb','CVVHD heparin Cytosorb','CVVHDF Citrat','CVVHDF citrat','CVVHDF citrat Cytosorb','CVVHDF Citrat Cytosorb','CVVHDF Heparin', 'CVVHDF heparin','CVVHDF Heparin Cytosorb','CVVHDF heparin Cytosorb','HD','HD Citrat','HDF','SLED','SLED Genius','SLED Genius Citrat','SLED MF','SLED MF Citrat','UF','Kreisen')
Value dtype: VARCHAR

{
  "type": "native_dynamic",
  "table": "it_copra6_therapy",
  "where": "c_apparat_mode IN ('C-HD','CVVHD','CVVHD Citrat','CVVHD citrat','CVVHD citrat Cytosorb','CVVHD Citrat Cytosorb','CVVHD Cytosorb', 'CVVHD Heparin', 'CVVHD Heparin Cytosorb','CVVHD heparin Cytosorb','CVVHDF Citrat','CVVHDF citrat','CVVHDF citrat Cytosorb','CVVHDF Citrat Cytosorb','CVVHDF Heparin', 'CVVHDF heparin','CVVHDF Heparin Cytosorb','CVVHDF heparin Cytosorb','HD','HD Citrat','HDF','SLED','SLED Genius','SLED Genius Citrat','SLED MF','SLED MF Citrat','UF','Kreisen')",
  "value_dtype": "VARCHAR"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • End times are not always correct, as confirmed by clinical review. • Sessions are split. A single dialysis session is split into several rows whenever clinicians change the documentation. There is no logic yet for combining consecutive rows into one session. • Kreisen is included. The definition also extracts the mode Kreisen (circuit recirculating), which may mean that the patient is actually not being dialyzed.

Clinical

Start and end times of all intermittent and continuous renal replacement therapy (RRT) in the ICU, from the COPRA therapy bars.

All RRT sessions documented as therapy bars in COPRA6, both intermittent (HD, HDF, SLED) and continuous (CVVHD, CVVHDF), including isolated ultrafiltration (UF). Each row is one documented RRT interval with its mode.

Implementation

Type native_dynamic, read directly from table it_copra6_therapy where c_apparat_mode is one of the following 28 modes (exact match):

• CVVHD: CVVHD, C-HD, CVVHD Citrat, CVVHD citrat, CVVHD Heparin, CVVHD Cytosorb, CVVHD Citrat Cytosorb, CVVHD citrat Cytosorb, CVVHD Heparin Cytosorb, CVVHD heparin Cytosorb • CVVHDF: CVVHDF Citrat, CVVHDF citrat, CVVHDF Heparin, CVVHDF heparin, CVVHDF Citrat Cytosorb, CVVHDF citrat Cytosorb, CVVHDF Heparin Cytosorb, CVVHDF heparin Cytosorb • Intermittent: HD, HD Citrat, HDF, SLED, SLED Genius, SLED Genius Citrat, SLED MF, SLED MF Citrat • Other: UF, Kreisen

Values are stored as VARCHAR. No cleaning is applied.

Output: recordtime / recordtime_end: Start and end of the RRT interval value: RRT mode (c_apparat_mode)

`icu_admiss_type`

v1 in corr_v1

charite_demo Type derived_static Admission CORR-ICU Static, per ICU stay surgical / medical

Definition

Type: derived_static
Compatible with: ["icu_stay"]
Requires: icu_admission
any_surgery_ops_peri_icu_admission

{
  "type": "derived_static",
  "compatible_with": [
    "icu_stay"
  ],
  "requires": {
    "icu_admission": {
      "template": "icu_admission",
      "tmin": "inherit",
      "tmax": "inherit"
    },
    "any_surgery_ops_peri_icu_admission": {
      "template": "any_surgery_ops",
      "tmin": [
        "icu_admission",
        "-24h"
      ],
      "tmax": [
        "icu_admission",
        "6h"
      ]
    }
  }
}

Python

1def icu_admiss_type(var, cohort):
2    return (
3        var.required_vars["icu_admission"]
4        .data.join(
5            var.required_vars["any_surgery_ops_peri_icu_admission"].data.select(
6                "icu_stay_id", "any_surgery_ops"
7            ),
8            on="icu_stay_id",
9            how="inner",
10        )
11        .group_by("icu_stay_id")
12        .agg(
13            pl.any("any_surgery_ops")
14            .replace_strict({True: "surgical", False: "medical"})
15            .alias("icu_admiss_type")
16        )
17    )

Documentation Publication ready

Caveats. • Not the ICU's department. This classification differs from classifications of the specific ICU (icu_id), which depend on the responsible department. • Misclassification is possible. Medical admissions with a minor procedure in the window, surgical patients admitted to the ICU for a medical reason, and patients who need surgery later in their ICU stay can all be misclassified. Adjust the window or the logic where this matters for a study. • ICU-level cohorts only. The code uses icu_stay_id directly instead of the cohort's primary key.

Clinical

ICU admission type per ICU stay: surgical (surgery within ±1 day of ICU admission) or medical.

Classifies each ICU admission as surgical or medical, based on the timing of documented surgery relative to ICU admission:

• Surgical: surgery documented (anesthesia start) within ±1 day of ICU admission. This captures direct postoperative admissions as well as surgery shortly before or after admission, e.g. in trauma surgery. • Medical: no surgery in this window, typically admissions for acute medical conditions.

This split is commonly used in clinical trials and epidemiological studies.

Implementation

Based on icu_admission and any_surgery_ops_peri_icu_admission. The ±1-day window and the surgery timestamps (op_start_anaesthesia) are defined in any_surgery_ops_peri_icu_admission.

1. Join. ICU stays are joined with any_surgery_ops from the helper concept on icu_stay_id (inner join). 2. Classify. If any any_surgery_ops row of the stay is true, the stay is surgical; otherwise it is medical.

Output: icu_stay_id: ICU stay icu_admiss_type: surgical or medical (one value per stay)

`icu_admission_apache_iii`

v1 in corr_v1

charite_demo Type derived_static Admission CORR-ICU Static, per ICU stay category

Definition

Type: derived_static
Compatible with: ["icu_stay"]
Requires: surgery_ops_peri_icu_admission

{
  "type": "derived_static",
  "compatible_with": [
    "icu_stay"
  ],
  "requires": {
    "surgery_ops_peri_icu_admission": {
      "template": "surgery_ops",
      "tmin": [
        "icu_admission",
        "-24h"
      ],
      "tmax": [
        "icu_admission",
        "6h"
      ]
    }
  }
}

Python

first 60 of 148 lines

1def icu_admission_apache_iii(var, cohort):
2    surgery_ops_peri_icu_admission: pl.LazyFrame = var.required_vars[
3        "surgery_ops_peri_icu_admission"
4    ].data.lazy()
5
6    # diagnosis/apache3_diagnosis_mappings_apache3_j_anzics.csv in the charite_demo
7    # file library
8    apache_iii_mapping = pl.scan_csv(getfile("84c31bdb-67d9-5543-a419-e7a8a4e6829f"))
9
10    apache_iii_ops_first_condition_mapping = (
11        apache_iii_mapping.filter(pl.col("code_system").eq("OPS-2025"))
12        .select(
13            "category",
14            "disease_name",
15            pl.col("codes").str.split(",").alias("first_code"),
16            "ranking_ops_categories",
17            pl.col("only_cat_1212_second_condition")
18            .is_not_null()
19            .alias("check_second_condition"),
20        )
21        .explode("first_code")
22    )
23
24    apache_iii_ops_second_condition_mapping = (
25        apache_iii_mapping.filter(
26            pl.col("code_system").eq("OPS-2025")
27            & pl.col("only_cat_1212_second_condition").is_not_null()
28        )
29        .select(
30            pl.col("codes").str.split(",").alias("first_code"),
31            pl.col("only_cat_1212_second_condition")
32            .str.split(",")
33            .alias("second_code"),
34        )
35        .explode("first_code")
36        .explode("second_code")
37    )
38
39    ops_first_condition_matched = surgery_ops_peri_icu_admission.select(
40        "icu_stay_id", "value"
41    ).join_where(
42        apache_iii_ops_first_condition_mapping,
43        pl.col("value").str.starts_with(pl.col("first_code")),
44    )
45
46    ops_second_condition_matched = (
47        surgery_ops_peri_icu_admission.select(
48            pl.col("icu_stay_id").name.suffix("_left"), "value"
49        )
50        .lazy()
51        .join_where(
52            ops_first_condition_matched.lazy()
53            .select(pl.col("icu_stay_id").name.suffix("_right"), "first_code")
54            .join(apache_iii_ops_second_condition_mapping.lazy(), on="first_code"),
55            pl.col("icu_stay_id_left").eq(pl.col("icu_stay_id_right")),
56            pl.col("value").str.starts_with(pl.col("second_code")),
57        )
58        .drop("icu_stay_id_right")
59        .rename({"icu_stay_id_left": "icu_stay_id"})
60    )

Documentation Publication ready

Caveats. • Surgery takes priority over the diagnosis. If a mapped OPS code is found from 24 h before to 6 h after ICU admission, its category is used, even if the main diagnosis points to a different category. • The main diagnosis is not always the admission diagnosis. It may not reflect the reason for ICU admission and could have occurred after ICU admission. • 2025 code versions. The mapping uses OPS-2025 and ICD-10-GM-2025. Codes that changed in earlier versions may not be matched. • No match, no category. Stays without a mapped OPS or ICD code get an empty value.

Clinical

APACHE III diagnostic category of the ICU admission, from surgery around ICU admission (OPS) or, if none, the main diagnosis (ICD-10-GM).

Assigns each ICU admission to one of 11 predefined APACHE III admission diagnosis categories, using a manual mapping based on APACHE III classification principles (ANZICS APACHE III-J). Surgical procedures around ICU admission take priority. Otherwise, the main diagnosis is used, because it is consistently coded for every ICU case.

Implementation

Type derived_static, for icu_stay cohorts. Based on surgery_ops_peri_icu_admission (template surgery_ops, window ICU admission −24 h to +6 h), the cohort's ICU admission diagnoses, and the mapping file diagnosis/apache3_diagnosis_mappings_apache3_j_anzics.csv (file id 84c31bdb-67d9-5543-a419-e7a8a4e6829f).

1. OPS match. Each OPS code in the window is matched by prefix to the OPS-2025 codes in the mapping. 2. Second condition. For mapping entries with a second condition (only_cat_1212_second_condition), another OPS code of the same stay must also match its second code list. 3. OPS priority. Of all matched categories, only those with the best (lowest) ranking_ops_categories are kept. 4. ICD match. The first ICU admission diagnosis (main diagnosis) is matched by prefix to the ICD-10-GM-2025 codes in the mapping. 5. Combine. icu_admission_apache_iii = OPS category if available, otherwise ICD category.

Output: icu_admission_apache_iii: APACHE III category (one value per stay) icu_admission_apache_iii_components: ops_category, icd_category

`icu_length_of_stay`

v1 in corr_v1

charite_demo Type derived_static Admission CORR-ICU Static days

Definition

Type: derived_static
Compatible with: ["icu_stay"]
Requires: icu_admission
icu_discharge
Expression: IF(icu_discharge - icu_admission IS NULL, NULL, GREATEST((EXTRACT(EPOCH FROM icu_discharge) - EXTRACT(EPOCH FROM icu_admission)) / (24 * 60 * 60), 1.0))

{
  "type": "derived_static",
  "compatible_with": [
    "icu_stay"
  ],
  "requires": [
    "icu_admission",
    "icu_discharge"
  ],
  "expression": "IF(icu_discharge - icu_admission IS NULL, NULL, GREATEST((EXTRACT(EPOCH FROM icu_discharge) - EXTRACT(EPOCH FROM icu_admission)) / (24 * 60 * 60), 1.0))"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • The minimum is 1 day. Stays shorter than 24 h are set to 1. This includes implausible stays where discharge is before admission. • Decimal days. The value is not rounded (e.g. 2.5 = 60 h). • Missing admission or discharge time gives an empty value.

Clinical

ICU length of stay in days (decimal), with a minimum of 1 day.

The length of this ICU stay in days, calculated from ICU admission to ICU discharge. If consecutive ICU stays were merged (ICU readmission within less than 24 h, see icu_stay_id), it is the length of the merged stay, from the first ICU admission to the last ICU discharge. Time spent outside the ICU in between (e.g. in the operating room, for diagnostics or on a normal ward) is then included. ICU stays separated by 24 h or more remain separate stays, each with its own length of stay.

Implementation

Type derived_static, for icu_stay cohorts, based on icu_admission and icu_discharge. Same logic as in CORR 1.0:

value = max((icu_discharge − icu_admission) in seconds / 86 400, 1)

Output: value: ICU length of stay (days, one value per ICU stay)

`invasive_vent`

v1 in corr_v1

charite_demo Type derived_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, interval datetime

Definition

Type: derived_dynamic
Requires: hospital_admission
hospital_discharge
death_timestamp

{
  "type": "derived_dynamic",
  "requires": [
    "airway_device",
    "therapy_all",
    "hospital_admission",
    "hospital_discharge",
    "death_timestamp"
  ]
}

Python

first 60 of 282 lines

1def invasive_vent(var: VariableContext, cohort: Cohort) -> pl.DataFrame:
2    # ---------- Primary Keys & Admission Data ----------
3    pk = cohort.primary_key
4
5    admission_discharge = cohort.obs.select(
6        pk, "hospital_admission", "hospital_discharge"
7    )
8
9    # ---------- Vent_mode Part ------------
10    df = var.required_vars["therapy_all"].data.unnest("attributes")
11    df = df.rename({"devicename": "c_apparat_name", "value": "c_apparat_mode"})
12
13    # ventilation/mapping_ventilator_modes_JHH_28022025.csv in the charite_demo file library
14    vent_loc = pl.read_csv(
15        getfile("2df4a1f9-bf24-583c-8cae-94c9b57691e3"), encoding="utf8-lossy"
16    ).unique()
17
18    df_final_vent = df.join(
19        vent_loc, on=["c_apparat_mode", "c_apparat_name"], how="left"
20    )
21
22    ventilation_df = (
23        df_final_vent.rename({"apparat_mode_new_cat": "value"})
24        .with_columns(attributes=pl.struct(["c_apparat_mode", "c_apparat_name"]))
25        .rename({"c_apparat_name": "devicename"})
26        .filter(pl.col("value").is_in(["mechanical ventilation"]))
27        .drop(["devicename", "c_apparat_mode", "category"])
28    )
29
30    # ---------- Airway Filtering -----------
31    df_airway = var.required_vars["airway_device"].data
32
33    # Join hospital bounds and add duration in minutes
34    df_airway = df_airway.join(admission_discharge, on=pk, how="left")
35    df_airway = df_airway.with_columns(
36        pl.col("recordtime_end")
37        .sub(pl.col("recordtime"))
38        .dt.total_seconds()
39        .truediv(60)
40        .alias("duration_min")
41    )
42
43    # Apply quality filters
44    df_airway = df_airway.filter(
45        (pl.col("duration_min").is_null() | pl.col("duration_min").ge(5))
46        & (
47            pl.col("recordtime_end").is_null()
48            | pl.col("recordtime").is_null()
49            | pl.col("recordtime_end").ge(pl.col("recordtime"))
50        )
51        & (
52            pl.col("recordtime_end").is_null()
53            | pl.col("hospital_admission").is_null()
54            | pl.col("recordtime_end").ge(pl.col("hospital_admission"))
55        )
56        & (
57            pl.col("recordtime").is_null()
58            | pl.col("hospital_discharge").is_null()
59            | pl.col("recordtime").le(pl.col("hospital_discharge"))
60        )

Documentation Publication ready (Later refinement)

Caveats. • Not an outcome measure. This is a dynamic variable listing every IMV interval. Total ventilation time or ventilator-free days must be derived downstream. • Endotracheal and laryngectomy tubes count as IMV without checking ventilator data. For tracheal tubes, the episode bounds come from the ventilator record, not from cannula insertion or removal. • Ventilator intervals reaching more than 30 min outside the tracheal-tube period are dropped, not clipped. This can lose ventilation that continues across a tube change. • Merging of intervals. Gaps of less than 1 h between consecutive ventilation episodes are merged into a single episode. This bridges short interruptions of the ventilator record, e.g. during patient transport with a transport ventilator that does not transmit data to COPRA. The gaps are included in the calculated duration, which may overestimate the actual ventilation time. Conversely, an interruption longer than 1 h (e.g. a longer intervention or transport) splits the episode and creates an artificial gap in ventilation. • Missing end times. Only the patient's last airway-device row (any device type) is imputed, with the time of death or the cohort end (t_max). Other open-ended records cause their episode to be dropped. • Unmapped ventilator modes are treated as no ventilation. • Attributes of merged episodes. For merged ventilation episodes, attributes retains only the source of the first interval. It may therefore not represent all airway devices or ventilation modes used during the episode.

Clinical

All episodes of invasive mechanical ventilation (IMV), one row per episode, with duration in hours.

Invasive ventilation is ventilation through an artificial airway:

• an endotracheal tube (incl. microcuff and laryngectomy tubes), or • a tracheal tube (tracheostomy), only while a ventilator runs in a mechanical-ventilation mode.

Each episode has a recordtime and a recordtime_end, and a patient can have several episodes. The concept works for ICU/procedure and hospital-stay cohorts.

Implementation

1. Ventilation intervals. Map device and mode from therapy_all with mapping_ventilator_modes_JHH_28022025.csv. Keep only mechanical ventilation. 2. Filter airway_device. Drop records shorter than 5 min, records that end before they start, and records completely outside the hospital stay. 3. Merge intervals per patient (overlap or gap < 1 h), separately for: ◦ ET tubes: Endotracheal tube, Microcuff Endotracheal tube, Laryngektomietubus ◦ Tracheal tubes: Tracheal tube, Endotracheal tube inserted through tracheostoma 4. Impute a missing end on the last row: death_timestamp if the patient died, otherwise t_max. 5. Build IMV intervals. ◦ ET: the whole tube episode counts (endotracheal). ◦ Tracheal: use ventilator intervals that lie within the tube period (tracheal_direct) or overlap it with at most 30 min outside (tracheal_overlap). 6. Final merge (gap < 1 h). value = duration in hours. Rows with null or negative duration are removed.

Output: recordtime / recordtime_end: Start and end of the IMV episode value, value_unit: Duration, hours attributes: endotracheal, tracheal_direct or tracheal_overlap

`med_norepinephrine`

v1 in corr_v1

charite_demo Type native_dynamic Vasopressors CORR-ICU and CORR-OR Dynamic, continuous mg

Definition

Type: native_dynamic
Dynamic: true
Table: it_copra6_medication
Where: c_drug_name IN ('Norepinephrin (20 µg/ml)', 'Norepinephrin 100µg/ml', 'Norepinephrin (100 µg/ml)', 'Norepinephrin 10mg/50ml', 'Norepinephrin 200µg/ml', 'Norepinephrin 20µg/ml', 'Norepinephrin (0,10 mg/ml)', 'Norepinephrin (10 µg/ml)', 'Norepinephrin (60 µg/ml)', 'Norepinephrin, 25 mg/50 ml', 'Norepinephrin (200 µg/ml)', 'Norepinephrin 60µg/ml', 'Norepinephrin 10mg/50', 'Norepinephrin 3 mg/50 ml', 'Norepinephrin (0,20 mg/ml)', 'Norepinephrin 500µg/ml', 'Norepinephrin (0,02 mg/ml)', 'Norepinephrin', 'Norepinephrin (0,06 mg/ml)', 'Norepinephrin (6 µg/ml)', 'Norepinephrin (500 µg/ml)', 'Norepinephrin, 25 mg / 50 ml', 'Norepinephrin 1000µg/ml', 'Norepinephrin (1.000 µg/ml)', 'Norepinephrin (120 µg/ml)', 'Norepinephrin (0,04 mg/ml)', 'Norepinephrin (0,40 mg/ml)', 'Norepinephrin 0,10 mg/ml', 'Norepinephrin (1 mg/ml)', 'Norepinephrin (0,50 mg/ml)', 'Norepinephrin, 1 mg / 50 ml', 'Norepinephrin, 20 mg / 50 ml', 'Norepinephrin (0,006 mg/ml)', 'Norepinephrin 0,20 mg/ml', 'Norepinephrin 0,5mg/ml', 'Norepinephrin 0,02 mg/ml', 'Norepinephrin 0,06 mg/ml', 'Norepinephrin 0,04 mg/ml')

{
  "type": "native_dynamic",
  "dynamic": true,
  "table": "it_copra6_medication",
  "where": "c_drug_name IN ('Norepinephrin (20 µg/ml)', 'Norepinephrin 100µg/ml', 'Norepinephrin (100 µg/ml)', 'Norepinephrin 10mg/50ml', 'Norepinephrin 200µg/ml', 'Norepinephrin 20µg/ml', 'Norepinephrin (0,10 mg/ml)', 'Norepinephrin (10 µg/ml)', 'Norepinephrin (60 µg/ml)', 'Norepinephrin, 25 mg/50 ml', 'Norepinephrin (200 µg/ml)', 'Norepinephrin 60µg/ml', 'Norepinephrin 10mg/50', 'Norepinephrin 3 mg/50 ml', 'Norepinephrin (0,20 mg/ml)', 'Norepinephrin 500µg/ml', 'Norepinephrin (0,02 mg/ml)', 'Norepinephrin', 'Norepinephrin (0,06 mg/ml)', 'Norepinephrin (6 µg/ml)', 'Norepinephrin (500 µg/ml)', 'Norepinephrin, 25 mg / 50 ml', 'Norepinephrin 1000µg/ml', 'Norepinephrin (1.000 µg/ml)', 'Norepinephrin (120 µg/ml)', 'Norepinephrin (0,04 mg/ml)', 'Norepinephrin (0,40 mg/ml)', 'Norepinephrin 0,10 mg/ml', 'Norepinephrin (1 mg/ml)', 'Norepinephrin (0,50 mg/ml)', 'Norepinephrin, 1 mg / 50 ml', 'Norepinephrin, 20 mg / 50 ml', 'Norepinephrin (0,006 mg/ml)', 'Norepinephrin 0,20 mg/ml', 'Norepinephrin 0,5mg/ml', 'Norepinephrin 0,02 mg/ml', 'Norepinephrin 0,06 mg/ml', 'Norepinephrin 0,04 mg/ml')"
}

Python

first 60 of 77 lines

1def med_norepinephrine(var, cohort):
2    """Process norepinephrine medication data at ICU stay level."""
3    original_fields = var.data["attributes"].struct.fields
4    keep_fields = [
5        field
6        for field in original_fields
7        if field not in ["drugname", "genericname", "drugid"]
8    ]
9    var.data = var.data.unnest("attributes")
10
11    # Cast numeric columns
12    var.data = var.data.with_columns(pl.col("value").cast(pl.Float64))
13
14    # Track if original unit was µg
15    var.data = var.data.with_columns((pl.col("value_unit") == "µg").alias("was_ug"))
16
17    # Convert µg → mg for value AND concentration
18    if "concentration" in var.data.columns:
19        var.data = var.data.with_columns(pl.col("concentration").cast(pl.Float64))
20        var.data = var.data.with_columns(
21            pl.when(pl.col("was_ug"))
22            .then(pl.col("concentration") / 1000)
23            .otherwise(pl.col("concentration"))
24            .alias("concentration")
25        )
26
27    # Now convert value and unit
28    var.data = var.data.with_columns(
29        [
30            pl.when(pl.col("was_ug"))
31            .then(pl.col("value") / 1000)
32            .otherwise(pl.col("value"))
33            .alias("value"),
34            pl.when(pl.col("was_ug"))
35            .then(pl.lit("mg"))
36            .otherwise(pl.col("value_unit"))
37            .alias("value_unit"),
38        ]
39    )
40
41    # Filter concentration ≤21 mg/ml and value ≠ 0
42    if "concentration" in var.data.columns:
43        var.data = var.data.filter(
44            (pl.col("concentration") <= 21) & (pl.col("value") != 0)
45        )
46    else:
47        var.data = var.data.filter(pl.col("value") != 0)
48
49    # Clean up temporary column
50    var.data = var.data.drop("was_ug")
51
52    # Flag bolus applications
53    var.data = var.data.with_columns(
54        (pl.col("recordtime") == pl.col("recordtime_end")).alias("bolus")
55    )
56
57    # Add uniform drug name
58    var.data = var.data.with_columns(pl.lit("norepinephrine").alias("drug_name"))
59
60    # Create attributes struct

Documentation Publication ready

Caveats. • Amounts, not rates. value is the amount given per record. Standardized rates, combined across lines running in parallel, are provided in a separate CCC. • Unit conversion. Rows with the unit µg are converted to mg. • Rows without a concentration are dropped, as are rows with a value of 0.

Clinical

Norepinephrine administration records across all formulations

Norepinephrine, an alpha-1 vasopressor, from COPRA6 medication records. The relevant drug names were identified with a regex search over structured and free-text medication entries. They cover 38 different spellings, formulations and concentrations, which are combined into one concept.

Implementation

Type native_dynamic, read directly from table it_copra6_medication where c_drug_name IN (…), with 38 names (e.g. Norepinephrin (20 µg/ml), Norepinephrin, 25 mg / 50 ml, Norepinephrin).

1. Convert units. If value_unit = µg, value and concentration are divided by 1000 and the unit is set to mg. 2. Clean. Rows are kept only if concentration ≤ 21 mg/ml and value ≠ 0. 3. Flag boluses. bolus = true if recordtime = recordtime_end. 4. Unify the name. drug_name = norepinephrine. The original drug name and ID fields are removed.

Output: recordtime / recordtime_end: Start and end of the administration value, value_unit: Amount given, mostly in mg attributes: drug_name, bolus, concentration and other medication fields

`pf_ratio`

v1 in corr_v1

charite_demo Type derived_dynamic Oxygenation CORR-ICU and CORR-OR Dynamic, per measurement mmHg

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "blood_pao2_arterial",
    "vent_fio2"
  ]
}

Python

1def pf_ratio(
2    var: VariableContext,
3    cohort: Cohort,
4    plusminus: pd.Timedelta = pd.Timedelta(hours=1),
5    strategy: AsofJoinStrategy = "backward",
6) -> pd.DataFrame:
7    """
8    Calculate the PF ratio by matching each PaO2 value to the last FiO2 value recorded at or before it
9    (at most 1 hour earlier by default), and filter PF ratios to keep only values between 10 and 1000.
10
11    Args:
12        var: VariableContext container with required data for PaO2 and FiO2.
13        cohort: Cohort object containing the primary key.
14        plusminus (pd.Timedelta): Optional time range within which to find the FiO2 for each PaO2.
15                                  Defaults to 1 hour.
16        strategy (str): Strategy for asof join - "nearest", "backward", or "forward". Defaults to "backward"
17                        (the last FiO2 before the PaO2).
18
19    Returns:
20        pd.DataFrame: DataFrame with the primary key, PaO2, matched FiO2, and calculated, cleaned PF ratio.
21    """
22
23    merged_df = utils.attach_asof_value(
24        var.required_vars["blood_pao2_arterial"].data,
25        var.required_vars["vent_fio2"].data,
26        name="fio2",
27        by=cohort.primary_key,
28        strategy=strategy,
29        tolerance=plusminus,
30    )
31
32    # Calculate PF ratio and filter
33    merged_df = (
34        merged_df.with_columns(pl.col("value").truediv(pl.col("fio2")))
35        .filter(pl.col("value").is_between(10, 1000))
36        .select(cohort.primary_key, "recordtime", "value")
37    )
38
39    return merged_df

Documentation Publication ready

Caveats. • Do not use the PF ratio / Horowitz index from COPRA. That field is calculated with the FiO₂ entered manually on the blood gas analyzer, which may be left at the default value of 0.21. • Ventilator FiO₂ only. Blood gases with no ventilator FiO₂ in the preceding hour (e.g. room air or nasal cannula) get no PF ratio. • Observed and set FiO₂ are not distinguished. Whichever FiO₂ value was documented last is used. • No cut-off at the end of ventilation. The matching does not check whether ventilation was still ongoing at the time of the blood gas. A blood gas taken shortly after extubation or after the end of non-invasive ventilation (within 1 h) is matched to the last FiO₂ documented during ventilation.

Clinical

PF ratio (Horowitz index, PaO₂/FiO₂) calculated from arterial blood gases and ventilator FiO₂.

The ratio of arterial oxygen partial pressure (PaO₂, mmHg) to the fraction of inspired oxygen (FiO₂, as a fraction). It is calculated for each arterial PaO₂ measurement, using the last ventilator FiO₂ (vent_fio2) documented before the blood gas. There is one value per blood gas.

Implementation

1. Match FiO₂ to PaO₂. Each blood_pao2_arterial value is matched to the last vent_fio2 value of the same stay recorded at or before the blood gas, at most 1 h earlier (as-of join, strategy="backward", tolerance=1 h). 2. Calculate. PF = PaO₂ / FiO₂. 3. Clean. Only PF values between 10 and 1000 mmHg (inclusive) are kept. Blood gases without a matching FiO₂ are dropped.

Output: recordtime: Time of the PaO₂ measurement value: PF ratio (mmHg)

`sofa_score_total`

v1 in corr_v1

charite_demo Type co6_hierarchy Scores CORR-ICU Dynamic, per assessment score 0-24

Definition

Type: co6_hierarchy
Dynamic: true
Parent name: Score_SOFA
Suffixes: {"_Wert":"value","_Date":"recordtime"}
Value dtype: Float64

{
  "type": "co6_hierarchy",
  "dynamic": true,
  "parent_name": "Score_SOFA",
  "suffixes": {
    "_Wert": "value",
    "_Date": "recordtime"
  },
  "value_dtype": "Float64"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Charted value, not a calculated score. The total SOFA score is extracted as documented and is not independently recalculated or validated against its individual organ-system components. Discrepancies between the documented total and the underlying components (e.g. in the summation) may therefore occur. • Missing scores are real missings. If no SOFA was charted, the record is absent. This is a documentation gap, not a data-extraction issue. Missingness is high: a large proportion of ICU stays in CORR-ICU have no charted SOFA score in the first 24 h. For a complete score, use sofa_score_imputed, which recomputes SOFA from its components.

Clinical

Total SOFA score as charted by clinicians in COPRA. It is not recalculated from its components.

This is the total Sequential Organ Failure Assessment (SOFA) score, taken as documented in the COPRA patient data management system. It is a dynamic variable: a stay can have several scores over time, each with its own documentation time.

Implementation

Type co6_hierarchy, parent node Score_SOFA. The child entries are combined per parent ID:

Score_SOFA_Wert: value Score_SOFA_Date: recordtime

Output: recordtime: Documentation time of the score value: Total SOFA score as charted

`surgery`

v1 in corr_v1

charite_demo Type complex Perioperative CORR-OR Dynamic, per procedure datetime

Definition

Type: complex
Dynamic: true

{
  "type": "complex",
  "dynamic": true
}

Python

1def surgery(var: VariableContext, cohort: Cohort) -> pl.DataFrame:
2    conn = helpers.reinit_conn(cohort)
3
4    # Build the shared per-procedure frame (same logic as the procedure obs level).
5    lf_proc = helpers.build_procedures(conn, cohort.sources["charite_demo"]["database"])
6
7    # Prepare columns for nesting into attributes
8    attr_cols = [
9        col
10        for col in lf_proc.columns
11        if col not in ["case_id", "ops_code", "or_time_begin", "or_time_end"]
12    ]
13
14    # Create attributes struct and rename columns according to requirements
15    lf_proc = lf_proc.with_columns(pl.struct(attr_cols).alias("attributes")).drop(
16        attr_cols
17    )
18
19    # Rename columns to match the required format
20    lf_proc = lf_proc.rename(
21        {
22            "ops_code": "value",
23            "or_time_begin": "recordtime",
24            "or_time_end": "recordtime_end",
25        }
26    )
27
28    # build_procedures is not cohort-scoped; the inner join both restricts it to
29    # the cohort and attaches the primary key.
30    return helpers.attach_obs_ids(lf_proc.collect(), cohort)

Documentation Publication ready

Caveats. • Times are OR times. recordtime and recordtime_end are the OR begin and end, not the time the OPS code was charted. • Procedure logic is shared. The procedures are built with the same logic as the procedure observation level (build_procedures). Which procedures and OPS codes are included is defined there.

Clinical

All surgical procedures with OPS code and operating room (OR) times, one row per procedure.

All surgical procedures of the patient's hospital case. Each row is one procedure, with its OPS code, OR start and OR end time. Further procedure details are in attributes.

Implementation

1. Build procedures. helpers.build_procedures creates one row per procedure from the charite_demo database. 2. Format. value = OPS code, recordtime = OR begin, recordtime_end = OR end. All other procedure columns are stored in attributes. 3. Assign to cohort stays. attach_obs_ids restricts the procedures to the cohort and adds the primary key (inner join).

Output: recordtime / recordtime_end: OR begin and end value: OPS code attributes: Further procedure details

`surgery_ops`

v1 in corr_v1

charite_demo Type native_dynamic Perioperative CORR-ICU and CORR-OR Dynamic, per procedure OPS code

Definition

Type: native_dynamic
Table: it_ishmed_procedure
Where: c_prozedur_code LIKE '5%'
Value dtype: VARCHAR

{
  "type": "native_dynamic",
  "table": "it_ishmed_procedure",
  "where": "c_prozedur_code LIKE '5%'",
  "value_dtype": "VARCHAR"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Chapter 5 includes minor procedures. Every chapter 5 code counts, including small procedures such as wound care, not only major surgery. • Billing codes, not OR data. The timestamps come from the procedure coding in ISH-MED. For OR start and end times, use surgery.

Clinical

All OPS codes from chapter 5 (operations) charted in ISH-MED.

All coded surgical procedures, defined as OPS codes from chapter 5 ("Operationen", codes 5-…). Each row is one coded procedure. This concept is the base for any_surgery_ops and the template for surgery_ops_peri_icu_admission.

Implementation

Type native_dynamic, read directly from table it_ishmed_procedure where c_prozedur_code LIKE '5%'. Values are stored as VARCHAR.

Output: recordtime: Procedure time as charted in ISH-MED value: OPS code

`surgery_urgency`

v1 in corr_v1

charite_demo Type native_dynamic Perioperative CORR-OR Dynamic, per assessment N0-N5

Definition

Type: native_dynamic
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'BEH_ANAE_OP_DRINGL'
Value dtype: STRING

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'BEH_ANAE_OP_DRINGL'",
  "value_dtype": "STRING"
}

Python

1def surgery_urgency(var, cohort):
2    df = var.data
3
4    # Erlaubte Werte
5    allowed_values = ["N0", "N1", "N2", "N3", "N4", "N5"]
6
7    # Filterung
8    df = df.filter(pl.col("value").is_in(allowed_values))
9
10    # Schreibe Ergebnis zurück
11    var.data = df
12
13    return df

`therapy_all`

v1 in corr_v1

charite_demo Type native_dynamic Therapy CORR-ICU Dynamic, interval therapy mode

Definition

Type: native_dynamic
Table: it_copra6_therapy
Where: c_therapy_type IS NOT NULL

{
  "type": "native_dynamic",
  "table": "it_copra6_therapy",
  "where": "c_therapy_type IS NOT NULL"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Mixed therapy types. All therapy types are in one variable, so filter for the therapy you need before using it. • Different COPRA pages. ECMO and dialysis come mainly from CO6 page 2 (extracorporeal support, shown as bars). Ventilator modes come from a different CO6 page. • Raw modes. Device names and modes are used as charted. Downstream concepts map them to categories, e.g. invasive_vent uses mapping_ventilator_modes_JHH_28022025.csv to identify mechanical ventilation.

Clinical

Start and end times, devices and modes of all ICU therapy types in COPRA6 (for example ECMO, dialysis, ventilator mode).

This concept holds documented therapy events of all therapy types, for example ECMO, dialysis and ventilator mode. Each row is one therapy interval, with start (recordtime), end (recordtime_end), device and mode.

Implementation

Type native_dynamic, read directly from table it_copra6_therapy. Only rows with a therapy type are kept (c_therapy_type IS NOT NULL).

Output: recordtime / recordtime_end: Start and end of the therapy interval value: Therapy mode attributes: Includes devicename

`urine_output`

v1 in corr_v1

charite_demo Type native_dynamic Kidney CORR-ICU and CORR-OR Dynamic, per measurement mL

Definition

Type: native_dynamic
Cleaning: value 0 to 3000
Table: it_copra6_hierarchy_v2
Where: c_var_name IN ('CO_Bilanz_Ausfuhr_Spontanurin', 'Fall_Urinableitung_Verlauf_Menge', 'Fall_Urinableitung_Verlauf_Zulauf', 'FALL_ANAE_VERL_AUSFUHR_URIN')
Value dtype: DOUBLE
Columns: {"value":"c_value","attributes":{"type":"c_var_name","bladder_irrigation":"c_var_name = 'Fall_Urinableitung_Verlauf_Zulauf'"}}

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name IN ('CO_Bilanz_Ausfuhr_Spontanurin', 'Fall_Urinableitung_Verlauf_Menge', 'Fall_Urinableitung_Verlauf_Zulauf', 'FALL_ANAE_VERL_AUSFUHR_URIN')",
  "value_dtype": "DOUBLE",
  "columns": {
    "value": "c_value",
    "attributes": {
      "type": "c_var_name",
      "bladder_irrigation": "c_var_name = 'Fall_Urinableitung_Verlauf_Zulauf'"
    }
  },
  "cleaning": {
    "value": {
      "low": 0,
      "high": 3000
    }
  }
}

Python

No Python: corr-vars reads this concept directly from the definition above.

Documentation Publication ready

Caveats. • Bladder irrigation inflates urine output. The irrigation volume, which can be substantial, is captured as urine output. Either exclude days with bladder irrigation, or work with cumulative daily volumes and subtract the irrigation volume. Subtraction is not reliable either, because irrigation volume and output are not always charted on the same calendar day. • Irrigation rows are part of the concept. Rows with bladder_irrigation = true contain the irrigation inflow volume. Exclude them before adding up urine output. • Missing urine output is ambiguous. It can mean the patient was anuric, or that nothing was charted despite ongoing diuresis. This is an inherent limitation of routine data. • Cleaning applies to single chartings only. No daily plausibility check is applied.

Clinical

All urine output chartings from COPRA6 (spontaneous and catheter), plus bladder irrigation volumes as flagged rows.

A dynamic concept in long format with every urine output charting (spontaneous voiding and urinary catheter), as documented in COPRA6 and cleaned for implausible values. Bladder irrigation inflow volumes are included as separate rows flagged with bladder_irrigation. They have to be handled per project (see aki_urine_output for reference).

Implementation

Type native_dynamic, read directly from table it_copra6_hierarchy_v2:

CO_Bilanz_Ausfuhr_Spontanurin: Spontaneous urine output Fall_Urinableitung_Verlauf_Menge: Urine output via urinary catheter FALL_ANAE_VERL_AUSFUHR_URIN: Urine output (anesthesia documentation) Fall_Urinableitung_Verlauf_Zulauf: Bladder irrigation inflow volume

1. Value. value = c_value, stored as DOUBLE. The irrigation volume is not subtracted. 2. Attributes. type = the source variable name. bladder_irrigation = true for rows from Fall_Urinableitung_Verlauf_Zulauf. 3. Clean. Single chartings below 0 or above 3000 mL are removed.

Output: recordtime: Time of charting value: Volume (mL) attributes: type (source variable), bladder_irrigation (true / false)

`vent_fio2`

v1 in corr_v1

charite_demo Type derived_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, continuous fraction

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "fio2_set",
    "fio2_observed"
  ]
}

Python

1def vent_fio2(var, cohort):
2    dfs: list[pl.DataFrame] = []
3    for name, var in var.required_vars.items():
4        df: pl.DataFrame = var.data
5        dfs.append(
6            df.select(
7                cohort.primary_key,
8                "recordtime",
9                "value",
10                "value_unit",
11                pl.struct(pl.lit(name).alias("source")).alias("attributes"),
12            )
13        )
14
15    fio2 = pl.concat(dfs)
16
17    fio2 = fio2.with_columns(
18        pl.when(pl.col("value") > 1)
19        .then(pl.col("value") / 100)
20        .otherwise(pl.col("value"))
21        .alias("value")
22    )
23    return fio2

Documentation Publication ready

Caveats. • Do not use the FiO₂ from the lab directly. The lab value is calculated with the FiO₂ entered on the blood gas analyzer, which may be left at the default value of 0.21. Use and calculate the PF ratio with this concept instead. • Observed and set values are mixed. Both can be present at the same time point. Use attributes.source to tell them apart.

Clinical

FiO₂ from the ventilator, observed and set, as a fraction (0–1). Invasive and non-invasive ventilation.

The fraction of inspired oxygen (FiO₂) documented from the ventilator. It includes both observed (measured) and set values, during invasive or non-invasive ventilation. This is the concept to use; the helper variables fio2_observed, fio2_set and fio2_set_helper should not be used directly.

Implementation

1. Sources. Five COPRA locations were screened, of which three were empty. The helper variables are cleaned upstream: values below 0 or above 100 and all standby values in fio2_set are removed. 2. Combine. All required variables are stacked. The name of the source variable is stored in attributes.source. 3. Convert to a fraction. Values > 1 are divided by 100. Values ≤ 1 are kept as they are.

Output: recordtime: Time of documentation value: FiO₂ as a fraction (0–1) value_unit: Unit from the source variable attributes: source: name of the source variable (fio2_observed, fio2_set, fio2_set_helper)

`ventilator_mode_automatic`

v1 in corr_v1

charite_demo Type native_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, continuous text

Definition

Type: native_dynamic
Table: it_copra6_hierarchy_v2
Where: c_var_name = 'beat_einstell_modus'
Value dtype: VARCHAR

{
  "type": "native_dynamic",
  "table": "it_copra6_hierarchy_v2",
  "where": "c_var_name = 'beat_einstell_modus'",
  "value_dtype": "VARCHAR"
}

Python

No Python: corr-vars reads this concept directly from the definition above.

`ventilator_mode_automatic_standby`

v1 in corr_v1

charite_demo Type derived_dynamic Ventilation CORR-ICU and CORR-OR Dynamic, interval datetime

Definition

Type: derived_dynamic
Requires

{
  "type": "derived_dynamic",
  "requires": [
    "ventilator_mode_automatic"
  ]
}

Python

first 60 of 61 lines

1def ventilator_mode_automatic_standby(var, cohort):
2    ventilator_mode: pl.DataFrame = var.required_vars["ventilator_mode_automatic"].data
3
4    pause_values = ["stdby", "pause", "standby", "stand by", "stand-by"]
5
6    intervals = (
7        ventilator_mode.select(cohort.primary_key, "recordtime", "value")
8        .sort(cohort.primary_key, "recordtime")
9        .with_columns(pl.col("value").str.to_lowercase().alias("cleaned"))
10        .with_columns(
11            pl.col("cleaned")
12            .shift(-1)
13            .over(cohort.primary_key)
14            .fill_null(False)
15            .alias("next_cleaned"),
16            pl.col("cleaned").is_in(pause_values).alias("paused"),
17        )
18        .with_columns(
19            pl.col("paused")
20            .shift(-1)
21            .over(cohort.primary_key)
22            .fill_null(False)
23            .alias("next_paused")
24        )
25        .with_columns(
26            (
27                pl.col("cleaned").eq(pl.col("next_cleaned"))
28                | (pl.col("paused") & pl.col("next_paused"))
29            ).alias("current_eq_next")
30        )
31    )
32
33    intervals = (
34        intervals.with_columns(
35            pl.col("current_eq_next")
36            .not_()
37            .cum_sum()
38            .over(cohort.primary_key)
39            .alias("merge_group")
40        )
41        .group_by(cohort.primary_key, "merge_group")
42        .agg(
43            pl.col("recordtime").first(),
44            pl.col("value"),
45            pl.col("cleaned").first(),
46            pl.col("paused").any(),
47        )
48        .drop("merge_group")
49        .sort(cohort.primary_key, "recordtime")
50        .with_columns(
51            pl.col("recordtime")
52            .shift(-1)
53            .over(cohort.primary_key)
54            .alias("recordtime_end")
55        )
56        .filter(pl.col("paused"))
57        .drop("paused", "cleaned")
58        .select(pl.all().exclude("value"), "value")
59    )
60

Documentation Publication ready

Caveats. • Exact match only (case-insensitive): stdby, pause, standby, stand by, stand-by. • Bounds shifted by one record. The interval does not start exactly at the first standby record but at the record charted just before it, and it can end one record after standby has ended. Example: with modes charted at 10:00 (PCV), 10:15 (standby), 10:30 (standby) and 10:45 (PCV), the interval starts at 10:00 instead of 10:15. Values documented shortly before or after standby may therefore also be treated as standby values (e.g. removed from fio2_set). • Open end if standby is the last charted mode.

Clinical

Intervals during which the ventilator was in standby or pause.

The periods in which the ventilator was in standby or pause mode, derived from the charted ventilator mode. During these periods, ventilator settings do not reflect the therapy the patient received. The concept is used to clean ventilator parameters, e.g. in fio2_set.

Implementation

Type derived_dynamic, based on ventilator_mode_automatic.

1. Detect standby. Per stay, modes are sorted by time, converted to lowercase, and marked as standby if they exactly match one of the terms above. 2. Group runs. Consecutive records with the same mode, or consecutive standby records, are grouped together. 3. Build intervals. Each group starts at its first record and ends at the start of the next group. Only groups that contain a standby record are kept.

Output: recordtime: Start of the standby interval recordtime_end: End of the standby interval (empty if open-ended) value: List of the raw modes charted in the interval

The Concepts Browser documents every concept: definition, derivation code, version history, clinical documentation and known caveats. Pick a concept, or follow a Requires link.

From study idea to analysis-ready cohort

The CORR package borrows the logic of an electronic case report form. A study variable is a concept, a time anchor, an observation window, a cleaning rule and an aggregation method. Scroll through one real example: the median PF-ratio in the first 24 hours after intubation.

Start from a validated concept

The study variable is built on the CCC pf_ratio, not on raw blood-gas rows. All matching of paO₂ to FiO₂ has already happened inside the concept.

Anchor it in time

Time anchors are themselves concepts. Here the window opens at first intubation and closes 24 hours later. time0, end of follow-up or any event can serve as anchor.

Declare the cleaning rule

Plausibility limits are explicit and versioned with the study, so a reviewer can see exactly which values were dropped.

Choose the aggregation

Median over the window. First, last, min, max, count or slope are equally one keyword. The result is one column in a wide, analysis-ready cohort table.

study_variables.pyCORR-Vars

1cohort.add_variable(
2    NativeStatic(
3        base_var="pf_ratio",              # CORR CCC
4        tmin=("first_intubation", 0),     # time anchor (lower)
5        tmax=("first_intubation", "24h"), # time anchor (upper)
6        where="10 <= value <= 1000",      # data cleaning
7        select="median",                  # aggregation method
8        var_name="median_pf_ratio",       # output name
9    )
10)

The same derivation is available without code through the graphical cohort builder; reproducible code is generated in the backend.

One concept layer, three kinds of use

Retrospective studies, prospective trials and bedside applications all read the same validated ground truth. Nothing is recoded between them.

Retrospective: focus on methods, not wrangling

Target trial emulations and cohort studies start from validated concepts and an eCRF-style specification. Investigators spend their time on design and interpretation. More than 40 clinical projects currently run on CORR.

Prospective: the Sweet-Water trial

A pragmatic, embedded, stepped-wedge cluster-randomized trial across 6 hospitals and 11 ICU clusters, 6 of them at Charité. All Charité data came through CORR using 29 validated concepts, without case report forms or trial-specific extraction code. The analysis dataset took days rather than months.

Screenshot of the extubation dashboard: Sankey diagram of airway outcomes, quarterly re-intubation rates and daily heatmap.

Bedside: an extubation dashboard on the live feed

Among patients intubated in the ICU, the dashboard tracks primary extubation, re-intubation and related outcomes over time. All metrics are existing concepts and update automatically through the continuous data stream.

Airway outcomes of intubation episodes over one quarter.

How we validate concepts

Every concept passes the same eight stages before it can be used in a study, and stays under surveillance afterwards. A weekly cohort per ICU re-executes all concepts and archives their distributions, so drift in bedside documentation surfaces within days.

Define

From a project need to an agreed definition and harmonized sources.

01
Need-based identification

A concept is requested by an ongoing or planned project.
02
Consensus definition

The multidisciplinary team agrees the definition iteratively, informed by local documentation practice, in regular data-quality meetings.
03
Source exploration

All candidate EHR sources are screened for presence of entries, granularity, temporal distribution and data quality.
04
Source selection and harmonization

Sources are selected and aligned across systems for units, value ranges and documentation conventions.

Build and validate

From pipeline to specialist sign-off, then weekly surveillance.

05
ETL pipeline implementation

A single pipeline encapsulates all cleaning and transformation logic; definitions are versioned in Git.
06
Quantitative and qualitative validation

Plausibility checks against reference ranges, then chart review against original clinical records.
07
Specialist review

Intensivist (CORR-ICU) or anesthesiologist (CORR-OR) review; approval or refinement, residual issues recorded as known caveats.
08
Continuous quality surveillance

Weekly surveillance cohorts per ICU detect ingestion failures, structural changes and shifts in bedside documentation.

Build on it

Patient-level data stay at Charité for regulatory reasons. The package, the concept standard and the documentation are open, and collaboration proposals such as external validations are welcome at any time.

Contact

Real-world data, made usable.

Why a raw EHR value is not a clinical concept

Try it: one blood gas, two answers

How the repository is structured

Observation levels

Sample size and overlap

reprodICU: public ICU data, harmonized

The concept library

Composition by category

Interoperability coverage

Four kinds of concept

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python

Definition

Python