solar-scores/src/scores/energyConsumption.js

Compute scores for solar decathlon competition - Cali 2015

'use strict';

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

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

    setProduction(values, param) {
        values = utils.filterValues(values, param);
        this.production = utils.filterByEpoch(values, 'EnergyConsumption');
        this.productionParam = param;
        return this;
    }

    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) {
        var production = this.production;
        var excessProduction = this.excessProduction;
        var gridConsumption = this.gridConsumption;
        let consumption;
        let firstConsumption;
        let lastConsumption;
            // Get largest consumption value
            let p = production.map(val => {
                return val[this.productionParam];
            });
            p = utils.interpolate(p);

            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(p.length && ep.length && gc.length &&  p[p.length-1] !== null && ep[ep.length-1] !== null && gc[gc.length-1] !== null) {
                lastConsumption = p[p.length-1] + gc[gc.length-1] - ep[ep.length-1];
            }
            if(p.length && ep.length && gc.length && p[0] !== null && ep[0] !== null && gc[0] !== null && firstConsumption === undefined) {
                firstConsumption = p[0] + gc[0] - ep[0];
            }

        consumption = lastConsumption - firstConsumption;
        var elapsedFraction = utils.getElapsedFraction('EnergyConsumption', asOfDate);

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


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

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

        var scoringFunction = utils.getSingleScoringFunction(this.singleScoringParams[0] * elapsedFraction, this.singleScoringParams[1] * elapsedFraction);

        var scoreFraction = scoringFunction(consumption*elapsedFraction);
        //console.log("Consumption "+consumption+" "+scoreFraction+" "+elapsedFraction);
        result.points = scoreFraction * points.EnergyConsumption * finished;
        result.projected = scoreFraction * points.EnergyConsumption;
        result.fraction = scoreFraction;
        return result;
    }
}



module.exports = EnergyConsumption;