public void AssembleCombinedFailureMechanismSections_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
{
// Setup
var random = new Random(39);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
CombinedFailureMechanismSectionAssemblyResultWrapper output = calculator.AssembleCombinedFailureMechanismSections(new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
}
}, random.NextDouble());
// Assert
CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
CombinedFailureMechanismSectionAssemblyAssert.AssertAssembly(new[]
{
kernel.FailureMechanismResult
}, kernel.CombinedSectionResults, output.AssemblyResults);
Assert.AreEqual(AssemblyMethod.BOI3A1, output.CommonSectionAssemblyMethod);
Assert.AreEqual(AssemblyMethod.BOI3B1, output.FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(AssemblyMethod.BOI3C1, output.CombinedSectionResultAssemblyMethod);
}
}
public CombinedFailureMechanismSectionAssemblyResultWrapper AssembleCombinedFailureMechanismSections(
IEnumerable <IEnumerable <CombinedAssemblyFailureMechanismSection> > input, double assessmentSectionLength)
{
if (ThrowExceptionOnCalculate)
{
throw new AssessmentSectionAssemblyCalculatorException("Message", new Exception());
}
CombinedFailureMechanismSectionsInput = input;
AssessmentSectionLength = assessmentSectionLength;
return(CombinedFailureMechanismSectionAssemblyOutput ?? (CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
new CombinedFailureMechanismSectionAssembly(
new CombinedAssemblyFailureMechanismSection(
0, 1, FailureMechanismSectionAssemblyGroup.Zero),
input.Select(failureMechanism => FailureMechanismSectionAssemblyGroup.Dominant).ToArray())
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1)));
}
/// <summary>
/// Assembles the combined failure mechanism sections.
/// </summary>
/// <param name="assessmentSection">The assessment section that contains all
/// the failure mechanism sections to assemble.</param>
/// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when a <see cref="CombinedFailureMechanismSectionAssemblyResult"/>
/// cannot be created.</exception>
public static IEnumerable <CombinedFailureMechanismSectionAssemblyResult> AssembleCombinedPerFailureMechanismSection(
AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
try
{
IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance;
IAssessmentSectionAssemblyCalculator calculator = calculatorFactory.CreateAssessmentSectionAssemblyCalculator(
AssemblyToolKernelFactory.Instance);
Dictionary <IFailureMechanism, int> failureMechanismsToAssemble = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Where(fm => fm.InAssembly)
.Select((fm, i) => new
{
FailureMechanism = fm,
Index = i
})
.ToDictionary(x => x.FailureMechanism, x => x.Index);
CombinedFailureMechanismSectionAssemblyResultWrapper output = calculator.AssembleCombinedFailureMechanismSections(
CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, failureMechanismsToAssemble.Keys),
assessmentSection.ReferenceLine.Length);
return(CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanismsToAssemble, assessmentSection));
}
catch (AssessmentSectionAssemblyCalculatorException e)
{
throw new AssemblyException(e.Message, e);
}
catch (AssemblyException e)
{
throw new AssemblyException(Resources.AssessmentSectionAssemblyFactory_Error_while_assembling_failureMechanisms, e);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var assemblyResults = new[]
{
new CombinedFailureMechanismSectionAssembly(
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()),
Array.Empty <FailureMechanismSectionAssemblyGroup>())
};
var commonSectionAssemblyMethod = random.NextEnumValue <AssemblyMethod>();
var failureMechanismResultsAssemblyMethod = random.NextEnumValue <AssemblyMethod>();
var combinedSectionResultAssemblyMethod = random.NextEnumValue <AssemblyMethod>();
// Call
var wrapper = new CombinedFailureMechanismSectionAssemblyResultWrapper(
assemblyResults, commonSectionAssemblyMethod, failureMechanismResultsAssemblyMethod, combinedSectionResultAssemblyMethod);
// Assert
Assert.AreSame(assemblyResults, wrapper.AssemblyResults);
Assert.AreEqual(commonSectionAssemblyMethod, wrapper.CommonSectionAssemblyMethod);
Assert.AreEqual(failureMechanismResultsAssemblyMethod, wrapper.FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(combinedSectionResultAssemblyMethod, wrapper.CombinedSectionResultAssemblyMethod);
}
public void Create_WithAllFailureMechanisms_ReturnsCombinedFailureMechanismSectionAssemblyResults()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
assessmentSection.SpecificFailureMechanisms.Add(new SpecificFailureMechanism());
Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Where(fm => fm.InAssembly)
.Select((fm, i) => new
{
FailureMechanism = fm,
Index = i
})
.ToDictionary(x => x.FailureMechanism, x => x.Index);
var section1 = new CombinedAssemblyFailureMechanismSection(0, 5, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var section2 = new CombinedAssemblyFailureMechanismSection(5, 11, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var output = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
new CombinedFailureMechanismSectionAssembly(section1, GetFailureMechanismsOutput(failureMechanisms.Keys, random)),
new CombinedFailureMechanismSectionAssembly(section2, GetFailureMechanismsOutput(failureMechanisms.Keys, random))
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
CombinedFailureMechanismSectionAssemblyResult[] results = CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, failureMechanisms, assessmentSection).ToArray();
// Assert
Assert.AreEqual(output.AssemblyResults.Count(), results.Length);
for (var i = 0; i < output.AssemblyResults.Count(); i++)
{
CombinedFailureMechanismSectionAssembly assemblyResult = output.AssemblyResults.ElementAt(i);
Assert.AreEqual(assemblyResult.Section.SectionStart, results[i].SectionStart);
Assert.AreEqual(assemblyResult.Section.SectionEnd, results[i].SectionEnd);
Assert.AreEqual(assemblyResult.Section.FailureMechanismSectionAssemblyGroup, results[i].TotalResult);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Piping]), results[i].Piping);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionInwards]), results[i].GrassCoverErosionInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.MacroStabilityInwards]), results[i].MacroStabilityInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.Microstability]), results[i].Microstability);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityStoneCover]), results[i].StabilityStoneCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaveImpactAsphaltCover]), results[i].WaveImpactAsphaltCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.WaterPressureAsphaltCover]), results[i].WaterPressureAsphaltCover);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverErosionOutwards]), results[i].GrassCoverErosionOutwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffOutwards]), results[i].GrassCoverSlipOffOutwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.GrassCoverSlipOffInwards]), results[i].GrassCoverSlipOffInwards);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.HeightStructures]), results[i].HeightStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.ClosingStructures]), results[i].ClosingStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.PipingStructure]), results[i].PipingStructure);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.StabilityPointStructures]), results[i].StabilityPointStructures);
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[assessmentSection.DuneErosion]), results[i].DuneErosion);
Assert.AreEqual(assessmentSection.SpecificFailureMechanisms.Count, results[i].SpecificFailureMechanisms.Length);
foreach (SpecificFailureMechanism specificFailureMechanism in assessmentSection.SpecificFailureMechanisms)
{
Assert.AreEqual(assemblyResult.FailureMechanismSectionAssemblyGroupResults.ElementAt(failureMechanisms[specificFailureMechanism]), results[i].SpecificFailureMechanisms.Single());
}
Assert.AreEqual(output.CommonSectionAssemblyMethod, results[i].CommonSectionAssemblyMethod);
Assert.AreEqual(output.FailureMechanismResultsAssemblyMethod, results[i].FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(output.CombinedSectionResultAssemblyMethod, results[i].CombinedSectionResultAssemblyMethod);
}
}
/// <summary>
/// Creates a collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/> based
/// on the given <paramref name="output"/> and <paramref name="failureMechanisms"/>.
/// </summary>
/// <param name="output">The output to create the results for.</param>
/// <param name="failureMechanisms">The failure mechanisms to create the results for.</param>
/// <param name="assessmentSection">The assessment section to use while creating the results.</param>
/// <returns>A collection of <see cref="CombinedFailureMechanismSectionAssemblyResult"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <CombinedFailureMechanismSectionAssemblyResult> Create(CombinedFailureMechanismSectionAssemblyResultWrapper output,
IDictionary <IFailureMechanism, int> failureMechanisms,
AssessmentSection assessmentSection)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
if (failureMechanisms == null)
{
throw new ArgumentNullException(nameof(failureMechanisms));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(output.AssemblyResults.Select(assembly => new CombinedFailureMechanismSectionAssemblyResult(
assembly.Section.SectionStart,
assembly.Section.SectionEnd,
assembly.Section.FailureMechanismSectionAssemblyGroup,
output.CommonSectionAssemblyMethod,
output.FailureMechanismResultsAssemblyMethod,
output.CombinedSectionResultAssemblyMethod,
CreateFailureMechanismResults(assembly.FailureMechanismSectionAssemblyGroupResults,
failureMechanisms, assessmentSection)))
.ToArray());
}
