/// <summary>
/// Removes a given <see cref="PipingStochasticSoilModel"/> from the <see cref="PipingFailureMechanism"/>
/// and clears all data that depends on it, either directly or indirectly.
/// </summary>
/// <param name="failureMechanism">The failure mechanism containing <paramref name="soilModel"/>.</param>
/// <param name="soilModel">The soil model residing in <paramref name="failureMechanism"/>
/// that should be removed.</param>
/// <returns>All observable objects affected by this method.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// or <paramref name="soilModel"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> RemoveStochasticSoilModel(PipingFailureMechanism failureMechanism,
PipingStochasticSoilModel soilModel)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (soilModel == null)
{
throw new ArgumentNullException(nameof(soilModel));
}
var changedObservables = new List <IObservable>();
IEnumerable <IPipingCalculationScenario <PipingInput> > pipingCalculations =
failureMechanism.Calculations
.Cast <IPipingCalculationScenario <PipingInput> >()
.Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilModel, soilModel));
foreach (IPipingCalculationScenario <PipingInput> pipingCalculation in pipingCalculations)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculation));
changedObservables.AddRange(ClearStochasticSoilModel(pipingCalculation.InputParameters));
}
failureMechanism.StochasticSoilModels.Remove(soilModel);
changedObservables.Add(failureMechanism.StochasticSoilModels);
return(changedObservables);
}
protected override void PerformCalculation()
{
calculationService.OnProgressChanged += UpdateProgressText;
RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation);
calculationService.Calculate(calculation, failureMechanism, assessmentSection);
}
public void ClearHydraulicBoundaryLocationCalculationOutput_CalculationsWithAndWithoutOutput_ClearsOutputAndReturnsAffectedCalculations()
{
// Setup
var random = new Random(21);
var calculationWithOutput1 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble())
};
var calculationWithOutput2 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble())
};
HydraulicBoundaryLocationCalculation[] calculations =
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
calculationWithOutput1,
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
calculationWithOutput2,
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
};
// Call
IEnumerable <IObservable> affectedCalculations = RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(calculations);
// Assert
Assert.IsTrue(calculations.All(c => c.Output == null));
CollectionAssert.AreEqual(new[]
{
calculationWithOutput1,
calculationWithOutput2
}, affectedCalculations);
}
/// <summary>
/// Removes a given <see cref="MacroStabilityInwardsStochasticSoilModel"/> from the <see cref="MacroStabilityInwardsFailureMechanism"/>
/// and clears all data that depends on it, either directly or indirectly.
/// </summary>
/// <param name="failureMechanism">The failure mechanism containing <paramref name="soilModel"/>.</param>
/// <param name="soilModel">The soil model residing in <paramref name="failureMechanism"/>
/// that should be removed.</param>
/// <returns>All observable objects affected by this method.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// or <paramref name="soilModel"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> RemoveStochasticSoilModel(MacroStabilityInwardsFailureMechanism failureMechanism, MacroStabilityInwardsStochasticSoilModel soilModel)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (soilModel == null)
{
throw new ArgumentNullException(nameof(soilModel));
}
var changedObservables = new List <IObservable>();
IEnumerable <MacroStabilityInwardsCalculation> calculationScenarios =
failureMechanism.Calculations
.Cast <MacroStabilityInwardsCalculation>()
.Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilModel, soilModel));
foreach (MacroStabilityInwardsCalculation calculationScenario in calculationScenarios)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculationScenario));
changedObservables.AddRange(ClearStochasticSoilModel(calculationScenario.InputParameters));
}
failureMechanism.StochasticSoilModels.Remove(soilModel);
changedObservables.Add(failureMechanism.StochasticSoilModels);
return(changedObservables);
}
/// <summary>
/// Clears the output for all calculations that corresponds with the <paramref name="calculationsForTargetProbability"/>
/// in the given <paramref name="failureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism which contains the calculations.</param>
/// <param name="calculationsForTargetProbability">The <see cref="HydraulicBoundaryLocationCalculationsForTargetProbability"/>
/// to clear for.</param>
/// <typeparam name="TFailureMechanism">The type of the calculatable failure mechanism.</typeparam>
/// <typeparam name="TCalculation">The type of the calculation.</typeparam>
/// <returns>An <see cref="IEnumerable{T}"/> of calculations which are affected by clearing the output.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllWaveConditionsCalculationOutput <TFailureMechanism, TCalculation>(
TFailureMechanism failureMechanism, HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability)
where TFailureMechanism : ICalculatableFailureMechanism
where TCalculation : ICalculation <WaveConditionsInput>
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (calculationsForTargetProbability == null)
{
throw new ArgumentNullException(nameof(calculationsForTargetProbability));
}
var affectedItems = new List <IObservable>();
foreach (TCalculation calculation in failureMechanism.Calculations
.Cast <TCalculation>()
.Where(c => c.InputParameters.WaterLevelType == WaveConditionsInputWaterLevelType.UserDefinedTargetProbability &&
c.InputParameters.CalculationsTargetProbability == calculationsForTargetProbability))
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
}
return(affectedItems);
}
protected override void PerformCalculation()
{
RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation);
calculationService.Calculate(
calculation,
assessmentSection,
failureMechanism.GeneralInput);
}
public void ClearHydraulicBoundaryLocationCalculationOutput_CalculationsNull_ThrowsArgumentNullException()
{
// Call
void Call() => RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculations", exception.ParamName);
}
public void ClearStructuresCalculationIllustrationPoints_CalculationsNull_ThrowsArgumentNullException()
{
// Call
void Call() => RiskeerCommonDataSynchronizationService.ClearStructuresCalculationIllustrationPoints(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculations", exception.ParamName);
}
public void ClearForeshoreProfile_CalculationsWithForeshoreProfile_ClearForeshoreProfileAndReturnAffectedInputs()
{
// Setup
var foreshoreProfileToBeRemoved = new TestForeshoreProfile(new Point2D(0, 0));
var foreshoreProfile = new TestForeshoreProfile(new Point2D(1, 1));
var calculation1 = new StructuresCalculation <TestStructuresInput>
{
InputParameters =
{
ForeshoreProfile = foreshoreProfile
}
};
var calculation2 = new StructuresCalculation <TestStructuresInput>
{
InputParameters =
{
ForeshoreProfile = foreshoreProfileToBeRemoved
}
};
var calculation3 = new StructuresCalculation <TestStructuresInput>
{
InputParameters =
{
ForeshoreProfile = foreshoreProfileToBeRemoved
},
Output = new TestStructuresOutput()
};
StructuresCalculation <TestStructuresInput>[] calculations =
{
calculation1,
calculation2,
calculation3
};
// Call
IEnumerable <IObservable> affectedObjects = RiskeerCommonDataSynchronizationService.ClearForeshoreProfile <TestStructuresInput, TestStructure>(
calculations, foreshoreProfileToBeRemoved);
// Assert
Assert.IsNull(calculation2.InputParameters.ForeshoreProfile);
Assert.IsNull(calculation3.InputParameters.ForeshoreProfile);
Assert.IsFalse(calculation3.HasOutput);
Assert.IsNotNull(calculation1.InputParameters.ForeshoreProfile);
CollectionAssert.AreEqual(new IObservable[]
{
calculation2.InputParameters,
calculation3,
calculation3.InputParameters
}, affectedObjects);
}
private static IEnumerable <IObservable> RemoveSurfaceLineDependentData(IEnumerable <MacroStabilityInwardsCalculation> calculationScenarios)
{
var changedObservables = new List <IObservable>();
foreach (MacroStabilityInwardsCalculation calculationScenario in calculationScenarios)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculationScenario));
changedObservables.AddRange(ClearSurfaceLine(calculationScenario.InputParameters));
}
return(changedObservables);
}
private static IEnumerable <IObservable> RemoveSurfaceLineDependentData(IEnumerable <IPipingCalculationScenario <PipingInput> > pipingCalculations)
{
var changedObservables = new List <IObservable>();
foreach (IPipingCalculationScenario <PipingInput> pipingCalculation in pipingCalculations)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculation));
changedObservables.AddRange(ClearSurfaceLine(pipingCalculation.InputParameters));
}
return(changedObservables);
}
private static IEnumerable <IObservable> ClearDikeProfileDependentData(
IEnumerable <GrassCoverErosionInwardsCalculation> calculationsWithRemovedDikeProfile)
{
var affectedObjects = new List <IObservable>();
foreach (GrassCoverErosionInwardsCalculation calculation in calculationsWithRemovedDikeProfile)
{
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
affectedObjects.AddRange(ClearDikeProfile(calculation.InputParameters));
}
return(affectedObjects);
}
private IEnumerable <IObservable> UpdateSurfaceLineDependentData(PipingSurfaceLine surfaceLine)
{
IEnumerable <IPipingCalculationScenario <PipingInput> > affectedCalculations = GetAffectedCalculationWithSurfaceLine(surfaceLine);
var affectedObjects = new List <IObservable>();
foreach (IPipingCalculationScenario <PipingInput> affectedCalculation in affectedCalculations)
{
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(affectedCalculation));
}
return(affectedObjects);
}
private IEnumerable <IObservable> UpdateSurfaceLineDependentData(MacroStabilityInwardsSurfaceLine surfaceLine)
{
IEnumerable <MacroStabilityInwardsCalculation> affectedCalculations = GetAffectedCalculationWithSurfaceLine(surfaceLine);
var affectedObjects = new List <IObservable>();
foreach (MacroStabilityInwardsCalculation affectedCalculation in affectedCalculations)
{
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(affectedCalculation));
}
return(affectedObjects);
}
private static List <IObservable> ClearStructureDependentData(IEnumerable <StructuresCalculation <StabilityPointStructuresInput> > calculationWithRemovedStructure)
{
var changedObservables = new List <IObservable>();
foreach (StructuresCalculation <StabilityPointStructuresInput> calculation in calculationWithRemovedStructure)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
calculation.InputParameters.ClearStructure();
changedObservables.Add(calculation.InputParameters);
}
return(changedObservables);
}
protected override IEnumerable <IObservable> RemoveObjectAndDependentData(ForeshoreProfile removedObject)
{
IEnumerable <ICalculation <ICalculationInput> > affectedCalculations = GetAffectedCalculationWithForeshoreProfiles(removedObject);
var affectedObjects = new List <IObservable>();
foreach (ICalculation <ICalculationInput> calculation in affectedCalculations)
{
((IHasForeshoreProfile)calculation.InputParameters).ForeshoreProfile = null;
affectedObjects.Add(calculation.InputParameters);
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
}
return(affectedObjects);
}
public void ClearHydraulicBoundaryLocation_InputWithoutHydraulicBoundaryLocation_ReturnsNoAffectedObjects()
{
// Setup
var mocks = new MockRepository();
var input = mocks.Stub <ICalculationInputWithHydraulicBoundaryLocation>();
mocks.ReplayAll();
// Call
IEnumerable <IObservable> affectedObjects = RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(input);
// Assert
CollectionAssert.IsEmpty(affectedObjects);
mocks.VerifyAll();
}
private static void UpdateStructureDerivedCalculationInput(StructuresCalculation <ClosingStructuresInput> calculation)
{
calculation.InputParameters.SynchronizeStructureInput();
var affectedObjects = new List <IObservable>
{
calculation.InputParameters
};
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
foreach (IObservable affectedObject in affectedObjects)
{
affectedObject.NotifyObservers();
}
}
private IEnumerable <IObservable> ClearNormDependingHydraulicBoundaryLocationCalculationOutput(bool normativeProbability)
{
NormativeProbabilityType normativeProbabilityToClearFor = GetNormativeProbabilityToClearFor(normativeProbability, assessmentSection.FailureMechanismContribution.NormativeProbabilityType);
IEnumerable <HydraulicBoundaryLocationCalculation> calculationsToClear = GetHydraulicBoundaryLocationCalculationsToClear(normativeProbabilityToClearFor);
var affectedObjects = new List <IObservable>();
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(calculationsToClear));
affectedObjects.AddRange(RiskeerDataSynchronizationService.ClearAllWaveConditionsCalculationOutput(assessmentSection, normativeProbabilityToClearFor));
if (affectedObjects.Any())
{
log.Info(Resources.FailureMechanismContributionNormChangeHandler_ClearNormDependingHydraulicBoundaryLocationCalculationOutput_Calculation_results_cleared);
}
return(affectedObjects);
}
public void ClearCalculationOutput_CalculationWithoutOutput_DoNothing()
{
// Setup
var mocks = new MockRepository();
var calculation = mocks.StrictMock <ICalculation>();
calculation.Expect(c => c.HasOutput).Return(false);
mocks.ReplayAll();
// Call
IEnumerable <IObservable> changedObjects = RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation);
// Assert
CollectionAssert.IsEmpty(changedObjects);
mocks.VerifyAll();
}
/// <summary>
/// Clears:
/// <list type="bullet">
/// <item>The <see cref="HydraulicBoundaryLocation"/> for all the calculations in the <see cref="MacroStabilityInwardsFailureMechanism"/>;</item>
/// <item>The output for all the calculations in the <see cref="MacroStabilityInwardsFailureMechanism"/>,
/// except where <see cref="MacroStabilityInwardsInput.UseAssessmentLevelManualInput"/> is <c>true</c>.</item>
/// </list>
/// </summary>
/// <param name="failureMechanism">The <see cref="MacroStabilityInwardsFailureMechanism"/> which contains the calculations.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(MacroStabilityInwardsFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var affectedItems = new List <IObservable>();
foreach (MacroStabilityInwardsCalculation calculation in failureMechanism.Calculations.Cast <MacroStabilityInwardsCalculation>())
{
affectedItems.AddRange(ClearAllCalculationOutputWithoutManualAssessmentLevel(failureMechanism));
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
}
return(affectedItems);
}
private IEnumerable <IObservable> UpdateDikeDependentData(DikeProfile objectToUpdate)
{
var affectedObjects = new List <IObservable>();
foreach (GrassCoverErosionInwardsCalculation calculation in GetAffectedCalculationsWithDikeProfile(objectToUpdate))
{
affectedObjects.Add(calculation.InputParameters);
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
if (!objectToUpdate.ForeshoreGeometry.Any())
{
calculation.InputParameters.UseForeshore = false;
}
}
return(affectedObjects);
}
/// <summary>
/// Clears the <see cref="HydraulicBoundaryLocation"/> and output for all the calculations
/// in the <see cref="StructuresCalculation{T}"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="ClosingStructuresFailureMechanism"/>
/// which contains the calculations.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(ClosingStructuresFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var affectedItems = new List <IObservable>();
foreach (StructuresCalculation <ClosingStructuresInput> calculation in failureMechanism.Calculations.Cast <StructuresCalculation <ClosingStructuresInput> >())
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
}
return(affectedItems);
}
/// <summary>
/// Clears the <see cref="HydraulicBoundaryLocation"/> and output for all the wave conditions calculations
/// in the <see cref="WaveImpactAsphaltCoverFailureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="WaveImpactAsphaltCoverFailureMechanism"/>
/// which contains the calculations.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllWaveConditionsCalculationOutputAndHydraulicBoundaryLocations(
WaveImpactAsphaltCoverFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var affectedItems = new List <IObservable>();
foreach (WaveImpactAsphaltCoverWaveConditionsCalculation calculation in failureMechanism.Calculations.Cast <WaveImpactAsphaltCoverWaveConditionsCalculation>())
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
}
return(affectedItems);
}
/// <summary>
/// Clears:
/// <list type="bullet">
/// <item>The <see cref="HydraulicBoundaryLocation"/> for all the calculations in the <see cref="PipingFailureMechanism"/>;</item>
/// <item>The output for all the calculations in the <see cref="PipingFailureMechanism"/>,
/// except for the <see cref="SemiProbabilisticPipingCalculationScenario"/> where
/// <see cref="SemiProbabilisticPipingInput.UseAssessmentLevelManualInput"/> is <c>true</c>.</item>
/// </list>
/// </summary>
/// <param name="failureMechanism">The <see cref="PipingFailureMechanism"/> which contains the calculations.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of objects which are affected by removing data.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearAllCalculationOutputAndHydraulicBoundaryLocations(PipingFailureMechanism failureMechanism)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
var affectedItems = new List <IObservable>();
affectedItems.AddRange(ClearAllSemiProbabilisticCalculationOutputWithoutManualAssessmentLevel(failureMechanism));
affectedItems.AddRange(ClearAllProbabilisticCalculationOutput(failureMechanism));
foreach (IPipingCalculationScenario <PipingInput> calculation in failureMechanism.Calculations.Cast <IPipingCalculationScenario <PipingInput> >())
{
affectedItems.AddRange(RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(calculation.InputParameters));
}
return(affectedItems.Distinct());
}
public void ClearHydraulicBoundaryLocation_InputWithHydraulicBoundaryLocation_ClearsLocationAndReturnsAffectedInput()
{
// Setup
var mocks = new MockRepository();
var input = mocks.Stub <ICalculationInputWithHydraulicBoundaryLocation>();
mocks.ReplayAll();
input.HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
// Call
IEnumerable <IObservable> affectedObjects = RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocation(input);
// Assert
Assert.IsNull(input.HydraulicBoundaryLocation);
CollectionAssert.AreEqual(new[]
{
input
}, affectedObjects);
mocks.VerifyAll();
}
protected override IEnumerable <IObservable> UpdateObjectAndDependentData(ForeshoreProfile objectToUpdate, ForeshoreProfile objectToUpdateFrom)
{
objectToUpdate.CopyProperties(objectToUpdateFrom);
var affectedObjects = new List <IObservable>();
IEnumerable <ICalculation <ICalculationInput> > affectedCalculations = GetAffectedCalculationWithForeshoreProfiles(objectToUpdate);
foreach (ICalculation <ICalculationInput> calculation in affectedCalculations)
{
affectedObjects.Add(calculation.InputParameters);
affectedObjects.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
if (!objectToUpdate.Geometry.Any())
{
((IUseForeshore)calculation.InputParameters).UseForeshore = false;
}
}
return(affectedObjects);
}
/// <summary>
/// Clears data dependent on a given <see cref="MacroStabilityInwardsStochasticSoilProfile"/>, either directly or indirectly,
/// from calculations in the <see cref="MacroStabilityInwardsFailureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism containing <paramref name="soilProfile"/>.</param>
/// <param name="soilProfile">The soil profile residing in <paramref name="failureMechanism"/>
/// that has been updated.</param>
/// <returns>All observable objects affected by this method.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// or <paramref name="soilProfile"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> ClearStochasticSoilProfileDependentData(MacroStabilityInwardsFailureMechanism failureMechanism, MacroStabilityInwardsStochasticSoilProfile soilProfile)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (soilProfile == null)
{
throw new ArgumentNullException(nameof(soilProfile));
}
var changedObservables = new List <IObservable>();
foreach (MacroStabilityInwardsCalculation calculation in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation));
changedObservables.Add(calculation.InputParameters);
}
return(changedObservables);
}
public void ClearCalculationOutput_WithCalculation_ClearsOutput()
{
// Setup
var mocks = new MockRepository();
var calculation = mocks.StrictMock <ICalculation>();
calculation.Expect(c => c.HasOutput).Return(true);
calculation.Expect(c => c.ClearOutput());
mocks.ReplayAll();
// Call
IEnumerable <IObservable> changedObjects = RiskeerCommonDataSynchronizationService.ClearCalculationOutput(calculation);
// Assert
// Note: To make sure the clear is performed regardless of what is done with
// the return result, no ToArray() should be called before these assertions:
mocks.VerifyAll();
CollectionAssert.AreEqual(new[]
{
calculation
}, changedObjects);
}
/// <summary>
/// Removes a given <see cref="PipingStochasticSoilProfile"/> from calculations in the <see cref="PipingFailureMechanism"/>
/// and clears all data that depends on it, either directly or indirectly.
/// </summary>
/// <param name="failureMechanism">The failure mechanism containing <paramref name="soilProfile"/>.</param>
/// <param name="soilProfile">The soil profile residing in <paramref name="failureMechanism"/>
/// that has been removed.</param>
/// <returns>All observable objects affected by this method.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// or <paramref name="soilProfile"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> RemoveStochasticSoilProfileFromInput(PipingFailureMechanism failureMechanism,
PipingStochasticSoilProfile soilProfile)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (soilProfile == null)
{
throw new ArgumentNullException(nameof(soilProfile));
}
var changedObservables = new List <IObservable>();
foreach (IPipingCalculationScenario <PipingInput> pipingCalculation in GetCalculationsWithSoilProfileAssigned(failureMechanism, soilProfile))
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculation));
changedObservables.AddRange(ClearStochasticSoilProfile(pipingCalculation.InputParameters));
}
return(changedObservables);
}