public void RemoveHydraulicConditionDoesNotChangeClassEstimatesNoExperts()
{
var treeEvent = new TreeEvent();
var hydraulicConditionToRemove = new HydraulicCondition(1.0, (Probability)0.01, 1, 1);
var hydraulicCondition2 = new HydraulicCondition(2.0, (Probability)0.001, 1, 1);
var project = new Project
{
EventTrees =
{
new EventTree
{
MainTreeEvent = treeEvent
}
},
HydraulicConditions =
{
hydraulicConditionToRemove,
hydraulicCondition2,
}
};
var projectManipulationService = new ProjectManipulationService(project);
Assert.AreEqual(0, treeEvent.ClassesProbabilitySpecification.Count);
projectManipulationService.RemoveHydraulicCondition(hydraulicConditionToRemove);
Assert.AreEqual(1, project.HydraulicConditions.Count);
Assert.AreEqual(hydraulicCondition2, project.HydraulicConditions.First());
Assert.AreEqual(0, treeEvent.ClassesProbabilitySpecification.Count);
}
private static void ReadFragilityCurve(TreeEvent treeEvent, IEnumerable <TreeEventFragilityCurveElementEntity> entities, ReadConversionCollector collector)
{
foreach (var treeEventFragilityCurveElementEntity in entities.OrderBy(e => e.Order))
{
treeEvent.FixedFragilityCurve.Add(treeEventFragilityCurveElementEntity.Read(collector));
}
}
public void RemoveExpertDoesNotChangeClassEstimatesNoHydraulicConditions()
{
var treeEvent = new TreeEvent();
var expertToRemove = new Expert();
var otherExpert = new Expert();
var project = new Project
{
EventTrees =
{
new EventTree
{
MainTreeEvent = treeEvent
}
},
Experts =
{
expertToRemove,
otherExpert
}
};
var projectManipulationService = new ProjectManipulationService(project);
Assert.AreEqual(0, treeEvent.ClassesProbabilitySpecification.Count);
projectManipulationService.RemoveExpert(expertToRemove);
Assert.AreEqual(1, project.Experts.Count);
Assert.AreEqual(otherExpert, project.Experts.First());
Assert.AreEqual(0, treeEvent.ClassesProbabilitySpecification.Count);
}
private static EventTree CreateEventTree(string treeName, int numberTreeEvents)
{
var mainTreeEvent = new TreeEvent
{
Name = "First element"
};
var tree = new EventTree
{
Name = treeName,
MainTreeEvent = mainTreeEvent
};
var currentTreeEvent = mainTreeEvent;
for (int i = 0; i < numberTreeEvents - 1; i++)
{
var falseEvent = new TreeEvent
{
Name = string.Format("Event no. {0}", i + 1)
};
currentTreeEvent.FailingEvent = falseEvent;
currentTreeEvent = falseEvent;
}
return(tree);
}
public TreeEventViewModel([NotNull] TreeEvent treeEvent, [NotNull] EventTreeViewModel parentEventTreeViewModel, [NotNull] ProjectManipulationService projectManipulationService)
{
this.projectManipulationService = projectManipulationService;
TreeEvent = treeEvent;
ParentEventTreeViewModel = parentEventTreeViewModel;
treeEvent.PropertyChanged += TreeEventPropertyChanged;
}
public TreeEvent RemoveTreeEvent(EventTree eventTree, TreeEvent selectedTreeEventToRemove)
{
if (Equals(eventTree.MainTreeEvent, selectedTreeEventToRemove))
{
eventTree.MainTreeEvent = null;
eventTree.OnPropertyChanged(nameof(eventTree.MainTreeEvent));
return(null);
}
var parent = eventTree.MainTreeEvent.FindTreeEvent(treeEvent => treeEvent.FailingEvent == selectedTreeEventToRemove ||
treeEvent.PassingEvent == selectedTreeEventToRemove);
if (parent == null)
{
throw new ArgumentNullException();
}
if (parent.FailingEvent == selectedTreeEventToRemove)
{
parent.FailingEvent = null;
parent.OnPropertyChanged(nameof(parent.FailingEvent));
}
else
{
parent.PassingEvent = null;
parent.OnPropertyChanged(nameof(parent.PassingEvent));
}
return(parent);
}
public FixedFragilityCurveSpecificationViewModel(TreeEvent treeEvent, Project project) : base(treeEvent)
{
Project = project;
fixedFragilityCurveViewModels = new ObservableCollection <FragilityCurveElementViewModel>(treeEvent.FixedFragilityCurve.Select(e => new FragilityCurveElementViewModel(e)));
fixedFragilityCurveViewModels.CollectionChanged += FragilityCurveViewModelsCollectionChanged;
}
private static void AddExpertClassEstimations(TreeEventEntity entity, TreeEvent model, PersistenceRegistry registry)
{
for (var index = 0; index < model.ClassesProbabilitySpecification.Count; index++)
{
var expertClassEstimationEntity = model.ClassesProbabilitySpecification[index].Create(registry);
expertClassEstimationEntity.TreeEventEntity = entity;
expertClassEstimationEntity.Order = index;
entity.ExpertClassEstimationEntities.Add(expertClassEstimationEntity);
}
}
public static void ChangeProbabilityEstimationType(TreeEvent treeEvent, ProbabilitySpecificationType type)
{
if (treeEvent.ProbabilitySpecificationType == type)
{
return;
}
treeEvent.ProbabilitySpecificationType = type;
treeEvent.OnPropertyChanged(nameof(TreeEvent.ProbabilitySpecificationType));
}
public static IEnumerable <TreeEvent> GetCriticalPath(TreeEvent mainTreeEvent, TreeEvent treeEventTo)
{
if (treeEventTo == null || mainTreeEvent == null)
{
return(null);
}
if (ReferenceEquals(treeEventTo, mainTreeEvent))
{
return(new[] { treeEventTo });
}
var pathToThisNode = GetCriticalPath(mainTreeEvent.FailingEvent, treeEventTo) ??
GetCriticalPath(mainTreeEvent.PassingEvent, treeEventTo);
return(pathToThisNode == null ? null : new[] { mainTreeEvent }.Concat(pathToThisNode));
}
internal static TreeEvent Read(this TreeEventEntity entity, ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.Contains(entity))
{
return(collector.Get(entity));
}
var treeEvent = new TreeEvent
{
Name = entity.Name,
Details = entity.Details,
FixedProbability = entity.FixedProbability == null
? Probability.NaN
: (Probability)(double)entity.FixedProbability,
ProbabilitySpecificationType = (ProbabilitySpecificationType)entity.ProbabilitySpecificationType,
Summary = entity.Summary,
Information = entity.Information,
Discussion = entity.Discussion
// TODO: Add PassPhrase
};
ReadFragilityCurve(treeEvent, entity.TreeEventFragilityCurveElementEntities, collector);
if (entity.TreeEventEntity3 != null)
{
treeEvent.FailingEvent = entity.TreeEventEntity3.Read(collector);
}
if (entity.TreeEventEntity2 != null)
{
treeEvent.PassingEvent = entity.TreeEventEntity2.Read(collector);
}
ReadExpertClassSpecifications(entity, collector, treeEvent);
collector.Collect(entity, treeEvent);
return(treeEvent);
}
private static void AddFragilityCurveElements(TreeEventEntity entity, TreeEvent model, PersistenceRegistry registry)
{
if (model.FixedFragilityCurve != null)
{
for (var index = 0; index < model.FixedFragilityCurve.Count; index++)
{
var fragilityCurveElement = model.FixedFragilityCurve[index];
var curveElementEntity = new TreeEventFragilityCurveElementEntity
{
FragilityCurveElementEntity = fragilityCurveElement.Create(registry),
TreeEventEntity = entity,
Order = index
};
entity.TreeEventFragilityCurveElementEntities.Add(curveElementEntity);
}
}
}
public ProbabilitySpecificationViewModelBase CreateViewModel(TreeEvent treeEvent)
{
switch (treeEvent.ProbabilitySpecificationType)
{
case ProbabilitySpecificationType.Classes:
return(new ClassesProbabilitySpecificationViewModel(treeEvent, Project));
case ProbabilitySpecificationType.FixedValue:
return(new FixedProbabilitySpecificationViewModel(treeEvent));
case ProbabilitySpecificationType.FixedFreqeuncy:
return(new FixedFragilityCurveSpecificationViewModel(treeEvent, Project));
default:
throw new InvalidEnumArgumentException();
}
}
public TreeEvent AddTreeEvent(EventTree eventTree, TreeEvent selectedTreeEventToAddTo, TreeEventType type)
{
var newTreeEvent = new TreeEvent
{
Name = "Nieuwe gebeurtenis"
};
foreach (var expert in project.Experts)
{
foreach (var hydraulicCondition in project.HydraulicConditions)
{
newTreeEvent.ClassesProbabilitySpecification.Add(new ExpertClassEstimation
{
Expert = expert,
HydraulicCondition = hydraulicCondition,
AverageEstimation = ProbabilityClass.None,
MinEstimation = ProbabilityClass.None,
MaxEstimation = ProbabilityClass.None
});
}
}
if (eventTree.MainTreeEvent == null)
{
eventTree.MainTreeEvent = newTreeEvent;
eventTree.OnPropertyChanged(nameof(eventTree.MainTreeEvent));
return(newTreeEvent);
}
switch (type)
{
case TreeEventType.Failing:
selectedTreeEventToAddTo.FailingEvent = newTreeEvent;
selectedTreeEventToAddTo.OnPropertyChanged(nameof(selectedTreeEventToAddTo.FailingEvent));
break;
case TreeEventType.Passing:
selectedTreeEventToAddTo.PassingEvent = newTreeEvent;
selectedTreeEventToAddTo.OnPropertyChanged(nameof(selectedTreeEventToAddTo.PassingEvent));
break;
}
return(newTreeEvent);
}
private void AssertEqualTreeEvents(TreeEvent treeEvent1, TreeEvent treeEvent2)
{
Assert.AreEqual(treeEvent1 == null, treeEvent2 == null);
if (treeEvent1 == null)
{
return;
}
Assert.AreEqual(treeEvent1.Name, treeEvent2.Name);
Assert.AreEqual(treeEvent1.ProbabilitySpecificationType, treeEvent2.ProbabilitySpecificationType);
Assert.AreEqual(treeEvent1.Details, treeEvent2.Details);
Assert.AreEqual(treeEvent1.FixedProbability, treeEvent2.FixedProbability);
Assert.AreEqual(treeEvent1.Summary, treeEvent2.Summary);
Assert.AreEqual(treeEvent1.Information, treeEvent2.Information);
Assert.AreEqual(treeEvent1.Discussion, treeEvent2.Discussion);
AssertEqualTreeEvents(treeEvent1.PassingEvent, treeEvent2.PassingEvent);
AssertEqualTreeEvents(treeEvent1.FailingEvent, treeEvent2.FailingEvent);
Assert.AreEqual(treeEvent1.ClassesProbabilitySpecification.Count, treeEvent2.ClassesProbabilitySpecification.Count);
for (int i = 0; i < treeEvent1.ClassesProbabilitySpecification.Count; i++)
{
var spec1 = treeEvent1.ClassesProbabilitySpecification[i];
var spec2 = treeEvent2.ClassesProbabilitySpecification[i];
Assert.AreEqual(spec1.HydraulicCondition.WaterLevel, spec2.HydraulicCondition.WaterLevel);
Assert.AreEqual(spec1.HydraulicCondition.Probability, spec2.HydraulicCondition.Probability);
Assert.AreEqual(spec1.HydraulicCondition.WaveHeight, spec2.HydraulicCondition.WaveHeight);
Assert.AreEqual(spec1.HydraulicCondition.WavePeriod, spec2.HydraulicCondition.WavePeriod);
AssertEqualExperts(spec1.Expert, spec2.Expert);
Assert.AreEqual(spec1.AverageEstimation, spec2.AverageEstimation);
Assert.AreEqual(spec1.MinEstimation, spec2.MinEstimation);
Assert.AreEqual(spec1.MaxEstimation, spec2.MaxEstimation);
}
Assert.AreEqual(treeEvent1.FixedFragilityCurve.Count, treeEvent2.FixedFragilityCurve.Count);
for (int i = 0; i < treeEvent1.FixedFragilityCurve.Count; i++)
{
var element1 = treeEvent1.FixedFragilityCurve[i];
var element2 = treeEvent2.FixedFragilityCurve[i];
Assert.AreEqual(element1.WaterLevel, element2.WaterLevel);
Assert.AreEqual(element1.Probability, element2.Probability);
}
}
internal static TreeEventEntity Create(this TreeEvent model, PersistenceRegistry registry)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(model))
{
return(registry.Get(model));
}
var entity = new TreeEventEntity
{
Name = model.Name.DeepClone(),
Details = model.Details.DeepClone(),
Summary = model.Summary.DeepClone(),
FixedProbability = ((double)model.FixedProbability).ToNaNAsNull(),
ProbabilitySpecificationType = Convert.ToByte(model.ProbabilitySpecificationType),
Information = model.Information.DeepClone(),
Discussion = model.Discussion.DeepClone(),
// Add passphrase
};
AddExpertClassEstimations(entity, model, registry);
AddFragilityCurveElements(entity, model, registry);
if (model.FailingEvent != null)
{
entity.TreeEventEntity3 = model.FailingEvent.Create(registry);
}
if (model.PassingEvent != null)
{
entity.TreeEventEntity2 = model.PassingEvent.Create(registry);
}
registry.Register(model, entity);
return(entity);
}
protected static bool ExtractInput(object[] values, out HydraulicCondition[] hydraulicConditions, out CriticalPathElement[] elements, out TreeEvent[] treeEvents)
{
hydraulicConditions = null;
elements = new CriticalPathElement[] { };
treeEvents = new TreeEvent[] { };
if (values.Length != 2)
{
return(true);
}
var hydraulicConditionViewModels = values[1] as ObservableCollection <HydraulicConditionViewModel>;
if (!(values[0] is TreeEvent[] criticalPath) ||
hydraulicConditionViewModels == null)
{
return(true);
}
var orderedWaterLevels = hydraulicConditionViewModels.Select(h => h.WaterLevel).Distinct();
hydraulicConditions = hydraulicConditionViewModels.Select(vm => vm.HydraulicCondition).OrderBy(c => c.WaterLevel).ToArray();
var allElements = new List <CriticalPathElement>();
for (int i = 0; i < criticalPath.Length; i++)
{
var failElement = true;
if (i < criticalPath.Length - 1)
{
failElement = criticalPath[i].FailingEvent != null && criticalPath[i].FailingEvent == criticalPath[i + 1];
}
allElements.Add(new CriticalPathElement(criticalPath[i], criticalPath[i].GetFragilityCurve(orderedWaterLevels), failElement));
}
elements = allElements.ToArray();
treeEvents = criticalPath;
return(false);
}
public void AddExpertChangesClassEstimatesWithHydraulicConditions()
{
var treeEvent = new TreeEvent();
var project = new Project
{
EventTrees = { new EventTree
{
MainTreeEvent = treeEvent
} },
HydraulicConditions =
{
new HydraulicCondition(1.0, (Probability)0.01, 1, 1),
new HydraulicCondition(2.0, (Probability)0.001, 1, 1),
}
};
var projectManipulationService = new ProjectManipulationService(project);
Assert.AreEqual(0, treeEvent.ClassesProbabilitySpecification.Count);
var expert = new Expert();
projectManipulationService.AddExpert(expert);
Assert.AreEqual(1, project.Experts.Count);
Assert.AreEqual(expert, project.Experts.First());
Assert.AreEqual(2, treeEvent.ClassesProbabilitySpecification.Count);
var firstSpecification = treeEvent.ClassesProbabilitySpecification.First();
Assert.AreEqual(expert, firstSpecification.Expert);
Assert.Contains(firstSpecification.HydraulicCondition, project.HydraulicConditions);
var secondSpecification = treeEvent.ClassesProbabilitySpecification.Last();
Assert.AreEqual(expert, secondSpecification.Expert);
Assert.Contains(secondSpecification.HydraulicCondition, project.HydraulicConditions);
Assert.AreNotEqual(firstSpecification.HydraulicCondition, secondSpecification.HydraulicCondition);
}
public void CalculateCriticalPathWorks()
{
var targetNode = new TreeEvent {
Name = "Scooooreee!!"
};
var node1 = new TreeEvent {
FailingEvent = targetNode, PassingEvent = new TreeEvent()
};
var node2 = new TreeEvent {
FailingEvent = node1
};
var mainNode = new TreeEvent {
FailingEvent = node2
};
var path = CriticalPathCalculator.GetCriticalPath(mainNode, targetNode).ToArray();
Assert.AreEqual(4, path.Length);
Assert.AreEqual(mainNode, path[0]);
Assert.AreEqual(node2, path[1]);
Assert.AreEqual(node1, path[2]);
Assert.AreEqual(targetNode, path[3]);
}
public TreeEventEntity Get(TreeEvent model)
{
return(Get(treeEvents, model));
}
public FixedProbabilitySpecificationViewModel(TreeEvent treeEvent) : base(treeEvent)
{
}
public ClassesProbabilitySpecificationViewModel([NotNull] TreeEvent treeEvent, Project project) : base(treeEvent)
{
ClassesProbabilitySpecification = new ObservableCollection <ExpertClassEstimationViewModel>(
TreeEvent.ClassesProbabilitySpecification.Select(e => new ExpertClassEstimationViewModel(e)));
}
private static void ReadExpertClassSpecifications(TreeEventEntity entity, ReadConversionCollector collector, TreeEvent treeEvent)
{
var specifications = entity.ExpertClassEstimationEntities.OrderBy(e => e.Order).Select(e => e.Read(collector));
foreach (var specification in specifications)
{
treeEvent.ClassesProbabilitySpecification.Add(specification);
}
}
internal void Register(TreeEvent model, TreeEventEntity entity)
{
Register(treeEvents, model, entity);
}
internal bool Contains(TreeEvent model)
{
return(ContainsValue(treeEvents, model));
}
public CriticalPathElement(TreeEvent treeEvent, FragilityCurve fragilityCurve, bool failElement)
{
Element = treeEvent;
FragilityCurve = fragilityCurve;
ElementFails = failElement;
}
public ProbabilitySpecificationViewModelBase([NotNull] TreeEvent treeEvent)
{
TreeEvent = treeEvent;
TreeEvent.PropertyChanged += TreeEventPropertyChanged;
}
public static void ShowMessage(object sender, TreeEvent e)
{
Console.WriteLine(e.Message);
}
internal void Collect(TreeEventEntity entity, TreeEvent model)
{
Collect(treeEvents, entity, model);
}
public void RemoveExpertChangesClassEstimatesWithHydraulicConditions()
{
var expertToRemove = new Expert();
var otherExpert = new Expert();
var hydraulicCondition1 = new HydraulicCondition(1.0, (Probability)0.01, 1, 1);
var hydraulicCondition2 = new HydraulicCondition(2.0, (Probability)0.001, 1, 1);
var treeEvent = new TreeEvent
{
ClassesProbabilitySpecification =
{
new ExpertClassEstimation {
Expert = expertToRemove, HydraulicCondition = hydraulicCondition1
},
new ExpertClassEstimation {
Expert = expertToRemove, HydraulicCondition = hydraulicCondition2
},
new ExpertClassEstimation {
Expert = otherExpert, HydraulicCondition = hydraulicCondition1
},
new ExpertClassEstimation {
Expert = otherExpert, HydraulicCondition = hydraulicCondition2
}
}
};
var project = new Project
{
EventTrees =
{
new EventTree
{
MainTreeEvent = treeEvent
}
},
Experts =
{
expertToRemove,
otherExpert
},
HydraulicConditions =
{
hydraulicCondition1,
hydraulicCondition2,
}
};
var projectManipulationService = new ProjectManipulationService(project);
Assert.AreEqual(4, treeEvent.ClassesProbabilitySpecification.Count);
projectManipulationService.RemoveExpert(expertToRemove);
Assert.AreEqual(1, project.Experts.Count);
Assert.AreEqual(otherExpert, project.Experts.First());
Assert.AreEqual(2, treeEvent.ClassesProbabilitySpecification.Count);
var firstSpecification = treeEvent.ClassesProbabilitySpecification.First();
Assert.AreEqual(otherExpert, firstSpecification.Expert);
Assert.AreEqual(hydraulicCondition1, firstSpecification.HydraulicCondition);
Assert.Contains(firstSpecification.HydraulicCondition, project.HydraulicConditions);
var secondSpecification = treeEvent.ClassesProbabilitySpecification.Last();
Assert.AreEqual(otherExpert, secondSpecification.Expert);
Assert.AreEqual(hydraulicCondition2, secondSpecification.HydraulicCondition);
Assert.Contains(secondSpecification.HydraulicCondition, project.HydraulicConditions);
Assert.AreNotEqual(firstSpecification.HydraulicCondition, secondSpecification.HydraulicCondition);
}
