private static double SingularSeparate(double denominator1, double denominator2, CollocationPoint collPointR, Segment segmentI, CollocationPoint collPointI)
        {
            double value = 0.0;
            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    0.0,
                    collPointR.ParametricPosition,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((collPointR.ParametricPosition) * CalculateCore(collPointR.RealPosition, singularIntegrationPoint, denominator1, denominator2, segmentI, collPointI));
            }

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    collPointR.ParametricPosition,
                    1.0,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((1.0 - collPointR.ParametricPosition) * CalculateCore(collPointR.RealPosition, singularIntegrationPoint, denominator1, denominator2, segmentI, collPointI));
            }
            return value;
        }
        private static double CalculateCore(RealPoint point, BoundaryIntegrationPoint integrationPoint, double denominator1, double denominator2, Segment segment, CollocationPoint collPoint)
        {
            double lambda1 = point.x - integrationPoint.RealPosition.x;
            double lambda2 = point.y - integrationPoint.RealPosition.y;

            double r2 = (double)(lambda1 * lambda1 + lambda2 * lambda2);
            double a = (double)r2 / denominator1;

            return (double)(integrationPoint.QuadratureValue
                               * CzebyshewSeries.calculate(integrationPoint.ParametricPosition * segment.Lenght, collPoint.Index)
                               * integrationPoint.Jacobian
                               * (FunctionEi.calculate(a) / denominator2));
        }
Exemplo n.º 3
0
        private List <BoundaryIntegrationPoint> calculateBoundaryIntegrationPoints(int regularBoundaryIntegrationPointsCount)
        {
            var BoundaryIntegrationPoints = new List <BoundaryIntegrationPoint>();

            var gaussQuadrature = new GaussQuadrature(regularBoundaryIntegrationPointsCount);

            for (int index = 0; index < regularBoundaryIntegrationPointsCount; index++)
            {
                var BoundaryIntegrationPoint = new BoundaryIntegrationPoint(index, gaussQuadrature.xi[index], 0.0, 1.0, gaussQuadrature.Ai[index], this.ShapeFunction);
                BoundaryIntegrationPoints.Add(BoundaryIntegrationPoint);
            }

            return(BoundaryIntegrationPoints);
        }
Exemplo n.º 4
0
        private static double CalculateCore(double denominator2, RealPoint point, BoundaryIntegrationPoint integrationPoint, Segment segment, CollocationPoint collPoint)
        {
            double lambda1 = point.x - integrationPoint.RealPosition.x;
            double lambda2 = point.y - integrationPoint.RealPosition.y;

            double r2           = (double)(lambda1 * lambda1 + lambda2 * lambda2);
            double d            = (double)(lambda1 * integrationPoint.NormalVector.X + lambda2 * integrationPoint.NormalVector.Y);
            double denomiantor1 = (double)4.0 * Math.PI * r2;
            double core         = (double)d / denomiantor1 * Math.Exp(-r2 / denominator2);

            return((double)(integrationPoint.QuadratureValue
                            * CzebyshewSeries.calculate(integrationPoint.ParametricPosition * segment.Lenght, collPoint.Index)
                            * integrationPoint.Jacobian
                            * core));
        }
Exemplo n.º 5
0
        private static double SigularSeparate(double denominator2, Segment segmentR, CollocationPoint collPointR, Segment segmentI, CollocationPoint collPointI)
        {
            double value = 0.0;
            ///TODO: Sprawdzić jak dla nieliniowych ma być
            var destx = (1 - collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV0().x + (collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV1().x;
            var desty = (1 - collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV0().y + (collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV1().y;
            var dest  = (double)Math.Sqrt((segmentI.ShapeFunction.GetV0().x - destx) * (segmentI.ShapeFunction.GetV0().x - destx) + (segmentI.ShapeFunction.GetV0().y - desty) * (segmentI.ShapeFunction.GetV0().y - desty));

            value = 0.5 * CzebyshewSeries.calculate(dest, collPointI.Index);

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    0.0,
                    collPointR.ParametricPosition,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((collPointR.ParametricPosition) * CalculateCore(denominator2, collPointR.RealPosition, singularIntegrationPoint, segmentI, collPointI));
            }

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    collPointR.ParametricPosition,
                    1.0,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((1.0 - collPointR.ParametricPosition) * CalculateCore(denominator2, collPointR.RealPosition, singularIntegrationPoint, segmentI, collPointI));
            }
            return(value);
        }
Exemplo n.º 6
0
        private static double SigularSeparateWithAnalitycal(double denominator2, Segment segmentR, CollocationPoint collPointR, Segment segmentI, CollocationPoint collPointI)
        {
            double value = 0.0;
            ///TODO: Sprawdzić jak dla nieliniowych ma być
            var destx = (1 - collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV0().x + (collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV1().x;
            var desty = (1 - collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV0().y + (collPointR.ParametricPosition) * segmentR.ShapeFunction.GetV1().y;
            var dest  = (double)Math.Sqrt((segmentI.ShapeFunction.GetV0().x - destx) * (segmentI.ShapeFunction.GetV0().x - destx) + (segmentI.ShapeFunction.GetV0().y - desty) * (segmentI.ShapeFunction.GetV0().y - desty));

            value = 0.5 * CzebyshewSeries.calculate(dest, collPointI.Index);

            double distance = segmentR.DistanceFromSingularPoint;
            double a        = collPointR.ParametricPosition - distance;
            double b        = collPointR.ParametricPosition + distance;

            double I1            = 0.0;
            double I2            = 0.0;
            double s1            = collPointR.ParametricPosition;
            var    boundaryShape = (BezieCurve)segmentR.ShapeFunction;

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                double w          = 0.5 * (segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1] + 1.0);
                double parametera = (a - s1) * w + s1;
                double parameterb = (b - s1) * w + s1;
                double sa         = (parametera - a);
                double sb         = (parameterb - b);

                I1 -= (functionF(boundaryShape, sa, s1, denominator2, collPointR.Index)
                       * segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1])
                      - (functionF(boundaryShape, s1, s1, denominator2, collPointR.Index)
                         * Math.Log(Math.Abs(a * boundaryShape.lenght - s1 * boundaryShape.lenght)));

                I2 += (functionF(boundaryShape, sb, s1, denominator2, collPointR.Index)
                       * segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1])
                      + (functionF(boundaryShape, s1, s1, denominator2, collPointR.Index)
                         * Math.Log(Math.Abs(b * boundaryShape.lenght - s1 * boundaryShape.lenght)));
            }

            value += (1.0 / (2.0 * Math.PI)) * (I1 + I2);

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    0.0,
                    a,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((collPointR.ParametricPosition) * CalculateCore(denominator2, collPointR.RealPosition, singularIntegrationPoint, segmentI, collPointI));
            }

            for (int singularIndex1 = 0; singularIndex1 < segmentI.SingularBoundaryIntegrationPointsCount; singularIndex1++)
            {
                var singularIntegrationPoint = new BoundaryIntegrationPoint(
                    singularIndex1,
                    segmentI.GaussQuadratureForSingularIntegral.xi[singularIndex1],
                    b,
                    1.0,
                    segmentI.GaussQuadratureForSingularIntegral.Ai[singularIndex1],
                    segmentI.ShapeFunction);

                value += (double)((1.0 - collPointR.ParametricPosition) * CalculateCore(denominator2, collPointR.RealPosition, singularIntegrationPoint, segmentI, collPointI));
            }
            return(value);
        }