Layer.hpp

#ifndef __NGEN_LAYER__
#define __NGEN_LAYER__
 
#include <NGenConfig.h>
 
#include "LayerData.hpp"
#include "Simulation_Time.hpp"
#include "State_Exception.hpp"
#include "geojson/FeatureBuilder.hpp"
#include <boost/core/span.hpp>
#include <memory>
 
namespace hy_features
{
    class HY_Features;
    class HY_Features_MPI;
}
 
namespace utils { class CatchmentOutputsMgr; }
 
namespace ngen
{
 
    class Layer
    {    
        public:
 
        #if NGEN_WITH_MPI
            using feature_type = hy_features::HY_Features_MPI;
        #else
            using feature_type = hy_features::HY_Features;
        #endif
 
        Layer(
                const LayerDescription& desc, 
                const std::vector<std::string>& p_u, 
                const Simulation_Time& s_t, 
                feature_type& f,
                geojson::GeoJSON cd,
                long idx,
                std::shared_ptr<utils::CatchmentOutputsMgr> cat_output_mgr) :
            description(desc),
            processing_units(p_u),
            simulation_time(s_t),
            features(f),
            catchment_data(cd),
            output_time_index(idx),
            catchment_output_mgr(cat_output_mgr)
        {
 
        }
 
        Layer(
                const LayerDescription& desc,
                const Simulation_Time& s_t,
                feature_type& f,
                long idx,
                std::shared_ptr<utils::CatchmentOutputsMgr> cat_output_mgr) :
            description(desc),
            simulation_time(s_t),
            features(f),
            output_time_index(idx),
            catchment_output_mgr(cat_output_mgr)
        {
 
        }
 
        virtual ~Layer();   // out-of-line; see Layer.cpp
 
 
        time_t next_timestep_epoch_time() { return simulation_time.next_timestep_epoch_time(); }
 
 
 
        time_t current_timestep_epoch_time() { return simulation_time.get_current_epoch_time(); }
 
 
 
        int get_id() const { return this->description.id; }
 
 
        const std::string& get_name() const { return this->description.name; }
 
 
        const double get_time_step() const { return this->description.time_step; }
 
 
        const std::string& get_time_step_units() const { return this->description.time_step_units; }
 
 
        virtual void update_models(boost::span<double> catchment_outflows, 
                                   std::unordered_map<std::string, int> const& catchment_indexes,
                                   boost::span<double> nexus_downstream_flows,
                                   std::unordered_map<std::string, int> const& nexus_indexes,
                                   int current_step);
 
        protected:
 
        const LayerDescription description;
        //TODO is this really required at the top level?
        //See "minimum" constructor above used for DomainLayer impl...
        const std::vector<std::string> processing_units;
        Simulation_Time simulation_time;
        feature_type& features;
        //TODO is this really required at the top level? or can this be moved to SurfaceLayer?
        const geojson::GeoJSON catchment_data;
        long output_time_index;
        std::shared_ptr<utils::CatchmentOutputsMgr> catchment_output_mgr = nullptr;
 
    };
}
 
#endif