private void MakeTransportationDevice([NotNull] CalcHousehold chh,
[NotNull][ItemNotNull]
List <CalcTransportationDeviceDto> transportationDevices)
{
foreach (var transportationDevice in transportationDevices)
{
var loads = new List <CalcDeviceLoad>();
foreach (var load in transportationDevice.Loads)
{
CalcLoadType clt = _loadTypeDict.GetLoadtypeByGuid(load.LoadTypeGuid);
loads.Add(new CalcDeviceLoad(load.Name, load.MaxPower, clt, 0, 0));
}
double distanceToEnergyFactor = transportationDevice.EnergyToDistanceFactor;
CalcLoadType chargingLoadType = null;
if (transportationDevice.ChargingCalcLoadTypeGuid.HasValue)
{
chargingLoadType = _loadTypeDict.GetLoadtypeByGuid(transportationDevice.ChargingCalcLoadTypeGuid.Value);
}
if (chh.TransportationHandler == null)
{
throw new LPGException("no transportation handler");
}
CalcDeviceDto cdd = new CalcDeviceDto(transportationDevice.Name,
transportationDevice.Category.Guid,
chh.HouseholdKey,
OefcDeviceType.Transportation, transportationDevice.Category.Name,
string.Empty, transportationDevice.Guid, StrGuid.Empty, string.Empty);
var category = chh.TransportationHandler.GetCategory(transportationDevice.Category);
CalcTransportationDevice cd = new CalcTransportationDevice(
category,
transportationDevice.AverageSpeedInMPerS, loads,
transportationDevice.FullRangeInMeters,
distanceToEnergyFactor, transportationDevice.MaxChargingPower, chargingLoadType,
chh.TransportationHandler.CalcSites,
cdd, _calcRepo);
if (category.IsLimitedToSingleLocation)
{
chh.TransportationHandler.AddVehicleDepotDevice(cd);
}
else
{
chh.TransportationHandler.LocationUnlimitedDevices.Add(cd);
}
}
}
private List <CalcSite> MakeCalcSites([NotNull] CalcHouseholdDto household, [NotNull]
DtoCalcLocationDict locDict, [NotNull] CalcLoadTypeDictionary ltDict,
[NotNull] TransportationHandler th
)
{
List <CalcSite> sites = new List <CalcSite>();
//Dictionary<string, CalcSite> siteDictByGuid = new Dictionary<string, CalcSite>();
if (household.CalcSites == null)
{
throw new LPGException("CalcSites was null"); //for the bug in the null checking
}
foreach (var siteDto in household.CalcSites)
{
var calcSite = new CalcSite(siteDto.Name, siteDto.Guid, household.HouseholdKey);
sites.Add(calcSite);
//siteDictByGuid.Add(siteDto.Guid, calcSite);
foreach (var locGuid in siteDto.LocationGuid)
{
CalcLocation calcLoc = locDict.GetCalcLocationByGuid(locGuid);
calcLoc.CalcSite = calcSite;
calcSite.Locations.Add(calcLoc);
}
foreach (var chargingStation in siteDto.ChargingStations)
{
var gridLt = ltDict.GetLoadtypeByGuid(chargingStation.GridChargingLoadType.Guid);
var carLt = ltDict.GetLoadtypeByGuid(chargingStation.CarChargingLoadType.Guid);
var cat = th.GetCategory(chargingStation.DeviceCategory);
calcSite.AddChargingStation(gridLt, cat, chargingStation.MaxChargingPower,
carLt, _calcRepo);
}
}
return(sites);
}
private void MakeAllTransformationDevices([NotNull] CalcHouseDto house,
[NotNull] CalcHouse calchouse,
[NotNull] HouseholdKey householdKey) //List<CalcDeviceTaggingSet> taggingSets,
{
var ctds = new List <CalcTransformationDevice>();
var devcategoryGuid = Guid.NewGuid().ToStrGuid();
var trafolocGuid = Guid.NewGuid().ToStrGuid();
foreach (var trafo in house.TransformationDevices)
{
foreach (var set in _calcDeviceTaggingSets.AllCalcDeviceTaggingSets)
{
set.AddTag(trafo.Name, "House Device");
}
CalcDeviceDto cdd = new CalcDeviceDto(trafo.Name, devcategoryGuid, householdKey,
OefcDeviceType.Transformation, "Transformation Devices", "", trafo.Guid, trafolocGuid, "Transformation Devices");
var ctd = new CalcTransformationDevice(_calcRepo.Odap,
trafo.MinValue,
trafo.MaxValue,
trafo.MinPower,
trafo.MaxPower,
cdd, _ltDict.GetLoadtypeByGuid(trafo.InputLoadType.Guid));
foreach (var outlt in trafo.OutputLoadTypes)
{
ctd.AddOutputLoadType(_ltDict.GetLoadtypeByGuid(outlt.LoadType.Guid), outlt.ValueScalingFactor, outlt.FactorType);
}
if (ctd.OutputLoadTypes.Count > 0)
{
if (trafo.Datapoints != null)
{
foreach (var datapoint in trafo.Datapoints)
{
ctd.AddDatapoint(datapoint.Ref, datapoint.Val);
}
}
foreach (var condition in trafo.Conditions)
{
var variable = _variableRepository.GetVariableByGuid(condition.CalcVariableDto.Guid);
ctd.AddCondition(condition.Name, variable, condition.MinValue, condition.MaxValue, condition.Guid);
}
ctds.Add(ctd);
}
}
calchouse.SetTransformationDevices(ctds);
}
private List <CalcAffordance.DeviceEnergyProfileTuple> MakeDeviceEnergyProfileTuples([ItemNotNull][NotNull] List <CalcDevice> devices,
[NotNull] CalcAffordanceDto affordancedto)
{
List <CalcAffordance.DeviceEnergyProfileTuple> deviceEnergyProfiles =
new List <CalcAffordance.DeviceEnergyProfileTuple>();
foreach (DeviceEnergyProfileTupleDto dto in affordancedto.Energyprofiles)
{
StrGuid devguid = dto.CalcDeviceGuid;
CalcDevice device = devices.Single(x => x.Guid == devguid);
CalcProfile cp = CalcDeviceFactory.MakeCalcProfile(dto.TimeProfile, _calcRepo.CalcParameters);
CalcLoadType clt = _loadTypeDictionary.GetLoadtypeByGuid(dto.CalcLoadTypeGuid);
CalcAffordance.DeviceEnergyProfileTuple dep = new CalcAffordance.DeviceEnergyProfileTuple(device,
cp, clt, dto.TimeOffset, _calcRepo.CalcParameters.InternalStepsize, dto.Multiplier, dto.Probability);
deviceEnergyProfiles.Add(dep);
}
return(deviceEnergyProfiles);
}
public static List <CalcDeviceLoad> MakeCalcDeviceLoads([NotNull] CalcDeviceDto device,
[NotNull] CalcLoadTypeDictionary calcLoadTypeDictionary)
{
var deviceLoads = new List <CalcDeviceLoad>();
foreach (var ltdto in device.Loads)
{
if (calcLoadTypeDictionary.SimulateLoadtype(ltdto.LoadTypeGuid))
{
var lt = calcLoadTypeDictionary.GetLoadtypeByGuid(ltdto.LoadTypeGuid);
var cdl = new CalcDeviceLoad(ltdto.Name,
ltdto.MaxPower, lt,
ltdto.AverageYearlyConsumption, ltdto.PowerStandardDeviation);
deviceLoads.Add(cdl);
}
}
return(deviceLoads);
}
public List <CalcAutoDev> MakeCalcAutoDevs(
[NotNull][ItemNotNull] List <CalcAutoDevDto> autoDevices,
[NotNull] DtoCalcLocationDict locationDict)
{
var autodevs = new List <CalcAutoDev>(autoDevices.Count);
foreach (var autoDevDto in autoDevices)
{
if (_loadTypeDictionary.SimulateLoadtype(autoDevDto.LoadtypeGuid))
{
var deviceLoads = MakeCalcDeviceLoads(autoDevDto, _loadTypeDictionary);
CalcProfile cp = MakeCalcProfile(autoDevDto.CalcProfile, _calcRepo.CalcParameters);
var loadtype = _loadTypeDictionary.GetLoadtypeByGuid(autoDevDto.LoadtypeGuid);
CalcLocation calcLocation = locationDict.GetCalcLocationByGuid(autoDevDto.CalcLocationGuid);
List <VariableRequirement> requirements = new List <VariableRequirement>();
foreach (var req in autoDevDto.Requirements)
{
VariableRequirement vreq = new VariableRequirement(req.Name,
req.Value, req.CalcLocationName, req.LocationGuid,
req.VariableCondition, _calcVariableRepository, req.VariableGuid);
requirements.Add(vreq);
}
autoDevDto.AdditionalName = " (autonomous)";
var cautodev = new CalcAutoDev(cp, loadtype,
deviceLoads, autoDevDto.TimeStandardDeviation,
1, calcLocation,
requirements, autoDevDto, _calcRepo);
var busyarr = _availabilityDtoRepository.GetByGuid(autoDevDto.BusyArr.Guid);
cautodev.ApplyBitArry(busyarr, loadtype);
autodevs.Add(cautodev);
}
}
return(autodevs);
}