/// <summary>
/// Gets the value for the initial failure mechanism result per failure mechanism section as a probability.
/// </summary>
/// <param name="sectionResult">The section result to get the initial failure mechanism result probability for.</param>
/// <param name="calculationScenarios">All probabilistic calculation scenarios in the failure mechanism.</param>
/// <param name="getOutputFunc">The function to get the output from a calculation scenario.</param>
/// <returns>The calculated initial failure mechanism result probability; or <see cref="double.NaN"/> when there
/// are no relevant calculations, when not all relevant calculations are performed or when the
/// contributions of the relevant calculations don't add up to 1.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static double GetInitialFailureMechanismResultProbability(this AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
IEnumerable <ProbabilisticPipingCalculationScenario> calculationScenarios,
Func <ProbabilisticPipingCalculationScenario, IPartialProbabilisticPipingOutput> getOutputFunc)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
if (getOutputFunc == null)
{
throw new ArgumentNullException(nameof(getOutputFunc));
}
ProbabilisticPipingCalculationScenario[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios <ProbabilisticPipingCalculationScenario>(
calculationScenarios,
(scenario, lineSegments) => scenario.IsSurfaceLineIntersectionWithReferenceLineInSection(lineSegments))
.ToArray();
return(CalculationScenarioHelper.ScenariosAreValid(relevantScenarios)
? relevantScenarios.Sum(scenario => StatisticsConverter.ReliabilityToProbability(getOutputFunc(scenario).Reliability) * (double)scenario.Contribution)
: double.NaN);
}
/// <summary>
/// Gets the value for the initial failure mechanism result per failure mechanism section as a probability.
/// </summary>
/// <param name="sectionResult">The section result to get the initial failure mechanism result probability for.</param>
/// <param name="calculationScenarios">All semi probabilistic calculation scenarios in the failure mechanism.</param>
/// <param name="norm">The norm to assess for.</param>
/// <returns>The calculated initial failure mechanism result probability; or <see cref="double.NaN"/> when there
/// are no relevant calculations, when not all relevant calculations are performed or when the
/// contributions of the relevant calculations don't add up to 1.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static double GetInitialFailureMechanismResultProbability(this AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
IEnumerable <SemiProbabilisticPipingCalculationScenario> calculationScenarios,
double norm)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
SemiProbabilisticPipingCalculationScenario[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios <SemiProbabilisticPipingCalculationScenario>(
calculationScenarios,
(scenario, lineSegments) => scenario.IsSurfaceLineIntersectionWithReferenceLineInSection(lineSegments))
.ToArray();
if (!CalculationScenarioHelper.ScenariosAreValid(relevantScenarios))
{
return(double.NaN);
}
double totalInitialFailureMechanismResult = 0;
foreach (SemiProbabilisticPipingCalculationScenario scenario in relevantScenarios)
{
DerivedSemiProbabilisticPipingOutput derivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(scenario.Output, norm);
totalInitialFailureMechanismResult += derivedOutput.PipingProbability * (double)scenario.Contribution;
}
return(totalInitialFailureMechanismResult);
}
public void ScenariosAreValid_ScenariosWithOutputAndContributionOne_ReturnsTrue(double scenarioContribution1,
double scenarioContribution2)
{
// Setup
var calculationScenario1 = new TestCalculationScenario
{
Contribution = (RoundedDouble)scenarioContribution1,
Output = new object()
};
var calculationScenario2 = new TestCalculationScenario
{
Contribution = (RoundedDouble)scenarioContribution2,
Output = new object()
};
// Call
bool valid = CalculationScenarioHelper.ScenariosAreValid(new[]
{
calculationScenario1,
calculationScenario2
});
// Assert
Assert.IsTrue(valid);
}
public string GetCalculatedProbabilityValidationError(Func <double> getProbabilityFunc)
{
if (getProbabilityFunc == null)
{
throw new ArgumentNullException(nameof(getProbabilityFunc));
}
T[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios(calculationScenarios, intersectionFunc).ToArray();
if (relevantScenarios.Length == 0)
{
return(Resources.FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider_No_relevant_calculation_scenarios_present);
}
if (Math.Abs(CalculationScenarioHelper.GetTotalContribution(relevantScenarios) - 1.0) > 1e-6)
{
return(Resources.FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider_Scenario_contribution_for_this_section_not_100);
}
if (!relevantScenarios.All(s => s.HasOutput))
{
return(Resources.FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider_Not_all_relevant_calculation_scenarios_have_been_executed);
}
if (double.IsNaN(getProbabilityFunc()))
{
return(Resources.FailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider_All_relevant_calculation_scenarios_must_have_valid_output);
}
return(string.Empty);
}
/// <summary>
/// Gets the value for the initial failure mechanism result per failure mechanism section as a probability.
/// </summary>
/// <param name="sectionResult">The section result to get the initial failure mechanism result probability for.</param>
/// <param name="calculationScenarios">All probabilistic calculation scenarios in the failure mechanism.</param>
/// <returns>The calculated initial failure mechanism result probability; or <see cref="double.NaN"/> when there
/// are no relevant calculations, when not all relevant calculations are performed or when the
/// contributions of the relevant calculations don't add up to 1.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static double GetInitialFailureMechanismResultProbability(this AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult,
IEnumerable <GrassCoverErosionInwardsCalculationScenario> calculationScenarios)
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
GrassCoverErosionInwardsCalculationScenario[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios <GrassCoverErosionInwardsCalculationScenario>(
calculationScenarios,
(scenario, lineSegments) => scenario.IsDikeProfileIntersectionWithReferenceLineInSection(lineSegments))
.ToArray();
if (!CalculationScenarioHelper.ScenariosAreValid(relevantScenarios))
{
return(double.NaN);
}
double totalInitialFailureMechanismResult = 0;
foreach (GrassCoverErosionInwardsCalculationScenario scenario in relevantScenarios)
{
ProbabilityAssessmentOutput derivedOutput = ProbabilityAssessmentOutputFactory.Create(scenario.Output.OvertoppingOutput.Reliability);
totalInitialFailureMechanismResult += derivedOutput.Probability * (double)scenario.Contribution;
}
return(totalInitialFailureMechanismResult);
}
/// <summary>
/// Gets the value for the initial failure mechanism result per failure mechanism section as a probability.
/// </summary>
/// <param name="sectionResult">The section result to get the initial failure mechanism result probability for.</param>
/// <param name="calculationScenarios">All probabilistic calculation scenarios in the failure mechanism.</param>
/// <typeparam name="T">The type of the structure which can be assigned to the calculation.</typeparam>
/// <returns>The calculated initial failure mechanism result probability; or <see cref="double.NaN"/> when there
/// are no relevant calculations, when not all relevant calculations are performed or when the
/// contributions of the relevant calculations don't add up to 1.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static double GetInitialFailureMechanismResultProbability <T>(this AdoptableFailureMechanismSectionResult sectionResult,
IEnumerable <StructuresCalculationScenario <T> > calculationScenarios)
where T : IStructuresCalculationInput <StructureBase>, new()
{
if (sectionResult == null)
{
throw new ArgumentNullException(nameof(sectionResult));
}
if (calculationScenarios == null)
{
throw new ArgumentNullException(nameof(calculationScenarios));
}
StructuresCalculationScenario <T>[] relevantScenarios = sectionResult.GetRelevantCalculationScenarios <StructuresCalculationScenario <T> >(
calculationScenarios,
(scenario, lineSegments) => scenario.IsStructureIntersectionWithReferenceLineInSection(lineSegments))
.ToArray();
if (!CalculationScenarioHelper.ScenariosAreValid(relevantScenarios))
{
return(double.NaN);
}
double totalInitialFailureMechanismResult = 0;
foreach (StructuresCalculationScenario <T> scenario in relevantScenarios)
{
ProbabilityAssessmentOutput derivedOutput = ProbabilityAssessmentOutputFactory.Create(scenario.Output.Reliability);
totalInitialFailureMechanismResult += derivedOutput.Probability * (double)scenario.Contribution;
}
return(totalInitialFailureMechanismResult);
}
public void ValidateScenarioContribution_ValidValue_DoesNotThrow(double newValue)
{
// Call
void Call() => CalculationScenarioHelper.ValidateScenarioContribution((RoundedDouble)newValue);
// Assert
Assert.DoesNotThrow(Call);
}
public void ScenariosAreValid_ScenariosEmpty_ReturnsFalse()
{
// Call
bool valid = CalculationScenarioHelper.ScenariosAreValid(Array.Empty <ICalculationScenario>());
// Assert
Assert.IsFalse(valid);
}
public void GetTotalContribution_CalculationScenariosNull_ThrowsArgumentNullException()
{
// Call
void Call() => CalculationScenarioHelper.GetTotalContribution <ICalculationScenario>(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("calculationScenarios", exception.ParamName);
}
public void ValidateScenarioContribution_InvalidValue_ThrowsArgumentException(double newValue)
{
// Call
void Call() => CalculationScenarioHelper.ValidateScenarioContribution((RoundedDouble)newValue);
// Assert
const string expectedMessage = "De waarde voor de bijdrage moet binnen het bereik [0, 100] liggen.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage);
}
public void ScenariosAreValid_RelevantScenariosNull_ThrowsArgumentNullException()
{
// Call
void Call() => CalculationScenarioHelper.ScenariosAreValid <ICalculationScenario>(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("relevantScenarios", exception.ParamName);
}
public void ScenariosAreValid_ScenariosWithoutOutput_ReturnsFalse()
{
// Setup
var calculationScenario1 = new TestCalculationScenario
{
Contribution = (RoundedDouble)0.4323,
Output = new object()
};
var calculationScenario2 = new TestCalculationScenario
{
Contribution = (RoundedDouble)0.1226
};
// Call
bool valid = CalculationScenarioHelper.ScenariosAreValid(new[]
{
calculationScenario1,
calculationScenario2
});
// Assert
Assert.IsFalse(valid);
}
public void GetTotalContribution_WithCalculationScenarios_ReturnsTotalContribution()
{
// Setup
var calculationScenario1 = new TestCalculationScenario
{
Contribution = (RoundedDouble)0.4323
};
var calculationScenario2 = new TestCalculationScenario
{
Contribution = (RoundedDouble)0.1226
};
// Call
RoundedDouble totalContribution = CalculationScenarioHelper.GetTotalContribution(new[]
{
calculationScenario1,
calculationScenario2
});
// Assert
RoundedDouble expectedTotalContribution = calculationScenario1.Contribution + calculationScenario2.Contribution;
Assert.AreEqual(expectedTotalContribution, totalContribution);
}
