3#ifndef OPM_ADAPTIVE_TIME_STEPPING_EBOS_HPP
4#define OPM_ADAPTIVE_TIME_STEPPING_EBOS_HPP
9#include <opm/simulators/timestepping/SimulatorReport.hpp>
10#include <opm/grid/utility/StopWatch.hpp>
11#include <opm/common/OpmLog/OpmLog.hpp>
12#include <opm/common/ErrorMacros.hpp>
13#include <opm/simulators/timestepping/SimulatorTimer.hpp>
14#include <opm/simulators/timestepping/AdaptiveSimulatorTimer.hpp>
15#include <opm/simulators/timestepping/TimeStepControlInterface.hpp>
16#include <opm/simulators/timestepping/TimeStepControl.hpp>
17#include <opm/core/props/phaseUsageFromDeck.hpp>
18#include <opm/input/eclipse/Schedule/ScheduleState.hpp>
19#include <opm/common/Exceptions.hpp>
21namespace Opm::Properties {
27template<
class TypeTag,
class MyTypeTag>
29 using type = UndefinedProperty;
31template<
class TypeTag,
class MyTypeTag>
33 using type = UndefinedProperty;
35template<
class TypeTag,
class MyTypeTag>
37 using type = UndefinedProperty;
39template<
class TypeTag,
class MyTypeTag>
41 using type = UndefinedProperty;
43template<
class TypeTag,
class MyTypeTag>
45 using type = UndefinedProperty;
47template<
class TypeTag,
class MyTypeTag>
49 using type = UndefinedProperty;
51template<
class TypeTag,
class MyTypeTag>
53 using type = UndefinedProperty;
55template<
class TypeTag,
class MyTypeTag>
57 using type = UndefinedProperty;
59template<
class TypeTag,
class MyTypeTag>
61 using type = UndefinedProperty;
63template<
class TypeTag,
class MyTypeTag>
65 using type = UndefinedProperty;
67template<
class TypeTag,
class MyTypeTag>
69 using type = UndefinedProperty;
71template<
class TypeTag,
class MyTypeTag>
73 using type = UndefinedProperty;
75template<
class TypeTag,
class MyTypeTag>
77 using type = UndefinedProperty;
79template<
class TypeTag,
class MyTypeTag>
81 using type = UndefinedProperty;
83template<
class TypeTag,
class MyTypeTag>
85 using type = UndefinedProperty;
87template<
class TypeTag,
class MyTypeTag>
89 using type = UndefinedProperty;
91template<
class TypeTag,
class MyTypeTag>
93 using type = UndefinedProperty;
95template<
class TypeTag,
class MyTypeTag>
97 using type = UndefinedProperty;
99template<
class TypeTag,
class MyTypeTag>
101 using type = UndefinedProperty;
103template<
class TypeTag,
class MyTypeTag>
105 using type = UndefinedProperty;
107template<
class TypeTag,
class MyTypeTag>
109 using type = UndefinedProperty;
111template<
class TypeTag,
class MyTypeTag>
113 using type = UndefinedProperty;
115template<
class TypeTag,
class MyTypeTag>
117 using type = UndefinedProperty;
120template<
class TypeTag>
122 using type = GetPropType<TypeTag, Scalar>;
123 static constexpr type value = 0.33;
125template<
class TypeTag>
127 using type = GetPropType<TypeTag, Scalar>;
128 static constexpr type value = 2.0;
130template<
class TypeTag>
132 using type = GetPropType<TypeTag, Scalar>;
133 static constexpr type value = 3.0;
135template<
class TypeTag>
137 using type = GetPropType<TypeTag, Scalar>;
138 static constexpr type value = 365.0;
140template<
class TypeTag>
142 using type = GetPropType<TypeTag, Scalar>;
143 static constexpr type value = 1.0e-12;
145template<
class TypeTag>
147 static constexpr bool value =
false;
149template<
class TypeTag>
151 static constexpr int value = 10;
153template<
class TypeTag>
155 static constexpr int value = 1;
157template<
class TypeTag>
159 static constexpr int value = 1;
161template<
class TypeTag>
163 using type = GetPropType<TypeTag, Scalar>;
164 static constexpr type value = 1.0;
166template<
class TypeTag>
168 static constexpr bool value =
false;
170template<
class TypeTag>
172 using type = GetPropType<TypeTag, Scalar>;
173 static constexpr type value = -1.0;
175template<
class TypeTag>
177 static constexpr auto value =
"pid+newtoniteration";
179template<
class TypeTag>
181 using type = GetPropType<TypeTag, Scalar>;
182 static constexpr type value = 1e-1;
184template<
class TypeTag>
186 static constexpr int value = 30;
188template<
class TypeTag>
190 static constexpr int value = 8;
192template<
class TypeTag>
194 using type = GetPropType<TypeTag, Scalar>;
195 static constexpr type value = 0.75;
197template<
class TypeTag>
199 using type = GetPropType<TypeTag, Scalar>;
200 static constexpr type value = 1.25;
202template<
class TypeTag>
204 using type = GetPropType<TypeTag, Scalar>;
205 static constexpr type value = 1.0;
207template<
class TypeTag>
209 using type = GetPropType<TypeTag, Scalar>;
210 static constexpr type value = 3.2;
212template<
class TypeTag>
214 static constexpr auto value =
"timesteps";
216template<
class TypeTag>
218 using type = GetPropType<TypeTag, Scalar>;
219 static constexpr type value = 0.01;
222template<
class TypeTag>
224 using type = GetPropType<TypeTag, Scalar>;
225 static constexpr type value = 0.0;
235 template<
class TypeTag>
238 template <
class Solver>
241 const Solver& solver_;
243 SolutionTimeErrorSolverWrapperEbos(
const Solver& solver)
248 double relativeChange()
const
249 {
return solver_.model().relativeChange(); }
253 void logException_(
const E& exception,
bool verbose)
257 message =
"Caught Exception: ";
258 message += exception.what();
259 OpmLog::debug(message);
266 const bool terminalOutput =
true)
268 ,
restartFactor_(EWOMS_GET_PARAM(TypeTag, double, SolverRestartFactor))
269 ,
growthFactor_(EWOMS_GET_PARAM(TypeTag, double, SolverGrowthFactor))
270 ,
maxGrowth_(EWOMS_GET_PARAM(TypeTag, double, SolverMaxGrowth))
271 ,
maxTimeStep_(EWOMS_GET_PARAM(TypeTag, double, SolverMaxTimeStepInDays)*24*60*60)
272 ,
minTimeStep_(unitSystem.to_si(UnitSystem::measure::time, EWOMS_GET_PARAM(TypeTag, double, SolverMinTimeStep)))
275 ,
solverVerbose_(EWOMS_GET_PARAM(TypeTag, int, SolverVerbosity) > 0 && terminalOutput)
276 ,
timestepVerbose_(EWOMS_GET_PARAM(TypeTag, int, TimeStepVerbosity) > 0 && terminalOutput)
281 , minTimeStepBeforeShuttingProblematicWells_(EWOMS_GET_PARAM(TypeTag, double, MinTimeStepBeforeShuttingProblematicWellsInDays)*unit::day)
293 const Tuning& tuning,
294 const UnitSystem& unitSystem,
295 const bool terminalOutput =
true)
304 ,
solverVerbose_(EWOMS_GET_PARAM(TypeTag, int, SolverVerbosity) > 0 && terminalOutput)
305 ,
timestepVerbose_(EWOMS_GET_PARAM(TypeTag, int, TimeStepVerbosity) > 0 && terminalOutput)
310 , minTimeStepBeforeShuttingProblematicWells_(EWOMS_GET_PARAM(TypeTag, double, MinTimeStepBeforeShuttingProblematicWellsInDays)*unit::day)
315 static void registerParameters()
318 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverRestartFactor,
319 "The factor time steps are elongated after restarts");
320 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverGrowthFactor,
321 "The factor time steps are elongated after a successful substep");
322 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMaxGrowth,
323 "The maximum factor time steps are elongated after a report step");
324 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMaxTimeStepInDays,
325 "The maximum size of a time step in days");
326 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMinTimeStep,
327 "The minimum size of a time step in days for field and metric and hours for lab. If a step cannot converge without getting cut below this step size the simulator will stop");
328 EWOMS_REGISTER_PARAM(TypeTag,
bool, SolverContinueOnConvergenceFailure,
329 "Continue instead of stop when minimum solver time step is reached");
330 EWOMS_REGISTER_PARAM(TypeTag,
int, SolverMaxRestarts,
331 "The maximum number of breakdowns before a substep is given up and the simulator is terminated");
332 EWOMS_REGISTER_PARAM(TypeTag,
int, SolverVerbosity,
333 "Specify the \"chattiness\" of the non-linear solver itself");
334 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepVerbosity,
335 "Specify the \"chattiness\" during the time integration");
336 EWOMS_REGISTER_PARAM(TypeTag,
double, InitialTimeStepInDays,
337 "The size of the initial time step in days");
338 EWOMS_REGISTER_PARAM(TypeTag,
bool, FullTimeStepInitially,
339 "Always attempt to finish a report step using a single substep");
340 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepAfterEventInDays,
341 "Time step size of the first time step after an event occurs during the simulation in days");
342 EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControl,
343 "The algorithm used to determine time-step sizes. valid options are: 'pid' (default), 'pid+iteration', 'pid+newtoniteration', 'iterationcount', 'newtoniterationcount' and 'hardcoded'");
344 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlTolerance,
345 "The tolerance used by the time step size control algorithm");
346 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepControlTargetIterations,
347 "The number of linear iterations which the time step control scheme should aim for (if applicable)");
348 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations,
349 "The number of Newton iterations which the time step control scheme should aim for (if applicable)");
350 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlDecayRate,
351 "The decay rate of the time step size of the number of target iterations is exceeded");
352 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlGrowthRate,
353 "The growth rate of the time step size of the number of target iterations is undercut");
354 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor,
355 "The decay rate of the time step decrease when the target iterations is exceeded");
356 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor,
357 "The growth rate of the time step increase when the target iterations is undercut");
358 EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControlFileName,
359 "The name of the file which contains the hardcoded time steps sizes");
360 EWOMS_REGISTER_PARAM(TypeTag,
double, MinTimeStepBeforeShuttingProblematicWellsInDays,
361 "The minimum time step size in days for which problematic wells are not shut");
362 EWOMS_REGISTER_PARAM(TypeTag,
double, MinTimeStepBasedOnNewtonIterations,
363 "The minimum time step size (in days for field and metric unit and hours for lab unit) can be reduced to based on newton iteration counts");
369 template <
class Solver>
373 const std::vector<int>* fipnum =
nullptr)
392 auto& ebosSimulator = solver.model().ebosSimulator();
393 auto& ebosProblem = ebosSimulator.problem();
402 while (!substepTimer.
done()) {
406 logTimer(substepTimer);
410 std::string causeOfFailure =
"";
412 substepReport = solver.step(substepTimer);
415 OpmLog::debug(
"Overall linear iterations used: " + std::to_string(substepReport.total_linear_iterations));
418 catch (
const TooManyIterations& e) {
419 substepReport = solver.failureReport();
420 causeOfFailure =
"Solver convergence failure - Iteration limit reached";
425 catch (
const LinearSolverProblem& e) {
426 substepReport = solver.failureReport();
427 causeOfFailure =
"Linear solver convergence failure";
432 catch (
const NumericalIssue& e) {
433 substepReport = solver.failureReport();
434 causeOfFailure =
"Solver convergence failure - Numerical problem encountered";
439 catch (
const std::runtime_error& e) {
440 substepReport = solver.failureReport();
445 catch (
const Dune::ISTLError& e) {
446 substepReport = solver.failureReport();
451 catch (
const Dune::MatrixBlockError& e) {
452 substepReport = solver.failureReport();
459 ebosSimulator.problem().setSubStepReport(substepReport);
461 report += substepReport;
465 if (continue_on_uncoverged_solution) {
466 const auto msg = std::string(
"Solver failed to converge but timestep ")
467 + std::to_string(dt) +
" is smaller or equal to "
468 + std::to_string(
minTimeStep_) +
"\n which is the minimum threshold given"
469 +
"by option --solver-min-time-step= \n";
475 if (substepReport.converged || continue_on_uncoverged_solution) {
481 SolutionTimeErrorSolverWrapperEbos<Solver> relativeChange(solver);
485 : substepReport.total_linear_iterations;
486 double dtEstimate =
timeStepControl_->computeTimeStepSize(dt, iterations, relativeChange,
489 assert(dtEstimate > 0);
491 dtEstimate = std::min(dtEstimate,
double(
maxGrowth_ * dt));
492 assert(dtEstimate > 0);
502 if (solver.model().wellModel().hasTHPConstraints()) {
503 const double maxPredictionTHPTimestep = 16.0 * unit::day;
504 dtEstimate = std::min(dtEstimate, maxPredictionTHPTimestep);
506 assert(dtEstimate > 0);
508 std::ostringstream ss;
510 OpmLog::info(ss.str());
517 if (!substepTimer.
done()) {
519 solver.computeFluidInPlace(*fipnum);
521 time::StopWatch perfTimer;
524 ebosProblem.writeOutput();
526 report.success.output_write_time += perfTimer.secsSinceStart();
532 report.success.converged = substepTimer.
done();
542 const auto msg = std::string(
"Solver failed to converge after cutting timestep ")
543 + std::to_string(restarts) +
" times.";
547 OPM_THROW_NOLOG(NumericalIssue, msg);
557 const auto msg = std::string(
"Solver failed to converge after cutting timestep to ")
558 + std::to_string(
minTimeStep_) +
"\n which is the minimum threshold given"
559 +
"by option --solver-min-time-step= \n";
563 OPM_THROW_NOLOG(NumericalIssue, msg);
567 auto chopTimestep = [&]() {
571 msg = causeOfFailure +
"\nTimestep chopped to "
572 + std::to_string(unit::convert::to(substepTimer.
currentStepLength(), unit::day)) +
" days\n";
573 OpmLog::problem(msg);
578 const double minimumChoppedTimestep = minTimeStepBeforeShuttingProblematicWells_;
579 if (newTimeStep > minimumChoppedTimestep) {
584 std::set<std::string> failing_wells = consistentlyFailingWells(solver.model().stepReports());
585 if (failing_wells.empty()) {
590 int num_shut_wells = 0;
591 for (
const auto& well : failing_wells) {
592 bool was_shut = solver.model().wellModel().forceShutWellByName(well, substepTimer.
simulationTimeElapsed());
597 if (num_shut_wells == 0) {
605 msg =
"\nProblematic well(s) were shut: ";
606 for (
const auto& well : failing_wells) {
610 msg +=
"(retrying timestep)\n";
611 OpmLog::problem(msg);
623 std::ostringstream ss;
625 ss <<
"Suggested next step size = " << unit::convert::to(
suggestedNextTimestep_, unit::day) <<
" (days)" << std::endl;
626 OpmLog::debug(ss.str());
641 void setSuggestedNextStep(
const double x)
644 void updateTUNING(
double max_next_tstep,
const Tuning& tuning)
656 void init_(
const UnitSystem& unitSystem)
659 std::string control = EWOMS_GET_PARAM(TypeTag, std::string, TimeStepControl);
661 const double tol = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlTolerance);
662 if (control ==
"pid") {
665 else if (control ==
"pid+iteration") {
666 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetIterations);
667 const double decayDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor);
668 const double growthDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor);
669 timeStepControl_ = TimeStepControlType(
new PIDAndIterationCountTimeStepControl(iterations, decayDampingFactor, growthDampingFactor, tol));
671 else if (control ==
"pid+newtoniteration") {
672 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations);
673 const double decayDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor);
674 const double growthDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor);
675 const double nonDimensionalMinTimeStepIterations = EWOMS_GET_PARAM(TypeTag,
double, MinTimeStepBasedOnNewtonIterations);
677 double minTimeStepReducedByIterations = unitSystem.to_si(UnitSystem::measure::time, nonDimensionalMinTimeStepIterations);
678 timeStepControl_ = TimeStepControlType(
new PIDAndIterationCountTimeStepControl(iterations, decayDampingFactor,
679 growthDampingFactor, tol, minTimeStepReducedByIterations));
682 else if (control ==
"iterationcount") {
683 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetIterations);
684 const double decayrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayRate);
685 const double growthrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthRate);
686 timeStepControl_ = TimeStepControlType(
new SimpleIterationCountTimeStepControl(iterations, decayrate, growthrate));
688 else if (control ==
"newtoniterationcount") {
689 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations);
690 const double decayrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayRate);
691 const double growthrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthRate);
692 timeStepControl_ = TimeStepControlType(
new SimpleIterationCountTimeStepControl(iterations, decayrate, growthrate));
695 else if (control ==
"hardcoded") {
696 const std::string filename = EWOMS_GET_PARAM(TypeTag, std::string, TimeStepControlFileName);
697 timeStepControl_ = TimeStepControlType(
new HardcodedTimeStepControl(filename));
701 OPM_THROW(std::runtime_error,
"Unsupported time step control selected "<< control);
707 template <
class ProblemType>
708 std::set<std::string> consistentlyFailingWells(
const std::vector<ProblemType>& sr)
712 std::ostringstream msg;
713 msg <<
" Excessive chopping detected in report step "
714 << sr.back().report_step <<
", substep " << sr.back().current_step <<
"\n";
716 std::set<std::string> failing_wells;
720 if(sr.back().report.empty())
721 return failing_wells;
723 const auto& wfs = sr.back().report.back().wellFailures();
724 for (
const auto& wf : wfs) {
725 msg <<
" Well that failed: " << wf.wellName() <<
"\n";
728 OpmLog::debug(msg.str());
731 const int num_steps = 3;
732 const int rep_step = sr.back().report_step;
733 const int sub_step = sr.back().current_step;
734 const int sr_size = sr.size();
735 if (sr_size >= num_steps) {
736 for (
const auto& wf : wfs) {
737 failing_wells.insert(wf.wellName());
739 for (
int s = 1; s < num_steps; ++s) {
740 const auto& srep = sr[sr_size - 1 - s];
743 if (srep.report_step != rep_step || srep.current_step != sub_step) {
747 std::set<std::string> failing_wells_step;
748 for (
const auto& wf : srep.report.back().wellFailures()) {
749 if (failing_wells.count(wf.wellName()) > 0) {
750 failing_wells_step.insert(wf.wellName());
753 failing_wells.swap(failing_wells_step);
756 return failing_wells;
759 typedef std::unique_ptr<TimeStepControlInterface> TimeStepControlType;
775 double minTimeStepBeforeShuttingProblematicWells_;
Simulation timer for adaptive time stepping.
Definition: AdaptiveSimulatorTimer.hpp:41
bool done() const
Definition: AdaptiveSimulatorTimer.cpp:130
double currentStepLength() const
Definition: AdaptiveSimulatorTimer.cpp:112
void provideTimeStepEstimate(const double dt_estimate)
provide and estimate for new time step size
Definition: AdaptiveSimulatorTimer.cpp:76
void report(std::ostream &os) const
report start and end time as well as used steps so far
Definition: AdaptiveSimulatorTimer.cpp:157
double simulationTimeElapsed() const
Definition: AdaptiveSimulatorTimer.cpp:128
void setLastStepFailed(bool lastStepFailed)
tell the timestepper whether timestep failed or not
Definition: AdaptiveSimulatorTimer.hpp:104
Definition: AdaptiveTimeSteppingEbos.hpp:237
double maxTimeStep_
maximal allowed time step size in days
Definition: AdaptiveTimeSteppingEbos.hpp:765
double growthFactor_
factor to multiply time step when solver recovered from failed convergence
Definition: AdaptiveTimeSteppingEbos.hpp:763
double minTimeStep_
minimal allowed time step size before throwing
Definition: AdaptiveTimeSteppingEbos.hpp:766
bool fullTimestepInitially_
beginning with the size of the time step from data file
Definition: AdaptiveTimeSteppingEbos.hpp:772
double suggestedNextStep() const
Returns the simulator report for the failed substeps of the last report step.
Definition: AdaptiveTimeSteppingEbos.hpp:638
int solverRestartMax_
how many restart of solver are allowed
Definition: AdaptiveTimeSteppingEbos.hpp:768
double timestepAfterEvent_
suggested size of timestep after an event
Definition: AdaptiveTimeSteppingEbos.hpp:773
TimeStepControlType timeStepControl_
time step control object
Definition: AdaptiveTimeSteppingEbos.hpp:761
AdaptiveTimeSteppingEbos(const UnitSystem &unitSystem, const bool terminalOutput=true)
contructor taking parameter object
Definition: AdaptiveTimeSteppingEbos.hpp:265
bool timestepVerbose_
timestep verbosity
Definition: AdaptiveTimeSteppingEbos.hpp:770
bool ignoreConvergenceFailure_
continue instead of stop when minimum time step is reached
Definition: AdaptiveTimeSteppingEbos.hpp:767
double restartFactor_
factor to multiply time step with when solver fails to converge
Definition: AdaptiveTimeSteppingEbos.hpp:762
SimulatorReport step(const SimulatorTimer &simulatorTimer, Solver &solver, const bool isEvent, const std::vector< int > *fipnum=nullptr)
step method that acts like the solver::step method in a sub cycle of time steps
Definition: AdaptiveTimeSteppingEbos.hpp:370
bool solverVerbose_
solver verbosity
Definition: AdaptiveTimeSteppingEbos.hpp:769
AdaptiveTimeSteppingEbos(double max_next_tstep, const Tuning &tuning, const UnitSystem &unitSystem, const bool terminalOutput=true)
contructor taking parameter object
Definition: AdaptiveTimeSteppingEbos.hpp:292
bool useNewtonIteration_
use newton iteration count for adaptive time step control
Definition: AdaptiveTimeSteppingEbos.hpp:774
double suggestedNextTimestep_
suggested size of next timestep
Definition: AdaptiveTimeSteppingEbos.hpp:771
double maxGrowth_
factor that limits the maximum growth of a time step
Definition: AdaptiveTimeSteppingEbos.hpp:764
RelativeChangeInterface.
Definition: TimeStepControlInterface.hpp:32
Definition: SimulatorTimer.hpp:37
double currentStepLength() const override
Current step length.
Definition: SimulatorTimer.cpp:94
This file contains a set of helper functions used by VFPProd / VFPInj.
Definition: BlackoilPhases.hpp:27
Definition: AdaptiveTimeSteppingEbos.hpp:68
Definition: AdaptiveTimeSteppingEbos.hpp:64
Definition: AdaptiveTimeSteppingEbos.hpp:116
Definition: AdaptiveTimeSteppingEbos.hpp:112
Definition: AdaptiveTimeSteppingEbos.hpp:48
Definition: AdaptiveTimeSteppingEbos.hpp:32
Definition: AdaptiveTimeSteppingEbos.hpp:36
Definition: AdaptiveTimeSteppingEbos.hpp:52
Definition: AdaptiveTimeSteppingEbos.hpp:40
Definition: AdaptiveTimeSteppingEbos.hpp:44
Definition: AdaptiveTimeSteppingEbos.hpp:28
Definition: AdaptiveTimeSteppingEbos.hpp:56
Definition: AdaptiveTimeSteppingEbos.hpp:24
Definition: AdaptiveTimeSteppingEbos.hpp:72
Definition: AdaptiveTimeSteppingEbos.hpp:100
Definition: AdaptiveTimeSteppingEbos.hpp:92
Definition: AdaptiveTimeSteppingEbos.hpp:108
Definition: AdaptiveTimeSteppingEbos.hpp:104
Definition: AdaptiveTimeSteppingEbos.hpp:96
Definition: AdaptiveTimeSteppingEbos.hpp:84
Definition: AdaptiveTimeSteppingEbos.hpp:88
Definition: AdaptiveTimeSteppingEbos.hpp:80
Definition: AdaptiveTimeSteppingEbos.hpp:76
Definition: AdaptiveTimeSteppingEbos.hpp:60
A struct for returning timing data from a simulator to its caller.
Definition: SimulatorReport.hpp:31
void reportStep(std::ostringstream &os) const
Print a report suitable for a single simulation step.
Definition: SimulatorReport.cpp:89
Definition: SimulatorReport.hpp:70