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); }