Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsGridOutput.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsGridOutput.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsGridOutput.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,82 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// The grid result of a macro stability calculation. + /// + public class MacroStabilityInwardsGridOutput + { + /// + /// Creates a new instance of . + /// + /// The left boundary of the grid. + /// The right boundary of the grid. + /// The top boundary of the grid. + /// The bottom boundary of the grid. + /// The number of horizontal points. + /// The number of vertical points. + public MacroStabilityInwardsGridOutput(double xLeft, double xRight, double zTop, double zBottom, int numberOfHorizontalPoints, int numberOfVerticalPoints) + { + XLeft = xLeft; + XRight = xRight; + ZTop = zTop; + ZBottom = zBottom; + NumberOfHorizontalPoints = numberOfHorizontalPoints; + NumberOfVerticalPoints = numberOfVerticalPoints; + } + + /// + /// Gets the left boundary. + /// [m] + /// + public double XLeft { get; } + + /// + /// Gets the right boundary. + /// [m] + /// + public double XRight { get; } + + /// + /// Gets the top boundary. + /// [m+NAP] + /// + public double ZTop { get; } + + /// + /// Gets the bottom boundary. + /// [m+NAP] + /// + public double ZBottom { get; } + + /// + /// Gets the number of horizontal points. + /// + public int NumberOfHorizontalPoints { get; } + + /// + /// Gets the number of vertical points. + /// + public int NumberOfVerticalPoints { get; } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlice.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlice.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlice.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,512 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.Base.Geometry; + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// The slice result of a macro stability calculation. + /// + public class MacroStabilityInwardsSlice + { + /// + /// Creates a new instance of . + /// + /// The top left point of the slice. + /// The top right point of the slice. + /// The bottom left point of the slice. + /// The bottom right point of the slice. + /// The object containing the values for the properties + /// of the new . + /// Thrown when any parameter is null. + public MacroStabilityInwardsSlice(Point2D topLeftPoint, Point2D topRightPoint, + Point2D bottomLeftPoint, Point2D bottomRightPoint, + ConstructionProperties properties) + { + if (topLeftPoint == null) + { + throw new ArgumentNullException(nameof(topLeftPoint)); + } + if (topRightPoint == null) + { + throw new ArgumentNullException(nameof(topRightPoint)); + } + if (bottomLeftPoint == null) + { + throw new ArgumentNullException(nameof(bottomLeftPoint)); + } + if (bottomRightPoint == null) + { + throw new ArgumentNullException(nameof(bottomRightPoint)); + } + if (properties == null) + { + throw new ArgumentNullException(nameof(properties)); + } + + TopLeftPoint = topLeftPoint; + TopRightPoint = topRightPoint; + BottomLeftPoint = bottomLeftPoint; + BottomRightPoint = bottomRightPoint; + + Cohesion = properties.Cohesion; + FrictionAngle = properties.FrictionAngle; + CriticalPressure = properties.CriticalPressure; + OverConsolidationRatio = properties.OverConsolidationRatio; + Pop = properties.Pop; + DegreeOfConsolidationPorePressureSoil = properties.DegreeOfConsolidationPorePressureSoil; + DegreeOfConsolidationPorePressureLoad = properties.DegreeOfConsolidationPorePressureLoad; + Dilatancy = properties.Dilatancy; + ExternalLoad = properties.ExternalLoad; + HydrostaticPorePressure = properties.HydrostaticPorePressure; + LeftForce = properties.LeftForce; + LeftForceAngle = properties.LeftForceAngle; + LeftForceY = properties.LeftForceY; + RightForce = properties.RightForce; + RightForceAngle = properties.RightForceAngle; + RightForceY = properties.RightForceY; + LoadStress = properties.LoadStress; + NormalStress = properties.NormalStress; + PorePressure = properties.PorePressure; + HorizontalPorePressure = properties.HorizontalPorePressure; + VerticalPorePressure = properties.VerticalPorePressure; + PiezometricPorePressure = properties.PiezometricPorePressure; + EffectiveStress = properties.EffectiveStress; + EffectiveStressDaily = properties.EffectiveStressDaily; + ExcessPorePressure = properties.ExcessPorePressure; + ShearStress = properties.ShearStress; + SoilStress = properties.SoilStress; + TotalPorePressure = properties.TotalPorePressure; + TotalStress = properties.TotalStress; + Weight = properties.Weight; + } + + /// + /// Gets the top left point. + /// + public Point2D TopLeftPoint { get; } + + /// + /// Gets the top right point. + /// + public Point2D TopRightPoint { get; } + + /// + /// Gets the bottom left point. + /// + public Point2D BottomLeftPoint { get; } + + /// + /// Gets the bottom right point. + /// + public Point2D BottomRightPoint { get; } + + /// + /// Gets the cohesion. + /// [kN/m²] + /// + public double Cohesion { get; } + + /// + /// Gets the friction angle. + /// [°] + /// + public double FrictionAngle { get; } + + /// + /// Gets the critical pressure. + /// + public double CriticalPressure { get; } + + /// + /// Gets the OCR. + /// [-] + /// + public double OverConsolidationRatio { get; } + + /// + /// Gets the POP. + /// [kN/m²] + /// + public double Pop { get; } + + /// + /// Gets the pore pressure from degree of consolidation soil. + /// [kN/m²] + /// + public double DegreeOfConsolidationPorePressureSoil { get; } + + /// + /// Gets the pore pressure from degree of consolidation load. + /// [kN/m²] + /// + public double DegreeOfConsolidationPorePressureLoad { get; } + + /// + /// Gets the dilatancy of the slice. + /// + public double Dilatancy { get; } + + /// + /// Gets the external load. + /// [kN/m²] + /// + public double ExternalLoad { get; } + + /// + /// Gets the hydraostatic pore pressure. + /// [kN/m²] + /// + public double HydrostaticPorePressure { get; } + + /// + /// Gets the left force. + /// + public double LeftForce { get; } + + /// + /// Gets the left force angle. + /// [°] + /// + public double LeftForceAngle { get; } + + /// + /// Gets the left force y. + /// + public double LeftForceY { get; } + + /// + /// Gets the right force. + /// + public double RightForce { get; } + + /// + /// Gets the right force angle. + /// [°] + /// + public double RightForceAngle { get; } + + /// + /// Gets the right force y. + /// + public double RightForceY { get; } + + /// + /// Gets the load stress. + /// [kN/m²] + /// + public double LoadStress { get; } + + /// + /// Gets the normal stress. + /// [kN/m²] + /// + public double NormalStress { get; } + + /// + /// Gets the pore pressure. + /// [kN/m²] + /// + public double PorePressure { get; } + + /// + /// Gets the horizontal pore pressure. + /// [kN/m²] + /// + public double HorizontalPorePressure { get; } + + /// + /// Gets the vertical pore pressure. + /// [kN/m²] + /// + public double VerticalPorePressure { get; } + + /// + /// Gets the piezometric pore pressure. + /// [kN/m²] + /// + public double PiezometricPorePressure { get; } + + /// + /// Gets the effective stress. + /// [kN/m²] + /// + public double EffectiveStress { get; } + + /// + /// Gets the daily effective stress. + /// [kN/m²] + /// + public double EffectiveStressDaily { get; } + + /// + /// Gets the excess pore pressure. + /// [kN/m²] + /// + public double ExcessPorePressure { get; } + + /// + /// Gets the shear stress. + /// [kN/m²] + /// + public double ShearStress { get; } + + /// + /// Gets the soil stress. + /// [kN/m²] + /// + public double SoilStress { get; } + + /// + /// Gets the total pore pressure. + /// [kN/m²] + /// + public double TotalPorePressure { get; } + + /// + /// Gets the total stress. + /// [kN/m²] + /// + public double TotalStress { get; } + + /// + /// Gets the weight. + /// [kN/m] + /// + public double Weight { get; } + + public class ConstructionProperties + { + /// + /// Creates a new instance of . + /// + public ConstructionProperties() + { + Cohesion = double.NaN; + FrictionAngle = double.NaN; + CriticalPressure = double.NaN; + OverConsolidationRatio = double.NaN; + Pop = double.NaN; + DegreeOfConsolidationPorePressureSoil = double.NaN; + DegreeOfConsolidationPorePressureLoad = double.NaN; + Dilatancy = double.NaN; + ExternalLoad = double.NaN; + HydrostaticPorePressure = double.NaN; + LeftForce = double.NaN; + LeftForceAngle = double.NaN; + LeftForceY = double.NaN; + RightForce = double.NaN; + RightForceAngle = double.NaN; + RightForceY = double.NaN; + LoadStress = double.NaN; + NormalStress = double.NaN; + PorePressure = double.NaN; + HorizontalPorePressure = double.NaN; + VerticalPorePressure = double.NaN; + PiezometricPorePressure = double.NaN; + EffectiveStress = double.NaN; + EffectiveStressDaily = double.NaN; + ExcessPorePressure = double.NaN; + ShearStress = double.NaN; + SoilStress = double.NaN; + TotalPorePressure = double.NaN; + TotalStress = double.NaN; + Weight = double.NaN; + } + + /// + /// Gets or sets the cohesion. + /// [kN/m²] + /// + public double Cohesion { internal get; set; } + + /// + /// Gets or sets the friction angle. + /// [°] + /// + public double FrictionAngle { internal get; set; } + + /// + /// Gets or sets the critical pressure. + /// + public double CriticalPressure { internal get; set; } + + /// + /// Gets or sets the OCR. + /// [-] + /// + public double OverConsolidationRatio { internal get; set; } + + /// + /// Gets or sets the POP. + /// [kN/m²] + /// + public double Pop { internal get; set; } + + /// + /// Gets or sets the pore pressure from degree of consolidation soil. + /// [kN/m²] + /// + public double DegreeOfConsolidationPorePressureSoil { internal get; set; } + + /// + /// Gets or sets the pore pressure from degree of consolidation load. + /// [kN/m²] + /// + public double DegreeOfConsolidationPorePressureLoad { internal get; set; } + + /// + /// Gets or sets the dilatancy of the slice. + /// + public double Dilatancy { internal get; set; } + + /// + /// Gets or sets the external load. + /// [kN/m²] + /// + public double ExternalLoad { internal get; set; } + + /// + /// Gets or sets the hydraostatic pore pressure. + /// [kN/m²] + /// + public double HydrostaticPorePressure { internal get; set; } + + /// + /// Gets or sets the left force. + /// + public double LeftForce { internal get; set; } + + /// + /// Gets or sets the left force angle. + /// [°] + /// + public double LeftForceAngle { internal get; set; } + + /// + /// Gets or sets the left force y. + /// + public double LeftForceY { internal get; set; } + + /// + /// Gets or sets the right force. + /// + public double RightForce { internal get; set; } + + /// + /// Gets or sets the right force angle. + /// [°] + /// + public double RightForceAngle { internal get; set; } + + /// + /// Gets or sets the right force y. + /// + public double RightForceY { internal get; set; } + + /// + /// Gets or sets the load stress. + /// [kN/m²] + /// + public double LoadStress { internal get; set; } + + /// + /// Gets or sets the normal stress. + /// [kN/m²] + /// + public double NormalStress { internal get; set; } + + /// + /// Gets or sets the pore pressure. + /// [kN/m²] + /// + public double PorePressure { internal get; set; } + + /// + /// Gets or sets the horizontal pore pressure. + /// [kN/m²] + /// + public double HorizontalPorePressure { internal get; set; } + + /// + /// Gets or sets the vertical pore pressure. + /// [kN/m²] + /// + public double VerticalPorePressure { internal get; set; } + + /// + /// Gets or sets the piezometric pore pressure. + /// [kN/m²] + /// + public double PiezometricPorePressure { internal get; set; } + + /// + /// Gets or sets the effective stress. + /// [kN/m²] + /// + public double EffectiveStress { internal get; set; } + + /// + /// Gets or sets the daily effective stress. + /// [kN/m²] + /// + public double EffectiveStressDaily { internal get; set; } + + /// + /// Gets or sets the excess pore pressure. + /// [kN/m²] + /// + public double ExcessPorePressure { internal get; set; } + + /// + /// Gets or sets the shear stress. + /// [kN/m²] + /// + public double ShearStress { internal get; set; } + + /// + /// Gets or sets the soil stress. + /// [kN/m²] + /// + public double SoilStress { internal get; set; } + + /// + /// Gets or sets the total pore pressure. + /// [kN/m²] + /// + public double TotalPorePressure { internal get; set; } + + /// + /// Gets or sets the total stress. + /// [kN/m²] + /// + public double TotalStress { internal get; set; } + + /// + /// Gets or sets the weight. + /// [kN/m] + /// + public double Weight { internal get; set; } + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCircle.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCircle.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCircle.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,96 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.Base.Geometry; + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// The sliding circle result of a macro stability calculation. + /// + public class MacroStabilityInwardsSlidingCircle + { + /// + /// Creates a new instance of . + /// + /// The center coordinate of the circle. + /// The radius of the circle. + /// Indicator whether the circle is active or not. + /// The non iterated force of the circle. + /// The iterated force of the circle. + /// The driving moment of the circle. + /// The resisting moment of the circle. + /// Thrown when + /// is null. + public MacroStabilityInwardsSlidingCircle(Point2D center, double radius, bool isActive, + double nonIteratedForce, double iteratedForce, + double drivingMoment, double resistingMoment) + { + if (center == null) + { + throw new ArgumentNullException(nameof(center)); + } + Center = center; + Radius = radius; + IsActive = isActive; + NonIteratedForce = nonIteratedForce; + IteratedForce = iteratedForce; + DrivingMoment = drivingMoment; + ResistingMoment = resistingMoment; + } + + /// + /// Gets the center coordinate of the circle. + /// + public Point2D Center { get; } + + /// + /// Gets the radius of the circle. + /// + public double Radius { get; } + + /// + /// Gets whether the circle is the active circle or not. + /// + public bool IsActive { get; } + + /// + /// Gets the non iterated force of the circle. + /// + public double NonIteratedForce { get; } + + /// + /// Gets the iterated force of the circle. + /// + public double IteratedForce { get; } + + /// + /// Gets the driving moment of the circle. + /// + public double DrivingMoment { get; } + + /// + /// Gets the resisting moment of the circle. + /// + public double ResistingMoment { get; } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCurve.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCurve.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlidingCurve.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,92 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// The sliding curve result of a macro stability calculation. + /// + public class MacroStabilityInwardsSlidingCurve + { + /// + /// Creates a new instance of . + /// + /// The left circle of the curve. + /// The right circle of the curve. + /// The slices of the curve. + /// The non iterated horizontal + /// force of the curve. + /// The iterated horizontal force + /// of the curve. + /// Thrown when any parameter + /// is null. + public MacroStabilityInwardsSlidingCurve(MacroStabilityInwardsSlidingCircle leftCircle, MacroStabilityInwardsSlidingCircle rightCircle, + IEnumerable slices, double nonIteratedHorizontalForce, double iteratedHorizontalForce) + { + if (leftCircle == null) + { + throw new ArgumentNullException(nameof(leftCircle)); + } + if (rightCircle == null) + { + throw new ArgumentNullException(nameof(rightCircle)); + } + if (slices == null) + { + throw new ArgumentNullException(nameof(slices)); + } + + LeftCircle = leftCircle; + RightCircle = rightCircle; + Slices = slices; + NonIteratedHorizontalForce = nonIteratedHorizontalForce; + IteratedHorizontalForce = iteratedHorizontalForce; + } + + /// + /// Gets the left circle. + /// + public MacroStabilityInwardsSlidingCircle LeftCircle { get; } + + /// + /// Gets the right circle. + /// + public MacroStabilityInwardsSlidingCircle RightCircle { get; } + + /// + /// Gets the slices. + /// + public IEnumerable Slices { get; } + + /// + /// Gets the non iterated horizontal force. + /// + public double NonIteratedHorizontalForce { get; } + + /// + /// Gets the iterated horizontal force. + /// + public double IteratedHorizontalForce { get; } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlipPlaneUpliftVan.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlipPlaneUpliftVan.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/MacroStabilityInwardsSlipPlaneUpliftVan.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,76 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; + +namespace Ringtoets.MacroStabilityInwards.Data +{ + /// + /// The upliftVan calculation grid result of a macro stability calculation. + /// + public class MacroStabilityInwardsSlipPlaneUpliftVan + { + /// + /// Creates a new instance of . + /// + /// The left grid of the result. + /// The right grid of the result. + /// The tangent lines of the result. + /// Thrown when any parameter is null. + public MacroStabilityInwardsSlipPlaneUpliftVan(MacroStabilityInwardsGridOutput leftGrid, + MacroStabilityInwardsGridOutput rightGrid, + IEnumerable tangentLines) + { + if (leftGrid == null) + { + throw new ArgumentNullException(nameof(leftGrid)); + } + if (rightGrid == null) + { + throw new ArgumentNullException(nameof(rightGrid)); + } + if (tangentLines == null) + { + throw new ArgumentNullException(nameof(tangentLines)); + } + + LeftGrid = leftGrid; + RightGrid = rightGrid; + TangentLines = tangentLines; + } + + /// + /// Gets the left grid result. + /// + public MacroStabilityInwardsGridOutput LeftGrid { get; } + + /// + /// Gets the right grid result. + /// + public MacroStabilityInwardsGridOutput RightGrid { get; } + + /// + /// Gets the tangent lines result. + /// + public IEnumerable TangentLines { get; } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj =================================================================== diff -u -r4e00271fd762917c0ce059fe0697e607ed0065fb -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj (.../Ringtoets.MacroStabilityInwards.Data.csproj) (revision 4e00271fd762917c0ce059fe0697e607ed0065fb) +++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Data/Ringtoets.MacroStabilityInwards.Data.csproj (.../Ringtoets.MacroStabilityInwards.Data.csproj) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -39,6 +39,7 @@ Properties\GlobalAssembly.cs + @@ -50,6 +51,10 @@ + + + + Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsGridOutputTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsGridOutputTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsGridOutputTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,54 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsGridOutputTest + { + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var random = new Random(21); + double xLeft = random.Next(); + double xRight = random.Next(); + double zTop = random.Next(); + double zBottom = random.Next(); + int nrOfHorizontalPoints = random.Next(); + int nrOfVerticalPoints = random.Next(); + + // Call + var grid = new MacroStabilityInwardsGridOutput(xLeft, xRight, zTop, zBottom, nrOfHorizontalPoints, nrOfVerticalPoints); + + // Assert + Assert.AreEqual(xLeft, grid.XLeft); + Assert.AreEqual(xRight, grid.XRight); + Assert.AreEqual(zTop, grid.ZTop); + Assert.AreEqual(zBottom, grid.ZBottom); + Assert.AreEqual(nrOfHorizontalPoints, grid.NumberOfHorizontalPoints); + Assert.AreEqual(nrOfVerticalPoints, grid.NumberOfVerticalPoints); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSliceTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSliceTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSliceTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,258 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.Base.Geometry; +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsSliceTest + { + [Test] + public void Constructor_TopLeftPointNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlice(null, new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("topLeftPoint", exception.ParamName); + } + + [Test] + public void Constructor_TopRightPointNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlice(new Point2D(0, 0), null, new Point2D(0, 0), new Point2D(0, 0), + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("topRightPoint", exception.ParamName); + } + + [Test] + public void Constructor_BottomLeftPointNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), null, new Point2D(0, 0), + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("bottomLeftPoint", exception.ParamName); + } + + [Test] + public void Constructor_BottomRightPointNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), null, + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("bottomRightPoint", exception.ParamName); + } + + [Test] + public void Constructor_ConstructionPropertiesNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("properties", exception.ParamName); + } + + [Test] + public void Constructor_WithCoordinates_ExpectedValues() + { + // Setup + var topLeftPoint = new Point2D(0, 0); + var topRightPoint = new Point2D(1, 1); + var bottomLeftPoint = new Point2D(2, 2); + var bottomRightPoint = new Point2D(3, 3); + + // Call + var slice = new MacroStabilityInwardsSlice(topLeftPoint, topRightPoint, bottomLeftPoint, bottomRightPoint, + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + Assert.AreEqual(topLeftPoint, slice.TopLeftPoint); + Assert.AreEqual(topRightPoint, slice.TopRightPoint); + Assert.AreEqual(bottomLeftPoint, slice.BottomLeftPoint); + Assert.AreEqual(bottomRightPoint, slice.BottomRightPoint); + } + + [Test] + public void Constructor_ConstructionPropertiesEmpty_ExpectedValues() + { + // Call + var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), + new MacroStabilityInwardsSlice.ConstructionProperties()); + + // Assert + Assert.IsNaN(slice.Cohesion); + Assert.IsNaN(slice.FrictionAngle); + Assert.IsNaN(slice.CriticalPressure); + Assert.IsNaN(slice.OverConsolidationRatio); + Assert.IsNaN(slice.Pop); + Assert.IsNaN(slice.DegreeOfConsolidationPorePressureSoil); + Assert.IsNaN(slice.DegreeOfConsolidationPorePressureLoad); + Assert.IsNaN(slice.Dilatancy); + Assert.IsNaN(slice.ExternalLoad); + Assert.IsNaN(slice.HydrostaticPorePressure); + Assert.IsNaN(slice.LeftForce); + Assert.IsNaN(slice.LeftForceAngle); + Assert.IsNaN(slice.LeftForceY); + Assert.IsNaN(slice.RightForce); + Assert.IsNaN(slice.RightForceAngle); + Assert.IsNaN(slice.RightForceY); + Assert.IsNaN(slice.LoadStress); + Assert.IsNaN(slice.NormalStress); + Assert.IsNaN(slice.PorePressure); + Assert.IsNaN(slice.HorizontalPorePressure); + Assert.IsNaN(slice.VerticalPorePressure); + Assert.IsNaN(slice.PiezometricPorePressure); + Assert.IsNaN(slice.EffectiveStress); + Assert.IsNaN(slice.EffectiveStressDaily); + Assert.IsNaN(slice.ExcessPorePressure); + Assert.IsNaN(slice.ShearStress); + Assert.IsNaN(slice.SoilStress); + Assert.IsNaN(slice.TotalPorePressure); + Assert.IsNaN(slice.TotalStress); + Assert.IsNaN(slice.Weight); + } + + [Test] + public void Constructor_ConstructionPropertiesSet_ExpectedValues() + { + // Setup + var random = new Random(21); + double cohesion = random.NextDouble(); + double frictionAngle = random.NextDouble(); + double criticalPressure = random.NextDouble(); + double overConsolidationRatio = random.NextDouble(); + double pop = random.NextDouble(); + double degreeOfConsolidationPorePressureSoil = random.NextDouble(); + double degreeOfConsolidationPorePressureLoad = random.NextDouble(); + double dilatancy = random.NextDouble(); + double externalLoad = random.NextDouble(); + double hydrostaticPorePressure = random.NextDouble(); + double leftForce = random.NextDouble(); + double leftForceAngle = random.NextDouble(); + double leftForceY = random.NextDouble(); + double rightForce = random.NextDouble(); + double rightForceAngle = random.NextDouble(); + double rightForceY = random.NextDouble(); + double loadStress = random.NextDouble(); + double normalStress = random.NextDouble(); + double porePressure = random.NextDouble(); + double horizontalPorePressure = random.NextDouble(); + double verticalPorePressure = random.NextDouble(); + double piezometricPorePressure = random.NextDouble(); + double effectiveStress = random.NextDouble(); + double effectiveStressDaily = random.NextDouble(); + double excessPorePressure = random.NextDouble(); + double shearStress = random.NextDouble(); + double soilStress = random.NextDouble(); + double totalPorePressure = random.NextDouble(); + double totalStress = random.NextDouble(); + double weight = random.NextDouble(); + + var properties = new MacroStabilityInwardsSlice.ConstructionProperties + { + Cohesion = cohesion, + FrictionAngle = frictionAngle, + CriticalPressure = criticalPressure, + OverConsolidationRatio = overConsolidationRatio, + DegreeOfConsolidationPorePressureSoil = degreeOfConsolidationPorePressureSoil, + DegreeOfConsolidationPorePressureLoad = degreeOfConsolidationPorePressureLoad, + Pop = pop, + Dilatancy = dilatancy, + ExternalLoad = externalLoad, + HydrostaticPorePressure = hydrostaticPorePressure, + LeftForce = leftForce, + LeftForceAngle = leftForceAngle, + LeftForceY = leftForceY, + RightForce = rightForce, + RightForceAngle = rightForceAngle, + RightForceY = rightForceY, + LoadStress = loadStress, + NormalStress = normalStress, + PorePressure = porePressure, + HorizontalPorePressure = horizontalPorePressure, + VerticalPorePressure = verticalPorePressure, + PiezometricPorePressure = piezometricPorePressure, + EffectiveStress = effectiveStress, + EffectiveStressDaily = effectiveStressDaily, + ExcessPorePressure = excessPorePressure, + ShearStress = shearStress, + SoilStress = soilStress, + TotalPorePressure = totalPorePressure, + TotalStress = totalStress, + Weight = weight + }; + + // Call + var slice = new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), + new Point2D(0, 0), new Point2D(0, 0), + properties); + + // Assert + Assert.AreEqual(cohesion, slice.Cohesion); + Assert.AreEqual(frictionAngle, slice.FrictionAngle); + Assert.AreEqual(criticalPressure, slice.CriticalPressure); + Assert.AreEqual(overConsolidationRatio, slice.OverConsolidationRatio); + Assert.AreEqual(pop, slice.Pop); + Assert.AreEqual(degreeOfConsolidationPorePressureSoil, slice.DegreeOfConsolidationPorePressureSoil); + Assert.AreEqual(degreeOfConsolidationPorePressureLoad, slice.DegreeOfConsolidationPorePressureLoad); + Assert.AreEqual(dilatancy, slice.Dilatancy); + Assert.AreEqual(externalLoad, slice.ExternalLoad); + Assert.AreEqual(hydrostaticPorePressure, slice.HydrostaticPorePressure); + Assert.AreEqual(leftForce, slice.LeftForce); + Assert.AreEqual(leftForceAngle, slice.LeftForceAngle); + Assert.AreEqual(leftForceY, slice.LeftForceY); + Assert.AreEqual(rightForce, slice.RightForce); + Assert.AreEqual(rightForceAngle, slice.RightForceAngle); + Assert.AreEqual(rightForceY, slice.RightForceY); + Assert.AreEqual(loadStress, slice.LoadStress); + Assert.AreEqual(normalStress, slice.NormalStress); + Assert.AreEqual(porePressure, slice.PorePressure); + Assert.AreEqual(horizontalPorePressure, slice.HorizontalPorePressure); + Assert.AreEqual(verticalPorePressure, slice.VerticalPorePressure); + Assert.AreEqual(piezometricPorePressure, slice.PiezometricPorePressure); + Assert.AreEqual(effectiveStress, slice.EffectiveStress); + Assert.AreEqual(effectiveStressDaily, slice.EffectiveStressDaily); + Assert.AreEqual(excessPorePressure, slice.ExcessPorePressure); + Assert.AreEqual(shearStress, slice.ShearStress); + Assert.AreEqual(soilStress, slice.SoilStress); + Assert.AreEqual(totalPorePressure, slice.TotalPorePressure); + Assert.AreEqual(totalStress, slice.TotalStress); + Assert.AreEqual(weight, slice.Weight); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCircleTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCircleTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCircleTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,69 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.Base.Geometry; +using Core.Common.TestUtil; +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsSlidingCircleTest + { + [Test] + public void Constructor_CenterNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new MacroStabilityInwardsSlidingCircle(null, 0.1, true, 0.2, 0.3, 0.4, 0.5); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("center", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var random = new Random(11); + var center = new Point2D(random.NextDouble(), random.NextDouble()); + double radius = random.NextDouble(); + bool isActive = random.NextBoolean(); + double nonIteratedForce = random.NextDouble(); + double iteratedForce = random.NextDouble(); + double drivingMoment = random.NextDouble(); + double resistingMoment = random.NextDouble(); + + // Call + var circle = new MacroStabilityInwardsSlidingCircle(center, radius, isActive, nonIteratedForce, iteratedForce, drivingMoment, resistingMoment); + + // Assert + Assert.AreEqual(center, circle.Center); + Assert.AreEqual(radius, circle.Radius); + Assert.AreEqual(isActive, circle.IsActive); + Assert.AreEqual(nonIteratedForce, circle.NonIteratedForce); + Assert.AreEqual(iteratedForce, circle.IteratedForce); + Assert.AreEqual(drivingMoment, circle.DrivingMoment); + Assert.AreEqual(resistingMoment, circle.ResistingMoment); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCurveTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCurveTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlidingCurveTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,102 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Linq; +using Core.Common.Base.Geometry; +using NUnit.Framework; +using Ringtoets.MacroStabilityInwards.Data.TestUtil; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsSlidingCurveTest + { + [Test] + public void Constructor_LeftCircleNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsSlidingCircle rightCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlidingCurve(null, rightCircle, Enumerable.Empty(), 0, 0); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("leftCircle", exception.ParamName); + } + + [Test] + public void Constructor_RightCircleNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsSlidingCircle leftCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlidingCurve(leftCircle, null, Enumerable.Empty(), 0, 0); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("rightCircle", exception.ParamName); + } + + [Test] + public void Constructor_SlicesNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsSlidingCircle circle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlidingCurve(circle, circle, null, 0, 0); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("slices", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var random = new Random(21); + MacroStabilityInwardsSlidingCircle rightCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + MacroStabilityInwardsSlidingCircle leftCircle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + var slices = new[] + { + new MacroStabilityInwardsSlice(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), + new MacroStabilityInwardsSlice.ConstructionProperties()) + }; + + double nonIteratedHorizontalForce = random.NextDouble(); + double iteratedHorizontalForce = random.NextDouble(); + + // Call + var curve = new MacroStabilityInwardsSlidingCurve(leftCircle, rightCircle, slices, nonIteratedHorizontalForce, iteratedHorizontalForce); + + // Assert + Assert.AreSame(leftCircle, curve.LeftCircle); + Assert.AreSame(rightCircle, curve.RightCircle); + Assert.AreEqual(nonIteratedHorizontalForce, curve.NonIteratedHorizontalForce); + Assert.AreEqual(iteratedHorizontalForce, curve.IteratedHorizontalForce); + CollectionAssert.AreEqual(slices, curve.Slices); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlipPlaneUpliftVanTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlipPlaneUpliftVanTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSlipPlaneUpliftVanTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,98 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Linq; +using NUnit.Framework; +using Ringtoets.MacroStabilityInwards.Data.TestUtil; + +namespace Ringtoets.MacroStabilityInwards.Data.Test +{ + [TestFixture] + public class MacroStabilityInwardsSlipPlaneUpliftVanTest + { + [Test] + public void Constructor_LeftGridNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsGridOutput grid = MacroStabilityInwardsGridOutputTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlipPlaneUpliftVan(null, grid, Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("leftGrid", exception.ParamName); + } + + [Test] + public void Constructor_RightGridNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsGridOutput grid = MacroStabilityInwardsGridOutputTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlipPlaneUpliftVan(grid, null, Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("rightGrid", exception.ParamName); + } + + [Test] + public void Constructor_TangentLinesNull_ThrowsArgumentNullException() + { + // Setup + MacroStabilityInwardsGridOutput leftGrid = MacroStabilityInwardsGridOutputTestFactory.Create(); + MacroStabilityInwardsGridOutput rightGrid = MacroStabilityInwardsGridOutputTestFactory.Create(); + + // Call + TestDelegate call = () => new MacroStabilityInwardsSlipPlaneUpliftVan(leftGrid, rightGrid, null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("tangentLines", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + MacroStabilityInwardsGridOutput leftGrid = MacroStabilityInwardsGridOutputTestFactory.Create(); + MacroStabilityInwardsGridOutput rightGrid = MacroStabilityInwardsGridOutputTestFactory.Create(); + var tangentLines = new[] + { + 0, + 1, + 1.5, + 2 + }; + + // Call + var result = new MacroStabilityInwardsSlipPlaneUpliftVan(leftGrid, rightGrid, tangentLines); + + // Assert + Assert.AreSame(leftGrid, result.LeftGrid); + Assert.AreSame(rightGrid, result.RightGrid); + CollectionAssert.AreEqual(tangentLines, result.TangentLines); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.Test.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.Test.csproj) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -61,7 +61,12 @@ + + + + + Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsGridOutputTestFactoryTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsGridOutputTestFactoryTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsGridOutputTestFactoryTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,44 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.Data.TestUtil.Test +{ + [TestFixture] + public class MacroStabilityInwardsGridOutputTestFactoryTest + { + [Test] + public void Create_Always_ReturnGridWithDefaultValues() + { + // Call + MacroStabilityInwardsGridOutput grid = MacroStabilityInwardsGridOutputTestFactory.Create(); + + // Assert + Assert.AreEqual(0.1, grid.XLeft); + Assert.AreEqual(0.2, grid.XRight); + Assert.AreEqual(0.3, grid.ZTop); + Assert.AreEqual(0.4, grid.ZBottom); + Assert.AreEqual(1, grid.NumberOfHorizontalPoints); + Assert.AreEqual(2, grid.NumberOfVerticalPoints); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsSlidingCircleTestFactoryTest.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsSlidingCircleTestFactoryTest.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/MacroStabilityInwardsSlidingCircleTestFactoryTest.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,46 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using Core.Common.Base.Geometry; +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.Data.TestUtil.Test +{ + [TestFixture] + public class MacroStabilityInwardsSlidingCircleTestFactoryTest + { + [Test] + public void Create_Always_ReturnCircleWithDefaultValues() + { + // Call + MacroStabilityInwardsSlidingCircle circle = MacroStabilityInwardsSlidingCircleTestFactory.Create(); + + // Assert + Assert.AreEqual(new Point2D(0, 0), circle.Center); + Assert.AreEqual(0.1, circle.Radius); + Assert.IsTrue(circle.IsActive); + Assert.AreEqual(0.2, circle.NonIteratedForce); + Assert.AreEqual(0.3, circle.IteratedForce); + Assert.AreEqual(0.4, circle.DrivingMoment); + Assert.AreEqual(0.5, circle.ResistingMoment); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.TestUtil.Test.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test/Ringtoets.MacroStabilityInwards.Data.TestUtil.Test.csproj (.../Ringtoets.MacroStabilityInwards.Data.TestUtil.Test.csproj) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -50,7 +50,9 @@ Properties\GlobalAssembly.cs + + Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsGridOutputTestFactory.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsGridOutputTestFactory.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsGridOutputTestFactory.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,39 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +namespace Ringtoets.MacroStabilityInwards.Data.TestUtil +{ + /// + /// Factory to create simple + /// instances that can be used for testing. + /// + public class MacroStabilityInwardsGridOutputTestFactory + { + /// + /// Creates a new . + /// + /// The created . + public static MacroStabilityInwardsGridOutput Create() + { + return new MacroStabilityInwardsGridOutput(0.1, 0.2, 0.3, 0.4, 1, 2); + } + } +} Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsSlidingCircleTestFactory.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsSlidingCircleTestFactory.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/MacroStabilityInwardsSlidingCircleTestFactory.cs (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -0,0 +1,41 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using Core.Common.Base.Geometry; + +namespace Ringtoets.MacroStabilityInwards.Data.TestUtil +{ + /// + /// Factory to create simple + /// instances that can be used for testing. + /// + public static class MacroStabilityInwardsSlidingCircleTestFactory + { + /// + /// Creates a new . + /// + /// The created . + public static MacroStabilityInwardsSlidingCircle Create() + { + return new MacroStabilityInwardsSlidingCircle(new Point2D(0, 0), 0.1, true, 0.2, 0.3, 0.4, 0.5); + } + } +} \ No newline at end of file Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj =================================================================== diff -u -ra1fa1538918813373bcc864f0bce092bf28fd0ce -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj (.../Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj) (revision a1fa1538918813373bcc864f0bce092bf28fd0ce) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.TestUtil/Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj (.../Ringtoets.MacroStabilityInwards.Data.TestUtil.csproj) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -50,8 +50,10 @@ Properties\GlobalAssembly.cs + + Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Result/MacroStabilityInwardsSlidingCurveResultTest.cs =================================================================== diff -u -r2c63c29d4e7a6ea52e12ab8ae673c5681a3fb2fc -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Result/MacroStabilityInwardsSlidingCurveResultTest.cs (.../MacroStabilityInwardsSlidingCurveResultTest.cs) (revision 2c63c29d4e7a6ea52e12ab8ae673c5681a3fb2fc) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Result/MacroStabilityInwardsSlidingCurveResultTest.cs (.../MacroStabilityInwardsSlidingCurveResultTest.cs) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -35,7 +35,7 @@ public void Constructor_LeftCircleNull_ThrowsArgumentNullException() { // Setup - MacroStabilityInwardsSlidingCircleResult rightCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); + MacroStabilityInwardsSlidingCircleResult rightCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); // Call TestDelegate call = () => new MacroStabilityInwardsSlidingCurveResult(null, rightCircle, Enumerable.Empty(), 0, 0); @@ -49,7 +49,7 @@ public void Constructor_RightCircleNull_ThrowsArgumentNullException() { // Setup - MacroStabilityInwardsSlidingCircleResult leftCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); + MacroStabilityInwardsSlidingCircleResult leftCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); // Call TestDelegate call = () => new MacroStabilityInwardsSlidingCurveResult(leftCircle, null, Enumerable.Empty(), 0, 0); @@ -63,7 +63,7 @@ public void Constructor_SlicesNull_ThrowsArgumentNullException() { // Setup - MacroStabilityInwardsSlidingCircleResult circle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); + MacroStabilityInwardsSlidingCircleResult circle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); // Call TestDelegate call = () => new MacroStabilityInwardsSlidingCurveResult(circle, circle, null, 0, 0); @@ -78,8 +78,8 @@ { // Setup var random = new Random(21); - MacroStabilityInwardsSlidingCircleResult rightCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); - MacroStabilityInwardsSlidingCircleResult leftCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); + MacroStabilityInwardsSlidingCircleResult rightCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); + MacroStabilityInwardsSlidingCircleResult leftCircle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); var slices = new[] { new MacroStabilityInwardsSliceResult(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Test/Result/MacroStabilityInwardsSlidingCircleResultTestFactoryTest.cs =================================================================== diff -u -rf79fd1627089fd5c8887fd7c19ca5e75df6db29d -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Test/Result/MacroStabilityInwardsSlidingCircleResultTestFactoryTest.cs (.../MacroStabilityInwardsSlidingCircleResultTestFactoryTest.cs) (revision f79fd1627089fd5c8887fd7c19ca5e75df6db29d) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Test/Result/MacroStabilityInwardsSlidingCircleResultTestFactoryTest.cs (.../MacroStabilityInwardsSlidingCircleResultTestFactoryTest.cs) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -33,7 +33,7 @@ public void Create_Always_ReturnCircleWithDefaultValues() { // Call - MacroStabilityInwardsSlidingCircleResult circle = MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(); + MacroStabilityInwardsSlidingCircleResult circle = MacroStabilityInwardsSlidingCircleResultTestFactory.Create(); // Assert Assert.AreEqual(new Point2D(0, 0), circle.Center); Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCircleResultTestFactory.cs =================================================================== diff -u -rf79fd1627089fd5c8887fd7c19ca5e75df6db29d -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCircleResultTestFactory.cs (.../MacroStabilityInwardsSlidingCircleResultTestFactory.cs) (revision f79fd1627089fd5c8887fd7c19ca5e75df6db29d) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCircleResultTestFactory.cs (.../MacroStabilityInwardsSlidingCircleResultTestFactory.cs) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -34,7 +34,7 @@ /// Creates a new . /// /// The created . - public static MacroStabilityInwardsSlidingCircleResult CreateCircle() + public static MacroStabilityInwardsSlidingCircleResult Create() { return new MacroStabilityInwardsSlidingCircleResult(new Point2D(0, 0), 0.1, true, 0.2, 0.3, 0.4, 0.5); } Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCurveResultTestFactory.cs =================================================================== diff -u -r2c63c29d4e7a6ea52e12ab8ae673c5681a3fb2fc -r2c8c5eec330543aab5ece02da4159ce53cfde11b --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCurveResultTestFactory.cs (.../MacroStabilityInwardsSlidingCurveResultTestFactory.cs) (revision 2c63c29d4e7a6ea52e12ab8ae673c5681a3fb2fc) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Result/MacroStabilityInwardsSlidingCurveResultTestFactory.cs (.../MacroStabilityInwardsSlidingCurveResultTestFactory.cs) (revision 2c8c5eec330543aab5ece02da4159ce53cfde11b) @@ -37,8 +37,8 @@ public static MacroStabilityInwardsSlidingCurveResult Create() { return new MacroStabilityInwardsSlidingCurveResult( - MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(), - MacroStabilityInwardsSlidingCircleResultTestFactory.CreateCircle(), + MacroStabilityInwardsSlidingCircleResultTestFactory.Create(), + MacroStabilityInwardsSlidingCircleResultTestFactory.Create(), Enumerable.Empty(), 0, 0); } }