test-patient-generator 1.0.0

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem 'hqmf-parser', '~> 1.0.2'
+gem 'hquery-patient-api', '~> 0.3.0'
+gem 'hqmf2js', '~> 1.0.0'
+gem 'health-data-standards', '~> 2.1.2'
+
+gem 'rake'
+gem 'pry'
+gem 'pry-nav'
+gem 'bson_ext'
+
+group :test do
+  gem 'simplecov'
+end

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/testtask'
+require "simplecov"
+
+Dir['lib/tasks/*.rake'].sort.each do |ext|
+  load ext
+end
+
+Rake::TestTask.new(:test_unit) do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :test => [:test_unit] do
+  system("open coverage/index.html")
+end
+
+task :default => [:test]

data/lib/test-patient-generator.rb

@@ -0,0 +1,18 @@
+require 'hqmf-parser'
+require 'health-data-standards'
+
+require_relative 'tpg/ext/coded'
+require_relative 'tpg/ext/conjunction'
+require_relative 'tpg/ext/data_criteria'
+require_relative 'tpg/ext/derivation_operator'
+require_relative 'tpg/ext/population_criteria'
+require_relative 'tpg/ext/precondition'
+require_relative 'tpg/ext/range'
+require_relative 'tpg/ext/record'
+require_relative 'tpg/ext/subset_operator'
+require_relative 'tpg/ext/temporal_reference'
+require_relative 'tpg/ext/value'
+
+require_relative 'tpg/generation/generator'
+require_relative 'tpg/generation/randomizer'
+require_relative 'tpg/generation/exporter'

data/lib/tpg/ext/coded.rb

@@ -0,0 +1,40 @@
+module HQMF
+  class Coded
+    # Select the relevant value set that matches the given OID and generate a hash that can be stored on a Record.
+    # The hash will be of this format: { "code_set_identified" => [code] }
+    #
+    # @param [String] oid The target value set.
+    # @param [Hash] value_sets Value sets that might contain the OID for which we're searching.
+    # @return A Hash of code sets corresponding to the given oid, each containing one randomly selected code.
+    def self.select_codes(oid, value_sets)
+      value_sets = HQMF::Coded.select_value_sets(oid, value_sets)
+      code_sets = {}
+      value_sets["code_sets"].each do |value_set|
+        code_sets[value_set["code_set"]] = [value_set["codes"].first]
+      end
+      code_sets
+    end
+    
+    def self.select_value_sets(oid, value_sets)
+      # Pick the value set for this DataCriteria. If it can't be found, it is an error from the value set source. We'll add the entry without codes for now.
+      index = value_sets.index{|value_set| value_set["oid"] == oid}
+      value_sets = index.nil? ? { "code_sets" => [] } : value_sets[index]
+      value_sets
+    end
+
+    # Select the relevant value set that matches the given OID and generate a hash that can be stored on a Record.
+    # The hash will be of this format: { "codeSystem" => "code_set_identified", "code" => code }
+    #
+    # @param [String] oid The target value set.
+    # @param [Hash] value_sets Value sets that might contain the OID for which we're searching.
+    # @return A Hash including a code and code system containing one randomly selected code.
+    def self.select_code(oid, value_sets)
+      codes = select_codes(oid, value_sets)
+      codeSystem = codes.keys()[0]
+      {
+        'codeSystem' => codeSystem,
+        'code' => codes[codeSystem][0]
+      }
+    end
+  end
+end

data/lib/tpg/ext/conjunction.rb

@@ -0,0 +1,23 @@
+module Conjunction
+  module AllTrue
+    # 
+    #
+    # @param [Array] base_patients
+    # @return 
+    def generate(base_patients)
+      preconditions.each do |precondition|
+        precondition.generate(base_patients)
+      end
+    end
+  end
+  
+  # 
+  #
+  # @param [Array] base_patients
+  # @return 
+  module AtLeastOneTrue
+    def generate(base_patients)
+      preconditions.sample.generate(base_patients)
+    end
+  end
+end

data/lib/tpg/ext/data_criteria.rb

@@ -0,0 +1,159 @@
+module HQMF
+  class DataCriteria
+    attr_accessor :generation_range, :values
+
+    # Generate all acceptable ranges of values and times for this data criteria. These ranges will then be updated by the permutate function 
+    # and passed to modify_patient to actually augment the base_patients Records.
+    # 
+    # @param [Array] base_patients The list of patients who will be augmented by this data criteria.
+    # @return The updated list of patients. The array will be modified by reference already so this is just for potential convenience.
+    def generate(base_patients)
+      acceptable_times = []
+
+      # Evaluate all of the temporal restrictions on this data criteria.
+      unless temporal_references.nil?
+        # Generate for patients based on each reference and merge the potential times together.
+        temporal_references.each do |reference|
+          acceptable_time = reference.generate(base_patients)
+          acceptable_times = DerivationOperator.intersection(acceptable_time, acceptable_times)
+        end
+      end
+      
+      # Apply any subset operators (e.g. FIRST)
+      # e.g., if the subset operator is THIRD we need to make at least three entries
+      unless subset_operators.nil?
+        subset_operators.each do |subset_operator|
+          subset_operator.generate(base_patients)
+        end
+      end
+      
+      # Apply any derivation operator (e.g. UNION)
+      unless derivation_operator.nil?
+        Range.merge(DerivationOperator.generate(base_patients, children_criteria, derivation_operator), acceptable_times)
+      end
+      
+      # Set the acceptable ranges for this data criteria so any parents can read it
+      @generation_range = acceptable_times
+
+      # Calculate value information
+      acceptable_values = []
+      acceptable_values << value
+      
+      # Walk through all acceptable time/value combinations and alter out patients
+      base_patients.each do |patient|
+        acceptable_times.each do |time|
+          acceptable_values.each do |value|
+            modify_patient(patient, time, Generator.value_sets)
+          end
+        end
+      end
+      
+      base_patients
+    end
+    
+    # 
+    #
+    # @param [Array] acceptable_times
+    # @param [Array] acceptable_values
+    def permutate(acceptable_times, acceptable_values)
+      
+    end
+    
+    # Modify a Record with this data criteria. Acceptable times and values are defined prior to this function.
+    #
+    # @param [Record] patient The Record that is being modified. 
+    # @param [Range] time An acceptable range of times for the coded entry being put on this patient.
+    # @param [Hash] value_sets The value sets that this data criteria references.
+    # @return The modified patient. The passed in patient object will be modified by reference already so this is just for potential convenience.
+    def modify_patient(patient, time, value_sets)
+      # Figure out what kind of data criteria we're looking at
+      if type == :characteristic and property != nil and patient_api_function == nil
+        # We have a special case on our hands.
+        if property == :birthtime
+          patient.birthdate = time.low.to_seconds
+        elsif value.present? && value.system == "Gender"
+          patient.gender = value.code
+          patient.first = Randomizer.randomize_first_name(value.code)
+        elsif property == :clinicalTrialParticipant
+          patient.clinicalTrialParticipant = true
+        end
+      else
+        # Otherwise this is a regular coded entry. Start by choosing the correct type and assigning basic metadata.
+        entry_type = Generator.classify_entry(patient_api_function)
+        entry = entry_type.classify.constantize.new
+        entry.description = "#{description} (Code List: #{code_list_id})"
+        entry.start_time = time.low.to_seconds if time.low
+        entry.end_time = time.high.to_seconds if time.high
+        entry.status = status
+        entry.codes = Coded.select_codes(code_list_id, value_sets)
+        entry.oid = HQMF::DataCriteria.template_id_for_definition(definition, status, negation)
+
+        # If the value itself has a code, it will be a Coded type. Otherwise, it's just a regular value with a unit.
+        if value.present? && !value.is_a?(AnyValue)
+          entry.values ||= []
+          if value.type == "CD"
+            entry.values << CodedResultValue.new({codes: Coded.select_codes(value.code_list_id, value_sets)})
+          else
+            entry.values << PhysicalQuantityResultValue.new(value.format)
+          end
+        end
+        
+        if values.present?
+           entry.values ||= []
+           values.each do |value|
+             if value.type == "CD"
+               entry.values << CodedResultValue.new({codes: Coded.select_codes(value.code_list_id, value_sets), description: Coded.select_value_sets(value.code_list_id, value_sets)['description']})
+             else
+               entry.values << PhysicalQuantityResultValue.new(value.format)
+             end
+           end
+        end
+        
+        # Choose a code from each relevant code vocabulary for this entry's negation, if it is negated and referenced.
+        if negation && negation_code_list_id.present?
+          entry.negation_ind = true
+          entry.negation_reason = Coded.select_code(negation_code_list_id, value_sets)
+        end
+        
+        # Additional fields (e.g. ordinality, severity, etc) seem to all be special cases. Capture them here.
+        if field_values.present?
+          field_values.each do |name, field|
+            next if field.nil?
+            
+            # These fields are sometimes Coded and sometimes Values.
+            if field.type == "CD"
+              codes = Coded.select_codes(field.code_list_id, value_sets)
+            elsif field.type == "IVL_PQ"
+              value = field.format
+            end
+            
+            case name
+            when "ORDINAL"
+              entry.ordinality_code = codes
+            when "FACILITY_LOCATION"
+              entry.facility = Facility.new("name" => field.title, "codes" => codes)
+            when "CUMULATIVE_MEDICATION_DURATION"
+              entry.cumulative_medication_duration = value              
+            when "SEVERITY"
+              entry.severity = codes
+            when "REASON"
+              
+            when "SOURCE"
+
+            end
+          end
+        end
+         
+        # Figure out which section this entry will be added to. Some entry names don't map prettily to section names.
+        section_map = { "lab_results" => "results" }
+        section_name = section_map[entry_type]
+        section_name ||= entry_type
+        # Add the updated section to this patient.
+        section = patient.send(section_name)
+        section.push(entry)
+        
+        patient
+      end
+    end
+  end
+end

data/lib/tpg/ext/derivation_operator.rb

@@ -0,0 +1,49 @@
+module HQMF
+  class DerivationOperator
+    # Perform an intersection between two sets of Ranges (assuming these are timestamps).
+    #
+    # @param [Array] set1 One array of Ranges to be intersected.
+    # @param [Array] set2 The other array of Ranges to be intersected.
+    # @return A new array that contains the shared Ranges between set1 and set2.
+    def self.intersection(set1, set2)
+      # Special cases to account for emptiness
+      return [] if set1.empty? && set2.empty?
+      return set1 if set2.empty?
+      return set2 if set1.empty?
+
+      # Merge each element of the two sets together
+      result = []
+      set1.each do |range1|
+        set2.each do |range2|
+          intersect = range1.intersection(range2)
+          result << intersect unless intersect.nil?
+        end
+      end
+      
+      result
+    end
+    
+    # Perform a union between two sets of Ranges (assuming these are timestamps)
+    #
+    # @param [Array] set1 One array of Ranges to be unioned.
+    # @param [Array] set2 The other array of Ranges to be unioned.
+    # @return A new array tha contains the union of Ranges between set1 and set2.
+    def self.union(set1, set2)
+      # Special cases to account for emptiness
+      return [] if set1.empty? && set2.empty?
+      return set1 if set2.empty?
+      return set2 if set1.empty?
+      
+      # Join each element of the two sets together
+      result = []
+      set1.each do |range1|
+        set2.each do |range2|
+          union = range1.union(range2)
+          result.concat!(union)
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/tpg/ext/population_criteria.rb

@@ -0,0 +1,12 @@
+module HQMF
+  class PopulationCriteria
+    # 
+    #
+    # @param [Array] base_patients
+    # @return
+    def generate(base_patients)
+      # All population criteria begin with a single conjunction precondition
+      preconditions.first.generate(base_patients)
+    end
+  end
+end

data/lib/tpg/ext/precondition.rb

@@ -0,0 +1,23 @@
+module HQMF
+  class Precondition
+    # 
+    #
+    # @param [Array] base_patients
+    # @return 
+    def generate(base_patients)
+      # d = HQMF::Generator.hqmf.data_criteria(preconditions[2].preconditions[1].preconditions.first.reference.id)
+      
+      if conjunction?
+        # Include the matching module to override our generation functions
+        conjunction_module = "Conjunction::#{self.conjunction_code.classify}"
+        conjunction_module = conjunction_module.split('::').inject(Kernel) {|scope, name| scope.const_get(name)}
+
+        extend conjunction_module
+        generate(base_patients)
+      elsif reference
+        data_criteria = HQMF::Generator.hqmf.data_criteria(reference.id)
+        data_criteria.generate(base_patients)
+      end
+    end
+  end
+end

data/lib/tpg/ext/range.rb

@@ -0,0 +1,144 @@
+module HQMF
+  class Range
+    # Perform a deep copy of this Range.
+    #
+    # @return A deep copy of this Range.
+    def clone
+      Range.new(type.try(:clone), low.try(:clone), high.try(:clone), width.try(:clone))
+    end
+    
+    #
+    def format
+      if low
+        low.format
+      elsif high
+        high.format
+      else
+        {}
+      end
+    end
+    
+    # Perform an intersection between this Range and the passed in Range.
+    # There are three potential situations that can happen: disjoint, equivalent, or overlapping.
+    #
+    # @param [Range] range The other Range intersecting this. If it is nil it implies all times are ok (i.e. no restrictions).
+    # @return A new Range that represents the shared amount of time between these two Ranges. nil means there is no common time.
+    def intersection(range)
+      # Return self if nil (the other range has no restrictions) or if it matches the other range (they are equivalent)
+      return self.clone if range.nil?
+      return self.clone if eql?(range)
+
+      # Figure out which range starts later (the more restrictive one)
+      if low <= range.low
+        earlier_start = self
+        later_start = range
+      else
+        earlier_start = range
+        later_start = self
+      end
+      
+      # Return nil if there is no common time (the two ranges are entirely disjoint)
+      return nil unless later_start.contains?(earlier_start.high)
+      
+      # Figure out which ranges ends earlier (the more restrictive one)
+      if high >= range.high
+        earlier_end = self
+        later_end = range
+      else
+        earlier_end = range
+        later_end = self
+      end
+
+      Range.new("TS", later_start.low.clone, earlier_end.high.clone, nil)
+    end
+    
+    # Perform a union between this Range and the passed in Range.
+    # There are three potential situations that can happen: disjoint, equivalent, or overlapping.
+    #
+    # @param [Range] range The other Range unioning this.
+    # @return An array of Ranges. One element if the two ranges are overlapping and can be expressed as one new Range
+    #   or two Ranges if the times are disjoint.
+    def union(range)
+      # Return self if nil (nothing new to add) or if it matches the other range (they are equivalent)
+      return self.clone if range.nil?
+      return self.clone if eql?(range)
+
+      # Figure out which range starts earlier (to capture the most time)
+      if low <= range.low
+        earlier_start = self
+        later_start = range
+      else
+        earlier_start = range
+        later_start = self
+      end
+      
+      # Figure out which ranges ends earlier (the more restrictive one)
+      if high >= range.high
+        earlier_end = self
+        later_end = range
+      else
+        earlier_end = range
+        later_end = self
+      end
+      
+      result = []
+      # We have continuous Ranges so we can return one Range to encapsulate both
+      if earlier_start.contains?(later_start.low)
+        result << Range.new("TS", earlier_start.low.clone, later_end.high.clone, nil)
+      else
+        # The Ranges are disjoint, so we'll need to return two arrays to capture all of the potential times
+        result << Range.new("TS", earlier_start.low.clone, earlier_start.high.clone, nil)
+        result << Range.new("TS", later_start.low.clone, later_start.high.clone, nil)
+      end
+    end
+    
+    # 
+    #
+    # @param [Range] ivl_pq
+    # @return
+    def apply_pq(ivl_pq)
+      
+    end
+    
+    # 
+    #
+    # @param [Range] range1 
+    # @param [Range] range2 
+    # @return 
+    def self.merge_ranges(range1, range2)
+      return nil if range1.nil? && range2.nil?
+      return range1 if range2.nil?
+      return range2 if range1.nil?
+      
+      type = range1.type == "PQ" && range2.type == "PQ" ? "IVL_PQ" : "IVL_TS"
+      low = Value.merge_values(range1.low, range2.low)
+      high = Value.merge_values(range1.high, range2.high)
+      width = nil
+      
+      Range.new(type, low, high, width)
+    end
+    
+    # Check to see if a given value falls within this Range's high and low.
+    #
+    # @param [Value] value The value that may or may not fall within the range.
+    # @return True if the value is contained. Otherwise, false.
+    def contains?(value)
+      start_time = low.to_time_object
+      end_time = high.to_time_object
+      time = value.to_time_object
+      
+      time.between?(start_time, end_time)
+    end
+    
+    # Check to see if a given Range's low and high matches this' low and high.
+    #
+    # @param [Range] range The Range to which we're comparing.
+    # @return True if the given range starts and ends at the same time as this. Otherwise, false.
+    def eql?(range)
+      return false if range.nil? || low.nil? || range.low.nil? || high.nil? || range.high.nil?
+      
+      return low.value == range.low.value && low.inclusive? == range.low.inclusive? &&
+             high.value == range.high.value && high.inclusive? == range.high.inclusive?
+    end
+  end
+end