@neaps/tide-predictor 0.0.4

package/lib/constituents/index.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _constituent = _interopRequireDefault(require("./constituent"));
+
+var _compoundConstituent = _interopRequireDefault(require("./compound-constituent"));
+
+var _index = _interopRequireDefault(require("../node-corrections/index"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var constituents = {}; // Long Term
+
+constituents.Z0 = (0, _constituent["default"])('Z0', [0, 0, 0, 0, 0, 0, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.SA = (0, _constituent["default"])('Sa', [0, 0, 1, 0, 0, 0, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.SSA = (0, _constituent["default"])('Ssa', [0, 0, 2, 0, 0, 0, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.MM = (0, _constituent["default"])('MM', [0, 1, 0, -1, 0, 0, 0], _index["default"].uZero, _index["default"].fMm);
+constituents.MF = (0, _constituent["default"])('MF', [0, 2, 0, 0, 0, 0, 0], _index["default"].uMf, _index["default"].fMf); // Diurnals
+
+constituents.Q1 = (0, _constituent["default"])('Q1', [1, -2, 0, 1, 0, 0, 1], _index["default"].uO1, _index["default"].fO1);
+constituents.O1 = (0, _constituent["default"])('O1', [1, -1, 0, 0, 0, 0, 1], _index["default"].uO1, _index["default"].fO1);
+constituents.K1 = (0, _constituent["default"])('K1', [1, 1, 0, 0, 0, 0, -1], _index["default"].uK1, _index["default"].fK1);
+constituents.J1 = (0, _constituent["default"])('J1', [1, 2, 0, -1, 0, 0, -1], _index["default"].uJ1, _index["default"].fJ1);
+constituents.M1 = (0, _constituent["default"])('M1', [1, 0, 0, 0, 0, 0, 1], _index["default"].uM1, _index["default"].fM1);
+constituents.P1 = (0, _constituent["default"])('P1', [1, 1, -2, 0, 0, 0, 1], _index["default"].uZero, _index["default"].fUnity);
+constituents.S1 = (0, _constituent["default"])('S1', [1, 1, -1, 0, 0, 0, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.OO1 = (0, _constituent["default"])('OO1', [1, 3, 0, 0, 0, 0, -1], _index["default"].uOO1, _index["default"].fOO1); // Semi diurnals
+
+constituents['2N2'] = (0, _constituent["default"])('2N2', [2, -2, 0, 2, 0, 0, 0], _index["default"].uM2, _index["default"].fM2);
+constituents.N2 = (0, _constituent["default"])('N2', [2, -1, 0, 1, 0, 0, 0], _index["default"].uM2, _index["default"].fM2);
+constituents.NU2 = (0, _constituent["default"])('NU2', [2, -1, 2, -1, 0, 0, 0], _index["default"].uM2, _index["default"].fM2);
+constituents.M2 = (0, _constituent["default"])('M2', [2, 0, 0, 0, 0, 0, 0], _index["default"].uM2, _index["default"].fM2);
+constituents.LAM2 = (0, _constituent["default"])('LAM2', [2, 1, -2, 1, 0, 0, 2], _index["default"].uM2, _index["default"].fM2);
+constituents.L2 = (0, _constituent["default"])('L2', [2, 1, 0, -1, 0, 0, 2], _index["default"].uL2, _index["default"].fL2);
+constituents.T2 = (0, _constituent["default"])('T2', [2, 2, -3, 0, 0, 1, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.S2 = (0, _constituent["default"])('S2', [2, 2, -2, 0, 0, 0, 0], _index["default"].uZero, _index["default"].fUnity);
+constituents.R2 = (0, _constituent["default"])('R2', [2, 2, -1, 0, 0, -1, 2], _index["default"].uZero, _index["default"].fUnity);
+constituents.K2 = (0, _constituent["default"])('K2', [2, 2, 0, 0, 0, 0, 0], _index["default"].uK2, _index["default"].fK2); // Third diurnal
+
+constituents.M3 = (0, _constituent["default"])('M3', [3, 0, 0, 0, 0, 0, 0], function (a) {
+  return _index["default"].uModd(a, 3);
+}, function (a) {
+  return _index["default"].fModd(a, 3);
+}); // Compound
+
+constituents.MSF = (0, _compoundConstituent["default"])('MSF', [{
+  constituent: constituents.S2,
+  factor: 1
+}, {
+  constituent: constituents.M2,
+  factor: -1
+}]); // Diurnal
+
+constituents['2Q1'] = (0, _compoundConstituent["default"])('2Q1', [{
+  constituent: constituents.N2,
+  factor: 1
+}, {
+  constituent: constituents.J1,
+  factor: -1
+}]);
+constituents.RHO = (0, _compoundConstituent["default"])('RHO', [{
+  constituent: constituents.NU2,
+  factor: 1
+}, {
+  constituent: constituents.K1,
+  factor: -1
+}]); // Semi-Diurnal
+
+constituents.MU2 = (0, _compoundConstituent["default"])('MU2', [{
+  constituent: constituents.M2,
+  factor: 2
+}, {
+  constituent: constituents.S2,
+  factor: -1
+}]);
+constituents['2SM2'] = (0, _compoundConstituent["default"])('2SM2', [{
+  constituent: constituents.S2,
+  factor: 2
+}, {
+  constituent: constituents.M2,
+  factor: -1
+}]); // Third-Diurnal
+
+constituents['2MK3'] = (0, _compoundConstituent["default"])('2MK3', [{
+  constituent: constituents.M2,
+  factor: 1
+}, {
+  constituent: constituents.O1,
+  factor: 1
+}]);
+constituents.MK3 = (0, _compoundConstituent["default"])('MK3', [{
+  constituent: constituents.M2,
+  factor: 1
+}, {
+  constituent: constituents.K1,
+  factor: 1
+}]); // Quarter-Diurnal
+
+constituents.MN4 = (0, _compoundConstituent["default"])('MN4', [{
+  constituent: constituents.M2,
+  factor: 1
+}, {
+  constituent: constituents.N2,
+  factor: 1
+}]);
+constituents.M4 = (0, _compoundConstituent["default"])('M4', [{
+  constituent: constituents.M2,
+  factor: 2
+}]);
+constituents.MS4 = (0, _compoundConstituent["default"])('MS4', [{
+  constituent: constituents.M2,
+  factor: 1
+}, {
+  constituent: constituents.S2,
+  factor: 1
+}]);
+constituents.S4 = (0, _compoundConstituent["default"])('S4', [{
+  constituent: constituents.S2,
+  factor: 2
+}]); // Sixth-Diurnal
+
+constituents.M6 = (0, _compoundConstituent["default"])('M6', [{
+  constituent: constituents.M2,
+  factor: 3
+}]);
+constituents.S6 = (0, _compoundConstituent["default"])('S6', [{
+  constituent: constituents.S2,
+  factor: 3
+}]); // Eighth-Diurnals
+
+constituents.M8 = (0, _compoundConstituent["default"])('M8', [{
+  constituent: constituents.M2,
+  factor: 4
+}]);
+var _default = constituents;
+exports["default"] = _default;

package/lib/harmonics/index.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTimeline = exports.getDate = exports["default"] = void 0;
+
+var _prediction = _interopRequireDefault(require("./prediction"));
+
+var _index = _interopRequireDefault(require("../constituents/index"));
+
+var _constants = require("../astronomy/constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var getDate = function 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');
+};
+
+exports.getDate = getDate;
+
+var getTimeline = function getTimeline(start, end, seconds) {
+  seconds = typeof seconds !== 'undefined' ? seconds : 10 * 60;
+  var timeline = [];
+  var endTime = end.getTime() / 1000;
+  var lastTime = start.getTime() / 1000;
+  var startTime = lastTime;
+  var hours = [];
+
+  while (lastTime <= endTime) {
+    timeline.push(new Date(lastTime * 1000));
+    hours.push((lastTime - startTime) / (60 * 60));
+    lastTime += seconds;
+  }
+
+  return {
+    items: timeline,
+    hours: hours
+  };
+};
+
+exports.getTimeline = getTimeline;
+
+var harmonicsFactory = function harmonicsFactory(_ref) {
+  var harmonicConstituents = _ref.harmonicConstituents,
+      phaseKey = _ref.phaseKey,
+      offset = _ref.offset;
+
+  if (!Array.isArray(harmonicConstituents)) {
+    throw new Error('Harmonic constituents are not an array');
+  }
+
+  var constituents = [];
+  harmonicConstituents.forEach(function (constituent, index) {
+    if (typeof constituent.name === 'undefined') {
+      throw new Error('Harmonic constituents must have a name property');
+    }
+
+    if (typeof _index["default"][constituent.name] !== 'undefined') {
+      constituent._model = _index["default"][constituent.name];
+      constituent._phase = _constants.d2r * constituent[phaseKey];
+      constituents.push(constituent);
+    }
+  });
+
+  if (offset !== false) {
+    constituents.push({
+      name: 'Z0',
+      _model: _index["default"].Z0,
+      _phase: 0,
+      amplitude: offset
+    });
+  }
+
+  var start = new Date();
+  var end = new Date();
+  var harmonics = {};
+
+  harmonics.setTimeSpan = function (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 = function (options) {
+    options = typeof options !== 'undefined' ? options : {
+      timeFidelity: 10 * 60
+    };
+    return (0, _prediction["default"])({
+      timeline: getTimeline(start, end, options.timeFidelity),
+      constituents: constituents,
+      start: start
+    });
+  };
+
+  return Object.freeze(harmonics);
+};
+
+var _default = harmonicsFactory;
+exports["default"] = _default;

package/lib/harmonics/prediction.js

@@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _index = _interopRequireDefault(require("../astronomy/index"));
+
+var _constants = require("../astronomy/constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var modulus = function modulus(a, b) {
+  return (a % b + b) % b;
+};
+
+var addExtremesOffsets = function 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;
+};
+
+var getExtremeLabel = function getExtremeLabel(label, highLowLabels) {
+  if (typeof highLowLabels !== 'undefined' && typeof highLowLabels[label] !== 'undefined') {
+    return highLowLabels[label];
+  }
+
+  var labels = {
+    high: 'High',
+    low: 'Low'
+  };
+  return labels[label];
+};
+
+var predictionFactory = function predictionFactory(_ref) {
+  var timeline = _ref.timeline,
+      constituents = _ref.constituents,
+      start = _ref.start;
+
+  var getLevel = function getLevel(hour, modelBaseSpeed, modelU, modelF, modelBaseValue) {
+    var amplitudes = [];
+    var result = 0;
+    constituents.forEach(function (constituent) {
+      var amplitude = constituent.amplitude;
+      var phase = constituent._phase;
+      var f = modelF[constituent.name];
+      var speed = modelBaseSpeed[constituent.name];
+      var u = modelU[constituent.name];
+      var V0 = modelBaseValue[constituent.name];
+      amplitudes.push(amplitude * f * Math.cos(speed * hour + (V0 + u) - phase));
+    }); // sum up each row
+
+    amplitudes.forEach(function (item) {
+      result += item;
+    });
+    return result;
+  };
+
+  var prediction = {};
+
+  prediction.getExtremesPrediction = function (options) {
+    var _ref2 = typeof options !== 'undefined' ? options : {},
+        labels = _ref2.labels,
+        offsets = _ref2.offsets;
+
+    var results = [];
+
+    var _prepare = prepare(),
+        baseSpeed = _prepare.baseSpeed,
+        u = _prepare.u,
+        f = _prepare.f,
+        baseValue = _prepare.baseValue;
+
+    var goingUp = false;
+    var goingDown = false;
+    var lastLevel = getLevel(0, baseSpeed, u[0], f[0], baseValue);
+    timeline.items.forEach(function (time, index) {
+      var hour = timeline.hours[index];
+      var 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 = function () {
+    var results = [];
+
+    var _prepare2 = prepare(),
+        baseSpeed = _prepare2.baseSpeed,
+        u = _prepare2.u,
+        f = _prepare2.f,
+        baseValue = _prepare2.baseValue;
+
+    timeline.items.forEach(function (time, index) {
+      var hour = timeline.hours[index];
+      var prediction = {
+        time: time,
+        hour: hour,
+        level: getLevel(hour, baseSpeed, u[index], f[index], baseValue)
+      };
+      results.push(prediction);
+    });
+    return results;
+  };
+
+  var prepare = function prepare() {
+    var baseAstro = (0, _index["default"])(start);
+    var baseValue = {};
+    var baseSpeed = {};
+    var u = [];
+    var f = [];
+    constituents.forEach(function (constituent) {
+      var value = constituent._model.value(baseAstro);
+
+      var speed = constituent._model.speed(baseAstro);
+
+      baseValue[constituent.name] = _constants.d2r * value;
+      baseSpeed[constituent.name] = _constants.d2r * speed;
+    });
+    timeline.items.forEach(function (time) {
+      var uItem = {};
+      var fItem = {};
+      var itemAstro = (0, _index["default"])(time);
+      constituents.forEach(function (constituent) {
+        var constituentU = modulus(constituent._model.u(itemAstro), 360);
+        uItem[constituent.name] = _constants.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);
+};
+
+var _default = predictionFactory;
+exports["default"] = _default;