static HouseCreationAndCalculationJob PrepareHousejob(Simulator sim)
            {
                var hj = new HouseCreationAndCalculationJob();

                hj.CalcSpec                        = JsonCalcSpecification.MakeDefaultsForTesting();
                hj.CalcSpec.StartDate              = new DateTime(2020, 1, 1);
                hj.CalcSpec.EndDate                = new DateTime(2020, 1, 3);
                hj.CalcSpec.DeleteDAT              = false;
                hj.CalcSpec.DefaultForOutputFiles  = OutputFileDefault.Reasonable;
                hj.CalcSpec.DeleteSqlite           = false;
                hj.CalcSpec.ExternalTimeResolution = "00:15:00";
                hj.CalcSpec.EnableTransportation   = true;
                if (hj.CalcSpec.CalcOptions == null)
                {
                    throw new LPGException("calcoptions was null");
                }

                hj.CalcSpec.CalcOptions.Add(CalcOption.TotalsPerLoadtype);
                hj.House            = new HouseData(StrGuid.FromString("houseguid"), "HT01", 1000, 100, "housename");
                hj.House.Households = new List <HouseholdData>();
                var chargingstationSet = sim.ChargingStationSets.FindFirstByName("car electricity", FindMode.Partial);
                var hhd = new HouseholdData("householdid", "householdname", chargingstationSet.GetJsonReference(),
                                            sim.TransportationDeviceSets[0].GetJsonReference(), sim.TravelRouteSets[0].GetJsonReference(), null,
                                            HouseholdDataSpecificationType.ByHouseholdName);
                var hh = sim.ModularHouseholds.FindFirstByName("CHR01", FindMode.StartsWith);

                hhd.HouseholdNameSpec = new HouseholdNameSpecification(hh.GetJsonReference());
                hj.House.Households.Add(hhd);
                return(hj);
            }
        public static HouseCreationAndCalculationJob PrepareNewHouseForHousetypeTesting(Simulator sim, string guid)
        {
            var hj = new HouseCreationAndCalculationJob();

            hj.CalcSpec                        = JsonCalcSpecification.MakeDefaultsForTesting();
            hj.CalcSpec.StartDate              = new DateTime(2020, 1, 1);
            hj.CalcSpec.EndDate                = new DateTime(2020, 1, 3);
            hj.CalcSpec.DeleteDAT              = false;
            hj.CalcSpec.DefaultForOutputFiles  = OutputFileDefault.NoFiles;
            hj.CalcSpec.DeleteSqlite           = false;
            hj.CalcSpec.ExternalTimeResolution = "00:15:00";
            hj.CalcSpec.EnableTransportation   = false;
            var ht = sim.HouseTypes.FindByGuid(guid.ToStrGuid());

            hj.House            = new HouseData(StrGuid.FromString("houseguid"), ht.HouseTypeCode, 1000, 100, "housename");
            hj.House.Households = new List <HouseholdData>();
            var hhd = new HouseholdData("householdid",
                                        "householdname", sim.ChargingStationSets[0].GetJsonReference(),
                                        sim.TransportationDeviceSets[0].GetJsonReference(),
                                        sim.TravelRouteSets[0].GetJsonReference(), null,
                                        HouseholdDataSpecificationType.ByHouseholdName);
            var hh = sim.ModularHouseholds[0];

            hhd.HouseholdNameSpec = new HouseholdNameSpecification(hh.GetJsonReference());
            hj.House.Households.Add(hhd);
            return(hj);
        }
        public void TestParallelLaunch()
        {
            WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass());

            ParallelJsonLauncher.CopyAll(DatabaseSetup.AssemblyDirectory, wd.WorkingDirectory);
            using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
            {
                Logger.Info("Assembly directory: " + DatabaseSetup.AssemblyDirectory);
                Directory.SetCurrentDirectory(wd.WorkingDirectory);
                HouseCreationAndCalculationJob hcj = new HouseCreationAndCalculationJob();
                Simulator             sim          = new Simulator(db.ConnectionString);
                JsonCalcSpecification cspec        = JsonCalcSpecification.MakeDefaultsForTesting();
                cspec.DefaultForOutputFiles = OutputFileDefault.OnlySums;
                cspec.CalcOptions           = new List <CalcOption>();
                cspec.CalcOptions.Add(CalcOption.SumProfileExternalEntireHouse);
                hcj.CalcSpec = cspec;

                MakeSingleHouse(cspec, wd, hcj, sim.Houses[0], "house1");
                MakeSingleHouse(cspec, wd, hcj, sim.Houses[1], "house2");
                var fn = wd.Combine("profilegenerator.db3");
                hcj.PathToDatabase = fn;
                HouseJobSerializer.WriteJsonToFile(wd.Combine("hj2.json"), hcj);
                File.Copy(db.FileName, fn, true);
            }
            ParallelJsonLauncher.ThrowOnInvalidFile = true;
            ParallelJsonLauncher.ParallelJsonLauncherOptions options = new ParallelJsonLauncher.ParallelJsonLauncherOptions();
            options.JsonDirectory = wd.WorkingDirectory;
            ParallelJsonLauncher.LaunchParallel(options);
            //wd.CleanUp(1);
        }
        public static HouseCreationAndCalculationJob PrepareExistingHouseForTesting([JetBrains.Annotations.NotNull] House house)
        {
            var hj = new HouseCreationAndCalculationJob();

            hj.CalcSpec            = JsonCalcSpecification.MakeDefaultsForTesting();
            hj.HouseDefinitionType = HouseDefinitionType.HouseName;
            hj.HouseRef            = new HouseReference(house.GetJsonReference());
            return(hj);
        }
        public void SaveToDatabaseTest()
        {
            using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
            {
                ObservableCollection <TraitTag> traitTags = db.LoadTraitTags();
                var timeprofiles = db.LoadTimeBasedProfiles();
                var realDevices  = db.LoadRealDevices(out var deviceCategories, out var loadtypes, timeprofiles);
                var locations    = db.LoadLocations(realDevices, deviceCategories, loadtypes);
                db.LoadTransportation(locations, out var transportationDeviceSets,
                                      out var travelRouteSets, out var _,
                                      out var _, loadtypes,
                                      out var chargingStationSets);
                db.LoadHouseholdsAndHouses(out var modularHouseholds,
                                           out var houses, out var timeLimits, traitTags,
                                           chargingStationSets, travelRouteSets, transportationDeviceSets);
                var settlements        = new ObservableCollection <Settlement>();
                var geoloc             = db.LoadGeographicLocations(out _, timeLimits);
                var temperaturProfiles = db.LoadTemperatureProfiles();
                Settlement.LoadFromDatabase(settlements, db.ConnectionString, temperaturProfiles, geoloc,
                                            modularHouseholds, houses, false);
                settlements.Clear();
                db.ClearTable(Settlement.TableName);
                db.ClearTable(SettlementHH.TableName);
                JsonCalcSpecification jcs = JsonCalcSpecification.MakeDefaultsForTesting();
                jcs.EnergyIntensityType = EnergyIntensityType.EnergySaving;
                var se = new Settlement("blub", null, "blub",
                                        "fdasdf", "blub", "blub", "asdf", db.ConnectionString, geoloc[0], temperaturProfiles[0], "Testing",
                                        CreationType.ManuallyCreated, Guid.NewGuid().ToStrGuid(), jcs);
                se.SaveToDB();

                se.AddHousehold(modularHouseholds[0], 10);
                Settlement.LoadFromDatabase(settlements, db.ConnectionString, temperaturProfiles, geoloc,
                                            modularHouseholds, houses, false);
                (settlements.Count).Should().Be(1);
                (settlements[0].Households.Count).Should().Be(1);
                (geoloc[0]).Should().Be(settlements[0].GeographicLocation);
                (temperaturProfiles[0]).Should().Be(settlements[0].TemperatureProfile);
                (EnergyIntensityType.EnergySaving).Should().Be(settlements[0].EnergyIntensityType);
                db.Cleanup();
            }
        }
        public static HouseCreationAndCalculationJob PrepareNewHouseForOutputFileTesting(Simulator sim)
        {
            var hj = new HouseCreationAndCalculationJob();

            hj.CalcSpec                        = JsonCalcSpecification.MakeDefaultsForTesting();
            hj.CalcSpec.StartDate              = new DateTime(2020, 1, 1);
            hj.CalcSpec.EndDate                = new DateTime(2020, 1, 3);
            hj.CalcSpec.DeleteDAT              = false;
            hj.CalcSpec.DefaultForOutputFiles  = OutputFileDefault.NoFiles;
            hj.CalcSpec.DeleteSqlite           = false;
            hj.CalcSpec.ExternalTimeResolution = "00:15:00";
            hj.House            = new HouseData(StrGuid.FromString("houseguid"), "HT01", 1000, 100, "housename");
            hj.House.Households = new List <HouseholdData>();
            var hhd = new HouseholdData("householdid",
                                        "householdname", null, null, null, null,
                                        HouseholdDataSpecificationType.ByHouseholdName);
            var hh = sim.ModularHouseholds.FindFirstByName("CHR01", FindMode.StartsWith);

            hhd.HouseholdNameSpec = new HouseholdNameSpecification(hh.GetJsonReference());
            hj.House.Households.Add(hhd);
            return(hj);
        }
        public void OnlyExternalTest()
        {
            Logger.Get().StartCollectingAllMessages();
            Logger.Info(Utili.GetCurrentAssemblyVersion());
            Config.SkipFreeSpaceCheckForCalculation = true;
            using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
            {
                DirectoryInfo simengine = new DirectoryInfo(@"V:\Dropbox\LPG\SimulationEngine\bin\Debug\net472");
                foreach (FileInfo srcFile in simengine.GetFiles("*.*", SearchOption.AllDirectories))
                {
                    string relative = srcFile.FullName.Substring(simengine.FullName.Length);
                    while (relative.StartsWith("\\"))
                    {
                        relative = relative.Substring(1);
                    }

                    string   dstPath = Path.Combine(wd.WorkingDirectory, relative);
                    FileInfo dstFile = new FileInfo(dstPath);
                    if (dstFile.Directory != null && !(dstFile.Directory.Exists))
                    {
                        dstFile.Directory.Create();
                    }
                    srcFile.CopyTo(dstPath);
                }
                Directory.SetCurrentDirectory(wd.WorkingDirectory);
                using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
                {
                    Simulator sim   = new Simulator(db.ConnectionString);
                    var       house = sim.Houses.FindFirstByName("CHR07 in HT04 with Car, 05 km to work, 3.7 kW Charging at home");
                    if (house == null)
                    {
                        throw new LPGException("house not found");
                    }

                    JsonCalcSpecification jcs = JsonCalcSpecification.MakeDefaultsForTesting();
                    jcs.OutputDirectory = Path.Combine(wd.WorkingDirectory, "Results");
                    jcs.DeleteSqlite    = true;
                    jcs.StartDate       = new DateTime(2019, 1, 1);
                    jcs.EndDate         = new DateTime(2019, 1, 7);
                    if (jcs.LoadtypesForPostprocessing == null)
                    {
                        jcs.LoadtypesForPostprocessing = new List <string>();
                    }
                    jcs.LoadtypesForPostprocessing.Add("Electricity");

                    jcs.DefaultForOutputFiles = OutputFileDefault.NoFiles;
                    if (jcs.CalcOptions == null)
                    {
                        jcs.CalcOptions = new List <CalcOption>();
                    }
                    jcs.CalcOptions.Add(CalcOption.SumProfileExternalEntireHouse);

                    JsonCalculator jc = new JsonCalculator();
                    jc.StartHousehold(sim, jcs, house.GetJsonReference(), null);
                    const string sqliteanalyizer = @"v:\dropbox\lpg\sqlite3_analyzer.exe";
                    if (File.Exists(sqliteanalyizer))
                    {
                        StreamWriter  sw       = new StreamWriter(Path.Combine(jcs.OutputDirectory, "analyzesqlite.cmd"));
                        DirectoryInfo resultDi = new DirectoryInfo(jcs.OutputDirectory);
                        var           fis      = resultDi.GetFiles("*.sqlite");
                        foreach (var fi in fis)
                        {
                            sw.WriteLine(sqliteanalyizer + " \"" + fi.FullName + "\" > " + fi.Name + ".analysis.txt");
                        }
                        sw.Close();
                    }
                    else
                    {
                        throw new LPGException("analyzer not found");
                    }
                }
            }
            // db.Cleanup();
        }