Replace boost::shared_ptr with std::shared_ptr. Ensure the rotation logic updates the output datastructures on chkp resume

Author: Chrismarsh

docs/filterdev.rst

@@ -19,7 +19,7 @@ station.
 
 .. code:: cpp
 
-   void process(boost::shared_ptr<station> station);
+   void process(std::shared_ptr<station> station);
 
 init()
 ~~~~~~~~~~

docs/moduledev.rst

@@ -126,7 +126,7 @@ explicitly done by the module. The constructor specifies the paralle type: ``par
    ...
    }
 
-   void run(mesh domain, boost::shared_ptr<global> global_param)
+   void run(mesh domain, std::shared_ptr<global> global_param)
    {
     #pragma omp parallel for
        for (size_t i = 0; i < domain->size_faces(); i++)

src/core.cpp

@@ -245,7 +245,7 @@ void core::config_modules(pt::ptree &value, const pt::ptree &config, std::vector
             SPDLOG_DEBUG("No config for {}", module_name);
         }
 
-        boost::shared_ptr<module_base> module = module_factory::create(module_name, cfg);
+        std::shared_ptr<module_base> module = module_factory::create(module_name, cfg);
         //internal tracking of module initialization order
         module->IDnum = modnum;
 
@@ -504,6 +504,51 @@ void core::config_checkpoint( pt::ptree& value)
                     }
                 }
             }
+
+            if (_checkpoint_opts.load_from_checkpoint && !_checkpoint_opts.ugrid_outputs.empty())
+            {
+                // Outputs are configured before we load checkpoint metadata, so apply ugrid state here.
+                // Apply checkpoint ugrid rotation state now that outputs are configured.
+                for (auto &out : _outputs)
+                {
+                    if (out.mesh_output_formats != output_info::mesh_outputs::ugrid)
+                    {
+                        continue;
+                    }
+
+                    const chkptOp::ugrid_output_state* match = nullptr;
+                    for (const auto &state : _checkpoint_opts.ugrid_outputs)
+                    {
+                        if (state.base_name == out.base_name)
+                        {
+                            match = &state;
+                            break;
+                        }
+                    }
+                    if (!match && _checkpoint_opts.ugrid_outputs.size() == 1)
+                    {
+                        match = &_checkpoint_opts.ugrid_outputs.front();
+                    }
+                    if (!match)
+                    {
+                        // Warn if the checkpoint metadata doesn't match the configured ugrid outputs.
+                        SPDLOG_WARN("No checkpoint ugrid state matches base_name={}", out.base_name);
+                        continue;
+                    }
+
+                    if (!match->path.empty())
+                    {
+                        auto& writer = boost::get<boost::shared_ptr<ugrid_writer>>(out.writer);
+                        writer->set_store_path(match->path);
+                        SPDLOG_DEBUG("Resuming ugrid output from checkpoint file {}", match->path);
+                    }
+                    if (match->rotate_offset)
+                    {
+                        out.rotate_offset = match->rotate_offset;
+                        SPDLOG_DEBUG("Resuming ugrid rotation with offset {}", *match->rotate_offset);
+                    }
+                }
+            }
         }
 }
 void core::config_forcing(pt::ptree &value)
@@ -597,7 +642,7 @@ void core::config_forcing(pt::ptree &value)
     if(_use_netcdf)
     {
         std::string file = value.get<std::string>("file");
-        std::map<std::string, boost::shared_ptr<filter_base> > netcdf_filters;
+        std::map<std::string, std::shared_ptr<filter_base> > netcdf_filters;
         try
         {
             auto filter_section = value.get_child("filter");
@@ -607,7 +652,7 @@ void core::config_forcing(pt::ptree &value)
                 auto filter_name = jtr.first.data();
                 auto cfg  = jtr.second;
 
-                boost::shared_ptr<filter_base> filter = filter_factory::create(filter_name,cfg);
+                std::shared_ptr<filter_base> filter = filter_factory::create(filter_name,cfg);
                 filter->init();
                 netcdf_filters[filter_name] = filter;
             }
@@ -688,7 +733,7 @@ void core::config_forcing(pt::ptree &value)
                         auto filter_name = jtr.first.data();
                         auto cfg = jtr.second;
 
-                        boost::shared_ptr<filter_base> filter = filter_factory::create(filter_name,cfg);
+                        std::shared_ptr<filter_base> filter = filter_factory::create(filter_name,cfg);
                         filter->init();
 
                         //save this filter to run later
@@ -832,7 +877,7 @@ bool core::config_meshes( pt::ptree &value)
 {
     SPDLOG_DEBUG("Found meshes sections");
 
-    _mesh = boost::make_shared<triangulation>();
+    _mesh = std::make_shared<triangulation>();
 
     _mesh->_global = _global;
 
@@ -1192,7 +1237,7 @@ void core::config_output(pt::ptree &value)
                 boost::filesystem::create_directories(f.parent_path());
                 out.fname = f.string();
                 out.mesh_output_formats = output_info::mesh_outputs::vtu;
-                out.writer = boost::make_shared<vtk_writer>(_mesh);
+                out.writer = std::make_shared<vtk_writer>(_mesh);
             }
             else
             {
@@ -1216,15 +1261,15 @@ void core::config_output(pt::ptree &value)
                 out.mesh_output_formats = output_info::mesh_outputs::ugrid;
                 out.fname = ugrid_path.string();
 
-                out.writer = boost::make_shared<ugrid_writer>(
+                out.writer = std::make_shared<ugrid_writer>(
                     _mesh,
                     _global,
                     _mesh->write_param_to_output(),
                     out.fname,
                     use_zarr);
 
-                boost::get<boost::shared_ptr<ugrid_writer>>(out.writer)->compress = itr.second.get<bool>("compress", true);
-                boost::get<boost::shared_ptr<ugrid_writer>>(out.writer)->bitgroom = itr.second.get<bool>("bitgroom", true);
+                boost::get<std::shared_ptr<ugrid_writer>>(out.writer)->compress = itr.second.get<bool>("compress", true);
+                boost::get<std::shared_ptr<ugrid_writer>>(out.writer)->bitgroom = itr.second.get<bool>("bitgroom", true);
 
             }
 
@@ -1239,7 +1284,7 @@ void core::config_output(pt::ptree &value)
             out.write_ghost_neighbors = write_ghost;
             if (out.mesh_output_formats == output_info::mesh_outputs::vtu)
             {
-                boost::get<boost::shared_ptr<vtk_writer>>(out.writer)->set_write_ghost_neighbors(write_ghost);
+                boost::get<std::shared_ptr<vtk_writer>>(out.writer)->set_write_ghost_neighbors(write_ghost);
             }
 
             out.frequency = itr.second.get_optional<size_t>("frequency"); //defaults to every timestep
@@ -1284,37 +1329,6 @@ void core::config_output(pt::ptree &value)
                     ->set_chunking_override(chunk_len_steps, chunk_target_mb);
             }
 
-            if (_checkpoint_opts.load_from_checkpoint && out.mesh_output_formats == output_info::mesh_outputs::ugrid)
-            {
-                // Restore the output path and rotation offset captured in the checkpoint metadata.
-                const chkptOp::ugrid_output_state* match = nullptr;
-                for (const auto &state : _checkpoint_opts.ugrid_outputs)
-                {
-                    if (state.base_name == out.base_name)
-                    {
-                        match = &state;
-                        break;
-                    }
-                }
-                if (!match && _checkpoint_opts.ugrid_outputs.size() == 1)
-                {
-                    match = &_checkpoint_opts.ugrid_outputs.front();
-                }
-                if (match)
-                {
-                    if (!match->path.empty())
-                    {
-                        auto& writer = boost::get<boost::shared_ptr<ugrid_writer>>(out.writer);
-                        writer->set_store_path(match->path);
-                        SPDLOG_DEBUG("Resuming ugrid output from checkpoint file {}", match->path);
-                    }
-                    if (match->rotate_offset)
-                    {
-                        out.rotate_offset = match->rotate_offset;
-                    }
-                }
-            }
-
             auto specific_datetime = itr.second.get_optional<std::string>("specific_datetime");
             if(specific_datetime)
             {
@@ -1538,7 +1552,7 @@ void core::init(int argc, char **argv)
     SPDLOG_DEBUG("Logger initialized. Writing to cout and {}",  log_name);
 
 
-    _global = boost::make_shared<global>();
+    _global = std::make_shared<global>();
 
     // This needs to be set so that underflows in gsl math
     // computations are not treated as errors. i.e.,
@@ -2567,7 +2581,7 @@ void core::run()
                 pt::ptree entry;
                 entry.put("base_name", out.base_name);
 
-                auto& writer = boost::get<boost::shared_ptr<ugrid_writer>>(out.writer);
+                auto& writer = boost::get<std::shared_ptr<ugrid_writer>>(out.writer);
                 entry.put("path", writer->store_path());
 
                 if (out.rotate_frequency)
@@ -2625,7 +2639,7 @@ void core::run()
                     {
                         std::string base_name = itr.fname + std::to_string(_global->posix_time_int());
                         boost::filesystem::path p(base_name);
-                        auto& writer = boost::get<boost::shared_ptr<vtk_writer>>(itr.writer);
+                        auto& writer = boost::get<std::shared_ptr<vtk_writer>>(itr.writer);
                         writer->set_write_ghost_neighbors(itr.write_ghost_neighbors);
                         writer->update_data(output);
 
@@ -2656,7 +2670,7 @@ void core::run()
                         // first, check if we need a new ugrid file
                         bool new_ugrid = itr.should_rotate(max_ts, current_ts, _global->_current_date);
 
-                        auto& writer = boost::get<boost::shared_ptr<ugrid_writer>>(itr.writer);
+                        auto& writer = boost::get<std::shared_ptr<ugrid_writer>>(itr.writer);
                         if (new_ugrid)
                         {
                             auto rotated_path = [&]() {
@@ -2775,7 +2789,7 @@ void core::run()
 
         if (itr.mesh_output_formats == output_info::mesh_outputs::ugrid)
         {
-            boost::get<boost::shared_ptr<ugrid_writer>>(itr.writer)->close_ugrid();
+            boost::get<std::shared_ptr<ugrid_writer>>(itr.writer)->close_ugrid();
         }
     }
 

src/core.hpp

@@ -59,13 +59,13 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graphviz.hpp>
 #include <boost/graph/topological_sort.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
 #include <boost/program_options.hpp>
 #include <boost/property_tree/json_parser.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/regex.hpp>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/tokenizer.hpp>
 #include <boost/tuple/tuple.hpp>
 namespace pt = boost::property_tree;
@@ -298,7 +298,7 @@ class core
     std::vector< std::pair<module,size_t> > _modules;
     std::vector< std::vector < module> > _chunked_modules;
     std::vector< std::pair<std::string,std::string> > _overrides;
-    boost::shared_ptr<global> _global;
+    std::shared_ptr<global> _global;
 
     bool _use_netcdf; // flag if we are using netcdf. If we are, it enables incremental reads of the netcdf file for speed.
     std::shared_ptr<metdata> _metdata; //met data loader, shared for use with boost::bind

src/factory.hpp

@@ -27,15 +27,15 @@
 #include <vector>
 #include <functional>
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "exception.hpp"
 
 template <class Interface, class... ConstructorArgs>
 class factory {
 public:
   // Only ever hand out unique pointers
-  static boost::shared_ptr<Interface> create(std::string name, ConstructorArgs... args);
+  static std::shared_ptr<Interface> create(std::string name, ConstructorArgs... args);
   // Actual registration function
   static void register_factory_function(std::string name,
         std::function<Interface*(ConstructorArgs...)> implementation_constructor_function);
@@ -62,7 +62,7 @@ class registration_helper {
 };
 
 template <class Interface, class... ConstructorArgs>
-boost::shared_ptr<Interface> factory<Interface,ConstructorArgs...>::create(std::string name, ConstructorArgs... args)
+std::shared_ptr<Interface> factory<Interface,ConstructorArgs...>::create(std::string name, ConstructorArgs... args)
 {
   Interface * instance = nullptr;
 
@@ -75,7 +75,7 @@ boost::shared_ptr<Interface> factory<Interface,ConstructorArgs...>::create(std::
   if(instance == nullptr) {
     CHM_THROW_EXCEPTION(module_not_found, "Requested module not found in registry: [" + name +"]");
   }
-  return boost::shared_ptr<Interface>(instance);
+  return std::shared_ptr<Interface>(instance);
 }
 
 template <class Interface, class... ConstructorArgs>

src/filters/filter_base.hpp

@@ -23,7 +23,7 @@
 #pragma once
 
 #include <string>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/json_parser.hpp>
 

src/interpolation/interpolation.cpp

@@ -34,15 +34,15 @@ void interpolation::init(interp_alg ia, size_t size,std::map<std::string,std::st
 
     if (ia == interp_alg::tpspline)
     {
-        base = boost::make_shared<thin_plate_spline>(size,config);
+        base = std::make_shared<thin_plate_spline>(size,config);
     }
     else if(ia == interp_alg::idw)
     {
-        base = boost::make_shared<inv_dist>();
+        base = std::make_shared<inv_dist>();
     }
     else if(ia == interp_alg::nearest_sta)
     {
-        base = boost::make_shared<nearest>();
+        base = std::make_shared<nearest>();
     }
     else
     {

src/interpolation/interpolation.hpp

@@ -29,8 +29,8 @@
 
 #include <vector>
 #include <boost/tuple/tuple.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
+#include <memory>
+
 
 #include "logger.hpp"
 enum interp_alg
@@ -56,7 +56,7 @@ class interpolation
     void init(interp_alg ia, size_t size=0, std::map<std::string,std::string> config = std::map<std::string,std::string>());
 
     double operator()(std::vector< boost::tuple<double,double,double> >& sample_points, boost::tuple<double,double,double>& query_point);
-    boost::shared_ptr<interp_base> base;
+    std::shared_ptr<interp_base> base;
 private:
 
     size_t size;

src/mesh/triangulation.cpp

@@ -1067,7 +1067,7 @@ void triangulation::_build_dDtree()
     }
 
     //make the search tree
-    dD_tree = boost::make_shared<Tree>(boost::make_zip_iterator(boost::make_tuple( center_points.begin(),_faces.begin() )),
+    dD_tree = std::make_shared<Tree>(boost::make_zip_iterator(boost::make_tuple( center_points.begin(),_faces.begin() )),
                                        boost::make_zip_iterator(boost::make_tuple( center_points.end(),  _faces.end() ) )
     );
 }
@@ -2491,9 +2491,9 @@ double triangulation::min_z()
     return _min_z;
 }
 
-boost::shared_ptr<segmented_AABB> triangulation::AABB(size_t rows, size_t cols)
+std::shared_ptr<segmented_AABB> triangulation::AABB(size_t rows, size_t cols)
 {
-boost::shared_ptr<segmented_AABB> AABB = boost::make_shared<segmented_AABB>();
+std::shared_ptr<segmented_AABB> AABB = std::make_shared<segmented_AABB>();
 AABB->make(this,rows,cols);
 return AABB;