updates air chemistry subday and day buffers More...

Classes
class	EcHy
	Watercycle model EcosystemHydrology - EcHy. More...

struct	mobile_module_info_t
	structure representing module information from MoBiLE's setup module list block More...

class	mobile_modules_info_t
	structure manages module list information More...

class	MoBiLE_Substate
	abstract) base class for all simulation system state compartments More...

struct	module_option_register_t
	supported options shall be registered before referencing them More...

class	PhysiologyPlaMox
	Plamox. More...

class	PhysiologyVOCBIM
	This gas exchange module calculates emission of biogenetic volatile organic compounds. More...

class	SoilChemistryMeTrX
	Biogeochemical model MeTrx. More...

class	WatercycleDNDC
	Watercycle model WatercycleDNDC. More...

Typedefs
typedef speciesparameters::speciesparameters_set_t	MoBiLE_PlantParameters

Enumerations
enum	lmodule_flag_e { LMOD_FLAG_NONE = 0u, LMOD_FLAG_CONTROL = 1u << 0, LMOD_FLAG_USER = 1u << 1, LMOD_FLAG_SYSTEM = 1u << 2, LMOD_FLAG_INITIALIZER = 1u << 3, LMOD_FLAG_FINALIZER = 1u << 4, LMOD_FLAG_MAINTENANCE = 1u << 5, LMOD_FLAG_OUTPUT = 1u << 6, LMOD_FLAG_TEST_MODULE = 1u << 7 }

enum	{ LSUB_FLAG_NONE = 0u }

enum
	Lower bounds for number of foliage layers.

enum	stomatalconductance_method_e
	Stomatal conductance methods.

enum	{ CPOOL_VL, CPOOL_L, CPOOL_R, CPOOL_B }
	Order of carbon pools in array passed to allocate_litter. More...

Functions
lerr_t	assign_soillayer_porosity (double &_porosity_without_stones, int const &_nd_stratum, double const &_depth, double const &_c_org_without_stones, double const &_bulk_density_without_stones, const ldndc::site::input_class_site_t _site, const ldndc::soillayers::input_class_soillayers_t _soillayers, const ldndc::soilparameters::input_class_soilparameters_t *_soilparameters, bool _info=false)

lerr_t	assign_soillayer_field_capacity_and_wilting_point (double &_wcmax_without_stones, double &_wcmin_without_stones, double _wfps_max, double _wfps_min, double _porosity_without_stones, int const &_nd_stratum, double const &_depth, const ldndc::site::input_class_site_t _site, const ldndc::soillayers::input_class_soillayers_t _soillayers, const ldndc::soilparameters::input_class_soilparameters_t *_soilparameters, bool _vg_prio=false, bool _info=false)

double	resistance_aero_abovecanopy (double const &, double const &)
	returns boundary layer resistance above canopy

double	resistance_aero_incanopy (double const &, double const &, double const &)
	returns boundary layer resistance within canopy

double	crown_shape_parameter (double _length, double lref, double ps)
	Returns a crown shape parameter which is modified by canopy length. More...

void	canopy_biomass_distribution (size_t const _fl_cnt_max, size_t const _fl_cnt, double const _ps, double const _h_bottom, double const _h_top, double const _h_fl, double _fFol_fl)
	Foliage biomass distribution vertically across canopy. More...

void	canopy_lai_distribution (double _sla_min, double _sla_max, double _height_max, double _height_min, double _mFol, double const _fFol_fl, double const _h_fl, double _lai_fl, double _sla_fl, size_t _foliage_layer_cnt, size_t _foliage_layer_cnt_max)
	Leaf area distribution vertically across the whole canopy. More...

void	estimate_single_layer_biomass (double const _ps, double const _h_bottom, double const _h_top, double _lw, double &_fract, double _h_cum_bottom, double _h_cum_top)
	Vertical biomass estimation. More...

void	fineroots_biomass_distribution (size_t _sl_cnt_litter, size_t _sl_cnt_soil, double _ps, double _rooting_depth, double _f_frt_sl, double const _h_sl)

double	get_optimum_sap_wood_biomass (MoBiLE_Plant *_p)

double	get_sapwood_foliage_ratio (MoBiLE_Plant *_p)

double	sapwood_foliage_area_ratio (double _height, double _qsf_p1, double _qsf_p2)

double	stomatal_conductance_ballberry_1987 (double, double, double, double)
	Stomatal conductance according to Berry, Woodward and Ball 1987.

double	stomatal_conductance_leuning_1990 (double, double, double, double, double)
	Stomatal conductance according to Leuning 1990.

double	stomatal_conductance_leuning_1995_a (double, double, double, double, double, double, double)
	Stomatal conductance according to Leuning 1995.

double	stomatal_conductance_eller_2020 (double, double, double, double, double, double, double, double, double, double, double)
	Stomatal conductance according to Eller et al. 2020.

double	potential_wood_transpiration (soillayers::input_class_soillayers_t const &, double _vpd, double _carbon_uptake, double _f_area, double _wuecmax, double _wuecmin, lvector_t< double > _h_sl, lvector_t< double > _wc, lvector_t< double > _wc_min, lvector_t< double > _wc_max)
	Returns potential transpiration in [m] for trees.

double	potential_crop_transpiration (double _co2, double _carbon_uptake, double _wuecmax)
	Returns potential transpiration in [m] for crops and grass.

double	potential_transpiration (size_t, double gsmin, double gsmax, double _lai_fl, lvector_t< double > _vpd_fl, double _relative_conductance_fl)
	Returns potential transpiration in [m] for any species type.

lerr_t	get_voc_emission_factors (ldndc::MoBiLE_Plant *, int, bool, double, int, double, double)

lerr_t LDNDC_API	allocate_litter (double _c, double _n, double _RCNRVL, double _RCNRL, double _RCNRR, double _C[], double &_n_diff)
	calculates the amount of C which is added to the very labile, labile and recalcitrant decomposition pool More...

double LDNDC_API	cation_exchange_capacity (double _clay, double _sand, double _som, double _ph, ecosystem_type_e _ecosystem)
	Detailed description provided here . More...

double	d_eff_air_a (double const &, double const &)
	Returns effective diffusion coefficient depending on gas content. More...

double	d_eff_air_b (double const &, double const &, double const &, double const &)
	Returns effective diffusion coefficient depending on gas content and porosity. More...

double	d_eff_air_millington_and_quirk_1961 (double const &, double const &)
	Returns effective diffusion coefficient after [55]. More...

lerr_t	update_litter_height (soillayers::input_class_soillayers_t const &, substate_watercycle_t &, substate_soilchemistry_t &)
	Detailed description provided here . More...

bool	forest_floor (size_t, soillayers::input_class_soillayers_t const &, const ldndc::site::input_class_site_t &)
	First floor defined by: More...

double LDNDC_API	sap_wood_fraction (double _lai_max, double _qsfa, double _height_min, double _height_max, double _depth)
	sap_wood_fraction The calculation of the fraction of sapwood in coarse roots is based on the idealized volume fraction and assumes that the stem in the crown as well as the coarse roots are shaped as cones, and that core wood reaches a third of the cone More...

lerr_t	wood_initialization (soillayers::input_class_soillayers_t const &, MoBiLE_Plant *, substate_soilchemistry_t &, ecosystem_type_e)
	Initialization of aboveground and belowground wood debris, derived from existing vegetation. More...

double	non_stomatal_water_limitation (double const &_var, double const &_var_ref, double const &_var_scale)
	Non stomatal water limitation. More...

double LDNDC_API	thornthwaite_heat_index (double, size_t, double, double)
	Thornthwaite heat index.

double LDNDC_API	thornthwaite (double, double, double)
	Potential evapotranspiration after [65].

Variables
LDNDC_API lflags_t const	TMODE_DEFAULTS = TMODE_SUBDAILY\|TMODE_PRE_DAILY\|TMODE_POST_DAILY\|TMODE_PRE_YEARLY\|TMODE_POST_YEARLY

LDNDC_API MoBiLE_ModuleFactoryEnvelope const	module_factories []
	a list of destructors (because i was to lazy to add a one line file for these base classes..) module factory array is defined here. More...

substate_factory_t< substate_airchemistry_t > const	substate_airchemistry_factory
	substate base class implementation, sources factories More...

Detailed Description

updates air chemistry subday and day buffers

data synthesizer base class

declare common types related to species

common types related to species (implementation)

declare species groups known to the simulation system

container class for one complete soil and humus parameters set

container class for site parameters

Declare common types related to site input.

declare common types related to setup input

common types related to setup input

declare common types related to remotesensing input

collection of various helper functions

class containing full set of van Genuchten parametrization

declare common types related to groundwater input

declare common types related to geometry input

common event related data types

(management) event factories

base class for (management) events

declare common types related to climate input

declare common types related to checkpoint input

declare common types related to air chemistry input

Dynamic farmer.

david kraus

kind of helper module to perform additional tasks after all user modules have been run

container for state variable belonging to water cycle processes

container for state variable belonging to soil processes

container for state variable belonging to micro climate processes. it also acts as a one-timestep buffer for climate data records.

convenience header pulling all substate headers

helper functions for checkpointing mobile substate

container for MoBiLE substates

kind of helper module to perform additional tasks before user modules are run.

updates climate subday and day buffers

Author: steffen klatt, edwin haas; steffen klatt, edwin haas

Note: Old simmaster methods: <fluxInitials> + <nd-[CL|AC]arr2scalar> + <ndGeneral> + <readEventHandlingFile>

Author: steffen klatt; steffen klatt (created on: oct 27, 2012), edwin haas; steffen klatt edwin haas; Steffen Klatt, Edwin Haas, David Kraus; David Kraus; steffen klatt (created on: mar 05, 2013), edwin haas; steffen klatt (created on: aug 13, 2012), edwin haas; steffen klatt (created on: may 23, 2014), edwin haas; steffen klatt (created on: dec 16, 2012), edwin haas; steffen klatt (created on: dec 10, 2011)

Author: steffen klatt (created on: dec 10, 2011); Steffen Klatt (created on: dec 10, 2011), Edwin Haas; steffen klatt (created on: feb 03, 2014), edwin haas; Steffen Klatt (created on: may 29, 2015), David Kraus; steffen klatt (created on: may 29, 2015), david kraus; David Kraus (created on: february 28, 2017); david kraus, ruediger grote, steffen klatt, ...; Steffen Klatt on: may 29, 2015), David Kraus; steffen klatt (created on: sep 03, 2013), edwin haas

for now, also pulls in all kernel specific input declarations

Author

steffen klatt (created on: aug 11, 2012), edwin haas

Steffen Klatt (created on: jun 06, 2013)
David Kraus
Edwin Haas

steffen klatt (created on: jun 19, 2013), edwin haas

Ruediger Grote, David Kraus

Steffen Klatt (created on: jun 20, 2013) Edwin Haas David Kraus

Steffen Klatt (created on: mar 31, 2013) Edwin Haas David Kraus

steffen klatt (created on jun 19, 2013), edwin haas

steffen klatt (created on: jun 20, 2013), edwin haas

steffen klatt (created on: apr 04, 2013), edwin haas

steffen klatt (created on: jan 19, 2013)

Typedef Documentation

◆ MoBiLE_PlantParameters

typedef speciesparameters::speciesparameters_set_t ldndc::MoBiLE_PlantParameters

overview of plant properties ...

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
LSUB_FLAG_NONE	empty flag

 {
     LSUB_FLAG_NONE = 0u
 };

◆ anonymous enum

anonymous enum

Order of carbon pools in array passed to allocate_litter.

Enumerator
CPOOL_VL	very labile
CPOOL_L	labile
CPOOL_R	recalcitrant
CPOOL_B	wood

 {
     CPOOL_VL,
     CPOOL_L,
     CPOOL_R,
     CPOOL_B,
     
     CPOOL_CNT
 };

◆ lmodule_flag_e

enum ldndc::lmodule_flag_e

Enumerator
LMOD_FLAG_NONE	empty flag
LMOD_FLAG_CONTROL	marks model as control model
LMOD_FLAG_USER	marks model as user model
LMOD_FLAG_SYSTEM	marks model as internal system model
LMOD_FLAG_INITIALIZER	marks model as initializer (runs before user legacy models)
LMOD_FLAG_FINALIZER	marks model as finalizer (runs after user legacy models)
LMOD_FLAG_MAINTENANCE	marks model as maintenance model (e.g. updates, resets, etc)
LMOD_FLAG_OUTPUT	marks model as output model (always added last)
LMOD_FLAG_TEST_MODULE	marks model as test model

 {
     LMOD_FLAG_NONE = 0u,
 
     LMOD_FLAG_CONTROL = 1u << 0,
 
     LMOD_FLAG_USER = 1u << 1,
 
     LMOD_FLAG_SYSTEM = 1u << 2,
     LMOD_FLAG_INITIALIZER = 1u << 3,
     LMOD_FLAG_FINALIZER = 1u << 4,
     LMOD_FLAG_MAINTENANCE = 1u << 5,
 
     LMOD_FLAG_OUTPUT = 1u << 6,
 
     LMOD_FLAG_TEST_MODULE = 1u << 7,
 
     LMOD_FLAG_CNT_,
     LMOD_FLAG_CNT = 1 + 1 + cbm::log2_t< LMOD_FLAG_CNT_-1 >::LOG2
 };

Function Documentation

◆ allocate_litter()

lerr_t ldndc::allocate_litter	(	double	_c,
		double	_n,
		double	_RCNRVL,
		double	_RCNRL,
		double	_RCNRR,
		double	_C[],
		double &	_n_diff
	)

calculates the amount of C which is added to the very labile, labile and recalcitrant decomposition pool

The needed information in this function are the amount of carbon in litter _c and the corresponding CN ratio (determined from nitrogen _n).

four cases: If the CN ratio is lower than the CN ratio of the very labile litter pool, all litter-C goes to the very labile decomposition pool.

If the CN ratio is between RCNRVL and the harmonic mean of RCNRVL and RCNRR, an increasing CN ratio decreases C_0 and increases C_1 and C_2.

If thc CN ratio is between the harmonic mean of RCNRVL and RCNRR and RCNRR, C_1 and C_2 decrease and only C_0 increases.

If CN ratio is higher than RCNRR, all Litter-C goes to C_2.

Parameters

_c	Carbon in litter flux
_n	Nitrogen in litter flux
_C	Organic carbon that is added to the very labile, labile, recalcitrant decomposition pool (kgC ha-1)
_n_diff

Note: rr_vl_l harmonic mean of RCNRL and RCNRVL; used to calculate weights how addC is partitioned into C1,C2 and C3 rr_l_r harmonic mean of RCNRL and RCNRR

Author: david kraus (created on: may 6, 2014)

References CPOOL_B, CPOOL_L, CPOOL_R, and CPOOL_VL.

 {
     ldndc_assert( _n >= 0.0);
     
     if (cbm::flt_equal_zero(_n))
     {
         _C[CPOOL_VL] = 0.0;
         _C[CPOOL_L] = 0.0;
         _C[CPOOL_R] = 0.0;
         _C[CPOOL_B] = _c;
         _n_diff = 0.0;
     }
     else
     {
         ldndc_assert(( _RCNRVL > 0.0) && ( _RCNRL > 0.0) && ( _RCNRR > 0.0));
         double const  cn( _c / _n);
         
         if ( cn < _RCNRVL)
         {
             /* cn \in (0,rL) */
             _C[CPOOL_VL] = _c;
             _C[CPOOL_L] = 0.0;
             _C[CPOOL_R] = 0.0;
             _C[CPOOL_B] = 0.0;
             _n_diff = ( _n - _c/_RCNRVL);
         }
         else if (( cn >= _RCNRVL) && ( cn < _RCNRL))
         {
             /* cn \in [rL,r) */
             double  rr_l_r( 2.0 * _RCNRR * _RCNRL / ( _RCNRR + _RCNRL));
             double  addrr( _c * ( rr_l_r - cn) / ( rr_l_r - _RCNRVL) * ( _RCNRVL / cn));
             _C[CPOOL_VL] = ( 1.25 * addrr - _c * 0.25);
             _C[CPOOL_L] = ( _c - addrr);
             _C[CPOOL_R] = (( _c - addrr) * 0.25);
             _C[CPOOL_B] = 0.0;
             _n_diff = 0.0;
         }
         else if (( cn >= _RCNRL) && ( cn <= _RCNRR))
         {
             /* cn \in [r,rR] */
             double  rr_vl_l( 2.0 * _RCNRVL * _RCNRL / ( _RCNRVL + _RCNRL));
             double  addrr( _c * ( rr_vl_l - cn) / (rr_vl_l - _RCNRR) * ( _RCNRR / cn));
             _C[CPOOL_VL] = (( _c - addrr) * 0.25);
             _C[CPOOL_L] = ( _c - addrr);
             _C[CPOOL_R] = ( _c - ( _C[0] + _C[1]));
             _C[CPOOL_B] = 0.0;
             _n_diff = 0.0;
         }
         else
         {
             /* cn \in (rR,\inf) */
             _C[CPOOL_VL] = 0.0;
             _C[CPOOL_L] = 0.0;
             _C[CPOOL_R] = _n * _RCNRR;
             _C[CPOOL_B] = _c - _n * _RCNRR;
             _n_diff = 0.0;
         }    
     }
     
     return  LDNDC_ERR_OK;
 }

◆ assign_soillayer_field_capacity_and_wilting_point()

lerr_t ldndc::assign_soillayer_field_capacity_and_wilting_point	(	double &	_wcmax_without_stones,
		double &	_wcmin_without_stones,
		double	_wfps_max,
		double	_wfps_min,
		double	_porosity_without_stones,
		int const &	_nd_stratum,
		double const &	_depth,
		const ldndc::site::input_class_site_t *	_site,
		const ldndc::soillayers::input_class_soillayers_t *	_soillayers,
		const ldndc::soilparameters::input_class_soilparameters_t *	_soilparameters,
		bool	_vg_prio = `false`,
		bool	_info = `false`
	)

Wilting point is checked for consistency against field capacity, i.e., field capacity is not allowed to exceed 90% of estimated field capacity:

\( \theta_{min} = min(\theta_{min}, 0.9 \; \theta_{max}) \)

References assign_soillayer_porosity(), and forest_floor().

 {
     ldndc::site::iclass_site_stratum_t stratum;
     lerr_t  rc_stratum = _soillayers->stratum( _nd_stratum, &stratum);
     RETURN_IF_NOT_OK( rc_stratum);
     
     bool vg_parameter_from_input( true);
     double vg_a( 0.0);
     double vg_n( 0.0);
     double vg_m( 0.0);
     lerr_t rc_vg = assign_soillayer_van_genuchten_parameter( vg_a, vg_n, vg_m, vg_parameter_from_input,
                                                              _nd_stratum, _depth, _site, _soillayers, _soilparameters, false);
     if ( rc_vg)
     {
         LOGERROR( "Initialization of field capacity and wilting point of stratum ", _nd_stratum+1, " not successfull due to invalid van Genuchen parameters");
         return  LDNDC_ERR_FAIL;
     }
 
     double stone_fraction( 0.0);
     lerr_t rc_stone = assign_soillayer_stone_fraction( stone_fraction, _nd_stratum, _depth, _site, _soillayers, _soilparameters, false);
     if ( rc_stone)
     {
         LOGERROR( "Initialization of field capacity and wilting point of stratum ", _nd_stratum+1, " not successfull due to invalid stone content");
         return  LDNDC_ERR_FAIL;
     }
 
     double clay( 0.0);
     double sand( 0.0);
     double silt( 0.0);
     lerr_t rc_texture = assign_soillayer_soil_texture( clay, sand, silt, _nd_stratum, _depth, _site, _soillayers, _soilparameters, false);
     if ( rc_texture)
     {
         LOGERROR( "Initialization of field capacity and wilting point of stratum ", _nd_stratum+1, " not successfull due to invalid soil texture info");
         return  LDNDC_ERR_FAIL;
     }
 
     cbm::string_t texture_name( ldndc::get_soil_texture( sand * 100.0, clay * 100.0));
     ldndc::soillayers::soil_type_e texture_type( ldndc::get_soil_texture_type( texture_name));
 
     if( cbm::flt_greater_equal_zero( stratum.wcmax))
     {
         _wcmax_without_stones = stratum.wcmax * cbm::M_IN_MM;
     }
     else
     {
         if ( vg_parameter_from_input || _vg_prio)
         {
             //capillary pressure at field capacity (pF value of 1.8)
             double const cp_fc = 0.63; // [m]
             _wcmax_without_stones = ldndc::hydrology::water_content( cp_fc, vg_a, vg_n, vg_m,
                                                                      _wfps_max * _porosity_without_stones,
                                                                      _wfps_min * _porosity_without_stones);
             STRATUM_INFO( "Field capacity in stratum ", _nd_stratum+1," not initialized, estimated value (without stones): ",
                           _wcmax_without_stones  * (1.0 - stone_fraction), " [m3 m-3] (based on van Genuchten)");
         }
         else
         {
             if ( forest_floor( _depth, *_soillayers, *_site))
             {
                 _wcmax_without_stones = _soilparameters->HUMUS_WCMAX( _soillayers->humus_type()) * cbm::M_IN_MM;
             }
             else
             {
                 if ( ldndc::use_usda_soil_texture_triangle( _soillayers->soil_type()) &&
                      (texture_type != ldndc::soillayers::SOIL_NONE))
                 {
                     _wcmax_without_stones = _soilparameters->SOIL_WCMAX( texture_type) * cbm::M_IN_MM;
                 }
                 else
                 {
                     _wcmax_without_stones = _soilparameters->SOIL_WCMAX( _soillayers->soil_type()) * cbm::M_IN_MM;
                 }
             }
             STRATUM_INFO( "Field capacity in stratum ", _nd_stratum+1," not initialized, estimated value is (without stones): ",
                           _wcmax_without_stones, " [m3 m-3] (based on soil texture)");
         }
     }
     if( !cbm::flt_in_range_lu( 0.0, _wcmax_without_stones, 1.0))
     {
         LOGERROR( "Invalid value for field capacity in stratum ",_nd_stratum+1, ": ", _wcmax_without_stones," [m3 m-3]");
         return  LDNDC_ERR_FAIL;
     }
 
     double const wcmin_fraction( 0.9);
     if( cbm::flt_greater_equal_zero( stratum.wcmin))
     {
         _wcmin_without_stones = stratum.wcmin * cbm::M_IN_MM;
     }
     else
     {
         if ( vg_parameter_from_input || _vg_prio)
         {
             double const cp_wp = 150.0; // must be the same unit as 1/alpha -> m
             _wcmin_without_stones = ldndc::hydrology::water_content( cp_wp, vg_a, vg_n, vg_m,
                                                                      _wfps_max * _porosity_without_stones,
                                                                      _wfps_min * _porosity_without_stones);
             STRATUM_INFO( "Wilting point in stratum ", _nd_stratum+1," not initialized, estimated value (without stones): ",
                           _wcmin_without_stones  * (1.0 - stone_fraction), " [m3 m-3] (based on van Genuchten)");
         }
         else
         {
             if ( forest_floor( _depth, *_soillayers, *_site))
             {
                 _wcmin_without_stones = _soilparameters->HUMUS_WCMIN( _soillayers->humus_type()) * cbm::M_IN_MM;
             }
             else
             {
                 if ( ldndc::use_usda_soil_texture_triangle( _soillayers->soil_type()) &&
                      (texture_type != ldndc::soillayers::SOIL_NONE))
                 {
                     _wcmin_without_stones = _soilparameters->SOIL_WCMIN( texture_type) * cbm::M_IN_MM;
                 }
                 else
                 {
                     _wcmin_without_stones = _soilparameters->SOIL_WCMIN( _soillayers->soil_type()) * cbm::M_IN_MM;
                 }
             }
             STRATUM_INFO( "Wilting point in stratum ", _nd_stratum+1," not initialized, estimated value is (without stones): ",
                           _wcmin_without_stones, " [m3 m-3] (based on soil texture)");
         }
     }
     if( !cbm::flt_in_range_lu( 0.0, _wcmin_without_stones, 1.0))
     {
         LOGERROR( "Invalid value for wilting point in stratum ", _nd_stratum+1, ": ", _wcmin_without_stones," [m3 m-3]");
         return  LDNDC_ERR_FAIL;
     }
     else if ( cbm::flt_greater( _wcmin_without_stones, wcmin_fraction * _wcmax_without_stones))
     {
         _wcmin_without_stones = wcmin_fraction * _wcmax_without_stones;
         STRATUM_INFO( "Wilting point in stratum ", _nd_stratum+1," too close to field capacity. Wilting point changed to: ", _wcmin_without_stones, " [mm/m]");
     }
     return  LDNDC_ERR_OK;
 }

Here is the call graph for this function:

◆ assign_soillayer_porosity()

lerr_t ldndc::assign_soillayer_porosity	(	double &	_porosity_without_stones,
		int const &	_nd_stratum,
		double const &	_depth,
		double const &	_c_org_without_stones,
		double const &	_bulk_density_without_stones,
		const ldndc::site::input_class_site_t *	_site,
		const ldndc::soillayers::input_class_soillayers_t *	_soillayers,
		const ldndc::soilparameters::input_class_soilparameters_t *	_soilparameters,
		bool	_info = `false`
	)

Porosity is estimated based on organic carbon fraction and bulk density for the soil including stones. Porosity is given by a value between 0 and 1. See: porosity()

References forest_floor().

Referenced by assign_soillayer_field_capacity_and_wilting_point().

 {
     ldndc::site::iclass_site_stratum_t stratum;
     lerr_t  rc_stratum = _soillayers->stratum( _nd_stratum, &stratum);
     RETURN_IF_NOT_OK( rc_stratum);
     
     if( cbm::flt_greater_equal_zero( stratum.porosity))
     {
         _porosity_without_stones = stratum.porosity;
     }
     else
     {
         double clay( 0.0);
         double sand( 0.0);
         double silt( 0.0);
         lerr_t rc_texture = assign_soillayer_soil_texture( clay, sand, silt, _nd_stratum, _depth, _site, _soillayers, _soilparameters, false);
         if ( rc_texture)
         {
             LOGERROR( "Initialization of porosity of stratum ", _nd_stratum+1, " not successfull due to invalid soil texture info");
             return  LDNDC_ERR_FAIL;
         }
         
         //needed since clay+sand+silt may not add up to 1.0 for litter,peat or other organic soil
         double const clay_sand_silt( clay+sand+silt);
         double const min_dens( (clay * cbm::DCLA + sand * cbm::DSAN + silt * cbm::DSIL) / clay_sand_silt);
         _porosity_without_stones = ldndc::porosity( _c_org_without_stones, _bulk_density_without_stones, min_dens);
         
         STRATUM_INFO( "Porosity of stratum ",_nd_stratum+1," not initialized, estimated value (without stones): ", _porosity_without_stones*100.0," [%]");
     }
 
     if ( !cbm::flt_in_range_lu( 0.0, _porosity_without_stones, 1.0))
     {
         STRATUM_INFO( "Porosity of stratum ", _nd_stratum+1, " out of range: ", _porosity_without_stones," [m3 m-3]");
         return  LDNDC_ERR_FAIL;
     }
     else
     {
         return  LDNDC_ERR_OK;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ canopy_biomass_distribution()

void ldndc::canopy_biomass_distribution	(	size_t const	_fl_cnt_max,
		size_t const	_fl_cnt,
		double const	_ps,
		double const	_h_bottom,
		double const	_h_top,
		double const *	_h_fl,
		double *	_fFol_fl
	)

Foliage biomass distribution vertically across canopy.

Parameters

_fl_cnt_max	maximum number of foliage parameters
_fl_cnt	current actively used number of foliage parameters
_ps
_h_bottom
_h_top
_h_fl
_fFol_fl

Returns: no return value

References estimate_single_layer_biomass().

 {
     /* reset */
     for ( size_t fl = 0; fl < _fl_cnt_max; ++fl)
     {
         _fFol_fl[fl] = 0.0;
     }
 
     // total distribution length
     if ( cbm::flt_greater( _h_top, _h_bottom))
     {
         double h_cum_top( 0.0);
         for ( size_t fl = 0;  fl < _fl_cnt;  ++fl)
         {
             double const h_cum_bottom( h_cum_top);
             h_cum_top += _h_fl[fl];
 
             estimate_single_layer_biomass(
                                           _ps, _h_bottom, _h_top,
                                           _h_fl[fl], _fFol_fl[fl],
                                           h_cum_bottom, h_cum_top);
         }
 
         double const fFol_sum( cbm::sum( _fFol_fl, _fl_cnt));
         if ( cbm::flt_equal_zero( fFol_sum))
         {
             for ( size_t fl = 0; fl < _fl_cnt; ++fl)
             {
                 _fFol_fl[fl] = 1.0 / double( _fl_cnt);
             }
         }
         else
         {
             for ( size_t fl = 0; fl < _fl_cnt; ++fl)
             {
                 _fFol_fl[fl] /= fFol_sum;
             }
         }
     }
 }

Here is the call graph for this function:

◆ canopy_lai_distribution()

void ldndc::canopy_lai_distribution	(	double	_sla_min,
		double	_sla_max,
		double	_height_max,
		double	_height_min,
		double	_mFol,
		double const *	_fFol_fl,
		double const *	_h_fl,
		double *	_lai_fl,
		double *	_sla_fl,
		size_t	_foliage_layer_cnt,
		size_t	_foliage_layer_cnt_max
	)

Leaf area distribution vertically across the whole canopy.

Parameters

_sla_min	specific leaf area at canopy top
_sla_max	specific leaf area at canopy bottom
_height_max	total plant height
_height_min	plant height at start of canopy
_mFol	foliage biomass
_fFol_fl	foliage biomass distribution
_h_fl	canopy discretization
_lai_fl	canopy layer leaf area index
_sla_fl	canopy layer specific leaf are
_foliage_layer_cnt	number of canopy layers
_foliage_layer_cnt_max	maximum number of canopy layers

Returns: no return value

 {
     /* reset canopy */
     for ( size_t  fl = 0;  fl < _foliage_layer_cnt_max;  ++fl)
     {
         _sla_fl[fl] = 0.0;
         _lai_fl[fl] = 0.0;
     }
 
     double const crown_length( _height_max - _height_min);
     if ( cbm::flt_greater_zero( crown_length))
     {
         double const delta_sla( cbm::bound_min( 0.0, _sla_max - _sla_min));
 
         /* cumulative height of total plant */
         double h_cum_total_top( 0.0);
         double h_cum_crown_bottom( 0.0);
         for (size_t fl = 0; fl < _foliage_layer_cnt; ++fl)
         {
             h_cum_total_top += _h_fl[fl];
 
             /* sla and lai are greater zero only within canopy */
             if ( cbm::flt_greater( h_cum_total_top, _height_min))
             {
                 double const h_cum_crown_top( cbm::bound_max( h_cum_total_top - _height_min, crown_length));
                 double const h_cum_crown( 0.5 * (h_cum_crown_bottom + h_cum_crown_top));
 
                 _sla_fl[fl] = _sla_max - (delta_sla * h_cum_crown / crown_length);
                 _lai_fl[fl] = _sla_fl[fl] * _mFol * _fFol_fl[fl];
 
                 h_cum_crown_bottom = h_cum_crown_top;
             }
         }
     }
 }

◆ cation_exchange_capacity()

double LDNDC_API ldndc::cation_exchange_capacity	(	double	_clay,
		double	_sand,
		double	_som,
		double	_ph,
		ecosystem_type_e	_ecosystem
	)

Detailed description provided here .

Parameters

_clay	Clay content [%]
_sand	Sand content [%]
_som	Soil organic matter content [%]
_ph	pH value [-]
_ecosystem	Ecosystem type [-]

Returns: Cation exchange capacity [mol:g-1:1e-5]

Referenced by ldndc::SoilChemistryMeTrX::MeTrX_clay_nh4_equilibrium().

Here is the caller graph for this function:

◆ crown_shape_parameter()

double ldndc::crown_shape_parameter	(	double	_length,
		double	lref,
		double	ps
	)

Returns a crown shape parameter which is modified by canopy length.

modification of crown shape by canopy length

 {
     // crown/ root profile shape value shifts with crown length/ root profile depth
     double  ps2(ps);
     if (_length <= 1.0)
     {
         ps2 = 1.0;
     }
     else if (lref > 1.0)
     {
         ps2 = cbm::bound_max(1.0 + (ps - 1.0) * (_length - 1.0) / (lref - 1.0), ps);
     }
 
     return ps2;
 }

◆ d_eff_air_a()

double ldndc::d_eff_air_a	(	double const &	_exp,
		double const &	_gas_content
	)

Returns effective diffusion coefficient depending on gas content.

Parameters

[in]	_exp	Exponent [-]
[in]	_gas_content	Gas content [m^3:m^-3]

Returns: Effective diffusion coefficient [-]

Referenced by ldndc::SoilChemistryMeTrX::MeTrX_physics().

 {
     return std::pow( _gas_content, _exp);
 }

Here is the caller graph for this function:

◆ d_eff_air_b()

double ldndc::d_eff_air_b	(	double const &	_exp_g,
		double const &	_exp_p,
		double const &	_gas_content,
		double const &	_porosity
	)

Returns effective diffusion coefficient depending on gas content and porosity.

Parameters

[in]	_exp_g	Exponent for gas content [-]
[in]	_exp_p	Exponent for porosity [-]
[in]	_gas_content	Gas content [m^3:m^-3]
[in]	_porosity	Porosity [m^3:m^-3]

Returns: Effective diffusion coefficient [-]

 {
     return std::pow( _gas_content, _exp_g) / std::pow( _porosity, _exp_p);
 }

◆ d_eff_air_millington_and_quirk_1961()

double ldndc::d_eff_air_millington_and_quirk_1961	(	double const &	_gas_content,
		double const &	_porosity
	)

Returns effective diffusion coefficient after [55].

Parameters

[in]	_gas_content	Gas content [m^3:m^-3]
[in]	_porosity	Porosity [m^3:m^-3]

Returns: Effective diffusion coefficient [-]

Referenced by ldndc::SoilChemistryMeTrX::MeTrX_physics().

 {
     return std::pow( _gas_content, 10.0/3.0) / (_porosity * _porosity);
 }

Here is the caller graph for this function:

◆ estimate_single_layer_biomass()

void ldndc::estimate_single_layer_biomass	(	double const	_ps,
		double const	_h_bottom,
		double const	_h_top,
		double	_lw,
		double &	_fract,
		double	_h_cum_bottom,
		double	_h_cum_top
	)

Vertical biomass estimation.

Parameters

_ps	form parameter
_h_bottom	height of start of distributed biomass
_h_top	height of end of distributed biomass
_lw
_fract
_h_cum_bottom
_h_cum_top

Returns: No return value

The standard vertical distribution of biomass is done with the same assumptions for canopy (veglibs_canopy) and rooting space (Fine root distribution). Only for root distribution there are several more options available.

Referenced by canopy_biomass_distribution(), and fineroots_biomass_distribution().

 {
     // calculation proceeds as long as cumulative length is smaller than total crown length
     if ( cbm::flt_greater( _h_cum_top, _h_bottom) &&
          cbm::flt_less_equal( _h_cum_bottom, _h_top))
     {
         // distance from the crown start/ soil surface for which the relative biomass shall be estimated
         double  hAct( 0.0);
         double const length( _h_top - _h_bottom);
         
         // if total crown height is within the first canopy layer
         if ( cbm::flt_less( _h_top, _lw))
         {
             hAct = length;
         }
         // for the partially filled last canopy/ soil layer
         else if ( cbm::flt_less_equal( _h_top, _h_cum_top))
         {
             hAct = length - ( _h_top - _h_cum_bottom) * 0.5;
         }
         // for the partially filled first canopy/ soil layer
         else if ( cbm::flt_less( _h_cum_bottom, _h_bottom))
         {
             hAct = ( _h_cum_top - _h_bottom) * 0.5;
         }
         // for fully filled canopy/ soil layers
         else
         {
             hAct = ( _h_cum_bottom - _h_bottom) + (_h_cum_top - _h_cum_bottom) * 0.5;
         }
 
         double const relH( cbm::flt_less( length, _lw) ? 1.0 : ((length - hAct) / length));
 
         // relative biomass distribution throughout the canopy/ soil according to Grote 2007
         double  fH( pow( _ps, 100.0 * hAct / ( cbm::flt_greater( length, 5.0) ? (length * length) : 25.0)));
 
         _fract = relH * fH;
     }
     else
     {
         _fract = 0.0;
     }
 }

Here is the caller graph for this function:

◆ fineroots_biomass_distribution()

void ldndc::fineroots_biomass_distribution	(	size_t	_sl_cnt_litter,
		size_t	_sl_cnt_soil,
		double	_ps,
		double	_rooting_depth,
		double *	_f_frt_sl,
		double const *	_h_sl
	)

scaling factor for root distribution (basically to enable root and canopy profile calculations with the same function)

fraction of fine roots in the litter layer

fraction of fine roots in the mineral soil

References estimate_single_layer_biomass().

 {
     if (  cbm::flt_greater_zero( _rooting_depth))
     {
         double const SCALE( 10.0);
         
         double f_litter( 0.0);
         
         double litter_depth( 0.0);
         for ( size_t  sl = 0;  sl < _sl_cnt_litter;  ++sl)
         {
             litter_depth += _h_sl[sl];
         }
         
         /* if rooting depth <= litter depth neglect litter layer (new seedlings start in mineral layer)*/
         if ( cbm::flt_greater( litter_depth, _rooting_depth))
         {
             _sl_cnt_litter = 0;
             f_litter = 0.0;
         }
         /* else assume that fine roots are distributed according to litter height relative to soil profile*/
         else
         {
             f_litter = litter_depth / _rooting_depth;
         }
         
         for ( size_t  sl = 0;  sl < _sl_cnt_litter;  ++sl)
         {
             _f_frt_sl[sl] = f_litter / (double)_sl_cnt_litter;
         }
         
         double const f_soil( 1.0 - f_litter);
         
         double h_cum( 0.0);
         double f_frt_sum( 0.0);
         for ( size_t  sl = _sl_cnt_litter;  sl < _sl_cnt_soil;  ++sl)
         {
             double const  h_cum_old( h_cum);
             h_cum += _h_sl[sl] * SCALE;
             
             estimate_single_layer_biomass(
                                           _ps, 0.0, SCALE * _rooting_depth,
                                           SCALE * _h_sl[sl], _f_frt_sl[sl],
                                           h_cum_old, h_cum);
             f_frt_sum += _f_frt_sl[sl];
         }
         
         for ( size_t  sl = _sl_cnt_litter;  sl < _sl_cnt_soil;  ++sl)
         {
             _f_frt_sl[sl] = _f_frt_sl[sl] / f_frt_sum * f_soil;
         }
     }
     else
     {
         for ( size_t sl = 0; sl < _sl_cnt_soil;  ++sl)
         {
             _f_frt_sl[sl] = 0.0;
         }
     }
 }

Here is the call graph for this function:

◆ forest_floor()

bool ldndc::forest_floor	(	size_t	_sl,
		soillayers::input_class_soillayers_t const &	_soillayers,
		const ldndc::site::input_class_site_t &	_site
	)

First floor defined by:

litter height
ecosystem type

Referenced by assign_soillayer_field_capacity_and_wilting_point(), and assign_soillayer_porosity().

 {
     if ( _sl < _soillayers.soil_layers_in_litter_cnt())
     {
         if ( (_site.soil_use_history() == ECOSYS_FOREST) ||
              (_site.soil_use_history() == ECOSYS_FOREST_NATURAL))
         {
             return true;
         }
     }
 
     return false;
 }

Here is the caller graph for this function:

◆ get_optimum_sap_wood_biomass()

double ldndc::get_optimum_sap_wood_biomass ( MoBiLE_Plant * _p )

Parameters

_p Plant

Returns: Optimum sap wood biomass depending on foliage biomass.

Referenced by get_sapwood_foliage_ratio().

 {
     double const sapwood_area_demand( _p->lai_max  * _p->qsfa);
     double  optimum_sap_wood( (*_p)->DSAP() * cbm::DM3_IN_M3 * sapwood_area_demand
                              * ( _p->height_at_canopy_start
                                 + (_p->rooting_depth / 3.0)
                                 + (_p->height_max - _p->height_at_canopy_start) / 3.0));
 
     if ( (*_p)->IS_WOOD())
     {
         double const total_wood( _p->aboveground_wood() + _p->belowground_wood());
         return cbm::bound_max( optimum_sap_wood, total_wood);
     }
     else
     {
         return optimum_sap_wood;
     }
 }

Here is the caller graph for this function:

◆ get_sapwood_foliage_ratio()

double ldndc::get_sapwood_foliage_ratio ( MoBiLE_Plant * _p )

Parameters

_p Plant

Returns: sap wood to foliage ratio

References get_optimum_sap_wood_biomass().

 {
     double const biomass_limit( 0.001);
 
     if ( !(*_p)->FREEGROWTH() && (_p->nb_ageclasses() > 0) )
     {
         size_t na_max( _p->nb_ageclasses() - 1);
         if ( cbm::flt_greater( _p->mBud + _p->mFol - _p->mFol_na[na_max], biomass_limit))
         {
             double const m_sap_opt( get_optimum_sap_wood_biomass(_p));
             return m_sap_opt / ( _p->mBud + _p->mFol - _p->mFol_na[na_max]);
         }
     }
     else if ( cbm::flt_greater( _p->mFol + _p->mBud, biomass_limit))
     {
         double const m_sap_opt( get_optimum_sap_wood_biomass(_p));
         return m_sap_opt / ( _p->mFol + _p->mBud);
     }
 
     return 0.0;
 }

Here is the call graph for this function:

◆ get_voc_emission_factors()

lerr_t ldndc::get_voc_emission_factors	(	ldndc::MoBiLE_Plant *	_vt,
		int	_fl,
		bool	_calc_synthase_activity,
		double	_latitude,
		int	_yearday,
		double	_foliage_temperature,
		double	_foliage_radiation
	)

Daily calculation of voc (isoprene and monoterpenes) synthase activity NOTE that fCO2 depends on outside CO2, internal CO2 would probably be better (explaining relatively high emissions when stomata closed)

 {
 // if running subdaily calc activity on last subdaily time step    
    
     
 //     if ("beginning of simulation and first time that pointers are assigned")
 //         --> assign ef with sef
 //         --> assign ef with iso/monoAct
 //         
 //     else if ( "further within simulation ")
 //         --> assign ef with iso/monoAct
         
     
     
     if ( !_calc_synthase_activity)
     {
         ldndc_use_standard_emission_factors( _vt, _fl);
         return  LDNDC_ERR_OK;
     }
     
     else if (( _calc_synthase_activity) && (( ( *_vt)->ALPHA0_IS() + ( *_vt)->ALPHA0_MT()) > 0.0) && ( ( *_vt)->PA() > 0.0))
     {
         LOGINFO_ONCE( "Calculation of voc synthase activity instead of standard emission factors");
         ldndc_calc_voc_synthase_activity( _vt, _fl, _latitude, _yearday, _foliage_temperature, _foliage_radiation);
             
          /* factors for conversion from enzyme activity (nmol m-2 (leaf area) s-1) to emission factor (ug component gDW-1 h-1) */
         double const  lsw = cbm::G_IN_KG / _vt->sla_fl[_fl];
         double const  UNIT_CONV = cbm::SEC_IN_HR * cbm::UMOL_IN_NMOL; 
         
         /* "isoAct_vtfl"/"monoAct_vtfl" [nmol enzyme product m-2 leaf area s-1] activity of isoprene/monterpene synthase to produce isoprene/monoterpenes */
         _vt->ef_iso_fl[_fl]  = _vt->isoAct_fl[_fl] * cbm::MC5H8 * UNIT_CONV / ( lsw * ( *_vt)->SCALE_I());
         _vt->ef_mono_fl[_fl] = _vt->monoAct_fl[_fl] * cbm::MC10H16 * UNIT_CONV / ( lsw * ( *_vt)->SCALE_M());
 
         
         return LDNDC_ERR_OK;
     }
     
     else if (( _calc_synthase_activity) && ((( ( *_vt)->ALPHA0_IS() + ( *_vt)->ALPHA0_MT()) <= 0.0) || ( ( *_vt)->PA() <= 0.0)))
     {
         LOGWARN_ONCE( "Dynamic calculation of emission activity not possible",
                 " because species specific paramters ALPHA0_IS + ALPHA0_MT, or PA is equal or less than zero",
                 "  [ALPHA0_IS=",( *_vt)->ALPHA0_IS(),",ALPHA0_MT=",( *_vt)->ALPHA0_MT(),",PA=",( *_vt)->PA(),"]", 
                 " Thus standard emission factors are used!");
         
         ldndc_use_standard_emission_factors( _vt, _fl);
         return  LDNDC_ERR_OK;
 
     }
     
     else
     {
         LOGERROR("Wrong configuration of CalcSynthaseActivity, CalcParTempDependence, or species specific parameters...");
         return LDNDC_ERR_FAIL;
     }
 
 }

◆ non_stomatal_water_limitation()

double ldndc::non_stomatal_water_limitation	(	double const &	_var,
		double const &	_var_ref,
		double const &	_var_scale
	)

Non stomatal water limitation.

Parameters

_var	...
_var_ref	...
_var_scale	...

Returns: Drought stress scaling factor [0-1]

 {
     // water impact on non-stomatal limitations based on Tuzet et al.2003
     if ( cbm::flt_greater_equal_zero( _var))
     {
         return 1.0;
     }
     else
     {
         return cbm::bound(0.0, (1.0 + std::exp(_var_ref * _var_scale)) / (1.0 + std::exp((_var_ref - _var) * _var_scale)), 1.0);
     }
 }

◆ sap_wood_fraction()

double ldndc::sap_wood_fraction	(	double	_lai_max,
		double	_qsfa,
		double	_height_min,
		double	_height_max,
		double	_depth
	)

sap_wood_fraction The calculation of the fraction of sapwood in coarse roots is based on the idealized volume fraction and assumes that the stem in the crown as well as the coarse roots are shaped as cones, and that core wood reaches a third of the cone

Calculation is based on the sapwood area demand for foliage. Sapwood volume is assumed to equal a cone within the canopy and across the rooted soil, and a column between the ground and canopy start.

Author: david kraus (created on: may 6, 2014)

 {
     /* sapwood area (assumed to be in equilibrium with foliage demand) */
     double const  sapArea( _lai_max * _qsfa);
     
     /* estimated aboveground sapwood biomass */
     double const  msap_a( sapArea * _height_min + sapArea/3.0 * (_height_max - _height_min));
     
     /* estimated belowground sapwood biomass */
     double const  msap_b( sapArea / 3.0 * _depth);
     
     if ( cbm::flt_greater_zero( msap_a + msap_b))
     {
         return  msap_b / ( msap_a + msap_b);
     }
     
     return  0.0;
 }

◆ sapwood_foliage_area_ratio()

double ldndc::sapwood_foliage_area_ratio	(	double	_height,
		double	_qsf_p1,
		double	_qsf_p2
	)

Parameters

_height	Tree height
_qsf_p1	species parameter
_qsf_p2	species parameter

Returns: Ratio of sap wood area to foliage area.

 {
     return (_qsf_p1 + _height * _qsf_p2) * cbm::M2_IN_CM2;
 }

◆ update_litter_height()

lerr_t ldndc::update_litter_height	(	soillayers::input_class_soillayers_t const &	_soillayers,
		substate_watercycle_t &	_wc,
		substate_soilchemistry_t &	_sc
	)

Detailed description provided here .

Parameters

_sl	Soil layers class
_wc	Watercycle state
_sc	Soilchemistry state

Returns: Error code

Referenced by ldndc::SoilChemistryMeTrX::MeTrX_update().

 {
     double const raw_litter_above( _sc.c_raw_lit_1_above +
                                    _sc.c_raw_lit_2_above +
                                    _sc.c_raw_lit_3_above);
     
     double h_cum( 0.0);
     for( size_t  sl = 0;  sl < _soillayers.soil_layer_cnt();  ++sl)
     {
         if ( sl < _soillayers.soil_layers_in_litter_cnt())
         {
             if ( cbm::flt_greater_zero( _sc.dens_sl[sl] * _sc.fcorg_sl[sl]) && 
                  cbm::flt_greater_zero( _sc.som_sl[sl]))
             {
                 double const volume_water( _wc.wc_sl[sl] * _sc.h_sl[sl]);
                 
                 double const mass_soil( _sc.min_sl[sl] + _sc.som_sl[sl] + raw_litter_above / _soillayers.soil_layers_in_litter_cnt());
                 double const density_soil( cbm::DM3_IN_M3 * _sc.dens_sl[sl]);
                 
                 // soil organic matter increases --> inc sl-height
                 double const h_new( mass_soil / density_soil);
                 _sc.h_sl[sl] = h_new;
                 
                 double const wc_new( volume_water / _sc.h_sl[sl]);
                 if ( cbm::flt_less_equal(  wc_new, _sc.poro_sl[sl]))
                 {
                     _wc.wc_sl[sl] = wc_new;
                 }
                 else
                 {
                     _wc.wc_sl[sl] = _sc.poro_sl[sl];
                     _wc.surface_water += (wc_new - _sc.poro_sl[sl]) * h_new;
                 }
             }
             else if ( !cbm::flt_greater_zero( _sc.som_sl[sl]))
             {
                 _sc.h_sl[sl] = 0.0;
                 _wc.wc_sl[sl] = 0.0;
 
                 LOGERROR( "Soil litter layer height vanished. Illegal situation!");
                 return  LDNDC_ERR_FAIL;
             }
         }
 
         h_cum += _sc.h_sl[sl];
         _sc.depth_sl[sl] = h_cum;
     }
 
     return  LDNDC_ERR_OK;
 }

Here is the caller graph for this function:

◆ wood_initialization()

lerr_t ldndc::wood_initialization	(	soillayers::input_class_soillayers_t const &	_sl,
		MoBiLE_Plant *	_p,
		substate_soilchemistry_t &	_sc,
		ecosystem_type_e	_ecosystemtype
	)

Initialization of aboveground and belowground wood debris, derived from existing vegetation.

Referenced by ldndc::SoilChemistryMeTrX::MeTrX_update().

 {
     double const add_c_wood( ((_ecosystemtype == ECOSYS_FOREST_NATURAL) ? 0.3 : 0.1) * ( _p->mSap + _p->mCor) * cbm::CCDM);
 
     //add 80% aboveground
     _sc.c_wood += 0.8 * add_c_wood;
     _sc.n_wood += 0.8 * add_c_wood / cbm::CCDM * _p->ncCor;
 
     //add 20% belowground
     for ( size_t  sl = 0;  sl < _sl.soil_layer_cnt();  ++sl)
     {
         _sc.c_wood_sl[sl] += 0.2 * _p->fFrt_sl[sl] * add_c_wood;
         _sc.n_wood_sl[sl] += 0.2 * _p->fFrt_sl[sl] * add_c_wood / cbm::CCDM * _p->ncCor;
     }
 
     return  LDNDC_ERR_OK;
 }

Here is the caller graph for this function:

Variable Documentation

◆ module_factories

ldndc::MoBiLE_ModuleFactoryEnvelope const ldndc::module_factories

a list of destructors (because i was to lazy to add a one line file for these base classes..)
module factory array is defined here.

Author

steffen klatt,
edwin haas,

◆ substate_airchemistry_factory

ldndc::substate_factory_t< substate_airchemistry_t > const ldndc::substate_airchemistry_factory

substate base class implementation, sources factories

Author: edwin haas, steffen klatt (created on: dec 05, 2013)

◆ TMODE_DEFAULTS

lflags_t const ldndc::TMODE_DEFAULTS = TMODE_SUBDAILY|TMODE_PRE_DAILY|TMODE_POST_DAILY|TMODE_PRE_YEARLY|TMODE_POST_YEARLY

Author: steffen klatt, edwin haas

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ MoBiLE_PlantParameters

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ lmodule_flag_e

Function Documentation

◆ allocate_litter()

◆ assign_soillayer_field_capacity_and_wilting_point()

◆ assign_soillayer_porosity()

◆ canopy_biomass_distribution()

◆ canopy_lai_distribution()

◆ cation_exchange_capacity()

◆ crown_shape_parameter()

◆ d_eff_air_a()

◆ d_eff_air_b()

◆ d_eff_air_millington_and_quirk_1961()

◆ estimate_single_layer_biomass()

◆ fineroots_biomass_distribution()

◆ forest_floor()

◆ get_optimum_sap_wood_biomass()

◆ get_sapwood_foliage_ratio()

◆ get_voc_emission_factors()

◆ non_stomatal_water_limitation()

◆ sap_wood_fraction()

◆ sapwood_foliage_area_ratio()

◆ update_litter_height()

◆ wood_initialization()

Variable Documentation

◆ module_factories

◆ substate_airchemistry_factory

◆ TMODE_DEFAULTS