public void Update_ModelWithUpdatedProperties_PropertiesUpdated()
{
// Setup
var model = new MacroStabilityInwardsStochasticSoilModel("name", new[]
{
new Point2D(1, 2),
new Point2D(4, 5)
}, new[]
{
CreateStochasticSoilProfile()
});
const string expectedName = "otherName";
var otherModel = new MacroStabilityInwardsStochasticSoilModel(expectedName, new[]
{
new Point2D(4, 2)
}, new[]
{
CreateStochasticSoilProfile()
});
// Call
MacroStabilityInwardsStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
AssertStochasticSoilModelAreEqual(otherModel, model);
CollectionAssert.IsEmpty(difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
public void ContextMenuStrip_Always_CallsBuilder()
{
// Setup
MacroStabilityInwardsStochasticSoilModel model = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var mocks = new MockRepository();
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
using (var treeViewControl = new TreeViewControl())
{
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(model, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(model, null, treeViewControl);
}
// Assert
mocks.VerifyAll();
}
public void Update_ModelWithAddedProfile_ProfileAdded()
{
// Setup
MacroStabilityInwardsStochasticSoilModel model = CreateValidModel(new[]
{
CreateStochasticSoilProfile()
});
var expectedAddedProfile = new MacroStabilityInwardsStochasticSoilProfile(0.2, new TestSoilProfile("Added Profile"));
MacroStabilityInwardsStochasticSoilModel otherModel = CreateValidModel(new[]
{
CreateStochasticSoilProfile(),
expectedAddedProfile
});
// Call
MacroStabilityInwardsStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
AssertStochasticSoilModelAreEqual(otherModel, model);
CollectionAssert.AreEqual(new[]
{
expectedAddedProfile
}, difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
/// <summary>
/// Creates a <see cref="StochasticSoilModelEntity"/> based on the information of the
/// <see cref="MacroStabilityInwardsStochasticSoilModel"/>.
/// </summary>
/// <param name="model">The model to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">Index at which this instance resides inside its parent container.</param>
/// <returns>A new <see cref="StochasticSoilModelEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
public static StochasticSoilModelEntity Create(this MacroStabilityInwardsStochasticSoilModel model,
PersistenceRegistry registry,
int order)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(model))
{
return(registry.Get(model));
}
var entity = new StochasticSoilModelEntity
{
Name = model.Name.DeepClone(),
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(model.Geometry),
Order = order
};
AddEntitiesForStochasticSoilProfiles(model, registry, entity);
registry.Register(entity, model);
return(entity);
}
/// <summary>
/// Tries to assign the stochastic soil model.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="calculation">The calculation to configure.</param>
/// <returns><c>false</c> when
/// <list type="bullet">
/// <item>the <paramref name="calculationConfiguration"/> has a <see cref="MacroStabilityInwardsStochasticSoilModel"/>
/// set which is not available in the failure mechanism.</item>
/// <item>The <see cref="MacroStabilityInwardsStochasticSoilModel"/> does not intersect
/// with the <see cref="MacroStabilityInwardsSurfaceLine"/>
/// when this is set.</item>
/// </list>
/// <c>true</c> otherwise.</returns>
private bool TrySetStochasticSoilModel(MacroStabilityInwardsCalculationConfiguration calculationConfiguration,
MacroStabilityInwardsCalculationScenario calculation)
{
if (calculationConfiguration.StochasticSoilModelName == null)
{
return(true);
}
MacroStabilityInwardsStochasticSoilModel soilModel = failureMechanism.StochasticSoilModels
.FirstOrDefault(ssm => ssm.Name == calculationConfiguration.StochasticSoilModelName);
if (soilModel == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.MacroStabilityInwardsCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_exist,
calculationConfiguration.StochasticSoilModelName),
calculation.Name);
return(false);
}
if (calculation.InputParameters.SurfaceLine != null &&
!soilModel.IntersectsWithSurfaceLineGeometry(calculation.InputParameters.SurfaceLine))
{
Log.LogCalculationConversionError(string.Format(
Resources.MacroStabilityInwardsCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_intersect_with_surfaceLine_1,
calculationConfiguration.StochasticSoilModelName,
calculationConfiguration.SurfaceLineName),
calculation.Name);
return(false);
}
calculation.InputParameters.StochasticSoilModel = soilModel;
return(true);
}
public void Create_WithStochasticSoilProfiles_ReturnsStochasticSoilModelEntityWithPropertiesSet()
{
// Setup
var stochasticSoilProfiles = new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.1, MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D()),
new MacroStabilityInwardsStochasticSoilProfile(0.9, MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D())
};
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("Model", stochasticSoilProfiles);
var registry = new PersistenceRegistry();
// Call
StochasticSoilModelEntity entity = stochasticSoilModel.Create(registry, 0);
// Assert
Assert.IsNotNull(entity);
CollectionAssert.IsEmpty(entity.PipingStochasticSoilProfileEntities);
Assert.AreEqual(stochasticSoilProfiles.Length, entity.MacroStabilityInwardsStochasticSoilProfileEntities.Count);
MacroStabilityInwardsStochasticSoilProfile firstStochasticSoilProfile = stochasticSoilProfiles[0];
MacroStabilityInwardsStochasticSoilProfileEntity firstStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.First();
Assert.AreEqual(firstStochasticSoilProfile.Probability, firstStochasticSoilProfileEntity.Probability);
Assert.IsNotNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
MacroStabilityInwardsStochasticSoilProfile secondStochasticSoilProfile = stochasticSoilProfiles[1];
MacroStabilityInwardsStochasticSoilProfileEntity secondStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.ElementAt(1);
Assert.AreEqual(secondStochasticSoilProfile.Probability, secondStochasticSoilProfileEntity.Probability);
Assert.IsNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNotNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
}
public void Update_ModelWithUpdatedStochasticSoilProfile_ProfileUpdated()
{
// Setup
const string profileName = "A";
var soilProfile = new MacroStabilityInwardsSoilProfile1D(profileName, -2, CreateLayers1D());
var expectedUpdatedProfile = new MacroStabilityInwardsStochasticSoilProfile(0.2, soilProfile);
MacroStabilityInwardsStochasticSoilModel model = CreateValidModel(new[]
{
expectedUpdatedProfile
});
MacroStabilityInwardsStochasticSoilModel otherModel = CreateValidModel(new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.5, soilProfile)
});
// Call
MacroStabilityInwardsStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
CollectionAssert.IsEmpty(difference.AddedProfiles);
CollectionAssert.AreEqual(new[]
{
expectedUpdatedProfile
}, difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
public void UpdateModelWithImportedData_WithCurrentModelAndImportedModelWithOtherName_ModelReplaced()
{
// Setup
MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("existing");
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.StochasticSoilModels.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism);
MacroStabilityInwardsStochasticSoilModel readModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("read");
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath);
// Assert
Assert.AreSame(readModel, failureMechanism.StochasticSoilModels[0]);
CollectionAssert.AreEqual(new[]
{
failureMechanism.StochasticSoilModels
}, affectedObjects);
}
private static void AssertStochasticSoilModelAreEqual(MacroStabilityInwardsStochasticSoilModel expected,
MacroStabilityInwardsStochasticSoilModel actual)
{
Assert.AreEqual(expected.Name, actual.Name);
CollectionAssert.AreEqual(expected.Geometry, actual.Geometry);
CollectionAssert.AreEqual(expected.StochasticSoilProfiles, actual.StochasticSoilProfiles);
}
public void IntersectsWithSurfaceLineGeometry_SurfaceLineIntersectingSoilModel_ReturnTrue()
{
// Setup
MacroStabilityInwardsStochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
});
var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
// Call
bool intersecting = soilModel.IntersectsWithSurfaceLineGeometry(surfaceLine);
// Assert
Assert.IsTrue(intersecting);
}
public void Update_ModelWithRemovedProfileSameNameOtherType_ProfileRemoved()
{
// Setup
const string profileName = "A";
var soilProfile = new MacroStabilityInwardsSoilProfile1D(profileName, -2, CreateLayers1D());
var expectedRemovedProfile = new MacroStabilityInwardsStochasticSoilProfile(0.2, soilProfile);
var newProfile = new MacroStabilityInwardsStochasticSoilProfile(
0.2,
new MacroStabilityInwardsSoilProfile2D(profileName, CreateLayers2D(), Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>()));
MacroStabilityInwardsStochasticSoilModel model = CreateValidModel(new[]
{
expectedRemovedProfile
});
MacroStabilityInwardsStochasticSoilModel otherModel = CreateValidModel(new[]
{
newProfile
});
// Call
MacroStabilityInwardsStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
CollectionAssert.AreEqual(new[]
{
newProfile
}, difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.AreEqual(new[]
{
expectedRemovedProfile
}, difference.RemovedProfiles);
}
public void ChildNodeObjects_Always_ReturnsChildrenOfData()
{
// Setup
var stochasticSoilProfile1 = new MacroStabilityInwardsStochasticSoilProfile(
1.0,
new MacroStabilityInwardsSoilProfile1D("soilProfile1", 0, new List <MacroStabilityInwardsSoilLayer1D>
{
new MacroStabilityInwardsSoilLayer1D(10)
}));
var stochasticSoilProfile2 = new MacroStabilityInwardsStochasticSoilProfile(
1.0,
new MacroStabilityInwardsSoilProfile1D("soilProfile2", 0, new List <MacroStabilityInwardsSoilLayer1D>
{
new MacroStabilityInwardsSoilLayer1D(10)
}));
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("SoilModel", new[]
{
stochasticSoilProfile1,
stochasticSoilProfile2
});
// Call
object[] objects = info.ChildNodeObjects(stochasticSoilModel);
// Assert
MacroStabilityInwardsStochasticSoilProfile[] expectedChildren =
{
stochasticSoilProfile1,
stochasticSoilProfile2
};
CollectionAssert.AreEqual(expectedChildren, objects);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var soilProfile = new MacroStabilityInwardsSoilProfile1D("MacroStabilityInwardsSoilProfile", 0, new List <MacroStabilityInwardsSoilLayer1D>
{
new MacroStabilityInwardsSoilLayer1D(10)
});
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(1.0, soilProfile);
var stochasticSoilModel = new MacroStabilityInwardsStochasticSoilModel("name", new[]
{
new Point2D(1.0, 2.0)
}, new[]
{
stochasticSoilProfile
});
// Call
var properties = new MacroStabilityInwardsStochasticSoilModelProperties(stochasticSoilModel);
// Assert
Assert.AreEqual(stochasticSoilModel.Name, properties.Name);
CollectionAssert.AreEqual(stochasticSoilModel.Geometry, properties.Geometry);
Assert.AreEqual(1, properties.MacroStabilityInwardsStochasticSoilProfiles.Length);
Assert.AreSame(stochasticSoilProfile, properties.MacroStabilityInwardsStochasticSoilProfiles[0].Data);
}
/// <summary>
/// Reads the <see cref="StochasticSoilModelEntity"/> and use the information to construct
/// a <see cref="MacroStabilityInwardsStochasticSoilModel"/>.
/// </summary>
/// <param name="entity">The <see cref="StochasticSoilModelEntity"/> to create <see cref="MacroStabilityInwardsStochasticSoilModel"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="MacroStabilityInwardsStochasticSoilModel"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <see cref="StochasticSoilModelEntity.StochasticSoilModelSegmentPointXml"/>
/// of <paramref name="entity"/> is empty.</exception>
public static MacroStabilityInwardsStochasticSoilModel ReadAsMacroStabilityInwardsStochasticSoilModel(this StochasticSoilModelEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.ContainsMacroStabilityInwardsStochasticSoilModel(entity))
{
return(collector.GetMacroStabilityInwardsStochasticSoilModel(entity));
}
Point2D[] geometry = ReadSegmentPoints(entity.StochasticSoilModelSegmentPointXml).ToArray();
MacroStabilityInwardsStochasticSoilProfile[] stochasticSoilProfiles = entity.ReadMacroStabilityInwardsStochasticSoilProfiles(collector)
.ToArray();
var model = new MacroStabilityInwardsStochasticSoilModel(entity.Name, geometry, stochasticSoilProfiles);
collector.Read(entity, model);
return(model);
}
public void SetMatchingStochasticSoilModel_CurrentSoilModelNotInOverlappingMultipleSoilModels_ClearsModel()
{
// Setup
MacroStabilityInwardsStochasticSoilModel nonOverlappingSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A");
var input = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties())
{
StochasticSoilModel = nonOverlappingSoilModel
};
MacroStabilityInwardsStochasticSoilModel soilModel1 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A");
MacroStabilityInwardsStochasticSoilModel soilModel2 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("C");
// Call
MacroStabilityInwardsInputService.SetMatchingStochasticSoilModel(input, new[]
{
soilModel1,
soilModel2
});
// Assert
Assert.IsNull(input.StochasticSoilModel);
}
private static CalculationGroup ConfigureCalculationGroup(IAssessmentSection assessmentSection, MacroStabilityInwardsFailureMechanism failureMechanism)
{
MacroStabilityInwardsStochasticSoilModel stochasticSoilModelForCalculation2 = failureMechanism.StochasticSoilModels.Last();
return(new CalculationGroup
{
Children =
{
new MacroStabilityInwardsCalculationScenario
{
Name = "Calculation 1",
InputParameters =
{
SurfaceLine = failureMechanism.SurfaceLines.First(),
StochasticSoilModel = failureMechanism.StochasticSoilModels.First(),
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First()
}
},
new MacroStabilityInwardsCalculationScenario
{
Name = "Calculation 2",
InputParameters =
{
SurfaceLine = failureMechanism.SurfaceLines.Last(),
StochasticSoilModel = stochasticSoilModelForCalculation2,
StochasticSoilProfile = stochasticSoilModelForCalculation2.StochasticSoilProfiles.First(),
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.Last()
}
}
}
});
}
public void ReadAsMacroStabilityInwardsStochasticSoilModel_SameStochasticSoilModelEntityMultipleTimes_ReturnSameStochasticSoilModel()
{
// Setup
var random = new Random(21);
string segmentPointsXml = new Point2DCollectionXmlSerializer().ToXml(new[]
{
new Point2D(random.NextDouble(), random.NextDouble())
});
var entity = new StochasticSoilModelEntity
{
Name = "StochasticSoilModel",
StochasticSoilModelSegmentPointXml = segmentPointsXml,
MacroStabilityInwardsStochasticSoilProfileEntities =
{
MacroStabilityInwardsStochasticSoilProfileEntityTestFactory.CreateStochasticSoilProfileEntity()
}
};
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsStochasticSoilModel soilModel1 = entity.ReadAsMacroStabilityInwardsStochasticSoilModel(collector);
MacroStabilityInwardsStochasticSoilModel soilModel2 = entity.ReadAsMacroStabilityInwardsStochasticSoilModel(collector);
// Assert
Assert.AreSame(soilModel1, soilModel2);
}
public void Read_EntityWithStochasticSoilModel_ReturnCalculationScenarioWithInputObjectWithStochasticSoilModelPropertiesSet()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var stochasticSoilModelEntity = new StochasticSoilModelEntity();
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(),
MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D());
var stochasticSoilProfileEntity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
StochasticSoilModelEntity = stochasticSoilModelEntity
};
var collector = new ReadConversionCollector();
collector.Read(stochasticSoilModelEntity, stochasticSoilModel);
collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile);
MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity();
entity.MacroStabilityInwardsStochasticSoilProfileEntity = stochasticSoilProfileEntity;
// Call
MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
MacroStabilityInwardsInput inputParameters = calculation.InputParameters;
Assert.AreSame(stochasticSoilModel, inputParameters.StochasticSoilModel);
Assert.AreSame(stochasticSoilProfile, inputParameters.StochasticSoilProfile);
}
public void ReadAsMacroStabilityInwardsStochasticSoilModel_WithValidEntity_ReturnsNewStochasticSoilModelWithPropertiesSet()
{
// Setup
var random = new Random(21);
var geometry = new[]
{
new Point2D(random.NextDouble(), random.NextDouble()),
new Point2D(random.NextDouble(), random.NextDouble())
};
var entity = new StochasticSoilModelEntity
{
Name = "testName",
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(geometry),
MacroStabilityInwardsStochasticSoilProfileEntities =
{
new MacroStabilityInwardsStochasticSoilProfileEntity
{
MacroStabilityInwardsSoilProfileOneDEntity = new MacroStabilityInwardsSoilProfileOneDEntity
{
MacroStabilityInwardsSoilLayerOneDEntities =
{
new MacroStabilityInwardsSoilLayerOneDEntity()
},
Name = "A"
},
Order = 1
},
new MacroStabilityInwardsStochasticSoilProfileEntity
{
MacroStabilityInwardsSoilProfileTwoDEntity = new MacroStabilityInwardsSoilProfileTwoDEntity
{
MacroStabilityInwardsSoilLayerTwoDEntities =
{
MacroStabilityInwardsSoilLayerTwoDEntityTestFactory.CreateMacroStabilityInwardsSoilLayerTwoDEntity()
},
Name = "B"
},
Order = 0
}
}
};
var collector = new ReadConversionCollector();
// Call
MacroStabilityInwardsStochasticSoilModel model = entity.ReadAsMacroStabilityInwardsStochasticSoilModel(collector);
// Assert
Assert.IsNotNull(model);
Assert.AreEqual(entity.Name, model.Name);
CollectionAssert.AreEqual(geometry, model.Geometry);
Assert.AreEqual(entity.MacroStabilityInwardsStochasticSoilProfileEntities.Count,
model.StochasticSoilProfiles.Count());
CollectionAssert.AreEqual(new[]
{
"B",
"A"
}, model.StochasticSoilProfiles.Select(ssp => ssp.SoilProfile.Name));
}
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Surface line");
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(1, 1, 1)
});
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = stochasticSoilModel.StochasticSoilProfiles.First();
// Precondition
Assert.IsNotNull(stochasticSoilProfile);
var original = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties());
MacroStabilityInwardsTestDataGenerator.SetRandomMacroStabilityInwardsInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void GenerateCalculationItemsStructure_Always_CreateCalculationsWithSurfaceLineNameSoilProfileNameGeneralInputAndSemiProbabilisticInput()
{
// Setup
var soilProfile1 = new MacroStabilityInwardsSoilProfile1D("Profile 1", -10.0, new[]
{
new MacroStabilityInwardsSoilLayer1D(-5.0),
new MacroStabilityInwardsSoilLayer1D(-2.0),
new MacroStabilityInwardsSoilLayer1D(1.0)
});
var soilProfile2 = new MacroStabilityInwardsSoilProfile1D("Profile 2", -8.0, new[]
{
new MacroStabilityInwardsSoilLayer1D(-4.0),
new MacroStabilityInwardsSoilLayer1D(0.0),
new MacroStabilityInwardsSoilLayer1D(4.0)
});
var soilModel = new MacroStabilityInwardsStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
}, new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.3, soilProfile1),
new MacroStabilityInwardsStochasticSoilProfile(0.7, soilProfile2)
});
MacroStabilityInwardsStochasticSoilModel[] availableSoilModels =
{
soilModel
};
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Surface Line");
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
MacroStabilityInwardsSurfaceLine[] surfaceLines =
{
surfaceLine
};
// Call
IEnumerable <ICalculationBase> result = MacroStabilityInwardsCalculationConfigurationHelper.GenerateCalculationItemsStructure(
surfaceLines,
availableSoilModels).ToArray();
// Assert
var group = result.First(sl => sl.Name == surfaceLine.Name) as CalculationGroup;
Assert.NotNull(group);
var calculationInput1 = (MacroStabilityInwardsCalculationScenario)group.Children[0];
var calculationInput2 = (MacroStabilityInwardsCalculationScenario)group.Children[1];
Assert.AreEqual($"{surfaceLine.Name} {soilProfile1.Name}", calculationInput1.Name);
Assert.AreEqual($"{surfaceLine.Name} {soilProfile2.Name}", calculationInput2.Name);
}
public void UpdateModelWithImportedData_UpdateCurrentModelWithImportedModelWithOtherProfiles_ProfilesAdded()
{
// Setup
const string modelsName = "same model";
MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(modelsName);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels;
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism);
MacroStabilityInwardsStochasticSoilModel readModel = CreateSimpleModel(modelsName, "new profile A", "new profile B");
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath);
// Assert
Assert.AreEqual(1, targetCollection.Count);
Assert.AreSame(existingModel, targetCollection[0]);
Assert.AreEqual(existingModel.StochasticSoilProfiles.Count(), targetCollection[0].StochasticSoilProfiles.Count());
CollectionAssert.AreEquivalent(new IObservable[]
{
targetCollection,
existingModel
}, affectedObjects);
}
public void Transform_ValidStochasticSoilModelWithSameProfileInTwoStochasticSoilProfiles_ReturnsExpectedMacroStabilityInwardsStochasticSoilModel(ISoilProfile soilProfile)
{
// Setup
const string soilModelName = "name";
const double originalProfileOneProbability = 0.2;
const double originalProfileTwoProbability = 0.7;
StochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry(soilModelName, new[]
{
new StochasticSoilProfile(originalProfileOneProbability, soilProfile),
new StochasticSoilProfile(originalProfileTwoProbability, soilProfile)
});
var transformer = new MacroStabilityInwardsStochasticSoilModelTransformer();
MacroStabilityInwardsStochasticSoilModel transformed = null;
// Call
Action call = () => transformed = transformer.Transform(soilModel);
// Assert
string expectedMessage = $"Ondergrondschematisatie '{soilProfile.Name}' is meerdere keren gevonden in ondergrondmodel '{soilModelName}'. " +
"Kansen van voorkomen worden opgeteld.";
TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Warn));
MacroStabilityInwardsStochasticSoilProfile[] transformedStochasticSoilProfiles = transformed.StochasticSoilProfiles.ToArray();
Assert.AreEqual(1, transformedStochasticSoilProfiles.Length);
const double expectedProbability = originalProfileOneProbability + originalProfileTwoProbability;
Assert.AreEqual(expectedProbability, transformedStochasticSoilProfiles[0].Probability, 1e-6);
}
private static void AddEntitiesForStochasticSoilProfiles(MacroStabilityInwardsStochasticSoilModel model,
PersistenceRegistry registry,
StochasticSoilModelEntity entity)
{
var i = 0;
foreach (MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile in model.StochasticSoilProfiles)
{
entity.MacroStabilityInwardsStochasticSoilProfileEntities.Add(stochasticSoilProfile.Create(registry, i++));
}
}
public void StochasticSoilModel_AlwaysOnChange_NotifyObserverCalculationPropertyChangedOutputCleared()
{
// Setup
MacroStabilityInwardsStochasticSoilModel newModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var newValue = new DataGridViewComboBoxItemWrapper <MacroStabilityInwardsStochasticSoilModel>(newModel);
var calculation = new MacroStabilityInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.StochasticSoilModel = newValue, 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 Update_WithOtherModel_PropertiesUpdated()
{
// Setup
const string equalProfileName = "nameA";
var stochasticProfileA = new MacroStabilityInwardsStochasticSoilProfile(0.5, CreateMacroStabilityInwardsSoilProfile(equalProfileName));
var stochasticProfileB = new MacroStabilityInwardsStochasticSoilProfile(0.5, CreateMacroStabilityInwardsSoilProfile("nameB"));
MacroStabilityInwardsStochasticSoilModel model = CreateValidModel(new[]
{
stochasticProfileA,
stochasticProfileB
});
const string otherName = "other name";
var otherGeometry = new[]
{
new Point2D(2, 0),
new Point2D(3, 0)
};
var otherStochasticProfileA = new MacroStabilityInwardsStochasticSoilProfile(0.7, new TestSoilProfile(equalProfileName));
var otherStochasticProfileB = new MacroStabilityInwardsStochasticSoilProfile(0.3, CreateMacroStabilityInwardsSoilProfile("other profile name"));
var otherModel = new MacroStabilityInwardsStochasticSoilModel(otherName, otherGeometry, new[]
{
otherStochasticProfileA,
otherStochasticProfileB
});
// Call
MacroStabilityInwardsStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
AssertStochasticSoilModelAreEqual(otherModel, model);
Assert.AreSame(otherGeometry, model.Geometry);
MacroStabilityInwardsStochasticSoilProfile[] stochasticSoilProfiles = model.StochasticSoilProfiles.ToArray();
Assert.AreEqual(2, stochasticSoilProfiles.Length);
Assert.AreSame(stochasticProfileA, stochasticSoilProfiles[0]);
Assert.AreSame(otherStochasticProfileA.SoilProfile, stochasticSoilProfiles[0].SoilProfile);
Assert.AreNotSame(stochasticProfileB, stochasticSoilProfiles[1]);
Assert.AreSame(otherStochasticProfileB.SoilProfile, stochasticSoilProfiles[1].SoilProfile);
CollectionAssert.AreEqual(new[]
{
stochasticProfileA
}, difference.UpdatedProfiles);
CollectionAssert.AreEqual(new[]
{
stochasticProfileB
}, difference.RemovedProfiles);
CollectionAssert.AreEqual(new[]
{
otherStochasticProfileB
}, difference.AddedProfiles);
}
/// <summary>
/// Creates an instance of <see cref="MacroStabilityInwardsStochasticSoilModel"/>.
/// </summary>
/// <param name="soilModelName">The name of the soil model.</param>
/// <param name="stochasticSoilProfiles">The geometry of the soil model.</param>
/// <returns>A valid configured <see cref="MacroStabilityInwardsStochasticSoilModel"/> with the
/// specified <paramref name="soilModelName"/> and <paramref name="stochasticSoilProfiles"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="soilModelName"/> or
/// <paramref name="stochasticSoilProfiles"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <oaramref name="stochasticSoilProfiles"/> is
/// <c>empty</c>.</exception>
public static MacroStabilityInwardsStochasticSoilModel CreateValidStochasticSoilModel(string soilModelName,
IEnumerable <MacroStabilityInwardsStochasticSoilProfile> stochasticSoilProfiles)
{
var model = new MacroStabilityInwardsStochasticSoilModel(soilModelName,
new[]
{
new Point2D(1, 1),
new Point2D(2, 2)
}, stochasticSoilProfiles);
return(model);
}
public void Transform_ValidStochasticSoilModelWithSoilProfile2D_ReturnsExpectedMacroStabilityInwardsStochasticSoilModel()
{
// Setup
var random = new Random(21);
double probability = random.NextDouble();
var transformer = new MacroStabilityInwardsStochasticSoilModelTransformer();
StochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry("some name", new[]
{
new StochasticSoilProfile(probability, new SoilProfile2D(2, "test", new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, Enumerable.Empty <PreconsolidationStress>()))
});
// Call
MacroStabilityInwardsStochasticSoilModel transformedModel = transformer.Transform(soilModel);
// Assert
Assert.AreEqual(soilModel.Name, transformedModel.Name);
CollectionAssert.AreEqual(soilModel.Geometry, transformedModel.Geometry);
Assert.AreEqual(1, transformedModel.StochasticSoilProfiles.Count());
var expectedStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(probability, new MacroStabilityInwardsSoilProfile2D("test", new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(1.0, 1.0),
new Point2D(2.0, 1.0)
}),
new MacroStabilityInwardsSoilLayerData
{
UsePop = true
},
new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(0.0, 0.0),
new Point2D(1.0, 0.0)
}),
new MacroStabilityInwardsSoilLayerData
{
UsePop = true
},
Enumerable.Empty <MacroStabilityInwardsSoilLayer2D>())
})
}, Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>()));
AssertStochasticSoilProfile(expectedStochasticSoilProfile, transformedModel.StochasticSoilProfiles.First());
}
public void GetStochasticSoilModelsForSurfaceLine_SurfaceLineIntersectingSoilModel_ReturnSoilModel()
{
// Setup
var soilProfile1 = new MacroStabilityInwardsStochasticSoilProfile(0.3, new MacroStabilityInwardsSoilProfile1D("Profile 1", -10.0, new[]
{
new MacroStabilityInwardsSoilLayer1D(-5.0),
new MacroStabilityInwardsSoilLayer1D(-2.0),
new MacroStabilityInwardsSoilLayer1D(1.0)
}));
var soilProfile2 = new MacroStabilityInwardsStochasticSoilProfile(0.7, new MacroStabilityInwardsSoilProfile1D("Profile 2", -8.0, new[]
{
new MacroStabilityInwardsSoilLayer1D(-4.0),
new MacroStabilityInwardsSoilLayer1D(0.0),
new MacroStabilityInwardsSoilLayer1D(4.0)
}));
var soilModel = new MacroStabilityInwardsStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
}, new[]
{
soilProfile1,
soilProfile2
});
MacroStabilityInwardsStochasticSoilModel[] availableSoilModels =
{
soilModel
};
var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
// Call
IEnumerable <MacroStabilityInwardsStochasticSoilModel> result = MacroStabilityInwardsCalculationConfigurationHelper.GetStochasticSoilModelsForSurfaceLine(
surfaceLine,
availableSoilModels);
// Assert
MacroStabilityInwardsStochasticSoilModel[] expected =
{
soilModel
};
CollectionAssert.AreEquivalent(expected, result);
}
