Follow-Up Care for Children Prescribed ADHD Medication

  CMD."CumulativeDuration" ( "ADHD Medications Taken on IPSD or During Continuation and Maintenance Phase" )

  ( ( ["Medication, Order": "Atomoxetine"]
    union ["Medication, Order": "Clonidine"]
    union ["Medication, Order": "Dexmethylphenidate"]
    union ["Medication, Order": "Dextroamphetamine"]
    union ["Medication, Order": "Lisdexamfetamine"]
    union ["Medication, Order": "methamphetamine hydrochloride 5 MG Oral Tablet"]
    union ["Medication, Order": "Methylphenidate"]
    union ["Medication, Order": "Guanfacine Medications"]
    union ["Medication, Order": "Viloxazine"]) ADHDMedications
    where Coalesce(ADHDMedications.relevantPeriod.low, ADHDMedications.authorDatetime) during "Intake Period" ) ADHDMedicationOrder
    without ( ["Medication, Active": "Atomoxetine"]
      union ["Medication, Active": "Clonidine"]
      union ["Medication, Active": "Dexmethylphenidate"]
      union ["Medication, Active": "Dextroamphetamine"]
      union ["Medication, Active": "Lisdexamfetamine"]
      union ["Medication, Active": "methamphetamine hydrochloride 5 MG Oral Tablet"]
      union ["Medication, Active": "Methylphenidate"]
      union ["Medication, Active": "Guanfacine Medications"]
      union ["Medication, Active": "Viloxazine"]) ActiveADHDMedication
      such that Global."ToDateInterval" ( Global."NormalizeInterval" ( ActiveADHDMedication.relevantDatetime, ActiveADHDMedication.relevantPeriod ) ) overlaps Interval[date from Coalesce(ADHDMedicationOrder.relevantPeriod.low, ADHDMedicationOrder.authorDatetime) - 120 days, date from Coalesce(ADHDMedicationOrder.relevantPeriod.low, ADHDMedicationOrder.authorDatetime) )
    sort by Coalesce(relevantPeriod.low, authorDatetime) asc

  ( ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Atomoxetine"] AtomoxetineMed
        return all {
          period: CMD."MedicationOrderPeriod" ( AtomoxetineMed ),
          periodStart: start of CMD."MedicationOrderPeriod" ( AtomoxetineMed )
        }
        sort by periodStart
    ).period )
  )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Clonidine"] ClonidineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( ClonidineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( ClonidineMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Dexmethylphenidate"] DexmethylphenidateMed
          return all {
            period: CMD."MedicationOrderPeriod" ( DexmethylphenidateMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( DexmethylphenidateMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Dextroamphetamine"] DextroamphetamineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( DextroamphetamineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( DextroamphetamineMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Lisdexamfetamine"] LisdexamfetamineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( LisdexamfetamineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( LisdexamfetamineMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Methylphenidate"] MethylphenidateMed
          return all {
            period: CMD."MedicationOrderPeriod" ( MethylphenidateMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( MethylphenidateMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Guanfacine Medications"] GuanfacineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( GuanfacineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( GuanfacineMed )
          }
          sort by periodStart
      ).period )
    )
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "methamphetamine hydrochloride 5 MG Oral Tablet"] MethamphetamineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( MethamphetamineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( MethamphetamineMed )
          }
          sort by periodStart
      ).period )
    ) 
    union ( CMD."RolloutIntervals" ( ( ["Medication, Order": "Viloxazine"] ViloxazineMed
          return all {
            period: CMD."MedicationOrderPeriod" ( ViloxazineMed ),
            periodStart: start of CMD."MedicationOrderPeriod" ( ViloxazineMed )
          }
          sort by periodStart
      ).period )
    )
    ) ADHDMedication
    let IPSDAndContinuationMaintenancePhase: Interval["IPSD", "IPSD" + 300 days]
    return all ADHDMedication
      intersect IPSDAndContinuationMaintenancePhase

  "Initial Population 1"

  "Initial Population 2"

  Hospice."Has Hospice Services"
    or exists ( "Narcolepsy Exclusion" )

  "Qualifying Numerator Encounter" ValidNumeratorEncounter
    where Global."ToDateInterval" ( ValidNumeratorEncounter.relevantPeriod ) starts during day of Interval["IPSD" + 31 days, "IPSD" + 300 days]
    return date from start of ValidNumeratorEncounter.relevantPeriod

  "Qualifying Numerator Encounter" ValidNumeratorEncounter
    where Global."ToDateInterval" ( ValidNumeratorEncounter.relevantPeriod ) starts 30 days or less after day of "IPSD"

  First("ADHD Medication Prescribed During Intake Period and Not Previously on ADHD Medication")

  "ADHD Cumulative Medication Duration" >= 210

  exists ( ["Encounter, Performed": "Encounter Inpatient"] InpatientEncounter
      where ( InpatientEncounter.dischargeDisposition ~ "Discharge to home for hospice care (procedure)"
          or InpatientEncounter.dischargeDisposition ~ "Discharge to healthcare facility for hospice care (procedure)"
      )
        and InpatientEncounter.relevantPeriod ends during day of "Measurement Period"
  )
    or exists ( ["Encounter, Performed": "Hospice Encounter"] HospiceEncounter
        where HospiceEncounter.relevantPeriod overlaps day of "Measurement Period"
    )
    or exists ( ["Assessment, Performed": "Hospice care [Minimum Data Set]"] HospiceAssessment
        where HospiceAssessment.result ~ "Yes (qualifier value)"
          and Global."NormalizeInterval" ( HospiceAssessment.relevantDatetime, HospiceAssessment.relevantPeriod ) overlaps day of "Measurement Period"
    )
    or exists ( ["Intervention, Order": "Hospice Care Ambulatory"] HospiceOrder
        where HospiceOrder.authorDatetime during day of "Measurement Period"
    )
    or exists ( ["Intervention, Performed": "Hospice Care Ambulatory"] HospicePerformed
        where Global."NormalizeInterval" ( HospicePerformed.relevantDatetime, HospicePerformed.relevantPeriod ) overlaps day of "Measurement Period"
    )
  or exists ( ["Diagnosis": "Hospice Diagnosis"] HospiceCareDiagnosis
        where HospiceCareDiagnosis.prevalencePeriod overlaps day of "Measurement Period"
    )

  AgeInYearsAt(date from start of "Intake Period") >= 6
    and AgeInYearsAt(date from 
      end of "Intake Period"
    ) <= 12
    and exists "Qualifying Encounter"
    and "First ADHD Medication Prescribed During Intake Period" is not null
    and not exists "Inpatient Stay with Qualifying Diagnosis During Initiation Phase"

  AgeInYearsAt(date from start of "Intake Period") >= 6
    and AgeInYearsAt(date from 
      end of "Intake Period"
    ) <= 12
    and exists "Qualifying Encounter"
    and "First ADHD Medication Prescribed During Intake Period" is not null
    and "Has ADHD Cumulative Medication Duration Greater Than or Equal to 210 Days"
    and not exists "Inpatient Stay with Qualifying Diagnosis During Continuation and Maintenance Phase"

  ( ["Encounter, Performed": "Encounter Inpatient"] InpatientStay
      where exists ( InpatientStay.diagnoses EncounterDiagnoses
          where ( EncounterDiagnoses.rank = 1
              and EncounterDiagnoses.code in "Mental Behavioral and Neurodevelopmental Disorders"
          )
      )
  )

  "Inpatient Stay with Qualifying Diagnosis" InpatientStay
    where Global."ToDateInterval" ( InpatientStay.relevantPeriod ) starts 300 days or less after day of "IPSD"

  "Inpatient Stay with Qualifying Diagnosis" InpatientStay
    where Global."ToDateInterval" ( InpatientStay.relevantPeriod ) starts 30 days or less after day of "IPSD"

  Interval["March 1 of Year Prior to Measurement Period", "Last Calendar Day of February of Measurement Period"]

  date from Coalesce("First ADHD Medication Prescribed During Intake Period".relevantPeriod.low, "First ADHD Medication Prescribed During Intake Period".authorDatetime)

  ( DateTime(year from start of "Measurement Period", 3, 1, 23, 59, 59, 0, 0) ) - 1 day

  DateTime((year from start of "Measurement Period" - 1), 3, 1, 0, 0, 0, 0, 0)

  ["Diagnosis": "Narcolepsy"] NarcolepsyDx
    where NarcolepsyDx.prevalencePeriod starts on or before end "Measurement Period"

  exists ( "Encounter During Initiation Phase" )

  exists ( "Encounter During Initiation Phase" )
    and ( ( "Two or More Encounters 31 to 300 Days into Continuation and Maintenance Phase" )
        or ( exists ( "Encounter 31 to 300 Days into Continuation and Maintenance Phase" Encounter1
              with "Virtual Encounter 31 to 300 Days into Continuation and Maintenance Phase" Encounter2
                such that Encounter1 is not null
                  and Encounter2 is not null
                  and Encounter1 !~ Encounter2
          )
        )
    )

  ( ["Encounter, Performed": "Office Visit"]
    union ["Encounter, Performed": "Home Healthcare Services"]
    union ["Encounter, Performed": "Preventive Care, Established Office Visit, 0 to 17"]
    union ["Encounter, Performed": "Preventive Care Services, Initial Office Visit, 0 to 17"] ) ValidEncounter
    where Global."ToDateInterval" ( ValidEncounter.relevantPeriod ) during day of Interval["IPSD" - 6 months, "IPSD"]

  ( ["Encounter, Performed": "Office Visit"]
      union ["Encounter, Performed": "Preventive Care Services Group Counseling"]
      union ["Encounter, Performed": "Behavioral Health Follow up Visit"]
      union ["Encounter, Performed": "Preventive Care Services Individual Counseling"]
      union ( ["Encounter, Performed": "Psychotherapy and Pharmacologic Management"] PsychPharmManagement
          where exists ( PsychPharmManagement.facilityLocations Location
              where Location.code in "Ambulatory"
          )
      )
      union ["Encounter, Performed": "Outpatient Consultation"]
      union ["Encounter, Performed": "Home Healthcare Services"]
      union ["Encounter, Performed": "Preventive Care Services, Initial Office Visit, 0 to 17"]
      union ["Encounter, Performed": "Preventive Care, Established Office Visit, 0 to 17"]
      union ["Encounter, Performed": "Psych Visit Diagnostic Evaluation"]
      union ["Encounter, Performed": "Psych Visit Psychotherapy"]
      union ["Encounter, Performed": "Telephone Visits"]
  )

  ["Patient Characteristic Ethnicity": "Ethnicity"]

  ["Patient Characteristic Payer": "Payer Type"]

  ["Patient Characteristic Race": "Race"]

  ["Patient Characteristic Sex": "Federal Administrative Sex"]

  Count("Encounter 31 to 300 Days into Continuation and Maintenance Phase") >= 2

  ["Encounter, Performed": "Virtual Encounter"] VirtualEnc
    where Global."ToDateInterval" ( VirtualEnc.relevantPeriod ) starts during day of Interval["IPSD" + 31 days, "IPSD" + 300 days]
    return date from start of VirtualEnc.relevantPeriod

  case
    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 null
  end

  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

  MedOrder Order
    let startDate: date from Coalesce(Order.relevantPeriod.low, Order.authorDatetime),
    totalDaysSupplied: Coalesce(Order.daysSupplied, Order.supply.value /(Order.dosage.value * ToDaily(Order.frequency))) * ( 1 + Coalesce(Order.refills, 0) )
    return if startDate is null then null 
      else if totalDaysSupplied is not null then Interval[startDate, startDate + Quantity { value: totalDaysSupplied - 1, unit: 'day' }]
      else if Order.relevantPeriod.high is not null then Interval[startDate, date from end of Order.relevantPeriod]
      else null

  case Frequency.unit
      when 'h' then (24.0 / Frequency.value)
      when 'min' then (24.0 / Frequency.value) * 60
      when 's' then (24.0 / Frequency.value) * 60 * 60
      when 'd' then (24.0 / Frequency.value) / 24
      when 'wk' then (24.0 / Frequency.value) / (24 * 7)
      when 'mo' then (24.0 / Frequency.value) / (24 * 30) /* assuming 30 days in month */
      when 'a' then (24.0 / Frequency.value) / (24 * 365) /* assuming 365 days in year */
      when 'hour' then (24.0 / Frequency.value)
      when 'minute' then (24.0 / Frequency.value) * 60
      when 'second' then (24.0 / Frequency.value) * 60 * 60
      when 'day' then (24.0 / Frequency.value) / 24
      when 'week' then (24.0 / Frequency.value) / (24 * 7)
      when 'month' then (24.0 / Frequency.value) / (24 * 30) /* assuming 30 days in month */
      when 'year' then (24.0 / Frequency.value) / (24 * 365) /* assuming 365 days in year */
      when 'hours' then (24.0 / Frequency.value)
      when 'minutes' then (24.0 / Frequency.value) * 60
      when 'seconds' then (24.0 / Frequency.value) * 60 * 60
      when 'days' then (24.0 / Frequency.value) / 24
      when 'weeks' then (24.0 / Frequency.value) / (24 * 7)
      when 'months' then (24.0 / Frequency.value) / (24 * 30) /* assuming 30 days in month */
      when 'years' then (24.0 / Frequency.value) / (24 * 365) /* assuming 365 days in year */
      else null
    end

  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 { value: Coalesce(duration in days of X, 0), unit: 'day' }
        return Interval[S, E]}
    )

  case
    when Frequency is Quantity then QuantityToDaily(Frequency as Quantity)
    else CodeToDaily(Frequency as Code)
  end

  if pointInTime is not null then Interval[pointInTime, pointInTime]
    else if period is not null then period 
    else null as Interval<DateTime>

  Interval[date from start of period, date from end of period]