//#define DUMP using System; using System.IO; using Deltares.Mathematics; // ======================================================================================================================= // Class name: // // Description: Executes the calculation of the bishop circles // Data form the interface is found by InterfaceData // // Cirkels are clusterd by centre points. This is usefull // (quicker) when moving the grids. // Finding minimum values per centre point is easier as well // // Copyright (c) 2008-2010 Deltares // // Date ID Modification // 2008-03-26 Best Created // 2010-04-20 Sel Implementation general StabilityCalculation class // 2010-05-12 Sel Implemented Genetic algorithm // 2010-05-20 Sel Finetuned use of GA in general // ======================================================================================================================= namespace Deltares.Stability.Calculation.Inner { // TDoProgress = TProgressDelegate; // TDoSetValues = TSetValuesDelegate; public class TBishopCalculation : TCircularCalculation, IExtremeCalculation { // Private fields private TBishopSlipCirkel FBishopCalculation; private bool FDumpMinimumCircel = false; private TCircleResult[] FMinimumResultCircles; private TMinCircleType[] FMinimumZoneIndication; // private TZones FZone = null; // ======================================================================================================================= // Date ID Modification // 2008-03-26 Best Created // ======================================================================================================================= //Constructor Create() public TBishopCalculation() : base() { // TODO: Add any constructor code here } public void StartBishopCalculation(double LXMid, double LZMid, double LRadius, int AZoneNr, ref double AStability, ref double[] ASliceData) { FBishopCalculation = new TBishopSlipCirkel(); FBishopCalculation.XCenterPoint = LXMid; FBishopCalculation.ZCenterPoint = LZMid; FBishopCalculation.Radius = LRadius; FBishopCalculation.InterfaceData = FInterfaceData; // Calculation AStability = FBishopCalculation.StabilityFactor; ASliceData = FBishopCalculation.GetSliceArray(); if (FDumpMinimumCircel) { AddMinimumCircle(FBishopCalculation, AZoneNr, AStability); } } public override void CalculationGrid() { int LZoneIndex; double[] LMinStability; int[] LMinCircle; int[] LMinCentrePoint; int LAutoGridMoves; string Lstr; LMinStability = new double[Constants.CMaxDumps]; LMinCircle = new int[Constants.CMaxDumps]; LMinCentrePoint = new int[Constants.CMaxDumps]; FMinimumZoneIndication = new TMinCircleType[Constants.CMaxDumps]; FMinimumResultCircles = new TCircleResult[Constants.CMaxDumps]; zonePenalty = 0; for (LZoneIndex = 0; LZoneIndex < Constants.CMaxDumps; LZoneIndex++) { LMinStability[LZoneIndex] = Constants.CFMinStart; LMinCircle[LZoneIndex] = 0; } FDumpMinimumCircel = false; LAutoGridMoves = FInterfaceData.CalculationOptions.NumberOfAutogridMoves; // Write interface data for controle //this.FInterfaceData.Writeinterfacedata(); FLocalSlipData = FInterfaceData.SlipCircleData; // Create all the circles CreateCircles(); int initAutoGridMoves = LAutoGridMoves; CalculateAllCircles(ref LMinCentrePoint, ref LMinCircle, ref LMinStability, ref LAutoGridMoves); // all circels are calculated now see if // if minimum circle lies in zone 1 if ((FInterfaceData.ModelData.HasZonePlot) && (useZone1Search)) { if (FMinimumZoneIndication[0].ZoneNumber > 2) { // Minimum circle lies not in zone 1 // recalculate with penalty // the minimal circle is the search circle // so it must be resetted to the initial value // first make a copy because it is the actual minimal circle TMinCircleType locMin = FMinimumZoneIndication[0]; double locMinStability = LMinStability[0]; LMinStability[0] = Constants.CFMinStart; zonePenalty = 10; CreateCircles(FMinimumZoneIndication[1]); LAutoGridMoves = initAutoGridMoves; CalculateAllCircles(ref LMinCentrePoint, ref LMinCircle, ref LMinStability, ref LAutoGridMoves); // reset the minimum value zonePenalty = 0; if (LMinStability[0] > locMinStability) { LMinStability[0] = locMinStability; FMinimumZoneIndication[0] = locMin; } } } FDumpMinimumCircel = true; for (LZoneIndex = 0; LZoneIndex < Constants.CMaxDumps; LZoneIndex++) { if ((LMinStability[LZoneIndex] < Constants.CFMinStart - 1)) { RecalculateMinimalCircle(FMinimumZoneIndication[LZoneIndex], LZoneIndex); } } FDumpMinimumCircel = false; if ((FIsProbabilisticCalculation)) { for (LZoneIndex = 0; LZoneIndex < Constants.CMaxDumps; LZoneIndex++) { if ((LMinStability[LZoneIndex] < Constants.CFMinStart - 1)) { try { CalculateProbabilisticCircle(FMinimumZoneIndication[LZoneIndex]); } catch (Exception E) { Lstr = E.Message; throw E; } } } } } public override void CalculationGA(GeneticAlgorithm AGeneticAlgorithm) { TBounds LBounds; TBishopSlipCirkel LBishopSlipCirkel; // Set options AGeneticAlgorithm.GenomeCount = 3; // Set the bounds for the genetic algorithm; the radius is composed of middle point and tanggeent line LBounds.Min = FInterfaceData.SlipCircleData.XLeftCenterPoint; LBounds.Inc = FInterfaceData.SlipCircleData.XRightCenterPoint - FInterfaceData.SlipCircleData.XLeftCenterPoint; AGeneticAlgorithm.SetBounds(0, LBounds); LBounds.Min = FInterfaceData.SlipCircleData.ZBottomCenterPoint; LBounds.Inc = FInterfaceData.SlipCircleData.ZTopCenterPoint - FInterfaceData.SlipCircleData.ZBottomCenterPoint; AGeneticAlgorithm.SetBounds(1, LBounds); LBounds.Min = FInterfaceData.SlipCircleData.BottomTangentZ; LBounds.Inc = FInterfaceData.SlipCircleData.TopTangentZ - FInterfaceData.SlipCircleData.BottomTangentZ; AGeneticAlgorithm.SetBounds(2, LBounds); // Communicate the address of the calculation AGeneticAlgorithm.GeneticCalculation = this; // Determine safety factor AGeneticAlgorithm.Calculation(); // Pass minimum circle to dumpdata FDumpMinimumCircel = true; LBishopSlipCirkel = new TBishopSlipCirkel(); LBishopSlipCirkel.XCenterPoint = AGeneticAlgorithm.Fittest[0]; LBishopSlipCirkel.ZCenterPoint = AGeneticAlgorithm.Fittest[1]; LBishopSlipCirkel.Radius = AGeneticAlgorithm.Fittest[1] - AGeneticAlgorithm.Fittest[2]; LBishopSlipCirkel.InterfaceData = FInterfaceData; // Recalculate the minimum circle object dummy = LBishopSlipCirkel.StabilityFactor; FDumpMinimumCircel = false; AddMinimumCircle(LBishopSlipCirkel, 0, AGeneticAlgorithm.Fittest[AGeneticAlgorithm.GenomeCount]); } public override void CalculationLM(LevenbergMarquardtExtreme ALevenbergMarquardt) { // TODO Must be implemented, see issue MSTAB-646. Is used in class StartCalculation: the critical point found by the GA must be used as inital point for LM. } public double ComputeExtremeResult(double[] AGenome) { // Create Bishop circle and pass data var LBishopSlipCirkel = new TBishopSlipCirkel(); LBishopSlipCirkel.XCenterPoint = AGenome[0]; LBishopSlipCirkel.ZCenterPoint = AGenome[1]; LBishopSlipCirkel.Radius = AGenome[1] - AGenome[2]; LBishopSlipCirkel.InterfaceData = FInterfaceData; // Calculation double result = LBishopSlipCirkel.StabilityFactor; if (result < FMinStabilityFactor) { FMinStabilityFactor = Math.Min(FMinStabilityFactor, result); if ((DoSetValues != null)) { double[] LStabilityResults = LBishopSlipCirkel.GetSliceArray(); var LMinStabilityResults = new double[LStabilityResults.Length + 1]; LStabilityResults.CopyTo(LMinStabilityResults, 0); LMinStabilityResults[LMinStabilityResults.Length - 1] = FMinStabilityFactor; DoSetValues("Bishop", LMinStabilityResults); } } return result; } // Private methods // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void Movegridleft(double dx, int AXIntervalCount) { FLocalSlipData.XLeftCenterPoint -= (AXIntervalCount - 1)*dx; FLocalSlipData.XRightCenterPoint -= (AXIntervalCount - 1)*dx; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MovegridRight(double dx, int AXIntervalCount) { FLocalSlipData.XLeftCenterPoint += (AXIntervalCount - 1)*dx; FLocalSlipData.XRightCenterPoint += (AXIntervalCount - 1)*dx; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveGridBottom(double Dz, int AZIntervalCount) { FLocalSlipData.ZBottomCenterPoint -= (AZIntervalCount - 1)*Dz; FLocalSlipData.ZTopCenterPoint -= (AZIntervalCount - 1)*Dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveGridTop(double Dz, int AZIntervalCount) { FLocalSlipData.ZBottomCenterPoint += (AZIntervalCount - 1)*Dz; FLocalSlipData.ZTopCenterPoint += (AZIntervalCount - 1)*Dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveGridLeftBottom(double dx, double dz, int AXIntervalCount, int AZIntervalCount) { FLocalSlipData.XLeftCenterPoint -= (AXIntervalCount - 1)*dx; FLocalSlipData.XRightCenterPoint -= (AXIntervalCount - 1)*dx; FLocalSlipData.ZBottomCenterPoint -= (AZIntervalCount - 1)*dz; FLocalSlipData.ZTopCenterPoint -= (AZIntervalCount - 1)*dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MovegridRightBottom(double dx, double Dz, int AXIntervalCount, int AZIntervalCount) { FLocalSlipData.XLeftCenterPoint += (AXIntervalCount - 1)*dx; FLocalSlipData.XRightCenterPoint += (AXIntervalCount - 1)*dx; FLocalSlipData.ZBottomCenterPoint -= (AZIntervalCount - 1)*Dz; FLocalSlipData.ZTopCenterPoint -= (AZIntervalCount - 1)*Dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveGridLeftTop(double dx, double Dz, int AXIntervalCount, int AZIntervalCount) { FLocalSlipData.XLeftCenterPoint -= (AXIntervalCount - 1)*dx; FLocalSlipData.XRightCenterPoint -= (AXIntervalCount - 1)*dx; FLocalSlipData.ZBottomCenterPoint += (AZIntervalCount - 1)*Dz; FLocalSlipData.ZTopCenterPoint += (AZIntervalCount - 1)*Dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveGridRightTop(double Dx, double Dz, int AXIntervalCount, int AZIntervalCount) { FLocalSlipData.XLeftCenterPoint += (AXIntervalCount - 1)*Dx; FLocalSlipData.XRightCenterPoint += (AXIntervalCount - 1)*Dx; FLocalSlipData.ZBottomCenterPoint += (AZIntervalCount - 1)*Dz; FLocalSlipData.ZTopCenterPoint += (AZIntervalCount - 1)*Dz; NotifyChange(Constants.GridDataID, FLocalSlipData); } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveTangentLineUp() {} // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void MoveTangentLineDown() {} // ======================================================================================================================= // Description : Find minimum procedure // // 8 4 9 // + + + + + // + + + + + // 1 + + + + + 2 // + + + + + // + + + + + // 6 3 7 // // ----------------------- 12 // ----------------------- // ----------------------- 13 // // Name Type Function // ---- ---- -------- // Parameters - IN/OUT : AutoGridMoves Integer Maximum number of // automatic steps for // findminimum procedure // // Date ID Modification // 2008-04-14 Best Created // ======================================================================================================================= private bool SearchForMinimum(ref int AutoGridMoves, ref int AMinCenterpoint, ref int AMinCircle) { bool result; int hlp; double dx; double dz; double error; bool cont; double LXMidMin; double LZMidMin; double LRadMin; double LMaxRad; double LMinRad; double LMinSafety; TCentrePoints LHulpResult; bool LHasTangentMoved; error = 0.0001; result = true; hlp = 0; if (!(FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].circles != null)) { result = false; return result; } LXMidMin = FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].XMid; LZMidMin = FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].ZMid; if (FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].circles.Count > 0) { LRadMin = LZMidMin - FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].circles[AMinCircle].ZTangent; LMinSafety = FCentrePoints.ArrayOfCentrePoints[AMinCenterpoint].circles[AMinCircle].FStability; } else { LRadMin = Double.MaxValue; LMinSafety = Double.MaxValue; } // with FInterfaceData.SlipCircleData do // TSlipCircleData fLocalSlipData = this.FLocalSlipData; // ... Is Stramien groot genoeg voor een zoekminimum procedure ... if ((FLocalSlipData.XIntervalCount < 2) || (FLocalSlipData.ZIntervalCount < 2)) { result = false; } if (result) { // ... Als er in vorig stramien Geen goede cirkels waren, dan Geen zoekminimum ... if ((Math.Abs(LMinSafety - Constants.CFMinStart) < Constants.CEpsMin)) { result = false; } } if (result) { // Kijk of het minimum op een rand ligt. hlp = 0; if ((Math.Abs(LXMidMin - FLocalSlipData.XLeftCenterPoint) < error)) { hlp = 1; } if ((Math.Abs(LXMidMin - FLocalSlipData.XRightCenterPoint) < error)) { hlp = 2; } if ((Math.Abs(LZMidMin - FLocalSlipData.ZBottomCenterPoint) < error)) { // De mogelijkheid bestaat dat minimum op en hoek ligt. // Dan stramien twee kanten uit schuiven. if ((hlp == 0)) { hlp = 3; } else { if ((hlp == 1)) { hlp = 6; } else { hlp = 7; } } } if ((Math.Abs(LZMidMin - FLocalSlipData.ZTopCenterPoint) < error)) { if ((hlp == 0)) { hlp = 4; } else { if ((hlp == 1)) { hlp = 8; } else { hlp = 9; } } } // ... check tangent lines only if centre point is enclosed ... if ((hlp == 0) && (FLocalSlipData.TangentIntervalCount > 1)) { LMaxRad = DistanceToTangentLine(LXMidMin, LZMidMin); LMinRad = LMaxRad - MStabDatafunctions.Distance2D(FLocalSlipData.TopTangentX, FLocalSlipData.TopTangentZ, FLocalSlipData.BottomTangentX, FLocalSlipData.BottomTangentZ); if ((Math.Abs(LRadMin - LMinRad) < error)) { hlp = 12; } if ((Math.Abs(LRadMin - LMaxRad) < error)) { hlp = 13; } } if ((hlp == 0)) { result = false; } } // If AutoGridMove > 0, move the grid and reduce // autogridmove by 1. if (result) { if ((AutoGridMoves == 0)) { cont = false; } else { cont = true; AutoGridMoves -= 1; } if (cont) { result = true; dx = Math.Abs(FLocalSlipData.XRightCenterPoint - FLocalSlipData.XLeftCenterPoint)/(FLocalSlipData.XIntervalCount); dz = Math.Abs(FLocalSlipData.ZTopCenterPoint - FLocalSlipData.ZBottomCenterPoint)/(FLocalSlipData.ZIntervalCount); switch (hlp) { case 1: Movegridleft(dx, FLocalSlipData.XIntervalCount); break; case 2: MovegridRight(dx, FLocalSlipData.XIntervalCount); break; case 3: MoveGridBottom(dz, FLocalSlipData.ZIntervalCount); break; case 4: MoveGridTop(dz, FLocalSlipData.ZIntervalCount); break; case 6: MoveGridLeftBottom(dx, dz, FLocalSlipData.XIntervalCount, FLocalSlipData.ZIntervalCount); break; case 7: MovegridRightBottom(dx, dz, FLocalSlipData.XIntervalCount, FLocalSlipData.ZIntervalCount); break; case 8: MoveGridLeftTop(dx, dz, FLocalSlipData.XIntervalCount, FLocalSlipData.ZIntervalCount); break; case 9: MoveGridRightTop(dx, dz, FLocalSlipData.XIntervalCount, FLocalSlipData.ZIntervalCount); break; case 12: MoveTangentLineUp(); break; case 13: MoveTangentLineDown(); break; } LHasTangentMoved = (hlp > 10); // Make a copy of the result array LHulpResult = FCentrePoints; try { // circles with the new center points are created CreateCircles(); // fill circle array with already calculated circles FCentrePoints.FilldataFromOldCentrePoints(LHulpResult, LHasTangentMoved); // Find the position of this minimum value in the new grid FCentrePoints.FindMinimumCircle(LXMidMin, LZMidMin, LRadMin, LMinSafety, ref AMinCenterpoint, ref AMinCircle); } finally { //@ Unsupported property or method(C): 'Free' LHulpResult = null; } } else { result = false; } } return result; } // ======================================================================================================================= // Date ID Modification // 2009-05-27 Created // ======================================================================================================================= private void AddMinimumCircle(TBishopSlipCirkel ABishopSlipCirkel, int AZonenr, double AStability) { TCircleResult LResultCircle; int i; int LNSlices; LNSlices = ABishopSlipCirkel.NSlices; LResultCircle = new TCircleResult(); LResultCircle.SetSliceDimension(LNSlices); for (i = 0; i < LNSlices; i++) { LResultCircle.Slices[i] = new Tslice(ABishopSlipCirkel.GetSlice(i)); } LResultCircle.ZoneNr = AZonenr; LResultCircle.CalcMethod = FInterfaceData.ModelData.CalcType; LResultCircle.StabilityFactor = AStability; LResultCircle.XCenterPoint = ABishopSlipCirkel.XCenterPoint; LResultCircle.ZCenterPoint = ABishopSlipCirkel.ZCenterPoint; LResultCircle.Radius = ABishopSlipCirkel.Radius; LResultCircle.SoilMoment = ABishopSlipCirkel.SoilMoment; LResultCircle.Watermoment = ABishopSlipCirkel.Watermoment; LResultCircle.ResistingMomUniterated = ABishopSlipCirkel.ResistingMom0; LResultCircle.ResistingMom = ABishopSlipCirkel.ResistingMom; LResultCircle.TextileMoment = ABishopSlipCirkel.TextileMoment; LResultCircle.GeotextileResults = ABishopSlipCirkel.GetGeotextileResults(); LResultCircle.NailMoment = ABishopSlipCirkel.NailMoment; LResultCircle.DrivingMoment = ABishopSlipCirkel.DrivingMoment; LResultCircle.EndsectionMom = ABishopSlipCirkel.EndsectionMom; LResultCircle.LoadMoment = ABishopSlipCirkel.LoadMoment; LResultCircle.HorQuakeMom = ABishopSlipCirkel.HorQuakeMom; FDumpData.AddMinimumCircle(LResultCircle); #if DUMP DoDumpMinimumCircel(LResultCircle); #endif } // ======================================================================================================================= // Date ID Modification // 2008-12-03 Best Created // ======================================================================================================================= private void DoDumpMinimumCircel(TCircleResult AResultCircle) { int i = 0; int LNSlices = 0; StreamWriter writer; Tslice LSlice; LNSlices = AResultCircle.Slices.Length; writer = new StreamWriter("test.txt"); writer.WriteLine("Slice| X-coor | Y-bot | Y-top | Width | Angle | Angle |Arc.len.|Cohesion|"); writer.WriteLine(" | [m] | [m] | [m] | [m] | bottom | top | [m] | [kN/m2]|"); writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|--------|--------|"); for (i = 0; i < LNSlices; i++) { LSlice = AResultCircle.Slices[i]; writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |{7,7:0.00} |{8,7:0.00} |", i + 1, LSlice.XMid, LSlice.ZBottomMid, LSlice.ZTopMid, LSlice.Width, LSlice.BottomAngle, LSlice.TopAngle, LSlice.ArcLength, LSlice.CohBottom); } writer.WriteLine(" "); writer.WriteLine(" "); writer.WriteLine(" "); writer.WriteLine("Slice| Phi | Sw surf| Fw hor.| Fw ver.| Weight | S-tot. | S-eff. |Sw-hydro|"); writer.WriteLine(" | degree | [kN/m2]| [kN] | [kN] | [kN] | [kN/m2]| [kN/m2]| [kN/m2]|"); writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|--------|--------|"); for (i = 0; i < LNSlices; i++) { LSlice = AResultCircle.Slices[i]; writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |{7,7:0.00} |{8,7:0.00} |", i + 1, LSlice.PhiBottom, LSlice.PoreOnSurface, LSlice.HPoreOnSurface, LSlice.VPoreOnSurface, LSlice.Weight, LSlice.TotalStress, LSlice.EffectiveStress, LSlice.HydrostaticPore); } writer.WriteLine(" "); writer.WriteLine(" "); writer.WriteLine(" "); writer.WriteLine("Slice| Sw-extr| Sw tot.|S shear | Cu | Ko | Sig-Vo'|Alf*SigB|Sig-Alfa|"); writer.WriteLine(" | [kN/m2]| [kN/m2]| [kN/m2]| [kN/m2]| | [kN/m2]| [kN/m2]| |"); writer.WriteLine("-----|--------|--------|--------|--------|--------|--------|--------|--------|"); for (i = 0; i < LNSlices; i++) { LSlice = AResultCircle.Slices[i]; writer.WriteLine("{0,4:0} |{1,7:0.00} |{2,7:0.00} |{3,7:0.00} |{4,7:0.00} |{5,7:0.00} |{6,7:0.00} |{7,7:0.00} |{8,7:0.00} |", i + 1, LSlice.ExcessPore, LSlice.TotalPore, LSlice.ShearStress, LSlice.Cu, LSlice.K0, LSlice.PreLoadStress, LSlice.LoadStress, LSlice.SigmaAlfa); } writer.Close(); } // ======================================================================================================================= // Date ID Modification // 2010-04-28 Best Created // ======================================================================================================================= private void CalculateCircle(int ACenterPoint, int ARadiusNumber, int AZoneNr, ref double AStability, ref double[] ASliceData) { double LXMid; double LRadius; double LZMid; TCentrePoint LCentrePoint = FCentrePoints.ArrayOfCentrePoints[ACenterPoint]; LXMid = LCentrePoint.XMid; LZMid = LCentrePoint.ZMid; LRadius = LZMid - FCentrePoints.ArrayOfCentrePoints[ACenterPoint].circles[ARadiusNumber].ZTangent; StartBishopCalculation(LXMid, LZMid, LRadius, AZoneNr, ref AStability, ref ASliceData); LCentrePoint.circles[ARadiusNumber].FStability = AStability; LCentrePoint.circles[ARadiusNumber].CircleMessage = FBishopCalculation.CalculationNote; } // ======================================================================================================================= // Date ID Modification // 2010-06-07 Created // ======================================================================================================================= private void CalculateProbabilisticCircle(TMinCircleType AZoneIndication) { double LXMid; double LRadius; TBishopSlipCirkel LBishopSlipCirkel; double LZMid; TprobabilisticData LProbabilisticData; LXMid = AZoneIndication.ActiveCentrePointX; LZMid = AZoneIndication.ActiveCentrePointY; LRadius = AZoneIndication.ActiveCentrePointRad; LBishopSlipCirkel = new TBishopSlipCirkel(); LBishopSlipCirkel.XCenterPoint = LXMid; LBishopSlipCirkel.ZCenterPoint = LZMid; LBishopSlipCirkel.Radius = LRadius; LBishopSlipCirkel.InterfaceData = FInterfaceData; // Calculation object dummy = LBishopSlipCirkel.ReliabilityIndex; LProbabilisticData = LBishopSlipCirkel.ProbabilisticResutData; FDumpData.AddProbabilisticData(LProbabilisticData); } private void HandleZoneData(ref int[] AMinCentrePoint, ref int[] AMinCircle, ref double[] AMinStability, ref int LZoneNr, double LStability, int LCenterPointIndex, int LRadiiIndex) { const double CMinRotation = 1.0E-6; int LExtraZonenr = 0; bool LIsBishopCalculation = false; bool LDoesPlaneIntesectsRestProfile = false; double LXMid = 0; double LZMid = 0; double LRadius = 0; double LXSurface = 0; double LZExit = 0; double LAngle = 0; double LRotatedStability; bool Isready = false; LXMid = FBishopCalculation.XCenterPoint; LZMid = FBishopCalculation.ZCenterPoint; LRadius = FBishopCalculation.Radius; if ((FInterfaceData.ZoneData.StabilitySide == TStabilitySideSet.LeftSide)) { LXSurface = FBishopCalculation.XRightSurface; LZExit = FBishopCalculation.ZLeftSurface; } else { LXSurface = FBishopCalculation.XLeftSurface; LZExit = FBishopCalculation.ZRightSurface; } // Bepaal Zone nr FZone.GetZoneNr(LIsBishopCalculation, LXMid, LZMid, LRadius, LStability, LXSurface, ref LAngle, ref LZoneNr, ref LExtraZonenr, LZExit, ref LDoesPlaneIntesectsRestProfile); // Check if zone is still the same after rotation Isready = ((LZoneNr < 3) || (Math.Abs(LAngle) < CMinRotation)); if (!Isready) { if (LZoneNr == 3) { Isready = LStability > InterfaceData.ZoneData.SafetyZone1a; } if (LZoneNr == 4) { Isready = LStability > InterfaceData.ZoneData.SafetyZone1b; } } if ((!Isready) && (LDoesPlaneIntesectsRestProfile)) { if (Math.Abs(LAngle) > CMinRotation) { FBishopCalculation.Angle = LAngle; FBishopCalculation.RemoldFactor = FInterfaceData.ZoneData.RemoldingReductionFactor; FBishopCalculation.SchemaFactor = FInterfaceData.ZoneData.SchematizationReductionFactor; LRotatedStability = FBishopCalculation.RotateSafety; /* { Aangezien bij de geroteerde cirkel uigegaan is van de schuifspanningen behorende bij een veiligheidsfactor van LStability, is de geroteerde fator ook relatief ten opzichte van LStability. } */ LRotatedStability = LRotatedStability*LStability; if (LZoneNr == 3) { Isready = LRotatedStability > InterfaceData.ZoneData.SafetyZone1a; } if (LZoneNr == 4) { Isready = LRotatedStability > InterfaceData.ZoneData.SafetyZone1b; } if (!Isready) { LZoneNr = LZoneNr - 2; Isready = true; } } } if (Isready) { // nr is zone nr if ((LStability < AMinStability[LZoneNr])) { TCentrePoint LCentrePoint = FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex]; FMinimumZoneIndication[LZoneNr].ActiveCentrePointX = LCentrePoint.XMid; FMinimumZoneIndication[LZoneNr].ActiveCentrePointY = LCentrePoint.ZMid; FMinimumZoneIndication[LZoneNr].ActiveCentrePointRad = LCentrePoint.ZMid - LCentrePoint.circles[LRadiiIndex].ZTangent; FMinimumZoneIndication[LZoneNr].ZoneNumber = LZoneNr; AMinCentrePoint[LZoneNr] = LCenterPointIndex; AMinCircle[LZoneNr] = LRadiiIndex; AMinStability[LZoneNr] = LStability; } if (LExtraZonenr > 4) { if (LStability < AMinStability[LExtraZonenr]) { TCentrePoint LCentrePoint = FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex]; FMinimumZoneIndication[LExtraZonenr].ActiveCentrePointX = LCentrePoint.XMid; FMinimumZoneIndication[LExtraZonenr].ActiveCentrePointY = LCentrePoint.ZMid; FMinimumZoneIndication[LExtraZonenr].ActiveCentrePointRad = LCentrePoint.ZMid - LCentrePoint.circles[LRadiiIndex].ZTangent; AMinCentrePoint[LExtraZonenr] = LCenterPointIndex; AMinCircle[LExtraZonenr] = LRadiiIndex; AMinStability[LExtraZonenr] = LStability; } } } } // ======================================================================================================================= // Date ID Modification // 2008-04-16 Best Created // ======================================================================================================================= private void CalculateCircles(ref int[] AMinCentrePoint, ref int[] AMinCircle, ref double[] AMinStability) { double LStability = 0; int LCenterPointIndex = 0; int LRadiiCount = 0; int LRadiiIndex = 0; int LCenterpointCount = 0; int LZoneNr = 0; double[] LStabilityResults = null; double[] LMinStabilityResults = null; LZoneNr = 0; // Make a calculation for each circle LCenterpointCount = FCentrePoints.ArrayOfCentrePoints.Count; // Calculate All circles for (LCenterPointIndex = 0; LCenterPointIndex < LCenterpointCount; LCenterPointIndex++) { TCentrePoint Centre = FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex]; if ((FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex].CentrePointMessage == "")) { LRadiiCount = Centre.circles.Count; for (LRadiiIndex = 0; LRadiiIndex < LRadiiCount; LRadiiIndex++) { if ((Centre.circles[LRadiiIndex].CircleMessage == "")) { CalculateCircle(LCenterPointIndex, LRadiiIndex, LZoneNr, ref LStability, ref LStabilityResults); } if ((LStability > 0) && (LStability < Constants.CFMinStart - 1)) { // If zone plot calculation Find zone nr if ((FInterfaceData.ModelData.HasZonePlot)) { HandleZoneData(ref AMinCentrePoint, ref AMinCircle, ref AMinStability, ref LZoneNr, LStability, LCenterPointIndex, LRadiiIndex); if (LZoneNr > 2) { LStability = LStability + ZonePenalty; } } // 0 is overall stability if ((LStability < AMinStability[0])) { TCentrePoint LCentrePoint = FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex]; FMinimumZoneIndication[0].ActiveCentrePointX = LCentrePoint.XMid; FMinimumZoneIndication[0].ActiveCentrePointY = LCentrePoint.ZMid; FMinimumZoneIndication[0].ActiveCentrePointRad = LCentrePoint.ZMid - LCentrePoint.circles[LRadiiIndex].ZTangent; FMinimumZoneIndication[0].ZoneNumber = LZoneNr; AMinCentrePoint[0] = LCenterPointIndex; AMinCircle[0] = LRadiiIndex; AMinStability[0] = LStability; //LMinStabilityResults = LStabilityResults; LMinStabilityResults = new double[LStabilityResults.Length + 1]; LStabilityResults.CopyTo(LMinStabilityResults, 0); LMinStabilityResults[LMinStabilityResults.Length - 1] = LStability; //?? why again best CalculateCircle(LCenterPointIndex, LRadiiIndex, LZoneNr, ref LStability, ref LStabilityResults); if (DoSetValues != null) { DoSetValues("Bishop", LMinStabilityResults); } } } if (DoProgress != null) { DoProgress(Convert.ToDouble(LCenterPointIndex + 1)/Convert.ToDouble(LCenterpointCount)); } } } FCentrePoints.ArrayOfCentrePoints[LCenterPointIndex].CentrePointMessage = Constants.CCalculated; } } // Date ID Modification // 2008-12-03 Best Created // ======================================================================================================================= private void RecalculateMinimalCircle(TMinCircleType AZoneIndication, int AZoneNr) { double LStability = 0; var LSliceArray = new double[0]; StartBishopCalculation(AZoneIndication.ActiveCentrePointX, AZoneIndication.ActiveCentrePointY, AZoneIndication.ActiveCentrePointRad, AZoneNr, ref LStability, ref LSliceArray); } // ======================================================================================================================= // ======================================================================================================================= // Date ID Modification // 2008-03-26 Best Created // ======================================================================================================================= private void CalculateAllCircles(ref int[] LMinCentrePoint, ref int[] LMinCircle, ref double[] LMinStability, ref int LAutoGridMoves) { CalculateCircles(ref LMinCentrePoint, ref LMinCircle, ref LMinStability); FDumpData.AddCentrePoints(FCentrePoints.ArrayOfCentrePoints.ToArray()); // // If the minimum cirkel lies on the oundary of the grid // and the option move grid is on than move the grid if ((FInterfaceData.CalculationOptions.IsGridMoved)) { while ((SearchForMinimum(ref LAutoGridMoves, ref LMinCentrePoint[0], ref LMinCircle[0]))) { // and (LAutoGridMoves > 0) do CalculateCircles(ref LMinCentrePoint, ref LMinCircle, ref LMinStability); FDumpData.AddCentrePoints(FCentrePoints.ArrayOfCentrePoints.ToArray()); } } } // ======================================================================================================================= // Date ID Modification // 2010-04-22 Sel Created // ======================================================================================================================= } // end TBishopCalculation }