protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make Car results");
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
var cars = analysisRepo.GetSlice(slice).Fetch <Car>();
var carDistanceEntries = analysisRepo.GetSlice(slice).Fetch <CarDistanceEntry>();
if (carDistanceEntries.Count != cars.Count)
{
throw new FlaException("Cars and car distance entries count don't match");
}
myt[slice].AddValue("Cars", cars.Count, DisplayUnit.Stk);
myt[slice].AddValue("Cars Electric", cars.Count(x => x.CarType == CarType.Electric), DisplayUnit.Stk);
myt[slice].AddValue("Cars Gasoline", cars.Count(x => x.CarType == CarType.Gasoline), DisplayUnit.Stk);
myt[slice].AddValue("Avg Kilometers Per Car", carDistanceEntries.Average(x => x.DistanceEstimate), DisplayUnit.Stk);
myt[slice].AddValue("Avg Energy Estimate Per car", carDistanceEntries.Average(x => x.EnergyEstimate), DisplayUnit.Stk);
var electricCars = cars.Where(x => x.CarType == CarType.Electric).Select(x => x.Guid).ToHashSet();
var electricCarDistanceEntries = carDistanceEntries.Where(x => electricCars.Contains(x.CarGuid)).ToList();
myt[slice].AddValue("Summed Electric Energy Estimate Per car",
electricCarDistanceEntries.Sum(x => x.EnergyEstimate),
DisplayUnit.GWh);
myt[slice].AddValue("Car Distance Entries", carDistanceEntries.Count, DisplayUnit.Stk);
}
var filename3 = MakeAndRegisterFullFilename("TotalCarDevelopment.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
}
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 RunChartMaking(ScenarioSliceParameters slice)
{
var dbProfileExport = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.HouseProfiles);
var sa = SaveableEntry <Prosumer> .GetSaveableEntry(dbProfileExport, SaveableEntryTableType.HouseLoad, Services.Logger);
var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
var houses = dbHouses.Fetch <House>();
var house = houses.Single(x => x.ComplexName == "Kornhausgasse 16");
List <Profile> relevantProsumers = new List <Profile>();
foreach (var prosumer in sa.ReadEntireTableDBAsEnumerable())
{
if (prosumer.HouseGuid == house.Guid)
{
if (prosumer.Profile == null)
{
throw new FlaException("profile was null");
}
relevantProsumers.Add(new Profile(prosumer.Name + " " + prosumer.ProfileSourceName, prosumer.Profile.Values, prosumer.Profile.EnergyOrPower));
}
}
var fn = MakeAndRegisterFullFilename("ExportedProfiles.xlsx", slice);
XlsxDumper.DumpProfilesToExcel(fn, slice.DstYear, 15, new ProfileWorksheetContent("kornhausgasse 16", "Last", relevantProsumers));
}
public void RunSingleAcTest()
{
PrepareUnitTest();
// ReSharper disable AssignNullToNotNullAttribute
ServiceRepository services = new ServiceRepository(null, null, Logger, Config, new Random());
// ReSharper restore AssignNullToNotNullAttribute
var dbRaw = services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var temperatures = dbRaw.Fetch <TemperatureProfileImport>();
Profile temperaturProfileHourly = new Profile(temperatures[0].Profile ?? throw new FlaException("was null"));
//make heatpumpprofile
var chp = new CoolingProfileGenerator(temperaturProfileHourly, 27, 24, Logger);
Random rnd = new Random();
var hpcp = CoolingCalculationParameters.MakeDefaults();
const double energyuse = 20000;
var hpr = chp.Run(hpcp, energyuse, rnd);
hpr.GetEnergyDemandProfile().Values.Sum().Should().BeApproximately(energyuse * 0.333, 100);
Profile houseEnergy = new Profile("House Energy", hpr.HouseEnergyTracker.AsReadOnly(), EnergyOrPower.Energy);
Profile heatPumpEnergysupply = new Profile("Heat pump Energy supply", hpr.CoolingEnergySupply.AsReadOnly(), EnergyOrPower.Energy);
Profile temperatureProfile15Min = new Profile("Temperatures", hpr.AvgTemperatures15Min.ToList().AsReadOnly(), EnergyOrPower.Energy);
string file = WorkingDirectory.Combine("coolingrofile_Single.xlsx");
List <Profile> profiles = new List <Profile>();
profiles.Add(temperatureProfile15Min);
profiles.Add(houseEnergy);
profiles.Add(heatPumpEnergysupply);
XlsxDumper.DumpProfilesToExcel(file, 2050, 15, new ProfileWorksheetContent("Sheet1", "Last", profiles));
}
private void MakeSingleChart([NotNull] ExcelWorksheet ws,
int chartRow,
int columnIdx,
[NotNull][ItemNotNull] List <ArchiveEntry> providerentries,
int startrow,
int endrow,
[NotNull] string chartname,
int width = 800)
{
ExcelChart chart = ws.Drawings.AddChart(chartname + "chart", eChartType.ColumnStacked);
chart.Title.Text = chartname;
chart.SetPosition(chartRow, 0, columnIdx + 2, 0);
chart.SetSize(width, 500);
var barChart = (ExcelBarChart)chart.PlotArea.ChartTypes[0];
barChart.GapWidth = 0;
for (int i = 0; i < providerentries.Count; i++)
{
var name = (string)ws.Cells[1, i + 2].Value;
string col = XlsxDumper.GetExcelColumnName(i + 2);
Trace("column " + col);
var ser1 = chart.Series.Add(ws.Cells[col + startrow + ":" + col + endrow], ws.Cells["A" + startrow + ":A" + endrow]);
ser1.Header = name;
}
chart.Legend.Position = eLegendPosition.Bottom;
AddBkwChart(providerentries, ws, chart, startrow, endrow);
}
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");
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
var airCons = analysisRepo.GetSlice(slice).Fetch <AirConditioningEntry>();
myt[slice].AddValue("Klimaanlagen", airCons.Count, DisplayUnit.Stk);
myt[slice].AddValue("Klimaanlagen Stromverbrauch", airCons.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.GWh);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
double percentage = (double)airCons.Count / houses.Count;
myt[slice].AddValue("Anteil Häuser mit Klimaanlage", percentage, DisplayUnit.Stk);
var houseGuidsWithAircon = airCons.ToReferenceGuidHashset(x => x.HouseGuid);
var housesWithAirCon = houses.Where(x => houseGuidsWithAircon.Contains(x.HouseGuid));
double totalebf = houses.Sum(x => x.EnergieBezugsFläche);
double airConEbf = housesWithAirCon.Sum(x => x.EnergieBezugsFläche);
myt[slice].AddValue("Anteil EBF mit Klimaanlage", airConEbf / totalebf, DisplayUnit.Stk);
}
var filename3 = MakeAndRegisterFullFilename("AirConditioning.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
}
private void ProcessOneSumTypeWithXls([NotNull] ScenarioSliceParameters slice, [NotNull] string fn, SumType sumType)
{
var dbArchive = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saHouses = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive, SaveableEntryTableType.SummedLoadsForAnalysis, Services.Logger);
var entries = saHouses.LoadAllOrMatching();
var providerentries = entries.Where(x => x.Key.SumType == sumType).ToList();
var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var bkwJ = dbRaw.Fetch <BkwProfile>();
foreach (var ae in providerentries)
{
if (sumType == SumType.ByProvider)
{
ae.Profile.Name = ae.Key.ProviderType + " " + ae.GenerationOrLoad;
}
else if (sumType == SumType.ByProfileSource)
{
ae.Profile.Name = ae.Key.ProfileSource ?? throw new InvalidOperationException();
}
else
{
throw new FlaException("Unknown sum type");
}
}
var profiles = providerentries.Select(x => x.Profile).ToList();
var bkw = new Profile(bkwJ[0].Profile);
bkw.Name = "Messung 2017";
profiles.Add(bkw);
XlsxDumper.DumpProfilesToExcel(fn, 2017, 15, new ProfileWorksheetContent("Profile", "Leistung [MW]", bkw.Name, profiles));
}
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 RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make trafostation results");
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
Info("Processing slice " + slice);
var dbArchiving = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileAnalysis, slice, DatabaseCode.Smartgrid);
var saArchiveEntry = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchiving, SaveableEntryTableType.Smartgrid, Services.Logger);
var sgis = dbArchiving.Fetch <SmartGridInformation>();
if (sgis.Count != 1)
{
throw new FlaException("invalid count");
}
var sgi = sgis[0];
myt[slice].AddValue("Gesamtspeichergrösse [GWh]", sgi.TotalStorageSize, DisplayUnit.GWh);
double avgreduction = sgi.SummedReductionFactor / sgi.NumberOfReductionFactors;
myt[slice].AddValue("Average Reduction Factor", avgreduction, DisplayUnit.Stk);
myt[slice].AddValue("Number of Prosumers", sgi.NumberOfProsumers, DisplayUnit.Stk);
var aes = saArchiveEntry.LoadAllOrMatching();
{
var cityload = aes.Single(x => x.Name == SummedLoadType.CityLoad.ToString());
myt[slice].AddValue("Energiebedarf Gesamt [GWh]", cityload.Profile.EnergySum(), DisplayUnit.GWh);
var cityGen1 = aes.Single(x => x.Name == SummedLoadType.CityGeneration.ToString());
var cityGenProf = cityGen1.Profile.MultiplyWith(-1, "Energieerzeugung");
if (cityGenProf.EnergySum() > 0)
{
throw new FlaException("Positive energy sum while generationg");
}
myt[slice].AddValue("Energieerzeugung Gesamt [GWh]", cityGenProf.EnergySum(), DisplayUnit.GWh);
var citySum = cityload.Profile.Add(cityGenProf, "sum");
myt[slice].AddValue("Netto-Energiebedarf [GWh]", citySum.EnergySum(), DisplayUnit.GWh);
myt[slice].AddValue("Maximale Last am Umspannwerk [MW]", citySum.MaxPower(), DisplayUnit.Mw);
myt[slice].AddValue("Minimale Last am Umspannwerk [MW]", citySum.MinPower(), DisplayUnit.Mw);
}
var smartcityload = aes.Single(x => x.Name == SummedLoadType.SmartCityLoad.ToString());
myt[slice].AddValue("Energiebedarf Gesamt (smart) [GWh]", smartcityload.Profile.EnergySum(), DisplayUnit.GWh);
var smartcityGen = aes.Single(x => x.Name == SummedLoadType.SmartCityGeneration.ToString());
myt[slice].AddValue("Energieerzeugung Gesamt (smart) [GWh[", smartcityGen.Profile.EnergySum(), DisplayUnit.GWh);
var smartcitySum = smartcityload.Profile.Add(smartcityGen.Profile, "sum");
myt[slice].AddValue("Netto-Energiebedarf (smart) [GWh]", smartcitySum.EnergySum(), DisplayUnit.GWh);
myt[slice].AddValue("Maximale Last am Umspannwerk (smart) [MW]", smartcitySum.MaxPower(), DisplayUnit.Mw);
myt[slice].AddValue("Minimale Last am Umspannwerk (smart) [MW]", smartcitySum.MinPower(), DisplayUnit.Mw);
}
var filename3 = MakeAndRegisterFullFilename("SmartGridOverview.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "4.5");
}
private void MakeXlsForCurrentProfile([NotNull] ScenarioSliceParameters slice)
{
var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var bkwArr = dbRaw.Fetch <BkwProfile>();
var bkwJProf = bkwArr[0];
var bkwProf = new Profile(bkwJProf.Profile);
var fnProfPresent = MakeAndRegisterFullFilename("PresentProfile.xlsx", slice);
XlsxDumper.DumpProfilesToExcel(fnProfPresent,
Constants.PresentSlice.DstYear,
15,
new ProfileWorksheetContent("bkw", "Last [kW]", 240, bkwProf)
);
SaveToPublicationDirectory(fnProfPresent, slice, "4.5");
}
private void AddBkwChart([NotNull][ItemNotNull] List <ArchiveEntry> providerentries,
[NotNull] ExcelWorksheet ws,
[NotNull] ExcelChart chart,
int startrow,
int endrow)
{
int colIdx = providerentries.Count + 2;
var name = (string)ws.Cells[1, colIdx].Value;
string col = XlsxDumper.GetExcelColumnName(colIdx);
Trace("column " + col);
var ls = chart.PlotArea.ChartTypes.Add(eChartType.Line);
var ser1 = ls.Series.Add(ws.Cells[col + startrow + ":" + col + endrow], ws.Cells["A" + startrow + ":A" + endrow]);
ser1.Header = name;
}
private void MakeAreaResults([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
MultiyearMultiVariableTrend mymvt = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
Dictionary <int, double> areaByYear = new Dictionary <int, double>();
Dictionary <int, int> countByYear = new Dictionary <int, int>();
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
foreach (var house in houses)
{
foreach (var app in house.Appartments)
{
if (!app.IsApartment)
{
continue;
}
if (!areaByYear.ContainsKey(app.Year))
{
areaByYear.Add(app.Year, 0);
countByYear.Add(app.Year, 0);
}
areaByYear[app.Year] += app.EnergieBezugsFläche;
countByYear[app.Year]++;
}
}
foreach (var pair in areaByYear)
{
mymvt[slice].AddValue("Area", pair.Key.ToString(), pair.Value, DisplayUnit.Stk);
}
foreach (var pair in countByYear)
{
mymvt[slice].AddValue("Anzahl Appartments", pair.Key.ToString(), pair.Value, DisplayUnit.Stk);
}
}
var filename4 = MakeAndRegisterFullFilename("Hausflächen.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename4);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename4, mymvt);
SaveToArchiveDirectory(filename4, RelativeDirectory.Report, Constants.PresentSlice);
}
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);
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make trafostation results");
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
HouseComponentRepository hcr = new HouseComponentRepository(analysisRepo, slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
Dictionary <string, double> energyUsePerTrafostation = new Dictionary <string, double>();
var hausanschlusses = analysisRepo.GetSlice(slice).Fetch <Hausanschluss>();
foreach (var house in houses)
{
var components = house.CollectHouseComponents(hcr);
foreach (var component in components)
{
if (component.HausAnschlussGuid == null)
{
continue;
}
var hausanschluss = hausanschlusses.GetByGuid(component.HausAnschlussGuid);
var trafo = hausanschluss.Trafokreis;
if (!energyUsePerTrafostation.ContainsKey(trafo))
{
energyUsePerTrafostation.Add(trafo, 0);
}
energyUsePerTrafostation[trafo] += component.EffectiveEnergyDemand;
}
}
double totalEnergy = 0;
foreach (var energy in energyUsePerTrafostation)
{
myt[slice].AddValue(energy.Key, energy.Value, DisplayUnit.GWh);
totalEnergy += energy.Value;
}
myt[slice].AddValue("Total", totalEnergy, DisplayUnit.GWh);
}
var filename3 = MakeAndRegisterFullFilename("TrafostationEnergyResults.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
}
public void Run()
{
PrepareUnitTest();
// ReSharper disable AssignNullToNotNullAttribute
ServiceRepository sp = new ServiceRepository(null, null, Logger, Config, new Random());
// ReSharper restore AssignNullToNotNullAttribute
var slice = Constants.PresentSlice;
var dbHouse = sp.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
var airconditioningEntries = dbHouse.Fetch <AirConditioningEntry>();
var hausanschlusses = dbHouse.Fetch <Hausanschluss>();
DBDto dbDto = new DBDto(new List <House>(), hausanschlusses, new List <Car>(), new List <Household>(), new List <RlmProfile>());
CoolingProvider hp = new CoolingProvider(sp, slice, dbDto);
Info("total hse: " + airconditioningEntries.Count);
Profile sumProfile = Profile.MakeConstantProfile(0, "Sum", Profile.ProfileResolution.QuarterHour);
foreach (var entry in airconditioningEntries)
{
(entry.HouseComponentType == HouseComponentType.Cooling).Should().BeTrue();
hp.IsCorrectProvider(entry).Should().BeTrue();
HouseComponentRo hro = new HouseComponentRo(string.Empty, string.Empty, 1, 1, string.Empty, string.Empty, string.Empty, 0);
ProviderParameterDto ppd = new ProviderParameterDto(entry, string.Empty, hro);
hp.PrepareLoadProfileIfNeeded(ppd);
var prof = hp.ProvideProfile(ppd);
if (prof != null)
{
if (prof.Profile == null)
{
throw new FlaException("Profile was null");
}
prof.Profile.EnergySum().Should().BeApproximately(entry.EffectiveEnergyDemand, entry.EffectiveEnergyDemand * 0.1);
sumProfile = sumProfile.Add(prof.Profile.Values);
}
}
string fn = WorkingDirectory.Combine("Profiletest_cooling.xlsx");
XlsxDumper.DumpProfilesToExcel(fn, 2050, 15, new ProfileWorksheetContent("Sum", "Last", 240, sumProfile));
Info("Wrote to " + fn);
}
public void RunSingleHpTest()
{
DhwProfileGenerator chp = new DhwProfileGenerator();
Random rnd = new Random();
var dhwcp = DhwCalculationParameters.MakeDefaults();
const double energyuse = 20000;
var hpr = chp.Run(dhwcp, energyuse, rnd);
var profile = hpr.GetEnergyDemandProfile();
const string file = "dhwProfile_Single.xlsx";
var colnames = new List <string> {
"turnoff"
};
XlsxDumper.DumpProfilesToExcel(file,
2017,
15,
new ProfileWorksheetContent("sheet1", "Last", 240, profile),
new EnumWorksheetContent <DhwTurnOffReason>("turnoffs", colnames, hpr.TurnOffReasons.AsReadOnly()));
profile.Values.Sum().Should().BeApproximately(energyuse, 100);
}
private void WriteBkwColumn([NotNull] ExcelWorksheet ws, int columnIdx, int sumCol)
{
var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var bkw = dbRaw.Fetch <BkwProfile>();
ws.Cells[1, columnIdx].Value = "BKW";
int rowIdx = 2;
var vals = bkw[0].Profile.Values;
for (int i = 0; i < vals.Count; i++)
{
ws.Cells[rowIdx, columnIdx].Value = vals[i];
rowIdx++;
}
ws.Cells[columnIdx, sumCol].Value = "BKW";
string colletter = XlsxDumper.GetExcelColumnName(columnIdx);
ws.Cells[columnIdx, sumCol + 1].Formula = "=Sum(" + colletter + ":" + colletter + ")/1000000/4";
}
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);
}
}
public void Run()
{
PrepareUnitTest();
// ReSharper disable AssignNullToNotNullAttribute
ServiceRepository sp = new ServiceRepository(null, null, Logger, Config, new Random());
// ReSharper restore AssignNullToNotNullAttribute
var utopiaSlice = new ScenarioSliceParameters(Scenario.FromEnum(ScenarioEnum.Utopia), 2050, null);
var dbHouse = sp.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, utopiaSlice);
var heatingSystemEntries = dbHouse.Fetch <HeatingSystemEntry>();
var hausanschlusses = dbHouse.Fetch <Hausanschluss>();
DBDto dbDto = new DBDto(new List <House>(), hausanschlusses, new List <Car>(), new List <Household>(), new List <RlmProfile>());
HeatingProvider hp = new HeatingProvider(sp, utopiaSlice, dbDto);
Info("total hse: " + heatingSystemEntries.Count);
Profile sumProfile = Profile.MakeConstantProfile(0, "Sum", Profile.ProfileResolution.QuarterHour);
foreach (var entry in heatingSystemEntries)
{
(entry.HouseComponentType == HouseComponentType.Heating).Should().BeTrue();
hp.IsCorrectProvider(entry).Should().BeTrue();
HouseComponentRo hro = new HouseComponentRo("", "", 1, 1, "", "", "", 0);
ProviderParameterDto ppd = new ProviderParameterDto(entry, "", hro);
hp.PrepareLoadProfileIfNeeded(ppd);
var prof = hp.ProvideProfile(ppd);
if (prof != null)
{
if (prof.Profile == null)
{
throw new FlaException("Profile was null");
}
prof.Profile.EnergySum().Should().BeApproximately(entry.EffectiveEnergyDemand / 3, entry.EffectiveEnergyDemand * 0.1);
sumProfile = sumProfile.Add(prof.Profile.Values);
}
}
var fn = Path.Combine(WorkingDirectory.Dir, "Profiletest.xlsx");
XlsxDumper.DumpProfilesToExcel(fn, 2050, 15, new ProfileWorksheetContent("Sum", "Last", 240, sumProfile));
}
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 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 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 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);
}
private void MakeExampleWsForSmartgrid([NotNull] ScenarioSliceParameters slice, [NotNull] Profile addedProfile, double storageSize, double cappingFactor)
{
var minimzed3 = ProfileSmoothing.FindBestPowerReductionRatio(addedProfile, storageSize, out var _, out var reductionFactor3, cappingFactor);
RowCollection rc = new RowCollection("TotalReduction", "Total Reduction");
var rb = RowBuilder.Start("Reduction", reductionFactor3);
rb.Add("BatterySize [GWh]", storageSize / 1000000);
rc.Add(rb);
var fnProf = MakeAndRegisterFullFilename("SmartGridTestProfiles_centralstorage_" + slice.DstYear + "_capp_" + cappingFactor + ".xlsx", slice);
var manualParameters = ProfileSmoothing.UsePeakShaving(addedProfile,
storageSize,
true,
out var storageProfile,
reductionFactor3,
out var temporaryTargetProfile,
out var sum24HProfile,
cappingFactor);
var adjustedStorageProfile = storageProfile?.MultiplyWith(1 / 4000000.0, "Speicherfüllstand") ?? throw new FlaException();
rb.Add("Energy", manualParameters.EnergySum());
rb.Add("Min Power", manualParameters.MinPower());
rb.Add("Max Power", manualParameters.MaxPower());
XlsxDumper.DumpProfilesToExcel(fnProf,
slice.DstYear,
15,
new RowWorksheetContent(rc),
new ProfileWorksheetContent("raw", "Last [kW]", 240, addedProfile),
new ProfileWorksheetContent("manualParameters", "Netto-Last [MW]", 240, manualParameters),
new ProfileWorksheetContent("storageprofile", "Speicherfüllstand [GWh]", 240, adjustedStorageProfile),
new ProfileWorksheetContent("minimized", "Netto-Last [MW]", 240, minimzed3),
new ProfileWorksheetContent("temptarget", "Ziel-Füllstand Speicher [kWh]", 240, temporaryTargetProfile),
new ProfileWorksheetContent("sum24h", "Tages-Energiemenge [GWh]", 240, sum24HProfile)
);
SaveToPublicationDirectory(fnProf, slice, "4.5");
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var fn = MakeAndRegisterFullFilename(FilenameHelpers.CleanFileName("SummedLoadProfileExport.xlsx"), slice);
var dbArchive = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saHouses = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive, SaveableEntryTableType.SummedLoadsForAnalysis, Services.Logger);
var dbRaw = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var bkwArr = dbRaw.Fetch <BkwProfile>();
var bkwjSonProfile = bkwArr[0];
var entries = saHouses.LoadAllOrMatching();
var providerentries = entries.Where(x => x.Key.SumType == SumType.ByProvider).ToList();
List <Profile> profiles = new List <Profile>();
foreach (var providerentry in providerentries)
{
providerentry.Profile.Name = (providerentry.Key.ProviderType ?? throw new FlaException()) + " " + providerentry.Key.GenerationOrLoad;
if (providerentry.Key.GenerationOrLoad == GenerationOrLoad.Load)
{
profiles.Add(providerentry.Profile);
}
else
{
profiles.Add(providerentry.Profile.MultiplyWith(-1, providerentry.Profile.Name));
}
}
profiles = MergeProfiles(profiles);
var bkwProfile = new Profile(bkwjSonProfile.Profile);
bkwProfile.Name = "Messung 2017 [kW]";
profiles.Add(bkwProfile);
XlsxDumper.DumpProfilesToExcel(fn, slice.DstYear, 15, new ProfileWorksheetContent("Profiles", "Last [kW]", bkwProfile.Name, profiles));
SaveToArchiveDirectory(fn, RelativeDirectory.Report, slice);
SaveToPublicationDirectory(fn, slice, "4.4");
SaveToPublicationDirectory(fn, slice, "5");
Info("saved " + fn);
}
private void MakePopulationResults([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
var households = analysisRepo.GetSlice(slice).Fetch <Household>();
var occupants = households.SelectMany(x => x.Occupants).ToList();
myt[slice].AddValue("Anzahl Häuser", houses.Count, DisplayUnit.Stk);
myt[slice].AddValue("Anzahl Haushalte", households.Count, DisplayUnit.Stk);
myt[slice].AddValue("Bewohner", occupants.Count, DisplayUnit.Stk);
myt[slice].AddValue("Durchschnittsalter", occupants.Average(x => x.Age), DisplayUnit.Stk);
var male = occupants.Count(x => x.Gender == Gender.Male);
myt[slice].AddValue("Geschlecht", male / (double)occupants.Count, DisplayUnit.Percentage);
var appartments = houses.Sum(x => x.OfficialNumberOfHouseholds);
myt[slice].AddValue("Gesamtanzahl Wohnungen Ebbe", appartments, DisplayUnit.Stk);
var leereWohnungenperHouse = houses.Sum(x =>
Math.Max(x.OfficialNumberOfHouseholds -
households.GetByReferenceGuidWithEmptyReturns(x.HouseGuid, "HouseGuid", y => y.HouseGuid).Count,
0));
myt[slice].AddValue("Leerstand Ebbe", leereWohnungenperHouse, DisplayUnit.Stk);
myt[slice].AddValue("Leerstand Stadtweit", appartments - households.Count, DisplayUnit.Stk);
myt[slice].AddValue("Durchschnitt. Haushaltsgrösse", households.Average(x => x.Occupants.Count), DisplayUnit.Stk);
myt[slice].AddValue("Energiebezugsfläche", houses.Sum(x => x.EnergieBezugsFläche), DisplayUnit.Stk);
myt[slice].AddValue("Durch. Energiebezugsfläche", houses.Average(x => x.EnergieBezugsFläche), DisplayUnit.Stk);
}
var filename3 = MakeAndRegisterFullFilename("PopulationResults.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "4.4");
}
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);
}
