@neaps/tide-predictor 0.0.5 → 0.2.0

package/src/harmonics/prediction.js

@@ -1,175 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

package/src/node-corrections/__tests__/index.js

@@ -1,114 +0,0 @@
-import nodeCorrections from '../index'
-
-const testItems = {
-  i: {
-    value: 5
-  },
-  I: { value: 6 },
-  omega: { value: 3 },
-  nu: { value: 4 },
-  nup: { value: 4 },
-  nupp: { value: 2 },
-  P: { value: 14 },
-  xi: {
-    value: 4
-  }
-}
-
-describe('Node corrections', () => {
-  test('have correct unity', () => {
-    expect(nodeCorrections.fUnity()).toBe(1)
-  })
-
-  test('calculates Schureman equations 73, 65 (f_Mm)', () => {
-    expect(nodeCorrections.fMm(testItems)).toBeCloseTo(0.999051998091, 4)
-  })
-
-  test('calculates Schureman equations 74, 66 (f_Mf)', () => {
-    expect(nodeCorrections.fMf(testItems)).toBeCloseTo(4.00426673883, 4)
-  })
-
-  test('calculates Schureman equations 75, 67 (f_O1)', () => {
-    expect(nodeCorrections.fO1(testItems)).toBeCloseTo(2.00076050158, 4)
-  })
-
-  test('calculates Schureman equations 76, 68 (f_J1)', () => {
-    expect(nodeCorrections.fJ1(testItems)).toBeCloseTo(2.0119685329, 4)
-  })
-
-  test('calculates Schureman equations 77, 69 (f_OO1)', () => {
-    expect(nodeCorrections.fOO1(testItems)).toBeCloseTo(8.01402871709, 4)
-  })
-
-  test('calculates Schureman equations 78, 70 (f_M2)', () => {
-    expect(nodeCorrections.fM2(testItems)).toBeCloseTo(0.999694287563, 4)
-  })
-
-  test('calculates Schureman equations 227, 226, 68 (f_K1)', () => {
-    expect(nodeCorrections.fK1(testItems)).toBeCloseTo(1.23843964182, 4)
-  })
-
-  test('calculates Schureman equations 215, 213, 204 (f_L2)', () => {
-    expect(nodeCorrections.fL2(testItems)).toBeCloseTo(0.98517860327, 4)
-  })
-
-  test('calculates Schureman equations 235, 234, 71 (f_K2)', () => {
-    expect(nodeCorrections.fK2(testItems)).toBeCloseTo(1.09775430048, 4)
-  })
-
-  test('calculates Schureman equations 206, 207, 195 (f_M1)', () => {
-    expect(nodeCorrections.fM1(testItems)).toBeCloseTo(3.90313810168, 4)
-  })
-
-  test('calculates e.g. Schureman equation 149 (f_Modd)', () => {
-    expect(nodeCorrections.fModd(testItems, 3)).toBeCloseTo(0.999541466395, 4)
-  })
-
-  test('has a zero for u_zero', () => {
-    expect(nodeCorrections.uZero()).toBe(0.0)
-  })
-
-  test('calculates u_Mf', () => {
-    expect(nodeCorrections.uMf(testItems)).toBe(-8.0)
-  })
-
-  test('calculates u_O1', () => {
-    expect(nodeCorrections.uO1(testItems)).toBe(4.0)
-  })
-
-  test('calculates u_J1', () => {
-    expect(nodeCorrections.uJ1(testItems)).toBe(-4)
-  })
-
-  test('calculates u_OO1', () => {
-    expect(nodeCorrections.uOO1(testItems)).toBe(-12.0)
-  })
-
-  test('calculates u_M2', () => {
-    expect(nodeCorrections.uM2(testItems)).toBe(0.0)
-  })
-
-  test('calculates u_K1', () => {
-    expect(nodeCorrections.uK1(testItems)).toBe(-4)
-  })
-
-  test('calculates u_L2', () => {
-    expect(nodeCorrections.uL2(testItems)).toBeCloseTo(-0.449812364499, 4)
-  })
-
-  test('calculates u_K2', () => {
-    expect(nodeCorrections.uK2(testItems)).toBe(-4.0)
-  })
-
-  test('calculates u_K2', () => {
-    expect(nodeCorrections.uK2(testItems)).toBe(-4.0)
-  })
-
-  test('calculates u_M1', () => {
-    expect(nodeCorrections.uM1(testItems)).toBeCloseTo(7.09154172301, 4)
-  })
-
-  test('calculates u_Modd', () => {
-    expect(nodeCorrections.uModd(testItems, 3)).toBe(0)
-  })
-})

package/src/node-corrections/index.js

@@ -1,208 +0,0 @@
-import { d2r, r2d } from '../astronomy/constants'
-
-const corrections = {
-  fUnity() {
-    return 1
-  },
-
-  // Schureman equations 73, 65
-  fMm(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean =
-      (2 / 3.0 - Math.pow(Math.sin(omega), 2)) *
-      (1 - (3 / 2.0) * Math.pow(Math.sin(i), 2))
-    return (2 / 3.0 - Math.pow(Math.sin(I), 2)) / mean
-  },
-
-  // Schureman equations 74, 66
-  fMf(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean = Math.pow(Math.sin(omega), 2) * Math.pow(Math.cos(0.5 * i), 4)
-    return Math.pow(Math.sin(I), 2) / mean
-  },
-
-  // Schureman equations 75, 67
-  fO1(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean =
-      Math.sin(omega) *
-      Math.pow(Math.cos(0.5 * omega), 2) *
-      Math.pow(Math.cos(0.5 * i), 4)
-    return (Math.sin(I) * Math.pow(Math.cos(0.5 * I), 2)) / mean
-  },
-
-  // Schureman equations 76, 68
-  fJ1(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean =
-      Math.sin(2 * omega) * (1 - (3 / 2.0) * Math.pow(Math.sin(i), 2))
-    return Math.sin(2 * I) / mean
-  },
-
-  // Schureman equations 77, 69
-  fOO1(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean =
-      Math.sin(omega) *
-      Math.pow(Math.sin(0.5 * omega), 2) *
-      Math.pow(Math.cos(0.5 * i), 4)
-    return (Math.sin(I) * Math.pow(Math.sin(0.5 * I), 2)) / mean
-  },
-
-  // Schureman equations 78, 70
-  fM2(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const mean =
-      Math.pow(Math.cos(0.5 * omega), 4) * Math.pow(Math.cos(0.5 * i), 4)
-    return Math.pow(Math.cos(0.5 * I), 4) / mean
-  },
-
-  // Schureman equations 227, 226, 68
-  // Should probably eventually include the derivations of the magic numbers (0.5023 etc).
-  fK1(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const nu = d2r * a.nu.value
-    const sin2IcosnuMean =
-      Math.sin(2 * omega) * (1 - (3 / 2.0) * Math.pow(Math.sin(i), 2))
-    const mean = 0.5023 * sin2IcosnuMean + 0.1681
-    return (
-      Math.pow(
-        0.2523 * Math.pow(Math.sin(2 * I), 2) +
-          0.1689 * Math.sin(2 * I) * Math.cos(nu) +
-          0.0283,
-        0.5
-      ) / mean
-    )
-  },
-
-  // Schureman equations 215, 213, 204
-  // It can be (and has been) confirmed that the exponent for R_a reads 1/2 via Schureman Table 7
-  fL2(a) {
-    const P = d2r * a.P.value
-    const I = d2r * a.I.value
-    const rAInv = Math.pow(
-      1 -
-        12 * Math.pow(Math.tan(0.5 * I), 2) * Math.cos(2 * P) +
-        36 * Math.pow(Math.tan(0.5 * I), 4),
-      0.5
-    )
-    return corrections.fM2(a) * rAInv
-  },
-
-  // Schureman equations 235, 234, 71
-  // Again, magic numbers
-  fK2(a) {
-    const omega = d2r * a.omega.value
-    const i = d2r * a.i.value
-    const I = d2r * a.I.value
-    const nu = d2r * a.nu.value
-    const sinsqIcos2nuMean =
-      Math.sin(omega) ** 2 * (1 - (3 / 2.0) * Math.sin(i) ** 2)
-    const mean = 0.5023 * sinsqIcos2nuMean + 0.0365
-    return (
-      Math.pow(
-        0.2523 * Math.pow(Math.sin(I), 4) +
-          0.0367 * Math.pow(Math.sin(I), 2) * Math.cos(2 * nu) +
-          0.0013,
-        0.5
-      ) / mean
-    )
-  },
-  // Schureman equations 206, 207, 195
-  fM1(a) {
-    const P = d2r * a.P.value
-    const I = d2r * a.I.value
-    const qAInv = Math.pow(
-      0.25 +
-        1.5 *
-          Math.cos(I) *
-          Math.cos(2 * P) *
-          Math.pow(Math.cos(0.5 * I), -0.5) +
-        2.25 * Math.pow(Math.cos(I), 2) * Math.pow(Math.cos(0.5 * I), -4),
-      0.5
-    )
-    return corrections.fO1(a) * qAInv
-  },
-
-  // See e.g. Schureman equation 149
-  fModd(a, n) {
-    return Math.pow(corrections.fM2(a), n / 2.0)
-  },
-
-  // Node factors u, see Table 2 of Schureman.
-
-  uZero(a) {
-    return 0.0
-  },
-
-  uMf(a) {
-    return -2.0 * a.xi.value
-  },
-
-  uO1(a) {
-    return 2.0 * a.xi.value - a.nu.value
-  },
-
-  uJ1(a) {
-    return -a.nu.value
-  },
-
-  uOO1(a) {
-    return -2.0 * a.xi.value - a.nu.value
-  },
-
-  uM2(a) {
-    return 2.0 * a.xi.value - 2.0 * a.nu.value
-  },
-
-  uK1(a) {
-    return -a.nup.value
-  },
-
-  // Schureman 214
-  uL2(a) {
-    const I = d2r * a.I.value
-    const P = d2r * a.P.value
-    const R =
-      r2d *
-      Math.atan(
-        Math.sin(2 * P) /
-          ((1 / 6.0) * Math.pow(Math.tan(0.5 * I), -2) - Math.cos(2 * P))
-      )
-    return 2.0 * a.xi.value - 2.0 * a.nu.value - R
-  },
-
-  uK2(a) {
-    return -2.0 * a.nupp.value
-  },
-
-  // Schureman 202
-  uM1(a) {
-    const I = d2r * a.I.value
-    const P = d2r * a.P.value
-    const Q =
-      r2d *
-      Math.atan(((5 * Math.cos(I) - 1) / (7 * Math.cos(I) + 1)) * Math.tan(P))
-    return a.xi.value - a.nu.value + Q
-  },
-
-  uModd(a, n) {
-    return (n / 2.0) * corrections.uM2(a)
-  }
-}
-
-export default corrections