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 "Process.h"
#include "ProcessLib/Output/Output.h"
 
namespace NumLib
{
class ConvergenceCriterion;
}
 
namespace ChemistryLib
{
class ChemicalSolverInterface;
}
 
namespace ProcessLib
{
struct ProcessData;
 
class TimeLoop
{
public:
    TimeLoop(std::unique_ptr<Output>&& output,
             std::vector<std::unique_ptr<ProcessData>>&& per_process_data,
             const int global_coupling_max_iterations,
             std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>&&
                 global_coupling_conv_crit,
             const double start_time, const double end_time);
 
    void initialize();
    bool loop();
 
    ~TimeLoop();
 
private:
    void setCoupledSolutions();
 
    NumLib::NonlinearSolverStatus solveUncoupledEquationSystems(
        const double t, const double dt, const std::size_t timestep_id);
 
    NumLib::NonlinearSolverStatus solveCoupledEquationSystemsByStaggeredScheme(
        const double t, const double dt, const std::size_t timestep_id);
 
    double computeTimeStepping(const double prev_dt, double& t,
                               std::size_t& accepted_steps,
                               std::size_t& rejected_steps);
 
    template <typename OutputClass, typename OutputClassMember>
    void outputSolutions(bool const output_initial_condition, unsigned timestep,
                         const double t, OutputClass& output_object,
                         OutputClassMember output_class_member) const;
 
private:
    std::vector<GlobalVector*> _process_solutions;
    std::vector<GlobalVector*> _process_solutions_prev;
    std::unique_ptr<Output> _output;
    std::vector<std::unique_ptr<ProcessData>> _per_process_data;
 
    bool _last_step_rejected = false;
    int _repeating_times_of_rejected_step = 0;
    const double _start_time;
    const double _end_time;
 
    const int _global_coupling_max_iterations;
    std::vector<std::unique_ptr<NumLib::ConvergenceCriterion>>
        _global_coupling_conv_crit;
 
    std::vector<GlobalVector*> _solutions_of_last_cpl_iteration;
 
    std::vector<std::size_t> _xdot_vector_ids;
};
}  // namespace ProcessLib