R/odin.R

In clockSim: Streamlined Simulation of Circadian Gene Networks

## Automatically generated by odin 1.2.7 - do not edit
deriv_leloup_goldbeter_ <- R6::R6Class(
  "odin_model",
  cloneable = FALSE,

  private = list(
    ptr = NULL,
    use_dde = NULL,

    odin = NULL,
    variable_order = NULL,
    output_order = NULL,
    n_out = NULL,
    ynames = NULL,
    interpolate_t = NULL,
    cfuns = list(
      rhs_dde = "deriv_leloup_goldbeter_rhs_dde",
      rhs_desolve = "deriv_leloup_goldbeter_rhs_desolve",
      initmod_desolve = "deriv_leloup_goldbeter_initmod_desolve"),
    dll = "clockSim",
    user = c("k_1", "k_2", "k_3", "k_4", "k_d", "K_dP", "K_dT", "K_IP",
             "K_IT", "K_mP", "K_mT", "K_p", "k_sP", "k_sT", "LD_HOURS", "n",
             "setUserInitial_C", "setUserInitial_C_N", "setUserInitial_M_P",
             "setUserInitial_M_T", "setUserInitial_P_0",
             "setUserInitial_P_1", "setUserInitial_P_2",
             "setUserInitial_T_0", "setUserInitial_T_1",
             "setUserInitial_T_2", "V_1P", "V_1T", "V_2P", "V_2T", "V_3P",
             "V_3T", "V_4P", "V_4T", "V_dP", "V_mP", "V_mT", "V_sP", "V_sT",
             "VdT_OFF", "VdT_ON"),

    ## This is never called, but is used to ensure that R finds our
    ## symbols that we will use from the package; without this they
    ## cannot be found by dynamic lookup now that we use the package
    ## FFI registration system.
    registration = function() {
      if (FALSE) {
        .C("deriv_leloup_goldbeter_rhs_dde", package = "clockSim")
        .C("deriv_leloup_goldbeter_rhs_desolve", package = "clockSim")
        .C("deriv_leloup_goldbeter_initmod_desolve", package = "clockSim")
      }
    },

    ## This only does something in delay models
    set_initial = function(t, y, use_dde) {
      .Call("deriv_leloup_goldbeter_set_initial", private$ptr, t, y, use_dde,
            PACKAGE= "clockSim")
    },

    update_metadata = function() {
      meta <- .Call("deriv_leloup_goldbeter_metadata", private$ptr,
                    PACKAGE = "clockSim")
      private$variable_order <- meta$variable_order
      private$output_order <- meta$output_order
      private$n_out <- meta$n_out
      private$ynames <- private$odin$make_names(
        private$variable_order, private$output_order, FALSE)
      private$interpolate_t <- meta$interpolate_t
    }
  ),

  public = list(
    initialize = function(..., user = list(...), use_dde = FALSE,
                          unused_user_action = NULL) {
      private$odin <- asNamespace("odin")
      private$ptr <- .Call("deriv_leloup_goldbeter_create", user, PACKAGE = "clockSim")
      self$set_user(user = user, unused_user_action = unused_user_action)
      private$use_dde <- use_dde
      private$update_metadata()
    },

    ir = function() {
      path_ir <- system.file("odin/deriv_leloup_goldbeter.json", mustWork = TRUE,
                             package = "clockSim")
      json <- readLines(path_ir)
      class(json) <- "json"
      json
    },

    ## Do we need to have the user-settable args here? It would be
    ## nice, but that's not super straightforward to do.
    set_user = function(..., user = list(...), unused_user_action = NULL) {
      private$odin$support_check_user(user, private$user, unused_user_action)
      .Call("deriv_leloup_goldbeter_set_user", private$ptr, user, PACKAGE = "clockSim")
      private$update_metadata()
    },

    ## This might be time sensitive and, so we can avoid computing
    ## it. I wonder if that's an optimisation we should drop for now
    ## as it does not seem generally useful. This would bring us
    ## closer to the js version which requires that we always pass the
    ## time in.
    initial = function(t) {
      .Call("deriv_leloup_goldbeter_initial_conditions", private$ptr, t, PACKAGE = "clockSim")
    },

    rhs = function(t, y) {
      .Call("deriv_leloup_goldbeter_rhs_r", private$ptr, t, y, PACKAGE = "clockSim")
    },

    deriv = function(t, y) {
      self$rhs(t, y)
    },

    contents = function() {
      .Call("deriv_leloup_goldbeter_contents", private$ptr, PACKAGE = "clockSim")
    },

    transform_variables = function(y) {
      private$odin$support_transform_variables(y, private)
    },

    run = function(t, y = NULL, ..., use_names = TRUE) {
      private$odin$wrapper_run_ode(
        self, private, t, y, ..., use_names = use_names)
    }
  ))


deriv_leloup_goldbeter <- function(..., user = list(...), use_dde = FALSE,
                     unused_user_action = NULL) {
  asNamespace("odin")$deprecated_constructor_call("deriv_leloup_goldbeter")
  deriv_leloup_goldbeter_$new(user = user, use_dde = use_dde,
                unused_user_action = unused_user_action)
}
class(deriv_leloup_goldbeter) <- "odin_generator"
attr(deriv_leloup_goldbeter, "generator") <- deriv_leloup_goldbeter_
discrete_leloup_goldbeter_ <- R6::R6Class(
  "odin_model",
  cloneable = FALSE,

  private = list(
    ptr = NULL,
    use_dde = NULL,

    odin = NULL,
    variable_order = NULL,
    output_order = NULL,
    n_out = NULL,
    ynames = NULL,
    interpolate_t = NULL,
    cfuns = list(
      rhs_dde = "discrete_leloup_goldbeter_rhs_dde"),
    dll = "clockSim",
    user = c("k_1", "k_2", "k_3", "k_4", "k_d", "K_dP", "K_dT", "K_IP",
             "K_IT", "K_mP", "K_mT", "K_p", "k_sP", "k_sT", "LD_HOURS", "n",
             "setUserInitial_C", "setUserInitial_C_N", "setUserInitial_M_P",
             "setUserInitial_M_T", "setUserInitial_P_0",
             "setUserInitial_P_1", "setUserInitial_P_2",
             "setUserInitial_T_0", "setUserInitial_T_1",
             "setUserInitial_T_2", "STEP_HOURS", "V_1P", "V_1T", "V_2P",
             "V_2T", "V_3P", "V_3T", "V_4P", "V_4T", "V_dP", "V_mP", "V_mT",
             "V_sP", "V_sT", "VdT_OFF", "VdT_ON"),

    ## This is never called, but is used to ensure that R finds our
    ## symbols that we will use from the package; without this they
    ## cannot be found by dynamic lookup now that we use the package
    ## FFI registration system.
    registration = function() {
      if (FALSE) {
        .C("discrete_leloup_goldbeter_rhs_dde", package = "clockSim")
      }
    },

    ## This only does something in delay models
    set_initial = function(step, y, use_dde) {
      .Call("discrete_leloup_goldbeter_set_initial", private$ptr, step, y, use_dde,
            PACKAGE= "clockSim")
    },

    update_metadata = function() {
      meta <- .Call("discrete_leloup_goldbeter_metadata", private$ptr,
                    PACKAGE = "clockSim")
      private$variable_order <- meta$variable_order
      private$output_order <- meta$output_order
      private$n_out <- meta$n_out
      private$ynames <- private$odin$make_names(
        private$variable_order, private$output_order, TRUE)
      private$interpolate_t <- meta$interpolate_t
    }
  ),

  public = list(
    initialize = function(..., user = list(...), use_dde = FALSE,
                          unused_user_action = NULL) {
      private$odin <- asNamespace("odin")
      private$ptr <- .Call("discrete_leloup_goldbeter_create", user, PACKAGE = "clockSim")
      self$set_user(user = user, unused_user_action = unused_user_action)
      private$use_dde <- use_dde
      private$update_metadata()
    },

    ir = function() {
      path_ir <- system.file("odin/discrete_leloup_goldbeter.json", mustWork = TRUE,
                             package = "clockSim")
      json <- readLines(path_ir)
      class(json) <- "json"
      json
    },

    ## Do we need to have the user-settable args here? It would be
    ## nice, but that's not super straightforward to do.
    set_user = function(..., user = list(...), unused_user_action = NULL) {
      private$odin$support_check_user(user, private$user, unused_user_action)
      .Call("discrete_leloup_goldbeter_set_user", private$ptr, user, PACKAGE = "clockSim")
      private$update_metadata()
    },

    ## This might be time sensitive and, so we can avoid computing
    ## it. I wonder if that's an optimisation we should drop for now
    ## as it does not seem generally useful. This would bring us
    ## closer to the js version which requires that we always pass the
    ## time in.
    initial = function(step) {
      .Call("discrete_leloup_goldbeter_initial_conditions", private$ptr, step, PACKAGE = "clockSim")
    },

    rhs = function(step, y) {
      .Call("discrete_leloup_goldbeter_rhs_r", private$ptr, step, y, PACKAGE = "clockSim")
    },

    update = function(step, y) {
      self$rhs(step, y)
    },

    contents = function() {
      .Call("discrete_leloup_goldbeter_contents", private$ptr, PACKAGE = "clockSim")
    },

    transform_variables = function(y) {
      private$odin$support_transform_variables(y, private)
    },

    run = function(step, y = NULL, ..., use_names = TRUE) {
      private$odin$wrapper_run_discrete(
        self, private, step, y, ..., use_names = use_names)
    }
  ))


discrete_leloup_goldbeter <- function(..., user = list(...), use_dde = FALSE,
                     unused_user_action = NULL) {
  asNamespace("odin")$deprecated_constructor_call("discrete_leloup_goldbeter")
  discrete_leloup_goldbeter_$new(user = user, use_dde = use_dde,
                unused_user_action = unused_user_action)
}
class(discrete_leloup_goldbeter) <- "odin_generator"
attr(discrete_leloup_goldbeter, "generator") <- discrete_leloup_goldbeter_
discreteNoisy_leloup_goldbeter_ <- R6::R6Class(
  "odin_model",
  cloneable = FALSE,

  private = list(
    ptr = NULL,
    use_dde = NULL,

    odin = NULL,
    variable_order = NULL,
    output_order = NULL,
    n_out = NULL,
    ynames = NULL,
    interpolate_t = NULL,
    cfuns = list(
      rhs_dde = "discreteNoisy_leloup_goldbeter_rhs_dde"),
    dll = "clockSim",
    user = c("k_1", "k_2", "k_3_conc", "k_4", "k_d", "K_dP_conc",
             "K_dT_conc", "K_IP_conc", "K_IT_conc", "K_mP_conc", "K_mT_conc",
             "K_p_conc", "k_sP", "k_sT", "LD_HOURS", "n", "NoiseVariance_C",
             "NoiseVariance_C_N", "NoiseVariance_M_P", "NoiseVariance_M_T",
             "NoiseVariance_P_0", "NoiseVariance_P_1", "NoiseVariance_P_2",
             "NoiseVariance_T_0", "NoiseVariance_T_1", "NoiseVariance_T_2",
             "setUserInitial_C", "setUserInitial_C_N", "setUserInitial_M_P",
             "setUserInitial_M_T", "setUserInitial_P_0",
             "setUserInitial_P_1", "setUserInitial_P_2",
             "setUserInitial_T_0", "setUserInitial_T_1",
             "setUserInitial_T_2", "STEP_HOURS", "V_1P_conc", "V_1T_conc",
             "V_2P_conc", "V_2T_conc", "V_3P_conc", "V_3T_conc", "V_4P_conc",
             "V_4T_conc", "V_dP_conc", "V_mP_conc", "V_mT_conc", "V_sP_conc",
             "V_sT_conc", "VdT_OFF_conc", "VdT_ON_conc"),

    ## This is never called, but is used to ensure that R finds our
    ## symbols that we will use from the package; without this they
    ## cannot be found by dynamic lookup now that we use the package
    ## FFI registration system.
    registration = function() {
      if (FALSE) {
        .C("discreteNoisy_leloup_goldbeter_rhs_dde", package = "clockSim")
      }
    },

    ## This only does something in delay models
    set_initial = function(step, y, use_dde) {
      .Call("discreteNoisy_leloup_goldbeter_set_initial", private$ptr, step, y, use_dde,
            PACKAGE= "clockSim")
    },

    update_metadata = function() {
      meta <- .Call("discreteNoisy_leloup_goldbeter_metadata", private$ptr,
                    PACKAGE = "clockSim")
      private$variable_order <- meta$variable_order
      private$output_order <- meta$output_order
      private$n_out <- meta$n_out
      private$ynames <- private$odin$make_names(
        private$variable_order, private$output_order, TRUE)
      private$interpolate_t <- meta$interpolate_t
    }
  ),

  public = list(
    initialize = function(..., user = list(...), use_dde = FALSE,
                          unused_user_action = NULL) {
      private$odin <- asNamespace("odin")
      private$ptr <- .Call("discreteNoisy_leloup_goldbeter_create", user, PACKAGE = "clockSim")
      self$set_user(user = user, unused_user_action = unused_user_action)
      private$use_dde <- use_dde
      private$update_metadata()
    },

    ir = function() {
      path_ir <- system.file("odin/discreteNoisy_leloup_goldbeter.json", mustWork = TRUE,
                             package = "clockSim")
      json <- readLines(path_ir)
      class(json) <- "json"
      json
    },

    ## Do we need to have the user-settable args here? It would be
    ## nice, but that's not super straightforward to do.
    set_user = function(..., user = list(...), unused_user_action = NULL) {
      private$odin$support_check_user(user, private$user, unused_user_action)
      .Call("discreteNoisy_leloup_goldbeter_set_user", private$ptr, user, PACKAGE = "clockSim")
      private$update_metadata()
    },

    ## This might be time sensitive and, so we can avoid computing
    ## it. I wonder if that's an optimisation we should drop for now
    ## as it does not seem generally useful. This would bring us
    ## closer to the js version which requires that we always pass the
    ## time in.
    initial = function(step) {
      .Call("discreteNoisy_leloup_goldbeter_initial_conditions", private$ptr, step, PACKAGE = "clockSim")
    },

    rhs = function(step, y) {
      .Call("discreteNoisy_leloup_goldbeter_rhs_r", private$ptr, step, y, PACKAGE = "clockSim")
    },

    update = function(step, y) {
      self$rhs(step, y)
    },

    contents = function() {
      .Call("discreteNoisy_leloup_goldbeter_contents", private$ptr, PACKAGE = "clockSim")
    },

    transform_variables = function(y) {
      private$odin$support_transform_variables(y, private)
    },

    run = function(step, y = NULL, ..., use_names = TRUE) {
      private$odin$wrapper_run_discrete(
        self, private, step, y, ..., use_names = use_names)
    }
  ))


discreteNoisy_leloup_goldbeter <- function(..., user = list(...), use_dde = FALSE,
                     unused_user_action = NULL) {
  asNamespace("odin")$deprecated_constructor_call("discreteNoisy_leloup_goldbeter")
  discreteNoisy_leloup_goldbeter_$new(user = user, use_dde = use_dde,
                unused_user_action = unused_user_action)
}
class(discreteNoisy_leloup_goldbeter) <- "odin_generator"
attr(discreteNoisy_leloup_goldbeter, "generator") <- discreteNoisy_leloup_goldbeter_