Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/Dike.cs =================================================================== diff -u -r554 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/Dike.cs (.../Dike.cs) (revision 554) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/Dike.cs (.../Dike.cs) (revision 578) @@ -371,11 +371,11 @@ { foreach (var invalidSoil in invalidSoils) { - var fl = spp.SoilProfile.Layers.Find(l => String.Equals(l.Soil.Name, invalidSoil.Name, StringComparison.CurrentCultureIgnoreCase)); + var fl = spp.SoilProfile1D.Layers.Find(l => String.Equals(l.Soil.Name, invalidSoil.Name, StringComparison.CurrentCultureIgnoreCase)); if (fl != null) { - soilProf = spp.SoilProfile.Name; + soilProf = spp.SoilProfile1D.Name; invSoil = invalidSoil.Name; return true; } Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/SoilGeometry.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/SoilGeometry.cs (.../SoilGeometry.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/SoilGeometry.cs (.../SoilGeometry.cs) (revision 578) @@ -36,7 +36,7 @@ public class SoilGeometryBase { - public virtual SoilGeometryType SoilGeometryType { get; set; } + public virtual SoilProfileType SoilProfileType { get; set; } public virtual string SoilGeometryName { get; set; } } @@ -58,20 +58,20 @@ } #region PublicPropteries - public override SoilGeometryType SoilGeometryType + public override SoilProfileType SoilProfileType { get { - SoilGeometryType soilGeometryType = SoilGeometryType.SoilGeometry2D; + SoilProfileType soilProfileType = SoilProfileType.ProfileType2D; if (soilProfile != null) { - soilGeometryType = SoilGeometryType.SoilGeometry1D; + soilProfileType = SoilProfileType.ProfileType1D; } if ((SoilProfile == null) && ((SoilGeometry2DName == null) || SoilGeometry2DName == "")) { throw new SoilGeometryException("No geometry assigned"); } - return soilGeometryType; + return soilProfileType; } } Index: dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/HydraulicShortcutRWEvaluator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/HydraulicShortcutRWEvaluator.cs (.../HydraulicShortcutRWEvaluator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/HydraulicShortcutRWEvaluator.cs (.../HydraulicShortcutRWEvaluator.cs) (revision 578) @@ -238,9 +238,9 @@ // plLinesCreator.SurfaceLine = location.LocalXZSurfaceLine2; // plLinesCreator.WaterLevelPolder = location.PolderLevel; // plLinesCreator.ModelParametersForPLLines = location.CreateModelParametersForPLLines(); -// plLinesCreator.SoilProfile = soilGeometry.SoilProfile; -// plLinesCreator.SoilGeometry2DName = null; -// plLinesCreator.SoilGeometryType = SoilGeometryType.SoilGeometry1D; +// plLinesCreator.SoilProfile1D = soilGeometry.SoilProfile1D; +// plLinesCreator.StiFileName = null; +// plLinesCreator.SoilProfileType = SoilProfileType.ProfileType1D; // plLinesCreator.GaugePLLines = null; // plLinesCreator.Gauges = null; // plLinesCreator.GaugeMissVal = 0.0; @@ -267,8 +267,8 @@ // UpliftLocationDeterminator upliftLocationDeterminator = new UpliftLocationDeterminator() // { // SurfaceLine = location.SurfaceLine2, -// SoilProfile = soilGeometry.SoilProfile, -// SoilGeometry2DName = null, +// SoilProfile1D = soilGeometry.SoilProfile1D, +// StiFileName = null, // SoilBaseDB = null, //soilbase, // DikeEmbankmentMaterial = location.GetDikeEmbankmentSoil(), // PLLines = CreatePLLines(), Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenariosCalculation.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenariosCalculation.cs (.../RWScenariosCalculation.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenariosCalculation.cs (.../RWScenariosCalculation.cs) (revision 578) @@ -224,7 +224,7 @@ { foreach (SoilGeometryProbability soilGeometryProbability in soilGeometryProbabilities) { - if (soilGeometryProbability.SoilGeometryType == SoilGeometryType.SoilGeometry2D) + if (soilGeometryProbability.SoilProfileType == SoilProfileType.ProfileType2D) { this.evaluationJob.FailedEvaluatedLocations.Add(location); sendMessageDelegate(new LogMessage(LogMessageType.Warning, location, LocalizationManager.GetTranslatedText(this, "Geometry2DNotSupportedInRegionalAssessment") + @@ -233,7 +233,7 @@ else { - SoilProfile soilProfile = soilGeometryProbability.SoilProfile; + SoilProfile soilProfile = soilGeometryProbability.SoilProfile1D; IList rwScenarios = null; try { @@ -337,11 +337,11 @@ // waterLevel = job.Location.BoezemLevelTp; // break; // } -// //job.SoilGeometryProbability.SoilProfile.EnsureUniqueLayerIds(); +// //job.SoilGeometryProbability.SoilProfile1D.EnsureUniqueLayerIds(); // var calculationName = GetCalculationNameForPipingCalculator(job); // calculator.FilenameCalculation = Path.Combine(Path.Combine(DamProjectData.ProjectWorkingPath, job.FailureMechanismType.ToString()), calculationName); // calculator.IsHydraulicShortcut = (job.HydraulicShortcutType == HydraulicShortcutType.HydraulicShortcut); -// double? pipingFactor = calculator.CalculatePipingFactor(job.Location, job.Location.LocalXZSurfaceLine2, job.SoilGeometryProbability.SoilProfile, waterLevel); +// double? pipingFactor = calculator.CalculatePipingFactor(job.Location, job.Location.LocalXZSurfaceLine2, job.SoilGeometryProbability.SoilProfile1D, waterLevel); // job.BaseFileName = calculator.FilenameCalculation; // // job.RwResultType = RWResultType.SafetyFactor; @@ -433,7 +433,7 @@ string soilDatabaseName = job.Location.SoildatabaseName; // DamFailureMechanismeCalculationSpecification damCalculation = -// calculator.GetSpecification(this.evaluationJob.DikeName, soilDatabaseName, job.Location, new SoilGeometry(job.SoilGeometryProbability.SoilProfile, null), +// calculator.GetSpecification(this.evaluationJob.DikeName, soilDatabaseName, job.Location, new SoilGeometry(job.SoilGeometryProbability.SoilProfile1D, null), // (MStabModelType)job.MstabModelOption, job.LoadSituation, job.DikeDrySensitivity, job.HydraulicShortcutType, MStabParameters); // // calculator.SaveToFile(damCalculation.FailureMechanismeParamatersMStab); Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/MStabProject.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/MStabProject.cs (.../MStabProject.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/MStabProject.cs (.../MStabProject.cs) (revision 578) @@ -116,7 +116,7 @@ // { // get // { -// return stabilityModel != null && stabilityModel.SoilProfile != null ? stabilityModel.SoilProfile.Geometry : null; +// return stabilityModel != null && stabilityModel.SoilProfile1D != null ? stabilityModel.SoilProfile1D.Geometry : null; // } // } // Index: dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs =================================================================== diff -u -r566 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 566) +++ dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 578) @@ -183,19 +183,19 @@ } [Test] - [TestCase(SoilGeometryType.SoilGeometry1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D)] - [TestCase(SoilGeometryType.SoilGeometry2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D)] - public void CanConvertToInputSoilGeometryType(SoilGeometryType soilGeometryType, SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType) + [TestCase(SoilProfileType.ProfileType1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D)] + [TestCase(SoilProfileType.ProfileType2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D)] + public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType) { - Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryType)); + Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilGeometryType(soilProfileType)); } [Test] - [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilGeometryType.SoilGeometry1D)] - [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilGeometryType.SoilGeometry2D)] - public void CanConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType, SoilGeometryType soilGeometryType) + [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilProfileType.ProfileType1D)] + [TestCase(SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilProfileType.ProfileType2D)] + public void CanConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType inputSoilGeometryType, SoilProfileType soilProfileType) { - Assert.AreEqual(soilGeometryType, ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType)); + Assert.AreEqual(soilProfileType, ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType)); } [Test] Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Geometry2DDataCreator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Geometry2DDataCreator.cs (.../Geometry2DDataCreator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/Geometry2DDataCreator.cs (.../Geometry2DDataCreator.cs) (revision 578) @@ -57,7 +57,7 @@ { // var geometry2DSectionAssembler = new DAMMStabGeometry2DSectionAssembler(); // var geometry2DSectionParameters = new Geometry2DSectionParameters(); -// geometry2DSectionParameters.SoilGeometry2DName = System.IO.Path.GetFullPath(filename); +// geometry2DSectionParameters.StiFileName = System.IO.Path.GetFullPath(filename); // geometry2DSectionParameters.XCoordinateSection = 0.0; // this parameter is not used // XDocument doc = geometry2DSectionAssembler.CreateDataTransferObject(geometry2DSectionParameters); // String LXMLInput = doc.ToString(); @@ -109,12 +109,12 @@ // geometryFilename = geometryFilename + ".sti"; // geometryFilename = Path.Combine(geometryDirectory, geometryFilename); // string soilgeometry2DFilename = null; - // if (soilProfileProbability.SoilGeometry2DName != null) + // if (soilProfileProbability.StiFileName != null) // { - // soilgeometry2DFilename = Path.GetFullPath(Path.Combine(DamProjectData.ProjectMap, Path.Combine(location.MapForSoilGeometries2D, soilProfileProbability.SoilGeometry2DName))); + // soilgeometry2DFilename = Path.GetFullPath(Path.Combine(DamProjectData.ProjectMap, Path.Combine(location.MapForSoilGeometries2D, soilProfileProbability.StiFileName))); // } // - // var soilGeometry = new SoilGeometry(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); + // var soilGeometry = new SoilGeometry(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // var failureMechanismeParamatersMStab = new FailureMechanismeParamatersMStab(); // PLLines plLines = new PLLines(); // var plLine = new PLLine(); @@ -128,8 +128,8 @@ // plLines.Lines[PLLineType.PL4] = plLine; // failureMechanismeParamatersMStab.Location = location; // failureMechanismeParamatersMStab.PLLines = plLines; - // failureMechanismeParamatersMStab.SoilProfile = soilGeometry.SoilProfile; - // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometryType = soilGeometry.SoilGeometryType; + // failureMechanismeParamatersMStab.SoilProfile1D = soilGeometry.SoilProfile1D; + // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType = soilGeometry.SoilProfileType; // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometry2DFilename = soilgeometry2DFilename; // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.MaterialForDike =location.DikeEmbankmentMaterial; // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.MaterialForShoulder = location.ShoulderEmbankmentMaterial; Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/MStabXmlDoc.cs =================================================================== diff -u -r544 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/MStabXmlDoc.cs (.../MStabXmlDoc.cs) (revision 544) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/MStabXmlDoc.cs (.../MStabXmlDoc.cs) (revision 578) @@ -43,14 +43,14 @@ { failureMechanismeParamatersMStab.SoilProfile = profile1D; // 1d-geometry - failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometryType = - SoilGeometryType.SoilGeometry1D; + failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType = + SoilProfileType.ProfileType1D; } else { // 2d-geometry - failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometryType = - SoilGeometryType.SoilGeometry2D; + failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType = + SoilProfileType.ProfileType2D; } // Geometry Creation Options failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometry2DFilename = Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/PlLinesCreator/PLLinesCreator.cs (.../PLLinesCreator.cs) (revision 578) @@ -66,7 +66,7 @@ private const double cOffsetPhreaticLineBelowSurface = 0.01; private ModelParametersForPLLines modelParametersForPLLines = new ModelParametersForPLLines(); public bool IsUseOvenDryUnitWeight { get; set; } - public SoilGeometryType SoilGeometryType { get; set; } + public SoilProfileType SoilProfileType { get; set; } public SoilProfile1D SoilProfile { get; set; } public string SoilGeometry2DName { get; set; } public Soil DikeEmbankmentMaterial { get; set; } @@ -136,7 +136,7 @@ // If hydraulic shortcut then use waterlevel for headPL3 if (IsHydraulicShortcut) { - if (SoilGeometryType == SoilGeometryType.SoilGeometry1D) + if (SoilProfileType == SoilProfileType.ProfileType1D) { if (SoilProfile.InBetweenAquiferLayer == null) { @@ -205,7 +205,7 @@ /// public PLLinesCreator() { - SoilGeometryType = SoilGeometryType.SoilGeometry1D; + SoilProfileType = SoilProfileType.ProfileType1D; PlLineOffsetBelowDikeTopAtRiver = 0.5; // Default value PlLineOffsetBelowDikeTopAtPolder = 1.5; // Default value PlLineOffsetBelowShoulderBaseInside = 0.1; // Default value @@ -220,14 +220,14 @@ /// private SoilProfile1D GetSoilProfileBelowPoint(double xCoordinate) { - switch (SoilGeometryType) + switch (SoilProfileType) { - case SoilGeometryType.SoilGeometry1D: + case SoilProfileType.ProfileType1D: var soilProfile = new SoilProfile1D(); soilProfile.Assign(this.SoilProfile); return soilProfile; -// case SoilGeometryType.SoilGeometry2D: -// var geometry2DTo1DConverter = new Geometry2DTo1DConverter(this.SoilGeometry2DName, this.SurfaceLine, this.DikeEmbankmentMaterial, this.SoilBaseDB, this.SoilList, -this.XSoilGeometry2DOrigin); +// case SoilProfileType.ProfileType2D: +// var geometry2DTo1DConverter = new Geometry2DTo1DConverter(this.StiFileName, this.SurfaceLine, this.DikeEmbankmentMaterial, this.SoilBaseDB, this.SoilList, -this.XSoilGeometry2DOrigin); // return geometry2DTo1DConverter.Convert(xCoordinate); ##Bka default: return null; @@ -251,11 +251,11 @@ /// private void ThrowIfInsufficientSoilGeometryData() { - bool hasNoGeometry1DData = (SoilGeometryType == SoilGeometryType.SoilGeometry1D) && SoilProfile == null; - bool hasNoGeometry2DData = (SoilGeometryType == SoilGeometryType.SoilGeometry2D) && (SoilGeometry2DName == null || DikeEmbankmentMaterial == null); + bool hasNoGeometry1DData = (SoilProfileType == SoilProfileType.ProfileType1D) && SoilProfile == null; + bool hasNoGeometry2DData = (SoilProfileType == SoilProfileType.ProfileType2D) && (SoilGeometry2DName == null || DikeEmbankmentMaterial == null); if (hasNoGeometry1DData && hasNoGeometry2DData) { - throw new PLLinesCreatorException("PLLinesCreator contains not enough soil geometry information (SoilProfile, SoilGeometry2DName, dikeEmbankmentMaterial or soilBase)"); + throw new PLLinesCreatorException("PLLinesCreator contains not enough soil geometry information (SoilProfile1D, StiFileName, dikeEmbankmentMaterial or soilBase)"); } } @@ -282,12 +282,12 @@ ThrowIfNoSurfaceLine(); ThrowIfSurfaceLineContainsNoPoints(); - switch (SoilGeometryType) + switch (SoilProfileType) { - case SoilGeometryType.SoilGeometry1D: + case SoilProfileType.ProfileType1D: plLine = CreatePlLine2ByExpertKnowledgeFor1DGeometry(penetrationLength, headInPLLine2); break; - case SoilGeometryType.SoilGeometry2D: + case SoilProfileType.ProfileType2D: plLine = CreatePlLine2ByExpertKnowledgeFor2DGeometry(penetrationLength, headInPLLine2); break; } @@ -362,7 +362,7 @@ // Split layer at separation level var extraLayer = new SoilLayer1D(); extraLayer.Assign(separationLayer); - //extraLayer.Id = this.SoilProfile.GetNewUniqueLayerId(); ##Bka + //extraLayer.Id = this.SoilProfile1D.GetNewUniqueLayerId(); ##Bka extraLayer.TopLevel = separationLevel; this.SoilProfile.Layers.Insert(this.SoilProfile.Layers.IndexOf(separationLayer) + 1, extraLayer); } Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs (.../UpliftLocationDeterminator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Uplift/UpliftLocationDeterminator.cs (.../UpliftLocationDeterminator.cs) (revision 578) @@ -286,7 +286,7 @@ { return SoilProfile2D.GetSoilProfile1D(xCoordinate); } - // Geometry2DTo1DConverter geometry2DTo1DConverter = new Geometry2DTo1DConverter(this.SoilGeometry2DName, this.SurfaceLine, this.DikeEmbankmentMaterial, this.SoilBaseDB, this.SoilList, -this.XSoilGeometry2DOrigin); ##BKA Replace with Conversion as used in DSM + // Geometry2DTo1DConverter geometry2DTo1DConverter = new Geometry2DTo1DConverter(this.StiFileName, this.SurfaceLine, this.DikeEmbankmentMaterial, this.SoilBaseDB, this.SoilList, -this.XSoilGeometry2DOrigin); ##BKA Replace with Conversion as used in DSM // return geometry2DTo1DConverter.Convert(xCoordinate); return null; } Index: dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs =================================================================== diff -u -r566 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs (.../FillDamFromXmlInputTests.cs) (revision 566) +++ dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/FillDamFromXmlInputTests.cs (.../FillDamFromXmlInputTests.cs) (revision 578) @@ -313,16 +313,18 @@ if (i == 0) { soilProfileProbability.SegmentFailureMechanismType = FailureMechanismSystemType.StabilityInside; - soilProfileProbability.SoilGeometry2DName = "Profile2D " + (i + 1).ToString(); + soilProfileProbability.SoilProfile2DName = "Profile2D " + (i + 1).ToString(); soilProfileProbability.SoilProfile2D = FillDamFromXmlInput.FindSoilProfile2DByName(damProjectData.Dike.SoilProfiles2D, - soilProfileProbability.SoilGeometry2DName); + soilProfileProbability.SoilProfile2DName); + soilProfileProbability.SoilProfileType = SoilProfileType.ProfileType2D; } else { soilProfileProbability.SegmentFailureMechanismType = FailureMechanismSystemType.Piping; - soilProfileProbability.SoilGeometry1DName = "Profile1D " + (i + 1).ToString(); - soilProfileProbability.SoilProfile = FillDamFromXmlInput.FindSoilProfile1DByName(damProjectData.Dike.SoilProfiles, - soilProfileProbability.SoilGeometry1DName); + soilProfileProbability.SoilProfile1DName = "Profile1D " + (i + 1).ToString(); + soilProfileProbability.SoilProfile1D = FillDamFromXmlInput.FindSoilProfile1DByName(damProjectData.Dike.SoilProfiles, + soilProfileProbability.SoilProfile1DName); + soilProfileProbability.SoilProfileType = SoilProfileType.ProfileType1D; } soilProfileProbability.Probability = 0.003 * (i + 1); segment.SoilProfileProbabilities.Add(soilProfileProbability); Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/CalculationHelper.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/CalculationHelper.cs (.../CalculationHelper.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/CalculationHelper.cs (.../CalculationHelper.cs) (revision 578) @@ -45,7 +45,7 @@ public MStabModelType Model { get; set; } public string StabilityWorkingPath { get; set; } public string SoilGeometry2DName { get; set; } - public SoilGeometryType SoilGeometryType { get; set; } + public SoilProfileType SoilProfileType { get; set; } public PLLines PLLines { get; set; } public FailureMechanismSystemType FailureMechanismType { get; set; } public MStabParameters StabilityParameters { get; set; } @@ -81,29 +81,29 @@ internal static DamFailureMechanismeCalculationSpecification GetCalculationSpecification(StabilityProjectFileCreationArguments arguments, string projectFileName) { return GetCalculationSpecification(arguments.FailureMechanismType, arguments.Location, - arguments.SoilGeometry2DName, arguments.SoilGeometryType, + arguments.SoilGeometry2DName, arguments.SoilProfileType, arguments.PLLines, arguments.StabilityParameters, arguments.Model, arguments.Location.SoildatabaseName, projectFileName); } internal static DamFailureMechanismeCalculationSpecification GetCalculationSpecification( FailureMechanismSystemType failureMechanismType, Location location, string soilGeometry2DName, - SoilGeometryType soilGeometryType, + SoilProfileType soilProfileType, PLLines plLines, MStabParameters mstabParameters, MStabModelType model, string soilDatabasePath, string projectFileName) { // Note: local use of new calculationSpecification for now ok but might be unwanted in future when you want to use multiple specifications var calculationSpecification = new DamFailureMechanismeCalculationSpecification(); - BuildDamCalculation(failureMechanismType, location, soilGeometry2DName, soilGeometryType, plLines, mstabParameters, model, calculationSpecification, soilDatabasePath, projectFileName); + BuildDamCalculation(failureMechanismType, location, soilGeometry2DName, soilProfileType, plLines, mstabParameters, model, calculationSpecification, soilDatabasePath, projectFileName); return calculationSpecification; } /// /// Fill damCalculation with the appropriate values /// - internal static void BuildDamCalculation(FailureMechanismSystemType failureMechanismType, Location location, string soilGeometry2DName, SoilGeometryType soilGeometryType, + internal static void BuildDamCalculation(FailureMechanismSystemType failureMechanismType, Location location, string soilGeometry2DName, SoilProfileType soilProfileType, PLLines plLines, MStabParameters mstabParameters, MStabModelType model, DamFailureMechanismeCalculationSpecification damCalculation, string soilDatabasePath, string projectFileName) { @@ -123,7 +123,7 @@ ProjectFileName = projectFileName, GeometryCreationOptions = { - SoilGeometryType = soilGeometryType, + SoilProfileType = soilProfileType, SoilGeometry2DFilename = soilGeometry2DName, MaterialForDike = location.DikeEmbankmentMaterial, MaterialForShoulder = location.ShoulderEmbankmentMaterial, @@ -353,9 +353,9 @@ /// The water level. /// The location. /// Name of the soil geometry2 D. - /// Type of the soil geometry. + /// Type of the soil geometry. /// - internal static PLLines CreateAllPLLines(double waterLevel, Location location, string soilGeometry2DName, SoilGeometryType soilGeometryType) + internal static PLLines CreateAllPLLines(double waterLevel, Location location, string soilGeometry2DName, SoilProfileType soilProfileType) { // When calculating with timeseries, we want PL3 and PL4 to derive the head from the waterlevel. // We can force that by overruling the location HeadPl3 and HeadPl4 with null, @@ -372,7 +372,7 @@ ModelParametersForPLLines = location.ModelParametersForPLLines, SoilProfile = location.GetMostProbableProfile(FailureMechanismSystemType.StabilityInside), SoilGeometry2DName = soilGeometry2DName, - SoilGeometryType = soilGeometryType, + SoilProfileType = soilProfileType, GaugePLLines = location.GaugePLLines, Gauges = location.Gauges, GaugeMissVal = location.GaugeMissVal, @@ -440,19 +440,19 @@ private static SoilGeometryBase GetSoilGeometryType(Location location) { - SoilGeometryType soilGeometryType; + SoilProfileType soilProfileType; string soilGeometry2DName; - DetermineSoilGeometryType(location, out soilGeometryType, out soilGeometry2DName); - return new SoilGeometryBase { SoilGeometryType = soilGeometryType, SoilGeometryName = soilGeometry2DName }; + DetermineSoilGeometryType(location, out soilProfileType, out soilGeometry2DName); + return new SoilGeometryBase { SoilProfileType = soilProfileType, SoilGeometryName = soilGeometry2DName }; } /// /// Determines the type of the soil geometry (1D or 2D). /// /// The location. - /// Type of the soil geometry. + /// Type of the soil geometry. /// Name of the soil geometry2 D. - internal static void DetermineSoilGeometryType(Location location, out SoilGeometryType soilGeometryType, out string soilGeometry2DName) + internal static void DetermineSoilGeometryType(Location location, out SoilProfileType soilProfileType, out string soilGeometry2DName) { SoilProfile1D soilProfile = location.GetMostProbableProfile(FailureMechanismSystemType.StabilityInside); soilGeometry2DName = location.GetMostProbableGeometry2DName(FailureMechanismSystemType.StabilityInside); @@ -463,15 +463,15 @@ } if (soilProfile != null) { - soilGeometryType = SoilGeometryType.SoilGeometry1D; + soilProfileType = SoilProfileType.ProfileType1D; } else { if (soilGeometry2DName == null) { throw new TimeSerieStabilityCalculatorException(String.Format("Location {0} does not have a soilprofile assigned", location.Name)); } - soilGeometryType = SoilGeometryType.SoilGeometry2D; + soilProfileType = SoilProfileType.ProfileType2D; } } } Index: dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs (.../SoilSurfaceProfile.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SoilSurfaceProfile.cs (.../SoilSurfaceProfile.cs) (revision 578) @@ -248,7 +248,7 @@ } /// - /// Returns a that represents this instance (either Name or SoilProfile). + /// Returns a that represents this instance (either Name or SoilProfile1D). /// /// /// A that represents this instance. @@ -463,7 +463,7 @@ // IsAquifer = soilLayer.IsAquifer, // WaterpressureInterpolationModel = soilLayer.WaterpressureInterpolationModel, // Soil = soilLayer.Soil, -// SoilProfile = this +// SoilProfile1D = this // }); // } // } ##Bka Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/Assemblers/DamMStabAssembler.cs =================================================================== diff -u -r544 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/Assemblers/DamMStabAssembler.cs (.../DamMStabAssembler.cs) (revision 544) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/DamMacroStability/Assemblers/DamMStabAssembler.cs (.../DamMStabAssembler.cs) (revision 578) @@ -119,7 +119,7 @@ /// public const string XmlElementGeometryCreationOptions = "GeometryCreationOptions"; - public const string XmlAttributeSoilGeometryType = "SoilGeometryType"; + public const string XmlAttributeSoilGeometryType = "SoilProfileType"; public const string XmlAttributeSoilGeometry2DFilename = "SoilGeometry2DFilename"; public const string XmlAttributeXOffsetSoilGeometry2DOrigin = "XOffsetSoilGeometry2DOrigin"; public const string XmlAttributeMaterialForDike = "MaterialForDike"; @@ -581,7 +581,7 @@ materialForShoulder = (materialForShoulder == null ? "" : materialForShoulder); return new XElement(tnsb + XmlElementGeometryCreationOptions, new XAttribute(XmlAttributeSoilGeometryType, failureMechanismeParamatersMStab. - MStabParameters.GeometryCreationOptions.SoilGeometryType), + MStabParameters.GeometryCreationOptions.SoilProfileType), new XAttribute(XmlAttributeSoilGeometry2DFilename, soilGeometryName), new XAttribute(XmlAttributeXOffsetSoilGeometry2DOrigin, failureMechanismeParamatersMStab. MStabParameters.GeometryCreationOptions.XOffsetSoilGeometry2DOrigin), Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculator.cs (.../StabilityCalculator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculator.cs (.../StabilityCalculator.cs) (revision 578) @@ -156,11 +156,11 @@ if (profile1D != null) { plLineCreator.SoilProfile = profile1D; - plLineCreator.SoilGeometryType = SoilGeometryType.SoilGeometry1D; + plLineCreator.SoilProfileType = SoilProfileType.ProfileType1D; } else { - plLineCreator.SoilGeometryType = SoilGeometryType.SoilGeometry2D; + plLineCreator.SoilProfileType = SoilProfileType.ProfileType2D; string mapForSoilGeometries2D = location.MapForSoilGeometries2D; soilGeometry2DName = Path.Combine(Path.Combine(DamProjectData.ProjectMap, mapForSoilGeometries2D), soilGeometry2DName); plLineCreator.SoilGeometry2DName = soilGeometry2DName; @@ -259,7 +259,7 @@ // MinimalCircleDepth = this.minimalCircleDepth, // ZonesType = scenario.Location.StabilityZoneType // }; -// SoilProfile profile; +// SoilProfile1D profile; // var surfaceLine = scenario.GetMostRecentSurfaceLine(soilProfile, // Path.GetFileName(soilGeometry2DName)); // //create mstabproj using .NET, without using delphi dll and xml files @@ -397,9 +397,9 @@ // } // } -// private static SoilProfile GetSoilProfileByType(SoilProfile1D soilProfile, string mapForSoilGeometries2D, string soilGeometry2DName) +// private static SoilProfile1D GetSoilProfileByType(SoilProfile1D soilProfile, string mapForSoilGeometries2D, string soilGeometry2DName) // { -// SoilProfile profile = null; +// SoilProfile1D profile = null; // if (soilProfile != null) // { // profile = soilProfile; @@ -425,7 +425,7 @@ // } // if (mStab != null) // { -// profile = mStab.Stability.SoilProfile; +// profile = mStab.Stability.SoilProfile1D; // mStab.Dispose(); // } // } @@ -434,14 +434,14 @@ // var converter = new Converter(); // mStab = new MStabProject(); // mStab.Stability = converter.ConvertClassicMStab(fullPath); -// if (mStab.Stability.SoilProfile.Surfaces != null && mStab.Stability.SoilProfile.Surfaces.Count > 0) +// if (mStab.Stability.SoilProfile1D.Surfaces != null && mStab.Stability.SoilProfile1D.Surfaces.Count > 0) // { // // Ensure that the bottom layer of the geometry is seen as Aquifer. // // There is no other way to get aquifer information as Delphi DGS does not work with aquifers and also not // // with soiltypes so you can not derive anything from that too. -// mStab.Stability.SoilProfile.Surfaces[0].IsAquifer = true; +// mStab.Stability.SoilProfile1D.Surfaces[0].IsAquifer = true; // } -// profile = mStab.Stability.SoilProfile; +// profile = mStab.Stability.SoilProfile1D; // mStab.Dispose(); // } // } @@ -942,7 +942,7 @@ /// /// /// -// public XDocument CreateMStabXmlDoc(string mstabProjectFilename, Scenario scenario, SoilProfile soilProfile, +// public XDocument CreateMStabXmlDoc(string mstabProjectFilename, Scenario scenario, SoilProfile1D soilProfile, // string soilGeometry2DName, double riverLevel, // MStabDesignEmbankment mstabDesignEmbankment, SurfaceLine2 surfaceLine) // { @@ -952,16 +952,16 @@ // failureMechanismeParamatersMStab.Location = scenario.Location; // if (profile1D != null) // { -// failureMechanismeParamatersMStab.SoilProfile = profile1D; +// failureMechanismeParamatersMStab.SoilProfile1D = profile1D; // // 1d-geometry -// failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometryType = -// SoilGeometryType.SoilGeometry1D; +// failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType = +// SoilProfileType.ProfileType1D; // } // else // { // // 2d-geometry -// failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometryType = -// SoilGeometryType.SoilGeometry2D; +// failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilProfileType = +// SoilProfileType.ProfileType2D; // } // // Geometry Creation Options // failureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.SoilGeometry2DFilename = Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculation.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculation.cs (.../StabilityCalculation.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Stability/StabilityCalculation.cs (.../StabilityCalculation.cs) (revision 578) @@ -224,7 +224,7 @@ // result = (CalculationResult) calculationmodule.Calculate(stabilityObjects, dumpdata); //Calculate should return results // // //DataEventPublisher.IsDataEventPublishStopped = true; - // mStabProject.SlidingData = ConvertDumpData2CalculationResults.Convert(dumpdata, mStabProject.Stability.SoilProfile); + // mStabProject.SlidingData = ConvertDumpData2CalculationResults.Convert(dumpdata, mStabProject.Stability.SoilProfile1D); // } // catch (Exception e) // { Index: dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs =================================================================== diff -u -r572 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs (.../FillXmlInputFromDam.cs) (revision 572) +++ dam engine/trunk/src/Deltares.DamEngine.Interface/FillXmlInputFromDam.cs (.../FillXmlInputFromDam.cs) (revision 578) @@ -388,15 +388,15 @@ { inputSoilGeometryProbability.FailureMechanismSystemTypeSpecified = false; } - if (soilGeometryProbability.SoilGeometryType == SoilGeometryType.SoilGeometry1D) + if (soilGeometryProbability.SoilProfileType == SoilProfileType.ProfileType1D) { - inputSoilGeometryProbability.SoilGeometryName = soilGeometryProbability.SoilGeometry1DName; + inputSoilGeometryProbability.SoilGeometryName = soilGeometryProbability.SoilProfile1DName; } else { - inputSoilGeometryProbability.SoilGeometryName = soilGeometryProbability.SoilGeometry2DName; + inputSoilGeometryProbability.SoilGeometryName = soilGeometryProbability.SoilProfile2DName; } - inputSoilGeometryProbability.SoilGeometryType = ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryProbability.SoilGeometryType); + inputSoilGeometryProbability.SoilGeometryType = ConversionHelper.ConvertToInputSoilGeometryType(soilGeometryProbability.SoilProfileType); inputSegment.SoilGeometryProbability[i] = inputSoilGeometryProbability; } } Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/MStabParameters.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/MStabParameters.cs (.../MStabParameters.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/MStabParameters.cs (.../MStabParameters.cs) (revision 578) @@ -389,7 +389,7 @@ { public MStabGeometryCreationOptions() { - SoilGeometryType = SoilGeometryType.SoilGeometry1D; + SoilProfileType = SoilProfileType.ProfileType1D; SoilGeometry2DFilename = ""; XOffsetSoilGeometry2DOrigin = 0.0; MaterialForDike = ""; @@ -402,7 +402,7 @@ PenetrationLength = 0.0; IsDesign = false; } - public SoilGeometryType SoilGeometryType { get; set; } + public SoilProfileType SoilProfileType { get; set; } public string SoilGeometry2DFilename { get; set; } public double XOffsetSoilGeometry2DOrigin { get; set; } public string MaterialForDike { get; set; } @@ -417,7 +417,7 @@ public void Assign(MStabGeometryCreationOptions mstabGeometryCreationOptions) { - this.SoilGeometryType = mstabGeometryCreationOptions.SoilGeometryType; + this.SoilProfileType = mstabGeometryCreationOptions.SoilProfileType; this.SoilGeometry2DFilename = mstabGeometryCreationOptions.SoilGeometry2DFilename; this.XOffsetSoilGeometry2DOrigin = mstabGeometryCreationOptions.XOffsetSoilGeometry2DOrigin; this.MaterialForDike = mstabGeometryCreationOptions.MaterialForDike; Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DAMFailureMechanismeCalculator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DAMFailureMechanismeCalculator.cs (.../DAMFailureMechanismeCalculator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DAMFailureMechanismeCalculator.cs (.../DAMFailureMechanismeCalculator.cs) (revision 578) @@ -175,7 +175,7 @@ { if (soilProfileProbability.SegmentFailureMechanismType == failureMechanismSystemType || soilProfileProbability.SegmentFailureMechanismType == null) { - scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, surfaceLine); + scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, surfaceLine); } } } @@ -354,12 +354,12 @@ // double? betaloc; // if (newSurfaceLine != null) // { -// betaloc = pipingCalculator.CalculateReliabilityIndex(scenario.Location, newSurfaceLine, soilProfileProbability.SoilProfile, waterLevel); +// betaloc = pipingCalculator.CalculateReliabilityIndex(scenario.Location, newSurfaceLine, soilProfileProbability.SoilProfile1D, waterLevel); // } // else // { -// betaloc = pipingCalculator.CalculateReliabilityIndex(scenario.Location, scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName), soilProfileProbability.SoilProfile, waterLevel); +// betaloc = pipingCalculator.CalculateReliabilityIndex(scenario.Location, scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName), soilProfileProbability.SoilProfile1D, waterLevel); // } // return betaloc; // } @@ -408,8 +408,8 @@ // case ProbabilisticType.Deterministic: // safetyFactor = pipingCalculator.CalculatePipingFactor( // scenario.Location, -// scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName), -// soilProfileProbability.SoilProfile, +// scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName), +// soilProfileProbability.SoilProfile1D, // scenario.RiverLevel); // if (pipingCalculator.UpliftLocationAndResult != null) // { @@ -429,8 +429,8 @@ // failureProbability = // pipingCalculator.CalculatePipingFailureProbability( // scenario.Location, -// scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName), -// soilProfileProbability.SoilProfile, +// scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName), +// soilProfileProbability.SoilProfile1D, // waterLevelProbabilistic); // break; // case ProbabilisticType.ProbabilisticFragility: @@ -445,15 +445,15 @@ // // if (pipingCalculationType == PipingModelType.SellmeijerVnk) // { -// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, safetyFactor); +// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, safetyFactor); // if (ProbabilisticType == ProbabilisticType.ProbabilisticFragility) // { -// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // failureProbabilityAdvanced); // } // else // { -// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // failureProbability); // } // } @@ -486,7 +486,7 @@ // break; // } // } -// scenario.SetPipingResults(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, pipingResults); +// scenario.SetPipingResults(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, pipingResults); // } // catch (DamFailureMechanismeCalculatorException calculatorException) // { @@ -497,7 +497,7 @@ // errorMessage = errorMessage + ";" + innerException.Message; // innerException = innerException.InnerException; // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, errorMessage); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, errorMessage); // // calculatorException.Scenario = scenario; // throw calculatorException; @@ -627,12 +627,12 @@ // { // try // { -// UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); +// UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // // The calculation for UpliftVan will only will done if there is Uplift // if (IsCalculationRequired(upliftSituation)) // { -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), iter); -// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), iter); +// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // if ((mStabResults != null) && (AnalysisType.AdaptNWO == analysisType)) // { // // Store the NWO results @@ -658,8 +658,8 @@ // // assign original surfaceline to redesigned surfaceline (not for NWODesign as that would provide wrong surface line) // if (analysisType != AnalysisType.AdaptNWO) // { -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, // scenario.Location.SurfaceLine2); // } // } @@ -672,8 +672,8 @@ // errorMessage = errorMessage + ";" + innerException.Message; // innerException = innerException.InnerException; // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, errorMessage); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, errorMessage); // // calculatorException.Scenario = scenario; // errorCount++; @@ -1000,11 +1000,11 @@ // newSurfaceLine = newCandidate; // } // -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, newSurfaceLine); -// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, safetyFactor); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, newSurfaceLine); +// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, safetyFactor); // PipingResults pipingResults = GetPipingResults(safetyFactor, pipingModelType, pipingCalculator); -// scenario.SetPipingResults(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, pipingResults); +// scenario.SetPipingResults(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, pipingResults); // break; // } // @@ -1026,7 +1026,7 @@ // // start by checking the uplift first (if so, a newShoulderHeight can be determined). If uplift is not an issue then // // probability of failure = 0. If uplift is an issue, add a berm until uplift is no longer an issue. // double? newShoulderHeight = pipingCalculator.CalculateDesignShoulderHeight(scenario.Location, newSurfaceLine, -// soilProfileProbability.SoilProfile, waterLevel); +// soilProfileProbability.SoilProfile1D, waterLevel); // // double currentShoulderHeight = 0; // double currentShoulderWidth = 0; @@ -1075,7 +1075,7 @@ // surfaceLineShoulderAdapter.MaxShoulderLevel = maxShoulderLevel; // newSurfaceLine = surfaceLineShoulderAdapter.ConstructNewSurfaceLine(newShoulderWidth, newShoulderHeight.Value, true); // newShoulderHeight = pipingCalculator.CalculateDesignShoulderHeight(scenario.Location, newSurfaceLine, -// soilProfileProbability.SoilProfile, waterLevel); +// soilProfileProbability.SoilProfile1D, waterLevel); // finished = (pipingCalculator.UpliftLocationAndResult.X > shoulderTopInside.X); // if (newShoulderHeight != null && (!finished)) // { @@ -1110,7 +1110,7 @@ // var waterLevelProbabilistic = new ProbabilisticStruct(0.0, 0.01, (int) DistributionType.LogNormal, false); // waterLevelProbabilistic.Mean = scenario.RiverLevel; // failureProbability = pipingCalculator.CalculatePipingFailureProbability(scenario.Location, newSurfaceLine, -// soilProfileProbability.SoilProfile, waterLevelProbabilistic); +// soilProfileProbability.SoilProfile1D, waterLevelProbabilistic); // } // else // { @@ -1140,7 +1140,7 @@ // waterLevelProbabilistic.Mean = scenario.RiverLevel; // failureProbability = pipingCalculator.CalculatePipingFailureProbability( // scenario.Location, newSurfaceLine, -// soilProfileProbability.SoilProfile, waterLevelProbabilistic); +// soilProfileProbability.SoilProfile1D, waterLevelProbabilistic); // } // else // { @@ -1159,9 +1159,9 @@ // if (iterationIndex >= PipingRedesingMaxIterations) // { // // #BKA: vraag voor Ray set the results in case of failure too to provide feedback. (of niet Tom???) Voorlopig even niet. Ray was net naar huis dus nog navragen. -// // scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// // scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // // failureProbability); -// // scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// // scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // // newSurfaceLine); // throw new MaximumRedesignIterationsReachedException(); // } @@ -1170,30 +1170,30 @@ // } // if (failureProbability != null) // { -// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // failureProbability); // } // else // { -// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, +// scenario.SetFailureProbabilityPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, // 999); // } -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, newSurfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, newSurfaceLine); // break; // } // } // -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, "Succes"); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, "Succes"); // } // catch (Exception exception) // { // string errorMessage = String.Format("Location '{0}', Soilprofile '{1}': {2}", // scenario.Location.Name, soilProfileProbability.SoilGeometryName, exception.Message); // PipingResults pipingResults = GetPipingResults(-1, pipingModelType, pipingCalculator); -// scenario.SetPipingResults(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, pipingResults); -// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, -1); +// scenario.SetPipingResults(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, pipingResults); +// scenario.SetSafetyFactorPiping(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, -1); // scenario.Errors.Add("FAIL: " + errorMessage); -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, "FAIL: " + errorMessage); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, "FAIL: " + errorMessage); // } // } // } @@ -1281,12 +1281,12 @@ // // Determine calculation filename to output piping calculation file // //pipingCalculator.PipingCalculationDirectory = GetPipingCalculationBaseDirectory(); // //string fileNameCalculation =String.Format("Calc({0})_Loc({1})_Pro({2})_Pnt({3}))", -// // pipingCalculator.CalculationModelIdentifier, scenario.Location.Name, soilProfileProbability.SoilProfile.Name, pointCount.ToString("d4")); ; +// // pipingCalculator.CalculationModelIdentifier, scenario.Location.Name, soilProfileProbability.SoilProfile1D.Name, pointCount.ToString("d4")); ; // //pipingCalculator.FilenameCalculation = Path.Combine(pipingCalculator.PipingCalculationDirectory, fileNameCalculation); // // // Calculate the piping design at the given point. This returns the required adaption (berm length and height) if any. // var pipingDesign = pipingCalculator.CalculateDesignAtPoint(scenario.Location, surfaceLine, -// soilProfileProbability.SoilProfile, +// soilProfileProbability.SoilProfile1D, // scenario.RiverLevel, point); // if (pipingDesign != null) // { @@ -1322,7 +1322,7 @@ // surfaceLineShoulderAdapter.MaxShoulderLevel = maxShoulderLevel; // SurfaceLine2 newSurfaceLine = surfaceLineShoulderAdapter.ConstructNewSurfaceLine(desiredShoulderLength, desiredShoulderHeight, true); // -// safetyFactor = pipingCalculator.CalculatePipingFactor(scenario.Location, newSurfaceLine, soilProfileProbability.SoilProfile, scenario.RiverLevel); +// safetyFactor = pipingCalculator.CalculatePipingFactor(scenario.Location, newSurfaceLine, soilProfileProbability.SoilProfile1D, scenario.RiverLevel); // if (safetyFactor < scenario.RequiredSafetyFactorPiping) // { // throw new DamFailureMechanismeCalculatorException("Deterministic Design: Piping is not safe yet."); @@ -1350,12 +1350,12 @@ // double riverLevel = 0.5*(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver).Z + // surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z); // string soilgeometry2DFilename = null; -// if (soilProfileProbability.SoilGeometry2DName != null) +// if (soilProfileProbability.StiFileName != null) // { // soilgeometry2DFilename = -// Path.GetFullPath(Path.Combine(DamProject.ProjectMap, Path.Combine(scenario.Location.MapForSoilGeometries2D, soilProfileProbability.SoilGeometry2DName))); +// Path.GetFullPath(Path.Combine(DamProject.ProjectMap, Path.Combine(scenario.Location.MapForSoilGeometries2D, soilProfileProbability.StiFileName))); // } -// XDocument mstabXML = stabilityCalculator.CreateMStabXmlDoc(initialgeometryFile, scenario, soilProfileProbability.SoilProfile, +// XDocument mstabXML = stabilityCalculator.CreateMStabXmlDoc(initialgeometryFile, scenario, soilProfileProbability.SoilProfile1D, // soilgeometry2DFilename, riverLevel, null, surfaceLine); // mstabXML.Save(initialgeometryFile + ".xml"); // var stabilityServiceAgent = new StabilityServiceAgent(); @@ -1407,7 +1407,7 @@ // foreach (var soilProfileProbability in validSoilProfileProbabilities) // { // // The calculation for UpliftVan will only will done if there is Uplift -// UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); +// UpliftSituation? upliftSituation = scenario.GetStabilityUpliftSituation(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // if (IsCalculationRequired(upliftSituation)) // { // switch (scenario.Location.StabilityDesignMethod) @@ -1458,7 +1458,7 @@ // // // Create the file with the initial geometry to be used to determine which layers have to be defined as dike embankment material // CreateInitialGeometry(scenario, stabilityCalculator, soilProfileProbability, orgSurfaceLine, out previousFilename); -// SurfaceLine2 surfaceLine = scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName).FullDeepClone(); +// SurfaceLine2 surfaceLine = scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName).FullDeepClone(); // // var mstabDesignEmbankment = new MStabDesignEmbankment // { @@ -1472,24 +1472,24 @@ // bool isRedesignRequired; // double? exitPointXCoordinate; // scenario.Location.AlignBoundaryPointsOfPL1LineWithAdaptedSurfaceLine(surfaceLine); -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, -// GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, +// GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), // iterationIndex, mstabDesignEmbankment); // mstabDesignEmbankment.PreviousGeometry2DFilename = stabilityCalculator.StabilityProjectFilename; // mstabDesignEmbankment.EmbankmentMaterialname = location.ShoulderEmbankmentMaterial; -// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // double? safetyFactor = mStabResults.Value.zone1.safetyFactor; -// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // isRedesignRequired = IsRedesignRequired(safetyFactor, requiredSafetyFactor, betaRequired, beta); // exitPointXCoordinate = mStabResults.Value.zone1.circleSurfacePointRightXCoordinate; // // if (!isRedesignRequired && surfaceLine != null) // { // // Set redesigned surfaceline to original, so in case no redesign is needed, the original surfaceline will be returned -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, surfaceLine); // } // else // { @@ -1526,7 +1526,7 @@ // throw new SurfaceLineException(validationError.Text); // } // -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, surfaceLine); // } // else // { @@ -1539,25 +1539,25 @@ // { // throw new SurfaceLineException(validationError.Text); // } -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, surfaceLine); // } // // scenario.Location.AlignBoundaryPointsOfPL1LineWithAdaptedSurfaceLine(surfaceLine); -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, -// GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, +// GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), // iterationIndex, mstabDesignEmbankment); // -// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // safetyFactor = mStabResults.Value.zone1.safetyFactor; -// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // isRedesignRequired = IsRedesignRequired(safetyFactor, requiredSafetyFactor, betaRequired, beta); // exitPointXCoordinate = mStabResults.Value.zone1.circleSurfacePointRightXCoordinate; // } // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, "Succes"); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, "Succes"); // } // catch (Exception exception) // { @@ -1568,13 +1568,13 @@ // errorMessage = errorMessage + ";" + innerException.Message; // innerException = innerException.InnerException; // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, errorMessage); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, errorMessage); // // Add message to log too for output tab. // errorMessage = scenario.Location.Name + ", scenario " + scenario.LocationScenarioID + ", " + soilProfileProbability.SoilGeometryName + " " + errorMessage; // stabilityCalculator.ErrorMessages.Add(new LogMessage(LogMessageType.Error, this, errorMessage)); // scenario.CalculationResult = CalculationResult.RunFailed; // // Redesign not succesful, so no redesigned surfaceline will be returned -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, null); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, null); // } // foreach (var errorMessage in stabilityCalculator.ErrorMessages) // { @@ -1633,7 +1633,7 @@ // // // Create the file with the initial geometry to be used to determine which layers have to be defined as dike embankment material // CreateInitialGeometry(scenario, stabilityCalculator, soilProfileProbability, orgSurfaceLine, out previousFilename); -// SurfaceLine2 surfaceLine = scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName).FullDeepClone(); +// SurfaceLine2 surfaceLine = scenario.GetMostRecentSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName).FullDeepClone(); // // var mstabDesignEmbankment = new MStabDesignEmbankment // { @@ -1647,24 +1647,24 @@ // bool isRedesignRequired; // double? exitPointXCoordinate; // scenario.Location.AlignBoundaryPointsOfPL1LineWithAdaptedSurfaceLine(surfaceLine); -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, -// GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, +// GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), // iterationIndex, mstabDesignEmbankment); // mstabDesignEmbankment.PreviousGeometry2DFilename = stabilityCalculator.StabilityProjectFilename; // mstabDesignEmbankment.EmbankmentMaterialname = location.ShoulderEmbankmentMaterial; -// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// MStabResults? mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // double? safetyFactor = mStabResults.Value.zone1.safetyFactor; -// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // isRedesignRequired = IsRedesignRequired(safetyFactor, requiredSafetyFactor, betaRequired, beta); // exitPointXCoordinate = mStabResults.Value.zone1.circleSurfacePointRightXCoordinate; // // if (!isRedesignRequired && surfaceLine != null) // { // // Set redesigned surfaceline to original, so in case no redesign is needed, the original surfaceline will be returned -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, surfaceLine); // } // else // { @@ -1706,20 +1706,20 @@ // { // throw new SurfaceLineException(validationError.Text); // } -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName, surfaceLine); // // // Recalculate new surfaceline // scenario.Location.AlignBoundaryPointsOfPL1LineWithAdaptedSurfaceLine(surfaceLine); -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, -// GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, +// GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), // iterationIndex, mstabDesignEmbankment); -// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // safetyFactor = mStabResults.Value.zone1.safetyFactor; // exitPointXCoordinate = mStabResults.Value.zone1.circleSurfacePointRightXCoordinate; -// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile, -// soilProfileProbability.SoilGeometry2DName); +// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile1D, +// soilProfileProbability.StiFileName); // isRedesignRequired = IsRedesignRequired(safetyFactor, requiredSafetyFactor, betaRequired, beta); // limitPointForShoulderDesign = surfaceLine.GetLimitPointForShoulderDesign(); // @@ -1752,22 +1752,22 @@ // { // throw new SurfaceLineException(validationError.Text); // } -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, surfaceLine); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, surfaceLine); // // // Recalculate new surfaceline // scenario.Location.AlignBoundaryPointsOfPL1LineWithAdaptedSurfaceLine(surfaceLine); -// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile, -// GetFullSoilGeometry2DName(soilProfileProbability.SoilGeometry2DName), +// stabilityCalculator.Calculate(scenario, soilProfileProbability.SoilProfile1D, +// GetFullSoilGeometry2DName(soilProfileProbability.StiFileName), // iterationIndex, mstabDesignEmbankment); -// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); +// mStabResults = scenario.GetMStabResults(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // safetyFactor = mStabResults.Value.zone1.safetyFactor; -// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName); +// beta = scenario.GetFailureProbabilityStability(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName); // isRedesignRequired = IsRedesignRequired(safetyFactor, requiredSafetyFactor, betaRequired, beta); // limitPointForShoulderDesign = surfaceLine.GetLimitPointForShoulderDesign(); // } // } // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, "Succes"); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, "Succes"); // } // catch (Exception exception) // { @@ -1778,10 +1778,10 @@ // errorMessage = errorMessage + ";" + innerException.Message; // innerException = innerException.InnerException; // } -// scenario.SetResultMessage(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, errorMessage); +// scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, errorMessage); // scenario.CalculationResult = CalculationResult.RunFailed; // // Redesign not succesful, so no redesigned surfaceline will be returned -// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile, soilProfileProbability.SoilGeometry2DName, null); +// scenario.SetRedesignedSurfaceLine(soilProfileProbability.SoilProfile1D, soilProfileProbability.StiFileName, null); // } // foreach (var errorMessage in stabilityCalculator.ErrorMessages) // { Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenarioSelector.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenarioSelector.cs (.../RWScenarioSelector.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/RWScenarioSelector.cs (.../RWScenarioSelector.cs) (revision 578) @@ -69,7 +69,7 @@ for (int i = 1; i < evaluators.Length + 1; i++) { - choices[i] = evaluators[i - 1].Evaluate(location, new SoilGeometry(soilGeometryProbability.SoilProfile, null), choices.ToArray()); + choices[i] = evaluators[i - 1].Evaluate(location, new SoilGeometry(soilGeometryProbability.SoilProfile1D, null), choices.ToArray()); //Is het een doorlopende tak? Zo niet break af (afbreken als geen veenkade en droge belastingsituatie resultsInScenarios = WillChoicesResultInScenarios(choices.ToArray()); @@ -201,7 +201,7 @@ //{ // // Soils are not transferred to the computational core at the moment, therefore this code has no meaning at the moment // // You could say the same about soils in general in the DAM C# code - // SoilProfile drySoilProfile = soilProfile.Clone(); + // SoilProfile1D drySoilProfile = soilProfile.Clone(); // foreach (Layer layer in drySoilProfile.Layers) // { // layer.Soil.AbovePhreaticLevel = layer.Soil.DryUnitWeight; @@ -230,7 +230,7 @@ //{ // // Soils are not transferred to the computational core at the moment, therefore this code has no meaning at the moment // // You could say the same about soils in general in the DAM C# code - // SoilProfile drySoilProfile = soilProfile.Clone(); + // SoilProfile1D drySoilProfile = soilProfile.Clone(); // foreach (Layer layer in drySoilProfile.Layers) // { // layer.Soil.AbovePhreaticLevel = layer.Soil.DryUnitWeight; Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/UpliftRWEvaluator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/UpliftRWEvaluator.cs (.../UpliftRWEvaluator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Assessment Regional/UpliftRWEvaluator.cs (.../UpliftRWEvaluator.cs) (revision 578) @@ -87,7 +87,7 @@ plLinesCreator.ModelParametersForPLLines = location.ModelParametersForPLLines; plLinesCreator.SoilProfile = soilGeometry.SoilProfile; plLinesCreator.SoilGeometry2DName = null; - plLinesCreator.SoilGeometryType = SoilGeometryType.SoilGeometry1D; + plLinesCreator.SoilProfileType = SoilProfileType.ProfileType1D; plLinesCreator.GaugePLLines = null; plLinesCreator.Gauges = null; plLinesCreator.GaugeMissVal = 0.0; Index: dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/TestFiles/InputFile.xml =================================================================== diff -u -r572 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/TestFiles/InputFile.xml (.../InputFile.xml) (revision 572) +++ dam engine/trunk/src/Deltares.DamEngine.Interface.Tests/TestFiles/InputFile.xml (.../InputFile.xml) (revision 578) @@ -71,30 +71,30 @@ - + - + - - + + - - + + - - - - + + + + @@ -143,8 +143,8 @@ - - + + @@ -193,6 +193,6 @@ - - + + \ No newline at end of file Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculatorCsvExportDataBuilder.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculatorCsvExportDataBuilder.cs (.../DamProjectCalculatorCsvExportDataBuilder.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculatorCsvExportDataBuilder.cs (.../DamProjectCalculatorCsvExportDataBuilder.cs) (revision 578) @@ -88,8 +88,8 @@ Message.ToString(), FailureMechanismSystemType, Scenario, - soilGeometryProbability.SoilProfile, - soilGeometryProbability.SoilGeometry2DName, + soilGeometryProbability.SoilProfile1D, + soilGeometryProbability.StiFileName, AnalysisType, index); Message.Clear(); Index: dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs =================================================================== diff -u -r572 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs (.../FillDamFromXmlInput.cs) (revision 572) +++ dam engine/trunk/src/Deltares.DamEngine.Interface/FillDamFromXmlInput.cs (.../FillDamFromXmlInput.cs) (revision 578) @@ -107,15 +107,15 @@ { foreach (var segmentSoilProfileProbability in segment.SoilProfileProbabilities) { - if (segmentSoilProfileProbability.SoilGeometryType == SoilGeometryType.SoilGeometry1D) + if (segmentSoilProfileProbability.SoilProfileType == SoilProfileType.ProfileType1D) { - segmentSoilProfileProbability.SoilProfile = FindSoilProfile1DByName(project.Dike.SoilProfiles, - segmentSoilProfileProbability.SoilGeometry1DName); + segmentSoilProfileProbability.SoilProfile1D = FindSoilProfile1DByName(project.Dike.SoilProfiles, + segmentSoilProfileProbability.SoilProfile1DName); } else { segmentSoilProfileProbability.SoilProfile2D = FindSoilProfile2DByName(project.Dike.SoilProfiles2D, - segmentSoilProfileProbability.SoilGeometry2DName); + segmentSoilProfileProbability.SoilProfile2DName); } } } @@ -374,18 +374,20 @@ { soilGeometryProbability.SegmentFailureMechanismType = null; } - if (inputSoilGeometryProbability.SoilGeometryType == SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D) + switch (inputSoilGeometryProbability.SoilGeometryType) { - soilGeometryProbability.SoilGeometry1DName = inputSoilGeometryProbability.SoilGeometryName; + case SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D: + { + soilGeometryProbability.SoilProfile1DName = inputSoilGeometryProbability.SoilGeometryName; + break; + } + case SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D: + { + soilGeometryProbability.SoilProfile2DName = inputSoilGeometryProbability.SoilGeometryName; + break; + } } - else - { - soilGeometryProbability.SoilGeometry2DName = inputSoilGeometryProbability.SoilGeometryName; - } - if (soilGeometryProbability.SoilGeometryType != ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryProbability.SoilGeometryType)) - { - throw new ConversionException(typeof(SegmentSoilGeometryProbabilitySoilGeometryType), soilGeometryProbability.SoilGeometryType); - } + soilGeometryProbability.SoilProfileType = ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryProbability.SoilGeometryType); segment.SoilProfileProbabilities.Add(soilGeometryProbability); } } Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculator.cs (.../DamProjectCalculator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/General/DamProjectCalculator.cs (.../DamProjectCalculator.cs) (revision 578) @@ -449,8 +449,8 @@ foreach (var nwoResult in scenario.NwoResults) { var resultMessage = scenario.GetResultMessage( - nwoResult.SoilProfileProbability.SoilProfile, - nwoResult.SoilProfileProbability.SoilGeometry2DName); + nwoResult.SoilProfileProbability.SoilProfile1D, + nwoResult.SoilProfileProbability.StiFileName); // The error message can contain "," and ";" and should therefor be surrounded with double quotes, so it will be read correctly as a scv file damProjectCalculatorLogBuilder.Append( @"""", @@ -482,8 +482,8 @@ if (scenario.CalculationResult != CalculationResult.NoRun) { // The error message can contain "," and ";" and should therefor be surrounded with double quotes, so it will be read correctly as a csv file - string resultMessage = scenario.GetResultMessage(soilProfileProbability.SoilProfile, - soilProfileProbability.SoilGeometry2DName); + string resultMessage = scenario.GetResultMessage(soilProfileProbability.SoilProfile1D, + soilProfileProbability.StiFileName); damProjectCalculatorLogBuilder.Append( @"""", ++recordIndex, @@ -501,8 +501,8 @@ { // The error message can contain "," and ";" and should therefor be surrounded with double quotes, so it will be read correctly as a scv file var resultMessage = scenario.GetResultMessage( - soilProfileProbability.SoilProfile, - soilProfileProbability.SoilGeometry2DName); + soilProfileProbability.SoilProfile1D, + soilProfileProbability.StiFileName); damProjectCalculatorLogBuilder.Append( @"""", @@ -585,32 +585,42 @@ if (plLines != null) { - string fullSoilGeometry2DName = (soilProfileProbability.SoilGeometry2DName == null) ? null : - Path.Combine(ProjectDataDirectory, Path.Combine(dike.MapForSoilGeometries2D, soilProfileProbability.SoilGeometry2DName)); + string fullSoilGeometry2DName = (soilProfileProbability.StiFileName == null) ? null : + Path.Combine(ProjectDataDirectory, Path.Combine(dike.MapForSoilGeometries2D, soilProfileProbability.StiFileName)); double? upliftFactor = GetLowestUpliftFactor(surfaceLineWithNewHeight, - soilProfileProbability.SoilProfile, fullSoilGeometry2DName, plLines, scenario.Location); + soilProfileProbability.SoilProfile1D, fullSoilGeometry2DName, plLines, scenario.Location); upliftSituation.IsUplift = (upliftFactor < upliftCriterion); } else { upliftSituation.IsUplift = false; } - scenario.SetStabilityUpliftSituation(soilProfileProbability.SoilProfile, - soilProfileProbability.SoilGeometry2DName, upliftSituation); + scenario.SetStabilityUpliftSituation(soilProfileProbability.SoilProfile1D, + soilProfileProbability.StiFileName, upliftSituation); } catch (Exception exception) { + var soilGeometryName = soilProfileProbability.StiFileName; + switch (soilProfileProbability.SoilProfileType) + { + case SoilProfileType.ProfileType1D: + soilGeometryName = soilProfileProbability.SoilProfile1DName; + break; + case SoilProfileType.ProfileType2D: + soilGeometryName = soilProfileProbability.StiFileName; + break; + } string errorMessage = String.Format("{0} in location '{1}' scenario '{2}' soilprofile '{3}'", exception.Message, scenario.Location.Name, scenario.LocationScenarioID, - soilProfileProbability.SoilGeometryName); - scenario.SetResultMessage(soilProfileProbability.SoilProfile, - soilProfileProbability.SoilGeometry2DName, exception.Message); + soilGeometryName); + scenario.SetResultMessage(soilProfileProbability.SoilProfile1D, + soilProfileProbability.StiFileName, exception.Message); var resultRecord = new DesignResult("Error: " + exception.Message, damProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications[0], scenario, - soilProfileProbability.SoilProfile, - soilProfileProbability.SoilGeometry2DName, + soilProfileProbability.SoilProfile1D, + soilProfileProbability.StiFileName, DamProjectCalculationSpecification.SelectedAnalysisType, 0); scenario.CalculationResults.Add(resultRecord); @@ -840,11 +850,11 @@ { var plLinesCreator = new PLLinesCreator(); // Determine geometry type - SoilGeometryType soilGeometryType = soilProfileProbability.SoilGeometryType; + SoilProfileType soilProfileType = soilProfileProbability.SoilProfileType; string mapForSoilGeometries2D = location.MapForSoilGeometries2D; - SoilProfile1D soilProfile = soilProfileProbability.SoilProfile; - string soilGeometry2DName = soilProfileProbability.SoilGeometry2DName; - if ((soilProfileProbability.SoilGeometry2DName != null) && (mapForSoilGeometries2D != null)) + SoilProfile1D soilProfile = soilProfileProbability.SoilProfile1D; + string soilGeometry2DName = soilProfileProbability.StiFileName; + if ((soilProfileProbability.StiFileName != null) && (mapForSoilGeometries2D != null)) { soilGeometry2DName = Path.Combine(mapForSoilGeometries2D, soilGeometry2DName); soilGeometry2DName = Path.Combine(ProjectDataDirectory, soilGeometry2DName); @@ -862,7 +872,7 @@ plLinesCreator.ModelParametersForPLLines = location.ModelParametersForPLLines; plLinesCreator.SoilProfile = soilProfile; plLinesCreator.SoilGeometry2DName = soilGeometry2DName; - plLinesCreator.SoilGeometryType = soilGeometryType; + plLinesCreator.SoilProfileType = soilProfileType; plLinesCreator.GaugePLLines = location.GaugePLLines; plLinesCreator.Gauges = location.Gauges; plLinesCreator.GaugeMissVal = location.GaugeMissVal; Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/Segment.cs =================================================================== diff -u -r563 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/Segment.cs (.../Segment.cs) (revision 563) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/Segment.cs (.../Segment.cs) (revision 578) @@ -31,34 +31,31 @@ /// /// Class holding the soilprofile (either 1D or 2D) and its probability /// - /// - public class SoilGeometryProbability : IComparable + public class SoilGeometryProbability { /// - /// Gets or sets the soil profile. + /// Gets or sets the name of the SoilProfile1D. /// /// - /// The soil profile. + /// The name of the soilgeometry1d. /// - public virtual SoilProfile1D SoilProfile { get; set; } + public virtual string SoilProfile1DName { get; set; } /// - /// Gets or sets the name of the soilgeometry2d. + /// Gets or sets the soil profile 1D. /// /// - /// The name of the soilgeometry2d. + /// The soil profile. /// + public virtual SoilProfile1D SoilProfile1D { get; set; } - public virtual string SoilGeometry2DName { get; set; } - /// - /// Gets or sets the name of the soilgeometry1d. + /// Gets or sets the name of the SoilProfile2D. /// /// /// The name of the soilgeometry1d. /// - public virtual string SoilGeometry1DName { get; set; } - + public virtual string SoilProfile2DName { get; set; } /// /// Gets or sets the soilprofile2d. /// @@ -68,6 +65,15 @@ public virtual SoilProfile2D SoilProfile2D { get; set; } /// + /// Gets or sets the name of the sti file (that holds the 2D profile). + /// + /// + /// The name of the soilgeometry2d. + /// + + public virtual string StiFileName { get; set; } + + /// /// Gets or sets the type of the segment failure mechanism. /// /// @@ -82,87 +88,23 @@ /// The probability. /// public virtual double Probability { get; set; } - + /// - /// Assigns the specified soil geometry probability. - /// - /// The soil geometry probability. - public void Assign(SoilGeometryProbability soilGeometryProbability) - { - if (soilGeometryProbability.SoilProfile != null) - { - SoilProfile = new SoilProfile1D(); - SoilProfile.Assign(soilGeometryProbability.SoilProfile); - } - SegmentFailureMechanismType = soilGeometryProbability.SegmentFailureMechanismType; - Probability = soilGeometryProbability.Probability; - SoilGeometry2DName = soilGeometryProbability.SoilGeometry2DName; - } - - /// /// Gets the type of the soil geometry. /// /// /// The type of the soil geometry. /// /// No soilprofile assigned - public SoilGeometryType SoilGeometryType - { - get - { - if (SoilProfile != null || !string.IsNullOrEmpty(SoilGeometry1DName)) - { - return SoilGeometryType.SoilGeometry1D; - } - else - { - if (SoilGeometry2DName == null) - { - throw new Exception("No soilprofile assigned"); - } - return SoilGeometryType.SoilGeometry2D; - } - } - } - - /// - /// Returns either the 1D-geometry or the 2D-geometry name - /// - public virtual string SoilGeometryName - { - get - { - string soilGeometryName = ""; - if (this.SoilProfile != null) - { - soilGeometryName = this.SoilProfile.Name; - } - else - { - soilGeometryName = this.SoilGeometry2DName; - } return soilGeometryName; - } - } - - /// - /// Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object. - /// - /// An object to compare with this instance. - /// - /// A value that indicates the relative order of the objects being compared. The return value has these meanings: Value Meaning Less than zero This instance precedes in the sort order. Zero This instance occurs in the same position in the sort order as . Greater than zero This instance follows in the sort order. - /// - public int CompareTo(SoilGeometryProbability other) - { - return - this.Probability.CompareTo(other.Probability); - } + public SoilProfileType SoilProfileType { get; set; } } /// /// Class holding all soilprofiles (1D/2D) and their probabilities as segment. /// public class Segment { - private List soilGeometryProbabilities = new List(); + private readonly List soilGeometryProbabilities = new List(); /// /// Gets or sets the name. @@ -191,8 +133,8 @@ where !spp.SegmentFailureMechanismType.HasValue || !segmentFailureMechanismType.HasValue || spp.SegmentFailureMechanismType == segmentFailureMechanismType orderby spp.Probability descending select spp; - if (spps.Count() > 0) - return spps.First().SoilProfile; + if (spps.Any()) + return spps.First().SoilProfile1D; else return null; } @@ -208,73 +150,13 @@ where !spp.SegmentFailureMechanismType.HasValue || !segmentFailureMechanismType.HasValue || spp.SegmentFailureMechanismType == segmentFailureMechanismType orderby spp.Probability descending select spp; - if (spps.Count() > 0) - return spps.First().SoilGeometry2DName; + if (spps.Any()) + return spps.First().StiFileName; else return null; } /// - /// Adds the soilprofile1D probability. - /// - /// The soil profile. - /// The probability. - /// Type of the segment failure mechanism. - public void AddSoilProfileProbability(SoilProfile1D soilProfile, double probability, FailureMechanismSystemType? segmentFailureMechanismType) - { - if (this.soilGeometryProbabilities.Where(x => x.SoilProfile == soilProfile && x.SegmentFailureMechanismType == segmentFailureMechanismType).Count() == 0) - this.soilGeometryProbabilities.Add(new SoilGeometryProbability() { SoilProfile = soilProfile, Probability = probability, SegmentFailureMechanismType = segmentFailureMechanismType, SoilGeometry2DName = null }); - } - - /// - /// Gets the soilprofile1D probability. - /// - /// The soil profile. - /// Type of the segment failure mechanism. - /// - public double? GetSoilProfileProbability(SoilProfile1D soilProfile, FailureMechanismSystemType? segmentFailureMechanismType) - { - IEnumerable probs = this.soilGeometryProbabilities.Where( - x => (x.SoilProfile == soilProfile) && - (segmentFailureMechanismType == null || x.SegmentFailureMechanismType == segmentFailureMechanismType || x.SegmentFailureMechanismType == null)); - - if (probs.Count() > 0) - return probs.Select(x => x.Probability).Average(); - else - return null; - } - - /// - /// Adds the soilgeometry2d probability. - /// - /// Name of the soilgeometry2d (= profile2D). - /// The probability. - /// Type of the segment failure mechanism. - public void AddSoilGeometry2DProbability(string soilGeometry2DName, double probability, FailureMechanismSystemType? segmentFailureMechanismType) - { - if (this.soilGeometryProbabilities.Where(x => x.SoilGeometry2DName == soilGeometry2DName && x.SegmentFailureMechanismType == segmentFailureMechanismType).Count() == 0) - this.soilGeometryProbabilities.Add(new SoilGeometryProbability() { SoilProfile = null, Probability = probability, SegmentFailureMechanismType = segmentFailureMechanismType, SoilGeometry2DName = soilGeometry2DName }); - } - - /// - /// Gets the soilgeometry2d probability. - /// - /// Name of the soilgeometry2d (=profile2D). - /// Type of the segment failure mechanism. - /// - public double? GetSoilGeometry2DProbability(string soilGeometry2DName, FailureMechanismSystemType? segmentFailureMechanismType) - { - IEnumerable probs = this.soilGeometryProbabilities.Where( - x => (x.SoilGeometry2DName == soilGeometry2DName) && - (segmentFailureMechanismType == null || x.SegmentFailureMechanismType == segmentFailureMechanismType || x.SegmentFailureMechanismType == null)); - - if (probs.Count() > 0) - return probs.Select(x => x.Probability).Average(); - else - return null; - } - - /// /// Returns a that represents this instance. /// /// @@ -291,69 +173,18 @@ sb.Append(": "); foreach (SoilGeometryProbability spp in this.SoilProfileProbabilities.Where(x => x.SegmentFailureMechanismType == null || x.SegmentFailureMechanismType == type)) { - if (spp.SoilProfile != null) + if (spp.SoilProfile1D != null) { - sb.Append(String.Format("(1D) {0} ({1}%) ", spp.SoilProfile.Name, spp.Probability)); + sb.Append(String.Format("(1D) {0} ({1}%) ", spp.SoilProfile1D.Name, spp.Probability)); } else { - sb.Append(String.Format("(2D) {0} ({1}%) ", spp.SoilGeometry2DName, spp.Probability)); + sb.Append(String.Format("(2D) {0} ({1}%) ", spp.StiFileName, spp.Probability)); } } } - return sb.ToString(); - } - - /// - /// Assemble a list of key/value pairs with the relevant parameters for the specified 1d-profile - /// - /// The soil profile1 d identifier. - /// Type of the failure mechanism system. - /// - public Dictionary GetParametersForSoilProfile1DAsNameValuePairs(string soilProfile1DId, FailureMechanismSystemType failureMechanismSystemType) - { - SoilGeometryProbability soilProfileProbability = this.SoilProfileProbabilities.FirstOrDefault(x => (x.SoilProfile != null && - x.SoilProfile.Name.Equals(soilProfile1DId) && - x.SegmentFailureMechanismType == failureMechanismSystemType - )); - if (soilProfileProbability != null) - { - var nameValuePairs = new Dictionary(); - var numberFormatInfo = new NumberFormatInfo(); - numberFormatInfo.NumberDecimalSeparator = "."; - nameValuePairs.Add("Probability", soilProfileProbability.Probability.ToString(numberFormatInfo)); - nameValuePairs.Add("FailureMechanismType", soilProfileProbability.SegmentFailureMechanismType.ToString()); - return nameValuePairs; - } - else - { - return null; - } - } - - /// - /// Assemble a list of key/value pairs with the relevant parameters for the specified 2d-profile - /// - /// - public Dictionary GetParametersForSoilProfile2DAsNameValuePairs(string soilProfile2DId, FailureMechanismSystemType failureMechanismSystemType) - { - SoilGeometryProbability soilProfileProbability = this.SoilProfileProbabilities.FirstOrDefault(x => x.SoilGeometry2DName.Equals(soilProfile2DId) && - x.SegmentFailureMechanismType == failureMechanismSystemType); - if (soilProfileProbability != null) - { - var nameValuePairs = new Dictionary(); - var numberFormatInfo = new NumberFormatInfo(); - numberFormatInfo.NumberDecimalSeparator = "."; - nameValuePairs.Add("Probability", soilProfileProbability.Probability.ToString(numberFormatInfo)); - nameValuePairs.Add("FailureMechanismType", soilProfileProbability.SegmentFailureMechanismType.ToString()); - return nameValuePairs; - } - else - { - return null; - } - } + } } } \ No newline at end of file Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs =================================================================== diff -u -r538 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs (.../DAMEnumerations.cs) (revision 538) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/DAMEnumerations.cs (.../DAMEnumerations.cs) (revision 578) @@ -48,7 +48,7 @@ public enum DamProjectType { Assessment, - AssessmentRegional, + AssessmentRegional, // #Bka: was/is: Assessment + type = regional. Not yet properly replaced Operational, Design, // TODO: NWO obsolete @@ -138,10 +138,11 @@ OrginalPLLines } - public enum SoilGeometryType + public enum SoilProfileType { - SoilGeometry1D, - SoilGeometry2D + ProfileType1D, + ProfileType2D, + ProfileTypeStiFile } Index: dam engine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs =================================================================== diff -u -r570 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs (.../ConversionHelper.cs) (revision 570) +++ dam engine/trunk/src/Deltares.DamEngine.Interface/ConversionHelper.cs (.../ConversionHelper.cs) (revision 578) @@ -290,29 +290,29 @@ /// /// Converts the type of to input soil geometry. /// - /// Type of the soil geometry. + /// Type of the soil geometry. /// - public static SegmentSoilGeometryProbabilitySoilGeometryType ConvertToInputSoilGeometryType(SoilGeometryType soilGeometryType) + public static SegmentSoilGeometryProbabilitySoilGeometryType ConvertToInputSoilGeometryType(SoilProfileType soilProfileType) { - var translationTable = new Dictionary() + var translationTable = new Dictionary() { - {SoilGeometryType.SoilGeometry1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D}, - {SoilGeometryType.SoilGeometry2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D} + {SoilProfileType.ProfileType1D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D}, + {SoilProfileType.ProfileType2D, SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D} }; - return translationTable[soilGeometryType]; + return translationTable[soilProfileType]; } /// /// Converts the type of to soil geometry. /// /// Type of the soil geometry. /// - public static SoilGeometryType ConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType soilGeometryType) + public static SoilProfileType ConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilGeometryType soilGeometryType) { - var translationTable = new Dictionary() + var translationTable = new Dictionary() { - {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilGeometryType.SoilGeometry1D}, - {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilGeometryType.SoilGeometry2D} + {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry1D, SoilProfileType.ProfileType1D}, + {SegmentSoilGeometryProbabilitySoilGeometryType.SoilGeometry2D, SoilProfileType.ProfileType2D} }; return translationTable[soilGeometryType]; } Index: dam engine/trunk/src/Deltares.DamEngine.Data/General/Location.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/General/Location.cs (.../Location.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/General/Location.cs (.../Location.cs) (revision 578) @@ -1374,10 +1374,10 @@ { foreach (var soilGeometryProbability in Segment.SoilProfileProbabilities) { - SoilProfile1D soilProfile = soilGeometryProbability.SoilProfile; + SoilProfile1D soilProfile = soilGeometryProbability.SoilProfile1D; if (soilProfile != null) { - isSurfaceLineAboveSoilProfile = isSurfaceLineAboveSoilProfile || (LocalXZSurfaceLine2.Geometry.GetMaxZ() > soilGeometryProbability.SoilProfile.TopLevel); + isSurfaceLineAboveSoilProfile = isSurfaceLineAboveSoilProfile || (LocalXZSurfaceLine2.Geometry.GetMaxZ() > soilGeometryProbability.SoilProfile1D.TopLevel); } } } @@ -1928,16 +1928,6 @@ return Segment.GetMostProbableGeometry2DName(segmentFailureMechanismType); } - public double? GetSoilProfileProbability(SoilProfile1D soilProfile, FailureMechanismSystemType? segmentFailureMechanismType) - { -// if (Segment == null) -// { -// throw new ArgumentNullException(String.Format(ThrowHelper.GetResourceString(StringResourceNames.LocationHasNoSegment), Name)); -// } - - return Segment.GetSoilProfileProbability(soilProfile, segmentFailureMechanismType); - } - /// /// Gets a sorted list of soil geometry probabilities for a certain failure mechanism type /// @@ -1973,7 +1963,7 @@ List soilGeometryProbabilities = GetGeometryProbabilities(failureMechanismType); SoilGeometryProbability soilGeometryProbability = index < soilGeometryProbabilities.Count ? soilGeometryProbabilities[index] : null; - SoilProfile1D originalProfile = soilGeometryProbability != null ? soilGeometryProbability.SoilProfile : null; + SoilProfile1D originalProfile = soilGeometryProbability != null ? soilGeometryProbability.SoilProfile1D : null; probability = soilGeometryProbability != null ? soilGeometryProbability.Probability : 0; if (soilSurfaceProfile == null || soilSurfaceProfile.SoilProfile != originalProfile || soilSurfaceProfile.SurfaceLine2 != LocalXZSurfaceLine2) Index: dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Operational/TimeSerieStabilityCalculator.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Operational/TimeSerieStabilityCalculator.cs (.../TimeSerieStabilityCalculator.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Calculators/Dikes Operational/TimeSerieStabilityCalculator.cs (.../TimeSerieStabilityCalculator.cs) (revision 578) @@ -149,9 +149,9 @@ TimeSerie serie = TimeSerie.CreateTimeSerie(timeSerieIn, serieName); int timeSerieEntryCounter = 0; - SoilGeometryType soilGeometryType; + SoilProfileType soilProfileType; string soilGeometry2DName; - CalculationHelper.DetermineSoilGeometryType(location, out soilGeometryType, out soilGeometry2DName); + CalculationHelper.DetermineSoilGeometryType(location, out soilProfileType, out soilGeometry2DName); string projectFileNameDikeFlow = CalculationHelper.GetProjectFileName(dike.Name, location, null, null, StabilityWorkingPath, null); TimeSerie safetyFactorTimeSerie = null; @@ -189,7 +189,7 @@ location.GaugeMissVal = timeSerieIn.MissVal; PLLines plLines = null; - plLines = CalculationHelper.CreateAllPLLines(sourceEntry.Value, location, soilGeometry2DName, soilGeometryType); + plLines = CalculationHelper.CreateAllPLLines(sourceEntry.Value, location, soilGeometry2DName, soilProfileType); if (this.IsMStabCalculationOff) { Random random = new Random(); @@ -215,7 +215,7 @@ var damCalculation = new DamFailureMechanismeCalculationSpecification(); CalculationHelper.BuildDamCalculation(failureMechanismType, location, soilGeometry2DName, - soilGeometryType, plLines, mstabParameters, model, + soilProfileType, plLines, mstabParameters, model, damCalculation, soilDatabasePath, projectFileName); // Create the project file Index: dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWScenariosResult.cs =================================================================== diff -u -r452 -r578 --- dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWScenariosResult.cs (.../RWScenariosResult.cs) (revision 452) +++ dam engine/trunk/src/Deltares.DamEngine.Data/RWScenarios/RWScenariosResult.cs (.../RWScenariosResult.cs) (revision 578) @@ -224,7 +224,7 @@ { get { - return soilGeometryProbability.SoilProfile.Name; + return soilGeometryProbability.SoilProfile1D.Name; } }