cmfcolumn-solutes.h

 
#ifndef  WATERCYCLE_CMFCOLUMN_SOLUTES_H_
#define  WATERCYCLE_CMFCOLUMN_SOLUTES_H_
 
#include  "watercycle/cmfcolumn/cmfcolumn-config.h"
 
#include  <input/groundwater/groundwater.h>
#include  <comm/cbm_msg.h>
 
namespace  cmf { namespace  water {
    struct  solute;
}}
 
namespace  ldndc {
 
class WaterCycleCMFColumn;
struct CMFColumnSolute
    {
        cmf::water::solute const *  cmf_solute;
        double  retention;
        double *  leach;
        double *  throughfall;
 
        double *  soil;
        size_t  n_soil;
 
        double *  bulk;
        size_t  n_bulk;
 
        double const *  rain;
    };
 
struct LDNDC_API CMFColumnSolutesTransportBase
{
    virtual ~CMFColumnSolutesTransportBase() {}
    virtual char  model() const = 0;
    virtual int  link( WaterCycleCMFColumn *) = 0;
    virtual int  publish_solute_buffers(
        char const * /*solute name*/, cbm::reply_t *) { return 0; }
    virtual int  publish_fluxscale_buffer( cbm::reply_t *) { return 0; }
    virtual bool  need_integratables() const { return  false; }
    virtual void  biogeochem_to_hydro(
                int /*stage*/, cbm::reply_t *) = 0;
    virtual void  hydro_to_biogeochem(
                int /*stage*/, cbm::reply_t *) = 0;
 
    virtual void  set_groundwaternitrate(
        groundwater::input_class_groundwater_t const *)
        { /*no op*/ }
 
// sk:rm    WaterCycleCMFColumn *  obj;
 
    CMFConfig *  cfg;
    CMFObjects *  co;
    CMFFluxes *  fluxes;
 
    double  R; /*day fraction*/
};
 
struct LDNDC_API CMFColumnSolutesTransportNone
    : public CMFColumnSolutesTransportBase
{
    virtual ~CMFColumnSolutesTransportNone() {}
    char  model() const { return  'N'; }
 
    int  link( WaterCycleCMFColumn *) { return  0; }
    void  biogeochem_to_hydro(
                int /*stage*/, cbm::reply_t * _reply) { _reply->resend = 0; }
    void  hydro_to_biogeochem(
                int /*stage*/, cbm::reply_t * _reply) { _reply->resend = 0; }
};
 
struct LDNDC_API CMFColumnSolutesTransportCoupled
    : public CMFColumnSolutesTransportBase
{
    virtual ~CMFColumnSolutesTransportCoupled() {}
    char  model() const { return  'C'; }
 
    int  link( WaterCycleCMFColumn *);
    void  biogeochem_to_hydro( int /*stage*/, cbm::reply_t *);
    void  hydro_to_biogeochem( int /*stage*/, cbm::reply_t *);
 
    std::vector< CMFColumnSolute >  solutes;
 
    void  update_biogeochem();
    void  update_hydro();
 
    void  set_groundwaternitrate(
        groundwater::input_class_groundwater_t const *);
};
struct LDNDC_API CMFColumnSolutesTransportWaterflux
    : public CMFColumnSolutesTransportBase
{
    virtual ~CMFColumnSolutesTransportWaterflux() {}
    char  model() const { return  'W'; }
    struct neighbor_t
    {
#ifdef  LDNDC_MPI
        std::shared_ptr< cmf::upslope::Cell >  cell;
#else
        cmf::upslope::Cell const *  cell;
#endif
        std::vector< double const * >  solutes;
        double const *  flux_scale;
    };
 
    std::vector< neighbor_t >  neighbors;
    struct solute_t
    {
        std::string  name;
 
        double  retention;
        double *  leach;
 
        double *  s0, *  s1;
        size_t  n_sx;
#ifdef  CMFCOLUMN_HAVE_SURFACETRANSPORT
        double *  b0, *  b1;
        size_t  n_bx;
#endif
    };
    std::vector< solute_t >  solutes;
 
    double *  flux_scale;
 
    int  link( WaterCycleCMFColumn *);
    int  publish_solute_buffers(
        char const * /*solute name*/, cbm::reply_t *);
    int  publish_fluxscale_buffer( cbm::reply_t *);
    bool  need_integratables() const { return  true; }
    void  biogeochem_to_hydro( int /*stage*/, cbm::reply_t *);
    void  hydro_to_biogeochem( int /*stage*/, cbm::reply_t *);
 
    void  storewatervolumes();
    void  fluxcorrection();
    void  displace();
    void  update_biogeochem();
};
} /* namespace ldndc */
 
#endif /* !WATERCYCLE_CMFCOLUMN_SOLUTES_H_ */