Actual source code: dmts.c
petsc-3.7.5 2017-01-01
1: #include <petsc/private/tsimpl.h> /*I "petscts.h" I*/
2: #include <petsc/private/dmimpl.h>
6: static PetscErrorCode DMTSDestroy(DMTS *kdm)
7: {
11: if (!*kdm) return(0);
13: if (--((PetscObject)(*kdm))->refct > 0) {*kdm = 0; return(0);}
14: if ((*kdm)->ops->destroy) {((*kdm)->ops->destroy)(*kdm);}
15: PetscHeaderDestroy(kdm);
16: return(0);
17: }
21: PetscErrorCode DMTSLoad(DMTS kdm,PetscViewer viewer)
22: {
26: PetscViewerBinaryRead(viewer,&kdm->ops->ifunction,1,NULL,PETSC_FUNCTION);
27: PetscViewerBinaryRead(viewer,&kdm->ops->ifunctionview,1,NULL,PETSC_FUNCTION);
28: PetscViewerBinaryRead(viewer,&kdm->ops->ifunctionload,1,NULL,PETSC_FUNCTION);
29: if (kdm->ops->ifunctionload) {
30: (*kdm->ops->ifunctionload)(&kdm->ifunctionctx,viewer);
31: }
32: PetscViewerBinaryRead(viewer,&kdm->ops->ijacobian,1,NULL,PETSC_FUNCTION);
33: PetscViewerBinaryRead(viewer,&kdm->ops->ijacobianview,1,NULL,PETSC_FUNCTION);
34: PetscViewerBinaryRead(viewer,&kdm->ops->ijacobianload,1,NULL,PETSC_FUNCTION);
35: if (kdm->ops->ijacobianload) {
36: (*kdm->ops->ijacobianload)(&kdm->ijacobianctx,viewer);
37: }
38: return(0);
39: }
43: PetscErrorCode DMTSView(DMTS kdm,PetscViewer viewer)
44: {
46: PetscBool isascii,isbinary;
49: PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
50: PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);
51: if (isascii) {
52: #if defined(PETSC_SERIALIZE_FUNCTIONS)
53: const char *fname;
55: PetscFPTFind(kdm->ops->ifunction,&fname);
56: if (fname) {
57: PetscViewerASCIIPrintf(viewer," IFunction used by TS: %s\n",fname);
58: }
59: PetscFPTFind(kdm->ops->ijacobian,&fname);
60: if (fname) {
61: PetscViewerASCIIPrintf(viewer," IJacobian function used by TS: %s\n",fname);
62: }
63: #endif
64: } else if (isbinary) {
65: struct {
66: TSIFunction ifunction;
67: } funcstruct;
68: struct {
69: PetscErrorCode (*ifunctionview)(void*,PetscViewer);
70: } funcviewstruct;
71: struct {
72: PetscErrorCode (*ifunctionload)(void**,PetscViewer);
73: } funcloadstruct;
74: struct {
75: TSIJacobian ijacobian;
76: } jacstruct;
77: struct {
78: PetscErrorCode (*ijacobianview)(void*,PetscViewer);
79: } jacviewstruct;
80: struct {
81: PetscErrorCode (*ijacobianload)(void**,PetscViewer);
82: } jacloadstruct;
84: funcstruct.ifunction = kdm->ops->ifunction;
85: funcviewstruct.ifunctionview = kdm->ops->ifunctionview;
86: funcloadstruct.ifunctionload = kdm->ops->ifunctionload;
87: PetscViewerBinaryWrite(viewer,&funcstruct,1,PETSC_FUNCTION,PETSC_FALSE);
88: PetscViewerBinaryWrite(viewer,&funcviewstruct,1,PETSC_FUNCTION,PETSC_FALSE);
89: PetscViewerBinaryWrite(viewer,&funcloadstruct,1,PETSC_FUNCTION,PETSC_FALSE);
90: if (kdm->ops->ifunctionview) {
91: (*kdm->ops->ifunctionview)(kdm->ifunctionctx,viewer);
92: }
93: jacstruct.ijacobian = kdm->ops->ijacobian;
94: jacviewstruct.ijacobianview = kdm->ops->ijacobianview;
95: jacloadstruct.ijacobianload = kdm->ops->ijacobianload;
96: PetscViewerBinaryWrite(viewer,&jacstruct,1,PETSC_FUNCTION,PETSC_FALSE);
97: PetscViewerBinaryWrite(viewer,&jacviewstruct,1,PETSC_FUNCTION,PETSC_FALSE);
98: PetscViewerBinaryWrite(viewer,&jacloadstruct,1,PETSC_FUNCTION,PETSC_FALSE);
99: if (kdm->ops->ijacobianview) {
100: (*kdm->ops->ijacobianview)(kdm->ijacobianctx,viewer);
101: }
102: }
103: return(0);
104: }
108: static PetscErrorCode DMTSCreate(MPI_Comm comm,DMTS *kdm)
109: {
113: TSInitializePackage();
114: PetscHeaderCreate(*kdm, DMTS_CLASSID, "DMTS", "DMTS", "DMTS", comm, DMTSDestroy, DMTSView);
115: return(0);
116: }
120: /* Attaches the DMTS to the coarse level.
121: * Under what conditions should we copy versus duplicate?
122: */
123: static PetscErrorCode DMCoarsenHook_DMTS(DM dm,DM dmc,void *ctx)
124: {
128: DMCopyDMTS(dm,dmc);
129: return(0);
130: }
134: /* This could restrict auxiliary information to the coarse level.
135: */
136: static PetscErrorCode DMRestrictHook_DMTS(DM dm,Mat Restrict,Vec rscale,Mat Inject,DM dmc,void *ctx)
137: {
140: return(0);
141: }
145: static PetscErrorCode DMSubDomainHook_DMTS(DM dm,DM subdm,void *ctx)
146: {
150: DMCopyDMTS(dm,subdm);
151: return(0);
152: }
156: /* This could restrict auxiliary information to the coarse level.
157: */
158: static PetscErrorCode DMSubDomainRestrictHook_DMTS(DM dm,VecScatter gscat,VecScatter lscat,DM subdm,void *ctx)
159: {
161: return(0);
162: }
166: /*@C
167: DMTSCopy - copies the information in a DMTS to another DMTS
169: Not Collective
171: Input Argument:
172: + kdm - Original DMTS
173: - nkdm - DMTS to receive the data, should have been created with DMTSCreate()
175: Level: developer
177: .seealso: DMTSCreate(), DMTSDestroy()
178: @*/
179: PetscErrorCode DMTSCopy(DMTS kdm,DMTS nkdm)
180: {
186: nkdm->ops->rhsfunction = kdm->ops->rhsfunction;
187: nkdm->ops->rhsjacobian = kdm->ops->rhsjacobian;
188: nkdm->ops->ifunction = kdm->ops->ifunction;
189: nkdm->ops->ijacobian = kdm->ops->ijacobian;
190: nkdm->ops->i2function = kdm->ops->i2function;
191: nkdm->ops->i2jacobian = kdm->ops->i2jacobian;
192: nkdm->ops->solution = kdm->ops->solution;
193: nkdm->ops->destroy = kdm->ops->destroy;
194: nkdm->ops->duplicate = kdm->ops->duplicate;
196: nkdm->rhsfunctionctx = kdm->rhsfunctionctx;
197: nkdm->rhsjacobianctx = kdm->rhsjacobianctx;
198: nkdm->ifunctionctx = kdm->ifunctionctx;
199: nkdm->ijacobianctx = kdm->ijacobianctx;
200: nkdm->i2functionctx = kdm->i2functionctx;
201: nkdm->i2jacobianctx = kdm->i2jacobianctx;
202: nkdm->solutionctx = kdm->solutionctx;
204: nkdm->data = kdm->data;
206: /*
207: nkdm->fortran_func_pointers[0] = kdm->fortran_func_pointers[0];
208: nkdm->fortran_func_pointers[1] = kdm->fortran_func_pointers[1];
209: nkdm->fortran_func_pointers[2] = kdm->fortran_func_pointers[2];
210: */
212: /* implementation specific copy hooks */
213: if (kdm->ops->duplicate) {(*kdm->ops->duplicate)(kdm,nkdm);}
214: return(0);
215: }
219: /*@C
220: DMGetDMTS - get read-only private DMTS context from a DM
222: Not Collective
224: Input Argument:
225: . dm - DM to be used with TS
227: Output Argument:
228: . tsdm - private DMTS context
230: Level: developer
232: Notes:
233: Use DMGetDMTSWrite() if write access is needed. The DMTSSetXXX API should be used wherever possible.
235: .seealso: DMGetDMTSWrite()
236: @*/
237: PetscErrorCode DMGetDMTS(DM dm,DMTS *tsdm)
238: {
243: *tsdm = (DMTS) dm->dmts;
244: if (!*tsdm) {
245: PetscInfo(dm,"Creating new DMTS\n");
246: DMTSCreate(PetscObjectComm((PetscObject)dm),tsdm);
247: dm->dmts = (PetscObject) *tsdm;
248: DMCoarsenHookAdd(dm,DMCoarsenHook_DMTS,DMRestrictHook_DMTS,NULL);
249: DMSubDomainHookAdd(dm,DMSubDomainHook_DMTS,DMSubDomainRestrictHook_DMTS,NULL);
250: }
251: return(0);
252: }
256: /*@C
257: DMGetDMTSWrite - get write access to private DMTS context from a DM
259: Not Collective
261: Input Argument:
262: . dm - DM to be used with TS
264: Output Argument:
265: . tsdm - private DMTS context
267: Level: developer
269: .seealso: DMGetDMTS()
270: @*/
271: PetscErrorCode DMGetDMTSWrite(DM dm,DMTS *tsdm)
272: {
274: DMTS sdm;
278: DMGetDMTS(dm,&sdm);
279: if (!sdm->originaldm) sdm->originaldm = dm;
280: if (sdm->originaldm != dm) { /* Copy on write */
281: DMTS oldsdm = sdm;
282: PetscInfo(dm,"Copying DMTS due to write\n");
283: DMTSCreate(PetscObjectComm((PetscObject)dm),&sdm);
284: DMTSCopy(oldsdm,sdm);
285: DMTSDestroy((DMTS*)&dm->dmts);
286: dm->dmts = (PetscObject) sdm;
287: }
288: *tsdm = sdm;
289: return(0);
290: }
294: /*@C
295: DMCopyDMTS - copies a DM context to a new DM
297: Logically Collective
299: Input Arguments:
300: + dmsrc - DM to obtain context from
301: - dmdest - DM to add context to
303: Level: developer
305: Note:
306: The context is copied by reference. This function does not ensure that a context exists.
308: .seealso: DMGetDMTS(), TSSetDM()
309: @*/
310: PetscErrorCode DMCopyDMTS(DM dmsrc,DM dmdest)
311: {
317: DMTSDestroy((DMTS*)&dmdest->dmts);
318: dmdest->dmts = dmsrc->dmts;
319: PetscObjectReference(dmdest->dmts);
320: DMCoarsenHookAdd(dmdest,DMCoarsenHook_DMTS,DMRestrictHook_DMTS,NULL);
321: DMSubDomainHookAdd(dmdest,DMSubDomainHook_DMTS,DMSubDomainRestrictHook_DMTS,NULL);
322: return(0);
323: }
327: /*@C
328: DMTSSetIFunction - set TS implicit function evaluation function
330: Not Collective
332: Input Arguments:
333: + dm - DM to be used with TS
334: . func - function evaluation function, see TSSetIFunction() for calling sequence
335: - ctx - context for residual evaluation
337: Level: advanced
339: Note:
340: TSSetFunction() is normally used, but it calls this function internally because the user context is actually
341: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
342: not. If DM took a more central role at some later date, this could become the primary method of setting the residual.
344: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
345: @*/
346: PetscErrorCode DMTSSetIFunction(DM dm,TSIFunction func,void *ctx)
347: {
349: DMTS tsdm;
353: DMGetDMTSWrite(dm,&tsdm);
354: if (func) tsdm->ops->ifunction = func;
355: if (ctx) tsdm->ifunctionctx = ctx;
356: return(0);
357: }
361: /*@C
362: DMTSGetIFunction - get TS implicit residual evaluation function
364: Not Collective
366: Input Argument:
367: . dm - DM to be used with TS
369: Output Arguments:
370: + func - function evaluation function, see TSSetIFunction() for calling sequence
371: - ctx - context for residual evaluation
373: Level: advanced
375: Note:
376: TSGetFunction() is normally used, but it calls this function internally because the user context is actually
377: associated with the DM.
379: .seealso: DMTSSetContext(), DMTSSetFunction(), TSSetFunction()
380: @*/
381: PetscErrorCode DMTSGetIFunction(DM dm,TSIFunction *func,void **ctx)
382: {
384: DMTS tsdm;
388: DMGetDMTS(dm,&tsdm);
389: if (func) *func = tsdm->ops->ifunction;
390: if (ctx) *ctx = tsdm->ifunctionctx;
391: return(0);
392: }
396: /*@C
397: DMTSSetI2Function - set TS implicit function evaluation function for 2nd order systems
399: Not Collective
401: Input Arguments:
402: + dm - DM to be used with TS
403: . fun - function evaluation function, see TSSetI2Function() for calling sequence
404: - ctx - context for residual evaluation
406: Level: advanced
408: Note:
409: TSSetI2Function() is normally used, but it calls this function internally because the user context is actually
410: associated with the DM.
412: .seealso: TSSetI2Function()
413: @*/
414: PetscErrorCode DMTSSetI2Function(DM dm,TSI2Function fun,void *ctx)
415: {
416: DMTS tsdm;
421: DMGetDMTSWrite(dm,&tsdm);
422: if (fun) tsdm->ops->i2function = fun;
423: if (ctx) tsdm->i2functionctx = ctx;
424: return(0);
425: }
429: /*@C
430: DMTSGetI2Function - get TS implicit residual evaluation function for 2nd order systems
432: Not Collective
434: Input Argument:
435: . dm - DM to be used with TS
437: Output Arguments:
438: + fun - function evaluation function, see TSSetI2Function() for calling sequence
439: - ctx - context for residual evaluation
441: Level: advanced
443: Note:
444: TSGetI2Function() is normally used, but it calls this function internally because the user context is actually
445: associated with the DM.
447: .seealso: DMTSSetI2Function(),TSGetI2Function()
448: @*/
449: PetscErrorCode DMTSGetI2Function(DM dm,TSI2Function *fun,void **ctx)
450: {
451: DMTS tsdm;
456: DMGetDMTS(dm,&tsdm);
457: if (fun) *fun = tsdm->ops->i2function;
458: if (ctx) *ctx = tsdm->i2functionctx;
459: return(0);
460: }
464: /*@C
465: DMTSSetI2Jacobian - set TS implicit Jacobian evaluation function for 2nd order systems
467: Not Collective
469: Input Arguments:
470: + dm - DM to be used with TS
471: . fun - Jacobian evaluation function, see TSSetI2Jacobian() for calling sequence
472: - ctx - context for Jacobian evaluation
474: Level: advanced
476: Note:
477: TSSetI2Jacobian() is normally used, but it calls this function internally because the user context is actually
478: associated with the DM.
480: .seealso: TSSetI2Jacobian()
481: @*/
482: PetscErrorCode DMTSSetI2Jacobian(DM dm,TSI2Jacobian jac,void *ctx)
483: {
484: DMTS tsdm;
489: DMGetDMTSWrite(dm,&tsdm);
490: if (jac) tsdm->ops->i2jacobian = jac;
491: if (ctx) tsdm->i2jacobianctx = ctx;
492: return(0);
493: }
497: /*@C
498: DMTSGetI2Jacobian - get TS implicit Jacobian evaluation function for 2nd order systems
500: Not Collective
502: Input Argument:
503: . dm - DM to be used with TS
505: Output Arguments:
506: + jac - Jacobian evaluation function, see TSSetI2Jacobian() for calling sequence
507: - ctx - context for Jacobian evaluation
509: Level: advanced
511: Note:
512: TSGetI2Jacobian() is normally used, but it calls this function internally because the user context is actually
513: associated with the DM.
515: .seealso: DMTSSetI2Jacobian(),TSGetI2Jacobian()
516: @*/
517: PetscErrorCode DMTSGetI2Jacobian(DM dm,TSI2Jacobian *jac,void **ctx)
518: {
519: DMTS tsdm;
524: DMGetDMTS(dm,&tsdm);
525: if (jac) *jac = tsdm->ops->i2jacobian;
526: if (ctx) *ctx = tsdm->i2jacobianctx;
527: return(0);
528: }
532: /*@C
533: DMTSSetRHSFunction - set TS explicit residual evaluation function
535: Not Collective
537: Input Arguments:
538: + dm - DM to be used with TS
539: . func - RHS function evaluation function, see TSSetRHSFunction() for calling sequence
540: - ctx - context for residual evaluation
542: Level: advanced
544: Note:
545: TSSetRSHFunction() is normally used, but it calls this function internally because the user context is actually
546: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
547: not. If DM took a more central role at some later date, this could become the primary method of setting the residual.
549: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
550: @*/
551: PetscErrorCode DMTSSetRHSFunction(DM dm,TSRHSFunction func,void *ctx)
552: {
554: DMTS tsdm;
558: DMGetDMTSWrite(dm,&tsdm);
559: if (func) tsdm->ops->rhsfunction = func;
560: if (ctx) tsdm->rhsfunctionctx = ctx;
561: return(0);
562: }
566: /*@C
567: DMTSGetSolutionFunction - gets the TS solution evaluation function
569: Not Collective
571: Input Arguments:
572: . dm - DM to be used with TS
574: Output Parameters:
575: + func - solution function evaluation function, see TSSetSolution() for calling sequence
576: - ctx - context for solution evaluation
578: Level: advanced
580: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
581: @*/
582: PetscErrorCode DMTSGetSolutionFunction(DM dm,TSSolutionFunction *func,void **ctx)
583: {
585: DMTS tsdm;
589: DMGetDMTS(dm,&tsdm);
590: if (func) *func = tsdm->ops->solution;
591: if (ctx) *ctx = tsdm->solutionctx;
592: return(0);
593: }
597: /*@C
598: DMTSSetSolutionFunction - set TS solution evaluation function
600: Not Collective
602: Input Arguments:
603: + dm - DM to be used with TS
604: . func - solution function evaluation function, see TSSetSolution() for calling sequence
605: - ctx - context for solution evaluation
607: Level: advanced
609: Note:
610: TSSetSolutionFunction() is normally used, but it calls this function internally because the user context is actually
611: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
612: not. If DM took a more central role at some later date, this could become the primary method of setting the residual.
614: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
615: @*/
616: PetscErrorCode DMTSSetSolutionFunction(DM dm,TSSolutionFunction func,void *ctx)
617: {
619: DMTS tsdm;
623: DMGetDMTSWrite(dm,&tsdm);
624: if (func) tsdm->ops->solution = func;
625: if (ctx) tsdm->solutionctx = ctx;
626: return(0);
627: }
631: /*@C
632: DMTSSetForcingFunction - set TS forcing function evaluation function
634: Not Collective
636: Input Arguments:
637: + dm - DM to be used with TS
638: . f - forcing function evaluation function; see TSForcingFunction
639: - ctx - context for solution evaluation
641: Level: advanced
643: Note:
644: TSSetForcingFunction() is normally used, but it calls this function internally because the user context is actually
645: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
646: not. If DM took a more central role at some later date, this could become the primary method of setting the residual.
648: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian(), TSSetForcingFunction(), DMTSGetForcingFunction()
649: @*/
650: PetscErrorCode DMTSSetForcingFunction(DM dm,TSForcingFunction f,void *ctx)
651: {
653: DMTS tsdm;
657: DMGetDMTSWrite(dm,&tsdm);
658: if (f) tsdm->ops->forcing = f;
659: if (ctx) tsdm->forcingctx = ctx;
660: return(0);
661: }
666: /*@C
667: DMTSGetForcingFunction - get TS forcing function evaluation function
669: Not Collective
671: Input Argument:
672: . dm - DM to be used with TS
674: Output Arguments:
675: + f - forcing function evaluation function; see TSForcingFunction for details
676: - ctx - context for solution evaluation
678: Level: advanced
680: Note:
681: TSSetForcingFunction() is normally used, but it calls this function internally because the user context is actually
682: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
683: not. If DM took a more central role at some later date, this could become the primary method of setting the residual.
685: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian(), TSSetForcingFunction(), DMTSGetForcingFunction()
686: @*/
687: PetscErrorCode DMTSGetForcingFunction(DM dm,TSForcingFunction *f,void **ctx)
688: {
690: DMTS tsdm;
694: DMGetDMTSWrite(dm,&tsdm);
695: if (f) *f = tsdm->ops->forcing;
696: if (ctx) *ctx = tsdm->forcingctx;
697: return(0);
698: }
702: /*@C
703: DMTSGetRHSFunction - get TS explicit residual evaluation function
705: Not Collective
707: Input Argument:
708: . dm - DM to be used with TS
710: Output Arguments:
711: + func - residual evaluation function, see TSSetRHSFunction() for calling sequence
712: - ctx - context for residual evaluation
714: Level: advanced
716: Note:
717: TSGetFunction() is normally used, but it calls this function internally because the user context is actually
718: associated with the DM.
720: .seealso: DMTSSetContext(), DMTSSetFunction(), TSSetFunction()
721: @*/
722: PetscErrorCode DMTSGetRHSFunction(DM dm,TSRHSFunction *func,void **ctx)
723: {
725: DMTS tsdm;
729: DMGetDMTS(dm,&tsdm);
730: if (func) *func = tsdm->ops->rhsfunction;
731: if (ctx) *ctx = tsdm->rhsfunctionctx;
732: return(0);
733: }
737: /*@C
738: DMTSSetIJacobian - set TS Jacobian evaluation function
740: Not Collective
742: Input Argument:
743: + dm - DM to be used with TS
744: . func - Jacobian evaluation function, see TSSetIJacobian() for calling sequence
745: - ctx - context for residual evaluation
747: Level: advanced
749: Note:
750: TSSetJacobian() is normally used, but it calls this function internally because the user context is actually
751: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
752: not. If DM took a more central role at some later date, this could become the primary method of setting the Jacobian.
754: .seealso: DMTSSetContext(), TSSetFunction(), DMTSGetJacobian(), TSSetJacobian()
755: @*/
756: PetscErrorCode DMTSSetIJacobian(DM dm,TSIJacobian func,void *ctx)
757: {
759: DMTS sdm;
763: DMGetDMTSWrite(dm,&sdm);
764: if (func) sdm->ops->ijacobian = func;
765: if (ctx) sdm->ijacobianctx = ctx;
766: return(0);
767: }
771: /*@C
772: DMTSGetIJacobian - get TS Jacobian evaluation function
774: Not Collective
776: Input Argument:
777: . dm - DM to be used with TS
779: Output Arguments:
780: + func - Jacobian evaluation function, see TSSetIJacobian() for calling sequence
781: - ctx - context for residual evaluation
783: Level: advanced
785: Note:
786: TSGetJacobian() is normally used, but it calls this function internally because the user context is actually
787: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
788: not. If DM took a more central role at some later date, this could become the primary method of setting the Jacobian.
790: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
791: @*/
792: PetscErrorCode DMTSGetIJacobian(DM dm,TSIJacobian *func,void **ctx)
793: {
795: DMTS tsdm;
799: DMGetDMTS(dm,&tsdm);
800: if (func) *func = tsdm->ops->ijacobian;
801: if (ctx) *ctx = tsdm->ijacobianctx;
802: return(0);
803: }
808: /*@C
809: DMTSSetRHSJacobian - set TS Jacobian evaluation function
811: Not Collective
813: Input Argument:
814: + dm - DM to be used with TS
815: . func - Jacobian evaluation function, see TSSetRHSJacobian() for calling sequence
816: - ctx - context for residual evaluation
818: Level: advanced
820: Note:
821: TSSetJacobian() is normally used, but it calls this function internally because the user context is actually
822: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
823: not. If DM took a more central role at some later date, this could become the primary method of setting the Jacobian.
825: .seealso: DMTSSetContext(), TSSetFunction(), DMTSGetJacobian(), TSSetJacobian()
826: @*/
827: PetscErrorCode DMTSSetRHSJacobian(DM dm,TSRHSJacobian func,void *ctx)
828: {
830: DMTS tsdm;
834: DMGetDMTSWrite(dm,&tsdm);
835: if (func) tsdm->ops->rhsjacobian = func;
836: if (ctx) tsdm->rhsjacobianctx = ctx;
837: return(0);
838: }
842: /*@C
843: DMTSGetRHSJacobian - get TS Jacobian evaluation function
845: Not Collective
847: Input Argument:
848: . dm - DM to be used with TS
850: Output Arguments:
851: + func - Jacobian evaluation function, see TSSetRHSJacobian() for calling sequence
852: - ctx - context for residual evaluation
854: Level: advanced
856: Note:
857: TSGetJacobian() is normally used, but it calls this function internally because the user context is actually
858: associated with the DM. This makes the interface consistent regardless of whether the user interacts with a DM or
859: not. If DM took a more central role at some later date, this could become the primary method of setting the Jacobian.
861: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
862: @*/
863: PetscErrorCode DMTSGetRHSJacobian(DM dm,TSRHSJacobian *func,void **ctx)
864: {
866: DMTS tsdm;
870: DMGetDMTS(dm,&tsdm);
871: if (func) *func = tsdm->ops->rhsjacobian;
872: if (ctx) *ctx = tsdm->rhsjacobianctx;
873: return(0);
874: }
878: /*@C
879: DMTSSetIFunctionSerialize - sets functions used to view and load a IFunction context
881: Not Collective
883: Input Arguments:
884: + dm - DM to be used with TS
885: . view - viewer function
886: - load - loading function
888: Level: advanced
890: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
891: @*/
892: PetscErrorCode DMTSSetIFunctionSerialize(DM dm,PetscErrorCode (*view)(void*,PetscViewer),PetscErrorCode (*load)(void**,PetscViewer))
893: {
895: DMTS tsdm;
899: DMGetDMTSWrite(dm,&tsdm);
900: tsdm->ops->ifunctionview = view;
901: tsdm->ops->ifunctionload = load;
902: return(0);
903: }
907: /*@C
908: DMTSSetIJacobianSerialize - sets functions used to view and load a IJacobian context
910: Not Collective
912: Input Arguments:
913: + dm - DM to be used with TS
914: . view - viewer function
915: - load - loading function
917: Level: advanced
919: .seealso: DMTSSetContext(), TSSetFunction(), DMTSSetJacobian()
920: @*/
921: PetscErrorCode DMTSSetIJacobianSerialize(DM dm,PetscErrorCode (*view)(void*,PetscViewer),PetscErrorCode (*load)(void**,PetscViewer))
922: {
924: DMTS tsdm;
928: DMGetDMTSWrite(dm,&tsdm);
929: tsdm->ops->ijacobianview = view;
930: tsdm->ops->ijacobianload = load;
931: return(0);
932: }