/// <summary>
        /// Convert from the SmartEnergyDatabase type to the SmartEnergyAzureDataTypes.EmissionsRelativeMeritDatapoint data type in the SmartEnergyAzureDataTypes NuGet package
        /// </summary>
        /// <param name="carbonEmissionsRelativeMeritDataPoint"></param>
        /// <returns></returns>
        public EmissionsRelativeMeritDatapoint ConvertToCarbonEmissionsRelativeMeritWebDataPoints(CarbonEmissionsRelativeMeritDataPoint carbonEmissionsRelativeMeritDataPoint)
        {
            EmissionsRelativeMeritDatapoint webDataPoint = new EmissionsRelativeMeritDatapoint
            {
                EmissionsRegionID              = carbonEmissionsRelativeMeritDataPoint.EmissionsRegionID,
                DateTimeUTC                    = carbonEmissionsRelativeMeritDataPoint.DateTimeUTC,
                EmissionsRelativeMerit         = carbonEmissionsRelativeMeritDataPoint.EmissionsRelativeMerit,
                EmissionsRelativeMerit_Forcast = carbonEmissionsRelativeMeritDataPoint.EmissionsRelativeMerit_Forcast
            };

            return(webDataPoint);
        }
コード例 #2
0
        /// <summary>
        /// Calculate the Relative Merit of Marginal Carbon Emissions Values which are present in the database between the given startDateTime and endDateTime.
        /// The Relative Merit is a value between 0 (meaning best) and 1 (being worst).
        /// </summary>
        /// <param name="regionId"></param>
        /// <param name="startDateTime"></param>
        /// <param name="endDateTime"></param>
        /// <returns>List of MarginalCarbonResult.Result representing the Relative Merit of the corresponding Marginal Carbon Emissions Values</returns>
        public List <EmissionsRelativeMeritDatapoint> CalculateHistoricRelativeMeritDataResults(int regionId, DateTime startDateTime, DateTime endDateTime)
        {
            /*** Implement your custom logic here to calculate relative merit data ***/

            /* Here is a sample method provided here which simply calculates it's comparison to a one week rolling average for the data */
            var results = new List <EmissionsRelativeMeritDatapoint>();

            using (var objectModel = new SmartEnergyOM(this.DatabaseConnectionString))
            {
                // Get datapoints on which to calculate relative merit
                var carbonResultsOnWhichToCalculateRelativeMetit =
                    objectModel.FindCarbonEmissionsDataPoints(regionId, startDateTime, endDateTime);

                foreach (var datapoint in carbonResultsOnWhichToCalculateRelativeMetit)
                {
                    try
                    {
                        // Get the last week of data
                        var startDateOfOneWeekRollingAverage = datapoint.DateTimeUTC.AddDays(-7);
                        var endDateOfOneWeekRollingAverage   = datapoint.DateTimeUTC.AddHours(1);
                        var emissionsDataPointsWithinWindow  =
                            objectModel.FindCarbonEmissionsDataPoints(regionId, startDateOfOneWeekRollingAverage,
                                                                      endDateOfOneWeekRollingAverage).Where(a => a.MarginalCO2Intensity_gCO2kWh != null);

                        // Calculate where this datapoints falls within the range of the last week
                        if (emissionsDataPointsWithinWindow.Any())
                        {
                            double?relativeMerit          = null;
                            double?relativeMerit_Forecast = null;
                            if (datapoint.MarginalCO2Intensity_gCO2kWh != null)
                            {
                                var maxValue = emissionsDataPointsWithinWindow.Max(a => a.MarginalCO2Intensity_gCO2kWh);
                                var minValue = emissionsDataPointsWithinWindow.Min(a => a.MarginalCO2Intensity_gCO2kWh);
                                var range    = (double)(maxValue - minValue);
                                relativeMerit =
                                    (datapoint.MarginalCO2Intensity_gCO2kWh - minValue) / range;

                                // One specicial check: 0 should be reserved for zero emissions. Set anything above zero to .2
                                if ((relativeMerit < .2) && (datapoint.MarginalCO2Intensity_gCO2kWh > 0))
                                {
                                    relativeMerit = .2;
                                }
                            }
                            if (datapoint.MarginalCO2Intensity_Forcast_gCO2kWh != null)
                            {
                                var maxValue = emissionsDataPointsWithinWindow.Max(a => a.MarginalCO2Intensity_Forcast_gCO2kWh);
                                var minValue = emissionsDataPointsWithinWindow.Min(a => a.MarginalCO2Intensity_Forcast_gCO2kWh);
                                var range    = (double)(maxValue - minValue);
                                relativeMerit_Forecast =
                                    (datapoint.MarginalCO2Intensity_Forcast_gCO2kWh - minValue) / range;

                                // One specicial check: 0 should be reserved for zero emissions. Set anything above zero to .2
                                if ((relativeMerit_Forecast < .2) && (datapoint.MarginalCO2Intensity_Forcast_gCO2kWh > 0))
                                {
                                    relativeMerit_Forecast = .2;
                                }
                            }
                            if ((relativeMerit != null) || (relativeMerit_Forecast != null))
                            {
                                var emissionsRelativeMeritDataResult =
                                    new EmissionsRelativeMeritDatapoint
                                {
                                    EmissionsRegionID              = regionId,
                                    Timestamp                      = datapoint.DateTimeUTC,
                                    EmissionsRelativeMerit         = relativeMerit,
                                    EmissionsRelativeMerit_Forcast = relativeMerit_Forecast
                                };
                                results.Add(emissionsRelativeMeritDataResult);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Logger.Error(
                            $"CarbonEmissionsMiner: CalculateHistoricRelativeMeritDataResults(): Exception encountered Calculate the Merit of datapoint at {datapoint.DateTimeUTC} for RegionId {datapoint.EmissionsRegionID}.",
                            "CarbonEmissionsMiner.CalculateHistoricRelativeMeritDataResults()",
                            null,
                            e);
                    }
                }
            }

            return(results);
        }