/*
* [JetBrains.Annotations.NotNull]
* private Dictionary<HouseholdKey, Dictionary<CalcLoadTypeDto, Dictionary<string, Dictionary<string, double>>>>
* _energyUseListByHouseholdAffordancePersonAndLoadtype;
*
* [JetBrains.Annotations.NotNull]
* private readonly Dictionary<HouseholdKey, Dictionary<CalcLoadTypeDto, Dictionary<string, List<double>>>>
* _energyUseListByHouseholdAffordanceAndLoadtype;
*
* [JetBrains.Annotations.NotNull]
* public Dictionary<HouseholdKey, Dictionary<CalcLoadTypeDto, Dictionary<string, double>>> EnergyUseByHouseholdAffordanceAndLoadtype { get; }
*/
/*
* public void RegisterDeviceActivation([JetBrains.Annotations.NotNull] HouseholdKey householdKey, [JetBrains.Annotations.NotNull] string affordanceName,
* [JetBrains.Annotations.NotNull] CalcLoadTypeDto loadType, double value,
* [JetBrains.Annotations.NotNull] double[] allvalues, [JetBrains.Annotations.NotNull] string activatorName)
* {
*
* if (!EnergyUseByHouseholdAffordanceAndLoadtype.ContainsKey(householdKey)) {
* EnergyUseByHouseholdAffordanceAndLoadtype.Add(householdKey,
* new Dictionary<CalcLoadTypeDto, Dictionary<string, double>>());
* _energyUseListByHouseholdAffordanceAndLoadtype.Add(householdKey,
* new Dictionary<CalcLoadTypeDto, Dictionary<string, List<double>>>());
* _energyUseListByHouseholdAffordancePersonAndLoadtype.Add(householdKey,
* new Dictionary<CalcLoadTypeDto, Dictionary<string, Dictionary<string, double>>>());
* }
*
* if (!EnergyUseByHouseholdAffordanceAndLoadtype[householdKey].ContainsKey(loadType)) {
* EnergyUseByHouseholdAffordanceAndLoadtype[householdKey].Add(loadType, new Dictionary<string, double>());
* _energyUseListByHouseholdAffordanceAndLoadtype[householdKey]
* .Add(loadType, new Dictionary<string, List<double>>());
* _energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey]
* .Add(loadType, new Dictionary<string, Dictionary<string, double>>());
* }
*
* if (!_energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey][loadType]
* .ContainsKey(affordanceName)) {
* _energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey][loadType]
* .Add(affordanceName, new Dictionary<string, double>());
* }
*
* if (!_energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey][loadType][affordanceName]
* .ContainsKey(activatorName)) {
* _energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey][loadType][affordanceName]
* .Add(activatorName, 0);
* }
*
* if (!EnergyUseByHouseholdAffordanceAndLoadtype[householdKey][loadType].ContainsKey(affordanceName)) {
* EnergyUseByHouseholdAffordanceAndLoadtype[householdKey][loadType].Add(affordanceName, 0);
* _energyUseListByHouseholdAffordanceAndLoadtype[householdKey][loadType]
* .Add(affordanceName, new List<double>());
* }
*
* EnergyUseByHouseholdAffordanceAndLoadtype[householdKey][loadType][affordanceName] += value;
*
* _energyUseListByHouseholdAffordanceAndLoadtype[householdKey][loadType][affordanceName].AddRange(allvalues);
* _energyUseListByHouseholdAffordancePersonAndLoadtype[householdKey][loadType][affordanceName][activatorName]
+=
* value;
* if (_energyUseListByHouseholdAffordanceAndLoadtype[householdKey][loadType][affordanceName].Count >
* _maxTime) {
* _maxTime = _energyUseListByHouseholdAffordanceAndLoadtype[householdKey][loadType][affordanceName].Count;
* }
* }*/
/*
* public void WriteResults([JetBrains.Annotations.NotNull] List<CalcAffordanceTaggingSetDto> affTaggingSets)
* {
* if (_wroteResultsAlready)
* {
* return;
* }
*
* foreach (var householdDict in
* EnergyUseByHouseholdAffordanceAndLoadtype)
* {
* foreach (var loadTypeDict in householdDict.Value)
* {
* using (var sw =
* _fft.MakeFile<StreamWriter>(
* "AffordanceEnergyUse." + householdDict.Key + "." + loadTypeDict.Key.FileName + ".csv",
* "Energy use per affordance " + loadTypeDict.Key.Name, true,
* ResultFileID.AffordanceEnergyUse,
* householdDict.Key, TargetDirectory.Reports, _calcParameters.InternalStepsize,
* loadTypeDict.Key.ConvertToLoadTypeInformation()))
* {
* var header = "Affordance" + _calcParameters.CSVCharacter + "Energy use [" +
* loadTypeDict.Key.UnitOfSum + "]" + _calcParameters.CSVCharacter;
* foreach (var set in affTaggingSets)
* {
* if (set.LoadTypes.Contains(loadTypeDict.Key))
* {
* header += set.Name + _calcParameters.CSVCharacter;
* }
* }
*
* sw.WriteLine(header);
* foreach (var affordanceTuple in loadTypeDict.Value)
* {
* var sb = new StringBuilder();
* sb.Append(affordanceTuple.Key);
* sb.Append(_calcParameters.CSVCharacter);
* sb.Append(affordanceTuple.Value * loadTypeDict.Key.ConversionFactor);
* foreach (var set in affTaggingSets)
* {
* if (set.LoadTypes.Contains(loadTypeDict.Key))
* {
* sb.Append(_calcParameters.CSVCharacter);
* if (set.AffordanceToTagDict.ContainsKey(affordanceTuple.Key))
* {
* sb.Append(set.AffordanceToTagDict[affordanceTuple.Key]);
* }
* else
* {
* sb.Append(affordanceTuple.Key);
* }
* }
* }
*
* sw.WriteLine(sb);
* }
* }
* }
* }
*
* foreach (
* var
* householdDict in _energyUseListByHouseholdAffordancePersonAndLoadtype)
* {
* foreach (var loadTypeDict in
* householdDict.Value)
* {
* using (var sw =
* _fft.MakeFile<StreamWriter>(
* "AffordanceEnergyUsePerPerson." + householdDict.Key + "." + loadTypeDict.Key.FileName +
* ".csv", "Energy use per affordance per Person for " + loadTypeDict.Key.Name, true,
* ResultFileID.AffordancePersonEnergyUse, householdDict.Key,
* TargetDirectory.Reports, _calcParameters.InternalStepsize,
* loadTypeDict.Key.ConvertToLoadTypeInformation()))
* {
* sw.WriteLine("Energy use per affordance per Person in [" + loadTypeDict.Key.UnitOfSum + "]");
* var header = "Affordance" + _calcParameters.CSVCharacter;
* var persons = new List<string>();
*
* foreach (var affDict in loadTypeDict.Value)
* {
* foreach (var person in affDict.Value)
* {
* if (!persons.Contains(person.Key))
* {
* persons.Add(person.Key);
* }
* }
* }
*
* foreach (var person in persons)
* {
* header += person + _calcParameters.CSVCharacter;
* }
*
* sw.WriteLine(header);
*
* foreach (var affdict in loadTypeDict.Value)
* {
* var line = affdict.Key + _calcParameters.CSVCharacter;
*
* foreach (var person in persons)
* {
* if (affdict.Value.ContainsKey(person))
* {
* line += affdict.Value[person] * loadTypeDict.Key.ConversionFactor +
* _calcParameters.CSVCharacter;
* }
* else
* {
* line += 0 + _calcParameters.CSVCharacter;
* }
* }
*
* sw.WriteLine(line);
* }
* }
* }
* }
*
* _wroteResultsAlready = true;
* }*/
protected override void PerformActualStep(IStepParameters parameters)
{
HouseholdLoadtypeStepParameters hsp = (HouseholdLoadtypeStepParameters)parameters;
if (hsp.Key.HHKey == Constants.GeneralHouseholdKey || hsp.Key.HHKey == Constants.HouseKey)
{
return;
}
var deviceActivations = Repository.LoadDeviceActivations(hsp.Key.HHKey);
if (deviceActivations.Count == 0)
{
throw new LPGException("No device activations were found");
}
Dictionary <string, AffordanceEnergyUseEntry> energyUseEntries = new Dictionary <string, AffordanceEnergyUseEntry>();
foreach (DeviceActivationEntry ae in deviceActivations)
{
string key = AffordanceEnergyUseEntry.MakeKey(ae.HouseholdKey, ae.LoadTypeGuid, ae.AffordanceName,
ae.ActivatorName);
if (!energyUseEntries.ContainsKey(key))
{
energyUseEntries.Add(key, new AffordanceEnergyUseEntry(
ae.HouseholdKey, ae.LoadTypeGuid, ae.AffordanceName, ae.ActivatorName,
ae.LoadTypeName));
}
var aeu = energyUseEntries[key];
aeu.EnergySum += ae.TotalEnergySum;
aeu.TotalActivationDurationInSteps += ae.DurationInSteps;
aeu.NumberOfActivations++;
}
if (energyUseEntries.Count == 0)
{
throw new LPGException("No energy use entries were found.");
}
_logger.Save(hsp.Key.HHKey, energyUseEntries.Values.ToList());
}
private void RunLoadTypeDependend([CanBeNull][ItemNotNull] List <string> loadTypesForPostProcessing)
{
if (_loadTypeSumPostProcessingSteps.Any(x => x.IsEnabled()))
{
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - Calculation of the sums per load type");
foreach (var calcLoadType in _repository.LoadTypes)
{
//if (!_fft.CheckForResultFileEntry(ResultFileID.OnlineSumActivationFiles,
// calcLoadType.Name,
// Constants.GeneralHouseholdKey,
// null,
// null)) {
// Logger.Info("Skipping post-processing of load type " + calcLoadType.Name +
// " because there was no sum dat file generated for it.");
// continue;
//}
if (loadTypesForPostProcessing != null && loadTypesForPostProcessing.Count > 0 &&
!loadTypesForPostProcessing.Contains(calcLoadType.Name))
{
Logger.Info("Skipping post-processing of load type " + calcLoadType.Name + " because it was not specified.");
continue;
}
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - " + calcLoadType.Name);
foreach (ILoadTypeSumStep loadTypePostProcessingStep in _loadTypeSumPostProcessingSteps)
{
LoadtypeSumStepParameters ltsp = new LoadtypeSumStepParameters(calcLoadType);
loadTypePostProcessingStep.Run(ltsp);
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - " + calcLoadType.Name);
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - Calculation of the sums per load type");
}
if (!_loadTypePostProcessingSteps.Any(x => x.IsEnabled()) &&
!_householdloadTypePostProcessingSteps.Any(x => x.IsEnabled())
)
{
return;
}
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - Calculation of the individual profiles for devices and households");
// needs to be persistent object to keep the dictionary for all load types
int fileCount = 0;
foreach (var calcLoadType in _repository.LoadTypes)
{
if (!_fft.CheckForResultFileEntry(ResultFileID.OnlineDeviceActivationFiles, calcLoadType.Name,
Constants.GeneralHouseholdKey, null, null))
{
Logger.Info("Skipping post-processing of load type " + calcLoadType.Name + " because there was no dat file generated for it.");
continue;
}
if (loadTypesForPostProcessing != null && loadTypesForPostProcessing.Count > 0 && !loadTypesForPostProcessing.Contains(calcLoadType.Name))
{
Logger.Info("Skipping post-processing of load type " + calcLoadType.Name + " because it was not specified.");
continue;
}
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass() + " - " + calcLoadType.Name);
List <OnlineEnergyFileRow> energyFileRows = ReadOnlineEnergyFileRowsIntoMemory(calcLoadType, out var total);
fileCount++;
if (Config.IsInUnitTesting && Config.ExtraUnitTestChecking)
{
Logger.Info("Starting total:" + total);
CheckTotalsForChange(energyFileRows, total);
}
foreach (ILoadTypeStep loadTypePostProcessingStep in _loadTypePostProcessingSteps)
{
LoadtypeStepParameters ltsp = new LoadtypeStepParameters(calcLoadType, energyFileRows);
loadTypePostProcessingStep.Run(ltsp);
}
foreach (HouseholdKeyEntry entry in _repository.HouseholdKeys)
{
foreach (var ltpps in _householdloadTypePostProcessingSteps)
{
HouseholdLoadtypeStepParameters ltsp = new HouseholdLoadtypeStepParameters(entry, calcLoadType, energyFileRows);
ltpps.Run(ltsp);
}
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - " + calcLoadType.Name);
}
if (fileCount == 0)
{
var ltp = _loadTypePostProcessingSteps.Where(x => x.IsEnabled()).Select(x => x.StepName).ToList();
var hhltp = _householdloadTypePostProcessingSteps.Where(x => x.IsEnabled()).Select(x => x.StepName)
.ToList();
string s1 = string.Join("\n", ltp);
string s2 = string.Join("\n", hhltp);
throw new LPGException("Not a single file for postprocessing was found, but the following steps were enabled:" + s1 + "\n" + s2);
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass() + " - Calculation of the individual profiles for devices and households");
//if (_repository.DeviceSumInformationList.DeviceSums.Count > 0) {
// _repository.DeviceSumInformationList.WriteJson(_fft, _repository.CalcParameters.InternalStepsize);
// }
}
