ldndc Namespace Reference

Spatially explicit groundwater model. More...

Classes
class	EcHy
	Hydrology model EcHy. More...
class	PhysiologyGrowthPSIM
	Vegetation model GrowthPSIM. More...
class	PhysiologyPlaMox
	Vegetation model PlaMox. More...
class	PhysiologyPNET
	Vegetation model PNET. More...
class	SoilChemistryMeTrX
	Biogeochemical model MeTrx. More...
class	WatercycleDNDC
	Watercycle model WatercycleDNDC. More...

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 ,   LMOD_FLAG_CNT_ ,   LMOD_FLAG_CNT = 1 + 1 + cbm::log2_t< LMOD_FLAG_CNT_-1 >::LOG2 }
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 ,   CPOOL_CNT }
	Order of carbon pools in array passed to allocate_litter. More...

Functions
lerr_t	assign_soillayer_porosity (double &_porosity_with_stones, size_t const &_nd_stratum, double const &_depth, double const &_stone_fraction, 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_macropores (double &_macropores_with_stones, double &_wc_fc, double &_wc_sat, size_t const &_nd_stratum, double const &_depth, double const &_stone_fraction, double const &_porosity_with_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)
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.
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.
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.
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.
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
double LDNDC_API	cation_exchange_capacity (double _clay, double _sand, double _som, double _ph, ecosystem_type_e _ecosystem)
	Detailed description provided here .
double	d_eff_air_a (double const &, double const &)
	Returns effective diffusion coefficient depending on gas content.
double	d_eff_air_b (double const &, double const &, double const &, double const &)
	Returns effective diffusion coefficient depending on gas content and porosity.
double	d_eff_air_millington_and_quirk_1961 (double const &, double const &)
	Returns effective diffusion coefficient after [55].
lerr_t	update_litter_height (soillayers::input_class_soillayers_t const &, substate_watercycle_t &, substate_soilchemistry_t &)
	Detailed description provided here .
bool	forest_floor (size_t, soillayers::input_class_soillayers_t const &, const ldndc::site::input_class_site_t &)
	First floor defined by:
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
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.
double	non_stomatal_water_limitation (double const &_var, double const &_var_ref, double const &_var_scale)
	Non stomatal water limitation.
double LDNDC_API	thornthwaite_heat_index (double, size_t, double, double)
	Thornthwaite heat index.
double LDNDC_API	thornthwaite (double, double, 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

Detailed Description

Spatially explicit groundwater model.

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

Author

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 David Kraus

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 David Kraus

steffen klatt, edwin haas

steffen klatt (created on: jan 19, 2013)

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)

{
    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;
}

References CPOOL_B, CPOOL_L, CPOOL_R, and CPOOL_VL.

assign_soillayer_macropores()

lerr_t ldndc::assign_soillayer_macropores	(	double &	_macropores_with_stones,
		double &	_wc_fc,
		double &	_wc_sat,
		size_t const &	_nd_stratum,
		double const &	_depth,
		double const &	_stone_fraction,
		double const &	_porosity_with_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 )

Hydraulic parameters are checked for consistency against each other.

{
    ldndc::site::iclass_site_stratum_t stratum;
    lerr_t  rc_stratum = _soillayers->stratum( _nd_stratum, &stratum);
    RETURN_IF_NOT_OK( rc_stratum);
 
    if ( cbm::is_valid( stratum.macropores))
    {
        _macropores_with_stones = stratum.macropores;
    }
    else
    {
        if ( forest_floor( _depth, *_soillayers, *_site))
        {
            _macropores_with_stones = _soilparameters->HUMUS_MACROPORES( _soillayers->humus_type());
        }
        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 field capacity and wilting point of stratum ",
                           _nd_stratum+1, " not successful 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 ( ldndc::use_usda_soil_texture_triangle( _soillayers->soil_type()) &&
                 (texture_type != ldndc::soillayers::SOIL_NONE))
            {
                _macropores_with_stones = _soilparameters->SOIL_MACROPORES( texture_type);
            }
            else
            {
                _macropores_with_stones = _soilparameters->SOIL_MACROPORES( _soillayers->soil_type());
            }
        }
    }
 
    _macropores_with_stones *= (1.0 - _stone_fraction);

    if( cbm::flt_greater( _wc_fc + _macropores_with_stones, _porosity_with_stones))
    {
        double const scale_down( _porosity_with_stones / ( _wc_fc + _macropores_with_stones));
        _wc_fc *= scale_down;
        STRATUM_INFO( "Field capacity exceeded porosity minus macropores in stratum ", _nd_stratum+1, ". ",
                      "Adjusted field capacity: ", _wc_fc / (1.0 - _stone_fraction) * 100.0," [%]");
    }
 
    if( cbm::flt_less_equal( _wc_sat, _wc_fc))
    {
        _wc_sat = 0.5 * (_wc_fc + _porosity_with_stones);
        STRATUM_INFO( "Saturated water content smaller than field capacity in stratum ", _nd_stratum+1, ". ",
                      "Adjusted saturated water content: ", _wc_sat / (1.0 - _stone_fraction) * 100.0," [%]");
    }
 
    return  LDNDC_ERR_OK;
}

References forest_floor().

Here is the call graph for this function:

assign_soillayer_porosity()

lerr_t ldndc::assign_soillayer_porosity	(	double &	_porosity_with_stones,
		size_t const &	_nd_stratum,
		double const &	_depth,
		double const &	_stone_fraction,
		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()

{
    ldndc::site::iclass_site_stratum_t stratum;
    lerr_t  rc_stratum = _soillayers->stratum( _nd_stratum, &stratum);
    if ( rc_stratum)
    {
        LOGERROR( "Invalid stratum [nd=", _nd_stratum,"]");
        return LDNDC_ERR_FAIL;
    }
 
    double porosity_without_stones( invalid_dbl);
    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, " [site id=",_site->object_id(),"] not successful due to invalid soil texture info");
            return  LDNDC_ERR_FAIL;
        }

        double mineral_soil_density( cbm::DMIN);
        double const clay_sand_silt( clay + sand + silt);
        if ( cbm::flt_greater_zero( clay_sand_silt))
        {
            mineral_soil_density = (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, mineral_soil_density);
        STRATUM_INFO( "Porosity of stratum ",_nd_stratum+1," not initialized, estimated value (without stones): ", porosity_without_stones*100.0," [%]");
    }
 
    _porosity_with_stones = porosity_without_stones * (1.0 - _stone_fraction);
 
    if ( !cbm::flt_in_range_lu( 0.0, _porosity_with_stones, 1.0))
    {
        LOGERROR( "Porosity of stratum ", _nd_stratum+1, " [site id=",_site->object_id(),"] out of range: ",
                  _porosity_with_stones / (1.0 - _stone_fraction)*100," [%]");
        return  LDNDC_ERR_FAIL;
    }
    else
    {
        return  LDNDC_ERR_OK;
    }
}

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

{
    /* 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;
            }
        }
    }
}

References estimate_single_layer_biomass().

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 [-]

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

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 [-]

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

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 (Root distribution). Only for root distribution there are several more options available.

{
    // 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;
    }
}

Referenced by canopy_biomass_distribution(), and fineroots_biomass_distribution().

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 )

Root distribution and root properties are generally fixed throughout the simulation period. Only, if the initial condition of planting doesn't allow the soil profile to be fully rooted (e.g. plants are too small), rooting depth increases linearly with \( GZRTZ \) until the maximum root depth (defined by the soil profile) is reached. This is different in Plamox, where plant roots start growing down with planting and should not grow as deep as the soil profile depth, but stop at the species parameter, the maximum rooting depth \( ZRTMC \).

Standard empirial root distribution

The distribution of fine root biomass \( m(z) \) within the rooting space depends on the rooting depth and is calculated with the same empirical equation as the foliage biomass (veglibs_canopy). The main difference is that the parameter 'p' is generally below 1 now to get a concave distribution ([28]).

\[ m(z) = M \cdot \frac{r_{ih} f(z)}{\int r_{ih} f(z)} \\ r_{ih} = \frac{RD - z}{RD} \\ f(z) = p^{100 \frac{z}{RD^2}} \]

\( RD \): root depth (m)
\( z \): distribution depth for which the percentage roots should be defined (between 0-1, from upper soil boundary to rooting depth)
\( p \): shape parameter

Fine roots biomass distribution

Note

This function is currently the standard option for PSIM/TREEDYN (implicitly)

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

{
   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;
       }
   }
}

References estimate_single_layer_biomass().

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 &	)

First floor defined by:

• litter height
• ecosystem type

{
    if ( _sl < _soillayers.soil_layers_in_litter_cnt())
    {
        return true;
    }
 
    return false;
}

Referenced by assign_soillayer_macropores().

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.

{
    double const sapwood_area_demand( _p->lai_max  * _p->qsfa);
    double const branch_sapwood(_p->aboveground_wood() * _p->f_branch);
    double const optimum_msap_tree( (*_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));
    double const optimum_sap_wood( optimum_msap_tree + branch_sapwood);
 
    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;
    }
}

Referenced by get_sapwood_foliage_ratio().

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

{
    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;
}

References get_optimum_sap_wood_biomass().

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);
    }
}

Referenced by ldndc::PhysiologyGrowthPSIM::PSIM_PhotosynthesisRates().

Here is the caller graph for this function:

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  sap_area( _lai_max * _qsfa);
 
    /* estimated aboveground sapwood biomass */
    double const  msap_a( sap_area * _height_min + sap_area / 3.0 * (_height_max - _height_min));
 
    /* estimated belowground sapwood biomass */
    double const  msap_b( sap_area / 3.0 * _depth);
 
    if ( cbm::flt_greater_zero( msap_a + msap_b))
    {
        return  msap_b / ( msap_a + msap_b);
    }
 
    return  0.0;
}

Referenced by ldndc::PhysiologyPNET::TransformPhysiology().

Here is the caller graph for this function:

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

{
    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;
}

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.

{
    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;
}

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

Here is the caller graph for this function:

Variable Documentation

TMODE_DEFAULTS

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

extern

Author

steffen klatt, edwin haas