public void SetAllAffordaces([NotNull][ItemNotNull] List <CalcAffordanceDto> affordances,
[NotNull] DtoCalcLocationDict locations,
[NotNull] CalcVariableRepository variableRepository,
[ItemNotNull][NotNull] List <CalcDevice> devices)
{
if (affordances.Count == 0)
{
throw new LPGException("No Affordances found.");
}
foreach (CalcAffordanceDto affordancedto in affordances)
{
CalcProfile personProfile = CalcDeviceFactory.MakeCalcProfile(affordancedto.PersonProfile, _calcRepo.CalcParameters);
CalcLocation calcLocation = locations.GetCalcLocationByGuid(affordancedto.CalcLocationGuid);
var calcDesires = MakeCalcDesires(affordancedto.Satisfactionvalues);
var color = new ColorRGB(affordancedto.ColorR, affordancedto.ColorG, affordancedto.ColorB);
var variableOps = MakeVariableOps(locations, affordancedto.VariableOps, variableRepository);
List <VariableRequirement> requirements = new List <VariableRequirement>();
foreach (VariableRequirementDto requirementDto in affordancedto.VariableRequirements)
{
VariableRequirement vrq = new VariableRequirement(requirementDto.Name,
requirementDto.Value, requirementDto.CalcLocationName, requirementDto.LocationGuid,
requirementDto.VariableCondition, variableRepository, requirementDto.VariableGuid);
requirements.Add(vrq);
}
var deviceEnergyProfiles = MakeDeviceEnergyProfileTuples(devices, affordancedto);
var busyarr = _availabilityDtoRepository.GetByGuid(affordancedto.IsBusyArray.Guid);
CalcAffordance caff = new CalcAffordance(
affordancedto.Name,
personProfile, calcLocation,
affordancedto.RandomEffect,
calcDesires,
affordancedto.MiniumAge,
affordancedto.MaximumAge,
affordancedto.PermittedGender,
affordancedto.NeedsLight,
affordancedto.TimeStandardDeviation,
color,
affordancedto.AffCategory,
affordancedto.IsInterruptable,
affordancedto.IsInterrupting,
variableOps,
requirements,
affordancedto.ActionAfterInterruption,
affordancedto.TimeLimitName,
affordancedto.Weight,
affordancedto.RequireAllDesires,
affordancedto.SrcTrait,
affordancedto.Guid,
variableRepository, deviceEnergyProfiles,
busyarr, affordancedto.BodilyActivityLevel, _calcRepo);
MakeSubAffordances(locations, variableRepository, affordancedto, caff);
calcLocation.AddAffordance(caff);
}
}
private List <CalcAutoDev> MakeCalcAutoDevsFromHouse([NotNull] CalcHouseDto house,
[NotNull][ItemNotNull] List <CalcLocation> houseLocations)
{
var autodevs = new List <CalcAutoDev>(house.AutoDevs.Count);
// zur kategorien zuordnung
foreach (var hhautodev in house.AutoDevs)
{
CalcProfile calcProfile = CalcDeviceFactory.MakeCalcProfile(hhautodev.CalcProfile, _calcRepo.CalcParameters);
CalcLoadType clt = _ltDict.GetLoadtypeByGuid(hhautodev.LoadtypeGuid);
List <CalcDeviceLoad> loads = new List <CalcDeviceLoad>();
foreach (CalcDeviceLoadDto loadDto in hhautodev.Loads)
{
CalcDeviceLoad load = new CalcDeviceLoad(loadDto.Name,
loadDto.MaxPower,
_ltDict.GetLoadtypeByGuid(loadDto.LoadTypeGuid),
loadDto.AverageYearlyConsumption,
loadDto.PowerStandardDeviation);
loads.Add(load);
}
List <VariableRequirement> requirements = new List <VariableRequirement>();
foreach (var reqDto in hhautodev.Requirements)
{
VariableRequirement rq = new VariableRequirement(reqDto.Name,
reqDto.Value,
reqDto.CalcLocationName,
reqDto.LocationGuid,
reqDto.VariableCondition,
_variableRepository,
reqDto.VariableGuid);
requirements.Add(rq);
}
CalcLocation houseLocation = houseLocations.Single(x => x.Guid == hhautodev.CalcLocationGuid);
var cautodev = new CalcAutoDev(
calcProfile,
clt,
loads,
hhautodev.TimeStandardDeviation,
hhautodev.Multiplier,
houseLocation,
requirements, hhautodev, _calcRepo);
var busyarr = _availabilityDtoRepository.GetByGuid(hhautodev.BusyArr.Guid);
cautodev.ApplyBitArry(busyarr, _ltDict.GetLoadtypeByGuid(hhautodev.LoadtypeGuid));
autodevs.Add(cautodev);
}
return(autodevs);
}
//private readonly CalcVariableDtoFactory _variableDtoFactory;
public CalcModularHouseholdFactory([NotNull] CalcLoadTypeDictionary ltDict,
[NotNull] CalcLocationFactory clf,
[NotNull] CalcPersonFactory cpf,
[NotNull] CalcDeviceFactory cdf,
[NotNull] CalcAffordanceFactory caf,
[NotNull] CalcTransportationFactory ctf,
[NotNull] CalcVariableRepository variableRepository,
CalcRepo calcRepo
)
{
_ltDict = ltDict;
_clf = clf;
_cpf = cpf;
_cdf = cdf;
_caf = caf;
_ctf = ctf;
_calcVariableRepository = variableRepository;
_calcRepo = calcRepo;
}
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 List <CalcLocation> MakeCalcLocations([NotNull][ItemNotNull] List <CalcLocationDto> locations,
[NotNull] DtoCalcLocationDict locdict, CalcRepo calcRepo)
{
var locs = new List <CalcLocation>();
foreach (var t in locations)
{
// loc anlegen
var cloc = new CalcLocation(t.Name, t.Guid);
foreach (var locdev in t.LightDevices)
{
var deviceLoads = CalcDeviceFactory.MakeCalcDeviceLoads(locdev, _calcLoadTypeDict);
var deviceName = CalcAffordanceFactory.FixAffordanceName(locdev.Name, _calcRepo.CalcParameters.CSVCharacter);
locdev.Name = deviceName;
var clightdevice = new CalcDevice(deviceLoads,
cloc, locdev, calcRepo);
cloc.AddLightDevice(clightdevice);
}
//deviceLocationDict.Add(cloc, new List<IAssignableDevice>());
locs.Add(cloc);
locdict.LocationDtoDict.Add(t, cloc);
}
return(locs);
}
