ldndc::RootSystemDNDC Struct Reference

Fine root system used by PlaMox and, for the distribution functions and nitrogen uptake, by other physiology modules (see Root system). More...

#include <models/physiology/ld_rootsystem.h>

Inheritance diagram for ldndc::RootSystemDNDC:

Collaboration diagram for ldndc::RootSystemDNDC:

Public Member Functions
	RootSystemDNDC (MoBiLE_State *, cbm::io_kcomm_t *)
	Connects the root system to the model state (soil, microclimate, water, vegetation).
void	reset (MoBiLE_Plant *)
	Resets rooting depth, fine root mass and the fine root distribution across soil layers of a plant to zero.
void	set_rooting_depth (unsigned int &, MoBiLE_Plant *, double, double _max_rooting_depth=invalid_dbl)
	Sets the rooting depth, limited by a given maximum or, if none is given, by the species parameter ZRTMC, and determines the number of rooted layers.
void	update_root_fraction_sigmoid (double, unsigned int, double, double, double, double, MoBiLE_Plant *)
	Updates the fine root distribution of a plant with the sigmoid shape (Sigmoid root distribution).
template<class _S>
void	update_root_fraction_sigmoid (double, unsigned int, double, double, double, double, _S _fFrt_sl, unsigned int nb_layers)
	Sigmoid root distribution applied to an arbitrary array of root fractions.
void	update_root_fraction_exponential (double, unsigned int, double, MoBiLE_Plant *)
	Updates the fine root distribution of a plant with the exponential shape (Exponential root distribution).
template<class _S>
void	update_root_fraction_exponential (double, unsigned int, double, _S _fFrt_sl, unsigned int nb_layers)
	Exponential root distribution applied to an arbitrary array of root fractions.
void	update_roots_static (const double, unsigned int &, MoBiLE_Plant *, ldndc::growable_array< BaseRootSystemDNDC *, 1000, 1 > &, double)
	Root growth of one time step with the static approach (Static root growth model).
void	specific_root_length (unsigned int const &, MoBiLE_Plant *, lvector_t< double > &)
	Specific root length of every evaluated layer (Root length and density).
void	reduce_root_system (unsigned int &, MoBiLE_Plant *, double)
	Removes root mass uniformly from all layers (respiration, exudation); the root distribution stays the same and root length is reduced accordingly.
void	reduce_root_system (unsigned int &, MoBiLE_Plant *, lvector_t< double >)
	Removes root mass from individual layers (e.g., senescence depending on layer conditions); root length, total root mass and the root distribution are updated.
void	update_rootlength (unsigned int &, MoBiLE_Plant *, double)
	Root length change for a root mass change of the whole root system, which is distributed over the layers according to the current fractions (see Root length and density).
void	update_rootlength (unsigned int &, MoBiLE_Plant *, lvector_t< double >)
	Root length change for root mass changes of individual layers (see Root length and density).
void	update_roots_dynamic (const double, unsigned int &, MoBiLE_Plant *, double)
	Root growth of one time step with the dynamic approach (Dynamic root growth model).
lvector_t< double >	root_restrictions_coarse_fragments (unsigned int)
	Root growth restriction by coarse fragments (stones) for every layer (Root growth restrictions).
lvector_t< double >	root_restrictions_soil_strength (unsigned int)
	Root growth restriction by soil strength for every layer (Root growth restrictions).
lvector_t< double >	root_restrictions_aeration (unsigned int, MoBiLE_Plant *)
	Root growth restriction by oxygen shortage for every layer (Root growth restrictions).
lvector_t< double >	root_restrictions_temperature (unsigned int, MoBiLE_Plant *)
	Root growth restriction by soil temperature for every layer (Root growth restrictions).
void	update_rooting_depth (const double, double &, unsigned int &, MoBiLE_Plant *)
	Increases the rooting depth by the restricted target increment (step 4 of the Dynamic root growth model) and updates the number of rooted layers.
void	target_rooting_depth_increase (double &_rooting_depth_increase, unsigned int &_sl_min_no_roots, double const _dt_per_day, MoBiLE_Plant *const _p)
	Target increase of the rooting depth under optimum conditions (Target rooting depth).
unsigned int	first_layer_below (double) const
	Number of rooted soil layers for a given rooting depth [m].
void	nitrogen_uptake (unsigned int _deepest_rooted_layer, double &n_plant, double n_opt, double _fts_tot, lvector_t< double > _no3_sl, lvector_t< double > _no3_uptake_sl, lvector_t< double > _nh4_sl, lvector_t< double > _nh4_uptake_sl, lvector_t< double > _don_sl, lvector_t< double > _don_uptake_sl, lvector_t< double > _temp_sl, MoBiLE_Plant *)
	Uptake of NH4, NO3 and DON from the rooted layers (Nitrogen uptake).

Public Attributes
input_class_soillayers_t const *	m_soillayers
	soil layer input (number of layers)
LD_PlantFunctions	m_pf
	plant functions (e.g., temperature dependency of nitrogen uptake)
substate_soilchemistry_t &	sc_
	soil state (layer depths and thicknesses, stones, density, texture)
substate_microclimate_t &	mc_
	microclimate state (soil temperature)
substate_physiology_t &	ph_
	physiology state
substate_watercycle_t &	wc_
	water state (water content, wilting point, field capacity)
MoBiLE_PlantVegetation *	m_veg
	vegetation

Detailed Description

Fine root system used by PlaMox and, for the distribution functions and nitrogen uptake, by other physiology modules (see Root system).

Member Function Documentation

first_layer_below()

unsigned int ldndc::RootSystemDNDC::first_layer_below

(

double

_rooting_depth

)

const

Number of rooted soil layers for a given rooting depth [m].

Number of rooted soil layers for a given rooting depth, i.e., the index of the first soil layer that does not hold any roots.

Layer depths are not commensurate with the root elongation, so the layer that contains the root tip counts as rooted. Used for the target and the actual rooting depth alike.

Parameters

_rooting_depth

rooting depth [m]

Returns

number of rooted layers, at most the number of soil layers

{
    for ( size_t  sl = 0;  sl < m_soillayers->soil_layer_cnt();  ++sl)
    {
        if ( cbm::flt_greater( sc_.depth_sl[sl], _rooting_depth))
        {
            return static_cast< unsigned int >( sl+1);
        }
    }
    return static_cast< unsigned int >( m_soillayers->soil_layer_cnt());
}

References m_soillayers, and sc_.

Referenced by set_rooting_depth(), target_rooting_depth_increase(), and update_rooting_depth().

Here is the caller graph for this function:

nitrogen_uptake()

void ldndc::RootSystemDNDC::nitrogen_uptake ( unsigned int _deepest_rooted_layer, double & _n_plant, double _n_opt, double _fts_tot, lvector_t< double > _no3_sl, lvector_t< double > _no3_uptake_sl, lvector_t< double > _nh4_sl, lvector_t< double > _nh4_uptake_sl, lvector_t< double > _don_sl, lvector_t< double > _don_uptake_sl, lvector_t< double > _temp_sl, MoBiLE_Plant * _vt )

virtual

Uptake of NH4, NO3 and DON from the rooted layers (Nitrogen uptake).

Parameters

_deepest_rooted_layer	index of the deepest rooted layer (inclusive)
_n_plant	plant nitrogen [kgN m-2] (updated)
_n_opt	optimum plant nitrogen [kgN m-2]
_fts_tot	length of the time step [d]
_no3_sl	nitrate of every layer [kgN m-2] (updated)
_no3_uptake_sl	nitrate uptake of every layer [kgN m-2] (accumulated)
_nh4_sl	ammonium of every layer [kgN m-2] (updated)
_nh4_uptake_sl	ammonium uptake of every layer [kgN m-2] (accumulated)
_don_sl	dissolved organic nitrogen of every layer [kgN m-2] (updated)
_don_uptake_sl	DON uptake of every layer [kgN m-2] (accumulated)
_temp_sl	soil temperature of every layer [oC]
_vt	plant

Implements ldndc::BaseRootSystemDNDC.

{
    /* Nitrogen status update  */
    double const n_demand( _n_opt - _n_plant);
 
    if ( cbm::flt_greater_zero( n_demand))
    {
        double n_up_total(0.0);
        for (size_t sl = 0; sl <= _deepest_rooted_layer; sl++)
        {
            double const mFrt( cbm::bound_min( 0.01, _vt->mFrt) * _vt->fFrt_sl[sl]);
            if ( !cbm::flt_greater_zero( mFrt))
            {
                break;
            }
 
            // temperature dependency
            double const fact_t( m_pf.nitrogen_uptake_temperature_dependency(
                                                                     0.8 * (*_vt)->TLIMIT(),
                                                                     1.2 * (*_vt)->TLIMIT(),
                                                                     _temp_sl[sl]));
 
            // potential uptake of NH4, NO3 and DON
            double const nh4_up( cbm::bound_max( (*_vt)->US_NH4() * mFrt * fact_t * _fts_tot
                                                 * _nh4_sl[sl] / (_nh4_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                 0.9 * _nh4_sl[sl]));
            double const no3_up( cbm::bound_max( (*_vt)->US_NO3() * mFrt * fact_t * _fts_tot
                                                 * _no3_sl[sl] / (_no3_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                 0.9 * _no3_sl[sl] ));
            double const don_up( cbm::bound_max( (*_vt)->US_NO3() * mFrt * fact_t * _fts_tot
                                                 * _don_sl[sl] / (_don_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                 0.9 * _don_sl[sl]));
            n_up_total += nh4_up + no3_up + don_up;
        }
 
 
        double const scale( ( n_up_total > 0.0) ? cbm::bound_max(n_demand / n_up_total, 1.0) : 0.0);
 
        if ( cbm::flt_greater_zero( scale))
        {
            for (size_t sl = 0; sl <= _deepest_rooted_layer; sl++)
            {
                double const mFrt( cbm::bound_min( 0.01, _vt->mFrt) * _vt->fFrt_sl[sl]);
 
                if ( !cbm::flt_greater_zero( mFrt))
                {
                    break;
                }
 
                double const fact_t( m_pf.nitrogen_uptake_temperature_dependency(
                                                                                 0.8 * (*_vt)->TLIMIT(),
                                                                                 1.2 * (*_vt)->TLIMIT(),
                                                                                 _temp_sl[sl]));
 
                double const nh4_up( scale * cbm::bound_max( (*_vt)->US_NH4() * mFrt * fact_t * _fts_tot
                                                            * _nh4_sl[sl] / (_nh4_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                            0.9 * _nh4_sl[sl]));
                double const no3_up( scale * cbm::bound_max( (*_vt)->US_NO3() * mFrt * fact_t * _fts_tot
                                                            * _no3_sl[sl] / (_no3_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                            0.9 * _no3_sl[sl] ));
                double const don_up( scale * cbm::bound_max( (*_vt)->US_NO3() * mFrt * fact_t * _fts_tot
                                                            * _don_sl[sl] / (_don_sl[sl] + (*_vt)->K_MM_NITROGEN_UPTAKE() * sc_.h_sl[sl]),
                                                            0.9 * _don_sl[sl]));
                if ( cbm::flt_greater_zero( nh4_up))
                {
                    _nh4_uptake_sl[sl] += nh4_up;
                    _nh4_sl[sl] -= nh4_up;
                    if ( _nh4_sl[sl] < 0.0)
                    {
                        _nh4_sl[sl] = 0.0;
                    }
                    _n_plant += nh4_up;
                }
 
                if ( cbm::flt_greater_zero( no3_up))
                {
                    _no3_uptake_sl[sl] += no3_up;
                    _no3_sl[sl] -= no3_up;
                    if ( _no3_sl[sl] < 0.0)
                    {
                        _no3_sl[sl] = 0.0;
                    }
                    _n_plant += no3_up;
                }
 
                if ( cbm::flt_greater_zero(don_up))
                {
                    _don_uptake_sl[sl] += don_up;
                    _don_sl[sl] -= don_up;
                    if ( _don_sl[sl] < 0.0)
                    {
                        _don_sl[sl] = 0.0;
                    }
                    _n_plant += don_up;
                }
            }
        }
    }
}

References m_pf, and sc_.

reduce_root_system() [1/2]

void ldndc::RootSystemDNDC::reduce_root_system ( unsigned int & _sl_below_roots, MoBiLE_Plant * _p, double _delta_dw_frt )

virtual

Removes root mass uniformly from all layers (respiration, exudation); the root distribution stays the same and root length is reduced accordingly.

Parameters

_sl_below_roots	number of rooted soil layers
_p	plant
_delta_dw_frt	root mass loss [kgDW m-2] (> 0)

Implements ldndc::BaseRootSystemDNDC.

{
    //layer specific root length reduction
    update_rootlength( _sl_below_roots, _p, -_delta_dw_frt);
    //root mass reduction
    _p->mFrt -= _delta_dw_frt;
}

References update_rootlength().

Here is the call graph for this function:

reduce_root_system() [2/2]

void ldndc::RootSystemDNDC::reduce_root_system ( unsigned int & _sl_below_roots, MoBiLE_Plant * _p, lvector_t< double > _delta_dw_frt_sl )

virtual

Removes root mass from individual layers (e.g., senescence depending on layer conditions); root length, total root mass and the root distribution are updated.

Parameters

_sl_below_roots	number of rooted soil layers
_p	plant
_delta_dw_frt_sl	root mass loss of every rooted layer [kgDW m-2] (> 0)

Implements ldndc::BaseRootSystemDNDC.

{
    //layer specific root length reduction
    update_rootlength( _sl_below_roots, _p, -_delta_dw_frt_sl);
 
    //root mass reduction
    double const dw_frt_new( _p->mFrt - _delta_dw_frt_sl.sum());
    for ( size_t sl = 0; sl < _sl_below_roots; ++sl)
    {
        _p->fFrt_sl[sl] = (_p->mFrt * _p->fFrt_sl[sl] - _delta_dw_frt_sl[sl]) / dw_frt_new;
    }
    _p->mFrt = dw_frt_new;
}

References update_rootlength().

Here is the call graph for this function:

reset()

void ldndc::RootSystemDNDC::reset ( MoBiLE_Plant * _p )

virtual

Resets rooting depth, fine root mass and the fine root distribution across soil layers of a plant to zero.

Note

Root length (rootlength_sl) is not reset here.

Implements ldndc::BaseRootSystemDNDC.

{
    _p->rooting_depth = 0.0;
    _p->mFrt = 0.0;
    for ( size_t sl = 0;  sl < _p->nb_soillayers();  ++sl)
    {
        _p->fFrt_sl[sl] = 0.0;
    }
}

root_restrictions_aeration()

lvector_t< double > ldndc::RootSystemDNDC::root_restrictions_aeration ( unsigned int _sl_no_roots, MoBiLE_Plant * _p )

virtual

Root growth restriction by oxygen shortage for every layer (Root growth restrictions).

Parameters

_sl_no_roots	number of soil layers to evaluate
_p	plant

Returns

restriction for every evaluated layer [0-1]

Implements ldndc::BaseRootSystemDNDC.

{
    lvector_t< double > layer_restrictions( _sl_no_roots, 1.0);
    // new version employing O2 content in soil directly rather than water filled pore space
    for( unsigned int sl = 0;  sl < _sl_no_roots;  ++sl)
    {
        if ( !cbm::flt_greater_zero( (*_p)->RS_CONDUCT()))
        {
            layer_restrictions[sl] = cbm::bound_min( 0.0, 1.0 - _p->hypoxia_sl[sl]);
        }
    }
 
    return layer_restrictions;
}

Referenced by update_roots_dynamic().

Here is the caller graph for this function:

root_restrictions_coarse_fragments()

lvector_t< double > ldndc::RootSystemDNDC::root_restrictions_coarse_fragments ( unsigned int _sl_no_roots )

virtual

Root growth restriction by coarse fragments (stones) for every layer (Root growth restrictions).

Parameters

_sl_no_roots

number of soil layers to evaluate

Returns

restriction for every evaluated layer [0-1]

Implements ldndc::BaseRootSystemDNDC.

{
    lvector_t< double > layer_restrictions( _sl_no_roots, 1.0);
    for( unsigned int sl = 0; sl < _sl_no_roots; ++sl)
    {
        layer_restrictions[sl] = 1.0 - sc_.stone_frac_sl[sl];
    }
    return layer_restrictions;
}

References sc_.

Referenced by update_roots_dynamic().

Here is the caller graph for this function:

root_restrictions_soil_strength()

lvector_t< double > ldndc::RootSystemDNDC::root_restrictions_soil_strength ( unsigned int _sl_no_roots )

virtual

Root growth restriction by soil strength for every layer (Root growth restrictions).

Parameters

_sl_no_roots

number of soil layers to evaluate

Returns

restriction for every evaluated layer [0-1]

Implements ldndc::BaseRootSystemDNDC.

{
    lvector_t< double > layer_restrictions( _sl_no_roots, 1.0);
    for( unsigned int sl = 0; sl < _sl_no_roots; ++sl)
    {
        // bulk density
        // estimate limits via sand content (without stones)
        double const bdo( 1.1 + 0.5 * sc_.sand_sl[sl]);
        double const bdx( 1.6 + 0.4 * sc_.sand_sl[sl]);
        // Reduction due to stones is already contained in coarse fragments.
        double const density_without_stones( (sc_.dens_sl[sl] - sc_.stone_frac_sl[sl] * cbm::DMIN) / (1. - sc_.stone_frac_sl[sl]));
        if( cbm::flt_greater( density_without_stones, bdo))
        {
            if( cbm::flt_greater( density_without_stones, bdx))
            {
                layer_restrictions[sl] = 0.0;
            }
            else
            {
                layer_restrictions[sl] = (bdx - density_without_stones)/(bdx-bdo);
            }
        }
        // take water content into account
        double thetaf = 99.0;
        if( cbm::flt_greater( wc_.wc_wp_sl[sl], wc_.wc_sl[sl]))
        {
            thetaf = 0.0;
        }
        else
        {
            if( cbm::flt_greater_equal( wc_.wc_fc_sl[sl], wc_.wc_sl[sl]))
            {
                thetaf = (wc_.wc_sl[sl] - wc_.wc_wp_sl[sl])/(wc_.wc_fc_sl[sl] - wc_.wc_wp_sl[sl]);
            }
            else
            {
                thetaf = 1.0;
            }
        }
 
        layer_restrictions[sl] *= sin( cbm::PI/2. * thetaf);
        if( !cbm::flt_in_range_lu( 0., layer_restrictions[sl], 1.))
        {
            LOGERROR( "layerrestriction soil strength in layer ", sl, " < 0 or > 1: ", layer_restrictions[sl]);
        }
    }
 
    return layer_restrictions;
}

References sc_, and wc_.

Referenced by update_roots_dynamic().

Here is the caller graph for this function:

root_restrictions_temperature()

lvector_t< double > ldndc::RootSystemDNDC::root_restrictions_temperature ( unsigned int _sl_no_roots, MoBiLE_Plant *  )

virtual

Root growth restriction by soil temperature for every layer (Root growth restrictions).

Parameters

_sl_no_roots

number of soil layers to evaluate

Returns

restriction for every evaluated layer [0-1]

Implements ldndc::BaseRootSystemDNDC.

{
    double const t_min( 0.0);//(*_p)->TLIMIT());
    double const t_max( 45.0);
    lvector_t< double > layer_restrictions( _sl_no_roots, 1.0);
    for( unsigned int sl = 0;  sl < _sl_no_roots;  ++sl)
    {
        if( cbm::flt_greater( t_min, mc_.temp_sl[sl]))
        {
            layer_restrictions[sl] = 0.0;
        }
        else
        {
            if( cbm::flt_greater( t_max, mc_.temp_sl[sl]))
            {
                double const Topt( t_min + (t_max - t_min) / 2.0);
                layer_restrictions[sl] = sin( cbm::PI / 2.0 * (mc_.temp_sl[sl] - t_min) /
                                                              (Topt - t_min));
            }
            else
            {
                layer_restrictions[sl] = 0.0;
            }
        }
        if( !cbm::flt_in_range_lu( 0., layer_restrictions[sl], 1.))
        {
            LOGERROR( "layerrestriction temperature in layer ", sl, " < 0 or > 1: ", layer_restrictions[sl]);
        }
    }
 
    return layer_restrictions;
}

References mc_.

Referenced by update_roots_dynamic().

Here is the caller graph for this function:

set_rooting_depth()

void ldndc::RootSystemDNDC::set_rooting_depth ( unsigned int & _root_q_vt, MoBiLE_Plant * _p, double _rooting_depth, double _max_rooting_depth = invalid_dbl )

virtual

Sets the rooting depth, limited by a given maximum or, if none is given, by the species parameter ZRTMC, and determines the number of rooted layers.

The number of rooted layers follows the same definition as in the dynamic root model (first_layer_below()): the layer that contains the root tip is rooted; if the rooting depth reaches the bottom of the soil profile, all layers are rooted. The rooting depth itself is not limited by the soil depth.

Used by ArableDNDC, GrasslandDNDC and Oryza2000.

Parameters

_root_q_vt	number of rooted soil layers (output)
_p	plant
_rooting_depth	new rooting depth [m]
_max_rooting_depth	optional maximum rooting depth [m]

Implements ldndc::BaseRootSystemDNDC.

{
    if ( cbm::is_valid( _max_rooting_depth))
    {
        _p->rooting_depth = ( _rooting_depth > _max_rooting_depth) ? _max_rooting_depth : _rooting_depth;
    }
    else
    {
        _p->rooting_depth = ( _rooting_depth > (*_p)->ZRTMC()) ? (*_p)->ZRTMC() : _rooting_depth;
    }
 
    if ( cbm::flt_equal_zero( _p->rooting_depth))
    {
        _root_q_vt = 0u;
    }
    else
    {
        unsigned int const layer_cnt( static_cast< unsigned int >( std::min( _p->nb_soillayers(),
                                                                             static_cast<size_t>(m_soillayers->soil_layer_cnt()))));
        _root_q_vt = std::min( first_layer_below( _p->rooting_depth), layer_cnt);
    }
}

References first_layer_below(), and m_soillayers.

Here is the call graph for this function:

specific_root_length()

void ldndc::RootSystemDNDC::specific_root_length ( unsigned int const & _sl_below_roots, MoBiLE_Plant * _p, lvector_t< double > & specifific_root_length_sl )

virtual

Specific root length of every evaluated layer (Root length and density).

Parameters

_sl_below_roots	number of layers to evaluate \( n \)
_p	plant
specifific_root_length_sl	specific root length of every evaluated layer [m kgDW-1] (output)

Implements ldndc::BaseRootSystemDNDC.

{
    for ( size_t sl = 0; sl < _sl_below_roots; ++sl)
    {
        double const srl_min( (*_p)->SRL_MAX() * (1.0 - (*_p)->SRL_DECLINE()));
        double const scale(cbm::bound( 0.0, 1.0 - sc_.depth_sl[sl] / sc_.depth_sl[_sl_below_roots-1], 1.0));
        // GS = growth stage elem [0,1]
        specifific_root_length_sl[sl] = (*_p)->SRL_MAX() - _p->dvsFlush * ((*_p)->SRL_MAX() - srl_min) * scale;
    }
}

References sc_.

Referenced by update_roots_dynamic(), and update_roots_static().

Here is the caller graph for this function:

target_rooting_depth_increase()

void ldndc::RootSystemDNDC::target_rooting_depth_increase ( double & _rooting_depth_increase, unsigned int & _sl_min_no_roots, double const _dt_per_day, MoBiLE_Plant *const _p )

virtual

Target increase of the rooting depth under optimum conditions (Target rooting depth).

Parameters

_rooting_depth_increase	target increase of the rooting depth [m] (output)
_sl_min_no_roots	number of rooted layers at the target depth (output)
_dt_per_day	length of the time step [d]
_p	plant

Implements ldndc::BaseRootSystemDNDC.

{
    // growth: currently linear as in Jones 1991
    // a) similar to conventional model
    _rooting_depth_increase = (*_p)->FRT_DGR_MAX() * _dt_per_day;
    // b) as suggested by Jones
    // todo: what is deltaGDD?
    //~ target_rooting_depth_increase = (*_vt)->FRT_DGR_MAX() * (_vt->growing_degree_days - GDD(t-1)???) / (*_vt)->GDD_ROOTS_GROWN();
 
    bool const gdd_ok( cbm::flt_greater( (*_p)->GDD_ROOTS_GROWN(), _p->growing_degree_days));
    if ( !gdd_ok)
    {
        _rooting_depth_increase = 0.0;
    }
    _rooting_depth_increase = cbm::bound( 0.0, _rooting_depth_increase, (*_p)->ZRTMC() - _p->rooting_depth);
 
    // first non-rooted layer (same definition as in update_rooting_depth)
    _sl_min_no_roots = first_layer_below( _p->rooting_depth + _rooting_depth_increase);
}

References first_layer_below().

Referenced by update_roots_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

update_root_fraction_exponential() [1/2]

template<class _S>

void ldndc::RootSystemDNDC::update_root_fraction_exponential	(	double	_adaption_rate,
		unsigned int	_deepest_rooted_layer,
		double	_fact_exp,
		_S	_fFrt_sl,
		unsigned int	nb_layers )

Exponential root distribution applied to an arbitrary array of root fractions.

Exponential root distribution (Exponential root distribution) applied to an arbitrary array of root fractions.

Parameters

_adaption_rate	adaption rate \( a \) [0-1]
_deepest_rooted_layer	number of rooted soil layers \( n_r \)
_fact_exp	\( k \) [m-1]
_fFrt_sl	root fractions to update
nb_layers	size of _fFrt_sl; entries of non-rooted layers are set to 0

{
    ldndc_kassert( cbm::flt_greater_equal( 1.0, _adaption_rate));
 
    double fFrt_sum( 0.0);
    for ( size_t sl = 0;  sl < _deepest_rooted_layer;  ++sl)
    {
        double const fFrt_target( exp(-_fact_exp * sc_.depth_sl[sl]) * sc_.h_sl[sl]);
        _fFrt_sl[sl] -= (_fFrt_sl[sl] - fFrt_target) * _adaption_rate;
        _fFrt_sl[sl] = cbm::bound_min( 0.0, _fFrt_sl[sl]);
        fFrt_sum += _fFrt_sl[sl];
    }
 
    if ( cbm::flt_greater_zero( fFrt_sum))
    {
        for ( size_t sl = 0;  sl < _deepest_rooted_layer;  ++sl)
        {
            _fFrt_sl[sl] /= fFrt_sum;
        }
        for ( size_t sl = _deepest_rooted_layer;  sl < nb_layers;  ++sl)
        {
            _fFrt_sl[sl] = 0.0;
        }
    }
    else
    {
        for ( size_t sl = 0;  sl < nb_layers;  ++sl)
        {
            _fFrt_sl[sl] = 0.0;
        }
    }
}

References sc_.

update_root_fraction_exponential() [2/2]

void ldndc::RootSystemDNDC::update_root_fraction_exponential ( double _adaption_rate, unsigned int _deepest_rooted_layer, double _fact_exp, MoBiLE_Plant * _vt )

virtual

Updates the fine root distribution of a plant with the exponential shape (Exponential root distribution).

Parameters

_adaption_rate	adaption rate \( a \) [0-1]
_deepest_rooted_layer	number of rooted soil layers \( n_r \)
_fact_exp	\( k \) [m-1]
_vt	plant (its fFrt_sl is updated)

Implements ldndc::BaseRootSystemDNDC.

{
    //not needed if parent function is called with MoBiLE_Plant*
    update_root_fraction_exponential( _adaption_rate, _deepest_rooted_layer, _fact_exp, _vt->fFrt_sl, _vt->nb_soillayers());
}

References update_root_fraction_exponential().

Referenced by update_root_fraction_exponential(), and update_roots_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

update_root_fraction_sigmoid() [1/2]

template<class _S>

void ldndc::RootSystemDNDC::update_root_fraction_sigmoid	(	double	_adaption_rate,
		unsigned int	_deepest_rooted_layer,
		double	_root_min,
		double	_root_max,
		double	_root_width,
		double	_root_height,
		_S	_fFrt_sl,
		unsigned int	_nb_layers )

Sigmoid root distribution applied to an arbitrary array of root fractions.

Sigmoid root distribution (Sigmoid root distribution) applied to an arbitrary array of root fractions.

Parameters

_adaption_rate	adaption rate \( a \) [0-1]
_deepest_rooted_layer	number of rooted soil layers \( n_r \)
_root_min	\( r_{min} \) [-]
_root_max	\( r_{max} \), depth of maximum root density [cm]
_root_width	\( r_{width} \) [cm2]
_root_height	\( r_{height} \) [-]
_fFrt_sl	root fractions to update
_nb_layers	size of _fFrt_sl; entries of non-rooted layers are set to 0

{
    ldndc_kassert( cbm::flt_greater_equal( 1.0, _adaption_rate));
 
    double fFrt_sum( 0.0);
    for ( size_t sl = 0; sl < _deepest_rooted_layer;  ++sl)
    {
        double const fFrt_target( (exp( -( cbm::sqr( (sc_.depth_sl[sl] * cbm::CM_IN_M) - _root_max) / _root_width))
                                  / _root_height + _root_min)
                                  * sc_.h_sl[sl]);
        _fFrt_sl[sl] -= (_fFrt_sl[sl] - fFrt_target) * _adaption_rate;
        _fFrt_sl[sl] = cbm::bound_min( 0.0, _fFrt_sl[sl]);
        fFrt_sum += _fFrt_sl[sl];
    }
 
    if ( cbm::flt_greater_zero( fFrt_sum))
    {
        for ( size_t sl = 0;  sl < _deepest_rooted_layer;  ++sl)
        {
            _fFrt_sl[sl] /= fFrt_sum;
        }
        for ( size_t sl = _deepest_rooted_layer;  sl < _nb_layers;  ++sl)
        {
            _fFrt_sl[sl] = 0.0;
        }
    }
    else
    {
        for ( size_t sl = 0;  sl < _nb_layers;  ++sl)
        {
            _fFrt_sl[sl] = 0.0;
        }
    }
}

References sc_.

update_root_fraction_sigmoid() [2/2]

void ldndc::RootSystemDNDC::update_root_fraction_sigmoid ( double _adaption_rate, unsigned int _deepest_rooted_layer, double _root_min, double _root_max, double _root_width, double _root_height, MoBiLE_Plant * _vt )

virtual

Updates the fine root distribution of a plant with the sigmoid shape (Sigmoid root distribution).

Parameters

_adaption_rate	adaption rate \( a \) [0-1]
_deepest_rooted_layer	number of rooted soil layers \( n_r \)
_root_min	\( r_{min} \) [-]
_root_max	\( r_{max} \), depth of maximum root density [cm]
_root_width	\( r_{width} \) [cm2]
_root_height	\( r_{height} \) [-]
_vt	plant (its fFrt_sl is updated)

Implements ldndc::BaseRootSystemDNDC.

{
    update_root_fraction_sigmoid( _adaption_rate,
                                  _deepest_rooted_layer,
                                  _root_min,
                                  _root_max,
                                  _root_width,
                                  _root_height,
                                  _vt->fFrt_sl,
                                  _vt->nb_soillayers());
}

References update_root_fraction_sigmoid().

Referenced by update_root_fraction_sigmoid(), and update_roots_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

update_rooting_depth()

void ldndc::RootSystemDNDC::update_rooting_depth ( const double target_rooting_depthincrease, double & growthrestriction, unsigned int & root_q_vt_, MoBiLE_Plant * _p )

virtual

Increases the rooting depth by the restricted target increment (step 4 of the Dynamic root growth model) and updates the number of rooted layers.

Parameters

target_rooting_depthincrease	target increase under optimum conditions [m]
growthrestriction	combined restriction at the root front [0-1]
root_q_vt_	number of rooted soil layers (output)
_p	plant

Implements ldndc::BaseRootSystemDNDC.

{
    _p->rooting_depth = cbm::bound_max( _p->rooting_depth + target_rooting_depthincrease * growthrestriction, (*_p)->ZRTMC());
 
    root_q_vt_ = first_layer_below( _p->rooting_depth);
}

References first_layer_below().

Referenced by update_roots_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

update_rootlength() [1/2]

void ldndc::RootSystemDNDC::update_rootlength ( unsigned int & _sl_below_roots, MoBiLE_Plant * _p, double _delta_dw_frt )

virtual

Root length change for a root mass change of the whole root system, which is distributed over the layers according to the current fractions (see Root length and density).

Must be called before the root mass is changed.

Parameters

_sl_below_roots	number of rooted soil layers
_p	plant
_delta_dw_frt	root mass change of the whole root system [kgDW m-2] (< 0 for losses)

Implements ldndc::BaseRootSystemDNDC.

{
    lvector_t< double > delta_dw_frt_sl( _sl_below_roots, 0.0);
    for ( size_t sl = 0; sl < _sl_below_roots; ++sl)
    {
        delta_dw_frt_sl[sl] = _delta_dw_frt * _p->fFrt_sl[sl];
    }
    update_rootlength( _sl_below_roots, _p, delta_dw_frt_sl);
}

References update_rootlength().

Referenced by reduce_root_system(), reduce_root_system(), and update_rootlength().

Here is the call graph for this function:

Here is the caller graph for this function:

update_rootlength() [2/2]

void ldndc::RootSystemDNDC::update_rootlength ( unsigned int & _sl_below_roots, MoBiLE_Plant * _p, lvector_t< double > _delta_dw_frt_sl )

virtual

Root length change for root mass changes of individual layers (see Root length and density).

Must be called before the root mass is changed. The mean specific root length of each layer is kept and bounded by SRL_MAX with respect to the root mass after the change; no lower bound is applied, since it would undo the SRL reduction of the Dynamic root growth model. Layers with root mass but without root length get \( L_i = SRL_{min} \, m_i \).

Parameters

_sl_below_roots	number of rooted soil layers
_p	plant
_delta_dw_frt_sl	root mass change of every rooted layer [kgDW m-2] (< 0 for losses)

Implements ldndc::BaseRootSystemDNDC.

{
    for ( size_t sl = 0; sl < _sl_below_roots; ++sl)
    {
        double const srl_min( (*_p)->SRL_MAX() * (1.0 - (*_p)->SRL_DECLINE()));
        double const dw_frt_sl( _p->mFrt * _p->fFrt_sl[sl]);
        double const dw_frt_sl_new( cbm::bound_min( 0.0, dw_frt_sl + _delta_dw_frt_sl[sl]));
        if ( cbm::flt_greater_zero( _p->rootlength_sl[sl]) &&
             cbm::flt_greater_zero( dw_frt_sl))
        {
            // determine average SRL in this soil layer
            double const srl_mean( _p->rootlength_sl[sl] / dw_frt_sl);
            _p->rootlength_sl[sl] = cbm::bound( 0.0,
                                                srl_mean * dw_frt_sl_new,
                                                (*_p)->SRL_MAX() * dw_frt_sl_new);
        }
        else
        {
            _p->rootlength_sl[sl] = srl_min * dw_frt_sl_new;
        }
    }
}

update_roots_dynamic()

void ldndc::RootSystemDNDC::update_roots_dynamic ( const double FTS_TOT_, unsigned int & _sl_min_no_roots, MoBiLE_Plant * _p, double _dw_frt_growth )

virtual

Root growth of one time step with the dynamic approach (Dynamic root growth model).

Parameters

FTS_TOT_	length of the time step [d]
_sl_min_no_roots	number of rooted soil layers (updated)
_p	plant; mFrt already includes the new growth
_dw_frt_growth	fine root growth of this time step [kgDW m-2]

Implements ldndc::BaseRootSystemDNDC.

{
    unsigned int sl_min_no_roots_tminusone( _sl_min_no_roots);
 
    // dry weight of fine roots before growth
    // (not considered so far for root length)
    double const dw_frt_tminusone( cbm::bound_min( 0.0, _p->mFrt - _dw_frt_growth));
 
    // dry weight of fine roots that can be redistributed
    double const dw_frt_redistribute( (*_p)->REDISTRIBUTION_ROOT() * FTS_TOT_ * dw_frt_tminusone);
    double const dw_frt_redistribute_and_growth( dw_frt_redistribute + _dw_frt_growth);
 
    // reduce root length by redistributed part (proportionally in all layers, i.e., mean SRL per layer is kept)
    if ( cbm::flt_greater_zero( dw_frt_tminusone))
    {
        double const f_remain( cbm::bound( 0.0, 1.0 - dw_frt_redistribute / dw_frt_tminusone, 1.0));
        for ( size_t sl = 0; sl < sl_min_no_roots_tminusone; ++sl)
        {
            _p->rootlength_sl[sl] *= f_remain;
        }
    }
 
    // root mass in every layer before growth and redistribution
    lvector_t< double > mFrt_sl_tminusone( sl_min_no_roots_tminusone, 0.0);
    for ( size_t sl = 0; sl < sl_min_no_roots_tminusone;  ++sl)
    {
        mFrt_sl_tminusone[sl] = _p->fFrt_sl[sl] * cbm::bound_min( 0.0, _p->mFrt - _dw_frt_growth - dw_frt_redistribute);
    }
 
    // target rooting depth (step 2) and growth restrictions (step 3)
    double delta_rooting_depth_target( 0.0);
    unsigned int sl_min_no_roots_target( 0);
    target_rooting_depth_increase( delta_rooting_depth_target,
                                   sl_min_no_roots_target,
                                   FTS_TOT_,
                                   _p);
 
    unsigned int const sl_restrictions( std::max( sl_min_no_roots_target, sl_min_no_roots_tminusone));
    lvector_t< double > root_res_coarse_fragments_sl = root_restrictions_coarse_fragments( sl_restrictions);
    lvector_t< double > root_res_soil_strength_sl    = root_restrictions_soil_strength( sl_restrictions);
    lvector_t< double > root_res_aeration_sl         = root_restrictions_aeration( sl_restrictions, _p);
    lvector_t< double > root_res_temperature_sl      = root_restrictions_temperature( sl_restrictions, _p);
 
    // actual rooting depth with restriction at the root front (step 4)
    if( cbm::flt_greater_zero( dw_frt_redistribute_and_growth) && (sl_min_no_roots_target > 0))
    {
        unsigned int sl_max_roots( sl_min_no_roots_target-1);
        double root_res_all( std::min( pow( std::min( {root_res_coarse_fragments_sl[sl_max_roots],
                                                       root_res_soil_strength_sl[sl_max_roots],
                                                       root_res_aeration_sl[sl_max_roots]}),
                                            0.5),
                                       root_res_temperature_sl[sl_max_roots]));
 
        update_rooting_depth( delta_rooting_depth_target, root_res_all, _sl_min_no_roots, _p);
        // actual depth never exceeds target depth, i.e., restrictions are available for all rooted layers
        ldndc_kassert( _sl_min_no_roots <= sl_restrictions);
    }
 
    size_t const sl_min_no_roots_common( std::min( {_sl_min_no_roots,
                                                    sl_min_no_roots_tminusone,
                                                    sl_min_no_roots_target}));
    size_t const sl_min_no_roots_max( std::max( {_sl_min_no_roots,
                                                  sl_min_no_roots_tminusone,
                                                  sl_min_no_roots_target}));
 
    // root mass in every layer before new mass is placed
    lvector_t< double > mFrt_sl( _sl_min_no_roots, 0.0);
 
    // initialize with static part of old biomass
    for (size_t sl = 0; sl < sl_min_no_roots_common; ++sl)
    {
        mFrt_sl[sl] = mFrt_sl_tminusone[sl];
    }
 
    if ( cbm::flt_greater_zero( dw_frt_redistribute_and_growth))
    {
        // placement of new root mass (step 5): optimum profile ...
        lvector_t< double > fFrt_opt_sl( _sl_min_no_roots, 0.0);
        if( cbm::flt_equal_zero( (*_p)->EXP_ROOT_DISTRIBUTION()))
        {
            update_root_fraction_sigmoid( 1.0, _sl_min_no_roots, 0.005, 10.0, 200.0, 10.0, fFrt_opt_sl, _sl_min_no_roots);
        }
        else
        {
            update_root_fraction_exponential( 1.0, _sl_min_no_roots, (*_p)->EXP_ROOT_DISTRIBUTION(), fFrt_opt_sl, _sl_min_no_roots);
        }
 
        // ... weighted with the restrictions to target masses ...
        lvector_t< double > fFrt_opt_rest_sl( _sl_min_no_roots, 0.0);
        lvector_t< double > mFrt_opt_rest_sl( _sl_min_no_roots, 0.0);
        double normalize_opt_rest( 0.0);
        for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
        {
            double root_res_all( std::min( pow( std::min( {root_res_coarse_fragments_sl[sl],
                                                           root_res_soil_strength_sl[sl],
                                                           root_res_aeration_sl[sl]}),
                                                0.5),
                                           root_res_temperature_sl[sl]));
            fFrt_opt_rest_sl[sl] = root_res_all * fFrt_opt_sl[sl];
            normalize_opt_rest += fFrt_opt_rest_sl[sl];
        }
 
        if ( cbm::flt_greater_zero( normalize_opt_rest))
        {
            for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
            {
                mFrt_opt_rest_sl[sl] = fFrt_opt_rest_sl[sl] / normalize_opt_rest * _p->mFrt; // mass(t=i)
            }
        }
        else
        {
            for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
            {
                mFrt_opt_rest_sl[sl] = fFrt_opt_sl[sl] * _p->mFrt; // mass(t=i)
            }
        }
 
        // ... deficits (negative values set to 0, roots are removed elsewhere) ...
        lvector_t< double > delta_mFrt_pot_sl( _sl_min_no_roots, 0.0);
        double normalize_delta_mFrt_pot( 0.0);
        for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
        {
            delta_mFrt_pot_sl[sl] = cbm::bound_min( 0.0, mFrt_opt_rest_sl[sl] - mFrt_sl[sl]);     // t=i  - t=i-1  overall >0
            normalize_delta_mFrt_pot += delta_mFrt_pot_sl[sl];
        }
        
        // ... and distribution of the new mass proportionally to the deficits
        if( cbm::flt_greater_zero( normalize_delta_mFrt_pot))
        {
            for ( size_t sl = 0;  sl < _sl_min_no_roots; ++sl)
            {
                mFrt_sl[sl] += dw_frt_redistribute_and_growth * delta_mFrt_pot_sl[sl] / normalize_delta_mFrt_pot;         // t=i
            }
        }
        else
        {
            // no potential growth (for instance, fully frozen ground)
            // However, the root mass must currently go somewhere..
            // todo: potentially better to allocate less C to roots
            for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
            {
                mFrt_sl[sl] += dw_frt_redistribute_and_growth * _p->fFrt_sl[sl];
            }
        }
        
        // new root distribution
        double mFrt_normalize( 0.0);
        for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
        {
            mFrt_normalize += mFrt_sl[sl];
        }
        if ( cbm::flt_greater_zero( mFrt_normalize))
        {
            for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
            {
                _p->fFrt_sl[sl] = mFrt_sl[sl] / mFrt_normalize;
            }
            for ( size_t sl = _sl_min_no_roots; sl < _p->nb_soillayers();  ++sl)
            {
                _p->fFrt_sl[sl] = 0.0;
            }
        }
        else if ( _sl_min_no_roots > 0)
        {
            for ( size_t sl = 0;  sl < _sl_min_no_roots;  ++sl)
            {
                _p->fFrt_sl[sl] = 1.0 / double(_sl_min_no_roots);
            }
            for ( size_t sl = _sl_min_no_roots; sl < _p->nb_soillayers();  ++sl)
            {
                _p->fFrt_sl[sl] = 0.0;
            }
        }
        else
        {
            for ( size_t sl = _sl_min_no_roots; sl < _p->nb_soillayers();  ++sl)
            {
                _p->fFrt_sl[sl] = 0.0;
            }
        }
    } // end if deltamass > 0
 
    // root length (step 6): specific root length, reduced by stones and soil strength
    lvector_t< double > specifific_root_length_sl( sl_min_no_roots_max, 0.0);
    specific_root_length( sl_min_no_roots_max, _p, specifific_root_length_sl);
    // use restrictions for SRL
    for( size_t sl = 0; sl < sl_min_no_roots_target; ++sl)
    {
        specifific_root_length_sl[sl] /= (4.0 - 3.0 * std::min( root_res_coarse_fragments_sl[sl],
                                                                root_res_soil_strength_sl[sl]));
    }
    
    // root length in every soil layer
    for ( size_t sl = 0; sl < sl_min_no_roots_common; ++sl)
    {
        double const deltamass_sl( mFrt_sl[sl] - mFrt_sl_tminusone[sl]);
        if ( cbm::flt_greater_equal_zero( deltamass_sl))
        {
            _p->rootlength_sl[sl] = cbm::bound_max( _p->rootlength_sl[sl] + specifific_root_length_sl[sl] * deltamass_sl,
                                                    (*_p)->SRL_MAX() * mFrt_sl[sl]);
        }
        else if ( cbm::flt_greater_zero( mFrt_sl_tminusone[sl]))
        {
            double const srl_min( (*_p)->SRL_MAX() * (1.0 - (*_p)->SRL_DECLINE()));
            double const srl_mean( _p->rootlength_sl[sl] / mFrt_sl_tminusone[sl]);
            _p->rootlength_sl[sl] = cbm::bound_min( srl_min * mFrt_sl[sl],
                                                    _p->rootlength_sl[sl] + srl_mean * deltamass_sl);
        }
        else
        {
            _p->rootlength_sl[sl] = specifific_root_length_sl[sl] * mFrt_sl[sl];
        }
    }
 
    for ( size_t sl = sl_min_no_roots_common; sl < _sl_min_no_roots; ++sl)
    {
        if ( cbm::flt_greater_zero( mFrt_sl[sl]))
        {
            _p->rootlength_sl[sl] = cbm::bound_max( _p->rootlength_sl[sl] + specifific_root_length_sl[sl] * mFrt_sl[sl],
                                                    (*_p)->SRL_MAX() * mFrt_sl[sl]);
        }
        else
        {
            _p->rootlength_sl[sl] = 0.0;
        }
    }
 
    for ( size_t sl = _sl_min_no_roots; sl < m_soillayers->soil_layer_cnt(); ++sl)
    {
        _p->rootlength_sl[sl] = 0.0;
    }
}

References m_soillayers, root_restrictions_aeration(), root_restrictions_coarse_fragments(), root_restrictions_soil_strength(), root_restrictions_temperature(), specific_root_length(), target_rooting_depth_increase(), update_root_fraction_exponential(), update_root_fraction_sigmoid(), and update_rooting_depth().

Here is the call graph for this function:

update_roots_static()

void ldndc::RootSystemDNDC::update_roots_static ( const double FTS_TOT_, unsigned int & root_q_vt_, MoBiLE_Plant * _vt, ldndc::growable_array< BaseRootSystemDNDC *, 1000, 1 > & root_system, double rootgrowthrestriction )

virtual

Root growth of one time step with the static approach (Static root growth model).

Parameters

FTS_TOT_	length of the time step [d]
root_q_vt_	number of rooted soil layers (updated)
_vt	plant
root_system	root systems of all plants (indexed by plant slot)
rootgrowthrestriction	factor reducing root extension [0-1]

Implements ldndc::BaseRootSystemDNDC.

{
    if (cbm::flt_less(_vt->rooting_depth, (*_vt)->ZRTMC()))
    {
        _vt->rooting_depth += rootgrowthrestriction * (*_vt)->FRT_DGR_MAX() * FTS_TOT_;
    }
 
    //update rooted layers
    root_q_vt_ = m_soillayers->soil_layer_cnt();
    for (size_t sl = 0; sl < m_soillayers->soil_layer_cnt(); ++sl)
    {
        if (cbm::flt_greater(sc_.depth_sl[sl], _vt->rooting_depth))
        {
            /* The layer depths are not necessarily commensurate with FRT_DGR_MAX. So the current layer probably still holds roots.
             * For the first non-rooted layer the index needs to be shifted. */
            root_q_vt_ = (sl + 1);
            break;
        }
    }
 
    //root distribution
    if( cbm::flt_equal_zero( (*_vt)->EXP_ROOT_DISTRIBUTION()))
    {
        root_system[_vt->slot]->update_root_fraction_sigmoid( 1.0, root_q_vt_, 0.005, 10.0, 200.0, 10.0, _vt);
    }
    else
    {
        root_system[_vt->slot]->update_root_fraction_exponential( 1.0, root_q_vt_, (*_vt)->EXP_ROOT_DISTRIBUTION(), _vt);
    }
 
    // specific root length of every rooted layer
    lvector_t< double > specifific_root_length_sl(root_q_vt_, 99.0);
    specific_root_length( root_q_vt_, _vt, specifific_root_length_sl);
 
    // root length in every rooted layer
    for (size_t sl = 0; sl <= root_q_vt_ - 1; ++sl)
    {
        //~ _vt->rootlength_sl[sl] = specifific_root_length_sl[sl] * _vt->fFrt_sl[sl] * (deltamassFrt + _vt->mFrt);
        _vt->rootlength_sl[sl] = specifific_root_length_sl[sl] * _vt->fFrt_sl[sl] * _vt->mFrt;
    }
}

References m_soillayers, sc_, and specific_root_length().

Here is the call graph for this function: