From 1c98633ea37d8891f0abdaf3f56e81459d4e29f1 Mon Sep 17 00:00:00 2001 From: Matthias Maier Date: Thu, 20 Feb 2020 02:00:57 -0600 Subject: [PATCH] Address some more review comments --- examples/step-69/doc/intro.dox | 43 ++++++-- examples/step-69/step-69.cc | 193 +++++++++++++++++---------------- 2 files changed, 129 insertions(+), 107 deletions(-) diff --git a/examples/step-69/doc/intro.dox b/examples/step-69/doc/intro.dox index 239c97cc26..d58612356b 100644 --- a/examples/step-69/doc/intro.dox +++ b/examples/step-69/doc/intro.dox @@ -244,27 +244,46 @@ With this notation at hand we can define the (explicit time stepping) scheme as: @f{align*}{ m_i \frac{\mathbf{U}_i^{n+1} - \mathbf{U}_i^{n}}{\tau} - + \sum_{j \in \mathcal{I}(i)} \mathbb{f}(\mathbf{U}_j^{n})\cdot - \mathbf{c}_{ij} - \sum_{j \in \mathcal{I}(i)} + + \sum_{j \in \mathcal{I}(i)\backslash\{i\}} \mathbb{f}(\mathbf{U}_j^{n})\cdot + \mathbf{c}_{ij} - \sum_{j \in \mathcal{I}(i)\backslash\{i\}} d_{ij} \mathbf{U}_j^{n} = \boldsymbol{0} \, , @f} where - $m_i \dealcoloneq \int_{\Omega} \phi_i \, \mathrm{d}\mathbf{x}$ + is the lumped mass matrix - $\tau$ is the time step size - $\mathbf{c}_{ij} \dealcoloneq \int_{\Omega} \nabla\phi_j\phi_i \, \mathrm{d}\mathbf{x}$ (note that $\mathbf{c}_{ij}\in \mathbb{R}^d$) - - $\mathcal{I}(i) \dealcoloneq \{j \in \mathcal{V} \ | \ \mathbf{c}_{ij} \not \equiv - \boldsymbol{0}\} \cup \{i\}$. We will refer to $\mathcal{I}(i)$ as the - "stencil" (or adjacency list) at the support point $i$. - - $\mathbb{f}(\mathbf{U}_j^{n})$ is just the flux $\mathbb{f}$ of the - hyperbolic system evaluated at the state $\mathbf{U}_j^{n}$ stored at the - support point $j$. + is a vector-valued matrix that was used to approximate the divergence + of the flux in a weak sense. + - $\mathcal{I}(i) \dealcoloneq \{j \in \mathcal{V} \ | \ \mathbf{c}_{ij} + \not \equiv \boldsymbol{0}\} \cup \{i\}$ is the adjacency list + containing all degrees of freedom coupling to the index $i$. In other + words $\mathcal{I}(i)$ contains all nonzero column indices for row + index i. $\mathcal{I}(i)$ will also be called a "stencil". + - $\mathbb{f}(\mathbf{U}_j^{n})$ is the flux $\mathbb{f}$ of the + hyperbolic system evaluated for the state $\mathbf{U}_j^{n}$ associated + with support point $\mathbf{x}_j$. - $d_{ij} \dealcoloneq \max \{ \lambda_{\text{max}} (\mathbf{U}_i^{n},\mathbf{U}_j^{n}, \textbf{n}_{ij}), \lambda_{\text{max}} (\mathbf{U}_j^{n}, \mathbf{U}_i^{n}, - \textbf{n}_{ji}) \} \|\mathbf{c}_{ij}\|$ if $i \not = j$ - - $d_{ii} = - \sum_{j \in \mathcal{I}(i)\backslash \{i\}} d_{ij}$ - - $\textbf{n}_{ij} = \frac{\mathbf{c}_{ij}}{ \|\mathbf{c}_{ij}\| }$ + \textbf{n}_{ji}) \} \|\mathbf{c}_{ij}\|$ if $i \not = j$ is the so + called graph viscosity. The graph viscosity serves as a + stabilization parameter (similarly to the linear stabilization term + $s_h$ we introduced in the previous section for a variational + approach). We will base our construction of $d_{ij}$ on an estimate of + the maximal local wavespeed $\lambda_{\text{max}}$ that will be + explained in detail in a moment. + - In above definition we do not use the diagonal element $d_{ii}$ and it + can thus be set arbitrarily. It is convenient to simply set + $d_{ii} = - \sum_{j \in \mathcal{I}(i)\backslash \{i\}} d_{ij}$ + so that the sum over all elements of a row is zero, + $\sum_{j\in\mathcal{I}}d_{ij} = 0$. + - $\textbf{n}_{ij} = \frac{\mathbf{c}_{ij}}{ \|\mathbf{c}_{ij}\| }$ is a + normalization of the $\textbf{c}_{ij}$ matrix that enters the + approximate Riemann solver with which we compute an the approximations + $\lambda_{\text{max}}$ on the local wavespeed. (This will be explained + further down below). The definition of $\lambda_{\text{max}} (\mathbf{U},\mathbf{V}, \textbf{n})$ is far from trivial and we will postpone the precise @@ -293,7 +312,7 @@ $t_n$: &\ \ \ \ \{\textbf{U}_j^n\}_{j \in \mathcal{I}(i)} \leftarrow \texttt{gather_state_vectors} (\textbf{U}^n, \mathcal{I}(i)) \\ &\ \ \ \ \ \textbf{U}_i^{n+1} \leftarrow \mathbf{U}_i^{n} \\ -&\ \ \ \ \textbf{for } j \in \mathcal{I}(i) \\ +&\ \ \ \ \textbf{for } j \in \mathcal{I}(i)\backslash\{i\} \\ &\ \ \ \ \ \ \ \ \texttt{compute } d_{ij} \\ &\ \ \ \ \ \ \ \ \texttt{compute } \mathbb{f}(\mathbf{U}_j^{n}) \\ &\ \ \ \ \ \ \ \ \textbf{U}_i^{n+1} \leftarrow \textbf{U}_i^{n+1} - \frac{\tau_n}{m_i} diff --git a/examples/step-69/step-69.cc b/examples/step-69/step-69.cc index 7ad20ef232..8888d17e7d 100644 --- a/examples/step-69/step-69.cc +++ b/examples/step-69/step-69.cc @@ -91,7 +91,7 @@ // usually centers around either a single data structure (such as the // Triangulation) in the Discretization class, or a single // method (such as the make_one_step() function of the -// TimeStep class). We typically declare parameter variables +// TimeStepping class). We typically declare parameter variables // and scratch data object `private` and make methods and data structures // used by other classes `public`. // @@ -116,7 +116,7 @@ namespace Step69 // numerical value. constexpr types::boundary_id do_nothing = 0; - constexpr types::boundary_id slip = 1; + constexpr types::boundary_id free_slip = 1; constexpr types::boundary_id dirichlet = 2; // @sect4{The Discretization class} @@ -236,9 +236,9 @@ namespace Step69 // // The member functions of this class are utility functions and data // structures specific to Euler's equations: - // - The type alias rank1_type is used for the states + // - The type alias state_type is used for the states // $\mathbf{U}_i^n$ - // - The type alias rank2_type is used for the fluxes + // - The type alias flux_type is used for the fluxes // $\mathbb{f}(\mathbf{U}_j^n)$. // - The momentum function extracts $\textbf{m}$ // out of the state vector $[\rho,\textbf{m},E]$ and stores it in a @@ -277,29 +277,29 @@ namespace Step69 public: static constexpr unsigned int problem_dimension = 2 + dim; - using rank1_type = Tensor<1, problem_dimension>; - using rank2_type = Tensor<1, problem_dimension, Tensor<1, dim>>; + using state_type = Tensor<1, problem_dimension>; + using flux_type = Tensor<1, problem_dimension, Tensor<1, dim>>; const static std::array component_names; static constexpr double gamma = 7. / 5.; static DEAL_II_ALWAYS_INLINE inline Tensor<1, dim> - momentum(const rank1_type &U); + momentum(const state_type &U); static DEAL_II_ALWAYS_INLINE inline double - internal_energy(const rank1_type &U); + internal_energy(const state_type &U); - static DEAL_II_ALWAYS_INLINE inline double pressure(const rank1_type &U); + static DEAL_II_ALWAYS_INLINE inline double pressure(const state_type &U); static DEAL_II_ALWAYS_INLINE inline double - speed_of_sound(const rank1_type &U); + speed_of_sound(const state_type &U); - static DEAL_II_ALWAYS_INLINE inline rank2_type f(const rank1_type &U); + static DEAL_II_ALWAYS_INLINE inline flux_type f(const state_type &U); static DEAL_II_ALWAYS_INLINE inline double - compute_lambda_max(const rank1_type & U_i, - const rank1_type & U_j, + compute_lambda_max(const state_type & U_i, + const state_type & U_j, const Tensor<1, dim> &n_ij); }; @@ -328,11 +328,11 @@ namespace Step69 class InitialValues : public ParameterAcceptor { public: - using rank1_type = typename ProblemDescription::rank1_type; + using state_type = typename ProblemDescription::state_type; InitialValues(const std::string &subsection = "InitialValues"); - std::function &point, double t)> initial_state; + std::function &point, double t)> initial_state; private: // We declare a private callback function that will be wired up to the @@ -343,12 +343,12 @@ namespace Step69 Tensor<1, 3> initial_1d_state; }; - // @sect4{The TimeStep class} + // @sect4{The TimeStepping class} // // With the OfflineData and ProblemDescription // classes at hand we can now implement the explicit time-stepping scheme // that was introduced in the discussion above. The main method of the - // TimeStep class is make_one_step(vector_type &U, + // TimeStepping class is make_one_step(vector_type &U, // double t) that takes a reference to a state vector // U and a time point t (as input arguments) // computes the updated solution, stores it in the vector @@ -360,23 +360,23 @@ namespace Step69 // vector temp and the matrix dij_matrix // respectively. template - class TimeStep : public ParameterAcceptor + class TimeStepping : public ParameterAcceptor { public: static constexpr unsigned int problem_dimension = ProblemDescription::problem_dimension; - using rank1_type = typename ProblemDescription::rank1_type; - using rank2_type = typename ProblemDescription::rank2_type; + using state_type = typename ProblemDescription::state_type; + using flux_type = typename ProblemDescription::flux_type; using vector_type = std::array, problem_dimension>; - TimeStep(const MPI_Comm mpi_communicator, - TimerOutput & computing_timer, - const OfflineData & offline_data, - const InitialValues &initial_values, - const std::string & subsection = "TimeStep"); + TimeStepping(const MPI_Comm mpi_communicator, + TimerOutput & computing_timer, + const OfflineData & offline_data, + const InitialValues &initial_values, + const std::string & subsection = "TimeStepping"); void prepare(); @@ -417,7 +417,7 @@ namespace Step69 static constexpr unsigned int problem_dimension = ProblemDescription::problem_dimension; - using rank1_type = typename ProblemDescription::rank1_type; + using state_type = typename ProblemDescription::state_type; using vector_type = std::array, problem_dimension>; @@ -446,21 +446,21 @@ namespace Step69 double schlieren_beta; }; - // @sect4{The TimeLoop class} + // @sect4{The MainLoop class} // // Now, all that is left to do is to chain the methods implemented in the - // TimeStep, InitialValues, and + // TimeStepping, InitialValues, and // SchlierenPostprocessor classes together. We do this in a - // separate class TimeLoop that contains an object of every + // separate class MainLoop that contains an object of every // class and again reads in a number of parameters with the help of the // ParameterAcceptor class. template - class TimeLoop : public ParameterAcceptor + class MainLoop : public ParameterAcceptor { public: - using vector_type = typename TimeStep::vector_type; + using vector_type = typename TimeStepping::vector_type; - TimeLoop(const MPI_Comm mpi_communnicator); + MainLoop(const MPI_Comm mpi_communnicator); void run(); @@ -489,7 +489,7 @@ namespace Step69 Discretization discretization; OfflineData offline_data; InitialValues initial_values; - TimeStep time_step; + TimeStepping time_stepping; SchlierenPostprocessor schlieren_postprocessor; std::thread output_thread; @@ -608,7 +608,7 @@ namespace Step69 // $x=-$disc_diameter and has to be shifted to // $x=-$disc_position. As a last step the boundary has to // be colorized with do_nothing on the right, - // dirichlet on the left and slip on the + // dirichlet on the left and free_slip on the // upper and lower outer boundaries and the obstacle. for (const auto &cell : triangulation.active_cell_iterators()) @@ -636,7 +636,7 @@ namespace Step69 else if (center[0] < -disc_position + 1.e-6) face->set_boundary_id(dirichlet); else - face->set_boundary_id(slip); + face->set_boundary_id(free_slip); } } } @@ -782,7 +782,7 @@ namespace Step69 } } - // This concludes the setup of the DoFHandler and SparseMatrix objects + // This concludes the setup of the DoFHandler and SparseMatrix objects. // Next, we have to assemble various matrices. We next define a number of // helper functions and data structures in an anonymous namespace. @@ -1090,7 +1090,7 @@ namespace Step69 // proper normalization requires an additional loop on // nodes. Tensor<1, dim> normal; - if (id == slip) + if (id == free_slip) { for (unsigned int q = 0; q < n_face_q_points; ++q) normal += fe_face_values.normal_vector(q) * @@ -1294,9 +1294,9 @@ namespace Step69 // boundary conditions: essential-like boundary conditions (we prescribe a // state in the left portion of our domain), outflow boundary conditions // (also called "do-nothing" boundary conditions) in the right portion of - // the domain, and "reflecting" boundary conditions (also called "slip" - // boundary conditions). With these boundary conditions we should not expect - // any form of conservation to hold. + // the domain, and "reflecting" boundary conditions (also called "free + // slip" boundary conditions). With these boundary conditions we should + // not expect any form of conservation to hold. // // However, if we were to use reflecting boundary conditions // $\mathbf{m} \cdot \boldsymbol{\nu}_i =0$ in the entirety of the boundary @@ -1354,7 +1354,7 @@ namespace Step69 if (!face->at_boundary()) continue; - if (id != slip) + if (id != free_slip) continue; const auto &fe_face_values = scratch.reinit(cell, f); @@ -1435,7 +1435,7 @@ namespace Step69 template DEAL_II_ALWAYS_INLINE inline Tensor<1, dim> - ProblemDescription::momentum(const rank1_type &U) + ProblemDescription::momentum(const state_type &U) { Tensor<1, dim> result; std::copy(&U[1], &U[1 + dim], &result[0]); @@ -1444,7 +1444,7 @@ namespace Step69 template DEAL_II_ALWAYS_INLINE inline double - ProblemDescription::internal_energy(const rank1_type &U) + ProblemDescription::internal_energy(const state_type &U) { const double &rho = U[0]; const auto m = momentum(U); @@ -1454,14 +1454,14 @@ namespace Step69 template DEAL_II_ALWAYS_INLINE inline double - ProblemDescription::pressure(const rank1_type &U) + ProblemDescription::pressure(const state_type &U) { return (gamma - 1.) * internal_energy(U); } template DEAL_II_ALWAYS_INLINE inline double - ProblemDescription::speed_of_sound(const rank1_type &U) + ProblemDescription::speed_of_sound(const state_type &U) { const double &rho = U[0]; const double p = pressure(U); @@ -1470,15 +1470,15 @@ namespace Step69 } template - DEAL_II_ALWAYS_INLINE inline typename ProblemDescription::rank2_type - ProblemDescription::f(const rank1_type &U) + DEAL_II_ALWAYS_INLINE inline typename ProblemDescription::flux_type + ProblemDescription::f(const state_type &U) { const double &rho = U[0]; const auto m = momentum(U); const auto p = pressure(U); const double &E = U[dim + 1]; - rank2_type result; + flux_type result; result[0] = m; for (unsigned int i = 0; i < dim; ++i) @@ -1535,7 +1535,7 @@ namespace Step69 // direction the unit vector. template DEAL_II_ALWAYS_INLINE inline std::array riemann_data_from_state( - const typename ProblemDescription::rank1_type U, + const typename ProblemDescription::state_type U, const Tensor<1, dim> & n_ij) { Tensor<1, 3> projected_U; @@ -1692,8 +1692,8 @@ namespace Step69 template DEAL_II_ALWAYS_INLINE inline double - ProblemDescription::compute_lambda_max(const rank1_type & U_i, - const rank1_type & U_j, + ProblemDescription::compute_lambda_max(const state_type & U_i, + const state_type & U_j, const Tensor<1, dim> &n_ij) { const auto riemann_data_i = riemann_data_from_state(U_i, n_ij); @@ -1805,12 +1805,12 @@ namespace Step69 // initial_direction by value. const auto from_1d_state = - [=](const Tensor<1, 3, double> &state_1d) -> rank1_type { + [=](const Tensor<1, 3, double> &state_1d) -> state_type { const auto rho = state_1d[0]; const auto u = state_1d[1]; const auto p = state_1d[2]; - rank1_type state; + state_type state; state[0] = rho; for (unsigned int i = 0; i < dim; ++i) @@ -1833,15 +1833,16 @@ namespace Step69 // @sect4{The Forward Euler step} - // The constructor of the TimeStep class does not contain + // The constructor of the TimeStepping class does not contain // any surprising code: template - TimeStep::TimeStep(const MPI_Comm mpi_communicator, - TimerOutput & computing_timer, - const OfflineData & offline_data, - const InitialValues &initial_values, - const std::string & subsection /*= "TimeStep"*/) + TimeStepping::TimeStepping( + const MPI_Comm mpi_communicator, + TimerOutput & computing_timer, + const OfflineData & offline_data, + const InitialValues &initial_values, + const std::string & subsection /*= "TimeStepping"*/) : ParameterAcceptor(subsection) , mpi_communicator(mpi_communicator) , computing_timer(computing_timer) @@ -1860,10 +1861,10 @@ namespace Step69 // temporarily before its contents is swapped with the old vector. template - void TimeStep::prepare() + void TimeStepping::prepare() { TimerOutput::Scope time(computing_timer, - "time_step - prepare scratch space"); + "time_stepping - prepare scratch space"); const auto &partitioner = offline_data->partitioner; for (auto &it : temp) @@ -1878,7 +1879,7 @@ namespace Step69 // state U in place and return the chosen time-step size. template - double TimeStep::make_one_step(vector_type &U, double t) + double TimeStepping::make_one_step(vector_type &U, double t) { // Declare a number of read-only references to various different // variables and data structures. We do this is mainly to have shorter @@ -1937,7 +1938,8 @@ namespace Step69 // nij_matrix above are used here again. { - TimerOutput::Scope time(computing_timer, "time_step - 1 compute d_ij"); + TimerOutput::Scope time(computing_timer, + "time_stepping - 1 compute d_ij"); // We define again a "worker" function on_subranges that // computes the viscosity $d_{ij}$ for a subrange [i1, i2) of column @@ -2030,7 +2032,7 @@ namespace Step69 { TimerOutput::Scope time(computing_timer, - "time_step - 2 compute d_ii, and tau_max"); + "time_stepping - 2 compute d_ii, and tau_max"); const auto on_subranges = [&](auto i1, const auto i2) { // On subrange will be executed on every thread individually. The @@ -2114,7 +2116,8 @@ namespace Step69 // artifacts. { - TimerOutput::Scope time(computing_timer, "time_step - 3 perform update"); + TimerOutput::Scope time(computing_timer, + "time_stepping - 3 perform update"); const auto on_subranges = [&](auto i1, const auto i2) { for (const auto i : boost::make_iterator_range(i1, i2)) @@ -2174,7 +2177,7 @@ namespace Step69 { TimerOutput::Scope time(computing_timer, - "time_step - 4 fix boundary states"); + "time_stepping - 4 fix boundary states"); const auto on_subranges = [&](const auto it1, const auto it2) { for (auto it = it1; it != it2; ++it) @@ -2191,9 +2194,9 @@ namespace Step69 auto U_i = gather(temp, i); - // On slip boundaries we remove the normal component of the + // On free slip boundaries we remove the normal component of the // momentum: - if (id == slip) + if (id == free_slip) { auto m = ProblemDescription::momentum(U_i); m -= 1. * (m * normal) * normal; @@ -2326,7 +2329,7 @@ namespace Step69 // The second thing to note is that we have to compute global minimum and // maximums $\max_j |\nabla r_j|$ and $\min_j |\nabla r_j|$. Following the // same ideas used to compute the time step size in the class member - // TimeStep::step we define $\max_j |\nabla r_j|$ and + // TimeStepping::step we define $\max_j |\nabla r_j|$ and // $\min_j |\nabla r_j|$ as atomic doubles in order to // resolve any conflicts between threads. As usual, we use // Utilities::MPI::max and Utilities::MPI::min to @@ -2393,10 +2396,10 @@ namespace Step69 r_i += c_ij * U_js; } - // We fix up the gradient r_i at slip boundaries similarly to + // We fix up the gradient r_i at free slip boundaries similarly to // how we fixed up boundary states in the forward Euler step. // This avoids sharp, artificial gradients in the Schlieren - // plot at slip boundaries and is a purely cosmetic choice. + // plot at free slip boundaries and is a purely cosmetic choice. const auto bnm_it = boundary_normal_map.find(i); if (bnm_it != boundary_normal_map.end()) @@ -2404,7 +2407,7 @@ namespace Step69 const auto &normal = std::get<0>(bnm_it->second); const auto &id = std::get<1>(bnm_it->second); - if (id == slip) + if (id == free_slip) r_i -= 1. * (r_i * normal) * normal; else r_i = 0.; @@ -2480,19 +2483,19 @@ namespace Step69 // // With all classes implemented it is time to create an instance of // Discretization, OfflineData, - // InitialValues, TimeStep, and + // InitialValues, TimeStepping, and // SchlierenPostprocessor, and run the forward Euler // step in a loop. // - // In the constructor of TimeLoop we now initialize an + // In the constructor of MainLoop we now initialize an // instance of all classes, and declare a number of parameters // controlling output. Most notable, we declare a boolean parameter // resume that will control whether the program attempts to // restart from an interrupted computation, or not. template - TimeLoop::TimeLoop(const MPI_Comm mpi_communicator) - : ParameterAcceptor("A - TimeLoop") + MainLoop::MainLoop(const MPI_Comm mpi_communicator) + : ParameterAcceptor("A - MainLoop") , mpi_communicator(mpi_communicator) , computing_timer(mpi_communicator, timer_output, @@ -2505,11 +2508,11 @@ namespace Step69 discretization, "C - OfflineData") , initial_values("D - InitialValues") - , time_step(mpi_communicator, - computing_timer, - offline_data, - initial_values, - "E - TimeStep") + , time_stepping(mpi_communicator, + computing_timer, + offline_data, + initial_values, + "E - TimeStepping") , schlieren_postprocessor(mpi_communicator, computing_timer, offline_data, @@ -2564,11 +2567,11 @@ namespace Step69 } // namespace // With print_head in place it is now time to implement the - // TimeLoop::run() that contains the main loop of our + // MainLoop::run() that contains the main loop of our // program. template - void TimeLoop::run() + void MainLoop::run() { // We start by reading in parameters and initializing all objects. We // note here that the call to ParameterAcceptor::initialize reads in @@ -2605,7 +2608,7 @@ namespace Step69 // and set up scratch space: print_head(pcout, "set up time step"); - time_step.prepare(); + time_stepping.prepare(); schlieren_postprocessor.prepare(); // We will store the current time and state in the variable @@ -2679,10 +2682,10 @@ namespace Step69 // and then perform a single forward Euler step. Note that the // state vector U is updated in place and that - // time_step.make_one_step() returns the chosen step + // time_stepping.make_one_step() returns the chosen step // size. - t += time_step.make_one_step(U, t); + t += time_stepping.make_one_step(U, t); // Post processing, generating output and writing out the current // state is a CPU and IO intensive task that we cannot afford to do @@ -2710,13 +2713,13 @@ namespace Step69 // help of the InitialValues::initial_state object. template - typename TimeLoop::vector_type - TimeLoop::interpolate_initial_values(const double t) + typename MainLoop::vector_type + MainLoop::interpolate_initial_values(const double t) { - pcout << "TimeLoop::interpolate_initial_values(t = " << t << ")" + pcout << "MainLoop::interpolate_initial_values(t = " << t << ")" << std::endl; TimerOutput::Scope timer(computing_timer, - "time_loop - setup scratch space"); + "main_loop - setup scratch space"); vector_type U; @@ -2765,13 +2768,13 @@ namespace Step69 // run the postprocessing outside of the worker thread. template - void TimeLoop::output(const typename TimeLoop::vector_type &U, + void MainLoop::output(const typename MainLoop::vector_type &U, const std::string & name, const double t, const unsigned int cycle, const bool checkpoint) { - pcout << "TimeLoop::output(t = " << t + pcout << "MainLoop::output(t = " << t << ", checkpoint = " << checkpoint << ")" << std::endl; // We check if the output thread is still running. If so, we have to @@ -2782,7 +2785,7 @@ namespace Step69 if (output_thread.joinable()) { - TimerOutput::Scope timer(computing_timer, "time_loop - stalled output"); + TimerOutput::Scope timer(computing_timer, "main_loop - stalled output"); output_thread.join(); } @@ -2884,7 +2887,7 @@ int main(int argc, char *argv[]) Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv); MPI_Comm mpi_communicator(MPI_COMM_WORLD); - TimeLoop time_loop(mpi_communicator); + MainLoop main_loop(mpi_communicator); - time_loop.run(); + main_loop.run(); } -- 2.39.5