postrunner 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ea85f9119389650b496a24e3adc7a960c5f0720
-  data.tar.gz: 622774385cb1a22076bf7d7cfbf6b760c1d34ada
+  metadata.gz: 30fc3ab83ce783076286638ede5faf67d2b5adbf
+  data.tar.gz: 465e09b0a7dac4cfdbcb129886f50afae1802680
 SHA512:
-  metadata.gz: e70a68cd0332762fc5255e4f9977a19c8be2bb1297f78dbb7b597c9727ebad0c1a769b0991ee568f43622ba6360c61763ae328ac75c9e7112fe242df974840b8
-  data.tar.gz: 6f8cb38a8e094bec344f5ac5ab7dc1bbaba0d5ba6f0d2d39eec1ccdace18ad964c5ef8dcd1120968a7206043260e37879a22c5b7cc56fc8539dbef8da1a954e6
+  metadata.gz: aa31ebe5811736bbcba8324d54a0dbb0bd4b19435544471236aac7563ad623002e5c4c2f7cec6e0095da7dfabbb6bdd25f10637cf88905a30d7dc35be6a2f459
+  data.tar.gz: 801afc538448f0615c3d2095559f6fb945dd14cabeb3d55d3c1faa8c323d49e38522edca58ca6b44572cb79c332ae78bb8c4dbf1c22e224e4d3bf32996e8079e

data/lib/postrunner/ActivitySummary.rb

@@ -77,7 +77,7 @@ module PostRunner
       t.body
       t.row([ 'Type:', @type ])
       t.row([ 'Sub Type:', @sub_type ])
-      t.row([ 'Date:', session.timestamp ])
+      t.row([ 'Start Time:', session.start_time])
       t.row([ 'Distance:',
               local_value(session, 'total_distance', '%.2f %s',
                           { :metric => 'km', :statute => 'mi'}) ])
@@ -159,9 +159,16 @@ module PostRunner
       t.row([ 'Suggested Recovery Time:',
               rec_time ? secsToDHMS(rec_time * 60) : '-' ])
 
-      hrv = HRV_Analyzer.new(@fit_activity)
-      if hrv.has_hrv_data?
-        t.row([ 'HRV Score:', "%.1f" % hrv.lnrmssdx20_1sigma ])
+      hrv = HRV_Analyzer.new(@activity)
+      # If we have HRV data for more than 120s we compute the PostRunner HRV
+      # Score for the 2nd and 3rd minute. The first minute is ignored as it
+      # often contains erratic data due to body movements and HRM adjustments.
+      # Clinical tests usually recommend a 5 minute measure time, but that's
+      # probably too long for daily tests.
+      if hrv.has_hrv_data? && hrv.duration > 180
+        if (hrv_score = hrv.hrv_score(60, 120)) > 0.0 && hrv_score < 100.0
+          t.row([ 'PostRunner HRV Score:', "%.1f" % hrv_score ])
+        end
       end
 
       t

data/lib/postrunner/ChartView.rb

@@ -21,7 +21,7 @@ module PostRunner
       @sport = activity.sport
       @unit_system = unit_system
       @empty_charts = {}
-      @hrv_analyzer = HRV_Analyzer.new(@activity.fit_activity)
+      @hrv_analyzer = HRV_Analyzer.new(activity)
 
       @charts = [
         {
@@ -63,14 +63,12 @@ module PostRunner
           :unit => 'ms',
           :graph => :line_graph,
           :colors => '#900000',
-          :show => @hrv_analyzer.has_hrv_data?,
-          :min_y => -30,
-          :max_y => 30
+          :show => @hrv_analyzer.has_hrv_data?
         },
         {
           :id => 'hrv_score',
-          :label => 'HRV Score (30s Window)',
-          :short_label => 'HRV Score',
+          :label => 'rMSSD (30s Window)',
+          :short_label => 'rMSSD',
           :graph => :line_graph,
           :colors => '#900000',
           :show => false
@@ -270,41 +268,53 @@ EOT
       start_time = @activity.fit_activity.sessions[0].start_time.to_i
       min_value = nil
       if chart[:id] == 'hrv_score'
-        0.upto(@hrv_analyzer.total_duration.to_i - 30) do |t|
-          next unless (hrv_score = @hrv_analyzer.lnrmssdx20(t, 30)) > 0.0
-          min_value = hrv_score if min_value.nil? || min_value > hrv_score
-          data_set << [ t * 1000, hrv_score ]
+        window_time = 120
+        0.upto(@hrv_analyzer.total_duration.to_i - window_time) do |t|
+          if (hrv_score = @hrv_analyzer.rmssd(t, window_time)) >= 0.0
+            min_value = hrv_score if min_value.nil? || min_value > hrv_score
+            data_set << [ (t * 1000).to_i, hrv_score ]
+          else
+            data_set << [ (t * 1000).to_i, nil ]
+          end
         end
       elsif chart[:id] == 'hrv'
-        1.upto(@hrv_analyzer.rr_intervals.length - 1) do |idx|
-          curr_intvl = @hrv_analyzer.rr_intervals[idx]
-          prev_intvl = @hrv_analyzer.rr_intervals[idx - 1]
-          next unless curr_intvl && prev_intvl
-
-          # Convert the R-R interval duration to ms.
-          dt = (curr_intvl - prev_intvl) * 1000.0
-          min_value = dt if min_value.nil? || min_value > dt
-          data_set << [ @hrv_analyzer.timestamps[idx] * 1000, dt ]
+        @hrv_analyzer.hrv.each_with_index do |dt, i|
+          if dt
+            data_set << [ (@hrv_analyzer.timestamps[i] * 1000).to_i, dt * 1000 ]
+          else
+            data_set << [ (@hrv_analyzer.timestamps[i] * 1000).to_i, nil ]
+          end
         end
+        min_value = 0
       else
+        last_value = nil
+        last_timestamp = nil
         @activity.fit_activity.records.each do |r|
-          value = r.get_as(chart[:id], chart[:unit] || '')
-
-          next unless value
-
-          if chart[:id] == 'pace'
-            # Slow speeds lead to very large pace values that make the graph
-            # hard to read. We cap the pace at 20.0 min/km to keep it readable.
-            if value > (@unit_system == :metric ? 20.0 : 36.0 )
-              value = nil
+          if last_timestamp && (r.timestamp - last_timestamp) > 5.0
+            # We have a gap in the values that is longer than 5 seconds. We'll
+            # finish the line and start a new one later.
+            data_set << [ (r.timestamp - start_time + 1).to_i * 1000, nil ]
+          end
+          if (value = r.get_as(chart[:id], chart[:unit] || ''))
+            if chart[:id] == 'pace'
+              # Slow speeds lead to very large pace values that make the graph
+              # hard to read. We cap the pace at 20.0 min/km to keep it
+              # readable.
+              if value > (@unit_system == :metric ? 20.0 : 36.0 )
+                value = nil
+              else
+                value = (value * 3600.0 * 1000).to_i
+              end
+              min_value = 0.0
             else
-              value = (value * 3600.0 * 1000).to_i
+              min_value = value if (min_value.nil? || min_value > value)
             end
-            min_value = 0.0
-          else
-            min_value = value if (min_value.nil? || min_value > value)
           end
-          data_set << [ ((r.timestamp.to_i - start_time) * 1000).to_i, value ]
+          unless last_value.nil? && value.nil?
+            data_set << [ (r.timestamp - start_time).to_i * 1000, value ]
+          end
+          last_value = value
+          last_timestamp = r.timestamp
         end
       end
 

data/lib/postrunner/DataSources.rb

@@ -59,8 +59,8 @@ module PostRunner
         t.cell(secsToHMS(source.timestamp - start_time))
         t.cell(@activity.distance(source.timestamp, @unit_system))
         t.cell(source.mode)
-        t.cell(device_name(source.distance))
         t.cell(device_name(source.speed))
+        t.cell(device_name(source.distance))
         t.cell(device_name(source.cadence))
         t.cell(device_name(source.elevation))
         t.cell(device_name(source.heart_rate))
@@ -75,8 +75,12 @@ module PostRunner
     def device_name(index)
       @fit_activity.device_infos.each do |device|
         if device.device_index == index
-          return (DeviceList::DeviceTypeNames[device.device_type] ||
-                  device.device_type) + " [#{device.device_index}]"
+          if device.device_type
+            return (DeviceList::DeviceTypeNames[device.device_type] ||
+                    device.device_type) + " [#{device.device_index}]"
+          else
+            return "Unknown [#{device.device_index}]"
+          end
         end
       end
 

data/lib/postrunner/FFS_Activity.rb

@@ -96,9 +96,8 @@ module PostRunner
       'all' => 'All'
     }
 
-    po_attr :device, :fit_file_name, :norecord, :name, :note, :sport,
-            :sub_sport, :timestamp, :total_distance, :total_timer_time,
-            :avg_speed
+    attr_persist :device, :fit_file_name, :norecord, :name, :note, :sport,
+      :sub_sport, :timestamp, :total_distance, :total_timer_time, :avg_speed
     attr_reader :fit_activity
 
     # Create a new FFS_Activity object.
@@ -288,7 +287,9 @@ module PostRunner
       end
     end
 
-    private
+    def purge_fit_file
+      @fit_activity = nil
+    end
 
   end
 

data/lib/postrunner/FFS_Device.rb

@@ -23,7 +23,7 @@ module PostRunner
   # dashes. All objects are transparently stored in the PEROBS::Store.
   class FFS_Device < PEROBS::Object
 
-    po_attr :activities, :monitorings, :short_uid, :long_uid
+    attr_persist :activities, :monitorings, :short_uid, :long_uid
 
     # Create a new FFS_Device object.
     # @param p [PEROBS::Handle] p
@@ -93,6 +93,13 @@ module PostRunner
       entities << entity
       entities.sort!
 
+      md5sums = @store['fit_file_md5sums']
+      md5sums << FitFileStore.calc_md5_sum(fit_file_name)
+      # We only store the 512 most recently added FIT files. This should be
+      # more than a device can store. This will allow us to skip the already
+      # imported FIT files quickly instead of having to parse them each time.
+      md5sums.shift if md5sums.length > 512
+
       # Scan the activity for any potential new personal records and register
       # them.
       if entity.is_a?(FFS_Activity)

data/lib/postrunner/FFS_Monitoring.rb

@@ -21,7 +21,7 @@ module PostRunner
 
     include DirUtils
 
-    po_attr :device, :fit_file_name, :name, :period_start, :period_end
+    attr_persist :device, :fit_file_name, :name, :period_start, :period_end
 
     # Create a new FFS_Monitoring object.
     # @param p [PEROBS::Handle] PEROBS handle

data/lib/postrunner/FitFileStore.rb

@@ -10,6 +10,7 @@
 # published by the Free Software Foundation.
 #
 
+require 'digest'
 require 'fit4ruby'
 require 'perobs'
 
@@ -29,7 +30,7 @@ module PostRunner
 
     include DirUtils
 
-    po_attr :devices
+    attr_persist :devices
 
     attr_reader :store, :views
 
@@ -54,6 +55,9 @@ module PostRunner
       # safely to another directory.
       @store['config']['devices_dir'] = @devices_dir
       create_directory(@devices_dir, 'devices')
+      unless @store['fit_file_md5sums']
+        @store['fit_file_md5sums'] = @store.new(PEROBS::Array)
+      end
 
       # Define which View objects the HTML output will consist of. This
       # doesn't really belong in this class but for now it's the best place
@@ -76,6 +80,12 @@ module PostRunner
     # @return [FFS_Activity or FFS_Monitoring] Corresponding entry in the
     #         FitFileStore or nil if file could not be added.
     def add_fit_file(fit_file_name, fit_entity = nil, overwrite = false)
+      md5sum = FitFileStore.calc_md5_sum(fit_file_name)
+      if @store['fit_file_md5sums'].include?(md5sum)
+        # The FIT file is already stored in the DB.
+        return nil unless overwrite
+      end
+
       # If we the file hasn't been read yet, read it in as a
       # Fit4Ruby::Activity or Fit4Ruby::Monitoring entity.
       unless fit_entity
@@ -176,7 +186,7 @@ module PostRunner
     def change_unit_system
       # If we have changed the unit system we need to re-generate all HTML
       # reports.
-      activities.each do |activity|
+      activities.reverse.each do |activity|
         activity.generate_html_report
       end
       @store['records'].generate_html_reports
@@ -209,7 +219,17 @@ module PostRunner
       @store['devices'].each do |id, device|
         list += device.activities
       end
-      list.sort
+      # Sort the activites by timestamps (newest to oldest). As the list is
+      # composed from multiple devices, there is a small chance of identical
+      # timestamps. To guarantee a stable list, we use the long UID of the
+      # device in cases of identical timestamps.
+      list.sort! do |a1, a2|
+        a1.timestamp == a2.timestamp ?
+          a1.device.long_uid <=> a2.device.long_uid :
+          a2.timestamp <=> a1.timestamp
+      end
+
+      list
     end
 
     # Read in all Monitoring_B FIT files that overlap with the given interval.
@@ -305,11 +325,10 @@ module PostRunner
     def check
       records = @store['records']
       records.delete_all_records
-      activities.sort do |a1, a2|
-        a1.timestamp <=> a2.timestamp
-      end.each do |a|
+      activities.reverse.each do |a|
         a.check
         records.scan_activity_for_records(a)
+        a.purge_fit_file
       end
       records.generate_html_reports
       generate_html_index_pages
@@ -411,6 +430,14 @@ module PostRunner
       puts MonitoringStatistics.new(monitoring_files).monthly(day)
     end
 
+    def FitFileStore::calc_md5_sum(file_name)
+      begin
+        Digest::MD5.hexdigest File.read(file_name)
+      rescue IOError
+        return 0
+      end
+    end
+
     private
 
     def read_fit_file(fit_file_name)

data/lib/postrunner/HRV_Analyzer.rb

@@ -3,14 +3,14 @@
 #
 # = HRV_Analyzer.rb -- PostRunner - Manage the data from your Garmin sport devices.
 #
-# Copyright (c) 2015 by Chris Schlaeger <cs@taskjuggler.org>
+# Copyright (c) 2015, 2016, 2017 by Chris Schlaeger <cs@taskjuggler.org>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of version 2 of the GNU General Public License as
 # published by the Free Software Foundation.
 #
 
-require 'postrunner/LinearPredictor'
+require 'postrunner/FFS_Activity'
 
 module PostRunner
 
@@ -19,20 +19,48 @@ module PostRunner
   # quality is good enough.
   class HRV_Analyzer
 
-    attr_reader :rr_intervals, :timestamps
+    attr_reader :hrv, :timestamps, :duration, :errors
+
+    # According to Nunan et. al. 2010
+    # (http://www.qeeg.co.uk/HRV/NUNAN-2010-A%20Quantitative%20Systematic%20Review%20of%20Normal%20Values%20for.pdf)
+    # rMSSD (ms) are expected to be in the rage of 19 to 75 in healthy, adult
+    # humans.  Typical ln(rMSSD) (ms) values for healthy, adult humans are
+    # between 2.94 and 4.32. We use a slighly broader interval. We'll add a
+    # bit of padding for our limits here.
+    LN_RMSSD_MIN = 2.9
+    LN_RMSSD_MAX = 4.4
 
     # Create a new HRV_Analyzer object.
-    # @param fit_file [Fit4Ruby::Activity] FIT file to analyze.
-    def initialize(fit_file)
-      @fit_file = fit_file
-      collect_rr_intervals
+    # @param arg [Activity, Array<Float>] R-R (or NN) time delta in seconds.
+    def initialize(arg)
+      if arg.is_a?(Array)
+        rr_intervals = arg
+      else
+        activity = arg
+        # Gather the RR interval list from the activity. Note that HRV data
+        # still gets recorded after the activity has been stoped until the
+        # activity gets saved.
+        # Each Fit4Ruby::HRV object has an Array called 'time' that contains up
+        # to 5 R-R interval durations. If less than 5 values are present the
+        # remaining are filled with nil entries.
+        rr_intervals = activity.fit_activity.hrv.map do |hrv|
+          hrv.time.compact
+        end.flatten
+      end
+      #$stderr.puts rr_intervals.inspect
+
+      cleanup_rr_intervals(rr_intervals)
     end
 
     # The method can be used to check if we have valid HRV data. The FIT file
     # must have HRV data and the measurement duration must be at least 30
     # seconds.
     def has_hrv_data?
-      !@fit_file.hrv.empty? && total_duration > 30.0
+      @hrv && !@hrv.empty? && total_duration > 30.0
+    end
+
+    def data_quality
+      (@hrv.size - @errors).to_f / @hrv.size * 100.0
     end
 
     # Return the total duration of all measured intervals in seconds.
@@ -65,111 +93,103 @@ module PostRunner
         end_idx = -1
       end
 
-      last_i = nil
       sum = 0.0
       cnt = 0
-      @rr_intervals[start_idx..end_idx].each do |i|
-        if i && last_i
-          sum += (last_i - i) ** 2.0
+      @hrv[start_idx..end_idx].each do |i|
+        if i
+          # Input values are in seconds, but rmssd is usually computed from
+          # milisecond values.
+          sum += (i * 1000) ** 2.0
           cnt += 1
         end
-        last_i = i
       end
 
       Math.sqrt(sum / cnt)
     end
 
-    # The RMSSD value is not very easy to memorize. Alternatively, we can
-    # multiply the natural logarithm of RMSSD by -20. This usually results in
-    # values between 1.0 (for untrained) and 100.0 (for higly trained)
-    # athletes. Values larger than 100.0 are rare but possible.
+    # The natural logarithm of rMSSD.
     # @param start_time [Float] Determines at what time mark (in seconds) the
     #        computation should start.
     # @param duration [Float] The duration of the total inteval in seconds to
     #        be considered for the computation. This value should be larger
     #        then 30 seconds to produce meaningful values.
-    def lnrmssdx20(start_time = 0.0, duration = nil)
-      -20.0 * Math.log(rmssd(start_time, duration))
+    def ln_rmssd(start_time = 0.0, duration = nil)
+      Math.log(rmssd(start_time, duration))
     end
 
-    # This method is similar to lnrmssdx20 but it tries to search the data for
-    # the best time period to compute the lnrmssdx20 value from.
-    def lnrmssdx20_1sigma
-      # Create a new Array that consists of rr_intervals and timestamps
-      # tuples.
-      set = []
-      0.upto(@rr_intervals.length - 1) do |i|
-        set << [ @rr_intervals[i] ? @rr_intervals[i] : 0.0, @timestamps[i] ]
-      end
-
-      percentiles = Percentiles.new(set)
-      # Compile a list of all tuples with rr_intervals that are outside of the
-      # PT84 (aka +1sigma range. Sort the list by time.
-      not_1sigma = percentiles.not_tp_x(84.13).sort { |e1, e2| e1[1] <=> e2[1] }
-
-      # Then find the largest time gap in that list. So all the values in that
-      # gap are within TP84.
-      gap_start = gap_end = 0
-      last = nil
-      not_1sigma.each do |e|
-        if last
-          if (e[1] - last) > (gap_end - gap_start)
-            gap_start = last
-            gap_end = e[1]
-          end
-        end
-        last = e[1]
-      end
-      # That gap should be at least 30 seconds long. Otherwise we'll just use
-      # all the values.
-      return lnrmssdx20 if gap_end - gap_start < 30
-
-      lnrmssdx20(gap_start, gap_end - gap_start)
+    # The ln_rmssd values are hard to interpret. Since we know the expected
+    # range we'll transform it into a value in the range 0 - 100. If the HRV
+    # is measured early in the morning while standing upright and with a
+    # regular 3s in/3s out breathing pattern the HRV Score is a performance
+    # indicator. The higher it is, the better the performance condition.
+    def hrv_score(start_time = 0.0, duration = nil)
+      ssd = ln_rmssd(start_time, duration)
+      ssd = LN_RMSSD_MIN if ssd < LN_RMSSD_MIN
+      ssd = LN_RMSSD_MAX if ssd > LN_RMSSD_MAX
+
+      (ssd - LN_RMSSD_MIN) * (100.0 / (LN_RMSSD_MAX - LN_RMSSD_MIN))
     end
 
     private
 
-    def collect_rr_intervals
-      # The rr_intervals Array stores the beat-to-beat time intervals (R-R).
-      # If one or move beats have been skipped during measurement, a nil value
-      # is inserted.
-      @rr_intervals = []
+    def cleanup_rr_intervals(rr_intervals)
       # The timestamps Array stores the relative (to start of sequence) time
       # for each interval in the rr_intervals Array.
       @timestamps = []
 
-      # Each Fit4Ruby::HRV object has an Array called 'time' that contains up
-      # to 5 R-R interval durations. If less than 5 are present, they are
-      # filled with nil.
-      raw_rr_intervals = []
-      @fit_file.hrv.each do |hrv|
-        raw_rr_intervals += hrv.time.compact
-      end
-      return if raw_rr_intervals.empty?
-
-      window = 20
-      intro_mean = raw_rr_intervals[0..4 * window].reduce(:+) / (4 * window)
-      predictor = LinearPredictor.new(window, intro_mean)
+      return if rr_intervals.empty?
 
-      # The timer accumulates the interval durations.
+      # The timer accumulates the interval durations and keeps track of the
+      # timestamp of the current value with respect to the beging of the
+      # series.
       timer = 0.0
-      raw_rr_intervals.each do |dt|
-        timer += dt
+      clean_rr_intervals = []
+      @errors = 0
+      rr_intervals.each_with_index do |rr, i|
         @timestamps << timer
 
-        # Sometimes the hrv data is missing one or more beats. The next
-        # detected beat is than listed with the time interval since the last
-        # detected beat. We try to detect these skipped beats by looking for
-        # time intervals that are 1.5 or more times larger than the predicted
-        # value for this interval.
-        if (next_dt = predictor.predict) && dt > 1.5 * next_dt
-          @rr_intervals << nil
+        # The biggest source of errors are missed beats resulting in intervals
+        # that are twice or more as large as the regular intervals. We look at
+        # a window of values surrounding the current interval to determine
+        # what's normal. We assume that at least half the values are normal.
+        # When we sort the values by size, the middle value must be a good
+        # proxy for a normal value.
+        # Any values that are 1.8 times larger than the normal proxy value
+        # will be discarded and replaced by nil.
+        if rr > 1.8 * median_value(rr_intervals, i, 21)
+          clean_rr_intervals << nil
+          @errors += 1
         else
-          @rr_intervals << dt
-          # Feed the value into the predictor.
-          predictor.insert(dt)
+          clean_rr_intervals << rr
         end
+
+        timer += rr
       end
+
+      # This array holds the cleanedup heart rate variability values.
+      @hrv = []
+      0.upto(clean_rr_intervals.length - 2) do |i|
+        rr1 = clean_rr_intervals[i]
+        rr2 = clean_rr_intervals[i + 1]
+        if rr1.nil? || rr2.nil?
+          @hrv << nil
+        else
+          @hrv << (rr1 - rr2).abs
+        end
+      end
+
+      # Save the overall duration of the HRV samples.
+      @duration = timer
+    end
+
+    def median_value(ary, index, half_window_size)
+      low_i = index - half_window_size
+      low_i = 0 if low_i < 0
+      high_i = index + half_window_size
+      high_i = ary.length - 1 if high_i > ary.length - 1
+      values = ary[low_i..high_i].delete_if{ |v| v.nil? }.sort
+
+      median = values[values.length / 2]
     end
 
   end

data/lib/postrunner/LinearPredictor.rb

@@ -18,8 +18,8 @@ module PostRunner
 
     # Create a new LinearPredictor object.
     # @param n [Fixnum] The number of coefficients the predictor should use.
-    def initialize(n, default = nil)
-      @values = Array.new(n, default)
+    def initialize(n)
+      @values = []
       @size = n
       @next = nil
     end
@@ -29,10 +29,12 @@ module PostRunner
     def insert(value)
       @values << value
 
-      if @values.length > @size
+      if @values.length >= @size
         @values.shift
-        @next = @values.reduce(:+) / @size
       end
+
+      @next = @values.reduce(:+) / @values.size
+      $stderr.puts "insert(#{value})  next: #{@next}"
     end
 
     # @return [Float] The predicted value of the next sample.

data/lib/postrunner/PersonalRecords.rb

@@ -72,7 +72,7 @@ module PostRunner
       }
     }
 
-    po_attr :sport_records
+    attr_persist :sport_records
 
     class ActivityResult
 
@@ -94,7 +94,7 @@ module PostRunner
 
       include Fit4Ruby::Converters
 
-      po_attr :activity, :sport, :distance, :duration, :start_time
+      attr_persist :activity, :sport, :distance, :duration, :start_time
 
       def initialize(p, result)
         super(p)
@@ -123,7 +123,7 @@ module PostRunner
 
       include Fit4Ruby::Converters
 
-      po_attr :sport, :year, :distance_record, :speed_records
+      attr_persist :sport, :year, :distance_record, :speed_records
 
       def initialize(p, sport, year)
         super(p)
@@ -246,7 +246,7 @@ module PostRunner
 
     class SportRecords < PEROBS::Object
 
-      po_attr :sport, :all_time, :yearly
+      attr_persist :sport, :all_time, :yearly
 
       def initialize(p, sport)
         super(p)

data/lib/postrunner/version.rb

@@ -11,5 +11,5 @@
 #
 
 module PostRunner
-  VERSION = '0.8.1'
+  VERSION = '0.9.0'
 end

data/postrunner.gemspec

@@ -29,7 +29,7 @@ well.}
   spec.required_ruby_version = '>=2.0'
 
   spec.add_dependency 'fit4ruby', '~> 1.6.1'
-  spec.add_dependency 'perobs', '~> 3.0.1'
+  spec.add_dependency 'perobs', '~> 4.0.0'
   spec.add_dependency 'nokogiri', '~> 1.6'
 
   spec.add_development_dependency 'bundler', '~> 1.6'

data/spec/HRV_Analyzer_spec.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = PostRunner_spec.rb -- PostRunner - Manage the data from your Garmin sport devices.
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'spec_helper'
+
+describe PostRunner::HRV_Analyzer do
+
+  it 'should cleanup the input data' do
+    rri = [ 0.6, 0.6, 0.6, 0.6, 0.6, 0.6, 1.1, 0.6,
+            0.6, 0.8, 0.6, 0.61, 0.59, 0.6, 0.6, 0.6,
+            0.6, 0.6, 0.2, 0.6, 0.6, 0.6, 0.6, 0.5,
+            0.6, 0.6, 0.6, 1.3, 0.6, 0.6, 0.6, 0.6 ]
+    hrv = PostRunner::HRV_Analyzer.new(rri)
+    expect(hrv.errors).to eql(2)
+    ts = [ 0.0, 0.6, 1.2, 1.8, 2.4, 3.0, 3.6, 4.7,
+           5.3, 5.9, 6.7, 7.3, 7.9, 8.5, 9.1, 9.7,
+           10.3, 10.9, 11.5, 11.7, 12.3, 12.9, 13.5, 14.1,
+           14.6, 15.2, 15.8, 16.4, 17.7, 18.3, 18.9, 19.5 ]
+    hrv.timestamps.each_with_index do |v, i|
+      expect(v).to be_within(0.01).of(ts[i])
+    end
+    expect(hrv.has_hrv_data?).to be false
+    expect(hrv.rmssd).to be_within(0.00001).of(124.81096817899)
+  end
+
+  it 'should compute an HRV Score' do
+    rri = [
+      0.837, 0.831, 0.843, 0.867, 0.788, 0.984, 0.872, 0.891, 0.878, 0.864,
+      0.844, 0.818, 0.798, 0.791, 0.808, 0.866, 0.927, 0.951, 0.958, 0.943,
+      0.613, 1.2, 0.884, 0.884, 0.878, 0.873, 0.867, 0.875, 0.872, 0.871,
+      0.892, 0.943, 1.185, 0.788, 1.255, 0.636, 0.901, 0.896, 0.9, 0.915,
+      0.698, 1.148, 0.894, 0.872, 0.85, 0.86, 0.893, 0.941, 0.692, 1.233,
+      0.981, 0.926, 0.93, 0.928, 0.928, 0.93, 1.158, 0.68, 0.877, 0.915,
+      0.926, 0.933, 0.933, 0.924, 0.681, 1.133, 0.901, 0.892, 0.887, 0.877,
+      0.732, 0.968, 0.826, 0.824, 0.865, 0.905, 0.915, 0.935, 0.932, 0.924,
+      0.915, 0.945, 0.96, 0.963, 0.939, 0.92, 0.892, 0.669, 1.037, 0.806,
+      0.818, 0.847, 0.879, 0.922, 0.938, 0.952, 0.969, 1.018, 1.03, 1.004,
+      0.98, 0.948, 0.919, 0.894, 0.896, 0.905, 0.913, 0.925, 0.905, 0.879,
+      0.855, 0.857, 0.866, 0.878, 0.881, 0.884, 0.873, 0.857, 0.851, 0.864,
+      0.883, 0.895, 0.898, 0.898, 0.876, 0.853, 0.841, 0.85, 0.857, 0.852,
+      0.861, 0.867, 0.869, 0.858, 0.844, 0.856, 0.869, 0.879, 0.886, 0.89,
+      0.876, 0.857, 0.843, 0.839, 0.838, 0.843, 0.845, 0.856, 0.856, 0.85,
+      0.838, 0.842, 0.844, 0.842, 0.834, 0.832, 0.818, 0.81, 0.801, 0.78,
+      0.797, 0.816, 0.838, 0.85, 0.845, 0.841, 0.84, 0.837, 0.859, 0.874,
+      0.89, 0.896, 0.893, 0.879, 0.863, 0.855, 0.87, 0.875, 0.861, 0.854,
+      0.843, 0.836, 0.822, 0.813, 0.806, 0.81, 0.824, 0.834, 0.847, 0.867,
+      0.877, 0.883, 0.877, 0.856, 0.872, 0.88, 0.87, 0.861, 0.855, 0.852,
+      0.84, 0.832, 0.82, 0.827, 0.838, 0.854, 0.881, 0.893, 0.857
+    ]
+
+    hrv = PostRunner::HRV_Analyzer.new(rri)
+    expect(hrv.data_quality).to be_within(0.00001).of(100)
+    expect(hrv.ln_rmssd(0.0, 90)).to be_within(0.00001).of(5.188390931)
+    expect(hrv.ln_rmssd(90, 90)).to be_within(0.00001).of(2.549616730)
+    expect(hrv.rmssd(0.0, 90)).to be_within(0.00001).of(179.1800079)
+    expect(hrv.hrv_score(0.0, 60)).to be_within(0.00001).of(100.0)
+  end
+
+  it 'should find the right interval for a HRV score computation' do
+    rri = [
+      0.752, 0.759, 0.755, 0.741, 0.733, 0.738, 0.751, 0.767, 0.774, 0.777,
+      0.771, 0.787, 0.795, 0.805, 0.797, 0.78, 0.77, 0.764, 0.766, 0.771,
+      0.764, 0.763, 0.776, 0.777, 0.785, 0.78, 0.768, 0.757, 0.745, 0.737,
+      0.724, 0.709, 0.695, 0.699, 0.703, 0.719, 0.726, 0.73, 0.733, 0.739,
+      0.744, 0.744, 0.738, 0.725, 0.713, 0.706, 0.705, 0.7, 0.694, 0.697,
+      0.706, 0.716, 0.728, 0.73, 0.731, 0.742, 0.748, 0.742, 0.733, 0.731,
+      0.729, 0.727, 0.712, 0.712, 0.715, 0.712, 0.706, 0.707, 0.729, 0.762,
+      0.773, 0.768, 0.78, 0.78, 0.771, 0.75, 0.736, 0.719, 0.704, 0.69, 0.683,
+      0.688, 0.703, 0.732, 0.742, 0.751, 0.758, 0.783, 0.786, 0.764, 0.752,
+      0.733, 0.722, 0.711, 0.694, 0.687, 0.69, 0.707, 0.722, 0.732, 0.761,
+      0.783, 0.805, 0.795, 0.779, 0.76, 0.744, 0.726, 0.707, 0.692, 0.688,
+      0.694, 0.695, 0.708, 0.729, 0.761, 0.776, 0.787, 0.799, 0.795, 0.773,
+      0.755, 0.738, 0.721, 0.71, 0.701, 0.692, 0.698, 0.712, 0.73, 0.736,
+      0.732, 0.722, 0.72, 0.712, 0.709, 0.695, 0.687, 0.688, 0.684, 0.687,
+      0.685, 0.685, 0.684, 0.689, 0.705, 0.716, 0.712, 0.71, 0.732, 0.75,
+      0.755, 0.757, 0.758, 0.759, 0.753, 0.748, 0.748, 0.724, 0.715, 0.721,
+      0.727, 0.743, 0.741, 0.743, 0.757, 0.765, 0.774, 0.781, 0.77, 0.745,
+      0.729, 0.707
+    ]
+    hrv = PostRunner::HRV_Analyzer.new(rri)
+    expect(hrv.hrv_score).to be_within(0.00001).of(0.0)
+  end
+
+end
+

data/spec/PostRunner_spec.rb

@@ -90,15 +90,15 @@ describe PostRunner::Main do
 
   it 'should list the imported file' do
     v = postrunner(%w( list ))
-    expect(v[:stdout].index(File.basename(@file1))).to be_a(Fixnum)
+    expect(v[:stdout].index(File.basename(@file1))).to be_a(Integer)
   end
 
   it 'should import the 2nd FIT file' do
     postrunner([ 'import', @file2 ])
     v = postrunner(%w( list ))
     list = v[:stdout]
-    expect(list.index(File.basename(@file1))).to be_a(Fixnum)
-    expect(list.index(File.basename(@file2))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file1))).to be_a(Integer)
+    expect(list.index(File.basename(@file2))).to be_a(Integer)
   end
 
   it 'should delete the first file' do
@@ -106,7 +106,7 @@ describe PostRunner::Main do
     v = postrunner(%w( list ))
     list = v[:stdout]
     expect(list.index(File.basename(@file1))).to be_nil
-    expect(list.index(File.basename(@file2))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file2))).to be_a(Integer)
   end
 
   it 'should not import the deleted file again' do
@@ -114,7 +114,7 @@ describe PostRunner::Main do
     v = postrunner(%w( list ))
     list = v[:stdout]
     expect(list.index(File.basename(@file1))).to be_nil
-    expect(list.index(File.basename(@file2))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file2))).to be_a(Integer)
   end
 
   it 'should rename FILE2.FIT activity' do
@@ -122,7 +122,7 @@ describe PostRunner::Main do
     v = postrunner(%w( list ))
     list = v[:stdout]
     expect(list.index(File.basename(@file2))).to be_nil
-    expect(list.index('foobar')).to be_a(Fixnum)
+    expect(list.index('foobar')).to be_a(Integer)
   end
 
   it 'should fail when setting bad attribute' do
@@ -135,7 +135,7 @@ describe PostRunner::Main do
     v = postrunner(%w( list ))
     list = v[:stdout]
     expect(list.index(@file2)).to be_nil
-    expect(list.index('foobar')).to be_a(Fixnum)
+    expect(list.index('foobar')).to be_a(Integer)
   end
 
   it 'should set activity type for 2nd activity' do
@@ -143,7 +143,7 @@ describe PostRunner::Main do
     v = postrunner(%w( summary :1 ))
     list = v[:stdout]
     expect(list.index('Running')).to be_nil
-    expect(list.index('Cycling')).to be_a(Fixnum)
+    expect(list.index('Cycling')).to be_a(Integer)
   end
 
   it 'should list the events of an activity' do
@@ -164,7 +164,7 @@ describe PostRunner::Main do
     v = postrunner(%w( summary :1 ))
     list = v[:stdout]
     expect(list.index('Generic')).to be_nil
-    expect(list.index('Road')).to be_a(Fixnum)
+    expect(list.index('Road')).to be_a(Integer)
   end
 
   it 'should fail when setting bad activity subtype' do
@@ -193,13 +193,13 @@ describe PostRunner::Main do
     postrunner([ 'import', '--force', @file1 ])
     v = postrunner([ 'records' ])
     list = v[:stdout]
-    expect(list.index(File.basename(@file1))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file1))).to be_a(Integer)
 
     # Add fast running activity
     postrunner([ 'import', @file3 ])
     v =postrunner([ 'records' ])
     list = v[:stdout]
-    expect(list.index(File.basename(@file3))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file3))).to be_a(Integer)
     expect(list.index(File.basename(@file1))).to be_nil
   end
 
@@ -207,7 +207,7 @@ describe PostRunner::Main do
     postrunner(%w( set norecord true :1 ))
     v = postrunner([ 'records' ])
     list = v[:stdout]
-    expect(list.index(File.basename(@file1))).to be_a(Fixnum)
+    expect(list.index(File.basename(@file1))).to be_a(Integer)
     expect(list.index(File.basename(@file3))).to be_nil
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postrunner
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Chris Schlaeger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-14 00:00:00.000000000 Z
+date: 2017-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fit4ruby
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -314,6 +314,7 @@ files:
 - spec/ActivitySummary_spec.rb
 - spec/FitFileStore_spec.rb
 - spec/FlexiTable_spec.rb
+- spec/HRV_Analyzer_spec.rb
 - spec/PersonalRecords_spec.rb
 - spec/PostRunner_spec.rb
 - spec/View_spec.rb
@@ -349,6 +350,7 @@ test_files:
 - spec/ActivitySummary_spec.rb
 - spec/FitFileStore_spec.rb
 - spec/FlexiTable_spec.rb
+- spec/HRV_Analyzer_spec.rb
 - spec/PersonalRecords_spec.rb
 - spec/PostRunner_spec.rb
 - spec/View_spec.rb