ldndc::PhysiologyGrowthPSIM Class Reference

Vegetation model GrowthPSIM. More...

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

References ldndc::sap_wood_fraction().

{
    // capacitance is replenished by (hourly) soil water uptake 
    // capacitance += wc_.accumulated_wateruptake_sl.sum();

    // 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        
   
        // calling soil hydraulic conductance as well as soil water potential and weighting 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 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, soil to root and threshold 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]);
        }

        // soil/root water potential in MPa (in negative terms), psi_soil only for checking (not used)
        p->psi_sr *= -1.0;
        psi_detach *= -1.0;

        // plant water potential, calculated by adding the (negative) water potential decrease of the previous day
        double psi_vt(std::max(p->psi_sr, psi_detach) + psidecline_cum_vt[p->slot]);

        // relative xylem conductivity based on current soil water state and previous plant water deficit
        double krc_rel = 1.0 - (1.0 - std::exp(-std::pow(psi_vt / vt->PSI_REF(), vt->PSI_EXP())));
        krc_rel = std::max(0.001, krc_rel);

        // canopy water potential
        // (calculated in a lumped fashion, alternatively define psi for each canopy layer separately)
        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
        double const dpsi = h_weighted * cbm::MPA_IN_KPA * cbm::KPA_IN_PA * cbm::DWAT * cbm::DM3_IN_M3 * cbm::G;

        // predawn canopy water potential
        int night(1);  // 1=false, 0=true not intuitive for simpler use in hydraulic function
        if (cbm::flt_equal_zero(mc_.shortwaveradiation_in))
        {
            // in the night, the multiplier for psi that accounts for increasing tension is set to zero
            night = 0;

            // calculations once per day directly after sunset (TODO: ensure that daytime is true at the first call)
            if (daytime == true)
            {
                // weighting by leaf/wood ratio as proxy for capacitance change
                // 
                // NOTE: Using potential capacitance for redistribution is assuming that the degree of capacitance deficit (if it occurs) is the same in all compartments
                // capacitancePot = mFol * watercontent_mFol + mFrt * watercontent_mFrt + mSap * watercontent_mSap;
                // qcapacitance = mFol * watercontent_mFol / capacitancePot;
                // if (capacitancePot > capacitanceMax) capacitanceMax = capacitancePot;
                // 
//                double const qcapacitance = p->mFol / (p->mFol + p->mSap + p->mCor + p->mFrt);  // assuming that active water is also stored in dead wood
//                double const qcapacitance = p->mFol / (p->mFol + p->mSap + p->mFrt);  // assuming that there is no active water in the core of the stem
                double const qcapacitance = (p->mFol + p->f_branch * p->mSap) / (p->mFol + p->mSap + p->mFrt);  // assuming that transpiration affects the primarily the crown tree water potential
//                double const qcapacitance = 1.0;  // assuming that transpiration affects the whole tree water potential

                // recovery of cumulative plant water potential due to rehydration during the previous day
                // NOTE: assumes that relative rehydration and plant water potential recovers in parallel
                // psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - qcapacitance));
                psidecline_cum_vt[p->slot] *= std::min(1.0, (1.0 - rehydrationindex_cum_vt[p->slot]));

                // decline of cumulative plant water potential due to cumulative canopy water potential decline during the previous day
                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;
        }
        else
        {
            //  calculations once per day directly after sunrise
            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;

            if ((*vt)->stem_shrinkage > (*vt)->twd_max_vt)
            {
                (*vt)->twd_max_vt = (*vt)->stem_shrinkage;
            }

        }

        // capacitance decrease
        // capacitance_deepwater_relation = 1.0; // parameter
        // double hr_potTrans(std::min(potentialtranspiration * nhr / 24.0, hr_pot_evapotrans));
        // capacitance -= hr_potTrans * capacitance_deepwater_relation;

        // 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))
        {
            p->psi_cr = psi_vt - (transp_mol * double(night) / (vt->CWP_REF() * krc_rel)) - dpsi;
        }

        // 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 = 1.0 - (1.0 - std::exp(-std::pow(p->psi_mean / vt->PSI_REF(), vt->PSI_EXP())));
        k_rc = std::max(0.001, k_rc);

        // whole plant resistances (in MPa s m2 mol-1)
        // TODO resistance should increase proportionally to the difference between qsaparea_vt[p->slot] and p->qsfa
        // TODO resistance should increase proportionally to the deficit of sapwood demand (RPMIN / (k_rc * qsaparea_vt[p->slot]) )?
        p->xylem_resistance = vt->RPMIN();
        if (cbm::flt_greater_zero(k_rc))
        {
            p->xylem_resistance /= k_rc;
        }

    } // vegetation type loop end

    return LDNDC_ERR_OK;
}

Here is the call 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;
}

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

rg 30.10.2024 substituted by the impact factor that reduces activity when the pool of free available carbon reserves is depleted (fsub_vt)

References ldndc::non_stomatal_water_limitation().

{
    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 (Maekelae et al. 2004 (S model))
                    else
                    {
                        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 = fsub_vt[p->slot];
//                            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;
}

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

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

{
    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)
            {
                wc_.accumulated_potentialtranspiration += 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 == "potentialtranspiration"
            {
                wc_.accumulated_potentialtranspiration += 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
        {
            wc_.accumulated_potentialtranspiration += potential_crop_transpiration(
                ac_.nd_co2_concentration,
                ph_.carbonuptake( m_veg, fl_cnt_),
                vt->WUECMAX());
        }
    }
    
    return  LDNDC_ERR_OK;
}

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)