watercycle-dndc.h

 
#ifndef  LM_WATERCYCLE_DNDC_H_
#define  LM_WATERCYCLE_DNDC_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  LDNDC_API  WatercycleDNDC  :  public  MBE_LegacyModel
{
    LMOD_EXPORT_MODULE_INFO(WatercycleDNDC,"watercycle:watercycledndc","WatercycleDNDC");
 
public:
    static const unsigned int  IMAX_W;
 
public:
    WatercycleDNDC( MoBiLE_State *,
                    cbm::io_kcomm_t *,
                    timemode_e);
 
    ~WatercycleDNDC();
 
    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 *  m_iokcomm;
 
    input_class_groundwater_t const *  m_groundwater;
    input_class_climate_t const *  m_climate;
    input_class_setup_t const *  m_setup;
    input_class_siteparameters_t const *  m_sipar;
    input_class_soillayers_t const *  m_soillayers;
 
    MoBiLE_PlantVegetation *  m_veg;
 
    substate_soilchemistry_t &  sc_;
    substate_watercycle_t &  wc_;
    substate_microclimate_t &  mc_;
        substate_physiology_t & ph_;
    
    struct cfg_t
    {
        bool  snowpack:1;
        bool  icecontent:1;
        cbm::string_t potentialevapotranspiration_method;
        cbm::string_t evapotranspiration_method;
        double  automaticirrigation;    // automatically triggers irrigation in order to avoid drought stress
        bool ggcmi_irrigation;          //at the start of each day magically reset water level to field capacity (if below)
    };
    struct cfg_t  m_cfg;
 
    struct StateMicroclimate
    {
        /*in*/
        double  air_temperature_below_canopy;
        double  precipitation;
 
        /*in/out*/
        CBM_Vector<double>  soil_temperature_sl;
    };
    StateMicroclimate  m_mc;
 
    struct StateWatercycle
    {
        double  accumulated_irrigation_event_executed;
        double  irrigation;
 
        CBM_Vector<double>  percolation_sl;
    };
    StateWatercycle  m_wc;
 
private:
 
    lerr_t  receive_state();
    lerr_t  send_state();
 
    WaterCycleSnowDNDC  m_snowdndc;
    WaterCycleSnowDNDC::IceContentStateIn  m_icecontent_in;
    WaterCycleSnowDNDC::IceContentStateOut  m_icecontent_out;
 
    EventHandlerFlood  m_eventflood;
 
    SubscribedEvent<LD_EventHandlerQueue>  m_ManureEvents;
    SubscribedEvent<LD_EventHandlerQueue>  m_IrrigationEvents;
 
private:
 
    size_t nwc;                         // number of loops per time step
    double nhr;                         // number of hours per internal loop
 
    /* water fluxes */
    double  day_potevapo;                           // daily potential evapotranspiration from air demand [m]
    double  hr_pot_evapotrans;                      // hourly potential evapotranspiration (derived from daily potential evapotranspiration) [m]
    double  hr_throughfall;
    double  potentialtranspiration;                 // hourly potential transpiration (derived from differently calculated potential demand considering also plant conductance) [m]
    double  accumulated_potentialtranspiration_ts_old; // accumulated potential transpiration at the last time step [m]
    double  accumulated_potentialtranspiration_nd_old; // accumulated potential transpiration at the last day [m]
 
    double  max_percolation;                        // maximum water percolation rate during flooding event
 
    /* state variables */
    double  leaf_dryfraction;                       // fraction of leaves uncovered with water
    double  ground_water_table;                     // ground water table depth below the soil surface [m]
 
    CBM_Vector<double>  transpiration_ts;
    CBM_Vector<double>  pot_evapotranspiration_ts;

    double  thornthwaite_heat_index;
 
    /********************/
    /* member functions */
    /********************/

    lerr_t event_irrigate();

    lerr_t event_flood();

    double balance_check( double * /*old balance (in=NULL, out!=NULL)*/);

    void CalcRaining( unsigned int);
 
    double  rainfall_intensity();

    void CalcIrrigation( unsigned int);
 
    lerr_t  CalcSnowPack();
 
    lerr_t  CalcIceContent();

    lerr_t  CalcPotEvapoTranspiration( );

    void  CalcInterception();

    double get_leaf_water();

    double get_impedance_factor( size_t /* soil layer */);

    lerr_t CalcTranspiration();

    lerr_t CalcTranspirationCouvreur( double const &hr_potTransinm /* potential transpiration */);

    void CalcSnowEvaporation();

    void CalcSurfaceWaterEvaporation();
    
    void CalcSurfaceFlux();

    void WatercycleDNDC_preferential_flow();

    void CalcSoilEvapoPercolation();

    void SoilWaterEvaporation( size_t);

    double WaterFlowBelowFieldCapacity( size_t /* layer */,
                                        double const & /* impedance factor */);

    double WaterFlowCapillaryRise( size_t /* layer */,
                                   double const & /* impedance factor */);

    double WaterFlowAboveFieldCapacity( size_t /* layer */,
                                        double const & /* impedance factor */);

    double WaterFlowSaturated( size_t /* layer */,
                               double const & /* impedance factor */);

    double Soillayerwaterhead( size_t /* soil layer */);

    double get_fsl( size_t /* soil layer */);

    double get_time_step_duration();

    double
    get_clay_limitation( size_t _sl,
                         double _water_avail,
                         double _water_ref);
 
    size_t hours_per_time_step();
 
};
} /*namespace ldndc*/
 
#endif  /*  !LM_WATERCYCLE_DNDC_H_  */