コード例 #1
0
        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 UpliftVanSliceResult(topLeftPoint, topRightPoint, bottomLeftPoint, bottomRightPoint,
                                                 new UpliftVanSliceResult.ConstructionProperties());

            // Assert
            Assert.AreSame(topLeftPoint, slice.TopLeftPoint);
            Assert.AreSame(topRightPoint, slice.TopRightPoint);
            Assert.AreSame(bottomLeftPoint, slice.BottomLeftPoint);
            Assert.AreSame(bottomRightPoint, slice.BottomRightPoint);
        }
コード例 #2
0
        /// <summary>
        /// Asserts whether <paramref name="actual"/> is equal to <paramref name="expected"/>.
        /// </summary>
        /// <param name="expected">The expected collection of <see cref="UpliftVanSliceResult"/>.</param>
        /// <param name="actual">The actual collection of <see cref="UpliftVanSliceResult"/>.</param>
        /// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
        /// is not equal to <paramref name="expected"/>.</exception>
        private static void AssertUpliftVanSliceResults(ICollection <UpliftVanSliceResult> expected, ICollection <UpliftVanSliceResult> actual)
        {
            Assert.AreEqual(expected.Count, actual.Count);

            for (var i = 0; i < expected.Count; i++)
            {
                UpliftVanSliceResult expectedUpliftVanSliceResult = expected.ElementAt(i);
                UpliftVanSliceResult actualUpliftVanSliceResult   = actual.ElementAt(i);

                Assert.AreEqual(expectedUpliftVanSliceResult.Cohesion, actualUpliftVanSliceResult.Cohesion);
                Assert.AreEqual(expectedUpliftVanSliceResult.FrictionAngle, actualUpliftVanSliceResult.FrictionAngle);
                Assert.AreEqual(expectedUpliftVanSliceResult.CriticalPressure, actualUpliftVanSliceResult.CriticalPressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.OverConsolidationRatio, actualUpliftVanSliceResult.OverConsolidationRatio);
                Assert.AreEqual(expectedUpliftVanSliceResult.Pop, actualUpliftVanSliceResult.Pop);
                Assert.AreEqual(expectedUpliftVanSliceResult.DegreeOfConsolidationPorePressureSoil, actualUpliftVanSliceResult.DegreeOfConsolidationPorePressureSoil);
                Assert.AreEqual(expectedUpliftVanSliceResult.DegreeOfConsolidationPorePressureLoad, actualUpliftVanSliceResult.DegreeOfConsolidationPorePressureLoad);
                Assert.AreEqual(expectedUpliftVanSliceResult.Dilatancy, actualUpliftVanSliceResult.Dilatancy);
                Assert.AreEqual(expectedUpliftVanSliceResult.ExternalLoad, actualUpliftVanSliceResult.ExternalLoad);
                Assert.AreEqual(expectedUpliftVanSliceResult.HydrostaticPorePressure, actualUpliftVanSliceResult.HydrostaticPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.LeftForce, actualUpliftVanSliceResult.LeftForce);
                Assert.AreEqual(expectedUpliftVanSliceResult.LeftForceAngle, actualUpliftVanSliceResult.LeftForceAngle);
                Assert.AreEqual(expectedUpliftVanSliceResult.LeftForceY, actualUpliftVanSliceResult.LeftForceY);
                Assert.AreEqual(expectedUpliftVanSliceResult.RightForce, actualUpliftVanSliceResult.RightForce);
                Assert.AreEqual(expectedUpliftVanSliceResult.RightForceAngle, actualUpliftVanSliceResult.RightForceAngle);
                Assert.AreEqual(expectedUpliftVanSliceResult.RightForceY, actualUpliftVanSliceResult.RightForceY);
                Assert.AreEqual(expectedUpliftVanSliceResult.LoadStress, actualUpliftVanSliceResult.LoadStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.NormalStress, actualUpliftVanSliceResult.NormalStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.PorePressure, actualUpliftVanSliceResult.PorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.HorizontalPorePressure, actualUpliftVanSliceResult.HorizontalPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.VerticalPorePressure, actualUpliftVanSliceResult.VerticalPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.PiezometricPorePressure, actualUpliftVanSliceResult.PiezometricPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.EffectiveStress, actualUpliftVanSliceResult.EffectiveStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.ExcessPorePressure, actualUpliftVanSliceResult.ExcessPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.ShearStress, actualUpliftVanSliceResult.ShearStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.SoilStress, actualUpliftVanSliceResult.SoilStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.TotalPorePressure, actualUpliftVanSliceResult.TotalPorePressure);
                Assert.AreEqual(expectedUpliftVanSliceResult.TotalStress, actualUpliftVanSliceResult.TotalStress);
                Assert.AreEqual(expectedUpliftVanSliceResult.Weight, actualUpliftVanSliceResult.Weight);
            }
        }
コード例 #3
0
        public void Constructor_ConstructionPropertiesEmpty_ExpectedValues()
        {
            // Call
            var slice = new UpliftVanSliceResult(new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0), new Point2D(0, 0),
                                                 new UpliftVanSliceResult.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.ExcessPorePressure);
            Assert.IsNaN(slice.ShearStress);
            Assert.IsNaN(slice.SoilStress);
            Assert.IsNaN(slice.TotalPorePressure);
            Assert.IsNaN(slice.TotalStress);
            Assert.IsNaN(slice.Weight);
        }
コード例 #4
0
        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 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 UpliftVanSliceResult.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,
                ExcessPorePressure      = excessPorePressure,
                ShearStress             = shearStress,
                SoilStress              = soilStress,
                TotalPorePressure       = totalPorePressure,
                TotalStress             = totalStress,
                Weight                  = weight
            };

            // Call
            var slice = new UpliftVanSliceResult(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(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);
        }
コード例 #5
0
        public void Create_SlidingCurveWithSlices_ReturnUpliftVanSlidingCurveResult()
        {
            // Setup
            var    random                 = new Random(21);
            double topLeftX               = random.NextDouble();
            double topLeftZ               = random.NextDouble();
            double topRightX              = random.NextDouble();
            double topRightZ              = random.NextDouble();
            double bottomLeftX            = random.NextDouble();
            double bottomLeftZ            = random.NextDouble();
            double bottomRightX           = random.NextDouble();
            double bottomRightZ           = random.NextDouble();
            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 excessPorePressure      = random.NextDouble();
            double shearStress             = random.NextDouble();
            double soilStress              = random.NextDouble();
            double totalPorePressure       = random.NextDouble();
            double totalStress             = random.NextDouble();
            double weight = random.NextDouble();

            var slidingCurve = new DualSlidingCircleMinimumSafetyCurve
            {
                ActiveCircleCenter  = new CSharpWrapperPoint2D(0, 0),
                PassiveCircleCenter = new CSharpWrapperPoint2D(1, 1),
                Slices = new[]
                {
                    new Slice
                    {
                        TopLeftPoint       = new CSharpWrapperPoint2D(topLeftX, topLeftZ),
                        TopRightPoint      = new CSharpWrapperPoint2D(topRightX, topRightZ),
                        BottomLeftPoint    = new CSharpWrapperPoint2D(bottomLeftX, bottomLeftZ),
                        BottomRightPoint   = new CSharpWrapperPoint2D(bottomRightX, bottomRightZ),
                        Cohesion           = cohesion,
                        FrictionAngleInput = frictionAngle,
                        YieldStress        = criticalPressure,
                        OCR = overConsolidationRatio,
                        POP = pop,
                        DegreeOfConsolidationPorePressure          = degreeOfConsolidationPorePressureSoil,
                        PorePressureDueToDegreeOfConsolidationLoad = degreeOfConsolidationPorePressureLoad,
                        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,
                        ExcessPorePressure      = excessPorePressure,
                        ShearStress             = shearStress,
                        SoilStress              = soilStress,
                        TotalPorePressure       = totalPorePressure,
                        TotalStress             = totalStress,
                        Weight = weight
                    }
                }
            };

            // Call
            UpliftVanSlidingCurveResult result = UpliftVanSlidingCurveResultCreator.Create(slidingCurve);

            // Assert
            Assert.AreEqual(1, result.Slices.Count());

            UpliftVanSliceResult slice = result.Slices.First();

            Assert.AreEqual(new Point2D(topLeftX, topLeftZ), slice.TopLeftPoint);
            Assert.AreEqual(new Point2D(topRightX, topRightZ), slice.TopRightPoint);
            Assert.AreEqual(new Point2D(bottomLeftX, bottomLeftZ), slice.BottomLeftPoint);
            Assert.AreEqual(new Point2D(bottomRightX, bottomRightZ), slice.BottomRightPoint);

            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(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);
        }