cmfcolumn-config.h

 
#ifndef  LM_CMFCOLUMN_CONFIG_H_
#define  LM_CMFCOLUMN_CONFIG_H_
 
#include  <string/cbm_string.h>
#include  <features/cmf-config.h>
 
//#define  CMFCOLUMN_HAVE_LATERAL
 
/* if set, flux_sl is set to 0 to suppress
 * solute transport by LDNDC even if we
 * have no CMF solutes. if CMF solutes are
 * given, flux_sl is 0 by definition.
 */
//#define  CMFCOLUMN_HAVE_FLUX
 
/* if set, use the concept of integratables
 * to get fluxes between nodes
 */
#define  CMFCOLUMN_HAVE_INTEGRATABLES
#ifdef  CMFCOLUMN_HAVE_INTEGRATABLES
#  include  "watercycle/cmfcolumn/cmfcolumn-fluxes.h"
#endif
 
/* select available solute transport mechanisms */
#define  CMFCOLUMN_HAVE_TRANSPORT_NONE
//#define  CMFCOLUMN_HAVE_TRANSPORT_WATERFLUX
#define  CMFCOLUMN_HAVE_TRANSPORT_COUPLED
 
/* if set, consider transport of solutes
 * on via surface flow (bulk)
 */
//#define  CMFCOLUMN_HAVE_SURFACETRANSPORT
 
/* if set, attempt to check balance for
 * solutes
 */
//#define  CMFCOLUMN_HAVE_SOLUTEBALANCES
 
/* if set, store lateral discharge of solutes
 * and water in scratch for output
 *
 * NOTE
 *      this destroys the stream discharge of
 *      the actual outlet connection
 */
//#define  CMFCOLUMN_HAVE_NEIGHBORSDISCHARGE
//#define  CMFCOLUMN_HAVE_NEIGHBORSDISCHARGE_FILTER
#ifdef  CMFCOLUMN_HAVE_NEIGHBORSDISCHARGE_FILTER
/* select a filter (hacky) */
#  define  CMFCOLUMN_HAVE_NEIGHBORSDISCHARGE_FILTER_GRID
#endif
 
#define  CMFCOLUMN_dailythroughfall  "a"
#define  CMFCOLUMN_dailyrainfall  "b"
#define  CMFCOLUMN_dailyinfiltration  "c"
#define  CMFCOLUMN_dailyexfiltration  "d"
#define  CMFCOLUMN_dailyevaporation  "e"
#define  CMFCOLUMN_dailytranspiration  "f"
#define  CMFCOLUMN_dailycanopyevaporation  "g"
#define  CMFCOLUMN_dailysurfacewaterevaporation  "h"
#define  CMFCOLUMN_dailysoilevaporation  "i"
#define  CMFCOLUMN_dailysurfacesnowevaporation  "j"
#define  CMFCOLUMN_dailystreamdischarge  "k"
#define  CMFCOLUMN_dailygroundwaterdischarge  "l"
#define  CMFCOLUMN_dailyrunoff  "m"
 
struct  CMFConfig
{
    CMFConfig() :
        solutes_names( ""), first_layer_connected( 0)
    {
        this->comp.models = cmf_config::models::UNKNOWN;
 
        this->flags.have_streamdischarge = 0;
        this->flags.have_groundwaterdischarge = 0;
        this->flags.have_outlets = 0;
        this->flags.have_snow = 0;
        this->flags.have_ice = 0;
        this->flags.have_infiltration = 0;
        this->flags.have_canopy = 0;
        this->flags.have_evapotranspiration = 0;
        this->flags.have_surfacewaterevaporation = 0;
        this->flags.have_soilevaporation = 0;
        this->flags.have_snowevaporation = 0;
        this->flags.have_surfacerunoff = 0;
        this->flags.have_rainthroughfall = 0;
        this->flags.have_canopythroughfall = 0;
        this->flags.have_lateral = 0;
 
#ifdef  CMFCOLUMN_HAVE_INTEGRATABLES
        this->flags.have_integratables = 1;
#else
        this->flags.have_integratables = 0;
#endif
        this->flags.bad = 0;
 
    }
    union cmf_model_configuration
    {
        struct
        {
            cmf_config::watertransport::model_e  watertransport;
            cmf_config::solutestransport::model_e  solutestransport;
            cmf_config::infiltration::model_e  infiltration;
            cmf_config::surfacerunoff::model_e  surfacerunoff;
            cmf_config::evapotranspiration::model_e  evapotranspiration;
        } model;
        unsigned int  models;
    } comp;
 
    cbm::string_t  solutes_names;
 
    size_t  first_layer_connected;
 
    struct  runoff_t
    {
        double  puddle_depth;
    } runoff;
    struct  streamdischarge_t
    {
        double  upper, lower;
        double  flowwidth;
        double  potential;
    } m_streamdischarge;
    struct  groundwaterdischarge_t
    {
        double  potential;
    } m_groundwaterdischarge;
    struct
    {
        bool  have_streamdischarge:1;
        bool  have_groundwaterdischarge:1;
        bool  have_outlets:1;
        bool  have_snow:1;
        bool  have_ice:1;
        bool  have_infiltration:1;
        bool  have_canopy:1;
        bool  have_evapotranspiration:1;
        bool  have_surfacewaterevaporation:1;
        bool  have_soilevaporation:1;
        bool  have_snowevaporation:1;
        bool  have_surfacerunoff:1;
        bool  have_rainthroughfall:1;
        bool  have_canopythroughfall:1;
        bool  have_lateral:1;
        bool  have_integratables:1;
 
        bool  bad:1;
    }  flags;
};
 
namespace  cmf
{
    class  project;
    namespace  atmosphere
    {
        class  ConstantRainSource;
    }
    namespace  math
    {
        class  Integrator;
    }
    namespace  upslope
    {
        class  Cell;
        namespace  ET
        {
            class  ShuttleworthWallace;
        }
    }
    namespace  water
    {
        class  flux_connection;
                class  flux_node;
        class  DirichletBoundary;
    }
}
 
#ifdef  CMFCOLUMN_HAVE_LATERAL
#  include  <kernel/kcomm.h>
#endif
 
struct  CMFObjects
{
    CMFObjects() :
        project( NULL), cell( NULL), rainsource( NULL),
        et( NULL), integrator( NULL),
        groundwater( NULL), stream( NULL), surfacerunoff( NULL)
    { }
 
    cmf::project *  project;
#ifdef  LDNDC_MPI
    std::shared_ptr< cmf::upslope::Cell >  cell;
#else
    cmf::upslope::Cell *  cell;
#endif
 
    std::shared_ptr< cmf::atmosphere::ConstantRainSource >  rainsource;
    std::shared_ptr< cmf::upslope::ET::ShuttleworthWallace >  et;
 
    cmf::math::Integrator *  integrator;
 
    std::shared_ptr< cmf::water::DirichletBoundary >  groundwater;
    std::shared_ptr< cmf::water::DirichletBoundary >  stream;
    std::shared_ptr< cmf::water::flux_connection >  surfacerunoff;
 
#ifdef  CMFCOLUMN_HAVE_LATERAL
    lcomponent_t  projectowner;
#endif
};
 
 
#endif  /* !LM_CMFCOLUMN_CONFIG_H_ */