/// <summary>
/// starter for real calcs
/// </summary>
public CalcStartParameterSet(
[NotNull] Func <bool, string, ObservableCollection <ResultFileEntry>, bool>
reportFinishFuncForHouseAndSettlement,
[NotNull] Func <bool, string, string, bool> reportFinishFuncForHousehold,
[NotNull] Func <object, bool> openTabFunc, [CanBeNull] ILPGDispatcher dispatcher,
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity, [NotNull] Func <bool> reportCancelFunc, bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection, LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] TravelRouteSet travelRouteSet,
[NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler,
[CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull][ItemNotNull] List <string> loadTypesToProcess,
DeviceProfileHeaderMode deviceProfileHeaderMode,
bool ignorePreviousActivitiesWhenNeeded, string resultPath, bool transportationEnabled)
{
IgnorePreviousActivitiesWhenNeeded = ignorePreviousActivitiesWhenNeeded;
ResultPath = resultPath;
LoadTypesToProcess = loadTypesToProcess;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
SelectedRandomSeed = selectedRandomSeed;
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
ReportFinishFuncForHouseAndSettlement = reportFinishFuncForHouseAndSettlement;
ReportFinishFuncForHousehold = reportFinishFuncForHousehold;
OpenTabFunc = openTabFunc;
Dispatcher = dispatcher;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ReportCancelFunc = reportCancelFunc;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = deviceProfileHeaderMode;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
public void CheckRouteCompletenessTest()
{
TravelRouteSet trs = new TravelRouteSet("trs", 1, "", "", Guid.NewGuid().ToStrGuid());
List <Site> sites = new List <Site>();
//test with empty
CalcTransportationDtoFactory.CheckRouteCompleteness(trs, sites);
//test with one route
Site sitea = new Site("sitea", 1, "", "", Guid.NewGuid().ToStrGuid());
Site siteb = new Site("siteb", 2, "", "", Guid.NewGuid().ToStrGuid());
sites.Add(sitea);
sites.Add(siteb);
trs.AddRoute(new TravelRoute(1, "", "Route1", "desc", sitea, siteb, Guid.NewGuid().ToStrGuid(), null), false);
CalcTransportationDtoFactory.CheckRouteCompleteness(trs, sites);
//one route missing
Site sitec = new Site("sitec", 2, "", "", Guid.NewGuid().ToStrGuid());
sites.Add(sitec);
trs.AddRoute(new TravelRoute(1, "", "Route2", "desc", siteb, sitec, Guid.NewGuid().ToStrGuid(), null), false);
Action crashfunction1 = () => CalcTransportationDtoFactory.CheckRouteCompleteness(trs, sites);
crashfunction1.Should().Throw <DataIntegrityException>();
//add missing route
trs.AddRoute(new TravelRoute(1, "", "Route3", "desc", sitea, sitec, Guid.NewGuid().ToStrGuid(), null), false);
CalcTransportationDtoFactory.CheckRouteCompleteness(trs, sites);
}
private static bool IsAtLeastOneRouteOk([NotNull] TravelRouteSet travelRouteSet,
[NotNull][ItemNotNull] List <TransportationDeviceCategory> categories, [NotNull] Site siteA, [NotNull] Site siteB)
{
var tr = travelRouteSet.TravelRoutes.Where(x =>
x.TravelRoute.SiteA == siteA && x.TravelRoute.SiteB == siteB ||
x.TravelRoute.SiteA == siteB && x.TravelRoute.SiteB == siteA).ToList();
bool atLeastOneRouteIsOk = false;
foreach (TravelRouteSetEntry routeSetEntry in tr)
{
bool allstepsareok = true;
foreach (TravelRouteStep step in routeSetEntry.TravelRoute.Steps)
{
if (!categories.Contains(step.TransportationDeviceCategory))
{
allstepsareok = false;
}
}
if (allstepsareok)
{
atLeastOneRouteIsOk = true;
}
}
return(atLeastOneRouteIsOk);
}
private static void CheckRouteTransportationDeviceCompleteness([NotNull] TravelRouteSet travelRouteSet,
[NotNull][ItemNotNull] List <Site> householdSites,
[NotNull] TransportationDeviceSet transportationDeviceSet)
{
var devices = transportationDeviceSet.TransportationDeviceSetEntries.Select(x => x.TransportationDevice)
.ToList();
var categories = devices.Select(x => x.TransportationDeviceCategory).Distinct().ToList();
//figure out if every site is connected to every other site
foreach (Site siteA in householdSites)
{
foreach (Site siteB in householdSites)
{
if (siteB == siteA)
{
continue;
}
bool atLeastOneRouteIsOk = IsAtLeastOneRouteOk(travelRouteSet, categories, siteA, siteB);
if (!atLeastOneRouteIsOk)
{
throw new DataIntegrityException("There seems to be no route from " + siteA.PrettyName +
" to " + siteB.PrettyName +
" that is usable by the given transportation device set. Please fix.");
}
}
}
}
public void TravelRouteSetTest()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TravelRouteSet.TableName);
db.ClearTable(TravelRouteSetEntry.TableName);
TravelRouteSet set = new TravelRouteSet("set1", null, db.ConnectionString, "desc", System.Guid.NewGuid().ToStrGuid());
set.SaveToDB();
Site a = new Site("a", null, db.ConnectionString, "desc", System.Guid.NewGuid().ToStrGuid());
a.SaveToDB();
Site b = new Site("b", null, db.ConnectionString, "desc", System.Guid.NewGuid().ToStrGuid());
b.SaveToDB();
TravelRoute route = new TravelRoute(null, db.ConnectionString, "routename", "routedesc", a, b, System.Guid.NewGuid().ToStrGuid(), null);
route.SaveToDB();
set.AddRoute(route);
//loading
ObservableCollection <TravelRoute> routes = new ObservableCollection <TravelRoute>
{
route
};
ObservableCollection <TravelRouteSet> sets = new ObservableCollection <TravelRouteSet>();
TravelRouteSet.LoadFromDatabase(sets, db.ConnectionString, false, routes);
db.Cleanup();
(sets.Count).Should().Be(1);
}
}
public static void CheckRouteCompleteness([NotNull] TravelRouteSet travelRouteSet, [NotNull][ItemNotNull] List <Site> sites)
{
//figure out if every site is connected to every other site
foreach (Site siteA in sites)
{
foreach (Site siteB in sites)
{
if (siteB == siteA)
{
continue;
}
var tr = travelRouteSet.TravelRoutes.FirstOrDefault(x =>
x.TravelRoute.SiteA == siteA && x.TravelRoute.SiteB == siteB ||
x.TravelRoute.SiteA == siteB && x.TravelRoute.SiteB == siteA);
if (tr == null)
{
throw new DataIntegrityException("There seems to be no route from " + siteA.PrettyName +
" to " + siteB.PrettyName +
" in the travel route set " + travelRouteSet.PrettyName +
". Every site needs to be connected to every other site, since the LPG has no routing functionality yet. Please fix.");
}
}
}
}
private static void MakeNewAdjustedRoute([NotNull] Simulator sim,
[NotNull] TravelRouteSetEntry oldTravelRouteSetEntry,
int adjustingDistances,
[CanBeNull] string modRouteKey,
[NotNull] TransportationDistanceModifier modifier,
[NotNull] TravelRouteSet adjustedTravelrouteset)
{
var oldRoute = oldTravelRouteSetEntry.TravelRoute;
TravelRoute newRoute = new TravelRoute(null,
sim.ConnectionString,
oldRoute.Name + " adjustment " + adjustingDistances,
oldRoute.Description,
oldRoute.SiteA,
oldRoute.SiteB,
Guid.NewGuid().ToStrGuid(),
oldRoute.RouteKey);
newRoute.SaveToDB();
sim.TravelRoutes.It.Add(newRoute);
foreach (var step in oldRoute.Steps)
{
double distance = step.Distance;
if (step.StepKey?.ToLower(CultureInfo.InvariantCulture) == modRouteKey)
{
distance = modifier.NewDistanceInMeters;
}
newRoute.AddStep(step.Name, step.TransportationDeviceCategory, distance, step.StepNumber, step.StepKey, false);
}
newRoute.SaveToDB();
//Logger.Info("Adjusted route " + newRoute.Name);
adjustedTravelrouteset.AddRoute(newRoute);
}
public TravelRouteSetPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] TravelRouteSetView view,
[NotNull] TravelRouteSet routeSet) : base(view, "ThisRouteSet.Name", routeSet,
applicationPresenter)
{
ThisRouteSet = routeSet;
_modularHousehold = Sim.ModularHouseholds[0];
RefreshDataTable();
RefreshRoutes();
}
public ChargingStationSetPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] ChargingStationSetView view,
[NotNull] ChargingStationSet routeSet) : base(view, "ThisChargingStationSet.Name", routeSet,
applicationPresenter)
{
ThisChargingStationSet = routeSet;
_selectedModularHousehold = Sim.ModularHouseholds[0];
_selectedTravelRouteSet = Sim.TravelRouteSets[0];
RefreshRelevantSites();
}
public HouseHousehold([CanBeNull] int?pID, int houseID, [CanBeNull] ICalcObject household, [NotNull] string connectionString,
[NotNull] string householdName, StrGuid guid, [CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] ChargingStationSet chargingStationSet, [CanBeNull] TravelRouteSet travelRouteSet) : base(householdName, TableName, connectionString, guid)
{
ID = pID;
HouseID = houseID;
_household = household;
TransportationDeviceSet = transportationDeviceSet;
ChargingStationSet = chargingStationSet;
TravelRouteSet = travelRouteSet;
TypeDescription = "House Household";
}
private static TravelRouteSet AdjustTravelDistancesBasedOnModifiers([NotNull] TravelRouteSet travelrouteset,
[NotNull] Simulator sim,
[NotNull] House house,
[NotNull] HouseholdData householdData,
int householdidx)
{
Stopwatch sw = Stopwatch.StartNew();
if (householdData.TransportationDistanceModifiers == null)
{
throw new LPGException("Was null even though this was checked before the function was called.");
}
var newName = travelrouteset.Name + "(" + house.Name + " - " + householdData.Name + " " + householdidx + ")";
var adjustedTravelrouteset = new TravelRouteSet(newName, null, sim.ConnectionString, travelrouteset.Description, Guid.NewGuid().ToStrGuid());
adjustedTravelrouteset.SaveToDB();
sim.TravelRouteSets.It.Add(adjustedTravelrouteset);
int adjustingDistances = 0;
foreach (TravelRouteSetEntry oldTravelRouteSetEntry in travelrouteset.TravelRoutes)
{
bool addUnmodifiedRoute = true;
foreach (var modifier in householdData.TransportationDistanceModifiers)
{
string modRouteKey = modifier.RouteKey?.ToLower(CultureInfo.InvariantCulture);
if (oldTravelRouteSetEntry.TravelRoute.RouteKey?.ToLower(CultureInfo.InvariantCulture) == modRouteKey)
{
Logger.Info("Adjusting distances for key " + modifier.RouteKey + "-" + modifier.StepKey + ", total routes in the db: " + sim.TravelRoutes.It.Count);
var modStepKey = modifier.StepKey?.ToLower(CultureInfo.InvariantCulture);
var oldRouteSteps = oldTravelRouteSetEntry.TravelRoute.Steps.Where(x => x.StepKey?.ToLower(CultureInfo.InvariantCulture) == modStepKey).ToList();
if (oldRouteSteps.Count > 0)
{
MakeNewAdjustedRoute(sim, oldTravelRouteSetEntry, adjustingDistances, modRouteKey, modifier, adjustedTravelrouteset);
addUnmodifiedRoute = false;
adjustingDistances++;
}
}
}
if (addUnmodifiedRoute)
{
adjustedTravelrouteset.AddRoute(oldTravelRouteSetEntry.TravelRoute);
}
}
//Config.ShowDeleteMessages = true;
travelrouteset = adjustedTravelrouteset;
adjustedTravelrouteset.SaveToDB();
sw.Stop();
Logger.Info("Total distances adjusted: " + adjustingDistances + ". This took " + sw.Elapsed.TotalSeconds.ToString("F2", CultureInfo.InvariantCulture) + " seconds.");
return(travelrouteset);
}
public void MakeTransportationDtos([NotNull] Simulator sim, [NotNull] ModularHousehold mhh,
[CanBeNull] TransportationDeviceSet transportationDeviceSet,
[CanBeNull] TravelRouteSet travelRouteSet,
[CanBeNull] ChargingStationSet chargingStationSet,
[NotNull][ItemNotNull] out List <CalcSiteDto> sites,
[NotNull][ItemNotNull] out List <CalcTransportationDeviceDto> transportationDevices,
[NotNull][ItemNotNull] out List <CalcTravelRouteDto> routes,
[NotNull][ItemNotNull] List <CalcLocationDto> locations, [NotNull] HouseholdKey key)
{
if (transportationDeviceSet == null)
{
throw new LPGException("Transportationdeviceset was null");
}
if (travelRouteSet == null)
{
throw new LPGException("travelRouteSet was null");
}
if (chargingStationSet == null)
{
throw new LPGException("chargingStationSet was null");
}
if (travelRouteSet == null)
{
throw new LPGException("Travel Route Set was null");
}
var sitesFromAllTravelRoutes = MakeTravelRouteSites(mhh, travelRouteSet, out var householdSites);
//check if all locations have sites
CheckReachabilityofLocations(mhh.CollectLocations(), sitesFromAllTravelRoutes, mhh.Name,
travelRouteSet.Name);
//check if all sites are reachable from all other sites
CheckRouteCompleteness(travelRouteSet, householdSites);
// check if at least one route from each site to each other site is doable with the given transport
CheckRouteTransportationDeviceCompleteness(travelRouteSet, householdSites, transportationDeviceSet);
var categoriesDict = MakeCalcTransportationDeviceCategoryDtos(sim);
sites = MakeCalcSiteDtos(householdSites, locations, categoriesDict, key, chargingStationSet);
// figure out the transportation devices
var selectedDevices = SelectTransportationDevices(transportationDeviceSet);
//create the calc transportation devices
//TODO: introduce load types
transportationDevices = MakeTransportationDevices(selectedDevices, categoriesDict, key);
routes = MakeTravelRoutes(travelRouteSet, householdSites, categoriesDict, sites, key);
}
//public const string TableName = "CalcStartParameterSet";
/// <summary>
/// starter for unit tests
/// </summary>
public CalcStartParameterSet(
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity,
bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection,
LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull] TravelRouteSet travelRouteSet, [NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler, string resultPath, bool transportationEnabled)
{
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
SelectedRandomSeed = selectedRandomSeed;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = DeviceProfileHeaderMode.Standard;
ResultPath = resultPath;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
public CalculationPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] CalculateView view) : base(view, "Headerstring", applicationPresenter)
{
CalcObjects = new ObservableCollection <ICalcObject>();
_applicationPresenter = applicationPresenter;
DefaultTimeSteps = new ObservableCollection <string>();
ExternalTimeSteps = new ObservableCollection <string>();
// load the previously selected item again
var cfg = Sim.MyGeneralConfig;
SelectedCalcObjectType = CalcObjectTypeHelper.GetFromString(cfg.LastSelectedCalcType);
foreach (var calcObject in CalcObjects)
{
if (calcObject.Name == Sim.MyGeneralConfig.LastSelectedCalcObject)
{
SelectedCalcObject = calcObject;
}
}
if (cfg.LastSelectedTransportationSetting == "TRUE")
{
EnableTransport = true;
}
else
{
EnableTransport = false;
}
if (!string.IsNullOrWhiteSpace(cfg.LastSelectedRouteSet))
{
_selectedTravelRouteSet = Sim.TravelRouteSets.FindFirstByName(cfg.LastSelectedRouteSet) ?? Sim.TravelRouteSets[0];
}
if (!string.IsNullOrWhiteSpace(cfg.LastSelectedChargingStationSet))
{
_selectedChargingStationSet = Sim.ChargingStationSets.FindFirstByName(cfg.LastSelectedChargingStationSet) ?? Sim.ChargingStationSets[0];
}
if (!string.IsNullOrWhiteSpace(cfg.LastSelectedTransportationDeviceSet))
{
_selectedTransportationDeviceSet = Sim.TransportationDeviceSets.FindFirstByName(cfg.LastSelectedTransportationDeviceSet) ?? Sim.TransportationDeviceSets[0];
}
else
{
_selectedTransportationDeviceSet = Sim.TransportationDeviceSets.It[0];
}
}
private static List <CalcTravelRouteDto> MakeTravelRoutes([NotNull] TravelRouteSet travelRouteSet, [NotNull][ItemNotNull] List <Site> householdSites,
[NotNull] Dictionary <TransportationDeviceCategory, CalcTransportationDeviceCategoryDto> categoriesDict,
[NotNull][ItemNotNull] List <CalcSiteDto> calcSites, [NotNull] HouseholdKey key)
{
List <CalcTravelRouteDto> routes = new List <CalcTravelRouteDto>();
//make travel routes
var neededRoutes = travelRouteSet.TravelRoutes.Where(x =>
householdSites.Contains(x.TravelRoute.SiteA) && householdSites.Contains(x.TravelRoute.SiteB));
foreach (TravelRouteSetEntry entry in neededRoutes)
{
if (entry.TravelRoute.SiteA == null)
{
throw new LPGException("site A was null");
}
if (entry.TravelRoute.SiteB == null)
{
throw new LPGException("site B was null");
}
CalcSiteDto siteA = calcSites.Single(x => x.ID == entry.TravelRoute.SiteA.IntID);
CalcSiteDto siteB = calcSites.Single(x => x.ID == entry.TravelRoute.SiteB.IntID);
CalcTravelRouteDto ctr = new CalcTravelRouteDto(entry.TravelRoute.Name, entry.TravelRoute.IntID, key,
Guid.NewGuid().ToStrGuid(), siteA.Name, siteA.Guid, siteB.Name, siteB.Guid);
foreach (TravelRouteStep step in entry.TravelRoute.Steps)
{
CalcTransportationDeviceCategoryDto cat = categoriesDict[step.TransportationDeviceCategory];
ctr.AddTravelRouteStep(step.Name, step.IntID, cat, step.StepNumber, step.Distance,
Guid.NewGuid().ToStrGuid());
}
routes.Add(ctr);
}
foreach (var site in calcSites)
{
CalcTravelRouteDto ctr = new CalcTravelRouteDto("Travel Route inside the site " + site.Name,
-1, key, Guid.NewGuid().ToStrGuid(), site.Name, site.Guid, site.Name, site.Guid);
routes.Add(ctr);
}
return(routes);
}
public void TravelRouteSetTestImportExport()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Simulator sim = new Simulator(db.ConnectionString);
var travelrouteset = sim.TravelRouteSets[0];
//var copy =
TravelRouteSet.ImportFromItem(travelrouteset, sim);
//var jsonOriginal = JsonConvert.SerializeObject(travelrouteset, Formatting.Indented,
// new JsonSerializerSettings()
// {
// ReferenceLoopHandling = ReferenceLoopHandling.Ignore
// });
//var jsonCopy = JsonConvert.SerializeObject(copy, Formatting.Indented,
// new JsonSerializerSettings()
// {
// ReferenceLoopHandling = ReferenceLoopHandling.Ignore
// });
db.Cleanup();
}
//(jsonCopy).Should().Be(jsonOriginal);
}
public CalcHouseholdDto MakeCalcModularHouseholdDto([NotNull] Simulator sim, [NotNull] ModularHousehold mhh,
[NotNull] TemperatureProfile temperatureProfile, [NotNull] HouseholdKey householdKey, [NotNull] GeographicLocation geographicLocation,
[NotNull] out LocationDtoDict locationDict,
[CanBeNull] TransportationDeviceSet transportationDeviceSet,
[CanBeNull] TravelRouteSet travelRouteSet, EnergyIntensityType energyIntensity,
[CanBeNull] ChargingStationSet chargingStationSet)
{
// _lf.RegisterKey(householdKey, mhh.PrettyName);
var name = CalcAffordanceFactory.FixAffordanceName(mhh.Name, sim.MyGeneralConfig.CSVCharacter);
if (geographicLocation == null)
{
throw new DataIntegrityException("no geographic Location was set");
}
var et = energyIntensity;
if (et == EnergyIntensityType.AsOriginal)
{
et = mhh.EnergyIntensityType;
}
name = name + " " + householdKey.Key;
var locations = mhh.CollectLocations();
//var deviceLocationDict = new Dictionary<CalcLocation, List<IAssignableDevice>>();
var deviceLocationDtoDict = new Dictionary <CalcLocationDto, List <IAssignableDevice> >();
locationDict = new LocationDtoDict();
List <DeviceCategoryDto> deviceCategoryDtos = new List <DeviceCategoryDto>();
foreach (var deviceCategory in sim.DeviceCategories.It)
{
deviceCategoryDtos.Add(new DeviceCategoryDto(deviceCategory.FullPath, Guid.NewGuid().ToStrGuid()));
}
var locationDtos = _calcLocationDtoFactory.MakeCalcLocations(locations,
householdKey,
et, deviceLocationDtoDict, sim.DeviceActions.It, locationDict, deviceCategoryDtos);
// persons
if (mhh.Vacation == null)
{
throw new LPGException("Vacation was null");
}
var personDtos = _calcPersonDtoFactory.MakePersonDtos(mhh.Persons.ToList(), householdKey,
mhh.Vacation.VacationTimeframes(), mhh.CollectTraitDesires(), mhh.Name);
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
_calcRepo.InputDataLogger.SaveList(personDtos.ConvertAll(x => (IHouseholdKey)x));
}
//mhh.Persons.ToList(),mhh.Vacation.VacationTimeframes(), sim.MyGeneralConfig.RepetitionCount,householdKey, locs[0],name);
//CalcPersonFactory.AddTraitDesires(mhh.CollectTraitDesires(), calcpersons,sim.MyGeneralConfig.TimeStepsPerHour, chh.Name, new Dictionary<Desire, SharedDesireValue>());
//check if unhungry and unhungry join only have been added both
//can't check it in the integrity checker, because that would mean having to duplicate the entire
// desire collection logic
/* foreach (CalcPerson person in calcpersons) {
* var desires =
* person.PersonDesires.Desires.Values.Where(x => x.Name.ToLower().Contains("unhungry") || x.Name.ToLower().Contains("un-hungry")).ToList();
* if (desires.Count > 1) {
* throw new DataIntegrityException("More than one unhungry desire for the person " + person.Name, mhh);
* }
* }*/
// devices
var deviceLocations = new List <DeviceLocationTuple>();
foreach (var modularHouseholdTrait in mhh.Traits)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (modularHouseholdTrait.HouseholdTrait != null)
{
CollectDevicesFromTrait(modularHouseholdTrait.HouseholdTrait, deviceLocations);
}
}
var deviceDtos = _calcDeviceDtoFactory.MakeCalcDevices(locationDtos,
deviceLocations, et, householdKey, deviceLocationDtoDict, sim.DeviceActions.It, _ltDict, deviceCategoryDtos);
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
_calcRepo.InputDataLogger.SaveList(deviceDtos.ConvertAll(x => (IHouseholdKey)x));
}
//autodevs
var autonomousDevices = mhh.CollectAutonomousDevices();
if (mhh.Vacation == null)
{
throw new LPGException("Vacation was null");
}
var autoDevDtos = _calcDeviceDtoFactory.MakeCalcAutoDevDtos(autonomousDevices,
energyIntensity, householdKey, mhh.Vacation.VacationTimeframes(),
mhh.Name + "###" + householdKey,
sim.DeviceActions.It, locationDict,
temperatureProfile, geographicLocation, deviceCategoryDtos);
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
_calcRepo.InputDataLogger.SaveList(autoDevDtos.ConvertAll(x => (IHouseholdKey)x));
}
//affordances
var affordancesAtLoc =
new Dictionary <CalcLocationDto, List <AffordanceWithTimeLimit> >();
foreach (var location in locations)
{
affordancesAtLoc.Add(locationDict.GetDtoForLocation(location), mhh.GetAllAffordancesForLocation(location));
}
if (mhh.Vacation == null)
{
throw new LPGException("Vacation was null");
}
List <CalcAffordanceDto> allAffordances = _calcAffordanceDtoFactory.SetCalcAffordances(locationDtos, temperatureProfile,
_ltDict,
geographicLocation, _random, sim.MyGeneralConfig.TimeStepsPerHour,
sim.MyGeneralConfig.InternalStepSize, mhh.Vacation.VacationTimeframes(),
mhh.Name + "###" + householdKey, sim.DeviceActions.MyItems, affordancesAtLoc, locationDict,
out List <DateTime> bridgeDays, householdKey, deviceDtos, deviceCategoryDtos);
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
_calcRepo.InputDataLogger.SaveList(allAffordances.ConvertAll(x => (IHouseholdKey)x));
_calcRepo.InputDataLogger.SaveList(_calcVariableRepositoryDtoFactory.GetAllVariableDtos()
.ConvertAll(x => (IHouseholdKey)x));
}
// SaveVariableDefinitionsDtos(_calcVariableRepositoryDtoFactory.GetAllVariableDtos());
//CalcVariableRepository variableRepository = _calcVariableRepositoryDtoFactory.GetRepository(householdKey);
List <CalcSiteDto> sites = null;
List <CalcTransportationDeviceDto> transportationDevices = null;
List <CalcTravelRouteDto> routes = null;
if (_calcRepo.CalcParameters.TransportationEnabled)
{
_transportationDtoFactory.MakeTransportationDtos(sim, mhh, transportationDeviceSet,
travelRouteSet, chargingStationSet,
out sites, out transportationDevices,
out routes, locationDtos, householdKey);
if (_calcRepo.CalcParameters.IsSet(CalcOption.TransportationStatistics))
{
_calcRepo.InputDataLogger.SaveList(sites.ConvertAll(x => (IHouseholdKey)x));
_calcRepo.InputDataLogger.SaveList(transportationDevices.ConvertAll(x => (IHouseholdKey)x));
_calcRepo.InputDataLogger.SaveList(routes.ConvertAll(x => (IHouseholdKey)x));
}
}
var chh = new CalcHouseholdDto(name, mhh.IntID, temperatureProfile.Name, householdKey, Guid.NewGuid().ToStrGuid(),
geographicLocation.Name,
bridgeDays, autoDevDtos, locationDtos, personDtos, deviceDtos,
allAffordances, mhh.Vacation.VacationTimeframes(),
sites, routes, transportationDevices,
mhh.Description);
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
_calcRepo.InputDataLogger.Save(householdKey, chh);
}
if (_calcRepo.CalcParameters.Options.Contains(CalcOption.HouseholdContents))
{
BridgeDayEntries bdes = new BridgeDayEntries(householdKey, chh.BridgeDays);
_calcRepo.InputDataLogger.Save(householdKey, bdes);
}
return(chh);
}
private static List <Site> MakeTravelRouteSites([NotNull] ModularHousehold mhh, [NotNull] TravelRouteSet travelRouteSet,
[NotNull][ItemNotNull] out List <Site> householdSites)
{
//first figure out the sites in the travel route set
List <Site> travelRouteSites = new List <Site>();
foreach (var route in travelRouteSet.TravelRoutes)
{
travelRouteSites.Add(route.TravelRoute.SiteA);
travelRouteSites.Add(route.TravelRoute.SiteB);
}
travelRouteSites = travelRouteSites.Distinct().ToList();
//then look for all the sites in the household and make sure that they are covered by the travel route
householdSites = new List <Site>();
foreach (Location location in mhh.CollectLocations())
{
Site site = travelRouteSites.FirstOrDefault(x => x.Locations.Any(y => y.Location == location));
if (site == null)
{
throw new LPGException("Could not find a site for the location " + location.PrettyName +
" in the travel route set " + travelRouteSet.PrettyName);
}
if (!householdSites.Contains(site))
{
householdSites.Add(site);
}
}
return(travelRouteSites);
}
private List <LoadingEntry> GetLoadingActions(bool ignoreMissingTables)
{
var actions = new List <LoadingEntry>
{
new LoadingEntry("Loadtypes",
() => VLoadType.LoadFromDatabase(LoadTypes.MyItems, ConnectionString, ignoreMissingTables),
LoadTypes),
new LoadingEntry("Holidays",
() => Holiday.LoadFromDatabase(Holidays.MyItems, ConnectionString, ignoreMissingTables), Holidays),
new LoadingEntry("Variables",
() => Variable.LoadFromDatabase(Variables.It, ConnectionString, ignoreMissingTables), Variables),
new LoadingEntry("Date Based Profiles",
() => DateBasedProfile.LoadFromDatabase(DateBasedProfiles.MyItems, ConnectionString,
ignoreMissingTables), DateBasedProfiles),
new LoadingEntry("Vacations",
() => Vacation.LoadFromDatabase(Vacations.MyItems, ConnectionString, ignoreMissingTables),
Vacations),
new LoadingEntry("Desires",
() => Desire.LoadFromDatabase(Desires.MyItems, ConnectionString, ignoreMissingTables), Desires),
new LoadingEntry("Time Profiles",
() => TimeBasedProfile.LoadFromDatabase(Timeprofiles.MyItems, ConnectionString, ignoreMissingTables),
Timeprofiles),
new LoadingEntry("Temperature Profiles",
() => TemperatureProfile.LoadFromDatabase(TemperatureProfiles.MyItems, ConnectionString,
ignoreMissingTables), TemperatureProfiles),
new LoadingEntry("Generators",
() => Generator.LoadFromDatabase(Generators.MyItems, ConnectionString, LoadTypes.MyItems,
DateBasedProfiles.MyItems, ignoreMissingTables), Generators),
new LoadingEntry("Energy Storages",
() => EnergyStorage.LoadFromDatabase(EnergyStorages.MyItems, ConnectionString, LoadTypes.MyItems, Variables.MyItems,
ignoreMissingTables), EnergyStorages),
new LoadingEntry("Transformation Devices",
() => TransformationDevice.LoadFromDatabase(TransformationDevices.MyItems, ConnectionString,
LoadTypes.MyItems, Variables.MyItems, ignoreMissingTables), TransformationDevices),
new LoadingEntry("Device Categories", () =>
{
DeviceCategory.LoadFromDatabase(DeviceCategories.MyItems, out _dcnone, ConnectionString,
RealDevices.MyItems, ignoreMissingTables);
DeviceCategories.DeviceCategoryNone = _dcnone;
}, DeviceCategories),
new LoadingEntry("Real Devices",
() => RealDevice.LoadFromDatabase(RealDevices.MyItems, DeviceCategories.MyItems,
DeviceCategories.DeviceCategoryNone, ConnectionString, LoadTypes.MyItems, Timeprofiles.MyItems,
ignoreMissingTables), RealDevices),
new LoadingEntry("Device Action Groups",
() => DeviceActionGroup.LoadFromDatabase(DeviceActionGroups.MyItems, ConnectionString,
ignoreMissingTables), DeviceActionGroups),
new LoadingEntry("Device Actions",
() => DeviceAction.LoadFromDatabase(DeviceActions.MyItems, ConnectionString, Timeprofiles.MyItems,
RealDevices.MyItems, LoadTypes.MyItems, DeviceActionGroups.MyItems, ignoreMissingTables),
DeviceActions),
new LoadingEntry("Device Tagging Sets",
() => DeviceTaggingSet.LoadFromDatabase(DeviceTaggingSets.MyItems, ConnectionString,
ignoreMissingTables, RealDevices.MyItems, LoadTypes.It), DeviceTaggingSets),
new LoadingEntry("Persons",
() => Person.LoadFromDatabase(Persons.MyItems, ConnectionString,
ignoreMissingTables), Persons),
new LoadingEntry("Locations",
() => Location.LoadFromDatabase(Locations.MyItems, ConnectionString, RealDevices.MyItems,
DeviceCategories.MyItems, LoadTypes.MyItems, ignoreMissingTables), Locations),
new LoadingEntry("Time Limits",
() => TimeLimit.LoadFromDatabase(TimeLimits.MyItems, DateBasedProfiles.MyItems, ConnectionString,
ignoreMissingTables), TimeLimits),
new LoadingEntry("Geographic Locations",
() => GeographicLocation.LoadFromDatabase(GeographicLocations.MyItems, ConnectionString,
Holidays.MyItems, TimeLimits.MyItems, ignoreMissingTables), GeographicLocations),
new LoadingEntry("Subaffordances",
() => SubAffordance.LoadFromDatabase(SubAffordances.MyItems, ConnectionString, Desires.MyItems,
ignoreMissingTables, Locations.It, Variables.It), SubAffordances),
new LoadingEntry("Affordances",
() => Affordance.LoadFromDatabase(Affordances.MyItems, ConnectionString, Timeprofiles.MyItems,
DeviceCategories.MyItems, RealDevices.MyItems, Desires.MyItems, SubAffordances.MyItems,
LoadTypes.MyItems, TimeLimits.MyItems, DeviceActions.MyItems, DeviceActionGroups.MyItems,
Locations.It, ignoreMissingTables, Variables.It), Affordances),
new LoadingEntry("Affordance Tagging Sets",
() => AffordanceTaggingSet.LoadFromDatabase(AffordanceTaggingSets.MyItems, ConnectionString,
ignoreMissingTables, Affordances.MyItems, LoadTypes.It), AffordanceTaggingSets),
new LoadingEntry("Trait Tags",
() => TraitTag.LoadFromDatabase(TraitTags.MyItems, ConnectionString, ignoreMissingTables),
TraitTags),
new LoadingEntry("Household Traits",
() => HouseholdTrait.LoadFromDatabase(HouseholdTraits.MyItems, ConnectionString, Locations.MyItems,
Affordances.MyItems, RealDevices.MyItems, DeviceCategories.MyItems, Timeprofiles.MyItems,
LoadTypes.MyItems, TimeLimits.MyItems, Desires.MyItems, DeviceActions.It, DeviceActionGroups.It,
TraitTags.It, ignoreMissingTables, Variables.It), HouseholdTraits),
new LoadingEntry("Device Selections",
() => DeviceSelection.LoadFromDatabase(DeviceSelections.MyItems, ConnectionString,
DeviceCategories.MyItems, RealDevices.MyItems, DeviceActions.It, DeviceActionGroups.It,
ignoreMissingTables), DeviceSelections),
new LoadingEntry("Household Tags",
() => HouseholdTag.LoadFromDatabase(HouseholdTags.It, ConnectionString, ignoreMissingTables),
HouseholdTags),
new LoadingEntry("Modular Households",
() => ModularHousehold.LoadFromDatabase(ModularHouseholds.MyItems, ConnectionString,
HouseholdTraits.MyItems, DeviceSelections.MyItems, ignoreMissingTables, Persons.MyItems,
Vacations.It, HouseholdTags.It, TraitTags.It), ModularHouseholds),
new LoadingEntry("Household Templates",
() => HouseholdTemplate.LoadFromDatabase(HouseholdTemplates.MyItems, ConnectionString,
HouseholdTraits.MyItems, ignoreMissingTables, Persons.MyItems, TraitTags.It, Vacations.It,
HouseholdTags.It, DateBasedProfiles.It), HouseholdTemplates),
new LoadingEntry("Template Persons",
() => TemplatePerson.LoadFromDatabase(TemplatePersons.It, ConnectionString, HouseholdTraits.It,
ignoreMissingTables, ModularHouseholds.It, Persons.It), TemplatePersons),
new LoadingEntry("Household Plans",
() => HouseholdPlan.LoadFromDatabase(HouseholdPlans.MyItems, ConnectionString, ignoreMissingTables,
Persons.MyItems, AffordanceTaggingSets.MyItems, ModularHouseholds.MyItems),
HouseholdPlans),
new LoadingEntry("House Types",
() => HouseType.LoadFromDatabase(HouseTypes.MyItems, ConnectionString, RealDevices.MyItems,
DeviceCategories.MyItems, Timeprofiles.MyItems, TimeLimits.MyItems, LoadTypes.MyItems,
TransformationDevices.MyItems, EnergyStorages.MyItems, Generators.MyItems, ignoreMissingTables,
Locations.MyItems, DeviceActions.It, DeviceActionGroups.It, Variables.It), HouseTypes),
new LoadingEntry("Transportation Device Categories",
() => TransportationDeviceCategory.LoadFromDatabase(TransportationDeviceCategories.It, ConnectionString,
ignoreMissingTables), TransportationDeviceCategories),
new LoadingEntry("Sites",
() => Site.LoadFromDatabase(Sites.It,
ConnectionString, ignoreMissingTables,
Locations.It), Sites),
new LoadingEntry("Transportation Devices",
() => TransportationDevice.LoadFromDatabase(TransportationDevices.It, ConnectionString, ignoreMissingTables,
TransportationDeviceCategories.It, LoadTypes.It), TransportationDevices),
new LoadingEntry("Transportation Device Sets",
() => TransportationDeviceSet.LoadFromDatabase(TransportationDeviceSets.It, ConnectionString,
ignoreMissingTables, TransportationDevices.It), TransportationDeviceSets),
new LoadingEntry("Travel Routes",
() => TravelRoute.LoadFromDatabase(TravelRoutes.It, ConnectionString, ignoreMissingTables,
TransportationDeviceCategories.It, Sites.It), TravelRoutes),
new LoadingEntry("Travel Route Sets",
() => TravelRouteSet.LoadFromDatabase(TravelRouteSets.It, ConnectionString, ignoreMissingTables,
TravelRoutes.It), TravelRouteSets),
new LoadingEntry("Charging Station Sets",
() => ChargingStationSet.LoadFromDatabase(ChargingStationSets.It,
ConnectionString, ignoreMissingTables,
LoadTypes.It, TransportationDeviceCategories.It, Sites.It), ChargingStationSets),
new LoadingEntry("Houses",
() => House.LoadFromDatabase(Houses.MyItems, ConnectionString, TemperatureProfiles.MyItems,
GeographicLocations.MyItems, HouseTypes.MyItems,
ModularHouseholds.MyItems, ChargingStationSets.MyItems,
TransportationDeviceSets.MyItems, TravelRouteSets.MyItems,
ignoreMissingTables), Houses),
new LoadingEntry("Settlements",
() => Settlement.LoadFromDatabase(Settlements.MyItems, ConnectionString,
TemperatureProfiles.MyItems, GeographicLocations.MyItems, ModularHouseholds.MyItems, Houses.MyItems,
ignoreMissingTables), Settlements),
new LoadingEntry("Settlement Templates",
() => SettlementTemplate.LoadFromDatabase(SettlementTemplates.It, ConnectionString,
HouseholdTemplates.It, HouseTypes.It, ignoreMissingTables, TemperatureProfiles.It,
GeographicLocations.It, HouseholdTags.It, HouseholdTraits.It), SettlementTemplates),
new LoadingEntry("Settings",
() => MyGeneralConfig = GeneralConfig.LoadFromDatabase(ConnectionString, ignoreMissingTables), null),
new LoadingEntry("Calculation Outcomes",
() => CalculationOutcome.LoadFromDatabase(CalculationOutcomes.MyItems, ConnectionString,
ignoreMissingTables), CalculationOutcomes)
};
return(actions);
}
