@neaps/tide-predictor 0.0.4

package/src/harmonics/__tests__/prediction.js

@@ -0,0 +1,148 @@
+import harmonics from '../index'
+import mockHarmonicConstituents from '../../__mocks__/constituents'
+import mockSecondaryStation from '../../__mocks__/secondary-station'
+
+const startDate = new Date()
+startDate.setFullYear(2019)
+startDate.setMonth(8)
+startDate.setDate(1)
+startDate.setHours(0)
+startDate.setMinutes(0)
+startDate.setSeconds(0)
+startDate.setMilliseconds(0)
+
+const endDate = new Date()
+endDate.setFullYear(2019)
+endDate.setMonth(8)
+endDate.setDate(1)
+endDate.setHours(6)
+endDate.setMinutes(0)
+endDate.setSeconds(0)
+endDate.setMilliseconds(0)
+
+const extremesEndDate = new Date()
+extremesEndDate.setFullYear(2019)
+extremesEndDate.setMonth(8)
+extremesEndDate.setDate(3)
+extremesEndDate.setHours(0)
+extremesEndDate.setMinutes(0)
+extremesEndDate.setSeconds(0)
+extremesEndDate.setMilliseconds(0)
+
+const setUpPrediction = () => {
+  const harmonic = harmonics({
+    harmonicConstituents: mockHarmonicConstituents,
+    phaseKey: 'phase_GMT',
+    offset: false,
+  })
+  harmonic.setTimeSpan(startDate, endDate)
+  return harmonic.prediction()
+}
+
+describe('harmonic prediction', () => {
+  test('it creates a timeline prediction', () => {
+    const testPrediction = setUpPrediction()
+    const results = testPrediction.getTimelinePrediction()
+    const lastResult = results.pop()
+    expect(results[0].level).toBeCloseTo(-1.347125, 3)
+    expect(lastResult.level).toBeCloseTo(2.85263589, 3)
+  })
+
+  test('it creates a timeline prediction with a non-default phase key', () => {
+    const results = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_local',
+      offset: false,
+    })
+      .setTimeSpan(startDate, endDate)
+      .prediction()
+      .getTimelinePrediction()
+    expect(results[0].level).toBeCloseTo(2.7560979, 3)
+    expect(results.pop().level).toBeCloseTo(-2.9170977, 3)
+  })
+
+  test('it finds high and low tides', () => {
+    const results = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_GMT',
+      offset: false,
+    })
+      .setTimeSpan(startDate, extremesEndDate)
+      .prediction()
+      .getExtremesPrediction()
+    expect(results[0].level).toBeCloseTo(-1.5650332, 4)
+
+    const customLabels = {
+      high: 'Super high',
+      low: 'Wayyy low',
+    }
+
+    const labelResults = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_GMT',
+      offset: false,
+    })
+      .setTimeSpan(startDate, extremesEndDate)
+      .prediction()
+      .getExtremesPrediction({ labels: customLabels })
+    expect(labelResults[0].label).toBe(customLabels.low)
+  })
+
+  test('it finds high and low tides with high fidelity', () => {
+    const results = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_GMT',
+      offset: false,
+    })
+      .setTimeSpan(startDate, extremesEndDate)
+      .prediction({ timeFidelity: 60 })
+      .getExtremesPrediction()
+    expect(results[0].level).toBeCloseTo(-1.5653894, 4)
+  })
+})
+
+describe('Secondary stations', () => {
+  test('it can add offsets to secondary stations', () => {
+    const regularResults = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_GMT',
+      offset: false,
+    })
+      .setTimeSpan(startDate, extremesEndDate)
+      .prediction()
+      .getExtremesPrediction()
+
+    const offsetResults = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+      phaseKey: 'phase_GMT',
+      offset: false,
+    })
+      .setTimeSpan(startDate, extremesEndDate)
+      .prediction()
+      .getExtremesPrediction({ offsets: mockSecondaryStation })
+
+    offsetResults.forEach((offsetResult, index) => {
+      if (offsetResult.low) {
+        expect(offsetResult.level).toBeCloseTo(
+          regularResults[index].level * mockSecondaryStation.height_offset.low,
+          4
+        )
+        expect(offsetResult.time.getTime()).toBe(
+          regularResults[index].time.getTime() +
+            mockSecondaryStation.time_offset.low * 60 * 1000
+        )
+      }
+      if (offsetResult.high) {
+        expect(offsetResult.level).toBeCloseTo(
+          regularResults[index].level * mockSecondaryStation.height_offset.high,
+          4
+        )
+
+        expect(offsetResult.time.getTime()).toBe(
+          regularResults[index].time.getTime() +
+            mockSecondaryStation.time_offset.high * 60 * 1000
+        )
+      }
+    })
+  })
+})

package/src/harmonics/index.js

@@ -0,0 +1,87 @@
+import prediction from './prediction'
+import constituentModels from '../constituents/index'
+import { d2r } from '../astronomy/constants'
+
+const getDate = (time) => {
+  if (time instanceof Date) {
+    return time
+  }
+  if (typeof time === 'number') {
+    return new Date(time * 1000)
+  }
+  throw new Error('Invalid date format, should be a Date object, or timestamp')
+}
+
+const getTimeline = (start, end, seconds) => {
+  seconds = typeof seconds !== 'undefined' ? seconds : 10 * 60
+  const timeline = []
+  const endTime = end.getTime() / 1000
+  let lastTime = start.getTime() / 1000
+  const startTime = lastTime
+  const hours = []
+  while (lastTime <= endTime) {
+    timeline.push(new Date(lastTime * 1000))
+    hours.push((lastTime - startTime) / (60 * 60))
+    lastTime += seconds
+  }
+
+  return {
+    items: timeline,
+    hours: hours,
+  }
+}
+
+const harmonicsFactory = ({ harmonicConstituents, phaseKey, offset }) => {
+  if (!Array.isArray(harmonicConstituents)) {
+    throw new Error('Harmonic constituents are not an array')
+  }
+  const constituents = []
+  harmonicConstituents.forEach((constituent, index) => {
+    if (typeof constituent.name === 'undefined') {
+      throw new Error('Harmonic constituents must have a name property')
+    }
+    if (typeof constituentModels[constituent.name] !== 'undefined') {
+      constituent._model = constituentModels[constituent.name]
+      constituent._phase = d2r * constituent[phaseKey]
+      constituents.push(constituent)
+    }
+  })
+
+  if (offset !== false) {
+    constituents.push({
+      name: 'Z0',
+      _model: constituentModels.Z0,
+      _phase: 0,
+      amplitude: offset,
+    })
+  }
+
+  let start = new Date()
+  let end = new Date()
+
+  const harmonics = {}
+
+  harmonics.setTimeSpan = (startTime, endTime) => {
+    start = getDate(startTime)
+    end = getDate(endTime)
+    if (start.getTime() >= end.getTime()) {
+      throw new Error('Start time must be before end time')
+    }
+    return harmonics
+  }
+
+  harmonics.prediction = (options) => {
+    options =
+      typeof options !== 'undefined' ? options : { timeFidelity: 10 * 60 }
+    return prediction({
+      timeline: getTimeline(start, end, options.timeFidelity),
+      constituents: constituents,
+      start: start,
+    })
+  }
+
+  return Object.freeze(harmonics)
+}
+
+export default harmonicsFactory
+export { getDate, getTimeline }

package/src/harmonics/prediction.js

@@ -0,0 +1,175 @@
+import astro from '../astronomy/index'
+import { d2r } from '../astronomy/constants'
+
+const modulus = (a, b) => {
+  return ((a % b) + b) % b
+}
+
+const addExtremesOffsets = (extreme, offsets) => {
+  if (typeof offsets === 'undefined' || !offsets) {
+    return extreme
+  }
+  if (extreme.high && offsets.height_offset && offsets.height_offset.high) {
+    extreme.level *= offsets.height_offset.high
+  }
+  if (extreme.low && offsets.height_offset && offsets.height_offset.low) {
+    extreme.level *= offsets.height_offset.low
+  }
+  if (extreme.high && offsets.time_offset && offsets.time_offset.high) {
+    extreme.time = new Date(
+      extreme.time.getTime() + offsets.time_offset.high * 60 * 1000
+    )
+  }
+  if (extreme.low && offsets.time_offset && offsets.time_offset.low) {
+    extreme.time = new Date(
+      extreme.time.getTime() + offsets.time_offset.low * 60 * 1000
+    )
+  }
+  return extreme
+}
+
+const getExtremeLabel = (label, highLowLabels) => {
+  if (
+    typeof highLowLabels !== 'undefined' &&
+    typeof highLowLabels[label] !== 'undefined'
+  ) {
+    return highLowLabels[label]
+  }
+  const labels = {
+    high: 'High',
+    low: 'Low',
+  }
+  return labels[label]
+}
+
+const predictionFactory = ({ timeline, constituents, start }) => {
+  const getLevel = (hour, modelBaseSpeed, modelU, modelF, modelBaseValue) => {
+    const amplitudes = []
+    let result = 0
+
+    constituents.forEach((constituent) => {
+      const amplitude = constituent.amplitude
+      const phase = constituent._phase
+      const f = modelF[constituent.name]
+      const speed = modelBaseSpeed[constituent.name]
+      const u = modelU[constituent.name]
+      const V0 = modelBaseValue[constituent.name]
+      amplitudes.push(amplitude * f * Math.cos(speed * hour + (V0 + u) - phase))
+    })
+    // sum up each row
+    amplitudes.forEach((item) => {
+      result += item
+    })
+    return result
+  }
+
+  const prediction = {}
+
+  prediction.getExtremesPrediction = (options) => {
+    const { labels, offsets } = typeof options !== 'undefined' ? options : {}
+    const results = []
+    const { baseSpeed, u, f, baseValue } = prepare()
+    let goingUp = false
+    let goingDown = false
+    let lastLevel = getLevel(0, baseSpeed, u[0], f[0], baseValue)
+    timeline.items.forEach((time, index) => {
+      const hour = timeline.hours[index]
+      const level = getLevel(hour, baseSpeed, u[index], f[index], baseValue)
+      // Compare this level to the last one, if we
+      // are changing angle, then the last one was high or low
+      if (level > lastLevel && goingDown) {
+        results.push(
+          addExtremesOffsets(
+            {
+              time: timeline.items[index - 1],
+              level: lastLevel,
+              high: false,
+              low: true,
+              label: getExtremeLabel('low', labels),
+            },
+            offsets
+          )
+        )
+      }
+      if (level < lastLevel && goingUp) {
+        results.push(
+          addExtremesOffsets(
+            {
+              time: timeline.items[index - 1],
+              level: lastLevel,
+              high: true,
+              low: false,
+              label: getExtremeLabel('high', labels),
+            },
+            offsets
+          )
+        )
+      }
+      if (level > lastLevel) {
+        goingUp = true
+        goingDown = false
+      }
+      if (level < lastLevel) {
+        goingUp = false
+        goingDown = true
+      }
+      lastLevel = level
+    })
+    return results
+  }
+
+  prediction.getTimelinePrediction = () => {
+    const results = []
+    const { baseSpeed, u, f, baseValue } = prepare()
+    timeline.items.forEach((time, index) => {
+      const hour = timeline.hours[index]
+      const prediction = {
+        time: time,
+        hour: hour,
+        level: getLevel(hour, baseSpeed, u[index], f[index], baseValue),
+      }
+
+      results.push(prediction)
+    })
+    return results
+  }
+
+  const prepare = () => {
+    const baseAstro = astro(start)
+
+    const baseValue = {}
+    const baseSpeed = {}
+    const u = []
+    const f = []
+    constituents.forEach((constituent) => {
+      const value = constituent._model.value(baseAstro)
+      const speed = constituent._model.speed(baseAstro)
+      baseValue[constituent.name] = d2r * value
+      baseSpeed[constituent.name] = d2r * speed
+    })
+    timeline.items.forEach((time) => {
+      const uItem = {}
+      const fItem = {}
+      const itemAstro = astro(time)
+      constituents.forEach((constituent) => {
+        const constituentU = modulus(constituent._model.u(itemAstro), 360)
+
+        uItem[constituent.name] = d2r * constituentU
+        fItem[constituent.name] = modulus(constituent._model.f(itemAstro), 360)
+      })
+      u.push(uItem)
+      f.push(fItem)
+    })
+
+    return {
+      baseValue: baseValue,
+      baseSpeed: baseSpeed,
+      u: u,
+      f: f,
+    }
+  }
+
+  return Object.freeze(prediction)
+}
+
+export default predictionFactory

package/src/index.js

@@ -0,0 +1,45 @@
+import harmonics from './harmonics/index'
+
+const tidePredictionFactory = (constituents, options) => {
+  const harmonicsOptions = {
+    harmonicConstituents: constituents,
+    phaseKey: 'phase_GMT',
+    offset: false
+  }
+
+  if (typeof options !== 'undefined') {
+    Object.keys(harmonicsOptions).forEach(key => {
+      if (typeof options[key] !== 'undefined') {
+        harmonicsOptions[key] = options[key]
+      }
+    })
+  }
+
+  const tidePrediction = {
+    getTimelinePrediction: ({ start, end }) => {
+      return harmonics(harmonicsOptions)
+        .setTimeSpan(start, end)
+        .prediction()
+        .getTimelinePrediction()
+    },
+
+    getExtremesPrediction: ({ start, end, labels, offsets, timeFidelity }) => {
+      return harmonics(harmonicsOptions)
+        .setTimeSpan(start, end)
+        .prediction({ timeFidelity: timeFidelity })
+        .getExtremesPrediction(labels, offsets)
+    },
+
+    getWaterLevelAtTime: ({ time }) => {
+      const endDate = new Date(time.getTime() + 10 * 60 * 1000)
+      return harmonics(harmonicsOptions)
+        .setTimeSpan(time, endDate)
+        .prediction()
+        .getTimelinePrediction()[0]
+    }
+  }
+
+  return tidePrediction
+}
+
+export default tidePredictionFactory