cmfcolumn-fluxes.h

 
#ifndef  INTEGRATABLES_H_
#define  INTEGRATABLES_H_
 
#define  CMFCOLUMN_DBKEY_MAXLEN  64
 
#include  "mbe_legacymodel.h"
 
#include  <memory>
#ifdef  CMFCOLUMN_HAVE_INTEGRATABLES
#  include  <map>
#  include  <vector>
#endif
 
struct  CMFConfig;
struct  CMFObjects;
namespace  cmf
{
    namespace  math
    {
        class  Integrator;
        class  integratable;
        class  Time;
    }
    namespace  upslope
    {
        class  Cell;
    }
    namespace  water
    {
        class  flux_connection;
                class  flux_node;
    }
}
 
 
struct  cmfcolumn_dbkeygen_t
{
    static char const *  solute_key(
        char * /*keybuffer*/, char const * /*key basename*/,
        char const *  /*solute*/);
};
 
enum  integratable_e
{
    ITG_rainthroughfall = 0,
    ITG_canopythroughfall,
    ITG_infiltration,
    ITG_exfiltration,
    ITG_canopyevaporation,
    ITG_surfacewaterevaporation,
    ITG_soilevaporation,
// sk:unused    ITG_snowmelt,
    ITG_snowthroughfall,
    ITG_snowevaporation,
    ITG_groundwaterdischarge,
    ITG_streamdischarge,
    ITG_rainsource,
    ITG_transpiration,
    ITG_evaporation,
    ITG_surfacewater,
    ITG_runoff,
    ITG_percolation,
    ITG_lateralflow,
    ITG_surfaceflow,
 
    ITG_count
};
extern char const * const  itg_names[ITG_count];
 
#define  noID  CMFIntegratables::IPos::NOID
struct  CMFIntegratables
{
    struct IPos
    {
        static const int  NOID = -1;
        IPos( int _id = NOID, size_t _layer = 0)
            : id( _id), layer( _layer) { }
 
        int  id;
        size_t  layer;
 
        bool operator<( IPos const &  _rhs)
            { return  this->id < _rhs.id; };
        bool operator<( IPos const &  _rhs) const
            { return  this->id < _rhs.id; };
    };
 
    double  query( integratable_e  _fx, IPos const &  _i) const
        { return  this->m_query( _fx, _i); }
    int  initialize( CMFConfig const &  _cfg,
                CMFObjects &  _cmf_objects)
        { return  this->m_initialize( _cfg, _cmf_objects); }
 
    private:
        struct  CMFIntegratableInfo
        {
            CMFIntegratableInfo() : I( NULL), n_queries( 0) { }
            cmf::math::integratable *  I;
            mutable int  n_queries;
        };
#ifdef  CMFCOLUMN_HAVE_INTEGRATABLES
        double  m_query( integratable_e, IPos const &) const;
        int  m_initialize( CMFConfig const &, CMFObjects &);
 
        typedef  std::vector< CMFIntegratableInfo >  CMFVerticalIntegratables;
        typedef  std::map< IPos, CMFVerticalIntegratables >  CMFHorizontalIntegratables;
        CMFHorizontalIntegratables  m_integratables[ITG_count];
 
        typedef  std::shared_ptr< cmf::water::flux_connection >  CMFFluxConnection;
        lerr_t  add_cmf_integratable( cmf::math::Integrator *  _solver,
            integratable_e, IPos, CMFFluxConnection);
        typedef  std::shared_ptr< cmf::water::flux_node >  CMFFluxNode;
        lerr_t  add_cmf_integratable( cmf::math::Integrator *  _solver,
            integratable_e, IPos, CMFFluxNode);
        lerr_t  add_cmf_integratable( cmf::math::Integrator *  _solver,
            integratable_e, IPos, CMFFluxNode, CMFFluxNode);
        typedef  std::shared_ptr< cmf::math::integratable >  CMFIntegratable;
        lerr_t  add_cmf_integratable( cmf::math::Integrator *  _solver,
            integratable_e, IPos, CMFIntegratable);
#else
        double  m_query( integratable_e, IPos const &) const
            { return 0.0; };
        int  m_initialize( CMFConfig const &, CMFObjects &)
            { return 0; }
#endif  /*  CMFCOLUMN_HAVE_INTEGRATABLES  */
};
 
class  CMFFluxes
{
    CMFIntegratables  m_itg;
    public:
        CMFFluxes( cbm::io_kcomm_t *  _io_kcomm = NULL)
            : io_kcomm( _io_kcomm)
        { }
    private:
        cbm::io_kcomm_t *  io_kcomm;
 
    public:
        typedef  char  keybuffer_t[CMFCOLUMN_DBKEY_MAXLEN];
        /* db */
        void  db_set( double /*value*/,
            char const * /*key*/, char const * = NULL /*solute*/);
        void  db_add( double /*value*/,
            char const * /*key*/, char const * = NULL /*solute*/);
        double  db_get( char const * /*key*/, char const * = NULL /*solute*/);
        double  db_getdel( char const * /*key*/, char const * = NULL /*solute*/);
 
        /* integratables */
        double  query( integratable_e  _fx) const
        {
            CMFIntegratables::IPos const  i;
            return  this->m_itg.query( _fx, i);
        }
        double  query( integratable_e  _fx, int _id /*cell id*/) const
        {
            CMFIntegratables::IPos const  i( _id);
            return  this->m_itg.query( _fx, i);
        }
        double  query( integratable_e  _fx,
            int _id /*cell id*/, size_t _layer /*layer*/) const
        {
            CMFIntegratables::IPos const  i( _id, _layer);
            return  this->m_itg.query( _fx, i);
        }
 
        int  initialize( CMFConfig const & _conf,
                    CMFObjects &  _cmf_objects)
        {
            return  this->m_itg.initialize(
                _conf, _cmf_objects);
        }
 
    private:
        std::map< uintptr_t, double >  watervolumes;
    public:
        void  set_watervolume( double, void * /*source*/);
        double  get_watervolume( void * /*source*/);
        void  get_watervolumes( double * /*buffer*/, size_t /*buffer size*/);
        size_t  watervolumes_count() const
            { return this->watervolumes.size(); }
};
 
#endif  /*  !INTEGRATABLES_H_  */