/// <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;
}
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 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 List <TransportationDevice> SelectTransportationDevices([NotNull] TransportationDeviceSet transportationDeviceSet)
{
List <TransportationDevice> selectedDevices = new List <TransportationDevice>();
foreach (var device in transportationDeviceSet.TransportationDeviceSetEntries)
{
if (!selectedDevices.Contains(device.TransportationDevice))
{
selectedDevices.Add(device.TransportationDevice);
}
}
return(selectedDevices);
}
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 void TransportationDeviceImportTest()
{
using (var db1 = new DatabaseSetup(Utili.GetCurrentMethodAndClass() + "1"))
{
using (var db2 = new DatabaseSetup(Utili.GetCurrentMethodAndClass() + "2"))
{
db1.ClearTable(TransportationDeviceSet.TableName);
var srcSim = new Simulator(db2.ConnectionString);
var dstSim = new Simulator(db1.ConnectionString);
foreach (var device in srcSim.TransportationDeviceSets.It)
{
TransportationDeviceSet.ImportFromItem(device, dstSim);
}
}
}
}
//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];
}
}
public void TransportationDeviceSetTest()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TransportationDeviceSet.TableName);
db.ClearTable(TransportationDevice.TableName);
db.ClearTable(TransportationDeviceCategory.TableName);
TransportationDeviceSet tds =
new TransportationDeviceSet("transportationdeviceset", null, db.ConnectionString, "desc",
System.Guid.NewGuid().ToStrGuid());
tds.SaveToDB();
TransportationDeviceCategory tdc = new TransportationDeviceCategory("transportationdevicecategory",
null, db.ConnectionString, "desc", true, System.Guid.NewGuid().ToStrGuid());
tdc.SaveToDB();
VLoadType vlt = (VLoadType)VLoadType.CreateNewItem(null, db.ConnectionString);
vlt.SaveToDB();
TransportationDevice tdev = new TransportationDevice("mydevice", null, db.ConnectionString, "", 1, SpeedUnit.Kmh,
tdc, 1000, 10, 100, 100, vlt,
System.Guid.NewGuid().ToStrGuid());
tdev.SaveToDB();
ObservableCollection <TransportationDevice> transportationDevices = new ObservableCollection <TransportationDevice>
{
tdev
};
tds.AddDevice(tdev);
/*ObservableCollection<TransportationDeviceCategory> categories = new ObservableCollection<TransportationDeviceCategory>
* {
* tdc
* };*/
ObservableCollection <TransportationDeviceSet> result = new ObservableCollection <TransportationDeviceSet>();
TransportationDeviceSet.LoadFromDatabase(result, db.ConnectionString, false, transportationDevices);
db.Cleanup();
(result.Count).Should().Be(1);
(result[0].TransportationDeviceSetEntries.Count).Should().Be(1);
}
}
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);
}
public TransportationDeviceSetPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] TransportationDeviceSetView view,
[NotNull] TransportationDeviceSet set) : base(view, "ThisSet.Name", set, applicationPresenter)
{
_transporatationDeviceSet = set;
}
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);
}
