echy.h

 
#ifndef  MOBILE_MODULE_ECHY_H_
#define  MOBILE_MODULE_ECHY_H_
 
#include  "mbe_legacymodel.h"
#include  "state/mbe_state.h"
#include  "ld_shared.h"
#include  "ld_eventqueue.h"
#include  "eventhandler/flood/flood.h"
#include  "watercycle/ld_icesnow.h"
 
namespace ldndc {
 
class  substate_microclimate_t;
class  substate_soilchemistry_t;
class  substate_watercycle_t;
 
class  LDNDC_API  EcHy  :  public  MBE_LegacyModel
{
    LMOD_EXPORT_MODULE_INFO(EcHy, "watercycle:echy", "EcHy");
 
public:
    EcHy( MoBiLE_State *,
           cbm::io_kcomm_t *, timemode_e);
    ~EcHy();
 
    lerr_t  configure( ldndc::config_file_t const *);
    lerr_t  register_ports( cbm::io_kcomm_t *);
    lerr_t  initialize();
 
    lerr_t  solve();
    lerr_t  unregister_ports( cbm::io_kcomm_t *);
    lerr_t  finalize();
 
    lerr_t  sleep();
    lerr_t  wake();
 
private:
 
    cbm::io_kcomm_t *  io_kcomm;
 
    input_class_groundwater_t const *  gw_;
    input_class_climate_t const *  m_climate;
    input_class_setup_t const *  m_setup;
    input_class_soillayers_t const *  soillayers_in;
    input_class_siteparameters_t const *  m_param;
 
    substate_soilchemistry_t const &  sc_;
    substate_microclimate_t &  mc_;
    substate_watercycle_t &  wc_;
    substate_physiology_t & ph_;
    MoBiLE_PlantVegetation *  m_veg;
 
    EventHandlerFlood  m_eventflood;
    WaterCycleSnowDNDC  m_snowdndc;
 
    SubscribedEvent<LD_EventHandlerQueue>  m_ManureEvents;
    SubscribedEvent<LD_EventHandlerQueue>  m_IrrigationEvents;
 
    double kst_bottom;
    double kst_bottom_gw_lateral;
    double kst_bottom_gw_vertical;
 
    double gw_depth_static;
 
    double accumulated_potentialtranspiration_old;
 
    double accumulated_irrigation_old;
 
    lvector< double > trwl_sl;
 
    lvector< double > wlfl_sl;
 
    lvector< double > cr_fill_sl;
 
    lvector< double > gw_fill_sl;
 
    lvector< double > bypass_fill_sl;
 
    double ev_surfacewater;
 
    lvector< double > evsws_sl;
 
    lvector< double > kst_sl;
    lvector< double > kst_eq_sl;
 
    lvector< double > wl_sl;
 
    lvector< double > wlfc_sl;
 
    lvector< double > wlwp_sl;
 
    double ev_leaf;
 
    double gw_fill_surface;
 
    double cr_fill_groundwater;
 
    double runoff;
 
    double throughfall_snow;
 
    double throughfall_water;
 
    double canopy_snowmelt;
    double surface_snowmelt;
 
    double canopy_water;
    double canopy_snow;
 
    double thornthwaite_heat_index;
 
    double daily_potential_evapotranspiration;
 
    double daily_potential_leaf_evaporation;
 
    double daily_potential_soil_evaporation;
 
    double daily_potential_transpiration;
 
    /* minimum height of surface watertable during flooding event (m) */
    double minimum_watertable_height;
 
    /* bund height during flooding event (m) */
    double bund_height;
 
    /* total amount of irrigation water applied including e.g., flooding (m) */
    double irrigation;
 
    /* irrigation by irrigation event (m) */
    double irrigation_event;
 
    enum irrigation_e
    {
        NONE,
        CONSTANT_POSITIVE_WATER_TABLE,
        CONSTANT_NEGATIVE_WATER_TABLE
    };
    irrigation_e irrigation_switch;
 
    /* Depth of ponded water at soil surface (mm) */
    double surface_water;
 
    /* Snow [m] */
    double surface_snow;
 
    WaterCycleSnowDNDC::IceContentStateIn  m_icecontent_in;
    WaterCycleSnowDNDC::IceContentStateOut  m_icecontent_out;
 
    cbm::string_t evapotranspiration_method;
 
    cbm::string_t runoff_method;
 
    bool have_capillary_rise;
 
private:
 
    lerr_t
    EcHyIrrigation();
 
    lerr_t
    EcHyFlood();
 
    lerr_t
    EcHyPercolation(
                    size_t /* integration step */,
                    size_t /* soil layer */);
 
    lerr_t
    EcHyBypassFlow(
                   double,
                   double &/* bypassing water */);
 
    lerr_t
    EcHyEvapotranspiration();
 
    lerr_t
    EcHyCapillaryRise(
               double const &,
               double const &,
               size_t const &,
               double const &,
               double &);
 
    lerr_t
    EcHyBalanceCheck(
                     double &);
 
    void
    EcHyreset();
 
    lerr_t
    EcHyGroundwater();
 
    lerr_t
    EcHyIntegration();
 
    lerr_t
    EcHyStepInit();
 
    lerr_t
    EcHyStepExit();
 
    double
    EcHyGetInterceptionCapacity();
 
    lerr_t
    EcHyCalculateLeafWaterDistribution(
                                       lvector_t< double > &/* leaf water */,
                                       lvector_t< double > &/* leaf snow */);
 
    lerr_t
    EcHyPotentialEvapotranspiration();
 
    lerr_t
    EcHySnowIce();
 
    double
    EcHyGetMinimumWater(
                        size_t /* soil layer */);
 
    double
    EcHyGetWiltingPoint(
                        size_t /* soil layer */);
 
    double
    EcHyGetAvailableWaterTranspiration(
                                       size_t /* soil layer */);
 
    double
    EcHyGetAvailableWaterEvaporation(
                                     size_t /* soil layer */);
 
    double
    EcHyGetDepthLimitation(
                           double _depth /* soil depth [m] */);
 
    double
    EcHyGetRootLimitation(
                          size_t _sl,
                          double /* dry weight fine roots [kg:m^-2] */);
 
    double
    EcHyGetWaterLimitationTranspiration(
                           double /* available water */,
                           size_t /* soil layer */);
 
    double
    EcHyGetWaterLimitationEvaporation(
                           double /* available water */,
                           size_t /* soil layer */);
 
    double
    EcHySoilWaterChange(
                    size_t /* soil layer */);
 
    lerr_t
    EcHy_check_for_negative_value(
                                  char const * /* position */);
 
    inline double
    pore_space( size_t _sl) const
    {
        return sc_.poro_sl[_sl] * sc_.h_sl[_sl];
    }
};
 
} /*namespace ldndc*/
 
#endif  /*  !MOBILE_MODULE_ECHY_H_  */