ldndc::PhysiologyPlaMox Class Reference

Vegetation model PlaMox: carbon and nitrogen dynamics of crops and grass (see PlaMox - Plant Growth Model). More...

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

Public Member Functions
	PhysiologyPlaMox (MoBiLE_State *, cbm::io_kcomm_t *, timemode_e)
	Constructor.
	~PhysiologyPlaMox ()
	Delete allocated classes.
lerr_t	configure (ldndc::config_file_t const *)
lerr_t	register_ports (cbm::io_kcomm_t *)
lerr_t	initialize ()
lerr_t	solve ()
lerr_t	unregister_ports (cbm::io_kcomm_t *)
lerr_t	finalize ()
	Finalization (nothing to do)
lerr_t	sleep ()
	Sleep (nothing to do)
lerr_t	wake ()
	Wake up (nothing to do)

Private Types
enum	plant_life_cycle_e {   ANNUAL = 0 ,   BIENNIAL ,   PLURIENNIAL ,   PERENNIAL }
	Life cycle of a plant. More...
enum	plamox_family_e {   FAMILY_RICE = 1u << 0 ,   FAMILY_WHEAT = 1u << 1 ,   FAMILY_CORNS = 1u << 2 ,   FAMILY_BRASSICANAPUS = 1u << 3 ,   FAMILY_MILT = 1u << 4 ,   FAMILY_SORG = 1u << 5 ,   FAMILY_CASSAVA = 1u << 6 ,   FAMILY_PERENNIAL = 1u << 7 }
	Species families with specific functions in PlaMox (bit flags) More...
typedef std::vector< MoBiLE_Plant * >::iterator	PlaMoxIterator
	Iterator over all plants whose family is handled by PlaMox (model option plantfamilies), see PlaMox_update_plant_list()

Private Member Functions
	LMOD_EXPORT_MODULE_INFO (PhysiologyPlaMox,"physiology:plamox","Physiology PlaMox")
	Module registration.
lerr_t	PlaMox_step_init ()
	pre-run initialization each time step
lerr_t	PlaMox_step_resize ()
	resize plant species vector
lerr_t	PlaMox_step_out ()
	Post-time step: oxygen deficiency, soil nitrogen and published fields.
lerr_t	PlaMox_management ()
	Applies grazing and cutting events.
lerr_t	PlaMox_planting ()
	Handles all pending planting events.
lerr_t	PlaMox_event_plant (MoBiLE_Plant *, EventAttributes const &)
	Initializes a newly planted plant (see Planting)
lerr_t	PlaMox_harvest ()
	Handles all pending harvest events.
lerr_t	PlaMox_event_harvest (MoBiLE_Plant *, EventAttributes const &)
	Harvests a plant (see Harvest)
lerr_t	PlaMox_reset_phenology (MoBiLE_Plant *)
	Resets the phenological state of a plant.
lerr_t	PlaMox_photosynthesis (MoBiLE_Plant *)
	Photosynthesis and allocation of assimilates (see Photosynthesis and growth)
void	PlaMox_vernalization (MoBiLE_Plant *)
	Chilling units and chill factor (see Vernalization)
void	PlaMox_growing_degree_days (MoBiLE_Plant *)
	Growing degree days, development stage, mortality state and emergence (see Growing degree days)
void	PlaMox_heat_stress_limitation (MoBiLE_Plant *_vt)
	Heat stress around flowering that limits the fruit set (see Heat stress around flowering)
void	PlaMox_plant_development_crop (MoBiLE_Plant *)
	Allocation fractions of crops (see Crops)
lerr_t	PlaMox_allocation_grass (MoBiLE_Plant *)
	Allocation fractions of grass (see Grass)
lerr_t	PlaMox_bud_burst (MoBiLE_Plant *)
	Translocation from storage to foliage of grass (see Bud burst of grass)
lerr_t	PlaMox_redistribution (MoBiLE_Plant *)
	Retranslocation of stem and leaf mass to the fruit (see Retranslocation to the fruit)
void	PlaMox_respiration (MoBiLE_Plant *)
	Maintenance and growth respiration (see Respiration)
void	PlaMox_exsudation (MoBiLE_Plant *)
	Root exudation (see Root exudation)
void	PlaMox_nitrogen_uptake (MoBiLE_Plant *)
	Nitrogen uptake from the soil (see Nitrogen uptake)
lerr_t	PlaMox_nitrogen_fixation (MoBiLE_Plant *)
	Symbiotic nitrogen fixation (see Nitrogen fixation)
lerr_t	PlaMox_senescence (MoBiLE_Plant *)
	Aboveground and belowground senescence (see Senescence)
lerr_t	PlaMox_abscission (MoBiLE_Plant *)
	Shedding of dead foliage and stems of grass (see Abscission of grass)
void	PlaMox_drought (MoBiLE_Plant *)
	Drought stress index (see Drought stress)
void	PlaMox_transpiration (MoBiLE_Plant *)
	Potential transpiration (see Transpiration)
void	PlaMox_update_root_structure (MoBiLE_Plant *, double)
	Distributes new fine root mass over the soil layers and updates the root conductivity (see Root structure)
void	PlaMox_update_height (MoBiLE_Plant *)
	Plant height and height of the canopy base (see Plant height)
void	PlaMox_update_ground_cover (MoBiLE_Plant *)
	Ground cover (see Ground cover)
void	PlaMox_update_foliage_structure (MoBiLE_Plant *)
	Foliage distribution and leaf area index of the foliage layers (see Leaf area)
void	PlaMox_update_specific_leaf_area (MoBiLE_Plant *)
	Specific leaf area of the foliage layers (see Specific leaf area)
void	PlaMox_update_nitrogen_concentrations (MoBiLE_Plant *)
	Distributes the plant nitrogen among the living compartments (see Nitrogen distribution)
double	PlaMox_get_nitrogen_deficiency (MoBiLE_Plant *)
	Nitrogen deficiency factor of photosynthesis [-] (see Nitrogen deficiency)
double	PlaMox_get_biomass_induced_downregulation (MoBiLE_Plant *)
	Biomass-induced down-regulation of photosynthesis [-] (see Biomass-induced down-regulation)
double	PlaMox_get_age_factor (MoBiLE_Plant *)
	Age factor [-] (see Age factor)
double	PlaMox_get_frost_factor (MoBiLE_Plant *, double)
	Low temperature factor [-] (see Low temperature factor)
double	PlaMox_get_hypoxia_factor (MoBiLE_Plant *)
	Photosynthesis factor for oxygen deficiency [-] (see Oxygen deficiency (hypoxia))
double	PlaMox_get_heat_factor (MoBiLE_Plant *)
	Heat factor [-] (see Heat factor)
double	PlaMox_get_foliage_nitrogen_concentration (MoBiLE_Plant *)
	Optimum foliage nitrogen concentration [kgN kgDW-1] (see Optimum foliage nitrogen concentration)
double	PlaMox_n_opt (MoBiLE_Plant *)
	Optimum nitrogen of the living plant [kgN m-2] (see Optimum plant nitrogen)
void	PlaMox_balance_check (int)
	Carbon and nitrogen balance check (stage ON_ENTRY or ON_EXIT)
lerr_t	PLAMOX_CHECK_FOR_NEGATIVE_VALUE (char const *)
	Debugging helper: checks the plant states for negative values or NaN.
void	PlaMox_update_plant_list ()
	Updates the list of plants handled by PlaMox and their family flags.
bool	PlaMox_is_family (MoBiLE_Plant const *_p, unsigned int _family) const
	True if the plant belongs to the given family (see plamox_family_e)
PlaMoxIterator	begin ()
	First plant handled by PlaMox.
PlaMoxIterator	end ()
	End of the plants handled by PlaMox.
plant_life_cycle_e	PlaMox_get_life_cycle (MoBiLE_Plant *)
	Life cycle of a plant: perennial for grass and the families ment and alfa, annual otherwise.

Private Attributes
MoBiLE_State *	m_state
	Model state.
cbm::io_kcomm_t *	io_kcomm
	Input/output communicator.
input_class_climate_t const &	cl_
	Climate input.
input_class_setup_t const *	m_setup
	Setup input (e.g., canopy layers, latitude)
input_class_soillayers_t const &	sl_
	Soil layers input.
input_class_species_t const *	m_species
	Species input.
input_class_speciesparameters_t const *	m_speciesparameters
	Species parameters input.
input_class_siteparameters_t const *	m_siteparameters
	Site parameters input.
remotesensing::input_class_remotesensing_t const *	rm_
	Optional remote sensing input (leaf area index)
MoBiLE_PlantVegetation *	m_veg
	Vegetation (all plants)
substate_airchemistry_t &	ac_
	Air chemistry state (CO2 concentration)
substate_microclimate_t &	mc_
	Microclimate state (temperature, radiation, vapour pressure deficit)
substate_physiology_t &	ph_
	Physiology state (canopy layers, nitrogen uptake, exports)
substate_soilchemistry_t &	sc_
	Soil chemistry state (nitrogen, carbon, litter, oxygen)
substate_watercycle_t &	wc_
	Water cycle state (soil water, ice, transpiration)
SubscribedEvent< LD_EventHandlerQueue >	m_HarvestEvents
	Harvest events.
SubscribedEvent< LD_EventHandlerQueue >	m_PlantEvents
	Planting events.
PublishedField< double >	aboveground_biomass
	Published field: aboveground biomass of all plants [kgDW m-2].
PublishedField< double >	maturity_status
	Published field: sum of the development stages of all plants [-].
PublishedField< double >	growing_degree_days_maturity
	Published field: sum of the growing degree days of all plants [°C d].
PublishedField< double >	dEmerg
	Published field: sum of the days of emergence of all plants.
PublishedField< double >	carbon_plant_biomass_total_exported_from_field
	Published field: carbon exported with harvest [kgC m-2].
PublishedField< double >	carbon_plant_biomass_fruit_exported_from_field
	Published field: carbon exported with the fruit [kgC m-2].
PublishedField< double >	nitrogen_plant_biomass_total_exported_from_field
	Published field: nitrogen exported with harvest [kgN m-2].
PublishedField< double >	nitrogen_plant_biomass_fruit_exported_from_field
	Published field: nitrogen exported with the fruit [kgN m-2].
EventHandlerGraze	m_eventgraze
	Grazing event handler.
EventHandlerCut	m_eventcut
	Cutting event handler.
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.
lvector_t< double >	no3_sl
	Soil nitrate (aerobic + anaerobic) available for uptake in the time step [kgN m-2].
lvector_t< double >	nh4_sl
	Soil ammonium available for uptake in the time step [kgN m-2].
lvector_t< double >	don_sl
	Soil DON available for uptake in the time step [kgN m-2].
bool	have_drought_stress
	Consider drought stress yes/no.
bool	have_heat_stress
	Consider heat stress yes/no.
cbm::string_t	droughtstress_method
	Drought stress method (option droughtstressmethod: rootweighted or uniform)
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< long long int >	seconds_crop_planting
	Time of planting [s].
lvector_t< double >	gdd_grain_filling
	Growing degree days at the onset of grain filling [°C d] (GDD_GRAIN_FILLING, delayed by drought for corn)
lvector_t< double >	hypoxia
	Hypoxia index of the root system [-] (0: no stress, 1: no oxygen)
lvector_t< int >	days_after_emergence
	Days after emergence [d] (-1 before emergence)
lvector_t< std::string >	location
	Location of the plant for location-specific nitrogen supply.
lvector_t< double >	dw_retranslocation_stem
	Stem mass available for retranslocation to the fruit [kgDW m-2].
lvector_t< double >	dw_retranslocation_foliage
	Foliage mass available for retranslocation to the fruit [kgDW m-2].
lvector_t< double >	dw_fol_old
	Foliage mass at the beginning of the time step [kgDW m-2].
lvector_t< double >	lai_dynamic
	Leaf area index used with remote sensing input [m2 m-2].
std::map< std::string, double >	gdd_target
	Growing degree days at the last harvest per plant name, used as maturity target [°C d].
bool	have_automatic_nitrogen
	Potential nitrogen mode (option npot): demand not covered by uptake is supplied directly.
double	automatic_nitrogen_uptake
	Nitrogen supplied in the potential nitrogen mode in the time step [kgN m-2].
double	photoperiod_min
	Minimum day length of the site [h].
double	photoperiod_max
	Maximum day length of the site [h].
double	tot_c_
	Carbon balance at the beginning of the time step [kgC m-2].
double	tot_n_
	Nitrogen balance at the beginning of the time step [kgN m-2].
double	timestep_c_assi
	Carbon assimilated (and added at planting) in the time step [kgC m-2].
double	n_at_planting
	Nitrogen added with the initial biomass at planting in the time step [kgN m-2].
lvector_t< double >	transplanting_shock_vt
	Transplanting shock [-] (1 at transplanting, decreasing by 0.1 per day)
lvector_t< int >	yearly_cuts
	Number of cutting events in the current year.
lvector_t< bool >	reset_phenology
	Phenology of a perennial plant is reset as soon as MOS > 0.99.
lvector_t< double >	n_plant
	Total plant nitrogen including dead foliage and stems [kgN m-2].
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 leaf area index [m2 m-2]. For crops with GDD_AUTOTROPHY, it increases from the value at planting to lai_min_at_tillering at AGDD = GDD_AUTOTROPHY.
lvector_t< double >	lai_min_at_tillering
	Minimum leaf area index at the end of the seedling phase (GDD_AUTOTROPHY) [m2 m-2].
lvector_t< double >	fractional_cover
	Density of seeded plants with regard to optimum (full area) seeding (-).
lvector_t< double >	chill_units
	Accumulated chilling units for vernalization;.
lvector_t< double >	m_fruit_maximum
	Maximum fruit mass [kgDW m-2] (M_FRUIT_OPT reduced by heat stress and spikelet sterility; -1: no limit)
lvector_t< double >	spikelets_sterility
	Spikelet sterility caused by oxygen deficiency [-].
lvector_t< double >	nc_fol_opt
	Reference foliage nitrogen concentration of the nitrogen deficiency factor [kgN kgDW-1].
lvector_t< unsigned int >	root_q_vt_
	Number of rooted soil layers [-], i.e., the index of the first soil layer without roots (invalid if the plant has no root system)
lvector_t< double >	daytime_temperatures
	Daytime temperatures of the last 19 days around flowering [°C] (shared by all plants)
lvector_t< double >	influence_heat_daily
	Daily heat impact on grain filling of the last 19 days [-].
double	influence_heat_reduction_grainfilling
	Heat factor for grain filling (minimum of the daily heat impact) [-].
double	day_of_flowering
	Days after emergence at flowering [d] (999 before flowering; shared by all plants)
double	Tcrit
	Critical temperature above which heat reduces the fruit set [°C] (depends on timing and duration of the heat episode)
double	Tzero
	Temperature of zero fruit set [°C].
double	c_total_exported
	Carbon exported with harvest in the time step, including roots [kgC m-2].
double	c_fruit_exported
	Carbon exported with the fruit in the time step [kgC m-2].
double	n_total_exported
	Nitrogen exported with harvest in the time step, including roots [kgN m-2].
double	n_fruit_exported
	Nitrogen exported with the fruit in the time step [kgN m-2].
std::vector< MoBiLE_Plant * >	plamox_plants
	Plants handled by PlaMox in the current time step (in the order of the vegetation); updated at the beginning of each time step and after planting.
std::vector< std::string >	plantfamily_tags
	Family tags (":family:") of the plant families handled by PlaMox.
lvector_t< unsigned int >	family_flags
	Species family flags of each plant (slot), see plamox_family_e; updated with the plant list.

Detailed Description

Vegetation model PlaMox: carbon and nitrogen dynamics of crops and grass (see PlaMox - Plant Growth Model).

Author

David Kraus

Member Enumeration Documentation

plamox_family_e

enum ldndc::PhysiologyPlaMox::plamox_family_e

private

Species families with specific functions in PlaMox (bit flags)

Enumerator
FAMILY_RICE	family :rice:
FAMILY_WHEAT	family :wheat:
FAMILY_CORNS	family :corns:
FAMILY_BRASSICANAPUS	family :brassicanapus:
FAMILY_MILT	family milt
FAMILY_SORG	family sorg
FAMILY_CASSAVA	family cassava
FAMILY_PERENNIAL	perennial life cycle (grass or families ment, alfa)

    {
        FAMILY_RICE = 1u << 0,
        FAMILY_WHEAT = 1u << 1,
        FAMILY_CORNS = 1u << 2,
        FAMILY_BRASSICANAPUS = 1u << 3,
        FAMILY_MILT = 1u << 4,
        FAMILY_SORG = 1u << 5,
        FAMILY_CASSAVA = 1u << 6,
        FAMILY_PERENNIAL = 1u << 7
    };

plant_life_cycle_e

enum ldndc::PhysiologyPlaMox::plant_life_cycle_e

private

Life cycle of a plant.

Enumerator
ANNUAL	Annual plant.
BIENNIAL	Biennial plant (currently not used)
PLURIENNIAL	Pluriennial plant (currently not used)
PERENNIAL	Perennial plant.

    {
        ANNUAL = 0,
        BIENNIAL,
        PLURIENNIAL,
        PERENNIAL
    };

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, and plamox_root_system.

Member Function Documentation

configure()

lerr_t ldndc::PhysiologyPlaMox::configure

(

ldndc::config_file_t const *

_cf

)

Reads the model options (see Model options).

{
    /* logger stream */
    std::string  loggerstream = get_option< char const * >( "loggerstream", "null");
    loggerstream = cbm::format_expand( loggerstream);
    PhysiologyPlaMoxLogger->initialize( loggerstream.c_str(), _cf->log_level());
    
    /* option npot: potential nitrogen supply (see plamox_options in doc/userguide.dox) */
    have_automatic_nitrogen = get_option< bool >( "npot", false);
    if ( have_automatic_nitrogen)
    {
        KLOGINFO_TO( PhysiologyPlaMoxLogger, "PlaMox runs in potential nitrogen mode!");
    }
    
    /* option transpirationmethod */
    cbm::string_t transpiration_method = get_option< char const * >("transpirationmethod", "wateruseefficiency");
    if ( transpiration_method == "wateruseefficiency")
    {
        wc_.transpiration_method = static_cast<lflags_t>(substate_watercycle_t::WATERUSEEFFICIENCY);
        KLOGINFO_TO( PhysiologyPlaMoxLogger,
                     "Transpiration estimated via carbon assimilation and water use efficiency!");
    }
    else
    {
        wc_.transpiration_method = static_cast<lflags_t>(substate_watercycle_t::POTENTIALTRANSPIRATION);
        KLOGINFO_TO( PhysiologyPlaMoxLogger,
                     "Transpiration estimated via stomatal conductance and vapour pressure deficit!");
    }
    
    /* option droughtstress */
    have_drought_stress = get_option< bool >( "droughtstress", true);
    if ( !have_drought_stress)
    {
        KLOGINFO_TO( PhysiologyPlaMoxLogger, "PlaMox runs not considering drought stress!");
    }
    /* option heatstress */
    have_heat_stress = get_option< bool >("heatstress", true);
    if (!have_heat_stress)
    {
        KLOGINFO_TO(PhysiologyPlaMoxLogger, "PlaMox runs not considering heat stress!");
    }
    
    /* option droughtstressmethod */
    droughtstress_method = get_option< char const * >( "droughtstressmethod", "rootweighted");
    if ( droughtstress_method == "uniform")
    {
        KLOGINFO_TO( PhysiologyPlaMoxLogger,
                    "Drought stress estimated from water availability in the rooted zone!");
    }
    else
    {
        KLOGINFO_TO( PhysiologyPlaMoxLogger,
                    "Drought stress estimated from water availability in the rooted zone ",
                    "weighted by fine roots distribution!");
    }
    
    plamox_berryball.stomatalconductance_method = leuning_1995_b;
    
    /* option plantfamilies */
    cbm::string_t  plantfamilylist = get_option< char const * >( "plantfamilies", "crops grass");
    plantfamilies = plantfamilylist.split( ' ');
    plantfamily_tags.clear();
    for ( size_t i = 0; i < plantfamilies.size(); ++i)
    {
        cbm::string_t family = ":";
        family << plantfamilies[i] <<":";
        plantfamily_tags.push_back( family.c_str());
    }
    
    return  LDNDC_ERR_OK;
}

References droughtstress_method, have_automatic_nitrogen, have_drought_stress, have_heat_stress, ldndc::PhysiologyPlaMoxLogger, plamox_berryball, plantfamilies, plantfamily_tags, and wc_.

initialize()

lerr_t ldndc::PhysiologyPlaMox::initialize

(

)

Checks the time resolution (subdaily, at least two time steps per day) and acquires the optional remote sensing input (leaf area index).

{
    /* check for proper time resolution */
    if ( lclock()->time_resolution() < 2)
    {
        KLOGERROR( "module \"", name(), "\" requires higher time resolution!\nchosen time resolution: ",
                  lclock()->time_resolution()," required time resolution: >1");
        return  LDNDC_ERR_OBJECT_INIT_FAILED;
    }
    
    /* optional remote sensing input (e.g., leaf area index) */
    cbm::source_descriptor_t  rm_source_info;
    lid_t  rm_id = io_kcomm->get_input_class_source_info< remotesensing::input_class_remotesensing_t >( &rm_source_info);
    if ( rm_id != invalid_lid)
    {
        rm_ = io_kcomm->acquire_input< remotesensing::input_class_remotesensing_t >( &rm_source_info);
    }
    else
    {
        rm_ = NULL;
    }
    
    return  LDNDC_ERR_OK;
}

References io_kcomm, and rm_.

PlaMox_balance_check()

void ldndc::PhysiologyPlaMox::PlaMox_balance_check ( int _stage )

private

Carbon and nitrogen balance check (stage ON_ENTRY or ON_EXIT)

Carbon and nitrogen balance check of all PlaMox plants. The plant carbon and nitrogen plus the cumulative litter, exudation and export fluxes minus the inputs (assimilation; uptake, fixation, automatic supply and planting for nitrogen) are stored on entry (ON_ENTRY). On exit (ON_EXIT), a warning is issued if they changed by more than cbm::DIFFMAX.

{
    double tot_c( - timestep_c_assi
                 + sc_.accumulated_c_litter_stubble
                 + ph_.accumulated_c_export_harvest
                 + ph_.accumulated_c_export_grazing
                 + sc_.accumulated_c_litter_above
                 + sc_.accumulated_c_litter_below_sl.sum()
                 + sc_.accumulated_c_root_exsudates_sl.sum());
    double tot_n( - automatic_nitrogen_uptake - n_at_planting
                 - m_pf.accumulated_n_uptake()
                 + sc_.accumulated_n_litter_stubble
                 + ph_.accumulated_n_export_harvest
                 + ph_.accumulated_n_export_grazing
                 + sc_.accumulated_n_litter_above
                 + sc_.accumulated_n_litter_below_sl.sum());
    
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        tot_c += p->total_biomass() * cbm::CCDM + p->rGro + p->rRes + p->rTra;
        
        tot_n += p->total_nitrogen() - p->n2_fixation;
    }
    if ( _stage == ON_ENTRY)
    {
        tot_c_ = tot_c;
        tot_n_ = tot_n;
    }
    else if ( _stage == ON_EXIT)
    {
        double difference( tot_c_ - tot_c);
        if ( cbm::flt_greater( std::abs( difference), cbm::DIFFMAX))
        {
            KLOGWARN("C-Leak:  difference is ", difference * cbm::M2_IN_HA, " kg C ha-1");
        }
        
        difference = tot_n_ - tot_n;
        if ( cbm::flt_greater( std::abs( difference), cbm::DIFFMAX))
        {
            KLOGWARN("N-Leak:  difference is ", difference * cbm::M2_IN_HA, " kg N ha-1");
        }
    }
    else
    {
        KLOGFATAL( "[BUG]  Unknown stage for Balance Check");
    }
}

References automatic_nitrogen_uptake, begin(), end(), m_pf, n_at_planting, ph_, sc_, timestep_c_assi, tot_c_, and tot_n_.

Referenced by PlaMox_get_age_factor(), and solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_event_harvest()

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

private

Harvests a plant (see Harvest)

Parameters

_vt	Plant
_attributes	Attributes of the harvest event

Returns

LDNDC_ERR_OK on success, an error code if the plant has no root system or the harvest attributes are invalid

Applies a harvest event to a plant (see Harvest).

{
    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 + root_c_export;
    c_fruit_exported += fru_c_export;
    n_total_exported += straw_n_export + fru_n_export + root_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;
        _vt->rootlength_sl[sl] = 0.0;
        _vt->hypoxia_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;
    _vt->chill_factor = 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, c_fruit_exported, c_total_exported, chill_units, days_after_emergence, dw_fol_old, dw_retranslocation_foliage, dw_retranslocation_stem, hypoxia, io_kcomm, lai_dynamic, m_fruit_maximum, m_setup, n_fruit_exported, n_plant, n_total_exported, ph_, plamox_root_system, root_q_vt_, sc_, seconds_crop_planting, sl_, spikelets_sterility, and yearly_cuts.

Referenced by PlaMox_harvest().

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

Initializes a newly planted plant (see Planting)

Parameters

_vt	Plant
_attributes	Attributes of the planting event

Returns

LDNDC_ERR_OK on success, an error code if the species group is not supported or the root system cannot be created

Initializes the state of a newly planted plant (see Planting).

{
    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);
 
    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;
    _vt->chill_factor = 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;
 
        if ( cbm::flt_greater_zero( (*_vt)->GDD_AUTOTROPHY()))
        {
            _vt->mFol = 0.01 * initial_biomass;
            _vt->mFrt = initial_biomass - _vt->mFol;
            _vt->dw_lst = 0.0;
            _vt->mBud = 0.0;
            _vt->mSap = 0.0;
            _vt->mCor = 0.0;
 
            //assuming a constant value of 50% of seeds being respired and 50% being allocated to leaves
            double const leaves_from_seed( 0.5 * 0.5);;
            lai_min[_vt->slot] = 0.001;
            lai_min_at_tillering[_vt->slot] = cbm::bound_min( lai_min[_vt->slot],
                                                              leaves_from_seed * initial_biomass * (*_vt)->SLAMAX());
        }
        else
        {
            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] = 0.01;
            lai_min_at_tillering[_vt->slot] = 0.01;
        }
 
        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;
        lai_min_at_tillering[_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);
    }
 
    if ( plamox_root_system[_vt->slot])
    {
        /* root system left over from a plant that was removed without PlaMox
         * harvest (should not happen; safeguard against leaking it) */
        KLOGWARN( "Replacing existing root system  [species=", _vt->name(),"]");
        LD_Allocator->destroy( plamox_root_system[_vt->slot]);
        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] = sl_.soil_layer_cnt();
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        if (cbm::flt_greater( sc_.depth_sl[sl], seed_depth))
        {
            root_q_vt_[_vt->slot] = sl+1;
            break;
        }
    }
 
    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_units, days_after_emergence, daytime_temperatures, dw_fol_old, dw_retranslocation_foliage, dw_retranslocation_stem, fractional_cover, gdd_grain_filling, gdd_target, hypoxia, io_kcomm, lai_dynamic, lai_min, lai_min_at_tillering, location, m_fruit_maximum, m_pf, m_species, m_state, m_veg, mc_, n_at_planting, n_plant, nc_fol_opt, PlaMox_reset_phenology(), plamox_root_system, PlaMox_update_nitrogen_concentrations(), PlaMox_update_root_structure(), root_q_vt_, sc_, seconds_crop_planting, sl_, spikelets_sterility, timestep_c_assi, and transplanting_shock_vt.

Referenced by PlaMox_planting().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_get_hypoxia_factor()

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

private

Photosynthesis factor for oxygen deficiency [-] (see Oxygen deficiency (hypoxia))

Returns

Photosynthesis factor for oxygen deficiency [-] (see Oxygen deficiency (hypoxia))

{
    return cbm::bound_min( 0.0, 1.0 - hypoxia[_vt->slot] * (*_vt)->HYPOXIA());
}

References hypoxia.

Referenced by PlaMox_get_age_factor(), and PlaMox_photosynthesis().

Here is the caller graph for this function:

PlaMox_harvest()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_harvest ( )

private

Handles all pending harvest events.

Applies all pending harvest events (see Harvest). Harvest events for plants that do not exist are ignored with a warning. If a plant is harvested at \( AGDD \) below 0.95 or above 1.1 times GDD_MATURITY, \( 0.95 \, AGDD \) is stored as maturity target for later plantings of the same plant (see Planting).

{
    EventAttributes const *  ev_harv = NULL;
    while (( ev_harv = this->m_HarvestEvents.pop()) != NULL)
    {
        char const *  p_name = ev_harv->get( "/name", "?");
        MoBiLE_Plant *  vt = m_veg->get_plant( p_name);
        if ( !vt)
        {
            /* skip only this event; returning here would drop all remaining
             * harvest events of the time step */
            KLOGWARN( "Harvest event for unknown plant ignored  [species=", p_name,"]");
            continue;
        }
        
        for ( size_t i = 0; i < this->plantfamily_tags.size(); ++i)
        {
            char const *  family = this->plantfamily_tags[i].c_str();
            if (   this->m_veg->is_family( vt->ctype(), family)
                || cbm::is_equal( vt->cname(), family))
            {
                if ( cbm::flt_less( vt->growing_degree_days, 0.95 * (*vt)->GDD_MATURITY()) ||
                     cbm::flt_greater( vt->growing_degree_days, 1.1 * (*vt)->GDD_MATURITY()))
                {
                    if ( gdd_target.find( vt->cname()) == gdd_target.end())
                    {
                        gdd_target.insert( { vt->cname(), 0.95 * vt->growing_degree_days});
                    }
                    else
                    {
                        gdd_target[vt->cname()] = 0.95 * vt->growing_degree_days;
                    }
                }
                lerr_t  rc_harv = PlaMox_event_harvest( vt, *ev_harv);
                if ( rc_harv)
                {
                    KLOGERROR( "Handling harvest event failed  [species=", vt->name(),"]");
                    return  LDNDC_ERR_FAIL;
                }
                // TODO  delete plant..
            }
        }
    }
    return  LDNDC_ERR_OK;
}

References gdd_target, m_HarvestEvents, m_veg, PlaMox_event_harvest(), and plantfamily_tags.

Referenced by solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_management()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_management ( )

private

Applies grazing and cutting events.

Applies grazing and cutting events (see Grazing and Cutting).

{
    lvector_t< double > agb_vt( m_veg->slot_cnt(), 0.0);
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        agb_vt[p->slot] = p->aboveground_biomass();
    }
 
    lerr_t rc_ff = m_eventgraze.update_available_freshfood_c( m_veg, species_groups_select_t< species::grass >());
    if ( rc_ff) { return rc_ff; }
 
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        if ( p->group() == "grass")
        {
            lerr_t  rc_graze = m_eventgraze.event_graze_physiology( p);
            if ( rc_graze == LDNDC_ERR_EVENT_MATCH)
            {
                n_plant[p->slot] = p->total_nitrogen();
            }
        }
    }
    
    lerr_t  rc_cut = m_eventcut.event_cut_physiology(
                                                     m_veg,
                                                     species_groups_select_t< species::grass, species::crop >());
    if ( rc_cut == LDNDC_ERR_EVENT_MATCH)
    {
        for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
        {
            MoBiLE_Plant *p = (*vt);
            yearly_cuts[p->slot] += 1;
            n_plant[p->slot] = p->total_nitrogen();
            
            if ( (*p)->RATOON())
            {
                PlaMox_reset_phenology( p);
            }
        }
    }
    
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        if ( cbm::flt_less( p->aboveground_biomass(), agb_vt[p->slot]))
        {
            double const scale( p->aboveground_biomass() / agb_vt[p->slot]);
            p->dvsFlush *= scale;
            p->dvsFlushOld *= scale;
        }
    }
    
    return  LDNDC_ERR_OK;
}

References begin(), end(), m_eventcut, m_eventgraze, m_veg, n_plant, PlaMox_reset_phenology(), and yearly_cuts.

Referenced by solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_n_opt()

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

private

Optimum nitrogen of the living plant [kgN m-2] (see Optimum plant nitrogen)

Returns

Optimum nitrogen of the living plant [kgN m-2] (see Optimum plant nitrogen)

{
    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_get_age_factor(), and PlaMox_update_nitrogen_concentrations().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_planting()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_planting ( )

private

Handles all pending planting events.

Creates the plants of all pending planting events and initializes them (see Planting).

{
    EventAttributes const *  ev_plant = NULL;
    while ((ev_plant = this->m_PlantEvents.pop()) != NULL)
    {
        char const *  p_name = ev_plant->get( "/name", "?");
        char const *  p_type = ev_plant->get( "/type", "?");
        char const *  p_group = ev_plant->get( "/group", "?");
        if ( !m_state->vegetation.have_plant( p_name))
        {
            species_t const *  p = NULL;
            if ( m_species)
            { p = m_species->get_species( p_name); }
 
            MoBiLE_PlantParameters  p_parameters;
            if ( p)
            { p_parameters = p->get_parameters(); }
            else if ( m_speciesparameters) /* assume event was not provided via input */
            { p_parameters = (*m_speciesparameters)[p_type]; }
            else
            { /* no parameters.. */ }
 
            MoBiLE_PlantSettings  plant_settings( static_cast< unsigned int >(m_setup->canopylayers()),
                                                 p_name, p_type, p_group, &p_parameters);
            plant_settings.nb_soillayers = sl_.soil_layer_cnt();
 
            MoBiLE_Plant *  plant = this->m_state->vegetation.new_plant( &plant_settings);
            if ( plant)
            {
                plant->initialize();
            }
            else
            {
                KLOGERROR( "Species creation failed  [species=", p->name(),"]");
                return  LDNDC_ERR_FAIL;
            }
        }
 
        PlaMox_step_resize();
 
        MoBiLE_Plant *  vt = m_veg->get_plant( ev_plant->get( "/name", "?"));
        if ( !vt){ return LDNDC_ERR_RUNTIME_ERROR; }
 
        for (size_t i = 0; i < this->plantfamily_tags.size(); ++i)
        {
            char const *  family = this->plantfamily_tags[i].c_str();
            if (   this->m_veg->is_family( vt->ctype(), family)
                || cbm::is_equal( vt->cname(), family))
            {
                lerr_t  rc_plant = PlaMox_event_plant( vt, *ev_plant);
                if ( rc_plant)
                {
                    KLOGERROR( "Handling plant event failed  [species=", vt->name(),"]");
                    return  LDNDC_ERR_FAIL;
                }
            }
        }
    }
    
    return  LDNDC_ERR_OK;
}

References m_PlantEvents, m_setup, m_species, m_speciesparameters, m_state, m_veg, PlaMox_event_plant(), PlaMox_step_resize(), plantfamily_tags, and sl_.

Referenced by solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_reset_phenology()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_reset_phenology ( MoBiLE_Plant * _p )

private

Resets the phenological state of a plant.

Resets the phenological state of a plant: accumulated growing degree days, development stage \( DVS \), mortality state \( MOS \), day of emergence, days after emergence, nitrogen fixed in the season and number of cuts in the current year. Used at planting, at the beginning of a new year for perennial plants and after cutting of ratoon species.

{
    _p->a_fix_n = 0.0;
    _p->growing_degree_days = 0.0;
    _p->dEmerg = -1;
    _p->dvsMort = 0.0;
    _p->dvsFlush = 0.0;
    _p->dvsFlushOld = 0.0;
    _p->mFol_na[0] = 0.0;
    _p->mFol_na[1] = _p->mFol;
 
    days_after_emergence[_p->slot] = -1;
    yearly_cuts[_p->slot] = 0;
    reset_phenology[_p->slot] = false;
 
    return  LDNDC_ERR_OK;
}

References days_after_emergence, reset_phenology, and yearly_cuts.

Referenced by PlaMox_event_plant(), PlaMox_management(), and PlaMox_step_init().

Here is the caller graph for this function:

PlaMox_step_init()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_step_init ( )

private

pre-run initialization each time step

• Resets the photosynthetic activity of all foliage layers and the accumulators of the time step (assimilation, automatic nitrogen supply, nitrogen added at planting, harvest exports).
• At the first time step of a day: increments the days after emergence and resets the daily food consumption of grazers.
• At the beginning of the year (hemisphere dependent), the phenology of perennial plants is flagged for a reset, which is carried out as soon as the mortality state \( MOS \) exceeds 0.99 (see Phenology).
• Copies the soil nitrogen pools available for uptake (ammonium, DON and the sum of aerobic and anaerobic nitrate).

{
    PlaMox_step_resize();
    PlaMox_update_plant_list();
 
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
 
        /* reset */
        for ( int  fl = 0;  fl < m_setup->canopylayers();  ++fl)
        {
            p->vcAct25_fl[fl] = 0.0;
            p->jAct25_fl[fl]  = 0.0;
            p->rdAct25_fl[fl] = 0.0;
        }
    }
 
    timestep_c_assi = 0.0;
    automatic_nitrogen_uptake = 0.0;
    n_at_planting = 0.0;
 
    c_total_exported = 0.0;
    c_fruit_exported = 0.0;
    n_total_exported = 0.0;
    n_fruit_exported = 0.0;
 
    
 
    if ( lclock()->subday() == 1)
    {
        m_eventgraze.reset_daily_food_consumption();
 
        for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
        {
            MoBiLE_Plant *p = (*vt);
            if ( days_after_emergence[p->slot] >= 0)
            {
                days_after_emergence[p->slot] += 1;
            }
        }
    }
 
    if ( MoBiLE_IsBeginningOfYear( lclock(), m_setup->latitude()))
    {
        for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
        {
            MoBiLE_Plant *p = (*vt);
            if (   (PlaMox_get_life_cycle( p) > PhysiologyPlaMox::ANNUAL)
                && (lclock()->seconds() > seconds_crop_planting[p->slot])) //avoid reset directly after planting at start of year
            {
                reset_phenology[p->slot] = true;
            }
        }
    }
 
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        if (   reset_phenology[p->slot]
            && cbm::flt_greater(p->dvsMort, 0.99))
        {
            PlaMox_reset_phenology( p);
        }
        dw_fol_old[p->slot] = p->mFol;
    }
 
    for ( size_t  sl = 0; sl < sl_.soil_layer_cnt(); ++sl)
    {
        nh4_sl[sl] = sc_.nh4_sl[sl];
        don_sl[sl] = sc_.don_sl[sl];
        no3_sl[sl] = sc_.no3_sl[sl] + sc_.an_no3_sl[sl];
    }
 
    return  LDNDC_ERR_OK;
}

References ANNUAL, automatic_nitrogen_uptake, begin(), c_fruit_exported, c_total_exported, days_after_emergence, don_sl, dw_fol_old, end(), m_eventgraze, m_setup, n_at_planting, n_fruit_exported, n_total_exported, nh4_sl, no3_sl, PlaMox_get_life_cycle(), PlaMox_reset_phenology(), PlaMox_step_resize(), PlaMox_update_plant_list(), reset_phenology, sc_, seconds_crop_planting, sl_, and timestep_c_assi.

Referenced by solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_step_out()

lerr_t ldndc::PhysiologyPlaMox::PlaMox_step_out ( )

private

Post-time step: oxygen deficiency, soil nitrogen and published fields.

• Calculates the oxygen deficiency of the rooted soil layers, which is used in the next time step (see Oxygen deficiency (hypoxia)).
• Stores the development stage of this time step (used by the development-based nitrogen fixation).
• Writes the soil nitrogen pools back. Nitrate is split between the aerobic and anaerobic soil fraction in proportion to the pools before uptake (by the anaerobic volume fraction if both pools were empty).
• Publishes aboveground biomass, development stage, growing degree days, day of emergence and the harvest exports of the time step.

{
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        hypoxia[p->slot] = 0.0;
        size_t const sl_rooted( cbm::is_valid( root_q_vt_[p->slot]) ? root_q_vt_[p->slot] : 0);
        for ( size_t sl = sl_rooted; sl < sl_.soil_layer_cnt(); ++sl)
        {
            p->hypoxia_sl[sl] = 0.0;
        }
        if ( cbm::flt_greater_zero( p->belowground_respiration()) &&
             cbm::flt_greater_zero( m_veg->dw_frt()) &&
             cbm::flt_greater_zero( p->mFrt) &&
             cbm::is_valid( root_q_vt_[p->slot]) &&
             cbm::flt_equal_zero( p->root_tc))
        {
            hypoxia[p->slot] = 0.0;
            // O2 demand [kgO2 m-2] of belowground respiration [kgC m-2] (1 mol O2 per mol C)
            double const o2_demand( p->belowground_respiration() * 2.0 * cbm::MO / cbm::MC);
            for (size_t sl = 0; sl < root_q_vt_[p->slot]; sl++)
            {
                // calc available o2 in this soil layer for this species
                double const v_pores( sc_.h_sl[sl] * sc_.poro_sl[sl]);
                double const v_water( wc_.wc_sl[sl] / cbm::DWAT * sc_.h_sl[sl]);
                double const v_ice( wc_.ice_sl[sl] / cbm::DICE * sc_.h_sl[sl]);
                double const v_air( cbm::bound_min( 0.0, v_pores - v_water - v_ice));
                double const o2( sc_.o2_sl[sl] * v_air /
                                 ((mc_.temp_sl[sl] + cbm::D_IN_K) * (cbm::RGAS / (2.0 * cbm::MO * cbm::KG_IN_G) * cbm::PA_IN_BAR)));
                // scale to root mass of species in relation to total root mass of all species per soil layer
                // calc o2 demand of this species in this soil layer
                double const o2_demand_sl( p->fFrt_sl[sl] * o2_demand);
                double const o2_avail( o2 * (p->fFrt_sl[sl] * p->mFrt) / m_veg->mfrt_sl( sl));
 
                if ( cbm::flt_greater( o2_demand_sl, o2_avail))
                {
                    // 1 is full stress (no o2 avail), 0 is no stress (demand can be fullfiled)
                    // The value for the whole root system is weighed by the fine root distribution.
                    p->hypoxia_sl[sl] = cbm::bound( 0.0, 1.0 - o2_avail / o2_demand_sl, 1.0);
                    hypoxia[p->slot] += p->fFrt_sl[sl] * p->hypoxia_sl[sl];
                }
                else
                {
                    p->hypoxia_sl[sl] = 0.0;
                }
            }
        }
    }
    
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = (*vt);
        p->dvsFlushOld = p->dvsFlush;
    }
    
    double agb( 0.0);
    double dvs( 0.0);
    double gdd( 0.0);
    double dEmerg_send(0.0);
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        agb += p->aboveground_biomass();
        dvs += p->dvsFlush;
        gdd += p->growing_degree_days;
        dEmerg_send += p->dEmerg;
    }
    
    for ( size_t  sl = 0;  sl < sl_.soil_layer_cnt();  ++sl)
    {
        if ( cbm::flt_greater_zero( nh4_sl[sl]))
        {
            sc_.nh4_sl[sl] = nh4_sl[sl];
        }
        else { sc_.nh4_sl[sl] = 0.0; }
        
        if ( cbm::flt_greater_zero( don_sl[sl]))
        {
            sc_.don_sl[sl] = don_sl[sl];
        }
        else { sc_.don_sl[sl] = 0.0; }
        
        double const no3_tot( sc_.no3_sl[sl] + sc_.an_no3_sl[sl]);
        if ( cbm::flt_greater_zero( no3_tot))
        {
            sc_.no3_sl[sl] = sc_.no3_sl[sl] / no3_tot * no3_sl[sl];
            sc_.an_no3_sl[sl] = no3_sl[sl] - sc_.no3_sl[sl];
        }
        else
        {
            sc_.no3_sl[sl] = no3_sl[sl] * (1.0 - sc_.anvf_sl[sl]);
            sc_.an_no3_sl[sl] = no3_sl[sl] - sc_.no3_sl[sl];
        }
    }
    
    aboveground_biomass.send( agb);
    maturity_status.send( dvs);
    growing_degree_days_maturity.send( gdd);
    dEmerg.send(dEmerg_send);
    
    carbon_plant_biomass_total_exported_from_field.send( c_total_exported);
    carbon_plant_biomass_fruit_exported_from_field.send( c_fruit_exported);
    nitrogen_plant_biomass_total_exported_from_field.send( n_total_exported);
    nitrogen_plant_biomass_fruit_exported_from_field.send( n_fruit_exported);
    
    
    return  LDNDC_ERR_OK;
}

References aboveground_biomass, begin(), c_fruit_exported, c_total_exported, carbon_plant_biomass_fruit_exported_from_field, carbon_plant_biomass_total_exported_from_field, dEmerg, don_sl, end(), growing_degree_days_maturity, hypoxia, m_veg, maturity_status, mc_, n_fruit_exported, n_total_exported, nh4_sl, nitrogen_plant_biomass_fruit_exported_from_field, nitrogen_plant_biomass_total_exported_from_field, no3_sl, root_q_vt_, sc_, sl_, and wc_.

Referenced by solve().

Here is the call graph for this function:

Here is the caller graph for this function:

PlaMox_update_foliage_structure()

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

private

Foliage distribution and leaf area index of the foliage layers (see Leaf area)

Calculates the foliage distribution and the leaf area index of all foliage layers (see Leaf area).

{
    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));
 
    if ( rm_ && cbm::is_valid( rm_->lai_subday( lclock_ref())))
    {
        lai_dynamic[_vt->slot] = rm_->lai_subday( lclock_ref());
    }
    else
    {
        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();
 
        //use dynamic lai only if remote sensing input is available
        if ( rm_)
        {
            for (size_t fl = 0; fl < fl_cnt; ++fl)
            {
                _vt->fFol_fl[fl] = _vt->sla_fl[fl] / sla_cum;
                _vt->lai_fl[fl] = lai_dynamic[_vt->slot] * _vt->fFol_fl[fl] * droughtstress.linear_threshold( _vt->f_h2o);
            }
        }
        else
        {
            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);
            }
        }
 
        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 dw_fol_old, lai_dynamic, lai_min, m_setup, rm_, and transplanting_shock_vt.

Referenced by PlaMox_update_ground_cover(), and solve().

Here is the caller graph for this function:

register_ports()

lerr_t ldndc::PhysiologyPlaMox::register_ports

(

cbm::io_kcomm_t *

_io_kcomm

)

Publishes aboveground biomass, development stage, growing degree days, day of emergence and harvest exports; subscribes to planting and harvest events and registers the ports of the cutting and grazing handlers.

{
    lerr_t  rc = LDNDC_ERR_OK;
    
    aboveground_biomass.publish( "AbovegroundBiomass", "kg/m2", _io_kcomm);
    maturity_status.publish( "MaturityStatus", "-", _io_kcomm);
    growing_degree_days_maturity.publish( "GrowingDegreeDays", "-", _io_kcomm);
    dEmerg.publish("dEmerg_send", "-", _io_kcomm);
    
    carbon_plant_biomass_total_exported_from_field.publish( "carbon_plant_biomass_total_exported_from_field", "kg/m2", _io_kcomm);
    carbon_plant_biomass_fruit_exported_from_field.publish( "carbon_plant_biomass_fruit_exported_from_field", "kg/m2", _io_kcomm);
    nitrogen_plant_biomass_total_exported_from_field.publish( "nitrogen_plant_biomass_total_exported_from_field", "kg/m2", _io_kcomm);
    nitrogen_plant_biomass_fruit_exported_from_field.publish( "nitrogen_plant_biomass_fruit_exported_from_field", "kg/m2", _io_kcomm);
    
    rc = m_eventcut.register_ports( _io_kcomm);
    if ( rc)
    { return LDNDC_ERR_FAIL; }
    
    rc = m_eventgraze.register_ports( _io_kcomm);
    if ( rc)
    { return LDNDC_ERR_FAIL; }
    
    int rc_harvest = this->m_HarvestEvents.subscribe( "harvest", _io_kcomm);
    if ( rc_harvest != LD_PortOk)
    { return  LDNDC_ERR_FAIL; }
    
    int rc_plant = this->m_PlantEvents.subscribe( "plant", _io_kcomm);
    if ( rc_plant != LD_PortOk)
    { return  LDNDC_ERR_FAIL; }
    
    return rc;
}

References aboveground_biomass, carbon_plant_biomass_fruit_exported_from_field, carbon_plant_biomass_total_exported_from_field, dEmerg, growing_degree_days_maturity, m_eventcut, m_eventgraze, m_HarvestEvents, m_PlantEvents, maturity_status, nitrogen_plant_biomass_fruit_exported_from_field, and nitrogen_plant_biomass_total_exported_from_field.

solve()

lerr_t ldndc::PhysiologyPlaMox::solve

(

)

Simulates one time step of all plants handled by PlaMox in the order given in Processes within a time step. Grazing, cutting and planting are applied at the beginning, harvest at the end of the time step. The carbon and nitrogen balance of all plants is checked in between.

{
    /* Pre-time step setting */
    (void)PlaMox_step_init();
 
    /* Begin balance check */
    PlaMox_balance_check( ON_ENTRY);
 
    /* Grazing and Cutting */
    lerr_t rc = PlaMox_management();
    if ( rc) { return rc; }
 
    /* Planting */
    PlaMox_planting();
    PlaMox_update_plant_list();
 
    /* Vernalization */
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        PlaMox_growing_degree_days( p);
        PlaMox_vernalization( p);
    }
 
    /* Plant development
     * determines how much C is given to which plant part in photosynthesis (C allocation) */
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        PlaMox_heat_stress_limitation( p);
 
        if ( p->group() == "crop")
        {
            PlaMox_plant_development_crop( p);
        }
        else if ( p->group() == "grass")
        {
            PlaMox_allocation_grass( p);
        }
    }
 
    /* Photosynthesis activity and carbon allocation
     * The C is translated into biomass via CCDM. */
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        
        // here some mass is added to _vt->mFrt! but the root length is not increased
        lerr_t rc_photosynthesis = PlaMox_photosynthesis( p);
        
        if ( rc_photosynthesis)
        {
            KLOGERROR( "Photosynthesis calculation failed  [species=", p->name(),"]");
            return  LDNDC_ERR_FAIL;
        }
        
        /* root growth */
        PlaMox_update_root_structure( p, p->dcFrt/cbm::CCDM);
        
        if ( p->group() == "grass")
        {
            PlaMox_bud_burst( p);
        }
        
        PlaMox_redistribution( p);
    }
    
    /* Nitrogen uptake/fixation */
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        
        PlaMox_nitrogen_uptake( p);
        
        PlaMox_nitrogen_fixation( p);
        
    }
    
    /* C-losses (respiration, exudation and senescence */
    for ( PlaMoxIterator vt = begin(); vt != end(); ++vt)
    {
        MoBiLE_Plant *p = *vt;
        
        /* respiration */
        PlaMox_respiration( p);
        
        /* exsudation */
        PlaMox_exsudation( p);
        
        /* senescence */
        PlaMox_senescence( p);
        
        /* abscission */
        PlaMox_abscission( p);
        
        /* ground coverage */
        PlaMox_update_ground_cover( p);
        
        /* plant height */
        PlaMox_update_height( p);
        
        /* specific leaf area */
        PlaMox_update_specific_leaf_area( p);
        
        /* leaf area index */
        PlaMox_update_foliage_structure( p);
        
        /* drought */
        PlaMox_drought( p);
        
        /* transpiration */
        PlaMox_transpiration( p);
        
    }
 
    /* Harvest */
    PlaMox_harvest();
    
    /* End balance check */
    PlaMox_balance_check( ON_EXIT);
    
    /* Post-time step setting */
    PlaMox_step_out();
    
    return  LDNDC_ERR_OK;
}

References begin(), end(), PlaMox_abscission(), PlaMox_allocation_grass(), PlaMox_balance_check(), PlaMox_bud_burst(), PlaMox_drought(), PlaMox_exsudation(), PlaMox_growing_degree_days(), PlaMox_harvest(), PlaMox_heat_stress_limitation(), PlaMox_management(), PlaMox_nitrogen_fixation(), PlaMox_nitrogen_uptake(), PlaMox_photosynthesis(), PlaMox_plant_development_crop(), PlaMox_planting(), PlaMox_redistribution(), PlaMox_respiration(), PlaMox_senescence(), PlaMox_step_init(), PlaMox_step_out(), PlaMox_transpiration(), PlaMox_update_foliage_structure(), PlaMox_update_ground_cover(), PlaMox_update_height(), PlaMox_update_plant_list(), PlaMox_update_root_structure(), PlaMox_update_specific_leaf_area(), and PlaMox_vernalization().

Here is the call graph for this function:

unregister_ports()

lerr_t ldndc::PhysiologyPlaMox::unregister_ports

(

cbm::io_kcomm_t *

_io_kcomm

)

Unpublishes the fields and unsubscribes from all events.

{
    aboveground_biomass.unpublish();
    maturity_status.unpublish();
    growing_degree_days_maturity.unpublish();
    dEmerg.unpublish();
    
    carbon_plant_biomass_total_exported_from_field.unpublish();
    carbon_plant_biomass_fruit_exported_from_field.unpublish();
    nitrogen_plant_biomass_total_exported_from_field.unpublish();
    nitrogen_plant_biomass_fruit_exported_from_field.unpublish();
    
    m_eventcut.unregister_ports( _io_kcomm);
    m_eventgraze.unregister_ports( _io_kcomm);
    
    m_HarvestEvents.unsubscribe();
    m_PlantEvents.unsubscribe();
    
    return  LDNDC_ERR_OK;
}

References aboveground_biomass, carbon_plant_biomass_fruit_exported_from_field, carbon_plant_biomass_total_exported_from_field, dEmerg, growing_degree_days_maturity, m_eventcut, m_eventgraze, m_HarvestEvents, m_PlantEvents, maturity_status, nitrogen_plant_biomass_fruit_exported_from_field, and nitrogen_plant_biomass_total_exported_from_field.

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 PhysiologyPlaMox(), PlaMox_event_harvest(), PlaMox_event_plant(), PlaMox_exsudation(), and ~PhysiologyPlaMox().