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");
MakePopulationResults(allSlices, analysisRepo);
MakeAreaResults(allSlices, analysisRepo);
}
public async Task StartAnalysisTest()
{
IAnalysisContext context = new MockAnalysisContext();
AnalysisRepository repo = new AnalysisRepository(context);
int id = await repo.StartAnalysisAsync("a-file-id");
Assert.AreEqual(-1, id);
}
public List <AnalysisHistory> LoadAnalysisHistories(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new List <AnalysisHistory>());
}
return(AnalysisRepository.LoadAnalysisHistories(userId));
}
public List <UserImport> LoadUserImports(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
return(new List <UserImport>());
}
return(AnalysisRepository.LoadUserImports(userId));
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
if (!Services.RunningConfig.MakeCharts)
{
return;
}
foreach (ScenarioSliceParameters parameter in allSlices)
{
RunOneYear(parameter, analysisRepo);
}
}
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 MakePVMap([NotNull] ScenarioSliceParameters slice, [NotNull] AnalysisRepository repo)
{
var pvSystems = repo.GetSlice(slice).Fetch <PvSystemEntry>();
var houses = repo.GetSlice(slice).Fetch <House>();
if (pvSystems.Count == 0)
{
return;
}
var adjustmentfactor = pvSystems.Max(x => x.EffectiveEnergyDemand) / 100;
var pvPoints = new List <MapPoint>();
foreach (var house in houses)
{
if (house.WgsGwrCoords.Count == 0)
{
continue;
}
var co = house.WgsGwrCoords[0];
var pvSystem = pvSystems.FirstOrDefault(x => x.HouseGuid == house.Guid);
if (pvSystem != null)
{
var radius = (int)(pvSystem.EffectiveEnergyDemand / adjustmentfactor);
if (radius < 10)
{
radius = 10;
}
pvPoints.Add(new MapPoint(co.Lat, co.Lon, radius, 255, 0, 0));
}
else
{
pvPoints.Add(new MapPoint(co.Lat, co.Lon, 10, 0, 0, 0));
}
}
var dstFileName2 = MakeAndRegisterFullFilename(slice.GetFileName() + "_PV_power_Map.svg", slice);
var lge = new List <MapLegendEntry> {
new MapLegendEntry(slice.DstScenario + " Jahr " + slice.DstYear, Constants.Black)
};
Services.MapDrawer.DrawMapSvg(pvPoints, dstFileName2, lge);
Info("PV Maps written");
}
public async Task AnalyzeExcelSheetAsync()
{
MappingConfig.RegisterMaps();
// open test excel file
string excelFile = Path.Combine(
Directory.GetCurrentDirectory(),
"TestBook1.xlsx");
using (var stream = new FileStream(path: excelFile, mode: FileMode.Open))
{
var context = new AnalysisContext();
var repo = new AnalysisRepository(context);
var analyzer = new ExcelAnalyzer(repo);
await analyzer.AnalyzeAsync(1, "1", stream);
}
}
public IAnalysisResult AnalyzeData(AnalysisParametersModel parameters)
{
SetAnalysisStrategy(parameters.AnalysisMethod);
var data = ImportService.LoadDataByImportId(parameters.ImportIds);
var headers = ImportService.LoadImportHeadersById(parameters.MainHeadersId);
var analysisHistory = new AnalysisHistory {
AnalysisDate = DateTime.Now
};
var analysisData = data.GroupBy(d => d.Header.Import).Select(g => new AnalysisData
{
AnalysisHistory = analysisHistory,
Import = g.Key
}).ToList();
AnalysisRepository.SaveAnalysis(analysisHistory, analysisData);
return(AnalysisStrategy.AnalyzeData(headers, data, parameters.Args));
}
public void Run()
{
AnalysisRepository ar = new AnalysisRepository(Config);
Config.LimitToScenarios.Add(Scenario.FromEnum(ScenarioEnum.Utopia));
Config.InitializeSlices(Logger);
if (Config.Slices == null)
{
throw new FlaException("No slices");
}
Config.Slices.Should().HaveCountGreaterOrEqualTo(3);
foreach (var slice in Config.Slices)
{
var house1 = ar.GetSlice(slice).Fetch <House>();
var house2 = ar.GetSlice(slice).Fetch <House>();
house1.Count.Should().Be(house2.Count);
}
}
public HouseComponentRepository([NotNull] AnalysisRepository repo,
[NotNull] ScenarioSliceParameters slice)
{
Households = repo.GetSlice(slice).Fetch <Household>();
ProcessComponents(Households);
Businesses = repo.GetSlice(slice).Fetch <BusinessEntry>();
ProcessComponents(Businesses);
PVSystems = repo.GetSlice(slice).Fetch <PvSystemEntry>();
ProcessComponents(PVSystems);
CarDistanceEntries = repo.GetSlice(slice).Fetch <CarDistanceEntry>();
ProcessComponents(CarDistanceEntries);
BuildingInfrastructures = repo.GetSlice(slice).Fetch <BuildingInfrastructure>();
ProcessComponents(BuildingInfrastructures);
Wasserkraft = repo.GetSlice(slice).Fetch <KleinWasserkraft>();
ProcessComponents(Wasserkraft);
HeatingSystemEntries = repo.GetSlice(slice).Fetch <HeatingSystemEntry>();
ProcessComponents(HeatingSystemEntries);
AirConditioningEntries = repo.GetSlice(slice).Fetch <AirConditioningEntry>();
ProcessComponents(AirConditioningEntries);
DhwEntries = repo.GetSlice(slice).Fetch <DHWHeaterEntry>();
ProcessComponents(DhwEntries);
}
public void RunSingleCrossScenarioStep()
{
RunningConfig settings = RunningConfig.MakeDefaults();
List <Stage> ptr = new List <Stage> {
Stage.ScenarioCreation
// Stage.ScenarioVisualisation,
};
settings.StagesToExecute.Clear();
settings.StagesToExecute.AddRange(ptr);
settings.MyOptions.Add(Options.ReadFromExcel);
settings.MyOptions.Add(Options.AddPresent);
settings.LimitToScenarios.Add(Scenario.FromEnum(ScenarioEnum.Utopia));
settings.LimitToYears.Add(2017);
settings.LimitToYears.Add(2050);
settings.LimitToScenarios.Add(Scenario.Present());
AnalysisRepository repo = new AnalysisRepository(settings);
using (Logger logger = new Logger(_output, settings)) {
settings.InitializeSlices(logger);
using (var container = CreateBuilderContainer(_output, logger, settings)) {
using (var scope = container.BeginLifetimeScope()) {
List <RunableForSingleSliceWithBenchmark> stuffToRun = new List <RunableForSingleSliceWithBenchmark>();
var a1 = scope.Resolve <A02_CrossSliceProfileAnalysis>();
if (settings.Slices == null)
{
throw new FlaException("slices was not initalized");
}
a1.Run(settings.Slices.ToList(), repo);
var pm = scope.Resolve <PlotMaker>();
pm.Finish();
PngSvgConverter con = new PngSvgConverter(logger, Stage.Preparation);
con.ConvertAllSVG(settings);
}
}
}
}
protected override void RunChartMaking()
{
//var dbHouse1 = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice);
var analysisRepo = new AnalysisRepository(Services.RunningConfig);
var dbHouse = analysisRepo.GetSlice(Constants.PresentSlice);
var houses = dbHouse.Fetch <House>();
var potentialHouseholds = dbHouse.Fetch <PotentialHousehold>();
var potentialBusinesses = dbHouse.Fetch <PotentialBusinessEntry>();
MakePotentialHouseholdsMap(Constants.PresentSlice);
MakePotentialBusinessMap();
EnergySankey(Constants.PresentSlice);
EnergySankeyTrafokreis(Constants.PresentSlice);
void MakePotentialHouseholdsMap(ScenarioSliceParameters slice)
{
var ssa = new SingleSankeyArrow("Potential Households", 1000, MyStage, SequenceNumber, Name, slice, Services);
ssa.AddEntry(new SankeyEntry("Potential Households total", potentialHouseholds.Count, 5000, Orientation.Straight));
var potentialHouseholdsEnergySmaller1000 = potentialHouseholds.Count(x => x.YearlyElectricityUse < 1000);
var potentialHouseholdsEnergySmaller2000 =
potentialHouseholds.Count(x => x.YearlyElectricityUse < 2000 && x.YearlyElectricityUse >= 1000);
var potentialHouseholdsEnergySmaller5000 =
potentialHouseholds.Count(x => x.YearlyElectricityUse < 5000 && x.YearlyElectricityUse >= 2000);
var potentialHouseholdsEnergyGreater5000 = potentialHouseholds.Count(x => x.YearlyElectricityUse > 5000);
ssa.AddEntry(new SankeyEntry("Haushalte mit Energie < 1000", potentialHouseholdsEnergySmaller1000 * -1, 5000, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Haushalte mit Energie < 2000", potentialHouseholdsEnergySmaller2000 * -1, 5000, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Haushalte mit Energie < 5000", potentialHouseholdsEnergySmaller5000 * -1, 5000, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Haushalte mit Energie > 5000", potentialHouseholdsEnergyGreater5000 * -1, 5000, Orientation.Down));
Services.PlotMaker.MakeSankeyChart(ssa);
RGB GetColor(House h)
{
var s = potentialHouseholds.Where(x => x.HouseGuid == h.Guid).ToString();
if (s.Length == 0)
{
return(new RGB(255, 0, 0));
}
if (h.GebäudeObjectIDs.Count == 1)
{
return(new RGB(0, 0, 255));
}
return(new RGB(0, 255, 0));
}
var mapPoints = houses.Select(x => x.GetMapPoint(GetColor)).ToList();
var filename = MakeAndRegisterFullFilename("MapHouseholdCountsPerHouse.svg", Constants.PresentSlice);
var legendEntries = new List <MapLegendEntry> {
new MapLegendEntry("No Household", 255, 0, 0),
new MapLegendEntry("Genau 1 Haushalt", 0, 0, 255),
new MapLegendEntry("Viele Haushalte", 0, 255, 0)
};
Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
}
void MakePotentialBusinessMap()
{
RGB GetColor(House h)
{
var s = potentialBusinesses.Where(x => x.HouseGuid == h.Guid).ToList();
if (s.Count == 0)
{
return(new RGB(255, 0, 0));
}
if (s.Count == 1)
{
return(new RGB(0, 0, 255));
}
return(new RGB(0, 255, 0));
}
var mapPoints = houses.Select(x => x.GetMapPoint(GetColor)).ToList();
var filename = MakeAndRegisterFullFilename("MapBusinessCountsPerHouse.svg", Constants.PresentSlice);
var legendEntries = new List <MapLegendEntry> {
new MapLegendEntry("No business", 255, 0, 0),
new MapLegendEntry("Genau 1 business", 0, 0, 255),
new MapLegendEntry("Viele geschäfte", 0, 255, 0)
};
Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
}
void EnergySankey(ScenarioSliceParameters slice)
{
var hhs = dbHouse.Fetch <PotentialHousehold>();
var business = dbHouse.Fetch <PotentialBusinessEntry>();
var buildingInfrastructures = dbHouse.Fetch <PotentialBuildingInfrastructure>();
var streetlights = dbHouse.Fetch <StreetLightingEntry>();
const double fac = 1_000_000;
var hhsum = hhs.Sum(x => x.YearlyElectricityUse) / fac;
var businessum = business.Sum(x => x.LowVoltageYearlyElectricityUse + x.HighVoltageYearlyElectricityUse) / fac;
var infrasum = buildingInfrastructures.Sum(x => x.LowVoltageTotalElectricityDemand + x.HighVoltageTotalElectricityDemand) / fac;
var streetsum = streetlights.Sum(x => x.YearlyElectricityUse) / fac;
var sum = hhsum + businessum + infrasum + streetsum;
var ssa = new SingleSankeyArrow("AufgeteilterStromverbrauch", 1000, MyStage, SequenceNumber, Name, slice, Services);
ssa.AddEntry(new SankeyEntry("Gesamt", sum, 500, Orientation.Straight));
ssa.AddEntry(new SankeyEntry("Haushalte", hhsum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Business", businessum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Buildings", infrasum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Beleuchtung", streetsum * -1, 500, Orientation.Up));
Services.PlotMaker.MakeSankeyChart(ssa);
}
void EnergySankeyTrafokreis(ScenarioSliceParameters slice)
{
var hhs = dbHouse.Fetch <PotentialHousehold>();
var business = dbHouse.Fetch <PotentialBusinessEntry>();
var buildingInfrastructures = dbHouse.Fetch <PotentialBuildingInfrastructure>();
var streetlights = dbHouse.Fetch <StreetLightingEntry>();
const double fac = 1_000_000;
var houseguids = houses.Where(x => !string.IsNullOrWhiteSpace(x.TrafoKreis)).Select(x => x.Guid).ToList();
var hhsum = hhs.Where(x => houseguids.Contains(x.HouseGuid)).Sum(x => x.YearlyElectricityUse) / fac;
var businessum = business.Where(x => houseguids.Contains(x.HouseGuid))
.Sum(x => x.LowVoltageYearlyElectricityUse + x.HighVoltageYearlyElectricityUse) / fac;
var infrasum = buildingInfrastructures.Where(x => houseguids.Contains(x.HouseGuid))
.Sum(x => x.LowVoltageTotalElectricityDemand + x.HighVoltageTotalElectricityDemand) / fac;
var streetsum = streetlights.Where(x => houseguids.Contains(x.HouseGuid)).Sum(x => x.YearlyElectricityUse) / fac;
var sum = hhsum + businessum + infrasum + streetsum;
var ssa = new SingleSankeyArrow("AufgeteilterStromverbrauchMitTrafokreis", 1000, MyStage, SequenceNumber, Name, slice, Services);
ssa.AddEntry(new SankeyEntry("Gesamt", sum, 500, Orientation.Straight));
ssa.AddEntry(new SankeyEntry("Haushalte", hhsum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Business", businessum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Buildings", infrasum * -1, 500, Orientation.Up));
ssa.AddEntry(new SankeyEntry("Beleuchtung", streetsum * -1, 500, Orientation.Up));
Services.PlotMaker.MakeSankeyChart(ssa);
}
}
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);
}
public void Run([NotNull][ItemNotNull] List <ScenarioSliceParameters> slices, [NotNull] AnalysisRepository analysisRepo)
{
if (!slices.Any(x => x.Equals(Constants.PresentSlice)))
{
throw new FlaException("Missing present slice. Have: " + string.Join("\n", slices.Select(x => x.ToString())));
}
Info("Starting " + Name);
var sw = new Stopwatch();
sw.Start();
MakeChartFunctionExecuted = false;
RunActualProcess(slices, analysisRepo);
if (Services.RunningConfig.MakeCharts)
{
var sw2 = new Stopwatch();
Info("Starting " + Name + " - Chartmaking");
MakeChartFunctionExecuted = true;
RunChartMaking(slices);
sw2.Stop();
Info("Finished " + Name + " - Chartmaking: " + Helpers.GetElapsedTimeString(sw2));
}
sw.Stop();
Info("Finished running " + Name + ": " + Helpers.GetElapsedTimeString(sw));
LogCall(sw);
}
protected abstract void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo);
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
if (!Services.RunningConfig.MakeCharts)
{
return;
}
Info("starting to make house results");
LineSeriesEntry housesCount = new LineSeriesEntry("Häuser");
LineSeriesEntry householdsCount = new LineSeriesEntry("Haushalte");
LineSeriesEntry occupantsCount = new LineSeriesEntry("Bewohner");
List <ScenarioSliceParameters> missingSlices = new List <ScenarioSliceParameters>();
foreach (var slice in allSlices)
{
Info("Checking for slice " + slice);
var db = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, 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 Slice Names: " + missingSlicesStr);
}
foreach (var slice in allSlices)
{
Info("Reading slice " + slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
housesCount.Values.Add(new Point(slice.DstYear, houses.Count));
var households = analysisRepo.GetSlice(slice).Fetch <Household>();
householdsCount.Values.Add(new Point(slice.DstYear, households.Count));
var occupants = households.SelectMany(x => x.Occupants).ToList();
occupantsCount.Values.Add(new Point(slice.DstYear, occupants.Count));
}
var s = Constants.PresentSlice;
var filename1 = MakeAndRegisterFullFilename("HousesForScenario." + s + ".png", s);
Services.PlotMaker.MakeLineChart(filename1, "Anzahl Häuser", housesCount, new List <AnnotationEntry>());
var filename2 = MakeAndRegisterFullFilename("HouseholdsForScenario." + s + ".png", s);
Services.PlotMaker.MakeLineChart(filename2, "Anzahl Haushalte", householdsCount, new List <AnnotationEntry>());
var filename3 = MakeAndRegisterFullFilename("OccupantForScenario." + s + ".png", s);
Services.PlotMaker.MakeLineChart(filename3, "Anzahl Einwohner", occupantsCount, new List <AnnotationEntry>());
}
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 List <ImportHeader> LoadImportHeaders(List <long> importIds)
{
return(AnalysisRepository.LoadImportHeaders(importIds));
}
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)
{
Info("starting to make house results");
MultiyearTrend myt = new MultiyearTrend();
foreach (var slice in allSlices)
{
var households = analysisRepo.GetSlice(slice).Fetch <Household>();
var occupants = households.SelectMany(x => x.Occupants).ToList();
HouseComponentRepository hcr = new HouseComponentRepository(analysisRepo, slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
houses[0].CollectHouseComponents(hcr);
myt[slice].AddValue("Businesses", hcr.Businesses.Count, DisplayUnit.Stk);
myt[slice].AddValue("Haushalt Energieverbrauch [GWh]", hcr.Households.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.GWh);
myt[slice].AddValue("Business Energieverbrauch [GWh]", hcr.Businesses.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.GWh);
myt[slice].AddValue("Gebäudeinfrastruktur Energieverbrauch [GWh]",
hcr.BuildingInfrastructures.Sum(x => x.EffectiveEnergyDemand),
DisplayUnit.GWh);
myt[slice].AddValue("Wärmepumpen Energieverbrauch [GWh]",
hcr.HeatingSystemEntries.Where(x => x.SynthesizedHeatingSystemType == HeatingSystemType.Heatpump)
.Sum(x => x.EffectiveEnergyDemand),
DisplayUnit.GWh);
myt[slice].AddValue("Klimatisierung Energieverbrauch [GWh]",
hcr.AirConditioningEntries.Sum(x => x.EffectiveEnergyDemand),
DisplayUnit.GWh);
var dhws = analysisRepo.GetSlice(slice).Fetch <DHWHeaterEntry>();
myt[slice].AddValue("Energiebedarf Warmwasserboiler [GWh]", dhws.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.GWh);
myt[slice].AddValue("PV Energie [Gwh]", hcr.PVSystems.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.GWh);
double distance = hcr.CarDistanceEntries.Sum(x => x.CommutingDistance + x.FreizeitDistance) / occupants.Count;
myt[slice].AddValue("Wegedistanz / Person / Jahr", distance, DisplayUnit.Stk);
myt[slice].AddValue("Car Distance Entries", hcr.CarDistanceEntries.Count, DisplayUnit.Stk);
myt[slice].AddValue("Anzahl Gebäudeinfrastruktur", hcr.BuildingInfrastructures.Count, DisplayUnit.Stk);
myt[slice].AddValue("Wasserkraftwerke", hcr.Wasserkraft.Count, DisplayUnit.Stk);
myt[slice].AddValue("Wasserkraftwerke Energie", hcr.Wasserkraft.Sum(x => x.EffectiveEnergyDemand), DisplayUnit.Stk);
myt[slice].AddValue("Heizsysteme Anzahl", hcr.HeatingSystemEntries.Count, DisplayUnit.Stk);
myt[slice].AddValue("Heizsysteme Gesamtenergiebedarf [GWh]",
hcr.HeatingSystemEntries.Sum(x => x.EffectiveEnergyDemand),
DisplayUnit.GWh);
myt[slice].AddValue("Heizsysteme Wärmepumpen Anzahl",
hcr.HeatingSystemEntries.Count(x => x.SynthesizedHeatingSystemType == HeatingSystemType.Heatpump),
DisplayUnit.Stk);
myt[slice].AddValue("Klimatisierung Anzahl", hcr.AirConditioningEntries.Count, DisplayUnit.Stk);
var cars = analysisRepo.GetSlice(slice).Fetch <Car>();
myt[slice].AddValue("Autos gesamt", cars.Count, DisplayUnit.Stk);
myt[slice].AddValue("Elektroautos", cars.Count(x => x.CarType == CarType.Electric), DisplayUnit.Stk);
myt[slice].AddValue("DHW Elektrisch", dhws.Count(x => x.DhwHeatingSystemType == DhwHeatingSystem.Electricity), DisplayUnit.Stk);
myt[slice].AddValue("DHW Heatpump", dhws.Count(x => x.DhwHeatingSystemType == DhwHeatingSystem.Heatpump), DisplayUnit.Stk);
}
var filename3 = MakeAndRegisterFullFilename("HouseEnergyResults.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearTrendToExcel(filename3, myt);
SaveToArchiveDirectory(filename3, RelativeDirectory.Report, Constants.PresentSlice);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "4.4");
}
private void RunOneYear([NotNull] ScenarioSliceParameters slice, [NotNull] AnalysisRepository repo)
{
MakePVMap(slice, repo);
}
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);
}
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 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);
}
#pragma warning disable xUnit1013 // Public method should be marked as test
public void RunBasedOnSettings([NotNull] RunningConfig settings, [NotNull] Logger logger)
#pragma warning restore xUnit1013 // Public method should be marked as test
{
Stopwatch sw = new Stopwatch();
sw.Start();
var container = CreateBuilderContainer(_output, logger, settings);
Dictionary <string, double> secondsPerStep = new Dictionary <string, double>();
using (var scope = container.BeginLifetimeScope()) {
var allItems = container.Resolve <IEnumerable <IBasicRunner> >().ToList();
logger.Info("#The following scenarios are going to be processed.", Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
if (settings.Slices == null)
{
throw new FlaException("slices was not initalized");
}
foreach (ScenarioSliceParameters scenarioSliceParameters in settings.Slices)
{
logger.Info("\t" + scenarioSliceParameters, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
}
logger.Info("#The following stages are going to be processed.", Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
foreach (Stage stage in settings.StagesToExecute)
{
logger.Info("\t" + stage, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
}
for (int stageIdx = 0; stageIdx < settings.StagesToExecute.Count; stageIdx++)
{
Stage currentStage = settings.StagesToExecute[stageIdx];
logger.Info("## Starting Stage " + currentStage, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
var steps = allItems.Where(x => x.MyStage == currentStage).ToList();
steps.Sort((x, y) => x.SequenceNumber.CompareTo(y.SequenceNumber));
logger.Info("### The following steps in this stage are going to be processed.",
Stage.Preparation,
nameof(MainBurgdorfStatisticsCreator));
foreach (var step in steps)
{
logger.Info("\t" + step.SequenceNumber + " - " + step.Name, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
}
CheckAndValidateSteps(steps, logger, currentStage, out var stepType);
switch (stepType)
{
case Steptype.Global: {
ProcessGlobalSteps(steps, secondsPerStep);
logger.SaveToDatabase(Constants.PresentSlice);
break;
}
case Steptype.SliceProcessors: {
ProcessSliceSteps(steps, logger, settings, secondsPerStep, currentStage);
break;
}
case Steptype.Scenario: {
List <RunnableForScenarioWithBenchmark> scenarioSteps = steps.Select(x => (RunnableForScenarioWithBenchmark)x).ToList();
var scenariosToProcess = settings.Slices.Select(x => x.DstScenario).Distinct().ToList();
if (scenariosToProcess.Contains(Scenario.Present()) && currentStage == Stage.ScenarioCreation)
{
scenariosToProcess.Remove(Scenario.Present());
}
foreach (var scenario in scenariosToProcess)
{
logger.Info("Processing " + scenario, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
var slicesWithScenario = settings.Slices.Where(x => x.DstScenario == scenario).ToList();
foreach (var step in scenarioSteps)
{
Stopwatch stopwatch = Stopwatch.StartNew();
step.Run(settings.Slices.ToList());
logger.SaveToDatabase(slicesWithScenario.Last());
var stepname = currentStage + "-" + step.Name;
stopwatch.Stop();
if (!secondsPerStep.ContainsKey(stepname))
{
secondsPerStep.Add(stepname, 0);
}
secondsPerStep[stepname] += stopwatch.ElapsedMilliseconds / 1000.0;
}
logger.Info("Finished processing " + scenario, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
}
}
break;
case Steptype.AllScenarios: {
List <RunnableForAllScenarioWithBenchmark> crossScenarioSteps =
steps.Select(x => (RunnableForAllScenarioWithBenchmark)x).ToList();
AnalysisRepository analysisRepository = new AnalysisRepository(settings);
foreach (var step in crossScenarioSteps)
{
Stopwatch stopwatch = Stopwatch.StartNew();
step.Run(settings.Slices.ToList(), analysisRepository);
logger.SaveToDatabase(Constants.PresentSlice);
var stepname = currentStage + "-" + step.Name;
stopwatch.Stop();
if (!secondsPerStep.ContainsKey(stepname))
{
secondsPerStep.Add(stepname, 0);
}
secondsPerStep[stepname] += stopwatch.ElapsedMilliseconds / 1000.0;
}
}
break;
default:
throw new Exception("unknown steptype");
}
logger.Info("Finished Stage " + currentStage + ", waiting for the charts to finish.",
Stage.Preparation,
nameof(MainBurgdorfStatisticsCreator));
var plotMaker = scope.Resolve <PlotMaker>();
plotMaker.Finish();
logger.Info("Finished Stage " + currentStage, Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
}
logger.SaveToDatabase(Constants.PresentSlice);
if (settings.MakeStageEntries)
{
PngSvgConverter psc = new PngSvgConverter(logger, Stage.Preparation);
psc.ConvertAllSVG(settings);
}
sw.Stop();
logger.Info("Finished everything after " + sw.Elapsed.TotalMinutes + " minutes",
Stage.Preparation,
nameof(MainBurgdorfStatisticsCreator));
foreach (var pair in secondsPerStep)
{
logger.Info(pair.Key + "\t" + pair.Value.ToString("F2"), Stage.Preparation, "Main");
}
logger.Info("Listing open threads before closing the logger", Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
ThreadProvider.Get().DisplayRunningThreads();
logger.Info("Listing open threads after closing the logger", Stage.Preparation, nameof(MainBurgdorfStatisticsCreator));
logger.FinishSavingEverything();
ThreadProvider.Get().DisplayRunningThreads();
}
container.Dispose();
}
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([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 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>());
}
}