protected override void AddSectionDependentData(FailureMechanismSection section)
{
((ObservableList <TestFailureMechanismSectionResult>)SectionResults).Add(new TestFailureMechanismSectionResult(section));
}
/// <inheritdoc />
/// <summary>
/// Creates a new instance of <see cref="NonAdoptableInitialFailureMechanismResultType"/>.
/// </summary>
public NonAdoptableFailureMechanismSectionResult(FailureMechanismSection section) : base(section)
{
InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.Manual;
}
/// <inheritdoc />
public TestFailureMechanismSectionResult(FailureMechanismSection section) : base(section)
{
}
private static StabilityStoneCoverFailureMechanism CreateFullyConfiguredFailureMechanism()
{
var section1 = new FailureMechanismSection("A", new[]
{
new Point2D(-1, 0),
new Point2D(2, 0)
});
var section2 = new FailureMechanismSection("B", new[]
{
new Point2D(2, 0),
new Point2D(4, 0)
});
var failureMechanism = new StabilityStoneCoverFailureMechanism();
failureMechanism.SetSections(new[]
{
section1,
section2
}, "some/path/to/sections");
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 0, 0);
var calculation = new StabilityStoneCoverWaveConditionsCalculation();
var calculationWithOutput = new StabilityStoneCoverWaveConditionsCalculation
{
Output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create()
};
var calculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
},
Output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create()
};
var calculationWithHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var subCalculation = new StabilityStoneCoverWaveConditionsCalculation();
var subCalculationWithOutput = new StabilityStoneCoverWaveConditionsCalculation
{
Output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create()
};
var subCalculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
},
Output = StabilityStoneCoverWaveConditionsOutputTestFactory.Create()
};
var subCalculationWithHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
failureMechanism.CalculationsGroup.Children.Add(calculation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Children =
{
subCalculation,
subCalculationWithOutput,
subCalculationWithOutputAndHydraulicBoundaryLocation,
subCalculationWithHydraulicBoundaryLocation
}
});
return(failureMechanism);
}
protected override IEnumerable <MacroStabilityInwardsScenarioRow> GetScenarioRows(FailureMechanismSection failureMechanismSection)
{
IEnumerable <Segment2D> lineSegments = Math2D.ConvertPointsToLineSegments(failureMechanismSection.Points);
IEnumerable <MacroStabilityInwardsCalculationScenario> calculations = CalculationGroup
.GetCalculations()
.OfType <MacroStabilityInwardsCalculationScenario>()
.Where(pc => pc.IsSurfaceLineIntersectionWithReferenceLineInSection(lineSegments));
return(calculations.Select(pc => new MacroStabilityInwardsScenarioRow(pc, FailureMechanism, failureMechanismSection)).ToList());
}
/// <summary>
/// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/>.
/// </summary>
/// <param name="factorOfStability">The value for <see cref="MacroStabilityInwardsOutput.FactorOfStability"/>.</param>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateMacroStabilityInwardsCalculationScenario(double factorOfStability,
FailureMechanismSection section)
{
MacroStabilityInwardsCalculationScenario scenario = CreateNotCalculatedMacroStabilityInwardsCalculationScenario(section);
scenario.Output = MacroStabilityInwardsOutputTestFactory.CreateOutput(new MacroStabilityInwardsOutput.ConstructionProperties
{
FactorOfStability = factorOfStability
});
return(scenario);
}
/// <summary>
/// Creates a scenario for which the surface line on the input intersects with <paramref name="section"/> and
/// is marked as not relevant for the assessment.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateIrrelevantMacroStabilityInwardsCalculationScenario(FailureMechanismSection section)
{
MacroStabilityInwardsCalculationScenario scenario = CreateMacroStabilityInwardsCalculationScenario(0.2, section);
scenario.IsRelevant = false;
return(scenario);
}
protected override IEnumerable <TestScenarioRow> GetScenarioRows(FailureMechanismSection failureMechanismSection)
{
return(CalculationGroup.Children.OfType <TestCalculationScenario>()
.Select(calculationScenario => new TestScenarioRow(calculationScenario))
.ToList());
}
/// <summary>
/// Configures a <see cref="PipingFailureMechanism"/> to a fully configured failure
/// mechanism with all possible parent and nested calculation configurations.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to be updated.</param>
/// <param name="hydraulicBoundaryLocation">The hydraulic boundary location used
/// by calculations.</param>
/// <remarks>This method assumes <paramref name="failureMechanism"/> is a newly
/// created instance.</remarks>
public static void ConfigureFailureMechanismWithAllCalculationConfigurations(PipingFailureMechanism failureMechanism,
HydraulicBoundaryLocation hydraulicBoundaryLocation)
{
var surfaceLine1 = new PipingSurfaceLine("Line A")
{
ReferenceLineIntersectionWorldPoint = new Point2D(0, 5)
};
surfaceLine1.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(0, 10, 0)
});
var surfaceLine2 = new PipingSurfaceLine("Line B")
{
ReferenceLineIntersectionWorldPoint = new Point2D(10, 5)
};
surfaceLine2.SetGeometry(new[]
{
new Point3D(10, 0, 0),
new Point3D(10, 10, 0)
});
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLine1,
surfaceLine2
}, "some/path/to/surfacelines");
var stochasticSoilModel1 = new PipingStochasticSoilModel("A", new[]
{
new Point2D(-5, 5),
new Point2D(5, 5)
}, new[]
{
new PipingStochasticSoilProfile(1.0, PipingSoilProfileTestFactory.CreatePipingSoilProfile())
});
var stochasticSoilModel2 = new PipingStochasticSoilModel("C", new[]
{
new Point2D(5, 5),
new Point2D(15, 5)
}, new[]
{
new PipingStochasticSoilProfile(1.0, PipingSoilProfileTestFactory.CreatePipingSoilProfile())
});
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel1,
stochasticSoilModel2
}, "some/path/to/stochasticsoilmodels");
var calculation = new TestPipingCalculationScenario();
var calculationWithOutput = new TestPipingCalculationScenario(true)
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
SurfaceLine = surfaceLine1,
StochasticSoilModel = stochasticSoilModel1
}
};
var calculationWithSurfaceLineAndSoilModel = new TestPipingCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
SurfaceLine = surfaceLine1,
StochasticSoilModel = stochasticSoilModel1,
StochasticSoilProfile = stochasticSoilModel1.StochasticSoilProfiles.First()
}
};
var calculationWithOutputAndHydraulicBoundaryLocation = new TestPipingCalculationScenario(true)
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
SurfaceLine = surfaceLine2,
StochasticSoilModel = stochasticSoilModel2
}
};
var calculationWithHydraulicBoundaryLocation = new TestPipingCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var calculationWithSurfaceLineAndStochasticSoilModel = new TestPipingCalculationScenario
{
InputParameters =
{
SurfaceLine = surfaceLine1,
StochasticSoilModel = stochasticSoilModel2,
StochasticSoilProfile = stochasticSoilModel2.StochasticSoilProfiles.First()
}
};
var subCalculation = new TestPipingCalculationScenario();
var subCalculationWithOutput = new TestPipingCalculationScenario(true)
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
SurfaceLine = surfaceLine2,
StochasticSoilModel = stochasticSoilModel2,
StochasticSoilProfile = stochasticSoilModel2.StochasticSoilProfiles.First()
}
};
var subCalculationWithOutputAndHydraulicBoundaryLocation = new TestPipingCalculationScenario(true)
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
SurfaceLine = surfaceLine1,
StochasticSoilModel = stochasticSoilModel1,
StochasticSoilProfile = stochasticSoilModel1.StochasticSoilProfiles.First()
}
};
var subCalculationWithHydraulicBoundaryLocation = new TestPipingCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var subCalculationWithSurfaceLineAndStochasticSoilModel = new TestPipingCalculationScenario
{
InputParameters =
{
SurfaceLine = surfaceLine1,
StochasticSoilModel = stochasticSoilModel2,
StochasticSoilProfile = stochasticSoilModel2.StochasticSoilProfiles.First()
}
};
failureMechanism.CalculationsGroup.Children.Add(calculation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
failureMechanism.CalculationsGroup.Children.Add(calculationWithSurfaceLineAndSoilModel);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithSurfaceLineAndStochasticSoilModel);
failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Children =
{
subCalculation,
subCalculationWithOutput,
subCalculationWithOutputAndHydraulicBoundaryLocation,
subCalculationWithHydraulicBoundaryLocation,
subCalculationWithSurfaceLineAndStochasticSoilModel
}
});
var section1 = new FailureMechanismSection("1",
new[]
{
new Point2D(-1, -1),
new Point2D(5, 5)
});
var section2 = new FailureMechanismSection("2",
new[]
{
new Point2D(5, 5),
new Point2D(15, 15)
});
failureMechanism.SetSections(new[]
{
section1,
section2
}, "path/to/sections");
}
/// <summary>
/// Creates a scenario for which the dike profile on the input intersects with <paramref name="section"/> and
/// the calculation has not been performed.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static GrassCoverErosionInwardsCalculationScenario CreateNotCalculatedGrassCoverErosionInwardsCalculationScenario(FailureMechanismSection section)
{
if (section == null)
{
throw new ArgumentNullException(nameof(section));
}
var scenario = new GrassCoverErosionInwardsCalculationScenario
{
IsRelevant = true,
InputParameters =
{
DikeProfile = DikeProfileTestFactory.CreateDikeProfile(section.StartPoint)
}
};
return(scenario);
}
private HeightStructuresFailureMechanism CreateFullyConfiguredFailureMechanism()
{
var section1 = new FailureMechanismSection("A", new[]
{
new Point2D(-1, 0),
new Point2D(2, 0)
});
var section2 = new FailureMechanismSection("B", new[]
{
new Point2D(2, 0),
new Point2D(4, 0)
});
var structure1 = new TestHeightStructure(new Point2D(1, 0), "Id 1,0");
var structure2 = new TestHeightStructure(new Point2D(3, 0), "Id 3,0");
var profile = new TestForeshoreProfile();
StructuresCalculation <HeightStructuresInput> calculation1 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
},
Output = new TestStructuresOutput()
};
StructuresCalculation <HeightStructuresInput> calculation2 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure2
}
};
StructuresCalculation <HeightStructuresInput> calculation3 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
}
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation1,
new CalculationGroup
{
Children =
{
calculation2
}
},
calculation3
}
}
};
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile
}, "path");
failureMechanism.HeightStructures.AddRange(new[]
{
structure1,
structure2
}, "someLocation");
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section1,
section2
});
return(failureMechanism);
}
/// <summary>
/// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/>.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="GrassCoverErosionInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static GrassCoverErosionInwardsCalculationScenario CreateGrassCoverErosionInwardsCalculationScenario(FailureMechanismSection section)
{
GrassCoverErosionInwardsCalculationScenario scenario = CreateNotCalculatedGrassCoverErosionInwardsCalculationScenario(section);
scenario.Output = new TestGrassCoverErosionInwardsOutput();
return(scenario);
}
private static FailureMechanismSection ClipSectionCoordinatesToReferencePoint(Point2D referencePoint, FailureMechanismSection section)
{
return(ArePointsSnapped(referencePoint, section.StartPoint)
? section
: new FailureMechanismSection(section.Name, section.Points.Reverse()));
}
protected override void AddSectionDependentData(FailureMechanismSection section)
{
base.AddSectionDependentData(section);
scenarioConfigurationsPerFailureMechanismSection.Add(new PipingScenarioConfigurationPerFailureMechanismSection(section));
}
/// <summary>
/// Creates a scenario for which the surface line on the input intersects with <paramref name="section"/> and
/// the calculation has not been performed.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateNotCalculatedMacroStabilityInwardsCalculationScenario(FailureMechanismSection section)
{
if (section == null)
{
throw new ArgumentNullException(nameof(section));
}
var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
Point2D p = section.Points.First();
surfaceLine.SetGeometry(new[]
{
new Point3D(p.X, p.Y, 0),
new Point3D(p.X + 2, p.Y + 2, 0)
});
surfaceLine.ReferenceLineIntersectionWorldPoint = section.Points.First();
var scenario = new MacroStabilityInwardsCalculationScenario
{
IsRelevant = true,
InputParameters =
{
SurfaceLine = surfaceLine
}
};
return(scenario);
}
private static FailureMechanismSectionRow CreateFailureMechanismSectionRow(FailureMechanismSection section,
double sectionStart,
double sectionEnd)
{
return(new FailureMechanismSectionRow(section, sectionStart, sectionEnd));
}
/// <summary>
/// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/>.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateMacroStabilityInwardsCalculationScenario(FailureMechanismSection section)
{
MacroStabilityInwardsCalculationScenario scenario = CreateNotCalculatedMacroStabilityInwardsCalculationScenario(section);
scenario.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
return(scenario);
}
public void Constructor_Always_PropertiesHaveExpectedAttributesValues()
{
// Setup
var probabilityAssessmentInput = new TestProbabilityAssessmentInput(0.5, 100);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
// Call
var properties = new FailureMechanismSectionProbabilityAssessmentProperties(section, double.NaN, double.NaN, probabilityAssessmentInput);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(7, dynamicProperties.Count);
PropertyDescriptor nameProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty,
"Algemeen",
"Vaknaam",
"De naam van het vak.",
true);
PropertyDescriptor sectionStartDistanceProperty = dynamicProperties[1];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sectionStartDistanceProperty,
"Algemeen",
"Metrering van* [m]",
"De afstand tussen het beginpunt van het vak en het begin van het traject, gemeten langs het traject in meters (afgerond).",
true);
PropertyDescriptor sectionEndDistanceProperty = dynamicProperties[2];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(sectionEndDistanceProperty,
"Algemeen",
"Metrering tot* [m]",
"De afstand tussen het eindpunt van het vak en het begin van het traject, gemeten langs het traject in meters (afgerond).",
true);
PropertyDescriptor lengthProperty = dynamicProperties[3];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(lengthProperty,
"Algemeen",
"Lengte* [m]",
"De totale lengte van het vak in meters (afgerond).",
true);
PropertyDescriptor startPointProperty = dynamicProperties[4];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(startPointProperty,
"Algemeen",
"Beginpunt",
"Beginpunt van het vak (X-coördinaat, Y-coördinaat).",
true);
PropertyDescriptor endPointProperty = dynamicProperties[5];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(endPointProperty,
"Algemeen",
"Eindpunt",
"Eindpunt van het vak (X-coördinaat, Y-coördinaat).",
true);
PropertyDescriptor nProperty = dynamicProperties[6];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nProperty,
"Algemeen",
"Nvak* [-]",
"Vakspecifieke waarde voor het in rekening brengen van " +
"het lengte-effect tijdens assemblage (afgerond).",
true);
}
/// <summary>
/// Creates a calculated scenario for which the surface line on the input intersects with <paramref name="section"/> and
/// the calculation has <see cref="double.NaN"/> as factor of stability.
/// </summary>
/// <param name="section">The section for which an intersection will be created.</param>
/// <returns>A new <see cref="MacroStabilityInwardsCalculationScenario"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="section"/> is <c>null</c>.</exception>
public static MacroStabilityInwardsCalculationScenario CreateMacroStabilityInwardsCalculationScenarioWithNaNOutput(FailureMechanismSection section)
{
return(CreateMacroStabilityInwardsCalculationScenario(double.NaN, section));
}
private FailureMechanismSectionProbabilityAssessmentRow CreateFailureMechanismSectionProbabilityAssessmentRow(FailureMechanismSection section,
double sectionStart,
double sectionEnd)
{
return(new FailureMechanismSectionProbabilityAssessmentRow(section, sectionStart, sectionEnd, probabilityAssessmentInput));
}
private static SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy CreateStrategyForMultipleScenarios(FailureMechanismSection section)
{
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
var calculationScenario3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section);
calculationScenario1.IsRelevant = true;
calculationScenario1.Contribution = (RoundedDouble)0.2111;
calculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(0.01, 0.02, 0.03);
calculationScenario2.IsRelevant = true;
calculationScenario2.Contribution = (RoundedDouble)0.7889;
calculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(0.04, 0.05, 0.06);
calculationScenario3.IsRelevant = false;
SemiProbabilisticPipingCalculationScenario[] calculations =
{
calculationScenario1,
calculationScenario2,
calculationScenario3
};
return(new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(
sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub()));
}
protected override IEnumerable <ClosingStructuresScenarioRow> GetScenarioRows(FailureMechanismSection failureMechanismSection)
{
IEnumerable <Segment2D> lineSegments = Math2D.ConvertPointsToLineSegments(failureMechanismSection.Points);
IEnumerable <StructuresCalculationScenario <ClosingStructuresInput> > calculations = CalculationGroup.GetCalculations()
.OfType <StructuresCalculationScenario <ClosingStructuresInput> >()
.Where(cs => cs.IsStructureIntersectionWithReferenceLineInSection(lineSegments));
return(calculations.Select(c => new ClosingStructuresScenarioRow(c)).ToList());
}
private static PipingScenarioConfigurationPerFailureMechanismSection CreateScenarioConfigurationForSection(FailureMechanismSection section)
{
return(new PipingScenarioConfigurationPerFailureMechanismSection(section));
}
private static FailureMechanismSectionProperties CreateFailureMechanismSectionProperties(FailureMechanismSection section,
double sectionStart,
double sectionEnd)
{
return(new FailureMechanismSectionProperties(section, sectionStart, sectionEnd));
}
private static GrassCoverErosionInwardsFailureMechanism CreateFullyConfiguredFailureMechanism()
{
DikeProfile dikeProfile1 = DikeProfileTestFactory.CreateDikeProfile("Profile 1", "ID 1");
DikeProfile dikeProfile2 = DikeProfileTestFactory.CreateDikeProfile("Profile 2", "ID 2");
var section1 = new FailureMechanismSection("A", new[]
{
new Point2D(-1, 0),
new Point2D(2, 0)
});
var section2 = new FailureMechanismSection("B", new[]
{
new Point2D(2, 0),
new Point2D(4, 0)
});
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.DikeProfiles.AddRange(new[]
{
dikeProfile1,
dikeProfile2
}, "some/path/to/dikeprofiles");
failureMechanism.SetSections(new[]
{
section1,
section2
}, "some/path/to/sections");
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 0, 0);
var calculation = new GrassCoverErosionInwardsCalculation();
var calculationWithOutput = new GrassCoverErosionInwardsCalculation
{
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0),
new TestDikeHeightOutput(0),
new TestOvertoppingRateOutput(0))
};
var calculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
},
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0),
new TestDikeHeightOutput(0),
new TestOvertoppingRateOutput(0))
};
var calculationWithHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var calculationWithHydraulicBoundaryLocationAndDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
DikeProfile = dikeProfile1
}
};
var calculationWithDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
DikeProfile = dikeProfile2
}
};
var calculationWithOutputHydraulicBoundaryLocationAndDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
DikeProfile = dikeProfile1
},
Output = new TestGrassCoverErosionInwardsOutput()
};
var subCalculation = new GrassCoverErosionInwardsCalculation();
var subCalculationWithOutput = new GrassCoverErosionInwardsCalculation
{
Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(0),
new TestDikeHeightOutput(0),
new TestOvertoppingRateOutput(0))
};
var subCalculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
},
Output = new TestGrassCoverErosionInwardsOutput()
};
var subCalculationWithHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation
}
};
var subCalculationWithHydraulicBoundaryLocationAndDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
DikeProfile = dikeProfile1
}
};
var subCalculationWithDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
DikeProfile = dikeProfile2
}
};
var subCalculationWithOutputHydraulicBoundaryLocationAndDikeProfile = new GrassCoverErosionInwardsCalculation
{
InputParameters =
{
HydraulicBoundaryLocation = hydraulicBoundaryLocation,
DikeProfile = dikeProfile1
},
Output = new TestGrassCoverErosionInwardsOutput()
};
failureMechanism.CalculationsGroup.Children.Add(calculation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculationWithDikeProfile);
failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocationAndDikeProfile);
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputHydraulicBoundaryLocationAndDikeProfile);
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Children =
{
subCalculation,
subCalculationWithOutput,
subCalculationWithOutputAndHydraulicBoundaryLocation,
subCalculationWithHydraulicBoundaryLocation,
subCalculationWithDikeProfile,
subCalculationWithHydraulicBoundaryLocationAndDikeProfile,
subCalculationWithOutputHydraulicBoundaryLocationAndDikeProfile
}
});
return(failureMechanism);
}
/// <inheritdoc />
/// <summary>
/// Creates a new instance of <see cref="AdoptableFailureMechanismSectionResult"/>.
/// </summary>
public AdoptableFailureMechanismSectionResult(FailureMechanismSection section) : base(section)
{
InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Adopt;
}
