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);
}
private static JsonCalcSpecification MakeCalcSpec([NotNull] ScenarioSliceParameters parameters, DateTime endtime)
{
DateTime startTime = new DateTime(parameters.DstYear, 1, 1);
JsonReference geoloc = new JsonReference("(Germany) Chemnitz", "eddeb22c-fbd4-44c1-bf2d-fbde3342f1bd");
JsonReference tempReference = new JsonReference("Berlin, Germany 1996 from Deutscher Wetterdienst DWD (www.dwd.de)",
"ec337ba6-60a1-404b-9db0-9be52c9e5702");
JsonCalcSpecification jcs = new JsonCalcSpecification(null,
null,
false,
null,
false,
endtime,
"00:15:00",
"00:01:00",
geoloc,
LoadTypePriority.RecommendedForHouses,
null,
false,
startTime,
tempReference,
null,
null)
{
DeleteDAT = true,
DefaultForOutputFiles = OutputFileDefault.None, SkipExisting = true
};
jcs.CalcOptions.Add(CalcOption.SumProfileExternalIndividualHouseholdsAsJson);
jcs.LoadtypesForPostprocessing.Add("Electricity");
jcs.LoadtypesForPostprocessing.Add("Car Charging Electricity");
jcs.OutputDirectory = "Results";
jcs.IgnorePreviousActivitiesWhenNeeded = true;
return(jcs);
}
public void ExecuteCalcJob([NotNull] MessageFromServerToClient job, [NotNull] CalcExecutor calcExecutor, [NotNull] RequestSocket client)
{
var cdp = new CalcDirectoryPreparer(_mySettings, _logger, _threadId);
cdp.Run();
HouseCreationAndCalculationJob hcj = null;
if (!string.IsNullOrWhiteSpace(job.HouseJobStr))
{
hcj = JsonConvert.DeserializeObject <HouseCreationAndCalculationJob>(job.HouseJobStr);
if (hcj.CalcSpec == null)
{
hcj.CalcSpec = JsonCalcSpecification.MakeDefaultsForProduction();
}
hcj.CalcSpec.OutputDirectory = "Results";
string jsonFileName = Path.Combine(_mySettings.ClientSettings.LPGCalcDirectory, "calcjob.json");
string correctedJob = JsonConvert.SerializeObject(hcj, Formatting.Indented);
File.WriteAllText(jsonFileName, correctedJob);
calcExecutor.Run(hcj);
}
else
{
_logger.Info("Client #" + _threadId + ": Got a task with an exe, not real, waiting 5s", _threadId);
Thread.Sleep(5000);
}
ReportFinishedCalcJob(job, client, hcj);
}
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 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 RunJsonCalculatorTestForExternalTimeResolutionJsonFile()
{
Logger.Get().StartCollectingAllMessages();
using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass()))
{
Directory.SetCurrentDirectory(wd.WorkingDirectory);
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
string dbPath = wd.Combine("my.db3");
File.Copy(db.FileName, dbPath);
Logger.Info("DB File Path: " + dbPath);
JsonCalcSpecification jcs = new JsonCalcSpecification();
if (jcs.CalcOptions == null)
{
throw new LPGException("Calcoptions was null");
}
jcs.DefaultForOutputFiles = OutputFileDefault.NoFiles;
jcs.CalcOptions.Add(CalcOption.SumProfileExternalIndividualHouseholdsAsJson);
jcs.StartDate = new DateTime(2019, 1, 1);
jcs.EndDate = new DateTime(2019, 1, 3);
jcs.ExternalTimeResolution = "00:15:00";
jcs.LoadTypePriority = LoadTypePriority.RecommendedForHouses;
Simulator sim = new Simulator(db.ConnectionString);
JsonCalculator jc = new JsonCalculator();
jc.StartHousehold(sim, jcs, sim.Houses[0].GetJsonReference(), null);
}
Directory.SetCurrentDirectory(wd.PreviousCurrentDir);
wd.CleanUp();
}
}
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);
}
private static void SetCalcSpec([NotNull] HouseCreationAndCalculationJob hj, [NotNull] Simulator sim)
{
hj.CalcSpec = JsonCalcSpecification.MakeDefaultsForProduction();
hj.CalcSpec.OutputDirectory = "Results";
hj.CalcSpec.CalcOptions = new List <CalcOption>();
hj.CalcSpec.CalcOptions.Add(CalcOption.SumProfileExternalIndividualHouseholdsAsJson);
hj.CalcSpec.DefaultForOutputFiles = OutputFileDefault.NoFiles;
hj.CalcSpec.ExternalTimeResolution = "00:15:00";
hj.CalcSpec.StartDate = new DateTime(2019, 1, 1);
hj.CalcSpec.EndDate = new DateTime(2019, 12, 31);
hj.CalcSpec.TemperatureProfile = sim.TemperatureProfiles[0].GetJsonReference();
var geoloc = sim.GeographicLocations.FindFirstByName("Chemnitz", FindMode.Partial) ?? throw new LPGException("Chemnitz not found");
hj.CalcSpec.GeographicLocation = geoloc.GetJsonReference();
}
private static void WriteHousejobsToDirectory([NotNull] string directory,
[NotNull][ItemNotNull] List <HouseCreationAndCalculationJob> filteredHouses,
[NotNull] JsonCalcSpecification calcSpec,
[NotNull] ILogger logger)
{
Stopwatch stopwatch = Stopwatch.StartNew();
DirectoryInfo subdir = new DirectoryInfo(directory);
if (!subdir.Exists)
{
subdir.Create();
Thread.Sleep(250);
}
var files = subdir.GetFiles("*.json");
foreach (var file in files)
{
file.Delete();
}
int housejobCount = 0;
foreach (HouseCreationAndCalculationJob houseJob in filteredHouses)
{
foreach (var hhj in houseJob.House.Households)
{
if (hhj.HouseholdDataPersonSpecification.Persons.Count == 0)
{
throw new FlaException("No persons were defined?");
}
}
houseJob.CalcSpec = calcSpec;
var filename = Path.Combine(directory, "HouseJob." + houseJob.House.Name + ".json");
var sw = new StreamWriter(filename);
sw.WriteLine(JsonConvert.SerializeObject(houseJob, Formatting.Indented));
sw.Close();
housejobCount++;
}
stopwatch.Stop();
logger.Info("wrote " + housejobCount + " house jobs to disc in " + stopwatch.Elapsed.TotalSeconds.ToString("F1") + " seconds",
Stage.ProfileGeneration,
nameof(HouseProcessor));
}
private static void MakeSingleHouse([JetBrains.Annotations.NotNull] JsonCalcSpecification cspec, [JetBrains.Annotations.NotNull] WorkingDir wd, [JetBrains.Annotations.NotNull] HouseCreationAndCalculationJob hcj,
[JetBrains.Annotations.NotNull] House house1, string housename)
{
cspec.OutputDirectory = housename;
if (cspec.OutputDirectory == null)
{
throw new LPGException("Output directory was null");
}
var dirtodelete = wd.Combine(cspec.OutputDirectory);
if (Directory.Exists(dirtodelete))
{
Directory.Delete(dirtodelete, true);
}
hcj.House = house1.MakeHouseData();
HouseJobSerializer.WriteJsonToFile(wd.Combine(housename + ".json"), hcj);
}
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 bool Calculate([NotNull] JsonDirectoryOptions calcDirectoryOptions)
* {
* _calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass());
* string jsonFileName = calcDirectoryOptions.Input;
* if (jsonFileName == null) {
* Logger.Error("No file was set.");
* return false;
* }
*
* var fi = new FileInfo(jsonFileName);
* if (!fi.Exists) {
* Logger.Error("File not found: " + fi.FullName);
* }
*
* string jsonContent = File.ReadAllText(fi.FullName);
* JsonCalcSpecification jcs = JsonConvert.DeserializeObject<JsonCalcSpecification>(jsonContent);
*
*
* if (!CheckBasicSettingsForLoadingDatabase(jcs)) {
* Logger.Error("Could not load the database ");
* return false;
* }
*
* //Logger.Info("Using the following configuration: \n" + JsonConvert.SerializeObject(jcs,Formatting.Indented) );
* var myConnectionString = "Data Source=" + jcs.PathToDatabase;
* string targetDirectory = jcs.OutputDirectory;
* if (string.IsNullOrWhiteSpace(targetDirectory)) {
* targetDirectory = Directory.GetCurrentDirectory();
* }
*
* if (!Directory.Exists(targetDirectory)) {
* Directory.CreateDirectory(targetDirectory);
* Thread.Sleep(500);
* }
*
* //Logger.LogFilePath = Path.Combine(targetDirectory, "mylog.txt");
* //Logger.LogToFile = true;
* //Config.ResetLogfileAtCalculationStart = false;
* Logger.Info("Loading...");
* var sim = new Simulator(myConnectionString);
* Logger.Info("Loading finished.");
* if (!CheckSimulator(jcs, sim)) {
* Logger.Error("Due to incorrect settings, calculation can not start.");
* return false;
* }
*
* StartHousehold(sim, jcs);
* _calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass());
* return true;
* }*/
//public bool CheckBasicSettingsForLoadingDatabase([NotNull] JsonCalcSpecification jcs)
//{
// if (!string.IsNullOrWhiteSpace(jcs.PathToDatabase)) {
// var fi = new FileInfo(jcs.PathToDatabase);
// if (!fi.Exists) {
// throw new LPGException("Database was not found. Path supplied:" + fi.FullName);
// }
// }
// return true;
//}
public bool CheckSimulator([NotNull] JsonCalcSpecification jcs, [NotNull] Simulator sim)
{
if (jcs.TemperatureProfile == null)
{
jcs.TemperatureProfile = sim.TemperatureProfiles[0].GetJsonReference();
}
if (jcs.GeographicLocation == null)
{
jcs.GeographicLocation = sim.GeographicLocations[0].GetJsonReference();
}
if (jcs.StartDate == null)
{
jcs.StartDate = new DateTime(DateTime.Now.Year, 1, 1);
}
if (jcs.EndDate == null)
{
jcs.EndDate = new DateTime(DateTime.Now.Year, 12, 31);
}
//jcs.LoadTypePriorityEnum = GetLoadtypePriority(jcs.LoadTypePriority,calcObject);
return(true);
}
private static GeographicLocation FindGeographicLocation([NotNull] Simulator sim, [NotNull] JsonCalcSpecification calcSpecification)
{
GeographicLocation geoloc = sim.GeographicLocations[0];
if (calcSpecification.GeographicLocation != null)
{
geoloc = sim.GeographicLocations.FindByJsonReference(calcSpecification.GeographicLocation);
}
return(geoloc);
}
private static TemperatureProfile FindTemperatureProfile([NotNull] Simulator sim, [NotNull] JsonCalcSpecification calcSpecification)
{
TemperatureProfile temperatureProfile = sim.TemperatureProfiles[0];
if (calcSpecification.TemperatureProfile != null)
{
temperatureProfile = sim.TemperatureProfiles.FindByJsonReference(calcSpecification.TemperatureProfile);
}
return(temperatureProfile);
}
public static void CreateExampleHouseJob([NotNull] string connectionString)
{
const string relativePathHousejobs = "Example\\HouseJobs";
DirectoryInfo diHouseJobs = new DirectoryInfo(relativePathHousejobs);
if (!diHouseJobs.Exists)
{
diHouseJobs.Create();
}
const string relativePathGuids = "Example\\GuidLists";
DirectoryInfo diGuids = new DirectoryInfo(relativePathGuids);
if (!diGuids.Exists)
{
diGuids.Create();
}
Simulator sim = new Simulator(connectionString);
HouseData houseData1 = new HouseData(Guid.NewGuid().ToStrGuid(), "HT01", 20000, 10000, "MyFirstHouse");
HouseholdData hhd1 = new HouseholdData(Guid.NewGuid().ToString(), "My First Household, template randomly chosen based on persons", null, null,
null, new List <TransportationDistanceModifier>(), HouseholdDataSpecificationType.ByPersons);
HouseholdDataPersonSpecification personSpec = new HouseholdDataPersonSpecification(new List <PersonData>()
{
new PersonData(25, Gender.Male)
});
hhd1.HouseholdDataPersonSpec = personSpec;
houseData1.Households.Add(hhd1);
HouseholdData hhd2 = new HouseholdData(Guid.NewGuid().ToString(),
"My Second Household (with transportation, template defined by name )",
sim.ChargingStationSets[0].GetJsonReference(),
sim.TransportationDeviceSets[0].GetJsonReference(),
sim.TravelRouteSets[0].GetJsonReference(),
null, HouseholdDataSpecificationType.ByTemplateName);
hhd2.HouseholdTemplateSpec = new HouseholdTemplateSpecification("CHR01");
houseData1.Households.Add(hhd2);
HouseData houseData2 = new HouseData(Guid.NewGuid().ToStrGuid(), "HT02", 20000, 10000, "MySecondHouse");
HouseholdData hhd3 = new HouseholdData(Guid.NewGuid().ToString(),
"My Third Household, using predefined household",
null, null, null, null, HouseholdDataSpecificationType.ByHouseholdName);
hhd3.HouseholdNameSpec = new HouseholdNameSpecification(sim.ModularHouseholds[0].GetJsonReference());
houseData2.Households.Add(hhd3);
HouseholdData hhd4 = new HouseholdData(Guid.NewGuid().ToString(), "My Fourth Household", null, null, null, null, HouseholdDataSpecificationType.ByPersons);
hhd4.HouseholdDataPersonSpec = new HouseholdDataPersonSpecification(new List <PersonData>()
{
new PersonData(75, Gender.Male),
new PersonData(74, Gender.Female)
});
houseData2.Households.Add(hhd4);
var calculationSettings = new JsonCalcSpecification {
StartDate = new DateTime(2019, 1, 1),
EndDate = new DateTime(2019, 1, 3),
DeleteDAT = true,
DefaultForOutputFiles = OutputFileDefault.OnlySums
};
if (calculationSettings.CalcOptions == null)
{
throw new LPGException("error");
}
calculationSettings.CalcOptions.Add(CalcOption.HouseSumProfilesFromDetailedDats);
//calculationSettings.CalcOptions.Add(CalcOption.OverallSum.ToString());
calculationSettings.CalcOptions.Add(CalcOption.SumProfileExternalEntireHouse);
calculationSettings.CalcOptions.Add(CalcOption.SumProfileExternalIndividualHouseholds);
calculationSettings.LoadtypesForPostprocessing?.Add("Electricity");
calculationSettings.CalculationName = "My Comment";
calculationSettings.ExternalTimeResolution = "00:15:00";
calculationSettings.InternalTimeResolution = "00:01:00";
calculationSettings.LoadTypePriority = LoadTypePriority.RecommendedForHouses;
calculationSettings.TemperatureProfile = sim.TemperatureProfiles[0].GetJsonReference();
calculationSettings.GeographicLocation = sim.GeographicLocations[0].GetJsonReference();
Logger.Info("--------");
Logger.Info("Writing example file and additional data file that you might need.");
HouseCreationAndCalculationJob hj = new HouseCreationAndCalculationJob("scenario", "year", "districtname", HouseDefinitionType.HouseData);
hj.House = houseData1;
hj.CalcSpec = calculationSettings;
hj.CalcSpec.OutputDirectory = "Example1-Results";
HouseJobSerializer.WriteJsonToFile(Path.Combine(diHouseJobs.FullName, "ExampleHouseJob-1.json"), hj);
hj.House = houseData2;
hj.CalcSpec.OutputDirectory = "Example2-Results";
HouseJobSerializer.WriteJsonToFile(Path.Combine(diHouseJobs.FullName, "ExampleHouseJob-2.json"), hj);
Logger.Info("Finished writing example house jobs...");
WriteGuidList("GuidsForAllHouseholds.csv", sim.ModularHouseholds.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllHouses.csv", sim.Houses.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllChargingStationSets.csv", sim.ChargingStationSets.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllDeviceSelections.csv", sim.DeviceSelections.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllGeographicLocations.csv", sim.GeographicLocations.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllTemperatureProfiles.csv", sim.TemperatureProfiles.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllTransportationDeviceSets.csv", sim.TransportationDeviceSets.It.Select(x => (DBBase)x).ToList(), diGuids);
WriteGuidList("GuidsForAllTravelRouteSets.csv", sim.TravelRouteSets.It.Select(x => (DBBase)x).ToList(), diGuids);
}
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);
}
}
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();
}
