//public override ICalcProfile CollectPersonProfile() => _personProfile;
public override List <CalcSubAffordance> CollectSubAffordances(TimeStep time,
bool onlyInterrupting,
CalcLocation srcLocation)
{
if (SubAffordances.Count == 0)
{
return(new List <CalcSubAffordance>());
}
if (RemainingActiveTime(time) < 1)
{
return(new List <CalcSubAffordance>());
}
// es gibt subaffs und diese aff ist aktiv
var result = new List <CalcSubAffordance>();
foreach (var calcSubAffordance in SubAffordances)
{
if (onlyInterrupting && calcSubAffordance.IsInterrupting || !onlyInterrupting)
{
var delaytimesteps = calcSubAffordance.Delaytimesteps;
var hasbeenactivefor = HasBeenActiveFor(time);
var issubaffbusy = calcSubAffordance.IsBusy(time, srcLocation, "name");
if (delaytimesteps < hasbeenactivefor && !issubaffbusy)
{
calcSubAffordance.SetDurations(RemainingActiveTime(time));
result.Add(calcSubAffordance);
}
}
}
return(result);
}
public override void Activate(TimeStep startTime, string activatorName, CalcLocation personSourceLocation,
out ICalcProfile personTimeProfile)
{
for (var i = 0; i < PersonProfileDuration && i + startTime.InternalStep < IsBusyArray.Length; i++)
{
IsBusyArray[i + startTime.InternalStep] = true;
}
foreach (var op in _variableOps)
{
// figure out end time
TimeStep time;
switch (op.ExecutionTime)
{
case VariableExecutionTime.Beginning:
time = startTime;
break;
case VariableExecutionTime.EndOfPerson:
case VariableExecutionTime.EndofDevices:
time = startTime.AddSteps(PersonProfileDuration);
break;
default:
throw new LPGException("Forgotten Variable Execution Time");
}
_repository.AddExecutionEntry(op.Name, op.Value, op.CalcLocation, op.VariableAction, time, op.VariableGuid);
}
personTimeProfile = new CalcSubAffTimeProfile(_durations,
_durations + " timesteps Person profile");
}
public void AddEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
var ee = new ExecutionEntry(name, value, location, variableAction,
timeStep, variableGuid);
_entries.Add(ee);
}
public override bool IsBusy(TimeStep time, CalcLocation srcLocation, string calcPersonName,
bool clearDictionaries = true)
{
if (IsBusyArray[time.InternalStep])
{
return(true);
}
return(false);
}
public CalcAffordanceVariableOp([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
VariableExecutionTime executionTime, StrGuid variableGuid)
{
Name = name;
Value = value;
CalcLocation = location;
VariableAction = variableAction;
ExecutionTime = executionTime;
VariableGuid = variableGuid;
}
public ExecutionEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
_variableGuid = variableGuid;
Name = name;
Value = value;
CalcLocation = location;
VariableAction = variableAction;
TimeStep = timeStep;
}
public CalcAutoDev([NotNull] CalcProfile pCalcProfile, [NotNull] CalcLoadType loadType,
[NotNull][ItemNotNull] List <CalcDeviceLoad> loads, double timeStandardDeviation,
double multiplier,
[NotNull] CalcLocation calclocation,
[NotNull][ItemNotNull] List <VariableRequirement> requirements, [NotNull] CalcDeviceDto autoDevDto, [NotNull] CalcRepo calcRepo)
: base(
loads, calclocation, autoDevDto, calcRepo)
{
_earliestNextStart = new TimeStep(-1, 0, true);
_calcProfile = pCalcProfile;
LoadType = loadType;
_timeStandardDeviation = timeStandardDeviation;
_multiplier = multiplier;
_calcLocation = calclocation;
if (requirements.Count > 0) // initialize the whole variable thing
{
_requirements.AddRange(requirements);
}
}
protected CalcAffordanceBase([NotNull] string pName, [NotNull] CalcLocation loc,
[NotNull][ItemNotNull] List <CalcDesire> satisfactionvalues,
int miniumAge, int maximumAge, PermittedGender permittedGender, bool needsLight,
bool randomEffect,
[NotNull] string pAffCategory, bool isInterruptable, bool isInterrupting,
ActionAfterInterruption actionAfterInterruption, int weight,
bool requireAllAffordances,
CalcAffordanceType calcAffordanceType,
StrGuid guid,
[ItemNotNull][NotNull] BitArray isBusyArray,
BodilyActivityLevel bodilyActivityLevel, [NotNull] CalcRepo calcRepo,
[CanBeNull] CalcSite site = null) : base(pName, guid)
{
CalcAffordanceType = calcAffordanceType;
BodilyActivityLevel = bodilyActivityLevel;
CalcRepo = calcRepo;
Site = site;
ParentLocation = loc;
Satisfactionvalues = satisfactionvalues;
_isBusyArray = new BitArray(calcRepo.CalcParameters.InternalTimesteps);
//copy to make sure that it is a separate instance
for (var i = 0; i < isBusyArray.Length; i++)
{
_isBusyArray[i] = isBusyArray[i];
}
Weight = weight;
RequireAllAffordances = requireAllAffordances;
MiniumAge = miniumAge;
MaximumAge = maximumAge;
PermittedGender = permittedGender;
NeedsLight = needsLight;
RandomEffect = randomEffect;
AffCategory = pAffCategory;
IsInterruptable = isInterruptable;
IsInterrupting = isInterrupting;
_actionAfterInterruption = actionAfterInterruption;
CalcAffordanceSerial = _calcAffordanceBaseSerialTracker;
#pragma warning disable S3010 // Static fields should not be updated in constructors
_calcAffordanceBaseSerialTracker++;
#pragma warning restore S3010 // Static fields should not be updated in constructors
}
public CalcSubAffordance([NotNull] string pName, [NotNull] CalcLocation loc, [NotNull][ItemNotNull] List <CalcDesire> satisfactionvalues,
int miniumAge, int maximumAge, int delaytimesteps, PermittedGender permittedGender, [NotNull] string pAffCategory,
bool isInterruptable, bool isInterrupting, [NotNull] CalcAffordance parentAffordance,
[NotNull][ItemNotNull] List <CalcAffordanceVariableOp> variableOps, int weight,
[NotNull] string sourceTrait,
StrGuid guid, [ItemNotNull][NotNull] BitArray isBusy,
[NotNull] CalcVariableRepository repository, BodilyActivityLevel bodilyActivityLevel, [NotNull] CalcRepo calcRepo)
: base(
pName, loc, satisfactionvalues, miniumAge, maximumAge, permittedGender, false, false, pAffCategory,
isInterruptable, isInterrupting, ActionAfterInterruption.GoBackToOld, weight, false,
CalcAffordanceType.Subaffordance, guid, isBusy, bodilyActivityLevel, calcRepo)
{
Delaytimesteps = delaytimesteps;
_variableOps = variableOps;
_repository = repository;
SubAffordances = new List <CalcSubAffordance>();
Energyprofiles = new List <CalcAffordance.DeviceEnergyProfileTuple>();
AffordanceColor = LPGColors.Black;
SourceTrait = sourceTrait;
TimeLimitName = null;
ParentAffordance = parentAffordance;
}
public CalcDevice([NotNull][ItemNotNull] List <CalcDeviceLoad> powerUsage,
[NotNull] CalcLocation calcLocation,
[NotNull] CalcDeviceDto calcDeviceDto,
[NotNull] CalcRepo calcRepo) : base(calcDeviceDto.Name, calcDeviceDto.Guid)
{
_calcDeviceDto = calcDeviceDto;
_calcRepo = calcRepo;
if (_calcDeviceDto.LocationGuid != calcLocation.Guid)
{
throw new LPGException("Inconsistent locations. This is a bug.");
}
_calcLocation = calcLocation;
foreach (var load in powerUsage)
{
_deviceLoadsBy.Add(load.LoadType, load);
Loads.Add(load);
}
/*foreach (var load in powerUsage) {
* if (Math.Abs(load.Value) < 0.0000001 && load.Name.ToLower(CultureInfo.InvariantCulture) != "none") {
* throw new LPGException("Trying to run the device " + calcDeviceDto.Name + " with a power load factor for " + load.LoadType.Name + " of 0. This is not going to work.");
* }
* }*/
if (calcRepo.CalcParameters.InternalTimesteps == 0)
{
throw new LPGException("Can't run with 0 timesteps");
}
_isBusyForLoadType = new Dictionary <CalcLoadType, BitArray>();
foreach (var calcDeviceLoad in powerUsage)
{
_isBusyForLoadType.Add(calcDeviceLoad.LoadType,
new BitArray(calcRepo.CalcParameters.InternalTimesteps));
_isBusyForLoadType[calcDeviceLoad.LoadType].SetAll(false);
//var key = new OefcKey(calcDeviceDto.HouseholdKey, calcDeviceDto.DeviceType,calcDeviceDto.Guid, calcDeviceDto.LocationGuid,calcDeviceLoad.LoadType.Guid, calcDeviceDto.DeviceCategoryName);
var key = calcRepo.Odap.RegisterDevice(calcDeviceLoad.LoadType.ConvertToDto(), calcDeviceDto);
_keyByLoad.Add(calcDeviceLoad.LoadType, key);
}
}
public override void Activate(TimeStep startTime,
string activatorName,
CalcLocation personSourceLocation,
out ICalcProfile personTimeProfile)
{
TimeStep timeLastDeviceEnds = startTime.GetAbsoluteStep(0);
foreach (var dpt in Energyprofiles)
{
if (dpt.Probability > _probabilitiesForTimes[startTime.InternalStep])
{
//_calcDevice.SetTimeprofile(tbp, startidx + TimeOffsetInSteps, loadType, timeFactor, affordancename,activatorName, _multiplier);
CalcProfile adjustedProfile = dpt.TimeProfile.CompressExpandDoubleArray(_timeFactorsForTimes[startTime.InternalStep]);
var endtime = dpt.CalcDevice.SetTimeprofile(adjustedProfile,
startTime.AddSteps(dpt.TimeOffsetInSteps),
dpt.LoadType,
Name,
activatorName,
dpt.Multiplier,
false);
if (endtime > timeLastDeviceEnds)
{
timeLastDeviceEnds = endtime;
}
}
}
var personsteps = CalcProfile.GetNewLengthAfterCompressExpand(_personProfile.StepValues.Count,
_timeFactorsForTimes[startTime.InternalStep]);
_startTimeStep = startTime;
_endTimeStep = startTime.AddSteps(personsteps);
if (DoubleCheckBusyArray)
{
for (var i = 0; i < personsteps && i + startTime.InternalStep < CalcRepo.CalcParameters.InternalTimesteps; i++)
{
if (IsBusyArray[i + startTime.InternalStep])
{
throw new LPGException("Affordance was already busy");
}
}
}
for (var i = 0; i < personsteps && i + startTime.InternalStep < CalcRepo.CalcParameters.InternalTimesteps; i++)
{
IsBusyArray[i + startTime.InternalStep] = true;
}
if (_variableOps.Count > 0)
{
foreach (var op in _variableOps)
{
// figure out end time
TimeStep time;
switch (op.ExecutionTime)
{
case VariableExecutionTime.Beginning:
time = startTime;
break;
case VariableExecutionTime.EndOfPerson:
time = _endTimeStep;
break;
case VariableExecutionTime.EndofDevices:
time = timeLastDeviceEnds;
break;
default:
throw new LPGException("Forgotten Variable Execution Time");
}
_variableRepository.AddExecutionEntry(op.Name, op.Value, op.CalcLocation,
op.VariableAction, time, op.VariableGuid);
_variableRepository.Execute(startTime);
}
}
double tf = _timeFactorsForTimes[startTime.InternalStep];
_probabilitiesForTimes.Clear();
_timeFactorsForTimes.Clear();
personTimeProfile = _personProfile.CompressExpandDoubleArray(tf);
//return tf ;
}
//private static VacationAffordance _vacationAffordance;
/* public VacationAffordance Get()
* {
* if (_vacationAffordance == null) {
* _vacationAffordance = new VacationAffordance(_calcParameters);
* }
* return _vacationAffordance;
* }*/
public override void Activate(TimeStep startTime, string activatorName,
CalcLocation personSourceLocation,
out ICalcProfile personTimeProfile) =>
throw new LPGException("This function should never be called");
public override List <CalcSubAffordance> CollectSubAffordances(TimeStep time,
bool onlyInterrupting,
CalcLocation srcLocation) => throw new NotImplementedException();
public override List <CalcSubAffordance> CollectSubAffordances(TimeStep time,
bool onlyInterrupting,
CalcLocation srcLocation) =>
new List <CalcSubAffordance>();
//public override ICalcProfile CollectPersonProfile() => throw new LPGException("This function should never be called");
public override bool IsBusy(TimeStep time,
CalcLocation srcLocation, string calcPersonName,
bool clearDictionaries = true) =>
throw new LPGException("This function should never be called");
public void AddExecutionEntry([NotNull] string name, double value, [NotNull] CalcLocation location, VariableAction variableAction,
[NotNull] TimeStep timeStep, StrGuid variableGuid)
{
_variableOperator.AddEntry(name, value, location, variableAction,
timeStep, variableGuid);
}
public CalcAffordance([NotNull] string pName,
[NotNull] CalcProfile personProfile,
[NotNull] CalcLocation loc,
bool randomEffect,
[NotNull][ItemNotNull] List <CalcDesire> satisfactionvalues,
int miniumAge,
int maximumAge,
PermittedGender permittedGender,
bool needsLight,
double timeStandardDeviation,
ColorRGB affordanceColor,
[NotNull] string pAffCategory,
bool isInterruptable,
bool isInterrupting,
[NotNull][ItemNotNull] List <CalcAffordanceVariableOp> variableOps,
[NotNull][ItemNotNull] List <VariableRequirement> variableRequirements,
ActionAfterInterruption actionAfterInterruption,
[NotNull] string timeLimitName,
int weight,
bool requireAllDesires,
[NotNull] string srcTrait,
StrGuid guid,
[NotNull] CalcVariableRepository variableRepository,
[NotNull][ItemNotNull] List <DeviceEnergyProfileTuple> energyprofiles,
[ItemNotNull][NotNull] BitArray isBusy, BodilyActivityLevel bodilyActivityLevel,
[NotNull] CalcRepo calcRepo) : base(pName,
loc,
satisfactionvalues,
miniumAge,
maximumAge,
permittedGender,
needsLight,
randomEffect,
pAffCategory,
isInterruptable,
isInterrupting,
actionAfterInterruption,
weight,
requireAllDesires,
CalcAffordanceType.Affordance,
guid,
isBusy, bodilyActivityLevel, calcRepo)
{
_variableOps = variableOps;
_variableRequirements = variableRequirements;
_variableRepository = variableRepository;
Energyprofiles = energyprofiles;
SourceTrait = srcTrait;
if (personProfile == null)
{
#pragma warning disable IDE0016 // Use 'throw' expression
throw new DataIntegrityException("The affordance " + Name + " has no person profile!");
#pragma warning restore IDE0016 // Use 'throw' expression
}
_timeStandardDeviation = timeStandardDeviation;
SubAffordances = new List <CalcSubAffordance>();
_personProfile = personProfile;
AffordanceColor = affordanceColor;
TimeLimitName = timeLimitName;
}
public override bool IsBusy(TimeStep time,
CalcLocation srcLocation,
string calcPersonName,
bool clearDictionaries = true)
{
if (!_timeFactorsForTimes.ContainsKey(time.InternalStep))
{
if (clearDictionaries)
{
// _timeFactorsForTimes.Clear();
}
_timeFactorsForTimes[time.InternalStep] = CalcRepo.NormalRandom.NextDouble(1, _timeStandardDeviation);
if (_timeFactorsForTimes[time.InternalStep] < 0)
{
throw new DataIntegrityException("The duration standard deviation on " + Name + " is too large: a negative value of " +
_timeFactorsForTimes[time.InternalStep] + " came up. The standard deviation is " +
_timeStandardDeviation);
}
}
if (!_probabilitiesForTimes.ContainsKey(time.InternalStep))
{
if (clearDictionaries)
{
// _probabilitiesForTimes.Clear();
}
_probabilitiesForTimes[time.InternalStep] = CalcRepo.Rnd.NextDouble();
}
if (_variableRequirements.Count > 0)
{
foreach (var requirement in _variableRequirements)
{
if (!requirement.IsMet())
{
return(true); // return is busy right now and not available.
}
}
}
if (time.InternalStep >= IsBusyArray.Length)
{
return(false);
}
if (IsBusyArray[time.InternalStep])
{
return(true);
}
foreach (var dpt in Energyprofiles)
{
if (dpt.Probability > _probabilitiesForTimes[time.InternalStep])
{
if (dpt.CalcDevice.IsBusyDuringTimespan(time.AddSteps(dpt.TimeOffsetInSteps),
dpt.TimeProfile.StepValues.Count,
_timeFactorsForTimes[time.InternalStep],
dpt.LoadType))
{
return(true);
}
}
}
return(false);
}
public abstract void Activate(TimeStep startTime, string activatorName,
CalcLocation personSourceLocation,
out ICalcProfile personTimeProfile);
public abstract List <CalcSubAffordance> CollectSubAffordances(TimeStep time,
bool onlyInterrupting,
CalcLocation srcLocation);
public abstract bool IsBusy(TimeStep time,
CalcLocation srcLocation, string calcPersonName,
bool clearDictionaries = true);