@grnsft/if 0.0.2

package/build/lib/ccf/gcp-use.json

@@ -0,0 +1,58 @@
+[
+    {
+        "": "0",
+        "Architecture": "Skylake",
+        "Min Watts": "0.6446044454253452",
+        "Max Watts": "3.8984738056304855",
+        "GB/Chip": "80.43037974683544"
+    },
+    {
+        "": "1",
+        "Architecture": "Broadwell",
+        "Min Watts": "0.7128342245989304",
+        "Max Watts": "3.3857473048128344",
+        "GB/Chip": "69.6470588235294"
+    },
+    {
+        "": "2",
+        "Architecture": "Haswell",
+        "Min Watts": "1.9005681818181814",
+        "Max Watts": "5.9688982156043195",
+        "GB/Chip": "27.310344827586206"
+    },
+    {
+        "": "3",
+        "Architecture": "EPYC 2nd Gen",
+        "Min Watts": "0.4742621527777778",
+        "Max Watts": "1.5751872939814815",
+        "GB/Chip": "129.77777777777777"
+    },
+    {
+        "": "4",
+        "Architecture": "Cascade Lake",
+        "Min Watts": "0.6389493581523519",
+        "Max Watts": "3.6424520285114035",
+        "GB/Chip": "98.11764705882354"
+    },
+    {
+        "": "5",
+        "Architecture": "EPYC 3rd Gen",
+        "Min Watts": "0.44538981119791665",
+        "Max Watts": "1.8719357994791666",
+        "GB/Chip": "128.0"
+    },
+    {
+        "": "6",
+        "Architecture": "Ivy Bridge",
+        "Min Watts": "3.0369270833333335",
+        "Max Watts": "8.199689511111112",
+        "GB/Chip": "14.933333333333334"
+    },
+    {
+        "": "7",
+        "Architecture": "Sandy Bridge",
+        "Min Watts": "2.1694411458333334",
+        "Max Watts": "8.550185877430936",
+        "GB/Chip": "16.480916030534353"
+    }
+]

package/build/lib/ccf/index.d.ts

@@ -0,0 +1,63 @@
+import { IOutputModelInterface } from '../interfaces';
+export declare class CloudCarbonFootprint implements IOutputModelInterface {
+    authParams: object | undefined;
+    name: string | undefined;
+    private computeInstances;
+    private computeInstanceUsageByArchitecture;
+    private vendor;
+    private instanceType;
+    private expectedLifespan;
+    private interpolation;
+    constructor();
+    /**
+     * Defined for compatibility. Not used in CCF.
+     */
+    authenticate(authParams: object): void;
+    /**
+     *  Configures the CCF Plugin for IEF
+     *  @param {string} name name of the resource
+     *  @param {Object} staticParams static parameters for the resource
+     *  @param {("aws"|"gcp"|"azure")} staticParams.vendor aws, gcp, azure
+     *  @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 linear(All Clouds), spline (only for AWS)
+     */
+    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[]>;
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: ISO 8601 timestamp string
+     *
+     * Uses a spline method for AWS and linear interpolation for GCP and Azure
+     */
+    private calculateEnergy;
+    /**
+     * 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;
+    private calculateAverage;
+    resolveAwsArchitecture(architecture: string): string;
+    /**
+     * Calculates the embodied emissions for a given input
+     */
+    private embodiedEmissions;
+}

package/build/lib/ccf/index.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudCarbonFootprint = void 0;
+const typescript_cubic_spline_1 = require("typescript-cubic-spline");
+const AWSInstanceTypes_1 = require("@cloud-carbon-footprint/aws/dist/lib/AWSInstanceTypes");
+const config_1 = require("../../config");
+const AWS_INSTANCES = require("./aws-instances.json");
+const GCP_INSTANCES = require("./gcp-instances.json");
+const AZURE_INSTANCES = require("./azure-instances.json");
+const GCP_USE = require("./gcp-use.json");
+const AWS_USE = require("./aws-use.json");
+const AZURE_USE = require("./azure-use.json");
+const GCP_EMBODIED = require("./gcp-embodied.json");
+const AWS_EMBODIED = require("./aws-embodied.json");
+const AZURE_EMBODIED = require("./azure-embodied.json");
+const common_1 = require("../../types/common");
+const { MODEL_IDS } = config_1.CONFIG;
+const { CCF } = MODEL_IDS;
+class CloudCarbonFootprint {
+    constructor() {
+        // compute instances grouped by the vendor with usage data
+        this.computeInstances = {};
+        // list of all the by Architecture
+        this.computeInstanceUsageByArchitecture = {
+            gcp: {},
+            aws: {},
+            azure: {},
+        };
+        this.vendor = '';
+        this.instanceType = '';
+        this.expectedLifespan = 4;
+        this.interpolation = common_1.Interpolation.LINEAR;
+        this.standardizeInstanceMetrics();
+    }
+    /**
+     * Defined for compatibility. Not used in CCF.
+     */
+    authenticate(authParams) {
+        this.authParams = authParams;
+    }
+    /**
+     *  Configures the CCF Plugin for IEF
+     *  @param {string} name name of the resource
+     *  @param {Object} staticParams static parameters for the resource
+     *  @param {("aws"|"gcp"|"azure")} staticParams.vendor aws, gcp, azure
+     *  @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 linear(All Clouds), spline (only for AWS)
+     */
+    async configure(name, staticParams = undefined) {
+        this.name = name;
+        if (staticParams === undefined) {
+            throw new Error('Required Parameters not provided');
+        }
+        if ('vendor' in staticParams) {
+            const vendor = staticParams?.vendor;
+            if (['aws', 'gcp', 'azure'].includes(vendor)) {
+                this.vendor = vendor;
+            }
+            else {
+                throw new Error('vendor not supported');
+            }
+        }
+        else {
+            throw new Error('vendor not provided');
+        }
+        if ('instance-type' in staticParams) {
+            const instanceType = staticParams['instance-type'];
+            if (instanceType in this.computeInstances[this.vendor]) {
+                this.instanceType = instanceType;
+            }
+            else {
+                throw new Error('Instance Type not supported');
+            }
+        }
+        else {
+            throw new Error('Instance Type not provided');
+        }
+        if ('expected-lifespan' in staticParams) {
+            this.expectedLifespan = staticParams['expected-lifespan'];
+        }
+        if ('interpolation' in staticParams) {
+            if (this.vendor !== 'aws') {
+                throw new Error('Interpolation method not supported');
+            }
+            const interpolation = staticParams?.interpolation;
+            if (Object.values(common_1.Interpolation).includes(interpolation)) {
+                this.interpolation = interpolation;
+            }
+            else {
+                throw new Error('Interpolation method not supported');
+            }
+        }
+        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 === '' || this.vendor === '') {
+            throw new Error('Configuration is incomplete');
+        }
+        inputs.map((input) => {
+            input['energy'] = this.calculateEnergy(input);
+            input['embodied-carbon'] = this.embodiedEmissions(input);
+            return input;
+        });
+        return inputs;
+    }
+    /**
+     * Calculates the energy consumption for a single input
+     * requires
+     *
+     * duration: duration of the input in seconds
+     * cpu-util: cpu usage in percentage
+     * timestamp: ISO 8601 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,timestamp not provided for input');
+        }
+        const duration = input['duration'];
+        const cpu = input['cpu-util'];
+        //  get the wattage for the instance type
+        let wattage;
+        if (this.vendor === 'aws' && this.interpolation === 'spline') {
+            const x = [0, 10, 50, 100];
+            const y = [
+                this.computeInstances['aws'][this.instanceType].consumption.idle ?? 0,
+                this.computeInstances['aws'][this.instanceType].consumption
+                    .tenPercent ?? 0,
+                this.computeInstances['aws'][this.instanceType].consumption
+                    .fiftyPercent ?? 0,
+                this.computeInstances['aws'][this.instanceType].consumption
+                    .hundredPercent ?? 0,
+            ];
+            const spline = new typescript_cubic_spline_1.default(x, y);
+            wattage = spline.at(cpu);
+        }
+        else {
+            const idle = this.computeInstances[this.vendor][this.instanceType].consumption
+                .minWatts ?? 0;
+            const max = this.computeInstances[this.vendor][this.instanceType].consumption
+                .maxWatts ?? 0;
+            // linear interpolation
+            wattage = idle + (max - idle) * (cpu / 100);
+        }
+        //  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;
+    }
+    /**
+     * Returns model identifier
+     */
+    modelIdentifier() {
+        return CCF;
+    }
+    /**
+     * 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() {
+        this.computeInstances['aws'] = {};
+        this.computeInstances['gcp'] = {};
+        this.computeInstances['azure'] = {};
+        this.calculateAverage('gcp', GCP_USE);
+        this.calculateAverage('azure', AZURE_USE);
+        this.calculateAverage('aws', AWS_USE);
+        AWS_INSTANCES.forEach((instance) => {
+            const cpus = parseInt(instance['Instance vCPU'], 10);
+            const architectures = AWSInstanceTypes_1.INSTANCE_TYPE_COMPUTE_PROCESSOR_MAPPING[instance['Instance type']] ?? ['Average'];
+            let minWatts = 0.0;
+            let maxWatts = 0.0;
+            let count = 0;
+            architectures.forEach((architecture) => {
+                architecture = this.resolveAwsArchitecture(architecture);
+                minWatts +=
+                    this.computeInstanceUsageByArchitecture['aws'][architecture]['Min Watts'] ?? 0;
+                maxWatts +=
+                    this.computeInstanceUsageByArchitecture['aws'][architecture]['Max Watts'] ?? 0;
+                count += 1;
+            });
+            minWatts = minWatts / count;
+            maxWatts = maxWatts / count;
+            this.computeInstances['aws'][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(',', '.')),
+                    minWatts: minWatts * cpus,
+                    maxWatts: maxWatts * cpus,
+                },
+                vCPUs: cpus,
+                maxvCPUs: parseInt(instance['Platform Total Number of vCPU'], 10),
+                name: instance['Instance type'],
+            };
+        });
+        GCP_INSTANCES.forEach((instance) => {
+            const cpus = parseInt(instance['Instance vCPUs'], 10);
+            let architecture = instance['Microarchitecture'];
+            if (!(architecture in this.computeInstanceUsageByArchitecture['gcp'])) {
+                architecture = 'Average';
+            }
+            this.computeInstances['gcp'][instance['Machine type']] = {
+                name: instance['Machine type'],
+                vCPUs: cpus,
+                consumption: {
+                    minWatts: this.computeInstanceUsageByArchitecture['gcp'][architecture]['Min Watts'] * cpus,
+                    maxWatts: this.computeInstanceUsageByArchitecture['gcp'][architecture]['Max Watts'] * cpus,
+                },
+                maxvCPUs: parseInt(instance['Platform vCPUs (highest vCPU possible)'], 10),
+            };
+        });
+        AZURE_INSTANCES.forEach((instance) => {
+            const cpus = parseInt(instance['Instance vCPUs'], 10);
+            let architecture = instance['Microarchitecture'];
+            if (!(architecture in this.computeInstanceUsageByArchitecture['azure'])) {
+                architecture = 'Average';
+            }
+            this.computeInstances['azure'][instance['Virtual Machine']] = {
+                consumption: {
+                    minWatts: this.computeInstanceUsageByArchitecture['azure'][architecture]['Min Watts'] * cpus,
+                    maxWatts: this.computeInstanceUsageByArchitecture['azure'][architecture]['Max Watts'] * cpus,
+                },
+                name: instance['Virtual Machine'],
+                vCPUs: instance['Instance vCPUs'],
+                maxvCPUs: parseInt(instance['Platform vCPUs (highest vCPU possible)'], 10),
+            };
+        });
+        AWS_EMBODIED.forEach((instance) => {
+            this.computeInstances['aws'][instance['type']].embodiedEmission =
+                instance['total'];
+        });
+        GCP_EMBODIED.forEach((instance) => {
+            this.computeInstances['gcp'][instance['type']].embodiedEmission =
+                instance['total'];
+        });
+        AZURE_EMBODIED.forEach((instance) => {
+            this.computeInstances['azure'][instance['type']].embodiedEmission =
+                instance['total'];
+        });
+    }
+    calculateAverage(vendor, instanceList) {
+        let min = 0.0;
+        let max = 0.0;
+        let count = 0.0;
+        instanceList.forEach((instance) => {
+            this.computeInstanceUsageByArchitecture[vendor][instance['Architecture']] = instance;
+            min += parseFloat(instance['Min Watts']);
+            max += parseFloat(instance['Max Watts']);
+            count += 1.0;
+        });
+        const avgMin = min / count;
+        const avgMax = max / count;
+        this.computeInstanceUsageByArchitecture[vendor]['Average'] = {
+            'Min Watts': avgMin,
+            'Max Watts': avgMax,
+            Architecture: 'Average',
+        };
+    }
+    // Architecture strings are different between Instances-Use.JSON and the bundled Typescript from CCF.
+    // This function resolves the differences.
+    resolveAwsArchitecture(architecture) {
+        if (architecture.includes('AMD ')) {
+            architecture = architecture.substring(4);
+        }
+        if (architecture.includes('Skylake')) {
+            architecture = 'Sky Lake';
+        }
+        if (architecture.includes('Graviton')) {
+            if (architecture.includes('2')) {
+                architecture = 'Graviton2';
+            }
+            else {
+                architecture = 'Graviton';
+            }
+        }
+        if (architecture.includes('Unknown')) {
+            architecture = 'Average';
+        }
+        if (!(architecture in this.computeInstanceUsageByArchitecture['aws'])) {
+            throw new Error(`${architecture} not supported`);
+        }
+        return architecture;
+    }
+    /**
+     * 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.vendor][this.instanceType].embodiedEmission ??
+            0;
+        const timeReserved = durationInHours;
+        const expectedLifespan = 8760 * this.expectedLifespan;
+        const reservedResources = this.computeInstances[this.vendor][this.instanceType].vCPUs ?? 1.0;
+        const totalResources = this.computeInstances[this.vendor][this.instanceType].maxVCPUs ?? 1.0;
+        // Multiply totalEmissions by 1000 to convert from kgCO2e to gCO2e
+        return (totalEmissions *
+            1000 *
+            (timeReserved / expectedLifespan) *
+            (reservedResources / totalResources));
+    }
+}
+exports.CloudCarbonFootprint = CloudCarbonFootprint;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/lib/ccf/index.ts"],"names":[],"mappings":"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","sourcesContent":["import Spline from 'typescript-cubic-spline';\n\nimport {IComputeInstance, IOutputModelInterface} from '../interfaces';\nimport {INSTANCE_TYPE_COMPUTE_PROCESSOR_MAPPING} from '@cloud-carbon-footprint/aws/dist/lib/AWSInstanceTypes';\n\nimport {CONFIG} from '../../config';\n\nimport * as AWS_INSTANCES from './aws-instances.json';\nimport * as GCP_INSTANCES from './gcp-instances.json';\nimport * as AZURE_INSTANCES from './azure-instances.json';\nimport * as GCP_USE from './gcp-use.json';\nimport * as AWS_USE from './aws-use.json';\nimport * as AZURE_USE from './azure-use.json';\nimport * as GCP_EMBODIED from './gcp-embodied.json';\nimport * as AWS_EMBODIED from './aws-embodied.json';\nimport * as AZURE_EMBODIED from './azure-embodied.json';\n\nimport {KeyValuePair, Interpolation} from '../../types/common';\n\nconst {MODEL_IDS} = CONFIG;\nconst {CCF} = MODEL_IDS;\n\nexport class CloudCarbonFootprint implements IOutputModelInterface {\n  // Defined for compatibility. Not used in CCF.\n  authParams: object | undefined;\n  // name of the data source\n  name: string | undefined;\n  // compute instances grouped by the vendor with usage data\n  private computeInstances: {\n    [key: string]: {\n      [key: string]: IComputeInstance;\n    };\n  } = {};\n\n  // list of all the by Architecture\n  private computeInstanceUsageByArchitecture: KeyValuePair = {\n    gcp: {},\n    aws: {},\n    azure: {},\n  };\n  private vendor = '';\n  private instanceType = '';\n  private expectedLifespan = 4;\n\n  private interpolation = Interpolation.LINEAR;\n\n  constructor() {\n    this.standardizeInstanceMetrics();\n  }\n\n  /**\n   * Defined for compatibility. Not used in CCF.\n   */\n  authenticate(authParams: object): void {\n    this.authParams = authParams;\n  }\n\n  /**\n   *  Configures the CCF Plugin for IEF\n   *  @param {string} name name of the resource\n   *  @param {Object} staticParams static parameters for the resource\n   *  @param {(\"aws\"|\"gcp\"|\"azure\")} staticParams.vendor aws, gcp, azure\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 linear(All Clouds), spline (only for AWS)\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 ('vendor' in staticParams) {\n      const vendor = staticParams?.vendor as string;\n      if (['aws', 'gcp', 'azure'].includes(vendor)) {\n        this.vendor = vendor;\n      } else {\n        throw new Error('vendor not supported');\n      }\n    } else {\n      throw new Error('vendor not provided');\n    }\n\n    if ('instance-type' in staticParams) {\n      const instanceType = staticParams['instance-type'] as string;\n      if (instanceType in this.computeInstances[this.vendor]) {\n        this.instanceType = instanceType;\n      } else {\n        throw new Error('Instance Type not supported');\n      }\n    } else {\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      if (this.vendor !== 'aws') {\n        throw new Error('Interpolation method not supported');\n      }\n      const interpolation = staticParams?.interpolation as Interpolation;\n      if (Object.values(Interpolation).includes(interpolation)) {\n        this.interpolation = interpolation;\n      } else {\n        throw new Error('Interpolation method not supported');\n      }\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 === '' || this.vendor === '') {\n      throw new Error('Configuration is incomplete');\n    }\n    inputs.map((input: KeyValuePair) => {\n      input['energy'] = this.calculateEnergy(input);\n      input['embodied-carbon'] = this.embodiedEmissions(input);\n      return input;\n    });\n\n    return inputs;\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: ISO 8601 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,timestamp not provided for input'\n      );\n    }\n\n    const duration = input['duration'];\n    const cpu = input['cpu-util'];\n\n    //  get the wattage for the instance type\n    let wattage;\n\n    if (this.vendor === 'aws' && this.interpolation === 'spline') {\n      const x = [0, 10, 50, 100];\n\n      const y: number[] = [\n        this.computeInstances['aws'][this.instanceType].consumption.idle ?? 0,\n        this.computeInstances['aws'][this.instanceType].consumption\n          .tenPercent ?? 0,\n        this.computeInstances['aws'][this.instanceType].consumption\n          .fiftyPercent ?? 0,\n        this.computeInstances['aws'][this.instanceType].consumption\n          .hundredPercent ?? 0,\n      ];\n\n      const spline = new Spline(x, y);\n\n      wattage = spline.at(cpu);\n    } else {\n      const idle =\n        this.computeInstances[this.vendor][this.instanceType].consumption\n          .minWatts ?? 0;\n      const max =\n        this.computeInstances[this.vendor][this.instanceType].consumption\n          .maxWatts ?? 0;\n\n      // linear interpolation\n      wattage = idle + (max - idle) * (cpu / 100);\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   * Returns model identifier\n   */\n  modelIdentifier(): string {\n    return CCF;\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    this.computeInstances['aws'] = {};\n    this.computeInstances['gcp'] = {};\n    this.computeInstances['azure'] = {};\n    this.calculateAverage('gcp', GCP_USE);\n    this.calculateAverage('azure', AZURE_USE);\n    this.calculateAverage('aws', AWS_USE);\n    AWS_INSTANCES.forEach((instance: KeyValuePair) => {\n      const cpus = parseInt(instance['Instance vCPU'], 10);\n      const architectures = INSTANCE_TYPE_COMPUTE_PROCESSOR_MAPPING[\n        instance['Instance type']\n      ] ?? ['Average'];\n      let minWatts = 0.0;\n      let maxWatts = 0.0;\n      let count = 0;\n      architectures.forEach((architecture: string) => {\n        architecture = this.resolveAwsArchitecture(architecture);\n        minWatts +=\n          this.computeInstanceUsageByArchitecture['aws'][architecture][\n            'Min Watts'\n          ] ?? 0;\n        maxWatts +=\n          this.computeInstanceUsageByArchitecture['aws'][architecture][\n            'Max Watts'\n          ] ?? 0;\n        count += 1;\n      });\n      minWatts = minWatts / count;\n      maxWatts = maxWatts / count;\n      this.computeInstances['aws'][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          minWatts: minWatts * cpus,\n          maxWatts: maxWatts * cpus,\n        },\n        vCPUs: cpus,\n        maxvCPUs: parseInt(instance['Platform Total Number of vCPU'], 10),\n        name: instance['Instance type'],\n      } as IComputeInstance;\n    });\n    GCP_INSTANCES.forEach((instance: KeyValuePair) => {\n      const cpus = parseInt(instance['Instance vCPUs'], 10);\n      let architecture = instance['Microarchitecture'];\n\n      if (!(architecture in this.computeInstanceUsageByArchitecture['gcp'])) {\n        architecture = 'Average';\n      }\n      this.computeInstances['gcp'][instance['Machine type']] = {\n        name: instance['Machine type'],\n        vCPUs: cpus,\n        consumption: {\n          minWatts:\n            this.computeInstanceUsageByArchitecture['gcp'][architecture][\n              'Min Watts'\n            ] * cpus,\n          maxWatts:\n            this.computeInstanceUsageByArchitecture['gcp'][architecture][\n              'Max Watts'\n            ] * cpus,\n        },\n        maxvCPUs: parseInt(\n          instance['Platform vCPUs (highest vCPU possible)'],\n          10\n        ),\n      } as IComputeInstance;\n    });\n    AZURE_INSTANCES.forEach((instance: KeyValuePair) => {\n      const cpus = parseInt(instance['Instance vCPUs'], 10);\n      let architecture = instance['Microarchitecture'];\n      if (!(architecture in this.computeInstanceUsageByArchitecture['azure'])) {\n        architecture = 'Average';\n      }\n      this.computeInstances['azure'][instance['Virtual Machine']] = {\n        consumption: {\n          minWatts:\n            this.computeInstanceUsageByArchitecture['azure'][architecture][\n              'Min Watts'\n            ] * cpus,\n          maxWatts:\n            this.computeInstanceUsageByArchitecture['azure'][architecture][\n              'Max Watts'\n            ] * cpus,\n        },\n        name: instance['Virtual Machine'],\n        vCPUs: instance['Instance vCPUs'],\n        maxvCPUs: parseInt(\n          instance['Platform vCPUs (highest vCPU possible)'],\n          10\n        ),\n      } as IComputeInstance;\n    });\n    AWS_EMBODIED.forEach((instance: KeyValuePair) => {\n      this.computeInstances['aws'][instance['type']].embodiedEmission =\n        instance['total'];\n    });\n    GCP_EMBODIED.forEach((instance: KeyValuePair) => {\n      this.computeInstances['gcp'][instance['type']].embodiedEmission =\n        instance['total'];\n    });\n    AZURE_EMBODIED.forEach((instance: KeyValuePair) => {\n      this.computeInstances['azure'][instance['type']].embodiedEmission =\n        instance['total'];\n    });\n  }\n\n  private calculateAverage(vendor: string, instanceList: KeyValuePair[]) {\n    let min = 0.0;\n    let max = 0.0;\n    let count = 0.0;\n    instanceList.forEach((instance: KeyValuePair) => {\n      this.computeInstanceUsageByArchitecture[vendor][\n        instance['Architecture']\n      ] = instance;\n      min += parseFloat(instance['Min Watts']);\n      max += parseFloat(instance['Max Watts']);\n      count += 1.0;\n    });\n    const avgMin = min / count;\n    const avgMax = max / count;\n    this.computeInstanceUsageByArchitecture[vendor]['Average'] = {\n      'Min Watts': avgMin,\n      'Max Watts': avgMax,\n      Architecture: 'Average',\n    };\n  }\n\n  // Architecture strings are different between Instances-Use.JSON and the bundled Typescript from CCF.\n  // This function resolves the differences.\n  resolveAwsArchitecture(architecture: string) {\n    if (architecture.includes('AMD ')) {\n      architecture = architecture.substring(4);\n    }\n\n    if (architecture.includes('Skylake')) {\n      architecture = 'Sky Lake';\n    }\n\n    if (architecture.includes('Graviton')) {\n      if (architecture.includes('2')) {\n        architecture = 'Graviton2';\n      } else {\n        architecture = 'Graviton';\n      }\n    }\n\n    if (architecture.includes('Unknown')) {\n      architecture = 'Average';\n    }\n\n    if (!(architecture in this.computeInstanceUsageByArchitecture['aws'])) {\n      throw new Error(`${architecture} not supported`);\n    }\n\n    return architecture;\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.vendor][this.instanceType].embodiedEmission ??\n      0;\n    const timeReserved = durationInHours;\n    const expectedLifespan = 8760 * this.expectedLifespan;\n    const reservedResources =\n      this.computeInstances[this.vendor][this.instanceType].vCPUs ?? 1.0;\n    const totalResources =\n      this.computeInstances[this.vendor][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"]}