Пример #1
0
        public void testFdmLinearOpLayout()
        {
            int[]      dims = new int[] { 5, 7, 8 };
            List <int> dim  = new List <int>(dims);

            FdmLinearOpLayout layout = new FdmLinearOpLayout(dim);

            int calculatedDim = layout.dim().Count;
            int expectedDim   = dim.Count;

            if (calculatedDim != expectedDim)
            {
                QAssert.Fail("index.dimensions() should be " + expectedDim
                             + ", but is " + calculatedDim);
            }

            int calculatedSize = layout.size();
            int expectedSize   = dim.accumulate(0, 3, 1, (x, y) => (x * y));

            if (calculatedSize != expectedSize)
            {
                QAssert.Fail("index.size() should be "
                             + expectedSize + ", but is " + calculatedSize);
            }

            for (int k = 0; k < dim[0]; ++k)
            {
                for (int l = 0; l < dim[1]; ++l)
                {
                    for (int m = 0; m < dim[2]; ++m)
                    {
                        List <int> tmp = new InitializedList <int>(3);
                        tmp[0] = k; tmp[1] = l; tmp[2] = m;

                        int calculatedIndex = layout.index(tmp);
                        int expectedIndex   = k + l * dim[0] + m * dim[0] * dim[1];

                        if (expectedIndex != layout.index(tmp))
                        {
                            QAssert.Fail("index.size() should be " + expectedIndex
                                         + ", but is " + calculatedIndex);
                        }
                    }
                }
            }

            FdmLinearOpIterator iter = layout.begin();

            for (int m = 0; m < dim[2]; ++m)
            {
                for (int l = 0; l < dim[1]; ++l)
                {
                    for (int k = 0; k < dim[0]; ++k, ++iter)
                    {
                        for (int n = 1; n < 4; ++n)
                        {
                            int nn = layout.neighbourhood(iter, 1, n);
                            int calculatedIndex = k + m * dim[0] * dim[1]
                                                  + ((l < dim[1] - n)? l + n
                                              : dim[1] - 1 - (l + n - (dim[1] - 1))) * dim[0];

                            if (nn != calculatedIndex)
                            {
                                QAssert.Fail("next neighbourhood index is " + nn
                                             + " but should be " + calculatedIndex);
                            }
                        }

                        for (int n = 1; n < 7; ++n)
                        {
                            int nn = layout.neighbourhood(iter, 2, -n);
                            int calculatedIndex = k + l * dim[0]
                                                  + ((m < n) ? n - m : m - n) * dim[0] * dim[1];
                            if (nn != calculatedIndex)
                            {
                                QAssert.Fail("next neighbourhood index is " + nn
                                             + " but should be " + calculatedIndex);
                            }
                        }
                    }
                }
            }
        }
Пример #2
0
        public void testDerivativeWeightsOnNonUniformGrids()
        {
            Fdm1dMesher mesherX =
                new Concentrating1dMesher(-2.0, 3.0, 50, new Pair <double?, double?>(0.5, 0.01));
            Fdm1dMesher mesherY =
                new Concentrating1dMesher(0.5, 5.0, 25, new Pair <double?, double?>(0.5, 0.1));
            Fdm1dMesher mesherZ =
                new Concentrating1dMesher(-1.0, 2.0, 31, new Pair <double?, double?>(1.5, 0.01));

            FdmMesher meshers =
                new FdmMesherComposite(mesherX, mesherY, mesherZ);

            FdmLinearOpLayout   layout  = meshers.layout();
            FdmLinearOpIterator endIter = layout.end();

            double tol = 1e-13;

            for (int direction = 0; direction < 3; ++direction)
            {
                SparseMatrix dfdx
                    = new FirstDerivativeOp(direction, meshers).toMatrix();
                SparseMatrix d2fdx2
                    = new SecondDerivativeOp(direction, meshers).toMatrix();

                Vector gridPoints = meshers.locations(direction);

                for (FdmLinearOpIterator iter = layout.begin();
                     iter != endIter; ++iter)
                {
                    int c       = iter.coordinates()[direction];
                    int index   = iter.index();
                    int indexM1 = layout.neighbourhood(iter, direction, -1);
                    int indexP1 = layout.neighbourhood(iter, direction, +1);

                    // test only if not on the boundary
                    if (c == 0)
                    {
                        Vector twoPoints = new Vector(2);
                        twoPoints[0] = 0.0;
                        twoPoints[1] = gridPoints[indexP1] - gridPoints[index];

                        Vector ndWeights1st = new NumericalDifferentiation(x => x, 1, twoPoints).weights();

                        double beta1  = dfdx[index, index];
                        double gamma1 = dfdx[index, indexP1];
                        if (Math.Abs((beta1 - ndWeights1st[0]) / beta1) > tol ||
                            Math.Abs((gamma1 - ndWeights1st[1]) / gamma1) > tol)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "first order derivative operator "
                                         + "on the lower boundary"
                                         + "\n expected beta:    " + ndWeights1st[0]
                                         + "\n calculated beta:  " + beta1
                                         + "\n difference beta:  "
                                         + (beta1 - ndWeights1st[0])
                                         + "\n expected gamma:   " + ndWeights1st[1]
                                         + "\n calculated gamma: " + gamma1
                                         + "\n difference gamma: "
                                         + (gamma1 - ndWeights1st[1]));
                        }

                        // free boundary condition by default
                        double beta2  = d2fdx2[index, index];
                        double gamma2 = d2fdx2[index, indexP1];

                        if (Math.Abs(beta2) > Const.QL_EPSILON ||
                            Math.Abs(gamma2) > Const.QL_EPSILON)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "second order derivative operator "
                                         + "on the lower boundary"
                                         + "\n expected beta:    " + 0.0
                                         + "\n calculated beta:  " + beta2
                                         + "\n expected gamma:   " + 0.0
                                         + "\n calculated gamma: " + gamma2);
                        }
                    }
                    else if (c == layout.dim()[direction] - 1)
                    {
                        Vector twoPoints = new Vector(2);
                        twoPoints[0] = gridPoints[indexM1] - gridPoints[index];
                        twoPoints[1] = 0.0;

                        Vector ndWeights1st = new NumericalDifferentiation(x => x, 1, twoPoints).weights();

                        double alpha1 = dfdx[index, indexM1];
                        double beta1  = dfdx[index, index];
                        if (Math.Abs((alpha1 - ndWeights1st[0]) / alpha1) > tol ||
                            Math.Abs((beta1 - ndWeights1st[1]) / beta1) > tol)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "first order derivative operator "
                                         + "on the upper boundary"
                                         + "\n expected alpha:   " + ndWeights1st[0]
                                         + "\n calculated alpha: " + alpha1
                                         + "\n difference alpha: "
                                         + (alpha1 - ndWeights1st[0])
                                         + "\n expected beta:    " + ndWeights1st[1]
                                         + "\n calculated beta:  " + beta1
                                         + "\n difference beta:  "
                                         + (beta1 - ndWeights1st[1]));
                        }

                        // free boundary condition by default
                        double alpha2 = d2fdx2[index, indexM1];
                        double beta2  = d2fdx2[index, index];

                        if (Math.Abs(alpha2) > Const.QL_EPSILON ||
                            Math.Abs(beta2) > Const.QL_EPSILON)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "second order derivative operator "
                                         + "on the upper boundary"
                                         + "\n expected alpha:   " + 0.0
                                         + "\n calculated alpha: " + alpha2
                                         + "\n expected beta:    " + 0.0
                                         + "\n calculated beta:  " + beta2);
                        }
                    }
                    else
                    {
                        Vector threePoints = new Vector(3);
                        threePoints[0] = gridPoints[indexM1] - gridPoints[index];
                        threePoints[1] = 0.0;
                        threePoints[2] = gridPoints[indexP1] - gridPoints[index];

                        Vector ndWeights1st = new NumericalDifferentiation(x => x, 1, threePoints).weights();

                        double alpha1 = dfdx[index, indexM1];
                        double beta1  = dfdx[index, index];
                        double gamma1 = dfdx[index, indexP1];

                        if (Math.Abs((alpha1 - ndWeights1st[0]) / alpha1) > tol ||
                            Math.Abs((beta1 - ndWeights1st[1]) / beta1) > tol ||
                            Math.Abs((gamma1 - ndWeights1st[2]) / gamma1) > tol)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "first order derivative operator"
                                         + "\n expected alpha:   " + ndWeights1st[0]
                                         + "\n calculated alpha: " + alpha1
                                         + "\n difference alpha: "
                                         + (alpha1 - ndWeights1st[0])
                                         + "\n expected beta:    " + ndWeights1st[1]
                                         + "\n calculated beta:  " + beta1
                                         + "\n difference beta:  "
                                         + (beta1 - ndWeights1st[1])
                                         + "\n expected gamma:   " + ndWeights1st[2]
                                         + "\n calculated gamma: " + gamma1
                                         + "\n difference gamma: "
                                         + (gamma1 - ndWeights1st[2]));
                        }

                        Vector ndWeights2nd = new NumericalDifferentiation(x => x, 2, threePoints).weights();

                        double alpha2 = d2fdx2[index, indexM1];
                        double beta2  = d2fdx2[index, index];
                        double gamma2 = d2fdx2[index, indexP1];
                        if (Math.Abs((alpha2 - ndWeights2nd[0]) / alpha2) > tol ||
                            Math.Abs((beta2 - ndWeights2nd[1]) / beta2) > tol ||
                            Math.Abs((gamma2 - ndWeights2nd[2]) / gamma2) > tol)
                        {
                            QAssert.Fail("can not reproduce the weights of the "
                                         + "second order derivative operator"
                                         + "\n expected alpha:   " + ndWeights2nd[0]
                                         + "\n calculated alpha: " + alpha2
                                         + "\n difference alpha: "
                                         + (alpha2 - ndWeights2nd[0])
                                         + "\n expected beta:    " + ndWeights2nd[1]
                                         + "\n calculated beta:  " + beta2
                                         + "\n difference beta:  "
                                         + (beta2 - ndWeights2nd[1])
                                         + "\n expected gamma:   " + ndWeights2nd[2]
                                         + "\n calculated gamma: " + gamma2
                                         + "\n difference gamma: "
                                         + (gamma2 - ndWeights2nd[2]));
                        }
                    }
                }
            }
        }