示例#1
0
        /// <summary>
        /// Take a CSV File containing CarbonEmissionsDataPoint values, and return them as a List of CarbonEmissionsDataPoint.
        /// DateTime is parsed as DD/MM/YYYY HH:MM and should be in this format in the CSV
        /// </summary>
        /// <param name="folderContainingCsv"></param>
        /// <param name="csvFileName"></param>
        /// <param name="regionId">RegionId to which the CarbonEmissionsDataPoint values pertain</param>
        /// <param name="dateTimeFormat">DateTime format to be passed to DateTime.ParseExact(). E.g. "MM/dd/yyyy HH:mm:ss"</param>
        /// <param name="ignoreParsingErrors">True to ignore errors parsing individual rows. False to rethrow the exceptions.</param>
        /// <returns></returns>
        public List <CarbonEmissionsDataPoint> ImportCarbonResultsFromCsv(
            string folderContainingCsv,
            string csvFileName,
            int regionId,
            string dateTimeFormat    = "MM/dd/yyyy HH:mm:ss",
            bool ignoreParsingErrors = true)
        {
            var results = new List <CarbonEmissionsDataPoint>();

            try
            {
                Logger.Information(
                    $"Importing Historic Carbon Results for RegionId {regionId} from CSV {csvFileName}.",
                    "CarbonEmissionsMiner.ImportCarbonResultsFromCsv()");

                var csvConnectionString = GenerateOleDbConnectionStringToFolder(folderContainingCsv);
                using (var cn = new OleDbConnection(csvConnectionString))
                {
                    cn.Open();
                    using (OleDbCommand cmd = cn.CreateCommand())
                    {
                        cmd.CommandText = $"SELECT * FROM [{csvFileName}]";
                        cmd.CommandType = CommandType.Text;
                        using (OleDbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                        {
                            foreach (DbDataRecord record in reader)
                            {
                                try
                                {
                                    // DateTime is parsed as DD/MM/YYYY HH:MM and should be in this format in the CSV
                                    var dateTimeUtcString = record.GetValue(reader.GetOrdinal("DateTimeUtc"))
                                                            .ToString();
                                    var dateTimeFormatToaPasrseWith = dateTimeFormat;

                                    var dateTimeUtc = DateTime.ParseExact(dateTimeUtcString, dateTimeFormatToaPasrseWith, CultureInfo.InvariantCulture);

                                    decimal systemWideEmissions     = -9999;
                                    decimal marginalEmissions       = -9999;
                                    string  systemWideEmissionsUnit = null;
                                    string  marginalEmissionsUnit   = null;

                                    try
                                    {
                                        systemWideEmissions = string.IsNullOrEmpty(
                                            record.GetValue(reader.GetOrdinal("SystemWideEmissions")).ToString())
                                            ? -9999
                                            : decimal.Parse(record.GetValue(reader.GetOrdinal("SystemWideEmissions"))
                                                            .ToString());
                                        systemWideEmissionsUnit =
                                            string.IsNullOrEmpty(
                                                record.GetValue(reader.GetOrdinal("SystemWideEmissionsUnit"))
                                                .ToString())
                                                ? null
                                                : record.GetString(reader.GetOrdinal("SystemWideEmissionsUnit"));
                                    }
                                    catch (Exception)
                                    {
                                    }

                                    try
                                    {
                                        marginalEmissions = string.IsNullOrEmpty(
                                            record.GetValue(reader.GetOrdinal("marginalEmissions")).ToString())
                                        ? -9999
                                        : decimal.Parse(record.GetValue(reader.GetOrdinal("marginalEmissions"))
                                                        .ToString());
                                        marginalEmissionsUnit =
                                            string.IsNullOrEmpty(
                                                record.GetValue(reader.GetOrdinal("marginalEmissionsUnit")).ToString())
                                            ? null
                                            : record.GetString(reader.GetOrdinal("marginalEmissionsUnit"));
                                    }
                                    catch (Exception)
                                    {
                                    }

                                    // Convert the units to ensure they are uniform in the database
                                    double?systemWideCarbonMetric = null;
                                    if (systemWideEmissions != -9999)
                                    {
                                        systemWideCarbonMetric = systemWideEmissionsUnit == "lbs/MWh"
                                            ? this.wattTimeEmissionsInteraction
                                                                 .ConvertLbsPerMWhTo_GCo2PerkWh(
                                            double.Parse(systemWideEmissions.ToString()))
                                            : double.Parse(systemWideEmissions.ToString());
                                    }

                                    double?marginalCarbonMetric = null;
                                    if (marginalEmissions != -9999)
                                    {
                                        marginalCarbonMetric = marginalEmissionsUnit == "lbs/MWh"
                                            ? this.wattTimeEmissionsInteraction
                                                               .ConvertLbsPerMWhTo_GCo2PerkWh(
                                            double.Parse(marginalEmissions.ToString()))
                                            : double.Parse(marginalEmissions.ToString());
                                    }

                                    var dataPoint = new CarbonEmissionsDataPoint()
                                    {
                                        DateTimeUTC       = dateTimeUtc,
                                        EmissionsRegion   = null,
                                        EmissionsRegionID = regionId,
                                        MarginalCO2Intensity_Forcast_gCO2kWh   = null,
                                        MarginalCO2Intensity_gCO2kWh           = marginalCarbonMetric,
                                        SystemWideCO2Intensity_Forcast_gCO2kWh = null,
                                        SystemWideCO2Intensity_gCO2kWh         = systemWideCarbonMetric
                                    };

                                    results.Add(dataPoint);
                                }
                                catch (Exception e)
                                {
                                    // Encountered an unreadable row in the CSV file.
                                    if (!ignoreParsingErrors)
                                    {
                                        throw;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Error(
                    $"CarbonEmissionsMiner: ImportCarbonResultsFromCsv(): Exception encountered importing emissions Data from CSV with name {csvFileName} in folder {folderContainingCsv}.",
                    "CarbonEmissionsMiner.ImportCarbonResultsFromCsv()",
                    null,
                    e);
            }

            return(results);
        }
        public GridEmissionsDataPoint ConvertCarbonEmissionsDataPointToCarbonEmissionsWebDataPoint(CarbonEmissionsDataPoint carbonEmissionsDataPoint)
        {
            GridEmissionsDataPoint webDataPoint = new GridEmissionsDataPoint
            {
                EmissionsRegionID = carbonEmissionsDataPoint.EmissionsRegionID,
                DateTimeUTC       = carbonEmissionsDataPoint.DateTimeUTC,
                SystemWideCO2Intensity_gCO2kWh =
                    carbonEmissionsDataPoint.SystemWideCO2Intensity_gCO2kWh,
                MarginalCO2Intensity_gCO2kWh =
                    carbonEmissionsDataPoint.MarginalCO2Intensity_gCO2kWh,
                SystemWideCO2Intensity_Forcast_gCO2kWh =
                    carbonEmissionsDataPoint.SystemWideCO2Intensity_Forcast_gCO2kWh,
                MarginalCO2Intensity_Forcast_gCO2kWh =
                    carbonEmissionsDataPoint.MarginalCO2Intensity_Forcast_gCO2kWh
            };

            return(webDataPoint);
        }