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/utility/parameters/ParameterGroup.hpp>
13 #include <opm/common/ErrorMacros.hpp>
14 #include <opm/simulators/timestepping/SimulatorTimer.hpp>
15 #include <opm/simulators/timestepping/AdaptiveSimulatorTimer.hpp>
16 #include <opm/simulators/timestepping/TimeStepControlInterface.hpp>
17 #include <opm/simulators/timestepping/TimeStepControl.hpp>
18 #include <opm/core/props/phaseUsageFromDeck.hpp>
19 #include <opm/input/eclipse/Schedule/ScheduleState.hpp>
20 #include <opm/common/Exceptions.hpp>
22 namespace Opm::Properties {
28 template<
class TypeTag,
class MyTypeTag>
30 using type = UndefinedProperty;
32 template<
class TypeTag,
class MyTypeTag>
34 using type = UndefinedProperty;
36 template<
class TypeTag,
class MyTypeTag>
38 using type = UndefinedProperty;
40 template<
class TypeTag,
class MyTypeTag>
42 using type = UndefinedProperty;
44 template<
class TypeTag,
class MyTypeTag>
46 using type = UndefinedProperty;
48 template<
class TypeTag,
class MyTypeTag>
50 using type = UndefinedProperty;
52 template<
class TypeTag,
class MyTypeTag>
54 using type = UndefinedProperty;
56 template<
class TypeTag,
class MyTypeTag>
58 using type = UndefinedProperty;
60 template<
class TypeTag,
class MyTypeTag>
62 using type = UndefinedProperty;
64 template<
class TypeTag,
class MyTypeTag>
66 using type = UndefinedProperty;
68 template<
class TypeTag,
class MyTypeTag>
70 using type = UndefinedProperty;
72 template<
class TypeTag,
class MyTypeTag>
74 using type = UndefinedProperty;
76 template<
class TypeTag,
class MyTypeTag>
78 using type = UndefinedProperty;
80 template<
class TypeTag,
class MyTypeTag>
82 using type = UndefinedProperty;
84 template<
class TypeTag,
class MyTypeTag>
86 using type = UndefinedProperty;
88 template<
class TypeTag,
class MyTypeTag>
90 using type = UndefinedProperty;
92 template<
class TypeTag,
class MyTypeTag>
94 using type = UndefinedProperty;
96 template<
class TypeTag,
class MyTypeTag>
98 using type = UndefinedProperty;
100 template<
class TypeTag,
class MyTypeTag>
102 using type = UndefinedProperty;
104 template<
class TypeTag,
class MyTypeTag>
106 using type = UndefinedProperty;
108 template<
class TypeTag,
class MyTypeTag>
110 using type = UndefinedProperty;
112 template<
class TypeTag,
class MyTypeTag>
114 using type = UndefinedProperty;
116 template<
class TypeTag,
class MyTypeTag>
118 using type = UndefinedProperty;
121 template<
class TypeTag>
123 using type = GetPropType<TypeTag, Scalar>;
124 static constexpr type value = 0.33;
126 template<
class TypeTag>
128 using type = GetPropType<TypeTag, Scalar>;
129 static constexpr type value = 2.0;
131 template<
class TypeTag>
133 using type = GetPropType<TypeTag, Scalar>;
134 static constexpr type value = 3.0;
136 template<
class TypeTag>
138 using type = GetPropType<TypeTag, Scalar>;
139 static constexpr type value = 365.0;
141 template<
class TypeTag>
143 using type = GetPropType<TypeTag, Scalar>;
144 static constexpr type value = 1.0e-12;
146 template<
class TypeTag>
148 static constexpr
bool value =
false;
150 template<
class TypeTag>
152 static constexpr
int value = 10;
154 template<
class TypeTag>
156 static constexpr
int value = 1;
158 template<
class TypeTag>
160 static constexpr
int value = 1;
162 template<
class TypeTag>
164 using type = GetPropType<TypeTag, Scalar>;
165 static constexpr type value = 1.0;
167 template<
class TypeTag>
169 static constexpr
bool value =
false;
171 template<
class TypeTag>
173 using type = GetPropType<TypeTag, Scalar>;
174 static constexpr type value = -1.0;
176 template<
class TypeTag>
178 static constexpr
auto value =
"pid+newtoniteration";
180 template<
class TypeTag>
182 using type = GetPropType<TypeTag, Scalar>;
183 static constexpr type value = 1e-1;
185 template<
class TypeTag>
187 static constexpr
int value = 30;
189 template<
class TypeTag>
191 static constexpr
int value = 8;
193 template<
class TypeTag>
195 using type = GetPropType<TypeTag, Scalar>;
196 static constexpr type value = 0.75;
198 template<
class TypeTag>
200 using type = GetPropType<TypeTag, Scalar>;
201 static constexpr type value = 1.25;
203 template<
class TypeTag>
205 using type = GetPropType<TypeTag, Scalar>;
206 static constexpr type value = 1.0;
208 template<
class TypeTag>
210 using type = GetPropType<TypeTag, Scalar>;
211 static constexpr type value = 3.2;
213 template<
class TypeTag>
215 static constexpr
auto value =
"timesteps";
217 template<
class TypeTag>
219 using type = GetPropType<TypeTag, Scalar>;
220 static constexpr type value = 0.01;
223 template<
class TypeTag>
225 using type = GetPropType<TypeTag, Scalar>;
226 static constexpr type value = 0.0;
236 template<
class TypeTag>
239 template <
class Solver>
242 const Solver& solver_;
244 SolutionTimeErrorSolverWrapperEbos(
const Solver& solver)
249 double relativeChange()
const
250 {
return solver_.model().relativeChange(); }
254 void logException_(
const E& exception,
bool verbose)
258 message =
"Caught Exception: ";
259 message += exception.what();
260 OpmLog::debug(message);
267 const bool terminalOutput =
true)
269 ,
restartFactor_(EWOMS_GET_PARAM(TypeTag, double, SolverRestartFactor))
270 ,
growthFactor_(EWOMS_GET_PARAM(TypeTag, double, SolverGrowthFactor))
271 ,
maxGrowth_(EWOMS_GET_PARAM(TypeTag, double, SolverMaxGrowth))
272 ,
maxTimeStep_(EWOMS_GET_PARAM(TypeTag, double, SolverMaxTimeStepInDays)*24*60*60)
273 ,
minTimeStep_(unitSystem.to_si(UnitSystem::measure::time, EWOMS_GET_PARAM(TypeTag, double, SolverMinTimeStep)))
276 ,
solverVerbose_(EWOMS_GET_PARAM(TypeTag, int, SolverVerbosity) > 0 && terminalOutput)
277 ,
timestepVerbose_(EWOMS_GET_PARAM(TypeTag, int, TimeStepVerbosity) > 0 && terminalOutput)
282 , minTimeStepBeforeShuttingProblematicWells_(EWOMS_GET_PARAM(TypeTag, double, MinTimeStepBeforeShuttingProblematicWellsInDays)*unit::day)
294 const Tuning& tuning,
295 const UnitSystem& unitSystem,
296 const bool terminalOutput =
true)
305 ,
solverVerbose_(EWOMS_GET_PARAM(TypeTag, int, SolverVerbosity) > 0 && terminalOutput)
306 ,
timestepVerbose_(EWOMS_GET_PARAM(TypeTag, int, TimeStepVerbosity) > 0 && terminalOutput)
311 , minTimeStepBeforeShuttingProblematicWells_(EWOMS_GET_PARAM(TypeTag, double, MinTimeStepBeforeShuttingProblematicWellsInDays)*unit::day)
316 static void registerParameters()
319 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverRestartFactor,
320 "The factor time steps are elongated after restarts");
321 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverGrowthFactor,
322 "The factor time steps are elongated after a successful substep");
323 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMaxGrowth,
324 "The maximum factor time steps are elongated after a report step");
325 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMaxTimeStepInDays,
326 "The maximum size of a time step in days");
327 EWOMS_REGISTER_PARAM(TypeTag,
double, SolverMinTimeStep,
328 "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");
329 EWOMS_REGISTER_PARAM(TypeTag,
bool, SolverContinueOnConvergenceFailure,
330 "Continue instead of stop when minimum solver time step is reached");
331 EWOMS_REGISTER_PARAM(TypeTag,
int, SolverMaxRestarts,
332 "The maximum number of breakdowns before a substep is given up and the simulator is terminated");
333 EWOMS_REGISTER_PARAM(TypeTag,
int, SolverVerbosity,
334 "Specify the \"chattiness\" of the non-linear solver itself");
335 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepVerbosity,
336 "Specify the \"chattiness\" during the time integration");
337 EWOMS_REGISTER_PARAM(TypeTag,
double, InitialTimeStepInDays,
338 "The size of the initial time step in days");
339 EWOMS_REGISTER_PARAM(TypeTag,
bool, FullTimeStepInitially,
340 "Always attempt to finish a report step using a single substep");
341 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepAfterEventInDays,
342 "Time step size of the first time step after an event occurs during the simulation in days");
343 EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControl,
344 "The algorithm used to determine time-step sizes. valid options are: 'pid' (default), 'pid+iteration', 'pid+newtoniteration', 'iterationcount', 'newtoniterationcount' and 'hardcoded'");
345 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlTolerance,
346 "The tolerance used by the time step size control algorithm");
347 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepControlTargetIterations,
348 "The number of linear iterations which the time step control scheme should aim for (if applicable)");
349 EWOMS_REGISTER_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations,
350 "The number of Newton iterations which the time step control scheme should aim for (if applicable)");
351 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlDecayRate,
352 "The decay rate of the time step size of the number of target iterations is exceeded");
353 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlGrowthRate,
354 "The growth rate of the time step size of the number of target iterations is undercut");
355 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor,
356 "The decay rate of the time step decrease when the target iterations is exceeded");
357 EWOMS_REGISTER_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor,
358 "The growth rate of the time step increase when the target iterations is undercut");
359 EWOMS_REGISTER_PARAM(TypeTag, std::string, TimeStepControlFileName,
360 "The name of the file which contains the hardcoded time steps sizes");
361 EWOMS_REGISTER_PARAM(TypeTag,
double, MinTimeStepBeforeShuttingProblematicWellsInDays,
362 "The minimum time step size in days for which problematic wells are not shut");
363 EWOMS_REGISTER_PARAM(TypeTag,
double, MinTimeStepBasedOnNewtonIterations,
364 "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");
370 template <
class Solver>
374 const std::vector<int>* fipnum =
nullptr)
393 auto& ebosSimulator = solver.model().ebosSimulator();
394 auto& ebosProblem = ebosSimulator.problem();
403 while (!substepTimer.
done()) {
407 logTimer(substepTimer);
411 std::string causeOfFailure =
"";
413 substepReport = solver.step(substepTimer);
416 OpmLog::debug(
"Overall linear iterations used: " + std::to_string(substepReport.total_linear_iterations));
419 catch (
const TooManyIterations& e) {
420 substepReport = solver.failureReport();
421 causeOfFailure =
"Solver convergence failure - Iteration limit reached";
426 catch (
const LinearSolverProblem& e) {
427 substepReport = solver.failureReport();
428 causeOfFailure =
"Linear solver convergence failure";
433 catch (
const NumericalIssue& e) {
434 substepReport = solver.failureReport();
435 causeOfFailure =
"Solver convergence failure - Numerical problem encountered";
440 catch (
const std::runtime_error& e) {
441 substepReport = solver.failureReport();
446 catch (
const Dune::ISTLError& e) {
447 substepReport = solver.failureReport();
452 catch (
const Dune::MatrixBlockError& e) {
453 substepReport = solver.failureReport();
460 ebosSimulator.problem().setSubStepReport(substepReport);
462 report += substepReport;
466 if (continue_on_uncoverged_solution) {
467 const auto msg = std::string(
"Solver failed to converge but timestep ")
468 + std::to_string(dt) +
" is smaller or equal to "
469 + std::to_string(
minTimeStep_) +
"\n which is the minimum threshold given"
470 +
"by option --solver-min-time-step= \n";
476 if (substepReport.converged || continue_on_uncoverged_solution) {
482 SolutionTimeErrorSolverWrapperEbos<Solver> relativeChange(solver);
486 : substepReport.total_linear_iterations;
487 double dtEstimate =
timeStepControl_->computeTimeStepSize(dt, iterations, relativeChange,
490 assert(dtEstimate > 0);
492 dtEstimate = std::min(dtEstimate,
double(
maxGrowth_ * dt));
493 assert(dtEstimate > 0);
503 if (solver.model().wellModel().hasTHPConstraints()) {
504 const double maxPredictionTHPTimestep = 16.0 * unit::day;
505 dtEstimate = std::min(dtEstimate, maxPredictionTHPTimestep);
507 assert(dtEstimate > 0);
509 std::ostringstream ss;
511 OpmLog::info(ss.str());
518 if (!substepTimer.
done()) {
520 solver.computeFluidInPlace(*fipnum);
522 time::StopWatch perfTimer;
525 ebosProblem.writeOutput();
527 report.success.output_write_time += perfTimer.secsSinceStart();
533 report.success.converged = substepTimer.
done();
543 const auto msg = std::string(
"Solver failed to converge after cutting timestep ")
544 + std::to_string(restarts) +
" times.";
548 OPM_THROW_NOLOG(NumericalIssue, msg);
558 const auto msg = std::string(
"Solver failed to converge after cutting timestep to ")
559 + std::to_string(
minTimeStep_) +
"\n which is the minimum threshold given"
560 +
"by option --solver-min-time-step= \n";
564 OPM_THROW_NOLOG(NumericalIssue, msg);
568 auto chopTimestep = [&]() {
572 msg = causeOfFailure +
"\nTimestep chopped to "
573 + std::to_string(unit::convert::to(substepTimer.
currentStepLength(), unit::day)) +
" days\n";
574 OpmLog::problem(msg);
579 const double minimumChoppedTimestep = minTimeStepBeforeShuttingProblematicWells_;
580 if (newTimeStep > minimumChoppedTimestep) {
585 std::set<std::string> failing_wells = consistentlyFailingWells(solver.model().stepReports());
586 if (failing_wells.empty()) {
591 int num_shut_wells = 0;
592 for (
const auto& well : failing_wells) {
593 bool was_shut = solver.model().wellModel().forceShutWellByName(well, substepTimer.
simulationTimeElapsed());
598 if (num_shut_wells == 0) {
606 msg =
"\nProblematic well(s) were shut: ";
607 for (
const auto& well : failing_wells) {
611 msg +=
"(retrying timestep)\n";
612 OpmLog::problem(msg);
624 std::ostringstream ss;
626 ss <<
"Suggested next step size = " << unit::convert::to(
suggestedNextTimestep_, unit::day) <<
" (days)" << std::endl;
627 OpmLog::debug(ss.str());
642 void setSuggestedNextStep(
const double x)
645 void updateTUNING(
double max_next_tstep,
const Tuning& tuning)
657 void init_(
const UnitSystem& unitSystem)
660 std::string control = EWOMS_GET_PARAM(TypeTag, std::string, TimeStepControl);
662 const double tol = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlTolerance);
663 if (control ==
"pid") {
666 else if (control ==
"pid+iteration") {
667 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetIterations);
668 const double decayDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor);
669 const double growthDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor);
670 timeStepControl_ = TimeStepControlType(
new PIDAndIterationCountTimeStepControl(iterations, decayDampingFactor, growthDampingFactor, tol));
672 else if (control ==
"pid+newtoniteration") {
673 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations);
674 const double decayDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayDampingFactor);
675 const double growthDampingFactor = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthDampingFactor);
676 const double nonDimensionalMinTimeStepIterations = EWOMS_GET_PARAM(TypeTag,
double, MinTimeStepBasedOnNewtonIterations);
678 double minTimeStepReducedByIterations = unitSystem.to_si(UnitSystem::measure::time, nonDimensionalMinTimeStepIterations);
679 timeStepControl_ = TimeStepControlType(
new PIDAndIterationCountTimeStepControl(iterations, decayDampingFactor,
680 growthDampingFactor, tol, minTimeStepReducedByIterations));
683 else if (control ==
"iterationcount") {
684 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetIterations);
685 const double decayrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayRate);
686 const double growthrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthRate);
687 timeStepControl_ = TimeStepControlType(
new SimpleIterationCountTimeStepControl(iterations, decayrate, growthrate));
689 else if (control ==
"newtoniterationcount") {
690 const int iterations = EWOMS_GET_PARAM(TypeTag,
int, TimeStepControlTargetNewtonIterations);
691 const double decayrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlDecayRate);
692 const double growthrate = EWOMS_GET_PARAM(TypeTag,
double, TimeStepControlGrowthRate);
693 timeStepControl_ = TimeStepControlType(
new SimpleIterationCountTimeStepControl(iterations, decayrate, growthrate));
696 else if (control ==
"hardcoded") {
697 const std::string filename = EWOMS_GET_PARAM(TypeTag, std::string, TimeStepControlFileName);
698 timeStepControl_ = TimeStepControlType(
new HardcodedTimeStepControl(filename));
702 OPM_THROW(std::runtime_error,
"Unsupported time step control selected "<< control);
708 template <
class ProblemType>
709 std::set<std::string> consistentlyFailingWells(
const std::vector<ProblemType>& sr)
713 std::ostringstream msg;
714 msg <<
" Excessive chopping detected in report step "
715 << sr.back().report_step <<
", substep " << sr.back().current_step <<
"\n";
717 std::set<std::string> failing_wells;
721 if(sr.back().report.empty())
722 return failing_wells;
724 const auto& wfs = sr.back().report.back().wellFailures();
725 for (
const auto& wf : wfs) {
726 msg <<
" Well that failed: " << wf.wellName() <<
"\n";
729 OpmLog::debug(msg.str());
732 const int num_steps = 3;
733 const int rep_step = sr.back().report_step;
734 const int sub_step = sr.back().current_step;
735 const int sr_size = sr.size();
736 if (sr_size >= num_steps) {
737 for (
const auto& wf : wfs) {
738 failing_wells.insert(wf.wellName());
740 for (
int s = 1; s < num_steps; ++s) {
741 const auto& srep = sr[sr_size - 1 - s];
744 if (srep.report_step != rep_step || srep.current_step != sub_step) {
748 std::set<std::string> failing_wells_step;
749 for (
const auto& wf : srep.report.back().wellFailures()) {
750 if (failing_wells.count(wf.wellName()) > 0) {
751 failing_wells_step.insert(wf.wellName());
754 failing_wells.swap(failing_wells_step);
757 return failing_wells;
760 typedef std::unique_ptr<TimeStepControlInterface> TimeStepControlType;
776 double minTimeStepBeforeShuttingProblematicWells_;
Simulation timer for adaptive time stepping.
Definition: AdaptiveSimulatorTimer.hpp:41
bool done() const
Definition: AdaptiveSimulatorTimer.cpp:126
double currentStepLength() const
Definition: AdaptiveSimulatorTimer.cpp:108
void provideTimeStepEstimate(const double dt_estimate)
provide and estimate for new time step size
Definition: AdaptiveSimulatorTimer.cpp:72
void report(std::ostream &os) const
report start and end time as well as used steps so far
Definition: AdaptiveSimulatorTimer.cpp:153
double simulationTimeElapsed() const
Definition: AdaptiveSimulatorTimer.cpp:124
void setLastStepFailed(bool lastStepFailed)
tell the timestepper whether timestep failed or not
Definition: AdaptiveSimulatorTimer.hpp:104
Definition: AdaptiveTimeSteppingEbos.hpp:238
double maxTimeStep_
maximal allowed time step size in days
Definition: AdaptiveTimeSteppingEbos.hpp:766
double growthFactor_
factor to multiply time step when solver recovered from failed convergence
Definition: AdaptiveTimeSteppingEbos.hpp:764
double minTimeStep_
minimal allowed time step size before throwing
Definition: AdaptiveTimeSteppingEbos.hpp:767
bool fullTimestepInitially_
beginning with the size of the time step from data file
Definition: AdaptiveTimeSteppingEbos.hpp:773
double suggestedNextStep() const
Returns the simulator report for the failed substeps of the last report step.
Definition: AdaptiveTimeSteppingEbos.hpp:639
int solverRestartMax_
how many restart of solver are allowed
Definition: AdaptiveTimeSteppingEbos.hpp:769
double timestepAfterEvent_
suggested size of timestep after an event
Definition: AdaptiveTimeSteppingEbos.hpp:774
TimeStepControlType timeStepControl_
time step control object
Definition: AdaptiveTimeSteppingEbos.hpp:762
AdaptiveTimeSteppingEbos(const UnitSystem &unitSystem, const bool terminalOutput=true)
contructor taking parameter object
Definition: AdaptiveTimeSteppingEbos.hpp:266
bool timestepVerbose_
timestep verbosity
Definition: AdaptiveTimeSteppingEbos.hpp:771
bool ignoreConvergenceFailure_
continue instead of stop when minimum time step is reached
Definition: AdaptiveTimeSteppingEbos.hpp:768
double restartFactor_
factor to multiply time step with when solver fails to converge
Definition: AdaptiveTimeSteppingEbos.hpp:763
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:371
bool solverVerbose_
solver verbosity
Definition: AdaptiveTimeSteppingEbos.hpp:770
AdaptiveTimeSteppingEbos(double max_next_tstep, const Tuning &tuning, const UnitSystem &unitSystem, const bool terminalOutput=true)
contructor taking parameter object
Definition: AdaptiveTimeSteppingEbos.hpp:293
bool useNewtonIteration_
use newton iteration count for adaptive time step control
Definition: AdaptiveTimeSteppingEbos.hpp:775
double suggestedNextTimestep_
suggested size of next timestep
Definition: AdaptiveTimeSteppingEbos.hpp:772
double maxGrowth_
factor that limits the maximum growth of a time step
Definition: AdaptiveTimeSteppingEbos.hpp:765
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:69
Definition: AdaptiveTimeSteppingEbos.hpp:65
Definition: AdaptiveTimeSteppingEbos.hpp:117
Definition: AdaptiveTimeSteppingEbos.hpp:113
Definition: AdaptiveTimeSteppingEbos.hpp:49
Definition: AdaptiveTimeSteppingEbos.hpp:33
Definition: AdaptiveTimeSteppingEbos.hpp:37
Definition: AdaptiveTimeSteppingEbos.hpp:53
Definition: AdaptiveTimeSteppingEbos.hpp:41
Definition: AdaptiveTimeSteppingEbos.hpp:45
Definition: AdaptiveTimeSteppingEbos.hpp:29
Definition: AdaptiveTimeSteppingEbos.hpp:57
Definition: AdaptiveTimeSteppingEbos.hpp:25
Definition: AdaptiveTimeSteppingEbos.hpp:73
Definition: AdaptiveTimeSteppingEbos.hpp:101
Definition: AdaptiveTimeSteppingEbos.hpp:93
Definition: AdaptiveTimeSteppingEbos.hpp:109
Definition: AdaptiveTimeSteppingEbos.hpp:105
Definition: AdaptiveTimeSteppingEbos.hpp:97
Definition: AdaptiveTimeSteppingEbos.hpp:85
Definition: AdaptiveTimeSteppingEbos.hpp:89
Definition: AdaptiveTimeSteppingEbos.hpp:81
Definition: AdaptiveTimeSteppingEbos.hpp:77
Definition: AdaptiveTimeSteppingEbos.hpp:61
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:88
Definition: SimulatorReport.hpp:69