@grnsft/if 0.0.2

package/build/lib/boavizta/index.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoaviztaCloudOutputModel = exports.BoaviztaCpuOutputModel = void 0;
+const axios_1 = require("axios");
+const config_1 = require("../../config");
+const { MODEL_IDS } = config_1.CONFIG;
+const { BOAVIZTA_CPU, BOAVIZTA_CLOUD } = MODEL_IDS;
+class BoaviztaOutputModel {
+    constructor() {
+        this.sharedParams = undefined;
+        this.metricType = 'cpu-util';
+        this.expectedLifespan = 4 * 365 * 24 * 60 * 60;
+    }
+    async authenticate(authParams) {
+        this.authCredentials = authParams;
+    }
+    async configure(name, staticParams = undefined) {
+        this.name = name;
+        this.sharedParams = await this.captureStaticParams(staticParams ?? {});
+        return this;
+    }
+    // list of supported locations by the model
+    async supportedLocations() {
+        const countries = await axios_1.default.get('https://api.boavizta.org/v1/utils/country_code');
+        return Object.values(countries.data);
+    }
+    // converts the usage from IMPL input to the format required by Boavizta API.
+    transformToBoaviztaUsage(duration, metric) {
+        // duration is in seconds, convert to hours
+        // metric is between 0 and 1, convert to percentage
+        let usageInput = {
+            hours_use_time: duration / 3600.0,
+            time_workload: metric,
+        };
+        // convert expected lifespan from seconds to years
+        usageInput['years_life_time'] =
+            this.expectedLifespan / (365.0 * 24.0 * 60.0 * 60.0);
+        usageInput = this.addLocationToUsage(usageInput);
+        return usageInput;
+    }
+    // Calculates the output of the given usage
+    async execute(inputs = undefined) {
+        if (Array.isArray(inputs)) {
+            const results = [];
+            for (const input of inputs) {
+                const usageResult = await this.calculateUsageForinput(input);
+                results.push(usageResult);
+            }
+            return results;
+        }
+        else {
+            throw new Error('Parameter Not Given: invalid inputs parameter. Expecting an array of inputs');
+        }
+    }
+    // Adds location to usage if location is defined in sharedParams
+    addLocationToUsage(usageRaw) {
+        if (this.sharedParams !== undefined && 'location' in this.sharedParams) {
+            usageRaw['usage_location'] = this.sharedParams['location'];
+        }
+        return usageRaw;
+    }
+    // extracts information from Boavizta API response to return the output in the format required by IMPL
+    formatResponse(data) {
+        let m = 0;
+        let e = 0;
+        if ('outputs' in data) {
+            // embodied-carbon output is in kgCO2eq, convert to gCO2eq
+            m = data['outputs']['gwp']['embedded']['value'] * 1000;
+            // use output is in J , convert to kWh.
+            // 1,000,000 J / 3600 = 277.7777777777778 Wh.
+            // 1 MJ / 3.6 = 0.278 kWh
+            e = data['outputs']['pe']['use']['value'] / 3.6;
+        }
+        else if ('gwp' in data && 'pe' in data) {
+            // embodied-carbon output is in kgCO2eq, convert to gCO2eq
+            m = data['gwp']['embodied-carbon'] * 1000;
+            // use output is in J , convert to kWh.
+            // 1,000,000 J / 3600 = 277.7777777777778 Wh.
+            // 1 MJ / 3.6 = 0.278 kWh
+            e = data['pe']['use'] / 3.6;
+        }
+        return { 'embodied-carbon': m, energy: e };
+    }
+    // converts the usage to the format required by Boavizta API.
+    async calculateUsageForinput(input) {
+        if ('timestamp' in input &&
+            'duration' in input &&
+            this.metricType in input) {
+            const usageInput = this.transformToBoaviztaUsage(input['duration'], input[this.metricType]);
+            const usage = (await this.fetchData(usageInput));
+            return usage;
+        }
+        else {
+            throw new Error('Invalid Input: Invalid inputs parameter');
+        }
+    }
+}
+class BoaviztaCpuOutputModel extends BoaviztaOutputModel {
+    constructor() {
+        super();
+        this.sharedParams = undefined;
+        this.verbose = false;
+        this.allocation = 'LINEAR';
+        this.componentType = 'cpu';
+        this.metricType = 'cpu-util';
+        this.componentType = 'cpu';
+    }
+    modelIdentifier() {
+        return BOAVIZTA_CPU;
+    }
+    async fetchData(usageData) {
+        if (this.sharedParams === undefined) {
+            throw new Error('Improper configure: Missing configuration parameters');
+        }
+        const dataCast = this.sharedParams;
+        dataCast['usage'] = usageData;
+        const response = await axios_1.default.post(`https://api.boavizta.org/v1/component/${this.componentType}?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`, dataCast);
+        const result = this.formatResponse(response.data);
+        // console.log(
+        //   'hitting ',
+        //   `https://api.boavizta.org/v1/component/${this.componentType}?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,
+        //   dataCast,
+        //   JSON.stringify(response.data)
+        // );
+        return {
+            'e-cpu': result.energy,
+            'embodied-carbon': result['embodied-carbon'],
+        };
+    }
+    async captureStaticParams(staticParams) {
+        if ('verbose' in staticParams) {
+            this.verbose = staticParams.verbose ?? false;
+            staticParams.verbose = undefined;
+        }
+        if (!('physical-processor' in staticParams)) {
+            throw new Error('Improper configure: Missing processor parameter');
+        }
+        if (!('core-units' in staticParams)) {
+            throw new Error('Improper configure: Missing core-units parameter');
+        }
+        if ('expected-lifespan' in staticParams) {
+            this.expectedLifespan = staticParams['expected-lifespan'];
+        }
+        this.sharedParams = Object.assign({}, staticParams);
+        return this.sharedParams;
+    }
+}
+exports.BoaviztaCpuOutputModel = BoaviztaCpuOutputModel;
+class BoaviztaCloudOutputModel extends BoaviztaOutputModel {
+    constructor() {
+        super(...arguments);
+        this.sharedParams = undefined;
+        this.instanceTypes = {};
+        this.verbose = false;
+        this.allocation = 'LINEAR';
+    }
+    modelIdentifier() {
+        return BOAVIZTA_CLOUD;
+    }
+    async validateLocation(staticParamsCast) {
+        if ('location' in staticParamsCast) {
+            const location = staticParamsCast.location ?? 'USA';
+            const countries = await this.supportedLocations();
+            if (!countries.includes(location)) {
+                throw new Error("Improper configure: Invalid location parameter: '" +
+                    location +
+                    "'. Valid values are : " +
+                    countries.join(', '));
+            }
+            return staticParamsCast.location;
+        }
+    }
+    async validateInstanceType(staticParamsCast) {
+        if (!('provider' in staticParamsCast)) {
+            throw new Error('Improper configure: Missing provider parameter');
+        }
+        if (!('instance-type' in staticParamsCast)) {
+            throw new Error("Improper configure: Missing 'instance-type' parameter");
+        }
+        const provider = staticParamsCast.provider;
+        if (this.instanceTypes[provider] === undefined ||
+            this.instanceTypes[provider].length === 0) {
+            this.instanceTypes[provider] = await this.supportedInstancesList(provider);
+        }
+        if ('instance-type' in staticParamsCast) {
+            if (!this.instanceTypes[provider].includes(staticParamsCast['instance-type'])) {
+                throw new Error(`Improper configure: Invalid 'instance-type' parameter: '${staticParamsCast['instance-type']}'. Valid values are : ${this.instanceTypes[provider].join(', ')}`);
+            }
+        }
+    }
+    async validateProvider(staticParamsCast) {
+        if (!('provider' in staticParamsCast)) {
+            throw new Error('Improper configure: Missing provider parameter');
+        }
+        else {
+            const supportedProviders = await this.supportedProvidersList();
+            if (!supportedProviders.includes(staticParamsCast.provider)) {
+                throw new Error("Improper configure: Invalid provider parameter: '" +
+                    staticParamsCast.provider +
+                    "'. Valid values are : " +
+                    supportedProviders.join(', '));
+            }
+        }
+    }
+    async supportedInstancesList(provider) {
+        const instances = await axios_1.default.get(`https://api.boavizta.org/v1/cloud/instance/all_instances?provider=${provider}`);
+        return instances.data;
+    }
+    async supportedProvidersList() {
+        const providers = await axios_1.default.get('https://api.boavizta.org/v1/cloud/instance/all_providers');
+        return Object.values(providers.data);
+    }
+    async fetchData(usageData) {
+        if (this.sharedParams === undefined) {
+            throw new Error('Improper configure: Missing configuration parameters');
+        }
+        const dataCast = this.sharedParams;
+        for (const key in dataCast) {
+            //   replace - with _ in keys
+            if (key.includes('-')) {
+                const newKey = key.replace(/-/g, '_');
+                dataCast[newKey] = dataCast[key];
+                delete dataCast[key];
+            }
+        }
+        dataCast['usage'] = usageData;
+        const response = await axios_1.default.post(`https://api.boavizta.org/v1/cloud/instance?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`, dataCast);
+        // console.log(
+        //   `https://api.boavizta.org/v1/cloud/instance?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,
+        //   JSON.stringify(response.data),
+        //   dataCast
+        // );
+        return this.formatResponse(response.data);
+    }
+    async captureStaticParams(staticParams) {
+        if ('verbose' in staticParams) {
+            this.verbose = staticParams.verbose ?? false;
+            staticParams.verbose = undefined;
+        }
+        // if no valid provider found, throw error
+        await this.validateProvider(staticParams);
+        // if no valid 'instance-type' found, throw error
+        await this.validateInstanceType(staticParams);
+        // if no valid location found, throw error
+        await this.validateLocation(staticParams);
+        if ('expected-lifespan' in staticParams) {
+            this.expectedLifespan = staticParams['expected-lifespan'];
+        }
+        this.sharedParams = Object.assign({}, staticParams);
+        return this.sharedParams;
+    }
+}
+exports.BoaviztaCloudOutputModel = BoaviztaCloudOutputModel;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/boavizta/index.ts"],"names":[],"mappings":"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","sourcesContent":["import axios from 'axios';\n\nimport {IOutputModelInterface} from '../interfaces';\nimport {CONFIG} from '../../config';\n\nimport {BoaviztaInstanceTypes, IBoaviztaUsageSCI} from '../../types/boavizta';\nimport {KeyValuePair} from '../../types/common';\n\nconst {MODEL_IDS} = CONFIG;\nconst {BOAVIZTA_CPU, BOAVIZTA_CLOUD} = MODEL_IDS;\n\nabstract class BoaviztaOutputModel implements IOutputModelInterface {\n  name: string | undefined;\n  sharedParams: object | undefined = undefined;\n  metricType: 'cpu-util' | 'gpu-util' | 'ram-util' = 'cpu-util';\n  expectedLifespan = 4 * 365 * 24 * 60 * 60;\n  protected authCredentials: object | undefined;\n\n  async authenticate(authParams: object) {\n    this.authCredentials = authParams;\n  }\n\n  async configure(\n    name: string,\n    staticParams: object | undefined = undefined\n  ): Promise<IOutputModelInterface> {\n    this.name = name;\n    this.sharedParams = await this.captureStaticParams(staticParams ?? {});\n    return this;\n  }\n\n  //defines the model identifier\n  abstract modelIdentifier(): string;\n\n  //fetches data from Boavizta API according to the specific endpoint of the model\n  abstract fetchData(usageData: object | undefined): Promise<object>;\n\n  // list of supported locations by the model\n  async supportedLocations(): Promise<string[]> {\n    const countries = await axios.get(\n      'https://api.boavizta.org/v1/utils/country_code'\n    );\n    return Object.values(countries.data);\n  }\n\n  // converts the usage from IMPL input to the format required by Boavizta API.\n  transformToBoaviztaUsage(duration: number, metric: number) {\n    // duration is in seconds, convert to hours\n    // metric is between 0 and 1, convert to percentage\n    let usageInput: KeyValuePair = {\n      hours_use_time: duration / 3600.0,\n      time_workload: metric,\n    };\n    // convert expected lifespan from seconds to years\n    usageInput['years_life_time'] =\n      this.expectedLifespan / (365.0 * 24.0 * 60.0 * 60.0);\n    usageInput = this.addLocationToUsage(usageInput);\n\n    return usageInput;\n  }\n\n  // Calculates the output of the given usage\n  async execute(\n    inputs: object | object[] | undefined = undefined\n  ): Promise<any[]> {\n    if (Array.isArray(inputs)) {\n      const results: KeyValuePair[] = [];\n\n      for (const input of inputs) {\n        const usageResult = await this.calculateUsageForinput(input);\n        results.push(usageResult);\n      }\n\n      return results;\n    } else {\n      throw new Error(\n        'Parameter Not Given: invalid inputs parameter. Expecting an array of inputs'\n      );\n    }\n  }\n\n  // Adds location to usage if location is defined in sharedParams\n  addLocationToUsage(usageRaw: KeyValuePair) {\n    if (this.sharedParams !== undefined && 'location' in this.sharedParams) {\n      usageRaw['usage_location'] = this.sharedParams['location'];\n    }\n\n    return usageRaw;\n  }\n\n  //abstract subs to make compatibility with base interface. allows configure to be defined in base class\n  protected abstract captureStaticParams(staticParams: object): object;\n\n  // extracts information from Boavizta API response to return the output in the format required by IMPL\n  protected formatResponse(data: KeyValuePair): KeyValuePair {\n    let m = 0;\n    let e = 0;\n    if ('outputs' in data) {\n      // embodied-carbon output is in kgCO2eq, convert to gCO2eq\n      m = data['outputs']['gwp']['embedded']['value'] * 1000;\n      // use output is in J , convert to kWh.\n      // 1,000,000 J / 3600 = 277.7777777777778 Wh.\n      // 1 MJ / 3.6 = 0.278 kWh\n      e = data['outputs']['pe']['use']['value'] / 3.6;\n    } else if ('gwp' in data && 'pe' in data) {\n      // embodied-carbon output is in kgCO2eq, convert to gCO2eq\n      m = data['gwp']['embodied-carbon'] * 1000;\n      // use output is in J , convert to kWh.\n      // 1,000,000 J / 3600 = 277.7777777777778 Wh.\n      // 1 MJ / 3.6 = 0.278 kWh\n      e = data['pe']['use'] / 3.6;\n    }\n\n    return {'embodied-carbon': m, energy: e};\n  }\n\n  // converts the usage to the format required by Boavizta API.\n  protected async calculateUsageForinput(\n    input: KeyValuePair\n  ): Promise<KeyValuePair> {\n    if (\n      'timestamp' in input &&\n      'duration' in input &&\n      this.metricType in input\n    ) {\n      const usageInput = this.transformToBoaviztaUsage(\n        input['duration'],\n        input[this.metricType]\n      );\n      const usage = (await this.fetchData(usageInput)) as IBoaviztaUsageSCI;\n\n      return usage;\n    } else {\n      throw new Error('Invalid Input: Invalid inputs parameter');\n    }\n  }\n}\n\nexport class BoaviztaCpuOutputModel\n  extends BoaviztaOutputModel\n  implements IOutputModelInterface\n{\n  sharedParams: object | undefined = undefined;\n  public name: string | undefined;\n  public verbose = false;\n  public allocation = 'LINEAR';\n  private readonly componentType = 'cpu';\n\n  constructor() {\n    super();\n    this.metricType = 'cpu-util';\n    this.componentType = 'cpu';\n  }\n\n  modelIdentifier(): string {\n    return BOAVIZTA_CPU;\n  }\n\n  async fetchData(usageData: object | undefined): Promise<object> {\n    if (this.sharedParams === undefined) {\n      throw new Error('Improper configure: Missing configuration parameters');\n    }\n\n    const dataCast = this.sharedParams as KeyValuePair;\n    dataCast['usage'] = usageData;\n\n    const response = await axios.post(\n      `https://api.boavizta.org/v1/component/${this.componentType}?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,\n      dataCast\n    );\n\n    const result = this.formatResponse(response.data);\n\n    // console.log(\n    //   'hitting ',\n    //   `https://api.boavizta.org/v1/component/${this.componentType}?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,\n    //   dataCast,\n    //   JSON.stringify(response.data)\n    // );\n    return {\n      'e-cpu': result.energy,\n      'embodied-carbon': result['embodied-carbon'],\n    };\n  }\n\n  protected async captureStaticParams(staticParams: object): Promise<object> {\n    if ('verbose' in staticParams) {\n      this.verbose = (staticParams.verbose as boolean) ?? false;\n      staticParams.verbose = undefined;\n    }\n\n    if (!('physical-processor' in staticParams)) {\n      throw new Error('Improper configure: Missing processor parameter');\n    }\n\n    if (!('core-units' in staticParams)) {\n      throw new Error('Improper configure: Missing core-units parameter');\n    }\n\n    if ('expected-lifespan' in staticParams) {\n      this.expectedLifespan = staticParams['expected-lifespan'] as number;\n    }\n    this.sharedParams = Object.assign({}, staticParams);\n\n    return this.sharedParams;\n  }\n}\n\nexport class BoaviztaCloudOutputModel\n  extends BoaviztaOutputModel\n  implements IOutputModelInterface\n{\n  public sharedParams: object | undefined = undefined;\n  public instanceTypes: BoaviztaInstanceTypes = {};\n  public name: string | undefined;\n  public verbose = false;\n  public allocation = 'LINEAR';\n\n  modelIdentifier(): string {\n    return BOAVIZTA_CLOUD;\n  }\n\n  async validateLocation(staticParamsCast: object): Promise<string | void> {\n    if ('location' in staticParamsCast) {\n      const location = (staticParamsCast.location as string) ?? 'USA';\n      const countries = await this.supportedLocations();\n      if (!countries.includes(location)) {\n        throw new Error(\n          \"Improper configure: Invalid location parameter: '\" +\n            location +\n            \"'. Valid values are : \" +\n            countries.join(', ')\n        );\n      }\n      return staticParamsCast.location as string;\n    }\n  }\n\n  async validateInstanceType(staticParamsCast: object) {\n    if (!('provider' in staticParamsCast)) {\n      throw new Error('Improper configure: Missing provider parameter');\n    }\n\n    if (!('instance-type' in staticParamsCast)) {\n      throw new Error(\"Improper configure: Missing 'instance-type' parameter\");\n    }\n\n    const provider = staticParamsCast.provider as string;\n\n    if (\n      this.instanceTypes[provider] === undefined ||\n      this.instanceTypes[provider].length === 0\n    ) {\n      this.instanceTypes[provider] = await this.supportedInstancesList(\n        provider\n      );\n    }\n\n    if ('instance-type' in staticParamsCast) {\n      if (\n        !this.instanceTypes[provider].includes(\n          staticParamsCast['instance-type'] as string\n        )\n      ) {\n        throw new Error(\n          `Improper configure: Invalid 'instance-type' parameter: '${\n            staticParamsCast['instance-type']\n          }'. Valid values are : ${this.instanceTypes[provider].join(', ')}`\n        );\n      }\n    }\n  }\n\n  async validateProvider(staticParamsCast: object) {\n    if (!('provider' in staticParamsCast)) {\n      throw new Error('Improper configure: Missing provider parameter');\n    } else {\n      const supportedProviders = await this.supportedProvidersList();\n\n      if (!supportedProviders.includes(staticParamsCast.provider as string)) {\n        throw new Error(\n          \"Improper configure: Invalid provider parameter: '\" +\n            staticParamsCast.provider +\n            \"'. Valid values are : \" +\n            supportedProviders.join(', ')\n        );\n      }\n    }\n  }\n\n  async supportedInstancesList(provider: string) {\n    const instances = await axios.get(\n      `https://api.boavizta.org/v1/cloud/instance/all_instances?provider=${provider}`\n    );\n\n    return instances.data;\n  }\n\n  async supportedProvidersList(): Promise<string[]> {\n    const providers = await axios.get(\n      'https://api.boavizta.org/v1/cloud/instance/all_providers'\n    );\n\n    return Object.values(providers.data);\n  }\n\n  async fetchData(usageData: object | undefined): Promise<object> {\n    if (this.sharedParams === undefined) {\n      throw new Error('Improper configure: Missing configuration parameters');\n    }\n\n    const dataCast = this.sharedParams as KeyValuePair;\n    for (const key in dataCast) {\n      //   replace - with _ in keys\n      if (key.includes('-')) {\n        const newKey = key.replace(/-/g, '_');\n        dataCast[newKey] = dataCast[key];\n        delete dataCast[key];\n      }\n    }\n    dataCast['usage'] = usageData;\n    const response = await axios.post(\n      `https://api.boavizta.org/v1/cloud/instance?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,\n      dataCast\n    );\n    // console.log(\n    //   `https://api.boavizta.org/v1/cloud/instance?verbose=${this.verbose}&duration=${dataCast['usage']['hours_use_time']}`,\n    //   JSON.stringify(response.data),\n    //   dataCast\n    // );\n\n    return this.formatResponse(response.data);\n  }\n\n  protected async captureStaticParams(staticParams: object) {\n    if ('verbose' in staticParams) {\n      this.verbose = (staticParams.verbose as boolean) ?? false;\n      staticParams.verbose = undefined;\n    }\n    // if no valid provider found, throw error\n    await this.validateProvider(staticParams);\n    // if no valid 'instance-type' found, throw error\n    await this.validateInstanceType(staticParams);\n    // if no valid location found, throw error\n    await this.validateLocation(staticParams);\n\n    if ('expected-lifespan' in staticParams) {\n      this.expectedLifespan = staticParams['expected-lifespan'] as number;\n    }\n\n    this.sharedParams = Object.assign({}, staticParams);\n\n    return this.sharedParams;\n  }\n}\n\n/**\n * For JSII.\n */\nexport {IOutputModelInterface} from '../interfaces';\nexport {BoaviztaInstanceTypes, IBoaviztaUsageSCI} from '../../types/boavizta';\nexport {KeyValuePair} from '../../types/common';\n"]}

package/build/lib/case-studies/aveva-model.d.ts

@@ -0,0 +1,29 @@
+import { IOutputModelInterface } from '../interfaces';
+export declare class EAvevaModel implements IOutputModelInterface {
+    authParams: object | undefined;
+    name: string | undefined;
+    staticParams: object | undefined;
+    /**
+     * Defined for compatibility. Not used here.
+     */
+    authenticate(authParams: object): void;
+    /**
+     * Configures the Aveva Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     */
+    configure(name: string, staticParams?: object | undefined): Promise<IOutputModelInterface>;
+    /**
+     * Calculate the total emissions for a list of inputs.
+     * Each input require:
+     * @param {Object[]} inputs
+     * @param {number} inputs[].time time to normalize to in hours
+     * @param {number} inputs[].pb baseline power
+     * @param {number} inputs[].pl measured power
+     */
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier(): string;
+}

package/build/lib/case-studies/aveva-model.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EAvevaModel = void 0;
+const config_1 = require("../../config");
+const { MODEL_IDS } = config_1.CONFIG;
+const { AVEVA } = MODEL_IDS;
+class EAvevaModel {
+    /**
+     * Defined for compatibility. Not used here.
+     */
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    /**
+     * Configures the Aveva Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     */
+    async configure(name, staticParams = undefined) {
+        this.name = name;
+        this.staticParams = staticParams;
+        return this;
+    }
+    /**
+     * Calculate the total emissions for a list of inputs.
+     * Each input require:
+     * @param {Object[]} inputs
+     * @param {number} inputs[].time time to normalize to in hours
+     * @param {number} inputs[].pb baseline power
+     * @param {number} inputs[].pl measured power
+     */
+    async execute(inputs) {
+        if (inputs === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        else if (!Array.isArray(inputs)) {
+            throw new Error('inputs must be an array');
+        }
+        return inputs.map(input => {
+            input['energy-cpu'] =
+                ((input['pl'] - input['pb']) * input['time']) / 1000;
+            return input;
+        });
+    }
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier() {
+        return AVEVA;
+    }
+}
+exports.EAvevaModel = EAvevaModel;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXZldmEtbW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2Nhc2Utc3R1ZGllcy9hdmV2YS1tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSx5Q0FBb0M7QUFFcEMsTUFBTSxFQUFDLFNBQVMsRUFBQyxHQUFHLGVBQU0sQ0FBQztBQUMzQixNQUFNLEVBQUMsS0FBSyxFQUFDLEdBQUcsU0FBUyxDQUFDO0FBRTFCLE1BQWEsV0FBVztJQUt0Qjs7T0FFRztJQUNILFlBQVksQ0FBQyxVQUFrQjtRQUM3QixJQUFJLENBQUMsVUFBVSxHQUFHLFVBQVUsQ0FBQztJQUMvQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUssQ0FBQyxTQUFTLENBQ2IsSUFBWSxFQUNaLGVBQW1DLFNBQVM7UUFFNUMsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUM7UUFFakMsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNILEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBcUM7UUFDakQsSUFBSSxNQUFNLEtBQUssU0FBUyxFQUFFO1lBQ3hCLE1BQU0sSUFBSSxLQUFLLENBQUMsa0NBQWtDLENBQUMsQ0FBQztTQUNyRDthQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFO1lBQ2pDLE1BQU0sSUFBSSxLQUFLLENBQUMseUJBQXlCLENBQUMsQ0FBQztTQUM1QztRQUVELE9BQU8sTUFBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUN4QixLQUFLLENBQUMsWUFBWSxDQUFDO2dCQUNqQixDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLElBQUksQ0FBQztZQUV2RCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsZUFBZTtRQUNiLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztDQUNGO0FBeERELGtDQXdEQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SU91dHB1dE1vZGVsSW50ZXJmYWNlfSBmcm9tICcuLi9pbnRlcmZhY2VzJztcblxuaW1wb3J0IHtDT05GSUd9IGZyb20gJy4uLy4uL2NvbmZpZyc7XG5cbmNvbnN0IHtNT0RFTF9JRFN9ID0gQ09ORklHO1xuY29uc3Qge0FWRVZBfSA9IE1PREVMX0lEUztcblxuZXhwb3J0IGNsYXNzIEVBdmV2YU1vZGVsIGltcGxlbWVudHMgSU91dHB1dE1vZGVsSW50ZXJmYWNlIHtcbiAgYXV0aFBhcmFtczogb2JqZWN0IHwgdW5kZWZpbmVkOyAvLyBEZWZpbmVkIGZvciBjb21wYXRpYmlsaXR5LiBOb3QgdXNlZCBpbiBBdmV2YS5cbiAgbmFtZTogc3RyaW5nIHwgdW5kZWZpbmVkOyAvLyBuYW1lIG9mIHRoZSBkYXRhIHNvdXJjZVxuICBzdGF0aWNQYXJhbXM6IG9iamVjdCB8IHVuZGVmaW5lZDsgLy8gRGVmaW5lZCBmb3IgY29tcGF0aWJpbGl0eS4gTm90IHVzZWQgaW4gQXZldmEuXG5cbiAgLyoqXG4gICAqIERlZmluZWQgZm9yIGNvbXBhdGliaWxpdHkuIE5vdCB1c2VkIGhlcmUuXG4gICAqL1xuICBhdXRoZW50aWNhdGUoYXV0aFBhcmFtczogb2JqZWN0KTogdm9pZCB7XG4gICAgdGhpcy5hdXRoUGFyYW1zID0gYXV0aFBhcmFtcztcbiAgfVxuXG4gIC8qKlxuICAgKiBDb25maWd1cmVzIHRoZSBBdmV2YSBQbHVnaW4gZm9yIElFRlxuICAgKiBAcGFyYW0ge3N0cmluZ30gbmFtZSBuYW1lIG9mIHRoZSByZXNvdXJjZVxuICAgKiBAcGFyYW0ge09iamVjdH0gc3RhdGljUGFyYW1zIHN0YXRpYyBwYXJhbWV0ZXJzIGZvciB0aGUgcmVzb3VyY2VcbiAgICovXG4gIGFzeW5jIGNvbmZpZ3VyZShcbiAgICBuYW1lOiBzdHJpbmcsXG4gICAgc3RhdGljUGFyYW1zOiBvYmplY3QgfCB1bmRlZmluZWQgPSB1bmRlZmluZWRcbiAgKTogUHJvbWlzZTxJT3V0cHV0TW9kZWxJbnRlcmZhY2U+IHtcbiAgICB0aGlzLm5hbWUgPSBuYW1lO1xuICAgIHRoaXMuc3RhdGljUGFyYW1zID0gc3RhdGljUGFyYW1zO1xuXG4gICAgcmV0dXJuIHRoaXM7XG4gIH1cblxuICAvKipcbiAgICogQ2FsY3VsYXRlIHRoZSB0b3RhbCBlbWlzc2lvbnMgZm9yIGEgbGlzdCBvZiBpbnB1dHMuXG4gICAqIEVhY2ggaW5wdXQgcmVxdWlyZTpcbiAgICogQHBhcmFtIHtPYmplY3RbXX0gaW5wdXRzXG4gICAqIEBwYXJhbSB7bnVtYmVyfSBpbnB1dHNbXS50aW1lIHRpbWUgdG8gbm9ybWFsaXplIHRvIGluIGhvdXJzXG4gICAqIEBwYXJhbSB7bnVtYmVyfSBpbnB1dHNbXS5wYiBiYXNlbGluZSBwb3dlclxuICAgKiBAcGFyYW0ge251bWJlcn0gaW5wdXRzW10ucGwgbWVhc3VyZWQgcG93ZXJcbiAgICovXG4gIGFzeW5jIGV4ZWN1dGUoaW5wdXRzOiBvYmplY3QgfCBvYmplY3RbXSB8IHVuZGVmaW5lZCk6IFByb21pc2U8YW55W10+IHtcbiAgICBpZiAoaW5wdXRzID09PSB1bmRlZmluZWQpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignUmVxdWlyZWQgUGFyYW1ldGVycyBub3QgcHJvdmlkZWQnKTtcbiAgICB9IGVsc2UgaWYgKCFBcnJheS5pc0FycmF5KGlucHV0cykpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcignaW5wdXRzIG11c3QgYmUgYW4gYXJyYXknKTtcbiAgICB9XG5cbiAgICByZXR1cm4gaW5wdXRzLm1hcChpbnB1dCA9PiB7XG4gICAgICBpbnB1dFsnZW5lcmd5LWNwdSddID1cbiAgICAgICAgKChpbnB1dFsncGwnXSAtIGlucHV0WydwYiddKSAqIGlucHV0Wyd0aW1lJ10pIC8gMTAwMDtcblxuICAgICAgcmV0dXJuIGlucHV0O1xuICAgIH0pO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHVybnMgbW9kZWwgaWRlbnRpZmllclxuICAgKi9cbiAgbW9kZWxJZGVudGlmaWVyKCkge1xuICAgIHJldHVybiBBVkVWQTtcbiAgfVxufVxuIl19

package/build/lib/case-studies/emem-model.d.ts

@@ -0,0 +1,42 @@
+import { IOutputModelInterface } from '../interfaces';
+export declare class EMemModel implements IOutputModelInterface {
+    authParams: object | undefined;
+    name: string | undefined;
+    memoryAllocation: number;
+    memoryEnergy: number;
+    /**
+     * Defined for compatibility. Not used.
+     */
+    authenticate(authParams: object): void;
+    /**
+     * Configures the Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     * @param {number} staticParams.thermal-design-power Thermal Design Power in Watts
+     * @param {Interpolation} staticParams.interpolation Interpolation method
+     */
+    configure(name: string, staticParams?: object | undefined): Promise<IOutputModelInterface>;
+    /**
+     * Calculate the total emissions for a list of inputs.
+     *
+     * Each input require:
+     * @param {Object[]} inputs
+     * @param {string} inputs[].timestamp RFC3339 timestamp string
+     * @param {number} inputs[].mem-util percentage mem usage
+     */
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier(): string;
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * mem-util: ram usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * multiplies memory used (GB) by a coefficient (wh/GB) and converts to kwh
+     */
+    private calculateEnergy;
+}

package/build/lib/case-studies/emem-model.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMemModel = void 0;
+const config_1 = require("../../config");
+const { MODEL_IDS } = config_1.CONFIG;
+const { EMEM } = MODEL_IDS;
+class EMemModel {
+    constructor() {
+        this.memoryAllocation = 0;
+        this.memoryEnergy = 0;
+    }
+    /**
+     * Defined for compatibility. Not used.
+     */
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    /**
+     * Configures the Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     * @param {number} staticParams.thermal-design-power Thermal Design Power in Watts
+     * @param {Interpolation} staticParams.interpolation Interpolation method
+     */
+    async configure(name, staticParams = undefined) {
+        this.name = name;
+        if (staticParams === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        if ('mem-alloc' in staticParams) {
+            this.memoryAllocation = staticParams['mem-alloc'];
+        }
+        if ('mem-energy' in staticParams) {
+            this.memoryEnergy = staticParams['mem-energy'];
+        }
+        return this;
+    }
+    /**
+     * Calculate the total emissions for a list of inputs.
+     *
+     * Each input require:
+     * @param {Object[]} inputs
+     * @param {string} inputs[].timestamp RFC3339 timestamp string
+     * @param {number} inputs[].mem-util percentage mem usage
+     */
+    async execute(inputs) {
+        if (inputs === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        else if (!Array.isArray(inputs)) {
+            throw new Error('inputs must be an array');
+        }
+        return inputs.map((input) => {
+            this.configure(this.name, input);
+            input['energy-memory'] = this.calculateEnergy(input);
+            return input;
+        });
+    }
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier() {
+        return EMEM;
+    }
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * mem-util: ram usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * multiplies memory used (GB) by a coefficient (wh/GB) and converts to kwh
+     */
+    calculateEnergy(input) {
+        if (!('mem-util' in input) || !('timestamp' in input)) {
+            throw new Error('Required Parameters duration,cpu-util,timestamp not provided for input');
+        }
+        if (this.memoryAllocation === 0) {
+            throw new Error('Required Parameter: mem-alloc not provided in configure');
+        }
+        if (this.memoryEnergy === 0) {
+            throw new Error('Required Parameter: mem-energy not provided in configure');
+        }
+        const mem_alloc = this.memoryAllocation;
+        const mem_util = input['mem-util']; // convert cpu usage to percentage
+        if (mem_util < 0 || mem_util > 100) {
+            throw new Error('cpu usage must be between 0 and 100');
+        }
+        return (mem_alloc * (mem_util / 100) * this.memoryEnergy) / 1000;
+    }
+}
+exports.EMemModel = EMemModel;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/case-studies/eshoppen-model.d.ts

@@ -0,0 +1,24 @@
+import { IOutputModelInterface } from '../interfaces';
+export { KeyValuePair } from '../../types/common';
+export declare class EshoppenModel implements IOutputModelInterface {
+    authParams: object | undefined;
+    modelType: 'energy-cpu' | 'energy-memory' | 'energy-network' | 'e-sum';
+    staticParams: object | undefined;
+    name: string | undefined;
+    authenticate(authParams: object): void;
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    configure(name: string, staticParams: object | undefined): Promise<IOutputModelInterface>;
+    modelIdentifier(): string;
+}
+export declare class EshoppenCpuModel extends EshoppenModel {
+    constructor();
+    modelIdentifier(): string;
+}
+export declare class EshoppenMemModel extends EshoppenModel {
+    constructor();
+    modelIdentifier(): string;
+}
+export declare class EshoppenNetModel extends EshoppenModel {
+    constructor();
+    modelIdentifier(): string;
+}