public void IsAffordanceAvailableTestRealDeviceIsThere()
{
// Location: realdevice
// affordance: same realdevice
Config.IsInUnitTesting = true;
var col = new ColorRGB(255, 0, 0);
var deviceActions = new ObservableCollection <DeviceAction>();
var aff = new Affordance("bla", null, null, false, PermittedGender.All, 1, col, string.Empty, null,
string.Empty, string.Empty,
true, true, 0, 100, false, ActionAfterInterruption.GoBackToOld, false, Guid.NewGuid().ToStrGuid(), BodilyActivityLevel.Low);
var rd1 = new RealDevice("rd1", 1, string.Empty, null, string.Empty, false, false, string.Empty, Guid.NewGuid().ToStrGuid());
var allDevices1 = new List <IAssignableDevice>
{
// check if only the device is there
rd1
};
var connectionString = string.Empty;
var lt = new VLoadType("lt", string.Empty, "bla", "blub", 1, 1, new TimeSpan(0, 1, 0), 1, connectionString,
LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
var tbp = new TimeBasedProfile("name", 1, connectionString, TimeProfileType.Absolute, "data source", Guid.NewGuid().ToStrGuid());
aff.AffordanceDevices.Add(new AffordanceDevice(rd1, tbp, null, 0, null,
new ObservableCollection <RealDevice>(),
new ObservableCollection <DeviceCategory>(), "name", lt, string.Empty, 1, Guid.NewGuid().ToStrGuid()));
(aff.IsAffordanceAvailable(allDevices1, deviceActions)).Should().BeTrue();
}
public HouseType([NotNull] string pName, [NotNull] string description, double heatingYearlyTotal, double heatingTemperature,
double roomTemperature, [CanBeNull] VLoadType heatingLoadType, [NotNull] string connectionString,
double coolingTemperature,
double coolingYearlyTotal, [CanBeNull] VLoadType coolingLoadType, bool adjustYearlyEnergy,
double referenceDegreeDays,
bool adjustYearlyCooling, double referenceCoolingHours, int minimumHouseholdCount,
int maximumHouseholdCount, StrGuid guid,
[CanBeNull] int?pID = null) : base(pName, TableName, connectionString, guid)
{
ID = pID;
TypeDescription = "House type";
_description = description;
_heatingLoadType = heatingLoadType;
_coolingTemperature = coolingTemperature;
_coolingYearlyTotal = coolingYearlyTotal;
_heatingTemperature = heatingTemperature;
_roomTemperature = roomTemperature;
_heatingYearlyTotal = heatingYearlyTotal;
_coolingLoadType = coolingLoadType;
_adjustYearlyEnergy = adjustYearlyEnergy;
_referenceDegreeDays = referenceDegreeDays;
_adjustYearlyCooling = adjustYearlyCooling;
_referenceCoolingHours = referenceCoolingHours;
_minimumHouseholdCount = minimumHouseholdCount;
_maximumHouseholdCount = maximumHouseholdCount;
}
public void SiteLocationTest()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(Site.TableName);
db.ClearTable(SiteLocation.TableName);
Location loc = new Location("loc1", null, db.ConnectionString, Guid.NewGuid().ToStrGuid());
loc.SaveToDB();
Site site = new Site("site1", null, db.ConnectionString, "desc", Guid.NewGuid().ToStrGuid());
TransportationDeviceCategory cat = new TransportationDeviceCategory("bla", 1, db.ConnectionString, "desc", true, Guid.NewGuid().ToStrGuid());
VLoadType lt = new VLoadType("mylt", "desc", "w", "kwh", 1, 1, new TimeSpan(0, 1, 0), 1, db.ConnectionString,
LoadTypePriority.All, false, Guid.NewGuid().ToStrGuid());
lt.SaveToDB();
cat.SaveToDB();
site.SaveToDB();
//site.AddChargingStation(cat, lt, 1);
site.AddLocation(loc);
//loading
ObservableCollection <Site> slocs = new ObservableCollection <Site>();
ObservableCollection <Location> locs = new ObservableCollection <Location>
{
loc
};
Site.LoadFromDatabase(slocs, db.ConnectionString,
false, locs);
//Site mysite = slocs[0];
//(mysite.ChargingStations.Count).Should().Be(1);
db.Cleanup();
(slocs.Count).Should().Be(1);
}
}
public void CalculateAverageEnergyUseTestAbsoluteProfile()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Config.IsInUnitTesting = true;
var rd2 = new RealDevice("rd2", 1, string.Empty, null, string.Empty, false, false,
db.ConnectionString, Guid.NewGuid().ToStrGuid());
var lt = new VLoadType("lt", string.Empty, "bla", "blub", 1, 1, new TimeSpan(0, 1, 0), 1,
db.ConnectionString, LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
lt.SaveToDB();
rd2.SaveToDB();
rd2.AddLoad(lt, 666, 0, 0);
var tp = new TimeBasedProfile("tp", null, db.ConnectionString,
TimeProfileType.Absolute, "fake", Guid.NewGuid().ToStrGuid());
tp.SaveToDB();
tp.AddNewTimepoint(new TimeSpan(0, 0, 0), 100, false);
tp.AddNewTimepoint(new TimeSpan(0, 2, 0), 0, false);
var allActions = new ObservableCollection <DeviceAction>();
var res = rd2.CalculateAverageEnergyUse(lt, allActions, tp, 1, 1);
foreach (var keyValuePair in res)
{
Logger.Info(keyValuePair.Item1 + ": " + keyValuePair.Item2);
}
(res.Count).Should().Be(1);
var first = res.First();
(first.Item2).Should().Be(200);
db.Cleanup();
}
}
public void TransportationDeviceTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TransportationDeviceCategory.TableName);
db.ClearTable(TransportationDevice.TableName);
var tdc = new TransportationDeviceCategory("tdc1", null, db.ConnectionString, "desc", true, Guid.NewGuid().ToStrGuid());
tdc.SaveToDB();
VLoadType chargingloadType = (VLoadType)VLoadType.CreateNewItem(null, db.ConnectionString);
chargingloadType.SaveToDB();
var sl = new TransportationDevice("name", null, db.ConnectionString, "desc", 1, SpeedUnit.Kmh, tdc, 100, 10, 10, 10, chargingloadType, Guid.NewGuid().ToStrGuid());
var slocs = new ObservableCollection <TransportationDevice>();
sl.SaveToDB();
var categories = new ObservableCollection <TransportationDeviceCategory> {
tdc
};
var loadTypes = new ObservableCollection <VLoadType>();
var mylt = new VLoadType("myloadtype", "", "W", "kWh", 1, 1, new TimeSpan(1, 0, 0), 1, db.ConnectionString, LoadTypePriority.RecommendedForHouseholds, true, Guid.NewGuid().ToStrGuid());
mylt.SaveToDB();
loadTypes.Add(mylt);
loadTypes.Add(chargingloadType);
sl.AddLoad(mylt, 10);
TransportationDevice.LoadFromDatabase(slocs, db.ConnectionString, false, categories, loadTypes);
db.Cleanup();
(slocs.Count).Should().Be(1);
TransportationDevice td = slocs[0];
(td.ChargingLoadType).Should().Be(chargingloadType);
}
}
public void ConvertPowerValueWithTimeTest()
{
var vlt = new VLoadType("bla", string.Empty, "Watt", "kWh", 1000, 1, new TimeSpan(1, 0, 0), 1,
string.Empty, LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
vlt.ConvertPowerValueWithTime(10000, new TimeSpan(1, 0, 0)).Should().Be(10);
vlt.ConvertPowerValueWithTime(10000, new TimeSpan(0, 30, 0)).Should().Be(5);
}
public DeviceTaggingSetLoadType([NotNull] string name, int taggingSetID, [CanBeNull] VLoadType loadType,
[NotNull] string connectionString, [CanBeNull] int?pID, StrGuid guid) : base(name, pID, TableName,
connectionString, guid)
{
_taggingSetID = taggingSetID;
_loadType = loadType;
TypeDescription = "Affordance Tagging Set Loadtype";
}
/*
* public bool SimulateLoadtype([NotNull] StrGuid guid)
* {
* if (_guids.Contains(guid))
* {
* return true;
* }
*
* return false;
* }*/
public bool SimulateLoadtype([NotNull] VLoadType lt)
{
if (Ltdtodict.ContainsKey(lt))
{
return(true);
}
return(false);
}
public LoadTypePresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] LoadTypeView view, [NotNull] VLoadType loadtype)
: base(view, "ThisLoadType.HeaderString", loadtype, applicationPresenter)
{
_applicationPresenter = applicationPresenter;
ThisLoadType = loadtype;
_amountForTesting = 1000;
TrueFalse.Add(true);
TrueFalse.Add(false);
RefreshUsedIn();
}
public void SynchronizeDataFromJson(JsonDto jto, Simulator sim)
{
var checkedProperties = new List <string>();
ValidateAndUpdateValueAsNeeded(nameof(Device),
checkedProperties,
_device?.GetJsonReference().Guid, jto.Device.Guid,
() => _device = sim.GetAssignableDeviceByGuid(jto.Device?.Guid) ??
throw new LPGException("Could not find a device with for " + jto.Device));
ValidateAndUpdateValueAsNeeded(nameof(Location),
checkedProperties, Location?.Guid, jto.Location.Guid,
() =>
_location = sim.Locations.FindByGuid(jto.Location?.Guid));
ValidateAndUpdateValueAsNeeded(nameof(TimeLimit),
checkedProperties, TimeLimit?.Guid, jto.TimeLimit.Guid,
() =>
_timeLimit = sim.TimeLimits.FindByGuid(jto.TimeLimit?.Guid));
ValidateAndUpdateValueAsNeeded(nameof(TimeProfile),
checkedProperties,
TimeProfile?.Guid, jto.TimeProfile?.Guid,
() => _timeprofile = sim.Timeprofiles.FindByJsonReference(jto.TimeProfile));
if (TimeStandardDeviation != jto.StandardDeviation)
{
_timeStandardDeviation = jto.StandardDeviation;
NeedsUpdate = true;
}
if (Variable?.Guid != jto.Variable?.Guid)
{
_variable = sim.Variables.FindByGuid(jto.Variable?.Guid);
NeedsUpdate = true;
}
if (VariableCondition != jto.VariableCondition)
{
_variableCondition = jto.VariableCondition;
NeedsUpdate = true;
}
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (VariableValue != jto.VariableValue)
{
_variableValue = jto.VariableValue;
NeedsUpdate = true;
}
if (LoadType?.Guid != jto.LoadType?.Guid)
{
_vLoadType = sim.LoadTypes.FindByGuid(jto.Variable?.Guid);
NeedsUpdate = true;
}
ValidateAndUpdateValueAsNeeded(nameof(Guid),
checkedProperties,
Guid, jto.Guid,
() => Guid = jto.Guid);
CheckIfAllPropertiesWereCovered(checkedProperties, this);
SaveToDB();
}
public TimeProfileEntry([NotNull] AffordanceDevice affDev, int newLength, [NotNull] VLoadType loadType, int offSet,
[NotNull] Affordance affordance, double timeFactor, [NotNull] string deviceName)
{
AffDev = affDev;
NewLength = newLength;
LoadType = loadType;
OffSet = offSet;
Affordance = affordance;
TimeFactor = timeFactor;
DeviceName = deviceName;
}
public TransportationDeviceLoad([NotNull] string name, [CanBeNull] int?transportationDeviceID, double maxPower,
[CanBeNull] VLoadType loadType,
[NotNull] string connectionString, StrGuid guid, [CanBeNull] int?id = null)
: base(name, TableName, connectionString, guid)
{
_transportationDeviceID = transportationDeviceID;
_maxPower = maxPower;
ID = id;
_loadType = loadType;
TypeDescription = "Transportation Device Load";
}
public Generator([NotNull] string pName, [CanBeNull] string description, [CanBeNull] VLoadType loadType, double scalingFactor,
[CanBeNull] DateBasedProfile dateBasedProfile, [NotNull] string connectionString, StrGuid guid, [CanBeNull] int?pID = null)
: base(pName, TableName, connectionString, guid)
{
ID = pID;
TypeDescription = "Generator";
_description = description;
_loadType = loadType;
_scalingFactor = scalingFactor;
_dateBasedProfile = dateBasedProfile;
}
public TransformationDeviceLoadType([CanBeNull] int?pID, [CanBeNull] VLoadType loadType, double factor,
int transformationDeviceID,
[NotNull] string connectionString, [NotNull] string loadTypeName, TransformationFactorType factorType, StrGuid guid)
: base(loadTypeName, TableName, connectionString, guid)
{
ID = pID;
_loadType = loadType;
Factor = factor;
TransformationDeviceID = transformationDeviceID;
FactorType = factorType;
TypeDescription = "Transformation Device Load Type";
}
private void BtnAddLoadTypeClick([CanBeNull] object sender, [CanBeNull] RoutedEventArgs e)
{
if (CmbLoadTypes.SelectedItem == null)
{
Logger.Warning("Please select a load type first.");
return;
}
VLoadType loadType = (VLoadType)CmbLoadTypes.SelectedItem;
Presenter.ThisAffordanceTaggingSet.AddNewLoadType(loadType);
Presenter.ThisAffordanceTaggingSet.SaveToDB();
}
public void DistanceToEnergyFactorTest()
{
VLoadType vlt = new VLoadType("elec", "", "W", "kWh", 1000, 1, new TimeSpan(1, 0, 0),
1, "", LoadTypePriority.All, true, Guid.NewGuid().ToStrGuid(), 1);
var result = CalcTransportationDtoFactory.DistanceToPowerFactor(100000, 15, vlt.ConversionFaktorPowerToSum);
result.Should().BeApproximatelyWithinPercent(0.00185, 0.1);
double distanceGained = 15000 * result * 3600;
distanceGained.Should().BeApproximatelyWithinPercent(100000, 0.001);
Logger.Info(result.ToString(CultureInfo.InvariantCulture));
}
public DeviceTaggingReference([NotNull] string name, int taggingSetID, [CanBeNull] DeviceTag tag, [NotNull] string connectionString,
[CanBeNull] int?pID,
int personCount, double referenceValue, [CanBeNull] VLoadType loadType,
StrGuid guid) : base(name, pID, TableName,
connectionString, guid)
{
_taggingSetID = taggingSetID;
_tag = tag;
_personCount = personCount;
_referenceValue = referenceValue;
_loadType = loadType;
TypeDescription = "Device Tagging Reference Entry";
}
public ChargingStationSetEntry([CanBeNull] int?pID, [CanBeNull] VLoadType carChargingLoadtype, [CanBeNull] TransportationDeviceCategory transportationDeviceCategory,
int chargingStationSetID, double maxChargingPower, [NotNull] string connectionString,
[NotNull] string name, [CanBeNull] Site site, StrGuid guid, [CanBeNull] VLoadType gridChargingLoadtype) : base(name, TableName, connectionString, guid)
{
_site = site;
TypeDescription = "Site Location";
ID = pID;
ChargingStationSetID = chargingStationSetID;
_carChargingLoadtype = carChargingLoadtype;
_gridChargingLoadtype = gridChargingLoadtype;
_transportationDeviceCategory = transportationDeviceCategory;
_maxChargingPower = maxChargingPower;
}
public void CalculateAverageEnergyUseTestDeviceAction()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Config.IsInUnitTesting = true;
var col = new ColorRGB(255, 0, 0);
var devices = new ObservableCollection <RealDevice>();
var rd2 = new RealDevice("rd2", 1, string.Empty, null, string.Empty, false, false, db.ConnectionString, Guid.NewGuid().ToStrGuid());
var lt = new VLoadType("lt", string.Empty, "bla", "blub", 1, 1, new TimeSpan(0, 1, 0), 1,
db.ConnectionString,
LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
lt.SaveToDB();
rd2.SaveToDB();
rd2.AddLoad(lt, 666, 0, 0);
devices.Add(rd2);
var deviceCategories = new ObservableCollection <DeviceCategory>();
var deviceActions = new ObservableCollection <DeviceAction>();
var aff = new Affordance("bla", null, null, false, PermittedGender.All, 1, col, string.Empty, null,
string.Empty,
db.ConnectionString, true, true, 0,
100, false, ActionAfterInterruption.GoBackToOld, false, Guid.NewGuid().ToStrGuid(),
BodilyActivityLevel.Low);
aff.SaveToDB();
var tp = new TimeBasedProfile("tp", null, db.ConnectionString, TimeProfileType.Relative, "fake", Guid.NewGuid().ToStrGuid());
tp.SaveToDB();
tp.AddNewTimepoint(new TimeSpan(0, 0, 0), 100, false);
tp.AddNewTimepoint(new TimeSpan(0, 2, 0), 0, false);
var dag = new DeviceActionGroup("dag", db.ConnectionString, string.Empty, Guid.NewGuid().ToStrGuid());
dag.SaveToDB();
var da = new DeviceAction("da", null, string.Empty, db.ConnectionString, dag, rd2, Guid.NewGuid().ToStrGuid());
da.SaveToDB();
da.AddDeviceProfile(tp, 0, lt, 1);
deviceActions.Add(da);
var tbp = new TimeBasedProfile("name", 1, db.ConnectionString, TimeProfileType.Absolute, "data source", Guid.NewGuid().ToStrGuid());
aff.AddDeviceProfile(dag, tbp, 0, devices, deviceCategories, lt, 1);
var res = aff.CalculateAverageEnergyUse(deviceActions);
foreach (var keyValuePair in res)
{
Logger.Info(keyValuePair.Key + ": " + keyValuePair.Value);
}
res.Count.Should().Be(1);
var first = res.First();
first.Value.Should().Be(666 * 2);
db.Cleanup();
}
}
public void IsAffordanceAvailableTestCheckDeviceActionGroupInDeviceActionGroup()
{
// Location: device action group
// affordance: device Action Group
Config.IsInUnitTesting = true;
var col = new ColorRGB(255, 0, 0);
var deviceActions = new ObservableCollection <DeviceAction>();
var aff = new Affordance("bla", null, null, false, PermittedGender.All, 1, col, string.Empty, null,
string.Empty, string.Empty,
true, true, 0, 100, false, ActionAfterInterruption.GoBackToOld, false, Guid.NewGuid().ToStrGuid(), BodilyActivityLevel.Low);
var rd1 = new RealDevice("rd1", 1, string.Empty, null, string.Empty, false, false, string.Empty, Guid.NewGuid().ToStrGuid());
var dg = new DeviceActionGroup("group", string.Empty, string.Empty, Guid.NewGuid().ToStrGuid());
var da = new DeviceAction("device action 1", null, "blub", string.Empty, dg, rd1, Guid.NewGuid().ToStrGuid());
deviceActions.Add(da);
var devices = new ObservableCollection <RealDevice>
{
rd1
};
// check if it works with a device category that has the device
var dc1 = new DeviceCategory("dc1", 0, string.Empty, false, devices, Guid.NewGuid().ToStrGuid(), null, true);
rd1.DeviceCategory = dc1;
dc1.RefreshSubDevices();
(dc1.SubDevices.Count).Should().Be(1);
var connectionString = string.Empty;
var lt = new VLoadType("lt", string.Empty, "bla", "blub", 1, 1, new TimeSpan(0, 1, 0), 1, connectionString,
LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
var tbp = new TimeBasedProfile("name", 1, connectionString, TimeProfileType.Absolute, "data source", Guid.NewGuid().ToStrGuid());
aff.AffordanceDevices.Add(new AffordanceDevice(dg, tbp, null, 0, null,
new ObservableCollection <RealDevice>(),
new ObservableCollection <DeviceCategory>(), "name", lt, string.Empty, 1, Guid.NewGuid().ToStrGuid()));
var allDevices3 = new List <IAssignableDevice>
{
dg
};
if (da.DeviceActionGroup == null)
{
throw new LPGException("device action group was null");
}
var relevantDeviceActionGroup = da.DeviceActionGroup.GetDeviceActions(deviceActions);
(relevantDeviceActionGroup.Count).Should().Be(1);
(aff.IsAffordanceAvailable(allDevices3, deviceActions)).Should().BeTrue();
}
public void MakeLoadTypesTest()
{
//_calcParameters.CSVCharacter = ";";
VLoadType vlt = new VLoadType("vlt", string.Empty, "W", "kWh", 1000, 1, new TimeSpan(1, 0, 0), 1,
string.Empty, LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid(), 1);
ObservableCollection <VLoadType> vlts = new ObservableCollection <VLoadType> {
vlt
};
var dtoDict = CalcLoadTypeDtoFactory.MakeLoadTypes(vlts, new TimeSpan(0, 0, 1), LoadTypePriority.All);
var ltdict = CalcLoadTypeFactory.MakeLoadTypes(dtoDict);
var dto = dtoDict.GetLoadtypeDtoByLoadType(vlt);
var clt = ltdict.GetCalcLoadTypeByLoadtype(dto);
clt.ConversionFactor.Should().Be(1.0 / 3600000);
}
private List <CalcTransportationDeviceDto> MakeTransportationDevices([NotNull][ItemNotNull] List <TransportationDevice> transportationDevices,
[NotNull] Dictionary <TransportationDeviceCategory, CalcTransportationDeviceCategoryDto> categoriesDict, [NotNull] HouseholdKey key)
{
List <CalcTransportationDeviceDto> transportationDeviceDtos = new List <CalcTransportationDeviceDto>();
foreach (var transportationDevice in transportationDevices)
{
var loads = new List <CalcDeviceLoadDto>();
foreach (TransportationDeviceLoad load in transportationDevice.Loads)
{
VLoadType lt = load.LoadType;
if (lt == null)
{
throw new LPGException("Loadtype was null. This should never happen. Please report");
}
if (_loadTypeDict.SimulateLoadtype(lt))
{
CalcLoadTypeDto loadType = _loadTypeDict.GetLoadtypeDtoByLoadType(lt);
loads.Add(new CalcDeviceLoadDto(transportationDevice.Name + " - " + lt.Name,
transportationDevice.IntID, loadType.Name, loadType.Guid,
0, 0, Guid.NewGuid().ToStrGuid(), load.MaxPower));
}
}
double distanceToEnergyFactor = 0;
CalcLoadTypeDto chargingLoadType = null;
if (transportationDevice.ChargingDistanceAmount > 0 && transportationDevice.ChargingLoadType != null)
{
distanceToEnergyFactor = DistanceToPowerFactor(transportationDevice.ChargingDistanceAmount, transportationDevice.ChargingEnergyAmount, transportationDevice.ChargingLoadType.ConversionFaktorPowerToSum);
chargingLoadType = _loadTypeDict.Ltdtodict[transportationDevice.ChargingLoadType];
}
if (transportationDevice.TransportationDeviceCategory == null)
{
throw new LPGException("Transportation device category was null");
}
CalcTransportationDeviceDto cd = new CalcTransportationDeviceDto(transportationDevice.Name,
transportationDevice.IntID, categoriesDict[transportationDevice.TransportationDeviceCategory],
transportationDevice.SpeedInMPerSecond, loads, key, transportationDevice.TotalRangeInMeters,
distanceToEnergyFactor, transportationDevice.ChargingPower, chargingLoadType?.Name, chargingLoadType?.Guid, Guid.NewGuid().ToStrGuid(),
transportationDevice.TransportationDeviceCategory.IsLimitedToSingleLocation);
transportationDeviceDtos.Add(cd);
}
return(transportationDeviceDtos);
}
public void CompleteAffordanceCreatorTest()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Simulator sim = new Simulator(db.ConnectionString);
VLoadType lt = sim.LoadTypes[0];
DeviceCategory dc = sim.DeviceCategories[1];
TimeBasedProfile tp = sim.Timeprofiles[1];
Location loc = sim.Locations[0];
TraitTag tag = sim.TraitTags[0];
TimeLimit timeLimit = sim.TimeLimits[0];
CompleteAffordanceAdd.CreateItems(sim, "aff", "Entertainment / desire", "device", "trait", lt, dc, tp, 1,
10, 1, 99, loc, tag, "traitclass", timeLimit, "affcategory", null, false, "newLocation");
SimIntegrityChecker.Run(sim);
db.Cleanup();
}
}
public EnergyStorage([NotNull] string pName, [CanBeNull] string description,
[CanBeNull] VLoadType loadType, double storageCapacity,
double initialFill, double minimumStorageRate, double maximumStorageRate,
double minimumWithdrawRate,
double maximumWithdrawRate, [NotNull] string connectionString, StrGuid guid, [CanBeNull] int?pID = null)
: base(pName, TableName, connectionString, guid)
{
ID = pID;
TypeDescription = "Energy Storage Device";
_description = description;
_loadType = loadType;
_storageCapacity = storageCapacity;
_initialFill = initialFill;
_minimumStorageRate = minimumStorageRate;
_maximumStorageRate = maximumStorageRate;
_minimumWithdrawRate = minimumWithdrawRate;
_maximumWithdrawRate = maximumWithdrawRate;
}
public HHTAutonomousDevice([CanBeNull] int?pID, [CanBeNull] IAssignableDevice device,
[CanBeNull] TimeBasedProfile timeprofile, int householdTraitID, decimal timeStandardDeviation,
[CanBeNull] VLoadType vLoadType, [CanBeNull] TimeLimit timeLimit, [NotNull] string connectionString, [NotNull] string name,
[CanBeNull] Location location, double variableValue, VariableCondition variableCondition,
[CanBeNull] Variable variable, StrGuid guid) : base(name, TableName, connectionString, guid)
{
TypeDescription = "Household Trait Autonomous Device";
ID = pID;
_device = device;
_timeprofile = timeprofile;
_householdTraitID = householdTraitID;
_timeStandardDeviation = timeStandardDeviation;
_vLoadType = vLoadType;
_timeLimit = timeLimit;
_location = location;
_variableValue = variableValue;
_variableCondition = variableCondition;
_variable = variable;
}
public void CalculateMaximumInternalTimeResolutionTestForDeviceAction()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
Config.IsInUnitTesting = true;
var col = new ColorRGB(255, 0, 0);
var devices = new ObservableCollection <RealDevice>();
var rd2 = new RealDevice("rd2", 1, string.Empty, null, string.Empty, false, false, db.ConnectionString, Guid.NewGuid().ToStrGuid());
rd2.SaveToDB();
devices.Add(rd2);
var deviceCategories = new ObservableCollection <DeviceCategory>();
var aff = new Affordance("bla", null, null, false, PermittedGender.All, 1, col, string.Empty, null,
string.Empty,
db.ConnectionString, true, true, 0, 100,
false, ActionAfterInterruption.GoBackToOld, false, Guid.NewGuid().ToStrGuid(), BodilyActivityLevel.Low);
aff.SaveToDB();
var tp = new TimeBasedProfile("tp", null, db.ConnectionString, TimeProfileType.Relative, "fake", Guid.NewGuid().ToStrGuid());
tp.SaveToDB();
tp.AddNewTimepoint(new TimeSpan(0, 0, 0), 1, false);
tp.AddNewTimepoint(new TimeSpan(0, 1, 0), 1, false);
tp.AddNewTimepoint(new TimeSpan(0, 10, 0), 1, false);
var lt = new VLoadType("lt", string.Empty, "bla", "blub", 1, 1, new TimeSpan(0, 1, 0), 1,
db.ConnectionString,
LoadTypePriority.Mandatory, true, Guid.NewGuid().ToStrGuid());
lt.SaveToDB();
var dag = new DeviceActionGroup("dag", db.ConnectionString, string.Empty, Guid.NewGuid().ToStrGuid());
dag.SaveToDB();
var da = new DeviceAction("da", null, string.Empty, db.ConnectionString, dag, rd2, Guid.NewGuid().ToStrGuid());
da.SaveToDB();
da.AddDeviceProfile(tp, 0, lt, 1);
new ObservableCollection <DeviceAction>().Add(da);
var tbp = new TimeBasedProfile("name", 1, db.ConnectionString, TimeProfileType.Absolute, "data source", Guid.NewGuid().ToStrGuid());
aff.AddDeviceProfile(da, tbp, 0, devices, deviceCategories, lt, 1);
var ts = aff.CalculateMaximumInternalTimeResolution();
(ts.TotalSeconds).Should().Be(60);
Logger.Info(ts.ToString());
db.Cleanup();
}
}
public TransformationDevice([NotNull] string pName,
[NotNull] string description,
[CanBeNull] VLoadType loadTypeIn,
double minValue,
double maxValue,
[NotNull] string connectionString,
double minimumInputPower,
double maximumInputPower,
StrGuid guid,
[CanBeNull] int?pID = null) : base(pName, TableName, connectionString, guid)
{
_minValue = minValue;
_maxValue = maxValue;
ID = pID;
TypeDescription = "Transformation Device";
_description = description;
_loadTypeIn = loadTypeIn;
_minimumInputPower = minimumInputPower;
_maximumInputPower = maximumInputPower;
}
public HouseTypeDevice([CanBeNull] int?pID, [CanBeNull] IAssignableDevice adev, [CanBeNull] TimeBasedProfile profile,
int houseID,
[CanBeNull] TimeLimit timeLimit, double timeStandardDeviation, [CanBeNull] VLoadType loadType,
[NotNull] string connectionString, [NotNull] string name,
[CanBeNull] Location loc, double variableValue, VariableCondition variableCondition,
[CanBeNull] Variable variable, StrGuid guid)
: base(name, TableName, connectionString, guid)
{
ID = pID;
_location = loc;
_device = adev;
_profile = profile;
HouseID = houseID;
TimeLimit = timeLimit;
_timeStandardDeviation = timeStandardDeviation;
_loadType = loadType;
_variableValue = variableValue;
TypeDescription = "House Type Device";
_variableCondition = variableCondition;
_variable = variable;
}
private void BtnAddLoad_Click([NotNull] object sender, [NotNull] RoutedEventArgs e)
{
string loadStr = TxtLoadValue.Text;
bool success = double.TryParse(loadStr, out double load);
if (!success)
{
Logger.Error("The maximum power was not a number.");
return;
}
VLoadType lt = (VLoadType)CmbLoadTypes.SelectedItem;
if (lt == null)
{
Logger.Error("No load type was selected. Please fix.");
return;
}
Presenter.ThisTransportationDevice.AddLoad(lt, load);
}
public void TransportationDeviceSetTest()
{
using (DatabaseSetup db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(TransportationDeviceSet.TableName);
db.ClearTable(TransportationDevice.TableName);
db.ClearTable(TransportationDeviceCategory.TableName);
TransportationDeviceSet tds =
new TransportationDeviceSet("transportationdeviceset", null, db.ConnectionString, "desc",
System.Guid.NewGuid().ToStrGuid());
tds.SaveToDB();
TransportationDeviceCategory tdc = new TransportationDeviceCategory("transportationdevicecategory",
null, db.ConnectionString, "desc", true, System.Guid.NewGuid().ToStrGuid());
tdc.SaveToDB();
VLoadType vlt = (VLoadType)VLoadType.CreateNewItem(null, db.ConnectionString);
vlt.SaveToDB();
TransportationDevice tdev = new TransportationDevice("mydevice", null, db.ConnectionString, "", 1, SpeedUnit.Kmh,
tdc, 1000, 10, 100, 100, vlt,
System.Guid.NewGuid().ToStrGuid());
tdev.SaveToDB();
ObservableCollection <TransportationDevice> transportationDevices = new ObservableCollection <TransportationDevice>
{
tdev
};
tds.AddDevice(tdev);
/*ObservableCollection<TransportationDeviceCategory> categories = new ObservableCollection<TransportationDeviceCategory>
* {
* tdc
* };*/
ObservableCollection <TransportationDeviceSet> result = new ObservableCollection <TransportationDeviceSet>();
TransportationDeviceSet.LoadFromDatabase(result, db.ConnectionString, false, transportationDevices);
db.Cleanup();
(result.Count).Should().Be(1);
(result[0].TransportationDeviceSetEntries.Count).Should().Be(1);
}
}
