ldndc::PhysiologyGrowthPSIM Class Reference

Vegetation model GrowthPSIM. More...

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

Inherits ldndc::MBE_LegacyModel.

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_NitrogenFixation ()
	Nitrogen fixation described similar to agricultural routines. Noted under PSIM_NitrogenUptake.
lerr_t	PSIM_BiomassUpdate ()
	Biomass growth according to allocation gains and respiration losses in different plant compartments. More...
lerr_t	PSIM_PhotosynthesisRates ()

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

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

PSIM_BiomassUpdate()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_BiomassUpdate ( )

protected

Biomass growth according to allocation gains and respiration losses 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 - mSapLoss_vt[p->slot]);
        p->mCor += (mSapLoss_vt[p->slot] * (1.0 - p->f_branch));
 
        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()) + mSapLoss_vt[p->slot] + 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;
}

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()));
 
    // 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 (cbm::flt_equal_zero(mc_.shortwaveradiation_in))  // nighttime without radiation (NOTE: problems occur if there is radiation input during night)
        {
            // in the night, the multiplier for psi that accounts for increasing tension is set to zero
            night = 0;
 
            if (daytime == true)
            {
                // 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 rehydration during the previous day
                psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - rehydrationindex_cum_vt[p->slot]));         // assumes that relative rehydration and plant water potential recovers in parallel
//                psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - qcapacitance));                           // assumes that the recovery is slowed down according to the relation between affected and total tissue
 
                // 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;
            }
 
            daytime = false;
        }
        // - state determination during daytime
        else
        {
            // calculations directly after nighttime
            if (daytime == false)
            {
                // 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;
            }
 
            daytime = true;
 
            // 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 would be to increase 
        // a) proportionally to the difference between qsaparea_vt[p->slot] and p->qsfa, or b) to the deficit of sapwood demand (RPMIN / (k_rc_rel * qsaparea_vt[p->slot]) )
        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;
        }
 
    } // vegetation type loop end
 
    return LDNDC_ERR_OK;
}

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

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);
 
                    // 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(); 
                    // 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().

Here is the call graph for this function:

PSIM_PlantingEvent()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_PlantingEvent ( )

protected

Returns

error code

{
    EventAttributes const *  ev_plant = NULL;
    while ( (ev_plant = this->m_PlantEvents.pop()) != NULL)
    {
        MoBiLE_Plant *vt = this->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;
        }
        CBM_LogDebug( "Seed plant '",vt->name(),"'");
 
        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) } );
 
        char const *  group = ev_plant->get( "/group", "?");
        if ( cbm::is_equal( group, "wood"))
        {
            lerr_t 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;
            }
        }
        else if ( cbm::is_equal( group, "grass")) // TODO could be done at "push-time"
        {
            lerr_t rc_plant = m_pf.initialize_grass( vt, sp->grass());
            if ( rc_plant)
            {
                KLOGERROR( "Plant initialization failed  [species=", vt->name(),"]");
                return  LDNDC_ERR_FAIL;
            }
        }
        else if ( cbm::is_equal( group, "crop")) // TODO could be done at "push-time"
        {
            lerr_t 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);
        }
    }
    
    return LDNDC_ERR_OK;
}

PSIM_Potentialtranspiration()

lerr_t ldndc::PhysiologyGrowthPSIM::PSIM_Potentialtranspiration ( )

protected

Returns

error code

{
    double potential_transpiration_vt(0.0);
    double potential_transpiration_sum (0.0);
 
    for ( PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        if (vt->IS_WOOD())
        {
            if ( wc_.transpiration_method == substate_watercycle_t::WATERUSEEFFICIENCY)
            {
                potential_transpiration_vt += potential_wood_transpiration(
                    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(
                    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_crop_transpiration(
                ac_.nd_co2_concentration,
                ph_.carbonuptake( m_veg, fl_cnt_),
                vt->WUECMAX());
        }
 
        potential_transpiration_sum += potential_transpiration_vt;
        wc_.accumulated_potentialtranspiration += potential_transpiration_vt;
    }
 
    for (PlantIterator vt = this->m_veg->begin(); vt != this->m_veg->end(); ++vt)
    {
        MoBiLE_Plant* p = (*vt);
        if (cbm::flt_greater_zero(potential_transpiration_sum))
        {
            p->f_ptransp = potential_transpiration_vt / potential_transpiration_sum;
        }
        else
        {
            p->f_ptransp = 0.0;
        }
    }
    
    return  LDNDC_ERR_OK;
}

References ldndc::potential_crop_transpiration(), ldndc::potential_transpiration(), and ldndc::potential_wood_transpiration().

Here is the call 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;
    }
 
    matrix_2d_dbl_t::extent_type const vtsl[] =
    { static_cast< matrix_2d_dbl_t::extent_type >( slot_cnt),
        static_cast< matrix_2d_dbl_t::extent_type >( sl_.soil_layer_cnt())};
 
    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);
 
    uptN2Old_vt.resize_and_preserve( slot_cnt, 0.0);
    uptNOxOld_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
    mSapLoss_vt.resize_and_preserve( slot_cnt, 0.0);    // dry matter transfered from sapwood to corewood
    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( vtsl, 0.0);
    n_sap_to_cor_vt.resize_and_preserve( vtsl, 0.0);
    n_bud_to_cor_vt.resize_and_preserve( vtsl, 0.0);
    n_fol_to_cor_vt.resize_and_preserve( vtsl, 0.0);
    n_frt_to_cor_vt.resize_and_preserve( vtsl, 0.0);
    n_sap_to_litter_vt.resize_and_preserve( vtsl, 0.0);
    n_sap_to_redistribute_vt.resize_and_preserve( vtsl, 0.0);
    n_bud_to_redistribute_vt.resize_and_preserve( vtsl, 0.0);
    n_fol_to_redistribute_vt.resize_and_preserve( vtsl, 0.0);
    n_frt_to_redistribute_vt.resize_and_preserve( vtsl, 0.0);
    n_sap_gain_vt.resize_and_preserve( vtsl, 0.0);
    n_bud_gain_vt.resize_and_preserve( vtsl, 0.0);
    n_fol_gain_vt.resize_and_preserve( vtsl, 0.0);
    n_frt_gain_vt.resize_and_preserve( vtsl, 0.0);
 
    return  LDNDC_ERR_OK;
}

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);
        nh3_uptake_fl.reference( ph_.ts_nh3_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);  // fw: both the same ...
 
        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);
        nh3_uptake_fl.reference( ph_.nd_nh3_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;
}

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

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)