reference_shift_demo/metrics.js at main · putmanmodel/reference_shift_demo · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
(function () {
  "use strict";

  function computeCoreMetrics(a, r, size, params) {
    var totalA = 0;
    var totalR = 0;
    var minA = Infinity;
    var maxA = -Infinity;
    var minR = Infinity;
    var maxR = -Infinity;
    var nanCountA = 0;
    var nanCountR = 0;

    for (var i = 0; i < size; i += 1) {
      var av = a[i];
      var rv = r[i];

      if (!Number.isFinite(av)) {
        nanCountA += 1;
      } else {
        totalA += av;
        if (av < minA) {
          minA = av;
        }
        if (av > maxA) {
          maxA = av;
        }
      }

      if (!Number.isFinite(rv)) {
        nanCountR += 1;
      } else {
        totalR += rv;
        if (rv < minR) {
          minR = rv;
        }
        if (rv > maxR) {
          maxR = rv;
        }
      }
    }

    var finiteCountA = size - nanCountA;
    var finiteCountR = size - nanCountR;
    var Abar = finiteCountA > 0 ? (totalA / finiteCountA) : 0;
    var C = finiteCountR > 0 ? (totalR / finiteCountR) : 0;
    return {
      Abar: Abar,
      C: C,
      minA: finiteCountA > 0 ? minA : 0,
      maxA: finiteCountA > 0 ? maxA : 0,
      meanA: Abar,
      minR: finiteCountR > 0 ? minR : 0,
      maxR: finiteCountR > 0 ? maxR : 0,
      meanR: C,
      nanCountA: nanCountA,
      nanCountR: nanCountR
    };
  }

  function computeMetrics(sim) {
    var core = computeCoreMetrics(sim.a, sim.r, sim.size, sim.config);
    var D = window.SimModule.getDamping(sim.config, core.C);
    var Aeff = sim.config.kappa * core.Abar * core.C;

    return {
      Abar: core.Abar,
      C: core.C,
      minA: core.minA,
      maxA: core.maxA,
      meanA: core.meanA,
      minR: core.minR,
      maxR: core.maxR,
      meanR: core.meanR,
      nanCountA: core.nanCountA,
      nanCountR: core.nanCountR,
      D: D,
      Aeff: Aeff,
      instability: Aeff > D,
      dt: Number.isFinite(sim.lastDt) ? sim.lastDt : 0,
      nanFixups: sim.nanFixups || 0
    };
  }

  function computeStripMetrics(sim, params) {
    var core = computeCoreMetrics(sim.a, sim.r, sim.size, params);
    var D = Math.max(0, params.D0 * (1 - (params.alpha * core.C)));
    return {
      A: core.Abar,
      C: core.C,
      D: D
    };
  }

  window.MetricsModule = {
    computeMetrics: computeMetrics,
    computeStripMetrics: computeStripMetrics
  };
}());