public override void Run(HouseholdKey key, object o)
{
var objects = (List <IHouseholdKey>)o;
var actionEntries = objects.ConvertAll(x => (SingleTimestepActionEntry)x).ToList();
var rowEntries = new List <Dictionary <string, object> >();
foreach (var affordanceEnergyUseEntry in actionEntries)
{
rowEntries.Add(RowBuilder.Start("Timestep", affordanceEnergyUseEntry.TimeStep)
.Add("Json", JsonConvert.SerializeObject(affordanceEnergyUseEntry, Formatting.Indented)).ToDictionary());
}
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Timestep", SqliteDataType.Text);
se.AddField("Json", SqliteDataType.Text);
foreach (Dictionary <string, object> entry in rowEntries)
{
se.AddRow(entry);
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
var objects = (List <IHouseholdKey>)o;
var transportationDeviceStateEntries = objects.ConvertAll(x => (ChargingStationState)x).ToList();
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Time", SqliteDataType.Integer);
se.AddField("ChargingStationName", SqliteDataType.Text);
se.AddField("IsAvailable", SqliteDataType.Bit);
se.AddField("CarName", SqliteDataType.Text);
se.AddField("ChargingPower", SqliteDataType.Double);
se.AddField("Json", SqliteDataType.JsonField);
foreach (var ae in transportationDeviceStateEntries)
{
se.AddRow(RowBuilder.Start("Time", ae.TimeStep)
.Add("ChargingStationName", ae.ChargingStationName)
.Add("IsAvailable", ae.IsAvailable?1:0)
.Add("CarName", ae.ConnectedCarName)
.Add("ChargingPower", ae.ChargingPower)
.Add("Json", JsonConvert.SerializeObject(ae, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public void SaveResultEntry([JetBrains.Annotations.NotNull] SaveableEntry entry)
{
entry.IntegrityCheck();
string dstFileName = GetFilenameForHouseholdKey(entry.HouseholdKey);
using (System.Data.SQLite.SQLiteConnection conn = new System.Data.SQLite.SQLiteConnection("Data Source=" + dstFileName + ";Version=3")) {
//;Synchronous=OFF;Journal Mode=WAL;"
conn.Open();
if (!IsTableCreated(entry))
{
MakeTableForListOfFields(entry.Fields, conn, entry.ResultTableDefinition.TableName);
Dictionary <string, object> fields = new Dictionary <string, object> {
{ "TableName", entry.ResultTableDefinition.TableName },
{ "Description", entry.ResultTableDefinition.Description },
{ "ResultTableID", entry.ResultTableDefinition.ResultTableID },
{ "EnablingOption", entry.ResultTableDefinition.EnablingOption }
};
List <Dictionary <string, object> > rows = new List <Dictionary <string, object> > {
fields
};
SaveDictionaryToDatabase(rows, "TableDescription", conn);
if (!_createdTablesPerHousehold.ContainsKey(entry.HouseholdKey))
{
_createdTablesPerHousehold.Add(entry.HouseholdKey, new List <string>());
}
_createdTablesPerHousehold[entry.HouseholdKey].Add(entry.ResultTableDefinition.TableName);
}
SaveDictionaryToDatabase(entry.RowEntries, entry.ResultTableDefinition.TableName, conn);
conn.Close();
}
}
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 override void Run(HouseholdKey key, object o)
{
var objects = (List <LogMessageEntry>)o;
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Time", SqliteDataType.DateTime);
se.AddField("RelativeTime", SqliteDataType.DateTime);
se.AddField("Message", SqliteDataType.Text);
se.AddField("Severity", SqliteDataType.Text);
se.AddField("MyStackTrace", SqliteDataType.Text);
foreach (var lme in objects)
{
se.AddRow(RowBuilder.Start("Time", lme.Time)
.Add("Message", lme.Message)
.Add("RelativeTime", lme.RelativeTime)
.Add("Severity", lme.Severity.ToString())
.Add("MyStackTrace", lme.MyStackTrace)
.ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
var objects = (List <IHouseholdKey>)o;
var actionEntries = objects.ConvertAll(x => (PersonStatus)x).ToList();
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("TimeStep", SqliteDataType.Text);
se.AddField("PersonName", SqliteDataType.Text);
se.AddField("AffordanceName", SqliteDataType.Text);
se.AddField("LocationName", SqliteDataType.Text);
se.AddField("SiteName", SqliteDataType.Text);
se.AddField("Json", SqliteDataType.Text);
foreach (var actionEntry in actionEntries)
{
se.AddRow(RowBuilder.Start("PersonName", actionEntry.PersonName).Add("AffordanceName", actionEntry.ActiveAffordance)
.Add("TimeStep", actionEntry.TimeStep).Add("LocationName", actionEntry.LocationName).Add("SiteName", actionEntry.SiteName)
.Add("Json", JsonConvert.SerializeObject(actionEntry, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
var sets = (BridgeDayEntries)o;
if (sets.Entries.Count == 0)
{
Logger.Info("No bridge days were found.");
return;
}
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("BridgeDay", SqliteDataType.DateTime);
se.AddField("BridgeDayJson", SqliteDataType.Text);
foreach (var afftagset in sets.Entries)
{
se.AddRow(RowBuilder.Start("BridgeDay", afftagset)
.Add("BridgeDayJson", JsonConvert.SerializeObject(afftagset, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
var hh = (HouseholdKeyEntry)o;
//check for duplicates
if (!_savedKeys.Add(hh.HHKey))
{
return;
//throw new LPGException("Householdkey already existed");
}
if (!_isTableCreated)
{
SaveableEntry se = GetStandardSaveableEntry(key);
se.AddRow(RowBuilder.Start("Name", hh.HHKey)
.Add("Json", JsonConvert.SerializeObject(hh, Formatting.Indented)).ToDictionary());
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
_isTableCreated = true;
return;
}
var dict = RowBuilder.Start("Name", hh.HHKey)
.Add("Json", JsonConvert.SerializeObject(hh, Formatting.Indented)).ToDictionary();
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveDictionaryToDatabaseNewConnection(dict, TableName, Constants.GeneralHouseholdKey);
}
public override void Run(HouseholdKey key, object o)
{
var hh = (ResultFileEntry)o;
if (!_isTableCreated)
{
SaveableEntry se = GetStandardSaveableEntry(key);
se.AddRow(RowBuilder.Start("Name", Constants.GeneralHouseholdKey)
.Add("Json", JsonConvert.SerializeObject(hh, Formatting.Indented)).ToDictionary());
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
_isTableCreated = true;
}
else
{
var row = RowBuilder.Start("Name", Constants.GeneralHouseholdKey)
.Add("Json", JsonConvert.SerializeObject(hh, Formatting.Indented)).ToDictionary();
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveDictionaryToDatabaseNewConnection(row, TableName, Constants.GeneralHouseholdKey);
}
}
public override void Run(HouseholdKey key, object o)
{
TemperatureProfile tp = (TemperatureProfile)o;
var tempProfile = tp.GetTemperatureArray(_calcParameters.InternalStartTime,
_calcParameters.OfficialEndTime,
_calcParameters.InternalStepsize);
DateStampCreator dsc = new DateStampCreator(_calcParameters);
if (!_calcParameters.IsSet(CalcOption.TemperatureFile))
{
return;
}
// var allTemperatures = new List<UsedTemperatures>();
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Timestep", SqliteDataType.Integer);
se.AddField("DateTime", SqliteDataType.Text);
se.AddField("Temperature", SqliteDataType.Double);
for (var i = 0; i < _calcParameters.OfficalTimesteps; i++)
{
string timestamp = dsc.MakeDateStringFromTimeStep(new TimeStep(i, 0, false));
se.AddRow(RowBuilder.Start("Timestep", i).Add("DateTime", timestamp).Add("Temperature", tempProfile[i]).ToDictionary());
}
_srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
CalcStartParameterSet csps = (CalcStartParameterSet)o;
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Name", SqliteDataType.Text);
se.AddField("Value", SqliteDataType.Text);
se.AddRow(RowBuilder.Start("Name", "CsvCharacter").Add("Value", csps.CsvCharacter).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "Temperature Profile").Add("Value", csps.TemperatureProfile.Name).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "AffordanceRepetitionCount").Add("Value", csps.AffordanceRepetitionCount.ToString(CultureInfo.InvariantCulture)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "CalcOptions").Add("Value", JsonConvert.SerializeObject(csps.CalcOptions, Formatting.Indented)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "CalcTarget").Add("Value", csps.CalcTarget.Name).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "DeleteDatFiles").Add("Value", csps.DeleteDatFiles.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "DeviceSelection").Add("Value", csps.DeviceSelection?.Name ?? "None").ToDictionary());
se.AddRow(RowBuilder.Start("Name", "EnergyIntensity").Add("Value", csps.EnergyIntensity.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "ExternalTimeResolution").Add("Value", csps.ExternalTimeResolution.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "GeographicLocation").Add("Value", csps.GeographicLocation.Name).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "InternalTimeResolution").Add("Value", csps.InternalTimeResolution.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "LPGVersion").Add("Value", csps.LPGVersion).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "LoadTypePriority").Add("Value", csps.LoadTypePriority.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "OfficialSimulationStartTime").Add("Value", csps.OfficialSimulationStartTime.ToString(CultureInfo.InvariantCulture)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "OfficialSimulationEndTime").Add("Value", csps.OfficialSimulationEndTime.ToString(CultureInfo.InvariantCulture)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "SelectedRandomSeed").Add("Value", csps.SelectedRandomSeed.ToString(CultureInfo.InvariantCulture)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "SettlingDays").Add("Value", csps.SettlingDays.ToString(CultureInfo.InvariantCulture)).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "ShowSettlingPeriod").Add("Value", csps.ShowSettlingPeriod.ToString()).ToDictionary());
se.AddRow(RowBuilder.Start("Name", "TransportationDeviceSet").Add("Value", csps.TransportationDeviceSet?.Name ?? "None").ToDictionary());
se.AddRow(RowBuilder.Start("Name", "TravelRouteSet").Add("Value", csps.TravelRouteSet?.Name ?? "None").ToDictionary());
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
DayLightStatus dayLightStatus = (DayLightStatus)o;
//List<EveryDayLightTimes> daylights = new List<EveryDayLightTimes>();
var startTimeStep = 0;
if (!_calcParameters.ShowSettlingPeriodTime)
{
startTimeStep = _calcParameters.DummyCalcSteps;
}
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Timestep", SqliteDataType.Integer);
se.AddField("DateTime", SqliteDataType.Integer);
se.AddField("Daylight", SqliteDataType.Bit);
for (var i = startTimeStep; i < dayLightStatus.Status.Count; i++)
{
TimeStep ts = new TimeStep(i, _calcParameters);
string timestamp = _dsc.MakeDateStringFromTimeStep(ts);
se.AddRow(RowBuilder.Start("Timestep", ts.ExternalStep).Add("DateTime", timestamp).Add("Daylight", dayLightStatus.Status[i]).ToDictionary());
//EveryDayLightTimes edlt = new EveryDayLightTimes(timestamp,timestep, );
//daylights.Add(edlt);
}
_srls.SaveResultEntry(se);
}
private bool MakeErzeugerLastgang([NotNull][ItemNotNull] List <House> houses, [NotNull] LastgangBusinessAssignment assignment, [NotNull][ItemNotNull] List <RlmProfile> profiles,
[NotNull] SaveableEntry <Prosumer> sa)
{
var selectedhouses = houses.Where(x => x.ErzeugerIDs.Contains(assignment.ErzeugerID)).ToList();
if (selectedhouses.Count != 1)
{
if (selectedhouses.Count == 0)
{
Log(MessageType.Info, "No house found for " + assignment.ErzeugerID);
return(true);
}
throw new Exception(selectedhouses.Count + " houses for erzeuger id " + assignment.ErzeugerID);
}
Hausanschluss ha = selectedhouses[0].Hausanschluss[0];
//odo: adjust with new factors
var rlmrprofile = profiles.Single(x => x.Name == assignment.RlmFilename);
var pa = new Prosumer(selectedhouses[0].HouseGuid, assignment.RlmFilename,
ProsumerType.LastgangGeneration, null, selectedhouses[0].GebäudeObjectIDs[0], ha.HausanschlussGuid, ha.ObjectID)
{
Profile = rlmrprofile.Profile
};
sa.AddRow(pa);
return(false);
}
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 override void Run(HouseholdKey key, object o)
{
var objects = (List <IHouseholdKey>)o;
var transportationDeviceStateEntries = objects.ConvertAll(x => (TransportationDeviceStateEntry)x).ToList();
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Time", SqliteDataType.Integer);
se.AddField("DateTime", SqliteDataType.Integer);
se.AddField("DeviceName", SqliteDataType.Text);
se.AddField("User", SqliteDataType.Text);
se.AddField("DeviceState", SqliteDataType.Text);
se.AddField("NumericDeviceState", SqliteDataType.Integer);
se.AddField("CurrentRange", SqliteDataType.Double);
se.AddField("CurrentSite", SqliteDataType.Text);
se.AddField("Json", SqliteDataType.JsonField);
foreach (var ae in transportationDeviceStateEntries)
{
se.AddRow(RowBuilder.Start("Time", ae.TimeStep)
.Add("DateTime", ae.DateTime)
.Add("DeviceName", ae.TransportationDeviceName)
.Add("User", ae.CurrentUser)
.Add("DeviceState", ae.TransportationDeviceState)
.Add("NumericDeviceState", (int)ae.TransportationDeviceStateEnum)
.Add("CurrentRange", ae.CurrentRange)
.Add("CurrentSite", ae.CurrentSite)
.Add("Json", JsonConvert.SerializeObject(ae, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
var dbProfileExport = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.HouseProfiles);
var sa = SaveableEntry <Prosumer> .GetSaveableEntry(dbProfileExport, SaveableEntryTableType.HouseLoad, Services.Logger);
int count = 0;
Stopwatch sw = Stopwatch.StartNew();
foreach (var prosumer in sa.ReadEntireTableDBAsEnumerable())
{
var keys = GenerateKeysFromProsumer(prosumer);
ProcessProsumer(keys, prosumer);
count++;
if (count % 1000 == 0)
{
Info("Subtotal processing load count: " + count + " in a total of " + sw.Elapsed);
}
}
count = 0;
sw = Stopwatch.StartNew();
var saGen = SaveableEntry <Prosumer> .GetSaveableEntry(dbProfileExport, SaveableEntryTableType.HouseGeneration, Services.Logger);
foreach (var prosumer in saGen.ReadEntireTableDBAsEnumerable())
{
var keys = GenerateKeysFromProsumer(prosumer);
ProcessProsumer(keys, prosumer);
count++;
if (count % 1000 == 0)
{
Info("Subtotal processing generation count: " + count + " in a total of " + sw.Elapsed);
}
}
Debug("summed up count: " + _entriesByKey.Count);
var dbArchive = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saArchive = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive, SaveableEntryTableType.SummedLoadsForAnalysis, Services.Logger);
saArchive.MakeCleanTableForListOfFields(false);
foreach (var value in _entriesByKey.Values)
{
saArchive.AddRow(value);
}
saArchive.SaveDictionaryToDatabase(MyLogger);
Debug("Finished saving prosumer loads to the db");
if (Services.RunningConfig.MakeHouseSums)
{
//make house sums
var dbHouses = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
var houses = dbHouses.Fetch <House>();
Dictionary <string, string> houseNames = new Dictionary <string, string>();
foreach (var house in houses)
{
houseNames.Add(house.Guid, house.ComplexName);
}
MakeHouseSums(dbArchive, sa, houseNames);
}
}
protected SaveableEntry GetStandardSaveableEntry([NotNull] HouseholdKey key)
{
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Name", SqliteDataType.Text);
se.AddField("Json", SqliteDataType.Text);
return(se);
}
private static void SaveCityProfile([JetBrains.Annotations.NotNull] ChangableProfile cityload,
[JetBrains.Annotations.NotNull] SaveableEntry <ArchiveEntry> saArchiveEntry,
SummedLoadType name,
GenerationOrLoad generationOrLoad)
{
AnalysisKey key1 = new AnalysisKey(null, null, SumType.ByCity, generationOrLoad, null, name.ToString(), null);
ArchiveEntry ae1 = new ArchiveEntry(name.ToString(), key1, cityload.ToProfile(), generationOrLoad, "City");
saArchiveEntry.AddRow(ae1);
}
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");
}
public override void Run(HouseholdKey key, object o)
{
CalcParameters calcParameters = (CalcParameters)o;
SaveableEntry se = GetStandardSaveableEntry(key);
se.AddRow(RowBuilder.Start("Name", "CalcParameters").Add("Json", JsonConvert.SerializeObject(calcParameters, Formatting.Indented)).ToDictionary());
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
protected override void RunActualProcess([NotNull] ScenarioSliceParameters slice)
{
if (!Services.RunningConfig.MakeExcelPerTrafokreis)
{
return;
}
var dbArchive = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saHouses = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive, SaveableEntryTableType.SummedHouseProfiles, Services.Logger);
string currentTrafokreis = "";
ExcelWorksheet ws;
int columnIdx = 1;
ExcelPackage p = new ExcelPackage();
ws = p.Workbook.Worksheets.Add("sheet1");
foreach (var house in saHouses.ReadEntireTableDBAsEnumerable("Trafokreis"))
{
if (currentTrafokreis != house.Trafokreis && !string.IsNullOrWhiteSpace(currentTrafokreis))
{
var fn = MakeAndRegisterFullFilename(FilenameHelpers.CleanFileName(currentTrafokreis) + ".xlsx", slice);
// ReSharper disable once PossibleNullReferenceException
p.SaveAs(new FileInfo(fn));
SaveToArchiveDirectory(fn, RelativeDirectory.Trafokreise, slice);
p.Dispose();
p = new ExcelPackage();
ws = p.Workbook.Worksheets.Add(currentTrafokreis);
columnIdx = 2;
}
currentTrafokreis = house.Trafokreis;
// ReSharper disable once PossibleNullReferenceException
ws.Cells[1, columnIdx].Value = house.Name;
int rowIdx = 2;
for (int i = 0; i < house.Profile.Values.Count; i++)
{
ws.Cells[rowIdx, columnIdx].Value = house.Profile.Values[i];
rowIdx++;
}
columnIdx++;
}
var fn2 = MakeAndRegisterFullFilename(FilenameHelpers.CleanFileName(currentTrafokreis) + ".xlsx", slice);
// ReSharper disable once PossibleNullReferenceException
p.SaveAs(new FileInfo(fn2));
SaveToArchiveDirectory(fn2, RelativeDirectory.Trafokreise, slice);
p.Dispose();
}
public PVProfileProvider([NotNull] ServiceRepository services, [NotNull] ScenarioSliceParameters slice,
[NotNull] DBDto dbDto) : base(nameof(PVProfileProvider), services, slice)
{
_dbDto = dbDto;
DevelopmentStatus.Add("use the correct weather year profile for the generation");
DevelopmentStatus.Add("instead of commenting out, check if all angles & right weather file based on key. If not right, clear table and regenerate");
Directory.SetCurrentDirectory(Services.RunningConfig.Directories.SamDirectory);
Info("SSC Version number = " + API.Version());
Info("SSC bBuild Information = " + API.BuildInfo());
var dbPV = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, Slice, DatabaseCode.PvProfiles);
_saveableEntries = SaveableEntry <Profile> .GetSaveableEntry(dbPV, SaveableEntryTableType.PVGeneration, MyLogger);
_saveableEntries.MakeTableForListOfFieldsIfNotExists(true);
}
public ElectricCarProvider([NotNull] ServiceRepository services,
[NotNull] ScenarioSliceParameters slice,
[NotNull] DBDto dbDto,
[NotNull][ItemNotNull] List <HouseCreationAndCalculationJob> housesToBeCreated,
[NotNull] CachingLPGProfileLoader lpgProfileLoader) : base(nameof(ElectricCarProvider), services, slice)
{
_dbDto = dbDto;
_housesToBeCreated = housesToBeCreated;
_lpgProfileLoader = lpgProfileLoader;
var profileCacheDb = services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.EvProfiles);
_saveableEntry = SaveableEntry <Profile> .GetSaveableEntry(profileCacheDb, SaveableEntryTableType.EvProfile, services.Logger);
_saveableEntry.MakeTableForListOfFieldsIfNotExists(true);
}
public void SaveDictionaryCalcParametersTest()
{
using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
wd.ClearDirectory();
var srl = new SqlResultLoggingService(wd.WorkingDirectory);
var hhkey = new HouseholdKey("hh0");
ResultTableDefinition rtd = new ResultTableDefinition("tbl1", ResultTableID.AffordanceDefinitions, "tabledesc", CalcOption.BasicOverview);
SaveableEntry se = new SaveableEntry(hhkey, rtd);
se.AddField("Name", SqliteDataType.Text);
se.AddField("Json", SqliteDataType.Text);
se.AddRow(RowBuilder.Start("Name", "first").Add("Json", "[]").ToDictionary());
srl.SaveResultEntry(se);
wd.CleanUp();
}
}
public override void Run(HouseholdKey key, object o)
{
SaveableEntry se = GetStandardSaveableEntry(key);
var sets = (List <CalcAffordanceTaggingSetDto>)o;
foreach (var afftagset in sets)
{
se.AddRow(RowBuilder.Start("Name", afftagset.Name)
.Add("Json", JsonConvert.SerializeObject(afftagset, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
/*
* private bool IgnoreThisField([NotNull] string fieldname)
* {
* if (fieldname == "HouseholdKey") {
* return true;
* }
*
* return false;
* }*/
private bool IsTableCreated([NotNull] SaveableEntry entry)
{
if (!_createdTablesPerHousehold.ContainsKey(entry.HouseholdKey))
{
return(false);
}
var tables = _createdTablesPerHousehold[entry.HouseholdKey];
if (!tables.Contains(entry.ResultTableDefinition.TableName))
{
return(false);
}
return(true);
}
public override void Run(HouseholdKey key, object o)
{
SaveableEntry se = GetStandardSaveableEntry(key);
var objects = (List <IHouseholdKey>)o;
var variableDefinitions = objects.ConvertAll(x => (CalcVariableDto)x).ToList();
foreach (var calcPersonDto in variableDefinitions)
{
se.AddRow(RowBuilder.Start("Name", calcPersonDto.Name)
.Add("Json", JsonConvert.SerializeObject(calcPersonDto, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
var actionEntries = (List <TransportationDeviceEventStatistics>)o;
//var actionEntries = objects.ConvertAll(x => (TransportationDeviceStatisticsEntry)x).ToList();
SaveableEntry se = GetStandardSaveableEntry(key);
foreach (var actionEntry in actionEntries)
{
se.AddRow(RowBuilder.Start("Name", actionEntry.TransportationDevice)
.Add("Json", JsonConvert.SerializeObject(actionEntry, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
SaveableEntry se = GetStandardSaveableEntry(key);
var objects = (List <IHouseholdKey>)o;
var transportationDeviceDtos = objects.ConvertAll(x => (CalcTravelRouteDto)x).ToList();
foreach (var device in transportationDeviceDtos)
{
se.AddRow(RowBuilder.Start("Name", device.Name)
.Add("Json", JsonConvert.SerializeObject(device, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
public override void Run(HouseholdKey key, object o)
{
SaveableEntry se = GetStandardSaveableEntry(key);
var objects = (List <AffordanceEnergyUseEntry>)o;
//var affordanceEnergyUseEntries = objects.ConvertAll(x => (AffordanceEnergyUseEntry) x).ToList();
foreach (var ae in objects)
{
se.AddRow(RowBuilder.Start("Name", ae.AffordanceName)
.Add("Json", JsonConvert.SerializeObject(ae, Formatting.Indented)).ToDictionary());
}
if (Srls == null)
{
throw new LPGException("Data Logger was null.");
}
Srls.SaveResultEntry(se);
}
