solar-scores/src/scores/energyBalance.js

Compute scores for solar decathlon competition - Cali 2015

'use strict';

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

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

    setExcessProduction(values, param) {
        values = utils.filterValues(values, param);
        this.excessProduction = utils.filterByEpoch(values, 'EnergyConsumption');
        this.excessProductionParam = param;
        return this;
    }

    setGridConsumption(values, param) {
        values = utils.filterValues(values, param);
        this.gridConsumption = utils.filterByEpoch(values, 'EnergyConsumption');
        this.gridconsumptionParam = param;
        return this;
    }


    getScore(asOfDate) {

        let excessProduction = this.excessProduction;
        let gridConsumption = this.gridConsumption;
        let balance;
        let firstBalance;
        let lastBalance;

        let ep = excessProduction.map(val => {
            return val[this.excessProductionParam];
        });
        ep = utils.interpolate(ep);

        let gc = gridConsumption.map(val => {
            return val[this.gridconsumptionParam];
        });
        gc = utils.interpolate(gc);

        if (ep.length && gc.length && ep[ep.length - 1] !== null && gc[gc.length - 1] !== null) {
            lastBalance = ep[ep.length - 1] - gc[gc.length - 1];
        }
        if (ep.length && gc.length && ep[0] !== null && gc[0] !== null && firstBalance === undefined) {
            firstBalance = ep[0] - gc[0];
        }

        balance = lastBalance - firstBalance;


        var elapsedFraction = utils.getElapsedFraction('EnergyBalance', asOfDate);

        var result = {
            points: 0,
            maxUntilNow: elapsedFraction * points.EnergyBalance,
            max: points.EnergyBalance,
            projected: 0
        };

        if (Number.isNaN(balance)) {
            return result;
        }

        //DO NOT REPORT PARTIAL POINTS!!!
        var finished = elapsedFraction>=1?1:0;

        var scoringFunction = utils.getDoubleScoringFunction.apply(null, this.doubleScoringParams.map(function (val) {
            return val * elapsedFraction;
        }));

        var scoreFraction = scoringFunction(balance);
        result.fraction = scoreFraction;
        result.points = scoreFraction * finished * points.EnergyBalance;
        result.projected = scoreFraction * points.EnergyBalance;
        return result;
    }
}


module.exports = EnergyBalance;