PageSourceSearch

https://longpaddock.qld.gov.au/js/climateData_cmip6.js

js longpaddock.qld.gov.au collected 2026-09-24 17:34:30 UTC 94,985 bytes, 2,653 lines download raw bytes

1"use strict";
2
3var _createClass = (function () {
4  function defineProperties(target, props) {
5    for (var i = 0; i < props.length; i++) {
6      var descriptor = props[i];
7      descriptor.enumerable = descriptor.enumerable || false;
8      descriptor.configurable = true;
9      if ("value" in descriptor) descriptor.writable = true;
10      Object.defineProperty(target, descriptor.key, descriptor);
11    }
12  }
13  return function (Constructor, protoProps, staticProps) {
14    if (protoProps) defineProperties(Constructor.prototype, protoProps);
15    if (staticProps) defineProperties(Constructor, staticProps);
16    return Constructor;
17  };
18})();
19
20function _classCallCheck(instance, Constructor) {
21  if (!(instance instanceof Constructor)) {
22    throw new TypeError("Cannot call a class as a function");
23  }
24}
25
26$.fn.hasAttr = function (name) {
27  return this.attr(name) !== undefined;
28};
29
30function distinct(value, index, self) {
31  if (value == "undefined") return false;
32  return self.indexOf(value) === index;
33}
34function haveSame(array1, array2) {
35  if (isEmpty(array1) || isEmpty(array2)) return false;
36  if (array1.length === array2.length) {
37    return array1.every((element) => {
38      if (array2.includes(element)) {
39        return true;
40      }
41
42      return false;
43    });
44  }
45
46  return false;
47}
48
49function areEqual(array1, array2) {
50  if (isEmpty(array1) || isEmpty(array2)) return false;
51  if (array1.length === array2.length) {
52    return array1.every((element, index) => {
53      if (element === array2[index]) {
54        return true;
55      }
56
57      return false;
58    });
59  }
60
61  return false;
62}
63
64const ReportDataType = {
65  Dashboard: Symbol("dashboard"),
66  Timeline: Symbol("timeline"),
67  Table: Symbol("table"),
68  Trend: Symbol("trend"),
69};
70
71var ClimateData = (function () {
72  _createClass(dataObj, [
73    {
74      key: "getGridHeader",
75      value: function getGridHeader() {
76        return new Promise(function (resolve, reject) {
77          //var prefix = (dataObj.prototype.DataPrefix == 'W' || dataObj.prototype.DataPrefix == 'D') ? "-2" : "";
78
79          var tempfile =
80            "Dashboard_files/" +
81            dataObj.scenario +
82            "/grids/" +
83            dataObj.txtinserts.defaults[dataObj.datatype].directory +
84            "_header.csv";
85          if (dataObj.loadedHeaderFile == tempfile) {
86            resolve(false);
87            return;
88          }
89          dataObj.loadedHeaderFile = tempfile;
90
91          Papa.parse(dataObj.dataroot + dataObj.loadedHeaderFile, {
92            download: true,
93            header: true,
94            dynamicTyping: true,
95            complete: function complete(csvobj) {
96              dataObj.gridheader = csvobj.data[0];
97              dataObj.prototype.trigger("HeaderLoaded", dataObj.gridheader);
98            },
99          });
100          resolve(true);
101        });
102      },
103    },
104    {
105      key: "getGrid",
106      value: function getGrid() {
107        return $.getJSON(
108          dataObj.txtroot + "QLD_grid_cmip6.geojson",
109          function (json) {
110            dataObj.geojson = json;
111            dataObj.prototype.trigger("GridLoaded", dataObj.geojson);
112          }
113        );
114      },
115    },
116    {
117      key: "ReportType",
118      get: function get() {
119        return dataObj.reporttype;
120      },
121      set: function set(val) {
122        if (val != dataObj.reporttype) {
123          dataObj.reporttype = val;
124        }
125      },
126    },
127    {
128      key: "LoadData",
129      value: async function LoadData(loadgrid) {
130        if (dataObj.dataloading) {
131          console.log("data already loading");
132          return;
133        }
134        /*if (loadgrid){
135                dataObj.prototype.getGridDataFile(dataObj.selvar);
136                return;
137            }*/
138        var retstr = dataObj.shirename;
139        var result;
140        dataObj.dataloading = true;
141        switch (dataObj.reporttype) {
142          case ReportDataType.Trend:
143            result = dataObj.prototype.LoadTrendData();
144
145            break;
146          case ReportDataType.Timeline:
147            result = await dataObj.prototype.GetHistoricData(
148              dataObj.theme,
149              dataObj.shirename
150            );
151
152            break;
153          case ReportDataType.Table:
154            result = await dataObj.prototype.GetReportData(
155              dataObj.theme,
156              dataObj.selectedOverlay,
157              dataObj.shirename
158            );
159
160            break;
161          default:
162            result = await dataObj.prototype.getRegionalData(dataObj.selvar);
163
164            break;
165        }
166
167        return result;
168      },
169    },
170    {
171      key: "getRegionOverlayData",
172      value: async function getRegionOverlayData() {
173        var tempfile = dataObj.selectedOverlay + "_cmip6.geojson";
174        if (dataObj.loadedRegionFile == tempfile) {
175          return true;
176        }
177        dataObj.loadedRegionFile = tempfile;
178
179        $.getJSON(dataObj.txtroot + dataObj.loadedRegionFile, function (json) {
180          dataObj.regions = json.features
181            .map(function (feat) {
182              return feat
183                .properties[dataObj.txtinserts.regionselect[dataObj.selectedOverlay].Field];
184            })
185            .sort();
186          dataObj.regions.unshift("Queensland");
187          dataObj.prototype.trigger("RegionsChanged", dataObj.regions);
188          dataObj.prototype.trigger("RegionOverlayDataChanged", json);
189          return true;
190        });
191      },
192    },
193    {
194      key: "getRegionalData",
195      value: async function getRegionalData(
196        selectedvariable,
197        fireevent = true
198      ) {
199        var promises = [];
200        if (selectedvariable.substr(0, 6) == "trends") {
201          return true;
202        }
203
204        dataObj.prototype.SelectableSeasons.forEach(function (season) {
205          ["abs", "percent"].forEach(function (datatype) {
206            if (
207              datatype != "percent" ||
208              dataObj.txtinserts.varselect[selectedvariable].PcntAvail
209            ) {
210              if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
211                var tempfile =
212                  "Dashboard_files/" +
213                  dataObj.scenario +
214                  "/" +
215                  dataObj.txtinserts.defaults[dataObj.datatype].directory +
216                  "/" +
217                  "Dashb_" +
218                  selectedvariable +
219                  "_" +
220                  dataObj.spi +
221                  "_" +
222                  dataObj.txtinserts.regionselect[dataObj.selectedOverlay]
223                    .File +
224                  "_" +
225                  season +
226                  "_" +
227                  datatype +
228                  "-change_" +
229                  dataObj.scenario +
230                  ".csv";
231              } else {
232                tempfile =
233                  "Dashboard_files/" +
234                  dataObj.scenario +
235                  "/" +
236                  dataObj.txtinserts.defaults[dataObj.datatype].directory +
237                  "/" +
238                  "Dashb_" +
239                  selectedvariable +
240                  "_" +
241                  dataObj.txtinserts.regionselect[dataObj.selectedOverlay]
242                    .File +
243                  "_" +
244                  season +
245                  "_" +
246                  datatype +
247                  "-change_" +
248                  dataObj.scenario +
249                  ".csv";
250              }
251              if (!dataObj.loadedRegionalDataFiles.includes(tempfile)) {
252                dataObj.loadedRegionalDataFiles.push(tempfile);
253                if (isEmpty(dataObj.regional)) dataObj.regional = {};
254                if (isEmpty(dataObj.regional[dataObj.scenario]))
255                  dataObj.regional[dataObj.scenario] = {};
256                if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
257                  if (isEmpty(dataObj.regional[dataObj.scenario][dataObj.spi]))
258                    dataObj.regional[dataObj.scenario][dataObj.spi] = {};
259                  if (
260                    isEmpty(
261                      dataObj.regional[dataObj.scenario][dataObj.spi][
262                        datatype + "-change"
263                      ]
264                    )
265                  )
266                    dataObj.regional[dataObj.scenario][dataObj.spi][
267                      datatype + "-change"
268                    ] = {};
269                  if (
270                    isEmpty(
271                      dataObj.regional[dataObj.scenario][dataObj.spi][
272                        datatype + "-change"
273                      ][selectedvariable]
274                    )
275                  )
276                    dataObj.regional[dataObj.scenario][dataObj.spi][
277                      datatype + "-change"
278                    ][selectedvariable] = {};
279                } else {
280                  if (
281                    isEmpty(
282                      dataObj.regional[dataObj.scenario][datatype + "-change"]
283                    )
284                  )
285                    dataObj.regional[dataObj.scenario][datatype + "-change"] =
286                      {};
287                  if (
288                    isEmpty(
289                      dataObj.regional[dataObj.scenario][datatype + "-change"][
290                        selectedvariable
291                      ]
292                    )
293                  )
294                    dataObj.regional[dataObj.scenario][datatype + "-change"][
295                      selectedvariable
296                    ] = {};
297                }
298                if (isEmpty(dataObj.bymodel)) dataObj.bymodel = {};
299                if (isEmpty(dataObj.bymodel[dataObj.scenario]))
300                  dataObj.bymodel[dataObj.scenario] = {};
301                if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
302                  if (isEmpty(dataObj.bymodel[dataObj.scenario][dataObj.spi]))
303                    dataObj.bymodel[dataObj.scenario][dataObj.spi] = {};
304                  if (
305                    isEmpty(
306                      dataObj.bymodel[dataObj.scenario][dataObj.spi][
307                        datatype + "-change"
308                      ]
309                    )
310                  )
311                    dataObj.bymodel[dataObj.scenario][dataObj.spi][
312                      datatype + "-change"
313                    ] = {};
314                  if (
315                    isEmpty(
316                      dataObj.bymodel[dataObj.scenario][dataObj.spi][
317                        datatype + "-change"
318                      ][selectedvariable]
319                    )
320                  )
321                    dataObj.bymodel[dataObj.scenario][dataObj.spi][
322                      datatype + "-change"
323                    ][selectedvariable] = {};
324                } else {
325                  if (
326                    isEmpty(
327                      dataObj.bymodel[dataObj.scenario][datatype + "-change"]
328                    )
329                  )
330                    dataObj.bymodel[dataObj.scenario][datatype + "-change"] =
331                      {};
332                  if (
333                    isEmpty(
334                      dataObj.bymodel[dataObj.scenario][datatype + "-change"][
335                        selectedvariable
336                      ]
337                    )
338                  )
339                    dataObj.bymodel[dataObj.scenario][datatype + "-change"][
340                      selectedvariable
341                    ] = {};
342                }
343                promises.push(
344                  new Promise(function (resolve) {
345                    Papa.parse(dataObj.dataroot + tempfile, {
346                      download: true,
347                      header: true,
348                      dynamicTyping: true,
349                      complete: function complete(csvobj) {
350                        csvobj.data.forEach(function (reg, ind) {
351                          var keys = Object.keys(reg);
352                          var location =
353                            reg[
354                              dataObj.txtinserts.regionselect[
355                                dataObj.selectedOverlay
356                              ].File
357                            ];
358                          if (location == "QLD" || location == "Queensland")
359                            location = "Qld";
360                          keys.forEach(function (item, i) {
361                            if (item.endsWith("0")) {
362                              var model = item.substr(0, item.length - 3);
363                              if (model.startsWith("ACCESS-ESM1-5_r20i1p1f1")) {
364                                model = "ACCESS-ESM1-5_r20_oc";
365                              } else if (
366                                model.startsWith("ACCESS-ESM1-5_r40i1p1f1")
367                              ) {
368                                model = "ACCESS-ESM1-5_r40_oc";
369                              } else if (model.endsWith("oc")) {
370                                model =
371                                  model.substring(0, model.indexOf("_")) +
372                                  "_oc";
373                              } else if (!model.startsWith("Mod")) {
374                                model = model.substring(0, model.indexOf("_"));
375                              }
376                              var year = item.substr(
377                                item.length - 2,
378                                item.length
379                              );
380                              if (
381                                model.endsWith("0") &&
382                                model !== "MRI-ESM2-0" &&
383                                model !== "ModAvg11_CCAM10_qld-10" &&
384                                model !== "ModAvg11_CCAM10_qld"
385                              ) {
386                                var p = item.substr(5, 2);
387                                if (
388                                  Data.DataPrefix == "D" ||
389                                  Data.DataPrefix == "W"
390                                ) {
391                                  if (
392                                    isEmpty(
393                                      dataObj.regional[dataObj.scenario][
394                                        dataObj.spi
395                                      ][datatype + "-change"][selectedvariable][
396                                        location
397                                      ]
398                                    )
399                                  )
400                                    dataObj.regional[dataObj.scenario][
401                                      dataObj.spi
402                                    ][datatype + "-change"][selectedvariable][
403                                      location
404                                    ] = {};
405                                  if (
406                                    isEmpty(
407                                      dataObj.regional[dataObj.scenario][
408                                        dataObj.spi
409                                      ][datatype + "-change"][selectedvariable][
410                                        location
411                                      ][dataObj.txtinserts.periodabbrev[year]]
412                                    )
413                                  )
414                                    dataObj.regional[dataObj.scenario][
415                                      dataObj.spi
416                                    ][datatype + "-change"][selectedvariable][
417                                      location
418                                    ][dataObj.txtinserts.periodabbrev[year]] =
419                                      {};
420                                  if (
421                                    isEmpty(
422                                      dataObj.regional[dataObj.scenario][
423                                        dataObj.spi
424                                      ][datatype + "-change"][selectedvariable][
425                                        location
426                                      ][dataObj.txtinserts.periodabbrev[year]][
427                                        season
428                                      ]
429                                    )
430                                  )
431                                    dataObj.regional[dataObj.scenario][
432                                      dataObj.spi
433                                    ][datatype + "-change"][selectedvariable][
434                                      location
435                                    ][dataObj.txtinserts.periodabbrev[year]][
436                                      season
437                      
437              ] = {};
438
439                                  dataObj.regional[dataObj.scenario][
440                                    dataObj.spi
441                                  ][datatype + "-change"][selectedvariable][
442                                    location
443                                  ][dataObj.txtinserts.periodabbrev[year]][
444                                    season
445                                  ]["pcnt" + p] = reg[item];
446                                } else {
447                                  if (
448                                    isEmpty(
449                                      dataObj.regional[dataObj.scenario][
450                                        datatype + "-change"
451                                      ][selectedvariable][location]
452                                    )
453                                  )
454                                    dataObj.regional[dataObj.scenario][
455                                      datatype + "-change"
456                                    ][selectedvariable][location] = {};
457                                  if (
458                                    isEmpty(
459                                      dataObj.regional[dataObj.scenario][
460                                        datatype + "-change"
461                                      ][selectedvariable][location][
462                                        dataObj.txtinserts.periodabbrev[year]
463                                      ]
464                                    )
465                                  )
466                                    dataObj.regional[dataObj.scenario][
467                                      datatype + "-change"
468                                    ][selectedvariable][location][
469                                      dataObj.txtinserts.periodabbrev[year]
470                                    ] = {};
471                                  if (
472                                    isEmpty(
473                                      dataObj.regional[dataObj.scenario][
474                                        datatype + "-change"
475                                      ][selectedvariable][location][
476                                        dataObj.txtinserts.periodabbrev[year]
477                                      ][season]
478                                    )
479                                  )
480                                    dataObj.regional[dataObj.scenario][
481                                      datatype + "-change"
482                                    ][selectedvariable][location][
483                                      dataObj.txtinserts.periodabbrev[year]
484                                    ][season] = {};
485
486                                  dataObj.regional[dataObj.scenario][
487                                    datatype + "-change"
488                                  ][selectedvariable][location][
489                                    dataObj.txtinserts.periodabbrev[year]
490                                  ][season]["pcnt" + p] = reg[item];
491                                }
492                              } else {
493                                if (
494                                  Data.DataPrefix == "D" ||
495                                  Data.DataPrefix == "W"
496                                ) {
497                                  if (
498                                    isEmpty(
499                                      dataObj.bymodel[dataObj.scenario][
500                                        dataObj.spi
501                                      ][datatype + "-change"][selectedvariable][
502                                        location
503                                      ]
504                                    )
505                                  )
506                                    dataObj.bymodel[dataObj.scenario][
507                                      dataObj.spi
508                                    ][datatype + "-change"][selectedvariable][
509                                      location
510                                    ] = {};
511                                  if (
512                                    isEmpty(
513                                      dataObj.bymodel[dataObj.scenario][
514                                        dataObj.spi
515                                      ][datatype + "-change"][selectedvariable][
516                                        location
517                                      ][dataObj.txtinserts.periodabbrev[year]]
518                                    )
519                                  )
520                                    dataObj.bymodel[dataObj.scenario][
521                                      dataObj.spi
522                                    ][datatype + "-change"][selectedvariable][
523                                      location
524                                    ][dataObj.txtinserts.periodabbrev[year]] =
525                                      {};
526                                  if (
527                                    isEmpty(
528                                      dataObj.bymodel[dataObj.scenario][
529                                        dataObj.spi
530                                      ][datatype + "-change"][selectedvariable][
531                                        location
532                                      ][dataObj.txtinserts.periodabbrev[year]][
533                                        season
534                                      ]
535                                    )
536                                  )
537                                    dataObj.bymodel[dataObj.scenario][
538                                      dataObj.spi
539                                    ][datatype + "-change"][selectedvariable][
540                                      location
541                                    ][dataObj.txtinserts.periodabbrev[year]][
542                                      season
543                                    ] = {};
544
545                                  dataObj.bymodel[dataObj.scenario][
546                                    dataObj.spi
547                                  ][datatype + "-change"][selectedvariable][
548                                    location
549                                  ][dataObj.txtinserts.periodabbrev[year]][
550                                    season
551                                  ][model] = reg[item];
552                                } else {
553                                  if (
554                                    isEmpty(
555                                      dataObj.bymodel[dataObj.scenario][
556                                        datatype + "-change"
557                                      ][selectedvariable][location]
558                                    )
559                                  )
560                                    dataObj.bymodel[dataObj.scenario][
561                                      datatype + "-change"
562                                    ][selectedvariable][location] = {};
563                                  if (
564                                    isEmpty(
565                                      dataObj.bymodel[dataObj.scenario][
566                                        datatype + "-change"
567                                      ][selectedvariable][location][
568                                        dataObj.txtinserts.periodabbrev[year]
569                                      ]
570                                    )
571                                  )
572                                    dataObj.bymodel[dataObj.scenario][
573                                      datatype + "-change"
574                                    ][selectedvariable][location][
575                                      dataObj.txtinserts.periodabbrev[year]
576                                    ] = {};
577                                  if (
578                                    isEmpty(
579                                      dataObj.bymodel[dataObj.scenario][
580                                        datatype + "-change"
581                                      ][selectedvariable][location][
582                                        dataObj.txtinserts.periodabbrev[year]
583                                      ][season]
584                                    )
585                                  )
586                                    dataObj.bymodel[dataObj.scenario][
587                                      datatype + "-change"
588                                    ][selectedvariable][location][
589                                      dataObj.txtinserts.periodabbrev[year]
590                                    ][season] = {};
591
592                                  dataObj.bymodel[dataObj.scenario][
593                                    datatype + "-change"
594                                  ][selectedvariable][location][
595                                    dataObj.txtinserts.periodabbrev[year]
596                                  ][season][model] = reg[item];
597                                }
598                              }
599                            }
600                          });
601                        });
602                        resolve(true);
603                      },
604                    });
605                  })
606                );
607              }
608            }
609          });
610        });
611
612        return await Promise.all(promises).then(function (data) {
613          if (
614            !isEmpty(data) &&
615            data.every(function (item) {
616              return item;
617            })
618          )
619            if (fireevent)
620              dataObj.prototype.trigger("DataLoaded", selectedvariable);
621            else if (fireevent) dataObj.prototype.trigger("DataLoaded", false);
622          dataObj.dataloading = false;
623        });
624      },
625    },
626    {
627      key: "getGridDataFile",
628      value: function getGridDataFile(vartype) {
629        return new Promise(function (resolve, reject) {
630          dataObj.prototype.getGridHeader().then(function () {
631            var datatype =
632              dataObj.txtinserts.varselect[dataObj.selvar].Type == "abs" &&
633              !(
634                dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch &&
635                dataObj.isPcnt
636              )
637                ? "_abs_change"
638                : "_percent_change";
639
640            var bias = dataObj.isBias ? "_bc" : "";
641
642            if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
643              var tempfile =
644                "Dashboard_files/" +
645                dataObj.scenario +
646                "/grids/" +
647                vartype +
648                "_" +
649                dataObj.spi +
650                datatype +
651                "_grid.csv";
652            } else {
653              tempfile =
654                "Dashboard_files/" +
655                dataObj.scenario +
656                "/grids/" +
657                vartype +
658                datatype +
659                "_grid.csv";
660            }
661
662            if (dataObj.loadedGridDataFile == tempfile) {
663              dataObj.prototype.trigger("GridDataChanged");
664              resolve(false);
665              return;
666            }
667            dataObj.loadedGridDataFile = tempfile;
668
669            $.get(
670              dataObj.dataroot + dataObj.loadedGridDataFile,
671              function (text) {
672                Papa.parse(text, {
673                  //header: true,
674                  dynamicTyping:
675                    dataObj.variableColours[dataObj.selvar].multiplier == 1,
676                  transform:
677                    dataObj.variableColours[dataObj.selvar].multiplier != 1
678                      ? function (val) {
679                          return (
680                            Number(val) *
681                            dataObj.variableColours[dataObj.selvar].multiplier
682                          ).toFixed(1);
683                        }
684                      : undefined,
685                  complete: function complete(csvobj) {
686                    dataObj.catagories = csvobj.data;
687                    dataObj.prototype.trigger(
688                      "GridDataChanged",
689                      dataObj.catagories
690                    );
691                    resolve(true);
692                  },
693                });
694              }
695            );
696          });
697          /*var p2 = $.get(dataroot + selvar + "_grid/" + selvar + "_model_qld.csv", function(text) {
698                    Papa.parse(text, {
699                        //header: true,
700                        dynamicTyping: true,
701                        complete: function(csvobj) {
702                            regionalExtremes = csvobj.data;
703                        }
704                    });*/
705        });
706      },
707    },
708    {
709      key: "parseData",
710      value: function parseData(varPrefix, mapReg, how) {
711        var data = void 0;
712        return new Promise(function (resolve) {
713          Papa.parse(
714            dataObj.prototype.DataRoot +
715              varPrefix +
716              "_" +
717              how +
718              "_" +
719              mapReg +
720              ".csv",
721            {
722              header: true,
723              delimiter: ",",
724              download: true,
725              dynamicTyping: true,
726              complete: function complete(results) {
727                resolve(results.data);
728              },
729            }
730          );
731        });
732      },
733    },
734    {
735      key: "GetHistoricData",
736      value: function GetHistoricData(theme, region, fireevent = true) {
737        return new Promise(function (resolve, reject) {
738          var data = void 0;
739
740          //if (dataObj.historicdata != undefined) resolve(dataObj.historicdata);
741          //var alteredregion = region.split(' ').join('-').split(',').join('');
742          //Papa.parse(dataObj.prototype.DataRoot + varPrefix + '_' + how + '_' + mapReg + '.csv', {
743          if (theme == "Wet") {
744            var time_dir = "Wetness";
745          } else time_dir = theme;
746          if (
747            (theme == "Wet" || theme == "Drought") &&
748            dataObj.selectedOverlay == "Locations"
749          ) {
750            dataObj.selectedOverlay = "LGA";
751            dataObj.prototype.getRegionOverlayData();
752            region = "Queensland";
753          }
754          Papa.parse(
755            dataObj.prototype.DataRoot +
756              "Timeseries/" +
757              time_dir +
758              "/" +
759              theme +
760              "_" +
761              dataObj.txtinserts.regionselect[dataObj.selectedOverlay].File +
762              "_" +
763              (region.toLowerCase() == "qld" ? "Queensland" : region) +
764              ".csv",
765            {
766              header: true,
767              delimiter: ",",
768              download: true,
769              dynamicTyping: true,
770              complete: function complete(results) {
771                //var models = ["ACCESS1-3","CESM1-CAM5","CanESM2","NorESM1-M"];
772                var seasons = [];
773                var data = _.groupBy(results.data, "variable");
774                data = _.mapValues(data, function (value, vari) {
775                  var regiondata = _.groupBy(value, "experiment");
776                  return _.mapValues(regiondata, function (value, scene) {
777                    //if (vari.startsWith("spi")){
778                    var catdata =
779                      vari.startsWith("SPI") || vari.startsWith("SPEI")
780                        ? _.groupBy(value, "category")
781                        : _.groupBy(value, "season");
782                    return _.mapValues(catdata, function (value, cat) {
783                      seasons.push(cat);
784                      var vartype = _.groupBy(value, "model");
785                      return _.mapValues(vartype, function (value, model) {
786                        return _.omit(
787                          value[0],
788                          value[0]["1980"] == "NA"
789                            ? [
790                                "region",
791                                "variable",
792                                "model",
793                                "experiment",
794                                "category",
795                                "1980",
796                              ]
797                            : [
798                                "region",
799                                "variable",
800                                "model",
801                                "experiment",
802                                "category",
803                              ]
804                        );
805                      });
806                    });
807                    /*}else{
808                                    var vartype = _.groupBy(value,"model");
809                                    return _.mapValues(vartype,function(value,model){
810                                        return _.omit(value[0], ['region', 'variable','model','experiment','category']);
811                                    });
812                                }*/
813                  });
814                });
815
816                if (
817                  dataObj.datatype == "timeline" &&
818                  dataObj.theme != "HeatW"
819                ) {
820                  dataObj.prototype.SelectableSeasons =
821                    dataObj.txtinserts.defaults[
822                      dataObj.txtinserts.themeselect[dataObj.theme].Defaults
823                    ].seasons;
824                } else if (
825                  dataObj.datatype == "timeline" &&
826                  dataObj.theme == "HeatW" &&
827                  dataObj.selvar == "HWAh"
828                ) {
829                  dataObj.prototype.SelectableSeasons =
830                    dataObj.txtinserts.defaults[
831                      dataObj.txtinserts.themeselect[dataObj.theme].Defaults
832                    ].seasons;
833                } else if (
834                  dataObj.datatype == "timeline" &&
835                  dataObj.theme == "HeatW" &&
836                  (dataObj.selvar == "HWF" ||
837                    dataObj.selvar == "HWL" ||
838                    dataObj.selvar == "HWD")
839                ) {
840                  dataObj.prototype.SelectableSeasons =
841                    dataObj.txtinserts.defaults[
842                      dataObj.txtinserts.themeselect[dataObj.theme].Defaults
843                    ].seasons2;
844                } else
845                  dataObj.prototype.SelectableSeasons =
846                    seasons.filter(distinct);
847
848                if (dataObj.historicdata == undefined) {
849                  dataObj.historicdata = {};
850                }
851                dataObj.historicdata[region] = _.mapKeys(
852                  _.omit(data, "undefined"),
853                  function (value, key) {
854                    return key.split("-").join(" ");
855                  }
856                );
857                if (fireevent)
858                  dataObj.prototype.trigger("DataLoaded", "Historic");
859                dataObj.dataloading = false;
860                resolve(true);
861              },
862            }
863          );
864        });
865      },
866    },
867    {
868      key: "GetReportData",
869      value: function GetReportData(
870        theme,
871        regiontype,
872        region,
873        fireevent = true
874      ) {
875        return new Promise(function (resolve, reject) {
876          var data = void 0;
877          var alteredregion = region.split(" ").join("-");
878          if (dataObj.theme == "Drought" || dataObj.theme == "Wet") {
879            var table_file =
880              dataObj.prototype.DataRoot +
881              "Table_Summaries/" +
882              theme +
883              "_" +
884              dataObj.spi +
885              "_" +
886              dataObj.txtinserts.regionselect[regiontype].File +
887              ".csv";
888          } else {
889            table_file =
890              dataObj.prototype.DataRoot +
891              "Table_Summaries/" +
892              theme +
893              "_" +
894              dataObj.txtinserts.regionselect[regiontype].File +
895              ".csv";
896          }
897          Papa.parse(table_file, {
898            beforeFirstChunk: function (chunk) {
899              /*var rows = chunk.split( /\r\n|\r|\n/ );
900                        var headings = rows[0].split(",");
901                        var second = rows[1].split(",");
902                        var third = rows[2].split(",");
903                        for (let index = 0; index < headings.length; index++) {
904                            if (headings[index] != "")
905                                headings[index] += "_" +second[index] + "_" + third[index]; 
906                            else
907                                headings[index] = third[index];                           
908                        }
909                        rows.splice(0,2);                               
910                        rows[0] = headings.join(",");
911                        rows.unshift(dataObj.headings);
912                        return rows.join("\n");*/
913              return dataObj.headings + "\n" + chunk;
914            },
915            header: true,
916            delimiter: ",",
917            download: true,
918            dynamicTyping: true,
919            complete: function complete(results) {
920              var data = _.groupBy(results.data, "Regiontype");
921              delete data[null];
922              data = _.mapValues(data, function (value, key) {
923                var regiondata = _.groupBy(value, "Region");
924                return _.mapValues(regiondata, function (value, key) {
925                  var vartype = _.groupBy(value, "Variable");
926                  //Some unusual coastal values were detected for the WSD and CSD indices on the cmip6 version of the dashboard. These have been removed until they are corrected.
927                  delete vartype["WSD"];
928                  delete vartype["CSD"];
929                  return _.mapValues(vartype, function (value, key) {
930                    var season = _.groupBy(value, "Season");
931                    return _.mapValues(season, function (value, key) {
932                      return {
933                        2030: {
934                          SSP1: {
935                            Mean: value[0]["2030_SSP1-2.6_Mean"],
936                            Min: value[0]["2030_SSP1-2.6_Min"],
937                            Max: value[0]["2030_SSP1-2.6_Max"],
938                          },
939                          SSP2: {
940                            Mean: value[0]["2030_SSP2-4.5_Mean"],
941                            Min: value[0]["2030_SSP2-4.5_Min"],
942                            Max: value[0]["2030_SSP2-4.5_Max"],
943                          },
944                          SSP3: {
945                            Mean: value[0]["2030_SSP3-7.0_Mean"],
946                            Min: value[0]["2030_SSP3-7.0_Min"],
947                            Max: value[0]["2030_SSP3-7.0_Max"],
948                          },
949                        },
950                        2050: {
951                          SSP1: {
952                            Mean: value[0]["2050_SSP1-2.6_Mean"],
953                            Min: value[0]["2050_SSP1-2.6_Min"],
954                            Max: value[0]["2050_SSP1-2.6_Max"],
955                          },
956                          SSP2: {
957                            Mean: value[0]["2050_SSP2-4.5_Mean"],
958                            Min: value[0]["2050_SSP2-4.5_Min"],
959                            Max: value[0]["2050_SSP2-4.5_Max"],
960                          },
961                          SSP3: {
962                            Mean: value[0]["2050_SSP3-7.0_Mean"],
963                            Min: value[0]["2050_SSP3-7.0_Min"],
964                            Max: value[0]["2050_SSP3-7.0_Max"],
965                          },
966                        },
967                        2070: {
968                          SSP1: {
969                            Mean: value[0]["2070_SSP1-2.6_Mean"],
970                            Min: value[0]["2070_SSP1-2.6_Min"],
971                            Max: value[0]["2070_SSP1-2.6_Max"],
972                          },
973                          SSP2: {
974                            Mean: value[0]["2070_SSP2-4.5_Mean"],
975                            Min: value[0]["2070_SSP2-4.5_Min"],
976                            Max: value[0]["2070_SSP2-4.5_Max"],
977                          },
978                          SSP3: {
979                            Mean: value[0]["2070_SSP3-7.0_Mean"],
980                            Min: value[0]["2070_SSP3-7.0_Min"],
981                            Max: value[0]["2070_SSP3-7.0_Max"],
982                          },
983                        },
984                        2090: {
985                          SSP1: {
986                            Mean: value[0]["2090_SSP1-2.6_Mean"],
987                            Min: value[0]["2090_SSP1-2.6_Min"],
988                            Max: value[0]["2090_SSP1-2.6_Max"],
989                          },
990                          SSP2: {
991                            Mean: value[0]["2090_SSP2-4.5_Mean"],
992                            Min: value[0]["2090_SSP2-4.5_Min"],
993                            Max: value[0]["2090_SSP2-4.5_Max"],
994                          },
995                          SSP3: {
996                            Mean: value[0]["2090_SSP3-7.0_Mean"],
997                            Min: value[0]["2090_SSP3-7.0_Min"],
998                            Max: value[0]["2090_SSP3-7.0_Max"],
999                          },
1000                        },
1001                        Ensemble_Mean: value[0]["ensemble_mean"],
1002                      };
1003                    });
1004                  });
1005                });
1006              });
1007              delete data[null];
1008              /*if (dataObj.reportdata == undefined){
1009                            dataObj.reportdata = data;  
1010                        } else{
1011                            $.extend(true, dataObj.reportdata, data );
1012                        } */
1013              dataObj.reportdata = data;
1014              if (fireevent) dataObj.prototype.trigger("DataLoaded", "Report");
1015              dataObj.dataloading = false;
1016
1017              //dataObj.regions = Object.keys(data[dataObj.selectedOverlay]);
1018              //dataObj.prototype.trigger('RegionsChanged', dataObj.regions);
1019
1020              resolve(region);
1021            },
1022          });
1023        });
1024      },
1025    },
1026    {
1027      key: "GetCalculatedRegionData",
1028      value: async function GetCalculatedRegionData(shirename) {
1029        //var Alt = dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch && !dataObj.isPcnt ? "Alt" : "";
1030
1031        var data = {
1032          ModelABS: {},
1033          RegionABS: {},
1034          ModelPcnt: {},
1035          RegionPcnt: {},
1036          CalcRegional: {},
1037          Units: dataObj.prototype.UnitStr,
1038          SeasonStr: dataObj.prototype.SeasonStr,
1039          PeriodStr: dataObj.prototype.PeriodLongStr,
1040          VariableStr: dataObj.prototype.VariableStr,
1041          ScenarioStr: dataObj.prototype.ScenarioStr,
1042          SPIStr: dataObj.prototype.SPIStr,
1043          Margin: dataObj.txtinserts.varselect[dataObj.selvar].margin,
1044          AxisStr:
1045            dataObj.txtinserts.varselect[dataObj.selvar][
1046              dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch &&
1047              !dataObj.isPcnt
1048                ? "AltAxis"
1049                : "Axis"
1050            ] +
1051            " (" +
1052            dataObj.prototype.UnitStr +
1053            ")",
1054          Seasons: dataObj.prototype.SelectableSeasons,
1055          Models: [],
1056          Periods: [],
1057          Means: {},
1058          SeasonalMin: {},
1059          SeasonalMax: {},
1060          PeriodMin: {},
1061          PeriodMax: {},
1062        };
1063        try {
1064          if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
1065            data.ModelABS =
1066              dataObj.bymodel[dataObj.scenario][dataObj.spi]["abs-change"][
1067                dataObj.selvar
1068              ][shirename];
1069            data.RegionABS =
1070              dataObj.regional[dataObj.scenario][dataObj.spi]["abs-change"][
1071                dataObj.selvar
1072              ][shirename];
1073          } else {
1074            data.ModelABS =
1075              dataObj.bymodel[dataObj.scenario]["abs-change"][dataObj.selvar][
1076                shirename
1077              ];
1078            data.RegionABS =
1079              dataObj.regional[dataObj.scenario]["abs-change"][dataObj.selvar][
1080                shirename
1081              ];
1082          }
1083        } catch (error) {
1084          await dataObj.prototype.LoadData();
1085          console.log("Appears data is missing / redo data load");
1086          return await GetCalculatedRegionData(shirename);
1087        }
1088        try {
1089          if (Data.DataPrefix == "D" || Data.DataPrefix == "W") {
1090            data.ModelPcnt =
1091              dataObj.bymodel[dataObj.scenario][dataObj.spi]["percent-change"][
1092                dataObj.selvar
1093              ][shirename];
1094            data.RegionPcnt =
1095              dataObj.regional[dataObj.scenario][dataObj.spi]["percent-change"][
1096                dataObj.selvar
1097              ][shirename];
1098          } else {
1099            data.ModelPcnt =
1100              dataObj.bymodel[dataObj.scenario]["percent-change"][
1101                dataObj.selvar
1102              ][shirename];
1103            data.RegionPcnt =
1104              dataObj.regional[dataObj.scenario]["percent-change"][
1105                dataObj.selvar
1106              ][shirename];
1107          }
1108        } catch (error) {
1109          //console.log("missing base data");
1110        }
1111
1112        data.CalcRegional =
1113          dataObj.txtinserts.varselect[dataObj.selvar].Type == "abs" &&
1114          !(
1115            dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch &&
1116            dataObj.isPcnt
1117          )
1118            ? data.ModelABS
1119            : data.ModelPcnt;
1120        try {
1121          data.Models = Object.keys(
1122            data.CalcRegional[data.PeriodStr][dataObj.prototype.SelectedSeason]
1123          ).sort();
1124        } catch (error) {
1125          await dataObj.prototype.LoadData();
1126          console.log(
1127            "Appears data has not been completely loaded / redo data load"
1128          );
1129          return await GetCalculatedRegionData(shirename);
1130        }
1131
1132        if (data.Models.indexOf("ModAvg11_CCAM10_qld") == -1) {
1133          var indx = data.Models.indexOf("ModAvg11_CCAM10_qld-10");
1134        } else indx = data.Models.indexOf("ModAvg11_CCAM10_qld");
1135        var del = data.Models.splice(indx, 1);
1136        data.Models.push(del[0]);
1137
1138        //var modelsSorted = Object.keys(data.CalcRegional[data.PeriodStr].annual).sort(function(a, b) { data.CalcRegional[data.PeriodStr].annual[a] - data.CalcRegional[data.PeriodStr].annual[b]; });
1139        data.SeasonalMin.All =
1140          data.CalcRegional[data.PeriodStr][dataObj.prototype.SelectedSeason][
1141            data.Models[0]
1142          ];
1143        data.SeasonalMax.All =
1144          data.CalcRegional[data.PeriodStr][dataObj.prototype.SelectedSeason][
1145            data.Models[0]
1146          ];
1147        data.PeriodMin.All =
1148          data.CalcRegional[data.PeriodStr][dataObj.prototype.SelectedSeason][
1149            data.Models[0]
1150          ];
1151        data.PeriodMax.All =
1152          data.CalcRegional[data.PeriodStr][dataObj.prototype.SelectedSeason][
1153            data.Models[0]
1154          ];
1155        data.Periods = Object.keys(data.CalcRegional).sort(function (a, b) {
1156          return data.CalcRegional[a] - data.CalcRegional[b];
1157        });
1158
1159        var num = 0;
1160        var sum = 0;
1161
1162        data.Seasons.forEach(function (season) {
1163          num = 0;
1164          sum = 0;
1165          data.SeasonalMin[season] =
1166            data.CalcRegional[data.PeriodStr][season][data.Models[0]];
1167          data.SeasonalMax[season] =
1168            data.CalcRegional[data.PeriodStr][season][data.Models[0]];
1169          data.Models.forEach(function (modname) {
1170            if (
1171              data.SeasonalMin.All >
1172              data.CalcRegional[data.PeriodStr][season][modname]
1173            )
1174              data.SeasonalMin.All =
1175                data.CalcRegional[data.PeriodStr][season][modname];
1176            if (
1177              data.SeasonalMax.All <
1178              data.CalcRegional[data.PeriodStr][season][modname]
1179            )
1180              data.SeasonalMax.All =
1181                data.CalcRegional[data.PeriodStr][season][modname];
1182            if (
1183              data.SeasonalMin[season] >
1184              data.CalcRegional[data.PeriodStr][season][modname]
1185            )
1186              data.SeasonalMin[season] =
1187                data.CalcRegional[data.PeriodStr][season][modname];
1188            if (
1189              data.SeasonalMax[season] <
1190              data.CalcRegional[data.PeriodStr][season][modname]
1191            )
1192              data.SeasonalMax[season] =
1193                data.CalcRegional[data.PeriodStr][season][modname];
1194
1195            sum += data.CalcRegional[data.PeriodStr][season][modname];
1196            num += 1;
1197          });
1198          data.Means[season] = sum / num;
1199        });
1200
1201        data.Periods.forEach(function (period) {
1202          num = 0;
1203          sum = 0;
1204          data.PeriodMin[period] =
1205            data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1206              data.Models[0]
1207            ];
1208          data.PeriodMax[period] =
1209            data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1210              data.Models[0]
1211            ];
1212          data.Models.forEach(function (modname) {
1213            if (
1214              data.PeriodMin.All >
1215              data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1216                modname
1217              ]
1218            )
1219              data.PeriodMin.All =
1220                data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1221                  modname
1222                ];
1223            if (
1224              data.PeriodMax.All <
1225              data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1226                modname
1227              ]
1228            )
1229              data.PeriodMax.All =
1230                data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1231                  modname
1232                ];
1233            if (
1234              data.PeriodMin[period] >
1235              data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1236                modname
1237              ]
1238            )
1239              data.PeriodMin[period] =
1240                data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1241                  modname
1242                ];
1243            if (
1244              data.PeriodMax[period] <
1245              data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1246                modname
1247              ]
1248            )
1249              data.PeriodMax[period] =
1250                data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1251                  modname
1252                ];
1253
1254            sum +=
1255              data.CalcRegional[period][dataObj.prototype.SelectedSeason][
1256                modname
1257              ];
1258            num += 1;
1259          });
1260          data.Means[period] = sum / num;
1261        });
1262
1263        return data;
1264      },
1265    },
1266    {
1267      key: "RegionalReportData",
1268      value: async function RegionalReportData() {
1269        var overlayname =
1270          dataObj.txtinserts.regionselect[dataObj.selectedOverlay].File;
1271        if (
1272          isEmpty(dataObj.reportdata) ||
1273          isEmpty(dataObj.reportdata[overlayname])
1274        ) {
1275          var tempregion = await dataObj.prototype.GetReportData(
1276            dataObj.theme,
1277            dataObj.selectedOverlay,
1278            dataObj.shirename,
1279            false
1280          );
1281        }
1282
1283        if (dataObj.shirename.toLowerCase() == "qld")
1284          return dataObj.reportdata[overlayname]["Queensland"];
1285
1286        if (!isEmpty(dataObj.reportdata[overlayname][dataObj.shirename]))
1287          return dataObj.reportdata[overlayname][dataObj.shirename];
1288
1289        var alteredregion = dataObj.shirename.split(" ").join("-");
1290
1291        if (!isEmpty(dataObj.reportdata[overlayname][alteredregion]))
1292          return dataObj.reportdata[overlayname][alteredregion];
1293
1294        return dataObj.reportdata[overlayname][alteredregion];
1295      },
1296    },
1297    {
1298      key: "RegionalGraphData",
1299      value: async function RegionalGraphData(scenario, season) {
1300        if (isEmpty(scenario)) scenario = dataObj.scenario;
1301
1302        if (
1303          isEmpty(dataObj.historicdata) ||
1304          isEmpty(dataObj.historicdata[dataObj.shirename]) ||
1305          isEmpty(dataObj.historicdata[dataObj.shirename][dataObj.selvar]) ||
1306          isEmpty(
1307            dataObj.historicdata[dataObj.shirename][dataObj.selvar][scenario]
1308          )
1309        ) {
1310          await dataObj.prototype.GetHistoricData(
1311            dataObj.theme,
1312            dataObj.shirename,
1313            false
1314          );
1315          //dataObj.prototype.trigger('DataLoaded','Historic');
1316        }
1317        if (season == null) season = dataObj.selseason;
1318
1319        var selvar = dataObj.selvar;
1320
1321        if (dataObj.theme == "Drought" || dataObj.theme == "Wet") {
1322          season = dataObj.txtinserts.seasonselect[season].toLowerCase();
1323          if (dataObj.spi == "SPI") {
1324            selvar = "SPI12";
1325          } else selvar = "SPEI12";
1326        }
1327
1328        var partdata =
1329          dataObj.historicdata[dataObj.shirename][selvar][scenario][season];
1330
1331        dataObj.models = _.keys(partdata);
1332        var years = _.map(_.keys(partdata[dataObj.models[0]]), Number);
1333        if (dataObj.theme !== "Drought" && dataObj.theme !== "Wet") {
1334          years.pop();
1335
1336          partdata = _.mapValues(partdata, function (o) {
1337            var t = _.values(o);
1338            t.pop();
1339            return t;
1340          });
1341        } else {
1342          partdata = _.mapValues(partdata, function (o) {
1343            var t = _.values(o);
1344            return t;
1345          });
1346        }
1347        //create function to omit certain models during the estimation of the range and Average
1348        const omit = (obj, arr) =>
1349          Object.fromEntries(
1350            Object.entries(obj).filter(([k]) => !arr.includes(k))
1351          );
1352
1353        //create function to select certain models during the estimation of the range and Average
1354        const select = (obj, arr) =>
1355          Object.fromEntries(
1356            Object.entries(obj).filter(([k]) => arr.includes(k))
1357          );
1358
1359        //for the range estimation and presentation of models in the timeseries we want to exclude the ModAvg11_CCAM10
1360        var partdata1 = omit(partdata, ["ModAvg11_CCAM10"]);
1361        //partdata1 = Object.values(partdata1).filter(value => (value !== 'NaN' && value !== 'NA'));
1362
1363        //for the model average estimation we want an 11 model average using the ensemble averages for the 3 models run in multiple configurations
1364        var partdata2 = select(partdata, ["ModAvg11_CCAM10"]);
1365
1366        //Rename Models
1367        // Original Model names
1368        var O_mod_names = [
1369          "ACCESS-CM2_r2i1p1f1_CCAM10oc",
1370          "ACCESS-ESM1-5_r20i1p1f1_CCAM10oc",
1371          "ACCESS-ESM1-5_r40i1p1f1_CCAM10oc",
1372          "ACCESS-ESM1-5_r6i1p1f1_CCAM10",
1373          "CMCC-ESM2_r1i1p1f1_CCAM10",
1374          "CNRM-CM6-1-HR_r1i1p1f2_CCAM10",
1375          "CNRM-CM6-1-HR_r1i1p1f2_CCAM10oc",
1376          "EC-Earth3_r1i1p1f1_CCAM10",
1377          "FGOALS-g3_r4i1p1f1_CCAM10",
1378          "GFDL-ESM4_r1i1p1f1_CCAM10",
1379          "GISS-E2-1-G_r2i1p1f2_CCAM10",
1380          "MPI-ESM1-2-LR_r9i1p1f1_CCAM10",
1381          "MRI-ESM2-0_r1i1p1f1_CCAM10",
1382          "NorESM2-MM_r1i1p1f1_CCAM10",
1383          "NorESM2-MM_r1i1p1f1_CCAM10oc",
1384        ];
1385
1386        // New Model names
1387        var N_mod_names = [
1388          "ACCESS-CM2_oc",
1389          "ACCESS-ESM1-5_r20_oc",
1390          "ACCESS-ESM1-5_r40_oc",
1391          "ACCESS-ESM1-5",
1392          "CMCC-ESM2",
1393          "CNRM-CM6-1-HR",
1394          "CNRM-CM6-1-HR_oc",
1395          "EC-Earth3",
1396          "FGOALS-g3",
1397          "GFDL-ESM4",
1398          "GISS-E2-1-G",
1399          "MPI-ESM1-2-LR",
1400          "MRI-ESM2-0",
1401          "NorESM2-MM",
1402          "NorESM2-MM_oc",
1403        ];
1404
1405        for (let i = 0; i < O_mod_names.length; i++) {
1406          if (partdata1[O_mod_names[i]] !== undefined) {
1407            partdata1[N_mod_names[i]] = partdata1[O_mod_names[i]];
1408            delete partdata1[O_mod_names[i]];
1409          }
1410        }
1411
1412        var byyear1 = _.unzip(_.values(partdata1));
1413        var byyear_F1 = []; //Filter out NaNs for max and min calc
1414        for (let i = 0; i < byyear1.length; i++) {
1415          var midArray = byyear1[i].filter(
1416            (item) => item !== "NaN" && item !== "NA"
1417          );
1418          byyear_F1.push(midArray);
1419        }
1420
1421        var byyear2 = _.unzip(_.values(partdata2));
1422        var byyear_F2 = []; //Filter out NaNs for Mean calc
1423        for (let i = 0; i < byyear2.length; i++) {
1424          var midArray = byyear2[i].filter(
1425            (item) => item !== "NaN" && item !== "NA"
1426          );
1427          byyear_F2.push(midArray);
1428        }
1429
1430        // Prepare Mean and range data for Timeseries
1431        // Note that because the summer and wet seasons strech across two years, no 2100 data is included for these seasons as there is no 2101 data available
1432        var means = [];
1433        if (dataObj.selseason == "djf" || dataObj.selseason == "ndjfma") {
1434          for (let i = 0; i < byyear_F1.length - 1; i++) {
1435            var max = _.max(byyear_F1[i]);
1436            var mean11 = Math.round(byyear_F2[i] * 100) / 100;
1437            var min = _.min(byyear_F1[i]);
1438            var range = [max, mean11, min];
1439            means.push(range);
1440          }
1441        } else
1442          for (let i = 0; i < byyear_F1.length; i++) {
1443            var max = _.max(byyear_F1[i]);
1444            var mean11 = Math.round(_.mean(byyear_F2[i]) * 100) / 100;
1445            var min = _.min(byyear_F1[i]);
1446            var range = [max, mean11, min];
1447            means.push(range);
1448          }
1449        //var means = _.map(byyear_F, o=>[_.max(o), Math.round(_.mean(o)*100)/100, _.min(o)]);
1450
1451        dataObj.rangedata = _.zipWith(years, means, function (m, d) {
1452          return _.concat(m, d);
1453        });
1454        var numrange = _.range(0, 1, 1 / years.length);
1455
1456        //dataObj.trendData = $.extend(true, {Year: years}, partdata, {Mean: means});
1457        dataObj.trendData = [];
1458        dataObj.trendData.push(_.concat("Year", years));
1459        _.forEach(partdata1, function (a, k) {
1460          dataObj.trendData.push(_.concat(k, a));
1461        });
1462        dataObj.trendData.push(_.concat("Mean", means));
1463
1464        // var regress;
1465
1466        // _.forEach(partdata, function(a,k){
1467        //     regress = regression.linear(_.zip(numrange,a));
1468        //     dataObj.trendData.push( _.concat(k + " trend", _.map(regress.points, p=>p[1])));
1469        // });
1470
1471        // var meantrend = _.unzip(_.map(_.unzip(means), function(a){
1472        //     regress = regression.linear(_.zip(numrange,a));
1473        //     return _.map(regress.points, p=>p[1]);
1474        // }));
1475        // dataObj.trendData.push( _.concat("Mean trend", meantrend
1475));
1476
1477        dataObj.calcTrend = true;
1478
1479        return dataObj.trendData;
1480      },
1481    },
1482    {
1483      key: "RegressData",
1484      value: async function RegressData(data) {},
1485    },
1486    {
1487      key: "GetBothScenarioData",
1488      value: async function GetBothScenarioData() {
1489        var dataforgraph = await dataObj.prototype.RegionalGraphData(
1490          dataObj.scenario,
1491          null
1492        );
1493        if (dataforgraph == undefined) return;
1494
1495        var newdata = _.filter(
1496          dataforgraph,
1497          (d) => d[0].includes("Mean") || d[0].includes("Year")
1498        );
1499        newdata = _.map(newdata, function (d) {
1500          d[0] = d[0].replace("Mean", dataObj.prototype.ScenarioStr);
1501          return d;
1502        });
1503
1504        var tempdata = _.filter(
1505          await dataObj.prototype.RegionalGraphData(
1506            dataObj.prototype.AlternateScenario1,
1507            null
1508          ),
1509          (d) => d[0].includes("Mean")
1510        );
1511        _.forEach(tempdata, function (d) {
1512          d[0] = d[0].replace("Mean", dataObj.prototype.AlternateScenario1Str);
1513          newdata.push(d);
1514        });
1515
1516        var tempdata2 = _.filter(
1517          await dataObj.prototype.RegionalGraphData(
1518            dataObj.prototype.AlternateScenario2,
1519            null
1520          ),
1521          (d) => d[0].includes("Mean")
1522        );
1523        _.forEach(tempdata2, function (d) {
1524          d[0] = d[0].replace("Mean", dataObj.prototype.AlternateScenario2Str);
1525          newdata.push(d);
1526        });
1527
1528        return newdata;
1529      },
1530    },
1531    {
1532      key: "GetDroghtScenarioData",
1533      value: async function GetDroghtScenarioData() {
1534        var extdata = dataObj.prototype.RegionalGraphData(
1535          dataObj.prototype.SelectedScenario,
1536          "extreme"
1537        );
1538        var serdata = dataObj.prototype.RegionalGraphData(
1539          dataObj.prototype.SelectedScenario,
1540          "severe"
1541        );
1542        var moddata = dataObj.prototype.RegionalGraphData(
1543          dataObj.prototype.SelectedScenario,
1544          "moderate"
1545        );
1546
1547        return Promise.all([extdata, serdata, moddata]).then(function (data) {
1548          var scenes = ["Extreme", "Severe", "Moderate"];
1549          var newdata = _.filter(data[0], (item) => item[0] == "Year");
1550          _.forEach(data, function (s, i) {
1551            var t = _.filter(s, (d) => d[0] == "Mean")[0];
1552            t = t.map(([a, b, c]) => b);
1553            t[0] = t[0] = scenes[i];
1554            newdata.push(t);
1555          });
1556
1557          return newdata;
1558          /*_.forEach(data, function(s,i){
1559                    var t = _.filter(s, d=> d[0] == "Mean")[0];
1560                    t.shift();                    
1561                    newdata.push(_.concat(scenes[i],_.map(t, function(v){ return v[1];}))); } );                
1562                return newdata; */
1563        });
1564      },
1565    },
1566    {
1567      key: "LoadDataSet",
1568      value: function LoadDataSet(varPrefix, mapReg) {
1569        var promises = [];
1570        dataObj.trendKeys.forEach(function (key) {
1571          promises.push(dataObj.prototype.parseData(varPrefix, mapReg, key));
1572        });
1573
1574        Promise.all(promises).then(function (data) {
1575          data.forEach(function (elem, indx) {
1576            dataObj.trendData[varPrefix][dataObj.trendKeys[indx]] = elem;
1577          });
1578          dataObj.prototype.trigger(
1579            "GenerateChart",
1580            dataObj.trendData[varPrefix],
1581            varPrefix
1582          );
1583        });
1584      },
1585    },
1586    {
1587      key: "LoadTrendData",
1588      value: function LoadTrendData(dataType) {
1589        dataObj.trendData =
1590          dataObj.prototype.SelectedOverlay == "GovArea"
1591            ? {
1592                HWD: { avg: {}, min: {}, max: {} },
1593                HWF: { avg: {}, min: {}, max: {} },
1594              }
1595            : {
1596                AI: { avg: {}, min: {}, max: {} },
1597                Q_Bud: { avg: {}, min: {}, max: {} },
1598              };
1599        dataObj.datakeys = Object.keys(dataObj.trendData);
1600        dataObj.trendKeys = Object.keys(dataObj.trendData[dataObj.datakeys[0]]);
1601        dataObj.datakeys.forEach(function (key) {
1602          dataObj.prototype.LoadDataSet(key, dataObj.prototype.SelectedOverlay);
1603        });
1604        dataObj.prototype.trigger("DataLoaded", "Trend");
1605        dataObj.dataloading = false;
1606      },
1607    },
1608    {
1609      key: "GetProperties",
1610      value: function GetProperties() {
1611        return {
1612          shire: dataObj.shirename,
1613          region: dataObj.selectedOverlay,
1614          variable: dataObj.selvar,
1615          season: dataObj.selseason,
1616          year: dataObj.selperiod,
1617          scenario: dataObj.scenario,
1618          spi: dataObj.spi,
1619          tab: dataObj.datatype,
1620          bias: dataObj.isBias,
1621          pcnt: dataObj.isPcnt,
1622        };
1623      },
1624    },
1625    {
1626      key: "SetProperties",
1627      value: function SetProperties(props) {
1628        return new Promise(function (resolve, reject) {
1629          //if (isEmpty(props)) {}
1630          if (props.hasOwnProperty("tab")) {
1631            //var sid = props['tab'].slice(0, -4).substring(4);
1632            dataObj.datatype = props.tab;
1633            dataObj.prototype.DataPrefix =
1634              dataObj.txtinserts.defaults[dataObj.datatype].prefix;
1635            dataObj.selseason =
1636              dataObj.txtinserts.defaults[dataObj.datatype].season;
1637            dataObj.selvar = dataObj.txtinserts.defaults[dataObj.datatype].var;
1638          }
1639          if (Object.keys(props).length > 1) dataObj.printing = true;
1640
1641          $.each(props, function (key, val) {
1642            switch (key) {
1643              case "region":
1644                dataObj.selectedOverlay = val;
1645                //delete urlParams.region;
1646                break;
1647              case "variable":
1648                dataObj.selvar = val;
1649                //delete urlParams.variable;
1650                break;
1651              case "season":
1652                dataObj.selseason = val;
1653                //delete urlParams.season;
1654                break;
1655              case "year":
1656                dataObj.selperiod = val;
1657                //delete urlParams.year;
1658                break;
1659              case "scenario":
1660                dataObj.scenario = val;
1661                break;
1662              case "spi":
1663                dataObj.spi = val;
1664                break;
1665              case "shire":
1666                dataObj.shirename = val;
1667                break;
1668              case "bias":
1669                dataObj.isBias = val == "true";
1670                break;
1671              case "pcnt":
1672                dataObj.isPcnt = val == "true";
1673                break;
1674            }
1675          });
1676          dataObj.prototype.trigger("SettingsDefined", {
1677            region: dataObj.selectedOverlay,
1678            variable: dataObj.selvar,
1679            season: dataObj.selseason,
1680            year: dataObj.selperiod,
1681            scenario: dataObj.scenario,
1682            spi: dataObj.spi,
1683            bias: dataObj.isBias,
1684            pcnt: dataObj.isPcnt,
1685          });
1686          resolve(true);
1687        });
1688      },
1689    },
1690    {
1691      key: "GetInfo",
1692      value: function GetInfo(whichmodal) {
1693        if (
1694          whichmodal == "varselectinfo" &&
1695          dataObj.prototype.DataPrefix == "FI"
1696        ) {
1697          whichmodal = "categoryselectinfo";
1698        }
1699        if (
1700          whichmodal == "varselectinfo" &&
1701          (dataObj.theme == "Drought" || dataObj.theme == "Wet") &&
1702          dataObj.datatype == "timeline"
1703        ) {
1704          whichmodal = "varextentselectinfo";
1705        }
1706        if (
1707          whichmodal == "severitycatselectinfo" &&
1708          (dataObj.theme == "Drought" || dataObj.theme == "Wet") &&
1709          dataObj.datatype == "timeline"
1710        ) {
1711          whichmodal = "ts_severitycatselectinfo";
1712        }
1713        if (
1714          whichmodal == "downloadinfo_table" &&
1715          dataObj.datatype == "timeline"
1716        ) {
1717          whichmodal = "downloadinfo_time";
1718        }
1719
1720        var tempinfo = dataObj.txtinserts.Infos[whichmodal];
1721        var temp = {
1722          title: tempinfo.Title,
1723          text: "",
1724        };
1725        if ("Text" in tempinfo)
1726          temp.text = dataObj.prototype.wrapPara(tempinfo.Text);
1727        else {
1728          if (
1729            dataObj.prototype.DataPrefix == "D" ||
1730            dataObj.prototype.DataPrefix == "W"
1731          ) {
1732            if (whichmodal == "seasonselectinfo")
1733              temp.title = "Select drought/wetness severity:";
1734            if (dataObj.selvar.endsWith("df")) {
1735              temp.text = dataObj.prototype.wrapPara(tempinfo.D);
1736              return temp;
1737            }
1738          }
1739          temp.text = dataObj.prototype.wrapPara(
1740            tempinfo[dataObj.prototype.DataPrefix]
1741          );
1742        }
1743        return temp;
1744      },
1745    },
1746    {
1747      key: "wrapPara",
1748      value: function wrapPara(arr) {
1749        var rettext = "";
1750        arr.forEach(function (txt) {
1751          rettext = rettext + "<p>" + txt + "</p><br>";
1752        });
1753        return rettext;
1754      },
1755    },
1756    {
1757      key: "getTextReplace",
1758      value: function getTextReplace() {
1759        var p1 = $.getJSON(
1760          dataObj.prototype.TextRoot + "textinserts_cmip6.json",
1761          function (data) {
1762            dataObj.txtinserts = data;
1763            dataObj.prototype.trigger("TextLoaded");
1764          }
1765        );
1766        var p2 = $.getJSON(
1767          dataObj.prototype.TextRoot + "Colourmaps_cmip6.json",
1768          function (data) {
1769            dataObj.variableColours = data;
1770            dataObj.prototype.trigger("ColoursLoaded", data);
1771          }
1772        );
1773
1774        /*$('.selectpicker').each(function(ind, sel) {
1775                var options = $(this).find("option");
1776                options.each(function(ind, opt) {
1777                    if (this.hasAttribute("data-tokens")) {
1778                        var tmp = txtinserts[sel.id][opt.attributes['data-tokens'].value];
1779                        $(this).html((sel.id == 'varselect' || sel.id == 'regionselect') ? tmp.Name : tmp);
1780                    }
1781                });
1782            });*/
1783        //dataObj.prototype.getRegionData(dataObj.selectedOverlay);
1784        return Promise.all([p1, p2]);
1785      },
1786    },
1787    {
1788      key: "checkAvailablity",
1789      value: function checkAvailablity(vara) {
1790        if (dataObj.isBias && !dataObj.txtinserts.varselect[vara].biasAvail) {
1791          dataObj.isBias = false;
1792          dataObj.prototype.trigger("BiasChanged", dataObj.isBias);
1793        }
1794        if (
1795          dataObj.scenario == "ssp126" &&
1796          !dataObj.txtinserts.varselect[vara].ssp126Avail
1797        ) {
1798          dataObj.scenario = "ssp370";
1799          dataObj.prototype.trigger("ScenarioChanged", dataObj.scenario);
1800        }
1801        if (
1802          dataObj.scenario == "ssp245" &&
1803          !dataObj.txtinserts.varselect[vara].ssp245Avail
1804        ) {
1805          dataObj.scenario = "ssp370";
1806          dataObj.prototype.trigger("ScenarioChanged", dataObj.scenario);
1807        }
1808      },
1809    },
1810    {
1811      key: "Catagories",
1812      get: function get() {
1813        return dataObj.catagories;
1814      },
1815    },
1816    {
1817      key: "ModelData",
1818      get: function get() {
1819        return dataObj.bymodel;
1820      },
1821    },
1822    {
1823      key: "RegionalData",
1824      get: function get() {
1825        return dataObj.regional;
1826      },
1827    },
1828    {
1829      key: "ColourTable",
1830      get: function get() {
1831        return dataObj.variableColours[dataObj.selvar];
1832      },
1833    },
1834    {
1835      key: "IsPrinting",
1836      get: function get() {
1837        return dataObj.printing;
1838      },
1839    },
1840    {
1841      key: "TextInserts",
1842      get: function get() {
1843        return dataObj.txtinserts;
1844      },
1845    },
1846    {
1847      key: "Header",
1848      get: function get() {
1849        return dataObj.gridheader;
1850      },
1851    },
1852    {
1853      key: "TrendDataSet",
1854      get: function get() {
1855        return dataObj.trendData;
1856      },
1857    },
1858    {
1859      key: "TrendKeys",
1860      get: function get() {
1861        return dataObj.trendKeys;
1862      },
1863    },
1864    {
1865      key: "isMobileDevice",
1866      get: function get() {
1867        return dataObj.device;
1868      },
1869    },
1870    {
1871      key: "SelectableSeasons",
1872      get: function get() {
1873        if (isEmpty(dataObj.seasons))
1874          dataObj.seasons =
1875            dataObj.txtinserts.defaults[dataObj.datatype].seasons;
1876
1877        if (
1878          dataObj.selvar == "HWF" ||
1879          dataObj.selvar == "HWL" ||
1880          dataObj.selvar == "HWD"
1881        ) {
1882          dataObj.seasons =
1883            dataObj.txtinserts.defaults[dataObj.datatype].seasons2;
1884          dataObj.prototype.SelectableSeasons =
1885            dataObj.txtinserts.defaults[dataObj.datatype].seasons2;
1886        } else if (dataObj.selvar == "HWAh") {
1887          dataObj.seasons =
1888            dataObj.txtinserts.defaults[dataObj.datatype].seasons;
1889          dataObj.prototype.SelectableSeasons =
1890            dataObj.txtinserts.defaults[dataObj.datatype].seasons;
1891        }
1892        return dataObj.seasons;
1893      },
1894      set: function set(seasons) {
1895        if (haveSame(seasons, dataObj.seasons)) return;
1896        dataObj.seasons = seasons;
1897        dataObj.prototype.trigger("SeasonsChanged", seasons);
1898        if (!seasons.includes(dataObj.selseason))
1899          dataObj.selseason = seasons[0];
1900      },
1901    },
1902    {
1903      key: "SelectableThemes",
1904      get: function get() {
1905        return Object.keys(dataObj.txtinserts.themeselect);
1906      },
1907    },
1908    {
1909      key: "SelectableVariables",
1910      get: function get() {
1911        if (dataObj.datatype == "table" || dataObj.datatype == "report") {
1912          dataObj.selvar =
1913            dataObj.txtinserts.defaults[
1914              dataObj.txtinserts.themeselect[dataObj.theme].Defaults
1915            ].var;
1916          return dataObj.txtinserts.defaults[
1917            dataObj.txtinserts.themeselect[dataObj.theme].Defaults
1918          ].variables;
1919        } else if (
1920          dataObj.datatype == "timeline" &&
1921          (dataObj.theme == "Drought" || dataObj.theme == "Wet")
1922        ) {
1923          return [dataObj.theme];
1924        } else if (
1925          dataObj.datatype == "timeline" &&
1926          !(dataObj.theme == "Drought" || dataObj.theme == "Wet")
1927        ) {
1928          dataObj.selvar =
1929            dataObj.txtinserts.defaults[
1930              dataObj.txtinserts.themeselect[dataObj.theme].Defaults
1931            ].var;
1932          return dataObj.txtinserts.defaults[
1933            dataObj.txtinserts.themeselect[dataObj.theme].Defaults
1934          ].variables;
1935        } else return dataObj.txtinserts.defaults[dataObj.datatype].variables;
1936      },
1937    },
1938    {
1939      key: "SelectableDataTypes",
1940      get: function get() {
1941        return Object.keys(dataObj.txtinserts.defaults);
1942      },
1943    },
1944    {
1945      key: "Regions",
1946      get: function get() {
1947        return dataObj.regions;
1948      },
1949    },
1950    {
1951      key: "UnitStr",
1952      get: function get() {
1953        if (dataObj.theme == "Drought" || dataObj.theme == "Wet")
1954          return dataObj.txtinserts.varselect[dataObj.theme].Units;
1955        return dataObj.txtinserts.varselect[dataObj.selvar][
1956          !dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch
1957            ? "Units"
1958            : dataObj.txtinserts.varselect[dataObj.selvar].ShowSwitch &&
1959              dataObj.isPcnt
1960            ? "AltUnits"
1961            : "Units"
1962        ];
1963      },
1964    },
1965    {
1966      key: "SeasonStr",
1967      get: function get() {
1968        return dataObj.txtinserts.seasonselect[dataObj.selseason];
1969      },
1970    },
1971    {
1972      key: "PeriodStr",
1973      get: function get() {
1974        return dataObj.txtinserts.periodconvert[dataObj.selperiod];
1975      },
1976    },
1977    {
1978      key: "PeriodLongStr",
1979      get: function get() {
1980        return +dataObj.selperiod - 10 + "-" + (+dataObj.selperiod + 9);
1981      },
1982    },
1983    {
1984      key: "VariableStr",
1985      get: function get() {
1986        if (dataObj.theme == "Drought" || dataObj.theme == "Wet")
1987          return dataObj.txtinserts.varselect[dataObj.theme].Name;
1988        return (
1989          (dataObj.isBias ? "Bias Corrected " : "") +
1990          dataObj.txtinserts.varselect[dataObj.selvar].Name
1991        );
1992      },
1993    },
1994    {
1995      key: "ScenarioStr",
1996      get: function get() {
1997        return dataObj.txtinserts.scenarioselect[dataObj.scenario];
1998      },
1999    },
2000    {
2001      key: "SPIStr",
2002      get: function get() {
2003        return dataObj.txtinserts.spiselect[dataObj.spi];
2004      },
2005    },
2006    {
2007      key: "RegionStr",
2008      get: function get() {
2009        return dataObj.txtinserts.regionselect[dataObj.selectedOverlay].Name;
2010      },
2011    },
2012    {
2013      key: "VariableLabel",
2014      get: function get() {
2015        return dataObj.prototype.DataPrefix == "FI" ? "Category:" : "Variable:";
2016      },
2017    },
2018    {
2019      key: "SeasonLabel",
2020      get: function get() {
2021        return dataObj.prototype.DataPrefix == "D"
2022          ? "Drought severity:"
2023          : dataObj.prototype.DataPrefix == "W"
2024          ? "Wetness severity:"
2025          : "Season:";
2026      },
2027    },
2028    {
2029      key: "CalcTrendData",
2030      get: function get() {
2031        return dataObj.calcTrend;
2032      },
2033      set: function set(val) {
2034        if (val != dataObj.calcTrend) dataObj.calcTrend = val;
2035      },
2036    },
2037    {
2038      key: "DataRoot",
2039      get: function get() {
2040        return dataObj.dataroot;
2041      },
2042      set: function set(val) {
2043        if (val != dataObj.dataroot) dataObj.dataroot = val;
2044      },
2045    },
2046    {
2047      key: "HoldEvent",
2048      get: function get() {
2049        return dataObj.holdevent;
2050      },
2051      set: function set(val) {
2052        dataObj.holdevent = val;
2053      },
2054    },
2055    {
2056      key: "TextRoot",
2057      get: function get() {
2058        return isEmpty(dataObj.txtroot) ? dataObj.dataroot : dataObj.txtroot;
2059      },
2060      set: function set(val) {
2061        if (val != dataObj.txtroot) dataObj.txtroot = val;
2062      },
2063    },
2064    {
2065      key: "RegionField",
2066      get: function get() {
2067        return dataObj.txtinserts.regionselect[dataObj.selectedOverlay].Field;
2068      },
2069      //set RegionField(val) { if (val != dataObj.regionField) dataObj.regionField = val; }
2070    },
2071    {
2072      key: "SelectedVariable",
2073      get: function get() {
2074        return dataObj.selvar;
2075      },
2076      set: function set(val) {
2077        if (val == dataObj.selvar) return;
2078        dataObj.prevar = dataObj.selvar;
2079        dataObj.newseason = dataObj.selseason;
2080        dataObj.selvar = val;
2081        dataObj.prototype.checkAvailablity(dataObj.selvar);
2082        dataObj.prototype.trigger("DataParameterChanged", "variable");
2083        if (
2084          dataObj.selvar == "HWAh" &&
2085          (dataObj.selseason == "djf" ||
2086            dataObj.selseason == "jja" ||
2087            dataObj.selseason == "mam" ||
2088            dataObj.selseason == "son" ||
2089            dataObj.selseason == "mjjaso")
2090        )
2091          dataObj.selseason = "jul_to_jun";
2092
2093        if (
2094          dataObj.prevar == "HWAh" &&
2095          (dataObj.selvar == "HWD" ||
2096            dataObj.selvar == "HWF" ||
2097            dataObj.selvar == "HWL")
2098        ) {
2099          dataObj.prototype.trigger("SeasonsChanged", dataObj.seasons);
2100        } else if (
2101          dataObj.selvar == "HWAh" &&
2102          (dataObj.prevar == "HWD" ||
2103            dataObj.prevar == "HWF" ||
2104            dataObj.prevar == "HWL")
2105        ) {
2106          dataObj.prototype.trigger("SeasonsChanged", dataObj.seasons);
2107        }
2108        /*if (dataObj.loadData){
2109                dataObj.prototype.getRegionalData(dataObj.selvar);
2110                dataObj.prototype.getGridDataFile(dataObj.selvar);
2111            }*/
2112      },
2113    },
2114    {
2115      key: "SelectedScenario",
2116      get: function get() {
2117        return dataObj.scenario;
2118      },
2119      set: function set(val) {
2120        if (val != dataObj.scenario) {
2121          dataObj.scenario = val;
2122          //dataObj.regional = {};
2123          //dataObj.bymodel = {};
2124          //dataObj.loadedRegionalDataFiles = [];
2125          dataObj.prototype.trigger("DataParameterChanged", "scene");
2126          /*if (dataObj.loadData){
2127                    dataObj.prototype.getGridDataFile(dataObj.selvar);
2128                    dataObj.prototype.getRegionalData(dataObj.selvar);
2129                }*/
2130          dataObj.prototype.trigger("ScenarioChanged", dataObj.scenario);
2131          // dataObj.prototype.trigger('DataTypeChanged', dataObj.datatype);
2132        }
2133      },
2134    },
2135    {
2136      key: "SelectedSPI",
2137      get: function get() {
2138        return dataObj.spi;
2139      },
2140      set: function set(val) {
2141        if (val != dataObj.spi) {
2142          dataObj.spi = val;
2143          dataObj.prototype.trigger("DataParameterChanged", "sp");
2144          dataObj.prototype.trigger("SPIChanged", dataObj.spi);
2145        }
2146      },
2147    },
2148    {
2149      key: "AlternateScenario1",
2150      get: function get() {
2151        if (
2152          dataObj.scenario == "ssp370" &&
2153          dataObj.txtinserts.varselect[dataObj.selvar].ssp245Avail
2154        ) {
2155          return "ssp245";
2156        }
2157        return "ssp370";
2158      },
2159    },
2160    {
2161      key: "AlternateScenario2",
2162      get: function get() {
2163        if (
2164          dataObj.scenario == "ssp126" &&
2165          dataObj.txtinserts.varselect[dataObj.selvar].ssp245Avail
2166        ) {
2167          return "ssp245";
2168        }
2169        return "ssp126";
2170      },
2171    },
2172    {
2173      key: "AlternateScenario1Str",
2174      get: function get() {
2175        return dataObj.txtinserts.scenarioselect[
2176          dataObj.prototype.AlternateScenario1
2177        ];
2178      },
2179    },
2180    {
2181      key: "AlternateScenario2Str",
2182      get: function get() {
2183        return dataObj.txtinserts.scenarioselect[
2184          dataObj.prototype.AlternateScenario2
2185        ];
2186      },
2187    },
2188    {
2189      key: "SelectedDataType",
2190      get: function get() {
2191        return dataObj.datatype;
2192      },
2193      set: function set(val) {
2194        if (val != dataObj.datatype) {
2195          dataObj.datatype = val;
2196          switch (dataObj.datatype) {
2197            case "timeline":
2198              dataObj.reporttype = ReportDataType.Timeline;
2199              break;
2200            case "table":
2201              dataObj.reporttype = ReportDataType.Table;
2202              break;
2203            case "trend":
2204              dataObj.reporttype = ReportDataType.Trend;
2205              break;
2206            default:
2207              dataObj.reporttype = ReportDataType.Dashboard;
2208              dataObj.prototype.SelectableSeasons =
2209                dataObj.txtinserts.defaults[dataObj.datatype].seasons;
2210          }
2211          dataObj.regional = {};
2212          dataObj.bymodel = {};
2213          dataObj.loadedRegionalDataFiles = [];
2214          dataObj.prototype.DataPrefix =
2215            dataObj.txtinserts.defaults[dataObj.datatype].prefix;
2216          dataObj.prototype.checkAvailablity(
2217            dataObj.txtinserts.defaults[dataObj.datatype].var
2218          );
2219          if (
2220            dataObj.datatype == "table" ||
2221            dataObj.datatype == "timeline" ||
2222            dataObj.datatype == "report"
2223          ) {
2224            dataObj.selseason =
2225              dataObj.txtinserts.defaults[
2226                dataObj.txtinserts.themeselect[dataObj.theme].Defaults
2227              ].season;
2228          } else {
2229            dataObj.selseason =
2230              dataObj.txtinserts.defaults[dataObj.datatype].season;
2231          }
2232          if (
2233            dataObj.datatype == "table" ||
2234            dataObj.datatype == "timeline" ||
2235            dataObj.datatype == "report"
2236          ) {
2237            dataObj.prototype.SelectedVariable =
2238              dataObj.txtinserts.defaults[
2239                dataObj.txtinserts.themeselect[dataObj.theme].Defaults
2240              ].var;
2241          } else {
2242            dataObj.prototype.SelectedVariable =
2243              dataObj.txtinserts.defaults[dataObj.datatype].var;
2244          }
2245          /*if (dataObj.loadData){
2246                    dataObj.prototype.getRegionalData(dataObj.txtinserts.defaults[dataObj.datatype].var);
2247                }*/
2248          dataObj.prototype.trigger("DataTypeChanged", dataObj.datatype);
2249        }
2250      },
2251    },
2252    {
2253      key: "SelectedSeason",
2254      get: function get() {
2255        return dataObj.selseason;
2256      },
2257      set: function set(val) {
2258        if (val != dataObj.selseason) {
2259          dataObj.selseason = val;
2260          dataObj.prototype.trigger("DataParameterChanged", "season");
2261        }
2262      },
2263    },
2264    {
2265      key: "SelectBias",
2266      get: function get() {
2267        return dataObj.isBias;
2268      },
2269      set: function set(val) {
2270        if (
2271          val != dataObj.isBias &&
2272          dataObj.txtinserts.varselect[dataObj.selvar].biasAvail
2273        ) {
2274          dataObj.isBias = val;
2275          dataObj.prototype.trigger("DataParameterChanged", "bias");
2276          /*if (dataObj.loadData){
2277                    dataObj.prototype.getRegionalData(dataObj.selvar);
2278                    dataObj.prototype.getGridDataFile(dataObj.selvar);
2279                }*/
2280          dataObj.prototype.trigger("BiasChanged", dataObj.isBias);
2281        }
2282      },
2283    },
2284    {
2285      key: "SelectedPeriod",
2286      get: function get() {
2287        return dataObj.selperiod;
2288      },
2289      set: function set(val) {
2290        if (val != dataObj.selperiod) {
2291          dataObj.selperiod = val;
2292          dataObj.prototype.trigger("DataParameterChanged", "period");
2293        }
2294      },
2295    },
2296    {
2297      key: "SelectedOverlay",
2298      get: function get() {
2299        return dataObj.selectedOverlay;
2300      },
2301      set: function set(val) {
2302        if (val == dataObj.selectedOverlay) return;
2303        dataObj.selectedOverlay = val;
2304        dataObj.shirename = dataObj.defaultshirename;
2305        dataObj.prototype.getRegionOverlayData();
2306
2307        // Trigger data reload to ensure data matches the new overlay
2308        dataObj.prototype.LoadData(true); // Pass `true` to force a full reload
2309      },
2310    },
2311    {
2312      key: "DefaultRegion",
2313      get: function get() {
2314        return dataObj.defaultshirename;
2315      },
2316    },
2317    {
2318      key: "SelectedRegion",
2319      get: function get() {
2320        return dataObj.shirename;
2321      },
2322      set: function set(val) {
2323        if (val != dataObj.shirename) {
2324          dataObj.shirename = val;
2325          if (isEmpty(dataObj.reportdata)) {
2326            if (!isEmpty(dataObj.datakeys)) {
2327              dataObj.datakeys.forEach(function (key) {
2328                dataObj.prototype.trigger(
2329                  "GenerateChart",
2330                  dataObj.trendData[key],
2331                  key
2332                );
2333              });
2334              return;
2335            }
2336          }
2337          dataObj.prototype.trigger("RegionChanged", dataObj.shirename);
2338        }
2339      },
2340    },
2341    {
2342      key: "SelectedTheme",
2343      get: function get() {
2344        return dataObj.theme;
2345      },
2346      set: function set(val) {
2347        if (val != dataObj.theme) {
2348          dataObj.theme = val;
2349          dataObj.selectedPrefix =
2350            dataObj.txtinserts.defaults[
2351              dataObj.txtinserts.themeselect[dataObj.theme].Defaults
2352            ].prefix;
2353          //if(dataObj.theme == 'Drought'||dataObj.theme == 'Wet'){dataObj.selseason = "Ext"}
2354          //else
2355          dataObj.selseason =
2356            dataObj.txtinserts.defaults[
2357              dataObj.txtinserts.themeselect[dataObj.theme].Defaults
2358            ].season;
2359        }
2360      },
2361    },
2362    {
2363      key: "SelectedThemeStr",
2364      get: function get() {
2365        return dataObj.txtinserts.themeselect[dataObj.theme].Name;
2366      },
2367    },
2368    {
2369      key: "RegionalRangeData",
2370      get: function get() {
2371        if (isEmpty(dataObj.historicdata)) return undefined;
2372
2373        return dataObj.rangedata;
2374      },
2375    },
2376    {
2377      key: "RegionalModels",
2378      get: function get() {
2379        if (isEmpty(dataObj.historicdata)) return undefined;
2380
2381        return dataObj.models;
2382      },
2383    },
2384    {
2385      key: "IsScenerio126Available",
2386      get: function get() {
2387        return dataObj.txtinserts.defaults[dataObj.datatype].ssp126Avail;
2388      },
2389    },
2390    {
2391      key: "IsScenerio245Available",
2392      get: function get() {
2393        return dataObj.txtinserts.defaults[dataObj.datatype].ssp245Avail;
2394      },
2395    },
2396    {
2397      key: "DataPrefix",
2398      get: function get() {
2399        return dataObj.selectedPrefix;
2400      },
2401      set: function set(val) {
2402        if (val == "reports") {
2403          dataObj.selectedPrefix =
2404            dataObj.txtinserts.defaults[
2405              dataObj.txtinserts.themeselect[dataObj.theme].Defaults
2406            ].prefix;
2407        } else if (val != dataObj.selectedPrefix) {
2408          dataObj.selectedPrefix = val;
2409
2410          if (
2411            !(
2412              dataObj.datatype == "table" ||
2413              dataObj.datatype == "timeline" ||
2414              dataObj.datatype == "report"
2415            )
2416          ) {
2417            var datatypes = Object.keys(dataObj.txtinserts.defaults);
2418
2419            datatypes.forEach(function (key) {
2420              if (dataObj.txtinserts.defaults[key].prefix == val) {
2421                dataObj.prototype.SelectedDataType = key;
2422              }
2423            });
2424          }
2425        }
2426      },
2427    },
2428    {
2429      key: "IsPcnt",
2430      get: function get() {
2431        return dataObj.isPcnt;
2432      },
2433      set: function set(val) {
2434        if (val != dataObj.isPcnt) {
2435          dataObj.isPcnt = val;
2436          if (!dataObj.holdevent) {
2437            dataObj.prototype.checkAvailablity(dataObj.selvar);
2438            dataObj.prototype.trigger("DataParameterChanged", "pcnt");
2439            /*if (dataObj.loadData){
2440                        dataObj.prototype.getRegionalData(dataObj.selvar);
2441                        dataObj.prototype.getGridDataFile(dataObj.selvar);
2442                    }*/
2443            dataObj.prototype.trigger("PcntChanged", dataObj.isPcnt);
2444          }
2445        }
2446      },
2447    },
2448  ]);
2449
2450  function dataObj(elementId, urlParams, basetype) {
2451    _classCallCheck(this, dataObj);
2452
2453    switch (basetype) {
2454      case "timeline":
2455        dataObj.reporttype = ReportDataType.Timeline;
2456        break;
2457      case "table":
2458        dataObj.reporttype = ReportDataType.Table;
2459        break;
2460      case "trend":
2461        dataObj.reporttype = ReportDataType.Trend;
2462        break;
2463      default:
2464        dataObj.reporttype = ReportDataType.Dashboard;
2465    }
2466
2467    dataObj.events = {};
2468    dataObj.device = window.mobilecheck();
2469    dataObj.printing = false;
2470
2471    dataObj.urlParams = urlParams;
2472    dataObj.idtag = elementId;
2473    dataObj.dataroot =
2474      "https://data.longpaddock.qld.gov.au/static/dashboard/v3/";
2475    dataObj.txtroot = "/app-data/";
2476
2477    dataObj.selseason = "annual";
2478    dataObj.selperiod = 2070;
2479
2480    dataObj.dataloading = false;
2481
2482    dataObj.geojson;
2483    dataObj.regions;
2484    dataObj.reportdata;
2485
2486    dataObj.historicdata;
2487    dataObj.graphdata;
2488    dataObj.rangedata;
2489    dataObj.models;
2490    dataObj.theme = "MeanClim";
2491    dataObj.regionjson;
2492    dataObj.gridheader;
2493    dataObj.variableColours;
2494    dataObj.txtinserts;
2495    dataObj.catagories;
2496    dataObj.isPcnt = false;
2497    dataObj.isBias = false;
2498    dataObj.isProcessingData = false;
2499    dataObj.holdevent = false;
2500
2501    dataObj.datatype = "climate";
2502    dataObj.trendData;
2503    dataObj.trendKeys;
2504    dataObj.datakeys;
2505    dataObj.trendRegion;
2506    dataObj.errcount;
2507    dataObj.calcTrend = true;
2508    dataObj.trendData;
2509
2510    dataObj.regional;
2511    dataObj.bymodel;
2512    dataObj.seasons;
2513    dataObj.selectedOverlay = "GovArea";
2514    dataObj.selectedPrefix = "MC";
2515    dataObj.selvar = "tas";
2516    if (dataObj.datatype == "timeline") {
2517      dataObj.shirename = "Queensland";
2518    } else dataObj.shirename = "Qld";
2519    dataObj.mapindx = -1;
2520    dataObj.scenario = "ssp370";
2521    dataObj.spi = "SPI";
2522    dataObj.loadGridData = true;
2523
2524    dataObj.loadedGridDataFile = "";
2525    dataObj.loadedRegionFile = "";
2526    dataObj.loadedRegionalDataFiles = [];
2527
2528    dataObj.loadedHeaderFile = "";
2529    dataObj.headings =
2530      "Regiontype,Region,Variable,Season,ensemble_mean,2030_SSP1-2.6_Mean,2030_SSP1-2.6_Min,2030_SSP1-2.6_Max,2030_SSP2-4.5_Mean,2030_SSP2-4.5_Min,2030_SSP2-4.5_Max,2030_SSP3-7.0_Mean,2030_SSP3-7.0_Min,2030_SSP3-7.0_Max,2050_SSP1-2.6_Mean,2050_SSP1-2.6_Min,2050_SSP1-2.6_Max,2050_SSP2-4.5_Mean,2050_SSP2-4.5_Min,2050_SSP2-4.5_Max,2050_SSP3-7.0_Mean,2050_SSP3-7.0_Min,2050_SSP3-7.0_Max,2070_SSP1-2.6_Mean,2070_SSP1-2.6_Min,2070_SSP1-2.6_Max,2070_SSP2-4.5_Mean,2070_SSP2-4.5_Min,2070_SSP2-4.5_Max,2070_SSP3-7.0_Mean,2070_SSP3-7.0_Min,2070_SSP3-7.0_Max,2090_SSP1-2.6_Mean,2090_SSP1-2.6_Min,2090_SSP1-2.6_Max,2090_SSP2-4.5_Mean,2090_SSP2-4.5_Min,2090_SSP2-4.5_Max,2090_SSP3-7.0_Mean,2090_SSP3-7.0_Min,2090_SSP3-7.0_Max";
2531
2532    dataObj.mapID = $("#" + dataObj.idtag);
2533
2534    if (dataObj.mapID.hasAttr("data-region"))
2535      dataObj.selectedOverlay = dataObj.mapID.attr("data-region");
2536    if (dataObj.mapID.hasAttr("data-indx"))
2537      dataObj.mapindx = Number(dataObj.mapID.attr("data-indx"));
2538    if (dataObj.mapID.hasAttr("data-initPrefix"))
2539      dataObj.selectedPrefix = dataObj.mapID.attr("data-initPrefix");
2540    if (dataObj.mapID.hasAttr("data-var"))
2541      dataObj.selvar = dataObj.mapID.attr("data-var");
2542    if (dataObj.mapID.hasAttr("data-selected"))
2543      dataObj.shirename = dataObj.mapID.attr("data-selected");
2544    if (dataObj.mapID.hasAttr("data-loadData"))
2545      dataObj.loadGridData = dataObj.mapID.attr("data-loadData") == "true";
2546
2547    if (dataObj.mapID.hasAttr("data-dataroot"))
2548      dataObj.dataroot = dataObj.mapID.attr("data-dataroot");
2549    if (dataObj.mapID.hasAttr("data-txtroot"))
2550      dataObj.txtroot = dataObj.mapID.attr("data-txtroot");
2551
2552    dataObj.defaultshirename = dataObj.shirename;
2553
2554    dataObj.prototype.on("GridLoaded", function () {
2555      dataObj.prototype.getGridDataFile(dataObj.selvar).then(function () {
2556        dataObj.prototype.getRegionOverlayData();
2557      });
2558    });
2559
2560    dataObj.prototype.on("GridDataChanged", function () {
2561      dataObj.prototype.LoadData(false);
2562    });
2563
2564    dataObj.prototype.on("DataParameterChanged", function (paratype) {
2565      //if (paratype == "variable" || paratype == "scene" || paratype == "season" || paratype == "period"){
2566      //dataObj.prototype.LoadData(true);
2567      //dataObj.prototype.trigger('ParameterUpdatedData', dataObj.shirename);
2568      //}
2569      if (dataObj.loadGridData)
2570        dataObj.prototype.getGridDataFile(dataObj.selvar);
2571    });
2572
2573    dataObj.prototype.getTextReplace().then(function () {
2574      dataObj.prototype.SetProperties(dataObj.urlParams).then(function () {
2575        if (dataObj.loadGridData) {
2576          dataObj.prototype.getGrid();
2577        }
2578      });
2579    });
2580  }
2581
2582  _createClass(dataObj, [
2583    {
2584      key: "trigger",
2585      value: function trigger(eventName) {
2586        var leftovers = Array.prototype.slice.apply(arguments, [1]);
2587
2588        if (eventName === "*") {
2589          for (var k in dataObj.events) {
2590            if (dataObj.events.hasOwnProperty(k)) {
2591              triggerHandlersForEvent(k, leftovers);
2592            }
2593          }
2594        } else {
2595          triggerHandlersForEvent(eventName, leftovers);
2596        }
2597
2598        function triggerHandlersForEvent(name, leftovers) {
2599          if (typeof dataObj.events[name] !== "undefined") {
2600            for (var i = 0; i < dataObj.events[name].length; i++) {
2601              dataObj.events[name][i].apply(dataObj, leftovers);
2602            }
2603          }
2604        }
2605      },
2606    },
2607    {
2608      key: "off",
2609      value: function off(eventName, fn) {
2610        // check for wildcard *
2611        if (eventName === "*" || typeof eventName === "undefined") {
2612          for (var k in dataObj.events) {
2613            if (dataObj.events.hasOwnProperty(k)) {
2614              removeHandlersForEvent(k, fn);
2615            }
2616          }
2617        } else {
2618          removeHandlersForEvent(eventName, fn);
2619        }
2620
2621        function removeHandlersForEvent(name, fn) {
2622          //check if we actually have an event array for this name
2623          if (typeof dataObj.events[name] !== "undefined") {
2624            // if no function or wildcard was given, we are removing all handlers for this event
2625            if (typeof fn === "undefined" || fn === "*") {
2626              dataObj.events[name] = [];
2627            }
2628            // else we try and remove just that function
2629            else {
2630              for (var i = 0; i < dataObj.events[name].length; i++) {
2631                if (dataObj.events[name][i] === fn) {
2632                  dataObj.events[name].splice(i, 1);
2633                  break;
2634                }
2635              }
2636            }
2637          }
2638        }
2639      },
2640    },
2641    {
2642      key: "on",
2643      value: function on(eventName, fn) {
2644        if (typeof dataObj.events[eventName] === "undefined") {
2645          dataObj.events[eventName] = [];
2646        }
2647        dataObj.events[eventName].push(fn);
2648      },
2649    },
2650  ]);
2651
2652  return dataObj;
2653})();

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.