cmfcolumn.h

 
#ifndef  LM_CMFCOLUMN_H_
#define  LM_CMFCOLUMN_H_
 
#include  "mbe_legacymodel.h"
#include  "state/mbe_state.h"
 
#include  "watercycle/cmfcolumn/cmfcolumn-config.h"
#include  "ld_eventqueue.h"
#ifdef  CMFCOLUMN_HAVE_LATERAL
#  include  <kernel/kcomm.h>
#endif
#include  <string/cbm_string.h>
#include  <comm/cbm_msg.h>
 
#include  <vector>
#include  <memory>
 
namespace ldndc { namespace event {
    class  EventFlood;
}}
 
namespace ldndc {
 
struct CMFColumnSolute;
struct CMFColumnSolutesTransportBase;
 
class  LDNDC_API  WaterCycleCMFColumn  :  public  MBE_LegacyModel
{
    LMOD_EXPORT_MODULE_INFO(WaterCycleCMFColumn,"watercycle:cmf","Watercycle CMF");
private:
    CMFConfig  cfg;
 
    int  configure_watertransport_model( char const *);
    int  configure_solutetransport_model( char const *);
    int  configure_infiltration_model( char const *);
    int  configure_surfacerunoff_model( char const *);
    int  configure_evapotranspiration_model( char const *);
 
public:
    WaterCycleCMFColumn( MoBiLE_State *,
                        cbm::io_kcomm_t *, timemode_e);
    ~WaterCycleCMFColumn();
 
    lerr_t  configure( ldndc::config_file_t const *);
    lerr_t  initialize();
    lerr_t  solve();
    lerr_t  finalize();
 
    lerr_t  register_ports( cbm::io_kcomm_t *);
    lerr_t  unregister_ports( cbm::io_kcomm_t *);
 
    lerr_t  sleep();
    lerr_t  wake();
 
 
private:
    cbm::io_kcomm_t *  io_kcomm;
#ifdef  CMFCOLUMN_HAVE_LATERAL
public:
    lerr_t  process_message( cbm::msg_t const *, cbm::reply_t *);
    int  register_cell();
private:
    cbm::kcomm_t  kcomm;
#endif
    input_class_climate_t const *  climate_in;
    input_class_event_t const *  event_in;
    input_class_groundwater_t const *  groundwater_in;
    input_class_setup_t const *  setup_in;
    input_class_site_t const *  site_in;
    input_class_siteparameters_t const *  siteparam_in;
    input_class_soillayers_t const *  soillayers_in;
 
    substate_airchemistry_t const *  airchem;
    substate_surfacebulk_t *  bulk;
    substate_microclimate_t const *  microclim;
    substate_physiology_t *  phys;
    substate_soilchemistry_t *  soilchem;
    substate_watercycle_t *  water;
 
    MoBiLE_PlantVegetation *  m_veg;
 
    EventQueue  m_HarvestEvents;
    CBM_Handle  m_HarvestHandle;
 
#ifdef  MoBiLE_WaterCycleSnowDNDC
    WaterCycleSnowDNDC  submodel_snowdndc;
#endif
 
    CMFObjects  co;
 
    // TODO  move to transport model
    //        CMFColumnSolute *  solutes;
    //        size_t  n_solutes;
 
    CMFColumnSolutesTransportBase *  m_solutetransport;
 
    CMFFluxes  cmf_fluxes;
    int  initialize_fluxobservers();
    bool  have_integratables() const
    { return  this->cfg.flags.have_integratables == 1; }
 
public:
    lerr_t  initialize_cmf();
    bool  configure_outlet_ownership(
                                     ldndc::config_file_t const *, lerr_t * /*status*/);
    bool  configure_streamdischarge(
                                    ldndc::config_file_t const *, lerr_t * /*status*/);
    bool  configure_groundwaterdischarge(
                                         ldndc::config_file_t const *, lerr_t * /*status*/);
    int  create_cmf_cell();
    int  set_cmf_neighborhood();
    int  create_cmf_discharge();
    int  create_cmf_streamdischarge();
    int  create_cmf_groundwaterdischarge();
    int  create_cmf_surfacerunoff();
    int  initialize_cmf_cell();
    int  construct_soil_layers( cmf::upslope::Cell * = NULL,
                               input_class_soillayers_t const * = NULL);
    int  construct_vertical_connections();
    int  construct_infiltration();
    int  construct_canopy_storage();
    int  construct_vegetation();
    int  construct_snow_storage_and_melt();
    int  construct_evapotranspiration();
    int  construct_rainsource();
    int  unset_tracer_filter();
 
 
    int  prepare_solutes( cmf_config::solutestransport::model_e);
    int  link_solutes();
    int  solute_entities(
                         CMFColumnSolute *,
                         char const * /*solute name*/);
    // sk:rm        int  link_solutes_for_model_coupled();
    // sk:rm        int  link_solutes_for_model_waterflux();
    // sk:rm        int  publish_solute_buffers(
    // sk:rm            char const * /*solute name*/, cbm::reply_t *);
    // sk:rm        int  publish_fluxscale_buffer( cbm::reply_t *);
 
    void  set_cmf_internal_state();
    void  set_cmf_internal_state( int /*stage*/, cbm::reply_t *);
    void  set_weather();
    void  set_icefraction();
    void  set_vegetation();
    void  set_watertable();
    void  set_groundwaternitrate();
 
    lerr_t  solve_single_timestep();
    void  refresh_evapotranspiration();
 
    void  get_cmf_internal_state();
    void  get_cmf_internal_state(
                                 int /*stage*/,
                                 cbm::reply_t *);
 
    void  WaterThroughfall();
    void  SurfaceWater();
    void  SoilWater();
    void  WaterFluxes();
    void  CanopyWater();
    void  EvapoTranspiration();
    void  Transpiration();
    void  CanopyEvaporation();
    // sk:unused        void  PotentialTranspiration();
    // sk:unused        void  PotentialEvaporation();
    void  SoilEvaporation();
    void  SurfacewaterEvaporation();
    void  SnowEvaporation();
 
    void  Discharge();
    double  StreamDischarge();
    double  GroundwaterDischarge();
    double  Runoff();
 
    // sk:off    void  SoluteLeaching();
    // sk:off    void  SoluteThroughfall();
 
    bool  Harvest();
 
    lerr_t  event_flood();
    lerr_t  do_event_flood( event::EventFlood const *);
    /* returns true in the case of current flood event, false otherwise */
    bool  have_flood_event();
    lerr_t  event_puddle();
    /* returns true in the case of current puddle event, false otherwise */
    bool  have_puddle_events();
 
#ifdef  CMFCOLUMN_HAVE_SOLUTEBALANCES
    lerr_t  get_solutebalances( double *);
    lerr_t  send_solutebalances(
                                char const * /*command*/, char const * /*variable key*/);
    lerr_t  send_solutebalances_in();
    lerr_t  send_solutebalances_out();
#endif
 
// sk:off    void  dump_storages();
};
} /* namespace ldndc */
 
#endif  /* !LM_CMFCOLUMN_H_ */