solar-scores/src/scores/eglEl.js

Compute scores for solar decathlon competition - Cali 2015

'use strict';

const utils = require('./../utils');
const baseScore = require('./../baseScore');

class EnergyConsumption extends baseScore {
    constructor(options) {
        super(options);
    }

    setProduction(values, param) {
        values = utils.filterValues(values, param);
        values = utils.resampleWithMax([values], [param], 'EnergyConsumption');
        this.productionByDay = utils.filterByEpochPerDay(values, 'EnergyConsumption');
        return this;
    }

    setExcessProduction(values, param) {
        values = utils.filterValues(values, param);
        values = utils.resampleWithMax([values], [param], 'EnergyConsumption');
        this.excessProductionByDay = utils.filterByEpochPerDay(values, 'EnergyConsumption');
        return this;
    }

    setGridConsumption(values, param) {
        values = utils.filterValues(values, param);
        values = utils.resampleWithMax([values], [param], 'EnergyConsumption');
        this.gridConsumptionByDay = utils.filterByEpochPerDay(values, 'EnergyConsumption');
        return this;
    }

    getScore(asOfDate) {
        var byDay = this.productionByDay;

        for(let i=0; i<byDay.length; i++) {
            let production = byDay[i].data;
            let excessProduction = this.excessProductionByDay[i].data;
            let gridConsumption = this.gridConsumptionByDay[i].data;


            let l = byDay[i].periods.length;

            byDay[i].points = new Array(l);
            byDay[i].maxUntilNow = new Array(l);
            byDay[i].fraction = new Array(l);

            for(let j = 0; j < l; j++) {
                // Get largest consumption value
                let p = production[j].map(mapValue);
                let ep = excessProduction[j].map(mapValue);
                let gc = gridConsumption[j].map(mapValue);

                p = utils.interpolate(p);
                ep = utils.interpolate(ep);
                gc = utils.interpolate(gc);

                var elapsedFraction = utils.getElapsedFraction([byDay[i].periods[j]], asOfDate);

                if (!p.length || !ep.length || !gc.length || p[0] === null || gc[0] === null || ep[0] === null) {
                    byDay[i].points[j] = 0;
                    byDay[i].maxUntilNow[j] = byDay[i].periods[j].points * elapsedFraction;
                    byDay[i].fraction[j] = 0;
                    continue;
                }

                p = utils.diff(p);
                ep = utils.diff(ep);
                gc = utils.diff(gc);


                var avg = 0, count = 0;
                for (var k = 0; k < p.length; k++) {
                    var nom = p[k] - ep[k];
                    var denom = nom + gc[k];
                    if(denom <= 0 || nom < 0) continue;
                    count++;
                    avg += nom / denom;
                }
                avg /= count;

                byDay[i].fraction[j] = avg;
                byDay[i].points[j] = avg * byDay[i].periods[j].points * elapsedFraction;
                byDay[i].maxUntilNow[j] = byDay[i].periods[j].points * elapsedFraction;
            }
        }
        return utils.finalizeScores(byDay);
    }
}

function mapValue(val) {
    return val.value;
}

module.exports = EnergyConsumption;