TimeLoop.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <memory>
 
#include "NumLib/ODESolver/NonlinearSolver.h"
#include "NumLib/TimeStepping/Algorithms/TimeStepAlgorithm.h"
#include "NumLib/TimeStepping/TimeIncrement.h"
#include "Process.h"
#include "ProcessLib/Output/Output.h"
 
namespace NumLib
{
class ConvergenceCriterion;
class StaggeredCoupling;
struct Time;
}
 
namespace ChemistryLib
{
class ChemicalSolverInterface;
}
 
namespace ProcessLib
{
struct ProcessData;
 
class TimeLoop
{
public:
    TimeLoop(std::vector<Output>&& outputs,
             std::vector<std::unique_ptr<ProcessData>>&& per_process_data,
             std::unique_ptr<NumLib::StaggeredCoupling>&& staggered_coupling,
             const NumLib::Time& start_time, const NumLib::Time& end_time);
 
    void initialize();
    void outputLastTimeStep() const;
 
    ~TimeLoop();
 
    bool executeTimeStep();
 
    bool calculateNextTimeStep();
 
    NumLib::Time endTime() const { return _end_time; }
    NumLib::Time currentTime() const { return _current_time; }
    bool successful_time_step = true;
 
private:
    bool preTsNonlinearSolvePostTs(NumLib::Time const& t, double const dt,
                                   std::size_t const timesteps);
 
    NumLib::NonlinearSolverStatus solveUncoupledEquationSystems(
        const NumLib::Time& t, const double dt, const std::size_t timestep_id);
 
    NumLib::NonlinearSolverStatus solveCoupledEquationSystemsByStaggeredScheme(
        const NumLib::Time& t, const double dt, const std::size_t timestep_id);
 
    using TimeStepConstraintCallback =
        std::function<double(NumLib::Time const&, double)>;
    std::pair<NumLib::TimeIncrement, bool> computeTimeStepping(
        const double prev_dt, NumLib::Time& t, std::size_t& accepted_steps,
        std::size_t& rejected_steps,
        std::vector<TimeStepConstraintCallback> const& time_step_constraints);
 
    template <typename OutputClassMember>
    void outputSolutions(unsigned timestep,
                         const double t,
                         OutputClassMember output_class_member) const;
 
private:
    std::vector<TimeStepConstraintCallback> generateOutputTimeStepConstraints(
        std::vector<double>&& fixed_times) const;
    void preOutputInitialConditions(NumLib::Time const& t,
                                    const double dt) const;
    std::vector<GlobalVector*> _process_solutions;
    std::vector<GlobalVector*> _process_solutions_prev;
    std::vector<Output> _outputs;
    std::vector<std::unique_ptr<ProcessData>> _per_process_data;
 
    const NumLib::Time _start_time;
    const NumLib::Time _end_time;
    NumLib::Time _current_time = _start_time;
    std::size_t _accepted_steps = 0;
    std::size_t _rejected_steps = 0;
    NumLib::TimeIncrement _dt{0.};
    int _repeating_times_of_rejected_step = 0;
    bool _last_step_rejected = false;
 
    std::unique_ptr<NumLib::StaggeredCoupling> _staggered_coupling;
};
}  // namespace ProcessLib