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