time_loop.template.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 "computing_timer.h"
#include "gpu.h"
#include "mpi_ensemble_container.h"
#include "state_vector.h"
#include "time_loop.h"
#include "version_info.h"
 
#include <deal.II/base/logstream.h>
#include <deal.II/base/work_stream.h>
 
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <set>
 
#ifdef WITH_OPENMP
#include "omp.h"
#endif
 
using namespace dealii;
 
namespace ryujin
{
  template <typename HD, typename PD, int dim, typename Number>
  TimeLoop<HD, PD, dim, Number>::TimeLoop(const MPI_Comm &mpi_comm)
      : ParameterAcceptor("/A - TimeLoop")
      , mpi_ensemble_(mpi_comm,
                      [] {
                        if constexpr (has_n_mpi_ensembles_v<HD>)
                          return HD::n_mpi_ensembles();
                        else
                          return 1;
                      }())
      , hyperbolic_system_(mpi_ensemble_, "/B - Equation")
      , parabolic_system_(mpi_ensemble_, "/B - Equation")
      , discretization_(mpi_ensemble_, "/C - Discretization")
      , offline_data_(mpi_ensemble_, discretization_, "/D - OfflineData")
      , initial_values_(mpi_ensemble_,
                        "/E - InitialValues",
                        mpi_ensemble_,
                        offline_data_,
                        hyperbolic_system_,
                        parabolic_system_)
      , hyperbolic_module_(mpi_ensemble_,
                           offline_data_,
                           hyperbolic_system_,
                           initial_values_,
                           "/F - HyperbolicModule")
      , parabolic_module_(mpi_ensemble_,
                          offline_data_,
                          hyperbolic_system_,
                          parabolic_system_,
                          initial_values_,
                          "/G - ParabolicModule")
      , time_integrator_(mpi_ensemble_,
                         offline_data_,
                         hyperbolic_module_,
                         parabolic_module_,
                         "/H - TimeIntegrator")
      , mesh_adaptor_(mpi_ensemble_,
                      offline_data_,
                      hyperbolic_system_,
                      parabolic_system_,
                      hyperbolic_module_.initial_precomputed(),
                      hyperbolic_module_.alpha(),
                      "/I - MeshAdaptor")
      , solution_transfer_(mpi_ensemble_,
                           offline_data_,
                           hyperbolic_system_,
                           parabolic_system_,
                           "/I - MeshAdaptor")
      , postprocessor_(mpi_ensemble_,
                       offline_data_,
                       hyperbolic_system_,
                       parabolic_system_,
                       "/J - VTUOutput")
      , vtu_output_(mpi_ensemble_,
                    offline_data_,
                    hyperbolic_system_,
                    parabolic_system_,
                    postprocessor_,
                    hyperbolic_module_.initial_precomputed(),
                    hyperbolic_module_.alpha(),
                    mesh_adaptor_.smoothness_indicators(),
                    "/J - VTUOutput")
      , quantities_(mpi_ensemble_,
                    offline_data_,
                    hyperbolic_system_,
                    parabolic_system_,
                    hyperbolic_module_.initial_precomputed(),
                    "/K - Quantities")
      , error_evaluation_(mpi_ensemble_,
                          offline_data_,
                          hyperbolic_system_,
                          parabolic_system_,
                          hyperbolic_module_.initial_precomputed(),
                          "/L - ErrorEvaluation")
      , n_global_dofs_(0)
      , n_devices_(0)
  {
    base_name_ = "test";
    add_parameter("basename", base_name_, "Base name for all output files");
 
    t_final_ = Number(5.);
    add_parameter("final time", t_final_, "Final time");
 
    enforce_t_final_ = false;
    add_parameter("enforce final time",
                  enforce_t_final_,
                  "Boolean indicating whether the final time should be "
                  "enforced strictly. If set to true the last time step is "
                  "shortened so that the simulation ends precisely at t_final");
 
    timer_granularity_ = Number(0.01);
    add_parameter("timer granularity",
                  timer_granularity_,
                  "The timer granularity specifies the time interval after "
                  "which compute, output, postprocessing, and mesh adaptation "
                  "routines are run. This \"baseline tick\" is further "
                  "modified by the corresponding \"*_multiplier\" options");
 
    enable_output_full_ = false;
    add_parameter("enable output full",
                  enable_output_full_,
                  "Write out full pvtu records. The frequency is determined by "
                  "\"timer granularity\" and \"timer output full multiplier\"");
 
    enable_output_levelsets_ = false;
    add_parameter(
        "enable output levelsets",
        enable_output_levelsets_,
        "Write out levelsets pvtu records. The frequency is determined by "
        "\"timer granularity\" and \"timer output levelsets multiplier\"");
 
    enable_compute_error_ = false;
    add_parameter(
        "enable compute error",
        enable_compute_error_,
        "Flag to control whether we compute error norms of the difference to "
        "an analytic solution. Implemented only for certain initial state "
        "configurations. The frequency how often errors are logged is "
        "determined by \"timer granularity\" and \"timer compute error "
        "multiplier\"");
 
    enable_compute_quantities_ = false;
    add_parameter(
        "enable compute quantities",
        enable_compute_quantities_,
        "Flag to control whether we compute quantities of interest. The "
        "frequency how often quantities are logged is determined by \"timer "
        "granularity\" and \"timer compute quantities multiplier\"");
 
    enable_mesh_adaptivity_ = false;
    add_parameter(
        "enable mesh adaptivity",
        enable_mesh_adaptivity_,
        "Flag to control whether we use an adaptive mesh refinement strategy. "
        "The frequency how often we query MeshAdaptor::analyze() for deciding "
        "on adapting the mesh is determined by \"timer granularity\" and "
        "\"timer mesh refinement multiplier\"");
 
    timer_output_full_multiplier_ = 1;
    add_parameter("timer output full multiplier",
                  timer_output_full_multiplier_,
                  "Multiplicative modifier applied to \"timer granularity\" "
                  "that determines the full pvtu writeout granularity");
 
    timer_output_levelsets_multiplier_ = 1;
    add_parameter("timer output levelsets multiplier",
                  timer_output_levelsets_multiplier_,
                  "Multiplicative modifier applied to \"timer granularity\" "
                  "that determines the levelsets pvtu writeout granularity");
 
    timer_compute_error_multiplier_ = 1;
    add_parameter("timer compute error multiplier",
                  timer_compute_error_multiplier_,
                  "Multiplicative modifier applied to \"timer granularity\" "
                  "that determines the writeout granularity for error norms");
 
    timer_compute_quantities_multiplier_ = 1;
    add_parameter(
        "timer compute quantities multiplier",
        timer_compute_quantities_multiplier_,
        "Multiplicative modifier applied to \"timer granularity\" that "
        "determines the writeout granularity for quantities of interest");
 
    resume_ = false;
    add_parameter("resume", resume_, "Resume an interrupted computation");
 
    resume_at_time_zero_ = false;
    add_parameter("resume at time zero",
                  resume_at_time_zero_,
                  "Resume from the latest checkpoint but set the time to t=0.");
 
    terminal_update_interval_ = 5;
    add_parameter("terminal update interval",
                  terminal_update_interval_,
                  "Number of seconds after which output statistics are "
                  "recomputed and printed on the terminal. Setting the "
                  "interval to zero disables terminal output.");
 
    terminal_correct_for_hypertreadhing_ = true;
    add_parameter(
        "terminal correct for hyperthreading",
        terminal_correct_for_hypertreadhing_,
        "If set to true, the CPU throughput is corrected by dividing the total "
        "consumed CPU time by a factor of 2. This correction is only active if "
        "the number of threads (per MPI rank) is 2.");
 
    checkpoint_update_interval_ = 0;
    add_parameter(
        "checkpoint update interval",
        checkpoint_update_interval_,
        "Number of seconds after which a new checkpoint is written out to "
        "disk. Setting the interval to zero disables checkpointing.");
 
    debug_command_ = "";
    add_parameter("debug command",
                  debug_command_,
                  "If set to a nonempty string then the host environment's "
                  "command processor is invoked via std::system() with the "
                  "specified string as command parameter.");
 
    debug_filename_ = "";
    add_parameter("debug filename",
                  debug_filename_,
                  "If set to a nonempty string then we output the contents of "
                  "this file at the end. This is mainly useful in the "
                  "testsuite to output files we wish to compare");
  }
 
 
  /*
   * ---------------------------------------------------------------------------
   * Setup and main loop:
   * ---------------------------------------------------------------------------
   */
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::run()
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::run()" << std::endl;
#endif
 
    DeviceTimer::reinit();
    ComputingTimer::reinit();
 
    {
      base_name_ensemble_ = base_name_;
      if (mpi_ensemble_.n_ensembles() > 1) {
        print_info("setting up MPI ensemble");
        unsigned int digits =
            dealii::Utilities::needed_digits(mpi_ensemble_.n_ensembles() - 1);
        base_name_ensemble_ +=
            "-ensemble_" +
            dealii::Utilities::int_to_string(mpi_ensemble_.ensemble(), digits);
      }
    }
 
    /* Attach log file and record runtime parameters: */
 
    if (mpi_ensemble_.world_rank() == 0)
      logfile_.open(base_name_ + ".log");
 
    print_parameters(logfile_);
 
    if (enable_compute_error_)
      error_evaluation_.prepare(base_name_);
 
    /*
     * Prepare data structures:
     */
 
    Number t = 0.;
    unsigned int timer_cycle = 0;
    StateVector<Number> state_vector;
 
    /* Create a small lambda for preparing compute kernels: */
    const auto prepare_compute_kernels = [&]() {
      print_info("preparing compute kernels");
 
      discretization_.update_mapping();
      offline_data_.prepare(problem_dimension, n_precomputed_values);
 
      hyperbolic_module_.prepare();
      parabolic_module_.prepare();
      time_integrator_.prepare();
      mesh_adaptor_.prepare(/*needs current timepoint*/ t);
      postprocessor_.prepare();
      vtu_output_.prepare();
      quantities_.prepare(base_name_ensemble_);
      print_mpi_partition(logfile_);
 
      if (mpi_ensemble_.ensemble_rank() == 0)
        n_global_dofs_ = dealii::Utilities::MPI::sum(
            offline_data_.dof_handler().n_dofs(),
            mpi_ensemble_.ensemble_leader_communicator());
    };
 
    {
      ComputingTimer::Scope scope("(re)initialize data structures");
      print_info("initializing data structures");
 
      if (resume_) {
        print_info("resume: reading mesh and loading state vector");
 
        read_checkpoint(state_vector,
                        base_name_ensemble_,
                        t,
                        timer_cycle,
                        prepare_compute_kernels);
 
        if (resume_at_time_zero_) {
          /* Reset the current time t and the output cycle count to zero: */
          t = 0.;
          timer_cycle = 0;
        }
 
      } else {
        print_info("creating mesh and interpolating initial values");
 
        discretization_.prepare(base_name_ensemble_);
 
        prepare_compute_kernels();
 
        hyperbolic_module_.reinit_state_vector(state_vector);
        parabolic_module_.reinit_state_vector(state_vector);
        {
          ComputingTimer::Scope scope(
              "time step [X]   - interpolate data vectors");
          state_vector.U =
              initial_values_.get().interpolate_hyperbolic_vector();
        }
        debug_poison_invalid_values(state_vector, offline_data_);
      }
    }
 
    print_device_information(logfile_);
 
    /* Prepare the state vector for time stepping. */
    time_integrator_.prepare_state_vector(state_vector, t);
 
    /*
     * The honorable main loop:
     */
 
    Number last_terminal_output = terminal_update_interval_ == Number(0.)
                                      ? std::numeric_limits<Number>::max()
                                      : Number(0.);
    Number last_checkpoint = checkpoint_update_interval_ == Number(0.)
                                 ? std::numeric_limits<Number>::max()
                                 : Number(0.);
 
    print_info("entering main loop");
    ComputingTimer::timer("time loop").start();
 
    constexpr Number relax =
        Number(1.) - Number(10.) * std::numeric_limits<Number>::epsilon();
 
    /* Create a small lambda for querying whether we write out vtu records: */
    const auto output_scheduled = [&](const unsigned int cycle) {
      const bool do_full_output =
          (cycle % timer_output_full_multiplier_ == 0) && enable_output_full_;
      const bool do_levelsets =
          (cycle % timer_output_levelsets_multiplier_ == 0) &&
          enable_output_levelsets_;
 
      return do_full_output || do_levelsets;
    };
 
    unsigned int cycle = 1;
    for (;; ++cycle) {
 
#ifdef DEBUG_OUTPUT
      std::cout << "\n\n###   cycle = " << cycle << "   ###\n\n" << std::endl;
#endif
 
      /* Accumulate quantities of interest: */
 
      if (enable_compute_quantities_) {
        ComputingTimer::Scope scope("time step [X]   - accumulate quantities");
        quantities_.accumulate(state_vector, t);
      }
 
      /* Perform output tasks whenever we reach a timer tick: */
 
      if (t >= relax * timer_cycle * timer_granularity_) {
        const bool do_compute_error =
            enable_compute_error_ &&
            (timer_cycle % timer_compute_error_multiplier_ == 0);
        const bool do_output_analytic =
            enable_compute_error_ && output_scheduled(timer_cycle);
 
        if (do_compute_error || do_output_analytic) {
          StateVector<Number> analytic;
          interpolate_analytic_solution(analytic, t);
 
          if (do_compute_error) {
            ComputingTimer::Scope scope("time step [X]   - compute error");
            error_evaluation_.write_out(state_vector, analytic, t);
          }
 
          if (do_output_analytic) {
            /* Apply boundary conditions and precompute values for output: */
            time_integrator_.prepare_state_vector(analytic, t);
 
            output(analytic,
                   base_name_ensemble_ + "-analytic_solution",
                   t,
                   timer_cycle);
          }
        }
 
        output(state_vector, base_name_ensemble_ + "-solution", t, timer_cycle);
 
        if (enable_compute_quantities_ &&
            (timer_cycle % timer_compute_quantities_multiplier_ == 0)) {
          ComputingTimer::Scope scope("time step [X]   - write out quantities");
          quantities_.write_out(state_vector, t, timer_cycle);
        }
 
        ++timer_cycle;
      }
 
      /* Break if we have reached the final time. */
 
      if (t >= relax * t_final_)
        break;
 
      /* Peform a mesh adaptation cycle: */
 
      if (enable_mesh_adaptivity_) {
        {
          ComputingTimer::Scope scope(
              "time step [X]   - analyze for mesh adaptation");
 
          mesh_adaptor_.analyze(state_vector, t, cycle);
        }
 
        if (mesh_adaptor_.need_mesh_adaptation()) {
          ComputingTimer::Scope scope_1("(re)initialize data structures");
          ComputingTimer::Scope scope_2(
              "time step [X]   - perform mesh adaptation");
          print_info("performing mesh adaptation");
 
          adapt_mesh_and_transfer_state_vector(state_vector,
                                               prepare_compute_kernels);
 
          /* Prepare the state vector for time stepping. */
          time_integrator_.prepare_state_vector(state_vector, t);
        }
      }
 
      /* Perform a time step: */
 
      const auto tau = time_integrator_.step(
          state_vector,
          t,
          enforce_t_final_
              ? std::min(t_final_, timer_cycle * timer_granularity_)
              : std::numeric_limits<Number>::max());
 
      t += tau;
 
      time_integrator_.prepare_state_vector(state_vector, t);
 
      /* Synchronize wall time: */
 
      auto wall_time = ComputingTimer::timer("time loop").wall_time();
      {
        ComputingTimer::Scope scope(
            "time step [X] _ - synchronization barriers");
        wall_time =
            Utilities::MPI::max(wall_time, mpi_ensemble_.world_communicator());
      }
 
      /* Print and record cycle statistics: */
 
      const bool write_to_log_file =
          (terminal_update_interval_ != Number(0.)) && /* suppress output */
          (t >= relax * timer_cycle * timer_granularity_);
 
      const bool update_terminal =
          (wall_time >= last_terminal_output + terminal_update_interval_);
 
      if (write_to_log_file || update_terminal) {
        ComputingTimer::Scope scope(
            "time step [X] _ - synchronization barriers");
        print_cycle_statistics(cycle,
                               t,
                               timer_cycle,
                               last_checkpoint,
                               /*logfile*/ write_to_log_file);
        last_terminal_output = wall_time;
      }
 
      const bool update_checkpoint =
          (wall_time >= last_checkpoint + checkpoint_update_interval_);
 
      if (update_checkpoint) {
        ComputingTimer::Scope scop("time step [X]   - perform checkpointing");
 
        print_info("scheduling checkpointing");
        write_checkpoint(state_vector, base_name_ensemble_, t, timer_cycle);
        last_checkpoint = wall_time;
      }
    } /* end of loop */
 
    /* We have actually performed one cycle less. */
    --cycle;
 
    if (checkpoint_update_interval_ != Number(0.)) {
      ComputingTimer::Scope scope("time step [X]   - perform checkpointing");
 
      print_info("scheduling checkpointing");
      write_checkpoint(state_vector, base_name_ensemble_, t, timer_cycle);
    }
 
    ComputingTimer::timer("time loop").stop();
 
    /* Write final timing statistics to screen and logfile: */
 
    if (terminal_update_interval_ != Number(0.)) {
      print_cycle_statistics(cycle,
                             t,
                             timer_cycle,
                             last_checkpoint,
                             /*logfile*/ true,
                             /*final*/ true);
    }
 
    /* Compute final error and write out to log file and screen: */
 
    if (enable_compute_error_) {
      /* Output final error: */
      StateVector<Number> analytic;
      interpolate_analytic_solution(analytic, t);
      const auto norms = error_evaluation_.compute(state_vector, analytic);
 
      logfile_ << std::endl << "Computed errors:" << std::endl << std::endl;
      error_evaluation_.print_summary(logfile_, t, n_global_dofs_, norms);
      error_evaluation_.print_summary(std::cout, t, n_global_dofs_, norms);
    }
 
    /* Print debug file to screen on rank 0: */
 
    if (mpi_ensemble_.world_rank() == 0) {
      if (debug_command_ != "") {
        auto result [[maybe_unused]] = std::system(debug_command_.c_str());
      }
 
      if (debug_filename_ != "") {
        std::ifstream f(debug_filename_);
        if (f.is_open())
          std::cout << f.rdbuf();
      }
    }
  }
 
 
  /*
   * ---------------------------------------------------------------------------
   * Checkpointing and VTK output:
   * ---------------------------------------------------------------------------
   */
 
 
  template <typename HD, typename PD, int dim, typename Number>
  template <typename Callable>
  void TimeLoop<HD, PD, dim, Number>::read_checkpoint(
      StateVector<Number> &state_vector,
      const std::string &base_name,
      Number &t,
      unsigned int &timer_cycle,
      const Callable &prepare_compute_kernels)
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::read_checkpoint()" << std::endl;
#endif
 
    /*
     * Initialize discretization, read in the mesh, and initialize everything:
     */
 
    discretization_.refinement() = 0; /* do not refine */
    discretization_.prepare(base_name);
    discretization_.triangulation().load(base_name + "-checkpoint.mesh");
 
    prepare_compute_kernels();
 
    /*
     * Read in and broadcast metadata:
     */
 
    std::string name = base_name + "-checkpoint";
 
    unsigned int transfer_handle;
    if (mpi_ensemble_.ensemble_rank() == 0) {
      std::string meta = name + ".metadata";
 
      std::ifstream file(meta, std::ios::binary);
      boost::archive::binary_iarchive ia(file);
      ia >> t >> timer_cycle >> transfer_handle;
    }
 
    int ierr;
    if constexpr (std::is_same_v<Number, double>)
      ierr = MPI_Bcast(
          &t, 1, MPI_DOUBLE, 0, mpi_ensemble_.ensemble_communicator());
    else
      ierr =
          MPI_Bcast(&t, 1, MPI_FLOAT, 0, mpi_ensemble_.ensemble_communicator());
    AssertThrowMPI(ierr);
 
    ierr = MPI_Bcast(&timer_cycle,
                     1,
                     MPI_UNSIGNED,
                     0,
                     mpi_ensemble_.ensemble_communicator());
    AssertThrowMPI(ierr);
 
    ierr = MPI_Bcast(&transfer_handle,
                     1,
                     MPI_UNSIGNED,
                     0,
                     mpi_ensemble_.ensemble_communicator());
    AssertThrowMPI(ierr);
 
    /* Now read in the state vector: */
 
    hyperbolic_module_.reinit_state_vector(state_vector);
    parabolic_module_.reinit_state_vector(state_vector);
 
    solution_transfer_.set_handle(transfer_handle);
    solution_transfer_.project(state_vector);
    solution_transfer_.reset_handle();
    debug_poison_invalid_values(state_vector, offline_data_);
 
    time_integrator_.prepare_state_vector(state_vector, t);
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::write_checkpoint(
      const StateVector<Number> &state_vector,
      const std::string &base_name,
      const Number &t,
      const unsigned int &timer_cycle)
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::write_checkpoint()" << std::endl;
#endif
 
    solution_transfer_.prepare_projection(state_vector);
    const auto transfer_handle = solution_transfer_.get_handle();
    solution_transfer_.reset_handle();
 
    std::string name = base_name + "-checkpoint";
 
    if (mpi_ensemble_.ensemble_rank() == 0) {
      for (const std::string suffix :
           {".mesh", ".mesh_fixed.data", ".mesh.info", ".metadata"})
        if (std::filesystem::exists(name + suffix))
          std::filesystem::rename(name + suffix, name + suffix + "~");
    }
 
    const auto &triangulation = discretization_.triangulation();
    triangulation.save(name + ".mesh");
 
    /*
     * Now, write out metadata on rank 0:
     */
 
    if (mpi_ensemble_.ensemble_rank() == 0) {
      std::string meta = name + ".metadata";
      std::ofstream file(meta, std::ios::binary | std::ios::trunc);
      boost::archive::binary_oarchive oa(file);
      oa << t << timer_cycle << transfer_handle;
    }
 
    const int ierr = MPI_Barrier(mpi_ensemble_.ensemble_communicator());
    AssertThrowMPI(ierr);
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  template <typename Callable>
  void TimeLoop<HD, PD, dim, Number>::adapt_mesh_and_transfer_state_vector(
      StateVector<Number> &state_vector,
      const Callable &prepare_compute_kernels)
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::adapt_mesh_and_transfer_state_vector()"
              << std::endl;
#endif
 
    AssertThrow(mpi_ensemble_.n_ensembles() == 1, dealii::ExcNotImplemented());
 
    /*
     * Mark cells for coarsening and refinement and set up triangulation:
     */
 
    auto &triangulation = discretization_.triangulation();
    mesh_adaptor_.mark_cells_for_coarsening_and_refinement(triangulation);
 
    triangulation.prepare_coarsening_and_refinement();
 
    solution_transfer_.prepare_projection(state_vector);
 
    /* Execute mesh adaptation and project old state to new state vector: */
 
    triangulation.execute_coarsening_and_refinement();
    prepare_compute_kernels();
 
    hyperbolic_module_.reinit_state_vector(state_vector);
    parabolic_module_.reinit_state_vector(state_vector);
 
    solution_transfer_.project(state_vector);
    solution_transfer_.reset_handle();
    debug_poison_invalid_values(state_vector, offline_data_);
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::interpolate_analytic_solution(
      StateVector<Number> &analytic, const Number t)
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::interpolate_analytic_solution()"
              << std::endl;
#endif
 
    ComputingTimer::Scope scope("time step [X]   - interpolate data vectors");
 
    hyperbolic_module_.reinit_state_vector(analytic);
    parabolic_module_.reinit_state_vector(analytic);
    analytic.U = initial_values_.get().interpolate_hyperbolic_vector(t);
 
    /* Populate precomputed values (without applying boundary conditions): */
    hyperbolic_system_.get().fill_precomputed_values(
        offline_data_, analytic, /*skip_constrained_dofs*/ false);
    analytic.precomputed.template view<n_precomputed_values>()
        .update_ghost_values();
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void
  TimeLoop<HD, PD, dim, Number>::output(const StateVector<Number> &state_vector,
                                        const std::string &name,
                                        const Number t,
                                        const unsigned int cycle)
  {
#ifdef DEBUG_OUTPUT
    std::cout << "TimeLoop<dim, Number>::output(t = " << t << ")" << std::endl;
#endif
 
    const bool do_full_output =
        (cycle % timer_output_full_multiplier_ == 0) && enable_output_full_;
    const bool do_levelsets =
        (cycle % timer_output_levelsets_multiplier_ == 0) &&
        enable_output_levelsets_;
 
    /* There is nothing to do: */
    if (!(do_full_output || do_levelsets))
      return;
 
    /* Data output: */
 
    ComputingTimer::Scope scope("time step [X]   - perform vtu output");
    print_info("scheduling output");
 
    postprocessor_.compute(state_vector);
    /*
     * Workaround: Manually reset bounds during the first output cycle
     * (which is often just a uniform flow field) to obtain a better
     * normailization:
     */
    if (cycle == 0)
      postprocessor_.reset_bounds();
 
    /* Make sure we have a valid vector of smoothness indicators. */
    mesh_adaptor_.compute_smoothness_indicators(state_vector);
 
    vtu_output_.schedule_output(
        state_vector, name, t, cycle, do_full_output, do_levelsets);
  }
 
 
  /*
   * ---------------------------------------------------------------------------
   * Output and logging related functions:
   * ---------------------------------------------------------------------------
   */
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_parameters(std::ostream &stream)
  {
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    /* Output commit and library information: */
 
    print_revision_and_version(stream);
 
    /* Print run time parameters: */
 
    stream << std::endl << "Run time parameters:" << std::endl << std::endl;
    ParameterAcceptor::prm.print_parameters(
        stream, ParameterHandler::OutputStyle::ShortPRM);
    stream << std::endl;
 
    /* Also print out parameters to a prm file: */
 
    std::ofstream output(base_name_ + "-parameters.prm");
    ParameterAcceptor::prm.print_parameters(output, ParameterHandler::ShortPRM);
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_mpi_partition(std::ostream &stream)
  {
    /*
     * Fixme: this conversion to double is really not elegant. We should
     * improve the Utilities::MPI::min_max_avg function in deal.II to
     * handle different data types
     */
 
    // NOLINTBEGIN
    std::vector<double> values = {
        (double)offline_data_.n_export_indices(),
        (double)offline_data_.n_locally_internal(),
        (double)offline_data_.n_locally_owned(),
        (double)offline_data_.n_locally_relevant(),
        (double)offline_data_.n_export_indices() /
            (double)offline_data_.n_locally_relevant(),
        (double)offline_data_.n_locally_internal() /
            (double)offline_data_.n_locally_relevant(),
        (double)offline_data_.n_locally_owned() /
            (double)offline_data_.n_locally_relevant()};
    // NOLINTEND
 
    const auto data =
        Utilities::MPI::min_max_avg(values, mpi_ensemble_.world_communicator());
 
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    std::ostringstream output;
 
    unsigned int n =
        dealii::Utilities::needed_digits(mpi_ensemble_.n_world_ranks());
 
    const auto print_snippet = [&output, n](const std::string &name,
                                            const auto &values) {
      output << name << ": ";
      // NOLINTBEGIN
      output << std::setw(9) << (unsigned int)values.min          //
             << " [p" << std::setw(n) << values.min_index << "] " //
             << std::setw(9) << (unsigned int)values.avg << " "   //
             << std::setw(9) << (unsigned int)values.max          //
             << " [p" << std::setw(n) << values.max_index << "]"; //
      // NOLINTEND
    };
 
    const auto print_percentages = [&output, n](const auto &percentages) {
      output << std::endl << "                  ";
      output << "  (" << std::setw(3) << std::setprecision(2)
             << percentages.min * 100 << "% )"
             << " [p" << std::setw(n) << percentages.min_index << "] "
             << "   (" << std::setw(3) << std::setprecision(2)
             << percentages.avg * 100 << "% )"
             << " "
             << "   (" << std::setw(3) << std::setprecision(2)
             << percentages.max * 100 << "% )"
             << " [p" << std::setw(n) << percentages.max_index << "]";
    };
 
    output << std::endl << std::endl << "Partition:   ";
    print_snippet("exp", data[0]);
    print_percentages(data[4]);
 
    output << std::endl << "             ";
    print_snippet("int", data[1]);
    print_percentages(data[5]);
 
    output << std::endl << "             ";
    print_snippet("own", data[2]);
    print_percentages(data[6]);
 
    output << std::endl << "             ";
    print_snippet("rel", data[3]);
 
    stream << output.str() << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void
  TimeLoop<HD, PD, dim, Number>::print_device_information(std::ostream &stream)
  {
    /* Device information is only meaningful for a device build: */
    if constexpr (!have_separate_memory_spaces)
      return;
 
#if defined(KOKKOS_ENABLE_CUDA) || defined(KOKKOS_ENABLE_HIP)
    /*
     * Determine how many distinct devices we are running on: Multiple
     * ranks might be bound to the same device, so counting ranks would
     * overreport. We thus count distinct (hostname, device id) pairs.
     */
    {
      using Device = std::pair<std::string, int>;
 
      const Device local{dealii::Utilities::System::get_hostname(),
                         Kokkos::device_id()};
      const auto all = dealii::Utilities::MPI::all_gather(
          mpi_ensemble_.world_communicator(), local);
      n_devices_ = std::set<Device>(all.begin(), all.end()).size();
    }
#endif
 
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    std::ostringstream output;
 
    const auto entry [[maybe_unused]] =
        [&output](const std::string &label) -> std::ostream & {
      output << std::endl
             << "             " << std::left << std::setw(22) << label;
      return output;
    };
 
    output << std::endl
           << std::endl
           << "Device:      " << std::left << std::setw(22) << "backend"
           << Kokkos::DefaultExecutionSpace::name();
 
    /*
     * Kokkos does not provide a portable device property class. We thus
     * have to query the individual backends by hand:
     */
 
#if defined(KOKKOS_ENABLE_CUDA)
    const auto &prop = Kokkos::Cuda{}.cuda_device_prop();
 
    entry("device") << prop.name;
    entry("compute capability") << prop.major << "." << prop.minor;
    entry("device id") << Kokkos::device_id() << " of "
                       << Kokkos::num_devices();
    entry("devices in use")
        << n_devices_ << " on " << mpi_ensemble_.n_world_ranks() << " ranks";
    entry("multiprocessors") << prop.multiProcessorCount;
    entry("warp size") << prop.warpSize << " (hardware), " << warp_size
                       << " (ryujin::warp_size)";
    entry("threads per SM")
        << prop.maxThreadsPerMultiProcessor << " ("
        << prop.maxThreadsPerMultiProcessor / prop.warpSize << " warps)";
    entry("threads per block") << prop.maxThreadsPerBlock;
    entry("concurrency") << Kokkos::DefaultExecutionSpace{}.concurrency();
    entry("registers per SM") << prop.regsPerBlock;
    entry("shared memory per SM")
        << prop.sharedMemPerMultiprocessor / 1024 << " KiB";
    entry("L2 cache") << prop.l2CacheSize / 1024 / 1024 << " MiB";
    entry("global memory") << prop.totalGlobalMem / 1024 / 1024 << " MiB";
 
#elif defined(KOKKOS_ENABLE_HIP)
    const auto &prop = Kokkos::HIP::hip_device_prop();
 
    entry("device") << prop.name;
    entry("architecture") << prop.gcnArchName;
    entry("device id") << Kokkos::device_id() << " of "
                       << Kokkos::num_devices();
    entry("devices in use")
        << n_devices_ << " on " << mpi_ensemble_.n_world_ranks() << " ranks";
    entry("compute units") << prop.multiProcessorCount;
    entry("warp size") << prop.warpSize << " (hardware), " << warp_size
                       << " (ryujin::warp_size)";
    entry("threads per CU")
        << prop.maxThreadsPerMultiProcessor << " ("
        << prop.maxThreadsPerMultiProcessor / prop.warpSize << " warps)";
    entry("threads per block") << prop.maxThreadsPerBlock;
    entry("concurrency") << Kokkos::DefaultExecutionSpace{}.concurrency();
    entry("registers per block") << prop.regsPerBlock;
    entry("shared memory per block") << prop.sharedMemPerBlock / 1024 << " KiB";
    entry("L2 cache") << prop.l2CacheSize / 1024 / 1024 << " MiB";
    entry("global memory") << prop.totalGlobalMem / 1024 / 1024 << " MiB";
#endif
 
    stream << output.str() << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_info(const std::string &header)
  {
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    std::cout << "[INFO] " << header << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_head(const std::string &header,
                                                 const std::string &secondary,
                                                 std::ostream &stream)
  {
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    const int header_size = header.size();
    const auto padded_header =
        std::string(std::max(0, 34 - header_size) / 2, ' ') + header +
        std::string(std::max(0, 35 - header_size) / 2, ' ');
 
    const int secondary_size = secondary.size();
    const auto padded_secondary =
        std::string(std::max(0, 34 - secondary_size) / 2, ' ') + secondary +
        std::string(std::max(0, 35 - secondary_size) / 2, ' ');
 
    /* clang-format off */
    stream << "\n";
    stream << "    ####################################################\n";
    stream << "    #########"     <<  padded_header   <<     "#########\n";
    stream << "    #########"     << padded_secondary <<     "#########\n";
    stream << "    ####################################################\n";
    stream << std::endl;
    /* clang-format on */
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void
  TimeLoop<HD, PD, dim, Number>::print_information(unsigned int timer_cycle,
                                                   Number last_checkpoint,
                                                   std::ostream &stream,
                                                   bool final_time)
  {
    static const std::string backend_name = [] {
      const auto precision = [] {
        if constexpr (std::is_same_v<Number, double>)
          return std::string("FP64");
        else if constexpr (std::is_same_v<Number, float>)
          return std::string("FP32");
        else
          __builtin_trap();
      }();
 
      constexpr auto simd_size = VectorizedArray<Number>::size();
 
      if constexpr (have_separate_memory_spaces)
        return "GPU, " + precision + ", warp size " + std::to_string(warp_size);
      else if constexpr (simd_size == 1)
        return "scalar, " + precision;
      else
        return "SIMD, " + precision + ", width " + std::to_string(simd_size);
    }();
 
    stream << "Information: (HYP) " << hyperbolic_system_.get().problem_name();
    if constexpr (!ParabolicSystem::is_identity) {
      stream << "\n             (PAR) "
             << parabolic_system_.get().problem_name();
    }
    stream << "\n             [" << base_name_ << "] ";
    if (mpi_ensemble_.n_ensembles() > 1) {
      stream << mpi_ensemble_.n_ensembles() << " ensembles ";
    }
    stream << "with " << n_global_dofs_ << " Qdofs on "
           << mpi_ensemble_.n_world_ranks() << " ranks "
#if defined(WITH_OPENMP)
           << "/ " << omp_get_max_threads() << " threads "
#ifndef WITH_DEAL_II_THREADS
           << "[serial dealii] "
#endif
#elif defined(WITH_DEAL_II_THREADS)
           << "/ " << MultithreadInfo::n_threads() << " threads "
#endif
           << "<" << backend_name << ">\n";
 
    stream << "             Last output cycle "                    //
           << timer_cycle - 1                                      //
           << " at t = " << timer_granularity_ * (timer_cycle - 1) //
           << "  [ log ";
 
    if (enable_output_full_)
      stream << "full ";
    if (enable_output_levelsets_)
      stream << "levelsets ";
    if (enable_compute_error_)
      stream << "error ";
    if (enable_compute_quantities_)
      stream << "quantities ";
 
    stream << "]\n";
 
    if (checkpoint_update_interval_ != Number(0.)) {
      const auto wall_time = Utilities::MPI::min_max_avg(
          ComputingTimer::timer("time loop").wall_time(),
          mpi_ensemble_.world_communicator());
 
      if (final_time) {
        stream << "             Last checkpoint at FINAL TIME\n";
      } else {
        stream << "             Last checkpoint at wall time "          //
               << std::setprecision(2) << std::fixed << last_checkpoint //
               << "s  (" << std::setprecision(0)
               << std::max(0., wall_time.max - last_checkpoint)
               << "s ago, interval " << checkpoint_update_interval_ << "s)\n";
      }
    }
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void
  TimeLoop<HD, PD, dim, Number>::print_memory_statistics(std::ostream &stream)
  {
    Utilities::System::MemoryStats stats;
    Utilities::System::get_memory_stats(stats);
 
    Utilities::MPI::MinMaxAvg data = Utilities::MPI::min_max_avg(
        stats.VmRSS / 1024., mpi_ensemble_.world_communicator());
 
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    std::ostringstream output;
 
    unsigned int n =
        dealii::Utilities::needed_digits(mpi_ensemble_.n_world_ranks());
 
    output << "\nMemory:      [MiB]"                          //
           << std::setw(8) << data.min                        //
           << " [p" << std::setw(n) << data.min_index << "] " //
           << std::setw(8) << data.avg << " "                 //
           << std::setw(8) << data.max                        //
           << " [p" << std::setw(n) << data.max_index << "]"; //
 
    stream << output.str() << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_timers(std::ostream &stream)
  {
    std::vector<std::ostringstream> output(ComputingTimer::timers().size());
 
    const auto equalize = [&]() {
      const auto ptr =
          std::max_element(output.begin(),
                           output.end(),
                           [](const auto &left, const auto &right) {
                             return left.str().length() < right.str().length();
                           });
      const auto length = ptr->str().length();
      for (auto &it : output)
        it << std::string(length - it.str().length() + 1, ' ');
    };
 
    const auto print_wall_time = [&](auto &timer, auto &stream) {
      const auto wall_time = Utilities::MPI::min_max_avg(
          timer.wall_time(), mpi_ensemble_.world_communicator());
 
      constexpr auto eps = std::numeric_limits<double>::epsilon();
      /*
       * Cut off at 99.9% to avoid silly percentages cluttering up the
       * output.
       */
      const auto skew_negative = std::max(
          100. * (wall_time.min - wall_time.avg) / wall_time.avg - eps, -99.9);
      const auto skew_positive = std::min(
          100. * (wall_time.max - wall_time.avg) / wall_time.avg + eps, 99.9);
 
      stream << std::setprecision(2) << std::fixed << std::setw(9)
             << wall_time.avg << "s [sk: " << std::setprecision(1)
             << std::setw(5) << std::fixed << skew_negative << "%/"
             << std::setw(4) << std::fixed << skew_positive << "%]";
      unsigned int n =
          dealii::Utilities::needed_digits(mpi_ensemble_.n_world_ranks());
      stream << " [p" << std::setw(n) << wall_time.min_index << "/"
             << wall_time.max_index << "]";
    };
 
    const auto cpu_time_statistics = Utilities::MPI::min_max_avg(
        ComputingTimer::timer("time loop").cpu_time(),
        mpi_ensemble_.world_communicator());
    const double total_cpu_time = cpu_time_statistics.sum;
 
    const auto print_cpu_time =
        [&](auto &timer, auto &stream, bool percentage) {
          const auto cpu_time = Utilities::MPI::min_max_avg(
              timer.cpu_time(), mpi_ensemble_.world_communicator());
 
          stream << std::setprecision(2) << std::fixed << std::setw(12)
                 << cpu_time.sum << "s ";
 
          if (percentage)
            stream << "(" << std::setprecision(1) << std::setw(4)
                   << 100. * cpu_time.sum / total_cpu_time << "%)";
        };
 
    auto jt = output.begin();
    for (auto &it : ComputingTimer::timers())
      *jt++ << "  " << it.first;
    equalize();
 
    jt = output.begin();
    for (auto &it : ComputingTimer::timers())
      print_wall_time(it.second, *jt++);
    equalize();
 
    jt = output.begin();
    bool compute_percentages = false;
    for (auto &it : ComputingTimer::timers()) {
      print_cpu_time(it.second, *jt++, compute_percentages);
      if (it.first.starts_with("time loop"))
        compute_percentages = true;
    }
    equalize();
 
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    stream << std::endl << "Timer statistics:\n";
    for (auto &it : output)
      stream << it.str() << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_throughput(unsigned int cycle,
                                                       Number t,
                                                       std::ostream &stream,
                                                       bool final_time)
  {
    /*
     * Fixme: The global state kept in this function should be refactored
     * into its own class object.
     */
    static struct Data {
      unsigned int cycle = 0;
      double t = 0.;
      double cpu_time_sum = 0.;
      double cpu_time_avg = 0.;
      double cpu_time_min = 0.;
      double cpu_time_max = 0.;
      double wall_time = 0.;
      double device_time_sum = 0.;
    } previous, current;
 
    static double time_per_second_exp = 0.;
 
    /* Update statistics: */
 
    {
      previous = current;
 
      current.cycle = cycle;
      current.t = t;
 
      const auto wall_time_statistics = Utilities::MPI::min_max_avg(
          ComputingTimer::timer("time loop").wall_time(),
          mpi_ensemble_.world_communicator());
      current.wall_time = wall_time_statistics.max;
 
      const auto cpu_time_statistics = Utilities::MPI::min_max_avg(
          ComputingTimer::timer("time loop").cpu_time(),
          mpi_ensemble_.world_communicator());
      current.cpu_time_sum = cpu_time_statistics.sum;
      current.cpu_time_avg = cpu_time_statistics.avg;
      current.cpu_time_min = cpu_time_statistics.min;
      current.cpu_time_max = cpu_time_statistics.max;
 
      if constexpr (have_separate_memory_spaces) {
        const auto device_time_statistics = Utilities::MPI::min_max_avg(
            DeviceTimer::seconds(), mpi_ensemble_.world_communicator());
        current.device_time_sum = device_time_statistics.sum;
      }
    }
 
    if (final_time)
      previous = Data();
 
    /* Take averages: */
 
    double delta_cycles = current.cycle - previous.cycle;
    const double cycles_per_second =
        delta_cycles / (current.wall_time - previous.wall_time);
 
    const auto efficiency = time_integrator_.efficiency();
    const auto n_dofs = static_cast<double>(n_global_dofs_);
 
    double wall_m_dofs_per_sec = delta_cycles * n_dofs * efficiency / 1.e6 /
                                 (current.wall_time - previous.wall_time);
 
    const double delta_time =
        (current.t - previous.t) / (current.cycle - previous.cycle);
    const double time_per_second =
        (current.t - previous.t) / (current.wall_time - previous.wall_time);
 
    /* Print Jean-Luc and Martin metrics: */
 
    std::ostringstream output;
 
    /* clang-format off */
    output << std::endl;
 
    output << "Throughput:" << std::endl;
 
    if constexpr (have_separate_memory_spaces) {
      /* Write out some statistics about GPU utilization: */
 
      const double delta_wall_time = current.wall_time - previous.wall_time;
      const double delta_device_time =
          current.device_time_sum - previous.device_time_sum;
 
      const double utilization =
          delta_device_time / (n_devices_ * delta_wall_time);
 
      const double device_m_dofs_per_sec =
          delta_cycles * n_dofs * efficiency / 1.e6 / delta_device_time;
      output << "  GPU : "
             << std::setprecision(4) << std::fixed << device_m_dofs_per_sec
             << " MQ/s in compute kernels (on "
             << n_devices_ << (n_devices_ == 1 ? " device)" : " devices)")
             << std::endl;
 
      output << "        ["
             << std::setprecision(2) << std::fixed << delta_device_time
             << "s device / "
             << std::setprecision(2) << std::fixed << delta_wall_time
             << "s wall = "
             << std::setprecision(1) << std::fixed << 100. * utilization
             << "% utilization ]" << std::endl;
 
    } else {
      /* Write out some statistics about CPU utilization: */
 
      double cpu_m_dofs_per_sec = delta_cycles * n_dofs * efficiency / 1.e6 /
                                  (current.cpu_time_sum - previous.cpu_time_sum);
 
      /* Determine whether we fudge the CPU timings: */
      const bool fudge_cpu_timings = terminal_correct_for_hypertreadhing_ &&
#if defined(WITH_OPENMP)
                                     (omp_get_max_threads() == 2);
#elif defined(WITH_DEAL_II_THREADS)
                                     (MultithreadInfo::n_threads() == 2);
#else
                                     false;
#endif
 
      if (fudge_cpu_timings)
        cpu_m_dofs_per_sec *= 2.;
 
      double cpu_time_skew = (current.cpu_time_max - current.cpu_time_min - //
                              previous.cpu_time_max + previous.cpu_time_min) /
                             delta_cycles;
      /* avoid printing small negative numbers: */
      cpu_time_skew = std::max(0., cpu_time_skew);
 
      const double cpu_time_skew_percentage =
          cpu_time_skew * delta_cycles /
          (current.cpu_time_avg - previous.cpu_time_avg);
 
      output << "  "
             << (fudge_cpu_timings ? "CPU*: " : "CPU : ")
             << std::setprecision(4) << std::fixed << cpu_m_dofs_per_sec
             << " MQ/s  ("
             << std::scientific << 1. / cpu_m_dofs_per_sec * 1.e-6
             << " s/Qdof/substep)" << std::endl;
 
      output << "        [cpu time skew: "
             << std::setprecision(2) << std::scientific << cpu_time_skew
             << "s/cycle ("
             << std::setprecision(1) << std::setw(4) << std::setfill(' ') << std::fixed
             << 100. * cpu_time_skew_percentage
             << "%)]" << std::endl;
    }
 
    output << "  WALL: "
           << std::setprecision(4) << std::fixed << wall_m_dofs_per_sec
           << " MQ/s  ("
           << std::scientific << 1. / wall_m_dofs_per_sec * 1.e-6
           << " s/Qdof/substep)  ("
           << std::setprecision(2) << std::fixed << cycles_per_second
           << " cycles/s)" << std::endl;
 
    const auto &scheme = time_integrator_.time_stepping_scheme();
    output << "        [ "
           << Patterns::Tools::Convert<TimeSteppingScheme>::to_string(scheme)
           << " with CFL = "
           << std::setprecision(2) << std::fixed << hyperbolic_module_.cfl()
           << " ("
           << std::setprecision(0) << std::fixed << hyperbolic_module_.n_restarts()
           << "/"
           << std::setprecision(0) << std::fixed << parabolic_module_.n_restarts()
           << " rsts) ("
           << std::setprecision(0) << std::fixed << hyperbolic_module_.n_warnings()
           << "/"
           << std::setprecision(0) << std::fixed << parabolic_module_.n_warnings()
           << " warn) ("
           << std::setprecision(0) << std::fixed << hyperbolic_module_.n_corrections()
           << "/"
           << std::setprecision(0) << std::fixed << parabolic_module_.n_corrections()
           << " corr) ]" << std::endl;
 
    if constexpr (!ParabolicSystem::is_identity)
      parabolic_module_.print_solver_statistics(output);
 
    output << "        [ dt = "
           << std::scientific << std::setprecision(2) << delta_time
           << " ( "
           << time_per_second
           << " dt/s) ]" << std::endl;
    /* clang-format on */
 
    /* And print an ETA: */
 
    time_per_second_exp = 0.8 * time_per_second_exp + 0.2 * time_per_second;
    auto eta = static_cast<unsigned int>(std::max(t_final_ - t, Number(0.)) /
                                         time_per_second_exp);
 
    output << "\n  ETA : ";
 
    const unsigned int days = eta / (24 * 3600);
    if (days > 0) {
      output << days << " d  ";
      eta %= 24 * 3600;
    }
 
    const unsigned int hours = eta / 3600;
    if (hours > 0) {
      output << hours << " h  ";
      eta %= 3600;
    }
 
    const unsigned int minutes = eta / 60;
    output << minutes << " min";
 
    output << "   (terminal update every " //
           << std::setprecision(2) << std::fixed << terminal_update_interval_
           << "s)";
 
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
    stream << output.str() << std::endl;
  }
 
 
  template <typename HD, typename PD, int dim, typename Number>
  void TimeLoop<HD, PD, dim, Number>::print_cycle_statistics(
      unsigned int cycle,
      Number t,
      unsigned int timer_cycle,
      Number last_checkpoint,
      bool write_to_logfile,
      bool final_time)
  {
    std::ostringstream output;
 
    /* Print header: */
 
    std::ostringstream primary;
    if (final_time) {
      primary << "FINAL  (cycle " << Utilities::int_to_string(cycle, 6) << ")";
    } else {
      primary << "Cycle  " << Utilities::int_to_string(cycle, 6) //
              << "  (" << std::fixed << std::setprecision(1)     //
              << t / t_final_ * 100 << "%)";
    }
 
    std::ostringstream secondary;
    secondary << "at time t = " << std::setprecision(8) << std::fixed << t;
 
    print_head(primary.str(), secondary.str(), output);
 
    /* Print information and statistics: */
 
    print_information(timer_cycle, last_checkpoint, output, final_time);
    print_memory_statistics(output);
    print_timers(output);
    print_throughput(cycle, t, output, final_time);
 
    /* Only output on rank 0: */
    if (mpi_ensemble_.world_rank() != 0)
      return;
 
#ifndef DEBUG_OUTPUT
    std::cout << "\033[2J\033[H";
#endif
    std::cout << output.str() << std::flush;
 
    if (write_to_logfile) {
      logfile_ << "\n" << output.str() << std::flush;
    }
  }
} // namespace ryujin