public void ModularHouseholdTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(ModularHousehold.TableName);
db.ClearTable(ModularHouseholdTrait.TableName);
db.ClearTable(ModularHouseholdPerson.TableName);
var persons = new ObservableCollection <Person>();
var result = new ObservableCollection <ModularHousehold>();
var householdTraits = new ObservableCollection <HouseholdTrait>();
var hht = new HouseholdTrait("blub", null, "blub", db.ConnectionString, "none", 1, 100, 10, 1, 1,
TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht.SaveToDB();
householdTraits.Add(hht);
var deviceSelections = new ObservableCollection <DeviceSelection>();
var ds = new DeviceSelection("ds", null, "bla", db.ConnectionString, Guid.NewGuid().ToStrGuid());
ds.SaveToDB();
deviceSelections.Add(ds);
var vacations = db.LoadVacations();
var hhTags = db.LoadHouseholdTags();
var traitTags = db.LoadTraitTags();
ModularHousehold.LoadFromDatabase(result, db.ConnectionString, householdTraits, deviceSelections, false,
persons, vacations, hhTags, traitTags);
(result.Count).Should().Be(0);
var chh = new ModularHousehold("blub", null, "blub", db.ConnectionString, ds, "src", null, null,
EnergyIntensityType.Random, CreationType.ManuallyCreated, Guid.NewGuid().ToStrGuid());
chh.SaveToDB();
chh.AddTrait(hht, ModularHouseholdTrait.ModularHouseholdTraitAssignType.Age, null);
chh.SaveToDB();
result.Clear();
ModularHousehold.LoadFromDatabase(result, db.ConnectionString, householdTraits, deviceSelections, false,
persons, vacations, hhTags, traitTags);
(result.Count).Should().Be(1);
(result[0].Traits.Count).Should().Be(1);
db.Cleanup();
}
}
public void DeviceCategoryPickerDeviceActionGroupAutoDev()
{
Random r = new Random(2);
DeviceSelection ds = new DeviceSelection("ds", 1, string.Empty, string.Empty, Guid.NewGuid().ToStrGuid());
DeviceCategoryPicker picker = new DeviceCategoryPicker(r, ds);
// device stuff
ObservableCollection <RealDevice> allDevices = new ObservableCollection <RealDevice>();
DeviceCategory dc = new DeviceCategory("dc", -1, "bla", false, allDevices, Guid.NewGuid().ToStrGuid());
RealDevice rd1 = new RealDevice("device1", 0, string.Empty, dc, "desc", false, true, string.Empty, Guid.NewGuid().ToStrGuid(), -1);
RealDevice rd2 = new RealDevice("device2", 0, string.Empty, dc, "desc", false, true, string.Empty, Guid.NewGuid().ToStrGuid(), -1);
DeviceActionGroup dag = new DeviceActionGroup("Dag1", string.Empty, "blub", Guid.NewGuid().ToStrGuid(), -1);
DeviceAction da1 = new DeviceAction("da1", -1, "blub", string.Empty, dag, rd1, Guid.NewGuid().ToStrGuid());
DeviceAction da2 = new DeviceAction("da2", -1, "blub", string.Empty, dag, rd2, Guid.NewGuid().ToStrGuid());
ObservableCollection <DeviceAction> deviceActions = new ObservableCollection <DeviceAction>
{
da1,
da2
};
allDevices.Add(rd1);
List <IAssignableDevice> otherDevicesAtLocation = new List <IAssignableDevice>
{
dag
};
DeviceAction pickedDeviceAction = picker.GetAutoDeviceActionFromGroup(dag, otherDevicesAtLocation,
EnergyIntensityType.Random, deviceActions, 5);
Logger.Info("Device Action 1 " + pickedDeviceAction);
for (int i = 0; i < 50; i++)
{
DeviceAction deviceAction2 = picker.GetAutoDeviceActionFromGroup(dag, otherDevicesAtLocation,
EnergyIntensityType.Random, deviceActions, 5);
Logger.Info("Device Action " + i + " " + deviceAction2);
pickedDeviceAction.Should().Be(deviceAction2);
}
}
public void DeviceCategoryPickerTestDeviceCategories()
{
Random r = new Random(5);
DeviceSelection ds = new DeviceSelection("ds", 1, string.Empty, string.Empty, Guid.NewGuid().ToStrGuid());
DeviceCategoryPicker dcp = new DeviceCategoryPicker(r, ds);
ObservableCollection <RealDevice> allDevices = new ObservableCollection <RealDevice>();
DeviceCategory dc = new DeviceCategory("dc", -1, "bla", false, allDevices, Guid.NewGuid().ToStrGuid());
RealDevice rd = new RealDevice("bla", 0, string.Empty, dc, "desc", false, true, string.Empty,
Guid.NewGuid().ToStrGuid(), -1);
allDevices.Add(rd);
Location loc = new Location("bla", -1, string.Empty, Guid.NewGuid().ToStrGuid());
List <IAssignableDevice> devices = new List <IAssignableDevice>
{
rd
};
ObservableCollection <DeviceAction> deviceActions = new ObservableCollection <DeviceAction>();
// put in an dc with one rd, get the rd 1
Logger.Info("put in a rd at the Location, get back null since it already exists");
devices.Clear();
devices.Add(rd);
RealDevice result3 = dcp.GetOrPickDevice(dc, loc, EnergyIntensityType.EnergyIntensive, devices,
deviceActions);
result3.Should().BeNull();
Logger.Info("put in a rd, get back rd");
devices.Clear();
DeviceCategoryPicker dcp2 = new DeviceCategoryPicker(r, ds);
RealDevice result4 = dcp2.GetOrPickDevice(dc, loc, EnergyIntensityType.EnergyIntensive, devices,
deviceActions);
rd.Should().Be(result4);
}
public void StartHousehold([NotNull] Simulator sim, [NotNull] JsonCalcSpecification jcs, [NotNull] JsonReference calcObjectReference, [CanBeNull] Action <CalculationProfiler, string> makeAllCharts)
{
if (!CheckSimulator(jcs, sim))
{
throw new LPGPBadParameterException("Invalid simulation state");
}
var calcObject = GetCalcObject(sim, calcObjectReference);
if (jcs.OutputDirectory == null)
{
jcs.OutputDirectory = AutomationUtili.CleanFileName(calcObject.Name) + " - " + calcObject;
}
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass());
if (calcObjectReference == null)
{
throw new LPGException("No calculation object was selected.");
}
var calculationStartTime = DateTime.Now;
if (calcObject == null)
{
throw new LPGException("Could not find the Calc Object with the guid " + calcObjectReference.Guid);
}
var generalResultsDirectory = new DirectoryInfo(jcs.OutputDirectory ?? throw new LPGException("Output directory was null."));
var finishedFile = Path.Combine(generalResultsDirectory.FullName, Constants.FinishedFileFlag);
if (Directory.Exists(generalResultsDirectory.FullName))
{
if (jcs.SkipExisting)
{
if (File.Exists(finishedFile))
{
Logger.Error("Directory already exists and calculation is finished. Exiting.");
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass());
return;
}
}
Logger.Warning("Directory already exists, but calculation is not finished or skip existing is not specified. Deleting folder.");
var files = generalResultsDirectory.GetFiles();
foreach (FileInfo file in files)
{
if (file.Name.StartsWith("Log.", StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (file.Name.EndsWith(".db3", StringComparison.OrdinalIgnoreCase))
{
continue;
}
file.Delete();
}
var directories = generalResultsDirectory.GetDirectories();
foreach (DirectoryInfo info in directories)
{
info.Delete(true);
}
Thread.Sleep(1000);
}
generalResultsDirectory.Create();
Thread.Sleep(500);
Logger.SetLogFilePath(Path.Combine(generalResultsDirectory.FullName, "Log.CommandlineCalculation.txt"));
Logger.LogToFile = true;
Logger.Get().FlushExistingMessages();
Logger.Info("---------------------------");
Logger.Info("Used calculation specification:");
Logger.Info(JsonConvert.SerializeObject(jcs, Formatting.Indented), true);
Logger.Info("---------------------------");
Logger.Info("Directory: " + generalResultsDirectory.FullName);
sim.MyGeneralConfig.StartDateUIString = jcs.StartDate.ToString();
sim.MyGeneralConfig.EndDateUIString = jcs.EndDate.ToString();
sim.MyGeneralConfig.InternalTimeResolution = "00:01:00";
sim.MyGeneralConfig.DestinationPath = generalResultsDirectory.FullName;
sim.MyGeneralConfig.ApplyOptionDefault(jcs.DefaultForOutputFiles);
if (jcs.CalcOptions != null)
{
foreach (var option in jcs.CalcOptions)
{
//var option = option;
/*if (option == null) {
* throw new LPGException("Could not identify Calc Option " + option + ". Stopping.");
* }*/
Logger.Info("Enabling option " + option);
sim.MyGeneralConfig.Enable(option);
}
}
if (jcs.DeleteDAT)
{
sim.MyGeneralConfig.DeleteDatFiles = "TRUE";
}
else
{
sim.MyGeneralConfig.DeleteDatFiles = "FALSE";
}
if (jcs.ExternalTimeResolution == null)
{
sim.MyGeneralConfig.ExternalTimeResolution = sim.MyGeneralConfig.InternalTimeResolution;
}
else
{
sim.MyGeneralConfig.ExternalTimeResolution = jcs.ExternalTimeResolution;
}
sim.MyGeneralConfig.RandomSeed = jcs.RandomSeed;
var eit = jcs.EnergyIntensityType;
if (eit == EnergyIntensityType.AsOriginal)
{
eit = calcObject.EnergyIntensityType;
}
var cs = new CalcStarter(sim);
var temperatureProfile = sim.TemperatureProfiles.FindByJsonReference(jcs.TemperatureProfile);
if (temperatureProfile == null)
{
throw new LPGException("Temperature Profile not found.");
}
if (jcs.GeographicLocation == null)
{
throw new LPGPBadParameterException("No geographic location was set in the calculation request");
}
var geographicLocation = sim.GeographicLocations.FindByJsonReference(jcs.GeographicLocation);
if (geographicLocation == null)
{
throw new LPGException("Geographic location not found.");
}
DeviceSelection deviceSelection = null;
if (jcs.DeviceSelection != null)
{
deviceSelection = sim.DeviceSelections.FindByJsonReference(jcs.DeviceSelection);
if (deviceSelection == null)
{
throw new LPGException("Unknown device selection \"" + jcs.DeviceSelection.Guid + "\"");
}
}
if (jcs.EnableTransportation)
{
}
if (jcs.LoadTypePriority == LoadTypePriority.Undefined)
{
if (calcObject.CalcObjectType == CalcObjectType.ModularHousehold)
{
jcs.LoadTypePriority = LoadTypePriority.RecommendedForHouseholds;
}
else
{
jcs.LoadTypePriority = LoadTypePriority.RecommendedForHouses;
}
}
var options = sim.MyGeneralConfig.AllEnabledOptions();
//options.Add(CalcOption.OverallDats);
var calcStartParameterSet = new CalcStartParameterSet(ReportFinishFuncForHouseAndSettlement,
ReportFinishFuncForHousehold,
OpenTabFunc,
null,
geographicLocation,
temperatureProfile,
calcObject,
eit,
ReportCancelFunc,
false,
deviceSelection,
jcs.LoadTypePriority,
null,
null,
options,
sim.MyGeneralConfig.StartDateDateTime,
sim.MyGeneralConfig.EndDateDateTime,
sim.MyGeneralConfig.InternalStepSize,
sim.MyGeneralConfig.CSVCharacter,
jcs.RandomSeed,
sim.MyGeneralConfig.ExternalStepSize,
sim.MyGeneralConfig.DeleteDatFilesBool,
sim.MyGeneralConfig.WriteExcelColumnBool,
sim.MyGeneralConfig.ShowSettlingPeriodBool,
3,
sim.MyGeneralConfig.RepetitionCount,
_calculationProfiler,
null,
jcs.LoadtypesForPostprocessing,
sim.MyGeneralConfig.DeviceProfileHeaderMode,
jcs.IgnorePreviousActivitiesWhenNeeded, jcs.OutputDirectory, jcs.EnableTransportation);
calcStartParameterSet.PreserveLogfileWhileClearingFolder = true;
cs.Start(calcStartParameterSet);
if (jcs.CalcOptions != null && jcs.CalcOptions.Contains(CalcOption.CalculationFlameChart))
{
string targetfile = Path.Combine(generalResultsDirectory.FullName, Constants.CalculationProfilerJson);
using (StreamWriter sw = new StreamWriter(targetfile))
{
_calculationProfiler.WriteJson(sw);
}
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass());
if (makeAllCharts != null)
{
makeAllCharts(_calculationProfiler, calcStartParameterSet.ResultPath);
}
var duration = DateTime.Now - calculationStartTime;
if (jcs.DeleteAllButPDF)
{
var allFileInfos = generalResultsDirectory.GetFiles("*.*", SearchOption.AllDirectories);
foreach (var fi in allFileInfos)
{
if (fi.Name.ToUpperInvariant().EndsWith(".PDF", StringComparison.Ordinal))
{
continue;
}
if (fi.Name.ToUpperInvariant().StartsWith("SUMPROFILES.", StringComparison.Ordinal))
{
continue;
}
if (fi.Name.ToUpperInvariant().StartsWith("HOUSEHOLDNAME.", StringComparison.Ordinal))
{
continue;
}
fi.Delete();
}
}
if (jcs.DeleteSqlite)
{
var allFileInfos = generalResultsDirectory.GetFiles("*.sqlite", SearchOption.AllDirectories);
GC.Collect();
GC.WaitForPendingFinalizers();
foreach (var fi in allFileInfos)
{
try {
fi.Delete();
}
catch (Exception ex) {
Logger.Exception(ex);
}
}
}
Logger.ImportantInfo("Calculation duration:" + duration);
//cleanup empty directories
var subdirs = generalResultsDirectory.GetDirectories();
foreach (var subdir in subdirs)
{
var files = subdir.GetFiles();
var subsubdirs = subdir.GetDirectories();
if (files.Length == 0 && subsubdirs.Length == 0)
{
subdir.Delete();
}
}
using (var sw = new StreamWriter(finishedFile)) {
sw.WriteLine("Finished at " + DateTime.Now);
sw.WriteLine("Duration in seconds:");
sw.WriteLine(duration.TotalSeconds);
}
}
private void RegisterEverything([NotNull] Simulator sim, [NotNull] string resultpath, [NotNull] CalcStartParameterSet csps, [NotNull] ICalcObject hh,
[NotNull] ContainerBuilder builder, [NotNull] string sqlFileName, [NotNull] CalcParameters calcParameters,
[CanBeNull] DeviceSelection ds)
{
builder.Register(c => new SqlResultLoggingService(sqlFileName)).As <SqlResultLoggingService>()
.SingleInstance();
builder.Register(c => calcParameters).As <CalcParameters>().SingleInstance();
Random rnd = new Random(calcParameters.ActualRandomSeed);
builder.Register(c => rnd).As <Random>().SingleInstance();
builder.Register(c => csps.CalculationProfiler).As <CalculationProfiler>().SingleInstance();
builder.Register(c => new NormalRandom(0, 0.1, rnd)).As <NormalRandom>().SingleInstance();
builder.RegisterType <OnlineDeviceActivationProcessor>().As <IOnlineDeviceActivationProcessor>()
.SingleInstance();
builder.RegisterType <CalcHouseFactory>().As <CalcHouseFactory>().SingleInstance();
builder.RegisterType <CalcManager>().As <CalcManager>().SingleInstance();
builder.RegisterType <AffordanceTaggingSetFactory>().As <AffordanceTaggingSetFactory>().SingleInstance();
builder.Register(x =>
CalcLoadTypeDtoFactory.MakeLoadTypes(sim.LoadTypes.It, calcParameters.InternalStepsize,
csps.LoadTypePriority))
.As <CalcLoadTypeDtoDictionary>().SingleInstance();
builder.Register(x => CalcLoadTypeFactory.MakeLoadTypes(x.Resolve <CalcLoadTypeDtoDictionary>()))
.As <CalcLoadTypeDictionary>().SingleInstance();
//builder.Register(x =>ds).As<DeviceSelection>().SingleInstance();
builder.Register(x => {
CalcDeviceTaggingSetFactory ctsf =
new CalcDeviceTaggingSetFactory(x.Resolve <CalcParameters>(), x.Resolve <CalcLoadTypeDtoDictionary>());
return(ctsf.GetDeviceTaggingSets(sim, hh.CalculatePersonCount()));
}).As <CalcDeviceTaggingSets>().SingleInstance();
builder.Register(x => new DeviceCategoryPicker(rnd, ds)).As <IDeviceCategoryPicker>().SingleInstance();
builder.RegisterType <CalcModularHouseholdFactory>().As <CalcModularHouseholdFactory>().SingleInstance();
builder.RegisterType <CalcHouseFactory>().As <CalcHouseFactory>().SingleInstance();
builder.RegisterType <CalcLocationFactory>().As <CalcLocationFactory>().SingleInstance();
builder.RegisterType <CalcPersonFactory>().As <CalcPersonFactory>().SingleInstance();
builder.RegisterType <CalcDeviceFactory>().As <CalcDeviceFactory>().SingleInstance();
builder.RegisterType <CalcRepo>().As <CalcRepo>().SingleInstance();
builder.RegisterType <CalcAffordanceFactory>().As <CalcAffordanceFactory>().SingleInstance();
builder.RegisterType <CalcTransportationFactory>().As <CalcTransportationFactory>().SingleInstance();
builder.RegisterType <CalcVariableDtoFactory>().As <CalcVariableDtoFactory>().SingleInstance();
builder.RegisterType <VacationDtoFactory>().As <VacationDtoFactory>().SingleInstance();
builder.RegisterType <CalcVariableRepository>().As <CalcVariableRepository>().SingleInstance();
builder.RegisterType <TemperatureDataLogger>().As <TemperatureDataLogger>().SingleInstance();
builder.Register(x => new FileFactoryAndTracker(resultpath, hh.Name, x.Resolve <IInputDataLogger>()))
.As <FileFactoryAndTracker>().SingleInstance();
builder.Register(_ => new SqlResultLoggingService(resultpath)).As <SqlResultLoggingService>().SingleInstance();
builder.Register(x => new DateStampCreator(x.Resolve <CalcParameters>())).As <DateStampCreator>().SingleInstance();
builder.Register(c => new OnlineLoggingData(c.Resolve <DateStampCreator>(), c.Resolve <IInputDataLogger>(),
c.Resolve <CalcParameters>()))
.As <OnlineLoggingData>().As <IOnlineLoggingData>().SingleInstance();
builder.Register(x => new LogFile(calcParameters, x.Resolve <FileFactoryAndTracker>())).As <ILogFile>().SingleInstance();
builder.RegisterType <AffordanceTaggingSetFactory>().As <AffordanceTaggingSetFactory>();
builder.RegisterType <CalcPersonDtoFactory>().As <CalcPersonDtoFactory>();
builder.RegisterType <CalcDeviceDtoFactory>().As <CalcDeviceDtoFactory>();
builder.RegisterType <CalcLocationDtoFactory>().As <CalcLocationDtoFactory>();
builder.RegisterType <CalcAffordanceDtoFactory>().As <CalcAffordanceDtoFactory>();
builder.RegisterType <CalcHouseDtoFactory>().As <CalcHouseDtoFactory>();
builder.RegisterType <CalcModularHouseholdDtoFactory>().As <CalcModularHouseholdDtoFactory>();
builder.RegisterType <AvailabilityDtoRepository>().As <AvailabilityDtoRepository>().SingleInstance();
builder.RegisterType <CalcTransportationDtoFactory>().As <CalcTransportationDtoFactory>();
//data save loggers + input data loggers
builder.RegisterType <InputDataLogger>().As <IInputDataLogger>().SingleInstance();
builder.RegisterType <CalcParameterLogger>().As <IDataSaverBase>();
builder.RegisterType <DeviceTaggingSetLogger>().As <IDataSaverBase>();
builder.RegisterType <HouseholdDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <DaylightTimesLogger>().As <IDataSaverBase>();
builder.RegisterType <TemperatureDataLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcStartParameterSetLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcLoadTypeDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <ActionEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcPersonDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcDeviceDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcAutoDevDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcVariableDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <HouseholdKeyLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcObjectInformationLogger>().As <IDataSaverBase>();
builder.RegisterType <BodilyActivityLevelStatisticsLogger>().As <IDataSaverBase>();
builder.RegisterType <ResultFileEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcAffordanceDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcAffordanceTaggingSetDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <DeviceActivationEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <ColumnEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <BridgeDayEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <HouseDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <LocationEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcSiteDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcTransportationDeviceDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <CalcTravelRouteDtoLogger>().As <IDataSaverBase>();
builder.RegisterType <TransportationEventLogger>().As <IDataSaverBase>();
builder.RegisterType <TransportationStatusLogger>().As <IDataSaverBase>();
builder.RegisterType <PersonStatusLogger>().As <IDataSaverBase>();
builder.RegisterType <TransportationStateEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <ChargingStationStateLogger>().As <IDataSaverBase>();
builder.RegisterType <VariableEntryLogger>().As <IDataSaverBase>();
builder.RegisterType <TransportationDeviceStatisticsLogger>().As <IDataSaverBase>();
builder.RegisterType <AffordanceEnergyUseLogger>().As <IDataSaverBase>();
//builder.Register(x=> x.Resolve<CalcVariableDtoFactory>().GetRepository()).As<CalcVariableRepository>().SingleInstance();
builder.Register(x => MakeLightNeededArray(csps.GeographicLocation, csps.TemperatureProfile,
rnd,
new List <VacationTimeframe>(), hh.Name, calcParameters)).As <DayLightStatus>().SingleInstance();
}
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);
}
