quality-measure-engine 0.2.0 → 0.8.0

data/lib/qme/importer/generic_importer.rb

@@ -5,65 +5,124 @@ module QME
     # it can then be passed a C32 document and will return a Hash with all of the information needed to calculate the measure.
     class GenericImporter
 
-      @@warnings = {}
+      class << self
+        attr_accessor :warnings
+      end
+
+      @warnings = []
 
       # Creates a generic importer for any quality measure.
       #
       # @param [Hash] definition A measure definition described in JSON
       def initialize(definition)
         @definition = definition
+        @warnings = []
       end
-      
+
       # Parses a HITSP C32 document and returns a Hash of information related to the measure
       #
       # @param [Hash] patient_hash representation of a patient
       # @return [Hash] measure information
       def parse(patient_hash)
         measure_info = {}
-        
         @definition['measure'].each_pair do |property, description|
           raise "No standard_category for #{property}" if !description['standard_category']
           matcher = PropertyMatcher.new(description)
-          entry_list = symbols_for_category(description['standard_category']).map do |section|
+          enrty_filter = filter_for_property(description['standard_category'], description['qds_data_type'])
+          entry_list = enrty_filter.call(patient_hash)
+          if ! entry_list.empty?
+            matched_list = matcher.match(entry_list)
+            measure_info[property] = matched_list if matched_list.length > 0
+          end
+        end
+        measure_info
+      end
+
+      private
+
+      def create_section_filter(*sections)
+        Proc.new do |patient_hash|
+          sections.map do |section|
             if patient_hash[section]
               patient_hash[section]
             else
               []
             end
           end.flatten
-          if ! entry_list.empty?
-            matched_list = matcher.match(entry_list)
-            measure_info[property]=matched_list if matched_list.length>0
+        end
+      end
+
+      def create_section_and_status_filter(status, *sections)
+        section_filter = create_section_filter(*sections)
+        Proc.new do |patient_hash|
+          entry_list = section_filter.call(patient_hash)
+          entry_list.select do |entry|
+            entry.status.nil? || entry.status == status
           end
         end
-        
-        measure_info
       end
-      
-      private
-      
-      def symbols_for_category(standard_category)
-        # Currently unsupported categories:
-        # characteristic, substance_allergy, medication_allergy, negation_rationale,
-        # diagnostic_study
+
+      def filter_for_property(standard_category, qds_data_type)
+        # Currently unsupported categories: negation_rationale, risk_category_assessment
         case standard_category
-        when 'encounter'; [:encounters]
-        when 'procedure'; [:procedures]
-        when 'communication'; [:procedures]
-        when 'laboratory_test'; [:results, :vital_signs]
-        when 'physical_exam'; [:vital_signs]
-        when 'medication'; [:medications]
-        when 'diagnosis_condition_problem'; [:conditions, :social_history]
-        when 'characteristic'; [:conditions, :social_history]
-        when 'device'; [:conditions, :procedures, :care_goals, :medical_equipment]
-        when 'care_goal'; [:care_goals]
-        when 'diagnostic_study'; [:procedures]
+        when 'encounter'
+          create_section_filter(:encounters)
+        when 'procedure'
+          case qds_data_type
+          when 'procedure_performed'
+            create_section_filter(:procedures)
+          when 'procedure_adverse_event', 'procedure_intolerance'
+            create_section_filter(:allergies)
+          when 'procedure_result'
+            create_section_filter(:procedures, :results, :vital_signs)
+          end
+        when 'risk_category_assessment'
+          create_section_filter(:procedures)
+        when 'communication'
+          create_section_filter(:procedures)
+        when 'laboratory_test'
+          create_section_filter(:results, :vital_signs)
+        when 'physical_exam'
+          create_section_filter(:vital_signs)
+        when 'medication'
+          case qds_data_type
+          when 'medication_dispensed', 'medication_order', 'medication_active', 'medication_administered'
+            create_section_filter(:medications, :immunizations)
+          when 'medication_allergy', 'medication_intolerance', 'medication_adverse_event'
+            create_section_filter(:allergies)
+          end
+        when 'diagnosis_condition_problem'
+          case qds_data_type
+          when 'diagnosis_active'
+            create_section_and_status_filter(:active, :conditions, :social_history)
+          when 'diagnosis_inactive'
+            create_section_and_status_filter(:inactive, :conditions, :social_history)
+          when 'diagnosis_resolved'
+            create_section_and_status_filter(:resolved, :conditions, :social_history)
+          end
+        when 'symptom'
+          create_section_filter(:conditions, :social_history)
+        when 'individual_characteristic'
+          create_section_filter(:conditions, :social_history)
+        when 'device'
+          case qds_data_type
+          when 'device_applied'
+            create_section_filter(:conditions, :procedures, :care_goals, :medical_equipment)
+          when 'device_allergy'
+            create_section_filter(:allergies)
+          end
+        when 'care_goal'
+          create_section_filter(:care_goals)
+        when 'diagnostic_study'
+          create_section_filter(:procedures)
+        when 'substance'
+          create_section_filter(:allergies)
         else
-          if !@@warnings[standard_category]
+          unless self.class.warnings.include?(standard_category)
             puts "Warning: Unsupported standard_category (#{standard_category})"
-            @@warnings[standard_category]=true
+            self.class.warnings << standard_category
           end
-          []
+          Proc.new {[]} # A proc that returns an empty array
         end
       end
     end

data/lib/qme/importer/patient_importer.rb

@@ -1,14 +1,15 @@
 module QME
   module Importer
-    
+
     # This class is the central location for taking a HITSP C32 XML document and converting it
     # into the processed form we store in MongoDB. The class does this by running each measure
     # independently on the XML document
     #
     # This class is a Singleton. It should be accessed by calling PatientImporter.instance
     class PatientImporter
+
       include Singleton
-      
+
       # Creates a new PatientImporter with the following XPath expressions used to find content in 
       # a HITSP C32:
       #
@@ -18,8 +19,8 @@ module QME
       # Procedure entries
       #    //cda:procedure[cda:templateId/@root='2.16.840.1.113883.10.20.1.29']
       #
-      # Result entries
-      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']
+      # Result entries - There seems to be some confusion around the correct templateId, so the code checks for both
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15.1'] | //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']
       #
       # Vital sign entries
       #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.14']
@@ -33,33 +34,44 @@ module QME
       # Condition entries
       #    //cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation
       #
+      # Codes for conditions are determined by examining the value child element as opposed to the code child element
+      #
       # Social History entries (non-C32 section, specified in the HL7 CCD)
       #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.19']
       #
       # Care Goal entries(non-C32 section, specified in the HL7 CCD)
       #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']
       #
-      # Codes for conditions are determined by examining the value child element as opposed to the code child element
+      # Allergy entries
+      #    //cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.18']
+      #
+      # Immunization entries
+      #    //cda:substanceAdministration[cda:templateId/@root='2.16.840.1.113883.10.20.1.24']
+      #
+      # Codes for immunizations are found in the substanceAdministration with the following relative XPath
+      #    ./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code
       def initialize
         @measure_importers = {}
-        
         @section_importers = {}
         @section_importers[:encounters] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.127']/cda:entry/cda:encounter")
         @section_importers[:procedures] = SectionImporter.new("//cda:procedure[cda:templateId/@root='2.16.840.1.113883.10.20.1.29']")
-        @section_importers[:results] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']")
+        @section_importers[:results] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15.1'] | //cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.15']")
         @section_importers[:vital_signs] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.14']")
         @section_importers[:medications] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.112']/cda:entry/cda:substanceAdministration",
                                                                "./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code")
-
         @section_importers[:conditions] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.103']/cda:entry/cda:act/cda:entryRelationship/cda:observation",
-                                                              "./cda:value")
-                                                              
+                                                              "./cda:value",
+                                                              "./cda:entryRelationship/cda:observation[cda:templateId/@root='2.16.840.1.1 13883.10.20.1.50']/cda:value")
         @section_importers[:social_history] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.19']")
         @section_importers[:care_goals] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.25']")
         @section_importers[:medical_equipment] = SectionImporter.new("//cda:section[cda:templateId/@root='2.16.840.1.113883.3.88.11.83.128']/cda:entry/cda:supply",
                                                                      "./cda:participant/cda:participantRole/cda:playingDevice/cda:code")
+        @section_importers[:allergies] = SectionImporter.new("//cda:observation[cda:templateId/@root='2.16.840.1.113883.10.20.1.18']",
+                                                             "./cda:participant/cda:participantRole/cda:playingEntity/cda:code")
+        @section_importers[:immunizations] = SectionImporter.new("//cda:substanceAdministration[cda:templateId/@root='2.16.840.1.113883.10.20.1.24']",
+                                                                 "./cda:consumable/cda:manufacturedProduct/cda:manufacturedMaterial/cda:code")
       end
-            
+
       # Parses a HITSP C32 document and returns a Hash of of the patient.
       #
       # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
@@ -71,7 +83,7 @@ module QME
         get_demographics(patient_record, doc)
         process_events(patient_record, c32_patient)
       end
-      
+
       # Parses a patient hash containing demongraphic and event information
       #
       # @param [Hash] patient_hash patient data
@@ -88,27 +100,32 @@ module QME
         end
         process_events(patient_record, event_hash)
       end
-      
+
       def process_events(patient_record, event_hash)
         patient_record['measures'] = {}
         @measure_importers.each_pair do |measure_id, importer|
           patient_record['measures'][measure_id] = importer.parse(event_hash)
         end
-        
         patient_record
       end
-      
+
       # Parses a list of event hashes into an array of Entry objects
       #
       # @param [Array] event_list list of event hashes
       # @return [Array] array of Entry objects
       def parse_events(event_list)
         event_list.collect do |event|
-          nil if event.class==String.class # skip
-          QME::Importer::Entry.from_event_hash(event)
+          if event.class==String.class
+            # skip String elements in the event list, patient randomization templates
+            # introduce String elements to simplify tailing-comma handling when generating
+            # JSON using ERb
+            nil
+          else
+            QME::Importer::Entry.from_event_hash(event)
+          end
         end.compact
       end
-      
+
       # Adds a measure to run on a C32 that is passed in
       #
       # @param [MeasureBase] measure an Class that can extract information from a C32 that is necessary
@@ -116,7 +133,7 @@ module QME
       def add_measure(measure_id, importer)
         @measure_importers[measure_id] = importer
       end
-      
+
       # Create a simple representation of the patient from a HITSP C32
       #
       # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
@@ -127,10 +144,9 @@ module QME
         @section_importers.each_pair do |section, importer|
           c32_patient[section] = importer.create_entries(doc)
         end
-        
         c32_patient
       end
-      
+
       # Inspects a C32 document and populates the patient Hash with first name, last name
       # birth date and gender.
       #

data/lib/qme/importer/property_matcher.rb

@@ -42,8 +42,13 @@ module QME
       #         Hashes will have a "value" and "date" property containing the respective data
       def extract_value_date_list(entry_list)
         basic_extractor(entry_list) do |entry, matching_values|
-          if entry.value[:scalar]
-            matching_values << {'date' => entry.as_point_in_time, 'value' => entry.value[:scalar]}
+          value = entry.value[:scalar]
+          if value
+            if @property_description['items']['properties']['value']['type'] == 'number'
+              value = value.to_f
+            end
+            
+            matching_values << {'date' => entry.as_point_in_time, 'value' => value}
           end
         end
       end

data/lib/qme/importer/section_importer.rb

@@ -8,11 +8,15 @@ module QME
       # @param [String] entry_xpath An XPath expression that can be used to find the desired entries
       # @param [String] code_xpath XPath expression to find the code element as a child of the desired CDA entry.
       #        Defaults to "./cda:code"
-      def initialize(entry_xpath, code_xpath="./cda:code")
+      # @param [String] status_xpath XPath expression to find the status element as a child of the desired CDA
+      #        entry. Defaults to nil. If not provided, a status will not be checked for since it is not applicable
+      #        to all enrty types
+      def initialize(entry_xpath, code_xpath="./cda:code", status_xpath=nil)
         @entry_xpath = entry_xpath
         @code_xpath = code_xpath
+        @status_xpath = status_xpath
       end
-      
+
       # Traverses that HITSP C32 document passed in using XPath and creates an Array of Entry
       # objects based on what it finds
       # @param [Nokogiri::XML::Document] doc It is expected that the root node of this document
@@ -27,34 +31,49 @@ module QME
           extract_codes(entry_element, entry)
           extract_dates(entry_element, entry)
           extract_value(entry_element, entry)
+          if @status_xpath
+            extract_status(entry_element, entry)
+          end
           if entry.usable?
             entry_list << entry
           end
         end
-        
         entry_list
       end
-      
+
       private
-      
+
+      def extract_status(parent_element, entry)
+        status_element = parent_element.at_xpath(@status_xpath)
+        if status_element
+          case status_element['code']
+          when '55561003'
+            entry.status = :active
+          when '73425007'
+            entry.status = :inactive
+          when '413322009'
+            entry.status = :resolved
+          end
+        end
+      end
+
       def extract_codes(parent_element, entry)
         code_elements = parent_element.xpath(@code_xpath)
         code_elements.each do |code_element|
           add_code_if_present(code_element, entry)
-          
           translations = code_element.xpath('cda:translation')
           translations.each do |translation|
             add_code_if_present(translation, entry)
           end
         end
       end
-      
+
       def add_code_if_present(code_element, entry)
         if code_element['codeSystem'] && code_element['code']
           entry.add_code(code_element['code'], CodeSystemHelper.code_system_for(code_element['codeSystem']))
         end
       end
-      
+
       def extract_dates(parent_element, entry)
         if parent_element.at_xpath('cda:effectiveTime')
           entry.time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime')['value'])
@@ -65,8 +84,11 @@ module QME
         if parent_element.at_xpath('cda:effectiveTime/cda:high')
           entry.end_time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime/cda:high')['value'])
         end
+        if parent_element.at_xpath('cda:effectiveTime/cda:center')
+          entry.time = HL7Helper.timestamp_to_integer(parent_element.at_xpath('cda:effectiveTime/cda:center')['value'])
+        end
       end
-      
+
       def extract_value(parent_element, entry)
         value_element = parent_element.at_xpath('cda:value')
         if value_element

data/lib/qme/map/map_reduce_builder.rb

@@ -31,18 +31,9 @@ module QME
           result = ''
           result << 'if (typeof(map)=="undefined") {'
           result << "\n"
-          Dir.glob(File.join(File.dirname(__FILE__), '../../../js/*.js')).each do |js_file|
-            result << File.read(js_file)
-            result << "\n"
-          end
-          Dir.glob(File.join('./js/*.js')).each do |js_file|
-            result << File.read(js_file)
-            result << "\n"
-          end
           @db['bundles'].find.each do |bundle|
             (bundle['extensions'] || []).each do |ext|
-              result << ext
-              result << "\n"
+              result << "#{ext}();\n"
             end
           end
           result << "}\n"
@@ -89,8 +80,19 @@ module QME
       # wrapper for the reduce utility function specified in
       # map-reduce-utils.js
       # @return [String] the reduce function
-      def reduce_function
-        'function (key, values) { return reduce(key, values);};'
+      def finalize_function
+        reduce = 
+        "function (key, value) { 
+          var patient = value;
+          patient.measure_id = \"#{@measure_def['id']}\";\n"
+        if @measure_def['sub_id']
+          reduce += "  patient.sub_id = \"#{@measure_def['sub_id']}\";\n"
+        end
+          
+        reduce += "patient.effective_date = #{@params['effective_date']};
+                   return patient;}"
+        
+        reduce
       end
 
 

data/lib/qme/map/map_reduce_executor.rb

@@ -4,112 +4,48 @@ module QME
     # Computes the value of quality measures based on the current set of patient
     # records in the database
     class Executor
-    
-      # Create a new Executor for the supplied database connection
-      def initialize(db)
-        @db = db
+      include DatabaseAccess
+      
+      def initialize(measure_id, sub_id, parameter_values)
+        @measure_id = measure_id
+        @sub_id = sub_id
+        @parameter_values = parameter_values
+        determine_connection_information
       end
 
-      # Retrieve a measure definition from the database
-      # @param [String] measure_id value of the measure's id field
-      # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
-      # @return [Hash] a JSON hash of the encoded measure
-      def measure_def(measure_id, sub_id=nil)
-        measures = @db.collection('measures')
-        if sub_id
-          measures.find_one({'id'=>measure_id, 'sub_id'=>sub_id})
-        else
-          measures.find_one({'id'=>measure_id})
+      # Examines the patient_cache collection and generates a total of all groups
+      # for the measure. The totals are placed in a document in the query_cache
+      # collection.
+      # @return [Hash] measure groups (like numerator) as keys, counts as values
+      def count_records_in_measure_groups
+        patient_cache = get_db.collection('patient_cache')
+        query = {'value.measure_id' => @measure_id, 'value.sub_id' => @sub_id,
+                 'value.effective_date' => @parameter_values['effective_date']}
+        result = {:measure_id => @measure_id, :sub_id => @sub_id, 
+                  :effective_date => @parameter_values['effective_date']}
+        
+        %w(population denominator numerator antinumerator exclusions).each do |measure_group|
+          patient_cache.find(query.merge("value.#{measure_group}" => true)) do |cursor|
+            result[measure_group] = cursor.count
+          end
         end
-      end
-
-      # Compute the specified measure
-      # @param [String] measure_id value of the measure's id field
-      # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
-      # @param [Hash] parameter_values a hash of the measure parameter values. Keys may be either a String or Symbol
-      # @return [Hash] a hash of the measure result with Symbol keys: population, denominator, numerator, antinumerator and exclusions whose values are the count of patient records that meet the criteria for each component of the measure. Also included are keys: population_members, denominator_members, numerator_members, antinumerator_members and exclusions_members whose values are arrays of the patient record identifiers that meet the criteria for each component of the measure.
-      def measure_result(measure_id, sub_id, parameter_values)
         
-        cache = @db.collection("query_cache")
-        cache_q = {:measure_id=>measure_id, :sub_id=>sub_id,:effective_date=>parameter_values[:effective_date]}
-        result = cache.find_one(cache_q)
-        unless result
-          measure = Builder.new(@db, measure_def(measure_id, sub_id), parameter_values)
-
-          records = @db.collection('records')
-          results = records.map_reduce(measure.map_function, measure.reduce_function)
-          result = results.find_one # only one key is used by map fn
-          result['value']['cache_name'] = cache_name(measure_id,sub_id,parameter_values[:effective_date])
-          cache_q["value"] =result['value']
-          cache << cache_q
-          
-          cache_measure_patients(measure_id,sub_id,parameter_values[:effective_date],result['value'])
-        end  
+        get_db.collection("query_cache").save(result)
         
-        value = result['value']
-        summary = {}
-        %w(population denominator numerator antinumerator exclusions).each do |field|
-          summary[field.intern] = value[field].length
-          summary[(field+'_members').intern] = value[field]
-        end
-        summary
-
-      end
-      
-      # Return a list of the measures in the database
-      # @return [Hash] an hash of measure definitions
-      def all_measures
-        result = {}
-        measures = @db.collection('measures')
-        measures.find().each do |measure|
-          id = measure['id']
-          sub_id = measure['sub_id']
-          measure_id = "#{id}#{sub_id}.json"
-          result[measure_id] ||= measure
-        end
         result
       end
-      
-      
-      private 
-      
-      
-      def cache_name(measure_id, sub_id, effective_date)
-        "cached_measure_patients_#{measure_id}_#{sub_id}_#{effective_date}"
-      end
-      
-       #  Private method to cache the patient record for a particular measure and effective time.  This also caches if they are part of the denominator, numeratore ..... which will be used for sorting.
-        # @param [String] measure_id value of the measure's id field
-        # @param [String] sub_id value of the measure's sub_id field, may be nil for measures with only a single numerator and denominator
-        # @param [Integer] effective_date the effective date used by the map reduce function to calculate popultion, denominator ....... 
-      def cache_measure_patients(measure_id, sub_id, effective_date, results,drop=true)
-        col_name =cache_name(measure_id, sub_id, effective_date)
-        @db.collection(col_name).drop if drop
-        cached_patients =  @db.collection(col_name)
-        population = results['population']
-        if population
-        records =   @db.collection("records").find('_id' => {'$in' => results['population']})
-        records.each do |record|
-          record_id = record['_id']
-          new_record = {:first=>record['first'],
-                     :last=>record['last'],
-                     :birthdate=>record['birthdate'],
-                     :gender=>record['gender'],
-                     :measure_id => measure_id,
-                     :sub_id=>sub_id,
-                     :effective_date => effective_date,
-                     :measure_data => record[measure_id],
-                     :numerator=>!results['numerator'].index(record_id).nil?,
-                     :denominator=>!results['denominator'].index(record_id).nil?,
-                     :exclusion=>!results['exclusions'].index(record_id).nil?,
-                     :antinumerator=>!results['antinumerator'].index(record_id).nil?}
-                     
-            cached_patients << new_record         
-          
-        end
-      end
+
+      # This method runs the MapReduce job for the measure which will create documents
+      # in the patient_cache collection. These documents will state the measure groups
+      # that the record belongs to, such as numerator, etc.
+      def map_records_into_measure_groups
+        qm = QualityMeasure.new(@measure_id, @sub_id)
+        measure = Builder.new(get_db, qm.definition, @parameter_values)
+        records = get_db.collection('records')
+        records.map_reduce(measure.map_function, "function(key, values){return values;}",
+                           :out => {:reduce => 'patient_cache'}, 
+                           :finalize => measure.finalize_function)
       end
-      
     end
   end
 end