Unattributed Code Systems

Copyright Fragment

This fragment is available on index.html

Copyright and Registered Trademark Uses

• IG © 2019+ HL7 International / Clinical Decision Support. Package hl7.fhir.us.cql#1.0.0-ballot based on FHIR 4.0.1. Generated 2025-04-01 Links: Table of Contents | QA Report | Version History | CC0 | Propose a change ( src )
• hl7.fhir.us.hai: Healthcare Associated Infection Implementation Guide ®© HL7 | CC0 ( src )
• /* @description: This library provides cumulative medication duration calculation logic for use with FHIR medication prescription, administration, and dispensing resources. The logic here follows the guidance provided as part of the 5.6 version of Quality Data Model. @comment: Note that the logic here assumes single-instruction dosing information. Split-dosing, tapering, and other more complex dosing instructions are not handled. @update: v0.2.000 Fixed Quantity handling in duration calculations Fixed authorDatetime null handling Changed to provide Date-level calculation, rather than DateTime v2.0.000 Updated as part of 2022 AU refresh Refactored to use QICoreCommon v2.0.001 Fixed invalid unit error evaluating RolloutIntervals Fixed RolloutIntervals incorrectly eliminating duplicates v3.1.000 updated to reflect changes from AU2022 QDM library changes _JKR */ library CumulativeMedicationDuration using USCore version '3.1.1' // NOTE: Including FHIR to handle MedicationDispense and MedicationAdministration (not in USCore 3.1.1) // TODO: Remove this reference once USCore supports MedicationDispense and MedicationAdministration using FHIR version '4.0.1' include FHIRHelpers version '4.0.1' include USCoreCommon // These code systems are not known to the MAT environment yet, request to have them added submitted codesystem "V3TimingEvent": 'http://terminology.hl7.org/CodeSystem/v3-TimingEvent' codesystem "EventTiming": 'http://hl7.org/fhir/event-timing' code "HS": 'HS' from "V3TimingEvent" // event occurs [offset] before the hour of sleep (or trying to) code "WAKE": 'WAKE' from "V3TimingEvent" // event occurs [offset] after waking code "C": 'C' from "V3TimingEvent" // event occurs at a meal (from the Latin cibus) code "CM": 'CM' from "V3TimingEvent" // event occurs at breakfast (from the Latin cibus matutinus) code "CD": 'CD' from "V3TimingEvent" // event occurs at lunch (from the Latin cibus diurnus) code "CV": 'CV' from "V3TimingEvent" // event occurs at dinner (from the Latin ante cibus vespertinus) code "AC": 'AC' from "V3TimingEvent" // event occurs [offset] before a meal (from the Latin ante cibus) code "ACM": 'ACM' from "V3TimingEvent" // event occurs [offset] before breakfast (from the Latin ante cibus matutinus) code "ACD": 'ACD' from "V3TimingEvent" // event occurs [offset] before lunch (from the Latin ante cibus diurnus) code "ACV": 'ACV' from "V3TimingEvent" // event occurs [offset] before dinner (from the Latin ante cibus vespertinus) code "PC": 'PC' from "V3TimingEvent" // event occurs [offset] after a meal (from the Latin post cibus) code "PCM": 'PCM' from "V3TimingEvent" // event occurs [offset] after breakfast (from the Latin post cibus matutinus) code "PCD": 'PCD' from "V3TimingEvent" // event occurs [offset] after lunch (from the Latin post cibus diurnus) code "PCV": 'PCV' from "V3TimingEvent" // event occurs [offset] after dinner (from the Latin post cibus vespertinus) code "MORN": 'MORN' from EventTiming // Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation. code "MORN.early": 'MORN.early' from EventTiming // Early Morning Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation. code "MORN.late": 'MORN.late' from EventTiming // Late Morning Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation. code "NOON": 'NOON' from EventTiming // Noon Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation. code "AFT": 'AFT' from EventTiming // Afternoon Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation. code "AFT.early": 'AFT.early' from EventTiming // Early Afternoon Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation. code "AFT.late": 'AFT.late' from EventTiming // Late Afternoon Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation. code "EVE": 'EVE' from EventTiming // Evening Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation. code "EVE.early": 'EVE.early' from EventTiming // Early Evening Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation. code "EVE.late": 'EVE.late' from EventTiming // Late Evening Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation. code "NIGHT": 'NIGHT' from EventTiming // Night Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation. code "PHS": 'PHS' from EventTiming // After Sleep Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation. code "Every eight hours (qualifier value)": '307469008' from USCoreCommon."SNOMEDCT" display 'Every eight hours (qualifier value)' code "Every eight to twelve hours (qualifier value)": '396140003' from USCoreCommon."SNOMEDCT" display 'Every eight to twelve hours (qualifier value)' code "Every forty eight hours (qualifier value)": '396131002' from USCoreCommon."SNOMEDCT" display 'Every forty eight hours (qualifier value)' code "Every forty hours (qualifier value)": '396130001' from USCoreCommon."SNOMEDCT" display 'Every forty hours (qualifier value)' code "Every four hours (qualifier value)": '225756002' from USCoreCommon."SNOMEDCT" display 'Every four hours (qualifier value)' code "Every seventy two hours (qualifier value)": '396143001' from USCoreCommon."SNOMEDCT" display 'Every seventy two hours (qualifier value)' code "Every six hours (qualifier value)": '307468000' from USCoreCommon."SNOMEDCT" display 'Every six hours (qualifier value)' code "Every six to eight hours (qualifier value)": '396139000' from USCoreCommon."SNOMEDCT" display 'Every six to eight hours (qualifier value)' code "Every thirty six hours (qualifier value)": '396126004' from USCoreCommon."SNOMEDCT" display 'Every thirty six hours (qualifier value)' code "Every three to four hours (qualifier value)": '225754004' from USCoreCommon."SNOMEDCT" display 'Every three to four hours (qualifier value)' code "Every three to six hours (qualifier value)": '396127008' from USCoreCommon."SNOMEDCT" display 'Every three to six hours (qualifier value)' code "Every twelve hours (qualifier value)": '307470009' from USCoreCommon."SNOMEDCT" display 'Every twelve hours (qualifier value)' code "Every twenty four hours (qualifier value)": '396125000' from USCoreCommon."SNOMEDCT" display 'Every twenty four hours (qualifier value)' code "Every two to four hours (qualifier value)": '225752000' from USCoreCommon."SNOMEDCT" display 'Every two to four hours (qualifier value)' code "Four times daily (qualifier value)": '307439001' from USCoreCommon."SNOMEDCT" display 'Four times daily (qualifier value)' code "Once daily (qualifier value)": '229797004' from USCoreCommon."SNOMEDCT" display 'Once daily (qualifier value)' code "One to four times a day (qualifier value)": '396109005' from USCoreCommon."SNOMEDCT" display 'One to four times a day (qualifier value)' code "One to three times a day (qualifier value)": '396108002' from USCoreCommon."SNOMEDCT" display 'One to three times a day (qualifier value)' code "One to two times a day (qualifier value)": '396107007' from USCoreCommon."SNOMEDCT" display 'One to two times a day (qualifier value)' code "Three times daily (qualifier value)": '229798009' from USCoreCommon."SNOMEDCT" display 'Three times daily (qualifier value)' code "Twice a day (qualifier value)": '229799001' from USCoreCommon."SNOMEDCT" display 'Twice a day (qualifier value)' code "Two to four times a day (qualifier value)": '396111001' from USCoreCommon."SNOMEDCT" display 'Two to four times a day (qualifier value)' parameter ErrorLevel String default 'Warning' context Patient /* Goal is to get to number of days Two broad approaches to the calculation: 1) Based on supply and frequency, calculate the number of expected days the medication will cover/has covered 2) Based on relevant period, determine a covered interval and calculate the length of that interval in days This topic covers several use cases and illustrates how to calculate Cumulative Medication Duration for each type of medication resource using the supply and frequency approach. */ /* For the first approach, we need to get from frequency to a frequency/day So we define ToDaily */ /* Calculates daily frequency given frequency within a period */ define function ToDaily(frequency System.Integer, period System.Quantity): case period.unit when 'h' then frequency * (24.0 / period.value) when 'min' then frequency * (24.0 / period.value) * 60 when 's' then frequency * (24.0 / period.value) * 60 * 60 when 'd' then frequency * (24.0 / period.value) / 24 when 'wk' then frequency * (24.0 / period.value) / (24 * 7) when 'mo' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ when 'a' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ when 'hour' then frequency * (24.0 / period.value) when 'minute' then frequency * (24.0 / period.value) * 60 when 'second' then frequency * (24.0 / period.value) * 60 * 60 when 'day' then frequency * (24.0 / period.value) / 24 when 'week' then frequency * (24.0 / period.value) / (24 * 7) when 'month' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ when 'year' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ when 'hours' then frequency * (24.0 / period.value) when 'minutes' then frequency * (24.0 / period.value) * 60 when 'seconds' then frequency * (24.0 / period.value) * 60 * 60 when 'days' then frequency * (24.0 / period.value) / 24 when 'weeks' then frequency * (24.0 / period.value) / (24 * 7) when 'months' then frequency * (24.0 / period.value) / (24 * 30) /* assuming 30 days in month */ when 'years' then frequency * (24.0 / period.value) / (24 * 365) /* assuming 365 days in year */ else Message(null, true, 'CMDLogic.ToDaily.UnknownUnit', ErrorLevel, 'Unknown unit ' & period.unit) end /* Returns a daily frequency for the given code representation of frequency. The function expects codes from the [EventTiming](http://hl7.org/fhir/codesystem-event-timing.html) or [V3TimingEvent](http://hl7.org/fhir/v3/TimingEvent/cs.html) code systems. // TODO: Determine whether or not we should use timing.code at all.... */ define function ToDaily(frequency Code): case when frequency ~ "HS" then 1 // event occurs [offset] before the hour of sleep (or trying to) when frequency ~ "WAKE" then 1 // event occurs [offset] after waking when frequency ~ "C" then 3 // event occurs at a meal (from the Latin cibus) when frequency ~ "CM" then 1 // event occurs at breakfast (from the Latin cibus matutinus) when frequency ~ "CD" then 1 // event occurs at lunch (from the Latin cibus diurnus) when frequency ~ "CV" then 1 // event occurs at dinner (from the Latin ante cibus vespertinus) when frequency ~ "AC" then 3 // event occurs [offset] before a meal (from the Latin ante cibus) when frequency ~ "ACM" then 1 // event occurs [offset] before breakfast (from the Latin ante cibus matutinus) when frequency ~ "ACD" then 1 // event occurs [offset] before lunch (from the Latin ante cibus diurnus) when frequency ~ "ACV" then 1 // event occurs [offset] before dinner (from the Latin ante cibus vespertinus) when frequency ~ "PC" then 3 // event occurs [offset] after a meal (from the Latin post cibus) when frequency ~ "PCM" then 1 // event occurs [offset] after breakfast (from the Latin post cibus matutinus) when frequency ~ "PCD" then 1 // event occurs [offset] after lunch (from the Latin post cibus diurnus) when frequency ~ "PCV" then 1 // event occurs [offset] after dinner (from the Latin post cibus vespertinus) when frequency ~ "MORN" then 1 // Event occurs during the morning. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "MORN.early" then 1 // Early Morning Event occurs during the early morning. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "MORN.late" then 1 // Late Morning Event occurs during the late morning. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "NOON" then 1 // Noon Event occurs around 12:00pm. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "AFT" then 1 // Afternoon Event occurs during the afternoon. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "AFT.early" then 1 // Early Afternoon Event occurs during the early afternoon. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "AFT.late" then 1 // Late Afternoon Event occurs during the late afternoon. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "EVE" then 1 // Evening Event occurs during the evening. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "EVE.early" then 1 // Early Evening Event occurs during the early evening. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "EVE.late" then 1 // Late Evening Event occurs during the late evening. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "NIGHT" then 1 // Night Event occurs during the night. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "PHS" then 1 // After Sleep Event occurs [offset] after subject goes to sleep. The exact time is unspecified and established by institution convention or patient interpretation. when frequency ~ "Once daily (qualifier value)" then 1.0 when frequency ~ "Twice a day (qualifier value)" then 2.0 when frequency ~ "Three times daily (qualifier value)" then 3.0 when frequency ~ "Four times daily (qualifier value)" then 4.0 when frequency ~ "Every twenty four hours (qualifier value)" then 1.0 when frequency ~ "Every twelve hours (qualifier value)" then 2.0 when frequency ~ "Every thirty six hours (qualifier value)" then 0.67 when frequency ~ "Every eight hours (qualifier value)" then 3.0 when frequency ~ "Every four hours (qualifier value)" then 6.0 when frequency ~ "Every six hours (qualifier value)" then 4.0 when frequency ~ "Every seventy two hours (qualifier value)" then 0.33 when frequency ~ "Every forty eight hours (qualifier value)" then 0.5 when frequency ~ "Every eight to twelve hours (qualifier value)" then 3.0 when frequency ~ "Every six to eight hours (qualifier value)" then 4.0 when frequency ~ "Every three to four hours (qualifier value)" then 8.0 when frequency ~ "Every three to six hours (qualifier value)" then 8.0 when frequency ~ "Every two to four hours (qualifier value)" then 12.0 when frequency ~ "One to four times a day (qualifier value)" then 4.0 when frequency ~ "One to three times a day (qualifier value)" then 3.0 when frequency ~ "One to two times a day (qualifier value)" then 2.0 when frequency ~ "Two to four times a day (qualifier value)" then 4.0 else Message(null, true, 'CMDLogic.ToDaily.UnknownFrequencyCode', ErrorLevel, 'Unknown frequency code ' & frequency.code) end /* Now that we have a ToDaily function, we can approach calculation of the duration of medication for an order. First, consider the definitions for each element: * 1 and only 1 dosageInstruction * 1 and only 1 doseAndRate * 1 timing with 1 repeat * frequency, frequencyMax, defaulting to 1 * period, periodUnit, defaulting to 1 'd' * doseQuantity or doseRange * timeOfDay * authoredOn: The date the prescription was written * dispenseRequest.validityPeriod: Time period supply is authorized for * dispenseRequest.quantity: amount of medication supplied per dispense * dispenseRequest.numberOfRepeatsAllowed: number of refills authorized * dispenseRequest.expectedSupplyDuration: number of days supply per dispense * dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat * dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat * dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat * dosageInstruction.timing.repeat.count: number of times to repeat * dosageInstruction.timing.repeat.countMax: maximum number of times to repeat * dosageInstruction.timing.repeat.frequency: event occurs frequency times per period * dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period * dosageInstruction.timing.repeat.period: event occurs frequency times per period * dosageInstruction.timing.repeat.periodMax: upper limit of period * dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a) * dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*) * dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...) * dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD... * dosageInstruction.asNeeded * dosageInstruction.doseAndRate.doseQuantity * dosageInstruction.doseAndRate.doseRange If expectedSupplyDuration is present, then the duration is expectedSupplyDuration * (1 + numberOfRepeatsAllowed) If expectedSupplyDuration is not present, then it must be calculated based on the quantity, dosage, and frequency: (quantity / (dosage * frequency)) * (1 + numberOfRepeatsAllowed) dosage: Coalesce(end of doseAndRate.doseRange, doseAndRate.doseQuantity) frequency: Coalesce(frequencyMax, frequency) period: Quantity(period, periodUnit) If expectedSupplyDuration is not present and cannot be calculated, and the boundsPeriod is present (and completely specified), we can use that directly dosage.timing.repeat.boundsPeriod This calculation results in a number of days, which can then be turned into a period by anchoring that to the start of the validityPeriod or the authoredOn: Interval[earliestDispensable, earliestDispensable + expectedSupplyDuration - 1] earliestDispensable: Coalesce(start of validityPeriod, authoredOn) The following function illustrates this completely: */ /* Calculates the Medication Period for a single MedicationRequest. MedicationRequest instances provided to this function are expected to conform to the [MMEMedicationRequest](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationrequest.html) profile, which expects: * 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error * 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error * 1 timing with 1 repeat, missing timing or repeat elements will result in a null * frequency, frequencyMax, defaulting to 1 * period, periodUnit, defaulting to 1 'd' * timeOfDay * doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null Note that MedicationRequest status is not considered by this calculation, as the list of MedicationRequest instances provided to this function should already have considered appropriate statuses, depending on the use case, typically `completed`. NOTE: Updated return to use "date from end of boundsPeriod" to ensure result is Interval<Date> */ define function MedicationRequestPeriodTest(Request USCore."MedicationRequestProfile"): Request R let dosage: singleton from R.dosageInstruction, doseAndRate: singleton from dosage.doseAndRate, timing: dosage.timing, frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), period: Quantity(timing.repeat.period, timing.repeat.periodUnit), doseRange: doseAndRate.dose, doseQuantity: doseAndRate.dose, dose: Coalesce(end of doseRange, doseQuantity), dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), boundsPeriod: timing.repeat.bounds as Interval<DateTime>, expectedDaysSupply: R.dispenseRequest.expectedSupplyDuration.value, // TODO: this isn't working as expected, convert results in null //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value, daysSupply: (R.dispenseRequest.expectedSupplyDuration).value, quantity: R.dispenseRequest.quantity, refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0), startDate: Coalesce( date from start of boundsPeriod, date from R.authoredOn // TODO: accessing the validityPeriod field is causing QICore to be depended on and results in an error when evaluating // , // date from start of R.dispenseRequest.validityPeriod ), totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills) return { dosage: dosage, doseAndRate: doseAndRate, timing: timing, frequency: frequency, period: period, doseRange: doseRange, doseQuantity: doseQuantity, dose: dose, dosesPerDay: dosesPerDay, boundsPeriod: boundsPeriod, expectedDaysSupply: expectedDaysSupply, daysSupply: daysSupply, quantity: quantity, refills: refills, startDate: startDate, totalDaysSupplied: totalDaysSupplied, requestPeriod: if startDate is not null and totalDaysSupplied is not null then Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ] else if startDate is not null and boundsPeriod."high" is not null then Interval[startDate, date from end of boundsPeriod] else null} define function MedicationRequestPeriod(Request USCore."MedicationRequestProfile"): Request R let dosage: singleton from R.dosageInstruction, doseAndRate: singleton from dosage.doseAndRate, timing: dosage.timing, frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), period: Quantity(timing.repeat.period, timing.repeat.periodUnit), doseRange: doseAndRate.dose, doseQuantity: doseAndRate.dose, dose: Coalesce(end of doseRange, doseQuantity), dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), boundsPeriod: timing.repeat.bounds as Interval<DateTime>, // TODO: this isn't working as expected, convert results in null //daysSupply: (convert(R.dispenseRequest.expectedSupplyDuration) to days).value, daysSupply: (R.dispenseRequest.expectedSupplyDuration).value, quantity: R.dispenseRequest.quantity, refills: Coalesce(R.dispenseRequest.numberOfRepeatsAllowed, 0), startDate: Coalesce( date from start of boundsPeriod, date from R.authoredOn // TODO: accessing the validityPeriod field is causing QICore to be depended on and results in an error when evaluating // , // date from start of R.dispenseRequest.validityPeriod ), totalDaysSupplied: Coalesce(daysSupply, quantity.value / (dose.value * dosesPerDay)) * (1 + refills) return if startDate is not null and totalDaysSupplied is not null then Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day') ] else if startDate is not null and boundsPeriod."high" is not null then Interval[startDate, date from end of boundsPeriod] else null /* Next, consider the MedicationDispense case: * whenPrepared: When product was prepared * whenHandedOver: When product was given out * quantity: Amount dispensed * daysSupply: Amount of medication expressed as a timing amount * dosageInstruction.timing.repeat.boundsDuration: total duration of the repeat * dosageInstruction.timing.repeat.boundsRange: range of durations of the repeat * dosageInstruction.timing.repeat.boundsPeriod: period bounds of the repeat * dosageInstruction.timing.repeat.count: number of times to repeat * dosageInstruction.timing.repeat.countMax: maximum number of times to repeat * dosageInstruction.timing.repeat.frequency: event occurs frequency times per period * dosageInstruction.timing.repeat.frequencyMax: event occurs up to frequencyMax times per period * dosageInstruction.timing.repeat.period: event occurs frequency times per period * dosageInstruction.timing.repeat.periodMax: upper limit of period * dosageInstruction.timing.repeat.periodUnit: period duration (s | min | h | d | wk | mo | a) * dosageInstruction.timing.repeat.timeOfDay: time of day for the event (0..*) * dosageInstruction.timing.repeat.when: event timing (HS | WAKE | C | CM | CD | CV | AC | ACM...) * dosageInstruction.timing.code: BID | TID | QID | AM | PM | QD | QOD... * dosageInstruction.asNeeded * dosageInstruction.doseAndRate.doseQuantity * dosageInstruction.doseAndRate.doseRange We have effectively the same elements, with the same meanings, with the exception that the event is documenting a single dispense, and does not contain refill information. In addition, multiple dispense events would typically be present, and those would all have to be considered as part of an overall calculation. That will be considered when we combine results, but for this function, we'll focus on calculating the duration of a single dispense. With a MedicationDispense, dosage information is expected to be the same as the related MedicationRequest, so boundsPeriod would still cover the entire prescription (including refills) and so cannot be used to calculate the interval covered by the dispense. If the daysSupply element is present, then the duration in days is simply daysSupply Note specifically that we are not considering refills, as those would be covered by subsequent dispense records. If daysSupplied is not present, then daysSupplied must be calculated based on the quantity, dosage, and frequency: (quantity / (dosage * frequency)) This calculation results in a number of days, which can then be turned into a period by anchoring that to the startDate, as determined by the first available value of the start of the boundsPeriod, whenHandedOver, and whenPrepared. Interval[startDate, startDate + totalDaysSupplied - 1 day] */ /* Calculates Medication Period for a given MedicationDispense MedicationDispense instances provided to this function are expected to conform to the [TODO: MMEMedicationDispense](http://build.fhir.org/ig/cqframework/opioid-mme-r4/StructureDefinition-mmemedicationdispense.html) profile, which expects: * 1 and only 1 dosageInstruction, multiple dosageInstruction elements will result in an error * 1 and only 1 doseAndRate, multiple doseAndRate elements will result in an error * 1 timing with 1 repeat, missing timing or repeat elements will result in a null * frequency, frequencyMax, defaulting to 1 * period, periodUnit, defaulting to 1 'd' * timeOfDay * doseQuantity or doseRange, missing doseQuantity and doseRange will result in a null * whenHandedOver or whenPrepared, if missing both whenHandedOver and whenPrepared will result in a null Note that MedicationDispense status is not considered by this calculation, as the list of MedicationDispense instances provided to this function should already have considered appropriate statuses, depending on the use case, typically `completed`, especially since whenHandedOver would be expected to be present for a completed MedicationDispense. Note also that the dosage information recorded in a dispense is expected to be a copy of the dispense information from the related medication request. As such, the boundsPeriod would be expected to cover the entire range, and should _not_ be used for timing of the event. There is also active discussion in the Pharmacy WG about what date should be used if whenPrepared/whenHandedOver is not present. This may take the form of an "original creation date", but may also be a "status change date" for dispense events that are updating status of an existing dispense. That discussion is ongoing, so until that is resolved, this logic will return null if whenPrepared/whenHandedOver are not available. */ define function MedicationDispensePeriod(Dispense "MedicationDispense"): Dispense D let dosage: singleton from D.dosageInstruction, doseAndRate: singleton from dosage.doseAndRate, timing: dosage.timing, frequency: Coalesce(timing.repeat.frequencyMax, timing.repeat.frequency), period: Quantity(timing.repeat.period, timing.repeat.periodUnit), doseRange: doseAndRate.dose, doseQuantity: doseAndRate.dose, dose: Coalesce(end of doseRange, doseQuantity), daysSupply: (convert D.daysSupply to days).value, dosesPerDay: Coalesce(ToDaily(frequency, period), Count(timing.repeat.timeOfDay), 1.0), startDate: Coalesce( date from D.whenHandedOver, date from D.whenPrepared ), totalDaysSupplied: Coalesce(daysSupply, D.quantity.value / (dose.value * dosesPerDay)) return if startDate is not null and totalDaysSupplied is not null then Interval[startDate, startDate + Quantity(totalDaysSupplied - 1, 'day')] else null /* Returns the established therapeutic duration for a given medication. This is likely measure specific, though could potentially be established for any drug and distributed as a CodeSystem supplement. Defaulting to 14 days here for illustration. */ define function TherapeuticDuration(medication Concept): 14 days /* Next we consider MedicationAdministration. This data type is typically used to capture specific administration, with the relevantPeriod capturing start and stop time of the administration event: * effective[x]: Start and end time of administration However, when calculating cumulative medication duration, it is typically the therapeutic period of the medication that should be considered. Currently neither the Medication nor MedicationKnowledge resources provide this information, so we model it here as a function that can potentially be implemented in a variety of ways, including measure-specific values, as well as distribution as an RxNorm code system supplement. However it is obtained, if therapeutic duration can be obtained, and the effective period has a start, the result will be Interval[startDate, startDate + therapeuticDuration - 1 day] NOTE: Therapeutic duration needs to be established and until a way is implemented to do that based on the medication, this logic is incomplete and should not be used. */ define function MedicationAdministrationPeriod(Administration "MedicationAdministration"): Administration M let therapeuticDuration: TherapeuticDuration(Administration.medication), startDate: date from start of Administration.effective return if startDate is not null and therapeuticDuration is not null then Interval[startDate, startDate + therapeuticDuration - 1] else null /* Now that we have functions for determining the medication period for individual prescriptions, administrations, and dispenses, we can combine those using an overall cumulative medication duration calculation. There are two broad approaches to calculating cumulative duration, one that _collapses_ overlapping intervals so that calculations are not duplicated, and one that _rolls out_ overlapping intervals so that the durations are laid end-to-end. First, we define a function that simply calculates CumulativeDuration of a set of intervals: NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>> */ define function CumulativeDuration(Intervals List<Interval<Date>>): if Intervals is not null then ( Sum((collapse Intervals per day)X return all(difference in days between start of X and end of X )+ 1 ) ) else null /* Next, we define a function that rolls out intervals: NOTE: Updated argument to List<Interval<Date>> instead of List<Interval<DateTime>> */ define function RolloutIntervals(intervals List<Interval<Date>>): intervals I aggregate all R starting ( null as List<Interval<Date>>): R union ( { I X let S: Max({ end of Last(R)+ 1 day, start of X } ), E: S + Quantity(Coalesce(duration in days of X, 0), 'day') return Interval[S, E]} ) /* Then, we define a function that allows us to calculate based on the various medication types: */ define function MedicationPeriod( medication Choice<USCore."MedicationRequestProfile", "MedicationDispense" >): case when medication is USCore."MedicationRequestProfile" then MedicationRequestPeriod(medication) when medication is MedicationDispense then MedicationDispensePeriod(medication) else null end /* We can then use this function, combined with the MedicationDuration functions above to calculate Cumulative Medication Duration: Generally speaking, we want to _roll out_ intervals from dispense and administration events, and then collapse across that result and intervals from prescriptions. Note also that the separation of medications by type should already be done by this stage as well. Calculations that combine dosages from different types of medications (such as Morphine Milligram Equivalent (MME) or Average MME) require further consideration. */ define function CumulativeMedicationDuration( Medications List<Choice<USCore."MedicationRequestProfile", "MedicationDispense" >>): CumulativeDuration(( Medications M where M is MedicationRequest return MedicationRequestPeriod(M) ) union ( RolloutIntervals( Medications M where M is MedicationDispense return MedicationDispensePeriod(M) ) ) ) /**********************************************************************/ /* Functions in this region are copied from opioid-mme-r4 */ /**********************************************************************/ define function Quantity(value Decimal, unit String): if value is not null then System.Quantity { value: value, unit: unit } else null ( src )
• This material contains content from LOINC. LOINC is copyright © 1995-2020, Regenstrief Institute, Inc. and the Logical Observation Identifiers Names and Codes (LOINC) Committee and is available at no cost under the license. LOINC® is a registered United States trademark of Regenstrief Institute, Inc. Show Usage * LOINC: USCoreElements ( src )
• This material derives from the HL7 Terminology (THO). THO is copyright ©1989+ Health Level Seven International and is made available under the CC0 designation. For more licensing information see: https://terminology.hl7.org/license.html Show Usage * LibraryType: CumulativeMedicationDuration, ExamplePatientAndCoverageInitialExpressions... Show 9 more , GMTPInitialExpressions, MBODAInitialExpressions, MNACInitialExpressions, UPPARFInitialExpressions, USCoreCommon, USCoreCommonTests, USCoreElements, USCoreModelInfo and USCoreTests ( src )

External References

Type	Reference	Content
web	github.com
web	github.com	To address this, static analysis of the CQL can be used to determine the set of data requirements for an expression (or set of expressions), as described in the Artifact Data Requirements section of the CQL specification. The DataRequirementsProcessor provides an implementation of this capability. This component can accept a list of the expressions that should be analyzed to determine data requirements.
web	github.com	Well-known Documentation Tags
web	github.com	Manually translate the PDF content into a FHIR Questionnaire (this can optionally be done first in FSH format but ultimately must be present as an XML or JSON FHIR resource located at the path input/resources/questionnaire ). An example for the form in #1 can be found here .
web	github.com	Create a CQL file located at input/cql and remember to name it the same as the end of the canonical URL defined in step #3. An example for the MNAC form can be found here .
web	marketplace.visualstudio.com	The CQL VS Code extension allows for right-clicking Execute CQL . To successfully investigate if a certain definition results in the desired output, some test resources need to be provided and located in a folder at the following path: input/tests/library/YOUR-CQL-LIBRARY-NAME . Sub-folders can define multiple patients filled with multiple resource files. The MNAC test folder with resources of a Patient called example can be found here .
web	github.com	The CQL VS Code extension allows for right-clicking Execute CQL . To successfully investigate if a certain definition results in the desired output, some test resources need to be provided and located in a folder at the following path: input/tests/library/YOUR-CQL-LIBRARY-NAME . Sub-folders can define multiple patients filled with multiple resource files. The MNAC test folder with resources of a Patient called example can be found here .
web	github.com	Start a local instance of the Clinical Reasoning enabled HAPI JPA Server Starter (e.g. by using Docker) or use a publicly available FHIR server that supports CQL processing and the SDC $populate operation .
web	github.com	Test and see if the operation $populate for your questionnaire results in the expected initial values for each item. A complete sample Postman collection for a different Questionnaire can be found here . This collection also contains automated tests to highlight what to look for.
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=2787759
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=1830868
web	www.aetnabetterhealth.com	https://www.aetnabetterhealth.com/content/dam/aetna/medicaid/maryland/providers/pdfs/abhmd_maryland_prenatal_risk_assesment_mdh.pdf
web	www.uhcprovider.com	https://www.uhcprovider.com/en/resource-library/maternity-support.html
web	www.blueshieldca.com	https://www.blueshieldca.com/content/dam/bsca/en/provider/docs/medical-policies/Knee-Arthroplasty-Adults.pdf
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=4728932
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=5106036
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=5029375
web	docushare-web.apps.external.pioneer.humana.com	https://docushare-web.apps.external.pioneer.humana.com/Marketing/docushare-app?file=4197323
web	payerinfo.zendesk.com	https://payerinfo.zendesk.com/hc/en-us/categories/10629830321047-Fax-Forms
web	www.geisinger.org	https://www.geisinger.org/health-plan/providers/forms-and-resources-for-providers
web	fm.formularynavigator.com	https://fm.formularynavigator.com/FormularyNavigator/DocumentManager/Download?clientDocumentId=nU_SBgZRGEKjIxwVIRtrEQ
web	www.iso.org	ISO Maintains the copyright on the country codes, and controls it's use carefully. For futher details see the ISO 3166 web page: https://www.iso.org/iso-3166-country-codes.html Show Usage ISO 3166-1 Codes for the representation of names of countries and their subdivisions — Part 1: Country code : CQLUSCommon , CumulativeMedicationDuration ... Show 11 more , ExamplePatientAndCoverageInitialExpressions, ExamplePatientAndCoverageQuestionnaire, GMTPInitialExpressions, MBODAInitialExpressions, MNACInitialExpressions, UPPARFInitialExpressions, USCoreCommon, USCoreCommonTests, USCoreElements, USCoreModelInfo and USCoreTests
web	github.com	NOTE: Content for this page was adapted from the QICore Authoring Patterns - Allergies topic.
web	github.com	NOTE: Content for this page was adapted from the QICore Authoring Patterns - Laboratory Result topic.
web	github.com	NOTE: Content for this page was adapted from the QICore Authoring Patterns - Medications topic.
web	docushare-web.apps.external.pioneer.humana.com	Almost all prior authorization forms contain a question about the urgency of the request. Different forms have different ways of expressing the same logic. E.g., the Humana Uniform Pharmacy Prior Authorization Request Form uses check boxes with the strings "Urgent" and "Non-Urgent". The form Geisinger Medical Benefit Outpatient Drug Authorization Form contains a categorization as "Urgent" more in a boolean logic with a required rationale if the request is labelled as "Urgent".
web	www.geisinger.org	Almost all prior authorization forms contain a question about the urgency of the request. Different forms have different ways of expressing the same logic. E.g., the Humana Uniform Pharmacy Prior Authorization Request Form uses check boxes with the strings "Urgent" and "Non-Urgent". The form Geisinger Medical Benefit Outpatient Drug Authorization Form contains a categorization as "Urgent" more in a boolean logic with a required rationale if the request is labelled as "Urgent".
web	github.com	NOTE: Content for this page was adapted from the QICore Authoring Patterns - Patient topic.
web	github.com	NOTE: Content for this page was adapted from the QICore Authoring Patterns - Procedures topic.
web	github.com	Compare those patterns with QI Core Authoring Patterns to see if we can align.
web	github.com	User's Guide - Adding Test Data
web	github.com	The DTR SMART on FHIR App has facilities for end-to-end testing of the DaVinci DTR questionnaire use case, including questionnaire population and EHR FHIR queries.
web	github.com	(NOTE: These collections were tested against a HAPI JPA Server Starter instance using version 3.19.0 of the Clinical Reasoning module. They also include their own version of the FHIRHelpers Library (4.1.0) due to some technical limitations in the CQF Tooling used to construct the questionnaire bundles. Once those limitations have been removed these example collections will be regenerated.)
web	github.com	(NOTE: These collections were tested against a HAPI JPA Server Starter instance using version 3.19.0 of the Clinical Reasoning module. They also include their own version of the FHIRHelpers Library (4.1.0) due to some technical limitations in the CQF Tooling used to construct the questionnaire bundles. Once those limitations have been removed these example collections will be regenerated.)
web	github.com	Postman Collections
web	provider.humana.com	Preauthorization and Notification Lists for Healthcare Providers - Humana

Internal Images

Integration-Test-Scenarios.png

dtr-data-flow.svg