Actual source code: tsevent.c

  1: #include <petsc/private/tsimpl.h>

  3: /*
  4:   TSEventInitialize - Initializes TSEvent for TSSolve
  5: */
  6: PetscErrorCode TSEventInitialize(TSEvent event, TS ts, PetscReal t, Vec U)
  7: {
  8:   PetscFunctionBegin;
  9:   if (!event) PetscFunctionReturn(PETSC_SUCCESS);
 13:   event->ptime_prev = t;
 14:   event->iterctr    = 0;
 15:   PetscCall((*event->eventhandler)(ts, t, U, event->fvalue_prev, event->ctx));
 16:   PetscFunctionReturn(PETSC_SUCCESS);
 17: }

 19: PetscErrorCode TSEventDestroy(TSEvent *event)
 20: {
 21:   PetscInt i;

 23:   PetscFunctionBegin;
 25:   if (!*event) PetscFunctionReturn(PETSC_SUCCESS);
 26:   if (--(*event)->refct > 0) {
 27:     *event = NULL;
 28:     PetscFunctionReturn(PETSC_SUCCESS);
 29:   }

 31:   PetscCall(PetscFree((*event)->fvalue));
 32:   PetscCall(PetscFree((*event)->fvalue_prev));
 33:   PetscCall(PetscFree((*event)->fvalue_right));
 34:   PetscCall(PetscFree((*event)->zerocrossing));
 35:   PetscCall(PetscFree((*event)->side));
 36:   PetscCall(PetscFree((*event)->direction));
 37:   PetscCall(PetscFree((*event)->terminate));
 38:   PetscCall(PetscFree((*event)->events_zero));
 39:   PetscCall(PetscFree((*event)->vtol));

 41:   for (i = 0; i < (*event)->recsize; i++) PetscCall(PetscFree((*event)->recorder.eventidx[i]));
 42:   PetscCall(PetscFree((*event)->recorder.eventidx));
 43:   PetscCall(PetscFree((*event)->recorder.nevents));
 44:   PetscCall(PetscFree((*event)->recorder.stepnum));
 45:   PetscCall(PetscFree((*event)->recorder.time));

 47:   PetscCall(PetscViewerDestroy(&(*event)->monitor));
 48:   PetscCall(PetscFree(*event));
 49:   PetscFunctionReturn(PETSC_SUCCESS);
 50: }

 52: /*@
 53:   TSSetPostEventIntervalStep - Set the time-step used immediately following the event interval

 55:   Logically Collective

 57:   Input Parameters:
 58: + ts - time integration context
 59: - dt - post event interval step

 61:   Options Database Key:
 62: . -ts_event_post_eventinterval_step <dt> time-step after event interval

 64:   Level: advanced

 66:   Notes:
 67:  `TSSetPostEventIntervalStep()` allows one to set a time-step that is used immediately following an event interval.

 69:   This function should be called from the postevent function set with `TSSetEventHandler()`.

 71:   The post event interval time-step should be selected based on the dynamics following the event.
 72:   If the dynamics are stiff, a conservative (small) step should be used.
 73:   If not, then a larger time-step can be used.

 75: .seealso: [](chapter_ts), `TS`, `TSEvent`, `TSSetEventHandler()`
 76: @*/
 77: PetscErrorCode TSSetPostEventIntervalStep(TS ts, PetscReal dt)
 78: {
 79:   PetscFunctionBegin;
 80:   ts->event->timestep_posteventinterval = dt;
 81:   PetscFunctionReturn(PETSC_SUCCESS);
 82: }

 84: /*@
 85:    TSSetEventTolerances - Set tolerances for event zero crossings when using event handler

 87:    Logically Collective

 89:    Input Parameters:
 90: +  ts - time integration context
 91: .  tol - scalar tolerance, `PETSC_DECIDE` to leave current value
 92: -  vtol - array of tolerances or NULL, used in preference to tol if present

 94:    Options Database Key:
 95: .  -ts_event_tol <tol> - tolerance for event zero crossing

 97:    Level: beginner

 99:    Notes:
100:    Must call `TSSetEventHandler(`) before setting the tolerances.

102:    The size of vtol is equal to the number of events.

104: .seealso: [](chapter_ts), `TS`, `TSEvent`, `TSSetEventHandler()`
105: @*/
106: PetscErrorCode TSSetEventTolerances(TS ts, PetscReal tol, PetscReal vtol[])
107: {
108:   TSEvent  event;
109:   PetscInt i;

111:   PetscFunctionBegin;
114:   PetscCheck(ts->event, PetscObjectComm((PetscObject)ts), PETSC_ERR_USER, "Must set the events first by calling TSSetEventHandler()");

116:   event = ts->event;
117:   if (vtol) {
118:     for (i = 0; i < event->nevents; i++) event->vtol[i] = vtol[i];
119:   } else {
120:     if ((tol != (PetscReal)PETSC_DECIDE) || (tol != (PetscReal)PETSC_DEFAULT)) {
121:       for (i = 0; i < event->nevents; i++) event->vtol[i] = tol;
122:     }
123:   }
124:   PetscFunctionReturn(PETSC_SUCCESS);
125: }

127: /*@C
128:    TSSetEventHandler - Sets a function used for detecting events

130:    Logically Collective

132:    Input Parameters:
133: +  ts - the `TS` context obtained from `TSCreate()`
134: .  nevents - number of local events
135: .  direction - direction of zero crossing to be detected. -1 => Zero crossing in negative direction,
136:                +1 => Zero crossing in positive direction, 0 => both ways (one for each event)
137: .  terminate - flag to indicate whether time stepping should be terminated after
138:                event is detected (one for each event)
139: .  eventhandler - event monitoring routine
140: .  postevent - [optional] post-event function
141: -  ctx       - [optional] user-defined context for private data for the
142:                event monitor and post event routine (use NULL if no
143:                context is desired)

145:    Calling sequence of eventhandler:
146:    PetscErrorCode PetscEventHandler(TS ts,PetscReal t,Vec U,PetscScalar fvalue[],void* ctx)

148:    Input Parameters:
149: +  ts  - the TS context
150: .  t   - current time
151: .  U   - current iterate
152: -  ctx - [optional] context passed with eventhandler

154:    Output parameters:
155: .  fvalue    - function value of events at time t

157:    Calling sequence of postevent:
158:    PetscErrorCode PostEvent(TS ts,PetscInt nevents_zero,PetscInt events_zero[],PetscReal t,Vec U,PetscBool forwardsolve,void* ctx)

160:    Input Parameters:
161: +  ts - the TS context
162: .  nevents_zero - number of local events whose event function is zero
163: .  events_zero  - indices of local events which have reached zero
164: .  t            - current time
165: .  U            - current solution
166: .  forwardsolve - Flag to indicate whether TS is doing a forward solve (1) or adjoint solve (0)
167: -  ctx          - the context passed with eventhandler

169:    Level: intermediate

171: .seealso: [](chapter_ts), `TSEvent`, `TSCreate()`, `TSSetTimeStep()`, `TSSetConvergedReason()`
172: @*/
173: PetscErrorCode TSSetEventHandler(TS ts, PetscInt nevents, PetscInt direction[], PetscBool terminate[], PetscErrorCode (*eventhandler)(TS, PetscReal, Vec, PetscScalar[], void *), PetscErrorCode (*postevent)(TS, PetscInt, PetscInt[], PetscReal, Vec, PetscBool, void *), void *ctx)
174: {
175:   TSAdapt   adapt;
176:   PetscReal hmin;
177:   TSEvent   event;
178:   PetscInt  i;
179:   PetscBool flg;
180: #if defined PETSC_USE_REAL_SINGLE
181:   PetscReal tol = 1e-4;
182: #else
183:   PetscReal tol = 1e-6;
184: #endif

186:   PetscFunctionBegin;
188:   if (nevents) {
191:   }

193:   PetscCall(PetscNew(&event));
194:   PetscCall(PetscMalloc1(nevents, &event->fvalue));
195:   PetscCall(PetscMalloc1(nevents, &event->fvalue_prev));
196:   PetscCall(PetscMalloc1(nevents, &event->fvalue_right));
197:   PetscCall(PetscMalloc1(nevents, &event->zerocrossing));
198:   PetscCall(PetscMalloc1(nevents, &event->side));
199:   PetscCall(PetscMalloc1(nevents, &event->direction));
200:   PetscCall(PetscMalloc1(nevents, &event->terminate));
201:   PetscCall(PetscMalloc1(nevents, &event->vtol));
202:   for (i = 0; i < nevents; i++) {
203:     event->direction[i]    = direction[i];
204:     event->terminate[i]    = terminate[i];
205:     event->zerocrossing[i] = PETSC_FALSE;
206:     event->side[i]         = 0;
207:   }
208:   PetscCall(PetscMalloc1(nevents, &event->events_zero));
209:   event->nevents                    = nevents;
210:   event->eventhandler               = eventhandler;
211:   event->postevent                  = postevent;
212:   event->ctx                        = ctx;
213:   event->timestep_posteventinterval = ts->time_step;
214:   PetscCall(TSGetAdapt(ts, &adapt));
215:   PetscCall(TSAdaptGetStepLimits(adapt, &hmin, NULL));
216:   event->timestep_min = hmin;

218:   event->recsize = 8; /* Initial size of the recorder */
219:   PetscOptionsBegin(((PetscObject)ts)->comm, ((PetscObject)ts)->prefix, "TS Event options", "TS");
220:   {
221:     PetscCall(PetscOptionsReal("-ts_event_tol", "Scalar event tolerance for zero crossing check", "TSSetEventTolerances", tol, &tol, NULL));
222:     PetscCall(PetscOptionsName("-ts_event_monitor", "Print choices made by event handler", "", &flg));
223:     PetscCall(PetscOptionsInt("-ts_event_recorder_initial_size", "Initial size of event recorder", "", event->recsize, &event->recsize, NULL));
224:     PetscCall(PetscOptionsReal("-ts_event_post_eventinterval_step", "Time step after event interval", "", event->timestep_posteventinterval, &event->timestep_posteventinterval, NULL));
225:     PetscCall(PetscOptionsReal("-ts_event_post_event_step", "Time step after event", "", event->timestep_postevent, &event->timestep_postevent, NULL));
226:     PetscCall(PetscOptionsReal("-ts_event_dt_min", "Minimum time step considered for TSEvent", "", event->timestep_min, &event->timestep_min, NULL));
227:   }
228:   PetscOptionsEnd();

230:   PetscCall(PetscMalloc1(event->recsize, &event->recorder.time));
231:   PetscCall(PetscMalloc1(event->recsize, &event->recorder.stepnum));
232:   PetscCall(PetscMalloc1(event->recsize, &event->recorder.nevents));
233:   PetscCall(PetscMalloc1(event->recsize, &event->recorder.eventidx));
234:   for (i = 0; i < event->recsize; i++) PetscCall(PetscMalloc1(event->nevents, &event->recorder.eventidx[i]));
235:   /* Initialize the event recorder */
236:   event->recorder.ctr = 0;

238:   for (i = 0; i < event->nevents; i++) event->vtol[i] = tol;
239:   if (flg) PetscCall(PetscViewerASCIIOpen(PETSC_COMM_SELF, "stdout", &event->monitor));

241:   PetscCall(TSEventDestroy(&ts->event));
242:   ts->event        = event;
243:   ts->event->refct = 1;
244:   PetscFunctionReturn(PETSC_SUCCESS);
245: }

247: /*
248:   TSEventRecorderResize - Resizes (2X) the event recorder arrays whenever the recording limit (event->recsize)
249:                           is reached.
250: */
251: static PetscErrorCode TSEventRecorderResize(TSEvent event)
252: {
253:   PetscReal *time;
254:   PetscInt  *stepnum;
255:   PetscInt  *nevents;
256:   PetscInt **eventidx;
257:   PetscInt   i, fact = 2;

259:   PetscFunctionBegin;

261:   /* Create large arrays */
262:   PetscCall(PetscMalloc1(fact * event->recsize, &time));
263:   PetscCall(PetscMalloc1(fact * event->recsize, &stepnum));
264:   PetscCall(PetscMalloc1(fact * event->recsize, &nevents));
265:   PetscCall(PetscMalloc1(fact * event->recsize, &eventidx));
266:   for (i = 0; i < fact * event->recsize; i++) PetscCall(PetscMalloc1(event->nevents, &eventidx[i]));

268:   /* Copy over data */
269:   PetscCall(PetscArraycpy(time, event->recorder.time, event->recsize));
270:   PetscCall(PetscArraycpy(stepnum, event->recorder.stepnum, event->recsize));
271:   PetscCall(PetscArraycpy(nevents, event->recorder.nevents, event->recsize));
272:   for (i = 0; i < event->recsize; i++) PetscCall(PetscArraycpy(eventidx[i], event->recorder.eventidx[i], event->recorder.nevents[i]));

274:   /* Destroy old arrays */
275:   for (i = 0; i < event->recsize; i++) PetscCall(PetscFree(event->recorder.eventidx[i]));
276:   PetscCall(PetscFree(event->recorder.eventidx));
277:   PetscCall(PetscFree(event->recorder.nevents));
278:   PetscCall(PetscFree(event->recorder.stepnum));
279:   PetscCall(PetscFree(event->recorder.time));

281:   /* Set pointers */
282:   event->recorder.time     = time;
283:   event->recorder.stepnum  = stepnum;
284:   event->recorder.nevents  = nevents;
285:   event->recorder.eventidx = eventidx;

287:   /* Double size */
288:   event->recsize *= fact;

290:   PetscFunctionReturn(PETSC_SUCCESS);
291: }

293: /*
294:    Helper routine to handle user postevents and recording
295: */
296: static PetscErrorCode TSPostEvent(TS ts, PetscReal t, Vec U)
297: {
298:   TSEvent   event     = ts->event;
299:   PetscBool terminate = PETSC_FALSE;
300:   PetscBool restart   = PETSC_FALSE;
301:   PetscInt  i, ctr, stepnum;
302:   PetscBool inflag[2], outflag[2];
303:   PetscBool forwardsolve = PETSC_TRUE; /* Flag indicating that TS is doing a forward solve */

305:   PetscFunctionBegin;
306:   if (event->postevent) {
307:     PetscObjectState state_prev, state_post;
308:     PetscCall(PetscObjectStateGet((PetscObject)U, &state_prev));
309:     PetscCall((*event->postevent)(ts, event->nevents_zero, event->events_zero, t, U, forwardsolve, event->ctx));
310:     PetscCall(PetscObjectStateGet((PetscObject)U, &state_post));
311:     if (state_prev != state_post) restart = PETSC_TRUE;
312:   }

314:   /* Handle termination events and step restart */
315:   for (i = 0; i < event->nevents_zero; i++)
316:     if (event->terminate[event->events_zero[i]]) terminate = PETSC_TRUE;
317:   inflag[0] = restart;
318:   inflag[1] = terminate;
319:   PetscCall(MPIU_Allreduce(inflag, outflag, 2, MPIU_BOOL, MPI_LOR, ((PetscObject)ts)->comm));
320:   restart   = outflag[0];
321:   terminate = outflag[1];
322:   if (restart) PetscCall(TSRestartStep(ts));
323:   if (terminate) PetscCall(TSSetConvergedReason(ts, TS_CONVERGED_EVENT));
324:   event->status = terminate ? TSEVENT_NONE : TSEVENT_RESET_NEXTSTEP;

326:   /* Reset event residual functions as states might get changed by the postevent callback */
327:   if (event->postevent) {
328:     PetscCall(VecLockReadPush(U));
329:     PetscCall((*event->eventhandler)(ts, t, U, event->fvalue, event->ctx));
330:     PetscCall(VecLockReadPop(U));
331:   }

333:   /* Cache current time and event residual functions */
334:   event->ptime_prev = t;
335:   for (i = 0; i < event->nevents; i++) event->fvalue_prev[i] = event->fvalue[i];

337:   /* Record the event in the event recorder */
338:   PetscCall(TSGetStepNumber(ts, &stepnum));
339:   ctr = event->recorder.ctr;
340:   if (ctr == event->recsize) PetscCall(TSEventRecorderResize(event));
341:   event->recorder.time[ctr]    = t;
342:   event->recorder.stepnum[ctr] = stepnum;
343:   event->recorder.nevents[ctr] = event->nevents_zero;
344:   for (i = 0; i < event->nevents_zero; i++) event->recorder.eventidx[ctr][i] = event->events_zero[i];
345:   event->recorder.ctr++;
346:   PetscFunctionReturn(PETSC_SUCCESS);
347: }

349: /* Uses Anderson-Bjorck variant of regula falsi method */
350: static inline PetscReal TSEventComputeStepSize(PetscReal tleft, PetscReal t, PetscReal tright, PetscScalar fleft, PetscScalar f, PetscScalar fright, PetscInt side, PetscReal dt)
351: {
352:   PetscReal new_dt, scal = 1.0;
353:   if (PetscRealPart(fleft) * PetscRealPart(f) < 0) {
354:     if (side == 1) {
355:       scal = (PetscRealPart(fright) - PetscRealPart(f)) / PetscRealPart(fright);
356:       if (scal < PETSC_SMALL) scal = 0.5;
357:     }
358:     new_dt = (scal * PetscRealPart(fleft) * t - PetscRealPart(f) * tleft) / (scal * PetscRealPart(fleft) - PetscRealPart(f)) - tleft;
359:   } else {
360:     if (side == -1) {
361:       scal = (PetscRealPart(fleft) - PetscRealPart(f)) / PetscRealPart(fleft);
362:       if (scal < PETSC_SMALL) scal = 0.5;
363:     }
364:     new_dt = (PetscRealPart(f) * tright - scal * PetscRealPart(fright) * t) / (PetscRealPart(f) - scal * PetscRealPart(fright)) - t;
365:   }
366:   return PetscMin(dt, new_dt);
367: }

369: static PetscErrorCode TSEventDetection(TS ts)
370: {
371:   TSEvent   event = ts->event;
372:   PetscReal t;
373:   PetscInt  i;
374:   PetscInt  fvalue_sign, fvalueprev_sign;
375:   PetscInt  in, out;

377:   PetscFunctionBegin;
378:   PetscCall(TSGetTime(ts, &t));
379:   for (i = 0; i < event->nevents; i++) {
380:     if (PetscAbsScalar(event->fvalue[i]) < event->vtol[i]) {
381:       if (!event->iterctr) event->zerocrossing[i] = PETSC_TRUE;
382:       event->status = TSEVENT_LOCATED_INTERVAL;
383:       if (event->monitor) {
384:         PetscCall(PetscViewerASCIIPrintf(event->monitor, "TSEvent: iter %" PetscInt_FMT " - Event %" PetscInt_FMT " interval detected due to zero value (tol=%g) [%g - %g]\n", event->iterctr, i, (double)event->vtol[i], (double)event->ptime_prev, (double)t));
385:       }
386:       continue;
387:     }
388:     if (PetscAbsScalar(event->fvalue_prev[i]) < event->vtol[i]) continue; /* avoid duplicative detection if the previous endpoint is an event location */
389:     fvalue_sign     = PetscSign(PetscRealPart(event->fvalue[i]));
390:     fvalueprev_sign = PetscSign(PetscRealPart(event->fvalue_prev[i]));
391:     if (fvalueprev_sign != 0 && (fvalue_sign != fvalueprev_sign)) {
392:       if (!event->iterctr) event->zerocrossing[i] = PETSC_TRUE;
393:       event->status = TSEVENT_LOCATED_INTERVAL;
394:       if (event->monitor) PetscCall(PetscViewerASCIIPrintf(event->monitor, "TSEvent: iter %" PetscInt_FMT " - Event %" PetscInt_FMT " interval detected due to sign change [%g - %g]\n", event->iterctr, i, (double)event->ptime_prev, (double)t));
395:     }
396:   }
397:   in = (PetscInt)event->status;
398:   PetscCall(MPIU_Allreduce(&in, &out, 1, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject)ts)));
399:   event->status = (TSEventStatus)out;
400:   PetscFunctionReturn(PETSC_SUCCESS);
401: }

403: static PetscErrorCode TSEventLocation(TS ts, PetscReal *dt)
404: {
405:   TSEvent   event = ts->event;
406:   PetscInt  i;
407:   PetscReal t;
408:   PetscInt  fvalue_sign, fvalueprev_sign;
409:   PetscInt  rollback = 0, in[2], out[2];

411:   PetscFunctionBegin;
412:   PetscCall(TSGetTime(ts, &t));
413:   event->nevents_zero = 0;
414:   for (i = 0; i < event->nevents; i++) {
415:     if (event->zerocrossing[i]) {
416:       if (PetscAbsScalar(event->fvalue[i]) < event->vtol[i] || *dt < event->timestep_min || PetscAbsReal((*dt) / ((event->ptime_right - event->ptime_prev) / 2)) < event->vtol[i]) { /* stopping criteria */
417:         event->status          = TSEVENT_ZERO;
418:         event->fvalue_right[i] = event->fvalue[i];
419:         continue;
420:       }
421:       /* Compute new time step */
422:       *dt             = TSEventComputeStepSize(event->ptime_prev, t, event->ptime_right, event->fvalue_prev[i], event->fvalue[i], event->fvalue_right[i], event->side[i], *dt);
423:       fvalue_sign     = PetscSign(PetscRealPart(event->fvalue[i]));
424:       fvalueprev_sign = PetscSign(PetscRealPart(event->fvalue_prev[i]));
425:       switch (event->direction[i]) {
426:       case -1:
427:         if (fvalue_sign < 0) {
428:           rollback               = 1;
429:           event->fvalue_right[i] = event->fvalue[i];
430:           event->side[i]         = 1;
431:         }
432:         break;
433:       case 1:
434:         if (fvalue_sign > 0) {
435:           rollback               = 1;
436:           event->fvalue_right[i] = event->fvalue[i];
437:           event->side[i]         = 1;
438:         }
439:         break;
440:       case 0:
441:         if (fvalue_sign != fvalueprev_sign) { /* trigger rollback only when there is a sign change */
442:           rollback               = 1;
443:           event->fvalue_right[i] = event->fvalue[i];
444:           event->side[i]         = 1;
445:         }
446:         break;
447:       }
448:       if (event->status == TSEVENT_PROCESSING) event->side[i] = -1;
449:     }
450:   }
451:   in[0] = (PetscInt)event->status;
452:   in[1] = rollback;
453:   PetscCall(MPIU_Allreduce(in, out, 2, MPIU_INT, MPI_MAX, PetscObjectComm((PetscObject)ts)));
454:   event->status = (TSEventStatus)out[0];
455:   rollback      = out[1];
456:   /* If rollback is true, the status will be overwritten so that an event at the endtime of current time step will be postponed to guarantee correct order */
457:   if (rollback) event->status = TSEVENT_LOCATED_INTERVAL;
458:   if (event->status == TSEVENT_ZERO) {
459:     for (i = 0; i < event->nevents; i++) {
460:       if (event->zerocrossing[i]) {
461:         if (PetscAbsScalar(event->fvalue[i]) < event->vtol[i] || *dt < event->timestep_min || PetscAbsReal((*dt) / ((event->ptime_right - event->ptime_prev) / 2)) < event->vtol[i]) { /* stopping criteria */
462:           event->events_zero[event->nevents_zero++] = i;
463:           if (event->monitor) PetscCall(PetscViewerASCIIPrintf(event->monitor, "TSEvent: iter %" PetscInt_FMT " - Event %" PetscInt_FMT " zero crossing located at time %g\n", event->iterctr, i, (double)t));
464:           event->zerocrossing[i] = PETSC_FALSE;
465:         }
466:       }
467:       event->side[i] = 0;
468:     }
469:   }
470:   PetscFunctionReturn(PETSC_SUCCESS);
471: }

473: PetscErrorCode TSEventHandler(TS ts)
474: {
475:   TSEvent   event;
476:   PetscReal t;
477:   Vec       U;
478:   PetscInt  i;
479:   PetscReal dt, dt_min, dt_reset = 0.0;

481:   PetscFunctionBegin;
483:   if (!ts->event) PetscFunctionReturn(PETSC_SUCCESS);
484:   event = ts->event;

486:   PetscCall(TSGetTime(ts, &t));
487:   PetscCall(TSGetTimeStep(ts, &dt));
488:   PetscCall(TSGetSolution(ts, &U));

490:   if (event->status == TSEVENT_NONE) {
491:     event->timestep_prev = dt;
492:     event->ptime_end     = t;
493:   }
494:   if (event->status == TSEVENT_RESET_NEXTSTEP) {
495:     /* user has specified a PostEventInterval dt */
496:     dt = event->timestep_posteventinterval;
497:     if (ts->exact_final_time == TS_EXACTFINALTIME_MATCHSTEP) {
498:       PetscReal maxdt = ts->max_time - t;
499:       dt              = dt > maxdt ? maxdt : (PetscIsCloseAtTol(dt, maxdt, 10 * PETSC_MACHINE_EPSILON, 0) ? maxdt : dt);
500:     }
501:     PetscCall(TSSetTimeStep(ts, dt));
502:     event->status = TSEVENT_NONE;
503:   }

505:   PetscCall(VecLockReadPush(U));
506:   PetscCall((*event->eventhandler)(ts, t, U, event->fvalue, event->ctx));
507:   PetscCall(VecLockReadPop(U));

509:   /* Detect the events */
510:   PetscCall(TSEventDetection(ts));

512:   /* Locate the events */
513:   if (event->status == TSEVENT_LOCATED_INTERVAL || event->status == TSEVENT_PROCESSING) {
514:     /* Approach the zero crosing by setting a new step size */
515:     PetscCall(TSEventLocation(ts, &dt));
516:     /* Roll back when new events are detected */
517:     if (event->status == TSEVENT_LOCATED_INTERVAL) {
518:       PetscCall(TSRollBack(ts));
519:       PetscCall(TSSetConvergedReason(ts, TS_CONVERGED_ITERATING));
520:       event->iterctr++;
521:     }
522:     PetscCall(MPIU_Allreduce(&dt, &dt_min, 1, MPIU_REAL, MPIU_MIN, PetscObjectComm((PetscObject)ts)));
523:     if (dt_reset > 0.0 && dt_reset < dt_min) dt_min = dt_reset;
524:     PetscCall(TSSetTimeStep(ts, dt_min));
525:     /* Found the zero crossing */
526:     if (event->status == TSEVENT_ZERO) {
527:       PetscCall(TSPostEvent(ts, t, U));

529:       dt = event->ptime_end - t;
530:       if (PetscAbsReal(dt) < PETSC_SMALL) { /* we hit the event, continue with the candidate time step */
531:         dt            = event->timestep_prev;
532:         event->status = TSEVENT_NONE;
533:       }
534:       if (event->timestep_postevent) { /* user has specified a PostEvent dt*/
535:         dt = event->timestep_postevent;
536:       }
537:       if (ts->exact_final_time == TS_EXACTFINALTIME_MATCHSTEP) {
538:         PetscReal maxdt = ts->max_time - t;
539:         dt              = dt > maxdt ? maxdt : (PetscIsCloseAtTol(dt, maxdt, 10 * PETSC_MACHINE_EPSILON, 0) ? maxdt : dt);
540:       }
541:       PetscCall(TSSetTimeStep(ts, dt));
542:       event->iterctr = 0;
543:     }
544:     /* Have not found the zero crosing yet */
545:     if (event->status == TSEVENT_PROCESSING) {
546:       if (event->monitor) PetscCall(PetscViewerASCIIPrintf(event->monitor, "TSEvent: iter %" PetscInt_FMT " - Stepping forward as no event detected in interval [%g - %g]\n", event->iterctr, (double)event->ptime_prev, (double)t));
547:       event->iterctr++;
548:     }
549:   }
550:   if (event->status == TSEVENT_LOCATED_INTERVAL) { /* The step has been rolled back */
551:     event->status      = TSEVENT_PROCESSING;
552:     event->ptime_right = t;
553:   } else {
554:     for (i = 0; i < event->nevents; i++) event->fvalue_prev[i] = event->fvalue[i];
555:     event->ptime_prev = t;
556:   }
557:   PetscFunctionReturn(PETSC_SUCCESS);
558: }

560: PetscErrorCode TSAdjointEventHandler(TS ts)
561: {
562:   TSEvent   event;
563:   PetscReal t;
564:   Vec       U;
565:   PetscInt  ctr;
566:   PetscBool forwardsolve = PETSC_FALSE; /* Flag indicating that TS is doing an adjoint solve */

568:   PetscFunctionBegin;
570:   if (!ts->event) PetscFunctionReturn(PETSC_SUCCESS);
571:   event = ts->event;

573:   PetscCall(TSGetTime(ts, &t));
574:   PetscCall(TSGetSolution(ts, &U));

576:   ctr = event->recorder.ctr - 1;
577:   if (ctr >= 0 && PetscAbsReal(t - event->recorder.time[ctr]) < PETSC_SMALL) {
578:     /* Call the user postevent function */
579:     if (event->postevent) {
580:       PetscCall((*event->postevent)(ts, event->recorder.nevents[ctr], event->recorder.eventidx[ctr], t, U, forwardsolve, event->ctx));
581:       event->recorder.ctr--;
582:     }
583:   }

585:   PetscCall(PetscBarrier((PetscObject)ts));
586:   PetscFunctionReturn(PETSC_SUCCESS);
587: }

589: /*@
590:   TSGetNumEvents - Get the numbers of events set

592:   Logically Collective

594:   Input Parameter:
595: . ts - the `TS` context

597:   Output Parameter:
598: . nevents - number of events

600:   Level: intermediate

602: .seealso: [](chapter_ts), `TSEvent`, `TSSetEventHandler()`
603: @*/
604: PetscErrorCode TSGetNumEvents(TS ts, PetscInt *nevents)
605: {
606:   PetscFunctionBegin;
607:   *nevents = ts->event->nevents;
608:   PetscFunctionReturn(PETSC_SUCCESS);
609: }