health-data-standards 3.4.6 → 3.5.0

data/lib/hqmf-parser/1.0/attribute.rb

@@ -61,8 +61,61 @@ module HQMF1
     end
     
     def to_json
-      {self.const_name => build_hash(self, [:code,:value,:unit,:name,:id])}
+      json = {self.const_name => build_hash(self, [:code,:value,:unit,:name,:id])}
+      extend_json_for_enhanced_model(json)
+    end
+
+    private
+
+    def extend_json_for_enhanced_model(json)
+      if (@entry.at_xpath('./cda:id'))
+        json[self.const_name][:id_obj] = id_xml_to_json('./cda:id')
+      end
+
+      if (@entry.at_xpath('./cda:code'))
+        json[self.const_name][:code_obj] = code_xml_to_json('./cda:code')
+      end
+
+      if (@entry.at_xpath('./cda:value'))
+        value_hash = { :type => attr_val('./cda:value/@xsi:type')}
+        case value_hash[:type]
+        when 'II'
+          value_hash.merge!(id_xml_to_json('./cda:value'))
+        when 'CD'
+          value_hash.merge!(code_xml_to_json('./cda:value'))
+        when 'ED'
+          value_hash[:value] = @entry.at_xpath('./cda:value').inner_text
+          value_hash[:media_type] = attr_val('./cda:value/@mediaType')
+        else
+          if (attr_val('./cda:value/@value'))
+            value_hash.merge!(HQMF1::Value.new(@entry.at_xpath('./cda:value')).to_json)
+            value_hash[:expression] = @entry.at_xpath('./cda:value/cda:expression').try(:inner_text).try(:strip)
+          else
+            value_hash[:value] = @entry.at_xpath('./cda:value').inner_text.try(:strip)
+          end
+        end
+        json[self.const_name][:value_obj] = value_hash
+      end
+      json
+    end
+
+    def id_xml_to_json(entry_xpath)
+      {
+        :root => attr_val("#{entry_xpath}/@root"),
+        :extension => attr_val("#{entry_xpath}/@extension")
+      }
+    end
+
+    def code_xml_to_json(entry_xpath)
+      {
+        :type => attr_val("#{entry_xpath}/@xsi:type") || 'CD',
+        :system => attr_val("#{entry_xpath}/@codeSystem"),
+        :code => attr_val("#{entry_xpath}/@code"),
+        :code_list_id => attr_val("#{entry_xpath}/@valueSet"),
+        :title => attr_val("#{entry_xpath}/@displayName"),
+        :null_flavor => attr_val("#{entry_xpath}/@nullFlavor"),
+        :original_text => @entry.at_xpath("#{entry_xpath}/cda:originalText").try(:inner_text)
+      }
     end
-    
   end
 end

data/lib/hqmf-parser/1.0/document.rb

@@ -26,36 +26,22 @@ module HQMF1
       @attributes = @doc.xpath('//cda:subjectOf/cda:measureAttribute').collect do |attr|
         Attribute.new(attr)
       end
-      @population_criteria = @doc.xpath('//cda:section[cda:code/@code="57026-7"]/cda:entry').collect do |attr|
-        PopulationCriteria.new(attr, self)
+      @population_criteria = @doc.xpath('//cda:section[cda:code/@code="57026-7"]/cda:entry').collect do |criteria|
+        PopulationCriteria.new(criteria, self)
       end
-      observations = @doc.xpath('//cda:section[cda:code/@code="57027-5"]/cda:entry').collect do |attr|
-        Observation.new(attr, self)
+      observations = @doc.xpath('//cda:section[cda:code/@code="57027-5"]/cda:entry').collect do |observation|
+        Observation.new(observation, self)
       end
       @population_criteria.concat(observations)
 
-      @stratification = @doc.xpath('//cda:section[cda:code/@code="69669-0"]/cda:entry').collect do |attr|
-        PopulationCriteria.new(attr, self)
+      @stratification = @doc.xpath('//cda:section[cda:code/@code="69669-0"]/cda:entry').collect do |strat|
+        PopulationCriteria.new(strat, self)
       end
       
       if (@stratification and !@stratification.empty?)
-        initial_populations = @population_criteria.select {|pc| pc.code.starts_with? 'IPP'}
-        initial_populations.each do |population|
-          
-          @stratification.each do |stratification|
-            new_population = HQMF1::PopulationCriteria.new(population.entry, population.doc)
-            new_population.hqmf_id = new_population.id
-            new_population.stratification_id = stratification.id
-            new_population.id = "#{new_population.id}_#{stratification.id}"
-            ids = stratification.preconditions.map(&:id)
-            new_population.preconditions.delete_if {|precondition| ids.include? precondition.id}
-            new_population.preconditions.concat(stratification.preconditions)
-            new_population.preconditions.rotate!(-1*stratification.preconditions.size)
-            @population_criteria << new_population
-          end
-          
+        @stratification.each do |stratification|
+          @population_criteria << stratification
         end
-        
       end
       
       @hqmf_set_id = @doc.at_xpath('//cda:setId/@root').value.upcase
@@ -136,7 +122,7 @@ module HQMF1
     # Parse an XML document from the supplied contents
     # @return [Nokogiri::XML::Document]
     def self.parse(hqmf_contents)
-      doc = Nokogiri::XML(hqmf_contents)
+      doc = hqmf_contents.kind_of?(Nokogiri::XML::Document) ? hqmf_contents : Nokogiri::XML(hqmf_contents)
       doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
       doc
     end
@@ -169,6 +155,7 @@ module HQMF1
         json[:data_criteria].merge! criteria_json
       end
       
+      # TODO: Investigate why we never use json[:attributes] in the model
       json[:metadata] = {}
       json[:attributes] = {}
       @attributes.each do |attribute|

data/lib/hqmf-parser/1.0/population_criteria.rb

@@ -26,10 +26,10 @@ module HQMF1
     # Get the code for the population criteria
     # @return [String] the code (e.g. IPP, DEMON, NUMER, DENEX, DENEXCEP)
     def code
-      value = attr_val('cda:observation/cda:value/@code')
+      value = attr_val('cda:observation/cda:value/@code') || HQMF::PopulationCriteria::STRAT
       # exclusion population criteria has id of DENOM with actionNegationInd of true
       # special case this to simply handling
-      if attr_val('cda:observation/@actionNegationInd')=='true'
+      if attr_val('cda:observation/@actionNegationInd')=='true' && value == HQMF::PopulationCriteria::DENOM
         value = HQMF::PopulationCriteria::DENEX
       end
       value.upcase

data/lib/hqmf-parser/1.0/range.rb

@@ -50,7 +50,6 @@ module HQMF1
         if (@low == nil && @high == nil)
           @low = optional_value('.',true)
           @high = optional_value('.',true)
-          puts "\tfound = relationship parsing temporal reference (bugfix)"
         end
       end
     end

data/lib/hqmf-parser/2.0/data_criteria.rb

@@ -8,14 +8,26 @@ module HQMF2
     attr_reader :temporal_references, :subset_operators, :children_criteria 
     attr_reader :derivation_operator, :negation, :negation_code_list_id, :description
     attr_reader :field_values, :source_data_criteria, :specific_occurrence_const
-    attr_reader :specific_occurrence, :is_source_data_criteria
-  
+    attr_reader :specific_occurrence, :is_source_data_criteria, :comments
+
+    VARIABLE_TEMPLATE = "0.1.2.3.4.5.6.7.8.9.1"
+    SATISFIES_ANY_TEMPLATE = "0.1.2.3.4.5.6.7.8.9.2"
+    SATISFIES_ALL_TEMPLATE = "0.1.2.3.4.5.6.7.8.9.3"
+
+    CONJUNCTION_CODE_TO_DERIVATION_OP = {
+      'OR' => 'UNION',
+      'AND' => 'XPRODUCT'
+    }
+    
+    CRITERIA_GLOB = "*[substring(name(),string-length(name())-7) = \'Criteria\']"
+
     # Create a new instance based on the supplied HQMF entry
     # @param [Nokogiri::XML::Element] entry the parsed HQMF entry
     def initialize(entry)
       @entry = entry
+      @local_variable_name = extract_local_variable_name
       @status = attr_val('./*/cda:statusCode/@code')
-      @description = attr_val('./*/cda:text/@value')
+      @description = attr_val("./#{CRITERIA_GLOB}/cda:text/@value")
       extract_negation()
       extract_specific_or_source()
       @effective_time = extract_effective_time
@@ -24,10 +36,12 @@ module HQMF2
       @field_values = extract_field_values
       @subset_operators = extract_subset_operators
       @children_criteria = extract_child_criteria
-      @id_xpath = './*/cda:id/cda:item/@extension'
+      @id_xpath = './*/cda:id/@extension'
       @code_list_xpath = './*/cda:code'
       @value_xpath = './*/cda:value'
-      
+      @comments = @entry.xpath("./#{CRITERIA_GLOB}/cda:text/cda:xml/cda:qdmUserComments/cda:item/text()", HQMF2::Document::NAMESPACES).map{ |v| v.content }
+      @variable = false
+
       # Try to determine what kind of data criteria we are dealing with
       # First we look for a template id and if we find one just use the definition
       # status and negation associated with that
@@ -46,9 +60,11 @@ module HQMF2
       # criteria
       # Assumes @definition and @status are already set
       case @definition
+      when 'transfer_to', 'transfer_from'
+        @code_list_xpath = './cda:observationCriteria/cda:value'
       when 'diagnosis', 'diagnosis_family_history'
         @code_list_xpath = './cda:observationCriteria/cda:value'
-      when 'risk_category_assessment', 'procedure_result', 'laboratory_test', 'diagnostic_study_result', 'functional_status_result', 'intervention_result'
+      when 'physical_exam', 'risk_category_assessment', 'procedure_result', 'laboratory_test', 'diagnostic_study_result', 'functional_status_result', 'intervention_result'
         @value = extract_value
       when 'medication'
         case @status
@@ -64,7 +80,19 @@ module HQMF2
       end
     end
 
+    def extract_local_variable_name
+      lvn = @entry.at_xpath("./cda:localVariableName")
+      lvn["value"] if lvn
+    end
+
     def extract_type_from_definition
+      if @entry.at_xpath("./cda:grouperCriteria") 
+        if @local_variable_name && @local_variable_name.match(/qdm_/)
+          @variable = true
+        end
+        @definition = 'derived'
+        return 
+      end
       # See if we can find a match for the entry definition value and status.
       entry_type = attr_val('./*/cda:definition/*/cda:id/@extension')
       begin
@@ -110,16 +138,33 @@ module HQMF2
       if template_ids.include?(HQMF::DataCriteria::SOURCE_DATA_CRITERIA_TEMPLATE_ID)
         @is_source_data_criteria = true
       end
+      found = false
       template_ids.each do |template_id|
         defs = HQMF::DataCriteria.definition_for_template_id(template_id)
+        
         if defs
           @definition = defs['definition']
           @status = defs['status'].length > 0 ? defs['status'] : nil
           @negation = defs['negation']
+          found ||= true
+        elsif template_id == VARIABLE_TEMPLATE
+          @derivation_operator = HQMF::DataCriteria::INTERSECT if @derivation_operator == HQMF::DataCriteria::XPRODUCT
+          @definition ||= 'derived'
+          @negation = false
+          @variable = true
+          found ||= true
+        elsif template_id == SATISFIES_ANY_TEMPLATE
+          @definition = HQMF::DataCriteria::SATISFIES_ANY
+          @negation = false
           return true
+        elsif template_id == SATISFIES_ALL_TEMPLATE
+          @definition = HQMF::DataCriteria::SATISFIES_ALL
+          @derivation_operator = HQMF::DataCriteria::INTERSECT
+          @negation = false
+          found ||= true
         end
       end
-      false
+      found
     end
     
     def to_s
@@ -141,7 +186,12 @@ module HQMF2
     # Get the title of the criteria, provides a human readable description
     # @return [String] the title of this data criteria
     def title
-      attr_val("#{@code_list_xpath}/cda:displayName/@value") || id
+      dispValue = attr_val("#{@code_list_xpath}/cda:displayName/@value") 
+      desc = nil
+      if @description && (@description.include? ":")
+         desc = @description.match(/.*:\s+(.+)/)[1]
+      end
+      dispValue || desc || id
     end
     
     # Get the code list OID of the criteria, used as an index to the code list database
@@ -166,6 +216,7 @@ module HQMF2
     end
     
     def to_model
+
       mv = value ? value.to_model : nil
       met = effective_time ? effective_time.to_model : nil
       mtr = temporal_references.collect {|ref| ref.to_model}
@@ -174,11 +225,23 @@ module HQMF2
       @field_values.each_pair do |id, val|
         field_values[id] = val.to_model
       end
-      
+
+      # Model transfers as a field
+      if ['transfer_to', 'transfer_from'].include? @definition 
+        field_values ||= {}
+        field_code_list_id = @code_list_id
+        if !field_code_list_id
+          field_code_list_id = attr_val("./#{CRITERIA_GLOB}/cda:outboundRelationship/#{CRITERIA_GLOB}/cda:value/@valueSet")
+        end
+        field_values[@definition.upcase] = HQMF::Coded.for_code_list(field_code_list_id, title)
+      end
+
+      field_values = nil if field_values.empty?
+
       HQMF::DataCriteria.new(id, title, nil, description, code_list_id, children_criteria, 
         derivation_operator, @definition, status, mv, field_values, met, inline_code_list, 
         @negation, @negation_code_list_id, mtr, mso, @specific_occurrence, 
-        @specific_occurrence_const, @source_data_criteria)
+        @specific_occurrence_const, @source_data_criteria, @comments, @variable)
     end
     
     private
@@ -194,7 +257,7 @@ module HQMF2
     end
     
     def extract_child_criteria
-      @entry.xpath('./*/cda:excerpt/*/cda:id', HQMF2::Document::NAMESPACES).collect do |ref|
+      @entry.xpath("./*/cda:outboundRelationship[@typeCode='COMP']/cda:criteriaReference/cda:id", HQMF2::Document::NAMESPACES).collect do |ref|
         Reference.new(ref).id
       end.compact
     end
@@ -215,11 +278,11 @@ module HQMF2
     end
     
     def extract_derivation_operator
-      derivation_operators = all_subset_operators.select do |operator|
-        ['UNION', 'XPRODUCT'].include?(operator.type)
+      codes = @entry.xpath("./*/cda:outboundRelationship[@typeCode='COMP']/cda:conjunctionCode/@code", HQMF2::Document::NAMESPACES)
+      codes.inject(nil) do | d_op, code |
+        raise "More than one derivation operator in data criteria" if d_op && d_op != CONJUNCTION_CODE_TO_DERIVATION_OP[code.value]
+        CONJUNCTION_CODE_TO_DERIVATION_OP[code.value]
       end
-      raise "More than one derivation operator in data criteria" if derivation_operators.size>1
-      derivation_operators.first ? derivation_operators.first.type : nil
     end
     
     def extract_subset_operators
@@ -229,14 +292,18 @@ module HQMF2
     end
     
     def extract_specific_or_source
-      specific_def = @entry.at_xpath('./*/cda:outboundRelationship[cda:subsetCode/@code="SPECIFIC"]', HQMF2::Document::NAMESPACES)
+      specific_def = @entry.at_xpath('./*/cda:outboundRelationship[@typeCode="OCCR"]', HQMF2::Document::NAMESPACES)
       source_def = @entry.at_xpath('./*/cda:outboundRelationship[cda:subsetCode/@code="SOURCE"]', HQMF2::Document::NAMESPACES)
       if specific_def
-        @source_data_criteria = HQMF2::Utilities.attr_val(specific_def, './cda:observationReference/cda:id/@extension')
+        @source_data_criteria = HQMF2::Utilities.attr_val(specific_def, './cda:criteriaReference/cda:id/@extension')
         @specific_occurrence_const = HQMF2::Utilities.attr_val(specific_def, './cda:localVariableName/@controlInformationRoot')
         @specific_occurrence = HQMF2::Utilities.attr_val(specific_def, './cda:localVariableName/@controlInformationExtension')
+        if !@specific_occurrence
+          @specific_occurrence = "A"
+          @specific_occurrence_const = @source_data_criteria.upcase
+        end
       elsif source_def
-        @source_data_criteria = HQMF2::Utilities.attr_val(source_def, './cda:observationReference/cda:id/@extension')
+        @source_data_criteria = HQMF2::Utilities.attr_val(source_def, './cda:criteriaReference/cda:id/@extension')
       end
     end
     
@@ -247,14 +314,14 @@ module HQMF2
         code = HQMF2::Utilities.attr_val(field, './*/cda:code/@code')
         code_id = HQMF::DataCriteria::VALUE_FIELDS[code]
         value = DataCriteria.parse_value(field, './*/cda:value')
-        fields[code_id] = value
+        fields[code_id] = value if value && code_id
       end
       # special case for facility location which uses a very different structure
       @entry.xpath('./*/cda:outboundRelationship[*/cda:participation]', HQMF2::Document::NAMESPACES).each do |field|
         code = HQMF2::Utilities.attr_val(field, './*/cda:participation/cda:role/@classCode')
         code_id = HQMF::DataCriteria::VALUE_FIELDS[code]
         value = Coded.new(field.at_xpath('./*/cda:participation/cda:role/cda:code', HQMF2::Document::NAMESPACES))
-        fields[code_id] = value
+        fields[code_id] = value if value && code_id
       end
       fields
     end
@@ -277,6 +344,8 @@ module HQMF2
         if value_type_def
           value_type = value_type_def.value
           case value_type
+          when 'PQ'
+            value = Value.new(value_def, 'PQ', true)
           when 'TS'
             value = Value.new(value_def)
           when 'IVL_PQ', 'IVL_INT'
@@ -316,4 +385,4 @@ module HQMF2
 
   end
   
-end
+end

data/lib/hqmf-parser/2.0/document.rb

@@ -21,11 +21,64 @@ module HQMF2
       
       # Extract measure attributes
       @attributes = @doc.xpath('/cda:QualityMeasureDocument/cda:subjectOf/cda:measureAttribute', NAMESPACES).collect do |attribute|
-        id = attribute.at_xpath('./cda:id/@extension', NAMESPACES).try(:value)
+        id = attribute.at_xpath('./cda:id/@root', NAMESPACES).try(:value)
         code = attribute.at_xpath('./cda:code/@code', NAMESPACES).try(:value)
         name = attribute.at_xpath('./cda:code/cda:displayName/@value', NAMESPACES).try(:value)
         value = attribute.at_xpath('./cda:value/@value', NAMESPACES).try(:value)
-        HQMF::Attribute.new(id, code, value, nil, name)
+
+        id_obj = nil
+        if attribute.at_xpath('./cda:id', NAMESPACES)
+          id_obj = HQMF::Identifier.new(attribute.at_xpath('./cda:id/@xsi:type', NAMESPACES).try(:value), id, attribute.at_xpath('./cda:id/@extension', NAMESPACES).try(:value))
+        end
+
+        code_obj = nil;
+        if attribute.at_xpath('./cda:code', NAMESPACES)
+          nullFlavor = attribute.at_xpath('./cda:code/@nullFlavor', NAMESPACES).try(:value)
+          oText = attribute.at_xpath('./cda:code/cda:originalText', NAMESPACES) ? attribute.at_xpath('./cda:code/cda:originalText/@value', NAMESPACES).try(:value) : nil
+          code_obj = HQMF::Coded.new(attribute.at_xpath('./cda:code/@xsi:type', NAMESPACES).try(:value) || 'CD',
+                                 attribute.at_xpath('./cda:code/@codeSystem', NAMESPACES).try(:value),
+                                 code,
+                                 attribute.at_xpath('./cda:code/@valueSet', NAMESPACES).try(:value),
+                                 name,
+                                 nullFlavor,
+                                 oText)
+
+
+          # Mapping for nil values to align with 1.0 parsing
+          if code == nil
+            code = nullFlavor
+          end
+
+          if name == nil
+            name = oText
+          end
+
+        end
+
+        value_obj = nil
+        if attribute.at_xpath('./cda:value', NAMESPACES)
+          type = attribute.at_xpath('./cda:value/@xsi:type', NAMESPACES).try(:value)
+          case type
+          when 'II'
+            value_obj = HQMF::Identifier.new(type, attribute.at_xpath('./cda:value/@root', NAMESPACES).try(:value), attribute.at_xpath('./cda:value/@extension', NAMESPACES).try(:value))
+            if value == nil
+              value = attribute.at_xpath('./cda:value/@extension', NAMESPACES).try(:value)
+            end
+          when 'ED'
+            value_obj = HQMF::ED.new(type, value, attribute.at_xpath('./cda:value/@mediaType', NAMESPACES).try(:value))
+          when 'CD'
+            value_obj = HQMF::Coded.new('CD', attribute.at_xpath('./cda:value/@codeSystem', NAMESPACES).try(:value), attribute.at_xpath('./cda:value/@code', NAMESPACES).try(:value), attribute.at_xpath('./cda:value/@valueSet', NAMESPACES).try(:value), attribute.at_xpath('./cda:value/cda:displayName/@value', NAMESPACES).try(:value))
+          else
+            value_obj = value.present? ? HQMF::GenericValueContainer.new(type, value) : HQMF::AnyValue.new(type)
+          end
+        end
+
+        # Handle the cms_id
+        if name == "eMeasure Identifier"
+           @cms_id = "CMS#{value}v#{@hqmf_version_number}"
+        end
+
+        HQMF::Attribute.new(id, code, value, nil, name, id_obj, code_obj, value_obj)
       end
       
       # Extract the data criteria
@@ -54,11 +107,13 @@ module HQMF2
         population['stratification'] = stratifier_id_def.value if stratifier_id_def
 
         {
-          HQMF::PopulationCriteria::IPP => 'patientPopulationCriteria',
+          HQMF::PopulationCriteria::IPP => 'initialPopulationCriteria',
           HQMF::PopulationCriteria::DENOM => 'denominatorCriteria',
           HQMF::PopulationCriteria::NUMER => 'numeratorCriteria',
           HQMF::PopulationCriteria::DENEXCEP => 'denominatorExceptionCriteria',
-          HQMF::PopulationCriteria::DENEX => 'denominatorExclusionCriteria'
+          HQMF::PopulationCriteria::DENEX => 'denominatorExclusionCriteria',
+          HQMF::PopulationCriteria::STRAT => 'stratifierCriteria',
+          HQMF::PopulationCriteria::MSRPOPL => 'measurePopulationCriteria'
         }.each_pair do |criteria_id, criteria_element_name|
           criteria_def = population_def.at_xpath("cda:component[cda:#{criteria_element_name}]", NAMESPACES)
           
@@ -95,12 +150,50 @@ module HQMF2
             end
           end
         end
+
+
         id_def = population_def.at_xpath('cda:id/@extension', NAMESPACES)
         population['id'] = id_def ? id_def.value : "Population#{population_index}"
         title_def = population_def.at_xpath('cda:title/@value', NAMESPACES)
         population['title'] = title_def ? title_def.value : "Population #{population_index}"
+        observation_section = @doc.xpath('cda:QualityMeasureDocument/cda:component/cda:measureObservationsSection', NAMESPACES)
+        if !observation_section.empty?
+           population['OBSERV'] = 'OBSERV'
+        end
         @populations << population
       end
+
+
+      #look for observation data in separate section but create a population for it if it exists
+      observation_section = @doc.xpath('cda:QualityMeasureDocument/cda:component/cda:measureObservationsSection', NAMESPACES)
+      if !observation_section.empty?
+        observation_section.xpath("cda:definition",NAMESPACES).each do |criteria_def|
+          criteria_id = "OBSERV"
+          population = {}
+          criteria = PopulationCriteria.new(criteria_def, self)
+          criteria.type="OBSERV"
+          # this section constructs a human readable id.  The first IPP will be IPP, the second will be IPP_1, etc.  This allows the populations to be
+          # more readable.  The alternative would be to have the hqmf ids in the populations, which would work, but is difficult to read the populations.
+          if ids_by_hqmf_id["#{criteria.hqmf_id}"]
+             criteria.create_human_readable_id(ids_by_hqmf_id[criteria.hqmf_id])
+          else
+            if population_counters[criteria_id]
+              population_counters[criteria_id] += 1
+              criteria.create_human_readable_id("#{criteria_id}_#{population_counters[criteria_id]}")
+            else
+              population_counters[criteria_id] = 0
+              criteria.create_human_readable_id(criteria_id)
+            end
+            ids_by_hqmf_id["#{criteria.hqmf_id}"] = criteria.id
+          end
+          
+          @population_criteria << criteria
+
+          population[criteria_id] = criteria.id
+          @populations << population
+          end 
+      end
+
     end
     
     # Get the title of the measure
@@ -142,19 +235,41 @@ module HQMF2
       find(@data_criteria, :id, id)
     end
     
-    # Parse an XML document at the supplied path
+   # Parse an XML document from the supplied contents
     # @return [Nokogiri::XML::Document]
     def self.parse(hqmf_contents)
-      doc = Nokogiri::XML(hqmf_contents)
+      doc = hqmf_contents.kind_of?(Nokogiri::XML::Document) ? hqmf_contents : Nokogiri::XML(hqmf_contents)
+      doc.root.add_namespace_definition('cda', 'urn:hl7-org:v3')
       doc
     end
     
     def to_model
+
       dcs = all_data_criteria.collect {|dc| dc.to_model}
       pcs = all_population_criteria.collect {|pc| pc.to_model}
       sdc = source_data_criteria.collect{|dc| dc.to_model}
-      HQMF::Document.new(id, id, hqmf_set_id, hqmf_version_number, nil, title, description, pcs, dcs, sdc, attributes, measure_period.to_model, populations)
+      dcs = update_data_criteria(dcs, sdc)
+      HQMF::Document.new(id, id, hqmf_set_id, hqmf_version_number, @cms_id, title, description, pcs, dcs, sdc, attributes, measure_period.to_model, populations)
+    end
+
+    # Update the data criteria to handle variables properly
+    def update_data_criteria(data_criteria, source_data_criteria)
+       # step through each criteria and look for groupers (type derived) with one child
+       data_criteria.map do |criteria|
+         if criteria.type == "derived".to_sym && criteria.children_criteria.length == 1
+           source_data_criteria.each do |source_criteria|
+             if source_criteria.title == criteria.children_criteria[0]
+               criteria.children_criteria = source_criteria.children_criteria
+               #if criteria.is_same_type?(source_criteria)
+               criteria.update_copy( source_criteria.hard_status, source_criteria.title, source_criteria.description,
+                                     source_criteria.derivation_operator, source_criteria.definition )#, occur_letter )
+             end
+           end
+         end
+         criteria
+       end
     end
+
     
     private