Add carbon emissions admin configuration options

client/src/components/DatasetInformation/DatasetDetails.vue

@@ -21,8 +21,12 @@
                             <inheritance-chain :dataset-id="datasetId" :dataset-name="dataset.name" />
                             <job-metrics
                                 v-if="config"
+                                :dataset-id="datasetId"
+                                :carbon-intensity="config.carbon_intensity"
+                                :geographical-server-location-name="config.geographical_server_location_name"
+                                :power-usage-effectiveness="config.power_usage_effectiveness"
                                 :should-show-aws-estimate="config.aws_estimate"
-                                :dataset-id="datasetId" />
+                                :should-show-carbon-emissions-estimates="config.carbon_emissions_estimates" />
                             <job-destination-params v-if="currentUser.is_admin" :job-id="dataset.creating_job" />
                             <job-dependencies :dependencies="job.dependencies"></job-dependencies>
                             <div v-if="dataset.peek">

client/src/components/JobMetrics/AwsEstimate.vue

@@ -50,7 +50,7 @@ const computedAwsEstimate = computed(() => {
 
 <template>
     <div v-if="computedAwsEstimate" id="aws-estimate" class="mt-4">
-        <h3>AWS estimate</h3>
+        <h2>AWS estimate</h2>
 
         <strong id="aws-cost">{{ computedAwsEstimate.price }} USD</strong>
 

client/src/components/JobMetrics/CarbonEmissions/CarbonEmissions.test.js

@@ -1,6 +1,7 @@
 import { mount } from "@vue/test-utils";
 import { getLocalVue } from "tests/jest/helpers";
 
+import { worldwideCarbonIntensity, worldwidePowerUsageEffectiveness } from "./carbonEmissionConstants.js";
 import CarbonEmissions from "./CarbonEmissions";
 
 const localVue = getLocalVue();
@@ -17,13 +18,15 @@ const testServerInstance = {
 };
 
 describe("CarbonEmissions/CarbonEmissions.vue", () => {
-    it("correctly calculates carbon emissions.", async () => {
+    it("correctly calculates carbon emissions.", () => {
         const wrapper = mount(CarbonEmissions, {
             propsData: {
+                carbonIntensity: worldwideCarbonIntensity,
+                coresAllocated: 1,
                 estimatedServerInstance: testServerInstance,
                 jobRuntimeInSeconds: oneHourInSeconds,
-                coresAllocated: 1,
                 memoryAllocatedInMebibyte: oneGibibyteMemoryInMebibyte,
+                powerUsageEffectiveness: worldwidePowerUsageEffectiveness,
             },
             localVue,
         });
@@ -42,14 +45,118 @@ describe("CarbonEmissions/CarbonEmissions.vue", () => {
     it("does not render memory estimates when no value can be determined.", () => {
         const wrapper = mount(CarbonEmissions, {
             propsData: {
-                estimatedServerInstance: testServerInstance,
-                jobRuntime: 1,
                 coresAllocated: 1,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 1,
             },
             localVue,
         });
 
         expect(wrapper.find("#memory-carbon-emissions").exists()).toBe(false);
         expect(wrapper.find("#memory-energy-usage").exists()).toBe(false);
     });
+
+    it("takes the configured `powerUsageEffectiveness` value into account.", () => {
+        const wrapper = mount(CarbonEmissions, {
+            propsData: {
+                carbonIntensity: 1,
+                coresAllocated: 1,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 1,
+                memoryAllocatedInMebibyte: 1,
+                powerUsageEffectiveness: 0,
+            },
+            localVue,
+        });
+
+        const cpuEmissions = wrapper.find("#cpu-carbon-emissions").text();
+        const cpuEnergyUsage = wrapper.find("#cpu-energy-usage").text();
+        const memoryEmissions = wrapper.find("#memory-carbon-emissions").text();
+        const memoryEnergyUsage = wrapper.find("#memory-energy-usage").text();
+
+        expect(cpuEmissions).toMatch("0 g CO2e");
+        expect(cpuEnergyUsage).toMatch("0 kW⋅h");
+        expect(memoryEmissions).toMatch("0 g CO2e");
+        expect(memoryEnergyUsage).toMatch("0 kW⋅h");
+    });
+
+    it("takes the configured `carbonIntensity` value into account.", () => {
+        const wrapper = mount(CarbonEmissions, {
+            propsData: {
+                carbonIntensity: 0,
+                coresAllocated: 1,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 1,
+                memoryAllocatedInMebibyte: 1,
+                powerUsageEffectiveness: 1,
+            },
+            localVue,
+        });
+
+        const cpuEmissions = wrapper.find("#cpu-carbon-emissions").text();
+        const memoryEmissions = wrapper.find("#memory-carbon-emissions").text();
+
+        expect(cpuEmissions).toMatch("0 g CO2e");
+        expect(memoryEmissions).toMatch("0 g CO2e");
+    });
+
+    it("displays text saying that global values were used when the `geographicalServerLocationName` prop is set to `GLOBAL`.", () => {
+        const carbonIntensity = worldwideCarbonIntensity;
+        const wrapper = mount(CarbonEmissions, {
+            propsData: {
+                carbonIntensity,
+                coresAllocated: 2,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 2,
+                geographicalServerLocationName: "GLOBAL",
+            },
+            localVue,
+        });
+        const locationText = wrapper.find("#location-explanation").element;
+        expect(locationText).toHaveTextContent(
+            `1. Based off of the global carbon intensity value of ${carbonIntensity}.`
+        );
+    });
+
+    it("displays text saying that the carbon intensity value corresponding to `geographicalServerLocationName` was used.", () => {
+        const locationName = "Italy";
+        const carbonIntensity = worldwideCarbonIntensity;
+        const wrapper = mount(CarbonEmissions, {
+            propsData: {
+                carbonIntensity,
+                coresAllocated: 2,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 2,
+                memoryAllocatedInMebibyte: oneGibibyteMemoryInMebibyte,
+                powerUsageEffectiveness: worldwideCarbonIntensity,
+                geographicalServerLocationName: locationName,
+            },
+            localVue,
+        });
+
+        const locationElement = wrapper.find("#location-explanation").element;
+        expect(locationElement).toHaveTextContent(
+            `1. based off of this galaxy instance's configured location of ${locationName}, which has a carbon intensity value of ${carbonIntensity} gCO2/kWh.`
+        );
+    });
+
+    it("displays text saying that global average values for PUE where used when `powerUsageEffectiveness` matches the global average.", () => {
+        const powerUsageEffectiveness = worldwidePowerUsageEffectiveness;
+        const wrapper = mount(CarbonEmissions, {
+            propsData: {
+                carbonIntensity: 1,
+                coresAllocated: 1,
+                estimatedServerInstance: testServerInstance,
+                jobRuntimeInSeconds: 1,
+                memoryAllocatedInMebibyte: 1,
+                powerUsageEffectiveness,
+            },
+            localVue,
+        });
+
+        const locationElement = wrapper.find("#pue").element;
+        expect(locationElement).toHaveTextContent(
+            `2. Using the global default power usage effectiveness value of ${powerUsageEffectiveness}.`
+        );
+    });
 });

client/src/components/JobMetrics/CarbonEmissions/CarbonEmissions.vue

@@ -24,15 +24,17 @@ interface CarbonEmissionsProps {
     };
     jobRuntimeInSeconds: number;
     coresAllocated: number;
+    powerUsageEffectiveness: number;
+    geographicalServerLocationName: string;
     memoryAllocatedInMebibyte?: number;
+    carbonIntensity: number;
 }
 
 const props = withDefaults(defineProps<CarbonEmissionsProps>(), {
     memoryAllocatedInMebibyte: 0,
 });
 
 const carbonEmissions = computed(() => {
-    const powerUsageEffectiveness = carbonEmissionsConstants.worldwidePowerUsageEffectiveness;
     const memoryPowerUsed = carbonEmissionsConstants.memoryPowerUsage;
     const runtimeInHours = props.jobRuntimeInSeconds / (60 * 60); // Convert to hours
     const memoryAllocatedInGibibyte = props.memoryAllocatedInMebibyte / 1024; // Convert to gibibyte
@@ -42,8 +44,8 @@ const carbonEmissions = computed(() => {
     const normalizedTdpPerCore = tdpPerCore * props.coresAllocated;
 
     // Power needed in Watt
-    const powerNeededCpu = powerUsageEffectiveness * normalizedTdpPerCore;
-    const powerNeededMemory = powerUsageEffectiveness * memoryAllocatedInGibibyte * memoryPowerUsed;
+    const powerNeededCpu = props.powerUsageEffectiveness * normalizedTdpPerCore;
+    const powerNeededMemory = props.powerUsageEffectiveness * memoryAllocatedInGibibyte * memoryPowerUsed;
     const totalPowerNeeded = powerNeededCpu + powerNeededMemory;
 
     // Energy needed. Convert Watt to kWh
@@ -52,7 +54,7 @@ const carbonEmissions = computed(() => {
     const totalEnergyNeeded = (runtimeInHours * totalPowerNeeded) / 1000;
 
     // Carbon emissions (carbon intensity is in grams/kWh so emissions results are in grams of CO2)
-    const carbonIntensity = carbonEmissionsConstants.worldwideCarbonIntensity;
+    const carbonIntensity = props.carbonIntensity;
     const cpuCarbonEmissions = energyNeededCPU * carbonIntensity;
     const memoryCarbonEmissions = energyNeededMemory * carbonIntensity;
     const totalCarbonEmissions = totalEnergyNeeded * carbonIntensity;
@@ -266,9 +268,9 @@ function getEnergyNeededText(energyNeededInKiloWattHours: number) {
 }
 </script>
 
-<template>
-    <div v-if="carbonEmissions && carbonEmissionsComparisons" class="mt-4">
-        <Heading h1 separator inline bold> Carbon Footprint </Heading>
+<template v-if="carbonEmissions && carbonEmissionsComparisons">
+    <div class="mt-4">
+        <Heading h2 separator inline bold> Carbon Footprint </Heading>
 
         <section class="carbon-emission-values my-4">
             <div class="emissions-grid">
@@ -307,8 +309,8 @@ function getEnergyNeededText(energyNeededInKiloWattHours: number) {
 
                     <thead>
                         <th>Component</th>
-                        <th>Carbon Emissions <sup>1.</sup> <sup>2.</sup></th>
-                        <th>Energy Usage <sup>1.</sup></th>
+                        <th>Carbon Emissions <sup>1.</sup> <sup>2.</sup> <sup>3.</sup></th>
+                        <th>Energy Usage <sup>2.</sup> <sup>3.</sup></th>
                     </thead>
 
                     <tbody>
@@ -333,16 +335,34 @@ function getEnergyNeededText(energyNeededInKiloWattHours: number) {
                 </table>
 
                 <p class="p-0 m-0">
-                    <strong>1.</strong> based off of the closest AWS EC2 instance comparable to the server that ran this
-                    job. Estimates depend on the core count, allocated memory and the job runtime. The closest estimate
-                    is a <strong>{{ estimatedServerInstance.name }}</strong> instance.
+                    <span v-if="geographicalServerLocationName === 'GLOBAL'" id="location-explanation">
+                        <strong>1.</strong> Based off of the global carbon intensity value of
+                        {{ carbonEmissionsConstants.worldwideCarbonIntensity }}.
+                    </span>
+                    <span v-else id="location-explanation">
+                        <strong>1.</strong> based off of this galaxy instance's configured location of
+                        <strong>{{ geographicalServerLocationName }}</strong
+                        >, which has a carbon intensity value of {{ carbonIntensity }} gCO2/kWh.
+                    </span>
 
                     <br />
 
-                    <strong>2.</strong> CO2e represents other types of greenhouse gases the have similar global warming
-                    potential as a metric unit amount of CO2 itself.
+                    <span
+                        v-if="powerUsageEffectiveness === carbonEmissionsConstants.worldwidePowerUsageEffectiveness"
+                        id="pue">
+                        <strong>2.</strong> Using the global default power usage effectiveness value of
+                        {{ carbonEmissionsConstants.worldwidePowerUsageEffectiveness }}.
+                    </span>
+                    <span v-else id="pue">
+                        <strong>2.</strong> using the galaxy instance's configured power usage effectiveness ratio value
+                        of of {{ powerUsageEffectiveness }}.
+                    </span>
 
                     <br />
+
+                    <strong>3.</strong> based off of the closest AWS EC2 instance comparable to the server that ran this
+                    job. Estimates depend on the core count, allocated memory and the job runtime. The closest estimate
+                    is a <strong>{{ estimatedServerInstance.name }}</strong> instance.
                 </p>
 
                 <router-link

client/src/components/JobMetrics/CarbonEmissions/carbonEmissionConstants.js

@@ -25,7 +25,7 @@ export const treeYear = 11000;
 // source: http://www.sciencedirect.com/science/article/pii/S0269749101002640
 export const treeMonth = 917;
 
-// source: https://www.iea.org/reports/global-energy-co2-status-report-2019/emissions
+// source: (in gCO2/kWh) https://www.iea.org/reports/global-energy-co2-status-report-2019/emissions
 export const worldwideCarbonIntensity = 475.0;
 
 // source: https://journal.uptimeinstitute.com/is-pue-actually-going-up/

client/src/components/JobMetrics/JobMetrics.vue

@@ -3,14 +3,12 @@ import { computed, ref, unref } from "vue";
 
 import { useJobMetricsStore } from "@/stores/jobMetricsStore";
 
+import { worldwideCarbonIntensity, worldwidePowerUsageEffectiveness } from "./CarbonEmissions/carbonEmissionConstants";
+
 import AwsEstimate from "./AwsEstimate.vue";
 import CarbonEmissions from "./CarbonEmissions/CarbonEmissions.vue";
 
 const props = defineProps({
-    jobId: {
-        type: String,
-        default: null,
-    },
     datasetFilesize: {
         type: Number,
         default: 0,
@@ -27,10 +25,30 @@ const props = defineProps({
         type: Boolean,
         default: true,
     },
+    jobId: {
+        type: String,
+        default: null,
+    },
+    powerUsageEffectiveness: {
+        type: Number,
+        default: worldwidePowerUsageEffectiveness,
+    },
+    geographicalServerLocationName: {
+        type: String,
+        default: "GLOBAL",
+    },
+    carbonIntensity: {
+        type: Number,
+        default: worldwideCarbonIntensity,
+    },
     shouldShowAwsEstimate: {
         type: Boolean,
         default: false,
     },
+    shouldShowCarbonEmissionsEstimates: {
+        type: Boolean,
+        default: true,
+    },
 });
 
 const jobMetricsStore = useJobMetricsStore();
@@ -184,7 +202,12 @@ const estimatedServerInstance = computed(() => {
             :memory-allocated-in-mebibyte="memoryAllocatedInMebibyte" />
 
         <CarbonEmissions
-            v-if="estimatedServerInstance && jobRuntimeInSeconds && coresAllocated"
+            v-if="
+                shouldShowCarbonEmissionsEstimates && estimatedServerInstance && jobRuntimeInSeconds && coresAllocated
+            "
+            :carbon-intensity="carbonIntensity"
+            :geographical-server-location-name="geographicalServerLocationName"
+            :power-usage-effectiveness="powerUsageEffectiveness"
             :estimated-server-instance="estimatedServerInstance"
             :job-runtime-in-seconds="jobRuntimeInSeconds"
             :cores-allocated="coresAllocated"