/// <summary>
/// Asserts whether the <see cref="PersistableDataModel"/> contains the data
/// that is representative for the <paramref name="calculation"/>
/// and the <paramref name="filePath"/>.
/// </summary>
/// <param name="calculation">The calculation that contains the original data.</param>
/// <param name="filePath">The file path that is used.</param>
/// <param name="persistableDataModel">The <see cref="PersistableDataModel"/> that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when the data in <paramref name="persistableDataModel"/>
/// is not correct.</exception>
public static void AssertPersistableDataModel(MacroStabilityInwardsCalculation calculation, string filePath, PersistableDataModel persistableDataModel)
{
AssertProjectInfo(calculation, filePath, persistableDataModel.Info);
AssertCalculationSettings(calculation.Output.SlidingCurve, persistableDataModel.CalculationSettings);
IEnumerable <MacroStabilityInwardsSoilLayer2D> layers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(calculation.InputParameters.SoilProfileUnderSurfaceLine.Layers);
AssertPersistableSoils(layers, persistableDataModel.Soils.Soils);
AssertPersistableGeometry(layers, persistableDataModel.Geometry);
AssertPersistableSoilLayers(layers, persistableDataModel.SoilLayers, persistableDataModel.Soils.Soils, persistableDataModel.Geometry);
AssertWaternets(new[]
{
DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput()),
DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN)
}, persistableDataModel.Waternets);
AssertWaternetCreatorSettings(calculation.InputParameters, persistableDataModel.WaternetCreatorSettings, AssessmentSectionTestHelper.GetTestAssessmentLevel(), new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
});
AssertStates(calculation.InputParameters.SoilProfileUnderSurfaceLine, persistableDataModel.States);
Assert.IsNull(persistableDataModel.AssessmentResults);
Assert.IsNull(persistableDataModel.Decorations);
Assert.IsNull(persistableDataModel.Loads);
Assert.IsNull(persistableDataModel.NailPropertiesForSoils);
Assert.IsNull(persistableDataModel.Reinforcements);
Assert.IsNull(persistableDataModel.SoilCorrelations);
Assert.IsNull(persistableDataModel.SoilVisualizations);
Assert.IsNull(persistableDataModel.StateCorrelations);
AssertStages(persistableDataModel.Stages, persistableDataModel.CalculationSettings, persistableDataModel.Geometry, persistableDataModel.SoilLayers,
persistableDataModel.Waternets, persistableDataModel.WaternetCreatorSettings, persistableDataModel.States);
}
private static IUpliftVanCalculator GetCalculator(MacroStabilityInwardsCalculation calculation, GeneralMacroStabilityInwardsInput generalInput, RoundedDouble normativeAssessmentLevel)
{
UpliftVanCalculatorInput upliftVanCalculatorInput = CreateInputFromData(calculation.InputParameters, generalInput, normativeAssessmentLevel);
IUpliftVanCalculator calculator = MacroStabilityInwardsCalculatorFactory.Instance.CreateUpliftVanCalculator(upliftVanCalculatorInput, MacroStabilityInwardsKernelWrapperFactory.Instance);
return(calculator);
}
/// <summary>
/// Creates a new instance of <see cref="MacroStabilityInwardsCalculationExporter"/>.
/// </summary>
/// <param name="calculation">The calculation to export.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="persistenceFactory">The persistence factory to use.</param>
/// <param name="filePath">The file path to export to.</param>
/// <param name="getNormativeAssessmentLevelFunc"><see cref="Func{TResult}"/>
/// for obtaining the normative assessment level.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>,
/// <paramref name="generalInput"/>, <paramref name="persistenceFactory"/> or
/// <paramref name="getNormativeAssessmentLevelFunc"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <paramref name="filePath"/> is invalid.</exception>
/// <remarks>A valid path:
/// <list type="bullet">
/// <item>is not empty or <c>null</c>,</item>
/// <item>does not consist out of only whitespace characters,</item>
/// <item>does not contain an invalid character,</item>
/// <item>does not end with a directory or path separator (empty file name).</item>
/// </list></remarks>
public MacroStabilityInwardsCalculationExporter(MacroStabilityInwardsCalculation calculation,
GeneralMacroStabilityInwardsInput generalInput,
IPersistenceFactory persistenceFactory,
string filePath, Func <RoundedDouble> getNormativeAssessmentLevelFunc)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (persistenceFactory == null)
{
throw new ArgumentNullException(nameof(persistenceFactory));
}
if (getNormativeAssessmentLevelFunc == null)
{
throw new ArgumentNullException(nameof(getNormativeAssessmentLevelFunc));
}
IOUtils.ValidateFilePath(filePath);
this.calculation = calculation;
this.generalInput = generalInput;
this.persistenceFactory = persistenceFactory;
this.filePath = filePath;
this.getNormativeAssessmentLevelFunc = getNormativeAssessmentLevelFunc;
}
private static void SetPropertyAndVerifyNotificationsForCalculation(Action <MacroStabilityInwardsGridSettingsProperties> setProperty,
MacroStabilityInwardsCalculation calculation)
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
MacroStabilityInwardsInput input = calculation.InputParameters;
var handler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var properties = new MacroStabilityInwardsGridSettingsProperties(input, handler);
// Call
setProperty(properties);
// Assert
Assert.IsTrue(handler.Called);
mocks.VerifyAll();
}
/// <summary>
/// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/>
/// are clones.
/// </summary>
/// <param name="original">The original object.</param>
/// <param name="clone">The cloned object.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="original"/> and
/// <paramref name="clone"/> are not clones.</exception>
public static void AreClones(MacroStabilityInwardsCalculation original,
MacroStabilityInwardsCalculation clone)
{
Assert.AreEqual(original.Name, clone.Name);
CoreCloneAssert.AreObjectClones(original.Comments, clone.Comments, CommonCloneAssert.AreClones);
CoreCloneAssert.AreObjectClones(original.InputParameters, clone.InputParameters, AreClones);
CoreCloneAssert.AreObjectClones(original.Output, clone.Output, AreClones);
}
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
MacroStabilityInwardsCalculation original = CreateRandomCalculationWithoutOutput();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void Calculations_AddCalculation_ItemIsAddedToCollection()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
// Call
failureMechanism.CalculationsGroup.Children.Add(calculation);
// Assert
CollectionAssert.Contains(failureMechanism.CalculationsGroup.Children, calculation);
}
public void UpdateSurfaceLinesWithImportedData_WithCalculationAssignedToRemovedLine_UpdatesCalculationAndDoesNotRemoveStochasticSoilInputs()
{
// Setup
var soilModel = new MacroStabilityInwardsStochasticSoilModel("A", new[]
{
new Point2D(2, -1),
new Point2D(2, 1)
}, new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.2, MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D())
});
MacroStabilityInwardsSurfaceLine surfaceLine = CreateValidSurfaceLineForCalculations();
var calculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = surfaceLine,
StochasticSoilModel = soilModel,
StochasticSoilProfile = soilModel.StochasticSoilProfiles.ElementAt(0)
}
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculation);
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLine
}, "path");
failureMechanism.StochasticSoilModels.AddRange(new[]
{
soilModel
}, "path");
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
"path").ToArray();
// Assert
MacroStabilityInwardsInput calculationInput = calculation.InputParameters;
CollectionAssert.AreEquivalent(new IObservable[]
{
failureMechanism.SurfaceLines,
calculationInput
}, affectedObjects);
Assert.IsNull(calculationInput.SurfaceLine);
Assert.AreSame(soilModel, calculationInput.StochasticSoilModel);
Assert.AreSame(soilModel.StochasticSoilProfiles.ElementAt(0), calculationInput.StochasticSoilProfile);
}
public void UpdateSurfaceLinesWithImportedData_CalculationWithSameReferences_OnlyReturnsDistinctCalculation()
{
// Setup
const string updatedSurfaceLineName = "Name A";
var affectedSurfaceLine = new MacroStabilityInwardsSurfaceLine(updatedSurfaceLineName);
affectedSurfaceLine.SetGeometry(new[]
{
new Point3D(1, 2, 3),
new Point3D(4, 5, 6)
});
var affectedCalculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = affectedSurfaceLine
},
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(affectedCalculation);
failureMechanism.CalculationsGroup.Children.Add(affectedCalculation);
failureMechanism.SurfaceLines.AddRange(new[]
{
affectedSurfaceLine
}, "path");
MacroStabilityInwardsSurfaceLine importedSurfaceLine = DeepCloneAndModifyPoints(affectedSurfaceLine);
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(new[]
{
importedSurfaceLine
}, "path").ToArray();
// Assert
CollectionAssert.AreEquivalent(new IObservable[]
{
failureMechanism.SurfaceLines,
affectedSurfaceLine,
affectedCalculation,
affectedCalculation.InputParameters
}, affectedObjects);
}
public void HasOutput_OutputSet_ReturnsTrue()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
// Call
bool hasOutput = calculation.HasOutput;
// Assert
Assert.IsTrue(hasOutput);
}
/// <summary>
/// Asserts whether the <see cref="PersistableProjectInfo"/> contains the data
/// that is representative for the <paramref name="calculation"/>
/// and the <paramref name="filePath"/>.
/// </summary>
/// <param name="calculation">The calculation that contains the original data.</param>
/// <param name="filePath">The file path that is used.</param>
/// <param name="persistableProjectInfo">The <see cref="PersistableProjectInfo"/> that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when the data in <paramref name="persistableProjectInfo"/>
/// is not correct.</exception>
public static void AssertProjectInfo(MacroStabilityInwardsCalculation calculation, string filePath, PersistableProjectInfo persistableProjectInfo)
{
Assert.AreEqual(filePath, persistableProjectInfo.Path);
Assert.AreEqual(calculation.Name, persistableProjectInfo.Project);
Assert.AreEqual(calculation.InputParameters.SurfaceLine.Name, persistableProjectInfo.CrossSection);
Assert.AreEqual($"Riskeer {AssemblyUtils.GetAssemblyInfo(Assembly.GetAssembly(typeof(PersistableDataModelTestHelper))).Version}", persistableProjectInfo.ApplicationCreated);
Assert.AreEqual("Export from Riskeer", persistableProjectInfo.Remarks);
Assert.IsNotNull(persistableProjectInfo.Created);
Assert.IsNull(persistableProjectInfo.Date);
Assert.IsNull(persistableProjectInfo.LastModified);
Assert.IsNull(persistableProjectInfo.LastModifier);
Assert.IsNull(persistableProjectInfo.Analyst);
Assert.IsTrue(persistableProjectInfo.IsDataValidated);
}
public void ShouldCalculate_OutputSet_ReturnsFalse()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.IsFalse(shouldCalculate);
}
private static MacroStabilityInwardsCalculation CreateRandomCalculationWithoutOutput()
{
var calculation = new MacroStabilityInwardsCalculation
{
Name = "A Name",
Comments =
{
Body = "A comment"
}
};
MacroStabilityInwardsTestDataGenerator.SetRandomMacroStabilityInwardsInput(calculation.InputParameters);
return(calculation);
}
public void ShouldCalculate_OutputNull_ReturnsTrue()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation
{
Output = null
};
// Call
bool shouldCalculate = calculation.ShouldCalculate;
// Assert
Assert.IsTrue(shouldCalculate);
}
public void Calculations_RemoveCalculation_ItemIsRemovedFromCollection()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculation);
// Call
failureMechanism.CalculationsGroup.Children.Remove(calculation);
// Assert
CollectionAssert.DoesNotContain(failureMechanism.CalculationsGroup.Children, calculation);
}
public void ClearOutput_Always_SetsOutputToNull()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
// Call
calculation.ClearOutput();
// Assert
Assert.IsNull(calculation.Output);
}
public void HasOutput_OutputNull_ReturnsFalse()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation
{
Output = null
};
// Call
bool hasOutput = calculation.HasOutput;
// Assert
Assert.IsFalse(hasOutput);
}
public void Constructor_ExpectedValues()
{
// Setup
var calculation = new MacroStabilityInwardsCalculation();
// Call
var activity = new MacroStabilityInwardsCalculationActivity(calculation, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN);
// Assert
Assert.IsInstanceOf <CalculatableActivity>(activity);
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}'", activity.Description);
Assert.IsNull(activity.ProgressText);
Assert.AreEqual(ActivityState.None, activity.State);
}
/// <summary>
/// Creates a new <see cref="PersistableDataModel"/>.
/// </summary>
/// <param name="calculation">The calculation to get the data from.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="getNormativeAssessmentLevelFunc"><see cref="Func{TResult}"/>
/// for obtaining the normative assessment level.</param>
/// <param name="filePath">The filePath that is used.</param>
/// <returns>A created <see cref="PersistableDataModel"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>,
/// <paramref name="generalInput"/> or <paramref name="getNormativeAssessmentLevelFunc"/> is <c>null</c>.</exception>
/// <exception cref="InvalidOperationException">Thrown when <paramref name="calculation"/>
/// has no output.</exception>
public static PersistableDataModel Create(MacroStabilityInwardsCalculation calculation,
GeneralMacroStabilityInwardsInput generalInput,
Func <RoundedDouble> getNormativeAssessmentLevelFunc,
string filePath)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (getNormativeAssessmentLevelFunc == null)
{
throw new ArgumentNullException(nameof(getNormativeAssessmentLevelFunc));
}
if (!calculation.HasOutput)
{
throw new InvalidOperationException("Calculation must have output.");
}
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
MacroStabilityInwardsInput input = calculation.InputParameters;
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = input.SoilProfileUnderSurfaceLine;
return(new PersistableDataModel
{
Info = PersistableProjectInfoFactory.Create(calculation, filePath),
CalculationSettings = PersistableCalculationSettingsFactory.Create(calculation.Output.SlidingCurve, idFactory, registry),
Soils = PersistableSoilCollectionFactory.Create(soilProfile, idFactory, registry),
Geometry = PersistableGeometryFactory.Create(soilProfile, idFactory, registry),
SoilLayers = PersistableSoilLayerCollectionFactory.Create(soilProfile, idFactory, registry),
Waternets = PersistableWaternetFactory.Create(
DerivedMacroStabilityInwardsInput.GetWaternetDaily(input, generalInput),
DerivedMacroStabilityInwardsInput.GetWaternetExtreme(input, generalInput, GetEffectiveAssessmentLevel(input, getNormativeAssessmentLevelFunc)),
generalInput, idFactory, registry),
WaternetCreatorSettings = PersistableWaternetCreatorSettingsFactory.Create(input, GetEffectiveAssessmentLevel(input, getNormativeAssessmentLevelFunc),
idFactory, registry),
States = PersistableStateFactory.Create(soilProfile, idFactory, registry),
Stages = PersistableStageFactory.Create(idFactory, registry)
});
}
/// <summary>
/// Creates a new instance of <see cref="MacroStabilityInwardsCalculationActivity"/>.
/// </summary>
/// <param name="calculation">The macro stability inwards calculation to perform.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="normativeAssessmentLevel">The normative assessment level to use in case the manual assessment level is not applicable.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public MacroStabilityInwardsCalculationActivity(MacroStabilityInwardsCalculation calculation,
GeneralMacroStabilityInwardsInput generalInput,
RoundedDouble normativeAssessmentLevel)
: base(calculation)
{
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
this.calculation = calculation;
this.normativeAssessmentLevel = normativeAssessmentLevel;
this.generalInput = generalInput;
Description = string.Format(RiskeerCommonServiceResources.Perform_calculation_with_name_0_, calculation.Name);
}
public void Constructor_ExpectedValues()
{
// Call
var calculation = new MacroStabilityInwardsCalculation();
// Assert
Assert.IsInstanceOf <ICalculation <MacroStabilityInwardsInput> >(calculation);
Assert.IsInstanceOf <CloneableObservable>(calculation);
Assert.AreEqual("Nieuwe berekening", calculation.Name);
Assert.IsInstanceOf <MacroStabilityInwardsInput>(calculation.InputParameters);
Assert.IsNull(calculation.Comments.Body);
Assert.IsNull(calculation.Output);
}
/// <summary>
/// Creates a new instance of <see cref="PersistableProjectInfo"/>.
/// </summary>
/// <param name="calculation">The calculation to use.</param>
/// <param name="filePath">The file path to use.</param>
/// <returns>A created <see cref="PersistableProjectInfo"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>
/// is <c>null</c>.</exception>
public static PersistableProjectInfo Create(MacroStabilityInwardsCalculation calculation, string filePath)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
return(new PersistableProjectInfo
{
Path = filePath,
Project = calculation.Name,
CrossSection = calculation.InputParameters.SurfaceLine.Name,
ApplicationCreated = string.Format(Resources.PersistableProjectInfoFactory_Create_Riskeer_Version_0,
AssemblyUtils.GetAssemblyInfo(Assembly.GetAssembly(typeof(PersistableProjectInfoFactory))).Version),
Remarks = Resources.PersistableProjectInfoFactory_Create_Export_from_Riskeer,
Created = DateTime.Now,
IsDataValidated = true
});
}
private bool ExportCalculation(MacroStabilityInwardsCalculation calculation, string currentFolderPath, List <string> exportedCalculations)
{
string uniqueName = NamingHelper.GetUniqueName(exportedCalculations, ((ICalculationBase)calculation).Name, c => c);
string calculationFilePath = GetCalculationFilePath(currentFolderPath, uniqueName);
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, generalInput, persistenceFactory, calculationFilePath, () => getNormativeAssessmentLevelFunc(calculation));
bool exportSucceeded = exporter.Export();
if (!exportSucceeded)
{
log.ErrorFormat("{0} {1}", string.Format(Resources.MacroStabilityInwardsCalculationGroupExporter_ExportCalculation_Unexpected_error_during_export_CalculationName_0, calculation.Name),
Resources.MacroStabilityInwardsCalculationExporter_Export_no_stability_project_exported);
return(false);
}
exportedCalculations.Add(uniqueName);
itemExported = true;
return(true);
}
public void UpdateSurfaceLinesWithImportedData_CalculationWithOutputAndAssignedLineDeleted_ClearsCalculationOutput()
{
// Setup
MacroStabilityInwardsSurfaceLine surfaceLine = CreateValidSurfaceLineForCalculations();
var calculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = surfaceLine
},
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculation);
MacroStabilityInwardsSurfaceLineCollection surfaceLineCollection = failureMechanism.SurfaceLines;
surfaceLineCollection.AddRange(new[]
{
surfaceLine
}, sourceFilePath);
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
sourceFilePath).ToArray();
// Assert
Assert.IsFalse(calculation.HasOutput);
Assert.IsNull(calculation.InputParameters.SurfaceLine);
CollectionAssert.AreEquivalent(new IObservable[]
{
surfaceLineCollection,
calculation,
calculation.InputParameters
}, affectedObjects);
}
/// <summary>
/// Creates a <see cref="CalculatableActivity"/> based on the given <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The calculation to create an activity for.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="assessmentSection">The assessment section the <paramref name="calculation"/>
/// belongs to.</param>
/// <returns>A <see cref="CalculatableActivity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static CalculatableActivity CreateCalculationActivity(MacroStabilityInwardsCalculation calculation,
GeneralMacroStabilityInwardsInput generalInput,
IAssessmentSection assessmentSection)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
return(new MacroStabilityInwardsCalculationActivity(calculation,
generalInput,
assessmentSection.GetNormativeAssessmentLevel(calculation.InputParameters.HydraulicBoundaryLocation)));
}
public void UpdateSurfaceLinesWithImportedData_MultipleCalculationsWithSurfaceLinesOneWithRemovedLine_OnlyUpdatesCalculationWithRemovedSurfaceLine()
{
// Setup
const string removedSurfaceLineName = "Name A";
const string unaffectedSurfaceLineName = "Name B";
var removedSurfaceLine = new MacroStabilityInwardsSurfaceLine(removedSurfaceLineName);
removedSurfaceLine.SetGeometry(new[]
{
new Point3D(1, 2, 3),
new Point3D(4, 5, 6)
});
var affectedCalculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = removedSurfaceLine
},
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var unaffectedGeometry = new[]
{
new Point3D(10, 9, 8),
new Point3D(7, 6, 5)
};
var unaffectedSurfaceLine = new MacroStabilityInwardsSurfaceLine(unaffectedSurfaceLineName);
unaffectedSurfaceLine.SetGeometry(unaffectedGeometry);
var unAffectedCalculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = unaffectedSurfaceLine
},
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsSurfaceLineCollection collection = failureMechanism.SurfaceLines;
collection.AddRange(new[]
{
removedSurfaceLine,
unaffectedSurfaceLine
}, sourceFilePath);
failureMechanism.CalculationsGroup.Children.Add(affectedCalculation);
failureMechanism.CalculationsGroup.Children.Add(unAffectedCalculation);
MacroStabilityInwardsSurfaceLine importedUnaffectedSurfaceLine = DeepCloneName(unaffectedSurfaceLine);
importedUnaffectedSurfaceLine.SetGeometry(unaffectedGeometry);
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(new[]
{
importedUnaffectedSurfaceLine
}, "path").ToArray();
// Assert
Assert.IsTrue(unAffectedCalculation.HasOutput);
MacroStabilityInwardsInput unaffectedInput = unAffectedCalculation.InputParameters;
Assert.AreSame(unaffectedSurfaceLine, unaffectedInput.SurfaceLine);
Assert.AreEqual(unaffectedSurfaceLine, unaffectedInput.SurfaceLine);
Assert.IsFalse(affectedCalculation.HasOutput);
MacroStabilityInwardsInput affectedInput = affectedCalculation.InputParameters;
Assert.IsNull(affectedInput.SurfaceLine);
CollectionAssert.AreEquivalent(new IObservable[]
{
collection,
affectedCalculation,
affectedInput
}, affectedObjects);
}
private IEnumerable <MacroStabilityInwardsStochasticSoilModel> GetSoilModelsForCalculation(MacroStabilityInwardsCalculation calculation)
{
return(MacroStabilityInwardsCalculationConfigurationHelper.GetStochasticSoilModelsForSurfaceLine(
calculation.InputParameters.SurfaceLine,
FailureMechanism.StochasticSoilModels));
}
public void UpdateSurfaceLinesWithImportedData_MultipleCalculations_OnlyUpdatesCalculationWithUpdatedSurfaceLine()
{
// Setup
const string updatedSurfaceLineName = "Name A";
var affectedSurfaceLine = new MacroStabilityInwardsSurfaceLine(updatedSurfaceLineName);
affectedSurfaceLine.SetGeometry(new[]
{
new Point3D(1, 2, 3),
new Point3D(4, 5, 6)
});
var affectedCalculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = affectedSurfaceLine
}
};
var unaffectedGeometry = new[]
{
new Point3D(10, 9, 8),
new Point3D(7, 6, 5)
};
var unaffectedSurfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
unaffectedSurfaceLine.SetGeometry(unaffectedGeometry);
var unAffectedCalculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = unaffectedSurfaceLine
}
};
MacroStabilityInwardsStochasticSoilModel[] soilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A", new[]
{
new Point2D(2, -1),
new Point2D(2, 1)
}),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("C", new[]
{
new Point2D(-2, -1),
new Point2D(-2, 1)
})
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(affectedCalculation);
failureMechanism.CalculationsGroup.Children.Add(unAffectedCalculation);
failureMechanism.SurfaceLines.AddRange(new[]
{
affectedSurfaceLine
}, "path");
failureMechanism.StochasticSoilModels.AddRange(soilModels, "path");
MacroStabilityInwardsSurfaceLine importedSurfaceLine = DeepCloneName(affectedSurfaceLine);
importedSurfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(10, 0, 0)
});
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(new[]
{
importedSurfaceLine
}, "path").ToArray();
// Assert
MacroStabilityInwardsInput affectedInput = affectedCalculation.InputParameters;
CollectionAssert.AreEquivalent(new IObservable[]
{
failureMechanism.SurfaceLines,
affectedInput,
affectedSurfaceLine
}, affectedObjects);
Assert.AreSame(affectedSurfaceLine, affectedInput.SurfaceLine);
CollectionAssert.AreEqual(importedSurfaceLine.Points, affectedSurfaceLine.Points);
Assert.AreEqual(soilModels[0], affectedInput.StochasticSoilModel);
MacroStabilityInwardsInput unaffectedInput = unAffectedCalculation.InputParameters;
Assert.AreSame(unaffectedSurfaceLine, unaffectedInput.SurfaceLine);
CollectionAssert.AreEqual(unaffectedGeometry, unaffectedSurfaceLine.Points);
Assert.IsNull(unaffectedInput.StochasticSoilModel);
}
private static IEnumerable <MacroStabilityInwardsStochasticSoilProfile> GetSoilProfilesForCalculation(MacroStabilityInwardsCalculation calculation)
{
return(calculation.InputParameters.StochasticSoilModel != null
? calculation.InputParameters.StochasticSoilModel.StochasticSoilProfiles
: Enumerable.Empty <MacroStabilityInwardsStochasticSoilProfile>());
}
public void UpdateSurfaceLinesWithImportedData_WithCalculationAssignedToUpdatedLineAndMultipleMatchingSoilModels_UpdatesCalculationAndStochasticSoilModelToNull()
{
// Setup
MacroStabilityInwardsStochasticSoilModel[] soilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A", new[]
{
new Point2D(2, -1),
new Point2D(2, 1)
}),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("C", new[]
{
new Point2D(-2, -1),
new Point2D(-2, 1)
}),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("E", new[]
{
new Point2D(6, -1),
new Point2D(6, 1)
})
};
MacroStabilityInwardsSurfaceLine surfaceLine = CreateValidSurfaceLineForCalculations();
var calculation = new MacroStabilityInwardsCalculation
{
InputParameters =
{
SurfaceLine = surfaceLine,
StochasticSoilModel = soilModels[1]
}
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculation);
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLine
}, "path");
failureMechanism.StochasticSoilModels.AddRange(soilModels, "path");
MacroStabilityInwardsSurfaceLine importedSurfaceLine = DeepCloneName(surfaceLine);
importedSurfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(10, 0, 0)
});
var strategy = new MacroStabilityInwardsSurfaceLineUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(new[]
{
importedSurfaceLine
}, "path").ToArray();
// Assert
MacroStabilityInwardsInput calculationInput = calculation.InputParameters;
CollectionAssert.AreEquivalent(new IObservable[]
{
failureMechanism.SurfaceLines,
surfaceLine,
calculationInput
}, affectedObjects);
Assert.AreSame(surfaceLine, calculationInput.SurfaceLine);
CollectionAssert.AreEqual(importedSurfaceLine.Points, surfaceLine.Points);
Assert.IsNull(calculationInput.StochasticSoilModel);
}
