health-data-standards 2.2.1 → 3.0.3

data/lib/hqmf-parser/converter/pass1/document_converter.rb

@@ -0,0 +1,185 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class DocumentConverter
+   
+    BIRTHTIME_CODE_LIST = {'LOINC'=>['21112-8']}
+    
+    def self.convert(json, codes)
+      
+      title = json[:title]
+      description = json[:description]
+      
+      metadata = json[:metadata]
+      metadata.keys.each {|key| metadata[key.to_s] = metadata[key]; metadata.delete(key.to_sym)}
+      
+      id = metadata["NQF_ID_NUMBER"][:value] if metadata["NQF_ID_NUMBER"]
+      emeasure_id = metadata['EMEASURE_IDENTIFIER'][:value] if metadata['EMEASURE_IDENTIFIER']
+      attributes = parse_attributes(metadata)
+      hqmf_id = json[:hqmf_id]
+      hqmf_set_id = json[:hqmf_set_id]
+      hqmf_version_number = json[:hqmf_version_number]
+      cms_id = "CMS#{emeasure_id}v#{hqmf_version_number}"
+      
+      measure_period = parse_measure_period(json)
+      @data_criteria_converter = DataCriteriaConverter.new(json, measure_period)
+      
+      # source data criteria are the original unmodified v2 data criteria
+      source_data_criteria = []
+      @data_criteria_converter.v2_data_criteria.each {|criteria| source_data_criteria << criteria}
+      
+      # PASS 1
+      @population_criteria_converter = PopulationCriteriaConverter.new(json, @data_criteria_converter)
+      population_criteria = @population_criteria_converter.population_criteria
+      
+      # PASS 2
+      comparison_converter = HQMF::ComparisonConverter.new(@data_criteria_converter)
+      comparison_converter.convert_comparisons(population_criteria)
+
+      # PASS 3
+      # specific_occurrence_converter = HQMF::SpecificOccurrenceConverter.new(@data_criteria_converter)
+      # specific_occurrence_converter.convert_specific_occurrences(population_criteria)
+
+      data_criteria = @data_criteria_converter.final_v2_data_criteria
+      
+      populations = @population_criteria_converter.sub_measures
+      
+      doc = HQMF::Document.new(id, hqmf_id, hqmf_set_id, hqmf_version_number, cms_id, title, description, population_criteria, data_criteria, source_data_criteria, attributes, measure_period, populations)
+       
+      backfill_patient_characteristics_with_codes(doc, codes)
+      
+      HQMF::DocumentConverter.validate(doc, codes)
+      
+      doc
+      
+    end
+   
+    private
+    
+    def self.parse_attributes(metadata)
+      attributes = []
+      metadata.keys.each do |key|
+        attribute_hash = metadata[key]
+        code = attribute_hash[:code]
+        value = attribute_hash[:value]
+        unit = attribute_hash[:unit]
+        name = attribute_hash[:name]
+        attributes << HQMF::Attribute.new(key,code,value,unit,name)
+      end
+      attributes
+    end
+    
+
+    # patient characteristics data criteria such as GENDER require looking at the codes to determine if the 
+    # measure is interested in Males or Females.  This process is awkward, and thus is done as a separate
+    # step after the document has been converted.
+    def self.backfill_patient_characteristics_with_codes(doc, codes)
+      
+      [].concat(doc.all_data_criteria).concat(doc.source_data_criteria).each do |data_criteria|
+        if (data_criteria.type == :characteristic and !data_criteria.property.nil?)
+          if (codes)
+            value_set = codes[data_criteria.code_list_id]
+            puts "\tno value set for unknown patient characteristic: #{data_criteria.id}" unless value_set
+          else
+            puts "\tno code set to back fill: #{data_criteria.title}"
+            next
+          end
+          
+          if (data_criteria.property == :gender)
+            key = value_set.keys[0]
+            data_criteria.value = HQMF::Coded.new('CD','Administrative Sex',value_set[key].first)
+          else
+            data_criteria.inline_code_list = value_set
+          end
+          
+        elsif (data_criteria.type == :characteristic)
+          if (codes)
+            value_set = codes[data_criteria.code_list_id]
+            if (value_set)
+              # this is looking for a birthdate characteristic that is set as a generic characteristic but points to a loinc code set
+              if (value_set['LOINC'] and value_set['LOINC'].first == '21112-8')
+                data_criteria.definition = 'patient_characteristic_birthdate'
+              end
+              # this is looking for a gender characteristic that is set as a generic characteristic
+              gender_key = (value_set.keys.select {|set| set == 'Administrative Sex' || set == 'AdministrativeSex'}).first
+              if (gender_key and ['M','F'].include? value_set[gender_key].first)
+                data_criteria.definition = 'patient_characteristic_gender'
+                data_criteria.value = HQMF::Coded.new('CD','Gender',value_set[gender_key].first)
+              end
+            end
+          end
+
+        end
+      end
+    end
+    
+
+    def self.parse_measure_period(json)
+      
+      # Create a new HQMF::EffectiveTime
+      # @param [Value] low
+      # @param [Value] high
+      # @param [Value] width
+      # ----------
+      # Create a new HQMF::Value
+      # @param [String] type
+      # @param [String] unit
+      # @param [String] value
+      # @param [String] inclusive
+      # @param [String] derived
+      # @param [String] expression
+      
+      low = HQMF::Value.new('TS',nil, '201201010000',nil, nil, nil)
+      high = HQMF::Value.new('TS',nil,'201212312359',nil, nil, nil)
+      width = HQMF::Value.new('PQ','a','1',nil, nil, nil)
+      
+#      puts ('need to figure out a way to make dates dynamic')
+      
+      HQMF::EffectiveTime.new(low,high,width)
+    end
+    
+    def self.validate(document,codes)
+      puts "\t(#{document.id})document is nil!!!!!!!!!!!" unless document
+      puts "\t(#{document.id})codes are nil!!!!!!!!!!!" unless codes
+      return unless document and codes
+      
+      referenced_oids = document.all_data_criteria.map(&:code_list_id).compact.uniq
+      
+      referenced_oids.each do |oid|
+        value_set = codes[oid]
+        puts "\tDC (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+      end
+      
+      oid_values = document.all_data_criteria.select {|dc| dc.value != nil and dc.value.type == 'CD'}
+      
+      if oid_values.size > 0
+        referenced_oids = (oid_values.map {|dc| dc.value.code_list_id }).compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tVALUE (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+      
+      
+      oid_negation = document.all_data_criteria.select {|dc| dc.negation_code_list_id != nil}
+      if oid_negation.size > 0
+        referenced_oids = (oid_negation.map {|dc| dc.negation_code_list_id}).compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tNEGATION (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+        
+      oid_fields = document.all_data_criteria.select {|dc| dc.field_values != nil}
+      if oid_fields.size > 0
+        referenced_oids = (oid_fields.map{|dc| dc.field_values.map {|key,field| puts "field: #{key} is nil" unless field || key.match(/DATETIME/); field.code_list_id if field != nil and field.type == 'CD'}}).flatten.compact.uniq
+        referenced_oids.each do |oid|
+          value_set = codes[oid]
+          puts "\tFIELDS (#{document.id},#{document.title}): referenced OID could not be found #{oid}" unless value_set
+        end
+      end
+      
+    end
+
+   
+  end  
+end

data/lib/hqmf-parser/converter/pass1/population_criteria_converter.rb

@@ -0,0 +1,165 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PopulationCriteriaConverter
+    
+    attr_reader :sub_measures
+    
+    def initialize(doc, data_criteria_converter)
+      @doc = doc
+      @data_criteria_converter = data_criteria_converter
+      @population_criteria_by_id = {}
+      @population_criteria_by_key = {}
+      @population_reference = {}
+      parse()
+      build_sub_measures()
+    end
+    
+    def population_criteria
+      @population_criteria_by_key.values
+    end
+    
+    private 
+    
+    def build_sub_measures()
+      @sub_measures = []
+      ipps = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::IPP}
+      denoms = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENOM}
+      nums = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::NUMER}
+      msrpopls = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::MSRPOPL}
+      observs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::OBSERV}
+      excls = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENEX}
+      denexcs = @population_criteria_by_id.select {|key, value| value.type == HQMF::PopulationCriteria::DENEXCEP}
+      
+      if (ipps.size<=1 and denoms.size<=1 and nums.size<=1 and excls.size<=1 and denexcs.size<=1 and msrpopls.size<=1 and observs.size<=1 )
+        sub_measure = {}
+          
+        sub_measure[HQMF::PopulationCriteria::IPP] = HQMF::PopulationCriteria::IPP if ipps.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENOM] = HQMF::PopulationCriteria::DENOM if denoms.size > 0
+        sub_measure[HQMF::PopulationCriteria::NUMER] = HQMF::PopulationCriteria::NUMER if nums.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENEXCEP] = HQMF::PopulationCriteria::DENEXCEP if denexcs.size > 0
+        sub_measure[HQMF::PopulationCriteria::DENEX] = HQMF::PopulationCriteria::DENEX if excls.size > 0
+        sub_measure[HQMF::PopulationCriteria::MSRPOPL] = HQMF::PopulationCriteria::MSRPOPL if msrpopls.size > 0
+        sub_measure[HQMF::PopulationCriteria::OBSERV] = HQMF::PopulationCriteria::OBSERV if observs.size > 0
+          
+        @sub_measures << sub_measure
+      else
+
+        nums.each do |num_id, num|
+          @sub_measures << {HQMF::PopulationCriteria::NUMER => num.id}
+        end
+        msrpopls.each do |popl_id, popl|
+          @sub_measures << {HQMF::PopulationCriteria::MSRPOPL => popl.id}
+        end
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENOM, denoms.values)
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::IPP, ipps.values)
+        
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENEX, excls.values, HQMF::PopulationCriteria::IPP,  get_unmatched_population_keys(ipps, excls))
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::DENEXCEP, denexcs.values, HQMF::PopulationCriteria::DENOM,  get_unmatched_population_keys(denoms, denexcs))
+
+        apply_to_submeasures(@sub_measures, HQMF::PopulationCriteria::OBSERV, observs.values)
+        
+        keep = []
+        
+        @sub_measures.each do |sub|
+          
+          value = sub
+          HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |type|
+            key = sub[type]
+            if (key)
+              reference_id = @population_reference[key]
+              reference = @population_criteria_by_id[reference_id] if reference_id
+              if (reference)
+                criteria = @population_criteria_by_key[sub[reference.type]]
+                value['stratification'] = criteria.stratification_id if criteria.stratification_id
+                value = nil if (sub[reference.type] != reference.id and criteria.stratification_id.nil?)
+              end
+            end
+          end
+          keep << value if (value)
+        end
+        
+        keep.each_with_index do |sub, i|
+          sub['title'] = "Population #{i+1}"
+          sub['id'] = "Population#{i+1}"
+        end
+        
+        @sub_measures = keep
+        
+      end
+    end
+    
+    # source are things like exceptions or exclusions, target are IPP, or denom
+    # we want to find any denoms or IPPs that do not have exceptions or exclusions
+    def get_unmatched_population_keys(target, source)
+      return [] if target.length == source.length
+      all_target_keys = target.values.map(&:id)
+      with_ref_keys = source.values.map(&:id).map {|key| @population_criteria_by_id[@population_reference[key]].id if @population_criteria_by_id[@population_reference[key]]}
+      # if we have a population without a reference, we cannot trust the results.
+      return [] if with_ref_keys.include? nil
+      all_target_keys - with_ref_keys
+    end
+    
+    # create a copy of each submeasre adding on the new values of the given type
+    # skip the unpaired values.  Unpaired values are denominators without exclusions or populations without exceptions
+    def apply_to_submeasures(subs, type, values, unpaired_type=nil, unpaired_keys=[])
+      new_subs = []
+      subs.each do |sub|
+        # this unless prevents us from forcing an exclusion or excepion onto a measure that has a submeasure without 
+        # an exclusion or exception, but other populations with an exclusion or excepion.
+        unless unpaired_keys.include? sub[unpaired_type]
+          # duplicate each new value if it is set, otherwise set this key on each submeasure.
+          values.each do |value|
+            if (sub[type] and sub[type] != value.id)
+              tmp = {}
+              HQMF::PopulationCriteria::ALL_POPULATION_CODES.each do |key|
+                tmp[key] = sub[key] if sub[key]
+              end
+              sub = tmp
+              new_subs << sub
+            end
+            sub[type] = value.id
+          end
+        end
+      end
+      subs.concat(new_subs)
+    end
+    
+    def find_sub_measures(type, value)
+      found = []
+      @sub_measures.each do |sub_measure|
+        found << sub_measure if sub_measure[type] and sub_measure[type] == value.id
+      end
+      found
+    end
+
+    def parse
+      @doc[:logic].each do |key,criteria|
+        @population_criteria_by_key[key] = convert(key.to_s, criteria)
+      end
+    end
+   
+    def convert(key, population_criteria)
+      
+      # @param [String] id
+      # @param [Array#Precondition] preconditions 
+      
+      preconditions = HQMF::PreconditionConverter.parse_preconditions(population_criteria[:preconditions],@data_criteria_converter) 
+      hqmf_id = population_criteria[:hqmf_id] || population_criteria[:id]
+      id = population_criteria[:id]
+      type = population_criteria[:code]
+      reference = population_criteria[:reference]
+      title = population_criteria[:title]
+
+      criteria = HQMF::Converter::SimplePopulationCriteria.new(key, hqmf_id, type, preconditions, title)
+      # mark the 2.0 simple population criteria as a stratification... this allows us to create the cartesian product for this in the populations
+      criteria.stratification_id = population_criteria[:stratification_id]
+      
+      @population_criteria_by_id[id] = criteria
+      @population_reference[key] = reference
+      
+      criteria
+     
+    end
+   
+  end  
+end

data/lib/hqmf-parser/converter/pass1/precondition_converter.rb

@@ -0,0 +1,173 @@
+module HQMF
+  # Class for converting an HQMF 1.0 representation to an HQMF 2.0 representation
+  class PreconditionConverter
+    
+    def self.parse_preconditions(source,data_criteria_converter)
+
+      # preconditions = []
+      # source.each do |precondition|
+      #   preconditions << HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+      # end
+      # 
+      # preconditions
+      
+      parse_and_merge_preconditions(source,data_criteria_converter)
+    end
+   
+    # converts a precondtion to a hqmf model
+    def self.parse_precondition(precondition,data_criteria_converter)
+      
+      # grab child preconditions, and parse recursively
+      preconditions = parse_and_merge_preconditions(precondition[:preconditions],data_criteria_converter) if precondition[:preconditions] || []
+      
+      preconditions_from_restrictions = HQMF::PreconditionExtractor.extract_preconditions_from_restrictions(precondition[:restrictions], data_criteria_converter)
+      
+      # driv preconditions are preconditions that are the children of an expression
+      driv_preconditions = []
+      preconditions_from_restrictions.delete_if {|element| driv_preconditions << element if element.is_a? HQMF::Converter::SimpleRestriction and element.operator.type == 'DRIV'}
+      
+      apply_restrictions_to_comparisons(preconditions, preconditions_from_restrictions) unless preconditions_from_restrictions.empty?
+
+      conjunction_code = convert_logical_conjunction(precondition[:conjunction])
+
+      if (precondition[:expression])
+        # this is for things like COUNT
+        type = precondition[:expression][:type]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, HQMF::Converter::SimpleOperator.parse_value(precondition[:expression][:value]))
+        children = []
+        if driv_preconditions and !driv_preconditions.empty?
+          children = driv_preconditions.map(&:preconditions).flatten
+        end
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        comparison_precondition.subset_comparison = true
+        preconditions << comparison_precondition
+      end
+      
+      reference = nil
+      
+      negation = precondition[:negation]
+      
+      
+      if (precondition[:comparison])
+        preconditions ||= []
+        comparison_precondition = HQMF::PreconditionExtractor.convert_comparison_to_precondition(precondition[:comparison],data_criteria_converter)
+        preconditions << comparison_precondition
+      end
+
+
+      if (precondition[:subset])
+        # this is for things like FIRST on preconditions
+        type = precondition[:subset]
+        operator = HQMF::Converter::SimpleOperator.new(HQMF::Converter::SimpleOperator.find_category(type), type, nil)
+        children = preconditions
+        
+        reference = nil
+        # take the conjunction code from the parent precondition
+        
+        restriction = HQMF::Converter::SimpleRestriction.new(operator, nil, children)
+        
+        comparison_precondition = HQMF::Converter::SimplePrecondition.new(nil,[restriction],reference,conjunction_code, false)
+        comparison_precondition.klass = HQMF::Converter::SimplePrecondition::COMPARISON
+        preconditions = [comparison_precondition]
+      end
+
+      
+      HQMF::Converter::SimplePrecondition.new(nil,preconditions,reference,conjunction_code, negation)
+      
+    end
+
+    def self.get_comparison_preconditions(preconditions)
+      comparisons = []
+      preconditions.each do |precondition|
+        if (precondition.comparison? and !precondition.subset_comparison)
+          comparisons << precondition
+        elsif(precondition.has_preconditions?)
+          comparisons.concat(get_comparison_preconditions(precondition.preconditions))
+        else
+          raise "precondition with no comparison or children... not valid"
+        end
+      end
+      comparisons
+    end
+
+    def self.apply_restrictions_to_comparisons(preconditions, restrictions)
+      comparisons = get_comparison_preconditions(preconditions)
+      raise "no comparisons to apply restriction to" if comparisons.empty?
+      comparisons.each do |comparison|
+        comparison.preconditions.concat(restrictions)
+      end
+    end
+    
+    private 
+    
+    
+    def self.parse_and_merge_preconditions(source,data_criteria_converter)
+      return [] unless source and source.size > 0
+      preconditions_by_conjunction = {}
+      source.each do |precondition|
+        parsed = HQMF::PreconditionConverter.parse_precondition(precondition,data_criteria_converter)
+        preconditions_by_conjunction[parsed.conjunction_code] ||= []
+        preconditions_by_conjunction[parsed.conjunction_code]  << parsed
+      end
+      
+      merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+    end
+    
+    def self.merge_precondtion_conjunction_groups(preconditions_by_conjunction)
+      joined = []
+      preconditions_by_conjunction.each do |conjunction_code, preconditions|
+        sub_conditions = []
+        negated_conditions = []
+        preconditions.each do |precondition|
+          unless (precondition.negation)
+            sub_conditions.concat precondition.preconditions if precondition.preconditions
+          else
+            negated_conditions.concat precondition.preconditions if precondition.preconditions
+          end
+        end
+        
+        if (!sub_conditions.empty?)
+          # if we have negated conditions, add them to a new precondition with an inverted conjunction on a negated precondition
+          # the reason we invert the conjunction is because we are turning 
+          # AND: NOT X
+          # AND: NOT Y
+          # into 
+          # NOT: X OR Y
+          # (i.e, demorgan's law)
+          if (!negated_conditions.empty?)
+            inverted_conjunction_code = HQMF::Precondition::INVERSIONS[conjunction_code]
+            sub_conditions << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,inverted_conjunction_code, true)
+          end
+          joined << HQMF::Converter::SimplePrecondition.new(nil,sub_conditions,nil,conjunction_code, false)
+        elsif (!negated_conditions.empty?)
+          # invert conjunction based on demorgan's law
+          inverted_conjunction_code = HQMF::Precondition::INVERSIONS[conjunction_code]
+          joined << HQMF::Converter::SimplePrecondition.new(nil,negated_conditions,nil,inverted_conjunction_code, true)
+        end
+        
+      end
+      joined
+    end
+    
+    def self.convert_logical_conjunction(code)
+      case code
+        when 'OR'
+          HQMF::Precondition::AT_LEAST_ONE_TRUE
+        when 'AND'
+          HQMF::Precondition::ALL_TRUE
+        else
+          raise "unsupported logical conjunction code conversion: #{code}"
+      end
+      
+    end
+    
+   
+  end  
+end