Vegetation model GrowthPSIM. More...

#include <models/physiology/psim/psim.h>

Public Attributes
cbm::string_t	branchfraction_opt
	...

cbm::string_t	crownlength_opt
	...

bool	competition_opt
	...

cbm::string_t	timemode_opt
	...

int	stand_structure_opt
	...

Static Public Attributes
static const unsigned int	IMAX_W = 24

static const double	C1 = 0.0367

static const double	CCOMNOX = 1.0

static const double	CSATNH3 = 50.0

static const double	CSATNOX = 5.0

static const double	EPOTNOX = 1.0

static const double	FRFRT = 0.5

static const double	FMIN = 0.05

static const double	KMMM = 0.0

static const double	PAMM = 0.17

static const double	PGDD = 0.0075

static const double	PMIN = 0.06

static const double	PNIT = 0.34

static const double	PPHLOE = 0.06

static const double	PREDFRT = 1.72

static const double	PREDSAP = 0.855

static const double	PTW = 0.29

static const double	TAU = 330.0

static const double	TGLIM = 6.0

static const double	TRMAX = 45.0

static const double	TRMIN = -7.0

static const double	TROPT = 20.0

static const double	UPOTNH3 = 10000.0

Protected Member Functions
lerr_t	PSIM_ResizeVegetationVectors ()

lerr_t	PSIM_StepInit ()

lerr_t	PSIM_PlantingEvent ()

lerr_t	PSIM_HydraulicConductance ()

lerr_t	PSIM_Photosynthesis ()

lerr_t	PSIM_Potentialtranspiration ()

lerr_t	PSIM_AgriculturalManagement ()

lerr_t	PSIM_BiomassUpdate ()
	Biomass growth according to allocation gains in different plant compartments.

lerr_t	PSIM_PhotosynthesisRates ()

Private Attributes
std::map< int, RootSystemDNDC >	root_system
	Root system.

Detailed Description

Vegetation model GrowthPSIM.

Author: Ruediger Grote

Member Function Documentation

◆ PSIM_AgriculturalManagement()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_AgriculturalManagement ( )

protected

PSIM considers:

grazing (for grasses)
cutting (for grasses) (for other management options on trees, see ref@ ld_treeDyn:treedyn_events)

{
    m_eventgraze.update_available_freshfood_c( m_veg, species_groups_select_t< species::grass >());
 
    for ( PlantIterator vt = m_veg->begin(); vt != m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        if ( p->group() == "grass")
        {
            lerr_t rc_graze = m_eventgraze.event_graze_physiology( *vt);
            if ( (rc_graze != LDNDC_ERR_EVENT_MATCH) &&
                 (rc_graze != LDNDC_ERR_EVENT_EMPTY_QUEUE))
            {
                LOGERROR("Grazing not successful");
                return rc_graze;
            }
        }
    }
 
    // cutting event by external module
    lerr_t rc_cut = m_eventcut.event_cut_physiology( m_veg, species_groups_select_t< species::grass >());
    if ( (rc_cut != LDNDC_ERR_EVENT_MATCH) &&
         (rc_cut != LDNDC_ERR_EVENT_EMPTY_QUEUE))
    {
        LOGERROR("Cutting not successful");
        return rc_cut;
    }
    else if (rc_cut == LDNDC_ERR_EVENT_MATCH)
    {
        for (PlantIterator vt = m_veg->begin(); vt != m_veg->end(); ++vt)
        {
            MoBiLE_Plant* p = (*vt);
            m_treedyn.OnStructureChange(p);
        }
    }
 
    return LDNDC_ERR_OK;
}

References PSIM_AgriculturalManagement().

Referenced by PSIM_AgriculturalManagement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_BiomassUpdate()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_BiomassUpdate ( )

protected

Biomass growth according to allocation gains in different plant compartments.

{
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
 
        // remembering starting values
        double const fFacOld = p->f_fac;
 
        double const mFolOld = p->mFol;
        double const mBudOld = p->mBud;
        double const mFrtOld = p->mFrt;
        double const mSapOld = p->mSap;
        double const mLivOld = mFolOld + mBudOld + mFrtOld + mSapOld;
 
        // increase of dry matter
        double const groFol = p->dcFol / cbm::CCDM;
        double const groBud = p->dcBud / cbm::CCDM;
        double const groFrt = p->dcFrt / cbm::CCDM;
        double const groSap = p->dcSap / cbm::CCDM;
        double const groSum = groBud + groFrt + groSap;
 
        /* biomass adjustment according to the shift in free available carbon
         * following the basic assumption that free available carbon is proportionally
         * distributed between or taken from the compartments but leaving reserves unchanged.*/
        if ( cbm::flt_greater_zero( mLivOld))
        {
            double const redistribC( p->dcFac / cbm::CCDM);
            p->mFol += (redistribC * mFolOld / mLivOld);
            p->mBud += (redistribC * mBudOld / mLivOld);
            p->mFrt += (redistribC * mFrtOld / mLivOld);
            p->mSap += (redistribC * mSapOld / mLivOld);
        }
 
        // considering growth and loss effects on compartment biomasses
        p->mFol += (groFol - p->sFol + mBudLoss_vt[p->slot]);
        p->mBud += (groBud - p->sBud - mBudLoss_vt[p->slot]);
        p->mFrt += (groFrt - cbm::sum( p->sFrt_sl, sl_.soil_layer_cnt()));
        p->mSap += (groSap - p->sSap);
        p->mCor += (p->sSap - p->sWoodAbove - p->sWoodBelow);
 
        if ( !cbm::flt_greater_zero( p->mFol)) p->mFol = 0.0;
        if ( !cbm::flt_greater_zero( p->mBud)) p->mBud = 0.0;
        if ( !cbm::flt_greater_zero( p->mFrt)) p->mFrt = 0.0;
        if ( !cbm::flt_greater_zero( p->mSap)) p->mSap = 0.0;
 
        // biomass and foliage area in layers
        m_pf.update_foliage_layer_biomass_and_lai((*vt), fl_cnt_, 0.0);
 
        // change foliage biomass in age classes due to growth and senescence
        if ( p->nb_ageclasses() == 1)
        {
            p->mFol_na[0] = p->mFol;
        }
        else
        {
            // allowing foliage mass increase in plants with non-annual growth behaviour
            p->mFol_na[0] += cbm::bound_min( 0.0, groFol + mBudLoss_vt[p->slot] - p->sFol_na[0]);
            for ( size_t  na = 1;  na < p->nb_ageclasses();  ++na)
            {
                p->mFol_na[na] = cbm::bound_min( 0.0, p->mFol_na[na] - p->sFol_na[na]);
            }
        }
 
        // total living biomass after growth (kgDM)
        double const mLivNew( p->mFol + p->mBud + p->mFrt + p->mSap);
        if ( cbm::flt_greater( mLivNew, 0.001))
        {
            // ratio of free available carbohydrates
            double const senSum = cbm::sum( p->sFrt_sl, sl_.soil_layer_cnt()) + p->sSap + p->sFol;
            p->f_fac = (fFacOld * (mLivOld - senSum) * cbm::CCDM + vt->FFACMAX() * groSum * cbm::CCDM + p->dcFac ) / (mLivNew * cbm::CCDM);
 
            if ( !cbm::flt_greater_zero( p->f_fac)) p->f_fac = 0.0;
        }
        else
        {
            p->f_fac = 0.0;
        }
 
        // peak foliage amount
        if ( cbm::flt_greater( p->mFol, p->mFolMax))
        {
            p->mFolMax = p->mFol;
        }
    }
    
    return  LDNDC_ERR_OK;
}

References PSIM_BiomassUpdate().

Referenced by PSIM_BiomassUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_HydraulicConductance()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_HydraulicConductance ( )

protected

Returns: error code

{
    // realized (soil water limited) transpiration (per ground area) in m per time step (should vary per hour) and vegetation type
    accumulated_wateruptake_old = wc_.accumulated_wateruptake_sl.sum();
 
    // transpiration demand given from potential demand derived from different stomata methods
    double transpiration_demand(wc_.accumulated_potentialtranspiration - accumulated_potentialtranspiration_old);
    accumulated_potentialtranspiration_old = wc_.accumulated_potentialtranspiration;
 
    // relative recovery of plant water deficit from the last time step
    double rehydrationindex(0.0);
    if (cbm::flt_greater_zero(plant_waterdeficit_old))
    {
        rehydrationindex = cbm::bound(0.0,
            (plant_waterdeficit_old - wc_.plant_waterdeficit) / plant_waterdeficit_old,
            1.0);
    }
    plant_waterdeficit_old = wc_.plant_waterdeficit;
 
    // number of hours per day
    double const daylength_hours(meteo::daylength(m_setup->latitude(), this->lclock()->yearday()));
 
    // day/night transitions
    bool const is_night( cbm::flt_equal_zero( mc_.shortwaveradiation_in));
    bool const after_daytime( is_night && daytime);
    bool const after_nighttime( !is_night && !daytime);
    daytime = !is_night;
 
    // setting soil to root hydraulic conductance equal to soil conductance
    double const lai_sum(m_veg->lai());
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant* p = *vt;
 
        // length of timestep [s]
        double const tslength = double(cbm::SEC_IN_HR) * double(cbm::HR_IN_DAY) / double(this->lclock_ref().time_resolution());
 
        // transform transpiration units from m timestep-1 to mol m-2leaf s-1 and relate it to daylength
        // TODO: find a better way to differentiate transpiration into vegetation classes
        double transp_mol(0.0);
        double const dayl(meteo::daylength(m_setup->latitude(), this->lclock()->yearday()));
        if ( cbm::flt_greater_zero( lai_sum))
        {
            double transp_vt = transpiration_demand * p->lai() / lai_sum;
            if (cbm::flt_greater_zero( dayl))
            {
                transp_mol = transp_vt * cbm::MM_IN_M * cbm::G_IN_KG / (tslength * cbm::MH2O * p->lai())
                             / (dayl / cbm::HR_IN_DAY);
            }
        }
 
        // soil layer water potential at which roots get detached (in MPa, positive units)
        double psi_detach(m_sipar->CP_WP() * cbm::MPA_IN_MH2O); // 150 mWS (1.5 MPa) is the predefined value for the water content at wilting point        
   
        // plant (root) hydraulic conductance calculated from soil water potential, weighted by fine root abundance
        double const SCALE_WP(1.2);
        p->psi_sr = 0.0;
        for (size_t sl = 0; sl < sl_.soil_layer_cnt(); ++sl)
        {
            double const wc( cbm::bound( 1.001 * wc_.wc_res_sl[sl],
                                         wc_.wc_sl[sl],
                                         0.999 * wc_.wc_sat_sl[sl]));
 
            // soil layer water potential (in MPa, positive units)
            double const psi_sl( ldndc::capillary_pressure( wc, wc_.vga_sl[sl], wc_.vgn_sl[sl], wc_.vgm_sl[sl],
                                                            wc_.wc_sat_sl[sl], wc_.wc_res_sl[sl] ) * cbm::MPA_IN_MH2O );
 
            // soil to root water potential (MPa) weighted by fine root abundance
            p->psi_sr += ( std::min(SCALE_WP * m_sipar->CP_WP() * cbm::MPA_IN_MH2O, psi_sl) * p->fFrt_sl[sl] );
        }
 
        p->psi_sr *= -1.0;
        psi_detach *= -1.0;
 
        // plant water potential calculated considering previous declines (without gravitational impact)
        double psi_vt(std::max(p->psi_sr, psi_detach) + psidecline_cum_vt[p->slot]);
 
        // canopy water potential
        // (calculated in a lumped fashion, alternatively define psi for each canopy layer separately)
        // - average canopy height
        double h_weighted(0.0);    // [m]
        double height_cum(0.0);    // [m]
        for (size_t fl = 0; fl < p->nb_foliagelayers(); ++fl)
        {
            height_cum += 0.5 * ph_.h_fl[fl];
            h_weighted += height_cum * p->fFol_fl[fl];
            height_cum += 0.5 * ph_.h_fl[fl];
        }
 
        // - increase of water potential due to vertical transport (gravitational impact)
        double const dpsi = h_weighted * cbm::MPA_IN_KPA * cbm::KPA_IN_PA * cbm::DWAT * cbm::DM3_IN_M3 * cbm::G;
 
        // decrease and recovery of plant water potential
        int night(1);  // 1=false, 0=true
        // - state determination after daytime 
        if ( is_night)
        {
            // in the night, the multiplier for psi that accounts for increasing tension is set to zero
            night = 0;
 
            if ( after_daytime)
            {
                // weighting by leaf/wood ratio as proxy for capacitance change
                // NOTE1: assuming that the degree of capacitance deficit (if it occurs) is the same in all compartments
                // NOTE2: doesn't consider a possible capacitance change with relative water content
                double const qcapacitance = (p->mFol + p->f_branch * p->mSap) / (p->mFol + p->mSap + p->mFrt); // assuming that transpiration affects primarily the crown tissue relation to all living tissue
//                double const qcapacitance = p->mFol / (p->mFol + p->mSap + p->mFrt);                         // assuming that transpiration only affects foliage tissue in relation to all living tissue
//                double const qcapacitance = p->mFol / (p->mFol + p->mSap + p->mCor + p->mFrt);               // assuming that transpiration only affects foliage tissue in relation to all tissues including core wood
//                double const qcapacitance = 1.0;                                                             // assuming that only transpiration affects tree water potential
//                double const qcapacitanc = p->mFol / (p->mFol + p->mSap * (*vt)->wc_rel + p->mFrt);          // assuming that transpiration only affects foliage tissue in relation to all living tissues reduced by water content
 
                // recovery of cumulative plant water potential
                // - due to rehysdration if stem water potential is considered (assumes that relative rehydration and plant water potential recovers in parallel)
                if (wc_.transpiration_method == substate_watercycle_t::TREEWATERDEFICIT)
                {
                    psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - rehydrationindex_cum_vt[p->slot]));     
                }
                // - buffered by capacitance (assumes that the recovery is slowed down according to the relation between affected and total tissue)
                else
                {
                    psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - qcapacitance));
                }
 
                // in case of root detachment (soil water potential below wilting point) plant water potential decline is accumulated
                if (cbm::flt_greater_equal(psi_detach, p->psi_sr))
                {
                    psidecline_cum_vt[p->slot] += std::min(0.0, (psidecline_daycum_vt[p->slot] / daylength_hours) * qcapacitance);
                }
 
                // reset of the cumulative rehydration index 
                rehydrationindex_cum_vt[p->slot] = 0.0;
 
                // reset the cumulative water potential deficit
                psidecline_daycum_vt[p->slot] = 0.0;
            }
        }
        // - state determination during daytime
        else
        {
            // calculations directly after nighttime
            if ( after_nighttime)
            {
                // predawn canopy water potential
                p->psi_pd = psi_vt - dpsi;
 
                // predawn (minimum) tree water deficit = maximum diurnal radius
                (*vt)->twd_pd_vt = (*vt)->stem_shrinkage;
                (*vt)->twd_max_vt = 0.0;
            }
 
            // minimum shrinkage (maximum tree water deficit) during the day
            if ((*vt)->stem_shrinkage > (*vt)->twd_max_vt)
            {
                (*vt)->twd_max_vt = (*vt)->stem_shrinkage;
            }
        }
 
        // relative xylem conductivity based on current plant water potential
        double krc_rel_vt = 1.0 - (1.0 - std::exp(-std::pow(psi_vt / vt->PSI_REF(), vt->PSI_EXP())));
        krc_rel_vt = std::max(0.001, krc_rel_vt);
 
        // canopy hydraulic potential in MPa (negative) due to water loss (only at daytime) considering height induced gradient
        p->psi_cr = psi_vt;
        if (cbm::flt_greater_zero(krc_rel_vt))
        {
            p->psi_cr = psi_vt - (transp_mol * double(night) / (vt->CWP_REF() * krc_rel_vt)) - dpsi;  // CWP_REF is the conductance of the whole pathlength
        }
 
        // mean canopy water potential (not important, but smoothing between timesteps)
        p->psi_mean = (p->psi_pd + p->psi_cr) * 0.5;
 
        // drop in plant water potential (!) due to evaporative demand cumulated over the day
        psidecline_daycum_vt[p->slot] += std::min(0.0, (p->psi_cr + dpsi - psi_vt));
 
        // daily cumulative reduction of drop in water potential after refilling (rehydration_index is in fraction per hour, needed in fraction per day)
        rehydrationindex_cum_vt[p->slot] += rehydrationindex;
        rehydrationindex_cum_vt[p->slot] = cbm::bound(0.0, rehydrationindex_cum_vt[p->slot], 1.0);
 
        // overall root-to-canopy (plant hydraulic) conductance considering current day demands (in mol MPa-1 s-1 m-2)
        double k_rc_rel_mean = 1.0 - (1.0 - std::exp(-std::pow(p->psi_mean / vt->PSI_REF(), vt->PSI_EXP())));
        k_rc_rel_mean = std::max(0.001, k_rc_rel_mean);
 
        // whole plant resistances (in MPa s m2 mol-1)
        // NOTE: resistance is reversible and is not affected by xylem senescence (e.g. embolism)
        // Possible solutions to increase k_rc_rel_mean accordingly are suggested
        p->xylem_resistance = vt->RPMIN(); // 1/RPMIN is the conductance in the crown area 
        if (cbm::flt_greater_zero(k_rc_rel_mean))
        {
            p->xylem_resistance /= k_rc_rel_mean;
 
            // option to increase resistance proportionally to sapwood area loss considering increases in conductive efficiency
//            p->xylem_resistance /= (k_rc_rel_mean / std::max(0.1, std::min(1.0, qsaparea_vt[p->slot] * (1.0 + vt->FOLRELGROMAX()))) );
 
            // (PIA) option to increase resistance dispropotionally
//            p->xylem_resistance /= (k_rc_rel_mean * sqrt(std::max(0.1, qsaparea_vt[p->slot])));
        }
 
    } // vegetation type loop end
 
    return LDNDC_ERR_OK;
}

References PSIM_HydraulicConductance().

Referenced by PSIM_HydraulicConductance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_Photosynthesis()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_Photosynthesis ( )

protected

Returns: error code

{
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
 
        for (size_t fl = 0; fl < p->nb_foliagelayers(); ++fl)
        {
            m_photo.vpd_fl[fl] = mc_.vpd_fl[fl];
            m_photo.rh_fl[fl] = cl_.rel_humidity_subday( lclock_ref());
            m_photo.temp_fl[fl] = mc_.temp_fl[fl];
            m_photo.parsun_fl[fl] = mc_.parsun_fl[fl];
            m_photo.parshd_fl[fl] = mc_.parshd_fl[fl];
            m_photo.tFol_fl[fl] = mc_.tFol_fl[fl];
            m_photo.co2_concentration_fl[fl] = ac_.ts_co2_concentration_fl[fl];
            m_photo.sunlitfoliagefraction_fl[fl] = mc_.ts_sunlitfoliagefraction_fl[fl];
        }
        m_photo.nd_airpressure = mc_.nd_airpressure;
        
        m_photo.set_vegetation_base_state( p);
 
        m_photo.set_vegetation_non_stomatal_water_limitation_state( p->xylem_resistance, p->psi_mean, p->psi_sr, p->psi_pd);
        
        m_photo.solve();
        
        m_photo.get_vegetation_state( p);
    }
 
    return LDNDC_ERR_OK;
}

References PSIM_Photosynthesis().

Referenced by PSIM_Photosynthesis().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_PhotosynthesisRates()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_PhotosynthesisRates ( )

protected

Nitrogen concentration is related to specific leaf area but declines generally not linear. Therefore, an exponential relationship with a parameter of 0.3 is used, fitted to various canopy gradient studies (e.g. Meir et al. 2002, Al Afas et al. 2007, Ellsworth and Reich 1993) (parameter should be consistent with the one used in m_pf.optimum_nitrogen_content_foliage())

{
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
 
        // phenological state
        bool const evergreen( (p->nb_ageclasses() > 1) && cbm::flt_greater_zero( p->mFol));
        double const pstatus( evergreen ?
                     (p->dvsFlush * p->mFol_na[0] + (1.0 - p->dvsMort) * (cbm::sum( p->mFol_na, p->nb_ageclasses()) - p->mFol_na[0])) / p->mFol :
                     std::min( p->dvsFlush, 1.0 - p->dvsMort));
 
        // drought stress impact
        // NOTE: consideration of water potential effects is only warranted if the whole hydraulic model is used
        double fwat(1.0);
        if (m_photo.stomatalconductance_method == eller_2020 && p->dvsFlush > 0.99)
        {
            fwat = ldndc::non_stomatal_water_limitation( p->psi_pd, (*p)->A_REF(), (*p)->A_EXP() );
        }
 
        // - in case drought stress decreases, its decrease is limited by recovery rate (legacy effect)
        const double RECOVER(0.01); // fraction recovery per hour 
        if (fwat > p->fwatOld)
        {
            double const tslength = double(cbm::HR_IN_DAY) / double(this->lclock_ref().time_resolution());
            fwat = std::min(fwat, p->fwatOld + RECOVER * tslength);
        }
        p->fwatOld = fwat;
 
        // enzyme activity
        // (activity of isoprene and monoterpene enzymes are unchanged during the dormant season)
        double nFolOpt(m_pf.optimum_nitrogen_content_foliage(p));
        double const ncFol_top = (p->mFol * p->ncFol / nFolOpt) * vt->NCFOLOPT();
 
        if ( cbm::flt_greater_zero( pstatus))
        {
            for ( size_t  fl = 0;  fl < fl_cnt_;  ++fl)
            {
                if ( cbm::flt_greater_zero( p->m_fol_fl(fl)) &&
                     cbm::flt_greater_zero( p->sla_fl[fl]))
                {
                    // nitrogen supply in dependence on specific leaf area
                    double const ncFol_fl( ncFol_top * pow( vt->SLAMIN() / p->sla_fl[fl], 0.3));
 
                    // dependency of photosynthesis linearly related to nitrogen (Reynolds et al. 1992)
                    double const fnit( cbm::bound( 0.0, (ncFol_fl - vt->NC_FOLIAGE_MIN()) / (vt->NCFOLOPT() - vt->NC_FOLIAGE_MIN()), 1.0));
 
                    // seasonality factor
                    double  fdorm(0.0);
                    // - deciduous
                    if (p->nb_ageclasses() == 1)
                    {
                        if ( p->dvsFlush < 1.0)
                        {
                            fdorm = cbm::sqr( p->dvsFlush);
                        }
                        else
                        {
                            fdorm = 1.0 - cbm::sqr( p->dvsMort);
                        }
                    }
                    // - evergreen
                    else
                    {
                        // - equal to the relative pool size of free available carbon reserves (fsub_vt)*/
                        fdorm = fsub_vt[p->slot];
 
                        // - temperature dependent according to Maekelae et al. 2004 (S model)
/*                      if ((mc_.tFol24_fl[fl] + cbm::HR_IN_DAY / TAU * (mc_.nd_temp_fl[fl] - mc_.tFol24_fl[fl])) >= vt->PSNTFROST())
                        {
//                            fdorm = C1 * (mc_.tFol24_fl[fl] + cbm::HR_IN_DAY / TAU * ( mc_.nd_temp_fl[fl] - mc_.tFol24_fl[fl]) - vt->PSNTFROST());
//                            fdorm = 1.0;
                        }
                        else
                        {
                            fdorm = 0.0;
                        }
*/
                    }
 
                    fdorm = cbm::bound( 0.0, fdorm, 1.0);
 
                    double ftemp(1.0);
                    // temperature acclimation of photosynthesis (Gan et al. 2026)
                    // (not quite clear to what growth temperature the standard values of vcmax25 and jmax refer to
                    //  and if the reduction of the ratio should decrease jmax, increase vcmax or both)
                    // double const PARAMETER(-0.5); // theoretical assumptions (refers qjvc decline to temperature with a slope of 0.034)
                    // mc_tFol15d = growth temperature (15 day average of air or leaf temperature)
                    // ftemp = mc_tFol15d * PARAMETER / 25.0 - PARAMETER;
 
                    // activity of rubisco under standard conditions
                    p->vcAct25_fl[fl] = vt->VCMAX25() * fnit * fdorm * fwat;
                    // activity of maximum electron transport rate under standard conditions
                    p->jAct25_fl[fl]  = p->vcAct25_fl[fl] * vt->QJVC() * ftemp; 
                    // activity of dark respiration under standard conditions
                    p->rdAct25_fl[fl] = p->vcAct25_fl[fl] * vt->QRD25();
                }
                else
                {
                    p->vcAct25_fl[fl] = 0.0;
                    p->jAct25_fl[fl]  = 0.0;
                    p->rdAct25_fl[fl] = 0.0;
                }
            }
        }
        else
        {
            for ( size_t  fl = 0;  fl < fl_cnt_;  ++fl)
            {
                p->vcAct25_fl[fl] = 0.0;
                p->jAct25_fl[fl] = 0.0;
                p->rdAct25_fl[fl] = 0.0;
            }
        }
    }
    
    return  LDNDC_ERR_OK;
}

References ldndc::non_stomatal_water_limitation(), and PSIM_PhotosynthesisRates().

Referenced by PSIM_PhotosynthesisRates().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_PlantingEvent()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_PlantingEvent ( )

protected

Returns: error code

{
    std::vector< std::pair< MoBiLE_Plant *, species::wood_properties_t const * > >  trees_planted;
 
    EventAttributes const *  ev_plant = NULL;
    while ( (ev_plant = m_PlantEvents.pop()) != NULL)
    {
        MoBiLE_Plant *vt = m_veg->get_plant( ev_plant->get( "/name", "?"));
        if ( !vt)
        {
            KLOGERROR( "Handling plant event failed  [species=", ev_plant->get( "/name", "?"),"]");
            return LDNDC_ERR_RUNTIME_ERROR;
        }
 
        species_t const *  sp = NULL;
        if ( m_species)
        {
            sp = m_species->get_species( vt->cname());
        }
 
        root_system.insert( { vt->slot, RootSystemDNDC( m_state, io_kcomm) } );
 
        lerr_t rc_plant = LDNDC_ERR_OK;
        char const *  group = ev_plant->get( "/group", "?");
        if ( cbm::is_equal( group, "wood"))
        {
            rc_plant = m_pf.initialize_tree( vt, sp->wood(), /*branchfraction_opt,*/ crownlength_opt, competition_opt);
            if ( rc_plant)
            {
                KLOGERROR( "Plant initialization failed  [species=", vt->name(),"]");
                return  LDNDC_ERR_FAIL;
            }
            
            //trees_planted.push_back( std::make_pair( vt, sp->wood()));
        }
        else if ( cbm::is_equal( group, "grass"))
        {
            rc_plant = m_pf.initialize_grass( vt, sp->grass());
        }
        else if ( cbm::is_equal( group, "crop"))
        {
            rc_plant = m_pf.initialize_crop( vt, sp->crop());
        }
        if ( rc_plant)
        {
            KLOGERROR( "Plant initialization failed  [species=", vt->name(),"]");
            return  LDNDC_ERR_FAIL;
        }
 
        // initialize local state variables after planting
        if ( vt->dEmerg > 0)
        {
            if ( (int)lclock()->yearday() > vt->dEmerg)
            {
                days_since_emergence[vt->slot] = (int)(lclock()->yearday()) - vt->dEmerg;
            }
            else
            {
                // use 366 on purpose to ensure always: days_since_emergence > 0
                days_since_emergence[vt->slot] = (int)(lclock()->yearday()) + (366 - vt->dEmerg);
            }
        }
        else
        {
            days_since_emergence[vt->slot] = 0;
        }
 
        if ( lclock()->yearday() >= PSIM_YEAR_START)
        {
            phenological_year[vt->slot] = lclock()->year();
        }
        else
        {
            phenological_year[vt->slot] = lclock()->year() - 1;
        }
 
        foliage_age_of_start_senescence[vt->slot] = m_pf.get_foliage_age_of_senescence( vt, 0.0);
 
        for ( size_t  na = 0;  na < vt->nb_ageclasses();  ++na)
        {
            foliage_age_na[vt->slot][na] = m_pf.get_foliage_age( PSIM_YEAR_START, lclock()->yearday(), na);
        }
    }
 
 
    /* each tree was initialized without knowing the trees planted after it:
     * repeat so that all see each other (shared crown cover, competition) */
    if ( trees_planted.size() > 1)
    {
        for (size_t t = 0; t < trees_planted.size(); ++t)
        {
            lerr_t rc_plant = m_pf.initialize_tree(trees_planted[t].first, trees_planted[t].second,
                /*branchfraction_opt,*/ crownlength_opt, competition_opt);
            if (rc_plant)
            {
                KLOGERROR("Plant initialization failed  [species=", trees_planted[t].first->name(), "]");
                return  LDNDC_ERR_FAIL;
            }
        }
    }
 
    return LDNDC_ERR_OK;
}

References competition_opt, crownlength_opt, PSIM_PlantingEvent(), and root_system.

Referenced by PSIM_PlantingEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_Potentialtranspiration()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_Potentialtranspiration ( )

protected

Returns: error code

{
    double potential_transpiration_sum( 0.0);
 
    for ( PlantIterator vt = m_veg->begin(); vt != m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p( *vt);
 
        double potential_transpiration_vt( 0.0);
        if (vt->IS_WOOD())
        {
            if ( wc_.transpiration_method == substate_watercycle_t::WATERUSEEFFICIENCY)
            {
                potential_transpiration_vt += potential_transpiration_soil_atmosphere_limited(
                                                                      sl_,
                                                                      mc_.nd_watervaporsaturationdeficit,
                                                                      ph_.carbonuptake(m_veg, fl_cnt_),
                                                                      p->f_area,
                                                                      vt->WUECMAX(),
                                                                      vt->WUECMIN(),
                                                                      sc_.h_sl,
                                                                      wc_.wc_sl,
                                                                      wc_.wc_wp_sl,
                                                                      wc_.wc_fc_sl);
            }
            else  // transpiration_method == "treewaterdeficit", "potentialtranspiration"
            {
                potential_transpiration_vt += potential_transpiration_stomatal_conductance_limited(
                                                                      p->nb_foliagelayers(),
                                                                      vt->GSMIN(),
                                                                      vt->GSMAX(),
                                                                      p->lai_fl,
                                                                      mc_.vpd_fl,
                                                                      p->relativeconductance_fl) * cbm::HR_IN_DAY * lclock()->day_fraction();
            }
        }
        else
        {
            potential_transpiration_vt += potential_transpiration_unlimited(
                                                                      ac_.nd_co2_concentration,
                                                                      ph_.carbonuptake( m_veg, fl_cnt_),
                                                                      vt->WUECMAX());
        }
 
        p->f_ptransp = potential_transpiration_vt;
        potential_transpiration_sum += potential_transpiration_vt;
        wc_.accumulated_potentialtranspiration += potential_transpiration_vt;
    }
 
    for ( PlantIterator vt = m_veg->begin(); vt != m_veg->end(); ++vt)
    {
        MoBiLE_Plant* p( *vt);
        if (cbm::flt_greater_zero( potential_transpiration_sum))
        {
            p->f_ptransp /= potential_transpiration_sum;
        }
        else
        {
            p->f_ptransp = 0.0;
        }
    }
 
    return  LDNDC_ERR_OK;
}

References ldndc::potential_transpiration_soil_atmosphere_limited(), ldndc::potential_transpiration_stomatal_conductance_limited(), ldndc::potential_transpiration_unlimited(), and PSIM_Potentialtranspiration().

Referenced by PSIM_Potentialtranspiration().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_ResizeVegetationVectors()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_ResizeVegetationVectors ( )

protected

Returns: error code

{
    // compare number of vegetation types
    size_t const slot_cnt( m_veg->slot_cnt());
    size_t const slot_cnt_old( additional_season.size());
    
    if ( slot_cnt <= slot_cnt_old)
    {
        return LDNDC_ERR_OK;
    }
 
    additional_season.resize_and_preserve( slot_cnt, false);
    phenological_year.resize_and_preserve( slot_cnt, 0);
    foliage_age_of_start_senescence.resize_and_preserve( slot_cnt, 0);
    days_since_emergence.resize_and_preserve( slot_cnt, 0);
 
    // average (effective) temperatures of all leaves of a vegetation type
    ts_leaftemp_vt.resize_and_preserve( slot_cnt, 0.0);
    nd_leaftemp_vt.resize_and_preserve( slot_cnt, 0.0);
 
    uptNH4Max_vt.resize_and_preserve( slot_cnt, 0.0);    // max. ammonium uptake
    uptNO3Max_vt.resize_and_preserve( slot_cnt, 0.0);    // max. nitrate uptake
    uptDONMax_vt.resize_and_preserve( slot_cnt, 0.0);    // max. dissolved organic nitrogen uptake
    uptNWetMax_vt.resize_and_preserve( slot_cnt, 0.0);   // tot. nitrogen uptake
    uptNWet_vt.resize_and_preserve( slot_cnt, 0.0);      // tot. nitrogen uptake
    uptNTot_vt.resize_and_preserve( slot_cnt, 0.0);      // tot. nitrogen uptake
 
    rFolOld_vt.resize_and_preserve( slot_cnt, 0.0);
    rBudOld_vt.resize_and_preserve( slot_cnt, 0.0);
    rSapOld_vt.resize_and_preserve( slot_cnt, 0.0);
    rFrtOld_vt.resize_and_preserve( slot_cnt, 0.0);
    rTraOld_vt.resize_and_preserve( slot_cnt, 0.0);
    exsuLossOld_vt.resize_and_preserve( slot_cnt, 0.0);
 
    uptNH4_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNO3_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNH3_vt.resize_and_preserve( slot_cnt, 0.0);
    uptDON_vt.resize_and_preserve( slot_cnt, 0.0);
 
    uptNH4Old_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNO3Old_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNH3Old_vt.resize_and_preserve( slot_cnt, 0.0);
    uptDONOld_vt.resize_and_preserve( slot_cnt, 0.0);
 
    uptNOxOld_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNHyOld_vt.resize_and_preserve(slot_cnt, 0.0);
 
    while ( slot_cnt > uptNH4Max_vtsl.size())
    {
        std::vector<double> help_sl( sl_.soil_layer_cnt(), 0.0);
        uptNH4Max_vtsl.push_back( help_sl);
    }
    while ( slot_cnt > uptNO3Max_vtsl.size())
    {
        std::vector<double> help_sl( sl_.soil_layer_cnt(), 0.0);
        uptNO3Max_vtsl.push_back( help_sl);
    }
    while ( slot_cnt > uptDONMax_vtsl.size())
    {
        std::vector<double> help_sl( sl_.soil_layer_cnt(), 0.0);
        uptDONMax_vtsl.push_back( help_sl);
    }
    while ( slot_cnt > foliage_age_na.size())
    {
        std::vector< int > help_sl( MoBiLE_MaximumAgeClasses, 0);
        foliage_age_na.push_back( help_sl);
    }
 
    carbonuptake_vt.resize_and_preserve( slot_cnt, 0.0);
    //xylem_resistance_smoothed_vt.resize_and_preserve(slot_cnt, 0.0);
    xylem_resistance_smoothed_old_vt.resize_and_preserve(slot_cnt, 0.0);
    psidecline_cum_vt.resize_and_preserve(slot_cnt, 0.0);
    psidecline_daycum_vt.resize_and_preserve(slot_cnt, 0.0);
    rehydrationindex_cum_vt.resize_and_preserve(slot_cnt, 0.0);
 
    //do not initialize to zero!
    mSapOpt_vt.resize_and_preserve( slot_cnt, 0.0);
    mSapOld_vt.resize_and_preserve( slot_cnt, 0.0);
    mCorOld_vt.resize_and_preserve( slot_cnt, 0.0);
    qsaparea_vt.resize_and_preserve(slot_cnt, 0.0);
    fsub_vt.resize_and_preserve(slot_cnt, 0.0);
 
    mBudLoss_vt.resize_and_preserve( slot_cnt, 0.0);    // dry matter transfered from buds to foliage
    ncFolOpt.resize_and_preserve( slot_cnt, 0.0);       // optimum nitrogen concentration of the whole foliage of one species (gN gDW-1)
    ncBudOpt.resize_and_preserve( slot_cnt, 0.0);       // optimum nitrogen concentration of the whole structural storage of one species (gN gDW-1)
    nDem_vt.resize_and_preserve( slot_cnt, 0.0);        // species specific nitrogen demand (kgN)
    nFol_vt.resize_and_preserve( slot_cnt, 0.0);        // last days foliage nitrogen content (kg)
    nFrt_vt.resize_and_preserve( slot_cnt, 0.0);        // last days fine root nitrogen content (kg)
    nSap_vt.resize_and_preserve( slot_cnt, 0.0);        // last days sapwood nitrogen content (kg)
    nCor_vt.resize_and_preserve( slot_cnt, 0.0);        // last days corwood nitrogen content (kg)
    nBud_vt.resize_and_preserve( slot_cnt, 0.0);        // last days bud nitrogen content (kg)
 
    n_bud_to_fol_vt.resize_and_preserve( slot_cnt, 0.0);
    n_sap_to_cor_vt.resize_and_preserve( slot_cnt, 0.0);
    n_bud_to_cor_vt.resize_and_preserve( slot_cnt, 0.0);
    n_fol_to_cor_vt.resize_and_preserve( slot_cnt, 0.0);
    n_frt_to_cor_vt.resize_and_preserve( slot_cnt, 0.0);
    n_sap_to_litter_vt.resize_and_preserve( slot_cnt, 0.0);
    n_sap_to_redistribute_vt.resize_and_preserve( slot_cnt, 0.0);
    n_bud_to_redistribute_vt.resize_and_preserve( slot_cnt, 0.0);
    n_fol_to_redistribute_vt.resize_and_preserve( slot_cnt, 0.0);
    n_frt_to_redistribute_vt.resize_and_preserve( slot_cnt, 0.0);
    n_sap_gain_vt.resize_and_preserve( slot_cnt, 0.0);
    n_bud_gain_vt.resize_and_preserve( slot_cnt, 0.0);
    n_fol_gain_vt.resize_and_preserve( slot_cnt, 0.0);
    n_frt_gain_vt.resize_and_preserve( slot_cnt, 0.0);
 
    return  LDNDC_ERR_OK;
}

References PSIM_ResizeVegetationVectors().

Referenced by PSIM_ResizeVegetationVectors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PSIM_StepInit()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_StepInit ( )

protected

Returns: error code

{
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        nh4_sl[sl] = sc_.nh4_sl[sl];
        no3_sl[sl] = sc_.no3_sl[sl] + sc_.an_no3_sl[sl];
        don_sl[sl] = sc_.don_sl[sl];
    }
 
    fl_cnt_ = m_veg->canopy_layers_used();
 
    if ( subdaily_timemode())
    {
        temp_sl.reference( mc_.temp_sl);
        ts_temp_fl.reference( mc_.temp_fl);
 
        no_concentration_fl.reference( ac_.ts_no_concentration_fl);
        no2_concentration_fl.reference( ac_.ts_no2_concentration_fl);
        nh3_concentration_fl.reference( ac_.ts_nh3_concentration_fl);
        nhy_uptake_fl.reference( ph_.ts_nhy_uptake_fl);
        nox_uptake_fl.reference( ph_.ts_nox_uptake_fl);
 
        for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
        {
            MoBiLE_Plant *p = *vt;
            carbonuptake_vt[p->slot] = 0.0;
            for ( size_t  fl = 0;  fl < p->nb_foliagelayers();  ++fl)
            {
                carbonuptake_vt[p->slot] += p->carbonuptake_fl[fl];
            }
        }
 
        // grazing event by external module
        if ( lclock()->subday() == 1)
        {
            m_eventgraze.reset_daily_food_consumption();
        }
    }
    else
    {
        temp_sl.reference( mc_.nd_temp_sl);
        ts_temp_fl.reference( mc_.nd_temp_fl); 
 
        no_concentration_fl.reference( ac_.nd_no_concentration_fl);
        no2_concentration_fl.reference( ac_.nd_no2_concentration_fl);
        nh3_concentration_fl.reference( ac_.nd_nh3_concentration_fl);
        nhy_uptake_fl.reference( ph_.nd_nhy_uptake_fl);
        nox_uptake_fl.reference( ph_.nd_nox_uptake_fl);
 
        for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
        {
            MoBiLE_Plant *p = *vt;
            carbonuptake_vt[p->slot] = 0.0;
            for ( size_t  fl = 0;  fl < p->nb_foliagelayers();  ++fl)
            {
                carbonuptake_vt[p->slot] += p->d_carbonuptake_fl[fl];
            }
        }
 
        m_eventgraze.reset_daily_food_consumption();
    }
 
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
 
        PSIM_Reset( p);
 
        // leaf temperature
        ts_leaftemp_vt[p->slot] = m_pf.leaf_temperature_( ts_temp_fl, p);
        nd_leaftemp_vt[p->slot] = m_pf.leaf_temperature_( mc_.nd_temp_fl, p);
    }
 
    // nitrous oxygen concentration in the air
    for ( size_t  fl = 0;  fl < fl_cnt_;  ++fl)
    {
        cNOx_fl[fl] = no_concentration_fl[fl] + no2_concentration_fl[fl];
    }
 
    return  LDNDC_ERR_OK;
}

References PSIM_StepInit().

Referenced by PSIM_StepInit().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ C1

const double ldndc::PhysiologyGrowthPSIM::C1 = 0.0367

static

second parameter for temperature influence on vcmax activity

◆ CCOMNOX

const double ldndc::PhysiologyGrowthPSIM::CCOMNOX = 1.0

static

compensation NOx concentration without gas exchange [ppb]

◆ CSATNH3

const double ldndc::PhysiologyGrowthPSIM::CSATNH3 = 50.0

static

saturation NH3 concentration [ppb]

◆ CSATNOX

const double ldndc::PhysiologyGrowthPSIM::CSATNOX = 5.0

static

saturation NOx concentration [ppb]

◆ EPOTNOX

const double ldndc::PhysiologyGrowthPSIM::EPOTNOX = 1.0

static

potential specific emission rate of NOx [ppb]

◆ FMIN

const double ldndc::PhysiologyGrowthPSIM::FMIN = 0.05

static

average concentration of minerals others than nitrogen [kg/kgDW]

◆ FRFRT

const double ldndc::PhysiologyGrowthPSIM::FRFRT = 0.5

static

fraction of nitrate that is reduced in the roots

◆ IMAX_W

const int unsigned ldndc::PhysiologyGrowthPSIM::IMAX_W = 24

static

number of iteration steps within a day

◆ KMMM

const double ldndc::PhysiologyGrowthPSIM::KMMM = 0.0

static

Michaelis Menten constant

◆ PAMM

const double ldndc::PhysiologyGrowthPSIM::PAMM = 0.17

static

carbon costs for ammonia uptake

◆ PGDD

const double ldndc::PhysiologyGrowthPSIM::PGDD = 0.0075

static

parameter for GDD relation to temperature related site conditions

◆ PMIN

const double ldndc::PhysiologyGrowthPSIM::PMIN = 0.06

static

carbon costs for minerals

◆ PNIT

const double ldndc::PhysiologyGrowthPSIM::PNIT = 0.34

static

carbon costs for nitrate uptake

◆ PPHLOE

const double ldndc::PhysiologyGrowthPSIM::PPHLOE = 0.06

static

carbon costs for carbon transport from the leafs

◆ PREDFRT

const double ldndc::PhysiologyGrowthPSIM::PREDFRT = 1.72

static

carbon costs for nitrate reduction in the roots

◆ PREDSAP

const double ldndc::PhysiologyGrowthPSIM::PREDSAP = 0.855

static

carbon costs for nitrate reduction in the shoot

◆ PTW

const double ldndc::PhysiologyGrowthPSIM::PTW = 0.29

static

weighting factor for maximum temperature

◆ root_system

std::map< int, RootSystemDNDC > ldndc::PhysiologyGrowthPSIM::root_system

private

Root system.

rooting depth
root distribution

Referenced by PSIM_PlantingEvent().

◆ TAU

const double ldndc::PhysiologyGrowthPSIM::TAU = 330.0

static

first parameter for temperature influence on vcmax activity

◆ TGLIM

const double ldndc::PhysiologyGrowthPSIM::TGLIM = 6.0

static

soil temperature below which no fine root growth occurs (oC)

◆ TRMAX

const double ldndc::PhysiologyGrowthPSIM::TRMAX = 45.0

static

maximum temperature for maintanence respiration

◆ TRMIN

const double ldndc::PhysiologyGrowthPSIM::TRMIN = -7.0

static

minimum temperature for maintanence respiration

◆ TROPT

const double ldndc::PhysiologyGrowthPSIM::TROPT = 20.0

static

temperature for optimum maintanence respiration

◆ UPOTNH3

const double ldndc::PhysiologyGrowthPSIM::UPOTNH3 = 10000.0

static

potential specific uptake rate of NH3 (ppb)

Public Attributes

Static Public Attributes

Protected Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ PSIM_AgriculturalManagement()

◆ PSIM_BiomassUpdate()

◆ PSIM_HydraulicConductance()

◆ PSIM_Photosynthesis()

◆ PSIM_PhotosynthesisRates()

◆ PSIM_PlantingEvent()

◆ PSIM_Potentialtranspiration()

◆ PSIM_ResizeVegetationVectors()

◆ PSIM_StepInit()

Member Data Documentation

◆ C1

◆ CCOMNOX

◆ CSATNH3

◆ CSATNOX

◆ EPOTNOX

◆ FMIN

◆ FRFRT

◆ IMAX_W

◆ KMMM

◆ PAMM

◆ PGDD

◆ PMIN

◆ PNIT

◆ PPHLOE

◆ PREDFRT

◆ PREDSAP

◆ PTW

◆ root_system

◆ TAU

◆ TGLIM

◆ TRMAX

◆ TRMIN

◆ TROPT

◆ UPOTNH3