check for fixed dt upon initialization; do other work for consistent dt only when needed

Author: mbkuhn

src/AMRWind.cpp

@@ -98,6 +98,11 @@ void AMRWind::set_timestep_size(const double dt)
     m_incflo.sim().time().delta_t() = dt;
 }
 
+bool AMRWind::is_fixed_timestep_size()
+{
+    return (!m_incflo.sim().time().adaptive_timestep());
+}
+
 void AMRWind::advance_timestep(size_t inonlin) { m_incflo.do_advance(inonlin); }
 
 void AMRWind::post_advance() { m_incflo.post_advance_work(); }

src/AMRWind.h

@@ -27,6 +27,7 @@ class AMRWind : public ExawindSolver
     ~AMRWind();
     bool is_unstructured() override { return false; }
     bool is_amr() override { return true; }
+    bool is_fixed_timestep_size() override;
     int overset_update_interval() override;
     int time_index() override;
     std::string identifier() override { return "AMR-Wind"; }

src/ExawindSolver.h

@@ -113,6 +113,7 @@ class ExawindSolver
 
     virtual bool is_unstructured() { return false; };
     virtual bool is_amr() { return false; };
+    virtual bool is_fixed_timestep_size() = 0;
     virtual int overset_update_interval() { return 100000000; };
     virtual int time_index() = 0;
     virtual std::string identifier() { return "ExawindSolver"; }

src/NaluWind.cpp

@@ -107,6 +107,11 @@ void NaluWind::set_timestep_size(const double dt)
     m_sim.timeIntegrator_->set_time_step(dt);
 }
 
+bool NaluWind::is_fixed_timestep_size()
+{
+    return m_sim.timeIntegrator_->get_is_fixed_time_step();
+}
+
 void NaluWind::advance_timestep(size_t /*inonlin*/)
 {
     for (auto* realm : m_sim.timeIntegrator_->realmVec_) {

src/NaluWind.h

@@ -50,6 +50,7 @@ class NaluWind : public ExawindSolver
     ~NaluWind();
     bool is_unstructured() override { return true; }
     bool is_amr() override { return false; }
+    bool is_fixed_timestep_size() override;
     int overset_update_interval() override;
     int time_index() override;
     std::string identifier() override

src/OversetSimulation.cpp

@@ -82,6 +82,13 @@ void OversetSimulation::initialize()
     }
     m_last_timestep = m_solvers.at(0)->time_index();
 
+    // Determine if any of the solvers have adaptive timestepping
+    for (auto& ss : m_solvers) {
+        m_fixed_dt = m_fixed_dt && ss->is_fixed_timestep_size();
+    }
+    MPI_Allreduce(MPI_IN_PLACE, &m_fixed_dt, 1, MPI_C_BOOL, MPI_LAND, m_comm);
+
+    // Should be able to remove this because of the Allreduce, right?
     MPI_Barrier(m_comm);
     m_initialized = true;
 }
@@ -153,12 +160,12 @@ void OversetSimulation::run_timesteps(
             double dt{1e8};
             for (auto& ss : m_solvers) {
                 ss->call_pre_advance_stage0(inonlin, increment_timer);
-                if (inonlin < 1) {
+                if (inonlin < 1 && !m_fixed_dt) {
                     dt = std::min(dt, ss->call_get_timestep_size());
                 }
             }
 
-            if (inonlin < 1) {
+            if (inonlin < 1 && !m_fixed_dt) {
                 MPI_Allreduce(
                     MPI_IN_PLACE, &dt, 1, MPI_DOUBLE, MPI_MIN, m_comm);
                 for (auto& ss : m_solvers) ss->call_set_timestep_size(dt);

src/OversetSimulation.h

@@ -30,6 +30,9 @@ class OversetSimulation
     int m_overset_update_interval{100000000};
     //! Last timestep run during this simulation
     int m_last_timestep{0};
+    //! Flag indicating whether all solvers use fixed dt. If any solver uses
+    //! adaptive dt, then this flag will be false
+    bool m_fixed_dt{true};
     //! Flag indicating whether initialization tasks have been performed
     bool m_initialized{false};
     //! Flag indicating if complementary comms have been initialized