time_loop.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2020 - 2026 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "discretization.h"
#include "error_evaluation.h"
#include "hyperbolic_module.h"
#include "initial_values.h"
#include "mesh_adaptor.h"
#include "mpi_ensemble.h"
#include "mpi_ensemble_container.h"
#include "offline_data.h"
#include "parabolic_module.h"
#include "postprocessor.h"
#include "quantities.h"
#include "solution_transfer.h"
#include "time_integrator.h"
#include "vtu_output.h"
 
#include <deal.II/base/parameter_acceptor.h>
 
#include <fstream>
 
namespace ryujin
{
  template <typename HyperbolicDescription,
            typename ParabolicDescription,
            int dim,
            typename Number = double>
  class TimeLoop final : public dealii::ParameterAcceptor
  {
  public:
 
    using HyperbolicSystem = typename HyperbolicDescription::HyperbolicSystem;
    using ParabolicSystem = typename ParabolicDescription::ParabolicSystem;
 
    using View = typename HyperbolicSystem::template View<dim, Number>;
 
    using ScalarNumber = typename View::ScalarNumber;
 
    static constexpr auto problem_dimension = View::problem_dimension;
 
    static constexpr auto n_precomputed_values = View::n_precomputed_values;
 
 
 
    TimeLoop(const MPI_Comm &mpi_comm);
 
    void run();
 
  private:
 
 
    std::string base_name_;
    std::string base_name_ensemble_;
 
    std::string debug_command_;
    std::string debug_filename_;
 
    Number t_final_;
    bool enforce_t_final_;
    Number timer_granularity_;
 
    bool enable_output_full_;
    bool enable_output_levelsets_;
    bool enable_compute_error_;
    bool enable_compute_quantities_;
    bool enable_mesh_adaptivity_;
 
    unsigned int timer_output_full_multiplier_;
    unsigned int timer_output_levelsets_multiplier_;
    unsigned int timer_compute_error_multiplier_;
    unsigned int timer_compute_quantities_multiplier_;
 
    bool resume_;
    bool resume_at_time_zero_;
 
    Number terminal_update_interval_;
    bool terminal_correct_for_hypertreadhing_;
 
    Number checkpoint_update_interval_;
 
 
 
    MPIEnsemble mpi_ensemble_;
 
    MPIEnsembleContainer<HyperbolicSystem> hyperbolic_system_;
    MPIEnsembleContainer<ParabolicSystem> parabolic_system_;
    Discretization<dim> discretization_;
    OfflineData<dim, Number> offline_data_;
    MPIEnsembleContainer<InitialValues<HyperbolicDescription, dim, Number>>
        initial_values_;
    HyperbolicModule<HyperbolicDescription, dim, Number> hyperbolic_module_;
    ParabolicModule<HyperbolicDescription, ParabolicDescription, dim, Number>
        parabolic_module_;
    TimeIntegrator<HyperbolicDescription, ParabolicDescription, dim, Number>
        time_integrator_;
    MeshAdaptor<HyperbolicDescription, dim, Number> mesh_adaptor_;
    SolutionTransfer<HyperbolicDescription, dim, Number> solution_transfer_;
    Postprocessor<HyperbolicDescription, dim, Number> postprocessor_;
    VTUOutput<HyperbolicDescription, dim, Number> vtu_output_;
    Quantities<HyperbolicDescription, dim, Number> quantities_;
    ErrorEvaluation<HyperbolicDescription, dim, Number> error_evaluation_;
 
    dealii::types::global_dof_index n_global_dofs_;
    unsigned int n_devices_;
 
    std::ofstream logfile_; /* log file */
 
 
 
    template <typename Callable>
    void read_checkpoint(StateVector<Number> &state_vector,
                         const std::string &base_name,
                         Number &t,
                         unsigned int &output_cycle,
                         const Callable &prepare_compute_kernels);
 
    void write_checkpoint(const StateVector<Number> &state_vector,
                          const std::string &base_name,
                          const Number &t,
                          const unsigned int &output_cycle);
 
    template <typename Callable>
    void adapt_mesh_and_transfer_state_vector(
        StateVector<Number> &state_vector,
        const Callable &prepare_compute_kernels);
 
    void interpolate_analytic_solution(StateVector<Number> &analytic, Number t);
 
    void output(const StateVector<Number> &state_vector,
                const std::string &name,
                const Number t,
                const unsigned int cycle);
 
    void print_parameters(std::ostream &stream);
    void print_mpi_partition(std::ostream &stream);
    void print_device_information(std::ostream &stream);
 
    void print_info(const std::string &header);
 
    void print_head(const std::string &header,
                    const std::string &secondary,
                    std::ostream &stream);
 
    void print_information(unsigned int output_cycle,
                           Number last_checkpoint,
                           std::ostream &stream,
                           bool final_time = false);
    void print_memory_statistics(std::ostream &stream);
    void print_timers(std::ostream &stream);
    void print_throughput(unsigned int cycle,
                          Number t,
                          std::ostream &stream,
                          bool final_time = false);
 
    void print_cycle_statistics(unsigned int cycle,
                                Number t,
                                unsigned int output_cycle,
                                Number last_checkpoint,
                                bool write_to_logfile = false,
                                bool final_time = false);
 
  };
 
} // namespace ryujin