private void MakeAbregelungWorksheet([NotNull] ScenarioSliceParameters slice, double maxDailyGen, [NotNull] Profile addedProfile) { RowCollection rc = new RowCollection("effect", "Effekt"); for (double i = 0; i < 1; i += 0.01) { double storageSize = maxDailyGen * 2; var minimzed = ProfileSmoothing.FindBestPowerReductionRatio(addedProfile, storageSize, out var _, out var reductionFactor, i); double friendlySize = storageSize / Constants.GWhFactor; Info("Size: " + i + " " + friendlySize + " gwh, Reduction factor: " + reductionFactor); RowBuilder rb = RowBuilder.Start("Size", friendlySize); rb.Add("storage", storageSize); rb.Add("ReductionFactor", reductionFactor); rb.Add("Capping", i); rb.Add("Max Power", minimzed.MaxPower() / 1000); rb.Add("Min Power", minimzed.MinPower() / 1000); rc.Add(rb); } var fnFactor = MakeAndRegisterFullFilename("CappingImpact.xlsx", slice); XlsxDumper.WriteToXlsx(fnFactor, rc); SaveToPublicationDirectory(fnFactor, slice, "4.5"); }
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo) { Info("starting to make house results"); var sheets = new List <RowCollection>(); foreach (var slice in allSlices) { RowCollection rc = new RowCollection(slice.DstScenario.ShortName + "_" + slice.DstYear, slice.DstScenario.Name + " - " + slice.DstYear); var pventries = analysisRepo.GetSlice(slice).Fetch <PvSystemEntry>(); var houses = analysisRepo.GetSlice(slice).Fetch <House>(); var pvPotential = analysisRepo.GetSlice(slice).Fetch <PVPotential>(); foreach (var house in houses) { var pventriesInHouse = pventries.GetByReferenceGuidWithEmptyReturns(house.HouseGuid, "HouseGuid", y => y.HouseGuid); var rb = RowBuilder.Start("House", house.ComplexName); var pvPotentialsInHouse = pvPotential.GetByReferenceGuidWithEmptyReturns(house.HouseGuid, "HouseGuid", y => y.HouseGuid); rb.Add("PV entries", pventriesInHouse.Count); if (pventriesInHouse.Count > 0) { rb.Add("PV Year", pventriesInHouse.Max(x => x.BuildYear)); } rb.Add("EnergySum", pventriesInHouse.Sum(x => x.EffectiveEnergyDemand)); rb.Add("Potential Count", pvPotentialsInHouse.Count); rb.Add("Potential Energy Sum", pvPotentialsInHouse.Sum(x => x.SonnendachStromErtrag)); rc.Add(rb); } sheets.Add(rc); } var fn = MakeAndRegisterFullFilename("PVAnalysis.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, sheets); }
protected override void RunActualProcess() { var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); var houses = dbHouse.Fetch <House>(); var ebbe = dbRaw.Fetch <EnergiebedarfsdatenBern>(); RowCollection rc = new RowCollection("Analysis", "Analysis"); foreach (var house in houses) { RowBuilder rb = RowBuilder.Start("House", house.ComplexName); var ebbedata = ebbe.Where(x => house.EGIDs.Contains((int)x.egid)).ToList(); foreach (var ebbeSet in ebbedata) { ebbe.Remove(ebbeSet); } rb.Add("Ebbe", JsonConvert.SerializeObject(ebbedata)); rc.Add(rb); } foreach (var ebbeset in ebbe) { RowBuilder rb = RowBuilder.Start("Ebbe eGid", ebbeset.egid); rb.Add("Ebbe", JsonConvert.SerializeObject(ebbeset)); rc.Add(rb); } var fn = MakeAndRegisterFullFilename("HeatingSystemAnalysis.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess([NotNull] ScenarioSliceParameters parameters) { //profile export var dbProfileExport = Services.SqlConnection.GetDatabaseConnection(Stage.ProfileExport, parameters); var prosumers = Prosumer.LoadProsumers(dbProfileExport, TableType.HouseGeneration); var resultPathGeneration = Path.Combine(dbProfileExport.GetResultFullPath(SequenceNumber, Name), "Export"); if (Directory.Exists(resultPathGeneration)) { Directory.Delete(resultPathGeneration, true); Thread.Sleep(500); } if (!Directory.Exists(resultPathGeneration)) { Directory.CreateDirectory(resultPathGeneration); Thread.Sleep(500); } HashSet <string> usedKeys = new HashSet <string>(); var trafokreise = prosumers.Select(x => x.TrafoKreis).Distinct().ToList(); RowCollection rc = new RowCollection(); foreach (var trafokreis in trafokreise) { if (string.IsNullOrWhiteSpace(trafokreis)) { continue; } var filteredProsumers = prosumers.Where(x => x.TrafoKreis == trafokreis).ToList(); string tkFileName = trafokreis.Replace("ä", "ae").Replace("ö", "oe").Replace("ü", "ue"); var csvFileNameGeneration = Path.Combine(resultPathGeneration, tkFileName + ".csv"); var sw2 = new StreamWriter(csvFileNameGeneration); int lines = 0; foreach (var prosumer in filteredProsumers) { var row = RowBuilder.Start("Trafokreis", trafokreis).Add("Name", prosumer.Name).Add("Energy", prosumer.SumElectricityFromProfile); if (usedKeys.Contains(prosumer.HausanschlussKey)) { throw new FlaException("This key was already exported"); } usedKeys.Add(prosumer.HausanschlussKey); sw2.WriteLine(prosumer.GetCSVLine()); lines++; rc.Add(row); } Log(MessageType.Info, "Wrote " + lines + " lines to " + csvFileNameGeneration); sw2.Close(); } var fn = MakeAndRegisterFullFilename("Generation.xlsx", parameters); XlsxDumper.WriteToXlsx(rc, fn, "Generators"); }
protected override void RunChartMaking() { AnalysisRepository rp = new AnalysisRepository(Services.RunningConfig); var slice = rp.GetSlice(Constants.PresentSlice); var potentials = slice.Fetch <PVPotential>(); RowCollection rc = new RowCollection("pv", "pv"); foreach (var potential in potentials) { rc.Add(RowBuilder.Start("Neigung", potential.Neigung) .Add("Ausrichtung", potential.Ausrichtung) .Add("Fläche", potential.SonnendachStromErtrag)); } var fn = MakeAndRegisterFullFilename("PVpotentials.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
private void ExportAsExcel([NotNull][ItemNotNull] List <Hausanschluss> hausanschlusses, [NotNull][ItemNotNull] List <House> houses) { { //houses direct RowCollection rc = new RowCollection("Houses", "Häuser"); foreach (House house in houses) { rc.Rows.Add(MakeHouseRow(house)); foreach (var ha in house.Hausanschluss) { rc.Rows.Add(MakeHausanschlussRow(ha)); } } var fn = MakeAndRegisterFullFilename("HousesWithHausanschluss.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); } { //houses by Trafokreis RowCollection rc = new RowCollection("Houses", "Häuser"); var trafokreise = hausanschlusses.Select(x => x.Trafokreis).Distinct().ToList(); foreach (var trafokreis in trafokreise) { var rbTk = RowBuilder.Start("Trafokreis Name", trafokreis); var selectedHouses = houses.Where(x => x.Hausanschluss.Any(y => y.Trafokreis == trafokreis)).ToList(); rbTk.Add("House Count", selectedHouses.Count); rc.Rows.Add(rbTk.GetRow()); foreach (House house in selectedHouses) { rc.Rows.Add(MakeHouseRow(house)); foreach (var ha in house.Hausanschluss) { rc.Rows.Add(MakeHausanschlussRow(ha)); } } } var fn = MakeAndRegisterFullFilename("HousesWithTrafokreisTree.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); } }
private void DumpHeatingSystemsToXlsx([NotNull] ScenarioSliceParameters slice, [NotNull][ItemNotNull] List <HeatingSystemEntry> srcHeatingSystems, [NotNull] Dictionary <string, House> dstHousesByGuid) { RowCollection rc1 = new RowCollection("HeatingSystems", "HeatingSystems"); foreach (var heatingSystemEntry in srcHeatingSystems) { var house = dstHousesByGuid[heatingSystemEntry.HouseGuid]; var rb = RowBuilder.Start("House", house.ComplexName); rb.Add("Effective EnergyDemand", heatingSystemEntry.EffectiveEnergyDemand); rb.Add("Effective HeatDemand", heatingSystemEntry.HeatDemand); rb.Add("Heating system type", heatingSystemEntry.SynthesizedHeatingSystemType); rb.Add("Age", heatingSystemEntry.Age); rc1.Add(rb); } var fn1 = MakeAndRegisterFullFilename("heatingsystemdump.xlsx", slice); XlsxDumper.WriteToXlsx(fn1, rc1); }
private void WriteSumLine([NotNull][ItemNotNull] List <CSVFile> csvs1, [NotNull] ScenarioSliceParameters slice) { if (slice.DstYear != 2050 && slice.SmartGridEnabled) { return; } string suffix = csvs1[0].GenerationOrLoad.ToString().ToLower(); var fn = MakeAndRegisterFullFilename("SummedProfilePerTrafokreis." + suffix + ".csv", slice); RowCollection rc = new RowCollection("Sheet1", "Sheet1"); using (StreamWriter sumfile = new StreamWriter(fn)) { Info("writing " + csvs1.Count + " sum lines for " + suffix); foreach (var csv in csvs1) { double[] arr = new double[35040]; foreach (var line in csv.Lines) { for (int i = 0; i < 35040; i++) { arr[i] += line.Values[i]; } } Profile p = new Profile(csv.FileName ?? throw new InvalidOperationException(), arr.ToList().AsReadOnly(), EnergyOrPower.Energy); RowBuilder rb = RowBuilder.Start("Name", csv.FileName); rb.Add("Value", p.EnergySum()); rc.Add(rb); sumfile.WriteLine(csv.FileName + ";" + p.GetCSVLine()); } sumfile.Close(); } var xlsfn = MakeAndRegisterFullFilename("SumsPerTrafokreis." + suffix + ".xlsx", slice); XlsxDumper.WriteToXlsx(xlsfn, rc); SaveToArchiveDirectory(fn, RelativeDirectory.Trafokreise, slice); SaveToArchiveDirectory(xlsfn, RelativeDirectory.Report, slice); }
private void MakeStorageSizeSheet([NotNull] ScenarioSliceParameters slice, double maxDailyGen, [NotNull] Profile addedProfile) { RowCollection rc = new RowCollection("effect", "Effekt"); for (double i = 0; i < 10; i += 0.1) { double storageSize = maxDailyGen * i; var minimzed = ProfileSmoothing.FindBestPowerReductionRatio(addedProfile, storageSize, out var _, out var reductionFactor, 1); var minimzed2 = ProfileSmoothing.FindBestPowerReductionRatio(addedProfile, storageSize, out var _, out var reductionFactor2, 0.5); double friendlySize = storageSize / Constants.GWhFactor; Info("Size: " + i + " " + friendlySize + " gwh, Reduction factor: " + reductionFactor); RowBuilder rb = RowBuilder.Start("Size", friendlySize); rb.Add("DaySize", i); rb.Add("ReductionFactor", reductionFactor); rb.Add("Max Power", minimzed.MaxPower() / 1000); rb.Add("Min Power", minimzed.MinPower() / 1000); rb.Add("Energy", minimzed.EnergySum() / 1000000); rb.Add("EnergyFromGrid", minimzed.GetOnlyPositive("pos").EnergySum() / 1000000); rb.Add("EnergyToGrid", minimzed.GetOnlyNegative("neg").EnergySum() / 1000000); rb.Add("ReductionFactor Curtailed", reductionFactor2); rb.Add("Max Power Curtailed", minimzed2.MaxPower() / 1000); rb.Add("Min Power Curtailed", minimzed2.MinPower() / 1000); rb.Add("Energy Curtailed", minimzed2.EnergySum() / 1000000); rb.Add("EnergyFromGrid Curtailed", minimzed2.GetOnlyPositive("pos").EnergySum() / 1000000); rb.Add("EnergyToGrid Curtailed", minimzed2.GetOnlyNegative("neg").EnergySum() / 1000000); rc.Add(rb); } var fnFactor = MakeAndRegisterFullFilename("BatterySizeImpact.xlsx", slice); XlsxDumper.WriteToXlsx(fnFactor, rc); SaveToPublicationDirectory(fnFactor, slice, "4.5"); }
private void WriteProfilesToExcel([NotNull] Profile temperaturProfile, [NotNull] Profile houseEnergy, [NotNull] Profile heatPumpEnergysupply, [NotNull] string file) { //dump to csv RowCollection rc = new RowCollection("sheet1", "Sheet1"); DateTime dt = new DateTime(2017, 1, 1); for (int i = 0; i < 35040; i++) { RowBuilder rb = RowBuilder.Start("Idx", i); rb.Add("Time", dt.ToShortDateString() + " " + dt.ToShortTimeString()); dt = dt.AddMinutes(15); rb.Add(temperaturProfile.Name, temperaturProfile.Values[i]); rb.Add(houseEnergy.Name, houseEnergy.Values[i]); rb.Add(heatPumpEnergysupply.Name, heatPumpEnergysupply.Values[i]); rc.Add(rb); } var fn = Path.Combine(Config.Directories.UnitTestingDirectory, nameof(HeatPumpTest), file); FileInfo fi = new FileInfo(fn); DirectoryInfo di = fi.Directory; if (di == null) { throw new FlaException("No path"); } if (!di.Exists) { di.Create(); } XlsxDumper.WriteToXlsx(fn, rc); Info("Wrote results to " + fn); Process.Start(di.FullName); }
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice) { if (!Services.RunningConfig.MakeHouseSums) { return; } var presentSums = GetEnergySumPerHouseForThePresent(); var energySums = GetPlannedEnergySumPerHouseForScenario(slice); var energyInProfiles = GetEnergyInProfiles(slice); RowCollection rc = new RowCollection("Comparison", "Comparison"); rc.ColumnsToSum.Add("Summe Gegenwart"); rc.ColumnsToSum.Add("Summe Haus Collection"); rc.ColumnsToSum.Add("Summe Profile"); rc.SumDivisionFactor = 1_000_000; presentSums.Sort((x, y) => y.Energy.CompareTo(x.Energy)); foreach (var presentSum in presentSums) { RowBuilder rb = RowBuilder.Start("Hausname", presentSum.HouseName); rb.Add("Summe Gegenwart", presentSum.Energy); rb.Add("Summe Haus Collection", energySums.Single(x => x.HouseName == presentSum.HouseName).Energy); var profile = energyInProfiles.FirstOrDefault(x => x.HouseName == presentSum.HouseName); if (profile != null) { rb.Add("Summe Profile", profile.Energy); } rc.Add(rb); } var fn = MakeAndRegisterFullFilename("EnergyComparison.xlsx", slice); XlsxDumper.WriteToXlsx(fn, rc); SaveToArchiveDirectory(fn, RelativeDirectory.Report, slice); }
protected override void RunActualProcess([NotNull] ScenarioSliceParameters parameters) { Services.SqlConnection.RecreateTable <HausAnschlussExportEntry>(Stage.ProfileExport, parameters); MyDb dbProfileExport = PrepareProfileExport(parameters); //prepare profile export //load previous data var dbProfileGeneration = LoadPreviousData(parameters, out var houses, out var households, out var businesses); //trafokreise var trafokreise = houses.SelectMany(x => x.Hausanschluss).Select(x => x.Trafokreis).Distinct().ToList(); //int trafokreiscount = 1; dbProfileGeneration.Database.BeginTransaction(); RowCollection rc = new RowCollection(); foreach (var trafokreis in trafokreise) { //prepare if (string.IsNullOrWhiteSpace(trafokreis)) { continue; } // if (trafokreiscount > 3) { // continue; //} // trafokreiscount++; //merge var houseExportEntries = MergeAllEntriesForTrafokreis(houses, dbProfileGeneration, trafokreis, households, businesses); //validate CheckHouseExportEntryIfAllHouseholdsAreCovered(households, houseExportEntries); //save var saLoad = Prosumer.GetSaveableEntry(dbProfileExport, TableType.HouseLoad); var saGeneration = Prosumer.GetSaveableEntry(dbProfileExport, TableType.HouseGeneration); foreach (var houseExportEntry in houseExportEntries) { var rb = RowBuilder.Start("Trafokreis", trafokreis); //load var ps = new Prosumer(houseExportEntry.HouseGuid, houseExportEntry.HouseName, ProsumerType.HouseLoad, houseExportEntry.HouseGuid, houseExportEntry.Isn, houseExportEntry.Trafokreis, houseExportEntry.GetSumProfile(HausAnschlussExportEntry.TypeOfSum.Load), houseExportEntry.HausanschlussGuid, houseExportEntry.HausAnschlussKeyString); double profileEnergy = ps.Profile?.EnergySum() ?? throw new Exception("Invalid profile"); rb.Add("Housename", houseExportEntry.HouseName) .Add("Load in Profile", profileEnergy).Add("Total Energy Load Planned", houseExportEntry.TotalEnergyLoad); if (Math.Abs(profileEnergy - houseExportEntry.TotalEnergyLoad) > 1) { throw new Exception("Wrong energy"); } saLoad.AddRow(ps); //generation if (houseExportEntry.TotalEnergyGeneration > 1) { var psGen = new Prosumer(houseExportEntry.HouseGuid, houseExportEntry.HouseName, ProsumerType.HouseLoad, houseExportEntry.HouseGuid, houseExportEntry.Isn, houseExportEntry.Trafokreis, houseExportEntry.GetSumProfile(HausAnschlussExportEntry.TypeOfSum.Generation), houseExportEntry.HausanschlussGuid, houseExportEntry.HausAnschlussKeyString); double profileEnergyGen = psGen.Profile?.EnergySum() ?? throw new Exception("Invalid profile"); if (Math.Abs(profileEnergyGen - houseExportEntry.TotalEnergyGeneration) > 1) { throw new Exception("Wrong energy"); } rb.Add("Generation Profile Energy", profileEnergyGen) .Add("Total Energy Generation Planned", houseExportEntry.TotalEnergyGeneration); saGeneration.AddRow(psGen); } dbProfileExport.Database.Save(houseExportEntry); rc.Add(rb); } saLoad.SaveDictionaryToDatabase(); if (saGeneration.RowEntries.Count > 0) { saGeneration.SaveDictionaryToDatabase(); } } var fnLoad = MakeAndRegisterFullFilename("MergedStuff.xlsx", Name, "", parameters); XlsxDumper.WriteToXlsx(rc, fnLoad, "ProsumersMerged"); }
protected override void RunActualProcess() { var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); var dbComplex = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Complexes, Constants.PresentSlice); dbHouses.RecreateTable <HouseHeating>(); var buildingcomplexes = dbComplex.Fetch <BuildingComplex>(); var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var energieBedarfsDatenBern = dbRaw.Fetch <EnergiebedarfsdatenBern>(); var houses = dbHouses.Fetch <House>(); var potentialHeatingSystems = dbHouses.Fetch <PotentialHeatingSystemEntry>(); RowCollection rc = new RowCollection("Heating", "Heizung"); dbHouses.BeginTransaction(); foreach (var h in houses) { RowBuilder rb = RowBuilder.Start("House", h.ComplexName); rc.Add(rb); var c = buildingcomplexes.First(x => x.ComplexID == h.ComplexID); var hs = potentialHeatingSystems.Where(x => x.HouseGuid == h.Guid).ToList(); var houseHeating = new HouseHeating { LocalnetFernwärmeEnergyUse = hs.Sum(x => x.YearlyFernwärmeDemand), LocalnetGasEnergyUse = hs.Sum(x => x.YearlyGasDemand), HouseGuid = h.Guid, LocalnetHeatingSystemEntryCount = hs.Count }; rb.Add("Fernwärme", houseHeating.LocalnetFernwärmeEnergyUse).Add("LocalnetEntries", hs.Count); rb.Add("Standort", string.Join(",", hs.Select(x => x.Standort).Distinct())); rb.Add("Gas", houseHeating.LocalnetGasEnergyUse); rb.Add("EBF", h.EnergieBezugsFläche); rb.Add("Abrechnung", JsonConvert.SerializeObject(hs, Formatting.Indented)); //collect ebbe daten foreach (var eGid in c.EGids) { var ebdbs = energieBedarfsDatenBern.Where(x => x.egid == eGid).ToList(); if (ebdbs.Count > 1) { throw new Exception("too many ebdb"); } if (ebdbs.Count == 1) { var eb = ebdbs[0]; houseHeating.KantonHeatingMethods.Add(GetHeatingMethodString((int)eb.upd_genhz)); houseHeating.KantonTotalEnergyDemand += eb.calc_ehzww; houseHeating.KantonHeizungEnergyDemand += eb.calc_ehz; houseHeating.KantonWarmwasserEnergyDemand += eb.calc_eww; houseHeating.KantonDhwMethods.Add(GetHeatingMethodString(eb.upd_genww)); } } houseHeating.LocalnetCombinedEnergyDemand = houseHeating.LocalnetFernwärmeEnergyUse + houseHeating.LocalnetGasEnergyUse; houseHeating.LocalnetHeatingEnergyDensity = houseHeating.LocalnetAdjustedHeatingDemand / h.EnergieBezugsFläche; if (houseHeating.LocalnetHeatingEnergyDensity > 500) { houseHeating.LocalnetHeatingEnergyDensity = 250; houseHeating.EnergyDensityIndustrialApplication = houseHeating.LocalnetHeatingEnergyDensity - 250; } houseHeating.KantonHeatingEnergyDensity = houseHeating.KantonTotalEnergyDemand / h.EnergieBezugsFläche; if (Math.Abs(houseHeating.LocalnetHeatingEnergyDensity) > 0.001) { houseHeating.HeatingEnergyDifference = houseHeating.LocalnetHeatingEnergyDensity - houseHeating.KantonHeatingEnergyDensity; if (double.IsNaN(houseHeating.HeatingEnergyDifference) || double.IsInfinity(houseHeating.HeatingEnergyDifference)) { houseHeating.HeatingEnergyDifference = 0; } } if (houseHeating.LocalnetHeatingEnergyDensity > 0) { houseHeating.MergedHeatingEnergyDensity = houseHeating.LocalnetHeatingEnergyDensity; } else { houseHeating.MergedHeatingEnergyDensity = houseHeating.KantonHeatingEnergyDensity; } if (houseHeating.MergedHeatingEnergyDensity < 0) { throw new Exception("Negative heating intensity"); } houseHeating.MergedHeatingDemand = 0; if (houseHeating.LocalnetCombinedEnergyDemand > 1) { houseHeating.MergedHeatingDemand = houseHeating.LocalnetCombinedEnergyDemand; } else { houseHeating.MergedHeatingDemand = houseHeating.KantonTotalEnergyDemand; } dbHouses.Save(h); dbHouses.Save(houseHeating); } dbHouses.CompleteTransaction(); var fn = MakeAndRegisterFullFilename("heatingCalcsDump.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess() { var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); dbHouse.RecreateTable <BusinessEntry>(); //load data var potentialBusinesses = dbHouse.Fetch <PotentialBusinessEntry>(); var hausanschlusses = dbHouse.Fetch <Hausanschluss>(); var houses = dbHouse.Fetch <House>(); var validIsns = houses.SelectMany(x => x.Hausanschluss.Select(y => y.Isn)).ToHashSet(); List <int> invalidIsns = new List <int>(); const int randomlyChosenHa = 0; const int reassignedHAs = 0; List <BusinessEntry> businesses = new List <BusinessEntry>(); dbHouse.BeginTransaction(); foreach (var pb in potentialBusinesses) { if ((pb.MyCategory == "Immobilien" || pb.MyCategory == "WEG") && pb.Standort != "Einschlagweg 59, Geschoss unbekannt, 3400 Burgdorf" && pb.Standort != "Fabrikweg 6, Geschoss unbekannt, 3400 Burgdorf") { if (pb.HighVoltageYearlyElectricityUse > 0) { throw new FlaException("Building infrastructure with MS?"); } var pbi = new PotentialBuildingInfrastructure(pb.HouseGuid, pb.BusinessName, pb.LowVoltageYearlyElectricityUse, pb.HighVoltageYearlyElectricityUse, pb.LowVoltageLocalnetEntries, pb.HighVoltageLocalnetEntries, pb.Standort, Guid.NewGuid().ToString()); dbHouse.Save(pbi); } else { BusinessType bt = GetTypeFromDescription(pb.MyCategory); var be = new BusinessEntry(pb, bt); be.HouseComponentType = HouseComponentType.BusinessNoLastgangLowVoltage; //var hasIndustry = false; /*if (pb.LowVoltageLocalnetEntries.Any(x => x.Rechnungsart == "Industrie") || * pb.HighVoltageLocalnetEntries.Any(x => x.Rechnungsart == "Industrie")) { * hasIndustry = true; * }*/ /* if (hasIndustry) { * be.BusinessType = BusinessType.Industrie; * } * else { * ; * }*/ //isn kontrolle int validisn = 0; foreach (int hhIsn in be.OriginalISNs) { if (!validIsns.Contains(hhIsn)) { invalidIsns.Add(hhIsn); } else { validisn = hhIsn; } } var house = houses.Single(x => x.Guid == be.HouseGuid); if (validisn == 0) { be.FinalIsn = house.Hausanschluss[0].Isn; } else { be.FinalIsn = validisn; } var ha = hausanschlusses.Single(x => x.Guid == pb.HausAnschlussGuid); if (ha == null) { throw new FlaException("ha was null"); } /* hausanschlusses.Where(x => x.HouseGuid == be.HouseGuid && x.Isn == be.FinalIsn).ToList(); * if (ha.Count == 0) * { * //throw new FlaException("Kein Hausanschluss gefunden."); * reassignedHAs++; * be.HausAnschlussGuid = house.Hausanschluss[0].HausanschlussGuid; * } * * if (ha.Count == 1) * { * be.HausAnschlussGuid = ha[0].HausanschlussGuid; * } * * if (ha.Count > 1) * { * randomlyChosenHa++; * be.HausAnschlussGuid = ha[Services.Rnd.Next(ha.Count)].HausanschlussGuid; * //throw new FlaException("zu viele Hausanschlüsse gefunden.: " + ha.Count); * }*/ be.HausAnschlussGuid = pb.HausAnschlussGuid; businesses.Add(be); } } dbHouse.CompleteTransaction(); AssignRlmProfiles(businesses, houses); foreach (var businessEntry in businesses) { if (businessEntry.LocalnetHighVoltageYearlyTotalElectricityUse > 0) { if (businessEntry.HouseComponentType == HouseComponentType.BusinessNoLastgangLowVoltage) { businessEntry.HouseComponentType = HouseComponentType.BusinessNoLastgangHighVoltage; } else if (businessEntry.HouseComponentType == HouseComponentType.BusinessWithLastgangLowVoltage) { businessEntry.HouseComponentType = HouseComponentType.BusinessWithLastgangHighVoltage; } } } Debug("Invalid Isns: " + invalidIsns.Distinct().Count()); Debug("Zufällig ausgewählte Hausanschlüsse bei Häusern mit mehr als einem HA: " + randomlyChosenHa); Debug("Wohnungen mit neuem Hausanschluss wegen nicht gefundener ISN: " + reassignedHAs); int normalBusinesses = businesses.Count(x => x.HouseComponentType == HouseComponentType.BusinessNoLastgangLowVoltage); int rlmBusinesses = businesses.Count(x => x.HouseComponentType == HouseComponentType.BusinessWithLastgangLowVoltage); Debug("Businesses without rlm:" + normalBusinesses + " with: " + rlmBusinesses); dbHouse.BeginTransaction(); foreach (BusinessEntry entry in businesses) { dbHouse.Save(entry); } dbHouse.CompleteTransaction(); RowCollection rc = new RowCollection("Businesses", ""); foreach (var entry in businesses) { RowBuilder rb = RowBuilder.Start("Name", entry.BusinessName); rb.Add("Verbrauchstyp", entry.EnergyType); rb.Add("Verbrauch", entry.EffectiveEnergyDemand); rb.Add("Businesstype", entry.BusinessType.ToString()); rc.Add(rb); } var fn = MakeAndRegisterFullFilename("Businesses.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess() { var dbComplex = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Complexes, Constants.PresentSlice); //var dbRaw = SqlConnection.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var buildingcomplexes = dbComplex.Fetch <BuildingComplex>(); var dbComplexEnergy = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ComplexEnergyData, Constants.PresentSlice); var complexdata = dbComplexEnergy.Fetch <ComplexBuildingData>(); var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); dbHouse.RecreateTable <House>(); dbHouse.RecreateTable <PotentialHousehold>(); //var sonnendach = dbRaw.Fetch<SonnenDach>(); dbHouse.BeginTransaction(); List <string> complexesToIgnore = new List <string> { "EGID191357110", "EGID1306724", "EGID1305755", "Fischermätteliweg nn" }; //complexesToIgnore.Add("Bernstrasse 113a"); //complexesToIgnore.Add("Finkhubelweg 8"); //complexesToIgnore.Add("Friedhof 4"); var manualCoordinates = ReadManualCoordinatesList(); foreach (var complex in buildingcomplexes) { if (complexesToIgnore.Contains(complex.ComplexName)) { continue; } //haus anlegen var h = new House(complex.ComplexName, complex.ComplexGuid, Guid.NewGuid().ToString() ) { ComplexID = complex.ComplexID, }; // ReSharper disable once ConditionIsAlwaysTrueOrFalse // ReSharper disable once HeuristicUnreachableCode if (h.Guid == null) { // ReSharper disable once HeuristicUnreachableCode throw new Exception("House guid was null"); } // ReSharper disable once ConditionIsAlwaysTrueOrFalse // ReSharper disable once HeuristicUnreachableCode if (h.ComplexGuid == null) { // ReSharper disable once HeuristicUnreachableCode throw new Exception("Complex guid was null"); } //gebäudeobjektids zuordnen foreach (var complexGebäudeObjectID in complex.GebäudeObjectIDs) { h.GebäudeObjectIDs.Add(complexGebäudeObjectID); } // egids zuordnen foreach (var eGid in complex.EGids) { h.EGIDs.Add((int)eGid); } //geo coords zuordnen foreach (var coord in complex.Coords) { h.WgsGwrCoords.Add(WgsPoint.ConvertKoordsToLonLat(coord.X, coord.Y)); } var manualCoord = manualCoordinates.Where(x => x.Name == h.ComplexName).ToList(); if (manualCoord.Any()) { foreach (var manualComplexCoordinatese in manualCoord) { h.WgsGwrCoords.Add(new WgsPoint(manualComplexCoordinatese.Lon, manualComplexCoordinatese.Lat)); } } foreach (var coord in complex.LocalnetCoords) { h.LocalWgsPoints.Add(WgsPoint.ConvertKoordsToLonLat(coord.X, coord.Y)); } //addressen zuordnen if (complex.Adresses.Count == 0) { h.Adress = "Unknown"; } else { h.Adress = complex.Adresses[0]; } if (complex.TrafoKreise.Count > 0) { foreach (var erzId in complex.ErzeugerIDs) { h.ErzeugerIDs.Add(erzId); } } //assign household data var thiscomplexdata = complexdata.FirstOrDefault(x => x.ComplexName == complex.ComplexName); if (thiscomplexdata == null) { h.Area = 0; h.Appartments.Add(new AppartmentEntry(Guid.NewGuid().ToString(), 0, false, Constants.PresentSlice.DstYear)); } else { if (thiscomplexdata.AnzahlWohnungenBern > 0) { double avgArea = thiscomplexdata.TotalEnergieBezugsfläche / thiscomplexdata.AnzahlWohnungenBern; for (int i = 0; i < thiscomplexdata.AnzahlWohnungenBern; i++) { h.Appartments.Add(new AppartmentEntry(Guid.NewGuid().ToString(), avgArea, true, Constants.PresentSlice.DstYear)); } } else { h.Appartments.Add(new AppartmentEntry(Guid.NewGuid().ToString(), thiscomplexdata.TotalEnergieBezugsfläche, false, Constants.PresentSlice.DstYear)); } h.Area += thiscomplexdata.TotalArea; h.AverageBuildingAge = thiscomplexdata.BuildingAges.Average(); } dbHouse.Save(h); } dbHouse.CompleteTransaction(); var allHouses = dbHouse.FetchAsRepo <House>(); RowCollection rc = new RowCollection("houses", "houses"); foreach (var house in allHouses) { RowBuilder rb = RowBuilder.Start("age", house.AverageBuildingAge); rc.Add(rb); } var fn = MakeAndRegisterFullFilename("HouseAges.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice) { var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSliceNotNull); var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice); dbDstHouses.RecreateTable <PvSystemEntry>(); dbDstHouses.RecreateTable <PVPotential>(); var srcHouses = dbSrcHouses.Fetch <House>(); var srcPVPotentials = dbSrcHouses.Fetch <PVPotential>(); var srcPvSystemEntries = dbSrcHouses.Fetch <PvSystemEntry>(); var hausanschlusses = dbDstHouses.Fetch <Hausanschluss>(); dbDstHouses.BeginTransaction(); foreach (var potential in srcPVPotentials) { potential.ID = 0; dbDstHouses.Save(potential); } //copy pv systems from previous slice HashSet <string> houseGuidsForSystemsWithPV = new HashSet <string>(); Dictionary <string, double> pvPotentialByHouseGuid = new Dictionary <string, double>(); foreach (var pvpot in srcPVPotentials) { if (!houseGuidsForSystemsWithPV.Contains(pvpot.HouseGuid)) { houseGuidsForSystemsWithPV.Add(pvpot.HouseGuid); pvPotentialByHouseGuid.Add(pvpot.HouseGuid, 0); } pvPotentialByHouseGuid[pvpot.HouseGuid] += pvpot.SonnendachStromErtrag; } var potentialhousesForPvSystems = srcHouses.Where(x => houseGuidsForSystemsWithPV.Contains(x.Guid)).ToList(); foreach (var entry in srcPvSystemEntries) { var toremove = potentialhousesForPvSystems.FirstOrDefault(x => x.Guid == entry.HouseGuid); if (toremove != null) { potentialhousesForPvSystems.Remove(toremove); } if (entry.PVAreas.Count == 0) { throw new FlaException("No PV System areas defined."); } entry.ID = 0; dbDstHouses.Save(entry); } var pvToInstallInkWh = slice.PvPowerToInstallInGwh * 1_000_000; bool continueAllocation = true; int pvSystemCount = 0; while (pvToInstallInkWh > 0 && continueAllocation) { //make ranges var rangeEntries = SetRanges(potentialhousesForPvSystems, pvPotentialByHouseGuid); if (rangeEntries.Count == 0) { continueAllocation = false; continue; } //randomly pick var max = rangeEntries.Max(x => x.EndRange); var pick = Services.Rnd.NextDouble() * max; var rangeEntry = rangeEntries.Single(x => pick >= x.StartRange && pick <= x.EndRange); //remove house potentialhousesForPvSystems.Remove(rangeEntry.House); //save pvsystementry var pvPotenial = pvPotentialByHouseGuid[rangeEntry.House.Guid]; pvSystemCount++; string erzeugerid = "PV-" + slice.DstYear + "-" + pvSystemCount; var hausanschlsus = rangeEntry.House.GetHausanschlussByIsn(new List <int>(), erzeugerid, hausanschlusses, MyLogger) ?? throw new FlaException("no hausanschluss"); if (hausanschlsus.ObjectID.ToLower().Contains("leuchte")) { throw new FlaException("pv an leuchte in " + slice.DstYear + " " + hausanschlsus.ObjectID); } var pvSystemEntry = new PvSystemEntry(rangeEntry.House.Guid, Guid.NewGuid().ToString(), hausanschlsus.Guid, rangeEntry.House.ComplexName, erzeugerid, slice.DstYear) { EffectiveEnergyDemand = pvPotenial }; var areas = srcPVPotentials.Where(x => x.HouseGuid == rangeEntry.House.Guid).ToList(); foreach (var area in areas) { pvSystemEntry.PVAreas.Add(new PVSystemArea(area.Ausrichtung, area.Neigung, area.SonnendachStromErtrag)); } if (pvSystemEntry.PVAreas.Count == 0) { throw new FlaException("No PV System areas defined."); } pvToInstallInkWh -= pvSystemEntry.EffectiveEnergyDemand; pvSystemEntry.BuildYear = slice.DstYear; dbDstHouses.Save(pvSystemEntry); //deduct from pvtoinstall } dbDstHouses.CompleteTransaction(); var newPVs = dbDstHouses.FetchAsRepo <PvSystemEntry>(); RowCollection rc = new RowCollection("pv", "pv"); foreach (var pv in newPVs) { foreach (var area in pv.PVAreas) { RowBuilder rb = RowBuilder.Start("HA", pv.HausAnschlussGuid); rc.Add(rb); rb.Add("Azimut", area.Azimut); rb.Add("Tilt", area.Tilt); rb.Add("Energy", area.Energy); } } var fn = MakeAndRegisterFullFilename("PVExport.xlsx", slice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice) { var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSliceNotNull); var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice); dbDstHouses.RecreateTable <HeatingSystemEntry>(); var srcHeatingSystems = dbSrcHouses.Fetch <HeatingSystemEntry>(); var srcHouses = dbSrcHouses.Fetch <House>(); var dstHouses = dbDstHouses.FetchAsRepo <House>(); if (srcHeatingSystems.Count == 0) { throw new FlaException("No heating systems were found"); } double totalHeatingDemand = srcHeatingSystems.Sum(x => x.HeatDemand); double totalEbf = srcHouses.Sum(x => x.EnergieBezugsFläche); double averageEnergyIntensityForNewAppartments = totalHeatingDemand / totalEbf * 0.5; //add heating demand from new appartments foreach (var hse in srcHeatingSystems) { var house = dstHouses.GetByGuid(hse.HouseGuid); foreach (var expansion in house.Appartments) { var hseExpansion = hse.HeatDemands.FirstOrDefault(x => x.HouseExpansionGuid == expansion.Guid); if (hseExpansion == null) { AppartmentHeatingDemand hsex = new AppartmentHeatingDemand(expansion.Guid, expansion.EnergieBezugsFläche, averageEnergyIntensityForNewAppartments * expansion.EnergieBezugsFläche, slice.DstYear); hse.HeatDemands.Add(hsex); } } } var dstHousesByGuid = dstHouses.ToDictionary(x => x.Guid, x => x); DumpHeatingSystemsToXlsx(slice, srcHeatingSystems, dstHousesByGuid); //building renovations WeightedRandomAllocator <HeatingSystemEntry> wra = new WeightedRandomAllocator <HeatingSystemEntry>(Services.Rnd, MyLogger); var potentialRenovationHeatingSystems = srcHeatingSystems .Where(x => x.Age > 10 && x.HeatDemand > 0 && Math.Abs(x.HeatDemand - x.OriginalHeatDemand2017) < 0.1).ToList(); if (potentialRenovationHeatingSystems.Count == 0) { throw new FlaException("Not a single heating system found"); } double averageRenovationFactor = slice.AverageHouseRenovationFactor; if (Math.Abs(averageRenovationFactor) < 0.000001) { throw new FlaException("Renovation factor was 0 for scenario " + slice); } int numberOfBuildingRenovations = (int)(slice.RenovationRatePercentage * srcHouses.Count); Info("renovating houses, target number " + numberOfBuildingRenovations + " GWh, renovation factor " + averageRenovationFactor); bool failOnOversubscribe = slice.DstYear != 2050; var systemsToRenovate = wra.PickNumberOfObjects(potentialRenovationHeatingSystems, WeighingFunctionForRenovation, numberOfBuildingRenovations, failOnOversubscribe); Info("Renovating " + systemsToRenovate.Count + " houses with a total heat demand of " + systemsToRenovate.Sum(x => x.HeatDemand)); foreach (var entry in systemsToRenovate) { entry.RenovateAllHeatDemand(averageRenovationFactor); } //change heating systems var changeableHeatingSystems = srcHeatingSystems.ToList(); int elapsedTime = slice.DstYear - slice.PreviousSliceNotNull.DstYear; foreach (var heatingSystemEntry in srcHeatingSystems) { heatingSystemEntry.Age += elapsedTime; } int yearsToAge = slice.DstYear - slice.PreviousSliceNotNull.DstYear; RowCollection rc = new RowCollection("Changes", "Changes"); double totalOilHeatDemand2017 = changeableHeatingSystems.Where(x => x.HeatingSystemType2017 == HeatingSystemType.Öl) .Sum(x => x.OriginalHeatDemand2017); double oilenergyAmountToChange = totalOilHeatDemand2017 * slice.Energy2017PercentageFromOilToHeatpump; ChangeHeatingSystemsForOneType(slice, changeableHeatingSystems, HeatingSystemType.Öl, oilenergyAmountToChange, rc, dstHousesByGuid); double totalGasHeatDemand2017 = changeableHeatingSystems.Where(x => x.HeatingSystemType2017 == HeatingSystemType.Gas) .Sum(x => x.OriginalHeatDemand2017); double gasEnergyAmountToChange = totalGasHeatDemand2017 * slice.Energy2017PercentageFromGasToHeatpump; ChangeHeatingSystemsForOneType(slice, changeableHeatingSystems, HeatingSystemType.Gas, gasEnergyAmountToChange, rc, dstHousesByGuid); double totalOtherHeatDemand = changeableHeatingSystems.Where(x => x.HeatingSystemType2017 == HeatingSystemType.Other) .Sum(x => x.OriginalHeatDemand2017); double otherDemandToChange = slice.Energy2017PercentageFromOtherToHeatpump * totalOtherHeatDemand; ChangeHeatingSystemsForOneType(slice, changeableHeatingSystems, HeatingSystemType.Other, otherDemandToChange, rc, dstHousesByGuid); var fn = MakeAndRegisterFullFilename("HeatingChangeLog.xlsx", slice); if (rc.Rows.Count > 0) { XlsxDumper.WriteToXlsx(fn, rc); } dbDstHouses.BeginTransaction(); foreach (HeatingSystemEntry heatingSystemEntry in srcHeatingSystems) { heatingSystemEntry.Age += yearsToAge; heatingSystemEntry.ID = 0; dbDstHouses.Save(heatingSystemEntry); } dbDstHouses.CompleteTransaction(); var srcHouseGuids = srcHouses.Select(x => x.Guid).ToHashSet(); var dstHouseGuids = dstHouses.Select(x => x.Guid).ToHashSet(); foreach (var heatingSystem in srcHeatingSystems) { srcHouseGuids.Should().Contain(heatingSystem.HouseGuid); dstHouseGuids.Should().Contain(heatingSystem.HouseGuid); } }
public void DumpToExcel([NotNull] string dstPath, XlsResultOutputMode mode) { RowCollection rc = new RowCollection("GeneratedLoadProfiles", "GeneratedLoadProfiles"); if (mode == XlsResultOutputMode.ByTrafoStationTree) { var trafostationen = Houses.SelectMany(x => x.HausAnschlussList).Select(y => y.Trafokreis).Distinct().ToList(); foreach (var trafostation in trafostationen) { rc.Add(RowBuilder.Start("Trafostation", trafostation)); foreach (var houseRo in Houses) { if (houseRo.HausAnschlussList.Any(x => x.Trafokreis == trafostation)) { rc.Add(houseRo.ToRowBuilder()); foreach (HausAnschlussRo hausAnschlussRo in houseRo.HausAnschlussList) { if (hausAnschlussRo.Trafokreis == trafostation) { rc.Add(hausAnschlussRo.ToRowBuilder(houseRo, mode)); foreach (HouseComponentRo component in hausAnschlussRo.HouseComponents) { rc.Add(component.ToRowBuilder(houseRo, hausAnschlussRo, mode)); } } } } } } } else if (mode == XlsResultOutputMode.ByTrafoStationHausanschlussTree) { var trafostationen = Houses.SelectMany(x => x.HausAnschlussList).Select(y => y.Trafokreis).Distinct().ToList(); var haros = Houses.SelectMany(x => x.HausAnschlussList).Distinct().ToList(); haros.Sort((x, y) => String.Compare(x.ObjektID, y.ObjektID, StringComparison.Ordinal)); foreach (var trafostation in trafostationen) { rc.Add(RowBuilder.Start("Trafostation", trafostation)); var filteredHaros = haros.Where(x => x.Trafokreis == trafostation); foreach (var anschlussRo in filteredHaros) { rc.Add(anschlussRo.ToRowBuilder(null, XlsResultOutputMode.ByTrafoStationHausanschlussTree)); var housesForAnschluss = Houses.Where(x => x.HausAnschlussList.Contains(anschlussRo)).ToList(); foreach (var houseRo in housesForAnschluss) { rc.Add(houseRo.ToRowBuilder()); foreach (HouseComponentRo component in anschlussRo.HouseComponents) { rc.Add(component.ToRowBuilder(houseRo, anschlussRo, mode)); } } } } } else { foreach (HouseRo house in Houses) { if (mode == XlsResultOutputMode.Tree) { rc.Add(house.ToRowBuilder()); } foreach (var anschlussRo in house.HausAnschlussList) { if (mode == XlsResultOutputMode.Tree) { rc.Add(anschlussRo.ToRowBuilder(house, mode)); } foreach (var component in anschlussRo.HouseComponents) { rc.Add(component.ToRowBuilder(house, anschlussRo, mode)); } } } } XlsxDumper.WriteToXlsx(dstPath, rc); }
protected override void RunChartMaking() { var slice = Constants.PresentSlice; //var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); var ap = new AnalysisRepository(Services.RunningConfig); var dbHouse = ap.GetSlice(Constants.PresentSlice); var houses = dbHouse.Fetch <House>(); var houseTypeEntries = dbHouse.Fetch <HouseTypeEntry>(); MakeHouseTypeEntries(); MakeHouseTypeMap(); MakeEnergyUseXls(); void MakeEnergyUseXls() { var households = dbHouse.Fetch <Household>(); var businesses = dbHouse.Fetch <BusinessEntry>(); var infra = dbHouse.Fetch <BuildingInfrastructure>(); var light = dbHouse.Fetch <StreetLightingEntry>(); var dhw = dbHouse.Fetch <DHWHeaterEntry>(); var rc = new RowCollection("energy", "energy"); RowBuilder rb = RowBuilder.Start("Haushalte", households.Sum(x => x.EffectiveEnergyDemand) / Constants.GWhFactor); var bigcustomers = businesses.Where(x => x.EffectiveEnergyDemand > 20000); var small = businesses.Where(x => x.EffectiveEnergyDemand <= 20000); rb.Add("Geschäftskunden > 20 MWh", bigcustomers.Sum(x => x.EffectiveEnergyDemand) / Constants.GWhFactor); rb.Add("Geschäftskunden < 20 MWh", small.Sum(x => x.EffectiveEnergyDemand) / Constants.GWhFactor); rb.Add("Gebäudeinfrastruktur", infra.Sum(x => x.EffectiveEnergyDemand) / Constants.GWhFactor); rb.Add("Strassenbeleuchtung", light.Sum(x => x.YearlyElectricityUse) / Constants.GWhFactor); rb.Add("Elektroboiler", dhw.Sum(x => x.EffectiveEnergyDemand) / Constants.GWhFactor); rc.Add(rb); var fn = MakeAndRegisterFullFilename("EnergyTreeMap.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); SaveToPublicationDirectory(fn, Constants.PresentSlice, "4.2"); } void MakeHouseTypeEntries() { var ssa = new SingleSankeyArrow("HouseTypeEntries", 1500, MyStage, SequenceNumber, Name, slice, Services); ssa.AddEntry(new SankeyEntry("Houses", houses.Count, 5000, Orientation.Straight)); var countsPerType = new Dictionary <HouseType, int>(); foreach (var entry in houseTypeEntries) { if (!countsPerType.ContainsKey(entry.HouseType)) { countsPerType.Add(entry.HouseType, 0); } countsPerType[entry.HouseType]++; } foreach (var pair in countsPerType) { ssa.AddEntry(new SankeyEntry(pair.Key.ToString(), pair.Value * -1, 2000, Orientation.Up)); } Services.PlotMaker.MakeSankeyChart(ssa); } void MakeHouseTypeMap() { var rgbs = new Dictionary <HouseType, RGB>(); var hs = houseTypeEntries.Select(x => x.HouseType).Distinct().ToList(); var idx = 0; foreach (var type in hs) { var rgb = ColorGenerator.GetRGB(idx++); if (rgb.R == 255 && rgb.B == 255 && rgb.G == 255) { rgb = new RGB(200, 200, 200); } if (rgb.R == 255 && rgb.B == 0 && rgb.G == 0) { rgb = Constants.Orange; } rgbs.Add(type, rgb); } RGB GetColor(House h) { var hse = houseTypeEntries.Single(x => x.HouseGuid == h.Guid); return(rgbs[hse.HouseType]); } var mapPoints = houses.Select(x => x.GetMapColorForHouse(GetColor)).ToList(); var filename = MakeAndRegisterFullFilename("HouseTypeMap.png", slice); var legendEntries = new List <MapLegendEntry>(); foreach (var pair in rgbs) { legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value)); } Services.PlotMaker.MakeOsmMap(Name, filename, mapPoints, new List <WgsPoint>(), legendEntries, new List <LineEntry>()); } }
protected override void MakeVisualization([NotNull] ScenarioSliceParameters slice, bool isPresent) { var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice); List <House> houses1 = dbHouse.Fetch <House>(); var heatingsystems1 = dbHouse.Fetch <HeatingSystemEntry>(); Dictionary <string, HeatingSystemEntry> heatingsystemsByGuid = new Dictionary <string, HeatingSystemEntry>(); foreach (var hse in heatingsystems1) { heatingsystemsByGuid.Add(hse.HouseGuid, hse); } MakeHeatingSystemAnalysis(); EnergyIntensityHistogram(); MakeHeatingTypeIntensityMap(); MakeHeatingTypeMap(); MakeHeatingSystemSankey(); HeatingSystemCountHistogram(); MakeHeatingSystemMapError(); MakeHeatingSystemMap(); MakeFernwärmeTypeMap(); if (isPresent) { PresentOnlyVisualisations(heatingsystemsByGuid, slice, houses1, dbHouse); } void MakeHeatingSystemAnalysis() { var filename = MakeAndRegisterFullFilename("analysis.csv", slice); var sw = new StreamWriter(filename); sw.WriteLine("Original Heating system - Anzahl"); foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType))) { var fs1 = heatingsystems1.Where(x => x.OriginalHeatingSystemType == hst).ToList(); sw.WriteLine(hst + ";" + fs1.Count); } sw.WriteLine(""); sw.WriteLine(""); sw.WriteLine("Original Heating system - Summe"); foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType))) { var fs1 = heatingsystems1.Where(x => x.OriginalHeatingSystemType == hst).ToList(); sw.WriteLine(hst + ";" + fs1.Sum(x => x.EffectiveEnergyDemand)); } sw.WriteLine(""); sw.WriteLine(""); sw.WriteLine("Target Anzahl"); foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType))) { var fs1 = heatingsystems1.Where(x => x.SynthesizedHeatingSystemType == hst).ToList(); sw.WriteLine(hst + ";" + fs1.Count); } sw.WriteLine(""); sw.WriteLine(""); sw.WriteLine("Target Summe"); foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType))) { var fs1 = heatingsystems1.Where(x => x.SynthesizedHeatingSystemType == hst).ToList(); sw.WriteLine(hst + ";" + fs1.Sum(x => x.EffectiveEnergyDemand)); } sw.Close(); } void EnergyIntensityHistogram() { var filename = MakeAndRegisterFullFilename("EnergyIntensityHistogram.png", slice); var ages = heatingsystems1.Select(x => x.CalculatedAverageHeatingEnergyDemandDensity).Where(y => y > 0).ToList(); var barSeries = new List <BarSeriesEntry>(); var h = new Histogram(ages, 100); barSeries.Add(BarSeriesEntry.MakeBarSeriesEntry(h, out var colnames, "F0")); Services.PlotMaker.MakeBarChart(filename, "EnergyIntensityHistogram", barSeries, colnames); var xlsfilename = MakeAndRegisterFullFilename("EnergyIntensity.xlsx", slice); var heatingSystems = heatingsystems1.Where(y => y.CalculatedAverageHeatingEnergyDemandDensityWithNulls != null).ToList(); var rbDict = new Dictionary <string, RowBuilder>(); foreach (var hs in heatingSystems) { int bucket = (int)(Math.Floor(hs.CalculatedAverageHeatingEnergyDemandDensityWithNulls / 50 ?? 0) * 50); string key = bucket.ToString(); string et = hs.EnergyType.ToString(); RowBuilder rb; if (rbDict.ContainsKey(key)) { rb = rbDict[key]; } else { rb = RowBuilder.Start("Energieträger", key); rbDict.Add(key, rb); } rb.AddToPossiblyExisting(et, 1); } RowCollection rc = new RowCollection("energy", "energy"); foreach (var builder in rbDict) { rc.Add(builder.Value); } RowCollection rc2 = new RowCollection("raw", "raw"); foreach (var heatingSystemEntry in heatingsystems1) { RowBuilder rb = RowBuilder.Start("Träger", heatingSystemEntry.EnergyType) .Add("Effektiv", heatingSystemEntry.EffectiveEnergyDemand) .Add("EBF", heatingSystemEntry.Ebf); rc2.Add(rb); } XlsxDumper.WriteToXlsx(xlsfilename, rc, rc2); } void MakeHeatingSystemSankey() { var ssa1 = new SingleSankeyArrow("HouseHeatingSystems", 1500, MyStage, SequenceNumber, Name, slice, Services); ssa1.AddEntry(new SankeyEntry("Houses", houses1.Count, 5000, Orientation.Straight)); var ssa2 = new SingleSankeyArrow("EnergyBySystems", 1500, MyStage, SequenceNumber, Name, slice, Services); ssa2.AddEntry(new SankeyEntry("Houses", heatingsystems1.Sum(x => x.EffectiveEnergyDemand) / 1000000, 5000, Orientation.Straight)); var counts = new Dictionary <HeatingSystemType, int>(); var energy = new Dictionary <HeatingSystemType, double>(); foreach (var entry in heatingsystems1) { if (!counts.ContainsKey(entry.SynthesizedHeatingSystemType)) { counts.Add(entry.SynthesizedHeatingSystemType, 0); energy.Add(entry.SynthesizedHeatingSystemType, 0); } counts[entry.SynthesizedHeatingSystemType]++; energy[entry.SynthesizedHeatingSystemType] += entry.EffectiveEnergyDemand; } var i = 1; foreach (var pair in counts) { ssa1.AddEntry(new SankeyEntry(pair.Key.ToString(), pair.Value * -1, 2000 * i, Orientation.Up)); i++; } i = 1; foreach (var pair in energy) { ssa2.AddEntry(new SankeyEntry(pair.Key.ToString(), pair.Value * -1 / 1000000, 2000 * i, Orientation.Up)); i++; } Services.PlotMaker.MakeSankeyChart(ssa1); Services.PlotMaker.MakeSankeyChart(ssa2); } void HeatingSystemCountHistogram() { var counts = new Dictionary <HeatingSystemType, int>(); foreach (var entry in heatingsystems1) { if (!counts.ContainsKey(entry.SynthesizedHeatingSystemType)) { counts.Add(entry.SynthesizedHeatingSystemType, 0); } counts[entry.SynthesizedHeatingSystemType]++; } var filename = MakeAndRegisterFullFilename("HeatingSystemHistogram.png", slice); var names = new List <string>(); var barSeries = new List <BarSeriesEntry>(); var column = 0; foreach (var pair in counts) { names.Add(pair.Value.ToString()); var count = pair.Value; barSeries.Add(BarSeriesEntry.MakeBarSeriesEntry(pair.Key.ToString(), count, column)); column++; } Services.PlotMaker.MakeBarChart(filename, "HeatingSystemHistogram", barSeries, names); } void MakeHeatingSystemMapError() { RGB GetColor(House h) { var hse = heatingsystemsByGuid[h.Guid]; if (hse.OriginalHeatingSystemType == HeatingSystemType.Fernwärme) { return(Constants.Red); } if (hse.OriginalHeatingSystemType == HeatingSystemType.Gas) { return(Constants.Orange); } if (hse.OriginalHeatingSystemType == HeatingSystemType.FeuerungsstättenGas) { return(Constants.Orange); } return(Constants.Black); } var mapPoints = houses1.Select(x => x.GetMapPoint(GetColor)).ToList(); var filename = MakeAndRegisterFullFilename("KantonHeatingSystemErrors.svg", slice); var legendEntries = new List <MapLegendEntry> { new MapLegendEntry("Kanton Fernwärme", Constants.Red), new MapLegendEntry("Kanton Gas", Constants.Orange) }; Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries); } void MakeHeatingSystemMap() { var rgbs = new Dictionary <HeatingSystemType, RGB>(); var hs = heatingsystems1.Select(x => x.SynthesizedHeatingSystemType).Distinct().ToList(); var idx = 0; foreach (var type in hs) { rgbs.Add(type, ColorGenerator.GetRGB(idx++)); } RGB GetColor(House h) { var hse = heatingsystemsByGuid[h.Guid]; return(rgbs[hse.SynthesizedHeatingSystemType]); } var mapPoints = houses1.Select(x => x.GetMapPoint(GetColor)).ToList(); var filename = MakeAndRegisterFullFilename("HeatingSystemMap.svg", slice); var legendEntries = new List <MapLegendEntry>(); foreach (var pair in rgbs) { legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value)); } Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries); } void MakeHeatingTypeMap() { var maxEnergy = heatingsystems1.Max(x => x.EffectiveEnergyDemand); var colorsByHeatingSystem = new Dictionary <HeatingSystemType, RGB> { { HeatingSystemType.Gas, Constants.Orange }, { HeatingSystemType.Öl, Constants.Black }, { HeatingSystemType.Electricity, Constants.Green }, { HeatingSystemType.Heatpump, Constants.Green }, { HeatingSystemType.Fernwärme, Constants.Blue }, { HeatingSystemType.Other, Constants.Türkis }, { HeatingSystemType.None, Constants.Yellow } }; RGBWithSize GetColorWithSize(House h) { var s = heatingsystemsByGuid[h.Guid]; var energy = Math.Log(s.EffectiveEnergyDemand / maxEnergy * 100) * 50; if (energy < 10) { energy = 10; } if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType)) { throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType); } var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType]; return(new RGBWithSize(rgb.R, rgb.G, rgb.B, (int)energy)); } RGB GetColor(House h) { var s = heatingsystemsByGuid[h.Guid]; if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType)) { throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType); } var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType]; return(new RGB(rgb.R, rgb.G, rgb.B)); } var mapPoints = houses1.Select(x => x.GetMapPointWithSize(GetColorWithSize)).ToList(); var filename = MakeAndRegisterFullFilename("MapHeatingTypeAndSystemPerHousehold.svg", slice); var legendEntries = new List <MapLegendEntry>(); foreach (var pair in colorsByHeatingSystem) { legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value)); } Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries); var filenameOsm = MakeAndRegisterFullFilename("MapHeatingTypeAndSystemPerHouseholdOsm.png", slice); legendEntries.Add(new MapLegendEntry("Nicht Stadtgebiet", Constants.Red)); var mceh = houses1.Select(x => x.GetMapColorForHouse(GetColor)).ToList(); Services.PlotMaker.MakeOsmMap("HeatingTypeMap", filenameOsm, mceh, new List <WgsPoint>(), legendEntries, new List <LineEntry>()); } void MakeFernwärmeTypeMap() { RGBWithLabel GetColor(House h) { var s = heatingsystemsByGuid[h.Guid]; if (s.SynthesizedHeatingSystemType == HeatingSystemType.Fernwärme) { return(new RGBWithLabel(Constants.Green, "")); } return(new RGBWithLabel(Constants.Blue, "")); //h.ComplexName } var legendEntries = new List <MapLegendEntry>(); var filenameOsm = MakeAndRegisterFullFilename("FernwärmeOSM.png", slice); legendEntries.Add(new MapLegendEntry("Nicht Stadtgebiet", Constants.Red)); legendEntries.Add(new MapLegendEntry("Nicht Fernwärme", Constants.Blue)); legendEntries.Add(new MapLegendEntry("Fernwärme", Constants.Green)); var mceh = houses1.Select(x => x.GetMapColorForHouse(GetColor)).ToList(); Services.PlotMaker.MakeOsmMap("HeatingTypeMap", filenameOsm, mceh, new List <WgsPoint>(), legendEntries, new List <LineEntry>()); } void MakeHeatingTypeIntensityMap() { var colorsByHeatingSystem = new Dictionary <HeatingSystemType, RGB> { { HeatingSystemType.Gas, Constants.Orange }, { HeatingSystemType.Öl, Constants.Black }, { HeatingSystemType.Electricity, Constants.Green }, { HeatingSystemType.Heatpump, Constants.Green }, { HeatingSystemType.Fernwärme, Constants.Blue }, { HeatingSystemType.Other, Constants.Türkis }, { HeatingSystemType.None, Constants.Türkis } }; RGBWithSize GetColor(House h) { var s = heatingsystemsByGuid[h.Guid]; var energy = s.CalculatedAverageHeatingEnergyDemandDensity / 10; if (energy < 10) { energy = 10; } if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType)) { throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType); } var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType]; return(new RGBWithSize(rgb.R, rgb.G, rgb.B, (int)energy)); } var mapPoints = houses1.Select(x => x.GetMapPointWithSize(GetColor)).ToList(); var filename = MakeAndRegisterFullFilename("MapHeatingTypeAndIntensityPerHouse.svg", slice); var legendEntries = new List <MapLegendEntry>(); foreach (var pair in colorsByHeatingSystem) { legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value)); } Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries); } }
protected override void RunActualProcess() { var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); dbHouses.RecreateTable <DHWHeaterEntry>(); var houses = dbHouses.Fetch <House>(); var households = dbHouses.Fetch <Household>(); var houseHeatings = dbHouses.Fetch <HouseHeating>(); var hausanschlusses = dbHouses.Fetch <Hausanschluss>(); if (houseHeatings.All(x => x.KantonDhwMethods.Count == 0)) { throw new Exception("not a single dhw heating method was set"); } if (houseHeatings.All(x => x.KantonHeatingMethods.Count == 0)) { throw new Exception("not a single space heating method was set"); } RowCollection rc = new RowCollection("Sheet1", "Sheet1"); dbHouses.BeginTransaction(); foreach (var house in houses) { var householdInHouse = households.Where(x => x.HouseGuid == house.Guid).ToList(); var occupantsInHouse = householdInHouse.SelectMany(x => x.Occupants).ToList(); var dhwHeaterEntry = new DHWHeaterEntry(house.Guid, Guid.NewGuid().ToString(), "DHW@" + house.ComplexName); var houseHeating = houseHeatings.Single(x => x.HouseGuid == house.Guid); var heatingMethod = HeatingSystemType.Unbekannt; if (houseHeating.KantonDhwMethods.Count > 0) { heatingMethod = houseHeating.GetDominantDhwHeatingMethod(); } var peopleInHouse = occupantsInHouse.Count; RowBuilder rb = RowBuilder.Start("House", house.ComplexName); rc.Add(rb); rb.Add("Households", households.Count); rb.Add("Persons", occupantsInHouse.Count); rb.Add("Ebbe DHW Estimate", houseHeating.KantonWarmwasserEnergyDemand); switch (heatingMethod) { case HeatingSystemType.Electricity: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; // electricity at night break; case HeatingSystemType.SolarThermal: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; break; case HeatingSystemType.Gas: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Gasheating; break; case HeatingSystemType.Heatpump: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; break; case HeatingSystemType.Fernwärme: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.DistrictHeating; break; case HeatingSystemType.Other: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; break; case HeatingSystemType.None: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.None; break; case HeatingSystemType.Öl: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.OilHeating; break; case HeatingSystemType.Holz: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; break; case HeatingSystemType.Unbekannt: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; break; case HeatingSystemType.GasheatingLocalnet: dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Gasheating; break; case HeatingSystemType.FernwärmeLocalnet: throw new Exception("Unknown heating method: " + heatingMethod); case HeatingSystemType.FeuerungsstättenOil: throw new Exception("Unknown heating method: " + heatingMethod); case HeatingSystemType.FeuerungsstättenGas: throw new Exception("Unknown heating method: " + heatingMethod); case HeatingSystemType.Kohle: throw new Exception("Unknown heating method: " + heatingMethod); default: throw new Exception("Unknown heating method: " + heatingMethod); } rb.Add("Heating Method", dhwHeaterEntry.DhwHeatingSystemType); double totalEnergy = 0; double dhwEnergy = 0; Hausanschluss hausanschluss; string hausanschlussGuid = null; string standort = null; foreach (var hh in householdInHouse) { double personEnergy = hh.EffectiveEnergyDemand / hh.Occupants.Count; if (personEnergy > 1800) { dhwHeaterEntry.DhwHeatingSystemType = DhwHeatingSystem.Electricity; } } foreach (var hh in householdInHouse) { double hhdhwEnergy = 0; double personEnergy = hh.EffectiveEnergyDemand / hh.Occupants.Count; if (dhwHeaterEntry.DhwHeatingSystemType == DhwHeatingSystem.Electricity) { hhdhwEnergy = CalculateDHWEnergy(personEnergy) * hh.Occupants.Count; } var rbhh = RowBuilder.Start("household", hh.Name); rbhh.Add("Persons", hh.Occupants.Count); rbhh.Add("Energy Per Person in Household [kWh]", hhdhwEnergy); rbhh.Add("Household DHW heating method", dhwHeaterEntry.DhwHeatingSystemType); rbhh.Add("Household Energy", hh.EffectiveEnergyDemand); rc.Add(rbhh); if (Math.Abs(hh.EffectiveEnergyDemand - hh.LocalnetLowVoltageYearlyTotalElectricityUse) > 0.1) { if (Math.Abs(hh.EffectiveEnergyDemand - (hh.LocalnetLowVoltageYearlyTotalElectricityUse + dhwEnergy)) > 0.1) { throw new FlaException("Energy use does not fit"); } } hh.SetEnergyReduction("DHW", hhdhwEnergy); if (hh.EffectiveEnergyDemand < 0) { throw new FlaException("Effective Energy demand was null"); } totalEnergy += hh.EffectiveEnergyDemand; hausanschlussGuid = hh.HausAnschlussGuid; standort = hh.Standort; dbHouses.Save(hh); dhwEnergy += hhdhwEnergy; } if (hausanschlussGuid != null) { hausanschluss = hausanschlusses.Single(x => x.Guid == hausanschlussGuid); } else { hausanschluss = house.GetHausanschlussByIsn(new List <int>(), null, hausanschlusses, MyLogger) ?? throw new FlaException("no hausanschluss"); } dhwHeaterEntry.Standort = standort; dhwHeaterEntry.HausAnschlussGuid = hausanschluss.Guid; dhwHeaterEntry.EffectiveEnergyDemand = dhwEnergy; if (totalEnergy < 0) { throw new FlaException("Negative total energy"); } rb.Add("Total Energy Originally [kWh]", totalEnergy); rb.Add("Total Energy DHW [kWh]", dhwEnergy); rb.Add("DHW Power [kWh]", dhwEnergy / 365 / 2); rb.Add("Total Energy After Dhw [kWh]", totalEnergy - dhwEnergy); rb.Add("Energy Per Person [kWh]", totalEnergy / peopleInHouse); dbHouses.Save(dhwHeaterEntry); } dbHouses.CompleteTransaction(); var hhdump = MakeAndRegisterFullFilename("Households.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(hhdump, rc); }
protected override void RunActualProcess(ScenarioSliceParameters slice) { if (!slice.Equals(Constants.PresentSlice)) { return; } var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice); Info("using house db in " + dbHouses.ConnectionString); var houses = dbHouses.Fetch <House>(); HouseComponentRepository hcr = new HouseComponentRepository(dbHouses); var hausanschlusses = dbHouses.Fetch <Hausanschluss>(); var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var suppIsn = dbRaw.Fetch <HausanschlussImportSupplement>(); var standortDict = new Dictionary <string, string>(); var rlms = dbRaw.Fetch <RlmProfile>(); List <AssignmentEntry> ases = new List <AssignmentEntry>(); foreach (var supplement in suppIsn) { if (!string.IsNullOrWhiteSpace(supplement.TargetStandort)) { if (standortDict.ContainsKey(supplement.TargetStandort)) { throw new FlaException("Already contains standort " + supplement.TargetStandort); } standortDict.Add(supplement.TargetStandort, supplement.HaObjectid); } AssignmentEntry ase = ases.FirstOrDefault(x => x.ObjectId == supplement.HaObjectid); if (ase == null) { ase = new AssignmentEntry(supplement.HaObjectid); ases.Add(ase); } ase.Targets.Add(supplement.TargetStandort); ase.TargetCount++; } List <string> checkedStandorte = new List <string>(); var lgzs = ReadZuordnungLastgänge(); var successfullAssignments = new List <LastgangZuordnung>(); RowCollection rc = new RowCollection("sheet", "Sheet1"); List <PvSystemEntry> assignedPVsystems = new List <PvSystemEntry>(); List <PvSystemEntry> otherPVsystems = new List <PvSystemEntry>(); foreach (House house in houses) { var houseComponents = house.CollectHouseComponents(hcr); foreach (var component in houseComponents) { if (component.Standort == null) { continue; } if (standortDict.ContainsKey(component.Standort)) { Hausanschluss ha = hausanschlusses.Single(x => x.Guid == component.HausAnschlussGuid); string targetObjectID = standortDict[component.Standort]; if (ha.ObjectID != targetObjectID) { throw new FlaException("Incorrect hausanschluss for " + component.Name + ": was supposed to be " + targetObjectID + " but instead was " + ha.ObjectID + " (standort: " + component.Standort); } var ase = ases.Single(x => x.ObjectId == ha.ObjectID); ase.AssignedCount++; ase.Assigned.Add(component.Standort); checkedStandorte.Add(component.Standort); } if (component.HouseComponentType == HouseComponentType.BusinessWithLastgangHighVoltage) { var businessEntry = (BusinessEntry)component; var rlmfn = businessEntry.RlmProfileName ?? throw new FlaException("No file"); var ha = hausanschlusses.First(x => x.Guid == businessEntry.HausAnschlussGuid); var rlm = rlms.Single(x => x.Name == businessEntry.RlmProfileName); var energysum = new Profile(rlm.Profile).EnergySum(); LogAssignment(lgzs, rlmfn, ha, successfullAssignments, rc, businessEntry.Name, businessEntry.Standort, suppIsn, "HS", businessEntry.EffectiveEnergyDemand, energysum, house.ComplexName, businessEntry.FinalIsn); } if (component.HouseComponentType == HouseComponentType.BusinessWithLastgangLowVoltage) { var businessEntry = (BusinessEntry)component; var rlmfn = businessEntry.RlmProfileName ?? throw new FlaException("no file?"); var ha = hausanschlusses.First(x => x.Guid == businessEntry.HausAnschlussGuid); var rlm = rlms.Single(x => x.Name == businessEntry.RlmProfileName); var energysum = new Profile(rlm.Profile).EnergySum(); LogAssignment(lgzs, rlmfn, ha, successfullAssignments, rc, businessEntry.Name, businessEntry.Standort, suppIsn, "NS", businessEntry.EffectiveEnergyDemand, energysum, house.ComplexName, businessEntry.FinalIsn); } if (component.HouseComponentType == HouseComponentType.Kwkw) { var kwkw = (KleinWasserkraft)component; var rlmfn = kwkw.RlmProfileName; var ha = hausanschlusses.First(x => x.Guid == kwkw.HausAnschlussGuid); var rlm = rlms.Single(x => x.Name == kwkw.RlmProfileName); var energysum = new Profile(rlm.Profile).EnergySum(); LogAssignment(lgzs, rlmfn, ha, successfullAssignments, rc, kwkw.Name, kwkw.Standort, suppIsn, "WKW", kwkw.EffectiveEnergyDemand, energysum, house.ComplexName, kwkw.FinalIsn); } if (component.HouseComponentType == HouseComponentType.Photovoltaik) { var ha = hausanschlusses.First(x => x.Guid == component.HausAnschlussGuid); if (lgzs.Any(x => string.Equals(x.Knoten.ToLower(), ha.ObjectID.ToLower(), StringComparison.InvariantCultureIgnoreCase))) { assignedPVsystems.Add((PvSystemEntry)component); } else { otherPVsystems.Add((PvSystemEntry)component); } } } } foreach (var zuordnung in lgzs) { if (!successfullAssignments.Contains(zuordnung)) { RowBuilder rb = RowBuilder.Start("Lastgang", zuordnung.FileName).Add("Diren Profilename", zuordnung.Knoten); var has = hausanschlusses.Where(x => x.ObjectID == zuordnung.Knoten).ToList(); var haguids = has.Select(x => x.Guid).Distinct().ToList(); var pvs = assignedPVsystems.Where(x => haguids.Contains(x.HausAnschlussGuid)).ToList(); var houseGuids = has.Select(x => x.HouseGuid).Distinct().ToList(); var otherPV = otherPVsystems.Where(x => houseGuids.Contains(x.HouseGuid)); rb.Add("PV Systems", string.Join(";", pvs.Select(x => x.Name))); rb.Add("Other PV Systems@house", string.Join(";", otherPV.Select(x => x.Name))); var rlm = rlms.Where(x => x.Name.Contains(zuordnung.FileName)).ToList(); for (int i = 0; i < rlm.Count; i++) { var energysum = new Profile(rlm[i].Profile).EnergySum(); rb.Add("Profilesumme " + i, energysum); } rc.Add(rb); if (has.Count > 0) { List <string> housenames = new List <string>(); foreach (var ha in has) { var house = houses.First(x => x.Guid == ha.HouseGuid); housenames.Add(house.ComplexName); } rb.Add("Hausname", string.Join(",", housenames.Distinct())); } } } foreach (var pVsystem in otherPVsystems) { House house = houses.First(x => x.Guid == pVsystem.HouseGuid); var rb = RowBuilder.Start("Hausname", house.ComplexName); rb.Add("Effective Energy", pVsystem.EffectiveEnergyDemand); rb.Add("Planned Energy", pVsystem.EffectiveEnergyDemand); var ha = hausanschlusses.First(x => x.Guid == pVsystem.HausAnschlussGuid); rb.Add("Zugeordnete ObjektID", ha.ObjectID); rc.Add(rb); } var fn = MakeAndRegisterFullFilename("WrongAssignments.xlsx", slice); XlsxDumper.WriteToXlsx(fn, rc); var missingAssigments = lgzs.Where(x => !successfullAssignments.Contains(x)).ToList(); if (missingAssigments.Count > 0) { Info("Missing assignments: " + string.Join("\n", missingAssigments.Select(x => x.FileName))); } foreach (var pair in standortDict) { if (!checkedStandorte.Contains(pair.Key)) { //throw new FlaException("Didn't find supplemental standort " + pair.Value + " in the list of components. Typo?"); } } foreach (var ase in ases) { foreach (var target in ase.Targets) { if (!ase.Assigned.Contains(target)) { // throw new FlaException("Missing " + target + " from the list of assigned standorts"); } } foreach (var assigned in ase.Assigned) { if (!ase.Targets.Contains(assigned)) { //throw new FlaException("Missing " + assigned + " from the list of target standorts"); } } } }
protected override void RunActualProcess() { var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); dbHouses.RecreateTable <HeatingSystemEntry>(); var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var dbComplexes = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Complexes, Constants.PresentSlice); var rnd = new Random(); var houses = dbHouses.Fetch <House>(); var hausanschlusses = dbHouses.Fetch <Hausanschluss>(); var houseHeatingMethods = dbHouses.Fetch <HouseHeating>(); var feuerungsstättenRaw = dbRaw.Fetch <FeuerungsStaette>(); var complexes = dbComplexes.Fetch <BuildingComplex>(); Dictionary <string, BuildingComplex> buildingComplexesByName = new Dictionary <string, BuildingComplex>(); foreach (BuildingComplex complex in complexes) { buildingComplexesByName.Add(complex.ComplexName, complex); } var potentialHeatingSystems = dbHouses.Fetch <PotentialHeatingSystemEntry>(); dbHouses.BeginTransaction(); OverrideRepository overrideRepository = new OverrideRepository(); double totalFernwärme = potentialHeatingSystems.Sum(x => x.YearlyFernwärmeDemand); var overrideEntries = overrideRepository.ReadEntries(Services); var houseNames = houses.Select(x => x.ComplexName).ToHashSet(); foreach (OverrideEntry entry in overrideEntries) { if (!houseNames.Contains(entry.ComplexName)) { throw new FlaException("Kein Haus für Override Entry " + entry.ComplexName + ". Vermutlich vertippt?"); } } List <HeatingSystemEntry> hses = new List <HeatingSystemEntry>(); foreach (var house in houses) { var complex = buildingComplexesByName[house.ComplexName]; List <FeuerungsStaette> feuerungsStättenForHouse = feuerungsstättenRaw.Where(x => { if (x.EGID == null) { throw new FlaException("x.EGID != null"); } return(complex.EGids.Contains((long)x.EGID)); }).ToList(); //set the age of the heating system, randomly up to 30 years old var feuerungsstättenType = string.Join(",", feuerungsStättenForHouse.Select(x => x.Brennstoff?.ToString()).Distinct()); var hausanschluss = house.GetHausanschlussByIsn(new List <int>(), null, hausanschlusses, MyLogger, false); if (hausanschluss != null && hausanschluss.ObjectID.ToLower().Contains("kleinanschluss")) { hausanschluss = null; } var hse = new HeatingSystemEntry(house.Guid, Guid.NewGuid().ToString(), feuerungsstättenType, hausanschluss?.Guid, house.ComplexName, house.ComplexName + " - Heating System - Unknown"); hses.Add(hse); var oldestYear = feuerungsStättenForHouse.Min(x => x.KesselBaujahr); if (oldestYear == null || oldestYear.Value < 1800) { hse.Age = rnd.Next(30); } else { hse.Age = 2019 - oldestYear.Value; } hse.FeuerungsstättenPower = feuerungsStättenForHouse.Sum(x => { if (x.KesselLeistung == null) { throw new FlaException("Kesselleistung was null"); } return((double)x.KesselLeistung); }); hse.EstimatedMinimumEnergyFromFeuerungsStätten = hse.FeuerungsstättenPower * 1500; hse.EstimatedMaximumEnergyFromFeuerungsStätten = hse.FeuerungsstättenPower * 2200; //this is a localnet heating system, so use the localnet information var potentialHouseHeatingSystems = potentialHeatingSystems.Where(x => x.HouseGuid == house.Guid).ToList(); var houseHeatingMethod = houseHeatingMethods.Single(x => x.HouseGuid == house.Guid); double totalHeatDemand = 0; OverrideEntry ore = overrideEntries.FirstOrDefault(x => x.ComplexName == house.ComplexName); if (ore != null) { Debug("Override Entry for " + house.ComplexName); } if (potentialHouseHeatingSystems.Count > 0) { var totalGas = potentialHouseHeatingSystems.Sum(x => x.YearlyGasDemand); var totalWärme = potentialHouseHeatingSystems.Sum(x => x.YearlyFernwärmeDemand); if (totalGas > 0) { //localnet heizung totalHeatDemand = totalGas; hse.OriginalHeatingSystemType = HeatingSystemType.GasheatingLocalnet; hse.SynthesizedHeatingSystemType = HeatingSystemType.Gas; if (totalWärme > 0) { throw new Exception("Both wärme and gas"); } if (ore != null) { throw new FlaException("Overrride Entry für Localnet Gas Gebäude: " + house.ComplexName + ", but that doesn't make sense"); } } if (totalWärme > 0) { totalHeatDemand = totalWärme; hse.OriginalHeatingSystemType = HeatingSystemType.FernwärmeLocalnet; hse.SynthesizedHeatingSystemType = HeatingSystemType.Fernwärme; } } // no data, so use feuerungsstätten else if (ore != null) { //kanton heizung hse.OriginalHeatingSystemType = HeatingSystemType.None; if (ore.HeatingSystemType == HeatingSystemType.Heatpump && hse.HausAnschlussGuid == null) { hse.SynthesizedHeatingSystemType = HeatingSystemType.None; } hse.SynthesizedHeatingSystemType = ore.HeatingSystemType; totalHeatDemand = ore.Amount; } else if (feuerungsStättenForHouse.Count > 0) { var fs = feuerungsStättenForHouse[0]; if (fs.Brennstoff == "Oel") { hse.OriginalHeatingSystemType = HeatingSystemType.FeuerungsstättenOil; hse.SynthesizedHeatingSystemType = HeatingSystemType.Öl; totalHeatDemand = houseHeatingMethod.KantonTotalEnergyDemand; } else if (fs.Brennstoff == "Gas") { hse.OriginalHeatingSystemType = HeatingSystemType.FeuerungsstättenGas; //beco says gas, but can't be, because localnet says no hse.SynthesizedHeatingSystemType = HeatingSystemType.Öl; totalHeatDemand = houseHeatingMethod.KantonTotalEnergyDemand; } else { throw new Exception("invalid heating system"); } } // no beco, so use ebbe daten else if (houseHeatingMethod.KantonHeatingMethods.Count > 0) { //kanton heizung var kantonHeatingMethod = houseHeatingMethod.KantonHeatingMethods[0]; GetKantonHeatingSystem(kantonHeatingMethod, hse, houseHeatingMethod, ref totalHeatDemand); } else if (feuerungsStättenForHouse.Count > 0) { var fs = feuerungsStättenForHouse[0]; if (fs.Brennstoff == "Oel") { hse.OriginalHeatingSystemType = HeatingSystemType.FeuerungsstättenOil; hse.SynthesizedHeatingSystemType = HeatingSystemType.Öl; totalHeatDemand = houseHeatingMethod.KantonTotalEnergyDemand; } else if (fs.Brennstoff == "Gas") { hse.OriginalHeatingSystemType = HeatingSystemType.FeuerungsstättenGas; //beco says gas, but can't be, because localnet says no hse.SynthesizedHeatingSystemType = HeatingSystemType.Öl; totalHeatDemand = houseHeatingMethod.KantonTotalEnergyDemand; } else { throw new Exception("invalid heating system"); } } // no beco, so use ebbe daten else if (houseHeatingMethod.KantonHeatingMethods.Count > 0) { //kanton heizung var kantonHeatingMethod = houseHeatingMethod.KantonHeatingMethods[0]; GetKantonHeatingSystem(kantonHeatingMethod, hse, houseHeatingMethod, ref totalHeatDemand); } else { hse.OriginalHeatingSystemType = HeatingSystemType.None; hse.SynthesizedHeatingSystemType = HeatingSystemType.None; totalHeatDemand = 0; } if (hse.SynthesizedHeatingSystemType == HeatingSystemType.Heatpump && hse.HausAnschlussGuid == null) { hse.SynthesizedHeatingSystemType = HeatingSystemType.None; } if (hse.SynthesizedHeatingSystemType == HeatingSystemType.Electricity && hse.HausAnschlussGuid == null) { throw new FlaException("electric heating without anschluss"); } if (hse.SynthesizedHeatingSystemType == HeatingSystemType.Heatpump && hse.HausAnschlussGuid == null) { throw new FlaException("hp heating without anschluss"); } hse.Standort = house.ComplexName + " - " + hse.SynthesizedHeatingSystemType; hse.ProvideProfile = false; hse.HeatingSystemType2017 = hse.SynthesizedHeatingSystemType; if (house.Appartments.Count == 0) { throw new FlaException("Not a single area in the house " + house.ComplexName); } double avgHeatDemand = totalHeatDemand / house.Appartments.Count; foreach (var appartment in house.Appartments) { hse.HeatDemands.Add(new AppartmentHeatingDemand(appartment.Guid, appartment.EnergieBezugsFläche, avgHeatDemand, Constants.PresentSlice.DstYear)); } if (Math.Abs(hse.HeatDemand - totalHeatDemand) > 0.01) { throw new FlaException("Invalid heat demand"); } hse.OriginalHeatDemand2017 = hse.HeatDemand; dbHouses.Save(hse); } dbHouses.CompleteTransaction(); double finalFernwärme = hses.Where(x => x.SynthesizedHeatingSystemType == HeatingSystemType.Fernwärme).Sum(x => x.EffectiveEnergyDemand); if (Math.Abs(finalFernwärme - totalFernwärme) > 1) { throw new FlaException("Fernwärme changed: Nach allem:" + finalFernwärme + " davor: " + totalFernwärme); } RowCollection rc = new RowCollection("Validation", "Validierung"); foreach (var feuerungsStaette in feuerungsstättenRaw) { string adress = feuerungsStaette.Strasse + " " + feuerungsStaette.Hausnummer; RowBuilder rb = RowBuilder.Start("FeuerungsAdresse", adress); rc.Add(rb); rb.Add("Brennstoff", feuerungsStaette.Brennstoff); rb.Add("Energienutzung", feuerungsStaette.Energienutzung); rb.Add("Leistung", feuerungsStaette.KesselLeistung); if (feuerungsStaette.EGID != null) { int egid = (int)feuerungsStaette.EGID; var house = houses.FirstOrDefault(x => x.EGIDs.Contains(egid)); if (house != null) { rb.Add("Haus", house.ComplexName); rb.Add("HausAdresse", house.Adress); HeatingSystemEntry hse = hses.Single(x => x.HouseGuid == house.Guid); rb.Add("Gewählter Heizungstyp 1", hse.OriginalHeatingSystemType.ToString()); rb.Add("Gewählter Heizungstyp 2", hse.SynthesizedHeatingSystemType.ToString()); rb.Add("EBF", house.EnergieBezugsFläche); } else { var h2 = houses.FirstOrDefault(x => x.Adress?.Contains(adress) == true); if (h2 != null) { rb.Add("Findbar über Adresse", h2.ComplexName); HeatingSystemEntry hse = hses.Single(x => x.HouseGuid == h2.Guid); rb.Add("Gewählter Heizungstyp 1", hse.OriginalHeatingSystemType.ToString()); rb.Add("Gewählter Heizungstyp 2", hse.SynthesizedHeatingSystemType.ToString()); rb.Add("EBF", h2.EnergieBezugsFläche); } } } else { rb.Add("Egid fehlt", "True"); } } var fn = MakeAndRegisterFullFilename("Feuerungsstätten-Validation.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }
protected override void RunActualProcess() { var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice); var dbHousesPersistence = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice, DatabaseCode.Persistence); dbHousesPersistence.CreateTableIfNotExists <PersistentHouseholdResidents>(); var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice); var households = dbHouses.Fetch <Household>(); var jahrgänge = dbRaw.Fetch <Jahrgang>(); if (households.Count == 0) { throw new Exception("no households founds"); } if (households.Count != A05_HouseholdMaker.HouseholdAccordingToStadtverwaltung) { throw new FlaException("Missing households!?"); } foreach (var household in households) { household.Occupants.Clear(); } var persistentResidents = dbHousesPersistence.Fetch <PersistentHouseholdResidents>(); int householdCountBefore = households.Count; dbHouses.BeginTransaction(); Info("found " + persistentResidents.Count + " persistent residents"); foreach (var persistentHouseholdResidentse in persistentResidents) { var household = households.FirstOrDefault(x => x.HouseholdKey == persistentHouseholdResidentse.HouseholdKey); if (household == null) { Info("Invalid persistence for " + persistentHouseholdResidentse.HouseholdKey); dbHousesPersistence.Delete(persistentHouseholdResidentse); continue; } foreach (var persistentOccupant in persistentHouseholdResidentse.Occupants) { var occupant = new Occupant(household.Guid, Guid.NewGuid().ToString(), persistentOccupant.Age, persistentOccupant.Gender, household.HouseGuid, household.HouseholdKey); household.Occupants.Add(occupant); var jahrgang = 2018 - persistentOccupant.Age; var einträge = jahrgänge.Single(x => x.Jahr == jahrgang); einträge.Count--; if (einträge.Count < 0) { throw new FlaException("Negative population"); } } dbHouses.Save(household); households.Remove(household); } Info("Covered " + (householdCountBefore - households.Count) + " households from persistence, households left: " + households.Count); var hmfc = new HouseMemberFuzzyCalc(Services.MyLogger, MyStage); var potentialPersons = new List <PotentialPerson>(); foreach (var jahrgang in jahrgänge) { var age = 2018 - jahrgang.Jahr; var g = Gender.Male; for (var i = 0; i < jahrgang.Count; i++) { var pp = new PotentialPerson(g, age); potentialPersons.Add(pp); g = g == Gender.Male ? Gender.Female : Gender.Male; } } var r = new Random(1); foreach (var household in households) { household.HeuristicFamiliySize = hmfc.GetPeopleCountForEnergy(household.EffectiveEnergyDemand); household.Occupants.Clear(); } //put at least one person into every household foreach (var household in households) { var eligiablePersons = potentialPersons.Where(x => x.Age >= 18).ToList(); var occ = MakeOccupant(eligiablePersons, r, potentialPersons, household); household.Occupants.Add(occ); dbHouses.Save(occ); } //put a second person into the households that might have a second one foreach (var household in households) { if (household.HeuristicFamiliySize < 2) { continue; } var g = household.Occupants[0].Gender; var otherGender = g == Gender.Male ? Gender.Female : Gender.Male; var eligiablePersons = potentialPersons.Where(x => x.Age >= 18 && x.Gender == otherGender).ToList(); if (eligiablePersons.Count == 0) { eligiablePersons = potentialPersons; } var occ2 = MakeOccupant(eligiablePersons, r, potentialPersons, household); household.Occupants.Add(occ2); } var count = 0; while (potentialPersons.Count > 0) { count++; if (count > 100000) { throw new Exception("Couldnt allocate everything after " + count + " iterations," + potentialPersons.Count + " left."); } var allocatedCount = 0; foreach (var household in households) { if (household.Occupants.Count >= household.HeuristicFamiliySize) { continue; } if (potentialPersons.Count == 0) { break; } var eligiablePersonsKids = potentialPersons.Where(x => x.Age < 18).ToList(); if (eligiablePersonsKids.Count == 0) { eligiablePersonsKids = potentialPersons; } var occ3 = MakeOccupant(eligiablePersonsKids, r, potentialPersons, household); household.Occupants.Add(occ3); allocatedCount++; } if (allocatedCount == 0 && potentialPersons.Count > 0) { var hhs = households.Where(x => x.HeuristicFamiliySize > 2).ToList(); if (hhs.Count == 0) { hhs = households; } var idx = Services.Rnd.Next(hhs.Count); hhs[idx].HeuristicFamiliySize++; } } List <PersistentHouseholdResidents> newPersistentResidents = new List <PersistentHouseholdResidents>(); int peopleCount = 0; foreach (var hh in households) { dbHouses.Save(hh); PersistentHouseholdResidents phhr = new PersistentHouseholdResidents(hh.HouseholdKey); foreach (var occupant in hh.Occupants) { phhr.Occupants.Add(new PersistentOccupant(occupant.Age, occupant.Gender)); peopleCount++; } newPersistentResidents.Add(phhr); } dbHouses.CompleteTransaction(); dbHousesPersistence.BeginTransaction(); foreach (var phhr in newPersistentResidents) { dbHousesPersistence.Save(phhr); } Info("Saved " + newPersistentResidents.Count + " persistence records with a total of " + peopleCount + " people"); dbHousesPersistence.CompleteTransaction(); var allhouseholds = dbHouses.FetchAsRepo <Household>(); var rc = new RowCollection("occupants", "occupants"); foreach (var hh in allhouseholds) { foreach (var occupant in hh.Occupants) { var rb = RowBuilder.Start("age", occupant.Age).Add("Gender", occupant.Gender); rc.Add(rb); } } var fn = MakeAndRegisterFullFilename("OccupantList.xlsx", Constants.PresentSlice); XlsxDumper.WriteToXlsx(fn, rc); }