diff --git a/R/RcppExports.R b/R/RcppExports.R index 1a8bbb439..e4202c5dd 100644 --- a/R/RcppExports.R +++ b/R/RcppExports.R @@ -253,6 +253,50 @@ OdeRunner___FF16r__object__get <- function(obj_) { .Call('_plant_OdeRunner___FF16r__object__get', PACKAGE = 'plant', obj_) } +OdeRunner___FF16drivers__ctor <- function(obj, control) { + .Call('_plant_OdeRunner___FF16drivers__ctor', PACKAGE = 'plant', obj, control) +} + +OdeRunner___FF16drivers__advance <- function(obj_, time) { + invisible(.Call('_plant_OdeRunner___FF16drivers__advance', PACKAGE = 'plant', obj_, time)) +} + +OdeRunner___FF16drivers__advance_fixed <- function(obj_, time) { + invisible(.Call('_plant_OdeRunner___FF16drivers__advance_fixed', PACKAGE = 'plant', obj_, time)) +} + +OdeRunner___FF16drivers__step <- function(obj_) { + invisible(.Call('_plant_OdeRunner___FF16drivers__step', PACKAGE = 'plant', obj_)) +} + +OdeRunner___FF16drivers__step_to <- function(obj_, time) { + invisible(.Call('_plant_OdeRunner___FF16drivers__step_to', PACKAGE = 'plant', obj_, time)) +} + +OdeRunner___FF16drivers__set_state <- function(obj_, y, time) { + invisible(.Call('_plant_OdeRunner___FF16drivers__set_state', PACKAGE = 'plant', obj_, y, time)) +} + +OdeRunner___FF16drivers__set_state_from_system <- function(obj_) { + invisible(.Call('_plant_OdeRunner___FF16drivers__set_state_from_system', PACKAGE = 'plant', obj_)) +} + +OdeRunner___FF16drivers__time__get <- function(obj_) { + .Call('_plant_OdeRunner___FF16drivers__time__get', PACKAGE = 'plant', obj_) +} + +OdeRunner___FF16drivers__state__get <- function(obj_) { + .Call('_plant_OdeRunner___FF16drivers__state__get', PACKAGE = 'plant', obj_) +} + +OdeRunner___FF16drivers__times__get <- function(obj_) { + .Call('_plant_OdeRunner___FF16drivers__times__get', PACKAGE = 'plant', obj_) +} + +OdeRunner___FF16drivers__object__get <- function(obj_) { + .Call('_plant_OdeRunner___FF16drivers__object__get', PACKAGE = 'plant', obj_) +} + OdeRunner___K93__ctor <- function(obj, control) { .Call('_plant_OdeRunner___K93__ctor', PACKAGE = 'plant', obj, control) } @@ -789,6 +833,94 @@ Individual___FF16r__FF16_Env__strategy_name__get <- function(obj_) { .Call('_plant_Individual___FF16r__FF16_Env__strategy_name__get', PACKAGE = 'plant', obj_) } +Individual___FF16drivers__FF16_Env__ctor <- function(s) { + .Call('_plant_Individual___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', s) +} + +Individual___FF16drivers__FF16_Env__state <- function(obj_, name) { + .Call('_plant_Individual___FF16drivers__FF16_Env__state', PACKAGE = 'plant', obj_, name) +} + +Individual___FF16drivers__FF16_Env__rate <- function(obj_, name) { + .Call('_plant_Individual___FF16drivers__FF16_Env__rate', PACKAGE = 'plant', obj_, name) +} + +Individual___FF16drivers__FF16_Env__aux <- function(obj_, name) { + .Call('_plant_Individual___FF16drivers__FF16_Env__aux', PACKAGE = 'plant', obj_, name) +} + +Individual___FF16drivers__FF16_Env__set_state <- function(obj_, name, v) { + invisible(.Call('_plant_Individual___FF16drivers__FF16_Env__set_state', PACKAGE = 'plant', obj_, name, v)) +} + +Individual___FF16drivers__FF16_Env__compute_competition <- function(obj_, h) { + .Call('_plant_Individual___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, h) +} + +Individual___FF16drivers__FF16_Env__compute_rates <- function(obj_, environment) { + invisible(.Call('_plant_Individual___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_, environment)) +} + +Individual___FF16drivers__FF16_Env__establishment_probability <- function(obj_, environment) { + .Call('_plant_Individual___FF16drivers__FF16_Env__establishment_probability', PACKAGE = 'plant', obj_, environment) +} + +Individual___FF16drivers__FF16_Env__net_mass_production_dt <- function(obj_, environment) { + .Call('_plant_Individual___FF16drivers__FF16_Env__net_mass_production_dt', PACKAGE = 'plant', obj_, environment) +} + +Individual___FF16drivers__FF16_Env__reset_mortality <- function(obj_) { + invisible(.Call('_plant_Individual___FF16drivers__FF16_Env__reset_mortality', PACKAGE = 'plant', obj_)) +} + +Individual___FF16drivers__FF16_Env__resource_compensation_point <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__resource_compensation_point', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__strategy__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__strategy__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__internals__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__internals__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__aux_size__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__aux_size__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__ode_names__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__ode_names__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__aux_names__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__aux_names__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__ode_state__set <- function(obj_, value) { + invisible(.Call('_plant_Individual___FF16drivers__FF16_Env__ode_state__set', PACKAGE = 'plant', obj_, value)) +} + +Individual___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__mortality_probability__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__mortality_probability__get', PACKAGE = 'plant', obj_) +} + +Individual___FF16drivers__FF16_Env__strategy_name__get <- function(obj_) { + .Call('_plant_Individual___FF16drivers__FF16_Env__strategy_name__get', PACKAGE = 'plant', obj_) +} + Individual___K93__K93_Env__ctor <- function(s) { .Call('_plant_Individual___K93__K93_Env__ctor', PACKAGE = 'plant', s) } @@ -913,6 +1045,18 @@ IndividualRunner___FF16r__FF16_Env__individual__set <- function(obj_, value) { invisible(.Call('_plant_IndividualRunner___FF16r__FF16_Env__individual__set', PACKAGE = 'plant', obj_, value)) } +IndividualRunner___FF16drivers__FF16_Env__ctor <- function(individual, environment) { + .Call('_plant_IndividualRunner___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', individual, environment) +} + +IndividualRunner___FF16drivers__FF16_Env__individual__get <- function(obj_) { + .Call('_plant_IndividualRunner___FF16drivers__FF16_Env__individual__get', PACKAGE = 'plant', obj_) +} + +IndividualRunner___FF16drivers__FF16_Env__individual__set <- function(obj_, value) { + invisible(.Call('_plant_IndividualRunner___FF16drivers__FF16_Env__individual__set', PACKAGE = 'plant', obj_, value)) +} + IndividualRunner___K93__K93_Env__ctor <- function(individual, environment) { .Call('_plant_IndividualRunner___K93__K93_Env__ctor', PACKAGE = 'plant', individual, environment) } @@ -1021,6 +1165,14 @@ Parameters___FF16r__FF16_Env__vdor <- function(obj) { .Call('_plant_Parameters___FF16r__FF16_Env__vdor', PACKAGE = 'plant', obj) } +Parameters___FF16drivers__FF16_Env__ctor <- function() { + .Call('_plant_Parameters___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant') +} + +Parameters___FF16drivers__FF16_Env__vdor <- function(obj) { + .Call('_plant_Parameters___FF16drivers__FF16_Env__vdor', PACKAGE = 'plant', obj) +} + Parameters___K93__K93_Env__ctor <- function() { .Call('_plant_Parameters___K93__K93_Env__ctor', PACKAGE = 'plant') } @@ -1209,6 +1361,66 @@ Node___FF16r__FF16_Env__ode_names__get <- function(obj_) { .Call('_plant_Node___FF16r__FF16_Env__ode_names__get', PACKAGE = 'plant', obj_) } +Node___FF16drivers__FF16_Env__ctor <- function(strategy) { + .Call('_plant_Node___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', strategy) +} + +Node___FF16drivers__FF16_Env__compute_competition <- function(obj_, height) { + .Call('_plant_Node___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, height) +} + +Node___FF16drivers__FF16_Env__growth_rate_gradient <- function(obj_, environment) { + .Call('_plant_Node___FF16drivers__FF16_Env__growth_rate_gradient', PACKAGE = 'plant', obj_, environment) +} + +Node___FF16drivers__FF16_Env__compute_rates <- function(obj_, environment, pr_patch_survival) { + invisible(.Call('_plant_Node___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_, environment, pr_patch_survival)) +} + +Node___FF16drivers__FF16_Env__compute_initial_conditions <- function(obj_, environment, pr_patch_survival, birth_rate) { + invisible(.Call('_plant_Node___FF16drivers__FF16_Env__compute_initial_conditions', PACKAGE = 'plant', obj_, environment, pr_patch_survival, birth_rate)) +} + +Node___FF16drivers__FF16_Env__individual__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__individual__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__height__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__height__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__log_density__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__log_density__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__competition_effect__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__competition_effect__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__fecundity__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__fecundity__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__ode_state__set <- function(obj_, value) { + invisible(.Call('_plant_Node___FF16drivers__FF16_Env__ode_state__set', PACKAGE = 'plant', obj_, value)) +} + +Node___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + +Node___FF16drivers__FF16_Env__ode_names__get <- function(obj_) { + .Call('_plant_Node___FF16drivers__FF16_Env__ode_names__get', PACKAGE = 'plant', obj_) +} + Node___K93__K93_Env__ctor <- function(strategy) { .Call('_plant_Node___K93__K93_Env__ctor', PACKAGE = 'plant', strategy) } @@ -1521,6 +1733,90 @@ Species___FF16r__FF16_Env__ode_rates__get <- function(obj_) { .Call('_plant_Species___FF16r__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) } +Species___FF16drivers__FF16_Env__ctor <- function(strategy) { + .Call('_plant_Species___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', strategy) +} + +Species___FF16drivers__FF16_Env__clear <- function(obj_) { + invisible(.Call('_plant_Species___FF16drivers__FF16_Env__clear', PACKAGE = 'plant', obj_)) +} + +Species___FF16drivers__FF16_Env__compute_rates <- function(obj_, environment, pr_patch_survival, birth_rate) { + invisible(.Call('_plant_Species___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_, environment, pr_patch_survival, birth_rate)) +} + +Species___FF16drivers__FF16_Env__compute_competition <- function(obj_, height) { + .Call('_plant_Species___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, height) +} + +Species___FF16drivers__FF16_Env__introduce_new_node <- function(obj_) { + invisible(.Call('_plant_Species___FF16drivers__FF16_Env__introduce_new_node', PACKAGE = 'plant', obj_)) +} + +Species___FF16drivers__FF16_Env__node_at <- function(obj_, index) { + .Call('_plant_Species___FF16drivers__FF16_Env__node_at', PACKAGE = 'plant', obj_, index) +} + +Species___FF16drivers__FF16_Env__competition_effects_error <- function(obj_, scal) { + .Call('_plant_Species___FF16drivers__FF16_Env__competition_effects_error', PACKAGE = 'plant', obj_, scal) +} + +Species___FF16drivers__FF16_Env__size__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__size__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__new_node__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__new_node__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__height_max__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__height_max__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__heights__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__heights__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__heights__set <- function(obj_, value) { + invisible(.Call('_plant_Species___FF16drivers__FF16_Env__heights__set', PACKAGE = 'plant', obj_, value)) +} + +Species___FF16drivers__FF16_Env__log_densities__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__log_densities__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__nodes__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__nodes__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__competition_effects__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__competition_effects__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__extrinsic_drivers__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__extrinsic_drivers__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +Species___FF16drivers__FF16_Env__ode_state__set <- function(obj_, value) { + invisible(.Call('_plant_Species___FF16drivers__FF16_Env__ode_state__set', PACKAGE = 'plant', obj_, value)) +} + +Species___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_Species___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + Species___K93__K93_Env__ctor <- function(strategy) { .Call('_plant_Species___K93__K93_Env__ctor', PACKAGE = 'plant', strategy) } @@ -1929,6 +2225,114 @@ Patch___FF16r__FF16_Env__node_ode_size__get <- function(obj_) { .Call('_plant_Patch___FF16r__FF16_Env__node_ode_size__get', PACKAGE = 'plant', obj_) } +Patch___FF16drivers__FF16_Env__ctor <- function(parameters, environment, control) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', parameters, environment, control) +} + +Patch___FF16drivers__FF16_Env__introduce_new_node <- function(obj_, species_index) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__introduce_new_node', PACKAGE = 'plant', obj_, species_index)) +} + +Patch___FF16drivers__FF16_Env__compute_environment <- function(obj_) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__compute_environment', PACKAGE = 'plant', obj_)) +} + +Patch___FF16drivers__FF16_Env__compute_rates <- function(obj_) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_)) +} + +Patch___FF16drivers__FF16_Env__reset <- function(obj_) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__reset', PACKAGE = 'plant', obj_)) +} + +Patch___FF16drivers__FF16_Env__set_ode_state <- function(obj_, values, time) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__set_ode_state', PACKAGE = 'plant', obj_, values, time)) +} + +Patch___FF16drivers__FF16_Env__derivs <- function(obj_, y, time) { + .Call('_plant_Patch___FF16drivers__FF16_Env__derivs', PACKAGE = 'plant', obj_, y, time) +} + +Patch___FF16drivers__FF16_Env__set_time <- function(obj_, time) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__set_time', PACKAGE = 'plant', obj_, time)) +} + +Patch___FF16drivers__FF16_Env__set_state <- function(obj_, time, state, n, env) { + invisible(.Call('_plant_Patch___FF16drivers__FF16_Env__set_state', PACKAGE = 'plant', obj_, time, state, n, env)) +} + +Patch___FF16drivers__FF16_Env__density <- function(obj_, time) { + .Call('_plant_Patch___FF16drivers__FF16_Env__density', PACKAGE = 'plant', obj_, time) +} + +Patch___FF16drivers__FF16_Env__pr_survival <- function(obj_, time) { + .Call('_plant_Patch___FF16drivers__FF16_Env__pr_survival', PACKAGE = 'plant', obj_, time) +} + +Patch___FF16drivers__FF16_Env__disturbance_mean_interval <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__disturbance_mean_interval', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__survival_weighting_cdf <- function(obj_, time) { + .Call('_plant_Patch___FF16drivers__FF16_Env__survival_weighting_cdf', PACKAGE = 'plant', obj_, time) +} + +Patch___FF16drivers__FF16_Env__survival_weighting_icdf <- function(obj_, prob) { + .Call('_plant_Patch___FF16drivers__FF16_Env__survival_weighting_icdf', PACKAGE = 'plant', obj_, prob) +} + +Patch___FF16drivers__FF16_Env__compute_competition <- function(obj_, height) { + .Call('_plant_Patch___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, height) +} + +Patch___FF16drivers__FF16_Env__time__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__time__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__size__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__size__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__height_max__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__height_max__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__parameters__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__parameters__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__environment__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__environment__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__species__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__species__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__ode_time__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ode_time__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__ode_aux__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__ode_aux__get', PACKAGE = 'plant', obj_) +} + +Patch___FF16drivers__FF16_Env__node_ode_size__get <- function(obj_) { + .Call('_plant_Patch___FF16drivers__FF16_Env__node_ode_size__get', PACKAGE = 'plant', obj_) +} + Patch___K93__K93_Env__ctor <- function(parameters, environment, control) { .Call('_plant_Patch___K93__K93_Env__ctor', PACKAGE = 'plant', parameters, environment, control) } @@ -2301,6 +2705,94 @@ SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get <- function(obj_) { .Call('_plant_SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get', PACKAGE = 'plant', obj_) } +SCM___FF16drivers__FF16_Env__ctor <- function(parameters, environment, control) { + .Call('_plant_SCM___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', parameters, environment, control) +} + +SCM___FF16drivers__FF16_Env__run <- function(obj_) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__run', PACKAGE = 'plant', obj_)) +} + +SCM___FF16drivers__FF16_Env__run_mutant <- function(obj_, p) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__run_mutant', PACKAGE = 'plant', obj_, p)) +} + +SCM___FF16drivers__FF16_Env__run_next <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__run_next', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__reset <- function(obj_) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__reset', PACKAGE = 'plant', obj_)) +} + +SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species <- function(obj_, species_index) { + .Call('_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species', PACKAGE = 'plant', obj_, species_index) +} + +SCM___FF16drivers__FF16_Env__competition_effect_error <- function(obj_, species_index) { + .Call('_plant_SCM___FF16drivers__FF16_Env__competition_effect_error', PACKAGE = 'plant', obj_, species_index) +} + +SCM___FF16drivers__FF16_Env__set_node_schedule_times <- function(obj_, times) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__set_node_schedule_times', PACKAGE = 'plant', obj_, times)) +} + +SCM___FF16drivers__FF16_Env__complete__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__complete__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__time__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__time__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__offspring_production__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__offspring_production__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__parameters__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__parameters__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__patch__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__patch__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__node_schedule__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__node_schedule__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__node_schedule__set <- function(obj_, value) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__node_schedule__set', PACKAGE = 'plant', obj_, value)) +} + +SCM___FF16drivers__FF16_Env__ode_times__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__ode_times__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__state__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__state__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__aux__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__aux__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__use_ode_times__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__use_ode_times__get', PACKAGE = 'plant', obj_) +} + +SCM___FF16drivers__FF16_Env__use_ode_times__set <- function(obj_, value) { + invisible(.Call('_plant_SCM___FF16drivers__FF16_Env__use_ode_times__set', PACKAGE = 'plant', obj_, value)) +} + +SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get <- function(obj_) { + .Call('_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get', PACKAGE = 'plant', obj_) +} + SCM___K93__K93_Env__ctor <- function(parameters, environment, control) { .Call('_plant_SCM___K93__K93_Env__ctor', PACKAGE = 'plant', parameters, environment, control) } @@ -2641,6 +3133,90 @@ StochasticSpecies___FF16r__FF16_Env__ode_rates__get <- function(obj_) { .Call('_plant_StochasticSpecies___FF16r__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) } +StochasticSpecies___FF16drivers__FF16_Env__ctor <- function(strategy) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', strategy) +} + +StochasticSpecies___FF16drivers__FF16_Env__clear <- function(obj_) { + invisible(.Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__clear', PACKAGE = 'plant', obj_)) +} + +StochasticSpecies___FF16drivers__FF16_Env__compute_rates <- function(obj_, environment) { + invisible(.Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_, environment)) +} + +StochasticSpecies___FF16drivers__FF16_Env__compute_competition <- function(obj_, height) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, height) +} + +StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node <- function(obj_) { + invisible(.Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node', PACKAGE = 'plant', obj_)) +} + +StochasticSpecies___FF16drivers__FF16_Env__individual_at <- function(obj_, index) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__individual_at', PACKAGE = 'plant', obj_, index) +} + +StochasticSpecies___FF16drivers__FF16_Env__deaths <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__deaths', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__establishment_probability <- function(obj_, environment) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__establishment_probability', PACKAGE = 'plant', obj_, environment) +} + +StochasticSpecies___FF16drivers__FF16_Env__size__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__size__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__new_node__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__new_node__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__height_max__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__height_max__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__heights__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__heights__set <- function(obj_, value) { + invisible(.Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__set', PACKAGE = 'plant', obj_, value)) +} + +StochasticSpecies___FF16drivers__FF16_Env__individuals__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__individuals__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__is_alive__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__is_alive__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +StochasticSpecies___FF16drivers__FF16_Env__ode_state__set <- function(obj_, value) { + invisible(.Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__set', PACKAGE = 'plant', obj_, value)) +} + +StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + StochasticSpecies___K93__K93_Env__ctor <- function(strategy) { .Call('_plant_StochasticSpecies___K93__K93_Env__ctor', PACKAGE = 'plant', strategy) } @@ -2977,6 +3553,90 @@ StochasticPatch___FF16r__FF16_Env__ode_rates__get <- function(obj_) { .Call('_plant_StochasticPatch___FF16r__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) } +StochasticPatch___FF16drivers__FF16_Env__ctor <- function(parameters, environment, control) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', parameters, environment, control) +} + +StochasticPatch___FF16drivers__FF16_Env__compute_competition <- function(obj_, height) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__compute_competition', PACKAGE = 'plant', obj_, height) +} + +StochasticPatch___FF16drivers__FF16_Env__introduce_new_node <- function(obj_, species_index) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node', PACKAGE = 'plant', obj_, species_index) +} + +StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update <- function(obj_, species_index) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update', PACKAGE = 'plant', obj_, species_index)) +} + +StochasticPatch___FF16drivers__FF16_Env__compute_environment <- function(obj_) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__compute_environment', PACKAGE = 'plant', obj_)) +} + +StochasticPatch___FF16drivers__FF16_Env__compute_rates <- function(obj_) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__compute_rates', PACKAGE = 'plant', obj_)) +} + +StochasticPatch___FF16drivers__FF16_Env__reset <- function(obj_) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__reset', PACKAGE = 'plant', obj_)) +} + +StochasticPatch___FF16drivers__FF16_Env__set_ode_state <- function(obj_, values, time) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__set_ode_state', PACKAGE = 'plant', obj_, values, time)) +} + +StochasticPatch___FF16drivers__FF16_Env__derivs <- function(obj_, y, time) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__derivs', PACKAGE = 'plant', obj_, y, time) +} + +StochasticPatch___FF16drivers__FF16_Env__set_state <- function(obj_, time, state, n) { + invisible(.Call('_plant_StochasticPatch___FF16drivers__FF16_Env__set_state', PACKAGE = 'plant', obj_, time, state, n)) +} + +StochasticPatch___FF16drivers__FF16_Env__deaths <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__deaths', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__time__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__time__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__size__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__size__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__height_max__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__height_max__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__parameters__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__parameters__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__environment__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__environment__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__species__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__species__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__ode_size__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__ode_size__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__ode_time__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__ode_time__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__ode_state__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__ode_state__get', PACKAGE = 'plant', obj_) +} + +StochasticPatch___FF16drivers__FF16_Env__ode_rates__get <- function(obj_) { + .Call('_plant_StochasticPatch___FF16drivers__FF16_Env__ode_rates__get', PACKAGE = 'plant', obj_) +} + StochasticPatch___K93__K93_Env__ctor <- function(parameters, environment, control) { .Call('_plant_StochasticPatch___K93__K93_Env__ctor', PACKAGE = 'plant', parameters, environment, control) } @@ -3205,6 +3865,54 @@ StochasticPatchRunner___FF16r__FF16_Env__state__get <- function(obj_) { .Call('_plant_StochasticPatchRunner___FF16r__FF16_Env__state__get', PACKAGE = 'plant', obj_) } +StochasticPatchRunner___FF16drivers__FF16_Env__ctor <- function(parameters, environment, control) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__ctor', PACKAGE = 'plant', parameters, environment, control) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__run <- function(obj_) { + invisible(.Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run', PACKAGE = 'plant', obj_)) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__run_next <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run_next', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__reset <- function(obj_) { + invisible(.Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__reset', PACKAGE = 'plant', obj_)) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times <- function(obj_, times) { + invisible(.Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times', PACKAGE = 'plant', obj_, times)) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__complete__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__complete__get', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__time__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__time__get', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__patch__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__patch__get', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get', PACKAGE = 'plant', obj_) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set <- function(obj_, value) { + invisible(.Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set', PACKAGE = 'plant', obj_, value)) +} + +StochasticPatchRunner___FF16drivers__FF16_Env__state__get <- function(obj_) { + .Call('_plant_StochasticPatchRunner___FF16drivers__FF16_Env__state__get', PACKAGE = 'plant', obj_) +} + StochasticPatchRunner___K93__K93_Env__ctor <- function(parameters, environment, control) { .Call('_plant_StochasticPatchRunner___K93__K93_Env__ctor', PACKAGE = 'plant', parameters, environment, control) } @@ -3385,6 +4093,10 @@ FF16_Environment__extrinsic_drivers__set <- function(obj_, value) { invisible(.Call('_plant_FF16_Environment__extrinsic_drivers__set', PACKAGE = 'plant', obj_, value)) } +FF16drivers_Strategy__ctor <- function() { + .Call('_plant_FF16drivers_Strategy__ctor', PACKAGE = 'plant') +} + FF16r_Strategy__ctor <- function() { .Call('_plant_FF16r_Strategy__ctor', PACKAGE = 'plant') } diff --git a/R/RcppR6.R b/R/RcppR6.R index bc14983d6..12e9db31a 100644 --- a/R/RcppR6.R +++ b/R/RcppR6.R @@ -1,6 +1,6 @@ ## Generated by RcppR6: do not edit by hand ## Version: 0.2.4 -## Hash: 8507e9ee206b712b2a2977cedf811376 +## Hash: d7d0b7fc35679a57524539fc206c8323 ##' @importFrom Rcpp evalCpp ##' @importFrom R6 R6Class @@ -86,8 +86,8 @@ check_type <- function(type, valid) { OdeRunner <- function(T) { type <- c(T) - valid <- list("OdeRunner"="Lorenz", "OdeRunner"="OdeR", "OdeRunner"="FF16", "OdeRunner"="FF16w", "OdeRunner"="FF16r", "OdeRunner"="K93") - constructors <- list("OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`) + valid <- list("OdeRunner"="Lorenz", "OdeRunner"="OdeR", "OdeRunner"="FF16", "OdeRunner"="FF16w", "OdeRunner"="FF16r", "OdeRunner"="FF16drivers", "OdeRunner"="K93") + constructors <- list("OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`, "OdeRunner"=`OdeRunner`) constructors[[check_type(type, valid)]] } .R6_OdeRunner <- R6::R6Class("OdeRunner") @@ -404,6 +404,68 @@ OdeRunner <- function(T) { })) +`OdeRunner` <- function(obj, control=OdeControl()) { + OdeRunner___FF16drivers__ctor(obj, control) +} +.R6_OdeRunner___FF16drivers <- + R6::R6Class( + "OdeRunner", + inherit=.R6_OdeRunner, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + advance = function(time) { + OdeRunner___FF16drivers__advance(self, time) + }, + advance_fixed = function(time) { + OdeRunner___FF16drivers__advance_fixed(self, time) + }, + step = function() { + OdeRunner___FF16drivers__step(self) + }, + step_to = function(time) { + OdeRunner___FF16drivers__step_to(self, time) + }, + set_state = function(y, time) { + OdeRunner___FF16drivers__set_state(self, y, time) + }, + set_state_from_system = function() { + OdeRunner___FF16drivers__set_state_from_system(self) + }), + active=list( + time = function(value) { + if (missing(value)) { + OdeRunner___FF16drivers__time__get(self) + } else { + stop("OdeRunner$time is read-only") + } + }, + state = function(value) { + if (missing(value)) { + OdeRunner___FF16drivers__state__get(self) + } else { + stop("OdeRunner$state is read-only") + } + }, + times = function(value) { + if (missing(value)) { + OdeRunner___FF16drivers__times__get(self) + } else { + stop("OdeRunner$times is read-only") + } + }, + object = function(value) { + if (missing(value)) { + OdeRunner___FF16drivers__object__get(self) + } else { + stop("OdeRunner$object is read-only") + } + })) + + `OdeRunner` <- function(obj, control=OdeControl()) { OdeRunner___K93__ctor(obj, control) } @@ -842,8 +904,8 @@ OdeRunner <- function(T) { ##' @export Individual <- function(T, E) { type <- c(T, E) - valid <- list("Individual"=c("FF16", "FF16_Env"), "Individual"=c("FF16w", "FF16_Env"), "Individual"=c("FF16r", "FF16_Env"), "Individual"=c("K93", "K93_Env")) - constructors <- list("Individual"=`Individual`, "Individual"=`Individual`, "Individual"=`Individual`, "Individual"=`Individual`) + valid <- list("Individual"=c("FF16", "FF16_Env"), "Individual"=c("FF16w", "FF16_Env"), "Individual"=c("FF16r", "FF16_Env"), "Individual"=c("FF16drivers", "FF16_Env"), "Individual"=c("K93", "K93_Env")) + constructors <- list("Individual"=`Individual`, "Individual"=`Individual`, "Individual"=`Individual`, "Individual"=`Individual`, "Individual"=`Individual`) constructors[[check_type(type, valid)]] } .R6_Individual <- R6::R6Class("Individual") @@ -1198,6 +1260,122 @@ Individual <- function(T, E) { })) +`Individual` <- function(s) { + Individual___FF16drivers__FF16_Env__ctor(s) +} +.R6_Individual___FF16drivers__FF16_Env <- + R6::R6Class( + "Individual", + inherit=.R6_Individual, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + state = function(name) { + Individual___FF16drivers__FF16_Env__state(self, name) + }, + rate = function(name) { + Individual___FF16drivers__FF16_Env__rate(self, name) + }, + aux = function(name) { + Individual___FF16drivers__FF16_Env__aux(self, name) + }, + set_state = function(name, v) { + Individual___FF16drivers__FF16_Env__set_state(self, name, v) + }, + compute_competition = function(h) { + Individual___FF16drivers__FF16_Env__compute_competition(self, h) + }, + compute_rates = function(environment) { + Individual___FF16drivers__FF16_Env__compute_rates(self, environment) + }, + establishment_probability = function(environment) { + Individual___FF16drivers__FF16_Env__establishment_probability(self, environment) + }, + net_mass_production_dt = function(environment) { + Individual___FF16drivers__FF16_Env__net_mass_production_dt(self, environment) + }, + reset_mortality = function() { + Individual___FF16drivers__FF16_Env__reset_mortality(self) + }, + resource_compensation_point = function() { + Individual___FF16drivers__FF16_Env__resource_compensation_point(self) + }), + active=list( + strategy = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__strategy__get(self) + } else { + stop("Individual$strategy is read-only") + } + }, + internals = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__internals__get(self) + } else { + stop("Individual$internals is read-only") + } + }, + aux_size = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__aux_size__get(self) + } else { + stop("Individual$aux_size is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__ode_size__get(self) + } else { + stop("Individual$ode_size is read-only") + } + }, + ode_names = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__ode_names__get(self) + } else { + stop("Individual$ode_names is read-only") + } + }, + aux_names = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__aux_names__get(self) + } else { + stop("Individual$aux_names is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__ode_state__get(self) + } else { + Individual___FF16drivers__FF16_Env__ode_state__set(self, value) + } + }, + ode_rates = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__ode_rates__get(self) + } else { + stop("Individual$ode_rates is read-only") + } + }, + mortality_probability = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__mortality_probability__get(self) + } else { + stop("Individual$mortality_probability is read-only") + } + }, + strategy_name = function(value) { + if (missing(value)) { + Individual___FF16drivers__FF16_Env__strategy_name__get(self) + } else { + stop("Individual$strategy_name is read-only") + } + })) + + `Individual` <- function(s) { Individual___K93__K93_Env__ctor(s) } @@ -1315,8 +1493,8 @@ Individual <- function(T, E) { IndividualRunner <- function(T, E) { type <- c(T, E) - valid <- list("IndividualRunner"=c("FF16", "FF16_Env"), "IndividualRunner"=c("FF16w", "FF16_Env"), "IndividualRunner"=c("FF16r", "FF16_Env"), "IndividualRunner"=c("K93", "K93_Env")) - constructors <- list("IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`) + valid <- list("IndividualRunner"=c("FF16", "FF16_Env"), "IndividualRunner"=c("FF16w", "FF16_Env"), "IndividualRunner"=c("FF16r", "FF16_Env"), "IndividualRunner"=c("FF16drivers", "FF16_Env"), "IndividualRunner"=c("K93", "K93_Env")) + constructors <- list("IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`, "IndividualRunner"=`IndividualRunner`) constructors[[check_type(type, valid)]] } .R6_IndividualRunner <- R6::R6Class("IndividualRunner") @@ -1392,6 +1570,29 @@ IndividualRunner <- function(T, E) { })) +`IndividualRunner` <- function(individual, environment) { + IndividualRunner___FF16drivers__FF16_Env__ctor(individual, environment) +} +.R6_IndividualRunner___FF16drivers__FF16_Env <- + R6::R6Class( + "IndividualRunner", + inherit=.R6_IndividualRunner, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }), + active=list( + individual = function(value) { + if (missing(value)) { + IndividualRunner___FF16drivers__FF16_Env__individual__get(self) + } else { + IndividualRunner___FF16drivers__FF16_Env__individual__set(self, value) + } + })) + + `IndividualRunner` <- function(individual, environment) { IndividualRunner___K93__K93_Env__ctor(individual, environment) } @@ -1493,8 +1694,8 @@ IndividualRunner <- function(T, E) { Parameters <- function(T, E) { type <- c(T, E) - valid <- list("Parameters"=c("FF16", "FF16_Env"), "Parameters"=c("FF16w", "FF16_Env"), "Parameters"=c("FF16r", "FF16_Env"), "Parameters"=c("K93", "K93_Env")) - constructors <- list("Parameters"=`Parameters`, "Parameters"=`Parameters`, "Parameters"=`Parameters`, "Parameters"=`Parameters`) + valid <- list("Parameters"=c("FF16", "FF16_Env"), "Parameters"=c("FF16w", "FF16_Env"), "Parameters"=c("FF16r", "FF16_Env"), "Parameters"=c("FF16drivers", "FF16_Env"), "Parameters"=c("K93", "K93_Env")) + constructors <- list("Parameters"=`Parameters`, "Parameters"=`Parameters`, "Parameters"=`Parameters`, "Parameters"=`Parameters`, "Parameters"=`Parameters`) constructors[[check_type(type, valid)]] } @@ -1544,6 +1745,21 @@ Parameters <- function(T, E) { Parameters___FF16r__FF16_Env__vdor(ret) } +`Parameters` <- function(..., values=list(...)) { + ret <- Parameters___FF16drivers__FF16_Env__ctor() + if (length(values) > 0L) { + if (is.null(names(values)) || any(names(values) == "")) { + stop("All values must be named") + } + if (length(err <- setdiff(names(values), names(ret))) > 0L) { + stop(sprintf("Unknown fields: %s", paste(err, collapse=", "))) + } + to_set <- intersect(names(values), names(ret)) + ret[to_set] <- values[to_set] + } + Parameters___FF16drivers__FF16_Env__vdor(ret) +} + `Parameters` <- function(..., values=list(...)) { ret <- Parameters___K93__K93_Env__ctor() if (length(values) > 0L) { @@ -1561,8 +1777,8 @@ Parameters <- function(T, E) { Node <- function(T, E) { type <- c(T, E) - valid <- list("Node"=c("FF16", "FF16_Env"), "Node"=c("FF16w", "FF16_Env"), "Node"=c("FF16r", "FF16_Env"), "Node"=c("K93", "K93_Env")) - constructors <- list("Node"=`Node`, "Node"=`Node`, "Node"=`Node`, "Node"=`Node`) + valid <- list("Node"=c("FF16", "FF16_Env"), "Node"=c("FF16w", "FF16_Env"), "Node"=c("FF16r", "FF16_Env"), "Node"=c("FF16drivers", "FF16_Env"), "Node"=c("K93", "K93_Env")) + constructors <- list("Node"=`Node`, "Node"=`Node`, "Node"=`Node`, "Node"=`Node`, "Node"=`Node`) constructors[[check_type(type, valid)]] } .R6_Node <- R6::R6Class("Node") @@ -1842,6 +2058,97 @@ Node <- function(T, E) { })) +`Node` <- function(strategy) { + Node___FF16drivers__FF16_Env__ctor(strategy) +} +.R6_Node___FF16drivers__FF16_Env <- + R6::R6Class( + "Node", + inherit=.R6_Node, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + compute_competition = function(height) { + Node___FF16drivers__FF16_Env__compute_competition(self, height) + }, + growth_rate_gradient = function(environment) { + Node___FF16drivers__FF16_Env__growth_rate_gradient(self, environment) + }, + compute_rates = function(environment, pr_patch_survival) { + Node___FF16drivers__FF16_Env__compute_rates(self, environment, pr_patch_survival) + }, + compute_initial_conditions = function(environment, pr_patch_survival, birth_rate) { + Node___FF16drivers__FF16_Env__compute_initial_conditions(self, environment, pr_patch_survival, birth_rate) + }), + active=list( + individual = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__individual__get(self) + } else { + stop("Node$individual is read-only") + } + }, + height = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__height__get(self) + } else { + stop("Node$height is read-only") + } + }, + log_density = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__log_density__get(self) + } else { + stop("Node$log_density is read-only") + } + }, + competition_effect = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__competition_effect__get(self) + } else { + stop("Node$competition_effect is read-only") + } + }, + fecundity = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__fecundity__get(self) + } else { + stop("Node$fecundity is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__ode_size__get(self) + } else { + stop("Node$ode_size is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__ode_state__get(self) + } else { + Node___FF16drivers__FF16_Env__ode_state__set(self, value) + } + }, + ode_rates = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__ode_rates__get(self) + } else { + stop("Node$ode_rates is read-only") + } + }, + ode_names = function(value) { + if (missing(value)) { + Node___FF16drivers__FF16_Env__ode_names__get(self) + } else { + stop("Node$ode_names is read-only") + } + })) + + `Node` <- function(strategy) { Node___K93__K93_Env__ctor(strategy) } @@ -1934,8 +2241,8 @@ Node <- function(T, E) { Species <- function(T, E) { type <- c(T, E) - valid <- list("Species"=c("FF16", "FF16_Env"), "Species"=c("FF16w", "FF16_Env"), "Species"=c("FF16r", "FF16_Env"), "Species"=c("K93", "K93_Env")) - constructors <- list("Species"=`Species`, "Species"=`Species`, "Species"=`Species`, "Species"=`Species`) + valid <- list("Species"=c("FF16", "FF16_Env"), "Species"=c("FF16w", "FF16_Env"), "Species"=c("FF16r", "FF16_Env"), "Species"=c("FF16drivers", "FF16_Env"), "Species"=c("K93", "K93_Env")) + constructors <- list("Species"=`Species`, "Species"=`Species`, "Species"=`Species`, "Species"=`Species`, "Species"=`Species`) constructors[[check_type(type, valid)]] } .R6_Species <- R6::R6Class("Species") @@ -2296,12 +2603,12 @@ Species <- function(T, E) { })) -`Species` <- function(strategy) { - Species___K93__K93_Env__ctor(strategy) +`Species` <- function(strategy) { + Species___FF16drivers__FF16_Env__ctor(strategy) } -.R6_Species___K93__K93_Env <- +.R6_Species___FF16drivers__FF16_Env <- R6::R6Class( - "Species", + "Species", inherit=.R6_Species, portable=TRUE, public=list( @@ -2310,113 +2617,231 @@ Species <- function(T, E) { self$.ptr <- ptr }, clear = function() { - Species___K93__K93_Env__clear(self) + Species___FF16drivers__FF16_Env__clear(self) }, compute_rates = function(environment, pr_patch_survival, birth_rate) { - Species___K93__K93_Env__compute_rates(self, environment, pr_patch_survival, birth_rate) + Species___FF16drivers__FF16_Env__compute_rates(self, environment, pr_patch_survival, birth_rate) }, compute_competition = function(height) { - Species___K93__K93_Env__compute_competition(self, height) + Species___FF16drivers__FF16_Env__compute_competition(self, height) }, introduce_new_node = function() { - Species___K93__K93_Env__introduce_new_node(self) + Species___FF16drivers__FF16_Env__introduce_new_node(self) }, node_at = function(index) { - Species___K93__K93_Env__node_at(self, index) + Species___FF16drivers__FF16_Env__node_at(self, index) }, competition_effects_error = function(scal=1) { - Species___K93__K93_Env__competition_effects_error(self, scal) + Species___FF16drivers__FF16_Env__competition_effects_error(self, scal) }), active=list( size = function(value) { if (missing(value)) { - Species___K93__K93_Env__size__get(self) + Species___FF16drivers__FF16_Env__size__get(self) } else { - stop("Species$size is read-only") + stop("Species$size is read-only") } }, new_node = function(value) { if (missing(value)) { - Species___K93__K93_Env__new_node__get(self) + Species___FF16drivers__FF16_Env__new_node__get(self) } else { - stop("Species$new_node is read-only") + stop("Species$new_node is read-only") } }, height_max = function(value) { if (missing(value)) { - Species___K93__K93_Env__height_max__get(self) + Species___FF16drivers__FF16_Env__height_max__get(self) } else { - stop("Species$height_max is read-only") + stop("Species$height_max is read-only") } }, heights = function(value) { if (missing(value)) { - Species___K93__K93_Env__heights__get(self) + Species___FF16drivers__FF16_Env__heights__get(self) } else { - Species___K93__K93_Env__heights__set(self, value) + Species___FF16drivers__FF16_Env__heights__set(self, value) } }, log_densities = function(value) { if (missing(value)) { - Species___K93__K93_Env__log_densities__get(self) + Species___FF16drivers__FF16_Env__log_densities__get(self) } else { - stop("Species$log_densities is read-only") + stop("Species$log_densities is read-only") } }, nodes = function(value) { if (missing(value)) { - Species___K93__K93_Env__nodes__get(self) + Species___FF16drivers__FF16_Env__nodes__get(self) } else { - stop("Species$nodes is read-only") + stop("Species$nodes is read-only") } }, net_reproduction_ratio_by_node = function(value) { if (missing(value)) { - Species___K93__K93_Env__net_reproduction_ratio_by_node__get(self) + Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(self) } else { - stop("Species$net_reproduction_ratio_by_node is read-only") + stop("Species$net_reproduction_ratio_by_node is read-only") } }, competition_effects = function(value) { if (missing(value)) { - Species___K93__K93_Env__competition_effects__get(self) + Species___FF16drivers__FF16_Env__competition_effects__get(self) } else { - stop("Species$competition_effects is read-only") + stop("Species$competition_effects is read-only") } }, extrinsic_drivers = function(value) { if (missing(value)) { - Species___K93__K93_Env__extrinsic_drivers__get(self) + Species___FF16drivers__FF16_Env__extrinsic_drivers__get(self) } else { - stop("Species$extrinsic_drivers is read-only") + stop("Species$extrinsic_drivers is read-only") } }, ode_size = function(value) { if (missing(value)) { - Species___K93__K93_Env__ode_size__get(self) + Species___FF16drivers__FF16_Env__ode_size__get(self) } else { - stop("Species$ode_size is read-only") + stop("Species$ode_size is read-only") } }, ode_state = function(value) { if (missing(value)) { - Species___K93__K93_Env__ode_state__get(self) + Species___FF16drivers__FF16_Env__ode_state__get(self) } else { - Species___K93__K93_Env__ode_state__set(self, value) + Species___FF16drivers__FF16_Env__ode_state__set(self, value) } }, ode_rates = function(value) { if (missing(value)) { - Species___K93__K93_Env__ode_rates__get(self) + Species___FF16drivers__FF16_Env__ode_rates__get(self) } else { - stop("Species$ode_rates is read-only") + stop("Species$ode_rates is read-only") } })) -Patch <- function(T, E) { - type <- c(T, E) - valid <- list("Patch"=c("FF16", "FF16_Env"), "Patch"=c("FF16w", "FF16_Env"), "Patch"=c("FF16r", "FF16_Env"), "Patch"=c("K93", "K93_Env")) - constructors <- list("Patch"=`Patch`, "Patch"=`Patch`, "Patch"=`Patch`, "Patch"=`Patch`) + +`Species` <- function(strategy) { + Species___K93__K93_Env__ctor(strategy) +} +.R6_Species___K93__K93_Env <- + R6::R6Class( + "Species", + inherit=.R6_Species, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + clear = function() { + Species___K93__K93_Env__clear(self) + }, + compute_rates = function(environment, pr_patch_survival, birth_rate) { + Species___K93__K93_Env__compute_rates(self, environment, pr_patch_survival, birth_rate) + }, + compute_competition = function(height) { + Species___K93__K93_Env__compute_competition(self, height) + }, + introduce_new_node = function() { + Species___K93__K93_Env__introduce_new_node(self) + }, + node_at = function(index) { + Species___K93__K93_Env__node_at(self, index) + }, + competition_effects_error = function(scal=1) { + Species___K93__K93_Env__competition_effects_error(self, scal) + }), + active=list( + size = function(value) { + if (missing(value)) { + Species___K93__K93_Env__size__get(self) + } else { + stop("Species$size is read-only") + } + }, + new_node = function(value) { + if (missing(value)) { + Species___K93__K93_Env__new_node__get(self) + } else { + stop("Species$new_node is read-only") + } + }, + height_max = function(value) { + if (missing(value)) { + Species___K93__K93_Env__height_max__get(self) + } else { + stop("Species$height_max is read-only") + } + }, + heights = function(value) { + if (missing(value)) { + Species___K93__K93_Env__heights__get(self) + } else { + Species___K93__K93_Env__heights__set(self, value) + } + }, + log_densities = function(value) { + if (missing(value)) { + Species___K93__K93_Env__log_densities__get(self) + } else { + stop("Species$log_densities is read-only") + } + }, + nodes = function(value) { + if (missing(value)) { + Species___K93__K93_Env__nodes__get(self) + } else { + stop("Species$nodes is read-only") + } + }, + net_reproduction_ratio_by_node = function(value) { + if (missing(value)) { + Species___K93__K93_Env__net_reproduction_ratio_by_node__get(self) + } else { + stop("Species$net_reproduction_ratio_by_node is read-only") + } + }, + competition_effects = function(value) { + if (missing(value)) { + Species___K93__K93_Env__competition_effects__get(self) + } else { + stop("Species$competition_effects is read-only") + } + }, + extrinsic_drivers = function(value) { + if (missing(value)) { + Species___K93__K93_Env__extrinsic_drivers__get(self) + } else { + stop("Species$extrinsic_drivers is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + Species___K93__K93_Env__ode_size__get(self) + } else { + stop("Species$ode_size is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + Species___K93__K93_Env__ode_state__get(self) + } else { + Species___K93__K93_Env__ode_state__set(self, value) + } + }, + ode_rates = function(value) { + if (missing(value)) { + Species___K93__K93_Env__ode_rates__get(self) + } else { + stop("Species$ode_rates is read-only") + } + })) + +Patch <- function(T, E) { + type <- c(T, E) + valid <- list("Patch"=c("FF16", "FF16_Env"), "Patch"=c("FF16w", "FF16_Env"), "Patch"=c("FF16r", "FF16_Env"), "Patch"=c("FF16drivers", "FF16_Env"), "Patch"=c("K93", "K93_Env")) + constructors <- list("Patch"=`Patch`, "Patch"=`Patch`, "Patch"=`Patch`, "Patch"=`Patch`, "Patch"=`Patch`) constructors[[check_type(type, valid)]] } .R6_Patch <- R6::R6Class("Patch") @@ -2849,6 +3274,148 @@ Patch <- function(T, E) { })) +`Patch` <- function(parameters, environment, control) { + Patch___FF16drivers__FF16_Env__ctor(parameters, environment, control) +} +.R6_Patch___FF16drivers__FF16_Env <- + R6::R6Class( + "Patch", + inherit=.R6_Patch, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + introduce_new_node = function(species_index) { + Patch___FF16drivers__FF16_Env__introduce_new_node(self, species_index) + }, + compute_environment = function() { + Patch___FF16drivers__FF16_Env__compute_environment(self) + }, + compute_rates = function() { + Patch___FF16drivers__FF16_Env__compute_rates(self) + }, + reset = function() { + Patch___FF16drivers__FF16_Env__reset(self) + }, + set_ode_state = function(values, time) { + Patch___FF16drivers__FF16_Env__set_ode_state(self, values, time) + }, + derivs = function(y, time) { + Patch___FF16drivers__FF16_Env__derivs(self, y, time) + }, + set_time = function(time) { + Patch___FF16drivers__FF16_Env__set_time(self, time) + }, + set_state = function(time, state, n, env) { + Patch___FF16drivers__FF16_Env__set_state(self, time, state, n, env) + }, + density = function(time) { + Patch___FF16drivers__FF16_Env__density(self, time) + }, + pr_survival = function(time) { + Patch___FF16drivers__FF16_Env__pr_survival(self, time) + }, + disturbance_mean_interval = function() { + Patch___FF16drivers__FF16_Env__disturbance_mean_interval(self) + }, + survival_weighting_cdf = function(time) { + Patch___FF16drivers__FF16_Env__survival_weighting_cdf(self, time) + }, + survival_weighting_icdf = function(prob) { + Patch___FF16drivers__FF16_Env__survival_weighting_icdf(self, prob) + }, + compute_competition = function(height) { + Patch___FF16drivers__FF16_Env__compute_competition(self, height) + }), + active=list( + time = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__time__get(self) + } else { + stop("Patch$time is read-only") + } + }, + size = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__size__get(self) + } else { + stop("Patch$size is read-only") + } + }, + height_max = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__height_max__get(self) + } else { + stop("Patch$height_max is read-only") + } + }, + parameters = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__parameters__get(self) + } else { + stop("Patch$parameters is read-only") + } + }, + environment = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__environment__get(self) + } else { + stop("Patch$environment is read-only") + } + }, + species = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__species__get(self) + } else { + stop("Patch$species is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__ode_size__get(self) + } else { + stop("Patch$ode_size is read-only") + } + }, + ode_time = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__ode_time__get(self) + } else { + stop("Patch$ode_time is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__ode_state__get(self) + } else { + stop("Patch$ode_state is read-only") + } + }, + ode_rates = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__ode_rates__get(self) + } else { + stop("Patch$ode_rates is read-only") + } + }, + ode_aux = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__ode_aux__get(self) + } else { + stop("Patch$ode_aux is read-only") + } + }, + node_ode_size = function(value) { + if (missing(value)) { + Patch___FF16drivers__FF16_Env__node_ode_size__get(self) + } else { + stop("Patch$node_ode_size is read-only") + } + })) + + `Patch` <- function(parameters, environment, control) { Patch___K93__K93_Env__ctor(parameters, environment, control) } @@ -2992,8 +3559,8 @@ Patch <- function(T, E) { SCM <- function(T, E) { type <- c(T, E) - valid <- list("SCM"=c("FF16", "FF16_Env"), "SCM"=c("FF16w", "FF16_Env"), "SCM"=c("FF16r", "FF16_Env"), "SCM"=c("K93", "K93_Env")) - constructors <- list("SCM"=`SCM`, "SCM"=`SCM`, "SCM"=`SCM`, "SCM"=`SCM`) + valid <- list("SCM"=c("FF16", "FF16_Env"), "SCM"=c("FF16w", "FF16_Env"), "SCM"=c("FF16r", "FF16_Env"), "SCM"=c("FF16drivers", "FF16_Env"), "SCM"=c("K93", "K93_Env")) + constructors <- list("SCM"=`SCM`, "SCM"=`SCM`, "SCM"=`SCM`, "SCM"=`SCM`, "SCM"=`SCM`) constructors[[check_type(type, valid)]] } .R6_SCM <- R6::R6Class("SCM") @@ -3274,91 +3841,212 @@ SCM <- function(T, E) { SCM___FF16r__FF16_Env__competition_effect_error(self, species_index) }, set_node_schedule_times = function(times) { - SCM___FF16r__FF16_Env__set_node_schedule_times(self, times) + SCM___FF16r__FF16_Env__set_node_schedule_times(self, times) + }), + active=list( + complete = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__complete__get(self) + } else { + stop("SCM$complete is read-only") + } + }, + time = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__time__get(self) + } else { + stop("SCM$time is read-only") + } + }, + net_reproduction_ratios = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__net_reproduction_ratios__get(self) + } else { + stop("SCM$net_reproduction_ratios is read-only") + } + }, + offspring_production = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__offspring_production__get(self) + } else { + stop("SCM$offspring_production is read-only") + } + }, + parameters = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__parameters__get(self) + } else { + stop("SCM$parameters is read-only") + } + }, + patch = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__patch__get(self) + } else { + stop("SCM$patch is read-only") + } + }, + node_schedule = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__node_schedule__get(self) + } else { + SCM___FF16r__FF16_Env__node_schedule__set(self, value) + } + }, + ode_times = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__ode_times__get(self) + } else { + stop("SCM$ode_times is read-only") + } + }, + state = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__state__get(self) + } else { + stop("SCM$state is read-only") + } + }, + aux = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__aux__get(self) + } else { + stop("SCM$aux is read-only") + } + }, + use_ode_times = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__use_ode_times__get(self) + } else { + SCM___FF16r__FF16_Env__use_ode_times__set(self, value) + } + }, + net_reproduction_ratio_errors = function(value) { + if (missing(value)) { + SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get(self) + } else { + stop("SCM$net_reproduction_ratio_errors is read-only") + } + })) + + +`SCM` <- function(parameters, environment, control) { + SCM___FF16drivers__FF16_Env__ctor(parameters, environment, control) +} +.R6_SCM___FF16drivers__FF16_Env <- + R6::R6Class( + "SCM", + inherit=.R6_SCM, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + run = function() { + SCM___FF16drivers__FF16_Env__run(self) + }, + run_mutant = function(p) { + SCM___FF16drivers__FF16_Env__run_mutant(self, p) + }, + run_next = function() { + SCM___FF16drivers__FF16_Env__run_next(self) + }, + reset = function() { + SCM___FF16drivers__FF16_Env__reset(self) + }, + net_reproduction_ratio_for_species = function(species_index) { + SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species(self, species_index) + }, + competition_effect_error = function(species_index) { + SCM___FF16drivers__FF16_Env__competition_effect_error(self, species_index) + }, + set_node_schedule_times = function(times) { + SCM___FF16drivers__FF16_Env__set_node_schedule_times(self, times) }), active=list( complete = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__complete__get(self) + SCM___FF16drivers__FF16_Env__complete__get(self) } else { - stop("SCM$complete is read-only") + stop("SCM$complete is read-only") } }, time = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__time__get(self) + SCM___FF16drivers__FF16_Env__time__get(self) } else { - stop("SCM$time is read-only") + stop("SCM$time is read-only") } }, net_reproduction_ratios = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__net_reproduction_ratios__get(self) + SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get(self) } else { - stop("SCM$net_reproduction_ratios is read-only") + stop("SCM$net_reproduction_ratios is read-only") } }, offspring_production = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__offspring_production__get(self) + SCM___FF16drivers__FF16_Env__offspring_production__get(self) } else { - stop("SCM$offspring_production is read-only") + stop("SCM$offspring_production is read-only") } }, parameters = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__parameters__get(self) + SCM___FF16drivers__FF16_Env__parameters__get(self) } else { - stop("SCM$parameters is read-only") + stop("SCM$parameters is read-only") } }, patch = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__patch__get(self) + SCM___FF16drivers__FF16_Env__patch__get(self) } else { - stop("SCM$patch is read-only") + stop("SCM$patch is read-only") } }, node_schedule = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__node_schedule__get(self) + SCM___FF16drivers__FF16_Env__node_schedule__get(self) } else { - SCM___FF16r__FF16_Env__node_schedule__set(self, value) + SCM___FF16drivers__FF16_Env__node_schedule__set(self, value) } }, ode_times = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__ode_times__get(self) + SCM___FF16drivers__FF16_Env__ode_times__get(self) } else { - stop("SCM$ode_times is read-only") + stop("SCM$ode_times is read-only") } }, state = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__state__get(self) + SCM___FF16drivers__FF16_Env__state__get(self) } else { - stop("SCM$state is read-only") + stop("SCM$state is read-only") } }, aux = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__aux__get(self) + SCM___FF16drivers__FF16_Env__aux__get(self) } else { - stop("SCM$aux is read-only") + stop("SCM$aux is read-only") } }, use_ode_times = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__use_ode_times__get(self) + SCM___FF16drivers__FF16_Env__use_ode_times__get(self) } else { - SCM___FF16r__FF16_Env__use_ode_times__set(self, value) + SCM___FF16drivers__FF16_Env__use_ode_times__set(self, value) } }, net_reproduction_ratio_errors = function(value) { if (missing(value)) { - SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get(self) + SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get(self) } else { - stop("SCM$net_reproduction_ratio_errors is read-only") + stop("SCM$net_reproduction_ratio_errors is read-only") } })) @@ -3485,8 +4173,8 @@ SCM <- function(T, E) { StochasticSpecies <- function(T, E) { type <- c(T, E) - valid <- list("StochasticSpecies"=c("FF16", "FF16_Env"), "StochasticSpecies"=c("FF16w", "FF16_Env"), "StochasticSpecies"=c("FF16r", "FF16_Env"), "StochasticSpecies"=c("K93", "K93_Env")) - constructors <- list("StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`) + valid <- list("StochasticSpecies"=c("FF16", "FF16_Env"), "StochasticSpecies"=c("FF16w", "FF16_Env"), "StochasticSpecies"=c("FF16r", "FF16_Env"), "StochasticSpecies"=c("FF16drivers", "FF16_Env"), "StochasticSpecies"=c("K93", "K93_Env")) + constructors <- list("StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`, "StochasticSpecies"=`StochasticSpecies`) constructors[[check_type(type, valid)]] } .R6_StochasticSpecies <- R6::R6Class("StochasticSpecies") @@ -3835,6 +4523,120 @@ StochasticSpecies <- function(T, E) { })) +`StochasticSpecies` <- function(strategy) { + StochasticSpecies___FF16drivers__FF16_Env__ctor(strategy) +} +.R6_StochasticSpecies___FF16drivers__FF16_Env <- + R6::R6Class( + "StochasticSpecies", + inherit=.R6_StochasticSpecies, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + clear = function() { + StochasticSpecies___FF16drivers__FF16_Env__clear(self) + }, + compute_rates = function(environment) { + StochasticSpecies___FF16drivers__FF16_Env__compute_rates(self, environment) + }, + compute_competition = function(height) { + StochasticSpecies___FF16drivers__FF16_Env__compute_competition(self, height) + }, + introduce_new_node = function() { + StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node(self) + }, + individual_at = function(index) { + StochasticSpecies___FF16drivers__FF16_Env__individual_at(self, index) + }, + deaths = function() { + StochasticSpecies___FF16drivers__FF16_Env__deaths(self) + }, + establishment_probability = function(environment) { + StochasticSpecies___FF16drivers__FF16_Env__establishment_probability(self, environment) + }), + active=list( + size = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__size__get(self) + } else { + stop("StochasticSpecies$size is read-only") + } + }, + size_individuals = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get(self) + } else { + stop("StochasticSpecies$size_individuals is read-only") + } + }, + new_node = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__new_node__get(self) + } else { + stop("StochasticSpecies$new_node is read-only") + } + }, + height_max = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__height_max__get(self) + } else { + stop("StochasticSpecies$height_max is read-only") + } + }, + heights = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__heights__get(self) + } else { + StochasticSpecies___FF16drivers__FF16_Env__heights__set(self, value) + } + }, + individuals = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__individuals__get(self) + } else { + stop("StochasticSpecies$individuals is read-only") + } + }, + is_alive = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__is_alive__get(self) + } else { + stop("StochasticSpecies$is_alive is read-only") + } + }, + net_reproduction_ratio_by_node = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(self) + } else { + stop("StochasticSpecies$net_reproduction_ratio_by_node is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__ode_size__get(self) + } else { + stop("StochasticSpecies$ode_size is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__ode_state__get(self) + } else { + StochasticSpecies___FF16drivers__FF16_Env__ode_state__set(self, value) + } + }, + ode_rates = function(value) { + if (missing(value)) { + StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get(self) + } else { + stop("StochasticSpecies$ode_rates is read-only") + } + })) + + `StochasticSpecies` <- function(strategy) { StochasticSpecies___K93__K93_Env__ctor(strategy) } @@ -3950,8 +4752,8 @@ StochasticSpecies <- function(T, E) { StochasticPatch <- function(T, E) { type <- c(T, E) - valid <- list("StochasticPatch"=c("FF16", "FF16_Env"), "StochasticPatch"=c("FF16w", "FF16_Env"), "StochasticPatch"=c("FF16r", "FF16_Env"), "StochasticPatch"=c("K93", "K93_Env")) - constructors <- list("StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`) + valid <- list("StochasticPatch"=c("FF16", "FF16_Env"), "StochasticPatch"=c("FF16w", "FF16_Env"), "StochasticPatch"=c("FF16r", "FF16_Env"), "StochasticPatch"=c("FF16drivers", "FF16_Env"), "StochasticPatch"=c("K93", "K93_Env")) + constructors <- list("StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`, "StochasticPatch"=`StochasticPatch`) constructors[[check_type(type, valid)]] } .R6_StochasticPatch <- R6::R6Class("StochasticPatch") @@ -4306,6 +5108,122 @@ StochasticPatch <- function(T, E) { })) +`StochasticPatch` <- function(parameters, environment, control) { + StochasticPatch___FF16drivers__FF16_Env__ctor(parameters, environment, control) +} +.R6_StochasticPatch___FF16drivers__FF16_Env <- + R6::R6Class( + "StochasticPatch", + inherit=.R6_StochasticPatch, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + compute_competition = function(height) { + StochasticPatch___FF16drivers__FF16_Env__compute_competition(self, height) + }, + introduce_new_node = function(species_index) { + StochasticPatch___FF16drivers__FF16_Env__introduce_new_node(self, species_index) + }, + introduce_new_node_and_update = function(species_index) { + StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update(self, species_index) + }, + compute_environment = function() { + StochasticPatch___FF16drivers__FF16_Env__compute_environment(self) + }, + compute_rates = function() { + StochasticPatch___FF16drivers__FF16_Env__compute_rates(self) + }, + reset = function() { + StochasticPatch___FF16drivers__FF16_Env__reset(self) + }, + set_ode_state = function(values, time) { + StochasticPatch___FF16drivers__FF16_Env__set_ode_state(self, values, time) + }, + derivs = function(y, time) { + StochasticPatch___FF16drivers__FF16_Env__derivs(self, y, time) + }, + set_state = function(time, state, n) { + StochasticPatch___FF16drivers__FF16_Env__set_state(self, time, state, n) + }, + deaths = function() { + StochasticPatch___FF16drivers__FF16_Env__deaths(self) + }), + active=list( + time = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__time__get(self) + } else { + stop("StochasticPatch$time is read-only") + } + }, + size = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__size__get(self) + } else { + stop("StochasticPatch$size is read-only") + } + }, + height_max = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__height_max__get(self) + } else { + stop("StochasticPatch$height_max is read-only") + } + }, + parameters = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__parameters__get(self) + } else { + stop("StochasticPatch$parameters is read-only") + } + }, + environment = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__environment__get(self) + } else { + stop("StochasticPatch$environment is read-only") + } + }, + species = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__species__get(self) + } else { + stop("StochasticPatch$species is read-only") + } + }, + ode_size = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__ode_size__get(self) + } else { + stop("StochasticPatch$ode_size is read-only") + } + }, + ode_time = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__ode_time__get(self) + } else { + stop("StochasticPatch$ode_time is read-only") + } + }, + ode_state = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__ode_state__get(self) + } else { + stop("StochasticPatch$ode_state is read-only") + } + }, + ode_rates = function(value) { + if (missing(value)) { + StochasticPatch___FF16drivers__FF16_Env__ode_rates__get(self) + } else { + stop("StochasticPatch$ode_rates is read-only") + } + })) + + `StochasticPatch` <- function(parameters, environment, control) { StochasticPatch___K93__K93_Env__ctor(parameters, environment, control) } @@ -4423,8 +5341,8 @@ StochasticPatch <- function(T, E) { StochasticPatchRunner <- function(T, E) { type <- c(T, E) - valid <- list("StochasticPatchRunner"=c("FF16", "FF16_Env"), "StochasticPatchRunner"=c("FF16w", "FF16_Env"), "StochasticPatchRunner"=c("FF16r", "FF16_Env"), "StochasticPatchRunner"=c("K93", "K93_Env")) - constructors <- list("StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`) + valid <- list("StochasticPatchRunner"=c("FF16", "FF16_Env"), "StochasticPatchRunner"=c("FF16w", "FF16_Env"), "StochasticPatchRunner"=c("FF16r", "FF16_Env"), "StochasticPatchRunner"=c("FF16drivers", "FF16_Env"), "StochasticPatchRunner"=c("K93", "K93_Env")) + constructors <- list("StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`, "StochasticPatchRunner"=`StochasticPatchRunner`) constructors[[check_type(type, valid)]] } .R6_StochasticPatchRunner <- R6::R6Class("StochasticPatchRunner") @@ -4641,6 +5559,76 @@ StochasticPatchRunner <- function(T, E) { })) +`StochasticPatchRunner` <- function(parameters, environment, control) { + StochasticPatchRunner___FF16drivers__FF16_Env__ctor(parameters, environment, control) +} +.R6_StochasticPatchRunner___FF16drivers__FF16_Env <- + R6::R6Class( + "StochasticPatchRunner", + inherit=.R6_StochasticPatchRunner, + portable=TRUE, + public=list( + .ptr=NULL, + initialize = function(ptr) { + self$.ptr <- ptr + }, + run = function() { + StochasticPatchRunner___FF16drivers__FF16_Env__run(self) + }, + run_next = function() { + StochasticPatchRunner___FF16drivers__FF16_Env__run_next(self) + }, + reset = function() { + StochasticPatchRunner___FF16drivers__FF16_Env__reset(self) + }, + set_schedule_times = function(times) { + StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times(self, times) + }), + active=list( + complete = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__complete__get(self) + } else { + stop("StochasticPatchRunner$complete is read-only") + } + }, + time = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__time__get(self) + } else { + stop("StochasticPatchRunner$time is read-only") + } + }, + parameters = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get(self) + } else { + stop("StochasticPatchRunner$parameters is read-only") + } + }, + patch = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__patch__get(self) + } else { + stop("StochasticPatchRunner$patch is read-only") + } + }, + schedule = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get(self) + } else { + StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set(self, value) + } + }, + state = function(value) { + if (missing(value)) { + StochasticPatchRunner___FF16drivers__FF16_Env__state__get(self) + } else { + stop("StochasticPatchRunner$state is read-only") + } + })) + + `StochasticPatchRunner` <- function(parameters, environment, control) { StochasticPatchRunner___K93__K93_Env__ctor(parameters, environment, control) } @@ -4844,6 +5832,8 @@ StochasticPatchRunner <- function(T, E) { } ##' FF16_Environment object +##' @param canopy_rescale_usually whether to rescale intervals when estimating light environment +##' @param soil_number_of_depths Number of soil layers to include ##' @export `FF16_Environment` <- function(canopy_rescale_usually, soil_number_of_depths) { FF16_Environment__ctor(canopy_rescale_usually, soil_number_of_depths) @@ -4917,6 +5907,26 @@ StochasticPatchRunner <- function(T, E) { } })) +##' Strategy parameters that tune various aspects of the biological model. +##' @title Strategy parameters +##' @param ...,values Values to initialise the struct with (either as +##' variadic arguments, or as a list, but not both). +##' @export +`FF16drivers_Strategy` <- function(..., values=list(...)) { + ret <- FF16drivers_Strategy__ctor() + if (length(values) > 0L) { + if (is.null(names(values)) || any(names(values) == "")) { + stop("All values must be named") + } + if (length(err <- setdiff(names(values), names(ret))) > 0L) { + stop(sprintf("Unknown fields: %s", paste(err, collapse=", "))) + } + to_set <- intersect(names(values), names(ret)) + ret[to_set] <- values[to_set] + } + ret +} + ##' Strategy parameters that tune various aspects of the biological model. ##' @title Strategy parameters ##' @param ...,values Values to initialise the struct with (either as diff --git a/R/ff16drivers.R b/R/ff16drivers.R new file mode 100644 index 000000000..fe7dec1ae --- /dev/null +++ b/R/ff16drivers.R @@ -0,0 +1,308 @@ +# Built from R/ff16.R on Wed Aug 12 11:12:34 2020 using the scaffolder, from the strategy: FF16 + +##' Create a FF16drivers Plant or Node +##' @title Create a FF16drivers Plant or Node +##' @param s A \code{\link{FF16drivers_Strategy}} object +##' @export +##' @rdname FF16drivers +##' @examples +##' pl <- FF16drivers_Individual() +##' pl$height +FF16drivers_Individual <- function(s=FF16drivers_Strategy()) { + Individual("FF16drivers", "FF16_Env")(s) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_Node <- function(s=FF16drivers_Strategy()) { + Node("FF16drivers", "FF16_Env")(s) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_Species <- function(s=FF16drivers_Strategy()) { + Species("FF16drivers", "FF16_Env")(s) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_Parameters <- function() { + Parameters("FF16drivers","FF16_Env")() +} + +##' @export +##' @rdname FF16drivers +##' @param p A \code{Parameters} object +FF16drivers_Patch <- function(p) { + Patch("FF16drivers", "FF16_Env")(p) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_SCM <- function(p) { + SCM("FF16drivers", "FF16_Env")(p) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_StochasticSpecies <- function(s=FF16drivers_Strategy()) { + StochasticSpecies("FF16drivers", "FF16_Env")(s) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_StochasticPatch <- function(p) { + StochasticPatch("FF16drivers", "FF16_Env")(p) +} + +##' @export +##' @rdname FF16drivers +FF16drivers_StochasticPatchRunner <- function(p) { + StochasticPatchRunner("FF16drivers", "FF16_Env")(p) +} + +## Helper: +##' @export +##' @rdname FF16_Environment +##' @param canopy_rescale_usually turns on environment rescaling (default = TRUE) +FF16drivers_make_environment <- function(canopy_rescale_usually = TRUE) { + + FF16_make_environment(canopy_rescale_usually) +} + + +##' This makes a pretend light environment over the plant height, +##' slightly concave up, whatever. +##' @title Create a test environment for FF16drivers startegy +##' @param height top height of environment object +##' @param n number of points +##' @param light_env function for light environment in test object +##' @param n_strategies number of strategies for test environment +##' @export +##' @rdname FF16drivers_test_environment +##' @examples +##' environment <- FF16drivers_test_environment(10) +FF16drivers_test_environment <- function(height, n=101, light_env=NULL, + n_strategies=1) { + hh <- seq(0, height, length.out=n) + if (is.null(light_env)) { + light_env <- function(x) { + exp(x/(height*2)) - 1 + (1 - (exp(.5) - 1))/2 + } + } + ee <- light_env(hh) + interpolator <- Interpolator() + interpolator$init(hh, ee) + + ret <- FF16drivers_make_environment() + ret$canopy$canopy_interpolator <- interpolator + attr(ret, "light_env") <- light_env + ret +} + + + +##' Hyperparameters for FF16drivers physiological model +##' @title Hyperparameters for FF16drivers physiological model +##' @param lma_0 Central (mean) value for leaf mass per area [kg /m2] +##' @param B_kl1 Rate of leaf turnover at lma_0 [/yr] +##' @param B_kl2 Scaling slope for phi in leaf turnover [dimensionless] +##' @param rho_0 Central (mean) value for wood density [kg /m3] +##' @param B_dI1 Rate of instantaneous mortality at rho_0 [/yr] +##' @param B_dI2 Scaling slope for wood density in intrinsic mortality [dimensionless] +##' @param B_ks1 Rate of sapwood turnover at rho_0 [/yr] +##' @param B_ks2 Scaling slope for rho in sapwood turnover [dimensionless] +##' @param B_rs1 CO_2 respiration per unit sapwood volume [mol / yr / m3 ] +##' @param B_rb1 CO_2 respiration per unit sapwood volume [mol / yr / m3 ] +##' @param B_f1 Cost of seed accessories per unit seed mass [dimensionless] +##' @param narea nitrogen per leaf area [kg / m2] +##' @param narea_0 central (mean) value for nitrogen per leaf area [kg / m2] +##' @param B_lf1 Potential CO_2 photosynthesis at average leaf nitrogen [mol / d / m2] +##' @param B_lf2 Curvature of leaf photosynthetic light response curve [dimensionless] +##' @param B_lf3 Quantum yield of leaf photosynthetic light response curve [dimensionless] +##' @param B_lf4 CO_2 respiration per unit leaf nitrogen [mol / yr / kg] +##' @param B_lf5 Scaling exponent for leaf nitrogen in maximum leaf photosynthesis [dimensionless] +##' @param k_I light extinction coefficient [dimensionless] +##' @param latitude degrees from equator (0-90), used in solar model [deg] +##' @importFrom stats coef nls +##' @export +##' @rdname FF16drivers_hyperpar +make_FF16drivers_hyperpar <- function( + lma_0=0.1978791, + B_kl1=0.4565855, + B_kl2=1.71, + rho_0=608.0, + B_dI1=0.01, + B_dI2=0.0, + B_ks1=0.2, + B_ks2=0.0, + B_rs1=4012.0, + B_rb1=2.0*4012.0, + B_f1 =3.0, + narea=1.87e-3, + narea_0=1.87e-3, + B_lf1=5120.738 * 1.87e-3 * 24 * 3600 / 1e+06, + B_lf2=0.5, + B_lf3=0.04, + B_lf4=21000, + B_lf5=1, + k_I=0.5, + latitude=0) { + assert_scalar <- function(x, name=deparse(substitute(x))) { + if (length(x) != 1L) { + stop(sprintf("%s must be a scalar", name), call. = FALSE) + } + } + assert_scalar(lma_0) + assert_scalar(B_kl1) + assert_scalar(B_kl2) + assert_scalar(rho_0) + assert_scalar(B_dI1) + assert_scalar(B_dI2) + assert_scalar(B_ks1) + assert_scalar(B_ks2) + assert_scalar(B_rs1) + assert_scalar(B_rb1) + assert_scalar(B_f1) + assert_scalar(narea) + assert_scalar(narea_0) + assert_scalar(B_lf1) + assert_scalar(B_lf2) + assert_scalar(B_lf3) + assert_scalar(B_lf4) + assert_scalar(B_lf5) + assert_scalar(k_I) + assert_scalar(latitude) + + function(m, s, filter=TRUE) { + with_default <- function(name, default_value=s[[name]]) { + rep_len(if (name %in% colnames(m)) m[, name] else default_value, + nrow(m)) + } + lma <- with_default("lma") + rho <- with_default("rho") + omega <- with_default("omega") + narea <- with_default("narea", narea) + + ## lma / leaf turnover relationship: + k_l <- B_kl1 * (lma / lma_0) ^ (-B_kl2) + + ## rho / mortality relationship: + d_I <- B_dI1 * (rho / rho_0) ^ (-B_dI2) + + ## rho / wood turnover relationship: + k_s <- B_ks1 * (rho / rho_0) ^ (-B_ks2) + + ## rho / sapwood respiration relationship: + + ## Respiration rates are per unit mass, so this next line has the + ## effect of holding constant the respiration rate per unit volume. + ## So respiration rates per unit mass vary with rho, respiration + ## rates per unit volume don't. + r_s <- B_rs1 / rho + # bark respiration follows from sapwood + r_b <- B_rb1 / rho + + ## omega / accessory cost relationship + a_f3 <- B_f1 * omega + + ## Narea, photosynthesis, respiration + + assimilation_rectangular_hyperbolae <- function(I, Amax, theta, QY) { + x <- QY * I + Amax + (x - sqrt(x^2 - 4 * theta * QY * I * Amax)) / (2 * theta) + } + + ## Photosynthesis [mol CO2 / m2 / yr] + approximate_annual_assimilation <- function(narea, latitude) { + E <- seq(0, 1, by=0.02) + ## Only integrate over half year, as solar path is symmetrical + D <- seq(0, 365/2, length.out = 10000) + I <- PAR_given_solar_angle(solar_angle(D, latitude = abs(latitude))) + + Amax <- B_lf1 * (narea/narea_0) ^ B_lf5 + theta <- B_lf2 + QY <- B_lf3 + + AA <- NA * E + + for (i in seq_len(length(E))) { + AA[i] <- 2 * trapezium(D, assimilation_rectangular_hyperbolae( + k_I * I * E[i], Amax, theta, QY)) + } + if(all(diff(AA) < 1E-8)) { + # line fitting will fail if all have are zero, or potentially same value + ret <- c(last(AA), 0) + names(ret) <- c("p1","p2") + } else { + fit <- nls(AA ~ p1 * E/(p2 + E), data.frame(E = E, AA = AA), start = list(p1 = 100, p2 = 0.2)) + ret <- coef(fit) + } + ret + } + + # This needed in case narea has length zero, in which case trapezium fails + a_p1 <- a_p2 <- 0 * narea + ## TODO: Remove the 0.5 hardcoded default for k_I here, and deal + ## with this more nicely. + if (length(narea) > 0 || k_I != 0.5) { + i <- match(narea, unique(narea)) + y <- vapply(unique(narea), approximate_annual_assimilation, + numeric(2), latitude) + a_p1 <- y["p1", i] + a_p2 <- y["p2", i] + } + + ## Respiration rates are per unit mass, so convert to mass-based + ## rate by dividing with lma + ## So respiration rates per unit mass vary with lma, while + ## respiration rates per unit area don't. + r_l <- B_lf4 * narea / lma + + extra <- cbind(k_l, # lma + d_I, k_s, r_s, r_b, # rho + a_f3, # omega + a_p1, a_p2, # narea + r_l) # lma, narea + + overlap <- intersect(colnames(m), colnames(extra)) + if (length(overlap) > 0L) { + stop("Attempt to overwrite generated parameters: ", + paste(overlap, collapse=", ")) + } + + ## Filter extra so that any column where all numbers are with eps + ## of the default strategy are not replaced: + if (filter) { + if (nrow(extra) == 0L) { + extra <- NULL + } else { + pos <- diff(apply(extra, 2, range)) == 0 + if (any(pos)) { + eps <- sqrt(.Machine$double.eps) + x1 <- extra[1, pos] + x2 <- unlist(s[names(x1)]) + drop <- abs(x1 - x2) < eps & abs(1 - x1/x2) < eps + if (any(drop)) { + keep <- setdiff(colnames(extra), names(drop)[drop]) + extra <- extra[, keep, drop=FALSE] + } + } + } + } + + if (!is.null(extra)) { + m <- cbind(m, extra) + } + m + } +} + +##' Hyperparameter function for FF16drivers physiological model +##' @title Hyperparameter function for FF16drivers physiological model +##' @param m A matrix of trait values, as returned by \code{trait_matrix} +##' @param s A strategy object +##' @param filter A flag indicating whether to filter columns. If TRUE, any numbers +##' that are within eps of the default strategy are not replaced. +##' @export +FF16drivers_hyperpar <- make_FF16drivers_hyperpar() diff --git a/R/strategy_support.R b/R/strategy_support.R index 59106475e..28a5e79b4 100644 --- a/R/strategy_support.R +++ b/R/strategy_support.R @@ -11,6 +11,7 @@ make_hyperpar <- function(type) { FF16=make_FF16_hyperpar, FF16w=make_FF16w_hyperpar, FF16r=make_FF16r_hyperpar, + FF16drivers=make_FF16drivers_hyperpar, K93=make_K93_hyperpar, stop("Unknown type ", type)) } @@ -23,6 +24,7 @@ param_hyperpar <- function(parameters) { FF16_Strategy=FF16_hyperpar, FF16w_Strategy=FF16w_hyperpar, FF16r_Strategy=FF16r_hyperpar, + FF16drivers_Strategy=FF16drivers_hyperpar, K93_Strategy=K93_hyperpar, stop("Unknown type ", type)) } @@ -37,6 +39,7 @@ hyperpar <- function(type) { FF16=FF16_hyperpar, FF16w=FF16w_hyperpar, FF16r=FF16r_hyperpar, + FF16drivers=FF16drivers_hyperpar, K93=K93_hyperpar, stop("Unknown type ", type)) } @@ -48,6 +51,7 @@ environment_type <- function(type) { FF16=sprintf("FF16_Env"), FF16w=sprintf("FF16_Env"), FF16r=sprintf("FF16_Env"), + FF16drivers=sprintf("FF16_Env"), K93=sprintf("K93_Env"), stop("Unknown type ", type)) } @@ -69,6 +73,7 @@ make_environment <- function(type = NULL, parameters = NULL, ...) { FF16=FF16_make_environment(...), FF16w=FF16w_make_environment(...), FF16r=FF16r_make_environment(...), + FF16drivers=FF16drivers_make_environment(...), K93=K93_make_environment(...), stop("Unknown type ", type)) } @@ -79,6 +84,7 @@ node_schedule_default <- function(p) { "Parameters"=`node_schedule_default__Parameters___FF16__FF16_Env`, "Parameters"=`node_schedule_default__Parameters___FF16w__FF16_Env`, "Parameters"=`node_schedule_default__Parameters___FF16r__FF16_Env`, + "Parameters"=`node_schedule_default__Parameters___FF16drivers__FF16_Env`, "Parameters"=`node_schedule_default__Parameters___K93__K93_Env`, stop("Unknown type: ", cl))(p) } @@ -89,6 +95,7 @@ make_node_schedule <- function(p) { "Parameters"=`make_node_schedule__Parameters___FF16__FF16_Env`, "Parameters"=`make_node_schedule__Parameters___FF16w__FF16_Env`, "Parameters"=`make_node_schedule__Parameters___FF16r__FF16_Env`, + "Parameters"=`make_node_schedule__Parameters___FF16drivers__FF16_Env`, "Parameters"=`make_node_schedule__Parameters___K93__K93_Env`, stop("Unknown type: ", cl))(p) } diff --git a/inst/RcppR6_classes.yml b/inst/RcppR6_classes.yml index 06522d2f3..b1a207896 100644 --- a/inst/RcppR6_classes.yml +++ b/inst/RcppR6_classes.yml @@ -26,6 +26,7 @@ OdeRunner: - ["FF16": "plant::tools::IndividualRunner"] - ["FF16w": "plant::tools::IndividualRunner"] - ["FF16r": "plant::tools::IndividualRunner"] + - ["FF16drivers": "plant::tools::IndividualRunner"] - ["K93": "plant::tools::IndividualRunner"] constructor: args: [obj: T, control: "plant::ode::OdeControl=OdeControl()"] @@ -235,6 +236,7 @@ Individual: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: [s: T] @@ -294,6 +296,7 @@ IndividualRunner: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: name_cpp: "plant::tools::IndividualRunner" @@ -350,6 +353,7 @@ Parameters: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] validator: name_cpp: validate @@ -372,6 +376,7 @@ Node: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: name_cpp: "plant::make_node" @@ -410,6 +415,7 @@ Species: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: [strategy: T] @@ -455,6 +461,7 @@ Patch: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: @@ -526,6 +533,7 @@ SCM: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: @@ -603,6 +611,7 @@ StochasticSpecies: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: [strategy: "T"] @@ -648,6 +657,7 @@ StochasticPatch: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: @@ -713,6 +723,7 @@ StochasticPatchRunner: - ["FF16": "plant::FF16_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16w": "plant::FF16w_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["FF16r": "plant::FF16r_Strategy", "FF16_Env": "plant::FF16_Environment"] + - ["FF16drivers": "plant::FF16drivers_Strategy", "FF16_Env": "plant::FF16_Environment"] - ["K93": "plant::K93_Strategy", "K93_Env": "plant::K93_Environment"] constructor: args: @@ -914,6 +925,64 @@ FF16_Environment: type: "plant::ExtrinsicDrivers" access: field +# The following strategy was built from FF16 on Fri Dec 08 14:12:34 2023 +FF16drivers_Strategy: + name_cpp: "plant::FF16drivers_Strategy" + roxygen: | + Strategy parameters that tune various aspects of the biological model. + @title Strategy parameters + @param ...,values Values to initialise the struct with (either as + variadic arguments, or as a list, but not both). + @export + list: + - lma: double + - rho: double + - hmat: double + - omega: double + - eta: double + - theta: double + - a_l1: double + - a_l2: double + - a_r1: double + - a_b1: double + - r_s: double + - r_b: double + - r_r: double + - r_l: double + - a_y: double + - a_bio: double + - k_l: double + - k_b: double + - k_s: double + - k_r: double + - a_p1: double + - a_p2: double + - a_f3: double + - a_f1: double + - a_f2: double + - S_D: double + - a_d0: double + - d_I: double + - a_dG1: double + - a_dG2: double + - k_I: double + - recruitment_decay: double + - control: "plant::Control" + - collect_all_auxiliary: bool + - birth_rate_x: std::vector + - birth_rate_y: std::vector + - is_variable_birth_rate: bool + - growth_rate_x: std::vector + - growth_rate_y: std::vector + - is_variable_growth_rate: bool + - herbivory_rate_x: std::vector + - herbivory_rate_y: std::vector + - is_variable_herbivory_rate: bool + - mortality_rate_x: std::vector + - mortality_rate_y: std::vector + - is_variable_mortality_rate: bool + - herbivory_size_threshold: double + # The following strategy was built from FF16 on Wed Aug 12 11:12:34 2020 FF16r_Strategy: name_cpp: "plant::FF16r_Strategy" diff --git a/inst/include/plant.h b/inst/include/plant.h index 591782487..b8e888bb6 100644 --- a/inst/include/plant.h +++ b/inst/include/plant.h @@ -31,6 +31,7 @@ #include #include #include +#include #include // Getting more serious down here. diff --git a/inst/include/plant/RcppR6_post.hpp b/inst/include/plant/RcppR6_post.hpp index 2b9c938e6..cd72e9c89 100644 --- a/inst/include/plant/RcppR6_post.hpp +++ b/inst/include/plant/RcppR6_post.hpp @@ -34,6 +34,10 @@ template <> inline std::string class_name_r inline std::string package_name > >() {return "plant";} template <> inline std::string generator_name > >() {return ".R6_OdeRunner___FF16r";} +template <> inline std::string class_name_r > >() {return "OdeRunner";} +template <> inline std::string package_name > >() {return "plant";} +template <> inline std::string generator_name > >() {return ".R6_OdeRunner___FF16drivers";} + template <> inline std::string class_name_r > >() {return "OdeRunner";} template <> inline std::string package_name > >() {return "plant";} template <> inline std::string generator_name > >() {return ".R6_OdeRunner___K93";} @@ -70,6 +74,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Individual___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "Individual";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_Individual___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "Individual";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Individual___K93__K93_Env";} @@ -85,6 +93,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_IndividualRunner___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "IndividualRunner";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_IndividualRunner___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "IndividualRunner";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_IndividualRunner___K93__K93_Env";} @@ -103,6 +115,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return "";} +template <> inline std::string class_name_r >() {return "Parameters";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return "";} + template <> inline std::string class_name_r >() {return "Parameters";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return "";} @@ -118,6 +134,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Node___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "Node";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_Node___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "Node";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Node___K93__K93_Env";} @@ -133,6 +153,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Species___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "Species";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_Species___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "Species";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Species___K93__K93_Env";} @@ -148,6 +172,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Patch___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "Patch";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_Patch___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "Patch";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_Patch___K93__K93_Env";} @@ -163,6 +191,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_SCM___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "SCM";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_SCM___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "SCM";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_SCM___K93__K93_Env";} @@ -178,6 +210,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticSpecies___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "StochasticSpecies";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_StochasticSpecies___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "StochasticSpecies";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticSpecies___K93__K93_Env";} @@ -193,6 +229,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticPatch___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "StochasticPatch";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_StochasticPatch___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "StochasticPatch";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticPatch___K93__K93_Env";} @@ -208,6 +248,10 @@ template <> inline std::string class_name_r inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticPatchRunner___FF16r__FF16_Env";} +template <> inline std::string class_name_r >() {return "StochasticPatchRunner";} +template <> inline std::string package_name >() {return "plant";} +template <> inline std::string generator_name >() {return ".R6_StochasticPatchRunner___FF16drivers__FF16_Env";} + template <> inline std::string class_name_r >() {return "StochasticPatchRunner";} template <> inline std::string package_name >() {return "plant";} template <> inline std::string generator_name >() {return ".R6_StochasticPatchRunner___K93__K93_Env";} @@ -229,6 +273,9 @@ template <> inline std::string generator_name() {return " template <> inline std::string class_name_r() {return "FF16_Environment";} template <> inline std::string package_name() {return "plant";} template <> inline std::string generator_name() {return ".R6_FF16_Environment";} +template <> inline std::string class_name_r() {return "FF16drivers_Strategy";} +template <> inline std::string package_name() {return "plant";} +template <> inline std::string generator_name() {return "";} template <> inline std::string class_name_r() {return "FF16r_Strategy";} template <> inline std::string package_name() {return "plant";} template <> inline std::string generator_name() {return "";} @@ -312,6 +359,13 @@ template <> inline plant::ode::Runner > >(x)); } +template <> inline SEXP wrap(const plant::ode::Runner >& x) { + return wrap(plant::RcppR6::RcppR6 > >(x)); +} +template <> inline plant::ode::Runner > as(SEXP x) { + return *(plant::RcppR6::RcppR6 > >(x)); +} + template <> inline SEXP wrap(const plant::ode::Runner >& x) { return wrap(plant::RcppR6::RcppR6 > >(x)); } @@ -512,6 +566,13 @@ template <> inline plant::Individual >(x)); } +template <> inline SEXP wrap(const plant::Individual& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::Individual as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::Individual& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -539,6 +600,13 @@ template <> inline plant::tools::IndividualRunner >(x)); } +template <> inline SEXP wrap(const plant::tools::IndividualRunner& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::tools::IndividualRunner as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::tools::IndividualRunner& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -686,6 +754,51 @@ template <> inline plant::Parameters inline SEXP wrap(const plant::Parameters& x) { + Rcpp::List ret; + ret["patch_area"] = Rcpp::wrap(x.patch_area); + ret["n_patches"] = Rcpp::wrap(x.n_patches); + ret["patch_type"] = Rcpp::wrap(x.patch_type); + ret["max_patch_lifetime"] = Rcpp::wrap(x.max_patch_lifetime); + ret["strategies"] = Rcpp::wrap(x.strategies); + ret["strategy_default"] = Rcpp::wrap(x.strategy_default); + ret["node_schedule_times_default"] = Rcpp::wrap(x.node_schedule_times_default); + ret["node_schedule_times"] = Rcpp::wrap(x.node_schedule_times); + ret["node_schedule_ode_times"] = Rcpp::wrap(x.node_schedule_ode_times); + ret.attr("class") = Rcpp::CharacterVector::create("Parameters", "Parameters"); + return ret; +} +template <> inline plant::Parameters as(SEXP x) { + if (!plant::RcppR6::is >(x)) { + Rcpp::stop("Expected an object of type Parameters"); + // NOTE: Won't drop through or return anything. + } + // NOTE: assumes default constructable, and will assign *every* + // field twice. No current support for a hook. + plant::Parameters ret; + Rcpp::List xl(x); + // ret.patch_area = Rcpp::as(xl["patch_area"]); + ret.patch_area = Rcpp::as(xl["patch_area"]); + // ret.n_patches = Rcpp::as(xl["n_patches"]); + ret.n_patches = Rcpp::as(xl["n_patches"]); + // ret.patch_type = Rcpp::as(xl["patch_type"]); + ret.patch_type = Rcpp::as(xl["patch_type"]); + // ret.max_patch_lifetime = Rcpp::as(xl["max_patch_lifetime"]); + ret.max_patch_lifetime = Rcpp::as(xl["max_patch_lifetime"]); + // ret.strategies = Rcpp::as(xl["strategies"]); + ret.strategies = Rcpp::as >(xl["strategies"]); + // ret.strategy_default = Rcpp::as(xl["strategy_default"]); + ret.strategy_default = Rcpp::as(xl["strategy_default"]); + // ret.node_schedule_times_default = Rcpp::as(xl["node_schedule_times_default"]); + ret.node_schedule_times_default = Rcpp::as >(xl["node_schedule_times_default"]); + // ret.node_schedule_times = Rcpp::as(xl["node_schedule_times"]); + ret.node_schedule_times = Rcpp::as > >(xl["node_schedule_times"]); + // ret.node_schedule_ode_times = Rcpp::as(xl["node_schedule_ode_times"]); + ret.node_schedule_ode_times = Rcpp::as >(xl["node_schedule_ode_times"]); + ret.validate(); + return ret; +} + template <> inline SEXP wrap(const plant::Parameters& x) { Rcpp::List ret; ret["patch_area"] = Rcpp::wrap(x.patch_area); @@ -751,6 +864,13 @@ template <> inline plant::Node as return *(plant::RcppR6::RcppR6 >(x)); } +template <> inline SEXP wrap(const plant::Node& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::Node as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::Node& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -778,6 +898,13 @@ template <> inline plant::Species return *(plant::RcppR6::RcppR6 >(x)); } +template <> inline SEXP wrap(const plant::Species& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::Species as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::Species& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -805,6 +932,13 @@ template <> inline plant::Patch a return *(plant::RcppR6::RcppR6 >(x)); } +template <> inline SEXP wrap(const plant::Patch& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::Patch as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::Patch& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -832,6 +966,13 @@ template <> inline plant::SCM as( return *(plant::RcppR6::RcppR6 >(x)); } +template <> inline SEXP wrap(const plant::SCM& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::SCM as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::SCM& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -859,6 +1000,13 @@ template <> inline plant::StochasticSpecies >(x)); } +template <> inline SEXP wrap(const plant::StochasticSpecies& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::StochasticSpecies as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::StochasticSpecies& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -886,6 +1034,13 @@ template <> inline plant::StochasticPatch >(x)); } +template <> inline SEXP wrap(const plant::StochasticPatch& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::StochasticPatch as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::StochasticPatch& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -913,6 +1068,13 @@ template <> inline plant::StochasticPatchRunner >(x)); } +template <> inline SEXP wrap(const plant::StochasticPatchRunner& x) { + return wrap(plant::RcppR6::RcppR6 >(x)); +} +template <> inline plant::StochasticPatchRunner as(SEXP x) { + return *(plant::RcppR6::RcppR6 >(x)); +} + template <> inline SEXP wrap(const plant::StochasticPatchRunner& x) { return wrap(plant::RcppR6::RcppR6 >(x)); } @@ -1076,6 +1238,163 @@ template <> inline SEXP wrap(const plant::FF16_Environment& x) { template <> inline plant::FF16_Environment as(SEXP x) { return *(plant::RcppR6::RcppR6(x)); } +template <> inline SEXP wrap(const plant::FF16drivers_Strategy& x) { + Rcpp::List ret; + ret["lma"] = Rcpp::wrap(x.lma); + ret["rho"] = Rcpp::wrap(x.rho); + ret["hmat"] = Rcpp::wrap(x.hmat); + ret["omega"] = Rcpp::wrap(x.omega); + ret["eta"] = Rcpp::wrap(x.eta); + ret["theta"] = Rcpp::wrap(x.theta); + ret["a_l1"] = Rcpp::wrap(x.a_l1); + ret["a_l2"] = Rcpp::wrap(x.a_l2); + ret["a_r1"] = Rcpp::wrap(x.a_r1); + ret["a_b1"] = Rcpp::wrap(x.a_b1); + ret["r_s"] = Rcpp::wrap(x.r_s); + ret["r_b"] = Rcpp::wrap(x.r_b); + ret["r_r"] = Rcpp::wrap(x.r_r); + ret["r_l"] = Rcpp::wrap(x.r_l); + ret["a_y"] = Rcpp::wrap(x.a_y); + ret["a_bio"] = Rcpp::wrap(x.a_bio); + ret["k_l"] = Rcpp::wrap(x.k_l); + ret["k_b"] = Rcpp::wrap(x.k_b); + ret["k_s"] = Rcpp::wrap(x.k_s); + ret["k_r"] = Rcpp::wrap(x.k_r); + ret["a_p1"] = Rcpp::wrap(x.a_p1); + ret["a_p2"] = Rcpp::wrap(x.a_p2); + ret["a_f3"] = Rcpp::wrap(x.a_f3); + ret["a_f1"] = Rcpp::wrap(x.a_f1); + ret["a_f2"] = Rcpp::wrap(x.a_f2); + ret["S_D"] = Rcpp::wrap(x.S_D); + ret["a_d0"] = Rcpp::wrap(x.a_d0); + ret["d_I"] = Rcpp::wrap(x.d_I); + ret["a_dG1"] = Rcpp::wrap(x.a_dG1); + ret["a_dG2"] = Rcpp::wrap(x.a_dG2); + ret["k_I"] = Rcpp::wrap(x.k_I); + ret["recruitment_decay"] = Rcpp::wrap(x.recruitment_decay); + ret["control"] = Rcpp::wrap(x.control); + ret["collect_all_auxiliary"] = Rcpp::wrap(x.collect_all_auxiliary); + ret["birth_rate_x"] = Rcpp::wrap(x.birth_rate_x); + ret["birth_rate_y"] = Rcpp::wrap(x.birth_rate_y); + ret["is_variable_birth_rate"] = Rcpp::wrap(x.is_variable_birth_rate); + ret["growth_rate_x"] = Rcpp::wrap(x.growth_rate_x); + ret["growth_rate_y"] = Rcpp::wrap(x.growth_rate_y); + ret["is_variable_growth_rate"] = Rcpp::wrap(x.is_variable_growth_rate); + ret["herbivory_rate_x"] = Rcpp::wrap(x.herbivory_rate_x); + ret["herbivory_rate_y"] = Rcpp::wrap(x.herbivory_rate_y); + ret["is_variable_herbivory_rate"] = Rcpp::wrap(x.is_variable_herbivory_rate); + ret["mortality_rate_x"] = Rcpp::wrap(x.mortality_rate_x); + ret["mortality_rate_y"] = Rcpp::wrap(x.mortality_rate_y); + ret["is_variable_mortality_rate"] = Rcpp::wrap(x.is_variable_mortality_rate); + ret["herbivory_size_threshold"] = Rcpp::wrap(x.herbivory_size_threshold); + ret.attr("class") = "FF16drivers_Strategy"; + return ret; +} +template <> inline plant::FF16drivers_Strategy as(SEXP x) { + if (!plant::RcppR6::is(x)) { + Rcpp::stop("Expected an object of type FF16drivers_Strategy"); + // NOTE: Won't drop through or return anything. + } + // NOTE: assumes default constructable, and will assign *every* + // field twice. No current support for a hook. + plant::FF16drivers_Strategy ret; + Rcpp::List xl(x); + // ret.lma = Rcpp::as(xl["lma"]); + ret.lma = Rcpp::as(xl["lma"]); + // ret.rho = Rcpp::as(xl["rho"]); + ret.rho = Rcpp::as(xl["rho"]); + // ret.hmat = Rcpp::as(xl["hmat"]); + ret.hmat = Rcpp::as(xl["hmat"]); + // ret.omega = Rcpp::as(xl["omega"]); + ret.omega = Rcpp::as(xl["omega"]); + // ret.eta = Rcpp::as(xl["eta"]); + ret.eta = Rcpp::as(xl["eta"]); + // ret.theta = Rcpp::as(xl["theta"]); + ret.theta = Rcpp::as(xl["theta"]); + // ret.a_l1 = Rcpp::as(xl["a_l1"]); + ret.a_l1 = Rcpp::as(xl["a_l1"]); + // ret.a_l2 = Rcpp::as(xl["a_l2"]); + ret.a_l2 = Rcpp::as(xl["a_l2"]); + // ret.a_r1 = Rcpp::as(xl["a_r1"]); + ret.a_r1 = Rcpp::as(xl["a_r1"]); + // ret.a_b1 = Rcpp::as(xl["a_b1"]); + ret.a_b1 = Rcpp::as(xl["a_b1"]); + // ret.r_s = Rcpp::as(xl["r_s"]); + ret.r_s = Rcpp::as(xl["r_s"]); + // ret.r_b = Rcpp::as(xl["r_b"]); + ret.r_b = Rcpp::as(xl["r_b"]); + // ret.r_r = Rcpp::as(xl["r_r"]); + ret.r_r = Rcpp::as(xl["r_r"]); + // ret.r_l = Rcpp::as(xl["r_l"]); + ret.r_l = Rcpp::as(xl["r_l"]); + // ret.a_y = Rcpp::as(xl["a_y"]); + ret.a_y = Rcpp::as(xl["a_y"]); + // ret.a_bio = Rcpp::as(xl["a_bio"]); + ret.a_bio = Rcpp::as(xl["a_bio"]); + // ret.k_l = Rcpp::as(xl["k_l"]); + ret.k_l = Rcpp::as(xl["k_l"]); + // ret.k_b = Rcpp::as(xl["k_b"]); + ret.k_b = Rcpp::as(xl["k_b"]); + // ret.k_s = Rcpp::as(xl["k_s"]); + ret.k_s = Rcpp::as(xl["k_s"]); + // ret.k_r = Rcpp::as(xl["k_r"]); + ret.k_r = Rcpp::as(xl["k_r"]); + // ret.a_p1 = Rcpp::as(xl["a_p1"]); + ret.a_p1 = Rcpp::as(xl["a_p1"]); + // ret.a_p2 = Rcpp::as(xl["a_p2"]); + ret.a_p2 = Rcpp::as(xl["a_p2"]); + // ret.a_f3 = Rcpp::as(xl["a_f3"]); + ret.a_f3 = Rcpp::as(xl["a_f3"]); + // ret.a_f1 = Rcpp::as(xl["a_f1"]); + ret.a_f1 = Rcpp::as(xl["a_f1"]); + // ret.a_f2 = Rcpp::as(xl["a_f2"]); + ret.a_f2 = Rcpp::as(xl["a_f2"]); + // ret.S_D = Rcpp::as(xl["S_D"]); + ret.S_D = Rcpp::as(xl["S_D"]); + // ret.a_d0 = Rcpp::as(xl["a_d0"]); + ret.a_d0 = Rcpp::as(xl["a_d0"]); + // ret.d_I = Rcpp::as(xl["d_I"]); + ret.d_I = Rcpp::as(xl["d_I"]); + // ret.a_dG1 = Rcpp::as(xl["a_dG1"]); + ret.a_dG1 = Rcpp::as(xl["a_dG1"]); + // ret.a_dG2 = Rcpp::as(xl["a_dG2"]); + ret.a_dG2 = Rcpp::as(xl["a_dG2"]); + // ret.k_I = Rcpp::as(xl["k_I"]); + ret.k_I = Rcpp::as(xl["k_I"]); + // ret.recruitment_decay = Rcpp::as(xl["recruitment_decay"]); + ret.recruitment_decay = Rcpp::as(xl["recruitment_decay"]); + // ret.control = Rcpp::as(xl["control"]); + ret.control = Rcpp::as(xl["control"]); + // ret.collect_all_auxiliary = Rcpp::as(xl["collect_all_auxiliary"]); + ret.collect_all_auxiliary = Rcpp::as(xl["collect_all_auxiliary"]); + // ret.birth_rate_x = Rcpp::as(xl["birth_rate_x"]); + ret.birth_rate_x = Rcpp::as >(xl["birth_rate_x"]); + // ret.birth_rate_y = Rcpp::as(xl["birth_rate_y"]); + ret.birth_rate_y = Rcpp::as >(xl["birth_rate_y"]); + // ret.is_variable_birth_rate = Rcpp::as(xl["is_variable_birth_rate"]); + ret.is_variable_birth_rate = Rcpp::as(xl["is_variable_birth_rate"]); + // ret.growth_rate_x = Rcpp::as(xl["growth_rate_x"]); + ret.growth_rate_x = Rcpp::as >(xl["growth_rate_x"]); + // ret.growth_rate_y = Rcpp::as(xl["growth_rate_y"]); + ret.growth_rate_y = Rcpp::as >(xl["growth_rate_y"]); + // ret.is_variable_growth_rate = Rcpp::as(xl["is_variable_growth_rate"]); + ret.is_variable_growth_rate = Rcpp::as(xl["is_variable_growth_rate"]); + // ret.herbivory_rate_x = Rcpp::as(xl["herbivory_rate_x"]); + ret.herbivory_rate_x = Rcpp::as >(xl["herbivory_rate_x"]); + // ret.herbivory_rate_y = Rcpp::as(xl["herbivory_rate_y"]); + ret.herbivory_rate_y = Rcpp::as >(xl["herbivory_rate_y"]); + // ret.is_variable_herbivory_rate = Rcpp::as(xl["is_variable_herbivory_rate"]); + ret.is_variable_herbivory_rate = Rcpp::as(xl["is_variable_herbivory_rate"]); + // ret.mortality_rate_x = Rcpp::as(xl["mortality_rate_x"]); + ret.mortality_rate_x = Rcpp::as >(xl["mortality_rate_x"]); + // ret.mortality_rate_y = Rcpp::as(xl["mortality_rate_y"]); + ret.mortality_rate_y = Rcpp::as >(xl["mortality_rate_y"]); + // ret.is_variable_mortality_rate = Rcpp::as(xl["is_variable_mortality_rate"]); + ret.is_variable_mortality_rate = Rcpp::as(xl["is_variable_mortality_rate"]); + // ret.herbivory_size_threshold = Rcpp::as(xl["herbivory_size_threshold"]); + ret.herbivory_size_threshold = Rcpp::as(xl["herbivory_size_threshold"]); + return ret; +} template <> inline SEXP wrap(const plant::FF16r_Strategy& x) { Rcpp::List ret; ret["lma"] = Rcpp::wrap(x.lma); diff --git a/inst/include/plant/RcppR6_pre.hpp b/inst/include/plant/RcppR6_pre.hpp index 3b3f71132..017c4930a 100644 --- a/inst/include/plant/RcppR6_pre.hpp +++ b/inst/include/plant/RcppR6_pre.hpp @@ -38,6 +38,9 @@ template <> plant::ode::Runner SEXP wrap(const plant::ode::Runner >&); template <> plant::ode::Runner > as(SEXP); +template <> SEXP wrap(const plant::ode::Runner >&); +template <> plant::ode::Runner > as(SEXP); + template <> SEXP wrap(const plant::ode::Runner >&); template <> plant::ode::Runner > as(SEXP); template <> SEXP wrap(const plant::NodeScheduleEvent&); @@ -63,6 +66,9 @@ template <> plant::Individual as( template <> SEXP wrap(const plant::Individual&); template <> plant::Individual as(SEXP); +template <> SEXP wrap(const plant::Individual&); +template <> plant::Individual as(SEXP); + template <> SEXP wrap(const plant::Individual&); template <> plant::Individual as(SEXP); template <> SEXP wrap(const plant::tools::IndividualRunner&); @@ -74,6 +80,9 @@ template <> plant::tools::IndividualRunner SEXP wrap(const plant::tools::IndividualRunner&); template <> plant::tools::IndividualRunner as(SEXP); +template <> SEXP wrap(const plant::tools::IndividualRunner&); +template <> plant::tools::IndividualRunner as(SEXP); + template <> SEXP wrap(const plant::tools::IndividualRunner&); template <> plant::tools::IndividualRunner as(SEXP); template <> SEXP wrap(const plant::Internals&); @@ -87,6 +96,9 @@ template <> plant::Parameters as( template <> SEXP wrap(const plant::Parameters&); template <> plant::Parameters as(SEXP); +template <> SEXP wrap(const plant::Parameters&); +template <> plant::Parameters as(SEXP); + template <> SEXP wrap(const plant::Parameters&); template <> plant::Parameters as(SEXP); template <> SEXP wrap(const plant::Node&); @@ -98,6 +110,9 @@ template <> plant::Node as(SEXP); template <> SEXP wrap(const plant::Node&); template <> plant::Node as(SEXP); +template <> SEXP wrap(const plant::Node&); +template <> plant::Node as(SEXP); + template <> SEXP wrap(const plant::Node&); template <> plant::Node as(SEXP); template <> SEXP wrap(const plant::Species&); @@ -109,6 +124,9 @@ template <> plant::Species as(SEX template <> SEXP wrap(const plant::Species&); template <> plant::Species as(SEXP); +template <> SEXP wrap(const plant::Species&); +template <> plant::Species as(SEXP); + template <> SEXP wrap(const plant::Species&); template <> plant::Species as(SEXP); template <> SEXP wrap(const plant::Patch&); @@ -120,6 +138,9 @@ template <> plant::Patch as(SEXP) template <> SEXP wrap(const plant::Patch&); template <> plant::Patch as(SEXP); +template <> SEXP wrap(const plant::Patch&); +template <> plant::Patch as(SEXP); + template <> SEXP wrap(const plant::Patch&); template <> plant::Patch as(SEXP); template <> SEXP wrap(const plant::SCM&); @@ -131,6 +152,9 @@ template <> plant::SCM as(SEXP); template <> SEXP wrap(const plant::SCM&); template <> plant::SCM as(SEXP); +template <> SEXP wrap(const plant::SCM&); +template <> plant::SCM as(SEXP); + template <> SEXP wrap(const plant::SCM&); template <> plant::SCM as(SEXP); template <> SEXP wrap(const plant::StochasticSpecies&); @@ -142,6 +166,9 @@ template <> plant::StochasticSpecies SEXP wrap(const plant::StochasticSpecies&); template <> plant::StochasticSpecies as(SEXP); +template <> SEXP wrap(const plant::StochasticSpecies&); +template <> plant::StochasticSpecies as(SEXP); + template <> SEXP wrap(const plant::StochasticSpecies&); template <> plant::StochasticSpecies as(SEXP); template <> SEXP wrap(const plant::StochasticPatch&); @@ -153,6 +180,9 @@ template <> plant::StochasticPatch SEXP wrap(const plant::StochasticPatch&); template <> plant::StochasticPatch as(SEXP); +template <> SEXP wrap(const plant::StochasticPatch&); +template <> plant::StochasticPatch as(SEXP); + template <> SEXP wrap(const plant::StochasticPatch&); template <> plant::StochasticPatch as(SEXP); template <> SEXP wrap(const plant::StochasticPatchRunner&); @@ -164,6 +194,9 @@ template <> plant::StochasticPatchRunner SEXP wrap(const plant::StochasticPatchRunner&); template <> plant::StochasticPatchRunner as(SEXP); +template <> SEXP wrap(const plant::StochasticPatchRunner&); +template <> plant::StochasticPatchRunner as(SEXP); + template <> SEXP wrap(const plant::StochasticPatchRunner&); template <> plant::StochasticPatchRunner as(SEXP); template <> SEXP wrap(const plant::Canopy&); @@ -178,6 +211,8 @@ template <> SEXP wrap(const plant::FF16_Strategy&); template <> plant::FF16_Strategy as(SEXP); template <> SEXP wrap(const plant::FF16_Environment&); template <> plant::FF16_Environment as(SEXP); +template <> SEXP wrap(const plant::FF16drivers_Strategy&); +template <> plant::FF16drivers_Strategy as(SEXP); template <> SEXP wrap(const plant::FF16r_Strategy&); template <> plant::FF16r_Strategy as(SEXP); template <> SEXP wrap(const plant::K93_Strategy&); diff --git a/inst/include/plant/individual.h b/inst/include/plant/individual.h index 7946841d3..6f2078d9c 100644 --- a/inst/include/plant/individual.h +++ b/inst/include/plant/individual.h @@ -79,7 +79,7 @@ template class Individual { double net_mass_production_dt(const environment_type &environment) { // TODO: maybe reuse intervals? default false - return strategy->net_mass_production_dt(environment, state(HEIGHT_INDEX), aux("competition_effect")); + return strategy->net_mass_production_dt(environment, state(HEIGHT_INDEX), aux("competition_effect"), environment.time); } // * ODE interface diff --git a/inst/include/plant/models/ff16_strategy.h b/inst/include/plant/models/ff16_strategy.h index 238e11e79..d2296ce23 100644 --- a/inst/include/plant/models/ff16_strategy.h +++ b/inst/include/plant/models/ff16_strategy.h @@ -89,8 +89,8 @@ class FF16_Strategy: public Strategy { double mass_sapwood, double mass_root) const; - void compute_rates(const FF16_Environment& environment, bool reuse_intervals, - Internals& vars); + virtual void compute_rates(const FF16_Environment& environment, bool reuse_intervals, + Internals& vars); void update_dependent_aux(const int index, Internals& vars); diff --git a/inst/include/plant/models/ff16drivers_strategy.h b/inst/include/plant/models/ff16drivers_strategy.h new file mode 100644 index 000000000..0ea56be77 --- /dev/null +++ b/inst/include/plant/models/ff16drivers_strategy.h @@ -0,0 +1,56 @@ +// -*-c++-*- +#ifndef PLANT_PLANT_FF16DRIVERS_STRATEGY_H_ +#define PLANT_PLANT_FF16DRIVERS_STRATEGY_H_ + +#include +#include +#include + +namespace plant { + +class FF16drivers_Strategy: public FF16_Strategy { +public: + typedef std::shared_ptr ptr; + FF16drivers_Strategy(); + + // add external drivers + std::vector growth_rate_x; + std::vector growth_rate_y = {1.0}; + bool is_variable_growth_rate = false; + + std::vector herbivory_rate_x; + std::vector herbivory_rate_y = {1.0}; + bool is_variable_herbivory_rate = false; + + std::vector mortality_rate_x; + std::vector mortality_rate_y = {1.0}; + bool is_variable_mortality_rate = false; + + // add size threshold + double herbivory_size_threshold = 1.2; + + // Overloads ---------------------------------------------- + virtual void compute_rates(const FF16_Environment& environment, bool reuse_intervals, + Internals& vars); + + virtual double net_mass_production_dt(const FF16_Environment& environment, + double height, double area_leaf_, double time, + bool reuse_intervals=false, double threshold=0.0); + + + virtual double turnover(double mass_leaf, double mass_bark, double mass_sapwood, double mass_root, double time, double height, double threshold=0.0) const; + virtual double turnover_leaf(double mass, double time, double height, double threshold) const; + + virtual double mortality_dt(double productivity_area, double cumulative_mortality, double time, double height, double threshold) const; + virtual double mortality_growth_independent_dt(double time, double height, double threshold) const; + + virtual double establishment_probability(const FF16_Environment& environment); + + void prepare_strategy(); +}; + +FF16drivers_Strategy::ptr make_strategy_ptr(FF16drivers_Strategy s); + +} + +#endif diff --git a/inst/include/plant/strategy.h b/inst/include/plant/strategy.h index ff9015981..3c06d87e1 100644 --- a/inst/include/plant/strategy.h +++ b/inst/include/plant/strategy.h @@ -57,6 +57,7 @@ class Strategy { double net_mass_production_dt(const environment_type& environment, double size, double competition_effect_, + double time, bool reuse_intervals=false); double establishment_probability(const environment_type& environment); diff --git a/inst/reports/FF16_report.Rmd b/inst/reports/FF16_report.Rmd index f7d107d2b..c0f6e6e6b 100644 --- a/inst/reports/FF16_report.Rmd +++ b/inst/reports/FF16_report.Rmd @@ -122,7 +122,13 @@ The following parameters were included in the model. Note, values for species ar p <- results$p extract_strategy <- function(strat) { - ex <- c("control" , "collect_all_auxiliary", "birth_rate_x", "birth_rate_y", "is_variable_birth_rate") + ex <- c("control" , "collect_all_auxiliary", "birth_rate_x", "birth_rate_y", + "is_variable_birth_rate", + "growth_rate_x", "growth_rate_y", + "is_variable_growth_rate", + "mortality_rate_x", "mortality_rate_y", + "is_variable_mortality_rate" + ) x <- strat[!(names(strat) %in% ex)] diff --git a/scripts/drivers.r b/scripts/drivers.r new file mode 100644 index 000000000..4cc9f56ac --- /dev/null +++ b/scripts/drivers.r @@ -0,0 +1,125 @@ +library(tidyverse) +devtools::load_all(".") + + + +## growth +sp = expand_parameters(trait_matrix(c(0.0825), "lma"), + scm_base_parameters("FF16drivers")) + +time_pts <- seq(0, 150) + +sp$strategies[[1]]$growth_rate_x = time_pts +sp$strategies[[1]]$growth_rate_y = 1 + sin(time_pts) +sp$strategies[[1]]$is_variable_growth_rate = T + +sp_smooth <- build_schedule(sp) + +result <- run_scm_collect(sp) %>% + tidy_patch() %>% + purrr::pluck("species") %>% + tidyr::drop_na() + +ggplot(result, aes(x = time, y = height, group = node, alpha = density)) + + geom_line() + + labs( + x = "Time (yrs)", + y = "Height (m)", + alpha = "Density (individuals.m^-2)", + subtitle = "Time-varying growth: 1 + sin(t)" + ) + + scale_alpha(na.value = 0) + + theme_classic(base_size = 16) + + theme(aspect.ratio = 0.7) + + + +## herbivory - leaf turnover +sp = expand_parameters(trait_matrix(c(0.0825), "lma"), + scm_base_parameters("FF16drivers")) + +time_pts <- seq(0, 150) + +sp$strategies[[1]]$herbivory_rate_x = time_pts +sp$strategies[[1]]$herbivory_rate_y = rep(2, 151) +sp$strategies[[1]]$is_variable_herbivory_rate = T +sp$strategies[[1]]$herbivory_size_threshold = 1.2 + +#sp_smooth <- build_schedule(sp) + +result <- run_scm_collect(sp) %>% + tidy_patch() %>% + purrr::pluck("species") %>% + tidyr::drop_na() + +ggplot(result, aes(x = time, y = height, group = node, alpha = density)) + + geom_line() + + labs( + x = "Time (yrs)", + y = "Height (m)", + alpha = "Density (individuals.m^-2)", + subtitle = "Double leaf turnover for cohorts < 1.2m" + ) + + scale_alpha(na.value = 0) + + theme_classic(base_size = 16) + + theme(aspect.ratio = 0.7) + + +## mortality +# strategy defaults +mulga <- function() { + p0 <- plant::scm_base_parameters("FF16drivers", "FF16_Env") + + p0$strategy_default$lma <- 0.0645 + p0$strategy_default$hmat <- 5 + p0$strategy_default$rho <- 1100 + p0$strategy_default$narea <- 0.0032 + p0$strategy_default$a_l1 <- 2.17 + p0$strategy_default$a_l2 <- 0.5 + p0$strategy_default$omega <- 0.00000926 + p0 +} + +sp = expand_parameters(trait_matrix(c(0.0645), "lma"), mulga()) + +time_pts <- seq(0, 150) + +sp$strategies[[1]]$mortality_rate_x = time_pts +sp$strategies[[1]]$mortality_rate_y = c(rep(100, 60), rep(1, 91)) +sp$strategies[[1]]$is_variable_mortality_rate = T +sp$strategies[[1]]$herbivory_size_threshold = 1.2 + +#sp_smooth <- build_schedule(sp) + +result <- run_scm_collect(sp) %>% + tidy_patch() %>% + purrr::pluck("species") %>% + tidyr::drop_na() + +times_in <- function(df, times) { + df %>% + filter(floor(time) %in% times) +} + +result %>% + times_in(., c(10, 20, 40, 50, 80, 100)) %>% + ggplot(., aes(x = height, y = log_density)) + + geom_line() + + facet_wrap(~ floor(time)) + + theme(aspect.ratio = 1) + + +ggplot(result, aes(x = time, y = height, group = node, alpha = density, colour = density)) + + geom_line(linewidth = 1) + + labs( + x = "Time (yrs)", + y = "Height (m)", + colour = "Density (individuals.m^-2)", + alpha = "Density (individuals.m^-2)", + subtitle = "Time-varying mortality affecting < 1.2 m trees: " + ) + + scale_alpha(na.value = 0) + + scale_colour_viridis_c() + + theme_classic(base_size = 16) + + theme(aspect.ratio = 0.7) + diff --git a/scripts/time_varying_drivers.R b/scripts/time_varying_drivers.R new file mode 100644 index 000000000..1bc72e692 --- /dev/null +++ b/scripts/time_varying_drivers.R @@ -0,0 +1,73 @@ +library(tidyverse) +devtools::load_all(".") + +# base parameters +p0 <- scm_base_parameters("FF16drivers") + +## Define sin function to vary through time from 0-amplitude +f_sin <- function(time_yrs, period_yrs = 1.0, amplitude = 1.0) { + amplitude * (1 + sin(2 * pi * time_yrs / period_yrs)) / 2.0 +} + +## Add species +sp <- expand_parameters(trait_matrix(c(0.0825), "lma"), p0) + +# Varying growth rate +## Create time-varying driver +time_pts <- seq(0, 150, length.out=1000) +## Multiplier on assimilation, varying between g_min and 1.0 of it's potential value +g_min <- 0.7 + +sp$strategies[[1]]$growth_rate_x <- time_pts +sp$strategies[[1]]$growth_rate_y = g_min + (1-g_min) * f_sin(time_pts, period_yrs = 10) +sp$strategies[[1]]$is_variable_growth_rate <- TRUE + +## Check, plot through time +plot(sp$strategies[[1]]$growth_rate_x, sp$strategies[[1]]$growth_rate_y, type = "l") + +## Force high resolution run, by adding more node introduction times to the default. This saves running Build_schedule + +n_extra_nodes <- 500 +sp$node_schedule_times[[1]] <- + c(p0$node_schedule_times_default, seq(0, p0$max_patch_lifetime, length.out = n_extra_nodes)) %>% sort() %>% unique() + +## Run the stand +system.time({sp_smooth <- run_scm_collect(sp)}) + +## Process results +result <- + sp_smooth %>% + tidy_patch() %>% + purrr::pluck("species") %>% + tidyr::drop_na() + +plot_size_distribution(result) + + labs(title = "Growth 0.7 to 1") + +ggsave(filename = "growth 0.75-1.png") + +FF16_generate_stand_report(sp_smooth, overwrite = TRUE) + + +# Varying mortality - as above but with mortality rate +sp = expand_parameters(trait_matrix(c(0.0825), "lma"), + scm_base_parameters("FF16drivers")) + +## Multiplier on assimilation, varying between m_min and 1.0 of it's potential value +time_pts <- seq(0, 150, length.out = 1000) +m_min <- 0.7 + +sp$strategies[[1]]$mortality_rate_x <- time_pts +sp$strategies[[1]]$mortality_rate_y <- m_min + (1 - m_min) * f_sin(time_pts, period_yrs = 10) +sp$strategies[[1]]$is_variable_mortality_rate <- TRUE + +system.time({sp_smooth <- run_scm_collect(sp)}) + +result <- sp_smooth %>% + tidy_patch() %>% + purrr::pluck("species") %>% + tidyr::drop_na() + +plot_size_distribution(result) + + labs(title = "Mortality 0.7 to 1") + diff --git a/src/RcppExports.cpp b/src/RcppExports.cpp index 9d9155d66..fe3567113 100644 --- a/src/RcppExports.cpp +++ b/src/RcppExports.cpp @@ -707,6 +707,127 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// OdeRunner___FF16drivers__ctor +plant::ode::Runner > OdeRunner___FF16drivers__ctor(plant::tools::IndividualRunner obj, plant::ode::OdeControl control); +RcppExport SEXP _plant_OdeRunner___FF16drivers__ctor(SEXP objSEXP, SEXP controlSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::tools::IndividualRunner >::type obj(objSEXP); + Rcpp::traits::input_parameter< plant::ode::OdeControl >::type control(controlSEXP); + rcpp_result_gen = Rcpp::wrap(OdeRunner___FF16drivers__ctor(obj, control)); + return rcpp_result_gen; +END_RCPP +} +// OdeRunner___FF16drivers__advance +void OdeRunner___FF16drivers__advance(plant::RcppR6::RcppR6 > > obj_, double time); +RcppExport SEXP _plant_OdeRunner___FF16drivers__advance(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + OdeRunner___FF16drivers__advance(obj_, time); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__advance_fixed +void OdeRunner___FF16drivers__advance_fixed(plant::RcppR6::RcppR6 > > obj_, std::vector time); +RcppExport SEXP _plant_OdeRunner___FF16drivers__advance_fixed(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector >::type time(timeSEXP); + OdeRunner___FF16drivers__advance_fixed(obj_, time); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__step +void OdeRunner___FF16drivers__step(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__step(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + OdeRunner___FF16drivers__step(obj_); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__step_to +void OdeRunner___FF16drivers__step_to(plant::RcppR6::RcppR6 > > obj_, double time); +RcppExport SEXP _plant_OdeRunner___FF16drivers__step_to(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + OdeRunner___FF16drivers__step_to(obj_, time); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__set_state +void OdeRunner___FF16drivers__set_state(plant::RcppR6::RcppR6 > > obj_, plant::ode::state_type y, double time); +RcppExport SEXP _plant_OdeRunner___FF16drivers__set_state(SEXP obj_SEXP, SEXP ySEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type y(ySEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + OdeRunner___FF16drivers__set_state(obj_, y, time); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__set_state_from_system +void OdeRunner___FF16drivers__set_state_from_system(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__set_state_from_system(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + OdeRunner___FF16drivers__set_state_from_system(obj_); + return R_NilValue; +END_RCPP +} +// OdeRunner___FF16drivers__time__get +double OdeRunner___FF16drivers__time__get(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(OdeRunner___FF16drivers__time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// OdeRunner___FF16drivers__state__get +plant::ode::state_type OdeRunner___FF16drivers__state__get(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(OdeRunner___FF16drivers__state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// OdeRunner___FF16drivers__times__get +std::vector OdeRunner___FF16drivers__times__get(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__times__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(OdeRunner___FF16drivers__times__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// OdeRunner___FF16drivers__object__get +plant::tools::IndividualRunner OdeRunner___FF16drivers__object__get(plant::RcppR6::RcppR6 > > obj_); +RcppExport SEXP _plant_OdeRunner___FF16drivers__object__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(OdeRunner___FF16drivers__object__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // OdeRunner___K93__ctor plant::ode::Runner > OdeRunner___K93__ctor(plant::tools::IndividualRunner obj, plant::ode::OdeControl control); RcppExport SEXP _plant_OdeRunner___K93__ctor(SEXP objSEXP, SEXP controlSEXP) { @@ -2219,6 +2340,254 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// Individual___FF16drivers__FF16_Env__ctor +plant::Individual Individual___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy s); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ctor(SEXP sSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::FF16drivers_Strategy >::type s(sSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__ctor(s)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__state +double Individual___FF16drivers__FF16_Env__state(plant::RcppR6::RcppR6 > obj_, std::string name); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__state(SEXP obj_SEXP, SEXP nameSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::string >::type name(nameSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__state(obj_, name)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__rate +double Individual___FF16drivers__FF16_Env__rate(plant::RcppR6::RcppR6 > obj_, std::string name); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__rate(SEXP obj_SEXP, SEXP nameSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::string >::type name(nameSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__rate(obj_, name)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__aux +double Individual___FF16drivers__FF16_Env__aux(plant::RcppR6::RcppR6 > obj_, std::string name); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__aux(SEXP obj_SEXP, SEXP nameSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::string >::type name(nameSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__aux(obj_, name)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__set_state +void Individual___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, std::string name, double v); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__set_state(SEXP obj_SEXP, SEXP nameSEXP, SEXP vSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::string >::type name(nameSEXP); + Rcpp::traits::input_parameter< double >::type v(vSEXP); + Individual___FF16drivers__FF16_Env__set_state(obj_, name, v); + return R_NilValue; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__compute_competition +double Individual___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double h); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP hSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type h(hSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__compute_competition(obj_, h)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__compute_rates +void Individual___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Individual___FF16drivers__FF16_Env__compute_rates(obj_, environment); + return R_NilValue; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__establishment_probability +double Individual___FF16drivers__FF16_Env__establishment_probability(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__establishment_probability(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__establishment_probability(obj_, environment)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__net_mass_production_dt +double Individual___FF16drivers__FF16_Env__net_mass_production_dt(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__net_mass_production_dt(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__net_mass_production_dt(obj_, environment)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__reset_mortality +void Individual___FF16drivers__FF16_Env__reset_mortality(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__reset_mortality(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Individual___FF16drivers__FF16_Env__reset_mortality(obj_); + return R_NilValue; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__resource_compensation_point +double Individual___FF16drivers__FF16_Env__resource_compensation_point(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__resource_compensation_point(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__resource_compensation_point(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__strategy__get +plant::FF16drivers_Strategy Individual___FF16drivers__FF16_Env__strategy__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__strategy__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__strategy__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__internals__get +plant::Internals Individual___FF16drivers__FF16_Env__internals__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__internals__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__internals__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__aux_size__get +size_t Individual___FF16drivers__FF16_Env__aux_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__aux_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__aux_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__ode_size__get +size_t Individual___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__ode_names__get +std::vector Individual___FF16drivers__FF16_Env__ode_names__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ode_names__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__ode_names__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__aux_names__get +std::vector Individual___FF16drivers__FF16_Env__aux_names__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__aux_names__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__aux_names__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type Individual___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__ode_state__set +void Individual___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type value(valueSEXP); + Individual___FF16drivers__FF16_Env__ode_state__set(obj_, value); + return R_NilValue; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type Individual___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__mortality_probability__get +double Individual___FF16drivers__FF16_Env__mortality_probability__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__mortality_probability__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__mortality_probability__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Individual___FF16drivers__FF16_Env__strategy_name__get +std::string Individual___FF16drivers__FF16_Env__strategy_name__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Individual___FF16drivers__FF16_Env__strategy_name__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Individual___FF16drivers__FF16_Env__strategy_name__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // Individual___K93__K93_Env__ctor plant::Individual Individual___K93__K93_Env__ctor(plant::K93_Strategy s); RcppExport SEXP _plant_Individual___K93__K93_Env__ctor(SEXP sSEXP) { @@ -2569,6 +2938,40 @@ BEGIN_RCPP return R_NilValue; END_RCPP } +// IndividualRunner___FF16drivers__FF16_Env__ctor +plant::tools::IndividualRunner IndividualRunner___FF16drivers__FF16_Env__ctor(plant::Individual individual, plant::FF16_Environment environment); +RcppExport SEXP _plant_IndividualRunner___FF16drivers__FF16_Env__ctor(SEXP individualSEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::Individual >::type individual(individualSEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(IndividualRunner___FF16drivers__FF16_Env__ctor(individual, environment)); + return rcpp_result_gen; +END_RCPP +} +// IndividualRunner___FF16drivers__FF16_Env__individual__get +plant::Individual IndividualRunner___FF16drivers__FF16_Env__individual__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_IndividualRunner___FF16drivers__FF16_Env__individual__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(IndividualRunner___FF16drivers__FF16_Env__individual__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// IndividualRunner___FF16drivers__FF16_Env__individual__set +void IndividualRunner___FF16drivers__FF16_Env__individual__set(plant::RcppR6::RcppR6 > obj_, plant::Individual value); +RcppExport SEXP _plant_IndividualRunner___FF16drivers__FF16_Env__individual__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::Individual >::type value(valueSEXP); + IndividualRunner___FF16drivers__FF16_Env__individual__set(obj_, value); + return R_NilValue; +END_RCPP +} // IndividualRunner___K93__K93_Env__ctor plant::tools::IndividualRunner IndividualRunner___K93__K93_Env__ctor(plant::Individual individual, plant::K93_Environment environment); RcppExport SEXP _plant_IndividualRunner___K93__K93_Env__ctor(SEXP individualSEXP, SEXP environmentSEXP) { @@ -2872,6 +3275,27 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// Parameters___FF16drivers__FF16_Env__ctor +SEXP Parameters___FF16drivers__FF16_Env__ctor(); +RcppExport SEXP _plant_Parameters___FF16drivers__FF16_Env__ctor() { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + rcpp_result_gen = Rcpp::wrap(Parameters___FF16drivers__FF16_Env__ctor()); + return rcpp_result_gen; +END_RCPP +} +// Parameters___FF16drivers__FF16_Env__vdor +SEXP Parameters___FF16drivers__FF16_Env__vdor(SEXP obj); +RcppExport SEXP _plant_Parameters___FF16drivers__FF16_Env__vdor(SEXP objSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< SEXP >::type obj(objSEXP); + rcpp_result_gen = Rcpp::wrap(Parameters___FF16drivers__FF16_Env__vdor(obj)); + return rcpp_result_gen; +END_RCPP +} // Parameters___K93__K93_Env__ctor SEXP Parameters___K93__K93_Env__ctor(); RcppExport SEXP _plant_Parameters___K93__K93_Env__ctor() { @@ -3403,47 +3827,217 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } -// Node___K93__K93_Env__ctor -plant::Node Node___K93__K93_Env__ctor(plant::K93_Strategy strategy); -RcppExport SEXP _plant_Node___K93__K93_Env__ctor(SEXP strategySEXP) { +// Node___FF16drivers__FF16_Env__ctor +plant::Node Node___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ctor(SEXP strategySEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::K93_Strategy >::type strategy(strategySEXP); - rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__ctor(strategy)); + Rcpp::traits::input_parameter< plant::FF16drivers_Strategy >::type strategy(strategySEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__ctor(strategy)); return rcpp_result_gen; END_RCPP } -// Node___K93__K93_Env__compute_competition -double Node___K93__K93_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); -RcppExport SEXP _plant_Node___K93__K93_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +// Node___FF16drivers__FF16_Env__compute_competition +double Node___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); Rcpp::traits::input_parameter< double >::type height(heightSEXP); - rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__compute_competition(obj_, height)); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__compute_competition(obj_, height)); return rcpp_result_gen; END_RCPP } -// Node___K93__K93_Env__growth_rate_gradient -double Node___K93__K93_Env__growth_rate_gradient(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment); -RcppExport SEXP _plant_Node___K93__K93_Env__growth_rate_gradient(SEXP obj_SEXP, SEXP environmentSEXP) { +// Node___FF16drivers__FF16_Env__growth_rate_gradient +double Node___FF16drivers__FF16_Env__growth_rate_gradient(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__growth_rate_gradient(SEXP obj_SEXP, SEXP environmentSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - Rcpp::traits::input_parameter< plant::K93_Environment >::type environment(environmentSEXP); - rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__growth_rate_gradient(obj_, environment)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__growth_rate_gradient(obj_, environment)); return rcpp_result_gen; END_RCPP } -// Node___K93__K93_Env__compute_rates -void Node___K93__K93_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment, double pr_patch_survival); -RcppExport SEXP _plant_Node___K93__K93_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP, SEXP pr_patch_survivalSEXP) { +// Node___FF16drivers__FF16_Env__compute_rates +void Node___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP, SEXP pr_patch_survivalSEXP) { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< double >::type pr_patch_survival(pr_patch_survivalSEXP); + Node___FF16drivers__FF16_Env__compute_rates(obj_, environment, pr_patch_survival); + return R_NilValue; +END_RCPP +} +// Node___FF16drivers__FF16_Env__compute_initial_conditions +void Node___FF16drivers__FF16_Env__compute_initial_conditions(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival, double birth_rate); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__compute_initial_conditions(SEXP obj_SEXP, SEXP environmentSEXP, SEXP pr_patch_survivalSEXP, SEXP birth_rateSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< double >::type pr_patch_survival(pr_patch_survivalSEXP); + Rcpp::traits::input_parameter< double >::type birth_rate(birth_rateSEXP); + Node___FF16drivers__FF16_Env__compute_initial_conditions(obj_, environment, pr_patch_survival, birth_rate); + return R_NilValue; +END_RCPP +} +// Node___FF16drivers__FF16_Env__individual__get +plant::Individual Node___FF16drivers__FF16_Env__individual__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__individual__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__individual__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__height__get +double Node___FF16drivers__FF16_Env__height__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__height__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__height__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__log_density__get +double Node___FF16drivers__FF16_Env__log_density__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__log_density__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__log_density__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__competition_effect__get +double Node___FF16drivers__FF16_Env__competition_effect__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__competition_effect__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__competition_effect__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__fecundity__get +double Node___FF16drivers__FF16_Env__fecundity__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__fecundity__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__fecundity__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__ode_size__get +size_t Node___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type Node___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__ode_state__set +void Node___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type value(valueSEXP); + Node___FF16drivers__FF16_Env__ode_state__set(obj_, value); + return R_NilValue; +END_RCPP +} +// Node___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type Node___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___FF16drivers__FF16_Env__ode_names__get +std::vector Node___FF16drivers__FF16_Env__ode_names__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Node___FF16drivers__FF16_Env__ode_names__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Node___FF16drivers__FF16_Env__ode_names__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Node___K93__K93_Env__ctor +plant::Node Node___K93__K93_Env__ctor(plant::K93_Strategy strategy); +RcppExport SEXP _plant_Node___K93__K93_Env__ctor(SEXP strategySEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::K93_Strategy >::type strategy(strategySEXP); + rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__ctor(strategy)); + return rcpp_result_gen; +END_RCPP +} +// Node___K93__K93_Env__compute_competition +double Node___K93__K93_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_Node___K93__K93_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type height(heightSEXP); + rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__compute_competition(obj_, height)); + return rcpp_result_gen; +END_RCPP +} +// Node___K93__K93_Env__growth_rate_gradient +double Node___K93__K93_Env__growth_rate_gradient(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment); +RcppExport SEXP _plant_Node___K93__K93_Env__growth_rate_gradient(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::K93_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(Node___K93__K93_Env__growth_rate_gradient(obj_, environment)); + return rcpp_result_gen; +END_RCPP +} +// Node___K93__K93_Env__compute_rates +void Node___K93__K93_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment, double pr_patch_survival); +RcppExport SEXP _plant_Node___K93__K93_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP, SEXP pr_patch_survivalSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); Rcpp::traits::input_parameter< plant::K93_Environment >::type environment(environmentSEXP); Rcpp::traits::input_parameter< double >::type pr_patch_survival(pr_patch_survivalSEXP); Node___K93__K93_Env__compute_rates(obj_, environment, pr_patch_survival); @@ -4275,6 +4869,240 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// Species___FF16drivers__FF16_Env__ctor +plant::Species Species___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__ctor(SEXP strategySEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::FF16drivers_Strategy >::type strategy(strategySEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__ctor(strategy)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__clear +void Species___FF16drivers__FF16_Env__clear(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__clear(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Species___FF16drivers__FF16_Env__clear(obj_); + return R_NilValue; +END_RCPP +} +// Species___FF16drivers__FF16_Env__compute_rates +void Species___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival, double birth_rate); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP, SEXP pr_patch_survivalSEXP, SEXP birth_rateSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< double >::type pr_patch_survival(pr_patch_survivalSEXP); + Rcpp::traits::input_parameter< double >::type birth_rate(birth_rateSEXP); + Species___FF16drivers__FF16_Env__compute_rates(obj_, environment, pr_patch_survival, birth_rate); + return R_NilValue; +END_RCPP +} +// Species___FF16drivers__FF16_Env__compute_competition +double Species___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type height(heightSEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__compute_competition(obj_, height)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__introduce_new_node +void Species___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__introduce_new_node(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Species___FF16drivers__FF16_Env__introduce_new_node(obj_); + return R_NilValue; +END_RCPP +} +// Species___FF16drivers__FF16_Env__node_at +plant::Node Species___FF16drivers__FF16_Env__node_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__node_at(SEXP obj_SEXP, SEXP indexSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type index(indexSEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__node_at(obj_, index)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__competition_effects_error +std::vector Species___FF16drivers__FF16_Env__competition_effects_error(plant::RcppR6::RcppR6 > obj_, double scal); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__competition_effects_error(SEXP obj_SEXP, SEXP scalSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type scal(scalSEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__competition_effects_error(obj_, scal)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__size__get +size_t Species___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__new_node__get +plant::Node Species___FF16drivers__FF16_Env__new_node__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__new_node__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__new_node__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__height_max__get +double Species___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__height_max__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__height_max__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__heights__get +std::vector Species___FF16drivers__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__heights__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__heights__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__heights__set +void Species___FF16drivers__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__heights__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector >::type value(valueSEXP); + Species___FF16drivers__FF16_Env__heights__set(obj_, value); + return R_NilValue; +END_RCPP +} +// Species___FF16drivers__FF16_Env__log_densities__get +std::vector Species___FF16drivers__FF16_Env__log_densities__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__log_densities__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__log_densities__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__nodes__get +std::vector > Species___FF16drivers__FF16_Env__nodes__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__nodes__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__nodes__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get +std::vector Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__competition_effects__get +std::vector Species___FF16drivers__FF16_Env__competition_effects__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__competition_effects__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__competition_effects__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__extrinsic_drivers__get +plant::ExtrinsicDrivers Species___FF16drivers__FF16_Env__extrinsic_drivers__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__extrinsic_drivers__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__extrinsic_drivers__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__ode_size__get +size_t Species___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type Species___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Species___FF16drivers__FF16_Env__ode_state__set +void Species___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type value(valueSEXP); + Species___FF16drivers__FF16_Env__ode_state__set(obj_, value); + return R_NilValue; +END_RCPP +} +// Species___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type Species___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Species___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Species___FF16drivers__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // Species___K93__K93_Env__ctor plant::Species Species___K93__K93_Env__ctor(plant::K93_Strategy strategy); RcppExport SEXP _plant_Species___K93__K93_Env__ctor(SEXP strategySEXP) { @@ -5430,31 +6258,338 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } -// Patch___K93__K93_Env__ctor -plant::Patch Patch___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control); -RcppExport SEXP _plant_Patch___K93__K93_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { +// Patch___FF16drivers__FF16_Env__ctor +plant::Patch Patch___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); - Rcpp::traits::input_parameter< plant::K93_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); Rcpp::traits::input_parameter< plant::Control >::type control(controlSEXP); - rcpp_result_gen = Rcpp::wrap(Patch___K93__K93_Env__ctor(parameters, environment, control)); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ctor(parameters, environment, control)); return rcpp_result_gen; END_RCPP } -// Patch___K93__K93_Env__introduce_new_node -void Patch___K93__K93_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); -RcppExport SEXP _plant_Patch___K93__K93_Env__introduce_new_node(SEXP obj_SEXP, SEXP species_indexSEXP) { +// Patch___FF16drivers__FF16_Env__introduce_new_node +void Patch___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__introduce_new_node(SEXP obj_SEXP, SEXP species_indexSEXP) { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); - Patch___K93__K93_Env__introduce_new_node(obj_, species_index); + Patch___FF16drivers__FF16_Env__introduce_new_node(obj_, species_index); return R_NilValue; END_RCPP } -// Patch___K93__K93_Env__compute_environment +// Patch___FF16drivers__FF16_Env__compute_environment +void Patch___FF16drivers__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__compute_environment(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Patch___FF16drivers__FF16_Env__compute_environment(obj_); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__compute_rates +void Patch___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Patch___FF16drivers__FF16_Env__compute_rates(obj_); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__reset +void Patch___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__reset(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Patch___FF16drivers__FF16_Env__reset(obj_); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__set_ode_state +void Patch___FF16drivers__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__set_ode_state(SEXP obj_SEXP, SEXP valuesSEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type values(valuesSEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + Patch___FF16drivers__FF16_Env__set_ode_state(obj_, values, time); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__derivs +plant::ode::state_type Patch___FF16drivers__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__derivs(SEXP obj_SEXP, SEXP ySEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< const plant::ode::state_type& >::type y(ySEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__derivs(obj_, y, time)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__set_time +void Patch___FF16drivers__FF16_Env__set_time(plant::RcppR6::RcppR6 > obj_, double time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__set_time(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + Patch___FF16drivers__FF16_Env__set_time(obj_, time); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__set_state +void Patch___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n, const std::vector& env); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__set_state(SEXP obj_SEXP, SEXP timeSEXP, SEXP stateSEXP, SEXP nSEXP, SEXP envSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + Rcpp::traits::input_parameter< const std::vector& >::type state(stateSEXP); + Rcpp::traits::input_parameter< const std::vector& >::type n(nSEXP); + Rcpp::traits::input_parameter< const std::vector& >::type env(envSEXP); + Patch___FF16drivers__FF16_Env__set_state(obj_, time, state, n, env); + return R_NilValue; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__density +std::vector Patch___FF16drivers__FF16_Env__density(plant::RcppR6::RcppR6 > obj_, std::vector time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__density(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector >::type time(timeSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__density(obj_, time)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__pr_survival +double Patch___FF16drivers__FF16_Env__pr_survival(plant::RcppR6::RcppR6 > obj_, double time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__pr_survival(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__pr_survival(obj_, time)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__disturbance_mean_interval +double Patch___FF16drivers__FF16_Env__disturbance_mean_interval(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__disturbance_mean_interval(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__disturbance_mean_interval(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__survival_weighting_cdf +double Patch___FF16drivers__FF16_Env__survival_weighting_cdf(plant::RcppR6::RcppR6 > obj_, double time); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__survival_weighting_cdf(SEXP obj_SEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__survival_weighting_cdf(obj_, time)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__survival_weighting_icdf +double Patch___FF16drivers__FF16_Env__survival_weighting_icdf(plant::RcppR6::RcppR6 > obj_, double prob); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__survival_weighting_icdf(SEXP obj_SEXP, SEXP probSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type prob(probSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__survival_weighting_icdf(obj_, prob)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__compute_competition +double Patch___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type height(heightSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__compute_competition(obj_, height)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__time__get +double Patch___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__size__get +size_t Patch___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__height_max__get +double Patch___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__height_max__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__height_max__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__parameters__get +plant::Parameters Patch___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__parameters__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__parameters__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__environment__get +plant::FF16_Environment Patch___FF16drivers__FF16_Env__environment__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__environment__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__environment__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__species__get +std::vector > Patch___FF16drivers__FF16_Env__species__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__species__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__species__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__ode_size__get +size_t Patch___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__ode_time__get +double Patch___FF16drivers__FF16_Env__ode_time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ode_time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ode_time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__ode_aux__get +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_aux__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__ode_aux__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__ode_aux__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___FF16drivers__FF16_Env__node_ode_size__get +size_t Patch___FF16drivers__FF16_Env__node_ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_Patch___FF16drivers__FF16_Env__node_ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(Patch___FF16drivers__FF16_Env__node_ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// Patch___K93__K93_Env__ctor +plant::Patch Patch___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control); +RcppExport SEXP _plant_Patch___K93__K93_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); + Rcpp::traits::input_parameter< plant::K93_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< plant::Control >::type control(controlSEXP); + rcpp_result_gen = Rcpp::wrap(Patch___K93__K93_Env__ctor(parameters, environment, control)); + return rcpp_result_gen; +END_RCPP +} +// Patch___K93__K93_Env__introduce_new_node +void Patch___K93__K93_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_Patch___K93__K93_Env__introduce_new_node(SEXP obj_SEXP, SEXP species_indexSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); + Patch___K93__K93_Env__introduce_new_node(obj_, species_index); + return R_NilValue; +END_RCPP +} +// Patch___K93__K93_Env__compute_environment void Patch___K93__K93_Env__compute_environment(plant::RcppR6::RcppR6 > obj_); RcppExport SEXP _plant_Patch___K93__K93_Env__compute_environment(SEXP obj_SEXP) { BEGIN_RCPP @@ -6469,6 +7604,250 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// SCM___FF16drivers__FF16_Env__ctor +plant::SCM SCM___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< plant::Control >::type control(controlSEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__ctor(parameters, environment, control)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__run +void SCM___FF16drivers__FF16_Env__run(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__run(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + SCM___FF16drivers__FF16_Env__run(obj_); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__run_mutant +void SCM___FF16drivers__FF16_Env__run_mutant(plant::RcppR6::RcppR6 > obj_, plant::Parameters p); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__run_mutant(SEXP obj_SEXP, SEXP pSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::Parameters >::type p(pSEXP); + SCM___FF16drivers__FF16_Env__run_mutant(obj_, p); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__run_next +std::vector SCM___FF16drivers__FF16_Env__run_next(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__run_next(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__run_next(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__reset +void SCM___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__reset(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + SCM___FF16drivers__FF16_Env__reset(obj_); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species +double SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species(SEXP obj_SEXP, SEXP species_indexSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species(obj_, species_index)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__competition_effect_error +std::vector SCM___FF16drivers__FF16_Env__competition_effect_error(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__competition_effect_error(SEXP obj_SEXP, SEXP species_indexSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__competition_effect_error(obj_, species_index)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__set_node_schedule_times +void SCM___FF16drivers__FF16_Env__set_node_schedule_times(plant::RcppR6::RcppR6 > obj_, std::vector> times); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__set_node_schedule_times(SEXP obj_SEXP, SEXP timesSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector> >::type times(timesSEXP); + SCM___FF16drivers__FF16_Env__set_node_schedule_times(obj_, times); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__complete__get +bool SCM___FF16drivers__FF16_Env__complete__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__complete__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__complete__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__time__get +double SCM___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get +std::vector SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__offspring_production__get +std::vector SCM___FF16drivers__FF16_Env__offspring_production__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__offspring_production__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__offspring_production__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__parameters__get +plant::Parameters SCM___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__parameters__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__parameters__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__patch__get +plant::Patch SCM___FF16drivers__FF16_Env__patch__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__patch__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__patch__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__node_schedule__get +plant::NodeSchedule SCM___FF16drivers__FF16_Env__node_schedule__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__node_schedule__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__node_schedule__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__node_schedule__set +void SCM___FF16drivers__FF16_Env__node_schedule__set(plant::RcppR6::RcppR6 > obj_, plant::NodeSchedule value); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__node_schedule__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::NodeSchedule >::type value(valueSEXP); + SCM___FF16drivers__FF16_Env__node_schedule__set(obj_, value); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__ode_times__get +std::vector SCM___FF16drivers__FF16_Env__ode_times__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__ode_times__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__ode_times__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__state__get +Rcpp::List SCM___FF16drivers__FF16_Env__state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__aux__get +Rcpp::List SCM___FF16drivers__FF16_Env__aux__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__aux__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__aux__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__use_ode_times__get +bool SCM___FF16drivers__FF16_Env__use_ode_times__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__use_ode_times__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__use_ode_times__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__use_ode_times__set +void SCM___FF16drivers__FF16_Env__use_ode_times__set(plant::RcppR6::RcppR6 > obj_, bool value); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__use_ode_times__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< bool >::type value(valueSEXP); + SCM___FF16drivers__FF16_Env__use_ode_times__set(obj_, value); + return R_NilValue; +END_RCPP +} +// SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get +std::vector> SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // SCM___K93__K93_Env__ctor plant::SCM SCM___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control); RcppExport SEXP _plant_SCM___K93__K93_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { @@ -7310,102 +8689,334 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__heights__get -std::vector StochasticSpecies___FF16r__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__heights__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16r__FF16_Env__heights__get +std::vector StochasticSpecies___FF16r__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__heights__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__heights__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__heights__set +void StochasticSpecies___FF16r__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__heights__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector >::type value(valueSEXP); + StochasticSpecies___FF16r__FF16_Env__heights__set(obj_, value); + return R_NilValue; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__individuals__get +std::vector > StochasticSpecies___FF16r__FF16_Env__individuals__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__individuals__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__individuals__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__is_alive__get +std::vector StochasticSpecies___FF16r__FF16_Env__is_alive__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__is_alive__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__is_alive__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get +std::vector StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__ode_size__get +size_t StochasticSpecies___FF16r__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__ode_state__get +plant::ode::state_type StochasticSpecies___FF16r__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__ode_state__set +void StochasticSpecies___FF16r__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type value(valueSEXP); + StochasticSpecies___FF16r__FF16_Env__ode_state__set(obj_, value); + return R_NilValue; +END_RCPP +} +// StochasticSpecies___FF16r__FF16_Env__ode_rates__get +plant::ode::state_type StochasticSpecies___FF16r__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__ctor +plant::StochasticSpecies StochasticSpecies___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__ctor(SEXP strategySEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::FF16drivers_Strategy >::type strategy(strategySEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__ctor(strategy)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__clear +void StochasticSpecies___FF16drivers__FF16_Env__clear(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__clear(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticSpecies___FF16drivers__FF16_Env__clear(obj_); + return R_NilValue; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__compute_rates +void StochasticSpecies___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + StochasticSpecies___FF16drivers__FF16_Env__compute_rates(obj_, environment); + return R_NilValue; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__compute_competition +double StochasticSpecies___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type height(heightSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__compute_competition(obj_, height)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node +void StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node(obj_); + return R_NilValue; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__individual_at +plant::Individual StochasticSpecies___FF16drivers__FF16_Env__individual_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__individual_at(SEXP obj_SEXP, SEXP indexSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type index(indexSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__individual_at(obj_, index)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__deaths +size_t StochasticSpecies___FF16drivers__FF16_Env__deaths(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__deaths(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__deaths(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__establishment_probability +double StochasticSpecies___FF16drivers__FF16_Env__establishment_probability(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__establishment_probability(SEXP obj_SEXP, SEXP environmentSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__establishment_probability(obj_, environment)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__size__get +size_t StochasticSpecies___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get +size_t StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__new_node__get +plant::Individual StochasticSpecies___FF16drivers__FF16_Env__new_node__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__new_node__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__new_node__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__height_max__get +double StochasticSpecies___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__height_max__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__height_max__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticSpecies___FF16drivers__FF16_Env__heights__get +std::vector StochasticSpecies___FF16drivers__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__heights__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__heights__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__heights__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__heights__set -void StochasticSpecies___FF16r__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__heights__set(SEXP obj_SEXP, SEXP valueSEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__heights__set +void StochasticSpecies___FF16drivers__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__heights__set(SEXP obj_SEXP, SEXP valueSEXP) { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); Rcpp::traits::input_parameter< std::vector >::type value(valueSEXP); - StochasticSpecies___FF16r__FF16_Env__heights__set(obj_, value); + StochasticSpecies___FF16drivers__FF16_Env__heights__set(obj_, value); return R_NilValue; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__individuals__get -std::vector > StochasticSpecies___FF16r__FF16_Env__individuals__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__individuals__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__individuals__get +std::vector > StochasticSpecies___FF16drivers__FF16_Env__individuals__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__individuals__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__individuals__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__individuals__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__is_alive__get -std::vector StochasticSpecies___FF16r__FF16_Env__is_alive__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__is_alive__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__is_alive__get +std::vector StochasticSpecies___FF16drivers__FF16_Env__is_alive__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__is_alive__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__is_alive__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__is_alive__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get -std::vector StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get +std::vector StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__net_reproduction_ratio_by_node__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__ode_size__get -size_t StochasticSpecies___FF16r__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_size__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__ode_size__get +size_t StochasticSpecies___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_size__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__ode_size__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__ode_state__get -plant::ode::state_type StochasticSpecies___FF16r__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_state__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type StochasticSpecies___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_state__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__ode_state__get(obj_)); return rcpp_result_gen; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__ode_state__set -void StochasticSpecies___FF16r__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__ode_state__set +void StochasticSpecies___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__set(SEXP obj_SEXP, SEXP valueSEXP) { BEGIN_RCPP Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); Rcpp::traits::input_parameter< plant::ode::state_type >::type value(valueSEXP); - StochasticSpecies___FF16r__FF16_Env__ode_state__set(obj_, value); + StochasticSpecies___FF16drivers__FF16_Env__ode_state__set(obj_, value); return R_NilValue; END_RCPP } -// StochasticSpecies___FF16r__FF16_Env__ode_rates__get -plant::ode::state_type StochasticSpecies___FF16r__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); -RcppExport SEXP _plant_StochasticSpecies___FF16r__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +// StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { BEGIN_RCPP Rcpp::RObject rcpp_result_gen; Rcpp::RNGScope rcpp_rngScope_gen; - Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); - rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16r__FF16_Env__ode_rates__get(obj_)); + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get(obj_)); return rcpp_result_gen; END_RCPP } @@ -8352,6 +9963,243 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// StochasticPatch___FF16drivers__FF16_Env__ctor +plant::StochasticPatch StochasticPatch___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< plant::Control >::type control(controlSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__ctor(parameters, environment, control)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__compute_competition +double StochasticPatch___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__compute_competition(SEXP obj_SEXP, SEXP heightSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type height(heightSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__compute_competition(obj_, height)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__introduce_new_node +bool StochasticPatch___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node(SEXP obj_SEXP, SEXP species_indexSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__introduce_new_node(obj_, species_index)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update +void StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update(SEXP obj_SEXP, SEXP species_indexSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::util::index >::type species_index(species_indexSEXP); + StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update(obj_, species_index); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__compute_environment +void StochasticPatch___FF16drivers__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__compute_environment(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticPatch___FF16drivers__FF16_Env__compute_environment(obj_); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__compute_rates +void StochasticPatch___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__compute_rates(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticPatch___FF16drivers__FF16_Env__compute_rates(obj_); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__reset +void StochasticPatch___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__reset(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticPatch___FF16drivers__FF16_Env__reset(obj_); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__set_ode_state +void StochasticPatch___FF16drivers__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__set_ode_state(SEXP obj_SEXP, SEXP valuesSEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::ode::state_type >::type values(valuesSEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + StochasticPatch___FF16drivers__FF16_Env__set_ode_state(obj_, values, time); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__derivs +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__derivs(SEXP obj_SEXP, SEXP ySEXP, SEXP timeSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< const plant::ode::state_type& >::type y(ySEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__derivs(obj_, y, time)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__set_state +void StochasticPatch___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__set_state(SEXP obj_SEXP, SEXP timeSEXP, SEXP stateSEXP, SEXP nSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< double >::type time(timeSEXP); + Rcpp::traits::input_parameter< const std::vector& >::type state(stateSEXP); + Rcpp::traits::input_parameter< const std::vector& >::type n(nSEXP); + StochasticPatch___FF16drivers__FF16_Env__set_state(obj_, time, state, n); + return R_NilValue; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__deaths +std::vector StochasticPatch___FF16drivers__FF16_Env__deaths(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__deaths(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__deaths(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__time__get +double StochasticPatch___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__size__get +size_t StochasticPatch___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__height_max__get +double StochasticPatch___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__height_max__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__height_max__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__parameters__get +plant::Parameters StochasticPatch___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__parameters__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__parameters__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__environment__get +plant::FF16_Environment StochasticPatch___FF16drivers__FF16_Env__environment__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__environment__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__environment__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__species__get +std::vector > StochasticPatch___FF16drivers__FF16_Env__species__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__species__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__species__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__ode_size__get +size_t StochasticPatch___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__ode_size__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__ode_size__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__ode_time__get +double StochasticPatch___FF16drivers__FF16_Env__ode_time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__ode_time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__ode_time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__ode_state__get +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__ode_state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__ode_state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatch___FF16drivers__FF16_Env__ode_rates__get +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatch___FF16drivers__FF16_Env__ode_rates__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatch___FF16drivers__FF16_Env__ode_rates__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // StochasticPatch___K93__K93_Env__ctor plant::StochasticPatch StochasticPatch___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control); RcppExport SEXP _plant_StochasticPatch___K93__K93_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { @@ -8985,6 +10833,138 @@ BEGIN_RCPP return rcpp_result_gen; END_RCPP } +// StochasticPatchRunner___FF16drivers__FF16_Env__ctor +plant::StochasticPatchRunner StochasticPatchRunner___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::Parameters >::type parameters(parametersSEXP); + Rcpp::traits::input_parameter< plant::FF16_Environment >::type environment(environmentSEXP); + Rcpp::traits::input_parameter< plant::Control >::type control(controlSEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__ctor(parameters, environment, control)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__run +void StochasticPatchRunner___FF16drivers__FF16_Env__run(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__run(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticPatchRunner___FF16drivers__FF16_Env__run(obj_); + return R_NilValue; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__run_next +plant::util::index StochasticPatchRunner___FF16drivers__FF16_Env__run_next(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__run_next(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__run_next(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__reset +void StochasticPatchRunner___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__reset(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + StochasticPatchRunner___FF16drivers__FF16_Env__reset(obj_); + return R_NilValue; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times +void StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times(plant::RcppR6::RcppR6 > obj_, std::vector > times); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times(SEXP obj_SEXP, SEXP timesSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< std::vector > >::type times(timesSEXP); + StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times(obj_, times); + return R_NilValue; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__complete__get +bool StochasticPatchRunner___FF16drivers__FF16_Env__complete__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__complete__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__complete__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__time__get +double StochasticPatchRunner___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__time__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__time__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get +plant::Parameters StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__patch__get +plant::StochasticPatch StochasticPatchRunner___FF16drivers__FF16_Env__patch__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__patch__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__patch__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get +plant::NodeSchedule StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get(obj_)); + return rcpp_result_gen; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set +void StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set(plant::RcppR6::RcppR6 > obj_, plant::NodeSchedule value); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set(SEXP obj_SEXP, SEXP valueSEXP) { +BEGIN_RCPP + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + Rcpp::traits::input_parameter< plant::NodeSchedule >::type value(valueSEXP); + StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set(obj_, value); + return R_NilValue; +END_RCPP +} +// StochasticPatchRunner___FF16drivers__FF16_Env__state__get +Rcpp::List StochasticPatchRunner___FF16drivers__FF16_Env__state__get(plant::RcppR6::RcppR6 > obj_); +RcppExport SEXP _plant_StochasticPatchRunner___FF16drivers__FF16_Env__state__get(SEXP obj_SEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + Rcpp::traits::input_parameter< plant::RcppR6::RcppR6 > >::type obj_(obj_SEXP); + rcpp_result_gen = Rcpp::wrap(StochasticPatchRunner___FF16drivers__FF16_Env__state__get(obj_)); + return rcpp_result_gen; +END_RCPP +} // StochasticPatchRunner___K93__K93_Env__ctor plant::StochasticPatchRunner StochasticPatchRunner___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control); RcppExport SEXP _plant_StochasticPatchRunner___K93__K93_Env__ctor(SEXP parametersSEXP, SEXP environmentSEXP, SEXP controlSEXP) { @@ -9489,6 +11469,16 @@ BEGIN_RCPP return R_NilValue; END_RCPP } +// FF16drivers_Strategy__ctor +SEXP FF16drivers_Strategy__ctor(); +RcppExport SEXP _plant_FF16drivers_Strategy__ctor() { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::RNGScope rcpp_rngScope_gen; + rcpp_result_gen = Rcpp::wrap(FF16drivers_Strategy__ctor()); + return rcpp_result_gen; +END_RCPP +} // FF16r_Strategy__ctor SEXP FF16r_Strategy__ctor(); RcppExport SEXP _plant_FF16r_Strategy__ctor() { @@ -10013,6 +12003,17 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_OdeRunner___FF16r__state__get", (DL_FUNC) &_plant_OdeRunner___FF16r__state__get, 1}, {"_plant_OdeRunner___FF16r__times__get", (DL_FUNC) &_plant_OdeRunner___FF16r__times__get, 1}, {"_plant_OdeRunner___FF16r__object__get", (DL_FUNC) &_plant_OdeRunner___FF16r__object__get, 1}, + {"_plant_OdeRunner___FF16drivers__ctor", (DL_FUNC) &_plant_OdeRunner___FF16drivers__ctor, 2}, + {"_plant_OdeRunner___FF16drivers__advance", (DL_FUNC) &_plant_OdeRunner___FF16drivers__advance, 2}, + {"_plant_OdeRunner___FF16drivers__advance_fixed", (DL_FUNC) &_plant_OdeRunner___FF16drivers__advance_fixed, 2}, + {"_plant_OdeRunner___FF16drivers__step", (DL_FUNC) &_plant_OdeRunner___FF16drivers__step, 1}, + {"_plant_OdeRunner___FF16drivers__step_to", (DL_FUNC) &_plant_OdeRunner___FF16drivers__step_to, 2}, + {"_plant_OdeRunner___FF16drivers__set_state", (DL_FUNC) &_plant_OdeRunner___FF16drivers__set_state, 3}, + {"_plant_OdeRunner___FF16drivers__set_state_from_system", (DL_FUNC) &_plant_OdeRunner___FF16drivers__set_state_from_system, 1}, + {"_plant_OdeRunner___FF16drivers__time__get", (DL_FUNC) &_plant_OdeRunner___FF16drivers__time__get, 1}, + {"_plant_OdeRunner___FF16drivers__state__get", (DL_FUNC) &_plant_OdeRunner___FF16drivers__state__get, 1}, + {"_plant_OdeRunner___FF16drivers__times__get", (DL_FUNC) &_plant_OdeRunner___FF16drivers__times__get, 1}, + {"_plant_OdeRunner___FF16drivers__object__get", (DL_FUNC) &_plant_OdeRunner___FF16drivers__object__get, 1}, {"_plant_OdeRunner___K93__ctor", (DL_FUNC) &_plant_OdeRunner___K93__ctor, 2}, {"_plant_OdeRunner___K93__advance", (DL_FUNC) &_plant_OdeRunner___K93__advance, 2}, {"_plant_OdeRunner___K93__advance_fixed", (DL_FUNC) &_plant_OdeRunner___K93__advance_fixed, 2}, @@ -10147,6 +12148,28 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_Individual___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Individual___FF16r__FF16_Env__ode_rates__get, 1}, {"_plant_Individual___FF16r__FF16_Env__mortality_probability__get", (DL_FUNC) &_plant_Individual___FF16r__FF16_Env__mortality_probability__get, 1}, {"_plant_Individual___FF16r__FF16_Env__strategy_name__get", (DL_FUNC) &_plant_Individual___FF16r__FF16_Env__strategy_name__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ctor, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__state", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__state, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__rate", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__rate, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__aux", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__aux, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__set_state", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__set_state, 3}, + {"_plant_Individual___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__compute_rates, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__establishment_probability", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__establishment_probability, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__net_mass_production_dt", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__net_mass_production_dt, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__reset_mortality", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__reset_mortality, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__resource_compensation_point", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__resource_compensation_point, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__strategy__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__strategy__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__internals__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__internals__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__aux_size__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__aux_size__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__ode_names__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ode_names__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__aux_names__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__aux_names__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__ode_state__set", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ode_state__set, 2}, + {"_plant_Individual___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__ode_rates__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__mortality_probability__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__mortality_probability__get, 1}, + {"_plant_Individual___FF16drivers__FF16_Env__strategy_name__get", (DL_FUNC) &_plant_Individual___FF16drivers__FF16_Env__strategy_name__get, 1}, {"_plant_Individual___K93__K93_Env__ctor", (DL_FUNC) &_plant_Individual___K93__K93_Env__ctor, 1}, {"_plant_Individual___K93__K93_Env__state", (DL_FUNC) &_plant_Individual___K93__K93_Env__state, 2}, {"_plant_Individual___K93__K93_Env__rate", (DL_FUNC) &_plant_Individual___K93__K93_Env__rate, 2}, @@ -10178,6 +12201,9 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_IndividualRunner___FF16r__FF16_Env__ctor", (DL_FUNC) &_plant_IndividualRunner___FF16r__FF16_Env__ctor, 2}, {"_plant_IndividualRunner___FF16r__FF16_Env__individual__get", (DL_FUNC) &_plant_IndividualRunner___FF16r__FF16_Env__individual__get, 1}, {"_plant_IndividualRunner___FF16r__FF16_Env__individual__set", (DL_FUNC) &_plant_IndividualRunner___FF16r__FF16_Env__individual__set, 2}, + {"_plant_IndividualRunner___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_IndividualRunner___FF16drivers__FF16_Env__ctor, 2}, + {"_plant_IndividualRunner___FF16drivers__FF16_Env__individual__get", (DL_FUNC) &_plant_IndividualRunner___FF16drivers__FF16_Env__individual__get, 1}, + {"_plant_IndividualRunner___FF16drivers__FF16_Env__individual__set", (DL_FUNC) &_plant_IndividualRunner___FF16drivers__FF16_Env__individual__set, 2}, {"_plant_IndividualRunner___K93__K93_Env__ctor", (DL_FUNC) &_plant_IndividualRunner___K93__K93_Env__ctor, 2}, {"_plant_IndividualRunner___K93__K93_Env__individual__get", (DL_FUNC) &_plant_IndividualRunner___K93__K93_Env__individual__get, 1}, {"_plant_IndividualRunner___K93__K93_Env__individual__set", (DL_FUNC) &_plant_IndividualRunner___K93__K93_Env__individual__set, 2}, @@ -10205,6 +12231,8 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_Parameters___FF16w__FF16_Env__vdor", (DL_FUNC) &_plant_Parameters___FF16w__FF16_Env__vdor, 1}, {"_plant_Parameters___FF16r__FF16_Env__ctor", (DL_FUNC) &_plant_Parameters___FF16r__FF16_Env__ctor, 0}, {"_plant_Parameters___FF16r__FF16_Env__vdor", (DL_FUNC) &_plant_Parameters___FF16r__FF16_Env__vdor, 1}, + {"_plant_Parameters___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_Parameters___FF16drivers__FF16_Env__ctor, 0}, + {"_plant_Parameters___FF16drivers__FF16_Env__vdor", (DL_FUNC) &_plant_Parameters___FF16drivers__FF16_Env__vdor, 1}, {"_plant_Parameters___K93__K93_Env__ctor", (DL_FUNC) &_plant_Parameters___K93__K93_Env__ctor, 0}, {"_plant_Parameters___K93__K93_Env__vdor", (DL_FUNC) &_plant_Parameters___K93__K93_Env__vdor, 1}, {"_plant_Node___FF16__FF16_Env__ctor", (DL_FUNC) &_plant_Node___FF16__FF16_Env__ctor, 1}, @@ -10252,6 +12280,21 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_Node___FF16r__FF16_Env__ode_state__set", (DL_FUNC) &_plant_Node___FF16r__FF16_Env__ode_state__set, 2}, {"_plant_Node___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Node___FF16r__FF16_Env__ode_rates__get, 1}, {"_plant_Node___FF16r__FF16_Env__ode_names__get", (DL_FUNC) &_plant_Node___FF16r__FF16_Env__ode_names__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ctor, 1}, + {"_plant_Node___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_Node___FF16drivers__FF16_Env__growth_rate_gradient", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__growth_rate_gradient, 2}, + {"_plant_Node___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__compute_rates, 3}, + {"_plant_Node___FF16drivers__FF16_Env__compute_initial_conditions", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__compute_initial_conditions, 4}, + {"_plant_Node___FF16drivers__FF16_Env__individual__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__individual__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__height__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__height__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__log_density__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__log_density__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__competition_effect__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__competition_effect__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__fecundity__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__fecundity__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__ode_state__set", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ode_state__set, 2}, + {"_plant_Node___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ode_rates__get, 1}, + {"_plant_Node___FF16drivers__FF16_Env__ode_names__get", (DL_FUNC) &_plant_Node___FF16drivers__FF16_Env__ode_names__get, 1}, {"_plant_Node___K93__K93_Env__ctor", (DL_FUNC) &_plant_Node___K93__K93_Env__ctor, 1}, {"_plant_Node___K93__K93_Env__compute_competition", (DL_FUNC) &_plant_Node___K93__K93_Env__compute_competition, 2}, {"_plant_Node___K93__K93_Env__growth_rate_gradient", (DL_FUNC) &_plant_Node___K93__K93_Env__growth_rate_gradient, 2}, @@ -10330,6 +12373,27 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_Species___FF16r__FF16_Env__ode_state__get", (DL_FUNC) &_plant_Species___FF16r__FF16_Env__ode_state__get, 1}, {"_plant_Species___FF16r__FF16_Env__ode_state__set", (DL_FUNC) &_plant_Species___FF16r__FF16_Env__ode_state__set, 2}, {"_plant_Species___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Species___FF16r__FF16_Env__ode_rates__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__ctor, 1}, + {"_plant_Species___FF16drivers__FF16_Env__clear", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__clear, 1}, + {"_plant_Species___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__compute_rates, 4}, + {"_plant_Species___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_Species___FF16drivers__FF16_Env__introduce_new_node", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__introduce_new_node, 1}, + {"_plant_Species___FF16drivers__FF16_Env__node_at", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__node_at, 2}, + {"_plant_Species___FF16drivers__FF16_Env__competition_effects_error", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__competition_effects_error, 2}, + {"_plant_Species___FF16drivers__FF16_Env__size__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__size__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__new_node__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__new_node__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__height_max__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__height_max__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__heights__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__heights__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__heights__set", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__heights__set, 2}, + {"_plant_Species___FF16drivers__FF16_Env__log_densities__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__log_densities__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__nodes__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__nodes__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__competition_effects__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__competition_effects__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__extrinsic_drivers__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__extrinsic_drivers__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_Species___FF16drivers__FF16_Env__ode_state__set", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__ode_state__set, 2}, + {"_plant_Species___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Species___FF16drivers__FF16_Env__ode_rates__get, 1}, {"_plant_Species___K93__K93_Env__ctor", (DL_FUNC) &_plant_Species___K93__K93_Env__ctor, 1}, {"_plant_Species___K93__K93_Env__clear", (DL_FUNC) &_plant_Species___K93__K93_Env__clear, 1}, {"_plant_Species___K93__K93_Env__compute_rates", (DL_FUNC) &_plant_Species___K93__K93_Env__compute_rates, 4}, @@ -10432,6 +12496,33 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_Patch___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Patch___FF16r__FF16_Env__ode_rates__get, 1}, {"_plant_Patch___FF16r__FF16_Env__ode_aux__get", (DL_FUNC) &_plant_Patch___FF16r__FF16_Env__ode_aux__get, 1}, {"_plant_Patch___FF16r__FF16_Env__node_ode_size__get", (DL_FUNC) &_plant_Patch___FF16r__FF16_Env__node_ode_size__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ctor, 3}, + {"_plant_Patch___FF16drivers__FF16_Env__introduce_new_node", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__introduce_new_node, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__compute_environment", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__compute_environment, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__compute_rates, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__reset", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__reset, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__set_ode_state", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__set_ode_state, 3}, + {"_plant_Patch___FF16drivers__FF16_Env__derivs", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__derivs, 3}, + {"_plant_Patch___FF16drivers__FF16_Env__set_time", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__set_time, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__set_state", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__set_state, 5}, + {"_plant_Patch___FF16drivers__FF16_Env__density", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__density, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__pr_survival", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__pr_survival, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__disturbance_mean_interval", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__disturbance_mean_interval, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__survival_weighting_cdf", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__survival_weighting_cdf, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__survival_weighting_icdf", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__survival_weighting_icdf, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_Patch___FF16drivers__FF16_Env__time__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__time__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__size__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__size__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__height_max__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__height_max__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__parameters__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__parameters__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__environment__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__environment__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__species__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__species__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ode_time__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ode_time__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ode_rates__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__ode_aux__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__ode_aux__get, 1}, + {"_plant_Patch___FF16drivers__FF16_Env__node_ode_size__get", (DL_FUNC) &_plant_Patch___FF16drivers__FF16_Env__node_ode_size__get, 1}, {"_plant_Patch___K93__K93_Env__ctor", (DL_FUNC) &_plant_Patch___K93__K93_Env__ctor, 3}, {"_plant_Patch___K93__K93_Env__introduce_new_node", (DL_FUNC) &_plant_Patch___K93__K93_Env__introduce_new_node, 2}, {"_plant_Patch___K93__K93_Env__compute_environment", (DL_FUNC) &_plant_Patch___K93__K93_Env__compute_environment, 1}, @@ -10525,6 +12616,28 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_SCM___FF16r__FF16_Env__use_ode_times__get", (DL_FUNC) &_plant_SCM___FF16r__FF16_Env__use_ode_times__get, 1}, {"_plant_SCM___FF16r__FF16_Env__use_ode_times__set", (DL_FUNC) &_plant_SCM___FF16r__FF16_Env__use_ode_times__set, 2}, {"_plant_SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get", (DL_FUNC) &_plant_SCM___FF16r__FF16_Env__net_reproduction_ratio_errors__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__ctor, 3}, + {"_plant_SCM___FF16drivers__FF16_Env__run", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__run, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__run_mutant", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__run_mutant, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__run_next", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__run_next, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__reset", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__reset, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__competition_effect_error", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__competition_effect_error, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__set_node_schedule_times", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__set_node_schedule_times, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__complete__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__complete__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__time__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__time__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__offspring_production__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__offspring_production__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__parameters__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__parameters__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__patch__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__patch__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__node_schedule__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__node_schedule__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__node_schedule__set", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__node_schedule__set, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__ode_times__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__ode_times__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__state__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__state__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__aux__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__aux__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__use_ode_times__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__use_ode_times__get, 1}, + {"_plant_SCM___FF16drivers__FF16_Env__use_ode_times__set", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__use_ode_times__set, 2}, + {"_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get", (DL_FUNC) &_plant_SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get, 1}, {"_plant_SCM___K93__K93_Env__ctor", (DL_FUNC) &_plant_SCM___K93__K93_Env__ctor, 3}, {"_plant_SCM___K93__K93_Env__run", (DL_FUNC) &_plant_SCM___K93__K93_Env__run, 1}, {"_plant_SCM___K93__K93_Env__run_mutant", (DL_FUNC) &_plant_SCM___K93__K93_Env__run_mutant, 2}, @@ -10610,6 +12723,27 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_StochasticSpecies___FF16r__FF16_Env__ode_state__get", (DL_FUNC) &_plant_StochasticSpecies___FF16r__FF16_Env__ode_state__get, 1}, {"_plant_StochasticSpecies___FF16r__FF16_Env__ode_state__set", (DL_FUNC) &_plant_StochasticSpecies___FF16r__FF16_Env__ode_state__set, 2}, {"_plant_StochasticSpecies___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_StochasticSpecies___FF16r__FF16_Env__ode_rates__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__ctor, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__clear", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__clear, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_rates, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__individual_at", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__individual_at, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__deaths", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__deaths, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__establishment_probability", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__establishment_probability, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__size__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__size__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__new_node__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__new_node__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__height_max__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__height_max__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__set", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__heights__set, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__individuals__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__individuals__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__is_alive__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__is_alive__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__set", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_state__set, 2}, + {"_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get, 1}, {"_plant_StochasticSpecies___K93__K93_Env__ctor", (DL_FUNC) &_plant_StochasticSpecies___K93__K93_Env__ctor, 1}, {"_plant_StochasticSpecies___K93__K93_Env__clear", (DL_FUNC) &_plant_StochasticSpecies___K93__K93_Env__clear, 1}, {"_plant_StochasticSpecies___K93__K93_Env__compute_rates", (DL_FUNC) &_plant_StochasticSpecies___K93__K93_Env__compute_rates, 2}, @@ -10694,6 +12828,27 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_StochasticPatch___FF16r__FF16_Env__ode_time__get", (DL_FUNC) &_plant_StochasticPatch___FF16r__FF16_Env__ode_time__get, 1}, {"_plant_StochasticPatch___FF16r__FF16_Env__ode_state__get", (DL_FUNC) &_plant_StochasticPatch___FF16r__FF16_Env__ode_state__get, 1}, {"_plant_StochasticPatch___FF16r__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_StochasticPatch___FF16r__FF16_Env__ode_rates__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__ctor, 3}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__compute_competition", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__compute_competition, 2}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node, 2}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update, 2}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__compute_environment", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__compute_environment, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__compute_rates", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__compute_rates, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__reset", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__reset, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__set_ode_state", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__set_ode_state, 3}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__derivs", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__derivs, 3}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__set_state", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__set_state, 4}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__deaths", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__deaths, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__time__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__time__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__size__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__size__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__height_max__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__height_max__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__parameters__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__parameters__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__environment__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__environment__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__species__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__species__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__ode_size__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__ode_size__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__ode_time__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__ode_time__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__ode_state__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__ode_state__get, 1}, + {"_plant_StochasticPatch___FF16drivers__FF16_Env__ode_rates__get", (DL_FUNC) &_plant_StochasticPatch___FF16drivers__FF16_Env__ode_rates__get, 1}, {"_plant_StochasticPatch___K93__K93_Env__ctor", (DL_FUNC) &_plant_StochasticPatch___K93__K93_Env__ctor, 3}, {"_plant_StochasticPatch___K93__K93_Env__compute_competition", (DL_FUNC) &_plant_StochasticPatch___K93__K93_Env__compute_competition, 2}, {"_plant_StochasticPatch___K93__K93_Env__introduce_new_node", (DL_FUNC) &_plant_StochasticPatch___K93__K93_Env__introduce_new_node, 2}, @@ -10751,6 +12906,18 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_StochasticPatchRunner___FF16r__FF16_Env__schedule__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16r__FF16_Env__schedule__get, 1}, {"_plant_StochasticPatchRunner___FF16r__FF16_Env__schedule__set", (DL_FUNC) &_plant_StochasticPatchRunner___FF16r__FF16_Env__schedule__set, 2}, {"_plant_StochasticPatchRunner___FF16r__FF16_Env__state__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16r__FF16_Env__state__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__ctor", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__ctor, 3}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run_next", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__run_next, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__reset", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__reset, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times, 2}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__complete__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__complete__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__time__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__time__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__patch__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__patch__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get, 1}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set, 2}, + {"_plant_StochasticPatchRunner___FF16drivers__FF16_Env__state__get", (DL_FUNC) &_plant_StochasticPatchRunner___FF16drivers__FF16_Env__state__get, 1}, {"_plant_StochasticPatchRunner___K93__K93_Env__ctor", (DL_FUNC) &_plant_StochasticPatchRunner___K93__K93_Env__ctor, 3}, {"_plant_StochasticPatchRunner___K93__K93_Env__run", (DL_FUNC) &_plant_StochasticPatchRunner___K93__K93_Env__run, 1}, {"_plant_StochasticPatchRunner___K93__K93_Env__run_next", (DL_FUNC) &_plant_StochasticPatchRunner___K93__K93_Env__run_next, 1}, @@ -10796,6 +12963,7 @@ static const R_CallMethodDef CallEntries[] = { {"_plant_FF16_Environment__soil__get", (DL_FUNC) &_plant_FF16_Environment__soil__get, 1}, {"_plant_FF16_Environment__extrinsic_drivers__get", (DL_FUNC) &_plant_FF16_Environment__extrinsic_drivers__get, 1}, {"_plant_FF16_Environment__extrinsic_drivers__set", (DL_FUNC) &_plant_FF16_Environment__extrinsic_drivers__set, 2}, + {"_plant_FF16drivers_Strategy__ctor", (DL_FUNC) &_plant_FF16drivers_Strategy__ctor, 0}, {"_plant_FF16r_Strategy__ctor", (DL_FUNC) &_plant_FF16r_Strategy__ctor, 0}, {"_plant_K93_Strategy__ctor", (DL_FUNC) &_plant_K93_Strategy__ctor, 0}, {"_plant_K93_Environment__ctor", (DL_FUNC) &_plant_K93_Environment__ctor, 0}, diff --git a/src/RcppR6.cpp b/src/RcppR6.cpp index 52bc02b4c..e2dc97828 100644 --- a/src/RcppR6.cpp +++ b/src/RcppR6.cpp @@ -284,6 +284,55 @@ plant::tools::IndividualRunner O } +// [[Rcpp::export]] +plant::ode::Runner > OdeRunner___FF16drivers__ctor(plant::tools::IndividualRunner obj, plant::ode::OdeControl control) { + return plant::ode::Runner >(obj, control); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__advance(plant::RcppR6::RcppR6 > > obj_, double time) { + obj_->advance(time); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__advance_fixed(plant::RcppR6::RcppR6 > > obj_, std::vector time) { + obj_->advance_fixed(time); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__step(plant::RcppR6::RcppR6 > > obj_) { + obj_->step(); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__step_to(plant::RcppR6::RcppR6 > > obj_, double time) { + obj_->step_to(time); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__set_state(plant::RcppR6::RcppR6 > > obj_, plant::ode::state_type y, double time) { + obj_->set_state(y, time); +} +// [[Rcpp::export]] +void OdeRunner___FF16drivers__set_state_from_system(plant::RcppR6::RcppR6 > > obj_) { + obj_->set_state_from_system(); +} +// [[Rcpp::export]] +double OdeRunner___FF16drivers__time__get(plant::RcppR6::RcppR6 > > obj_) { + return obj_->time(); +} + +// [[Rcpp::export]] +plant::ode::state_type OdeRunner___FF16drivers__state__get(plant::RcppR6::RcppR6 > > obj_) { + return obj_->state(); +} + +// [[Rcpp::export]] +std::vector OdeRunner___FF16drivers__times__get(plant::RcppR6::RcppR6 > > obj_) { + return obj_->times(); +} + +// [[Rcpp::export]] +plant::tools::IndividualRunner OdeRunner___FF16drivers__object__get(plant::RcppR6::RcppR6 > > obj_) { + return obj_->object(); +} + + // [[Rcpp::export]] plant::ode::Runner > OdeRunner___K93__ctor(plant::tools::IndividualRunner obj, plant::ode::OdeControl control) { return plant::ode::Runner >(obj, control); @@ -895,6 +944,105 @@ std::string Individual___FF16r__FF16_Env__strategy_name__get(plant::RcppR6::Rcpp } +// [[Rcpp::export]] +plant::Individual Individual___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy s) { + return plant::make_individual(s); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__state(plant::RcppR6::RcppR6 > obj_, std::string name) { + return obj_->state(name); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__rate(plant::RcppR6::RcppR6 > obj_, std::string name) { + return obj_->rate(name); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__aux(plant::RcppR6::RcppR6 > obj_, std::string name) { + return obj_->aux(name); +} +// [[Rcpp::export]] +void Individual___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, std::string name, double v) { + obj_->set_state(name, v); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double h) { + return obj_->compute_competition(h); +} +// [[Rcpp::export]] +void Individual___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + obj_->compute_rates(environment); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__establishment_probability(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + return obj_->establishment_probability(environment); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__net_mass_production_dt(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + return obj_->net_mass_production_dt(environment); +} +// [[Rcpp::export]] +void Individual___FF16drivers__FF16_Env__reset_mortality(plant::RcppR6::RcppR6 > obj_) { + obj_->reset_mortality(); +} +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__resource_compensation_point(plant::RcppR6::RcppR6 > obj_) { + return obj_->resource_compensation_point(); +} +// [[Rcpp::export]] +plant::FF16drivers_Strategy Individual___FF16drivers__FF16_Env__strategy__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_get_strategy(); +} + +// [[Rcpp::export]] +plant::Internals Individual___FF16drivers__FF16_Env__internals__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_internals(); +} + +// [[Rcpp::export]] +size_t Individual___FF16drivers__FF16_Env__aux_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->aux_size(); +} + +// [[Rcpp::export]] +size_t Individual___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +std::vector Individual___FF16drivers__FF16_Env__ode_names__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_names(); +} + +// [[Rcpp::export]] +std::vector Individual___FF16drivers__FF16_Env__aux_names__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->aux_names(); +} + +// [[Rcpp::export]] +plant::ode::state_type Individual___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} +// [[Rcpp::export]] +void Individual___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { + plant::ode::r_set_ode_state(*obj_, value); +} + +// [[Rcpp::export]] +plant::ode::state_type Individual___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + +// [[Rcpp::export]] +double Individual___FF16drivers__FF16_Env__mortality_probability__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->mortality_probability(); +} + +// [[Rcpp::export]] +std::string Individual___FF16drivers__FF16_Env__strategy_name__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->strategy_name(); +} + + // [[Rcpp::export]] plant::Individual Individual___K93__K93_Env__ctor(plant::K93_Strategy s) { return plant::make_individual(s); @@ -1036,6 +1184,20 @@ void IndividualRunner___FF16r__FF16_Env__individual__set(plant::RcppR6::RcppR6

IndividualRunner___FF16drivers__FF16_Env__ctor(plant::Individual individual, plant::FF16_Environment environment) { + return plant::tools::IndividualRunner(individual, environment); +} +// [[Rcpp::export]] +plant::Individual IndividualRunner___FF16drivers__FF16_Env__individual__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->individual; +} +// [[Rcpp::export]] +void IndividualRunner___FF16drivers__FF16_Env__individual__set(plant::RcppR6::RcppR6 > obj_, plant::Individual value) { + obj_->individual = value; +} + + // [[Rcpp::export]] plant::tools::IndividualRunner IndividualRunner___K93__K93_Env__ctor(plant::Individual individual, plant::K93_Environment environment) { return plant::tools::IndividualRunner(individual, environment); @@ -1158,6 +1320,16 @@ SEXP Parameters___FF16r__FF16_Env__vdor(SEXP obj) { } +// [[Rcpp::export]] +SEXP Parameters___FF16drivers__FF16_Env__ctor() { + return Rcpp::wrap(plant::Parameters()); +} +// [[Rcpp::export]] +SEXP Parameters___FF16drivers__FF16_Env__vdor(SEXP obj) { + return Rcpp::wrap(Rcpp::as >(obj)); +} + + // [[Rcpp::export]] SEXP Parameters___K93__K93_Env__ctor() { return Rcpp::wrap(plant::Parameters()); @@ -1378,6 +1550,76 @@ std::vector Node___FF16r__FF16_Env__ode_names__get(plant::RcppR6::R } +// [[Rcpp::export]] +plant::Node Node___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy) { + return plant::make_node(strategy); +} +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { + return obj_->compute_competition(height); +} +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__growth_rate_gradient(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + return obj_->r_growth_rate_gradient(environment); +} +// [[Rcpp::export]] +void Node___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival) { + obj_->compute_rates(environment, pr_patch_survival); +} +// [[Rcpp::export]] +void Node___FF16drivers__FF16_Env__compute_initial_conditions(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival, double birth_rate) { + obj_->compute_initial_conditions(environment, pr_patch_survival, birth_rate); +} +// [[Rcpp::export]] +plant::Individual Node___FF16drivers__FF16_Env__individual__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->individual; +} + +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__height__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->height(); +} + +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__log_density__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->get_log_density(); +} + +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__competition_effect__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->competition_effect(); +} + +// [[Rcpp::export]] +double Node___FF16drivers__FF16_Env__fecundity__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->fecundity(); +} + +// [[Rcpp::export]] +size_t Node___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +plant::ode::state_type Node___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} +// [[Rcpp::export]] +void Node___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { + plant::ode::r_set_ode_state(*obj_, value); +} + +// [[Rcpp::export]] +plant::ode::state_type Node___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + +// [[Rcpp::export]] +std::vector Node___FF16drivers__FF16_Env__ode_names__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_names(); +} + + // [[Rcpp::export]] plant::Node Node___K93__K93_Env__ctor(plant::K93_Strategy strategy) { return plant::make_node(strategy); @@ -1740,149 +1982,246 @@ plant::ode::state_type Species___FF16r__FF16_Env__ode_rates__get(plant::RcppR6:: // [[Rcpp::export]] -plant::Species Species___K93__K93_Env__ctor(plant::K93_Strategy strategy) { - return plant::Species(strategy); +plant::Species Species___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy) { + return plant::Species(strategy); } // [[Rcpp::export]] -void Species___K93__K93_Env__clear(plant::RcppR6::RcppR6 > obj_) { +void Species___FF16drivers__FF16_Env__clear(plant::RcppR6::RcppR6 > obj_) { obj_->clear(); } // [[Rcpp::export]] -void Species___K93__K93_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment, double pr_patch_survival, double birth_rate) { +void Species___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment, double pr_patch_survival, double birth_rate) { obj_->compute_rates(environment, pr_patch_survival, birth_rate); } // [[Rcpp::export]] -double Species___K93__K93_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { +double Species___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { return obj_->compute_competition(height); } // [[Rcpp::export]] -void Species___K93__K93_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_) { +void Species___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_) { obj_->introduce_new_node(); } // [[Rcpp::export]] -plant::Node Species___K93__K93_Env__node_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index) { +plant::Node Species___FF16drivers__FF16_Env__node_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index) { return obj_->r_node_at(index); } // [[Rcpp::export]] -std::vector Species___K93__K93_Env__competition_effects_error(plant::RcppR6::RcppR6 > obj_, double scal) { +std::vector Species___FF16drivers__FF16_Env__competition_effects_error(plant::RcppR6::RcppR6 > obj_, double scal) { return obj_->r_competition_effects_error(scal); } // [[Rcpp::export]] -size_t Species___K93__K93_Env__size__get(plant::RcppR6::RcppR6 > obj_) { +size_t Species___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_) { return obj_->size(); } // [[Rcpp::export]] -plant::Node Species___K93__K93_Env__new_node__get(plant::RcppR6::RcppR6 > obj_) { +plant::Node Species___FF16drivers__FF16_Env__new_node__get(plant::RcppR6::RcppR6 > obj_) { return obj_->r_new_node(); } // [[Rcpp::export]] -double Species___K93__K93_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { +double Species___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { return obj_->height_max(); } // [[Rcpp::export]] -std::vector Species___K93__K93_Env__heights__get(plant::RcppR6::RcppR6 > obj_) { +std::vector Species___FF16drivers__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_) { return obj_->r_heights(); } // [[Rcpp::export]] -void Species___K93__K93_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value) { +void Species___FF16drivers__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value) { obj_->r_set_heights(value); } // [[Rcpp::export]] -std::vector Species___K93__K93_Env__log_densities__get(plant::RcppR6::RcppR6 > obj_) { +std::vector Species___FF16drivers__FF16_Env__log_densities__get(plant::RcppR6::RcppR6 > obj_) { return obj_->r_log_densities(); } // [[Rcpp::export]] -std::vector > Species___K93__K93_Env__nodes__get(plant::RcppR6::RcppR6 > obj_) { +std::vector > Species___FF16drivers__FF16_Env__nodes__get(plant::RcppR6::RcppR6 > obj_) { return obj_->r_nodes(); } // [[Rcpp::export]] -std::vector Species___K93__K93_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_) { +std::vector Species___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_) { return obj_->net_reproduction_ratio_by_node(); } // [[Rcpp::export]] -std::vector Species___K93__K93_Env__competition_effects__get(plant::RcppR6::RcppR6 > obj_) { +std::vector Species___FF16drivers__FF16_Env__competition_effects__get(plant::RcppR6::RcppR6 > obj_) { return obj_->r_competition_effects(); } // [[Rcpp::export]] -plant::ExtrinsicDrivers Species___K93__K93_Env__extrinsic_drivers__get(plant::RcppR6::RcppR6 > obj_) { +plant::ExtrinsicDrivers Species___FF16drivers__FF16_Env__extrinsic_drivers__get(plant::RcppR6::RcppR6 > obj_) { return obj_->extrinsic_drivers(); } // [[Rcpp::export]] -size_t Species___K93__K93_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { +size_t Species___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { return obj_->ode_size(); } // [[Rcpp::export]] -plant::ode::state_type Species___K93__K93_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { +plant::ode::state_type Species___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { return plant::ode::r_ode_state(*obj_); } // [[Rcpp::export]] -void Species___K93__K93_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { +void Species___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { plant::ode::r_set_ode_state(*obj_, value); } // [[Rcpp::export]] -plant::ode::state_type Species___K93__K93_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { +plant::ode::state_type Species___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { return plant::ode::r_ode_rates(*obj_); } // [[Rcpp::export]] -plant::Patch Patch___FF16__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { - return plant::Patch(parameters, environment, control); +plant::Species Species___K93__K93_Env__ctor(plant::K93_Strategy strategy) { + return plant::Species(strategy); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { - obj_->r_introduce_new_node(species_index); +void Species___K93__K93_Env__clear(plant::RcppR6::RcppR6 > obj_) { + obj_->clear(); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_) { - obj_->r_compute_environment(); +void Species___K93__K93_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::K93_Environment environment, double pr_patch_survival, double birth_rate) { + obj_->compute_rates(environment, pr_patch_survival, birth_rate); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_) { - obj_->r_compute_rates(); +double Species___K93__K93_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { + return obj_->compute_competition(height); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { - obj_->reset(); +void Species___K93__K93_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_) { + obj_->introduce_new_node(); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time) { - plant::ode::r_set_ode_state(*obj_, values, time); +plant::Node Species___K93__K93_Env__node_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index) { + return obj_->r_node_at(index); } // [[Rcpp::export]] -plant::ode::state_type Patch___FF16__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time) { - return plant::ode::r_derivs(*obj_, y, time); +std::vector Species___K93__K93_Env__competition_effects_error(plant::RcppR6::RcppR6 > obj_, double scal) { + return obj_->r_competition_effects_error(scal); } // [[Rcpp::export]] -void Patch___FF16__FF16_Env__set_time(plant::RcppR6::RcppR6 > obj_, double time) { - obj_->r_set_time(time); +size_t Species___K93__K93_Env__size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->size(); } + // [[Rcpp::export]] -void Patch___FF16__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n, const std::vector& env) { - obj_->r_set_state(time, state, n, env); +plant::Node Species___K93__K93_Env__new_node__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_new_node(); } + // [[Rcpp::export]] -std::vector Patch___FF16__FF16_Env__density(plant::RcppR6::RcppR6 > obj_, std::vector time) { - return obj_->r_density(time); +double Species___K93__K93_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->height_max(); } + // [[Rcpp::export]] -double Patch___FF16__FF16_Env__pr_survival(plant::RcppR6::RcppR6 > obj_, double time) { - return obj_->r_pr_survival(time); +std::vector Species___K93__K93_Env__heights__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_heights(); } // [[Rcpp::export]] -double Patch___FF16__FF16_Env__disturbance_mean_interval(plant::RcppR6::RcppR6 > obj_) { - return obj_->r_disturbance_mean_interval(); +void Species___K93__K93_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value) { + obj_->r_set_heights(value); +} + +// [[Rcpp::export]] +std::vector Species___K93__K93_Env__log_densities__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_log_densities(); +} + +// [[Rcpp::export]] +std::vector > Species___K93__K93_Env__nodes__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_nodes(); +} + +// [[Rcpp::export]] +std::vector Species___K93__K93_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->net_reproduction_ratio_by_node(); +} + +// [[Rcpp::export]] +std::vector Species___K93__K93_Env__competition_effects__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_competition_effects(); +} + +// [[Rcpp::export]] +plant::ExtrinsicDrivers Species___K93__K93_Env__extrinsic_drivers__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->extrinsic_drivers(); +} + +// [[Rcpp::export]] +size_t Species___K93__K93_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +plant::ode::state_type Species___K93__K93_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} +// [[Rcpp::export]] +void Species___K93__K93_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { + plant::ode::r_set_ode_state(*obj_, value); +} + +// [[Rcpp::export]] +plant::ode::state_type Species___K93__K93_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + + +// [[Rcpp::export]] +plant::Patch Patch___FF16__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { + return plant::Patch(parameters, environment, control); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + obj_->r_introduce_new_node(species_index); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_environment(); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_rates(); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { + obj_->reset(); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time) { + plant::ode::r_set_ode_state(*obj_, values, time); +} +// [[Rcpp::export]] +plant::ode::state_type Patch___FF16__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time) { + return plant::ode::r_derivs(*obj_, y, time); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__set_time(plant::RcppR6::RcppR6 > obj_, double time) { + obj_->r_set_time(time); +} +// [[Rcpp::export]] +void Patch___FF16__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n, const std::vector& env) { + obj_->r_set_state(time, state, n, env); +} +// [[Rcpp::export]] +std::vector Patch___FF16__FF16_Env__density(plant::RcppR6::RcppR6 > obj_, std::vector time) { + return obj_->r_density(time); +} +// [[Rcpp::export]] +double Patch___FF16__FF16_Env__pr_survival(plant::RcppR6::RcppR6 > obj_, double time) { + return obj_->r_pr_survival(time); +} +// [[Rcpp::export]] +double Patch___FF16__FF16_Env__disturbance_mean_interval(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_disturbance_mean_interval(); } // [[Rcpp::export]] double Patch___FF16__FF16_Env__survival_weighting_cdf(plant::RcppR6::RcppR6 > obj_, double time) { @@ -2199,6 +2538,127 @@ size_t Patch___FF16r__FF16_Env__node_ode_size__get(plant::RcppR6::RcppR6 Patch___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { + return plant::Patch(parameters, environment, control); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + obj_->r_introduce_new_node(species_index); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_environment(); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_rates(); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { + obj_->reset(); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time) { + plant::ode::r_set_ode_state(*obj_, values, time); +} +// [[Rcpp::export]] +plant::ode::state_type Patch___FF16drivers__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time) { + return plant::ode::r_derivs(*obj_, y, time); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__set_time(plant::RcppR6::RcppR6 > obj_, double time) { + obj_->r_set_time(time); +} +// [[Rcpp::export]] +void Patch___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n, const std::vector& env) { + obj_->r_set_state(time, state, n, env); +} +// [[Rcpp::export]] +std::vector Patch___FF16drivers__FF16_Env__density(plant::RcppR6::RcppR6 > obj_, std::vector time) { + return obj_->r_density(time); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__pr_survival(plant::RcppR6::RcppR6 > obj_, double time) { + return obj_->r_pr_survival(time); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__disturbance_mean_interval(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_disturbance_mean_interval(); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__survival_weighting_cdf(plant::RcppR6::RcppR6 > obj_, double time) { + return obj_->r_survival_weighting_cdf(time); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__survival_weighting_icdf(plant::RcppR6::RcppR6 > obj_, double prob) { + return obj_->r_survival_weighting_icdf(prob); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { + return obj_->compute_competition(height); +} +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->time(); +} + +// [[Rcpp::export]] +size_t Patch___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->size(); +} + +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->height_max(); +} + +// [[Rcpp::export]] +plant::Parameters Patch___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_parameters(); +} + +// [[Rcpp::export]] +plant::FF16_Environment Patch___FF16drivers__FF16_Env__environment__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_environment(); +} + +// [[Rcpp::export]] +std::vector > Patch___FF16drivers__FF16_Env__species__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_species(); +} + +// [[Rcpp::export]] +size_t Patch___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +double Patch___FF16drivers__FF16_Env__ode_time__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_time(*obj_); +} + +// [[Rcpp::export]] +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} + +// [[Rcpp::export]] +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + +// [[Rcpp::export]] +plant::ode::state_type Patch___FF16drivers__FF16_Env__ode_aux__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_aux(*obj_); +} + +// [[Rcpp::export]] +size_t Patch___FF16drivers__FF16_Env__node_ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->node_ode_size(); +} + + // [[Rcpp::export]] plant::Patch Patch___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control) { return plant::Patch(parameters, environment, control); @@ -2623,6 +3083,107 @@ std::vector> SCM___FF16r__FF16_Env__net_reproduction_ratio_e } +// [[Rcpp::export]] +plant::SCM SCM___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { + return plant::SCM(parameters, environment, control); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__run(plant::RcppR6::RcppR6 > obj_) { + obj_->run(); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__run_mutant(plant::RcppR6::RcppR6 > obj_, plant::Parameters p) { + obj_->run_mutant(p); +} +// [[Rcpp::export]] +std::vector SCM___FF16drivers__FF16_Env__run_next(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_run_next(); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { + obj_->reset(); +} +// [[Rcpp::export]] +double SCM___FF16drivers__FF16_Env__net_reproduction_ratio_for_species(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + return obj_->r_net_reproduction_ratio_for_species(species_index); +} +// [[Rcpp::export]] +std::vector SCM___FF16drivers__FF16_Env__competition_effect_error(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + return obj_->r_competition_effect_error(species_index); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__set_node_schedule_times(plant::RcppR6::RcppR6 > obj_, std::vector> times) { + obj_->r_set_node_schedule_times(times); +} +// [[Rcpp::export]] +bool SCM___FF16drivers__FF16_Env__complete__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->complete(); +} + +// [[Rcpp::export]] +double SCM___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->time(); +} + +// [[Rcpp::export]] +std::vector SCM___FF16drivers__FF16_Env__net_reproduction_ratios__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->net_reproduction_ratios(); +} + +// [[Rcpp::export]] +std::vector SCM___FF16drivers__FF16_Env__offspring_production__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->offspring_production(); +} + +// [[Rcpp::export]] +plant::Parameters SCM___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_parameters(); +} + +// [[Rcpp::export]] +plant::Patch SCM___FF16drivers__FF16_Env__patch__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_patch(); +} + +// [[Rcpp::export]] +plant::NodeSchedule SCM___FF16drivers__FF16_Env__node_schedule__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_node_schedule(); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__node_schedule__set(plant::RcppR6::RcppR6 > obj_, plant::NodeSchedule value) { + obj_->r_set_node_schedule(value); +} + +// [[Rcpp::export]] +std::vector SCM___FF16drivers__FF16_Env__ode_times__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_ode_times(); +} + +// [[Rcpp::export]] +Rcpp::List SCM___FF16drivers__FF16_Env__state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::get_state(*obj_); +} + +// [[Rcpp::export]] +Rcpp::List SCM___FF16drivers__FF16_Env__aux__get(plant::RcppR6::RcppR6 > obj_) { + return plant::get_aux(*obj_); +} + +// [[Rcpp::export]] +bool SCM___FF16drivers__FF16_Env__use_ode_times__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_use_ode_times(); +} +// [[Rcpp::export]] +void SCM___FF16drivers__FF16_Env__use_ode_times__set(plant::RcppR6::RcppR6 > obj_, bool value) { + obj_->r_set_use_ode_times(value); +} + +// [[Rcpp::export]] +std::vector> SCM___FF16drivers__FF16_Env__net_reproduction_ratio_errors__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_net_reproduction_ratio_errors(); +} + + // [[Rcpp::export]] plant::SCM SCM___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control) { return plant::SCM(parameters, environment, control); @@ -3012,6 +3573,102 @@ plant::ode::state_type StochasticSpecies___FF16r__FF16_Env__ode_rates__get(plant } +// [[Rcpp::export]] +plant::StochasticSpecies StochasticSpecies___FF16drivers__FF16_Env__ctor(plant::FF16drivers_Strategy strategy) { + return plant::StochasticSpecies(strategy); +} +// [[Rcpp::export]] +void StochasticSpecies___FF16drivers__FF16_Env__clear(plant::RcppR6::RcppR6 > obj_) { + obj_->clear(); +} +// [[Rcpp::export]] +void StochasticSpecies___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + obj_->compute_rates(environment); +} +// [[Rcpp::export]] +double StochasticSpecies___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { + return obj_->compute_competition(height); +} +// [[Rcpp::export]] +void StochasticSpecies___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_) { + obj_->introduce_new_node(); +} +// [[Rcpp::export]] +plant::Individual StochasticSpecies___FF16drivers__FF16_Env__individual_at(plant::RcppR6::RcppR6 > obj_, plant::util::index index) { + return obj_->r_individual_at(index); +} +// [[Rcpp::export]] +size_t StochasticSpecies___FF16drivers__FF16_Env__deaths(plant::RcppR6::RcppR6 > obj_) { + return obj_->deaths(); +} +// [[Rcpp::export]] +double StochasticSpecies___FF16drivers__FF16_Env__establishment_probability(plant::RcppR6::RcppR6 > obj_, plant::FF16_Environment environment) { + return obj_->establishment_probability(environment); +} +// [[Rcpp::export]] +size_t StochasticSpecies___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->size(); +} + +// [[Rcpp::export]] +size_t StochasticSpecies___FF16drivers__FF16_Env__size_individuals__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->size_individuals(); +} + +// [[Rcpp::export]] +plant::Individual StochasticSpecies___FF16drivers__FF16_Env__new_node__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_new_node(); +} + +// [[Rcpp::export]] +double StochasticSpecies___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->height_max(); +} + +// [[Rcpp::export]] +std::vector StochasticSpecies___FF16drivers__FF16_Env__heights__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_heights(); +} +// [[Rcpp::export]] +void StochasticSpecies___FF16drivers__FF16_Env__heights__set(plant::RcppR6::RcppR6 > obj_, std::vector value) { + obj_->r_set_heights(value); +} + +// [[Rcpp::export]] +std::vector > StochasticSpecies___FF16drivers__FF16_Env__individuals__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_individuals(); +} + +// [[Rcpp::export]] +std::vector StochasticSpecies___FF16drivers__FF16_Env__is_alive__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_is_alive(); +} + +// [[Rcpp::export]] +std::vector StochasticSpecies___FF16drivers__FF16_Env__net_reproduction_ratio_by_node__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->net_reproduction_ratio_by_node(); +} + +// [[Rcpp::export]] +size_t StochasticSpecies___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +plant::ode::state_type StochasticSpecies___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} +// [[Rcpp::export]] +void StochasticSpecies___FF16drivers__FF16_Env__ode_state__set(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type value) { + plant::ode::r_set_ode_state(*obj_, value); +} + +// [[Rcpp::export]] +plant::ode::state_type StochasticSpecies___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + + // [[Rcpp::export]] plant::StochasticSpecies StochasticSpecies___K93__K93_Env__ctor(plant::K93_Strategy strategy) { return plant::StochasticSpecies(strategy); @@ -3393,6 +4050,101 @@ plant::ode::state_type StochasticPatch___FF16r__FF16_Env__ode_rates__get(plant:: } +// [[Rcpp::export]] +plant::StochasticPatch StochasticPatch___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { + return plant::StochasticPatch(parameters, environment, control); +} +// [[Rcpp::export]] +double StochasticPatch___FF16drivers__FF16_Env__compute_competition(plant::RcppR6::RcppR6 > obj_, double height) { + return obj_->compute_competition(height); +} +// [[Rcpp::export]] +bool StochasticPatch___FF16drivers__FF16_Env__introduce_new_node(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + return obj_->r_introduce_new_node(species_index); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__introduce_new_node_and_update(plant::RcppR6::RcppR6 > obj_, plant::util::index species_index) { + obj_->r_introduce_new_node_and_update(species_index); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__compute_environment(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_environment(); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__compute_rates(plant::RcppR6::RcppR6 > obj_) { + obj_->r_compute_rates(); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { + obj_->reset(); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__set_ode_state(plant::RcppR6::RcppR6 > obj_, plant::ode::state_type values, double time) { + plant::ode::r_set_ode_state(*obj_, values, time); +} +// [[Rcpp::export]] +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__derivs(plant::RcppR6::RcppR6 > obj_, const plant::ode::state_type& y, double time) { + return plant::ode::r_derivs(*obj_, y, time); +} +// [[Rcpp::export]] +void StochasticPatch___FF16drivers__FF16_Env__set_state(plant::RcppR6::RcppR6 > obj_, double time, const std::vector& state, const std::vector& n) { + obj_->r_set_state(time, state, n); +} +// [[Rcpp::export]] +std::vector StochasticPatch___FF16drivers__FF16_Env__deaths(plant::RcppR6::RcppR6 > obj_) { + return obj_->deaths(); +} +// [[Rcpp::export]] +double StochasticPatch___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->time(); +} + +// [[Rcpp::export]] +size_t StochasticPatch___FF16drivers__FF16_Env__size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->size(); +} + +// [[Rcpp::export]] +double StochasticPatch___FF16drivers__FF16_Env__height_max__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->height_max(); +} + +// [[Rcpp::export]] +plant::Parameters StochasticPatch___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_parameters(); +} + +// [[Rcpp::export]] +plant::FF16_Environment StochasticPatch___FF16drivers__FF16_Env__environment__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_environment(); +} + +// [[Rcpp::export]] +std::vector > StochasticPatch___FF16drivers__FF16_Env__species__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_species(); +} + +// [[Rcpp::export]] +size_t StochasticPatch___FF16drivers__FF16_Env__ode_size__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->ode_size(); +} + +// [[Rcpp::export]] +double StochasticPatch___FF16drivers__FF16_Env__ode_time__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_time(*obj_); +} + +// [[Rcpp::export]] +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__ode_state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_state(*obj_); +} + +// [[Rcpp::export]] +plant::ode::state_type StochasticPatch___FF16drivers__FF16_Env__ode_rates__get(plant::RcppR6::RcppR6 > obj_) { + return plant::ode::r_ode_rates(*obj_); +} + + // [[Rcpp::export]] plant::StochasticPatch StochasticPatch___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control) { return plant::StochasticPatch(parameters, environment, control); @@ -3653,6 +4405,61 @@ Rcpp::List StochasticPatchRunner___FF16r__FF16_Env__state__get(plant::RcppR6::Rc } +// [[Rcpp::export]] +plant::StochasticPatchRunner StochasticPatchRunner___FF16drivers__FF16_Env__ctor(plant::Parameters parameters, plant::FF16_Environment environment, plant::Control control) { + return plant::StochasticPatchRunner(parameters, environment, control); +} +// [[Rcpp::export]] +void StochasticPatchRunner___FF16drivers__FF16_Env__run(plant::RcppR6::RcppR6 > obj_) { + obj_->run(); +} +// [[Rcpp::export]] +plant::util::index StochasticPatchRunner___FF16drivers__FF16_Env__run_next(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_run_next(); +} +// [[Rcpp::export]] +void StochasticPatchRunner___FF16drivers__FF16_Env__reset(plant::RcppR6::RcppR6 > obj_) { + obj_->reset(); +} +// [[Rcpp::export]] +void StochasticPatchRunner___FF16drivers__FF16_Env__set_schedule_times(plant::RcppR6::RcppR6 > obj_, std::vector > times) { + obj_->r_set_schedule_times(times); +} +// [[Rcpp::export]] +bool StochasticPatchRunner___FF16drivers__FF16_Env__complete__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->complete(); +} + +// [[Rcpp::export]] +double StochasticPatchRunner___FF16drivers__FF16_Env__time__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->time(); +} + +// [[Rcpp::export]] +plant::Parameters StochasticPatchRunner___FF16drivers__FF16_Env__parameters__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_parameters(); +} + +// [[Rcpp::export]] +plant::StochasticPatch StochasticPatchRunner___FF16drivers__FF16_Env__patch__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_patch(); +} + +// [[Rcpp::export]] +plant::NodeSchedule StochasticPatchRunner___FF16drivers__FF16_Env__schedule__get(plant::RcppR6::RcppR6 > obj_) { + return obj_->r_schedule(); +} +// [[Rcpp::export]] +void StochasticPatchRunner___FF16drivers__FF16_Env__schedule__set(plant::RcppR6::RcppR6 > obj_, plant::NodeSchedule value) { + obj_->r_set_schedule(value); +} + +// [[Rcpp::export]] +Rcpp::List StochasticPatchRunner___FF16drivers__FF16_Env__state__get(plant::RcppR6::RcppR6 > obj_) { + return plant::get_state(*obj_); +} + + // [[Rcpp::export]] plant::StochasticPatchRunner StochasticPatchRunner___K93__K93_Env__ctor(plant::Parameters parameters, plant::K93_Environment environment, plant::Control control) { return plant::StochasticPatchRunner(parameters, environment, control); @@ -3854,6 +4661,12 @@ void FF16_Environment__extrinsic_drivers__set(plant::RcppR6::RcppR6 + +namespace plant { + +FF16drivers_Strategy::FF16drivers_Strategy() { + collect_all_auxiliary = false; + // build the string state/aux name to index map + refresh_indices(); + name = "FF16"; +} + +// one-shot update of the scm variables +// i.e. setting rates of ode vars from the state and updating aux vars +void FF16drivers_Strategy::compute_rates(const FF16_Environment& environment, + bool reuse_intervals, + Internals& vars) { + + double height = vars.state(HEIGHT_INDEX); + double area_leaf_ = vars.aux(aux_index.at("competition_effect")); + + const double net_mass_production_dt_ = + net_mass_production_dt(environment, height, area_leaf_, environment.time, reuse_intervals, herbivory_size_threshold); + + // store the aux sate + vars.set_aux(aux_index.at("net_mass_production_dt"), net_mass_production_dt_); + + if (net_mass_production_dt_ > 0) { + + const double fraction_allocation_reproduction_ = fraction_allocation_reproduction(height); + const double darea_leaf_dmass_live_ = darea_leaf_dmass_live(area_leaf_); + const double fraction_allocation_growth_ = fraction_allocation_growth(height); + const double area_leaf_dt = net_mass_production_dt_ * fraction_allocation_growth_ * darea_leaf_dmass_live_; + + vars.set_rate(HEIGHT_INDEX, dheight_darea_leaf(area_leaf_) * area_leaf_dt); + vars.set_rate(FECUNDITY_INDEX, + fecundity_dt(net_mass_production_dt_, fraction_allocation_reproduction_)); + + vars.set_rate(state_index.at("area_heartwood"), area_heartwood_dt(area_leaf_)); + const double area_sapwood_ = area_sapwood(area_leaf_); + const double mass_sapwood_ = mass_sapwood(area_sapwood_, height); + vars.set_rate(state_index.at("mass_heartwood"), mass_heartwood_dt(mass_sapwood_)); + + if (collect_all_auxiliary) { + vars.set_aux(aux_index.at("area_sapwood"), area_sapwood_); + } + } else { + vars.set_rate(HEIGHT_INDEX, 0.0); + vars.set_rate(FECUNDITY_INDEX, 0.0); + vars.set_rate(state_index.at("area_heartwood"), 0.0); + vars.set_rate(state_index.at("mass_heartwood"), 0.0); + } + // [eqn 21] - Instantaneous mortality rate + vars.set_rate(MORTALITY_INDEX, + mortality_dt(net_mass_production_dt_ / area_leaf_, + vars.state(MORTALITY_INDEX), + environment.time, + vars.state(HEIGHT_INDEX), + herbivory_size_threshold)); +} + +// One shot calculation of net_mass_production_dt +// Used by establishment_probability() and compute_rates(). +double FF16drivers_Strategy::net_mass_production_dt(const FF16_Environment& environment, + double height, double area_leaf_, double time, + bool reuse_intervals, double threshold) { + + const double mass_leaf_ = mass_leaf(area_leaf_); + const double area_sapwood_ = area_sapwood(area_leaf_); + const double mass_sapwood_ = mass_sapwood(area_sapwood_, height); + const double area_bark_ = area_bark(area_leaf_); + const double mass_bark_ = mass_bark(area_bark_, height); + const double mass_root_ = mass_root(area_leaf_); + + const double assimilation_ = assimilator.assimilate(environment, + height, + area_leaf_, + reuse_intervals) * + extrinsic_drivers.evaluate("growth_multiplier", time); + + const double respiration_ = respiration(mass_leaf_, mass_sapwood_, mass_bark_, mass_root_); + const double turnover_ = turnover(mass_leaf_, mass_bark_, mass_sapwood_, mass_root_, time, height, threshold); + return net_mass_production_dt_A(assimilation_, respiration_, turnover_); +} + +// [eqn 14] Total turnover +double FF16drivers_Strategy::turnover(double mass_leaf, double mass_bark, double mass_sapwood, double mass_root, double time, double height, double threshold) const { + return turnover_leaf(mass_leaf, time, height, threshold) + + turnover_bark(mass_bark) + + turnover_sapwood(mass_sapwood) + + turnover_root(mass_root); +} + +double FF16drivers_Strategy::turnover_leaf(double mass, double time, double height, double threshold) const { + double temp = (height < threshold) ? + extrinsic_drivers.evaluate("leaf_turnover_multiplier", time) : + 1.0; + + return (k_l * temp) * mass; +} + +double FF16drivers_Strategy::mortality_dt(double productivity_area, + double cumulative_mortality, + double time, double height, double threshold) const { + + // NOTE: When plants are extremely inviable, the rate of change in + // mortality can be Inf, because net production is negative, leaf + // area is small and so we get exp(big number). However, most of + // the time that happens we should get infinite mortality variable + // levels and the rate of change won't matter. It is possible that + // we will need to trim this to some large finite value, but for + // now, just checking that the actual mortality rate is finite. + if (R_FINITE(cumulative_mortality)) { + return + mortality_growth_independent_dt(time, height, threshold) + + mortality_growth_dependent_dt(productivity_area); + } else { + // If mortality probability is 1 (latency = Inf) then the rate + // calculations break. Setting them to zero gives the correct + // behaviour. + return 0.0; + } +} + +double FF16drivers_Strategy::mortality_growth_independent_dt(double time, double height, double threshold) const { + double temp; + + temp = (height < threshold) ? + extrinsic_drivers.evaluate("growth_independent_mortality_multiplier", time) : + 1.0; + + return d_I * temp; +} + +// [eqn 20] Survival of seedlings during establishment +double FF16drivers_Strategy::establishment_probability(const FF16_Environment& environment) { + + double decay_over_time = exp(-recruitment_decay * environment.time); + + const double net_mass_production_dt_ = + net_mass_production_dt(environment, height_0, area_leaf_0, environment.time); + if (net_mass_production_dt_ > 0) { + const double tmp = a_d0 * area_leaf_0 / net_mass_production_dt_; + return 1.0 / (tmp * tmp + 1.0) * decay_over_time; + } else { + return 0.0; + } +} + +void FF16drivers_Strategy::prepare_strategy() { + // Set up the integrator + assimilator.initialize(a_p1, a_p2, eta, + control.assimilator_adaptive_integration, + control.assimilator_integration_rule, + control.assimilator_integration_iterations, + control.assimilator_integration_tol); + + // NOTE: this pre-computes something to save a very small amount of time + eta_c = 1 - 2/(1 + eta) + 1/(1 + 2*eta); + // NOTE: Also pre-computing, though less trivial + height_0 = height_seed(); + area_leaf_0 = area_leaf(height_0); + + if (is_variable_birth_rate) { + extrinsic_drivers.set_variable("birth_rate", birth_rate_x, birth_rate_y); + } else { + extrinsic_drivers.set_constant("birth_rate", birth_rate_y[0]); + } + + if (is_variable_growth_rate) { + extrinsic_drivers.set_variable("growth_multiplier", growth_rate_x, growth_rate_y); + } else { + extrinsic_drivers.set_constant("growth_multiplier", growth_rate_y[0]); + } + + if (is_variable_herbivory_rate) { + extrinsic_drivers.set_variable("leaf_turnover_multiplier", herbivory_rate_x, herbivory_rate_y); + } else { + extrinsic_drivers.set_constant("leaf_turnover_multiplier", herbivory_rate_y[0]); + } + + + if (is_variable_mortality_rate) { + extrinsic_drivers.set_variable("growth_independent_mortality_multiplier", mortality_rate_x, mortality_rate_y); + } else { + extrinsic_drivers.set_constant("growth_independent_mortality_multiplier", mortality_rate_y[0]); + } +} + +FF16drivers_Strategy::ptr make_strategy_ptr(FF16drivers_Strategy s) { + s.prepare_strategy(); + return std::make_shared(s); +} +} diff --git a/tests/testthat/helper-plant.R b/tests/testthat/helper-plant.R index 1ccda3834..148aee90f 100644 --- a/tests/testthat/helper-plant.R +++ b/tests/testthat/helper-plant.R @@ -32,6 +32,7 @@ get_list_of_strategy_types <- function() { FF16=FF16_Strategy, FF16w=FF16w_Strategy, FF16r=FF16r_Strategy, + FF16drivers=FF16drivers_Strategy, K93=K93_Strategy ) } @@ -41,6 +42,7 @@ get_list_of_environment_types <- function() { FF16="FF16_Env", FF16w="FF16_Env", FF16r="FF16_Env", + FF16drivers="FF16_Env", K93="K93_Env" ) } @@ -51,6 +53,7 @@ get_list_of_hyperpar_functions <- function() { FF16=FF16_hyperpar, FF16w=FF16w_hyperpar, FF16r=FF16r_hyperpar, + FF16drivers=FF16drivers_hyperpar, K93=K93_hyperpar ) } @@ -60,6 +63,7 @@ test_environment <- function(type, ...) { FF16=FF16_test_environment(...), FF16w=FF16w_test_environment(...), FF16r=FF16_test_environment(...), + FF16drivers=FF16_test_environment(...), K93=K93_test_environment(...), stop("Unknown type ", type)) } @@ -69,6 +73,7 @@ fixed_environment<- function(type, ...) { FF16=FF16_fixed_environment(...), FF16w=FF16w_fixed_environment(...), FF16r=FF16_fixed_environment(...), + FF16drivers=FF16_fixed_environment(...), K93=K93_fixed_environment(...), stop("Unknown type ", type)) } diff --git a/tests/testthat/test-individual-utils.R b/tests/testthat/test-individual-utils.R index f5f73089b..f77f66f3e 100644 --- a/tests/testthat/test-individual-utils.R +++ b/tests/testthat/test-individual-utils.R @@ -54,7 +54,7 @@ test_that("Default schedule", { }) test_that("strategy_list", { - for (x in c("FF16", "FF16r")) { + for (x in c("FF16", "FF16r", "FF16drivers")) { e <- environment_types[[x]] p <- Parameters(x, e)() s <- strategy_list(trait_matrix(1, "lma"), p, make_hyperpar(x)(), 1.0) diff --git a/tests/testthat/test-patch.R b/tests/testthat/test-patch.R index 00e164722..4ceaed64a 100644 --- a/tests/testthat/test-patch.R +++ b/tests/testthat/test-patch.R @@ -44,7 +44,7 @@ for (x in names(strategy_types)) { expect_equal(patch$ode_size, env_size) # either 0 or numeric(0) - if(x %in% c("FF16", "FF16r", "K93")) { + if(x %in% c("FF16", "FF16r", "FF16drivers", "K93")) { expect_equal(patch$ode_state, numeric(0)) expect_equal(patch$ode_rates, numeric(0)) } diff --git a/tests/testthat/test-strategy-ff16drivers.R b/tests/testthat/test-strategy-ff16drivers.R new file mode 100644 index 000000000..10e15690a --- /dev/null +++ b/tests/testthat/test-strategy-ff16drivers.R @@ -0,0 +1,166 @@ +# Built from tests/testthat/test-strategy-ff16.R on Fri Jul 3 08:14:35 2020 using the scaffolder, from the strategy: FF16 +context("Strategy-FF16drivers") + +test_that("Defaults", { + expected <- list( + a_l2 = 0.306, + S_D = 0.25, + a_y = 0.7, + a_l1 = 5.44, + a_r1 = 0.07, + a_b1 = 0.17, + r_b = 8024 / 608, + r_l = 39.27 / 0.1978791, + r_r = 217, + r_s = 4012/608, + a_f3 = 3.0*3.8e-5, + a_bio = 0.0245, + d_I = 0.01, + a_dG1 = 5.5, + a_dG2 = 20, + a_p1 = 151.177775377968, + a_p2 = 0.204716166503633, + a_f1 = 1, + a_f2 = 2, + a_d0 = 0.1, + eta = 12, + hmat = 16.5958691, + k_b = 0.2, + k_l = 0.4565855, + k_r = 1, + k_s = 0.2, + lma = 0.1978791, + rho = 608, + omega = 3.8e-5, + theta = 1.0/4669, + k_I = 0.5, + recruitment_decay = 0, + control = Control(), + collect_all_auxiliary = FALSE, + birth_rate_x = numeric(0), # empty + birth_rate_y = c(1.0), + is_variable_birth_rate = FALSE) + + keys <- sort(names(expected)) + + s <- FF16drivers_Strategy() + expect_is(s, "FF16drivers_Strategy") + + expect_identical(sort(names(s)), keys) + expect_identical(unclass(s)[keys], expected[keys]) +}) + +test_that("FF16drivers collect_all_auxiliary option", { + + s <- FF16drivers_Strategy() + p <- FF16drivers_Individual(s) + expect_equal(p$aux_size, 2) + expect_equal(length(p$internals$auxs), 2) + expect_equal(p$aux_names, c( + "competition_effect", + "net_mass_production_dt" + )) + + s <- FF16drivers_Strategy(collect_all_auxiliary=TRUE) + expect_true(s$collect_all_auxiliary) + p <- FF16drivers_Individual(s) + expect_equal(p$aux_size, 3) + expect_equal(length(p$internals$auxs), 3) + expect_equal(p$aux_names, c( + "competition_effect", + "net_mass_production_dt", + "area_sapwood" + )) +}) + +test_that("Reference comparison", { + s <- FF16drivers_Strategy() + p <- FF16drivers_Individual(s) + + expect_identical(p$strategy, s) + + ## Set the height to something (here 10) + h0 <- 10 + p$set_state("height", h0) + + + expect_identical(p$state("height"), h0) + + ## Check: Is this redundant now + ## We now use + vars <- p$internals + expect_identical(p$state("height"), vars$states[which(p$ode_names == "height")]) +}) + + + +test_that("Critical Names", { + s <- FF16drivers_Strategy() + my_names <- FF16drivers_Individual(s)$ode_names + expect_identical(my_names[1:3], c("height", "mortality", "fecundity")) +}) +test_that("FF16drivers_Strategy hyper-parameterisation", { + s <- FF16drivers_Strategy() + + # lma + lma <- c(0.1,1) + ret <- FF16drivers_hyperpar(trait_matrix(lma, "lma"), s) + + expect_true(all(c("lma", "k_l", "r_l") %in% colnames(ret))) + expect_equal(ret[, "lma"], lma) + expect_equal(ret[, "k_l"], c(1.46678,0.028600), tolerance=1e-5) + expect_equal(ret[, "r_l"], c(392.70, 39.27), tolerance=1e-5) + + ## This happens on Linux (and therefore on travis) due to numerical + ## differences in the integration. + if ("a_p1" %in% colnames(ret)) { + a_p1 <- ret[, "a_p1"] + expect_equal(length(unique(a_p1)), 1L) + expect_equal(a_p1[[1]], s$a_p1, tolerance=1e-7) + } + + # wood density + rho <- c(200,300) + ret <- FF16drivers_hyperpar(trait_matrix(rho, "rho"), s) + expect_true(all(c("rho", "r_s", "r_b") %in% colnames(ret))) + expect_equal(ret[, "rho"], rho) + expect_equal(ret[, "r_s"], c(20.06000,13.37333), tolerance=1e-5) + expect_equal(ret[, "r_b"], 2*ret[, "r_s"]) + + ## This happens on Linux (and therefore on travis) due to numerical + ## differences in the integration. + if ("a_p1" %in% colnames(ret)) { + a_p1 <- ret[, "a_p1"] + expect_equal(length(unique(a_p1)), 1L) + expect_equal(a_p1[[1]], s$a_p1, tolerance=1e-7) + } + + # narea + narea <- c(0, 2E-3,2.3E-3) + ret <- FF16drivers_hyperpar(trait_matrix(narea, "narea"), s) + expect_true(all(c("narea", "a_p1", "a_p2", "r_l") %in% colnames(ret))) + expect_equal(ret[, "narea"], narea) + expect_equal(ret[, "r_l"], c(0, 212.2508, 244.0884), tolerance=1e-5) + expect_equal(ret[, "a_p1"], c(0, 162.2592, 188.1549), tolerance=1e-5) + expect_equal(ret[, "a_p2"], c(0, 0.220904, 0.259173), tolerance=1e-5) + + # seed mass + omega <- 3.8e-5*c(1,2,3) + ret <- FF16drivers_hyperpar(trait_matrix(omega, "omega"), s) + expect_true(all(c("omega", "a_f3") %in% colnames(ret))) + expect_equal(ret[, "omega"], omega) + expect_equal(ret[, "a_f3"], 3*omega) + + ## This happens on Linux (and therefore on travis) due to numerical + ## differences in the integration. + if ("a_p1" %in% colnames(ret)) { + a_p1 <- ret[, "a_p1"] + expect_equal(length(unique(a_p1)), 1L) + expect_equal(a_p1[[1]], s$a_p1, tolerance=1e-7) + } + + ## Empty trait matrix: + ret <- FF16drivers_hyperpar(trait_matrix(numeric(0), "lma"), s) + expect_equal(ret, trait_matrix(numeric(0), "lma")) +}) +