Actual source code: rosw.c
1: /*
2: Code for timestepping with Rosenbrock W methods
4: Notes:
5: The general system is written as
7: F(t,U,Udot) = G(t,U)
9: where F represents the stiff part of the physics and G represents the non-stiff part.
10: This method is designed to be linearly implicit on F and can use an approximate and lagged Jacobian.
12: */
13: #include <petsc/private/tsimpl.h>
14: #include <petscdm.h>
16: #include <petsc/private/kernels/blockinvert.h>
18: static TSRosWType TSRosWDefault = TSROSWRA34PW2;
19: static PetscBool TSRosWRegisterAllCalled;
20: static PetscBool TSRosWPackageInitialized;
22: typedef struct _RosWTableau *RosWTableau;
23: struct _RosWTableau {
24: char *name;
25: PetscInt order; /* Classical approximation order of the method */
26: PetscInt s; /* Number of stages */
27: PetscInt pinterp; /* Interpolation order */
28: PetscReal *A; /* Propagation table, strictly lower triangular */
29: PetscReal *Gamma; /* Stage table, lower triangular with nonzero diagonal */
30: PetscBool *GammaZeroDiag; /* Diagonal entries that are zero in stage table Gamma, vector indicating explicit statages */
31: PetscReal *GammaExplicitCorr; /* Coefficients for correction terms needed for explicit stages in transformed variables*/
32: PetscReal *b; /* Step completion table */
33: PetscReal *bembed; /* Step completion table for embedded method of order one less */
34: PetscReal *ASum; /* Row sum of A */
35: PetscReal *GammaSum; /* Row sum of Gamma, only needed for non-autonomous systems */
36: PetscReal *At; /* Propagation table in transformed variables */
37: PetscReal *bt; /* Step completion table in transformed variables */
38: PetscReal *bembedt; /* Step completion table of order one less in transformed variables */
39: PetscReal *GammaInv; /* Inverse of Gamma, used for transformed variables */
40: PetscReal ccfl; /* Placeholder for CFL coefficient relative to forward Euler */
41: PetscReal *binterpt; /* Dense output formula */
42: };
43: typedef struct _RosWTableauLink *RosWTableauLink;
44: struct _RosWTableauLink {
45: struct _RosWTableau tab;
46: RosWTableauLink next;
47: };
48: static RosWTableauLink RosWTableauList;
50: typedef struct {
51: RosWTableau tableau;
52: Vec *Y; /* States computed during the step, used to complete the step */
53: Vec Ydot; /* Work vector holding Ydot during residual evaluation */
54: Vec Ystage; /* Work vector for the state value at each stage */
55: Vec Zdot; /* Ydot = Zdot + shift*Y */
56: Vec Zstage; /* Y = Zstage + Y */
57: Vec vec_sol_prev; /* Solution from the previous step (used for interpolation and rollback)*/
58: PetscScalar *work; /* Scalar work space of length number of stages, used to prepare VecMAXPY() */
59: PetscReal scoeff; /* shift = scoeff/dt */
60: PetscReal stage_time;
61: PetscReal stage_explicit; /* Flag indicates that the current stage is explicit */
62: PetscBool recompute_jacobian; /* Recompute the Jacobian at each stage, default is to freeze the Jacobian at the start of each step */
63: TSStepStatus status;
64: } TS_RosW;
66: /*MC
67: TSROSWTHETA1 - One stage first order L-stable Rosenbrock-W scheme (aka theta method).
69: Only an approximate Jacobian is needed.
71: Level: intermediate
73: .seealso: TSROSW
74: M*/
76: /*MC
77: TSROSWTHETA2 - One stage second order A-stable Rosenbrock-W scheme (aka theta method).
79: Only an approximate Jacobian is needed.
81: Level: intermediate
83: .seealso: TSROSW
84: M*/
86: /*MC
87: TSROSW2M - Two stage second order L-stable Rosenbrock-W scheme.
89: Only an approximate Jacobian is needed. By default, it is only recomputed once per step. This method is a reflection of TSROSW2P.
91: Level: intermediate
93: .seealso: TSROSW
94: M*/
96: /*MC
97: TSROSW2P - Two stage second order L-stable Rosenbrock-W scheme.
99: Only an approximate Jacobian is needed. By default, it is only recomputed once per step. This method is a reflection of TSROSW2M.
101: Level: intermediate
103: .seealso: TSROSW
104: M*/
106: /*MC
107: TSROSWRA3PW - Three stage third order Rosenbrock-W scheme for PDAE of index 1.
109: Only an approximate Jacobian is needed. By default, it is only recomputed once per step.
111: This is strongly A-stable with R(infty) = 0.73. The embedded method of order 2 is strongly A-stable with R(infty) = 0.73.
113: References:
114: . 1. - Rang and Angermann, New Rosenbrock W methods of order 3 for partial differential algebraic equations of index 1, 2005.
116: Level: intermediate
118: .seealso: TSROSW
119: M*/
121: /*MC
122: TSROSWRA34PW2 - Four stage third order L-stable Rosenbrock-W scheme for PDAE of index 1.
124: Only an approximate Jacobian is needed. By default, it is only recomputed once per step.
126: This is strongly A-stable with R(infty) = 0. The embedded method of order 2 is strongly A-stable with R(infty) = 0.48.
128: References:
129: . 1. - Rang and Angermann, New Rosenbrock W methods of order 3 for partial differential algebraic equations of index 1, 2005.
131: Level: intermediate
133: .seealso: TSROSW
134: M*/
136: /*MC
137: TSROSWRODAS3 - Four stage third order L-stable Rosenbrock scheme
139: By default, the Jacobian is only recomputed once per step.
141: Both the third order and embedded second order methods are stiffly accurate and L-stable.
143: References:
144: . 1. - Sandu et al, Benchmarking stiff ODE solvers for atmospheric chemistry problems II, Rosenbrock solvers, 1997.
146: Level: intermediate
148: .seealso: TSROSW, TSROSWSANDU3
149: M*/
151: /*MC
152: TSROSWSANDU3 - Three stage third order L-stable Rosenbrock scheme
154: By default, the Jacobian is only recomputed once per step.
156: The third order method is L-stable, but not stiffly accurate.
157: The second order embedded method is strongly A-stable with R(infty) = 0.5.
158: The internal stages are L-stable.
159: This method is called ROS3 in the paper.
161: References:
162: . 1. - Sandu et al, Benchmarking stiff ODE solvers for atmospheric chemistry problems II, Rosenbrock solvers, 1997.
164: Level: intermediate
166: .seealso: TSROSW, TSROSWRODAS3
167: M*/
169: /*MC
170: TSROSWASSP3P3S1C - A-stable Rosenbrock-W method with SSP explicit part, third order, three stages
172: By default, the Jacobian is only recomputed once per step.
174: A-stable SPP explicit order 3, 3 stages, CFL 1 (eff = 1/3)
176: References:
177: . Emil Constantinescu
179: Level: intermediate
181: .seealso: TSROSW, TSROSWLASSP3P4S2C, TSROSWLLSSP3P4S2C, SSP
182: M*/
184: /*MC
185: TSROSWLASSP3P4S2C - L-stable Rosenbrock-W method with SSP explicit part, third order, four stages
187: By default, the Jacobian is only recomputed once per step.
189: L-stable (A-stable embedded) SPP explicit order 3, 4 stages, CFL 2 (eff = 1/2)
191: References:
192: . Emil Constantinescu
194: Level: intermediate
196: .seealso: TSROSW, TSROSWASSP3P3S1C, TSROSWLLSSP3P4S2C, TSSSP
197: M*/
199: /*MC
200: TSROSWLLSSP3P4S2C - L-stable Rosenbrock-W method with SSP explicit part, third order, four stages
202: By default, the Jacobian is only recomputed once per step.
204: L-stable (L-stable embedded) SPP explicit order 3, 4 stages, CFL 2 (eff = 1/2)
206: References:
207: . Emil Constantinescu
209: Level: intermediate
211: .seealso: TSROSW, TSROSWASSP3P3S1C, TSROSWLASSP3P4S2C, TSSSP
212: M*/
214: /*MC
215: TSROSWGRK4T - four stage, fourth order Rosenbrock (not W) method from Kaps and Rentrop
217: By default, the Jacobian is only recomputed once per step.
219: A(89.3 degrees)-stable, |R(infty)| = 0.454.
221: This method does not provide a dense output formula.
223: References:
224: + 1. - Kaps and Rentrop, Generalized Runge Kutta methods of order four with stepsize control for stiff ordinary differential equations, 1979.
225: - 2. - Hairer and Wanner, Solving Ordinary Differential Equations II, Section 4 Table 7.2.
227: Hairer's code ros4.f
229: Level: intermediate
231: .seealso: TSROSW, TSROSWSHAMP4, TSROSWVELDD4, TSROSW4L
232: M*/
234: /*MC
235: TSROSWSHAMP4 - four stage, fourth order Rosenbrock (not W) method from Shampine
237: By default, the Jacobian is only recomputed once per step.
239: A-stable, |R(infty)| = 1/3.
241: This method does not provide a dense output formula.
243: References:
244: + 1. - Shampine, Implementation of Rosenbrock methods, 1982.
245: - 2. - Hairer and Wanner, Solving Ordinary Differential Equations II, Section 4 Table 7.2.
247: Hairer's code ros4.f
249: Level: intermediate
251: .seealso: TSROSW, TSROSWGRK4T, TSROSWVELDD4, TSROSW4L
252: M*/
254: /*MC
255: TSROSWVELDD4 - four stage, fourth order Rosenbrock (not W) method from van Veldhuizen
257: By default, the Jacobian is only recomputed once per step.
259: A(89.5 degrees)-stable, |R(infty)| = 0.24.
261: This method does not provide a dense output formula.
263: References:
264: + 1. - van Veldhuizen, D stability and Kaps Rentrop methods, 1984.
265: - 2. - Hairer and Wanner, Solving Ordinary Differential Equations II, Section 4 Table 7.2.
267: Hairer's code ros4.f
269: Level: intermediate
271: .seealso: TSROSW, TSROSWGRK4T, TSROSWSHAMP4, TSROSW4L
272: M*/
274: /*MC
275: TSROSW4L - four stage, fourth order Rosenbrock (not W) method
277: By default, the Jacobian is only recomputed once per step.
279: A-stable and L-stable
281: This method does not provide a dense output formula.
283: References:
284: . 1. - Hairer and Wanner, Solving Ordinary Differential Equations II, Section 4 Table 7.2.
286: Hairer's code ros4.f
288: Level: intermediate
290: .seealso: TSROSW, TSROSWGRK4T, TSROSWSHAMP4, TSROSW4L
291: M*/
293: /*@C
294: TSRosWRegisterAll - Registers all of the Rosenbrock-W methods in TSRosW
296: Not Collective, but should be called by all processes which will need the schemes to be registered
298: Level: advanced
300: .seealso: TSRosWRegisterDestroy()
301: @*/
302: PetscErrorCode TSRosWRegisterAll(void)
303: {
307: if (TSRosWRegisterAllCalled) return(0);
308: TSRosWRegisterAllCalled = PETSC_TRUE;
310: {
311: const PetscReal A = 0;
312: const PetscReal Gamma = 1;
313: const PetscReal b = 1;
314: const PetscReal binterpt=1;
316: TSRosWRegister(TSROSWTHETA1,1,1,&A,&Gamma,&b,NULL,1,&binterpt);
317: }
319: {
320: const PetscReal A = 0;
321: const PetscReal Gamma = 0.5;
322: const PetscReal b = 1;
323: const PetscReal binterpt=1;
325: TSRosWRegister(TSROSWTHETA2,2,1,&A,&Gamma,&b,NULL,1,&binterpt);
326: }
328: {
329: /*const PetscReal g = 1. + 1./PetscSqrtReal(2.0); Direct evaluation: 1.707106781186547524401. Used for setting up arrays of values known at compile time below. */
330: const PetscReal
331: A[2][2] = {{0,0}, {1.,0}},
332: Gamma[2][2] = {{1.707106781186547524401,0}, {-2.*1.707106781186547524401,1.707106781186547524401}},
333: b[2] = {0.5,0.5},
334: b1[2] = {1.0,0.0};
335: PetscReal binterpt[2][2];
336: binterpt[0][0] = 1.707106781186547524401 - 1.0;
337: binterpt[1][0] = 2.0 - 1.707106781186547524401;
338: binterpt[0][1] = 1.707106781186547524401 - 1.5;
339: binterpt[1][1] = 1.5 - 1.707106781186547524401;
341: TSRosWRegister(TSROSW2P,2,2,&A[0][0],&Gamma[0][0],b,b1,2,&binterpt[0][0]);
342: }
343: {
344: /*const PetscReal g = 1. - 1./PetscSqrtReal(2.0); Direct evaluation: 0.2928932188134524755992. Used for setting up arrays of values known at compile time below. */
345: const PetscReal
346: A[2][2] = {{0,0}, {1.,0}},
347: Gamma[2][2] = {{0.2928932188134524755992,0}, {-2.*0.2928932188134524755992,0.2928932188134524755992}},
348: b[2] = {0.5,0.5},
349: b1[2] = {1.0,0.0};
350: PetscReal binterpt[2][2];
351: binterpt[0][0] = 0.2928932188134524755992 - 1.0;
352: binterpt[1][0] = 2.0 - 0.2928932188134524755992;
353: binterpt[0][1] = 0.2928932188134524755992 - 1.5;
354: binterpt[1][1] = 1.5 - 0.2928932188134524755992;
356: TSRosWRegister(TSROSW2M,2,2,&A[0][0],&Gamma[0][0],b,b1,2,&binterpt[0][0]);
357: }
358: {
359: /*const PetscReal g = 7.8867513459481287e-01; Directly written in-place below */
360: PetscReal binterpt[3][2];
361: const PetscReal
362: A[3][3] = {{0,0,0},
363: {1.5773502691896257e+00,0,0},
364: {0.5,0,0}},
365: Gamma[3][3] = {{7.8867513459481287e-01,0,0},
366: {-1.5773502691896257e+00,7.8867513459481287e-01,0},
367: {-6.7075317547305480e-01,-1.7075317547305482e-01,7.8867513459481287e-01}},
368: b[3] = {1.0566243270259355e-01,4.9038105676657971e-02,8.4529946162074843e-01},
369: b2[3] = {-1.7863279495408180e-01,1./3.,8.4529946162074843e-01};
371: binterpt[0][0] = -0.8094010767585034;
372: binterpt[1][0] = -0.5;
373: binterpt[2][0] = 2.3094010767585034;
374: binterpt[0][1] = 0.9641016151377548;
375: binterpt[1][1] = 0.5;
376: binterpt[2][1] = -1.4641016151377548;
378: TSRosWRegister(TSROSWRA3PW,3,3,&A[0][0],&Gamma[0][0],b,b2,2,&binterpt[0][0]);
379: }
380: {
381: PetscReal binterpt[4][3];
382: /*const PetscReal g = 4.3586652150845900e-01; Directly written in-place below */
383: const PetscReal
384: A[4][4] = {{0,0,0,0},
385: {8.7173304301691801e-01,0,0,0},
386: {8.4457060015369423e-01,-1.1299064236484185e-01,0,0},
387: {0,0,1.,0}},
388: Gamma[4][4] = {{4.3586652150845900e-01,0,0,0},
389: {-8.7173304301691801e-01,4.3586652150845900e-01,0,0},
390: {-9.0338057013044082e-01,5.4180672388095326e-02,4.3586652150845900e-01,0},
391: {2.4212380706095346e-01,-1.2232505839045147e+00,5.4526025533510214e-01,4.3586652150845900e-01}},
392: b[4] = {2.4212380706095346e-01,-1.2232505839045147e+00,1.5452602553351020e+00,4.3586652150845900e-01},
393: b2[4] = {3.7810903145819369e-01,-9.6042292212423178e-02,5.0000000000000000e-01,2.1793326075422950e-01};
395: binterpt[0][0]=1.0564298455794094;
396: binterpt[1][0]=2.296429974281067;
397: binterpt[2][0]=-1.307599564525376;
398: binterpt[3][0]=-1.045260255335102;
399: binterpt[0][1]=-1.3864882699759573;
400: binterpt[1][1]=-8.262611700275677;
401: binterpt[2][1]=7.250979895056055;
402: binterpt[3][1]=2.398120075195581;
403: binterpt[0][2]=0.5721822314575016;
404: binterpt[1][2]=4.742931142090097;
405: binterpt[2][2]=-4.398120075195578;
406: binterpt[3][2]=-0.9169932983520199;
408: TSRosWRegister(TSROSWRA34PW2,3,4,&A[0][0],&Gamma[0][0],b,b2,3,&binterpt[0][0]);
409: }
410: {
411: /* const PetscReal g = 0.5; Directly written in-place below */
412: const PetscReal
413: A[4][4] = {{0,0,0,0},
414: {0,0,0,0},
415: {1.,0,0,0},
416: {0.75,-0.25,0.5,0}},
417: Gamma[4][4] = {{0.5,0,0,0},
418: {1.,0.5,0,0},
419: {-0.25,-0.25,0.5,0},
420: {1./12,1./12,-2./3,0.5}},
421: b[4] = {5./6,-1./6,-1./6,0.5},
422: b2[4] = {0.75,-0.25,0.5,0};
424: TSRosWRegister(TSROSWRODAS3,3,4,&A[0][0],&Gamma[0][0],b,b2,0,NULL);
425: }
426: {
427: /*const PetscReal g = 0.43586652150845899941601945119356; Directly written in-place below */
428: const PetscReal
429: A[3][3] = {{0,0,0},
430: {0.43586652150845899941601945119356,0,0},
431: {0.43586652150845899941601945119356,0,0}},
432: Gamma[3][3] = {{0.43586652150845899941601945119356,0,0},
433: {-0.19294655696029095575009695436041,0.43586652150845899941601945119356,0},
434: {0,1.74927148125794685173529749738960,0.43586652150845899941601945119356}},
435: b[3] = {-0.75457412385404315829818998646589,1.94100407061964420292840123379419,-0.18642994676560104463021124732829},
436: b2[3] = {-1.53358745784149585370766523913002,2.81745131148625772213931745457622,-0.28386385364476186843165221544619};
438: PetscReal binterpt[3][2];
439: binterpt[0][0] = 3.793692883777660870425141387941;
440: binterpt[1][0] = -2.918692883777660870425141387941;
441: binterpt[2][0] = 0.125;
442: binterpt[0][1] = -0.725741064379812106687651020584;
443: binterpt[1][1] = 0.559074397713145440020984353917;
444: binterpt[2][1] = 0.16666666666666666666666666666667;
446: TSRosWRegister(TSROSWSANDU3,3,3,&A[0][0],&Gamma[0][0],b,b2,2,&binterpt[0][0]);
447: }
448: {
449: /*const PetscReal s3 = PetscSqrtReal(3.),g = (3.0+s3)/6.0;
450: * Direct evaluation: s3 = 1.732050807568877293527;
451: * g = 0.7886751345948128822546;
452: * Values are directly inserted below to ensure availability at compile time (compiler warnings otherwise...) */
453: const PetscReal
454: A[3][3] = {{0,0,0},
455: {1,0,0},
456: {0.25,0.25,0}},
457: Gamma[3][3] = {{0,0,0},
458: {(-3.0-1.732050807568877293527)/6.0,0.7886751345948128822546,0},
459: {(-3.0-1.732050807568877293527)/24.0,(-3.0-1.732050807568877293527)/8.0,0.7886751345948128822546}},
460: b[3] = {1./6.,1./6.,2./3.},
461: b2[3] = {1./4.,1./4.,1./2.};
462: PetscReal binterpt[3][2];
464: binterpt[0][0]=0.089316397477040902157517886164709;
465: binterpt[1][0]=-0.91068360252295909784248211383529;
466: binterpt[2][0]=1.8213672050459181956849642276706;
467: binterpt[0][1]=0.077350269189625764509148780501957;
468: binterpt[1][1]=1.077350269189625764509148780502;
469: binterpt[2][1]=-1.1547005383792515290182975610039;
471: TSRosWRegister(TSROSWASSP3P3S1C,3,3,&A[0][0],&Gamma[0][0],b,b2,2,&binterpt[0][0]);
472: }
474: {
475: const PetscReal
476: A[4][4] = {{0,0,0,0},
477: {1./2.,0,0,0},
478: {1./2.,1./2.,0,0},
479: {1./6.,1./6.,1./6.,0}},
480: Gamma[4][4] = {{1./2.,0,0,0},
481: {0.0,1./4.,0,0},
482: {-2.,-2./3.,2./3.,0},
483: {1./2.,5./36.,-2./9,0}},
484: b[4] = {1./6.,1./6.,1./6.,1./2.},
485: b2[4] = {1./8.,3./4.,1./8.,0};
486: PetscReal binterpt[4][3];
488: binterpt[0][0]=6.25;
489: binterpt[1][0]=-30.25;
490: binterpt[2][0]=1.75;
491: binterpt[3][0]=23.25;
492: binterpt[0][1]=-9.75;
493: binterpt[1][1]=58.75;
494: binterpt[2][1]=-3.25;
495: binterpt[3][1]=-45.75;
496: binterpt[0][2]=3.6666666666666666666666666666667;
497: binterpt[1][2]=-28.333333333333333333333333333333;
498: binterpt[2][2]=1.6666666666666666666666666666667;
499: binterpt[3][2]=23.;
501: TSRosWRegister(TSROSWLASSP3P4S2C,3,4,&A[0][0],&Gamma[0][0],b,b2,3,&binterpt[0][0]);
502: }
504: {
505: const PetscReal
506: A[4][4] = {{0,0,0,0},
507: {1./2.,0,0,0},
508: {1./2.,1./2.,0,0},
509: {1./6.,1./6.,1./6.,0}},
510: Gamma[4][4] = {{1./2.,0,0,0},
511: {0.0,3./4.,0,0},
512: {-2./3.,-23./9.,2./9.,0},
513: {1./18.,65./108.,-2./27,0}},
514: b[4] = {1./6.,1./6.,1./6.,1./2.},
515: b2[4] = {3./16.,10./16.,3./16.,0};
516: PetscReal binterpt[4][3];
518: binterpt[0][0]=1.6911764705882352941176470588235;
519: binterpt[1][0]=3.6813725490196078431372549019608;
520: binterpt[2][0]=0.23039215686274509803921568627451;
521: binterpt[3][0]=-4.6029411764705882352941176470588;
522: binterpt[0][1]=-0.95588235294117647058823529411765;
523: binterpt[1][1]=-6.2401960784313725490196078431373;
524: binterpt[2][1]=-0.31862745098039215686274509803922;
525: binterpt[3][1]=7.5147058823529411764705882352941;
526: binterpt[0][2]=-0.56862745098039215686274509803922;
527: binterpt[1][2]=2.7254901960784313725490196078431;
528: binterpt[2][2]=0.25490196078431372549019607843137;
529: binterpt[3][2]=-2.4117647058823529411764705882353;
531: TSRosWRegister(TSROSWLLSSP3P4S2C,3,4,&A[0][0],&Gamma[0][0],b,b2,3,&binterpt[0][0]);
532: }
534: {
535: PetscReal A[4][4],Gamma[4][4],b[4],b2[4];
536: PetscReal binterpt[4][3];
538: Gamma[0][0]=0.4358665215084589994160194475295062513822671686978816;
539: Gamma[0][1]=0; Gamma[0][2]=0; Gamma[0][3]=0;
540: Gamma[1][0]=-1.997527830934941248426324674704153457289527280554476;
541: Gamma[1][1]=0.4358665215084589994160194475295062513822671686978816;
542: Gamma[1][2]=0; Gamma[1][3]=0;
543: Gamma[2][0]=-1.007948511795029620852002345345404191008352770119903;
544: Gamma[2][1]=-0.004648958462629345562774289390054679806993396798458131;
545: Gamma[2][2]=0.4358665215084589994160194475295062513822671686978816;
546: Gamma[2][3]=0;
547: Gamma[3][0]=-0.6685429734233467180451604600279552604364311322650783;
548: Gamma[3][1]=0.6056625986449338476089525334450053439525178740492984;
549: Gamma[3][2]=-0.9717899277217721234705114616271378792182450260943198;
550: Gamma[3][3]=0;
552: A[0][0]=0; A[0][1]=0; A[0][2]=0; A[0][3]=0;
553: A[1][0]=0.8717330430169179988320388950590125027645343373957631;
554: A[1][1]=0; A[1][2]=0; A[1][3]=0;
555: A[2][0]=0.5275890119763004115618079766722914408876108660811028;
556: A[2][1]=0.07241098802369958843819203208518599088698057726988732;
557: A[2][2]=0; A[2][3]=0;
558: A[3][0]=0.3990960076760701320627260685975778145384666450351314;
559: A[3][1]=-0.4375576546135194437228463747348862825846903771419953;
560: A[3][2]=1.038461646937449311660120300601880176655352737312713;
561: A[3][3]=0;
563: b[0]=0.1876410243467238251612921333138006734899663569186926;
564: b[1]=-0.5952974735769549480478230473706443582188442040780541;
565: b[2]=0.9717899277217721234705114616271378792182450260943198;
566: b[3]=0.4358665215084589994160194475295062513822671686978816;
568: b2[0]=0.2147402862233891404862383521089097657790734483804460;
569: b2[1]=-0.4851622638849390928209050538171743017757490232519684;
570: b2[2]=0.8687250025203875511662123688667549217531982787600080;
571: b2[3]=0.4016969751411624011684543450940068201770721128357014;
573: binterpt[0][0]=2.2565812720167954547104627844105;
574: binterpt[1][0]=1.349166413351089573796243820819;
575: binterpt[2][0]=-2.4695174540533503758652847586647;
576: binterpt[3][0]=-0.13623023131453465264142184656474;
577: binterpt[0][1]=-3.0826699111559187902922463354557;
578: binterpt[1][1]=-2.4689115685996042534544925650515;
579: binterpt[2][1]=5.7428279814696677152129332773553;
580: binterpt[3][1]=-0.19124650171414467146619437684812;
581: binterpt[0][2]=1.0137296634858471607430756831148;
582: binterpt[1][2]=0.52444768167155973161042570784064;
583: binterpt[2][2]=-2.3015205996945452158771370439586;
584: binterpt[3][2]=0.76334325453713832352363565300308;
586: TSRosWRegister(TSROSWARK3,3,4,&A[0][0],&Gamma[0][0],b,b2,3,&binterpt[0][0]);
587: }
588: TSRosWRegisterRos4(TSROSWGRK4T,0.231,PETSC_DEFAULT,PETSC_DEFAULT,0,-0.1282612945269037e+01);
589: TSRosWRegisterRos4(TSROSWSHAMP4,0.5,PETSC_DEFAULT,PETSC_DEFAULT,0,125./108.);
590: TSRosWRegisterRos4(TSROSWVELDD4,0.22570811482256823492,PETSC_DEFAULT,PETSC_DEFAULT,0,-1.355958941201148);
591: TSRosWRegisterRos4(TSROSW4L,0.57282,PETSC_DEFAULT,PETSC_DEFAULT,0,-1.093502252409163);
592: return(0);
593: }
597: /*@C
598: TSRosWRegisterDestroy - Frees the list of schemes that were registered by TSRosWRegister().
600: Not Collective
602: Level: advanced
604: .seealso: TSRosWRegister(), TSRosWRegisterAll()
605: @*/
606: PetscErrorCode TSRosWRegisterDestroy(void)
607: {
608: PetscErrorCode ierr;
609: RosWTableauLink link;
612: while ((link = RosWTableauList)) {
613: RosWTableau t = &link->tab;
614: RosWTableauList = link->next;
615: PetscFree5(t->A,t->Gamma,t->b,t->ASum,t->GammaSum);
616: PetscFree5(t->At,t->bt,t->GammaInv,t->GammaZeroDiag,t->GammaExplicitCorr);
617: PetscFree2(t->bembed,t->bembedt);
618: PetscFree(t->binterpt);
619: PetscFree(t->name);
620: PetscFree(link);
621: }
622: TSRosWRegisterAllCalled = PETSC_FALSE;
623: return(0);
624: }
626: /*@C
627: TSRosWInitializePackage - This function initializes everything in the TSRosW package. It is called
628: from TSInitializePackage().
630: Level: developer
632: .seealso: PetscInitialize()
633: @*/
634: PetscErrorCode TSRosWInitializePackage(void)
635: {
639: if (TSRosWPackageInitialized) return(0);
640: TSRosWPackageInitialized = PETSC_TRUE;
641: TSRosWRegisterAll();
642: PetscRegisterFinalize(TSRosWFinalizePackage);
643: return(0);
644: }
646: /*@C
647: TSRosWFinalizePackage - This function destroys everything in the TSRosW package. It is
648: called from PetscFinalize().
650: Level: developer
652: .seealso: PetscFinalize()
653: @*/
654: PetscErrorCode TSRosWFinalizePackage(void)
655: {
659: TSRosWPackageInitialized = PETSC_FALSE;
660: TSRosWRegisterDestroy();
661: return(0);
662: }
664: /*@C
665: TSRosWRegister - register a Rosenbrock W scheme by providing the entries in the Butcher tableau and optionally embedded approximations and interpolation
667: Not Collective, but the same schemes should be registered on all processes on which they will be used
669: Input Parameters:
670: + name - identifier for method
671: . order - approximation order of method
672: . s - number of stages, this is the dimension of the matrices below
673: . A - Table of propagated stage coefficients (dimension s*s, row-major), strictly lower triangular
674: . Gamma - Table of coefficients in implicit stage equations (dimension s*s, row-major), lower triangular with nonzero diagonal
675: . b - Step completion table (dimension s)
676: . bembed - Step completion table for a scheme of order one less (dimension s, NULL if no embedded scheme is available)
677: . pinterp - Order of the interpolation scheme, equal to the number of columns of binterpt
678: - binterpt - Coefficients of the interpolation formula (dimension s*pinterp)
680: Notes:
681: Several Rosenbrock W methods are provided, this function is only needed to create new methods.
683: Level: advanced
685: .seealso: TSRosW
686: @*/
687: PetscErrorCode TSRosWRegister(TSRosWType name,PetscInt order,PetscInt s,const PetscReal A[],const PetscReal Gamma[],const PetscReal b[],const PetscReal bembed[],
688: PetscInt pinterp,const PetscReal binterpt[])
689: {
690: PetscErrorCode ierr;
691: RosWTableauLink link;
692: RosWTableau t;
693: PetscInt i,j,k;
694: PetscScalar *GammaInv;
703: TSRosWInitializePackage();
704: PetscNew(&link);
705: t = &link->tab;
706: PetscStrallocpy(name,&t->name);
707: t->order = order;
708: t->s = s;
709: PetscMalloc5(s*s,&t->A,s*s,&t->Gamma,s,&t->b,s,&t->ASum,s,&t->GammaSum);
710: PetscMalloc5(s*s,&t->At,s,&t->bt,s*s,&t->GammaInv,s,&t->GammaZeroDiag,s*s,&t->GammaExplicitCorr);
711: PetscArraycpy(t->A,A,s*s);
712: PetscArraycpy(t->Gamma,Gamma,s*s);
713: PetscArraycpy(t->GammaExplicitCorr,Gamma,s*s);
714: PetscArraycpy(t->b,b,s);
715: if (bembed) {
716: PetscMalloc2(s,&t->bembed,s,&t->bembedt);
717: PetscArraycpy(t->bembed,bembed,s);
718: }
719: for (i=0; i<s; i++) {
720: t->ASum[i] = 0;
721: t->GammaSum[i] = 0;
722: for (j=0; j<s; j++) {
723: t->ASum[i] += A[i*s+j];
724: t->GammaSum[i] += Gamma[i*s+j];
725: }
726: }
727: PetscMalloc1(s*s,&GammaInv); /* Need to use Scalar for inverse, then convert back to Real */
728: for (i=0; i<s*s; i++) GammaInv[i] = Gamma[i];
729: for (i=0; i<s; i++) {
730: if (Gamma[i*s+i] == 0.0) {
731: GammaInv[i*s+i] = 1.0;
732: t->GammaZeroDiag[i] = PETSC_TRUE;
733: } else {
734: t->GammaZeroDiag[i] = PETSC_FALSE;
735: }
736: }
738: switch (s) {
739: case 1: GammaInv[0] = 1./GammaInv[0]; break;
740: case 2: PetscKernel_A_gets_inverse_A_2(GammaInv,0,PETSC_FALSE,NULL); break;
741: case 3: PetscKernel_A_gets_inverse_A_3(GammaInv,0,PETSC_FALSE,NULL); break;
742: case 4: PetscKernel_A_gets_inverse_A_4(GammaInv,0,PETSC_FALSE,NULL); break;
743: case 5: {
744: PetscInt ipvt5[5];
745: MatScalar work5[5*5];
746: PetscKernel_A_gets_inverse_A_5(GammaInv,ipvt5,work5,0,PETSC_FALSE,NULL); break;
747: }
748: case 6: PetscKernel_A_gets_inverse_A_6(GammaInv,0,PETSC_FALSE,NULL); break;
749: case 7: PetscKernel_A_gets_inverse_A_7(GammaInv,0,PETSC_FALSE,NULL); break;
750: default: SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SUP,"Not implemented for %D stages",s);
751: }
752: for (i=0; i<s*s; i++) t->GammaInv[i] = PetscRealPart(GammaInv[i]);
753: PetscFree(GammaInv);
755: for (i=0; i<s; i++) {
756: for (k=0; k<i+1; k++) {
757: t->GammaExplicitCorr[i*s+k]=(t->GammaExplicitCorr[i*s+k])*(t->GammaInv[k*s+k]);
758: for (j=k+1; j<i+1; j++) {
759: t->GammaExplicitCorr[i*s+k]+=(t->GammaExplicitCorr[i*s+j])*(t->GammaInv[j*s+k]);
760: }
761: }
762: }
764: for (i=0; i<s; i++) {
765: for (j=0; j<s; j++) {
766: t->At[i*s+j] = 0;
767: for (k=0; k<s; k++) {
768: t->At[i*s+j] += t->A[i*s+k] * t->GammaInv[k*s+j];
769: }
770: }
771: t->bt[i] = 0;
772: for (j=0; j<s; j++) {
773: t->bt[i] += t->b[j] * t->GammaInv[j*s+i];
774: }
775: if (bembed) {
776: t->bembedt[i] = 0;
777: for (j=0; j<s; j++) {
778: t->bembedt[i] += t->bembed[j] * t->GammaInv[j*s+i];
779: }
780: }
781: }
782: t->ccfl = 1.0; /* Fix this */
784: t->pinterp = pinterp;
785: PetscMalloc1(s*pinterp,&t->binterpt);
786: PetscArraycpy(t->binterpt,binterpt,s*pinterp);
787: link->next = RosWTableauList;
788: RosWTableauList = link;
789: return(0);
790: }
792: /*@C
793: TSRosWRegisterRos4 - register a fourth order Rosenbrock scheme by providing parameter choices
795: Not Collective, but the same schemes should be registered on all processes on which they will be used
797: Input Parameters:
798: + name - identifier for method
799: . gamma - leading coefficient (diagonal entry)
800: . a2 - design parameter, see Table 7.2 of Hairer&Wanner
801: . a3 - design parameter or PETSC_DEFAULT to satisfy one of the order five conditions (Eq 7.22)
802: . b3 - design parameter, see Table 7.2 of Hairer&Wanner
803: . beta43 - design parameter or PETSC_DEFAULT to use Equation 7.21 of Hairer&Wanner
804: - e4 - design parameter for embedded method, see coefficient E4 in ros4.f code from Hairer
806: Notes:
807: This routine encodes the design of fourth order Rosenbrock methods as described in Hairer and Wanner volume 2.
808: It is used here to implement several methods from the book and can be used to experiment with new methods.
809: It was written this way instead of by copying coefficients in order to provide better than double precision satisfaction of the order conditions.
811: Level: developer
813: .seealso: TSRosW, TSRosWRegister()
814: @*/
815: PetscErrorCode TSRosWRegisterRos4(TSRosWType name,PetscReal gamma,PetscReal a2,PetscReal a3,PetscReal b3,PetscReal e4)
816: {
818: /* Declare numeric constants so they can be quad precision without being truncated at double */
819: const PetscReal one = 1,two = 2,three = 3,four = 4,five = 5,six = 6,eight = 8,twelve = 12,twenty = 20,twentyfour = 24,
820: p32 = one/six - gamma + gamma*gamma,
821: p42 = one/eight - gamma/three,
822: p43 = one/twelve - gamma/three,
823: p44 = one/twentyfour - gamma/two + three/two*gamma*gamma - gamma*gamma*gamma,
824: p56 = one/twenty - gamma/four;
825: PetscReal a4,a32,a42,a43,b1,b2,b4,beta2p,beta3p,beta4p,beta32,beta42,beta43,beta32beta2p,beta4jbetajp;
826: PetscReal A[4][4],Gamma[4][4],b[4],bm[4];
827: PetscScalar M[3][3],rhs[3];
830: /* Step 1: choose Gamma (input) */
831: /* Step 2: choose a2,a3,a4; b1,b2,b3,b4 to satisfy order conditions */
832: if (a3 == PETSC_DEFAULT) a3 = (one/five - a2/four)/(one/four - a2/three); /* Eq 7.22 */
833: a4 = a3; /* consequence of 7.20 */
835: /* Solve order conditions 7.15a, 7.15c, 7.15e */
836: M[0][0] = one; M[0][1] = one; M[0][2] = one; /* 7.15a */
837: M[1][0] = 0.0; M[1][1] = a2*a2; M[1][2] = a4*a4; /* 7.15c */
838: M[2][0] = 0.0; M[2][1] = a2*a2*a2; M[2][2] = a4*a4*a4; /* 7.15e */
839: rhs[0] = one - b3;
840: rhs[1] = one/three - a3*a3*b3;
841: rhs[2] = one/four - a3*a3*a3*b3;
842: PetscKernel_A_gets_inverse_A_3(&M[0][0],0,PETSC_FALSE,NULL);
843: b1 = PetscRealPart(M[0][0]*rhs[0] + M[0][1]*rhs[1] + M[0][2]*rhs[2]);
844: b2 = PetscRealPart(M[1][0]*rhs[0] + M[1][1]*rhs[1] + M[1][2]*rhs[2]);
845: b4 = PetscRealPart(M[2][0]*rhs[0] + M[2][1]*rhs[1] + M[2][2]*rhs[2]);
847: /* Step 3 */
848: beta43 = (p56 - a2*p43) / (b4*a3*a3*(a3 - a2)); /* 7.21 */
849: beta32beta2p = p44 / (b4*beta43); /* 7.15h */
850: beta4jbetajp = (p32 - b3*beta32beta2p) / b4;
851: M[0][0] = b2; M[0][1] = b3; M[0][2] = b4;
852: M[1][0] = a4*a4*beta32beta2p-a3*a3*beta4jbetajp; M[1][1] = a2*a2*beta4jbetajp; M[1][2] = -a2*a2*beta32beta2p;
853: M[2][0] = b4*beta43*a3*a3-p43; M[2][1] = -b4*beta43*a2*a2; M[2][2] = 0;
854: rhs[0] = one/two - gamma; rhs[1] = 0; rhs[2] = -a2*a2*p32;
855: PetscKernel_A_gets_inverse_A_3(&M[0][0],0,PETSC_FALSE,NULL);
856: beta2p = PetscRealPart(M[0][0]*rhs[0] + M[0][1]*rhs[1] + M[0][2]*rhs[2]);
857: beta3p = PetscRealPart(M[1][0]*rhs[0] + M[1][1]*rhs[1] + M[1][2]*rhs[2]);
858: beta4p = PetscRealPart(M[2][0]*rhs[0] + M[2][1]*rhs[1] + M[2][2]*rhs[2]);
860: /* Step 4: back-substitute */
861: beta32 = beta32beta2p / beta2p;
862: beta42 = (beta4jbetajp - beta43*beta3p) / beta2p;
864: /* Step 5: 7.15f and 7.20, then 7.16 */
865: a43 = 0;
866: a32 = p42 / (b3*a3*beta2p + b4*a4*beta2p);
867: a42 = a32;
869: A[0][0] = 0; A[0][1] = 0; A[0][2] = 0; A[0][3] = 0;
870: A[1][0] = a2; A[1][1] = 0; A[1][2] = 0; A[1][3] = 0;
871: A[2][0] = a3-a32; A[2][1] = a32; A[2][2] = 0; A[2][3] = 0;
872: A[3][0] = a4-a43-a42; A[3][1] = a42; A[3][2] = a43; A[3][3] = 0;
873: Gamma[0][0] = gamma; Gamma[0][1] = 0; Gamma[0][2] = 0; Gamma[0][3] = 0;
874: Gamma[1][0] = beta2p-A[1][0]; Gamma[1][1] = gamma; Gamma[1][2] = 0; Gamma[1][3] = 0;
875: Gamma[2][0] = beta3p-beta32-A[2][0]; Gamma[2][1] = beta32-A[2][1]; Gamma[2][2] = gamma; Gamma[2][3] = 0;
876: Gamma[3][0] = beta4p-beta42-beta43-A[3][0]; Gamma[3][1] = beta42-A[3][1]; Gamma[3][2] = beta43-A[3][2]; Gamma[3][3] = gamma;
877: b[0] = b1; b[1] = b2; b[2] = b3; b[3] = b4;
879: /* Construct embedded formula using given e4. We are solving Equation 7.18. */
880: bm[3] = b[3] - e4*gamma; /* using definition of E4 */
881: bm[2] = (p32 - beta4jbetajp*bm[3]) / (beta32*beta2p); /* fourth row of 7.18 */
882: bm[1] = (one/two - gamma - beta3p*bm[2] - beta4p*bm[3]) / beta2p; /* second row */
883: bm[0] = one - bm[1] - bm[2] - bm[3]; /* first row */
885: {
886: const PetscReal misfit = a2*a2*bm[1] + a3*a3*bm[2] + a4*a4*bm[3] - one/three;
887: if (PetscAbs(misfit) > PETSC_SMALL) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Assumptions violated, could not construct a third order embedded method");
888: }
889: TSRosWRegister(name,4,4,&A[0][0],&Gamma[0][0],b,bm,0,NULL);
890: return(0);
891: }
893: /*
894: The step completion formula is
896: x1 = x0 + b^T Y
898: where Y is the multi-vector of stages corrections. This function can be called before or after ts->vec_sol has been
899: updated. Suppose we have a completion formula b and an embedded formula be of different order. We can write
901: x1e = x0 + be^T Y
902: = x1 - b^T Y + be^T Y
903: = x1 + (be - b)^T Y
905: so we can evaluate the method of different order even after the step has been optimistically completed.
906: */
907: static PetscErrorCode TSEvaluateStep_RosW(TS ts,PetscInt order,Vec U,PetscBool *done)
908: {
909: TS_RosW *ros = (TS_RosW*)ts->data;
910: RosWTableau tab = ros->tableau;
911: PetscScalar *w = ros->work;
912: PetscInt i;
916: if (order == tab->order) {
917: if (ros->status == TS_STEP_INCOMPLETE) { /* Use standard completion formula */
918: VecCopy(ts->vec_sol,U);
919: for (i=0; i<tab->s; i++) w[i] = tab->bt[i];
920: VecMAXPY(U,tab->s,w,ros->Y);
921: } else {VecCopy(ts->vec_sol,U);}
922: if (done) *done = PETSC_TRUE;
923: return(0);
924: } else if (order == tab->order-1) {
925: if (!tab->bembedt) goto unavailable;
926: if (ros->status == TS_STEP_INCOMPLETE) { /* Use embedded completion formula */
927: VecCopy(ts->vec_sol,U);
928: for (i=0; i<tab->s; i++) w[i] = tab->bembedt[i];
929: VecMAXPY(U,tab->s,w,ros->Y);
930: } else { /* Use rollback-and-recomplete formula (bembedt - bt) */
931: for (i=0; i<tab->s; i++) w[i] = tab->bembedt[i] - tab->bt[i];
932: VecCopy(ts->vec_sol,U);
933: VecMAXPY(U,tab->s,w,ros->Y);
934: }
935: if (done) *done = PETSC_TRUE;
936: return(0);
937: }
938: unavailable:
939: if (done) *done = PETSC_FALSE;
940: else SETERRQ3(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"Rosenbrock-W '%s' of order %D cannot evaluate step at order %D. Consider using -ts_adapt_type none or a different method that has an embedded estimate.",tab->name,tab->order,order);
941: return(0);
942: }
944: static PetscErrorCode TSRollBack_RosW(TS ts)
945: {
946: TS_RosW *ros = (TS_RosW*)ts->data;
950: VecCopy(ros->vec_sol_prev,ts->vec_sol);
951: return(0);
952: }
954: static PetscErrorCode TSStep_RosW(TS ts)
955: {
956: TS_RosW *ros = (TS_RosW*)ts->data;
957: RosWTableau tab = ros->tableau;
958: const PetscInt s = tab->s;
959: const PetscReal *At = tab->At,*Gamma = tab->Gamma,*ASum = tab->ASum,*GammaInv = tab->GammaInv;
960: const PetscReal *GammaExplicitCorr = tab->GammaExplicitCorr;
961: const PetscBool *GammaZeroDiag = tab->GammaZeroDiag;
962: PetscScalar *w = ros->work;
963: Vec *Y = ros->Y,Ydot = ros->Ydot,Zdot = ros->Zdot,Zstage = ros->Zstage;
964: SNES snes;
965: TSAdapt adapt;
966: PetscInt i,j,its,lits;
967: PetscInt rejections = 0;
968: PetscBool stageok,accept = PETSC_TRUE;
969: PetscReal next_time_step = ts->time_step;
970: PetscErrorCode ierr;
971: PetscInt lag;
974: if (!ts->steprollback) {
975: VecCopy(ts->vec_sol,ros->vec_sol_prev);
976: }
978: ros->status = TS_STEP_INCOMPLETE;
979: while (!ts->reason && ros->status != TS_STEP_COMPLETE) {
980: const PetscReal h = ts->time_step;
981: for (i=0; i<s; i++) {
982: ros->stage_time = ts->ptime + h*ASum[i];
983: TSPreStage(ts,ros->stage_time);
984: if (GammaZeroDiag[i]) {
985: ros->stage_explicit = PETSC_TRUE;
986: ros->scoeff = 1.;
987: } else {
988: ros->stage_explicit = PETSC_FALSE;
989: ros->scoeff = 1./Gamma[i*s+i];
990: }
992: VecCopy(ts->vec_sol,Zstage);
993: for (j=0; j<i; j++) w[j] = At[i*s+j];
994: VecMAXPY(Zstage,i,w,Y);
996: for (j=0; j<i; j++) w[j] = 1./h * GammaInv[i*s+j];
997: VecZeroEntries(Zdot);
998: VecMAXPY(Zdot,i,w,Y);
1000: /* Initial guess taken from last stage */
1001: VecZeroEntries(Y[i]);
1003: if (!ros->stage_explicit) {
1004: TSGetSNES(ts,&snes);
1005: if (!ros->recompute_jacobian && !i) {
1006: SNESGetLagJacobian(snes,&lag);
1007: if (lag == 1) { /* use did not set a nontrival lag, so lag over all stages */
1008: SNESSetLagJacobian(snes,-2); /* Recompute the Jacobian on this solve, but not again for the rest of the stages */
1009: }
1010: }
1011: SNESSolve(snes,NULL,Y[i]);
1012: if (!ros->recompute_jacobian && i == s-1 && lag == 1) {
1013: SNESSetLagJacobian(snes,lag); /* Set lag back to 1 so we know user did not set it */
1014: }
1015: SNESGetIterationNumber(snes,&its);
1016: SNESGetLinearSolveIterations(snes,&lits);
1017: ts->snes_its += its; ts->ksp_its += lits;
1018: } else {
1019: Mat J,Jp;
1020: VecZeroEntries(Ydot); /* Evaluate Y[i]=G(t,Ydot=0,Zstage) */
1021: TSComputeIFunction(ts,ros->stage_time,Zstage,Ydot,Y[i],PETSC_FALSE);
1022: VecScale(Y[i],-1.0);
1023: VecAXPY(Y[i],-1.0,Zdot); /*Y[i] = F(Zstage)-Zdot[=GammaInv*Y]*/
1025: VecZeroEntries(Zstage); /* Zstage = GammaExplicitCorr[i,j] * Y[j] */
1026: for (j=0; j<i; j++) w[j] = GammaExplicitCorr[i*s+j];
1027: VecMAXPY(Zstage,i,w,Y);
1029: /* Y[i] = Y[i] + Jac*Zstage[=Jac*GammaExplicitCorr[i,j] * Y[j]] */
1030: TSGetIJacobian(ts,&J,&Jp,NULL,NULL);
1031: TSComputeIJacobian(ts,ros->stage_time,ts->vec_sol,Ydot,0,J,Jp,PETSC_FALSE);
1032: MatMult(J,Zstage,Zdot);
1033: VecAXPY(Y[i],-1.0,Zdot);
1034: ts->ksp_its += 1;
1036: VecScale(Y[i],h);
1037: }
1038: TSPostStage(ts,ros->stage_time,i,Y);
1039: TSGetAdapt(ts,&adapt);
1040: TSAdaptCheckStage(adapt,ts,ros->stage_time,Y[i],&stageok);
1041: if (!stageok) goto reject_step;
1042: }
1044: ros->status = TS_STEP_INCOMPLETE;
1045: TSEvaluateStep_RosW(ts,tab->order,ts->vec_sol,NULL);
1046: ros->status = TS_STEP_PENDING;
1047: TSGetAdapt(ts,&adapt);
1048: TSAdaptCandidatesClear(adapt);
1049: TSAdaptCandidateAdd(adapt,tab->name,tab->order,1,tab->ccfl,(PetscReal)tab->s,PETSC_TRUE);
1050: TSAdaptChoose(adapt,ts,ts->time_step,NULL,&next_time_step,&accept);
1051: ros->status = accept ? TS_STEP_COMPLETE : TS_STEP_INCOMPLETE;
1052: if (!accept) { /* Roll back the current step */
1053: TSRollBack_RosW(ts);
1054: ts->time_step = next_time_step;
1055: goto reject_step;
1056: }
1058: ts->ptime += ts->time_step;
1059: ts->time_step = next_time_step;
1060: break;
1062: reject_step:
1063: ts->reject++; accept = PETSC_FALSE;
1064: if (!ts->reason && ++rejections > ts->max_reject && ts->max_reject >= 0) {
1065: ts->reason = TS_DIVERGED_STEP_REJECTED;
1066: PetscInfo2(ts,"Step=%D, step rejections %D greater than current TS allowed, stopping solve\n",ts->steps,rejections);
1067: }
1068: }
1069: return(0);
1070: }
1072: static PetscErrorCode TSInterpolate_RosW(TS ts,PetscReal itime,Vec U)
1073: {
1074: TS_RosW *ros = (TS_RosW*)ts->data;
1075: PetscInt s = ros->tableau->s,pinterp = ros->tableau->pinterp,i,j;
1076: PetscReal h;
1077: PetscReal tt,t;
1078: PetscScalar *bt;
1079: const PetscReal *Bt = ros->tableau->binterpt;
1080: PetscErrorCode ierr;
1081: const PetscReal *GammaInv = ros->tableau->GammaInv;
1082: PetscScalar *w = ros->work;
1083: Vec *Y = ros->Y;
1086: if (!Bt) SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_SUP,"TSRosW %s does not have an interpolation formula",ros->tableau->name);
1088: switch (ros->status) {
1089: case TS_STEP_INCOMPLETE:
1090: case TS_STEP_PENDING:
1091: h = ts->time_step;
1092: t = (itime - ts->ptime)/h;
1093: break;
1094: case TS_STEP_COMPLETE:
1095: h = ts->ptime - ts->ptime_prev;
1096: t = (itime - ts->ptime)/h + 1; /* In the interval [0,1] */
1097: break;
1098: default: SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_PLIB,"Invalid TSStepStatus");
1099: }
1100: PetscMalloc1(s,&bt);
1101: for (i=0; i<s; i++) bt[i] = 0;
1102: for (j=0,tt=t; j<pinterp; j++,tt*=t) {
1103: for (i=0; i<s; i++) {
1104: bt[i] += Bt[i*pinterp+j] * tt;
1105: }
1106: }
1108: /* y(t+tt*h) = y(t) + Sum bt(tt) * GammaInv * Ydot */
1109: /* U <- 0*/
1110: VecZeroEntries(U);
1111: /* U <- Sum bt_i * GammaInv(i,1:i) * Y(1:i) */
1112: for (j=0; j<s; j++) w[j] = 0;
1113: for (j=0; j<s; j++) {
1114: for (i=j; i<s; i++) {
1115: w[j] += bt[i]*GammaInv[i*s+j];
1116: }
1117: }
1118: VecMAXPY(U,i,w,Y);
1119: /* U <- y(t) + U */
1120: VecAXPY(U,1,ros->vec_sol_prev);
1122: PetscFree(bt);
1123: return(0);
1124: }
1126: /*------------------------------------------------------------*/
1128: static PetscErrorCode TSRosWTableauReset(TS ts)
1129: {
1130: TS_RosW *ros = (TS_RosW*)ts->data;
1131: RosWTableau tab = ros->tableau;
1135: if (!tab) return(0);
1136: VecDestroyVecs(tab->s,&ros->Y);
1137: PetscFree(ros->work);
1138: return(0);
1139: }
1141: static PetscErrorCode TSReset_RosW(TS ts)
1142: {
1143: TS_RosW *ros = (TS_RosW*)ts->data;
1147: TSRosWTableauReset(ts);
1148: VecDestroy(&ros->Ydot);
1149: VecDestroy(&ros->Ystage);
1150: VecDestroy(&ros->Zdot);
1151: VecDestroy(&ros->Zstage);
1152: VecDestroy(&ros->vec_sol_prev);
1153: return(0);
1154: }
1156: static PetscErrorCode TSRosWGetVecs(TS ts,DM dm,Vec *Ydot,Vec *Zdot,Vec *Ystage,Vec *Zstage)
1157: {
1158: TS_RosW *rw = (TS_RosW*)ts->data;
1162: if (Ydot) {
1163: if (dm && dm != ts->dm) {
1164: DMGetNamedGlobalVector(dm,"TSRosW_Ydot",Ydot);
1165: } else *Ydot = rw->Ydot;
1166: }
1167: if (Zdot) {
1168: if (dm && dm != ts->dm) {
1169: DMGetNamedGlobalVector(dm,"TSRosW_Zdot",Zdot);
1170: } else *Zdot = rw->Zdot;
1171: }
1172: if (Ystage) {
1173: if (dm && dm != ts->dm) {
1174: DMGetNamedGlobalVector(dm,"TSRosW_Ystage",Ystage);
1175: } else *Ystage = rw->Ystage;
1176: }
1177: if (Zstage) {
1178: if (dm && dm != ts->dm) {
1179: DMGetNamedGlobalVector(dm,"TSRosW_Zstage",Zstage);
1180: } else *Zstage = rw->Zstage;
1181: }
1182: return(0);
1183: }
1186: static PetscErrorCode TSRosWRestoreVecs(TS ts,DM dm,Vec *Ydot,Vec *Zdot, Vec *Ystage, Vec *Zstage)
1187: {
1191: if (Ydot) {
1192: if (dm && dm != ts->dm) {
1193: DMRestoreNamedGlobalVector(dm,"TSRosW_Ydot",Ydot);
1194: }
1195: }
1196: if (Zdot) {
1197: if (dm && dm != ts->dm) {
1198: DMRestoreNamedGlobalVector(dm,"TSRosW_Zdot",Zdot);
1199: }
1200: }
1201: if (Ystage) {
1202: if (dm && dm != ts->dm) {
1203: DMRestoreNamedGlobalVector(dm,"TSRosW_Ystage",Ystage);
1204: }
1205: }
1206: if (Zstage) {
1207: if (dm && dm != ts->dm) {
1208: DMRestoreNamedGlobalVector(dm,"TSRosW_Zstage",Zstage);
1209: }
1210: }
1211: return(0);
1212: }
1214: static PetscErrorCode DMCoarsenHook_TSRosW(DM fine,DM coarse,void *ctx)
1215: {
1217: return(0);
1218: }
1220: static PetscErrorCode DMRestrictHook_TSRosW(DM fine,Mat restrct,Vec rscale,Mat inject,DM coarse,void *ctx)
1221: {
1222: TS ts = (TS)ctx;
1224: Vec Ydot,Zdot,Ystage,Zstage;
1225: Vec Ydotc,Zdotc,Ystagec,Zstagec;
1228: TSRosWGetVecs(ts,fine,&Ydot,&Ystage,&Zdot,&Zstage);
1229: TSRosWGetVecs(ts,coarse,&Ydotc,&Ystagec,&Zdotc,&Zstagec);
1230: MatRestrict(restrct,Ydot,Ydotc);
1231: VecPointwiseMult(Ydotc,rscale,Ydotc);
1232: MatRestrict(restrct,Ystage,Ystagec);
1233: VecPointwiseMult(Ystagec,rscale,Ystagec);
1234: MatRestrict(restrct,Zdot,Zdotc);
1235: VecPointwiseMult(Zdotc,rscale,Zdotc);
1236: MatRestrict(restrct,Zstage,Zstagec);
1237: VecPointwiseMult(Zstagec,rscale,Zstagec);
1238: TSRosWRestoreVecs(ts,fine,&Ydot,&Ystage,&Zdot,&Zstage);
1239: TSRosWRestoreVecs(ts,coarse,&Ydotc,&Ystagec,&Zdotc,&Zstagec);
1240: return(0);
1241: }
1244: static PetscErrorCode DMSubDomainHook_TSRosW(DM fine,DM coarse,void *ctx)
1245: {
1247: return(0);
1248: }
1250: static PetscErrorCode DMSubDomainRestrictHook_TSRosW(DM dm,VecScatter gscat,VecScatter lscat,DM subdm,void *ctx)
1251: {
1252: TS ts = (TS)ctx;
1254: Vec Ydot,Zdot,Ystage,Zstage;
1255: Vec Ydots,Zdots,Ystages,Zstages;
1258: TSRosWGetVecs(ts,dm,&Ydot,&Ystage,&Zdot,&Zstage);
1259: TSRosWGetVecs(ts,subdm,&Ydots,&Ystages,&Zdots,&Zstages);
1261: VecScatterBegin(gscat,Ydot,Ydots,INSERT_VALUES,SCATTER_FORWARD);
1262: VecScatterEnd(gscat,Ydot,Ydots,INSERT_VALUES,SCATTER_FORWARD);
1264: VecScatterBegin(gscat,Ystage,Ystages,INSERT_VALUES,SCATTER_FORWARD);
1265: VecScatterEnd(gscat,Ystage,Ystages,INSERT_VALUES,SCATTER_FORWARD);
1267: VecScatterBegin(gscat,Zdot,Zdots,INSERT_VALUES,SCATTER_FORWARD);
1268: VecScatterEnd(gscat,Zdot,Zdots,INSERT_VALUES,SCATTER_FORWARD);
1270: VecScatterBegin(gscat,Zstage,Zstages,INSERT_VALUES,SCATTER_FORWARD);
1271: VecScatterEnd(gscat,Zstage,Zstages,INSERT_VALUES,SCATTER_FORWARD);
1273: TSRosWRestoreVecs(ts,dm,&Ydot,&Ystage,&Zdot,&Zstage);
1274: TSRosWRestoreVecs(ts,subdm,&Ydots,&Ystages,&Zdots,&Zstages);
1275: return(0);
1276: }
1278: /*
1279: This defines the nonlinear equation that is to be solved with SNES
1280: G(U) = F[t0+Theta*dt, U, (U-U0)*shift] = 0
1281: */
1282: static PetscErrorCode SNESTSFormFunction_RosW(SNES snes,Vec U,Vec F,TS ts)
1283: {
1284: TS_RosW *ros = (TS_RosW*)ts->data;
1286: Vec Ydot,Zdot,Ystage,Zstage;
1287: PetscReal shift = ros->scoeff / ts->time_step;
1288: DM dm,dmsave;
1291: SNESGetDM(snes,&dm);
1292: TSRosWGetVecs(ts,dm,&Ydot,&Zdot,&Ystage,&Zstage);
1293: VecWAXPY(Ydot,shift,U,Zdot); /* Ydot = shift*U + Zdot */
1294: VecWAXPY(Ystage,1.0,U,Zstage); /* Ystage = U + Zstage */
1295: dmsave = ts->dm;
1296: ts->dm = dm;
1297: TSComputeIFunction(ts,ros->stage_time,Ystage,Ydot,F,PETSC_FALSE);
1298: ts->dm = dmsave;
1299: TSRosWRestoreVecs(ts,dm,&Ydot,&Zdot,&Ystage,&Zstage);
1300: return(0);
1301: }
1303: static PetscErrorCode SNESTSFormJacobian_RosW(SNES snes,Vec U,Mat A,Mat B,TS ts)
1304: {
1305: TS_RosW *ros = (TS_RosW*)ts->data;
1306: Vec Ydot,Zdot,Ystage,Zstage;
1307: PetscReal shift = ros->scoeff / ts->time_step;
1309: DM dm,dmsave;
1312: /* ros->Ydot and ros->Ystage have already been computed in SNESTSFormFunction_RosW (SNES guarantees this) */
1313: SNESGetDM(snes,&dm);
1314: TSRosWGetVecs(ts,dm,&Ydot,&Zdot,&Ystage,&Zstage);
1315: dmsave = ts->dm;
1316: ts->dm = dm;
1317: TSComputeIJacobian(ts,ros->stage_time,Ystage,Ydot,shift,A,B,PETSC_TRUE);
1318: ts->dm = dmsave;
1319: TSRosWRestoreVecs(ts,dm,&Ydot,&Zdot,&Ystage,&Zstage);
1320: return(0);
1321: }
1323: static PetscErrorCode TSRosWTableauSetUp(TS ts)
1324: {
1325: TS_RosW *ros = (TS_RosW*)ts->data;
1326: RosWTableau tab = ros->tableau;
1330: VecDuplicateVecs(ts->vec_sol,tab->s,&ros->Y);
1331: PetscMalloc1(tab->s,&ros->work);
1332: return(0);
1333: }
1335: static PetscErrorCode TSSetUp_RosW(TS ts)
1336: {
1337: TS_RosW *ros = (TS_RosW*)ts->data;
1339: DM dm;
1340: SNES snes;
1341: TSRHSJacobian rhsjacobian;
1344: TSRosWTableauSetUp(ts);
1345: VecDuplicate(ts->vec_sol,&ros->Ydot);
1346: VecDuplicate(ts->vec_sol,&ros->Ystage);
1347: VecDuplicate(ts->vec_sol,&ros->Zdot);
1348: VecDuplicate(ts->vec_sol,&ros->Zstage);
1349: VecDuplicate(ts->vec_sol,&ros->vec_sol_prev);
1350: TSGetDM(ts,&dm);
1351: DMCoarsenHookAdd(dm,DMCoarsenHook_TSRosW,DMRestrictHook_TSRosW,ts);
1352: DMSubDomainHookAdd(dm,DMSubDomainHook_TSRosW,DMSubDomainRestrictHook_TSRosW,ts);
1353: /* Rosenbrock methods are linearly implicit, so set that unless the user has specifically asked for something else */
1354: TSGetSNES(ts,&snes);
1355: if (!((PetscObject)snes)->type_name) {
1356: SNESSetType(snes,SNESKSPONLY);
1357: }
1358: DMTSGetRHSJacobian(dm,&rhsjacobian,NULL);
1359: if (rhsjacobian == TSComputeRHSJacobianConstant) {
1360: Mat Amat,Pmat;
1362: /* Set the SNES matrix to be different from the RHS matrix because there is no way to reconstruct shift*M-J */
1363: SNESGetJacobian(snes,&Amat,&Pmat,NULL,NULL);
1364: if (Amat && Amat == ts->Arhs) {
1365: if (Amat == Pmat) {
1366: MatDuplicate(ts->Arhs,MAT_COPY_VALUES,&Amat);
1367: SNESSetJacobian(snes,Amat,Amat,NULL,NULL);
1368: } else {
1369: MatDuplicate(ts->Arhs,MAT_COPY_VALUES,&Amat);
1370: SNESSetJacobian(snes,Amat,NULL,NULL,NULL);
1371: if (Pmat && Pmat == ts->Brhs) {
1372: MatDuplicate(ts->Brhs,MAT_COPY_VALUES,&Pmat);
1373: SNESSetJacobian(snes,NULL,Pmat,NULL,NULL);
1374: MatDestroy(&Pmat);
1375: }
1376: }
1377: MatDestroy(&Amat);
1378: }
1379: }
1380: return(0);
1381: }
1382: /*------------------------------------------------------------*/
1384: static PetscErrorCode TSSetFromOptions_RosW(PetscOptionItems *PetscOptionsObject,TS ts)
1385: {
1386: TS_RosW *ros = (TS_RosW*)ts->data;
1388: SNES snes;
1391: PetscOptionsHead(PetscOptionsObject,"RosW ODE solver options");
1392: {
1393: RosWTableauLink link;
1394: PetscInt count,choice;
1395: PetscBool flg;
1396: const char **namelist;
1398: for (link=RosWTableauList,count=0; link; link=link->next,count++) ;
1399: PetscMalloc1(count,(char***)&namelist);
1400: for (link=RosWTableauList,count=0; link; link=link->next,count++) namelist[count] = link->tab.name;
1401: PetscOptionsEList("-ts_rosw_type","Family of Rosenbrock-W method","TSRosWSetType",(const char*const*)namelist,count,ros->tableau->name,&choice,&flg);
1402: if (flg) {TSRosWSetType(ts,namelist[choice]);}
1403: PetscFree(namelist);
1405: PetscOptionsBool("-ts_rosw_recompute_jacobian","Recompute the Jacobian at each stage","TSRosWSetRecomputeJacobian",ros->recompute_jacobian,&ros->recompute_jacobian,NULL);
1406: }
1407: PetscOptionsTail();
1408: /* Rosenbrock methods are linearly implicit, so set that unless the user has specifically asked for something else */
1409: TSGetSNES(ts,&snes);
1410: if (!((PetscObject)snes)->type_name) {
1411: SNESSetType(snes,SNESKSPONLY);
1412: }
1413: return(0);
1414: }
1416: static PetscErrorCode TSView_RosW(TS ts,PetscViewer viewer)
1417: {
1418: TS_RosW *ros = (TS_RosW*)ts->data;
1419: PetscBool iascii;
1423: PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
1424: if (iascii) {
1425: RosWTableau tab = ros->tableau;
1426: TSRosWType rostype;
1427: char buf[512];
1428: PetscInt i;
1429: PetscReal abscissa[512];
1430: TSRosWGetType(ts,&rostype);
1431: PetscViewerASCIIPrintf(viewer," Rosenbrock-W %s\n",rostype);
1432: PetscFormatRealArray(buf,sizeof(buf),"% 8.6f",tab->s,tab->ASum);
1433: PetscViewerASCIIPrintf(viewer," Abscissa of A = %s\n",buf);
1434: for (i=0; i<tab->s; i++) abscissa[i] = tab->ASum[i] + tab->Gamma[i];
1435: PetscFormatRealArray(buf,sizeof(buf),"% 8.6f",tab->s,abscissa);
1436: PetscViewerASCIIPrintf(viewer," Abscissa of A+Gamma = %s\n",buf);
1437: }
1438: return(0);
1439: }
1441: static PetscErrorCode TSLoad_RosW(TS ts,PetscViewer viewer)
1442: {
1444: SNES snes;
1445: TSAdapt adapt;
1448: TSGetAdapt(ts,&adapt);
1449: TSAdaptLoad(adapt,viewer);
1450: TSGetSNES(ts,&snes);
1451: SNESLoad(snes,viewer);
1452: /* function and Jacobian context for SNES when used with TS is always ts object */
1453: SNESSetFunction(snes,NULL,NULL,ts);
1454: SNESSetJacobian(snes,NULL,NULL,NULL,ts);
1455: return(0);
1456: }
1458: /*@C
1459: TSRosWSetType - Set the type of Rosenbrock-W scheme
1461: Logically collective
1463: Input Parameter:
1464: + ts - timestepping context
1465: - roswtype - type of Rosenbrock-W scheme
1467: Level: beginner
1469: .seealso: TSRosWGetType(), TSROSW, TSROSW2M, TSROSW2P, TSROSWRA3PW, TSROSWRA34PW2, TSROSWRODAS3, TSROSWSANDU3, TSROSWASSP3P3S1C, TSROSWLASSP3P4S2C, TSROSWLLSSP3P4S2C, TSROSWARK3
1470: @*/
1471: PetscErrorCode TSRosWSetType(TS ts,TSRosWType roswtype)
1472: {
1478: PetscTryMethod(ts,"TSRosWSetType_C",(TS,TSRosWType),(ts,roswtype));
1479: return(0);
1480: }
1482: /*@C
1483: TSRosWGetType - Get the type of Rosenbrock-W scheme
1485: Logically collective
1487: Input Parameter:
1488: . ts - timestepping context
1490: Output Parameter:
1491: . rostype - type of Rosenbrock-W scheme
1493: Level: intermediate
1495: .seealso: TSRosWGetType()
1496: @*/
1497: PetscErrorCode TSRosWGetType(TS ts,TSRosWType *rostype)
1498: {
1503: PetscUseMethod(ts,"TSRosWGetType_C",(TS,TSRosWType*),(ts,rostype));
1504: return(0);
1505: }
1507: /*@C
1508: TSRosWSetRecomputeJacobian - Set whether to recompute the Jacobian at each stage. The default is to update the Jacobian once per step.
1510: Logically collective
1512: Input Parameter:
1513: + ts - timestepping context
1514: - flg - PETSC_TRUE to recompute the Jacobian at each stage
1516: Level: intermediate
1518: .seealso: TSRosWGetType()
1519: @*/
1520: PetscErrorCode TSRosWSetRecomputeJacobian(TS ts,PetscBool flg)
1521: {
1526: PetscTryMethod(ts,"TSRosWSetRecomputeJacobian_C",(TS,PetscBool),(ts,flg));
1527: return(0);
1528: }
1530: static PetscErrorCode TSRosWGetType_RosW(TS ts,TSRosWType *rostype)
1531: {
1532: TS_RosW *ros = (TS_RosW*)ts->data;
1535: *rostype = ros->tableau->name;
1536: return(0);
1537: }
1539: static PetscErrorCode TSRosWSetType_RosW(TS ts,TSRosWType rostype)
1540: {
1541: TS_RosW *ros = (TS_RosW*)ts->data;
1542: PetscErrorCode ierr;
1543: PetscBool match;
1544: RosWTableauLink link;
1547: if (ros->tableau) {
1548: PetscStrcmp(ros->tableau->name,rostype,&match);
1549: if (match) return(0);
1550: }
1551: for (link = RosWTableauList; link; link=link->next) {
1552: PetscStrcmp(link->tab.name,rostype,&match);
1553: if (match) {
1554: if (ts->setupcalled) {TSRosWTableauReset(ts);}
1555: ros->tableau = &link->tab;
1556: if (ts->setupcalled) {TSRosWTableauSetUp(ts);}
1557: ts->default_adapt_type = ros->tableau->bembed ? TSADAPTBASIC : TSADAPTNONE;
1558: return(0);
1559: }
1560: }
1561: SETERRQ1(PetscObjectComm((PetscObject)ts),PETSC_ERR_ARG_UNKNOWN_TYPE,"Could not find '%s'",rostype);
1562: }
1564: static PetscErrorCode TSRosWSetRecomputeJacobian_RosW(TS ts,PetscBool flg)
1565: {
1566: TS_RosW *ros = (TS_RosW*)ts->data;
1569: ros->recompute_jacobian = flg;
1570: return(0);
1571: }
1573: static PetscErrorCode TSDestroy_RosW(TS ts)
1574: {
1578: TSReset_RosW(ts);
1579: if (ts->dm) {
1580: DMCoarsenHookRemove(ts->dm,DMCoarsenHook_TSRosW,DMRestrictHook_TSRosW,ts);
1581: DMSubDomainHookRemove(ts->dm,DMSubDomainHook_TSRosW,DMSubDomainRestrictHook_TSRosW,ts);
1582: }
1583: PetscFree(ts->data);
1584: PetscObjectComposeFunction((PetscObject)ts,"TSRosWGetType_C",NULL);
1585: PetscObjectComposeFunction((PetscObject)ts,"TSRosWSetType_C",NULL);
1586: PetscObjectComposeFunction((PetscObject)ts,"TSRosWSetRecomputeJacobian_C",NULL);
1587: return(0);
1588: }
1590: /* ------------------------------------------------------------ */
1591: /*MC
1592: TSROSW - ODE solver using Rosenbrock-W schemes
1594: These methods are intended for problems with well-separated time scales, especially when a slow scale is strongly
1595: nonlinear such that it is expensive to solve with a fully implicit method. The user should provide the stiff part
1596: of the equation using TSSetIFunction() and the non-stiff part with TSSetRHSFunction().
1598: Notes:
1599: This method currently only works with autonomous ODE and DAE.
1601: Consider trying TSARKIMEX if the stiff part is strongly nonlinear.
1603: Since this uses a single linear solve per time-step if you wish to lag the jacobian or preconditioner computation you must use also -snes_lag_jacobian_persists true or -snes_lag_jacobian_preconditioner true
1605: Developer Notes:
1606: Rosenbrock-W methods are typically specified for autonomous ODE
1608: $ udot = f(u)
1610: by the stage equations
1612: $ k_i = h f(u_0 + sum_j alpha_ij k_j) + h J sum_j gamma_ij k_j
1614: and step completion formula
1616: $ u_1 = u_0 + sum_j b_j k_j
1618: with step size h and coefficients alpha_ij, gamma_ij, and b_i. Implementing the method in this form would require f(u)
1619: and the Jacobian J to be available, in addition to the shifted matrix I - h gamma_ii J. Following Hairer and Wanner,
1620: we define new variables for the stage equations
1622: $ y_i = gamma_ij k_j
1624: The k_j can be recovered because Gamma is invertible. Let C be the lower triangular part of Gamma^{-1} and define
1626: $ A = Alpha Gamma^{-1}, bt^T = b^T Gamma^{-1}
1628: to rewrite the method as
1630: $ [M/(h gamma_ii) - J] y_i = f(u_0 + sum_j a_ij y_j) + M sum_j (c_ij/h) y_j
1631: $ u_1 = u_0 + sum_j bt_j y_j
1633: where we have introduced the mass matrix M. Continue by defining
1635: $ ydot_i = 1/(h gamma_ii) y_i - sum_j (c_ij/h) y_j
1637: or, more compactly in tensor notation
1639: $ Ydot = 1/h (Gamma^{-1} \otimes I) Y .
1641: Note that Gamma^{-1} is lower triangular. With this definition of Ydot in terms of known quantities and the current
1642: stage y_i, the stage equations reduce to performing one Newton step (typically with a lagged Jacobian) on the
1643: equation
1645: $ g(u_0 + sum_j a_ij y_j + y_i, ydot_i) = 0
1647: with initial guess y_i = 0.
1649: Level: beginner
1651: .seealso: TSCreate(), TS, TSSetType(), TSRosWSetType(), TSRosWRegister(), TSROSWTHETA1, TSROSWTHETA2, TSROSW2M, TSROSW2P, TSROSWRA3PW, TSROSWRA34PW2, TSROSWRODAS3,
1652: TSROSWSANDU3, TSROSWASSP3P3S1C, TSROSWLASSP3P4S2C, TSROSWLLSSP3P4S2C, TSROSWGRK4T, TSROSWSHAMP4, TSROSWVELDD4, TSROSW4L
1653: M*/
1654: PETSC_EXTERN PetscErrorCode TSCreate_RosW(TS ts)
1655: {
1656: TS_RosW *ros;
1660: TSRosWInitializePackage();
1662: ts->ops->reset = TSReset_RosW;
1663: ts->ops->destroy = TSDestroy_RosW;
1664: ts->ops->view = TSView_RosW;
1665: ts->ops->load = TSLoad_RosW;
1666: ts->ops->setup = TSSetUp_RosW;
1667: ts->ops->step = TSStep_RosW;
1668: ts->ops->interpolate = TSInterpolate_RosW;
1669: ts->ops->evaluatestep = TSEvaluateStep_RosW;
1670: ts->ops->rollback = TSRollBack_RosW;
1671: ts->ops->setfromoptions = TSSetFromOptions_RosW;
1672: ts->ops->snesfunction = SNESTSFormFunction_RosW;
1673: ts->ops->snesjacobian = SNESTSFormJacobian_RosW;
1675: ts->usessnes = PETSC_TRUE;
1677: PetscNewLog(ts,&ros);
1678: ts->data = (void*)ros;
1680: PetscObjectComposeFunction((PetscObject)ts,"TSRosWGetType_C",TSRosWGetType_RosW);
1681: PetscObjectComposeFunction((PetscObject)ts,"TSRosWSetType_C",TSRosWSetType_RosW);
1682: PetscObjectComposeFunction((PetscObject)ts,"TSRosWSetRecomputeJacobian_C",TSRosWSetRecomputeJacobian_RosW);
1684: TSRosWSetType(ts,TSRosWDefault);
1685: return(0);
1686: }