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 HouseGeneratorTestWithHouseholdSpec()
{
//setup
Logger.Get().StartCollectingAllMessages();
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass())) {
Simulator sim = new Simulator(db.ConnectionString);
using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
//housedata
HouseData houseData = new HouseData(Guid.NewGuid().ToStrGuid(),
"HT01", 10000, 1000, "HouseGeneratorJobHouse");
var householdData = new HouseholdData(Guid.NewGuid().ToString(),
"blub", null, null, null, null,
HouseholdDataSpecificationType.ByHouseholdName);
houseData.Households.Add(householdData);
householdData.HouseholdNameSpec =
new HouseholdNameSpecification(sim.ModularHouseholds[0].GetJsonReference());
HouseCreationAndCalculationJob houseJob =
new HouseCreationAndCalculationJob("present", "2019", "trafokreis",
HouseDefinitionType.HouseData);
houseJob.House = houseData;
MakeAndCalculateHouseJob(houseJob, sim, wd, db);
}
}
}
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 ActionResult Household()
{
string name = this.GetRouteValue <string>("name", String.Empty);
if (String.IsNullOrEmpty(name))
{
return(RedirectToAction("Search"));
}
var household = new HouseholdData();
return(View("Household", household));
}
private static TravelRouteSet AdjustTravelDistancesBasedOnModifiers([NotNull] TravelRouteSet travelrouteset,
[NotNull] Simulator sim,
[NotNull] House house,
[NotNull] HouseholdData householdData,
int householdidx)
{
Stopwatch sw = Stopwatch.StartNew();
if (householdData.TransportationDistanceModifiers == null)
{
throw new LPGException("Was null even though this was checked before the function was called.");
}
var newName = travelrouteset.Name + "(" + house.Name + " - " + householdData.Name + " " + householdidx + ")";
var adjustedTravelrouteset = new TravelRouteSet(newName, null, sim.ConnectionString, travelrouteset.Description, Guid.NewGuid().ToStrGuid());
adjustedTravelrouteset.SaveToDB();
sim.TravelRouteSets.It.Add(adjustedTravelrouteset);
int adjustingDistances = 0;
foreach (TravelRouteSetEntry oldTravelRouteSetEntry in travelrouteset.TravelRoutes)
{
bool addUnmodifiedRoute = true;
foreach (var modifier in householdData.TransportationDistanceModifiers)
{
string modRouteKey = modifier.RouteKey?.ToLower(CultureInfo.InvariantCulture);
if (oldTravelRouteSetEntry.TravelRoute.RouteKey?.ToLower(CultureInfo.InvariantCulture) == modRouteKey)
{
Logger.Info("Adjusting distances for key " + modifier.RouteKey + "-" + modifier.StepKey + ", total routes in the db: " + sim.TravelRoutes.It.Count);
var modStepKey = modifier.StepKey?.ToLower(CultureInfo.InvariantCulture);
var oldRouteSteps = oldTravelRouteSetEntry.TravelRoute.Steps.Where(x => x.StepKey?.ToLower(CultureInfo.InvariantCulture) == modStepKey).ToList();
if (oldRouteSteps.Count > 0)
{
MakeNewAdjustedRoute(sim, oldTravelRouteSetEntry, adjustingDistances, modRouteKey, modifier, adjustedTravelrouteset);
addUnmodifiedRoute = false;
adjustingDistances++;
}
}
}
if (addUnmodifiedRoute)
{
adjustedTravelrouteset.AddRoute(oldTravelRouteSetEntry.TravelRoute);
}
}
//Config.ShowDeleteMessages = true;
travelrouteset = adjustedTravelrouteset;
adjustedTravelrouteset.SaveToDB();
sw.Stop();
Logger.Info("Total distances adjusted: " + adjustingDistances + ". This took " + sw.Elapsed.TotalSeconds.ToString("F2", CultureInfo.InvariantCulture) + " seconds.");
return(travelrouteset);
}
public static HouseholdData ToServiceObject(this Household obj)
{
var household = new HouseholdData();
household.Description = obj.Description;
household.ID = obj.ID;
household.ImageUri = obj.ImageUri;
household.Motto = obj.Motto;
household.Name = obj.Name;
household.HonorPoints = obj.HonorPoints;
household.MemberCount = obj.MemberCount;
household.DateCreated = obj.DateCreated;
return(household);
}
private static ModularHousehold MakeHousehold([NotNull] Simulator sim, [NotNull] HouseholdData householdData,
[NotNull] Random r)
{
if (sim == null)
{
throw new ArgumentNullException(nameof(sim));
}
// ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
switch (householdData.HouseholdDataSpecification)
{
case HouseholdDataSpecificationType.ByPersons when householdData.HouseholdDataPersonSpec == null:
throw new LPGException("No person specification was set for the household " + householdData.Name);
case HouseholdDataSpecificationType.ByPersons when householdData.HouseholdDataPersonSpec.Persons.Count == 0:
throw new LPGException("No persons were defined for the household " + householdData.Name);
case HouseholdDataSpecificationType.ByTemplateName when householdData.HouseholdTemplateSpec == null:
throw new LPGException("No household template specification was set for the household " + householdData.Name);
case HouseholdDataSpecificationType.ByTemplateName when string.IsNullOrWhiteSpace(householdData.HouseholdTemplateSpec.HouseholdTemplateName):
throw new LPGException("No household template name was set for the household " + householdData.Name);
case HouseholdDataSpecificationType.ByHouseholdName when householdData.HouseholdNameSpec == null:
throw new LPGException("No household specification was set for the household " + householdData.Name);
case HouseholdDataSpecificationType.ByHouseholdName when(householdData.HouseholdNameSpec?.HouseholdReference == null):
throw new LPGException("No household name was set for the household " + householdData.Name);
}
switch (householdData.HouseholdDataSpecification)
{
case HouseholdDataSpecificationType.ByPersons:
return(MakeHouseholdBaseOnPersonSpec(sim, householdData, r));
case HouseholdDataSpecificationType.ByTemplateName:
return(MakeHouseholdBaseOnTemplateSpec(sim, householdData));
case HouseholdDataSpecificationType.ByHouseholdName:
return(MakeHouseholdBaseOnHouseholdName(sim, householdData));
default:
throw new LPGException(nameof(HouseholdDataSpecificationType));
}
}
public void HouseJobForHeatpump()
{
//setup
Logger.Get().StartCollectingAllMessages();
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass())) {
Simulator sim = new Simulator(db.ConnectionString);
using (WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
File.Copy(db.FileName, wd.Combine("profilegenerator.db3"));
Directory.SetCurrentDirectory(wd.WorkingDirectory);
//housedata
HouseData houseData = new HouseData(Guid.NewGuid().ToStrGuid(),
"HT01", 10000, 1000, "HouseGeneratorJobHouse");
HouseCreationAndCalculationJob houseJob = new HouseCreationAndCalculationJob(
"present", "2019", "trafokreis", HouseDefinitionType.HouseData);
houseJob.House = houseData;
var householdData = new HouseholdData(Guid.NewGuid().ToString(),
"blub", null, null, null, null, HouseholdDataSpecificationType.ByPersons);
houseData.Households.Add(householdData);
var persons = new List <PersonData> {
new PersonData(30, Gender.Male)
};
householdData.HouseholdDataPersonSpec = new HouseholdDataPersonSpecification(persons);
houseJob.CalcSpec = new JsonCalcSpecification {
DefaultForOutputFiles = OutputFileDefault.NoFiles,
StartDate = new DateTime(2017, 1, 1),
EndDate = new DateTime(2017, 1, 3),
GeographicLocation = sim.GeographicLocations.FindFirstByName("Berlin", FindMode.Partial)
?.GetJsonReference() ??
throw new LPGException("No Berlin in the DB"),
TemperatureProfile = sim.TemperatureProfiles[0].GetJsonReference(),
OutputDirectory = wd.Combine("Results"),
CalcOptions = new List <CalcOption> {
CalcOption.HouseSumProfilesFromDetailedDats, CalcOption.DeviceProfilesIndividualHouseholds,
CalcOption.EnergyStorageFile, CalcOption.EnergyCarpetPlot,
CalcOption.HouseholdContents
}
};
StartHouseJob(houseJob, wd, "xxx");
}
}
}
public void HouseGeneratorTestWithPersonSpecAndTransport()
{
//setup
Logger.Get().StartCollectingAllMessages();
using (WorkingDir workingDir = new WorkingDir(Utili.GetCurrentMethodAndClass())) {
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass())) {
Simulator sim = new Simulator(db.ConnectionString);
WorkingDir wd = workingDir;
//housedata
HouseData houseData = new HouseData(Guid.NewGuid().ToStrGuid(),
"HT01", 10000, 1000, "HouseGeneratorJobHouse");
var chargingStationSet = sim.ChargingStationSets
.SafeFindByName("Charging At Home with 03.7 kW, output results to Car Electricity")
.GetJsonReference();
Logger.Info("Using charging station " + chargingStationSet);
var transportationDeviceSet = sim.TransportationDeviceSets[0].GetJsonReference();
var travelRouteSet = sim.TravelRouteSets[0].GetJsonReference();
var work = new TransportationDistanceModifier("Work", "Car", 0);
var entertainment = new TransportationDistanceModifier("Entertainment", "Car", 12000);
List <TransportationDistanceModifier> tdm = new List <TransportationDistanceModifier>
{
work, entertainment
};
var householdData = new HouseholdData(Guid.NewGuid().ToString(),
"blub", chargingStationSet, transportationDeviceSet,
travelRouteSet, tdm, HouseholdDataSpecificationType.ByPersons);
houseData.Households.Add(householdData);
var persons = new List <PersonData> {
new PersonData(30, Gender.Male)
};
householdData.HouseholdDataPersonSpec = new HouseholdDataPersonSpecification(persons);
HouseCreationAndCalculationJob houseJob =
new HouseCreationAndCalculationJob("present", "2019", "trafokreis",
HouseDefinitionType.HouseData);
houseJob.House = houseData;
MakeAndCalculateHouseJob(houseJob, sim, wd, db);
}
}
}
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);
}
private static ModularHousehold MakeHouseholdBaseOnHouseholdName([NotNull] Simulator sim, [NotNull] HouseholdData householdData)
{
HouseholdNameSpecification nameSpec = householdData.HouseholdNameSpec;
if (nameSpec == null)
{
throw new LPGCommandlineException("Household name specification was null");
}
var household = sim.ModularHouseholds.FindByJsonReference(nameSpec.HouseholdReference);
if (household == null)
{
throw new LPGException("No household found for the household name " + nameSpec.HouseholdReference?.Name);
}
var jsonHH = household.GetJson();
household.Description = DescriptionText + householdData.UniqueHouseholdId;
var newHH = sim.ModularHouseholds.CreateNewItem(sim.ConnectionString);
newHH.ImportFromJsonTemplate(jsonHH, sim);
household.SaveToDB();
Logger.Info("Finished household with template " + household.Name);
return(newHH);
}
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 bool PrepareLoadProfileIfNeeded([NotNull] ProviderParameterDto parameters)
{
CarDistanceEntry cde = (CarDistanceEntry)parameters.HouseComponent;
Car myCar = _dbDto.Cars.Single(x => x.Guid == cde.CarGuid);
parameters.HouseComponentResultObject.CarStatus = "Gasoline, not analyzed further";
if (myCar.RequiresProfile == CarProfileRequirement.NoProfile)
{
return(true);
}
Hausanschluss ha = _dbDto.Hausanschlusse.Single(x => x.Guid == cde.HausAnschlussGuid);
parameters.HouseComponentResultObject.CarStatus = "Electric";
parameters.HouseComponentResultObject.CommutingDistance = cde.CommutingDistance;
parameters.HouseComponentResultObject.OtherDrivingDistance = cde.FreizeitDistance;
Household flaHousehold = _dbDto.Households.FirstOrDefault(x => x.Guid == cde.HouseholdGuid);
if (flaHousehold == null)
{
parameters.HouseComponentResultObject.CarStatus += ", no household";
throw new FlaException("no household found");
}
var house = _dbDto.Houses.FirstOrDefault(x => x.HouseGuid == cde.HouseGuid);
if (house == null)
{
throw new FlaException("no house found");
}
HouseholdData householdData = null;
if (_housesToBeCreated.Count > 0)
{
var houseJob = _housesToBeCreated.FirstOrDefault(x => x.House.HouseGuid == ha.HouseGuid);
if (houseJob == null)
{
parameters.HouseComponentResultObject.CarStatus += ", no house";
throw new FlaException("no house found");
}
householdData = houseJob.House.Households.FirstOrDefault(x => x.HouseholdGuid == flaHousehold.HouseholdKey);
if (householdData == null)
{
parameters.HouseComponentResultObject.CarStatus += ", no household guid";
throw new FlaException("no household for household guid " + cde.HouseholdGuid);
}
//set lpg parameters
householdData.UseElectricCar = ElectricCarUse.UseElectricCar;
//find number of cars
var householdCars = _dbDto.Cars.Where(x => x.HouseholdGuid == cde.HouseholdGuid).ToList();
switch (householdCars.Count)
{
case 1:
//use lpg profile for a single car
householdData.TransportationDeviceSet = TransportationDevicesTwoCar;
break;
case 2:
//use lpg profile for a single car
householdData.TransportationDeviceSet = TransportationDevicesTwoCar;
break;
case 3:
// use lpg profile for a single car
// todo: fix this and put in the right transportation device set
householdData.TransportationDeviceSet = TransportationDevicesTwoCar;
break;
case 4:
//use lpg profile for a single car
//todo: fix this and put in the right transportation device set
householdData.TransportationDeviceSet = TransportationDevicesTwoCar;
break;
default: throw new FlaException("Household with " + householdCars.Count + " cars is missing");
}
householdData.TravelRouteSet = TravelRouteSet;
householdData.ChargingStationSet = ChargingStationSet;
if (householdData.TransportationDistanceModifiers == null)
{
householdData.TransportationDistanceModifiers = new List <TransportationDistanceModifier>();
}
householdData.TransportationDistanceModifiers.Add(new TransportationDistanceModifier("Work", "Car", cde.CommutingDistance * 1000));
householdData.TransportationDistanceModifiers.Add(new TransportationDistanceModifier("Entertainment",
"Car",
cde.FreizeitDistance * 1000));
parameters.HouseComponentResultObject.CarStatus += ", asking for repare with distances commuting: " + cde.CommutingDistance +
", free time: " + cde.FreizeitDistance + " km";
}
if (Services.RunningConfig.LpgPrepareMode == LpgPrepareMode.PrepareWithFullLpgLoad)
{
Profile lpgProfile = null;
try {
lpgProfile = _lpgProfileLoader.LoadLPGProfile(parameters,
ha.Trafokreis,
LoadtypetoSearchFor,
_saveableEntry,
flaHousehold.HouseholdKey,
out _,
house.ComplexName,
Services.RunningConfig);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex) {
#pragma warning restore CA1031 // Do not catch general exception types
Error("trying to load lpg profile: " + ex.Message);
parameters.HouseComponentResultObject.LPGErrors = "trying to load lpg profile failed: " + ex.Message;
}
// ReSharper disable PossibleNullReferenceException
if (_housesToBeCreated.Count > 0)
{
if (lpgProfile != null)
{
householdData.IsCarProfileCalculated = true;
parameters.HouseComponentResultObject.ProcessingStatus = "Found LPG profile on full check";
}
else
{
householdData.IsCarProfileCalculated = false;
parameters.HouseComponentResultObject.ProcessingStatus = "Missing LPG profile on full check";
}
}
// ReSharper restore PossibleNullReferenceException
}
else if (Services.RunningConfig.LpgPrepareMode == LpgPrepareMode.PrepareWithOnlyNamecheck)
{
// ReSharper disable PossibleNullReferenceException
if (_housesToBeCreated.Count > 0)
{
if (_saveableEntry.CheckForName(flaHousehold.HouseholdKey, Services.Logger))
{
householdData.IsHouseholdProfileCalculated = true;
parameters.HouseComponentResultObject.ProcessingStatus = "Found LPG profile on name check";
}
else
{
householdData.IsHouseholdProfileCalculated = false;
parameters.HouseComponentResultObject.ProcessingStatus = "Miissing LPG profile on name check";
}
}
// ReSharper restore PossibleNullReferenceException
}
else
{
throw new FlaException("Unknown lpg prepare mode");
}
return(true);
}
protected override void RunActualProcess()
{
var dbHouses = SqlConnection.GetDatabaseConnection(Stage.Houses, Constants.PresentSlice).Database;
var houses = dbHouses.Fetch <House>();
var households = dbHouses.Fetch <Household>();
var occupants = dbHouses.Fetch <Occupant>();
var tks = houses.Select(x => x.TrafoKreis).Distinct().ToList();
HashSet <string> usedKeys = new HashSet <string>();
foreach (var tk in tks)
{
if (string.IsNullOrWhiteSpace(tk))
{
continue;
}
var allHouses = new List <HouseData>();
var filteredhouses = houses.Where(x => x.TrafoKreis == tk).ToList();
foreach (var house in filteredhouses)
{
var myhouseholds = households.Where(x => x.HouseGuid == house.HouseGuid).ToList();
if (myhouseholds.Count == 0)
{
continue;
}
var hd = new HouseData(house.HouseGuid, GetHousetype(house), 1000, 0, house.ComplexName);
var houseidx = 0;
foreach (var household in myhouseholds)
{
if (usedKeys.Contains(household.HouseholdKey))
{
throw new Exception("Household key was already in use: " + household.HouseholdKey + " - TK " + tk);
}
usedKeys.Add(household.HouseholdKey);
var hhd = new HouseholdData(household.HouseholdKey,
household.LowVoltageYearlyTotalElectricityUse, 10, ElectricCarUse.NoElectricCar, house.ComplexName + " " + houseidx++,
null, null, null);
var myOccupants = occupants.Where(x => x.HouseholdGuid == household.HouseholdGuid).ToList();
foreach (var occupant in myOccupants)
{
var g = (Automation.Gender)occupant.Gender;
hhd.Persons.Add(new PersonData(occupant.Age, g));
}
hd.Households.Add(hhd);
}
//TODO: make load profiles for street lights
allHouses.Add(hd);
}
var filename = MakeAndRegisterFullFilename("HouseDataExport." + tk + ".json", Name, "", Constants.PresentSlice);
var sw = new StreamWriter(filename);
var tkd = new DistrictData {
Name = tk,
Houses = allHouses
};
sw.WriteLine(JsonConvert.SerializeObject(tkd, Formatting.Indented));
sw.Close();
}
}
private static ModularHousehold MakeHouseholdBaseOnTemplateSpec([NotNull] Simulator sim, [NotNull] HouseholdData householdData)
{
HouseholdTemplateSpecification templateSpec = householdData.HouseholdTemplateSpec;
if (templateSpec == null)
{
throw new LPGCommandlineException("Household template specification was null");
}
var template = sim.HouseholdTemplates.FindFirstByName(templateSpec.HouseholdTemplateName, FindMode.StartsWith);
if (template == null)
{
throw new LPGException("No household template found for the household template name " + templateSpec.HouseholdTemplateName);
}
template.Count = 1;
Logger.Info("Generating household with template " + template.Name);
var hhs = template.GenerateHouseholds(sim, false, new List <STTraitLimit>());
if (hhs.Count != 1)
{
throw new Exception("Could not generate this house");
}
hhs[0].Description = DescriptionText + householdData.UniqueHouseholdId;
hhs[0].SaveToDB();
Logger.Info("Finished generating household with template " + template.Name);
return(hhs[0]);
}
public void RunTest()
{
CompositeResolver.RegisterAndSetAsDefault(NativeDateTimeResolver.Instance, StandardResolver.Instance);
PrepareUnitTest();
Config.Directories.ResultStorageDirectory = WorkingDirectory.Dir;
Config.Directories.CalcServerLpgDirectory = WorkingDirectory.Dir;
// ReSharper disable twice AssignNullToNotNullAttribute
HouseCreationAndCalculationJob hcj = new HouseCreationAndCalculationJob(Scenario.Present().ToString(), "2017", "trafokreis");
HouseData hd = new HouseData("houseguid", "HT01", 1000, 1000, "houseName");
HouseholdData hhd = new HouseholdData("householdguid",
2000,
ElectricCarUse.UseElectricCar,
"householdname",
ElectricCarProvider.ChargingStationSet,
ElectricCarProvider.TransportationDevicesOneCar,
ElectricCarProvider.TravelRouteSet,
new List <TransportationDistanceModifier>(),
HouseholdDataSpecifictionType.ByPersons);
hd.Households.Add(hhd);
hhd.UseElectricCar = ElectricCarUse.UseElectricCar;
hhd.TransportationDeviceSet = ElectricCarProvider.TransportationDevicesOneCar;
hhd.TravelRouteSet = ElectricCarProvider.TravelRouteSet;
hhd.ChargingStationSet = ElectricCarProvider.ChargingStationSet;
hhd.HouseholdDataPersonSpecification = new HouseholdDataPersonSpecification(new List <PersonData> {
new PersonData(30, Gender.Male)
});
hcj.House = hd;
List <HouseCreationAndCalculationJob> houseJobs = new List <HouseCreationAndCalculationJob>();
houseJobs.Add(hcj);
FileHelpers.CopyRec(Config.Directories.LPGReleaseDirectory, WorkingDirectory.Dir, Logger, true);
var endTime = new DateTime(Constants.PresentSlice.DstYear, 1, 10);
ProfileGenerationRo pgro = new ProfileGenerationRo();
HouseProcessor.WriteDistrictsForLPG(houseJobs,
WorkingDirectory.DirDi,
Logger,
Constants.PresentSlice,
endTime,
pgro);
string districtsDir = WorkingDirectory.Combine("Districts");
var districtsDi = new DirectoryInfo(districtsDir);
var files = districtsDi.GetFiles("*.json");
void RunOneFile(FileInfo myfi)
{
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = WorkingDirectory.Combine("simulationengine.exe");
psi.UseShellExecute = true;
psi.WorkingDirectory = WorkingDirectory.Dir;
psi.Arguments = "ProcessHouseJob -j \"" + myfi.FullName + "\"";
Info("running " + psi.FileName + " " + psi.Arguments);
using (Process p = new Process()) {
p.StartInfo = psi;
p.Start();
p.WaitForExit();
}
}
foreach (var housejob in files)
{
RunOneFile(housejob);
}
DBDto dbDto = new DBDto(new List <House>(), new List <Hausanschluss>(), new List <Car>(), new List <Household>(), new List <RlmProfile>());
CachingLPGProfileLoader ca = new CachingLPGProfileLoader(Logger, dbDto);
List <int> isns = new List <int>();
isns.Add(10);
CarDistanceEntry cde = new CarDistanceEntry("houseguid",
"householdguid",
"carguid",
20,
20,
isns,
10,
"haguid",
"sourceguid",
"cdename",
CarType.Electric);
HouseComponentRo hcro = new HouseComponentRo("housecomponent", "componeenttype", 1000, 200, "processingstatus", "isns", "standort", 0);
ProviderParameterDto ppd = new ProviderParameterDto(cde, WorkingDirectory.Dir, hcro);
SqlConnectionPreparer scp = new SqlConnectionPreparer(Config);
MyDb db = scp.GetDatabaseConnection(Stage.Testing, Constants.PresentSlice);
SaveableEntry <Profile> sa = SaveableEntry <Profile> .GetSaveableEntry(db, SaveableEntryTableType.LPGProfile, Logger);
sa.MakeTableForListOfFieldsIfNotExists(true);
string dstDir = Path.Combine(WorkingDirectory.Dir, hcj.Trafokreis, hcj.House.Name);
FileHelpers.CopyRec(WorkingDirectory.Combine("Results"), dstDir, Logger, true);
//normal electricity test and cache test
Info("================== ");
Info("electricity");
Info("================== ");
var profElec1 = ca.LoadLPGProfile(ppd,
hcj.Trafokreis,
"Electricity",
sa,
hhd.HouseholdGuid,
out var profsource,
hcj.House.Name,
Config,
true);
Info("Source: " + profsource);
Assert.NotNull(profElec1);
Assert.NotNull(profsource);
var profElecCache = ca.LoadLPGProfile(ppd,
hcj.Trafokreis,
"Electricity",
sa,
hhd.HouseholdGuid,
out var profsourceCache,
hcj.House.Name,
Config,
true);
Info("Source 2: " + profsourceCache);
Assert.NotNull(profsourceCache);
Assert.NotNull(profsource);
profElec1.Should().BeEquivalentTo(profElecCache, options => options.Excluding(ctx => ctx.SelectedMemberPath.EndsWith("BinaryProfile")));
//Car Charging Electricity electricity test and cache test
Info("================== ");
Info("Car Charging Electricity electricity");
Info("================== ");
SaveableEntry <Profile> sa2 = SaveableEntry <Profile> .GetSaveableEntry(db, SaveableEntryTableType.EvProfile, Logger);
sa2.MakeCleanTableForListOfFields(true);
var prof2 = ca.LoadLPGProfile(ppd,
hcj.Trafokreis,
"Car Charging Electricity",
sa2,
hhd.HouseholdGuid,
out var profsource2,
hcj.House.Name,
Config,
true);
Info("Source Wp 1: " + profsource2);
Assert.NotNull(prof2);
Assert.NotNull(profsource2);
var prof3 = ca.LoadLPGProfile(ppd,
hcj.Trafokreis,
"Car Charging Electricity",
sa2,
hhd.HouseholdGuid,
out var profsource3,
hcj.House.Name,
Config,
true);
Info("Source Wp 2: " + profsource3);
Assert.NotNull(prof3);
Assert.NotNull(profsource3);
prof2.Should().BeEquivalentTo(prof3, options => options.Excluding(ctx =>
ctx.SelectedMemberPath.EndsWith("BinaryProfile")));
}
private static ModularHousehold MakeHouseholdBaseOnPersonSpec([NotNull] Simulator sim, [NotNull] HouseholdData householdData, [NotNull] Random r)
{
HouseholdDataPersonSpecification personSpec = householdData.HouseholdDataPersonSpec;
if (personSpec == null)
{
throw new LPGCommandlineException("Person specification was null");
}
List <HouseholdTemplate> templatesWithCorrectPersonCounts =
sim.HouseholdTemplates.It.Where(x => x.Persons.Count == personSpec.Persons.Count).ToList();
//make demanded person profile
List <PersonCategory> demandedPersonCategories = new List <PersonCategory>();
foreach (PersonData data in personSpec.Persons)
{
demandedPersonCategories.Add(new PersonCategory(data.Age, (PermittedGender)data.Gender));
}
List <HouseholdTemplate> selectedHouseholdTemplates = new List <HouseholdTemplate>();
foreach (var householdTemplate in templatesWithCorrectPersonCounts)
{
List <PersonCategory> thisOfferedCategories = new List <PersonCategory>();
foreach (var th in householdTemplate.Persons)
{
thisOfferedCategories.Add(new PersonCategory(th.Person.Age, th.Person.Gender));
}
if (AreOfferedCategoriesEnough(thisOfferedCategories, demandedPersonCategories))
{
selectedHouseholdTemplates.Add(householdTemplate);
}
}
if (selectedHouseholdTemplates.Count == 0)
{
_householdErrorCount++;
string s = "Error " + _householdErrorCount + Environment.NewLine + "Not a single household template was found for the household " +
householdData.Name + Environment.NewLine;
s += "Criteria for finding the household were: Persons: " + personSpec.Persons.Count + Environment.NewLine;
s += "Household templates found with this criteria: " + templatesWithCorrectPersonCounts.Count + Environment.NewLine;
s += "Requirements for the persons were:" + Environment.NewLine;
foreach (var cat in demandedPersonCategories)
{
s += cat + Environment.NewLine;
}
Logger.Warning(s);
//throw new LPGException(s);
if (templatesWithCorrectPersonCounts.Count > 0)
{
Logger.Warning("Using a random template with the same number of people.");
selectedHouseholdTemplates = templatesWithCorrectPersonCounts;
}
else
{
Logger.Warning("No household found with " + personSpec.Persons.Count + ", using a random template.");
selectedHouseholdTemplates = sim.HouseholdTemplates.It.ToList();
}
}
//try to find the right one based on energy use
var pickedHht = selectedHouseholdTemplates[r.Next(selectedHouseholdTemplates.Count)];
pickedHht.Count = 1;
Logger.Info("Generating household with template " + pickedHht.Name);
var hhs = pickedHht.GenerateHouseholds(sim, false, new List <STTraitLimit>());
if (hhs.Count != 1)
{
throw new Exception("Could not generate this house");
}
hhs[0].Description = DescriptionText + householdData.UniqueHouseholdId;
hhs[0].SaveToDB();
Logger.Info("Finished generating household with template " + pickedHht.Name);
return(hhs[0]);
}
private void InitializeData()
{
this.Data = new HouseholdData();
}
private void InitializeData()
{
this.Data = new HouseholdData();
}
public bool PrepareLoadProfileIfNeeded([NotNull] ProviderParameterDto parameters)
{
if (parameters.HouseComponent.HouseComponentType != HouseComponentType.Household)
{
throw new FlaException("Was not household: " + parameters.HouseComponent.HouseComponentType);
}
Household hh = (Household)parameters.HouseComponent;
Hausanschluss ha = _dbDto.Hausanschlusse.Single(x => x.Guid == hh.HausAnschlussGuid);
var houseJob = _housesToBeCreated.FirstOrDefault(x => x.House.HouseGuid == hh.HouseGuid);
if (houseJob == null)
{
var flahouse = _dbDto.Houses.Single(x => x.Guid == hh.HouseGuid);
houseJob = new HouseCreationAndCalculationJob(Slice.DstScenario.ToString(), Slice.DstYear.ToString(), ha.Trafokreis);
houseJob.House = new HouseData(hh.HouseGuid, "HT01", 0, 0, flahouse.ComplexName);
_housesToBeCreated.Add(houseJob);
}
HouseholdData hd = new HouseholdData(hh.HouseholdKey,
hh.EffectiveEnergyDemand,
ElectricCarUse.NoElectricCar,
hh.Name,
null,
null,
null,
null,
HouseholdDataSpecifictionType.ByPersons);
hd.IsCarProfileCalculated = true;
hd.HouseholdDataPersonSpecification = new HouseholdDataPersonSpecification(new List <PersonData>());
if (hh.Occupants.Count == 0)
{
throw new FlaException("No occupants in the household " + hh.Name);
}
foreach (var occupant in hh.Occupants)
{
hd.HouseholdDataPersonSpecification.Persons.Add(new PersonData(occupant.Age, (Gender)occupant.Gender));
}
House house = _dbDto.Houses.First(x => x.Guid == hh.HouseGuid);
if (Services.RunningConfig.LpgPrepareMode == LpgPrepareMode.PrepareWithFullLpgLoad)
{
Profile lpgProfile = null;
try {
lpgProfile = _lpgloader.LoadLPGProfile(parameters,
ha.Trafokreis,
LoadtypetoSearchFor,
_saveableEntry,
hh.HouseholdKey,
out _,
house.ComplexName,
Services.RunningConfig);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex) {
#pragma warning restore CA1031 // Do not catch general exception types
parameters.HouseComponentResultObject.LPGErrors = "trying to load lpg profile failed: " + ex.Message;
Error("trying to load lpg profile: " + ex.Message);
}
if (lpgProfile != null)
{
hd.IsHouseholdProfileCalculated = true;
}
else
{
hd.IsHouseholdProfileCalculated = false;
}
}
else if (Services.RunningConfig.LpgPrepareMode == LpgPrepareMode.PrepareWithOnlyNamecheck)
{
if (_saveableEntry.CheckForName(hh.HouseholdKey, Services.Logger))
{
hd.IsHouseholdProfileCalculated = true;
}
else
{
hd.IsHouseholdProfileCalculated = false;
}
}
else
{
throw new FlaException("Unknown lpg prepare mode");
}
houseJob.House.Households.Add(hd);
return(true);
}
