ldndc::PhysiologyPlaMox Class Reference

Plamox. More...

Inherits ldndc::MBE_LegacyModel.

Public Member Functions
	~PhysiologyPlaMox ()
	Delete allocated classes. More...

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 More...
lerr_t	PlaMox_event_harvest (MoBiLE_Plant *, EventAttributes const &)
	handle harvest event More...
lerr_t	PlaMox_photosynthesis (MoBiLE_Plant *)
	Update of information needed by photofarquhar. More...
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. More...
void	PlaMox_update_height (MoBiLE_Plant *)
	calculates new height of plant depending on the ratio of current to optimum aboveground biomass More...
void	PlaMox_update_ground_cover (MoBiLE_Plant *)
void	PlaMox_update_foliage_structure (MoBiLE_Plant *)
	Calculation of canopy layer properties: More...
void	PlaMox_update_specific_leaf_area (MoBiLE_Plant *)
	Calculates specific leaf area (sla) in each canopy layer. More...
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. More...
double	PlaMox_get_frost_factor (MoBiLE_Plant *, double)
	Calculates a temperature factor. More...
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. More...

Private Attributes
NitrogenFixation *	NitrogenFixation_
	Nitrogen fixation.
LD_PlantFunctions	m_pf
	All kind of plant related functions.
ldndc::growable_array< BaseRootSystemDNDC *, 1000, 1 >	root_system
	Root system. More...
cbm::string_t	transpiration_method
	Transpiration method used by PlaMox.
bool	have_drought_stress
	Consider drought 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 More...
double	Tzero
	The temperature at which there is zero pod-set (°C)

Detailed Description

Plamox.

Author

David Kraus

Constructor & Destructor Documentation

~PhysiologyPlaMox()

ldndc::PhysiologyPlaMox::~PhysiologyPlaMox

(

)

Delete allocated classes.

Delete:

• roots system
• nitrogen fixation

References droughtstress_method, have_drought_stress, m_pf, NitrogenFixation_, plantfamilies, root_system, and transpiration_method.

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

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.

...

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

Referenced by PlaMox_event_plant().

{
    if ( 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( root_system[_vt->slot]);
    root_system[_vt->slot] = NULL;

    return  LDNDC_ERR_OK;
}

Here is the caller graph for this function:

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.

...

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_event_harvest(), PlaMox_update_nitrogen_concentrations(), PlaMox_update_root_structure(), plantfamilies, root_q_vt_, and root_system.

Referenced by PlaMox_step_init().

{
    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 initial_biomass = _attributes.get( "/initial-biomass", 0.0);
    if ( cbm::flt_equal( initial_biomass, 0.0))
    {
        if ( m_veg->is_family( _vt, ":rice:"))
        {
            initial_biomass = 200.0;
        }
        else if ( m_veg->is_family( _vt, ":wheat:"))
        {
            initial_biomass = 150.0;
        }
        else if ( m_veg->is_family( _vt, ":corn:"))
        {
            initial_biomass = 50.0;
        }
        else if ( m_veg->is_family( _vt, ":rapeseed:"))
        {
            initial_biomass = 10.0;
        }
    }

    initial_biomass = cbm::bound_min( 0.0001, initial_biomass * 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;

    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 (root_system.size() <= _vt->slot)
    {
        root_system.resize(_vt->slot+1);
    }

    ldndc_kassert( root_system[_vt->slot] == NULL);
    root_system[_vt->slot] = LD_Allocator->construct_args< RootSystemDNDC >( 1, m_state, io_kcomm);
    if ( !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;
}

Here is the call graph for this function:

Here is the caller 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

Referenced by PlaMox_photosynthesis().

{
    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( _p->dvsFlush, 0.95))
            {
                return ( 1.0);
            }
            else
            {
                return cbm::bound_min( 0.0, (1.0 - _p->dvsFlush) / 0.05);
            }
        }
    }
}

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

References fractional_cover.

Referenced by PlaMox_photosynthesis().

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

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

Referenced by PlaMox_exsudation(), and PlaMox_photosynthesis().

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

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

Referenced by PlaMox_photosynthesis().

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

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} \)
  

References PlaMox_get_foliage_nitrogen_concentration().

Referenced by PlaMox_photosynthesis(), and PlaMox_update_nitrogen_concentrations().

{
    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());
}

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

References allocation_factor_fruit, allocation_factor_leafs, allocation_factor_roots, allocation_factor_stems, chill_factor, fractional_cover, FTS_TOT_, have_drought_stress, m_pf, NitrogenFixation_, 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(), PlaMox_n_opt(), PlaMox_nitrogen_fixation(), PlaMox_nitrogen_uptake(), PlaMox_respiration(), PlaMox_update_nitrogen_concentrations(), root_q_vt_, and root_system.

{
    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_temp));
    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)
    {
        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( _vt);
    m_photo.set_vegetation_non_stomatal_water_limitation_state( 0.0, 0.0, 0.0, 0.0);
    
    m_photo.solve();
    
    m_photo.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];
        // the root length for mass from photosynthesis gets adapted in update root system
        _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];
        
        dcFru[_vt->slot] = 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;
        dcLst[_vt->slot] = allocation_factor_stems[_vt->slot] * carbonuptake_sum;
        
        PlaMox_update_nitrogen_concentrations( _vt);
    }
    
    return LDNDC_ERR_OK;
}

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.

References lai_min.

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

PlaMox_update_ground_cover()

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

private

Parameters

[in]

_vt

Plant species

Referenced by PlaMox_transpiration().

Here is the caller graph for this function:

PlaMox_update_height()

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

private

calculates new height of plant depending on the ratio of current to optimum aboveground biomass

Parameters

[in]

_vt

Plant species

References fractional_cover.

{
    double const fol_opt( (*_vt)->MFOLOPT() * fractional_cover[_vt->slot]);
    double const lst_opt( (1.0 - (*_vt)->FALEAF()) / (*_vt)->FALEAF() * fol_opt);
    if ( _vt->group() == "crop")
    {
        //height evegrowth starts with stem elongation
        //minimum of 1% development until start of height growth required: dvs_of_start_height !> 0.0
        double const dvs_of_start_height( cbm::bound_min( 0.01, (*_vt)->GDD_STEM_ELONGATION() / (*_vt)->GDD_MATURITY()));
        //minimum of 2% development until end of height growth required: dvs_of_end_height !> dvs_of_start_height
        double const dvs_of_max_height( cbm::bound_min( 0.02, gdd_grain_filling[_vt->slot] / (*_vt)->GDD_MATURITY()));

        //until start of stem elongation, height modeled with plant development
        //10% of final height is always reached until start of stem elongation
        double const height_fraction_at_stem_elongation( 0.1);
        double height_fraction( cbm::bound_max( _vt->dvsFlush / dvs_of_start_height, 1.0) * height_fraction_at_stem_elongation);
        if ( cbm::flt_greater( _vt->dvsFlush, dvs_of_start_height))
        {
            double const biomass_fraction( cbm::bound_max( cbm::sqrt((_vt->dw_lst + _vt->mFol) / (lst_opt + fol_opt)), 1.0));
            //bound biomass-depending height by plant development
            //max should not be reached before start of grain filling (end of phase of stem elongation)
            height_fraction = cbm::bound( height_fraction,
                                          biomass_fraction,
                                          height_fraction_at_stem_elongation +
                                          (1.0 - height_fraction_at_stem_elongation) *
                                          (_vt->dvsFlush - dvs_of_start_height)/ (dvs_of_max_height- dvs_of_start_height));
        }
        _vt->height_max = cbm::bound_min( _vt->height_max, height_fraction * (*_vt)->HEIGHT_MAX());
        _vt->height_at_canopy_start = (*_vt)->CB() * _vt->height_max;
    }
    else
    {
        _vt->height_max = cbm::bound_max( (_vt->dw_lst + _vt->mFol) / (lst_opt + fol_opt) * (*_vt)->HEIGHT_MAX(), (*_vt)->HEIGHT_MAX());
        _vt->height_at_canopy_start = (*_vt)->CB() * _vt->height_max;
    }

    // update height of canopy layers (m)
    ph_.update_canopy_layers_height( m_veg);
}

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.

References PlaMox_get_foliage_nitrogen_concentration(), and PlaMox_n_opt().

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

{
    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();
    }
}

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(), and PlaMox_transpiration().

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

Member Data Documentation

root_system

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

private

Root system.

• rooting depth
• root distribution

Referenced by PlaMox_event_harvest(), PlaMox_event_plant(), PlaMox_exsudation(), PlaMox_photosynthesis(), PlaMox_transpiration(), 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().