@grnsft/if 0.0.2

package/build/lib/teads-aws/index.d.ts

@@ -0,0 +1,58 @@
+import { IOutputModelInterface } from '../interfaces';
+export declare class TeadsAWS implements IOutputModelInterface {
+    authParams: object | undefined;
+    name: string | undefined;
+    private computeInstances;
+    private instanceType;
+    private expectedLifespan;
+    private interpolation;
+    constructor();
+    /**
+     * Defined for compatibility. Not used in TEADS.
+     */
+    authenticate(authParams: object): void;
+    /**
+     *  Configures the TEADS Plugin for IEF
+     *  @param {string} name name of the resource
+     *  @param {Object} staticParams static parameters for the resource
+     *  @param {string} staticParams.instance-type instance type from the list of supported instances
+     *  @param {number} staticParams.expected-lifespan expected lifespan of the instance in years
+     *  @param {Interpolation} staticParams.interpolation expected lifespan of the instance in years
+     */
+    configure(name: string, staticParams?: object | undefined): Promise<IOutputModelInterface>;
+    /**
+     * Calculate the total emissions for a list of inputs
+     *
+     * Each input require:
+     *  @param {Object[]} inputs  ISO 8601 timestamp string
+     *  @param {string} inputs[].timestamp ISO 8601 timestamp string
+     *  @param {number} inputs[].duration input duration in seconds
+     *  @param {number} inputs[].cpu-util percentage cpu usage
+     */
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier(): string;
+    /**
+     * Standardize the instance metrics for all the vendors
+     *
+     * Maps the instance metrics to a standard format (min, max, idle, 10%, 50%, 100%) for all the vendors
+     */
+    standardizeInstanceMetrics(): void;
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * Uses a spline method for AWS and linear interpolation for GCP and Azure
+     */
+    private calculateEnergy;
+    /**
+     * Calculates the embodied emissions for a given input
+     */
+    private embodiedEmissions;
+}

package/build/lib/teads-aws/index.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeadsAWS = void 0;
+const typescript_cubic_spline_1 = require("typescript-cubic-spline");
+const AWS_INSTANCES = require("./aws-instances.json");
+const AWS_EMBODIED = require("./aws-embodied.json");
+const config_1 = require("../../config");
+const common_1 = require("../../types/common");
+const { MODEL_IDS } = config_1.CONFIG;
+const { TEADS_AWS } = MODEL_IDS;
+class TeadsAWS {
+    constructor() {
+        // compute instances grouped by the vendor with usage data
+        this.computeInstances = {};
+        // list of all the by Architecture
+        this.instanceType = '';
+        this.expectedLifespan = 4 * 365 * 24 * 3600;
+        this.interpolation = common_1.Interpolation.LINEAR;
+        this.standardizeInstanceMetrics();
+    }
+    /**
+     * Defined for compatibility. Not used in TEADS.
+     */
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    /**
+     *  Configures the TEADS Plugin for IEF
+     *  @param {string} name name of the resource
+     *  @param {Object} staticParams static parameters for the resource
+     *  @param {string} staticParams.instance-type instance type from the list of supported instances
+     *  @param {number} staticParams.expected-lifespan expected lifespan of the instance in years
+     *  @param {Interpolation} staticParams.interpolation expected lifespan of the instance in years
+     */
+    async configure(name, staticParams = undefined) {
+        this.name = name;
+        if (staticParams === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        if ('instance-type' in staticParams) {
+            const instanceType = staticParams['instance-type'];
+            if (instanceType in this.computeInstances) {
+                this.instanceType = instanceType;
+            }
+            else {
+                throw new Error('Instance Type not supported');
+            }
+        }
+        else if (this.instanceType === '') {
+            throw new Error('Instance Type not provided');
+        }
+        if ('expected-lifespan' in staticParams) {
+            this.expectedLifespan = staticParams['expected-lifespan'];
+        }
+        if ('interpolation' in staticParams) {
+            this.interpolation = staticParams?.interpolation;
+        }
+        return this;
+    }
+    /**
+     * Calculate the total emissions for a list of inputs
+     *
+     * Each input require:
+     *  @param {Object[]} inputs  ISO 8601 timestamp string
+     *  @param {string} inputs[].timestamp ISO 8601 timestamp string
+     *  @param {number} inputs[].duration input duration in seconds
+     *  @param {number} inputs[].cpu-util percentage cpu usage
+     */
+    async execute(inputs) {
+        if (inputs === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        if (!Array.isArray(inputs)) {
+            throw new Error('inputs should be an array');
+        }
+        if (this.instanceType === '') {
+            throw new Error('Configuration is incomplete');
+        }
+        return inputs.map((input) => {
+            this.configure(this.name, input);
+            const e = this.calculateEnergy(input);
+            const m = this.embodiedEmissions(input);
+            input['energy'] = e;
+            input['embodied-carbon'] = m;
+            return input;
+        });
+    }
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier() {
+        return TEADS_AWS;
+    }
+    /**
+     * Standardize the instance metrics for all the vendors
+     *
+     * Maps the instance metrics to a standard format (min, max, idle, 10%, 50%, 100%) for all the vendors
+     */
+    standardizeInstanceMetrics() {
+        AWS_INSTANCES.forEach((instance) => {
+            const cpus = parseInt(instance['Instance vCPU'], 10);
+            this.computeInstances[instance['Instance type']] = {
+                consumption: {
+                    idle: parseFloat(instance['Instance @ Idle'].replace(',', '.')),
+                    tenPercent: parseFloat(instance['Instance @ 10%'].replace(',', '.')),
+                    fiftyPercent: parseFloat(instance['Instance @ 50%'].replace(',', '.')),
+                    hundredPercent: parseFloat(instance['Instance @ 100%'].replace(',', '.')),
+                },
+                vCPUs: cpus,
+                maxvCPUs: parseInt(instance['Platform Total Number of vCPU'], 10),
+                name: instance['Instance type'],
+            };
+        });
+        AWS_EMBODIED.forEach((instance) => {
+            this.computeInstances[instance['type']].embodiedEmission =
+                instance['total'];
+        });
+    }
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * Uses a spline method for AWS and linear interpolation for GCP and Azure
+     */
+    calculateEnergy(input) {
+        if (!('duration' in input) ||
+            !('cpu-util' in input) ||
+            !('timestamp' in input)) {
+            throw new Error('Required Parameters duration,cpu-util,timestamp not provided for input');
+        }
+        const duration = input['duration']; // Duration is in seconds.
+        const cpu = input['cpu-util']; // Convert cpu usage to percentage.
+        const x = [0, 10, 50, 100]; // Get the wattage for the instance type.
+        const y = [
+            this.computeInstances[this.instanceType].consumption.idle ?? 0,
+            this.computeInstances[this.instanceType].consumption.tenPercent ?? 0,
+            this.computeInstances[this.instanceType].consumption.fiftyPercent ?? 0,
+            this.computeInstances[this.instanceType].consumption.hundredPercent ?? 0,
+        ];
+        const spline = new typescript_cubic_spline_1.default(x, y);
+        let wattage = 0.0;
+        if (this.interpolation === common_1.Interpolation.SPLINE) {
+            wattage = spline.at(cpu);
+        }
+        else if (this.interpolation === common_1.Interpolation.LINEAR) {
+            // base rate is from which level of cpu linear interpolation is applied at
+            let base_rate = 0;
+            let base_cpu = 0;
+            let ratio = 0;
+            // find the base rate and ratio
+            for (let i = 0; i < x.length; i++) {
+                if (cpu === x[i]) {
+                    base_rate = y[i];
+                    base_cpu = x[i];
+                    break;
+                }
+                else if (cpu > x[i] && cpu < x[i + 1]) {
+                    base_rate = y[i];
+                    base_cpu = x[i];
+                    ratio = (y[i + 1] - y[i]) / (x[i + 1] - x[i]);
+                    break;
+                }
+            }
+            // sum of base_rate + (cpu - base_cpu) * ratio = total rate of cpu usage
+            wattage = base_rate + (cpu - base_cpu) * ratio;
+        }
+        //  duration is in seconds
+        //  wattage is in watts
+        //  eg: 30W x 300s = 9000 J
+        //  1 Wh = 3600 J
+        //  9000 J / 3600 = 2.5 Wh
+        //  J / 3600 = Wh
+        //  2.5 Wh / 1000 = 0.0025 kWh
+        //  Wh / 1000 = kWh
+        // (wattage * duration) / (seconds in an hour) / 1000 = kWh
+        return (wattage * duration) / 3600 / 1000;
+    }
+    /**
+     * Calculates the embodied emissions for a given input
+     */
+    embodiedEmissions(input) {
+        // duration
+        const durationInHours = input['duration'] / 3600;
+        // M = TE * (TR/EL) * (RR/TR)
+        // Where:
+        // TE = Total Embodied Emissions, the sum of Life Cycle Assessment(LCA) emissions for all hardware components
+        // TR = Time Reserved, the length of time the hardware is reserved for use by the software
+        // EL = Expected Lifespan, the anticipated time that the equipment will be installed
+        // RR = Resources Reserved, the number of resources reserved for use by the software.
+        // TR = Total Resources, the total number of resources available.
+        const totalEmissions = this.computeInstances[this.instanceType].embodiedEmission ?? 0;
+        const timeReserved = durationInHours;
+        const expectedLifespan = this.expectedLifespan / 3600;
+        const reservedResources = this.computeInstances[this.instanceType].vCPUs ?? 1.0;
+        const totalResources = this.computeInstances[this.instanceType].maxVCPUs ?? 1.0;
+        // Multiply totalEmissions by 1000 to convert from kgCO2e to gCO2e
+        return (totalEmissions *
+            1000 *
+            (timeReserved / expectedLifespan) *
+            (reservedResources / totalResources));
+    }
+}
+exports.TeadsAWS = TeadsAWS;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/teads-aws/index.ts"],"names":[],"mappings":"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","sourcesContent":["import Spline from 'typescript-cubic-spline';\n\nimport * as AWS_INSTANCES from './aws-instances.json';\nimport * as AWS_EMBODIED from './aws-embodied.json';\n\nimport {IOutputModelInterface} from '../interfaces';\n\nimport {CONFIG} from '../../config';\n\nimport {KeyValuePair, Interpolation} from '../../types/common';\n\nconst {MODEL_IDS} = CONFIG;\nconst {TEADS_AWS} = MODEL_IDS;\n\nexport class TeadsAWS implements IOutputModelInterface {\n  authParams: object | undefined; // Defined for compatibility. Not used in TEADS.\n  name: string | undefined; // name of the data source\n  // compute instances grouped by the vendor with usage data\n  private computeInstances: {\n    [key: string]: KeyValuePair;\n  } = {};\n\n  // list of all the by Architecture\n  private instanceType = '';\n  private expectedLifespan = 4 * 365 * 24 * 3600;\n  private interpolation = Interpolation.LINEAR;\n\n  constructor() {\n    this.standardizeInstanceMetrics();\n  }\n\n  /**\n   * Defined for compatibility. Not used in TEADS.\n   */\n  authenticate(authParams: object): void {\n    this.authParams = authParams;\n  }\n\n  /**\n   *  Configures the TEADS Plugin for IEF\n   *  @param {string} name name of the resource\n   *  @param {Object} staticParams static parameters for the resource\n   *  @param {string} staticParams.instance-type instance type from the list of supported instances\n   *  @param {number} staticParams.expected-lifespan expected lifespan of the instance in years\n   *  @param {Interpolation} staticParams.interpolation expected lifespan of the instance in years\n   */\n  async configure(\n    name: string,\n    staticParams: object | undefined = undefined\n  ): Promise<IOutputModelInterface> {\n    this.name = name;\n\n    if (staticParams === undefined) {\n      throw new Error('Required Parameters not provided');\n    }\n\n    if ('instance-type' in staticParams) {\n      const instanceType = staticParams['instance-type'] as string;\n      if (instanceType in this.computeInstances) {\n        this.instanceType = instanceType;\n      } else {\n        throw new Error('Instance Type not supported');\n      }\n    } else if (this.instanceType === '') {\n      throw new Error('Instance Type not provided');\n    }\n\n    if ('expected-lifespan' in staticParams) {\n      this.expectedLifespan = staticParams['expected-lifespan'] as number;\n    }\n\n    if ('interpolation' in staticParams) {\n      this.interpolation = staticParams?.interpolation as Interpolation;\n    }\n\n    return this;\n  }\n\n  /**\n   * Calculate the total emissions for a list of inputs\n   *\n   * Each input require:\n   *  @param {Object[]} inputs  ISO 8601 timestamp string\n   *  @param {string} inputs[].timestamp ISO 8601 timestamp string\n   *  @param {number} inputs[].duration input duration in seconds\n   *  @param {number} inputs[].cpu-util percentage cpu usage\n   */\n  async execute(inputs: object | object[] | undefined): Promise<any[]> {\n    if (inputs === undefined) {\n      throw new Error('Required Parameters not provided');\n    }\n    if (!Array.isArray(inputs)) {\n      throw new Error('inputs should be an array');\n    }\n\n    if (this.instanceType === '') {\n      throw new Error('Configuration is incomplete');\n    }\n\n    return inputs.map((input: KeyValuePair) => {\n      this.configure(this.name!, input);\n      const e = this.calculateEnergy(input);\n      const m = this.embodiedEmissions(input);\n      input['energy'] = e;\n      input['embodied-carbon'] = m;\n      return input;\n    });\n  }\n\n  /**\n   * Returns model identifier\n   */\n  modelIdentifier(): string {\n    return TEADS_AWS;\n  }\n\n  /**\n   * Standardize the instance metrics for all the vendors\n   *\n   * Maps the instance metrics to a standard format (min, max, idle, 10%, 50%, 100%) for all the vendors\n   */\n  standardizeInstanceMetrics() {\n    AWS_INSTANCES.forEach((instance: KeyValuePair) => {\n      const cpus = parseInt(instance['Instance vCPU'], 10);\n      this.computeInstances[instance['Instance type']] = {\n        consumption: {\n          idle: parseFloat(instance['Instance @ Idle'].replace(',', '.')),\n          tenPercent: parseFloat(instance['Instance @ 10%'].replace(',', '.')),\n          fiftyPercent: parseFloat(\n            instance['Instance @ 50%'].replace(',', '.')\n          ),\n          hundredPercent: parseFloat(\n            instance['Instance @ 100%'].replace(',', '.')\n          ),\n        },\n        vCPUs: cpus,\n        maxvCPUs: parseInt(instance['Platform Total Number of vCPU'], 10),\n        name: instance['Instance type'],\n      } as KeyValuePair;\n    });\n    AWS_EMBODIED.forEach((instance: KeyValuePair) => {\n      this.computeInstances[instance['type']].embodiedEmission =\n        instance['total'];\n    });\n  }\n\n  /**\n   * Calculates the energy consumption for a single input\n   * requires\n   *\n   * duration: duration of the input in seconds\n   * cpu-util: cpu usage in percentage\n   * timestamp: RFC3339 timestamp string\n   *\n   * Uses a spline method for AWS and linear interpolation for GCP and Azure\n   */\n  private calculateEnergy(input: KeyValuePair) {\n    if (\n      !('duration' in input) ||\n      !('cpu-util' in input) ||\n      !('timestamp' in input)\n    ) {\n      throw new Error(\n        'Required Parameters duration,cpu-util,timestamp not provided for input'\n      );\n    }\n\n    const duration = input['duration']; // Duration is in seconds.\n    const cpu = input['cpu-util']; // Convert cpu usage to percentage.\n\n    const x = [0, 10, 50, 100]; // Get the wattage for the instance type.\n    const y: number[] = [\n      this.computeInstances[this.instanceType].consumption.idle ?? 0,\n      this.computeInstances[this.instanceType].consumption.tenPercent ?? 0,\n      this.computeInstances[this.instanceType].consumption.fiftyPercent ?? 0,\n      this.computeInstances[this.instanceType].consumption.hundredPercent ?? 0,\n    ];\n\n    const spline = new Spline(x, y);\n\n    let wattage = 0.0;\n    if (this.interpolation === Interpolation.SPLINE) {\n      wattage = spline.at(cpu);\n    } else if (this.interpolation === Interpolation.LINEAR) {\n      // base rate is from which level of cpu linear interpolation is applied at\n      let base_rate = 0;\n      let base_cpu = 0;\n      let ratio = 0;\n      // find the base rate and ratio\n      for (let i = 0; i < x.length; i++) {\n        if (cpu === x[i]) {\n          base_rate = y[i];\n          base_cpu = x[i];\n          break;\n        } else if (cpu > x[i] && cpu < x[i + 1]) {\n          base_rate = y[i];\n          base_cpu = x[i];\n          ratio = (y[i + 1] - y[i]) / (x[i + 1] - x[i]);\n          break;\n        }\n      }\n      // sum of base_rate + (cpu - base_cpu) * ratio = total rate of cpu usage\n      wattage = base_rate + (cpu - base_cpu) * ratio;\n    }\n    //  duration is in seconds\n    //  wattage is in watts\n    //  eg: 30W x 300s = 9000 J\n    //  1 Wh = 3600 J\n    //  9000 J / 3600 = 2.5 Wh\n    //  J / 3600 = Wh\n    //  2.5 Wh / 1000 = 0.0025 kWh\n    //  Wh / 1000 = kWh\n    // (wattage * duration) / (seconds in an hour) / 1000 = kWh\n    return (wattage * duration) / 3600 / 1000;\n  }\n\n  /**\n   * Calculates the embodied emissions for a given input\n   */\n  private embodiedEmissions(input: KeyValuePair): number {\n    // duration\n    const durationInHours = input['duration'] / 3600;\n    // M = TE * (TR/EL) * (RR/TR)\n    // Where:\n    // TE = Total Embodied Emissions, the sum of Life Cycle Assessment(LCA) emissions for all hardware components\n    // TR = Time Reserved, the length of time the hardware is reserved for use by the software\n    // EL = Expected Lifespan, the anticipated time that the equipment will be installed\n    // RR = Resources Reserved, the number of resources reserved for use by the software.\n    // TR = Total Resources, the total number of resources available.\n    const totalEmissions =\n      this.computeInstances[this.instanceType].embodiedEmission ?? 0;\n    const timeReserved = durationInHours;\n    const expectedLifespan = this.expectedLifespan / 3600;\n    const reservedResources =\n      this.computeInstances[this.instanceType].vCPUs ?? 1.0;\n    const totalResources =\n      this.computeInstances[this.instanceType].maxVCPUs ?? 1.0;\n    // Multiply totalEmissions by 1000 to convert from kgCO2e to gCO2e\n    return (\n      totalEmissions *\n      1000 *\n      (timeReserved / expectedLifespan) *\n      (reservedResources / totalResources)\n    );\n  }\n}\n"]}

package/build/lib/teads-curve/index.d.ts

@@ -0,0 +1,52 @@
+import { IOutputModelInterface } from '../interfaces';
+import { Interpolation } from '../../types/common';
+export declare class TeadsCurveModel implements IOutputModelInterface {
+    authParams: object | undefined;
+    name: string | undefined;
+    tdp: number;
+    curve: number[];
+    points: number[];
+    spline: any;
+    interpolation: Interpolation;
+    /**
+     * Defined for compatibility. Not used in TEADS.
+     */
+    authenticate(authParams: object): void;
+    /**
+     * Configures the TEADS Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     * @param {number} staticParams.tdp 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[].duration input duration in seconds
+     * @param {number} inputs[].cpu-util percentage cpu usage
+     */
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier(): string;
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * Uses a spline method on the teads cpu wattage data
+     */
+    private calculateEnergy;
+}
+/**
+ * For JSII.
+ */
+export { KeyValuePair, Interpolation } from '../../types/common';

package/build/lib/teads-curve/index.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interpolation = exports.TeadsCurveModel = void 0;
+const typescript_cubic_spline_1 = require("typescript-cubic-spline");
+const config_1 = require("../../config");
+const common_1 = require("../../types/common");
+const { MODEL_IDS } = config_1.CONFIG;
+const { TEADS_CURVE } = MODEL_IDS;
+class TeadsCurveModel {
+    constructor() {
+        this.tdp = 0; // `tdp` of the chip being measured.
+        this.curve = [0.12, 0.32, 0.75, 1.02]; // Default power curve provided by the Teads Team.
+        this.points = [0, 10, 50, 100]; // Default percentage points.
+        this.spline = new typescript_cubic_spline_1.default(this.points, this.curve); // Spline interpolation of the power curve.
+        this.interpolation = common_1.Interpolation.SPLINE; // Interpolation method.
+    }
+    /**
+     * Defined for compatibility. Not used in TEADS.
+     */
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    /**
+     * Configures the TEADS Plugin for IEF
+     * @param {string} name name of the resource
+     * @param {Object} staticParams static parameters for the resource
+     * @param {number} staticParams.tdp 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 ('thermal-design-power' in staticParams) {
+            this.tdp = staticParams['thermal-design-power'];
+        }
+        // if ('curve' in staticParams && 'points' in staticParams) {
+        //   this.curve = staticParams?.curve as number[];
+        //   this.points = staticParams?.points as number[];
+        //   if (this.curve.length !== this.points.length) {
+        //     throw new Error(
+        //       'Number of points and curve values must be the same length'
+        //     );
+        //   }
+        //   this.spline = new Spline(this.points, this.curve);
+        // }
+        if ('interpolation' in staticParams) {
+            this.interpolation = staticParams?.interpolation;
+        }
+        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[].duration input duration in seconds
+     * @param {number} inputs[].cpu-util percentage cpu 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-cpu'] = this.calculateEnergy(input);
+            return input;
+        });
+    }
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier() {
+        return TEADS_CURVE;
+    }
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: RFC3339 timestamp string
+     *
+     * Uses a spline method on the teads cpu wattage data
+     */
+    calculateEnergy(input) {
+        if (!('duration' in input) ||
+            !('cpu-util' in input) ||
+            !('timestamp' in input)) {
+            throw new Error('Required Parameters duration,cpu-util,timestamp not provided for input');
+        }
+        //    duration is in seconds
+        const duration = input['duration'];
+        //    convert cpu usage to percentage
+        const cpu = input['cpu-util'];
+        if (cpu < 0 || cpu > 100) {
+            throw new Error('cpu usage must be between 0 and 100');
+        }
+        let tdp = this.tdp;
+        if ('thermal-design-power' in input) {
+            tdp = input['thermal-design-power'];
+        }
+        if (tdp === 0) {
+            throw new Error('`thermal-design-power` not provided. Can not compute energy.');
+        }
+        let wattage = 0.0;
+        if (this.interpolation === common_1.Interpolation.SPLINE) {
+            wattage = this.spline.at(cpu) * tdp;
+        }
+        else if (this.interpolation === common_1.Interpolation.LINEAR) {
+            const x = this.points;
+            const y = this.curve;
+            // base rate is from which level of cpu linear interpolation is applied at
+            let base_rate = 0;
+            let base_cpu = 0;
+            let ratio = 0;
+            // find the base rate and ratio
+            for (let i = 0; i < x.length; i++) {
+                if (cpu === x[i]) {
+                    base_rate = y[i];
+                    base_cpu = x[i];
+                    break;
+                }
+                else if (cpu > x[i] && cpu < x[i + 1]) {
+                    base_rate = y[i];
+                    base_cpu = x[i];
+                    ratio = (y[i + 1] - y[i]) / (x[i + 1] - x[i]);
+                    break;
+                }
+            }
+            // sum of base_rate + (cpu - base_cpu) * ratio = total rate of cpu usage
+            // total rate * tdp = wattage
+            wattage = (base_rate + (cpu - base_cpu) * ratio) * tdp;
+        }
+        //  duration is in seconds
+        //  wattage is in watts
+        //  eg: 30W x 300s = 9000 J
+        //  1 Wh = 3600 J
+        //  9000 J / 3600 = 2.5 Wh
+        //  J / 3600 = Wh
+        //  2.5 Wh / 1000 = 0.0025 kWh
+        //  Wh / 1000 = kWh
+        // (wattage * duration) / (seconds in an hour) / 1000 = kWh
+        return (wattage * duration) / 3600 / 1000;
+    }
+}
+exports.TeadsCurveModel = TeadsCurveModel;
+/**
+ * For JSII.
+ */
+var common_2 = require("../../types/common");
+Object.defineProperty(exports, "Interpolation", { enumerable: true, get: function () { return common_2.Interpolation; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/teads-curve/index.ts"],"names":[],"mappings":"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","sourcesContent":["import Spline from 'typescript-cubic-spline';\n\nimport {IOutputModelInterface} from '../interfaces';\n\nimport {CONFIG} from '../../config';\n\nimport {KeyValuePair, Interpolation} from '../../types/common';\n\nconst {MODEL_IDS} = CONFIG;\nconst {TEADS_CURVE} = MODEL_IDS;\n\nexport class TeadsCurveModel implements IOutputModelInterface {\n  authParams: object | undefined; // Defined for compatibility. Not used in TEADS.\n  name: string | undefined; // Name of the data source.\n  tdp = 0; // `tdp` of the chip being measured.\n  curve: number[] = [0.12, 0.32, 0.75, 1.02]; // Default power curve provided by the Teads Team.\n  points: number[] = [0, 10, 50, 100]; // Default percentage points.\n  spline: any = new Spline(this.points, this.curve); // Spline interpolation of the power curve.\n  interpolation: Interpolation = Interpolation.SPLINE; // Interpolation method.\n\n  /**\n   * Defined for compatibility. Not used in TEADS.\n   */\n  authenticate(authParams: object): void {\n    this.authParams = authParams;\n  }\n\n  /**\n   * Configures the TEADS Plugin for IEF\n   * @param {string} name name of the resource\n   * @param {Object} staticParams static parameters for the resource\n   * @param {number} staticParams.tdp Thermal Design Power in Watts\n   * @param {Interpolation} staticParams.interpolation Interpolation method\n   */\n  async configure(\n    name: string,\n    staticParams: object | undefined = undefined\n  ): Promise<IOutputModelInterface> {\n    this.name = name;\n\n    if (staticParams === undefined) {\n      throw new Error('Required Parameters not provided');\n    }\n\n    if ('thermal-design-power' in staticParams) {\n      this.tdp = staticParams['thermal-design-power'] as number;\n    }\n\n    // if ('curve' in staticParams && 'points' in staticParams) {\n    //   this.curve = staticParams?.curve as number[];\n    //   this.points = staticParams?.points as number[];\n    //   if (this.curve.length !== this.points.length) {\n    //     throw new Error(\n    //       'Number of points and curve values must be the same length'\n    //     );\n    //   }\n    //   this.spline = new Spline(this.points, this.curve);\n    // }\n\n    if ('interpolation' in staticParams) {\n      this.interpolation = staticParams?.interpolation as Interpolation;\n    }\n\n    return this;\n  }\n\n  /**\n   * Calculate the total emissions for a list of inputs\n   *\n   * Each input require:\n   * @param {Object[]} inputs\n   * @param {string} inputs[].timestamp RFC3339 timestamp string\n   * @param {number} inputs[].duration input duration in seconds\n   * @param {number} inputs[].cpu-util percentage cpu usage\n   */\n  async execute(inputs: object | object[] | undefined): Promise<any[]> {\n    if (inputs === undefined) {\n      throw new Error('Required Parameters not provided');\n    } else if (!Array.isArray(inputs)) {\n      throw new Error('inputs must be an array');\n    }\n    return inputs.map((input: KeyValuePair) => {\n      this.configure(this.name!, input);\n      input['energy-cpu'] = this.calculateEnergy(input);\n      return input;\n    });\n  }\n\n  /**\n   * Returns model identifier\n   */\n  modelIdentifier(): string {\n    return TEADS_CURVE;\n  }\n\n  /**\n   * Calculates the energy consumption for a single input\n   * requires\n   *\n   * duration: duration of the input in seconds\n   * cpu-util: cpu usage in percentage\n   * timestamp: RFC3339 timestamp string\n   *\n   * Uses a spline method on the teads cpu wattage data\n   */\n  private calculateEnergy(input: KeyValuePair) {\n    if (\n      !('duration' in input) ||\n      !('cpu-util' in input) ||\n      !('timestamp' in input)\n    ) {\n      throw new Error(\n        'Required Parameters duration,cpu-util,timestamp not provided for input'\n      );\n    }\n\n    //    duration is in seconds\n    const duration = input['duration'];\n\n    //    convert cpu usage to percentage\n    const cpu = input['cpu-util'];\n    if (cpu < 0 || cpu > 100) {\n      throw new Error('cpu usage must be between 0 and 100');\n    }\n\n    let tdp = this.tdp;\n\n    if ('thermal-design-power' in input) {\n      tdp = input['thermal-design-power'] as number;\n    }\n    if (tdp === 0) {\n      throw new Error(\n        '`thermal-design-power` not provided. Can not compute energy.'\n      );\n    }\n\n    let wattage = 0.0;\n    if (this.interpolation === Interpolation.SPLINE) {\n      wattage = this.spline.at(cpu) * tdp;\n    } else if (this.interpolation === Interpolation.LINEAR) {\n      const x = this.points;\n      const y = this.curve;\n      // base rate is from which level of cpu linear interpolation is applied at\n      let base_rate = 0;\n      let base_cpu = 0;\n      let ratio = 0;\n      // find the base rate and ratio\n      for (let i = 0; i < x.length; i++) {\n        if (cpu === x[i]) {\n          base_rate = y[i];\n          base_cpu = x[i];\n          break;\n        } else if (cpu > x[i] && cpu < x[i + 1]) {\n          base_rate = y[i];\n          base_cpu = x[i];\n          ratio = (y[i + 1] - y[i]) / (x[i + 1] - x[i]);\n          break;\n        }\n      }\n      // sum of base_rate + (cpu - base_cpu) * ratio = total rate of cpu usage\n      // total rate * tdp = wattage\n      wattage = (base_rate + (cpu - base_cpu) * ratio) * tdp;\n    }\n    //  duration is in seconds\n    //  wattage is in watts\n    //  eg: 30W x 300s = 9000 J\n    //  1 Wh = 3600 J\n    //  9000 J / 3600 = 2.5 Wh\n    //  J / 3600 = Wh\n    //  2.5 Wh / 1000 = 0.0025 kWh\n    //  Wh / 1000 = kWh\n    // (wattage * duration) / (seconds in an hour) / 1000 = kWh\n    return (wattage * duration) / 3600 / 1000;\n  }\n}\n\n/**\n * For JSII.\n */\nexport {KeyValuePair, Interpolation} from '../../types/common';\n"]}

package/build/lib/watt-time/index.d.ts

@@ -0,0 +1,18 @@
+import { IOutputModelInterface } from '../interfaces';
+import { KeyValuePair } from '../../types/common';
+export declare class WattTimeGridEmissions implements IOutputModelInterface {
+    authParams: object | undefined;
+    token: string;
+    staticParams: object | undefined;
+    name: string | undefined;
+    baseUrl: string;
+    authenticate(authParams: object): Promise<void>;
+    execute(inputs: object | object[] | undefined): Promise<any[]>;
+    private getWattTimeDataForDuration;
+    private validateinputs;
+    private getLatitudeLongitudeFrominput;
+    private determineinputStartEnd;
+    fetchData(input: KeyValuePair): Promise<KeyValuePair[]>;
+    configure(name: string, staticParams: object | undefined): Promise<IOutputModelInterface>;
+    modelIdentifier(): string;
+}