API to get queries from MATS applications

[randytpierce]

This is a place for Molly and I to discuss the mechanism for getting queries from MATS apps.

[mollybsmith-noaa]

This is the javascript function for converting hits, misses, etc into statistics:

// calculates the statistic for ctc plots
const calculateStatCTC = function (hit, fa, miss, cn, n, statistic) {
    if (isNaN(hit) || isNaN(fa) || isNaN(miss) || isNaN(cn)) return null;
    var queryVal;
    switch (statistic) {
        case 'TSS (True Skill Score)':
            queryVal = ((hit * cn - fa * miss) / ((hit + miss) * (fa + cn))) * 100;
            break;
        // some PODy measures look for a value over a threshold, some look for under
        case 'PODy (POD of value < threshold)':
        case 'PODy (POD of value > threshold)':
            queryVal = hit / (hit + miss) * 100;
            break;
        // some PODn measures look for a value under a threshold, some look for over
        case 'PODn (POD of value > threshold)':
        case 'PODn (POD of value < threshold)':
            queryVal = cn / (cn + fa) * 100;
            break;
        case 'POFD (Probability of False Detection)':
            queryVal = fa / (fa + cn) * 100;
            break;
        case 'FAR (False Alarm Ratio)':
            queryVal = fa / (fa + hit) * 100;
            break;
        case 'Bias (forecast/actual)':
            queryVal = (hit + fa) / (hit + miss);
            break;
        case 'CSI (Critical Success Index)':
            queryVal = hit / (hit + miss + fa) * 100;
            break;
        case 'HSS (Heidke Skill Score)':
            queryVal = 2 * (cn * hit - miss * fa) / ((cn + fa) * (fa + hit) + (cn + miss) * (miss + hit)) * 100;
            break;
        case 'ETS (Equitable Threat Score)':
            queryVal = (hit - ((hit + fa) * (hit + miss) / (hit + fa + miss + cn))) / ((hit + fa + miss) - ((hit + fa) * (hit + miss) / (hit + fa + miss + cn))) * 100;
            break;
        case 'Nlow (Number of obs < threshold (hits + misses))':
        case 'Nhigh (Number of obs > threshold (hits + misses))':
        case 'All observed yes':
            queryVal = hit + miss;
            break;
        case 'Nlow (Number of obs < threshold (false alarms + correct nulls))':
        case 'Nhigh (Number of obs > threshold (false alarms + correct nulls))':
        case 'All observed no':
            queryVal = cn + fa;
            break;
        case 'Ntot (Total number of obs, (Nlow + Nhigh))':
            queryVal = hit + fa + miss + cn;
            break;
        case 'Ratio Nlow / Ntot ((hit + miss)/(hit + miss + fa + cn))':
        case 'Ratio Nhigh / Ntot ((hit + miss)/(hit + miss + fa + cn))':
            queryVal = (hit + miss) / (hit + fa + miss + cn);
            break;
        case 'Ratio Nlow / Ntot ((fa + cn)/(hit + miss + fa + cn))':
        case 'Ratio Nhigh / Ntot ((fa + cn)/(hit + miss + fa + cn))':
            queryVal = (cn + fa) / (hit + fa + miss + cn);
            break;
        case 'N times*levels(*stations if station plot) per graph point':
            queryVal = n;
            break;
    }
    return queryVal;
};

[mollybsmith-noaa]

This is the javascript function for converting scalar partial sums into statistics:

// calculates the statistic for scalar partial sums plots
const calculateStatScalar = function (squareDiffSum, NSum, obsModelDiffSum, modelSum, obsSum, absSum, statistic) {
    if (isNaN(squareDiffSum) || isNaN(NSum) || isNaN(obsModelDiffSum) || isNaN(modelSum) || isNaN(obsSum) || isNaN(absSum)) return null;
    var queryVal;
    var variable = statistic.split("_")[1];
    statistic = statistic.split("_")[0];
    switch (statistic) {
        case 'RMSE':
            queryVal = Math.sqrt(squareDiffSum / NSum);
            break;
        case 'Bias (Model - Obs)':
            queryVal = (modelSum - obsSum) / NSum;
            break;
        case 'N':
            queryVal = NSum;
            break;
        case 'Model average':
            queryVal = modelSum / NSum;
            break;
        case 'Obs average':
            queryVal = obsSum / NSum;
            break;
        case 'Std deviation':
            queryVal = Math.sqrt(squareDiffSum / NSum - Math.pow((obsModelDiffSum / NSum), 2));
            break;
        case 'MAE (temp and dewpoint only)':
        case 'MAE (station plots only)':
        case 'MAE':
            queryVal = absSum / NSum;
            break;
    }
    if (isNaN(queryVal)) return null;
    // need to convert to correct units for surface data (variable names are capitalized in upper air
    // ("2m temperature" vs "Temperature"), so that should not trigger this if statement).
    if (statistic !== 'N') {
        if (variable.includes("temperature") || variable.includes("dewpoint")) {
            if (statistic.includes("average")) {
                queryVal = queryVal - 32;
            }
            queryVal = queryVal / 1.8;
        } else if (variable.includes("wind")) {
            queryVal = queryVal / 2.23693629;
        }
    }
    return queryVal;
};

[mollybsmith-noaa]

For anomalycor and other oddball apps, just use the one number returned by the database.

[mollybsmith-noaa]

Here is the vastly scaled down matching function from MATS:

// function for removing unmatched data from a dataset containing multiple curves
const getMatchedDataSet = function (dataset, curveInfoParams, appParams, binStats) {

    let subSecs = [];
    let independentVarGroups = [];
    let independentVarHasPoint = [];
    let currIndependentVar;
    let curveIndex;
    let data;
    let di;

    const curvesLength = 2; // always true for scorecards

    // matching in this function is based on a curve's independent variable. For a timeseries, the independentVar is epoch,
    // for a profile, it's level, for a dieoff, it's forecast hour, for a threshold plot, it's threshold, and for a
    // valid time plot, it's hour of day. This function identifies the the independentVar values common across all of
    // the curves, and then the common sub times/levels/values for those independentVar values.

    //determine whether data.x or data.y is the independent variable, and which is the stat value
    const independentVarName = 'x';;
    const statVarName = 'y';

    // find the matching independentVars shared across all curves
    for (curveIndex = 0; curveIndex < curvesLength; curveIndex++) {
        independentVarGroups[curveIndex] = [];  // array for the independentVars for each curve that are not null
        independentVarHasPoint[curveIndex] = [];   // array for the *all* of the independentVars for each curve
        subSecs[curveIndex] = {};  // map of the individual record times (subSecs) going into each independentVar for each curve
        data = dataset[curveIndex];
        // loop over every independentVar value in this curve
        for (di = 0; di < data[independentVarName].length; di++) {
            currIndependentVar = data[independentVarName][di];
            if (data[statVarName][di] !== null) {
                // store raw secs for this independentVar value, since it's not a null point
                subSecs[curveIndex][currIndependentVar] = data.subSecs[di];
                // store this independentVar value, since it's not a null point
                independentVarGroups[curveIndex].push(currIndependentVar);
            }
            // store all the independentVar values, regardless of whether they're null
            independentVarHasPoint[curveIndex].push(currIndependentVar);
        }
    }

    var matchingIndependentVars = _.intersection.apply(_, independentVarGroups);    // all of the non-null independentVar values common across all the curves
    var matchingIndependentHasPoint = _.intersection.apply(_, independentVarHasPoint);    // all of the independentVar values common across all the curves, regardless of whether or not they're null

    // remove non-matching independentVars and subSecs
    for (curveIndex = 0; curveIndex < curvesLength; curveIndex++) { // loop over every curve
        data = dataset[curveIndex];
        // need to loop backwards through the data array so that we can splice non-matching indices
        // while still having the remaining indices in the correct order
        var dataLength = data[independentVarName].length;
        for (di = dataLength - 1; di >= 0; di--) {
            if (matchingIndependentVars.indexOf(data[independentVarName][di]) === -1) {
                // if this is not a common non-null independentVar value, we'll have to remove some data
                if (matchingIndependentHasPoint.indexOf(data[independentVarName][di]) === -1) {
                    // if at least one curve doesn't even have a null here, much less a matching value (because of the cadence), just drop this independentVar
                    matsDataUtils.removePoint(data, di, plotType, statVarName, isCTC, isScalar, hasLevels);
                } else {
                    // if all of the curves have either data or nulls at this independentVar, and there is at least one null, ensure all of the curves are null
                    matsDataUtils.nullPoint(data, di, statVarName, isCTC, isScalar, hasLevels);
                }
            }
        }

        dataset[curveIndex] = data;
    }

    return dataset;
};