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 RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make heating system results");
MultiyearMultiVariableTrend myt = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
var heating = analysisRepo.GetSlice(slice).Fetch <HeatingSystemEntry>();
if (heating.Count == 0)
{
throw new FlaException("no heating entries for " + slice);
}
Dictionary <HeatingSystemType, double> heatDemandByType = new Dictionary <HeatingSystemType, double>();
Dictionary <HeatingSystemType, double> energyDemandByType = new Dictionary <HeatingSystemType, double>();
Dictionary <HeatingSystemType, double> countByType = new Dictionary <HeatingSystemType, double>();
Dictionary <int, double> heatDemandByYear = new Dictionary <int, double>();
foreach (var hse in heating)
{
if (!heatDemandByType.ContainsKey(hse.SynthesizedHeatingSystemType))
{
heatDemandByType.Add(hse.SynthesizedHeatingSystemType, 0);
energyDemandByType.Add(hse.SynthesizedHeatingSystemType, 0);
countByType.Add(hse.SynthesizedHeatingSystemType, 0);
}
heatDemandByType[hse.SynthesizedHeatingSystemType] += hse.HeatDemand;
energyDemandByType[hse.SynthesizedHeatingSystemType] += hse.EffectiveEnergyDemand;
countByType[hse.SynthesizedHeatingSystemType] += 1;
foreach (var demand in hse.HeatDemands)
{
if (!heatDemandByYear.ContainsKey(demand.Year))
{
heatDemandByYear.Add(demand.Year, 0);
}
heatDemandByYear[demand.Year] += demand.HeatDemand;
}
}
foreach (var pair in heatDemandByType)
{
myt[slice].AddValue("HeatDemand", pair.Key.ToString(), pair.Value, DisplayUnit.GWh);
}
foreach (var pair in energyDemandByType)
{
myt[slice].AddValue("Energy Demand", pair.Key.ToString(), pair.Value, DisplayUnit.GWh);
}
foreach (var pair in countByType)
{
myt[slice].AddValue("Count", pair.Key.ToString(), pair.Value, DisplayUnit.Stk);
}
foreach (var pair in heatDemandByYear)
{
myt[slice].AddValue("HeatDemandByYear", pair.Key.ToString(), pair.Value, DisplayUnit.GWh);
}
}
var filename3 = MakeAndRegisterFullFilename("HeatingSystemTrends.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make trafostation results");
MultiyearMultiVariableTrend myt = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
HouseComponentRepository hcr = new HouseComponentRepository(analysisRepo, slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
Dictionary <string, double> loadPerEnergyType = new Dictionary <string, double>();
Dictionary <string, double> genPerEnergyType = new Dictionary <string, double>();
Dictionary <string, double> loadPerComponentType = new Dictionary <string, double>();
Dictionary <string, double> genPerPerComponentType = new Dictionary <string, double>();
foreach (var house in houses)
{
var components = house.CollectHouseComponents(hcr);
foreach (var component in components)
{
if (component.HausAnschlussGuid == null)
{
continue;
}
string energyType = component.EnergyType.ToString();
string componentType = component.HouseComponentType + " - " + energyType;
if (component.GenerationOrLoad == GenerationOrLoad.Load)
{
if (!loadPerEnergyType.ContainsKey(energyType))
{
loadPerEnergyType.Add(energyType, 0);
}
loadPerEnergyType[energyType] += component.EffectiveEnergyDemand;
if (!loadPerComponentType.ContainsKey(componentType))
{
loadPerComponentType.Add(componentType, 0);
}
loadPerComponentType[componentType] += component.EffectiveEnergyDemand;
}
else if (component.GenerationOrLoad == GenerationOrLoad.Generation)
{
if (!genPerEnergyType.ContainsKey(energyType))
{
genPerEnergyType.Add(energyType, 0);
}
genPerEnergyType[energyType] += component.EffectiveEnergyDemand;
if (!genPerPerComponentType.ContainsKey(componentType))
{
genPerPerComponentType.Add(componentType, 0);
}
genPerPerComponentType[componentType] += component.EffectiveEnergyDemand;
}
else
{
throw new FlaException("invalid type");
}
}
}
foreach (var pair in loadPerEnergyType)
{
myt[slice].AddValue("LoadPerEnergyType", pair.Key, pair.Value, DisplayUnit.GWh);
}
foreach (var pair in genPerEnergyType)
{
myt[slice].AddValue("GenerationPerEnergyType", pair.Key, pair.Value, DisplayUnit.GWh);
}
loadPerComponentType = Helpers.MakeSortedDictionary(loadPerComponentType);
foreach (var pair in loadPerComponentType)
{
myt[slice].AddValue("LoadPerComponentType", pair.Key, pair.Value, DisplayUnit.GWh);
}
genPerPerComponentType = Helpers.MakeSortedDictionary(genPerPerComponentType);
foreach (var pair in genPerPerComponentType)
{
myt[slice].AddValue("GenerationPerComponentType", pair.Key, pair.Value, DisplayUnit.GWh);
}
}
var filename3 = MakeAndRegisterFullFilename("TotalEnergyResultsAreaCharts.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make trafostation results");
MultiyearMultiVariableTrend myt = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
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 providerentries1 = entries.Where(x => x.Key.SumType == SumType.ByProvider).ToList();
double electricitySum = 0;
foreach (var entry in providerentries1)
{
if (entry.GenerationOrLoad == GenerationOrLoad.Generation)
{
continue;
}
double energy = entry.Profile.EnergySum();
string providertype = (entry.Key.ProviderType ?? throw new FlaException("No provider set")) + " " + entry.GenerationOrLoad;
Info("Providertype: " + providertype);
electricitySum += energy;
}
HouseComponentRepository hcr = new HouseComponentRepository(analysisRepo, slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
Dictionary <string, double> loadPerEnergyType = new Dictionary <string, double>();
Dictionary <string, double> genPerEnergyType = new Dictionary <string, double>();
foreach (var house in houses)
{
var components = house.CollectHouseComponents(hcr);
foreach (var component in components)
{
if (component.HausAnschlussGuid == null)
{
continue;
}
string energyType = component.EnergyType.ToString();
if (component.GenerationOrLoad == GenerationOrLoad.Load)
{
if (!loadPerEnergyType.ContainsKey(energyType))
{
loadPerEnergyType.Add(energyType, 0);
}
loadPerEnergyType[energyType] += component.EffectiveEnergyDemand;
}
else if (component.GenerationOrLoad == GenerationOrLoad.Generation)
{
if (!genPerEnergyType.ContainsKey(energyType))
{
genPerEnergyType.Add(energyType, 0);
}
genPerEnergyType[energyType] += component.EffectiveEnergyDemand;
}
else
{
throw new FlaException("invalid type");
}
}
}
foreach (var pair in loadPerEnergyType)
{
if (pair.Key == "Strom")
{
myt[slice].AddValue("Jahresenergiebedarf [GWh]",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
electricitySum,
DisplayUnit.GWh);
}
else
{
myt[slice].AddValue("Jahresenergiebedarf [GWh]",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
pair.Value,
DisplayUnit.GWh);
}
}
foreach (var pair in genPerEnergyType)
{
if (pair.Key == "Strom")
{
myt[slice].AddValue("GenerationPerEnergyType",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
electricitySum,
DisplayUnit.GWh);
}
else
{
myt[slice].AddValue("GenerationPerEnergyType", ChartHelpers.GetFriendlyEnergTypeName(pair.Key), pair.Value, DisplayUnit.GWh);
}
}
}
var filename3 = MakeAndRegisterFullFilename("EnergieProEnergieträger.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, myt);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "5");
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
List <ScenarioSliceParameters> missingSlices = new List <ScenarioSliceParameters>();
foreach (var slice in allSlices)
{
Info("Checking for slice " + slice);
var db = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice);
var fi = new FileInfo(db.DBFilename);
if (!fi.Exists)
{
missingSlices.Add(slice);
}
}
if (missingSlices.Count > 0)
{
var missingSliceNames = missingSlices.Select(x => x.ToString()).ToList();
string missingSlicesStr = string.Join("\n", missingSliceNames);
throw new FlaException("Missing Profile Slices: " + missingSlicesStr);
}
Info("starting to make trafostation results");
MultiyearMultiVariableTrend mytProviders = new MultiyearMultiVariableTrend();
MultiyearMultiVariableTrend mytComponents = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
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 providerentries1 = entries.Where(x => x.Key.SumType == SumType.ByProvider).ToList();
providerentries1.Sort((x, y) => String.Compare(x.Key.ProviderType, y.Key.ProviderType, StringComparison.Ordinal));
Dictionary <Tuple <string, GenerationOrLoad>, double> energyByName = new Dictionary <Tuple <string, GenerationOrLoad>, double>();
foreach (var entry in providerentries1)
{
double energy = entry.Profile.EnergySum();
string providertype = (entry.Key.ProviderType ?? throw new FlaException("No provider set")) + " " + entry.GenerationOrLoad;
Info("Providertype: " + providertype);
var friendlyName = ChartHelpers.GetFriendlyProviderName(providertype);
var key = new Tuple <string, GenerationOrLoad>(friendlyName, entry.GenerationOrLoad);
if (!energyByName.ContainsKey(key))
{
energyByName.Add(key, 0);
}
energyByName[key] += energy;
}
foreach (var pair in energyByName)
{
if (pair.Key.Item2 == GenerationOrLoad.Load)
{
mytProviders[slice].AddValue("Stromlast [GWh]", pair.Key.Item1, pair.Value, DisplayUnit.GWh);
}
else
{
mytProviders[slice].AddValue("Erzeugung [GWh]", pair.Key.Item1, pair.Value, DisplayUnit.GWh);
}
}
var componentEntries = entries.Where(x => x.Key.SumType == SumType.ByHouseholdComponentType).ToList();
componentEntries.Sort((x, y) => String.Compare(x.Key.HouseComponentType, y.Key.HouseComponentType, StringComparison.Ordinal));
foreach (var entry in componentEntries)
{
double energy = entry.Profile.EnergySum();
string houseComponentType = entry.Key.HouseComponentType ?? throw new FlaException("No provider set");
Info("HouseComponentType: " + houseComponentType);
if (entry.Key.GenerationOrLoad == GenerationOrLoad.Load)
{
mytComponents[slice].AddValue("ComponentLoad", houseComponentType, energy, DisplayUnit.GWh);
}
else
{
mytComponents[slice].AddValue("ComponentGeneration", houseComponentType, energy, DisplayUnit.GWh);
}
}
}
var filename3 = MakeAndRegisterFullFilename("EnergieProVerbraucher.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, mytProviders);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "5");
var filename4 = MakeAndRegisterFullFilename("ComponentProfileEnergyCharts.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename4);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename4, mytComponents);
SaveToArchiveDirectory(filename4, RelativeDirectory.Report, Constants.PresentSlice);
}
