public async Task <TemperatureProfile> GetActiveProfile()
{
return(await Task.Run(() =>
{
TemperatureProfile profile = null;
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
var profiles = _context.TemperatureProfiles.Include(p => p.Schedules).ToList();
profile = profiles.Where(p => p.Current).First();
profile.Schedules = profile.Schedules.OrderBy(s => s.DayOfWeek).ThenBy(s => s.Start).ToList();
_logger.Information(
LogBuilder.StartNew("Active profile")
.KeyValue("Name", profile.Name)
.KeyValue("Configurations", profile.Schedules.Count)
.ElapsedTime(sw));
}
catch (Exception err)
{
_logger.Error(err, LogBuilder.StartNew("Errore nel recupero del profilo corrente").ElapsedTime(sw));
}
finally
{
sw.Stop();
}
return profile;
}));
}
/// <summary>
/// starter for real calcs
/// </summary>
public CalcStartParameterSet(
[NotNull] Func <bool, string, ObservableCollection <ResultFileEntry>, bool>
reportFinishFuncForHouseAndSettlement,
[NotNull] Func <bool, string, string, bool> reportFinishFuncForHousehold,
[NotNull] Func <object, bool> openTabFunc, [CanBeNull] ILPGDispatcher dispatcher,
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity, [NotNull] Func <bool> reportCancelFunc, bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection, LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] TravelRouteSet travelRouteSet,
[NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler,
[CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull][ItemNotNull] List <string> loadTypesToProcess,
DeviceProfileHeaderMode deviceProfileHeaderMode,
bool ignorePreviousActivitiesWhenNeeded, string resultPath, bool transportationEnabled)
{
IgnorePreviousActivitiesWhenNeeded = ignorePreviousActivitiesWhenNeeded;
ResultPath = resultPath;
LoadTypesToProcess = loadTypesToProcess;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
SelectedRandomSeed = selectedRandomSeed;
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
ReportFinishFuncForHouseAndSettlement = reportFinishFuncForHouseAndSettlement;
ReportFinishFuncForHousehold = reportFinishFuncForHousehold;
OpenTabFunc = openTabFunc;
Dispatcher = dispatcher;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ReportCancelFunc = reportCancelFunc;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = deviceProfileHeaderMode;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
private CoolingParameter MakeCoolingParameters([NotNull] TemperatureProfile temperatureProfile, [NotNull] HouseType houseType)
{
if (houseType == null)
{
throw new LPGException("Housetype was null");
}
if (houseType.CoolingLoadType != null && Math.Abs(houseType.CoolingYearlyTotal) > 0.000001 &&
!double.IsNaN(houseType.CoolingYearlyTotal))
{
var conversionFactor = _ltDict.GetLoadtypeDtoByLoadType(houseType.CoolingLoadType).ConversionFactor;
var degreeHours = DbCalcDegreeHour.GetCalcDegreeHours(temperatureProfile,
_calcParameters.InternalStartTime,
_calcParameters.InternalEndTime,
houseType.CoolingTemperature,
houseType.CoolingYearlyTotal / conversionFactor,
houseType.AdjustYearlyCooling,
houseType.ReferenceCoolingHours);
var isNan = false;
foreach (var degreeHour in degreeHours)
{
if (double.IsNaN(degreeHour.CoolingAmount))
{
isNan = true;
}
}
if (!isNan)
{
return(new CoolingParameter(degreeHours, houseType.CoolingLoadType, houseType.CoolingYearlyTotal));
}
}
return(null);
}
public TemperatureProfilePresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] TemperatureProfileView view,
[NotNull] TemperatureProfile tp) : base(view, "ThisProfile.HeaderString", tp, applicationPresenter)
{
_applicationPresenter = applicationPresenter;
_tp = tp;
_csvImporter = new CSVImporter(true);
}
public void LoadFromDatabaseTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TemperatureProfile.TableName);
db.ClearTable(TemperatureValue.TableName);
var profiles = new ObservableCollection <TemperatureProfile>();
TemperatureProfile.LoadFromDatabase(profiles, db.ConnectionString, false);
foreach (var temperaturProfile in profiles)
{
temperaturProfile.DeleteFromDB();
}
var tp = new TemperatureProfile("tempprofil1", null, "desc1", db.ConnectionString, Guid.NewGuid().ToStrGuid());
tp.SaveToDB();
tp.AddTemperature(new DateTime(2011, 1, 1), 20);
tp.AddTemperature(new DateTime(2011, 2, 1), 15);
tp.SaveToDB();
TemperatureProfile.LoadFromDatabase(profiles, db.ConnectionString, false);
(profiles.Count).Should().Be(1);
(profiles[0].TemperatureValues.Count).Should().Be(2);
profiles[0].DeleteOneTemperatur(profiles[0].TemperatureValues[0]);
(profiles[0].TemperatureValues.Count).Should().Be(1);
db.Cleanup();
}
}
public override void Run(HouseholdKey key, object o)
{
TemperatureProfile tp = (TemperatureProfile)o;
var tempProfile = tp.GetTemperatureArray(_calcParameters.InternalStartTime,
_calcParameters.OfficialEndTime,
_calcParameters.InternalStepsize);
DateStampCreator dsc = new DateStampCreator(_calcParameters);
if (!_calcParameters.IsSet(CalcOption.TemperatureFile))
{
return;
}
// var allTemperatures = new List<UsedTemperatures>();
SaveableEntry se = new SaveableEntry(key, ResultTableDefinition);
se.AddField("Timestep", SqliteDataType.Integer);
se.AddField("DateTime", SqliteDataType.Text);
se.AddField("Temperature", SqliteDataType.Double);
for (var i = 0; i < _calcParameters.OfficalTimesteps; i++)
{
string timestamp = dsc.MakeDateStringFromTimeStep(new TimeStep(i, 0, false));
se.AddRow(RowBuilder.Start("Timestep", i).Add("DateTime", timestamp).Add("Temperature", tempProfile[i]).ToDictionary());
}
_srls.SaveResultEntry(se);
}
private void MakeNewImages()
{
if (LimitPresenter == null)
{
return;
}
_calcImage = LimitPresenter.TmpCalcImage;
_selectedTemperatureProfile = LimitPresenter.PreviewTemperatureProfile;
_geographicLocation = LimitPresenter.PreviewGeographicLocation;
if (LimitPresenter.ThisTimeLimit.RootEntry == null)
{
throw new LPGException("root entry was null");
}
_rootEntry = LimitPresenter.ThisTimeLimit.RootEntry;
_household = LimitPresenter.PreviewHousehold;
TimeLimitPresenter p = null;
if (Dispatcher == null || Thread.CurrentThread == Dispatcher.Thread)
{
p = LimitPresenter;
}
var t = new Thread(() => UpdatePictures(p));
t.Start();
}
public void HouseLoadCreationAndSaveTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Logger.Threshold = Severity.Warning;
db.ClearTable(HouseType.TableName);
db.ClearTable(HouseTypeDevice.TableName);
var devices = new ObservableCollection <RealDevice>();
var deviceCategories = new ObservableCollection <DeviceCategory>();
var timeBasedProfiles = new ObservableCollection <TimeBasedProfile>();
var timeLimits = new ObservableCollection <TimeLimit>();
var variables = db.LoadVariables();
var loadTypes = db.LoadLoadTypes();
var energyStorages = db.LoadEnergyStorages(loadTypes, variables);
var trafoDevices = db.LoadTransformationDevices(loadTypes,
variables);
var dateprofiles = db.LoadDateBasedProfiles();
var generators = db.LoadGenerators(loadTypes, dateprofiles);
var locations = db.LoadLocations(devices, deviceCategories, loadTypes);
var deviceActionGroups = db.LoadDeviceActionGroups();
var deviceActions = db.LoadDeviceActions(timeBasedProfiles,
devices, loadTypes, deviceActionGroups);
var dt = new TimeLimit("blub", db.ConnectionString, Guid.NewGuid().ToStrGuid());
dt.SaveToDB();
timeLimits.Add(dt);
var rd = new RealDevice("blub", 1, string.Empty, null, string.Empty, true, false, db.ConnectionString, Guid.NewGuid().ToStrGuid());
rd.SaveToDB();
devices.Add(rd);
var tbp = new TimeBasedProfile("blub", null, db.ConnectionString, TimeProfileType.Relative,
"fake", Guid.NewGuid().ToStrGuid());
tbp.SaveToDB();
timeBasedProfiles.Add(tbp);
var tempP = new TemperatureProfile("blub", null, string.Empty, db.ConnectionString, Guid.NewGuid().ToStrGuid());
tempP.SaveToDB();
var houseTypes = new ObservableCollection <HouseType>();
HouseType.LoadFromDatabase(houseTypes, db.ConnectionString, devices, deviceCategories, timeBasedProfiles,
timeLimits, loadTypes, trafoDevices, energyStorages, generators, false, locations, deviceActions,
deviceActionGroups, variables);
(houseTypes.Count).Should().Be(0);
var housetype = new HouseType("haus1", "blub", 1000, 5, 10, loadTypes[0], db.ConnectionString, 1, 1,
loadTypes[1], false, 0, false, 0, 1, 100, Guid.NewGuid().ToStrGuid());
housetype.SaveToDB();
housetype.AddHouseTypeDevice(rd, dt, tbp, 1, loadTypes[0], locations[0], 0, VariableCondition.Equal,
variables[0]);
HouseType.LoadFromDatabase(houseTypes, db.ConnectionString, devices, deviceCategories, timeBasedProfiles,
timeLimits, loadTypes, trafoDevices, energyStorages, generators, false, locations, deviceActions,
deviceActionGroups, variables);
(houseTypes.Count).Should().Be(1);
(houseTypes[0].HouseDevices.Count).Should().Be(1);
var house2 = houseTypes[0];
(house2.Name).Should().Be("haus1");
(house2.Description).Should().Be("blub");
db.Cleanup();
}
}
private void CmbTemperatureProfilesSelectionChanged1([CanBeNull] object sender,
[CanBeNull] SelectionChangedEventArgs e)
{
if (CmbPreviewTemperatureProfiles.SelectedItem == null)
{
return;
}
_selectedTemperatureProfile = (TemperatureProfile)CmbPreviewTemperatureProfiles.SelectedItem;
MakeNewImages();
}
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 SettlementTemplate([NotNull] string pName, [CanBeNull] int?id, [CanBeNull] string description, [NotNull] string connectionString,
int desiredHHCount, [NotNull] string newName, [CanBeNull] TemperatureProfile temperatureProfile,
[CanBeNull] GeographicLocation geographicLocation, StrGuid guid) : base(pName, TableName, connectionString, guid)
{
ID = id;
_description = description;
TypeDescription = "Settlement Template";
_desiredHHCount = desiredHHCount;
_newName = newName;
_temperatureProfile = temperatureProfile;
_geographicLocation = geographicLocation;
}
public HouseTypePresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] HouseTypeView view, [NotNull] HouseType houseType)
: base(view, "ThisHouseType.HeaderString", houseType, applicationPresenter)
{
_houseType = houseType;
if (TemperaturProfiles.Count > 0)
{
_testingTemperatureProfile = TemperaturProfiles[0];
}
ThisHouseType.PropertyChanged += ThisHouseTypePropertyChanged;
_usedIns = new ObservableCollection <UsedIn>();
RefreshUsedIn();
}
private CalcAirConditioningDto MakeAirConditioning([NotNull] TemperatureProfile temperatureProfile,
[NotNull] HouseType houseType,
[NotNull] HouseholdKey householdKey,
[CanBeNull] out CalcLocationDto airConditioningLocation)
{
var coolingParameter = MakeCoolingParameters(temperatureProfile, houseType);
if (coolingParameter == null)
{
airConditioningLocation = null;
return(null);
}
var degreeHourDict = new List <CalcDegreeHourDto>();
foreach (var degreeHour in coolingParameter.DegreeHours)
{
var cdd = new CalcDegreeHourDto(degreeHour.Date.Year,
degreeHour.Date.Month,
degreeHour.Date.Day,
degreeHour.Date.Hour,
degreeHour.CoolingAmount);
degreeHourDict.Add(cdd);
}
CalcLoadTypeDto lt = _ltDict.GetLoadtypeDtoByLoadType(coolingParameter.CoolingLoadType);
var cdl = new CalcDeviceLoadDto(coolingParameter.CoolingLoadType.Name,
-1,
lt.Name,
lt.Guid,
coolingParameter.YearlyConsumption,
0,
Guid.NewGuid().ToStrGuid(),
1);
var cdls = new List <CalcDeviceLoadDto> {
cdl
};
airConditioningLocation = new CalcLocationDto("Air Conditioning", -100, Guid.NewGuid().ToStrGuid());
var csh = new CalcAirConditioningDto("Air Conditioning",
-1,
cdls,
degreeHourDict,
householdKey,
airConditioningLocation.Name,
airConditioningLocation.Guid,
Guid.NewGuid().ToStrGuid());
return(csh);
}
public House([NotNull] string pName, [CanBeNull] string description, [CanBeNull] TemperatureProfile temperatureProfile, [CanBeNull] GeographicLocation geographicLocation,
[CanBeNull] HouseType houseType, [NotNull] string connectionString, EnergyIntensityType energyIntensity, [CanBeNull] string source, CreationType creationType,
StrGuid guid, [CanBeNull] int?pID = null) : base(pName, TableName, connectionString, guid)
{
ID = pID;
TypeDescription = "House";
_description = description;
_energyIntensityType = energyIntensity;
_temperatureProfile = temperatureProfile;
_geographicLocation = geographicLocation;
_houseType = houseType;
_source = source;
_creationType = creationType;
}
public bool ItemExists([NotNull] ICalcObject mycalcObject, [NotNull] GeographicLocation geoloc,
[NotNull] TemperatureProfile temperatureProfile,
EnergyIntensityType intensity, [NotNull] string lpgVersion)
{
foreach (var co in MyItems)
{
if (co.HouseholdName == mycalcObject.Name && co.GeographicLocationName == geoloc.Name &&
co.TemperatureProfile == temperatureProfile.Name && co.EnergyIntensity == intensity.ToString() &&
co.LPGVersion == lpgVersion)
{
return(true);
}
}
return(false);
}
public void RealDeviceOneValueTest()
{
var startdt = new DateTime(2010, 1, 1);
var endDt = new DateTime(2010, 1, 11);
var stepsize = new TimeSpan(1, 0, 0);
var temperatureValues = new ObservableCollection <TemperatureValue>
{
new TemperatureValue(new DateTime(2010, 1, 2), 10, -1, null, string.Empty, Guid.NewGuid().ToStrGuid())
};
var values = TemperatureProfile.GetTemperatureArray(startdt, endDt, stepsize, temperatureValues);
(values.Length).Should().Be(240);
(values[0]).Should().Be(10);
(values[239]).Should().Be(10);
}
//public const string TableName = "CalcStartParameterSet";
/// <summary>
/// starter for unit tests
/// </summary>
public CalcStartParameterSet(
[NotNull] GeographicLocation geographicLocation,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] ICalcObject calcTarget,
EnergyIntensityType energyIntensity,
bool resumeSettlement,
[CanBeNull] DeviceSelection deviceSelection,
LoadTypePriority loadTypePriority,
[CanBeNull] TransportationDeviceSet transportationDeviceSet, [CanBeNull] ChargingStationSet chargingStationSet,
[CanBeNull] TravelRouteSet travelRouteSet, [NotNull] List <CalcOption> calcOptions,
DateTime officialSimulationStartTime,
DateTime officialSimulationEndTime,
TimeSpan internalTimeResolution,
[NotNull] string csvCharacter,
int selectedRandomSeed,
TimeSpan externalTimeResolution, bool deleteDatFiles, bool writeExcelColumn, bool showSettlingPeriod,
int settlingDays, int affordanceRepetitionCount, [NotNull] CalculationProfiler calculationProfiler, string resultPath, bool transportationEnabled)
{
OfficialSimulationStartTime = officialSimulationStartTime;
OfficialSimulationEndTime = officialSimulationEndTime;
InternalTimeResolution = internalTimeResolution;
CsvCharacter = csvCharacter;
SelectedRandomSeed = selectedRandomSeed;
ExternalTimeResolution = externalTimeResolution;
DeleteDatFiles = deleteDatFiles;
WriteExcelColumn = writeExcelColumn;
ShowSettlingPeriod = showSettlingPeriod;
SettlingDays = settlingDays;
AffordanceRepetitionCount = affordanceRepetitionCount;
CalculationProfiler = calculationProfiler;
GeographicLocation = geographicLocation;
TemperatureProfile = temperatureProfile;
CalcTarget = calcTarget;
EnergyIntensity = energyIntensity;
ResumeSettlement = resumeSettlement;
LPGVersion = Utili.GetCurrentAssemblyVersion();
DeviceSelection = deviceSelection;
LoadTypePriority = loadTypePriority;
TransportationDeviceSet = transportationDeviceSet;
TravelRouteSet = travelRouteSet;
CalcOptions = calcOptions;
ChargingStationSet = chargingStationSet;
DeviceProfileHeaderMode = DeviceProfileHeaderMode.Standard;
ResultPath = resultPath;
CalculationStartTime = DateTime.Now;
TransportationEnabled = transportationEnabled;
}
public List <CalcAffordanceDto> SetCalcAffordances([NotNull][ItemNotNull] IEnumerable <CalcLocationDto> locs,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] CalcLoadTypeDtoDictionary ltdict,
[NotNull] GeographicLocation geographicLocation,
[NotNull] Random rnd,
int timeStepsPerHour, TimeSpan internalStepSize,
[NotNull][ItemNotNull] List <VacationTimeframe> vacationTimeframes, [NotNull] string holidayKey,
[NotNull][ItemNotNull] ObservableCollection <DeviceAction> deviceActions,
[NotNull] Dictionary <CalcLocationDto, List <AffordanceWithTimeLimit> > affordanceDict,
[NotNull] LocationDtoDict locDict,
[NotNull] out List <DateTime> bridgeDays,
[NotNull] HouseholdKey householdKey, [NotNull][ItemNotNull] List <CalcDeviceDto> allCalcDeviceDtos,
[ItemNotNull][NotNull] List <DeviceCategoryDto> deviceCategoryDtos)
{
List <CalcAffordanceDto> allCalcAffordances = new List <CalcAffordanceDto>();
bridgeDays = new List <DateTime>();
// get affordances
foreach (var calcLocation in locs)
{
var affs = affordanceDict[calcLocation];
var tmp = affs.Distinct();
if (affs.Count != tmp.Count())
{
throw new LPGException("double affordances!?!");
}
var devicesAtLoc = allCalcDeviceDtos.Where(x => x.LocationGuid == calcLocation.Guid).ToList();
var affordances = GetCalcAffordancesAtLocation(calcLocation, affs, internalStepSize, timeStepsPerHour, temperatureProfile,
ltdict, geographicLocation, rnd, vacationTimeframes, holidayKey, deviceActions,
locDict,
out var tmpBridgeDays, householdKey, devicesAtLoc, deviceCategoryDtos);
allCalcAffordances.AddRange(affordances);
foreach (var tmpBridgeDay in tmpBridgeDays)
{
if (!bridgeDays.Contains(tmpBridgeDay))
{
bridgeDays.Add(tmpBridgeDay);
}
}
//calcLocation.SortAffordances();
}
return(allCalcAffordances);
}
private void MakeAffordanceTimelimit([NotNull] TemperatureProfile temperatureProfile,
[NotNull] GeographicLocation geographicLocation,
[NotNull] Random rnd, [NotNull][ItemNotNull] List <VacationTimeframe> vacationTimeframes,
[NotNull] string holidayKey, [NotNull] List <DateTime> bridgeDays,
AffordanceWithTimeLimit aff,
[NotNull] out AvailabilityDataReferenceDto availabilityDataReference)
{
//time limit stuff
if (aff.Affordance.TimeLimit == null)
{
throw new DataIntegrityException("The time limit on the affordance was null. Please fix",
aff.Affordance);
}
var tl = aff.Affordance.TimeLimit;
if (aff.TimeLimit != null)
{
tl = aff.TimeLimit;
}
if (tl.RootEntry == null)
{
throw new LPGException("Root Entry was null");
}
var tmparr = tl.RootEntry.GetOneYearArray(
_cp.InternalStepsize,
_cp.InternalStartTime,
_cp.InternalEndTime, temperatureProfile, geographicLocation, rnd,
vacationTimeframes, holidayKey, out var tmpBridgeDays, aff.StartMinusTime, aff.StartPlusTime,
aff.EndMinusTime,
aff.EndPlusTime);
foreach (var tmpBridgeDay in tmpBridgeDays)
{
if (!bridgeDays.Contains(tmpBridgeDay))
{
bridgeDays.Add(tmpBridgeDay);
}
}
// invertieren von erlaubten zu verbotenen zeiten
tmparr = tmparr.Not();
availabilityDataReference = _availabilityDtoRepository.MakeNewReference(tl.Name, tmparr);
}
public void TimeLimitArrayTestDateProfileTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TimeLimit.TableName);
db.ClearTable(TimeLimitEntry.TableName);
// test if night + day is always
var dateBasedProfile = new DateBasedProfile("blub", "bla", db.ConnectionString, Guid.NewGuid().ToStrGuid());
dateBasedProfile.SaveToDB();
dateBasedProfile.AddNewDatePoint(new DateTime(2014, 1, 1), 100);
dateBasedProfile.AddNewDatePoint(new DateTime(2014, 1, 3), 0);
dateBasedProfile.SaveToDB();
var start = new DateTime(1900, 1, 1, 0, 0, 0);
var end = new DateTime(1900, 1, 1, 1, 1, 1);
var dt = new TimeLimit("blub", db.ConnectionString, Guid.NewGuid().ToStrGuid(), 1);
var temp = new TemperatureProfile("blub", 1, "bla", string.Empty, Guid.NewGuid().ToStrGuid());
var enddate = new DateTime(1900, 1, 2, 0, 0, 0);
temp.AddTemperature(start, 0, 1, true, false);
temp.AddTemperature(enddate, 10, 1, true, false);
var dateBasedProfiles = new ObservableCollection <DateBasedProfile>();
dt.AddTimeLimitEntry(null, start, end, PermissionMode.ControlledByDateProfile, 1, 1, true, true, true, true,
true, true, true, 1, 1, 1, 1, 1, 1, 1, true, false, AnyAllTimeLimitCondition.Any, start, end,
dateBasedProfile.ID, 150, 50, false, false, true, false, 5, false, dateBasedProfiles, 0, 0, 0);
dateBasedProfiles.Add(dateBasedProfile);
var geoloc = new GeographicLocation(db.ConnectionString, null, Guid.NewGuid().ToStrGuid());
var r = new Random();
var vacationTimeFrames = new List <VacationTimeframe>();
var br = dt.TimeLimitEntries[0].GetOneYearHourArray(temp, geoloc, r, vacationTimeFrames, "test",
out _);
for (var i = 0; i < br.Count; i++)
{
if (i < 48)
{
(br[i]).Should().Be(true);
}
else
{
(br[i]).Should().Be(false);
}
}
db.Cleanup();
}
}
public void GetTemperatureArrayTest2()
{
// test mapping to a different year
var startdate = new DateTime(2014, 1, 1);
var endDate = new DateTime(2014, 1, 4);
var stepsize = new TimeSpan(12, 0, 0);
var temperatureValue = new TemperatureValue(new DateTime(2012, 1, 2), 5, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var temperatureValue2 = new TemperatureValue(new DateTime(2012, 1, 2, 12, 0, 0), 10, -1, -1,
string.Empty, Guid.NewGuid().ToStrGuid());
var tempvalues = new ObservableCollection <TemperatureValue>
{
temperatureValue,
temperatureValue2
};
var temparr = TemperatureProfile.GetTemperatureArray(startdate, endDate, stepsize, tempvalues);
double[] dstarr = { 5.0, 5, 5, 10, 10, 10 };
CompareArray(temparr, dstarr);
}
public void LoadGraph(Column c)
{
plotModel = new PlotModel();
TP = new TemperatureProfile(c.LX / 1000, c.LY / 1000, c.R * 60, c.FireCurve);
//generate values
var cs = new ContourSeries
{
Color = OxyColors.Black,
LabelBackground = OxyColors.White,
ColumnCoordinates = TP.Y.AsArray(),
RowCoordinates = TP.X.AsArray(),
Data = TP.Temp.ToArray()
};
cs.RenderInLegend = false;
cs.ContourLevelStep = 100;
plotModel.Series.Add(cs);
RaisePropertyChanged(nameof(PlotModel));
}
public void GetTemperatureArrayTest4()
{
// test Jahres�bergang
var startdate = new DateTime(2013, 12, 27);
var endDate = new DateTime(2014, 1, 3);
var stepsize = new TimeSpan(12, 0, 0);
var temperatureValue = new TemperatureValue(new DateTime(2012, 1, 1), 5, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var temperatureValue2 = new TemperatureValue(new DateTime(2012, 1, 2), 10, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var temperatureValue3 = new TemperatureValue(new DateTime(2012, 12, 28), 15, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var tempvalues = new ObservableCollection <TemperatureValue>
{
temperatureValue,
temperatureValue2,
temperatureValue3
};
var temparr = TemperatureProfile.GetTemperatureArray(startdate, endDate, stepsize, tempvalues);
// 27.1.: 10, 28.1.-1.1.:5, 2.1:10
double[] dstarr = { 10, 10, 15, 15, 15, 15, 15, 15, 15, 15, 5.0, 5, 10, 10 };
CompareArray(temparr, dstarr);
}
public void GetTemperatureArrayTest3()
{
// test schaltjahr
var startdate = new DateTime(2014, 2, 27);
var endDate = new DateTime(2014, 3, 2);
var stepsize = new TimeSpan(12, 0, 0);
var temperatureValue = new TemperatureValue(new DateTime(2012, 2, 2), 5, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var temperatureValue2 = new TemperatureValue(new DateTime(2012, 2, 29), 10, -1, -1,
string.Empty, Guid.NewGuid().ToStrGuid());
var temperatureValue3 = new TemperatureValue(new DateTime(2012, 3, 1), 15, -1, -1, string.Empty, Guid.NewGuid().ToStrGuid());
var tempvalues = new ObservableCollection <TemperatureValue>
{
temperatureValue,
temperatureValue2,
temperatureValue3
};
var temparr = TemperatureProfile.GetTemperatureArray(startdate, endDate, stepsize, tempvalues);
double[] dstarr = { 5.0, 5, 5, 5, 15, 15 };
CompareArray(temparr, dstarr);
}
public TimeLimitPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] TimeLimitView view, [NotNull] TimeLimit timeLimit)
: base(view, "ThisTimeLimit.HeaderString", timeLimit, applicationPresenter)
{
_dtv = view;
ThisTimeLimit = timeLimit;
_previewGeographicLocation = Sim.GeographicLocations.MyItems[0];
_previewTemperatureProfile = Sim.TemperatureProfiles.MyItems[0];
if (Sim.ModularHouseholds.It.Count > 0)
{
_household = Sim.ModularHouseholds.MyItems[0];
}
MakeCalculatingImage();
if (ThisTimeLimit.RootEntry == null)
{
ThisTimeLimit.AddTimeLimitEntry(null, Sim.DateBasedProfiles.MyItems);
}
RefreshAllPermissionLines();
view.SetOneRow(ThisTimeLimit.RootEntry);
RefreshUsedIn();
}
public static CalcSpaceHeatingDto CreateSpaceHeatingObject([NotNull] House house,
[NotNull] TemperatureProfile temperatureProfile,
[NotNull] HouseholdKey householdKey,
[CanBeNull]
out CalcLocationDto heatingLocation, DateTime
startTime, DateTime endTime,
CalcLoadTypeDtoDictionary ltDict) //, List<CalcDeviceTaggingSet> deviceTaggingSets)
{
if (house.HouseType == null)
{
throw new LPGException("Housetype was null");
}
if (house.HouseType.HeatingLoadType != null && Math.Abs(house.HouseType.HeatingYearlyTotal) > 0.0001 &&
!double.IsNaN(house.HouseType.HeatingYearlyTotal))
{
var degreeDays = MakeDegreeDaysClass.MakeDegreeDays(temperatureProfile,
startTime, endTime,
house.HouseType.HeatingTemperature,
house.HouseType.RoomTemperature,
house.HouseType.HeatingYearlyTotal,
house.HouseType.AdjustYearlyEnergy,
house.HouseType.ReferenceDegreeDays);
foreach (var degreeHour in degreeDays)
{
if (double.IsNaN(degreeHour.HeatingAmount))
{
throw new LPGException("Heating Amount was NaN");
}
}
var heatingParameter = new HeatingParameter(degreeDays, house.HouseType.HeatingLoadType, house.HouseType.HeatingYearlyTotal);
var spaceheating = MakeSpaceHeatingDto(heatingParameter, ltDict, householdKey, out heatingLocation);
return(spaceheating); //,deviceTaggingSets
}
heatingLocation = null;
return(null);
}
public void TimeLimitArrayTestlightControlledTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TimeLimit.TableName);
db.ClearTable(TimeLimitEntry.TableName);
// test if night + day is always
var temp = new TemperatureProfile("blub", 1, "bla", db.ConnectionString, Guid.NewGuid().ToStrGuid());
var start = new DateTime(1900, 1, 1, 0, 0, 0);
var end = new DateTime(1900, 1, 1, 1, 1, 1);
temp.AddTemperature(start, 10, 1, true, false);
temp.AddTemperature(end, 0, 1, true, false);
var dt = new TimeLimit("blub", db.ConnectionString, Guid.NewGuid().ToStrGuid(), 1);
var dateBasedProfiles = new ObservableCollection <DateBasedProfile>();
var dtbe = dt.AddTimeLimitEntry(null, start, end, PermissionMode.LightControlled, 1, 1, true,
true, true, true, true, true, true, 1, 1, 1, 1, 1, 1, 1, true, false, AnyAllTimeLimitCondition.Any,
start, end, -1, 0, 0, false, false, true, false, 5, false, dateBasedProfiles, 0, 0, 0);
dt.AddTimeLimitEntry(dtbe, start, end, PermissionMode.LightControlled, 1, 1, true, true, true, true, true,
true, true, 1, 1, 1, 1, 1, 1, 1, true, false, AnyAllTimeLimitCondition.Any, start, end, -1, 0, 0, false,
false, false, false, 5, false, dateBasedProfiles, 0, 0, 0);
dt.AddTimeLimitEntry(dtbe, start, end, PermissionMode.LightControlled, 1, 1, true, true, true, true, true,
true, true, 1, 1, 1, 1, 1, 1, 1, false, true, AnyAllTimeLimitCondition.Any, start, end, -1, 0, 0, false,
false, false, false, 5, false, dateBasedProfiles, 0, 0, 0);
var geoloc = new GeographicLocation(db.ConnectionString, null, Guid.NewGuid().ToStrGuid());
var r = new Random();
var vacations = new List <VacationTimeframe>();
var br = dt.TimeLimitEntries[0].GetOneYearHourArray(temp, geoloc, r, vacations, "test", out _);
var br2 = dt.TimeLimitEntries[1].GetOneYearHourArray(temp, geoloc, r, vacations, "test", out _);
var brtotal = new BitArray(br);
brtotal = brtotal.Or(br2);
foreach (bool b in brtotal)
{
(b).Should().Be(true);
}
db.Cleanup();
}
}
public void TimeLimitArrayTestTemperatureControlledTest()
{
// test temperatures
var temp = new TemperatureProfile("blub", 1, "bla", string.Empty, Guid.NewGuid().ToStrGuid());
var start = new DateTime(1900, 1, 1, 0, 0, 0);
var end = new DateTime(1900, 1, 1, 1, 1, 1);
var enddate = new DateTime(1900, 1, 2, 0, 0, 0);
temp.AddTemperature(start, 0, 1, true, false);
temp.AddTemperature(enddate, 10, 1, true, false);
var dt = new TimeLimit("blub", string.Empty, Guid.NewGuid().ToStrGuid(), 1);
var dateBasedProfiles = new ObservableCollection <DateBasedProfile>();
dt.AddTimeLimitEntry(null, start, end, PermissionMode.Temperature, 1, 1, true, true, true, true, true, true,
true, 1, 1, 1, 1, 1, -10, 5, true, false, AnyAllTimeLimitCondition.Any, start, end, -1, 0, 0, false,
false, false, false, 5, false, dateBasedProfiles, 0, 0, 0, false);
var geoloc = new GeographicLocation(string.Empty, null, Guid.NewGuid().ToStrGuid());
var r = new Random();
var hhVacations = new List <VacationTimeframe>();
var br = dt.TimeLimitEntries[0].GetOneYearHourArray(temp, geoloc, r, hhVacations, "test",
out _);
for (var i = 0; i < 24; i++)
{
Logger.Info("hour: " + i + ":" + br[i]);
(br[i]).Should().Be(true);
}
for (var i = 24; i < br.Length; i++)
{
if (i % 24 == 0)
{
Logger.Info("hour: " + i + ":" + br[i]);
}
(br[i]).Should().Be(false);
}
}
private static JsonReference CreateSingleHouse(
[NotNull] HouseCreationAndCalculationJob hj,
[NotNull] Simulator sim,
GeographicLocation geoloc,
TemperatureProfile temperatureProfile,
Random r)
{
if (hj.House == null)
{
throw new LPGException("No house data was set in the file");
}
//string name = hj.House?.Name ?? "";
var housedata = hj.House;
Logger.Info("Creating new house with " + hj.House?.Households.Count + " households...");
//List<ModularHousehold> createdHouseholds = new List<ModularHousehold>();
//make the house
var house = MakeHouse(sim, hj.House);
house.GeographicLocation = geoloc;
house.TemperatureProfile = temperatureProfile;
//add the Households
int householdidx = 1;
foreach (var householdData in housedata.Households)
{
var hhs = MakeHousehold(sim, householdData, r);
var chargingStationSet = sim.ChargingStationSets.FindByJsonReference(householdData.ChargingStationSet);
var travelrouteset = sim.TravelRouteSets.FindByJsonReference(householdData.TravelRouteSet);
var transportationDeviceSet = sim.TransportationDeviceSets.FindByJsonReference(householdData.TransportationDeviceSet);
if (householdData.TransportationDistanceModifiers != null && travelrouteset != null && householdData.TransportationDistanceModifiers.Count > 0
)
{
Logger.Info("Settings new travel distances for " + hhs.Name + " " + "");
travelrouteset = AdjustTravelDistancesBasedOnModifiers(travelrouteset, sim, house,
householdData, householdidx++);
Logger.Info("Name of the new travel route set to be used is " + travelrouteset.Name);
}
house.AddHousehold(hhs, chargingStationSet, travelrouteset, transportationDeviceSet);
//createdHouseholds.Add(hhs);
}
/*
* if (createdHouseholds.Count == 0) {
* sim.Houses.DeleteItem(house);
* continue;
* }*/
house.SaveToDB();
Logger.Info("Successfully created house.");
//saving matching calculation file
Logger.Info("Creating calculation file.");
if (house == null)
{
throw new LPGException("House generation failed");
}
return(house.GetJsonReference());
}
public List <CalcAutoDevDto> MakeCalcAutoDevDtos(
[NotNull][ItemNotNull] List <IAutonomousDevice> autoDevices,
EnergyIntensityType energyIntensity,
[NotNull] HouseholdKey householdKey,
[NotNull][ItemNotNull] List <VacationTimeframe> vacationTimeframes,
[NotNull] string holidayKey,
[NotNull][ItemNotNull] ObservableCollection <DeviceAction> deviceActions,
[NotNull] LocationDtoDict locationDict,
[NotNull] TemperatureProfile temperatureProfile, [NotNull] GeographicLocation geographicLocation,
[ItemNotNull][NotNull] List <DeviceCategoryDto> deviceCategoryDtos)
{
var autodevs = new List <CalcAutoDevDto>(autoDevices.Count);
//// zur kategorien zuordnung
var allAutonomousDevices = new List <IAssignableDevice>();
allAutonomousDevices.AddRange(autoDevices.Select(x => x.Device));
foreach (var hhautodev in autoDevices)
{
var busyarr = new BitArray(_calcParameters.InternalTimesteps);
busyarr.SetAll(false);
Logger.Debug(
"Determining the permitted times for each autonomous device. Device: " + hhautodev.Name);
if (hhautodev.TimeLimit?.RootEntry == null)
{
throw new DataIntegrityException("Time limit was null");
}
busyarr =
hhautodev.TimeLimit.RootEntry.GetOneYearArray(
_calcParameters.InternalStepsize,
_calcParameters.InternalStartTime,
_calcParameters.InternalEndTime, temperatureProfile, geographicLocation,
_rnd, vacationTimeframes, holidayKey, out _, 0, 0, 0, 0);
// invertieren von erlaubten zu verbotenen zeiten
busyarr = busyarr.Not();
var timeprofilereference =
_availabilityDtoRepository.MakeNewReference(hhautodev.TimeLimit.Name, busyarr);
if (hhautodev.Location == null)
{
throw new DataIntegrityException("Location was null");
}
var calcLocation = locationDict.LocationDict[hhautodev.Location];
if (hhautodev.Device == null)
{
throw new DataIntegrityException("Device was null");
}
switch (hhautodev.Device.AssignableDeviceType)
{
case AssignableDeviceType.Device:
case AssignableDeviceType.DeviceCategory:
if (hhautodev.LoadType == null || hhautodev.TimeProfile == null)
{
throw new LPGException("load type was null");
}
if (_loadTypeDictionary.SimulateLoadtype(hhautodev.LoadType))
{
var profile = GetCalcProfileDto(hhautodev.TimeProfile);
var rd = _picker.GetAutoDeviceDeviceFromDeviceCategoryOrDevice(
hhautodev.Device, allAutonomousDevices, energyIntensity, deviceActions,
hhautodev.Location.IntID);
var cdl = MakeCalcDeviceLoads(rd, _loadTypeDictionary);
var ltdto = _loadTypeDictionary.GetLoadtypeDtoByLoadType(hhautodev.LoadType);
List <VariableRequirementDto> requirementDtos = new List <VariableRequirementDto>();
if (hhautodev.Variable != null)
{
var myVariable =
_calcVariableRepositoryDtoFactory.RegisterVariableIfNotRegistered(hhautodev.Variable,
hhautodev.Location, householdKey, locationDict);
VariableRequirementDto req = new VariableRequirementDto(hhautodev.Variable.Name,
hhautodev.VariableValue, calcLocation.Name, calcLocation.Guid,
hhautodev.VariableCondition, myVariable.Guid);
requirementDtos.Add(req);
}
if (rd.DeviceCategory == null)
{
throw new LPGException("Device category was null");
}
var deviceCategoryDto =
deviceCategoryDtos.Single(x => x.FullCategoryName == rd.DeviceCategory.FullPath);
var cautodev = new CalcAutoDevDto(rd.Name, profile,
ltdto.Name, ltdto.Guid, cdl,
(double)hhautodev.TimeStandardDeviation,
deviceCategoryDto.Guid, householdKey, 1, calcLocation.Name, calcLocation.Guid,
deviceCategoryDto.FullCategoryName, Guid.NewGuid().ToStrGuid(),
timeprofilereference, requirementDtos, deviceCategoryDto.FullCategoryName);
autodevs.Add(cautodev);
}
break;
case AssignableDeviceType.DeviceAction:
case AssignableDeviceType.DeviceActionGroup:
var deviceAction = _picker.GetAutoDeviceActionFromGroup(hhautodev.Device,
allAutonomousDevices, energyIntensity, deviceActions, hhautodev.Location.IntID);
foreach (var actionProfile in deviceAction.Profiles)
{
if (actionProfile.VLoadType == null)
{
throw new DataIntegrityException("Vloadtype was null");
}
if (actionProfile.Timeprofile == null)
{
throw new DataIntegrityException("Timeprofile was null");
}
if (_loadTypeDictionary.SimulateLoadtype(actionProfile.VLoadType))
{
var profile = GetCalcProfileDto(actionProfile.Timeprofile);
if (deviceAction.Device == null)
{
throw new LPGException("Device was null");
}
var cdl = MakeCalcDeviceLoads(deviceAction.Device, _loadTypeDictionary);
var lt = _loadTypeDictionary.GetLoadtypeDtoByLoadType(actionProfile.VLoadType);
List <VariableRequirementDto> requirementDtos = new List <VariableRequirementDto>();
if (hhautodev.Variable != null)
{
var myVariable =
_calcVariableRepositoryDtoFactory.RegisterVariableIfNotRegistered(hhautodev.Variable,
hhautodev.Location, householdKey, locationDict);
VariableRequirementDto req = new VariableRequirementDto(hhautodev.Variable?.Name,
hhautodev.VariableValue, calcLocation.Name, calcLocation.Guid,
hhautodev.VariableCondition, myVariable.Guid);
requirementDtos.Add(req);
}
if (deviceAction.Device.DeviceCategory == null)
{
throw new LPGException("device category was null");
}
var deviceCategoryDto =
deviceCategoryDtos.Single(x => x.FullCategoryName == deviceAction.Device.DeviceCategory.FullPath);
var cautodev = new CalcAutoDevDto(deviceAction.Device.Name,
profile, lt.Name, lt.Guid, cdl,
(double)hhautodev.TimeStandardDeviation,
deviceCategoryDto.Guid,
householdKey, actionProfile.Multiplier, calcLocation.Name, calcLocation.Guid,
deviceAction.Device.DeviceCategory.FullPath, Guid.NewGuid().ToStrGuid(),
timeprofilereference, requirementDtos,
deviceCategoryDto.FullCategoryName);
autodevs.Add(cautodev);
}
}
break;
default:
throw new LPGException("Forgotten AssignableDeviceType. Please Report!");
}
}
return(autodevs);
}
