private void ReportProgress(DateTime start,
int processedHouseCount,
int totalNumberOfComponents,
[NotNull] ScenarioSliceParameters slice,
ref DateTime lastLog,
[NotNull] Stopwatch collecting,
[NotNull] Stopwatch writing)
{
TimeSpan durationsinceLastLog = DateTime.Now - lastLog;
if (durationsinceLastLog.TotalSeconds < 10)
{
return;
}
lastLog = DateTime.Now;
TimeSpan duration = DateTime.Now - start;
double average = processedHouseCount / duration.TotalSeconds;
double timeLeft = (totalNumberOfComponents - processedHouseCount) / average / 60;
_services.Logger.Info(slice + ": processed " + processedHouseCount + "/" + totalNumberOfComponents + " components in " +
duration.TotalSeconds + "s, for a rate of " + average + " per second, estimated time left: " +
timeLeft.ToString("F1") + " minutes, collecting took " + collecting.Elapsed + ", writing took " + writing.Elapsed,
Stage.ProfileGeneration,
"HouseProcessor");
}
public static string MakeAndRegisterFullFilenameStatic([NotNull] string filename,
Stage stage,
int sequenceNumber,
[NotNull] string name,
[NotNull] ScenarioSliceParameters slice,
[NotNull] RunningConfig config,
bool replaceSpaces)
{
if (replaceSpaces)
{
filename = filename.Replace(" ", "");
}
var fullpath = GetTargetDirectory(stage, sequenceNumber, name, slice, config);
if (!Directory.Exists(fullpath))
{
Directory.CreateDirectory(fullpath);
Thread.Sleep(500);
}
var fullName = Path.Combine(fullpath, filename);
if (_usedFileNames.ContainsKey(fullName))
{
throw new FlaException("File already registered: " + fullName + " @ this location:\n" + _usedFileNames[fullName] +
" \n--------------------------\n");
}
StackTrace t = new StackTrace();
_usedFileNames.Add(fullName, t.ToString());
return(fullName);
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var dbSrcProfiles = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
var dbDstProfiles = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice);
dbDstProfiles.RecreateTable <ResidualProfile>();
var bkw = dbSrcProfiles.Fetch <BkwProfile>();
var rlmProfiles = dbSrcProfiles.Fetch <RlmProfile>();
var main = new Profile(bkw[0].Profile);
foreach (var rlm in rlmProfiles)
{
Profile profile = new Profile(rlm.Name, rlm.Profile.Values, rlm.Profile.EnergyOrPower);
main = main.Minus(profile, "residual");
}
JsonSerializableProfile jsp = new JsonSerializableProfile(main);
var residualProfile = new ResidualProfile("Residual after all RLMs")
{
Profile = jsp
};
dbDstProfiles.BeginTransaction();
dbDstProfiles.Save(residualProfile);
dbDstProfiles.CompleteTransaction();
}
private void CopyCSVFiles([NotNull] ScenarioSliceParameters parameters, int sequence, [NotNull] string exporteRName, [NotNull] string subPath)
{
var path = FilenameHelpers.GetTargetDirectory(Stage.ProfileExport, sequence, exporteRName, parameters);
var di = new DirectoryInfo(Path.Combine(path, "Export"));
if (!di.Exists)
{
throw new FlaException("Directory " + di.FullName + " does not exist");
}
var csvfiles = di.GetFiles("*.csv");
if (csvfiles.Length == 0)
{
throw new FlaException("No exported files found");
}
string dstpath = @"v:\tstcopy\v01";
dstpath = Path.Combine(dstpath, parameters.DstScenario.ToString(), parameters.DstYear.ToString(), subPath);
if (Directory.Exists(dstpath))
{
Directory.Delete(dstpath, true);
Thread.Sleep(500);
}
Directory.CreateDirectory(dstpath);
Thread.Sleep(500);
foreach (var fileInfo in csvfiles)
{
string dstfullName = Path.Combine(dstpath, fileInfo.Name);
Info("Copying " + dstfullName);
fileInfo.CopyTo(dstfullName);
}
}
public void SaveToPublicationDirectory([NotNull] string fn, [NotNull] ScenarioSliceParameters slice, [NotNull] string chapter)
{
var dstDir = GetResultArchiveDirectory(slice, Services.StartingTime, Services.RunningConfig, RelativeDirectory.Abschlussbericht, chapter);
FileInfo fi1 = new FileInfo(fn);
fi1.CopyTo(Path.Combine(dstDir, fi1.Name), true);
}
private void MakeResultExcel([NotNull][ItemNotNull] List <CSVFile> csvs, [NotNull] ScenarioSliceParameters slice)
{
string suffix = csvs[0].GenerationOrLoad.ToString();
using (var p = new ExcelPackage()) {
var ws = p.Workbook.Worksheets.Add("MySheet");
var tgt = FilenameHelpers.GetTargetDirectory(MyStage,
SequenceNumber,
nameof(C01_CSVProfileVisualizer),
slice,
Services.RunningConfig);
var row = 1;
var col = 1;
ws.Cells[row, col++].Value = "TrafoKreis";
ws.Cells[row, col++].Value = "ISN ID";
ws.Cells[row, col++].Value = "CSV Energy";
ws.Cells[row, col].Value = "DB Energy";
row++;
foreach (var csvFile in csvs)
{
foreach (var csvLine in csvFile.Lines)
{
col = 1;
ws.Cells[row, col++].Value = csvFile.TsName;
ws.Cells[row, col++].Value = csvLine.HausanschlussID;
var csvEnergy = csvLine.CalculateTotalEnergy();
ws.Cells[row, col].Value = csvEnergy;
}
}
p.SaveAs(new FileInfo(Path.Combine(tgt, "ComparisonCSVvsDB" + suffix + ".xlsx")));
}
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSliceNotNull);
var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
dbDstHouses.RecreateTable <BusinessEntry>();
var srcBusinessEntries = dbSrcHouses.Fetch <BusinessEntry>();
if (srcBusinessEntries.Count == 0)
{
throw new FlaException("No srcBusinessEntries were found");
}
dbDstHouses.BeginTransaction();
double factor = slice.EnergyReductionFactorBusiness;
if (Math.Abs(factor) < 0.000001)
{
throw new FlaException("Factor 0 for energy reduction in slice " + slice);
}
foreach (var entry in srcBusinessEntries)
{
entry.ID = 0;
entry.SetEnergyReduction(slice.DstYear.ToString(), entry.EffectiveEnergyDemand * (1 - factor));
entry.LocalnetEntries.Clear();
dbDstHouses.Save(entry);
}
dbDstHouses.CompleteTransaction();
}
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(ScenarioSliceParameters slice)
{
string srcPath = FilenameHelpers.GetTargetDirectory(Stage.ProfileGeneration,
500,
nameof(E_ApplySmartGridToGeneratedProfiles),
slice,
Services.RunningConfig);
string lz4ProfilePath = Path.Combine(srcPath, "addedProfile.lz4");
byte[] arr = File.ReadAllBytes(lz4ProfilePath);
var addedProfileraw = LZ4MessagePackSerializer.Deserialize <Profile>(arr);
var pos = addedProfileraw.GetOnlyPositive("pos");
var neg = addedProfileraw.GetOnlyNegative("neg");
var addedProfile = pos.Add(neg, "added");
var maxDailyGen = addedProfile.MakeDailyAverages().Values.Max() * 24 * 4;
double storageSize = maxDailyGen * 2;
MakeXlsForCurrentProfile(slice);
MakeExampleWsForSmartgrid(slice, addedProfile, storageSize, 1);
MakeExampleWsForSmartgrid(slice, addedProfile, storageSize, 0.5);
MakeStorageSizeSheet(slice, maxDailyGen, addedProfile);
MakeAbregelungWorksheet(slice, maxDailyGen, addedProfile);
}
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));
}
public void RunForScenarios([NotNull] ScenarioSliceParameters parameters)
{
ClearTargetDirectory(parameters);
Debug("Starting " + Name);
Info("Slice " + parameters.DstScenario + " - " + parameters.DstYear);
var sw = new Stopwatch();
sw.Start();
RunActualProcess(parameters);
if (Services.RunningConfig.MakeCharts)
{
var sw2 = new Stopwatch();
Debug("Starting " + Name + " - Chartmaking");
MakeChartFunctionExecuted = true;
RunChartMaking(parameters);
sw2.Stop();
Debug("Finished " + Name + " - Chartmaking: " + Helpers.GetElapsedTimeString(sw2));
}
if (VisualizeSlice != null && Services.RunningConfig.MakeCharts)
{
var sw3 = new Stopwatch();
Debug("Starting " + Name + " - visualization");
// ReSharper disable once PossibleNullReferenceException
VisualizeSlice.MakeVisualization(parameters, this);
sw3.Stop();
Debug("Finished " + Name + " - visualization: " + Helpers.GetElapsedTimeString(sw3));
}
LogCall(sw);
sw.Stop();
Info("Finished " + Name + ": " + Helpers.GetElapsedTimeString(sw) + "Scenario " + parameters.DstScenario + " - " + parameters.DstYear);
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
if (slice.PreviousSlice == null)
{
throw new FlaException("Previous slice was null");
}
var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSlice);
var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
dbDstHouses.RecreateTable <KleinWasserkraft>();
var srcKwk = dbSrcHouses.Fetch <KleinWasserkraft>();
if (srcKwk.Count == 0)
{
throw new Exception("No building infrastructures were found");
}
dbDstHouses.BeginTransaction();
foreach (var wasserkraft in srcKwk)
{
wasserkraft.ID = 0;
dbDstHouses.Save(wasserkraft);
}
dbDstHouses.CompleteTransaction();
}
private static List <string> WriteExcelResultFiles([NotNull] ScenarioSliceParameters parameters,
[NotNull] Func <string, ScenarioSliceParameters, bool, string> makeAndRegisterFullFilename,
ProcessingMode processingMode,
[NotNull] ProfileGenerationRo pgRo)
{
List <string> excelFileNames = new List <string>();
var fn1 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".Tree.xlsx", parameters, true);
excelFileNames.Add(fn1);
pgRo.DumpToExcel(fn1, XlsResultOutputMode.Tree);
var fn2 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".Full.xlsx", parameters, true);
pgRo.DumpToExcel(fn2, XlsResultOutputMode.FullLine);
excelFileNames.Add(fn2);
var fn3 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".ByTrafoStationTree.xlsx",
parameters,
true);
excelFileNames.Add(fn3);
pgRo.DumpToExcel(fn3, XlsResultOutputMode.ByTrafoStationTree);
var fn4 = makeAndRegisterFullFilename("AllGeneratedLoadProfilesAndEnergy." + processingMode + ".ByTrafoStationHausanschlussTree.xlsx",
parameters,
true);
excelFileNames.Add(fn4);
pgRo.DumpToExcel(fn4, XlsResultOutputMode.ByTrafoStationHausanschlussTree);
return(excelFileNames);
}
private static void WriteBrokenLpgCalcCleanupBatch([NotNull] ScenarioSliceParameters parameters,
[NotNull] Func <string, ScenarioSliceParameters, bool, string> makeAndRegisterFullFilename,
ProcessingMode processingMode,
[NotNull][ItemNotNull] List <string> brokenLpgDirectories,
[NotNull][ItemNotNull] List <string> brokenLpgJsons)
{
var lpgCleaner = makeAndRegisterFullFilename("CleanBrokenLPGStuff." + processingMode + "." + parameters.GetFileName() + ".cmd",
parameters,
true);
Encoding utf8WithoutBom = new UTF8Encoding(false);
FileStream fs = new FileStream(lpgCleaner, FileMode.Create);
StreamWriter sw = new StreamWriter(fs, utf8WithoutBom);
sw.WriteLine("chcp 65001");
foreach (string brokenLpgDirectory in brokenLpgDirectories)
{
sw.WriteLine("rmdir /S /Q \"" + brokenLpgDirectory + "\" ");
}
foreach (string brokenLpgJson in brokenLpgJsons)
{
sw.WriteLine("del \"" + brokenLpgJson + "\" ");
}
sw.Close();
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
Log(MessageType.Debug, "running house copying");
Services.SqlConnection.RecreateTable <Household>(Stage.Houses, slice);
var dbSrcHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, slice.PreviousScenarioNotNull).Database;
var dbDstHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, slice).Database;
var dstHouses = dbDstHouses.Fetch <House>();
var srcHouseholds = dbSrcHouses.Fetch <Household>();
dbDstHouses.BeginTransaction();
var houseHoldsByHouseKey = new Dictionary <string, List <Household> >();
foreach (var hh in srcHouseholds)
{
if (!houseHoldsByHouseKey.ContainsKey(hh.HouseGuid))
{
houseHoldsByHouseKey.Add(hh.HouseGuid, new List <Household>());
}
houseHoldsByHouseKey[hh.HouseGuid].Add(hh);
}
/*
* WeightedRandomAllocator<House> wra = new WeightedRandomAllocator<House>(Services.Rnd);
* List<House> tornDownHouses = wra.PickObjects(srcHouses, (x => x.AverageBuildingAge), parameters.TornDownHouses);
*
*
* List<House> newHouses = new List<House>();
* for (int i = 0; i < parameters.NewlyBuiltHouses; i++) {
* //replace an existing house
* if (tornDownHouses.Count > 0) {
* House pickedHouse = null;
* pickedHouse = tornDownHouses[Services.Rnd.Next(tornDownHouses.Count)];
* tornDownHouses.Remove(pickedHouse);
* }
* else
* {
* var h = new House();
* h.Area = pickedHouse 200 + Services.Rnd.NextDouble(1000);
* h.AverageBuildingAge = 0;
* }
* }*/
int householdsSaved = 0;
foreach (var house in dstHouses)
{
if (houseHoldsByHouseKey.ContainsKey(house.HouseGuid))
{
var hhs = houseHoldsByHouseKey[house.HouseGuid];
foreach (var hh in hhs)
{
hh.HouseholdID = 0;
dbDstHouses.Save(hh);
householdsSaved++;
}
}
}
Log(MessageType.Info, "finished writing " + householdsSaved + " households");
dbDstHouses.CompleteTransaction();
Log(MessageType.Debug, "finished house copying");
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSliceNotNull);
var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
dbDstHouses.RecreateTable <DHWHeaterEntry>();
var srcdhwsystems = dbSrcHouses.Fetch <DHWHeaterEntry>();
dbDstHouses.BeginTransaction();
WeightedRandomAllocator <DHWHeaterEntry> dhwAllocator = new WeightedRandomAllocator <DHWHeaterEntry>(Services.Rnd, Services.Logger);
int numberOfObjects = (int)slice.DHWSystemConversionNumber;
var electricBoilers = srcdhwsystems.Where(x => x.DhwHeatingSystemType == DhwHeatingSystem.Electricity).ToList();
if (electricBoilers.Count == 0 && numberOfObjects > 0)
{
throw new FlaException("No electric boilers left when trying to allocate " + numberOfObjects);
}
bool failOnOversubscribe = slice.DstYear != 2050;
var systemsToChange = dhwAllocator.PickNumberOfObjects(srcdhwsystems, x => x.EffectiveEnergyDemand, numberOfObjects, failOnOversubscribe);
foreach (var entry in systemsToChange)
{
entry.DhwHeatingSystemType = DhwHeatingSystem.Heatpump;
entry.EffectiveEnergyDemand = entry.EffectiveEnergyDemand / 3;
}
foreach (var dhw in srcdhwsystems)
{
dhw.ID = 0;
dbDstHouses.Save(dhw);
}
dbDstHouses.CompleteTransaction();
}
void MakeTrafoKreisMapForNonTrafoKreisHouses(ScenarioSliceParameters slice)
{
RGBWithSize GetColor(House h)
{
var eu = energyUses.Single(x => x.HouseGuid == h.Guid);
var energy = eu.ElectricityUse / 1_000_000;
if (energy < 10)
{
energy = 10;
}
if (string.IsNullOrWhiteSpace(h.TrafoKreis))
{
return(new RGBWithSize(255, 0, 0, (int)energy));
}
return(new RGBWithSize(0, 0, 0, 10));
}
var mapPoints = houses.Select(x => x.GetMapPointWithSize(GetColor)).ToList();
var filename = MakeAndRegisterFullFilename("HousesWithoutTrafoKreisEnergyUse.svg", slice);
var legendEntries = new List <MapLegendEntry>();
Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
}
public string MakeAndRegisterFullFilename([NotNull] string filename, [NotNull] ScenarioSliceParameters slice, bool replaceSpaces = true)
{
FilesCreated++;
return(FilenameHelpers.MakeAndRegisterFullFilenameStatic(
filename, MyStage, SequenceNumber,
Name, slice, Services.RunningConfig, replaceSpaces));
}
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 ClearTargetDirectory([NotNull] ScenarioSliceParameters slice)
{
var fullpath = FilenameHelpers.GetTargetDirectory(MyStage,
SequenceNumber, Name, slice, Services.RunningConfig);
if (Directory.Exists(fullpath))
{
try {
DirectoryInfo di = new DirectoryInfo(fullpath);
var files = di.GetFiles("*.*", SearchOption.AllDirectories);
foreach (var fileInfo in files)
{
fileInfo.Delete();
}
di.Delete(true);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e) {
#pragma warning restore CA1031 // Do not catch general exception types
SLogger.Error(e.Message);
}
}
if (!Directory.Exists(fullpath))
{
Directory.CreateDirectory(fullpath);
Thread.Sleep(250);
}
}
protected override void RunChartMaking()
{
ScenarioSliceParameters slice = Constants.PresentSlice;
double min = 0;
var dbSrcProfiles = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Raw, Constants.PresentSlice);
{
var allLs = new List <LineSeriesEntry>();
var bkws = dbSrcProfiles.Fetch <BkwProfile>();
var bkwProf = new Profile(bkws[0].Profile);
var ls = bkwProf.GetLineSeriesEntry();
allLs.Add(ls);
var filename = MakeAndRegisterFullFilename("BKW_Profile.png", slice);
Services.PlotMaker.MakeLineChart(filename, bkwProf.Name, allLs, new List <AnnotationEntry>(), min);
}
var rlms = dbSrcProfiles.Fetch <RlmProfile>();
foreach (var rlm in rlms)
{
var allLs = new List <LineSeriesEntry>();
Profile profile = new Profile(rlm.Name, rlm.Profile.Values, rlm.Profile.EnergyOrPower);
var ls1 = profile.GetLineSeriesEntry();
allLs.Add(ls1);
var filename = MakeAndRegisterFullFilename("RLMProfile." + rlm.Name + ".png", slice);
min = Math.Min(0, rlm.Profile.Values.Min());
Services.PlotMaker.MakeLineChart(filename, rlm.Name, allLs, new List <AnnotationEntry>(), min);
}
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var dbSrcHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice.PreviousSliceNotNull);
var dbDstHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
dbDstHouses.RecreateTable <BuildingInfrastructure>();
var srcBuildingInfrastructures = dbSrcHouses.Fetch <BuildingInfrastructure>();
if (srcBuildingInfrastructures.Count == 0)
{
throw new Exception("No building infrastructures were found");
}
dbDstHouses.BeginTransaction();
foreach (var buildingInfrastructure in srcBuildingInfrastructures)
{
buildingInfrastructure.ID = 0;
double energy = buildingInfrastructure.LocalnetLowVoltageYearlyTotalElectricityUse +
buildingInfrastructure.LocalnetHighVoltageYearlyTotalElectricityUse;
double energyReduction = energy * (1 - slice.EnergyReductionFactorBuildingInfrastructure);
if (Math.Abs(energyReduction) > 0.000001)
{
buildingInfrastructure.SetEnergyReduction(slice.ToString(), energyReduction);
//throw new FlaException("Factor 0 for house infrastructure energy reduction in slice " + slice);
}
dbDstHouses.Save(buildingInfrastructure);
}
dbDstHouses.CompleteTransaction();
}
public static string GetResultArchiveDirectory([NotNull] ScenarioSliceParameters slice,
DateTime startingTime,
[NotNull] RunningConfig config,
RelativeDirectory relativeDir,
[CanBeNull] string chapter)
{
string date = FilenameHelpers.CleanFileName(startingTime.ToString("yyyy-MM-dd"));
string scenario = slice.GetFileName();
if (slice.SmartGridEnabled)
{
scenario += "smart";
}
string resultArchiveDirectory = Path.Combine(config.Directories.ResultStorageDirectory, date, scenario, relativeDir.ToString());
if (chapter != null)
{
resultArchiveDirectory = Path.Combine(config.Directories.ResultStorageDirectory,
"Abschlussbericht",
date,
"Kapitel " + chapter,
scenario);
}
if (!Directory.Exists(resultArchiveDirectory))
{
Directory.CreateDirectory(resultArchiveDirectory);
Thread.Sleep(250);
}
return(resultArchiveDirectory);
}
protected override void MakeVisualization([NotNull] ScenarioSliceParameters slice, bool isPresent)
{
var dbHouse = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice);
var houses = dbHouse.Fetch <House>();
var pvSystems = dbHouse.Fetch <PvSystemEntry>();
MakePvSystemSankey();
MakePVMap();
MakePvSystemComparison();
void MakePvSystemSankey()
{
var ssa = new SingleSankeyArrow("HousePVSystems", 1500, MyStage, SequenceNumber, Name, slice, Services);
ssa.AddEntry(new SankeyEntry("Houses", houses.Count, 5000, Orientation.Straight));
var count = pvSystems.Count;
ssa.AddEntry(new SankeyEntry("PVSystems", count * -1, 2000, Orientation.Straight));
ssa.AddEntry(new SankeyEntry("Kein PV", (houses.Count - count) * -1, 2000, Orientation.Straight));
Services.PlotMaker.MakeSankeyChart(ssa);
}
void MakePvSystemComparison()
{
var ssa = new SingleSankeyArrow("RealPVSystemsVsPotential", 50, MyStage, SequenceNumber, Name, slice, Services);
var houseGuidsWithPV = pvSystems.Select(x => x.HouseGuid).ToList();
var potentials = dbHouse.Fetch <PVPotential>();
var relevantPotentials = potentials.Where(x => houseGuidsWithPV.Contains(x.HouseGuid)).ToList();
const double fac = 1_000_000;
var potentialEnergy = relevantPotentials.Sum(x => x.SonnendachStromErtrag) / fac;
var installedEnergy = pvSystems.Sum(x => x.EffectiveEnergyDemand) / fac;
ssa.AddEntry(new SankeyEntry("Sonnendach Potential auf Häusern mit PV", potentialEnergy, 20, Orientation.Straight));
ssa.AddEntry(new SankeyEntry("Installed", installedEnergy * -1, 20, Orientation.Straight));
ssa.AddEntry(new SankeyEntry("Verschwendetes Potential", (potentialEnergy - installedEnergy) * -1, 20, Orientation.Down));
Services.PlotMaker.MakeSankeyChart(ssa);
}
void MakePVMap()
{
RGB GetColor(House h)
{
if (pvSystems.Any(x => x.HouseGuid == h.Guid))
{
return(Constants.Red);
}
return(Constants.Black);
}
var mapPoints = houses.Select(x => x.GetMapPoint(GetColor)).ToList();
var filename = MakeAndRegisterFullFilename("PVSystems.svg", slice);
var legendEntries = new List <MapLegendEntry> {
new MapLegendEntry("PV", Constants.Red)
};
Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
}
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters parameters)
{
Log(MessageType.Debug, "Allocating occupants");
Services.SqlConnection.RecreateTable <Occupant>(Stage.Houses, parameters);
var dbSrcHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, parameters.PreviousScenarioNotNull).Database;
var dbDstHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, parameters).Database;
var srcOccupants = dbSrcHouses.Fetch <Occupant>();
var yearsToAge = parameters.DstYear - parameters.PreviousScenario?.DstYear ?? throw new FlaException("No Previous Scenario Set");
dbDstHouses.BeginTransaction();
int occupantsWritten = 0;
foreach (var occ in srcOccupants)
{
occ.OccupantID = 0;
occ.Age += yearsToAge;
if (occ.Age < 100)
{
dbDstHouses.Save(occ);
occupantsWritten++;
}
}
Log(MessageType.Info, "transfered " + occupantsWritten + " people");
//make new children
//
//add immigration
dbDstHouses.CompleteTransaction();
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters parameters)
{
Log(MessageType.Debug, "running house copying");
Services.SqlConnection.RecreateTable <House>(Stage.Houses, parameters);
var dbSrcHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, parameters.PreviousScenarioNotNull).Database;
var dbDstHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, parameters).Database;
var srcHouses = dbSrcHouses.Fetch <House>();
if (srcHouses.Count == 0)
{
throw new FlaException("No houses were found in source slice " + parameters.PreviousScenario);
}
dbDstHouses.BeginTransaction();
int housecount = 0;
foreach (var srcHouse in srcHouses)
{
srcHouse.HouseID = 0;
dbDstHouses.Save(srcHouse);
housecount++;
}
dbDstHouses.CompleteTransaction();
Log(MessageType.Info, "Transfered " + housecount + " houses from " + parameters.PreviousScenarioNotNull + " to " + parameters + " in the scenario " + parameters.DstScenario);
Log(MessageType.Debug, "finished house copying");
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters parameters)
{
/*
* throw new NotImplementedException();
* Services.SqlConnection.RecreateTable<HeatingSystemEntry>(Stage.Houses, up.DstScenario, up.DstYear);
* var dbSrcHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, up.SrcScenario, up.SrcYear).Database;
* var dbDstHouses = Services.SqlConnection.GetDatabaseConnection(Stage.Houses, up.DstScenario, up.DstYear).Database;
* var srcHeatingSystems = dbSrcHouses.Fetch<HeatingSystemEntry>();
* if (srcHeatingSystems.Count == 0)
* {
* throw new Exception("No cars were found");
* }
*
* int yearsToAge = up.DstYear - up.SrcYear;
* var potentialSystemsToChange = srcHeatingSystems.Where(x =>
* x.HeatingSystemType == HeatingSystemType.OilHeating ||
* x.HeatingSystemType == HeatingSystemType.Gasheating).ToList();
* List<G_DHWSystemChanger.RangeEntry> rangeEntries = new List<G_DHWSystemChanger.RangeEntry>();
* foreach (HeatingSystemEntry heatingSystemEntry in potentialSystemsToChange)
* {
* G_DHWSystemChanger.RangeEntry re = new G_DHWSystemChanger.RangeEntry();
* heatingSystemEntry.Age += yearsToAge;
* double ageWeight = heatingSystemEntry.Age / 30.0;
* double energyWeight = 1 - heatingSystemEntry.AverageHeatingEnergyDemandDensity / 200;
* if (energyWeight <= 0)
* {
* energyWeight = 0.000001;
* }
* double combinedWeight = 1 / (ageWeight * energyWeight);
* if (double.IsInfinity(combinedWeight))
* {
* throw new Exception("Invalid weight");
* }
*
* re.HeatingSystemEntry = heatingSystemEntry;
* re.Weight = combinedWeight;
* rangeEntries.Add(re);
* }
*
* if (potentialSystemsToChange.Count < up.ConversionToHeatPumpNumber)
* {
* throw new Exception("not enough other heating systems left for heat pump conversion demand");
* }
* double maxRangeValue = rangeEntries.Max(x => x.EndRange);
* for (int i = 0; i < up.ConversionToHeatPumpNumber; i++)
* {
* double pick = Services.Rnd.NextDouble() * maxRangeValue;
* var re = rangeEntries.Single(x => pick >= x.StartRange && pick <= x.EndRange);
* re.HeatingSystemEntry.Age = 0;
* re.HeatingSystemEntry.HeatingSystemType = HeatingSystemType.Heatpump;
* }
* dbDstHouses.BeginTransaction();
* foreach (HeatingSystemEntry heatingSystemEntry in srcHeatingSystems)
* {
* heatingSystemEntry.HeatingSystemID = 0;
* dbDstHouses.Save(heatingSystemEntry);
* }
*
* dbDstHouses.CompleteTransaction();*/
}
public void RunPVProviderTestForAllEntries()
{
ServiceRepository services = new ServiceRepository(null, null, Logger, Config, new Random(1));
var slice = new ScenarioSliceParameters(Scenario.FromEnum(ScenarioEnum.Utopia), 2050, null);
var dbHouse = services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
var pventries = dbHouse.Fetch <PvSystemEntry>();
var has = dbHouse.Fetch <Hausanschluss>();
var dbdto = new DBDto(null, has, null, null, null);
PVProfileProvider pvp = new PVProfileProvider(services, slice, dbdto);
foreach (var entry in pventries)
{
HouseComponentRo hcro = new HouseComponentRo("myname", "PV", 1, 1, "status", "isns", "standort", 0);
ProviderParameterDto pp = new ProviderParameterDto(entry, null, hcro);
pvp.PrepareLoadProfileIfNeeded(pp);
var prosumer = pvp.ProvideProfile(pp);
if (prosumer?.Profile == null)
{
throw new FlaException("No profile");
}
if (Math.Abs(prosumer.Profile.EnergySum() - entry.EffectiveEnergyDemand) > 0.1)
{
throw new FlaException("Invalid profile: missing energy: should be " + entry.EffectiveEnergyDemand + " but was " +
prosumer.Profile.EnergySum());
}
Info("Profile generated correctly.");
}
}
public void RunSingleParameterSlice()
{
_output?.WriteLine("This is output from {0}", "RunSingleParameterSlice");
RunningConfig settings = RunningConfig.MakeDefaults();
settings.MyOptions.Add(Options.ReadFromExcel);
settings.LimitToYears.Add(2050);
settings.LimitToScenarios.Add(Scenario.FromEnum(ScenarioEnum.Utopia));
settings.MakeCharts = false;
using (Logger logger = new Logger(_output, settings)) {
settings.InitializeSlices(logger);
using (var container = CreateBuilderContainer(_output, logger, settings)) {
using (var scope = container.BeginLifetimeScope()) {
if (settings.Slices == null)
{
throw new FlaException("slices was not initalized");
}
ScenarioSliceParameters ssp = settings.Slices[0];
//ssp = Constants.PresentSlice;
var s1 = scope.Resolve <Z_GeneralExporter>();
s1.RunForScenarios(ssp);
var pm = scope.Resolve <PlotMaker>();
pm.Finish();
PngSvgConverter con = new PngSvgConverter(logger, Stage.Preparation);
con.ConvertAllSVG(settings);
logger.SaveToDatabase(Constants.PresentSlice);
}
}
}
}
private static JsonCalcSpecification MakeCalcSpec([NotNull] ScenarioSliceParameters parameters, DateTime endtime)
{
DateTime startTime = new DateTime(parameters.DstYear, 1, 1);
JsonReference geoloc = new JsonReference("(Germany) Chemnitz", "eddeb22c-fbd4-44c1-bf2d-fbde3342f1bd");
JsonReference tempReference = new JsonReference("Berlin, Germany 1996 from Deutscher Wetterdienst DWD (www.dwd.de)",
"ec337ba6-60a1-404b-9db0-9be52c9e5702");
JsonCalcSpecification jcs = new JsonCalcSpecification(null,
null,
false,
null,
false,
endtime,
"00:15:00",
"00:01:00",
geoloc,
LoadTypePriority.RecommendedForHouses,
null,
false,
startTime,
tempReference,
null,
null)
{
DeleteDAT = true,
DefaultForOutputFiles = OutputFileDefault.None, SkipExisting = true
};
jcs.CalcOptions.Add(CalcOption.SumProfileExternalIndividualHouseholdsAsJson);
jcs.LoadtypesForPostprocessing.Add("Electricity");
jcs.LoadtypesForPostprocessing.Add("Car Charging Electricity");
jcs.OutputDirectory = "Results";
jcs.IgnorePreviousActivitiesWhenNeeded = true;
return(jcs);
}
