Actual source code: ex1.c
1: static char help[] = "Tests 1D discretization tools.\n\n";
3: #include <petscdt.h>
4: #include <petsc/private/petscimpl.h>
5: #include <petsc/private/dtimpl.h>
7: static PetscErrorCode CheckPoints(const char *name, PetscInt npoints, const PetscReal *points, PetscInt ndegrees, const PetscInt *degrees)
8: {
9: PetscReal *B, *D, *D2;
10: PetscInt i, j;
12: PetscFunctionBegin;
13: PetscCall(PetscMalloc3(npoints * ndegrees, &B, npoints * ndegrees, &D, npoints * ndegrees, &D2));
14: PetscCall(PetscDTLegendreEval(npoints, points, ndegrees, degrees, B, D, D2));
15: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "%s\n", name));
16: for (i = 0; i < npoints; i++) {
17: for (j = 0; j < ndegrees; j++) {
18: PetscReal b, d, d2;
19: b = B[i * ndegrees + j];
20: d = D[i * ndegrees + j];
21: d2 = D2[i * ndegrees + j];
22: if (PetscAbsReal(b) < PETSC_SMALL) b = 0;
23: if (PetscAbsReal(d) < PETSC_SMALL) d = 0;
24: if (PetscAbsReal(d2) < PETSC_SMALL) d2 = 0;
25: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "degree %" PetscInt_FMT " at %12.4g: B=%12.4g D=%12.4g D2=%12.4g\n", degrees[j], (double)points[i], (double)b, (double)d, (double)d2));
26: }
27: }
28: PetscCall(PetscFree3(B, D, D2));
29: PetscFunctionReturn(PETSC_SUCCESS);
30: }
32: typedef PetscErrorCode (*quadratureFunc)(PetscInt, PetscReal, PetscReal, PetscReal, PetscReal, PetscReal[], PetscReal[]);
34: static PetscErrorCode CheckQuadrature_Basics(PetscInt npoints, PetscReal alpha, PetscReal beta, const PetscReal x[], const PetscReal w[])
35: {
36: PetscInt i;
38: PetscFunctionBegin;
39: for (i = 1; i < npoints; i++) {
40: PetscCheck(x[i] > x[i - 1], PETSC_COMM_SELF, PETSC_ERR_PLIB, "Quadrature points not monotonically increasing, %" PetscInt_FMT " points, alpha = %g, beta = %g, i = %" PetscInt_FMT ", x[i] = %g, x[i-1] = %g", npoints, (double)alpha, (double)beta, i, (double)x[i], (double)x[i - 1]);
41: }
42: for (i = 0; i < npoints; i++) {
43: PetscCheck(w[i] > 0., PETSC_COMM_SELF, PETSC_ERR_PLIB, "Quadrature weight not positive, %" PetscInt_FMT " points, alpha = %g, beta = %g, i = %" PetscInt_FMT ", w[i] = %g", npoints, (double)alpha, (double)beta, i, (double)w[i]);
44: }
45: PetscFunctionReturn(PETSC_SUCCESS);
46: }
48: static PetscErrorCode CheckQuadrature(PetscInt npoints, PetscReal alpha, PetscReal beta, const PetscReal x[], const PetscReal w[], PetscInt nexact)
49: {
50: PetscInt i, j, k;
51: PetscReal *Pi, *Pj;
52: PetscReal eps;
54: PetscFunctionBegin;
55: eps = PETSC_SMALL;
56: PetscCall(PetscMalloc2(npoints, &Pi, npoints, &Pj));
57: for (i = 0; i <= nexact; i++) {
58: PetscCall(PetscDTJacobiEval(npoints, alpha, beta, x, 1, &i, Pi, NULL, NULL));
59: for (j = i; j <= nexact - i; j++) {
60: PetscReal I_quad = 0.;
61: PetscReal I_exact = 0.;
62: PetscReal err, tol;
63: PetscCall(PetscDTJacobiEval(npoints, alpha, beta, x, 1, &j, Pj, NULL, NULL));
65: tol = eps;
66: if (i == j) {
67: PetscReal norm, norm2diff;
69: I_exact = PetscPowReal(2.0, alpha + beta + 1.) / (2. * i + alpha + beta + 1.);
70: #if PetscDefined(HAVE_LGAMMA)
71: I_exact *= PetscExpReal(PetscLGamma(i + alpha + 1.) + PetscLGamma(i + beta + 1.) - (PetscLGamma(i + alpha + beta + 1.) + PetscLGamma(i + 1.)));
72: #else
73: {
74: PetscInt ibeta = (PetscInt)beta;
76: PetscCheck((PetscReal)ibeta == beta, PETSC_COMM_SELF, PETSC_ERR_SUP, "lgamma() - math routine is unavailable.");
77: for (k = 0; k < ibeta; k++) I_exact *= (i + 1. + k) / (i + alpha + 1. + k);
78: }
79: #endif
81: PetscCall(PetscDTJacobiNorm(alpha, beta, i, &norm));
82: norm2diff = PetscAbsReal(norm * norm - I_exact);
83: PetscCheck(norm2diff <= eps * I_exact, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Jacobi norm error %g", (double)norm2diff);
85: tol = eps * I_exact;
86: }
87: for (k = 0; k < npoints; k++) I_quad += w[k] * (Pi[k] * Pj[k]);
88: err = PetscAbsReal(I_exact - I_quad);
89: PetscCall(PetscInfo(NULL, "npoints %" PetscInt_FMT ", alpha %g, beta %g, i %" PetscInt_FMT ", j %" PetscInt_FMT ", exact %g, err %g\n", npoints, (double)alpha, (double)beta, i, j, (double)I_exact, (double)err));
90: PetscCheck(err <= tol, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Incorrectly integrated P_%" PetscInt_FMT " * P_%" PetscInt_FMT " using %" PetscInt_FMT " point rule with alpha = %g, beta = %g: exact %g, err %g", i, j, npoints, (double)alpha, (double)beta, (double)I_exact, (double)err);
91: }
92: }
93: PetscCall(PetscFree2(Pi, Pj));
94: PetscFunctionReturn(PETSC_SUCCESS);
95: }
97: static PetscErrorCode CheckJacobiQuadrature(PetscInt npoints, PetscReal alpha, PetscReal beta, quadratureFunc func, PetscInt nexact)
98: {
99: PetscReal *x, *w;
101: PetscFunctionBegin;
102: PetscCall(PetscMalloc2(npoints, &x, npoints, &w));
103: PetscCall((*func)(npoints, -1., 1., alpha, beta, x, w));
104: PetscCall(CheckQuadrature_Basics(npoints, alpha, beta, x, w));
105: PetscCall(CheckQuadrature(npoints, alpha, beta, x, w, nexact));
106: #if defined(PETSCDTGAUSSIANQUADRATURE_EIG)
107: /* compare methods of computing quadrature */
108: PetscDTGaussQuadratureNewton_Internal = (PetscBool)!PetscDTGaussQuadratureNewton_Internal;
109: {
110: PetscReal *x2, *w2;
111: PetscReal eps;
113: eps = PETSC_SMALL;
114: PetscCall(PetscMalloc2(npoints, &x2, npoints, &w2));
115: PetscCall((*func)(npoints, -1., 1., alpha, beta, x2, w2));
116: PetscCall(CheckQuadrature_Basics(npoints, alpha, beta, x2, w2));
117: PetscCall(CheckQuadrature(npoints, alpha, beta, x2, w2, nexact));
118: for (PetscInt i = 0; i < npoints; i++) {
119: PetscReal xdiff, xtol, wdiff, wtol;
121: xdiff = PetscAbsReal(x[i] - x2[i]);
122: wdiff = PetscAbsReal(w[i] - w2[i]);
123: xtol = eps * (1. + PetscMin(PetscAbsReal(x[i]), 1. - PetscAbsReal(x[i])));
124: wtol = eps * (1. + w[i]);
125: PetscCall(PetscInfo(NULL, "npoints %" PetscInt_FMT ", alpha %g, beta %g, i %" PetscInt_FMT ", xdiff/xtol %g, wdiff/wtol %g\n", npoints, (double)alpha, (double)beta, i, (double)(xdiff / xtol), (double)(wdiff / wtol)));
126: PetscCheck(xdiff <= xtol, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Mismatch quadrature point: %" PetscInt_FMT " points, alpha = %g, beta = %g, i = %" PetscInt_FMT ", xdiff = %g", npoints, (double)alpha, (double)beta, i, (double)xdiff);
127: PetscCheck(wdiff <= wtol, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Mismatch quadrature weight: %" PetscInt_FMT " points, alpha = %g, beta = %g, i = %" PetscInt_FMT ", wdiff = %g", npoints, (double)alpha, (double)beta, i, (double)wdiff);
128: }
129: PetscCall(PetscFree2(x2, w2));
130: }
131: /* restore */
132: PetscDTGaussQuadratureNewton_Internal = (PetscBool)!PetscDTGaussQuadratureNewton_Internal;
133: #endif
134: PetscCall(PetscFree2(x, w));
135: PetscFunctionReturn(PETSC_SUCCESS);
136: }
138: int main(int argc, char **argv)
139: {
140: PetscInt degrees[1000], ndegrees, npoints, two;
141: PetscReal points[1000], weights[1000], interval[2];
142: PetscInt minpoints, maxpoints;
143: PetscBool flg;
145: PetscFunctionBeginUser;
146: PetscCall(PetscInitialize(&argc, &argv, NULL, help));
147: PetscOptionsBegin(PETSC_COMM_WORLD, NULL, "Discretization tools test options", NULL);
148: {
149: ndegrees = 1000;
150: degrees[0] = 0;
151: degrees[1] = 1;
152: degrees[2] = 2;
153: PetscCall(PetscOptionsIntArray("-degrees", "list of degrees to evaluate", "", degrees, &ndegrees, &flg));
155: if (!flg) ndegrees = 3;
156: npoints = 1000;
157: points[0] = 0.0;
158: points[1] = -0.5;
159: points[2] = 1.0;
160: PetscCall(PetscOptionsRealArray("-points", "list of points at which to evaluate", "", points, &npoints, &flg));
162: if (!flg) npoints = 3;
163: two = 2;
164: interval[0] = -1.;
165: interval[1] = 1.;
166: PetscCall(PetscOptionsRealArray("-interval", "interval on which to construct quadrature", "", interval, &two, NULL));
168: minpoints = 1;
169: PetscCall(PetscOptionsInt("-minpoints", "minimum points for thorough Gauss-Jacobi quadrature tests", "", minpoints, &minpoints, NULL));
170: maxpoints = 30;
171: if (PetscDefined(USE_REAL_SINGLE)) maxpoints = 5;
172: else if (PetscDefined(USE_REAL___FLOAT128)) maxpoints = 20; /* just to make test faster */
173: PetscCall(PetscOptionsInt("-maxpoints", "maximum points for thorough Gauss-Jacobi quadrature tests", "", maxpoints, &maxpoints, NULL));
174: }
175: PetscOptionsEnd();
176: PetscCall(CheckPoints("User-provided points", npoints, points, ndegrees, degrees));
178: PetscCall(PetscDTGaussQuadrature(npoints, interval[0], interval[1], points, weights));
179: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Quadrature weights\n"));
180: PetscCall(PetscRealView(npoints, weights, PETSC_VIEWER_STDOUT_WORLD));
181: {
182: PetscReal a = interval[0], b = interval[1], zeroth, first, second;
184: zeroth = b - a;
185: first = (b * b - a * a) / 2;
186: second = (b * b * b - a * a * a) / 3;
187: for (PetscInt i = 0; i < npoints; i++) {
188: zeroth -= weights[i];
189: first -= weights[i] * points[i];
190: second -= weights[i] * PetscSqr(points[i]);
191: }
192: if (PetscAbs(zeroth) < 1e-10) zeroth = 0.;
193: if (PetscAbs(first) < 1e-10) first = 0.;
194: if (PetscAbs(second) < 1e-10) second = 0.;
195: PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Moment error: zeroth=%g, first=%g, second=%g\n", (double)(-zeroth), (double)(-first), (double)(-second)));
196: }
197: PetscCall(CheckPoints("Gauss points", npoints, points, ndegrees, degrees));
198: {
199: for (PetscInt i = minpoints; i <= maxpoints; i++) {
200: PetscReal a1, b1, a2, b2;
202: #if PetscDefined(HAVE_LGAMMA)
203: a1 = -0.6;
204: b1 = 1.1;
205: a2 = 2.2;
206: b2 = -0.6;
207: #else
208: a1 = 0.;
209: b1 = 1.;
210: a2 = 2.;
211: b2 = 0.;
212: #endif
213: PetscCall(CheckJacobiQuadrature(i, 0., 0., PetscDTGaussJacobiQuadrature, 2 * i - 1));
214: PetscCall(CheckJacobiQuadrature(i, a1, b1, PetscDTGaussJacobiQuadrature, 2 * i - 1));
215: PetscCall(CheckJacobiQuadrature(i, a2, b2, PetscDTGaussJacobiQuadrature, 2 * i - 1));
216: if (i >= 2) {
217: PetscCall(CheckJacobiQuadrature(i, 0., 0., PetscDTGaussLobattoJacobiQuadrature, 2 * i - 3));
218: PetscCall(CheckJacobiQuadrature(i, a1, b1, PetscDTGaussLobattoJacobiQuadrature, 2 * i - 3));
219: PetscCall(CheckJacobiQuadrature(i, a2, b2, PetscDTGaussLobattoJacobiQuadrature, 2 * i - 3));
220: }
221: }
222: }
223: PetscCall(PetscFinalize());
224: return 0;
225: }
227: /*TEST
228: test:
229: suffix: 1
230: args: -degrees 1,2,3,4,5 -points 0,.2,-.5,.8,.9,1 -interval -.5,1
231: TEST*/