ldndc::PhysiologyPlaMox Class Reference

Vegetation model PlaMox. More...

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

Public Member Functions
	~PhysiologyPlaMox ()
	Delete allocated classes.

Private Member Functions
lerr_t	PlaMox_step_init ()
	pre-run initialization each time step
lerr_t	PlaMox_step_resize ()
	resize plant species vector
lerr_t	PlaMox_management ()
	Applies grazing and cutting.
lerr_t	PlaMox_event_plant (MoBiLE_Plant *, EventAttributes const &)
	handle plant event
lerr_t	PlaMox_event_harvest (MoBiLE_Plant *, EventAttributes const &)
	handle harvest event
lerr_t	PlaMox_photosynthesis (MoBiLE_Plant *)
	Update of information needed by photofarquhar.
void	PlaMox_vernalization (MoBiLE_Plant *)
	Determines the growing degree days and the plant development stage based on if vernalization requirements are fullfilled or not.
void	PlaMox_growing_degree_days (MoBiLE_Plant *)
	Calculates growing degree days depending on daily average temperature.
void	PlaMox_heat_stress_limitation (MoBiLE_Plant *_vt)
	Limits pod filling due to heat stress around anthesis.
lerr_t	PlaMox_allocation_grass (MoBiLE_Plant *)
	Allocation metrics for grass species.
lerr_t	PlaMox_bud_burst (MoBiLE_Plant *)
	Burst of buds.
lerr_t	PlaMox_redistribution (MoBiLE_Plant *)
	Redistribution of reserves.
void	PlaMox_respiration (MoBiLE_Plant *)
	Calculates maintenance/residual and growth respiration.
void	PlaMox_exsudation (MoBiLE_Plant *)
	Determines root exsudation as fraction of root growth respiration.
void	PlaMox_nitrogen_uptake (MoBiLE_Plant *)
	Calculates plant nitrogen uptake based on daily demand.
lerr_t	PlaMox_nitrogen_fixation (MoBiLE_Plant *)
	Calculates plant nitrogen fixation.
lerr_t	PlaMox_senescence (MoBiLE_Plant *)
	Calculates aboveground and belowground plant senecsence.
void	PlaMox_drought (MoBiLE_Plant *)
	Calculates drought stress.
void	PlaMox_transpiration (MoBiLE_Plant *)
	Calculates potential transpiration.
void	PlaMox_update_root_structure (MoBiLE_Plant *, double)
	Updates all relevant root structural matters.
void	PlaMox_update_height (MoBiLE_Plant *)
void	PlaMox_update_ground_cover (MoBiLE_Plant *)
void	PlaMox_update_foliage_structure (MoBiLE_Plant *)
	Calculation of canopy layer properties:
void	PlaMox_update_specific_leaf_area (MoBiLE_Plant *)
	Calculates specific leaf area (sla) in each canopy layer.
void	PlaMox_update_nitrogen_concentrations (MoBiLE_Plant *)
double	PlaMox_get_nitrogen_deficiency (MoBiLE_Plant *)
double	PlaMox_get_biomass_induced_downregulation (MoBiLE_Plant *)
double	PlaMox_get_age_factor (MoBiLE_Plant *)
	Calculates an age factor.
double	PlaMox_get_frost_factor (MoBiLE_Plant *, double)
	Calculates a temperature factor.
double	PlaMox_get_hypoxia_factor (MoBiLE_Plant *)
	Calculates a temperature factor.
double	PlaMox_get_heat_factor (MoBiLE_Plant *)
	Calculates a temperature factor.
double	PlaMox_get_foliage_nitrogen_concentration (MoBiLE_Plant *)
	Calculates optimum foliage nitrogen concentration.
double	PlaMox_n_opt (MoBiLE_Plant *)
	Determines optimum nitrogen concentration.

Private Attributes
BerryBall	plamox_berryball
	Photosynthesis.
NitrogenFixation *	plamox_nitrogen_fixation
	Nitrogen fixation.
ldndc::growable_array< BaseRootSystemDNDC *, 1000, 1 >	plamox_root_system
	Root system.
LD_PlantFunctions	m_pf
	All kind of plant related functions.
bool	have_drought_stress
	Consider drought stress yes/no.
bool	have_heat_stress
	Consider heat stress yes/no.
cbm::string_t	droughtstress_method
	Transpiration method used by PlaMox.
cbm::string_t::cbmstring_array_t	plantfamilies
	Plant families that are considered by PlaMox.
double const	FTS_TOT_
	Time resolution factor: \( \text{FTS_TOT_} = \frac{1.0}{\text{time resolution}} \).
lvector_t< double >	allocation_factor_leafs
	Allocation factor of daily assimilated carbon to leaf growth [-].
lvector_t< double >	allocation_factor_stems
	Allocation factor of daily assimilated carbon to stem growth [-].
lvector_t< double >	allocation_factor_fruit
	Allocation factor of daily assimilated carbon to fruit growth [-].
lvector_t< double >	allocation_factor_roots
	Allocation factor of daily assimilated carbon to root growth [-].
lvector_t< double >	lai_min
	Minimum value of üplamt leaf area index (m^2:m^-2). For crops, this value is fixed until between sowing and emergence.
lvector_t< double >	fractional_cover
	Density of seeded plants with regard to optimum (full area) seeding (-).
lvector_t< double >	chill_factor
	Factor that retards plant development if vernalization requirement is not fullfilled.
lvector_t< double >	chill_units
	Accumulated chilling units for vernalization;.
lvector_t< unsigned int >	root_q_vt_
	Largest soil layer index where roots exist [-].
lvector_t< double >	daytime_temperatures
	store daytime temperature for heat stress analysis
lvector_t< double >	influence_heat_daily
	store daily impact factor of heat stress on grain yield;
double	influence_heat_reduction_grainfilling
	Resulting impact factor of the heat stress influence on grain yield.
double	day_of_flowering
	day after emergence where flowering is onset
double	Tcrit
	the timing of the episode of high temperatures relative to flowering
double	Tzero
	The temperature at which there is zero pod-set (°C)

Detailed Description

Vegetation model PlaMox.

Author

David Kraus

Constructor & Destructor Documentation

~PhysiologyPlaMox()

ldndc::PhysiologyPlaMox::~PhysiologyPlaMox

(

)

Delete allocated classes.

Delete:

• roots system
• nitrogen fixation

{
    for ( size_t  r = 0;  r < plamox_root_system.size();  ++r)
    {
        if ( plamox_root_system[r])
        {
            LD_Allocator->destroy( plamox_root_system[r]);
        }
    }
    
    delete plamox_nitrogen_fixation;
}

References plamox_nitrogen_fixation, plamox_root_system, and ~PhysiologyPlaMox().

Referenced by ~PhysiologyPlaMox().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

PlaMox_event_harvest()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_event_harvest ( MoBiLE_Plant * _vt, EventAttributes const & _attributes )

private

handle harvest event

Parameters

species

Returns

LDNDC_ERR_OK if no harvest event is pending or everything went well.

...

{
    if ( plamox_root_system[_vt->slot] == NULL)
    {
        KLOGERROR( "[BUG] ", "root_system is NULL when not expected \"",_vt->name(),"\"!");
        return  LDNDC_ERR_RUNTIME_ERROR;
    }
    
    bool const mulching = _attributes.get( "/mulching", false);
    
    double const export_root = _attributes.get( "/fraction-export-rootwood", 0.0);
    double const rootlitter_c( (1.0 - export_root) * _vt->mFrt * cbm::CCDM);
    double const rootlitter_n( (1.0 - export_root) * _vt->n_frt());
    double const root_c_export( export_root * _vt->mFrt * cbm::CCDM);
    double const root_n_export( export_root * _vt->mFrt * _vt->ncFrt);
    
    double const straw_c( (_vt->mFol + _vt->dw_dfol + _vt->dw_lst+ _vt->dw_dst) * cbm::CCDM);
    double const straw_n( _vt->n_fol() + _vt->n_dfol + _vt->n_lst + _vt->n_dst);
    
    double const fru_c( _vt->mBud * cbm::CCDM);
    double const fru_n( _vt->n_bud());
    
    double fru_c_export( 0.0);
    double fru_n_export( 0.0);
    
    double straw_c_export( 0.0);
    double straw_n_export( 0.0);
    
    double mulching_c( 0.0);
    double mulching_n( 0.0);
    
    double stubble_c( 0.0);
    double stubble_n( 0.0);
    
    double gdd_sum( _vt->growing_degree_days );
    double dvs_flush( _vt->dvsFlush );
 
    double const height( _attributes.get( "/height", invalid_flt));
    double remains_relative( _attributes.get( "/remains_relative", invalid_flt));
    double remains_absolute( _attributes.get( "/remains_absolute", invalid_flt));
    if( cbm::is_valid( remains_absolute))
    {
        remains_absolute *= cbm::HA_IN_M2;
    }
 
    if (   !cbm::flt_greater_equal_zero( remains_relative)
        && !cbm::flt_greater_equal_zero( remains_absolute)
        && !cbm::flt_greater_equal_zero( height))
    {
        if ( _vt->is_covercrop)
        {
            remains_relative = 1.0;
        }
        else
        {
            KLOGWARN( "harvest event attribute \"remains_relative\" and \"remains_absolute\" and \"height\" not set;",
                      " \"remains_relative\" set to zero and used [species=", _vt->name(),"]");
        }
    }
    else  if (   (cbm::flt_greater_equal_zero( remains_relative) ||
                  cbm::flt_greater_equal_zero( remains_absolute))
              && cbm::flt_greater_equal_zero( height))
    {
        KLOGWARN( "harvest event attribute \"remains_(relative/absolute)\" and \"height\" both set;"
                  " attribute \"remains_relative\" used [species=", _vt->name(),"]");
    }
    
    if ( cbm::flt_greater_equal_zero( remains_relative))
    {
        /* no op */
    }
    else if ( cbm::flt_greater_equal_zero( remains_absolute))
    {
        remains_relative = cbm::bound( 0.0,
                                       remains_absolute / (_vt->mFol + _vt->dw_dfol + _vt->dw_lst+ _vt->dw_dst),
                                       1.0);
    }
    else if ( cbm::flt_equal_zero( height))
    {
        remains_relative = 0.0;
    }
    else if ( cbm::flt_greater_zero( height))
    {
        double h_cum( 0.0);
        double remains_relative_fol = 0.0;
        for ( int  fl = 0;  fl < m_setup->canopylayers();  ++fl)
        {
            remains_relative_fol += _vt->fFol_fl[fl];
            h_cum += ph_.h_fl[fl];
            if ( cbm::flt_greater_equal( h_cum, height))
            {
                break;
            }
        }
        
        h_cum = 0.0;
        double remains_relative_lst = 0.0;
        double remains_relative_lst_total = 0.0;
        for ( int  fl = 0;  fl < m_setup->canopylayers();  ++fl)
        {
            //lst decreases with height
            remains_relative_lst_total += pow( cbm::bound_min( 0.0, _vt->height_max - h_cum), 0.3);
            if ( cbm::flt_less_equal( h_cum, height))
            {
                remains_relative_lst += pow( cbm::bound_min( 0.0, _vt->height_max - h_cum), 0.3);
            }
            h_cum += ph_.h_fl[fl];
        }
        remains_relative_lst /= remains_relative_lst_total;
        
        remains_relative = (remains_relative_fol * (_vt->mFol + _vt->dw_dfol) +
                            remains_relative_lst * (_vt->dw_lst+ _vt->dw_dst)) /
        (_vt->mFol + _vt->dw_dfol + _vt->dw_lst+ _vt->dw_dst);
    }
    else
    {
        KLOGERROR( "[BUG] ", "harvest event attribute \"remains_relative\" and \"height\" are invalid [species=", _vt->name(),"]");
        return LDNDC_ERR_FAIL;
    }
    
    stubble_c += remains_relative * straw_c;
    stubble_n += remains_relative * straw_n;
    if ( mulching)
    {
        mulching_c += (1.0-remains_relative) * straw_c;
        mulching_n += (1.0-remains_relative) * straw_n;
    }
    else
    {
        straw_c_export += (1.0-remains_relative) * straw_c;
        straw_n_export += (1.0-remains_relative) * straw_n;
    }
    
    if ( _vt->is_covercrop)
    {
        stubble_c += remains_relative * fru_c;
        stubble_n += remains_relative * fru_n;
        if ( mulching)
        {
            mulching_c += (1.0-remains_relative) * fru_c;
            mulching_n += (1.0-remains_relative) * fru_n;
        }
        else
        {
            stubble_c += (1.0-remains_relative) * fru_c;
            stubble_n += (1.0-remains_relative) * fru_n;
        }
    }
    else
    {
        fru_c_export = fru_c;
        fru_n_export = fru_n;
    }
    
    //export
    c_total_exported += straw_c_export + fru_c_export;
    c_fruit_exported += fru_c_export;
    n_total_exported += straw_n_export + fru_n_export;
    n_fruit_exported += fru_n_export;
    
    ph_.accumulated_c_export_harvest += straw_c_export + fru_c_export + root_c_export;
    ph_.accumulated_n_export_harvest += straw_n_export + fru_n_export + root_n_export;
    
    ph_.accumulated_c_fru_export_harvest += fru_c_export;
    ph_.accumulated_n_fru_export_harvest += fru_n_export;
    
    //stubble litter
    sc_.c_stubble_lit3 += stubble_c * (*_vt)->LIGNIN();
    sc_.c_stubble_lit2 += stubble_c * (*_vt)->CELLULOSE();
    sc_.c_stubble_lit1 += stubble_c * (1.0 - (*_vt)->LIGNIN() - (*_vt)->CELLULOSE());
    sc_.accumulated_c_litter_stubble += stubble_c;
    
    sc_.n_stubble_lit3 += stubble_n * (*_vt)->LIGNIN();
    sc_.n_stubble_lit2 += stubble_n * (*_vt)->CELLULOSE();
    sc_.n_stubble_lit1 += stubble_n * (1.0 - (*_vt)->LIGNIN() - (*_vt)->CELLULOSE());
    sc_.accumulated_n_litter_stubble += stubble_n;
    
    //raw litter
    sc_.c_raw_lit_1_above += mulching_c * (1.0 - (*_vt)->CELLULOSE() - (*_vt)->LIGNIN());
    sc_.c_raw_lit_2_above += mulching_c * (*_vt)->CELLULOSE();
    sc_.c_raw_lit_3_above += mulching_c * (*_vt)->LIGNIN();
    sc_.accumulated_c_litter_above += mulching_c;
    
    sc_.n_raw_lit_1_above += mulching_n * (1.0 - (*_vt)->CELLULOSE() - (*_vt)->LIGNIN());
    sc_.n_raw_lit_2_above += mulching_n * (*_vt)->CELLULOSE();
    sc_.n_raw_lit_3_above += mulching_n * (*_vt)->LIGNIN();
    sc_.accumulated_n_litter_above += mulching_n;
    
    //root litter
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        double const dw_rootlitter( rootlitter_c / cbm::CCDM * _vt->fFrt_sl[sl]);
        double const n_rootlitter( dw_rootlitter * _vt->ncFrt);
        
        sc_.c_raw_lit_1_sl[sl] += dw_rootlitter * (1.0 - (*_vt)->CELLULOSE() - (*_vt)->LIGNIN()) * cbm::CCDM;
        sc_.c_raw_lit_2_sl[sl] += dw_rootlitter * (*_vt)->CELLULOSE() * cbm::CCDM;
        sc_.c_raw_lit_3_sl[sl] += dw_rootlitter * (*_vt)->LIGNIN() * cbm::CCDM;
        sc_.accumulated_c_litter_below_sl[sl] += dw_rootlitter * cbm::CCDM;
        
        sc_.n_raw_lit_1_sl[sl] += n_rootlitter * (1.0 - (*_vt)->CELLULOSE() - (*_vt)->LIGNIN());
        sc_.n_raw_lit_2_sl[sl] += n_rootlitter * (*_vt)->CELLULOSE();
        sc_.n_raw_lit_3_sl[sl] += n_rootlitter * (*_vt)->LIGNIN();
        sc_.accumulated_n_litter_below_sl[sl] += n_rootlitter;
    }
    
    cbm::state_scratch_t *  mcom = io_kcomm->get_scratch();
    std::string  mcom_key;
    
    char const *  species_name = _attributes.get( "/name", "?");
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:daysOnField", species_name);
    mcom->set( mcom_key.c_str(), (double)((lclock()->seconds() - seconds_crop_planting[_vt->slot]) / cbm::SEC_IN_DAY));
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:gddsum", species_name);
    mcom->set( mcom_key.c_str(), gdd_sum);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:dvsflush", species_name);
    mcom->set( mcom_key.c_str(), dvs_flush);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_fru", species_name);
    mcom->set( mcom_key.c_str(), fru_c);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_fru_export", species_name);
    mcom->set( mcom_key.c_str(), fru_c_export);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_fru", species_name);
    mcom->set( mcom_key.c_str(), fru_n);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_fru_export", species_name);
    mcom->set( mcom_key.c_str(), fru_n_export);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_straw", species_name);
    mcom->set( mcom_key.c_str(), straw_c);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_straw_export", species_name);
    mcom->set( mcom_key.c_str(), straw_c_export);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_straw", species_name);
    mcom->set( mcom_key.c_str(), straw_n);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_straw_export", species_name);
    mcom->set( mcom_key.c_str(), straw_n_export);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_stubble", species_name);
    mcom->set( mcom_key.c_str(), stubble_c);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_stubble", species_name);
    mcom->set( mcom_key.c_str(), stubble_n);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:c_frt", species_name);
    mcom->set( mcom_key.c_str(), rootlitter_c);
    
    cbm::state_scratch_t::make_item_key(  &mcom_key, "harvest:%s:n_frt", species_name);
    mcom->set( mcom_key.c_str(), rootlitter_n);
    
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        _vt->fFrt_sl[sl] = 0.0;
    }
    
    cbm::invalidate( root_q_vt_[_vt->slot]);
    _vt->rooting_depth = 0.0;
 
    days_after_emergence[_vt->slot] = -1;
 
    dw_retranslocation_stem[_vt->slot] = 0.0;
    dw_retranslocation_foliage[_vt->slot] = 0.0;
 
    dw_fol_old[_vt->slot] = 0.0;
    lai_dynamic[_vt->slot] = 0.0;
 
    _vt->mFol = 0.0;
    _vt->dw_dfol = 0.0;
    _vt->ncFol = 0.0;
    _vt->n_dfol = 0.0;
 
    _vt->dw_lst = 0.0;
    _vt->n_lst = 0.0;
 
    _vt->dw_dst = 0.0;
    _vt->n_dst = 0.0;
 
    _vt->mBud = 0.0;
    _vt->mBudStart = 0.0;
    _vt->ncBud = 0.0;
 
    _vt->mFrt = 0.0;
    _vt->ncFrt = 0.0;
 
    _vt->dEmerg = -1;
    _vt->growing_degree_days = 0.0;
    _vt->dvsMort = 0.0;
    _vt->dvsFlush = 0.0;
    _vt->dvsFlushOld = 0.0;
 
    n_plant[_vt->slot] = 0.0;
    _vt->a_fix_n = 0.0;
 
    _vt->height_max = 0.0;
    _vt->height_at_canopy_start = 0.0;
 
    _vt->f_area = 0.0;
    for ( int  fl = 0;  fl < m_setup->canopylayers();  ++fl)
    {
        _vt->fFol_fl[fl] = 0.0;
        _vt->lai_fl[fl] = 0.0;
    }
 
    _vt->f_fac = 0.0;
    chill_units[_vt->slot] = 0.0;
    chill_factor[_vt->slot] = 1.0;
 
    yearly_cuts[_vt->slot] = 0;
 
    allocation_factor_leafs[_vt->slot] = 0.0;
    allocation_factor_stems[_vt->slot] = 0.0;
    allocation_factor_fruit[_vt->slot] = 0.0;
    allocation_factor_roots[_vt->slot] = 0.0;
 
    m_fruit_maximum[_vt->slot] = -1.0;
    spikelets_sterility[_vt->slot] = 0.0;
    hypoxia[_vt->slot] = 0.0;
 
    LD_Allocator->destroy( plamox_root_system[_vt->slot]);
    plamox_root_system[_vt->slot] = NULL;
 
    return  LDNDC_ERR_OK;
}

References allocation_factor_fruit, allocation_factor_leafs, allocation_factor_roots, allocation_factor_stems, chill_factor, chill_units, plamox_root_system, and root_q_vt_.

PlaMox_event_plant()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_event_plant ( MoBiLE_Plant * _vt, EventAttributes const & _attributes )

private

handle plant event

Parameters

species

Returns

LDNDC_ERR_OK if no plant event is pending or everything went well.

...

{
    species_t const *  sp = NULL;
    if ( m_species)
    {
        sp = m_species->get_species( _vt->cname());
    }
 
    daytime_temperatures = 0;
 
    seconds_crop_planting[_vt->slot] = lclock()->seconds();
    fractional_cover[_vt->slot] = _attributes.get( "/fractional-cover", 1.0);
 
    //Scale growing degree days
    //Currently only used by FarmSystem to dynamically adjust species
    //over larger regions and/or time periods
    double gdd_maturity_target( _attributes.get( "/gdd-maturity-target", -1.0));
    if ( cbm::flt_less( gdd_maturity_target, 0.0) &&
         (std::strstr( _vt->cname(), "GDD-MATURITY-TARGET") != NULL) &&
         gdd_target.find( _vt->cname()) != gdd_target.end())
    {
        gdd_maturity_target = gdd_target[_vt->cname()];
    }
 
    if ( cbm::flt_greater_zero( gdd_maturity_target) &&
         cbm::flt_greater_zero( (*_vt)->GDD_MATURITY()))
    {
        double const scale_gdd( gdd_maturity_target / (*_vt)->GDD_MATURITY());
        MoBiLE_PlantParameters p_parameters = (*m_speciesparameters)[_vt->ctype()];
        p_parameters.GDD_EMERGENCE_UPDATE( (*_vt)->GDD_EMERGENCE() * scale_gdd);
        p_parameters.GDD_STEM_ELONGATION_UPDATE( (*_vt)->GDD_STEM_ELONGATION() * scale_gdd);
        p_parameters.GDD_FLOWERING_UPDATE( (*_vt)->GDD_FLOWERING() * scale_gdd);
        p_parameters.GDD_GRAIN_FILLING_UPDATE( (*_vt)->GDD_GRAIN_FILLING() * scale_gdd);
        p_parameters.GDD_ROOTS_GROWN_UPDATE( (*_vt)->GDD_ROOTS_GROWN() * scale_gdd);
        p_parameters.GDD_MATURITY_UPDATE( gdd_maturity_target);
        _vt->switchparameters( p_parameters);
    }
 
    _vt->is_covercrop = _attributes.get( "/cover-crop", false);
    //_vt->f_fac = (*_vt)->FFACMAX();
 
    //amount of seeds
    double const initial_biomass( cbm::bound_min( 10.0,
                                  cbm::flt_greater_zero( _attributes.get( "/initial-biomass", 0.0)) ?
                                                         _attributes.get( "/initial-biomass", 0.0) :
                                                         (*_vt)->SEED_RATE()) * cbm::HA_IN_M2);
 
    lai_min[_vt->slot] = 0.01;
 
    location[_vt->slot] = _attributes.get( "/location", "?");
 
    dw_retranslocation_stem[_vt->slot] = 0.0;
    dw_retranslocation_foliage[_vt->slot] = 0.0;
 
    dw_fol_old[_vt->slot] = 0.0;
    lai_dynamic[_vt->slot] = 0.0;
 
    //plant gets biomass by species initializer
    //store and substract later according amounts of C and N
    //for balance check at day of planting
    double const plant_n_old( _vt->total_nitrogen());
    double const plant_c_old( _vt->total_biomass() * cbm::CCDM);
 
    _vt->height_max = 0.0;
    _vt->height_at_canopy_start = 0.0;
 
    chill_units[_vt->slot] = 0.0;
    chill_factor[_vt->slot] = 1.0;
 
    _vt->f_heat_daily = 1.0;
 
    if ( cbm::flt_greater_zero( (*_vt)->M_FRUIT_OPT()))
    {
        m_fruit_maximum[_vt->slot] = (*_vt)->M_FRUIT_OPT();
    }
    else
    {
        m_fruit_maximum[_vt->slot] = -1.0;
    }
    spikelets_sterility[_vt->slot] = 0.0;
    
    if ( m_veg->is_family( _vt, ":rice:"))
    {
        nc_fol_opt[_vt->slot] = 0.5 * ((*_vt)->NC_FOLIAGE_MAX() + (*_vt)->NC_FOLIAGE_MIN());
    }
    else if ( m_veg->is_family( _vt, ":wheat:"))
    {
        nc_fol_opt[_vt->slot] = 0.5 * ((*_vt)->NC_FOLIAGE_MAX() + (*_vt)->NC_FOLIAGE_MIN());
    }
    else
    {
        nc_fol_opt[_vt->slot] = (*_vt)->NC_FOLIAGE_MAX();
    }
 
    gdd_grain_filling[_vt->slot] = (*_vt)->GDD_GRAIN();
 
    hypoxia[_vt->slot] = 0.0;
    transplanting_shock_vt[_vt->slot] = 0.0;
 
    PlaMox_reset_phenology( _vt);
 
    if ( cbm::is_equal( _vt->group().c_str(), "crop"))
    {
        lerr_t rc_plant = m_pf.initialize_crop( _vt, sp ? sp->crop() : NULL);
        if ( rc_plant)
        {
            return LDNDC_ERR_OK;
        }
 
        /* only considered for rice so far */
        int const seedbedduration( _attributes.get( "/seedbed-duration", 0));
        if ( seedbedduration > 0)
        {
            double const mean_gdd( cbm::bound_max(mc_.nd_airtemperature - (*_vt)->GDD_BASE_TEMPERATURE(), (*_vt)->GDD_MAX_TEMPERATURE()));
            _vt->growing_degree_days = seedbedduration * mean_gdd;
            _vt->dvsFlush = _vt->growing_degree_days / (*_vt)->GDD_MATURITY();
            transplanting_shock_vt[_vt->slot] = 1.0;
            days_after_emergence[_vt->slot] = 0;
        }
        else
        {
            _vt->growing_degree_days = 0.0;
            _vt->dvsFlush = 0.0;
        }
 
        allocation_factor_roots[_vt->slot] = (*_vt)->FRACTION_ROOT();
        allocation_factor_leafs[_vt->slot] = 1.0 - (*_vt)->FRACTION_ROOT();
        allocation_factor_stems[_vt->slot] = 0.0;
        allocation_factor_fruit[_vt->slot] = 0.0;
 
        _vt->ncFrt = (*_vt)->NC_FINEROOTS_MAX();
        _vt->ncFol = (*_vt)->NC_FOLIAGE_MAX();
        _vt->n_lst = 0.0;
        _vt->ncBud = 0.0;
        _vt->ncSap = 0.0;
        _vt->ncCor = 0.0;
 
        double const fraction_root_start( cbm::flt_greater_zero( (*_vt)->FRACTION_ROOT_START()) ?
                                         (*_vt)->FRACTION_ROOT_START() :
                                         (*_vt)->FRACTION_ROOT());
        double const initial_foliage_biomass_max( 0.02);
        _vt->mFol = cbm::bound_max( (1.0 - fraction_root_start) * initial_biomass,
                                    initial_foliage_biomass_max );
 
        _vt->mFrt = cbm::bound_min( 0.0, initial_biomass - _vt->mFol);
        _vt->dw_lst = 0.0;
        _vt->mBud = 0.0;
        _vt->mSap = 0.0;
        _vt->mCor = 0.0;
 
        lai_min[_vt->slot] = cbm::bound_min( lai_min[_vt->slot], _vt->mFol * (*_vt)->SLAMAX());
        n_plant[_vt->slot] = _vt->total_nitrogen();
        PlaMox_update_nitrogen_concentrations( _vt);
 
        n_at_planting += (n_plant[_vt->slot] - plant_n_old);
        timestep_c_assi += (initial_biomass * cbm::CCDM - plant_c_old);
    }
    else if ( cbm::is_equal( _vt->cgroup(), "grass"))
    {
        lerr_t rc_plant = m_pf.initialize_grass( _vt, sp ? sp->grass() : NULL);
        if ( rc_plant)
        {
            return LDNDC_ERR_OK;
        }
 
        if ( lclock()->seconds() > cbm::SEC_IN_DAY)
        {
            PlaMox_reset_phenology( _vt);
        }
 
        /* set to fixed value */
        lai_min[_vt->slot] = 0.1;
 
        allocation_factor_roots[_vt->slot] = (*_vt)->FRACTION_ROOT();
        allocation_factor_fruit[_vt->slot] = (*_vt)->FRACTION_FRUIT();
        allocation_factor_leafs[_vt->slot] = (*_vt)->FRACTION_FOLIAGE();
        allocation_factor_stems[_vt->slot] = (1.0 - allocation_factor_leafs[_vt->slot] - allocation_factor_roots[_vt->slot] - allocation_factor_fruit[_vt->slot]);
 
        _vt->mFrt   = allocation_factor_roots[_vt->slot] * initial_biomass;
        _vt->mFol   = allocation_factor_leafs[_vt->slot] * initial_biomass;
        _vt->dw_lst = allocation_factor_stems[_vt->slot] * initial_biomass;
        _vt->mBud   = allocation_factor_fruit[_vt->slot] * initial_biomass;
        
        _vt->ncFrt = (*_vt)->NC_FINEROOTS_MAX();
        _vt->ncFol = (*_vt)->NC_FOLIAGE_MAX();
        _vt->n_lst = (*_vt)->NC_STRUCTURAL_TISSUE_MAX() * _vt->dw_lst;
        _vt->ncBud = (*_vt)->NC_FRUIT_MAX();
        
        n_plant[_vt->slot] = _vt->total_nitrogen();
        
        PlaMox_update_nitrogen_concentrations( _vt);
        
        n_at_planting += (n_plant[_vt->slot] - plant_n_old);
        timestep_c_assi += (initial_biomass * cbm::CCDM - plant_c_old);
    }
    else
    {
        KLOGERROR( "I do not handle this group of species  ",
                  "[species=\"",_vt->name(),"\",group=",_vt->group(),"]");
        return  LDNDC_ERR_RUNTIME_ERROR;
    }
 
    // currently no concept for free available carbon
    _vt->f_fac = 0.0;
    
    // initialize root system
    if (plamox_root_system.size() <= _vt->slot)
    {
        plamox_root_system.resize(_vt->slot+1);
    }
 
    ldndc_kassert( plamox_root_system[_vt->slot] == NULL);
    plamox_root_system[_vt->slot] = LD_Allocator->construct_args< RootSystemDNDC >( 1, m_state, io_kcomm);
    if ( !plamox_root_system[_vt->slot])
    {
        KLOGERROR( "Failed to allocate root-system object");
        return  LDNDC_ERR_NOMEM;
    }
 
    double const seed_depth = _attributes.get( "/seed-depth", 0.05);
    root_q_vt_[_vt->slot] = 0; // no rooted layers yet
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        if (cbm::flt_greater( sc_.depth_sl[sl], seed_depth))
        {
            break;
        }
        root_q_vt_[_vt->slot] = sl; // no rooted layers yet
    }
 
    PlaMox_update_root_structure( _vt, _vt->mFrt);
 
    return  LDNDC_ERR_OK;
}

References allocation_factor_fruit, allocation_factor_leafs, allocation_factor_roots, allocation_factor_stems, chill_factor, chill_units, daytime_temperatures, fractional_cover, lai_min, m_pf, plamox_root_system, PlaMox_update_nitrogen_concentrations(), PlaMox_update_root_structure(), and root_q_vt_.

Here is the call graph for this function:

PlaMox_get_age_factor()

double ldndc::PhysiologyPlaMox::PlaMox_get_age_factor ( MoBiLE_Plant * _p )

private

Calculates an age factor.

Parameters

[in]

_vt

Plant species

{
    if ( PlaMox_get_life_cycle( _p) > PhysiologyPlaMox::ANNUAL)
    {
        if ( (*_p)->GDD_EMERGENCE() > _p->growing_degree_days)
        {
            return ( 1.0 - ((*_p)->GDD_EMERGENCE() - _p->growing_degree_days) / (*_p)->GDD_EMERGENCE());
        }
        return ( 1.0);
    }
    else
    {
        if ( days_after_emergence[_p->slot] < 0)
        {
            return 0.0;
        }
        else
        {
            if ( cbm::flt_less_equal( _p->growing_degree_days, (*_p)->GDD_MATURITY()))
            {
                return ( 1.0);
            }
            else
            {
                return 1.0 / std::exp( 0.01 * (_p->growing_degree_days - (*_p)->GDD_MATURITY()));
            }
        }
    }
}

Referenced by PlaMox_photosynthesis(), and PlaMox_update_ground_cover().

Here is the caller graph for this function:

PlaMox_get_biomass_induced_downregulation()

double ldndc::PhysiologyPlaMox::PlaMox_get_biomass_induced_downregulation ( MoBiLE_Plant * _vt )

private

Parameters

[in]

_vt

Plant species

{
    if ( m_veg->is_family( _vt, ":wheat:"))
    {
        double const fol_opt( (*_vt)->MFOLOPT() * fractional_cover[_vt->slot]);
        double const lst_opt( (1.0 - (*_vt)->FALEAF()) / (*_vt)->FALEAF() * fol_opt);
 
        if ( cbm::flt_greater_zero( _vt->dw_lst) &&
             cbm::flt_greater( _vt->dw_lst, lst_opt))
        {
            return lst_opt / _vt->dw_lst;
        }
    }
 
    return 1.0;
}

References fractional_cover.

Referenced by PlaMox_photosynthesis(), and PlaMox_update_ground_cover().

Here is the caller graph for this function:

PlaMox_get_frost_factor()

double ldndc::PhysiologyPlaMox::PlaMox_get_frost_factor ( MoBiLE_Plant * _vt, double _temp )

private

Calculates a temperature factor.

Parameters

[in]	_vt	Plant species
[in]	_temp	Temperature

Returns

Temperature factor

{
    double const t_min( (*_vt)->TLIMIT() - 2.0);
    double const t_max( (*_vt)->TLIMIT());
 
    if ( cbm::flt_less( _temp, t_min))
    {
        return 0.0;
    }
    else if ( cbm::flt_less( _temp, t_max))
    {
        return (_temp - t_min) / (t_max - t_min);
    }
    else
    {
        return 1.0;
    }
}

Referenced by PlaMox_photosynthesis(), and PlaMox_update_ground_cover().

Here is the caller graph for this function:

PlaMox_get_nitrogen_deficiency()

double ldndc::PhysiologyPlaMox::PlaMox_get_nitrogen_deficiency ( MoBiLE_Plant * _vt )

private

Parameters

[in]

_vt

Plant species

{
//    if ( m_veg->is_family( _vt, ":winterwheat:"))
//    {
//        double const nc_lai_based_opt( cbm::flt_greater_zero( _vt->lai()) ?
//                                       (*_vt)->NC_FOLIAGE_MAX() * _vt->mFol * cbm::G_IN_KG / _vt->lai() : 0.0);
//        double const nc_lai_based( cbm::flt_greater_zero( _vt->lai()) ?
//                                   _vt->ncFol * _vt->mFol * cbm::G_IN_KG / _vt->lai() : 0.0);
//        double const vc( cbm::bound_min( 0.01, 87.3 * (nc_lai_based - 0.33)));
//        double const vc_max( cbm::bound_min( 0.01, 87.3 * (nc_lai_based_opt - 0.33)))   ;
//
//        return cbm::bound( 0.01,
//                           vc / vc_max,
//                           1.0);
//    }
//    else
    {
        double const n_ratio( _vt->ncFol / nc_fol_opt[_vt->slot]);
        if ( n_ratio < 1.0)
        {
            return cbm::bound( 0.01,
                               pow( n_ratio, (*_vt)->N_DEF_FACTOR()),
                               1.0);
        }
        else
        {
            return 1.0;
        }
    }
}

Referenced by PlaMox_photosynthesis(), and PlaMox_update_ground_cover().

Here is the caller graph for this function:

PlaMox_n_opt()

double ldndc::PhysiologyPlaMox::PlaMox_n_opt ( MoBiLE_Plant * _vt )

private

Determines optimum nitrogen concentration.

Adding the optimum concentrations of foliage, sapwood, fine roots and buds.

Returns

Optimum nitrogen concentration of the whole plant

• Optimum concentration for foliage is calculated by: get_foliage_nitrogen_concentration()
• For sapwood by Sapwood Biomass \( * \) NC_STRUCTURAL_TISSUE
  
• For fine roots by Fine Root Biomass \( * \) NC_FINE_ROOTS
  
• For buds by: \( \frac{BudBiomass * CarbonContent}{BudC:N} \)
  

{
    return (  _vt->mFol * PlaMox_get_foliage_nitrogen_concentration( _vt)
            + _vt->dw_lst * (*_vt)->NC_STRUCTURAL_TISSUE_MAX()
            + _vt->mFrt * (*_vt)->NC_FINEROOTS_MAX()
            + _vt->mBud * (*_vt)->NC_FRUIT_MAX());
}

References PlaMox_get_foliage_nitrogen_concentration().

Referenced by PlaMox_update_ground_cover(), and PlaMox_update_nitrogen_concentrations().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_photosynthesis()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_photosynthesis ( MoBiLE_Plant * _vt )

private

Update of information needed by photofarquhar.

Nitrogen concentration:
Nitrogen concentrations are updated in each compartment update_nitrogen_concentrations()

{
    DroughtStress  droughtstress;
    droughtstress.fh2o_ref = (*_vt)->H2OREF_A();
    double const fact_d( droughtstress.linear_threshold( _vt->f_h2o));
    double const fact_a( PlaMox_get_age_factor( _vt));
    double const fact_t( PlaMox_get_frost_factor( _vt, mc_.ts_airtemperature));
    double const fact_h( PlaMox_get_heat_factor( _vt));
    double const fact_o( PlaMox_get_hypoxia_factor( _vt));
    double const fact_n( PlaMox_get_nitrogen_deficiency( _vt));
    double const fact_b( PlaMox_get_biomass_induced_downregulation( _vt));
 
    double const fact_all( cbm::bound_max( fact_d * fact_t * fact_h * fact_o * fact_n * fact_b, fact_a));
    
    /* update activity of photosynthesis apparat */
    if ( cbm::flt_greater_zero( fact_all))
    {
        for ( size_t  fl = 0;  fl < _vt->nb_foliagelayers();  ++fl)
        {
            //rubisco activity
            _vt->vcAct25_fl[fl] = (*_vt)->VCMAX25() * fact_all;
            
            //electron transport under standard conditions
            _vt->jAct25_fl[fl]  = _vt->vcAct25_fl[fl] * (*_vt)->QJVC();
            
            //photorespiration under standard conditions
            _vt->rdAct25_fl[fl] = _vt->vcAct25_fl[fl] * (*_vt)->QRD25();
        }
    }
    
    for (size_t fl = 0; fl < _vt->nb_foliagelayers(); ++fl)
    {
        plamox_berryball.vpd_fl[fl] = mc_.vpd_fl[fl];
        plamox_berryball.rh_fl[fl] = cl_.rel_humidity_subday( lclock_ref());
        plamox_berryball.temp_fl[fl] = mc_.temp_fl[fl];
        plamox_berryball.parsun_fl[fl] = mc_.parsun_fl[fl];
        plamox_berryball.parshd_fl[fl] = mc_.parshd_fl[fl];
        plamox_berryball.tFol_fl[fl] = mc_.tFol_fl[fl];
        plamox_berryball.co2_concentration_fl[fl] = ac_.ts_co2_concentration_fl[fl];
        plamox_berryball.sunlitfoliagefraction_fl[fl] = mc_.ts_sunlitfoliagefraction_fl[fl];
    }
    plamox_berryball.nd_airpressure = mc_.nd_airpressure;
    plamox_berryball.set_vegetation_base_state( _vt);
    plamox_berryball.set_vegetation_non_stomatal_water_limitation_state( 0.0, 0.0, 0.0, 0.0);
    
    plamox_berryball.solve();
    
    plamox_berryball.get_vegetation_state( _vt);
    
    double const carbonuptake_sum( cbm::sum( _vt->carbonuptake_fl, _vt->nb_foliagelayers()));
    
    if ( cbm::flt_greater_zero( carbonuptake_sum))
    {
        timestep_c_assi += carbonuptake_sum;
        double const dw_assi( carbonuptake_sum / cbm::CCDM);
        
        _vt->mBud += dw_assi * allocation_factor_fruit[_vt->slot];
        _vt->mFrt += dw_assi * allocation_factor_roots[_vt->slot];
        _vt->mFol += dw_assi * allocation_factor_leafs[_vt->slot];
        _vt->dw_lst += dw_assi * allocation_factor_stems[_vt->slot];
 
        _vt->dcBud = allocation_factor_fruit[_vt->slot] * carbonuptake_sum;
        _vt->dcFrt = allocation_factor_roots[_vt->slot] * carbonuptake_sum;
        _vt->dcFol = allocation_factor_leafs[_vt->slot] * carbonuptake_sum;
        _vt->dcSap = allocation_factor_stems[_vt->slot] * carbonuptake_sum;

        PlaMox_update_nitrogen_concentrations( _vt);
    }
    
    return LDNDC_ERR_OK;
}

References allocation_factor_fruit, allocation_factor_leafs, allocation_factor_roots, allocation_factor_stems, plamox_berryball, PlaMox_get_age_factor(), PlaMox_get_biomass_induced_downregulation(), PlaMox_get_frost_factor(), PlaMox_get_heat_factor(), PlaMox_get_hypoxia_factor(), PlaMox_get_nitrogen_deficiency(), and PlaMox_update_nitrogen_concentrations().

Here is the call graph for this function:

PlaMox_update_foliage_structure()

void ldndc::PhysiologyPlaMox::PlaMox_update_foliage_structure ( MoBiLE_Plant * _vt )

private

Calculation of canopy layer properties:

• foliage biomass
• foliage biomass fraction
• leaf area index

Parameters

[in]

_vt

Plant species

• foliage biomass
• foliage biomass fraction
• leaf area index By these means, germination and growth of very small biomasses depend less on early lai development, which is not well represented by lai<->photosynthesis feedbacks.

{
    size_t const fl_cnt( _vt->nb_foliagelayers());
 
    double sla_cum( 0.0);
    for (size_t fl = 0; fl < fl_cnt; ++fl)
    {
        sla_cum += _vt->sla_fl[fl];
    }
 
    /* Foliage biomass for lai calculation has lower boundary ensuring: lai >= lai_min */
    double mFol_lai( cbm::bound_min( lai_min[_vt->slot] / (*_vt)->SLAMAX(),
                                     _vt->mFol));
    lai_dynamic[_vt->slot] = cbm::bound_min( lai_min[_vt->slot],
                                             lai_dynamic[_vt->slot] + (_vt->mFol - dw_fol_old[_vt->slot]) * _vt->sla_fl[fl_cnt-1]);
    if (cbm::flt_greater_zero( transplanting_shock_vt[_vt->slot]))
    {
        mFol_lai = mFol_lai * cbm::bound_min( 0.01, 1.0 - transplanting_shock_vt[_vt->slot]);
    }
 
    if ( cbm::flt_greater_zero( sla_cum))
    {
        DroughtStress  droughtstress;
        droughtstress.fh2o_ref = (*_vt)->H2OREF_LEAF_GROWTH();
 
        for (size_t fl = 0; fl < fl_cnt; ++fl)
        {
            _vt->fFol_fl[fl] = _vt->sla_fl[fl] / sla_cum;
            _vt->lai_fl[fl] = mFol_lai * _vt->fFol_fl[fl] * _vt->sla_fl[fl] * droughtstress.linear_threshold( _vt->f_h2o);
            //_vt->lai_fl[fl] = lai_dynamic[_vt->slot] * _vt->fFol_fl[fl] * droughtstress.linear_threshold( _vt->f_h2o);
        }
        for (int fl = fl_cnt; fl < m_setup->canopylayers(); ++fl)
        {
            _vt->fFol_fl[fl] = 0.0;
            _vt->lai_fl[fl] = 0.0;
            _vt->sla_fl[fl] = 0.0;
        }
    }
    else
    {
        for (int fl = 0; fl < m_setup->canopylayers(); ++fl)
        {
            _vt->fFol_fl[fl] = 0.0;
            _vt->lai_fl[fl] = 0.0;
            _vt->sla_fl[fl] = 0.0;
        }
    }
}

References lai_min.

Referenced by PlaMox_update_ground_cover().

Here is the caller graph for this function:

PlaMox_update_ground_cover()

void ldndc::PhysiologyPlaMox::PlaMox_update_ground_cover ( MoBiLE_Plant * )

private

Parameters

[in]

_vt

Plant species

References PlaMox_get_age_factor(), PlaMox_get_biomass_induced_downregulation(), PlaMox_get_foliage_nitrogen_concentration(), PlaMox_get_frost_factor(), PlaMox_get_heat_factor(), PlaMox_get_hypoxia_factor(), PlaMox_get_nitrogen_deficiency(), PlaMox_n_opt(), PlaMox_update_foliage_structure(), PlaMox_update_nitrogen_concentrations(), PlaMox_update_specific_leaf_area(), and plantfamilies.

Here is the call graph for this function:

PlaMox_update_height()

void ldndc::PhysiologyPlaMox::PlaMox_update_height ( MoBiLE_Plant * )

private

Parameters

[in]

_vt

Plant species

PlaMox_update_nitrogen_concentrations()

void ldndc::PhysiologyPlaMox::PlaMox_update_nitrogen_concentrations ( MoBiLE_Plant * _vt )

private

Parameters

[in]

_vt

Plant species

Distribution of total plant nitrogen throughout complete plant assumed to occur instantaneously.

{
    double const n_living_plant( cbm::bound_min( 0.0, n_plant[_vt->slot] - _vt->n_dst - _vt->n_dfol));
    double const nitrogen_satisfaction( cbm::flt_greater_zero( PlaMox_n_opt( _vt)) ? cbm::bound(0.0, n_living_plant / PlaMox_n_opt( _vt), 1.0) : 1.0);
 
//    double const n_fol_opt( get_foliage_nitrogen_concentration( _vt) * _vt->mFol);
 
    double const n_fol_opt( (cbm::flt_greater_zero( (*_vt)->NC_FOLIAGE_MAX()) &&
                             cbm::flt_greater_zero( (*_vt)->NC_FOLIAGE_MIN())) ?
                            _vt->mFol * ((1.0 - nitrogen_satisfaction) * (*_vt)->NC_FOLIAGE_MIN()
                                       + (nitrogen_satisfaction * PlaMox_get_foliage_nitrogen_concentration( _vt))) :
                            _vt->mFol * (*_vt)->NC_FOLIAGE_MAX());
    double const n_lst_opt( (cbm::flt_greater_zero( (*_vt)->NC_STRUCTURAL_TISSUE_MAX()) &&
                             cbm::flt_greater_zero( (*_vt)->NC_STRUCTURAL_TISSUE_MIN())) ?
                            _vt->dw_lst * ((1.0 - nitrogen_satisfaction) * (*_vt)->NC_STRUCTURAL_TISSUE_MIN()
                                       + (nitrogen_satisfaction * (*_vt)->NC_STRUCTURAL_TISSUE_MAX())) :
                            _vt->dw_lst * (*_vt)->NC_STRUCTURAL_TISSUE_MAX());
    double const n_frt_opt( (cbm::flt_greater_zero( (*_vt)->NC_FINEROOTS_MAX()) &&
                             cbm::flt_greater_zero( (*_vt)->NC_FINEROOTS_MIN())) ?
                            _vt->mFrt * ((1.0 - nitrogen_satisfaction) * (*_vt)->NC_FINEROOTS_MIN()
                                       + (nitrogen_satisfaction * (*_vt)->NC_FINEROOTS_MAX())) :
                            _vt->mFrt * (*_vt)->NC_FINEROOTS_MAX());
    double const n_fru_opt( (cbm::flt_greater_zero( (*_vt)->NC_FRUIT_MAX()) &&
                             cbm::flt_greater_zero( (*_vt)->NC_FRUIT_MIN())) ?
                            _vt->mBud * ((1.0 - nitrogen_satisfaction) * (*_vt)->NC_FRUIT_MIN()
                                       + (nitrogen_satisfaction * (*_vt)->NC_FRUIT_MAX())) :
                            _vt->mBud * (*_vt)->NC_FRUIT_MAX());
 
    double const n_tot_opt( n_fol_opt + n_lst_opt + n_fru_opt + n_frt_opt);
    if ( cbm::flt_greater_zero( n_tot_opt))
    {
        // CB: fraction of available N to optimum N
        double const n_tot_opt_scale( n_living_plant / n_tot_opt);
        // CB: N gets distributed evenly over all compartments regarding their optimum N content
        _vt->ncFol = cbm::flt_greater_zero( _vt->mFol) ? n_tot_opt_scale * n_fol_opt / _vt->mFol :
                                                         (*_vt)->NC_FOLIAGE_MAX();
        _vt->n_lst = cbm::flt_greater_zero( _vt->dw_lst) ? n_tot_opt_scale * n_lst_opt :
                                                         0.0;
        _vt->ncBud = cbm::flt_greater_zero( _vt->mBud) ? n_tot_opt_scale * n_fru_opt / _vt->mBud :
                                                         (*_vt)->NC_FRUIT_MAX();
        _vt->ncFrt = cbm::flt_greater_zero( _vt->mFrt) ? n_tot_opt_scale * n_frt_opt / _vt->mFrt :
                                                         (*_vt)->NC_FINEROOTS_MAX();
    }
}

References PlaMox_get_foliage_nitrogen_concentration(), and PlaMox_n_opt().

Referenced by PlaMox_bud_burst(), PlaMox_event_plant(), PlaMox_exsudation(), PlaMox_photosynthesis(), and PlaMox_update_ground_cover().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_update_root_structure()

void ldndc::PhysiologyPlaMox::PlaMox_update_root_structure ( MoBiLE_Plant * , double  )

private

Updates all relevant root structural matters.

Parameters

[in]	_vt	Plant species
[in]	_deltamassFrt	Fine root mass development

Referenced by PlaMox_event_plant().

Here is the caller graph for this function:

PlaMox_update_specific_leaf_area()

void ldndc::PhysiologyPlaMox::PlaMox_update_specific_leaf_area ( MoBiLE_Plant * _vt )

private

Calculates specific leaf area (sla) in each canopy layer.

Parameters

[in]

_vt

Plant species

For mungbean, the species parameter SLAMAX is neglected and sla is calculated based on the following table taken from the WOFOST model parametrisation.

dvs sla 0.0 26.0 1.0 33.0 2.0 16.0

{
    size_t const fl_cnt( _vt->nb_foliagelayers());

    if ( IS_SPECIE( _vt->cname(), "mungbean"))
    {
        double slamax( 26.0);
        if ( !cbm::flt_greater( _vt->dvsFlush, 0.5))
        {
            slamax = 26.0 + _vt->dvsFlush / 0.5 * 7.0;
        }
        else
        {
            slamax = 33.0 - (_vt->dvsFlush - 0.5) / 0.5 * 17.0;
        }
 
        for (size_t fl = 0; fl < fl_cnt; ++fl)
        {
            _vt->sla_fl[fl] = slamax;
        }
    }
    else if ( m_veg->is_family( _vt, ":rice:"))
    {
        double const dvs( (*_vt)->GDD_FLOWERING() > 0.0 ?
                         cbm::bound_max( _vt->growing_degree_days / (*_vt)->GDD_FLOWERING(), 1.0) :
                         _vt->dvsMort);
 
        double const delta_sla( dvs * (*_vt)->SLADECLINE() * (*_vt)->SLAMAX());
        for (size_t fl = 0; fl < fl_cnt; ++fl)
        {
            _vt->sla_fl[fl] = cbm::bound_min( 0.0, (*_vt)->SLAMAX() - delta_sla);
        }
    }
    else
    {
        // reduction of specific leaf area with crop age
        double sla_red( 1.0);
        if (_vt->groupId() == SPECIES_GROUP_GRASS)
        {
            if ( cbm::flt_greater( _vt->dvsMort, 0.5))
            {
                sla_red = 1.0 - ((*_vt)->SLADECLINE() * (_vt->dvsMort - 0.5) / 0.5);
            }
        }
        else
        {
            sla_red = 1.0 - ((*_vt)->SLADECLINE() * _vt->dvsMort);
        }
 
        for (size_t fl = 0; fl < fl_cnt; ++fl)
        {
            _vt->sla_fl[fl] = (*_vt)->SLAMAX() * sla_red;
        }
    }
 
    for (int fl = fl_cnt; fl < m_setup->canopylayers(); ++fl)
    {
        _vt->sla_fl[fl] = 0.0;
    }
}

Referenced by PlaMox_update_ground_cover().

Here is the caller graph for this function:

Member Data Documentation

plamox_root_system

ldndc::growable_array< BaseRootSystemDNDC*, 1000, 1 > ldndc::PhysiologyPlaMox::plamox_root_system

private

Root system.

• rooting depth
• root distribution

Referenced by PlaMox_event_harvest(), PlaMox_event_plant(), PlaMox_exsudation(), and ~PhysiologyPlaMox().

Tcrit

double ldndc::PhysiologyPlaMox::Tcrit

private

the timing of the episode of high temperatures relative to flowering

the duration of the episode of high temperatures relative to flowering

The critical temperature at which temperatuer affects pod-set, dependent on timing and duration of the heatshock (°C)

Referenced by PlaMox_heat_stress_limitation().