Post processing logic fix (#1683)

* unit tests to check output at end, use of delay. time_output_end currently fails

* modify enforce test to differentiate between time and step intervals

* fixing unit test

* adding unit test for aborts

* add information to documentation

* remove unused variable

Author: mbkuhn

amr-wind/utilities/PostProcessing.H

@@ -114,6 +114,12 @@ public:
                 "enforce_output_time_dt is true, but output_time_interval "
                 "has not been specified.");
         }
+
+        // Because of default, turn off step interval when time interval is
+        // meant to replace it
+        if (has_valid_time_int && !(has_interval || has_frequency)) {
+            m_out_interval = -1;
+        }
     }
 
     //! Determine if output will happen this time step

docs/sphinx/user/inputs_post_processing.rst

@@ -13,6 +13,11 @@ actual keyword is determined by the labels provided to
 ``incflo.post_processing = my_postproc``, then the options must be prefixed with
 ``my_postproc.``.
 
+For post-processing If plotfile output is active,
+   a plotfile will be written at the end of a simulation (when
+   :input_param:`time.stop_time` or :input_param:`time.max_step` is reached), regardless
+   of the output timing parameters.
+
 .. input_param:: postproc.type
 
    **type:** String, optional, default = Sampling
@@ -24,7 +29,10 @@ data via fields that are output to plotfiles; therefore, these types do
 not have specific outputs to files in the post_processing directory. However,
 for the rest of these routines, which do output data to post-processing files,
 there are general input arguments to designate when to write these files,
-and these arguments are described below.
+and these arguments are described below. Note that for these post-processing types,
+output will automatically occur at the end of a simulation (when
+:input_param:`time.stop_time` or :input_param:`time.max_step` is reached), regardless
+of the output timing parameters.
 
 .. input_param:: postproc.output_interval
 
@@ -33,7 +41,7 @@ and these arguments are described below.
    Specify the output interval (in time steps) when post-processing is performed
    and output to disk. This quantity can instead be specified as ``output_frequency``,
    which was the legacy input argument. Because ``output_interval`` is a more
-   accurate name, this is the preferred input argument.
+   accurate name, this is the preferred input argument. 
 
 .. input_param:: postproc.output_time_interval
 

docs/sphinx/user/inputs_time.rst

@@ -111,7 +111,10 @@ This section also addresses the time-dependent nature of checkpoint files, plot
    **type:** Integer, optional, default = -1
 
    If this value is greater than zero, it indicates the frequency (in timesteps)
-   at which outputs (plot files) are written to disk.
+   at which outputs (plot files) are written to disk. If plotfile output is active,
+   a plotfile will be written at the end of a simulation (when
+   :input_param:`time.stop_time` or :input_param:`time.max_step` is reached), regardless
+   of the output timing parameters.
 
 .. input_param:: time.plot_time_interval
 
@@ -147,7 +150,10 @@ This section also addresses the time-dependent nature of checkpoint files, plot
    **type:** Integer
 
    If this value is greater than zero, it indicates the frequency (in timesteps)
-   at which checkpoint (restart) files are written to disk.
+   at which checkpoint (restart) files are written to disk. If checkpoint output is active,
+   a checkpoint will be written at the end of a simulation (when
+   :input_param:`time.stop_time` or :input_param:`time.max_step` is reached), regardless
+   of the output timing parameters.
 
 .. input_param:: time.checkpoint_time_interval
 

unit_tests/utilities/test_post_processing_time.cpp

@@ -94,11 +94,11 @@ TEST_F(PostProcTimeTest, enforce_time_interval)
     {
         amrex::ParmParse pp("time");
         pp.add("stop_time", 1.0);
-        pp.add("max_step", 10);
+        pp.add("max_step", 20);
     }
     {
         amrex::ParmParse pp("fnorm");
-        pp.add("output_time_interval", 0.5);
+        pp.add("output_time_interval", 0.45);
         pp.add("enforce_output_time_dt", true);
     }
     initialize_mesh();
@@ -136,14 +136,167 @@ TEST_F(PostProcTimeTest, enforce_time_interval)
         out_time_sum += data_time;
     }
 
-    EXPECT_EQ(out_counter, 1 + 2);
-    EXPECT_NEAR(out_time_sum, 1.5, 1e-8);
-    EXPECT_EQ(out_step_sum, 2 + 6);
+    EXPECT_EQ(out_counter, 3);
+    EXPECT_NEAR(out_time_sum, 0. + 0.45 + 2. * 0.45, 1e-8);
+    EXPECT_EQ(out_step_sum, 2 + 9);
 
     // Remove file
     if (ifh.good()) {
         remove(fname.c_str());
     }
 }
 
+TEST_F(PostProcTimeTest, output_end)
+{
+    populate_parameters();
+    {
+        amrex::ParmParse pp("time");
+        pp.add("fixed_dt", 0.3);
+        pp.add("stop_time", 10.0);
+        pp.add("max_step", 21);
+    }
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_delay", 1000);
+    }
+    initialize_mesh();
+
+    auto& m_sim = sim();
+    amr_wind::PostProcessManager& post_manager = m_sim.post_manager();
+    auto& time = sim().time();
+    post_manager.pre_init_actions();
+    post_manager.post_init_actions();
+
+    int out_counter = 0;
+    amrex::Real out_time_sum = 0.0;
+    int out_step_sum = 0;
+    while (time.new_timestep()) {
+        time.set_current_cfl(0.45 / 0.3, 0.0, 0.0);
+        time.advance_time();
+        post_manager.post_advance_work();
+    }
+    post_manager.final_output();
+
+    // Read file output for time steps, times
+    std::string fname = "post_processing/fnorm00000.txt";
+    std::ifstream ifh(fname, std::ios::in);
+    if (!ifh.good()) {
+        amrex::Abort("Cannot find file: " + fname);
+    }
+    int data_tstep;
+    amrex::Real data_time;
+    ifh.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    while (ifh >> data_tstep) {
+        ifh >> data_time;
+        ++out_counter;
+        out_step_sum += data_tstep;
+        out_time_sum += data_time;
+    }
+
+    EXPECT_EQ(out_counter, 1);
+    EXPECT_NEAR(out_time_sum, 6.3, 1e-8);
+    EXPECT_EQ(out_step_sum, 21);
+
+    // Remove file
+    if (ifh.good()) {
+        remove(fname.c_str());
+    }
+}
+
+TEST_F(PostProcTimeTest, time_output_end)
+{
+    populate_parameters();
+    {
+        amrex::ParmParse pp("time");
+        pp.add("fixed_dt", 0.3);
+        pp.add("stop_time", 10.0);
+        pp.add("max_step", 21);
+    }
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_time_interval", 1.0);
+        pp.add("output_time_delay", 1000.0);
+    }
+    initialize_mesh();
+
+    auto& m_sim = sim();
+    amr_wind::PostProcessManager& post_manager = m_sim.post_manager();
+    auto& time = sim().time();
+    post_manager.pre_init_actions();
+    post_manager.post_init_actions();
+
+    int out_counter = 0;
+    amrex::Real out_time_sum = 0.0;
+    int out_step_sum = 0;
+    while (time.new_timestep()) {
+        time.set_current_cfl(0.45 / 0.3, 0.0, 0.0);
+        time.advance_time();
+        post_manager.post_advance_work();
+    }
+    post_manager.final_output();
+
+    // Read file output for time steps, times
+    std::string fname = "post_processing/fnorm00000.txt";
+    std::ifstream ifh(fname, std::ios::in);
+    if (!ifh.good()) {
+        amrex::Abort("Cannot find file: " + fname);
+    }
+    int data_tstep;
+    amrex::Real data_time;
+    ifh.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    while (ifh >> data_tstep) {
+        ifh >> data_time;
+        ++out_counter;
+        out_step_sum += data_tstep;
+        out_time_sum += data_time;
+    }
+
+    EXPECT_EQ(out_counter, 1);
+    EXPECT_NEAR(out_time_sum, 6.3, 1e-8);
+    EXPECT_EQ(out_step_sum, 21);
+
+    // Remove file
+    if (ifh.good()) {
+        remove(fname.c_str());
+    }
+}
+
+TEST_F(PostProcTimeTest, conflict_fails)
+{
+    populate_parameters();
+    initialize_mesh();
+
+    auto& m_sim = sim();
+    amr_wind::PostProcessManager& post_manager = m_sim.post_manager();
+    post_manager.pre_init_actions();
+    // Confirm no fail with default arguments
+    post_manager.post_init_actions();
+    // Confirm no fail with time interval
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_time_interval", 1.0);
+    }
+    post_manager.post_init_actions();
+    // Should fail when overspecified arguments
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_interval", 1);
+    }
+    EXPECT_THROW(post_manager.post_init_actions(), std::runtime_error);
+    // Should fail when both invalid
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_interval", -1);
+        pp.add("output_time_interval", -1.0);
+    }
+    EXPECT_THROW(post_manager.post_init_actions(), std::runtime_error);
+    // Should fail for combination of enforce and step interval
+    {
+        amrex::ParmParse pp("fnorm");
+        pp.add("output_interval", 1);
+        pp.add("enforce_output_time_dt", true);
+    }
+    EXPECT_THROW(post_manager.post_init_actions(), std::runtime_error);
+}
+
 } // namespace amr_wind_tests