Datasets:

introvoyz045
/

CoRC

#' Run optimization
#'
#' \code{runOptimization} runs optimization and returns the results in a list.
#' 
#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
#'
#' @param expression Expression to optimize, as string.
#' @param maximize flag
#' @eval paste0("@param subtask string
#' 
#' Available tasks: ", rox_print_v(task_enum), ".")
#' @param randomize_start_values flag
#' @param calculate_statistics flag
#' @param update_model flag
#' @param executable flag
#' @param parameters corc_opt_parm or list of corc_opt_parm objects
#' 
#' See also \code{\link{defineOptimizationParameter}}.
#' @eval rox_method_param("Optimization", "_p_COptTask")
#' @param model A model object.
#' @return A list of results.
#' @family optimization
#' @export
runOptimization <- function(expression = NULL, maximize = NULL, subtask = NULL, randomize_start_values = NULL, calculate_statistics = NULL, update_model = NULL, executable = NULL, parameters = NULL, method = NULL, model = getCurrentModel()) {
  c_datamodel <- assert_datamodel(model)
  
  # does assertions
  settings <- opt_assemble_settings(
    expression             = expression,
    maximize               = maximize,
    subtask                = subtask,
    randomize_start_values = randomize_start_values,
    calculate_statistics   = calculate_statistics,
    update_model           = update_model,
    executable             = executable
  )
  
  c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
  
  # does assertions
  method_settings <- opt_assemble_method(method, c_task)
  
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  # does assertions
  parameter_list <- opt_assemble_parameters(parameters, c_problem)

  # try to avoid doing changes for performance reasons
  do_settings <- !is_empty(settings)
  do_method <- !is_empty(method_settings)
  do_parameters <- !is_empty(parameter_list)
  
  c_model <- c_datamodel$getModel()
  
  tryCatch({
    # save all previous settings
    if (do_settings)
      pre_settings <- opt_get_settings(c_task)
    if (do_method) {
      # keep track of the originally set method
      pre_method <- c_task$getMethod()$getSubType()
      # change the method first, then save the settings for the new method
      if (!is.null(method_settings$method))
        c_task$setMethodType(method_settings$method)
      c_method <- as(c_task$getMethod(), "_p_COptMethod")
      pre_method_settings <- get_method_settings(c_method, with_name = TRUE)
    } else {
      c_method <- as(c_task$getMethod(), "_p_COptMethod")
    }
    
    # apply settings
    if (do_settings)
      opt_set_settings(settings, c_task)
    if (do_method)
      set_method_settings(method_settings, c_method)
    if (do_parameters)
      addOptimizationParameter(parameter_list, model = c_datamodel)
    
    compile_and_check(c_model)
    
    # initialize task
    assert_that(
      grab_msg(c_task$initializeRaw(OUTPUTFLAG)),
      msg = "Initializing the task failed."
    )
    
    # save current settings
    full_settings <- opt_get_settings(c_task)
    full_settings$method <- get_method_settings(c_method, with_name = TRUE)
    
    # run task
    process_task(c_task)
    
    # get results
    ret <- opt_get_results(c_task, full_settings)
  },
  finally = {
    # revert all settings
    if (do_settings)
      opt_set_settings(pre_settings, c_task)
    if (do_method) {
      set_method_settings(pre_method_settings, c_method)
      c_task$setMethodType(pre_method)
    }
    if (do_parameters)
      clearOptimizationParameters()
  })
  
  ret
}

#' Set optimization settings
#'
#' \code{setOptimizationSettings} sets optimization task settings including parameters, experiments and method options.
#'
#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
#'
#' @param expression Expression to optimize, as string.
#' @param maximize flag
#' @eval paste0("@param subtask string
#' 
#' Available tasks: ", rox_print_v(task_enum), ".")
#' @param randomize_start_values flag
#' @param calculate_statistics flag
#' @param update_model flag
#' @param executable flag
#' @param parameters corc_opt_parm or list of corc_opt_parm objects
#' 
#' See also \code{\link{defineOptimizationParameter}}.
#' @eval rox_method_param("Optimization", "_p_COptTask")
#' @param model a model object
#' @family optimization
#' @export
setOptimizationSettings <- function(expression = NULL, maximize = NULL, subtask = NULL, randomize_start_values = NULL, calculate_statistics = NULL, update_model = NULL, executable = NULL, parameters = NULL, method = NULL, model = getCurrentModel()) {
  c_datamodel <- assert_datamodel(model)
  
  # does assertions
  settings <- opt_assemble_settings(
    expression             = expression,
    maximize               = maximize,
    subtask                = subtask,
    randomize_start_values = randomize_start_values,
    calculate_statistics   = calculate_statistics,
    update_model           = update_model,
    executable             = executable
  )
  
  c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
  
  # does assertions
  method_settings <- opt_assemble_method(method, c_task)
  
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  # does assertions
  parameter_list <- opt_assemble_parameters(parameters, c_problem)

  # parameters get rolled back when not setting them properly
  tryCatch(
    addOptimizationParameter(parameter_list, model = c_datamodel),
    error = function(e) {
      clearOptimizationParameters(c_datamodel)
      base::stop(e)
      # stop("Failed when applying parameters.")
    }
  )

  # switch to given method
  if (!is.null(method_settings$method))
    c_task$setMethodType(method_settings$method)
  
  c_method <- as(c_task$getMethod(), "_p_COptMethod")
  
  opt_set_settings(settings, c_task)
  set_method_settings(method_settings, c_method)
  
  invisible()
}

#' Set optimization settings
#'
#' \code{getOptimizationSettings} gets optimization task settings including method options.
#'
#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
#'
#' @param model a model object
#' @return A list of parameter estimation task settings including method options.
#' @family optimization
#' @export
getOptimizationSettings <- function(model = getCurrentModel()) {
  c_datamodel <- assert_datamodel(model)
  c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
  c_method <- as(c_task$getMethod(), "_p_COptMethod")
  
  ret <- opt_get_settings(c_task)
  ret$method <- get_method_settings(c_method, with_name = TRUE)
  
  ret
}

#' @rdname runOptimization
#' @export
runOpt <- runOptimization
#' @rdname setOptimizationSettings
#' @export
setOpt<- setOptimizationSettings
#' @rdname getOptimizationSettings
#' @export
getOpt <- getOptimizationSettings

new_corc_opt_parm <- function(x, start, lower, upper) {
  ret <- structure(
    list(
      ref   = x,
      start = start,
      lower = lower,
      upper = upper
    ),
    class = "corc_opt_parm"
  )
  
  validate_corc_opt_parm(ret)
  
  ret
}

#' @export
validate_corc_opt_parm <- function(x) {
  assert_that(
    all(hasName(x, c("ref", "start", "lower", "upper"))),
    is.string(x$ref),   noNA(x$ref),
    is.number(x$start), noNA(x$start),
    is.number(x$lower), noNA(x$lower),
    is.number(x$upper), noNA(x$upper),
    x$start < Inf,
    x$start > -Inf,
    x$lower <= x$start,
    x$start <= x$upper
  )
}

#' @export
is.corc_opt_parm <- function(x) {
  inherits(x, "corc_opt_parm")
}

#' @export
corc_opt_parm <- function(ref, start_value = (lower_bound + upper_bound) / 2, lower_bound = 1e-6, upper_bound = 1e6) {
  new_corc_opt_parm(
    ref,
    start = start_value,
    lower = lower_bound,
    upper = upper_bound
  )
}

#' Define an optimization parameter
#' 
#' @param ref value reference
#' @param start_value start value
#' @param lower_bound lower value bound
#' @param upper_bound upper value bound
#' @return corc_opt_parm object for input into related functions
#' @seealso \code{\link{addOptimizationParameter}} \code{\link{clearOptimizationParameters}}
#' @family optimization
#' @export
defineOptimizationParameter <- corc_opt_parm

#' Add an optimization parameter
#' 
#' @param ... objects as returned by \code{\link{defineOptimizationParameter}}.
#' Alternatively, the same parameters as used by \code{\link{defineOptimizationParameter}}.
#' @param model a model object
#' @seealso \code{\link{defineOptimizationParameter}} \code{\link{clearOptimizationParameters}}
#' @family optimization
#' @export
addOptimizationParameter <- function(..., model = getCurrentModel()) {
  c_datamodel <- assert_datamodel(model)
  
  # flatten all args into a single list
  # this list can be used to check if the user gave only corc_opt_parm
  arglist_compact <- rlang::squash(unname(list(...)))
  
  # if not all are corc_opt_parm, try handing the args to define... so we get corc_opt_parm
  if (!every(arglist_compact, is.corc_opt_parm))
    arglist_compact <- list(defineOptimizationParameter(...))
  
  walk(arglist_compact, validate_corc_opt_parm)
  
  cl_obj <-
    arglist_compact %>% 
    map_chr("ref") %>%
    map(xn_to_object, c_datamodel = c_datamodel)
  
  # Test if all refs are valid
  # This can probably be a more elaborate and safe test (by using dn_to_object(accepted_types))
  invalid_refs <- map_lgl(cl_obj, is.null)
  assert_that(
    !any(invalid_refs),
    msg = paste0("Given reference(s) ", paste0(which(invalid_refs), collapse = ", "), " are invalid for this model.")
  )
  
  c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  walk2(
    arglist_compact, cl_obj,
    ~ {
      c_optitem <- c_problem$addOptItem(.y$getCN())
      c_optitem$setStartValue(.x$start)
      c_optitem$setLowerBound(CCommonName(tolower(as.character(.x$lower))))
      c_optitem$setUpperBound(CCommonName(tolower(as.character(.x$upper))))
    }
  )
  
  invisible()
}

#' Clear all optimization parameters
#' 
#' @param model a model object
#' @seealso \code{\link{addOptimizationParameter}} \code{\link{defineOptimizationParameter}}
#' @family optimization
#' @export
clearOptimizationParameters <- function(model = getCurrentModel()) {
  c_datamodel <- assert_datamodel(model)
  
  c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  walk(
    seq_len_0(c_problem$getOptItemSize()),
    ~ c_problem$removeOptItem(0L)
  )
}

opt_assemble_parameters <- function(parameters, c_problem) {
  assert_that(is.null(parameters) || is.list(parameters) && every(parameters, is.corc_opt_parm) || is.corc_opt_parm(parameters))
  
  if (is.corc_opt_parm(parameters))
    parameters <- list(parameters)
  
  if (is_empty(parameters))
    return(list())
  
  assert_that(
    c_problem$getOptItemSize() == 0L,
    msg = "This function can not set parameters if there are already parameters set in COPASI."
  )
  
  walk(parameters, validate_corc_opt_parm)
  
  parameters
}

# The following functions should be the basis for implementation of any task
# They should allow for a common workflow with most tasks

# does assertions
# returns a list of settings
opt_assemble_settings <- function(expression, maximize, subtask, randomize_start_values, calculate_statistics, update_model, executable) {
  assert_that(
    is.null(expression)             || is.scalar(expression)           && is.cexpression(expression) && noNA(expression),
    is.null(maximize)               || is.flag(maximize)               && noNA(maximize),
    is.null(subtask)                || is.string(subtask),
    is.null(randomize_start_values) || is.flag(randomize_start_values) && noNA(randomize_start_values),
    is.null(calculate_statistics)   || is.flag(calculate_statistics)   && noNA(calculate_statistics),
    is.null(update_model)           || is.flag(update_model)           && noNA(update_model),
    is.null(executable)             || is.flag(executable)             && noNA(executable)
  )
  
  if (!is.null(subtask)) {
    subtask <- rlang::arg_match(subtask, task_enum)
  }
  
  if (!is.null(expression))
    expression <- to_cexpr(expression)
  
  list(
    expression             = expression,
    maximize               = maximize,
    subtask                = subtask,
    randomize_start_values = randomize_start_values,
    calculate_statistics   = calculate_statistics,
    update_model           = update_model,
    executable             = executable
  ) %>%
    discard(is.null)
}

# does assertions
# returns a list of method settings
opt_assemble_method <- function(method, c_task) {
  if (is.null(method))
    return(list())
  
  assert_that(
    is.string(method) || is.list(method) && (is_empty(method) || !is.null(names(method))),
    msg = "method must be a string (a length one character vector) or a named list."
  )
  
  if (is_scalar_character(method))
    method <- list(method = method)
  
  if (hasName(method, "method")) {
    valid_methods <- names(.__E___CTaskEnum__Method)[c_task$getValidMethods() + 1L]
    # hack to get nice error message if method string is not accepted.
    method$method <- args_match(method$method, name = "method", valid_methods)
  }
  
  method
}

# gets full list of settings
opt_get_settings <- function(c_task) {
  c_datamodel <- c_task$getObjectDataModel()
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  list(
    expression             = read_expr(c_problem$getObjectiveFunction(), c_datamodel),
    maximize               = as.logical(c_problem$maximize()),
    subtask                = c_problem$getSubtaskType(),
    randomize_start_values = as.logical(c_problem$getRandomizeStartValues()),
    calculate_statistics   = as.logical(c_problem$getCalculateStatistics()),
    update_model           = as.logical(c_task$isUpdateModel()),
    executable             = as.logical(c_task$isScheduled())
  )
}

# sets all settings given in list
opt_set_settings <- function(data, c_task) {
  if (is_empty(data))
    return()
  
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  
  if (!is.null(data$expression)) {
    c_datamodel <- c_task$getObjectDataModel()
    assert_that(
      grab_msg(c_problem$setObjectiveFunction(write_expr(data$expression, c_datamodel))),
      msg = "Error when setting optimization expression."
    )
  }
  
  if (!is.null(data$maximize))
    c_problem$setMaximize(data$maximize)
  
  if (!is.null(data$subtask))
    c_problem$setSubtaskType(data$subtask)
  
  if (!is.null(data$randomize_start_values))
    c_problem$setRandomizeStartValues(data$randomize_start_values)
  
  if (!is.null(data$calculate_statistics))
    c_problem$setCalculateStatistics(data$calculate_statistics)
  
  if (!is.null(data$update_model))
    c_task$setUpdateModel(data$update_model)
  
  if (!is.null(data$executable))
    c_task$setScheduled(data$executable)
}

# gathers all results
opt_get_results <- function(c_task, settings) {
  c_problem <- as(c_task$getProblem(), "_p_COptProblem")
  c_method <- as(c_task$getMethod(), "_p_COptMethod")
  
  cl_items <- get_sv(c_problem$getOptItemList()) %>% map(as, Class = "_p_COptItem")
  
  evals <- c_problem$getFunctionEvaluations()
  evaltime <- c_problem$getExecutionTime()
  
  main <-
    list(
      "Objective Value"          = c_problem$getSolutionValue(),
      "Function Evaluations"     = evals,
      "CPU Time [s]"             = evaltime,
      "Evaluations/second [1/s]" = evals / evaltime
    ) %>%
    transform_names()
  
  parameters <-
    tibble::tibble(
      "Parameter"   = get_key(cl_items),
      "Lower Bound" = map_swig_dbl(cl_items, "getLowerBoundValue"),
      "Start Value" = map_swig_dbl(cl_items, "getStartValue"),
      "Value"       = get_cv(c_problem$getSolutionVariables()),
      "Upper Bound" = map_swig_dbl(cl_items, "getUpperBoundValue"),
      "Gradient"    = get_cv(c_problem$getVariableGradients()),
      .rows = length(cl_items),
      .name_repair = transform_names_worker
    )
  
  protocol <- c_method$getMethodLog()$getPlainLog()
  
  list(
    settings   = settings,
    main       = main,
    parameters = parameters,
    protocol   = protocol
  )
}

	#' Run optimization
	#'
	#' \code{runOptimization} runs optimization and returns the results in a list.
	#'
	#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
	#'
	#' @param expression Expression to optimize, as string.
	#' @param maximize flag
	#' @eval paste0("@param subtask string
	#'
	#' Available tasks: ", rox_print_v(task_enum), ".")
	#' @param randomize_start_values flag
	#' @param calculate_statistics flag
	#' @param update_model flag
	#' @param executable flag
	#' @param parameters corc_opt_parm or list of corc_opt_parm objects
	#'
	#' See also \code{\link{defineOptimizationParameter}}.
	#' @eval rox_method_param("Optimization", "_p_COptTask")
	#' @param model A model object.
	#' @return A list of results.
	#' @family optimization
	#' @export
	runOptimization <- function(expression = NULL, maximize = NULL, subtask = NULL, randomize_start_values = NULL, calculate_statistics = NULL, update_model = NULL, executable = NULL, parameters = NULL, method = NULL, model = getCurrentModel()) {
	c_datamodel <- assert_datamodel(model)

	# does assertions
	settings <- opt_assemble_settings(
	expression = expression,
	maximize = maximize,
	subtask = subtask,
	randomize_start_values = randomize_start_values,
	calculate_statistics = calculate_statistics,
	update_model = update_model,
	executable = executable
	)

	c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")

	# does assertions
	method_settings <- opt_assemble_method(method, c_task)

	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	# does assertions
	parameter_list <- opt_assemble_parameters(parameters, c_problem)

	# try to avoid doing changes for performance reasons
	do_settings <- !is_empty(settings)
	do_method <- !is_empty(method_settings)
	do_parameters <- !is_empty(parameter_list)

	c_model <- c_datamodel$getModel()

	tryCatch({
	# save all previous settings
	if (do_settings)
	pre_settings <- opt_get_settings(c_task)
	if (do_method) {
	# keep track of the originally set method
	pre_method <- c_task$getMethod()$getSubType()
	# change the method first, then save the settings for the new method
	if (!is.null(method_settings$method))
	c_task$setMethodType(method_settings$method)
	c_method <- as(c_task$getMethod(), "_p_COptMethod")
	pre_method_settings <- get_method_settings(c_method, with_name = TRUE)
	} else {
	c_method <- as(c_task$getMethod(), "_p_COptMethod")
	}

	# apply settings
	if (do_settings)
	opt_set_settings(settings, c_task)
	if (do_method)
	set_method_settings(method_settings, c_method)
	if (do_parameters)
	addOptimizationParameter(parameter_list, model = c_datamodel)

	compile_and_check(c_model)

	# initialize task
	assert_that(
	grab_msg(c_task$initializeRaw(OUTPUTFLAG)),
	msg = "Initializing the task failed."
	)

	# save current settings
	full_settings <- opt_get_settings(c_task)
	full_settings$method <- get_method_settings(c_method, with_name = TRUE)

	# run task
	process_task(c_task)

	# get results
	ret <- opt_get_results(c_task, full_settings)
	},
	finally = {
	# revert all settings
	if (do_settings)
	opt_set_settings(pre_settings, c_task)
	if (do_method) {
	set_method_settings(pre_method_settings, c_method)
	c_task$setMethodType(pre_method)
	}
	if (do_parameters)
	clearOptimizationParameters()
	})

	ret
	}

	#' Set optimization settings
	#'
	#' \code{setOptimizationSettings} sets optimization task settings including parameters, experiments and method options.
	#'
	#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
	#'
	#' @param expression Expression to optimize, as string.
	#' @param maximize flag
	#' @eval paste0("@param subtask string
	#'
	#' Available tasks: ", rox_print_v(task_enum), ".")
	#' @param randomize_start_values flag
	#' @param calculate_statistics flag
	#' @param update_model flag
	#' @param executable flag
	#' @param parameters corc_opt_parm or list of corc_opt_parm objects
	#'
	#' See also \code{\link{defineOptimizationParameter}}.
	#' @eval rox_method_param("Optimization", "_p_COptTask")
	#' @param model a model object
	#' @family optimization
	#' @export
	setOptimizationSettings <- function(expression = NULL, maximize = NULL, subtask = NULL, randomize_start_values = NULL, calculate_statistics = NULL, update_model = NULL, executable = NULL, parameters = NULL, method = NULL, model = getCurrentModel()) {
	c_datamodel <- assert_datamodel(model)

	# does assertions
	settings <- opt_assemble_settings(
	expression = expression,
	maximize = maximize,
	subtask = subtask,
	randomize_start_values = randomize_start_values,
	calculate_statistics = calculate_statistics,
	update_model = update_model,
	executable = executable
	)

	c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")

	# does assertions
	method_settings <- opt_assemble_method(method, c_task)

	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	# does assertions
	parameter_list <- opt_assemble_parameters(parameters, c_problem)

	# parameters get rolled back when not setting them properly
	tryCatch(
	addOptimizationParameter(parameter_list, model = c_datamodel),
	error = function(e) {
	clearOptimizationParameters(c_datamodel)
	base::stop(e)
	# stop("Failed when applying parameters.")
	}
	)

	# switch to given method
	if (!is.null(method_settings$method))
	c_task$setMethodType(method_settings$method)

	c_method <- as(c_task$getMethod(), "_p_COptMethod")

	opt_set_settings(settings, c_task)
	set_method_settings(method_settings, c_method)

	invisible()
	}

	#' Set optimization settings
	#'
	#' \code{getOptimizationSettings} gets optimization task settings including method options.
	#'
	#' The \href{https://jpahle.github.io/CoRC/articles/task_management.html}{online article on managing tasks} provides some further context.
	#'
	#' @param model a model object
	#' @return A list of parameter estimation task settings including method options.
	#' @family optimization
	#' @export
	getOptimizationSettings <- function(model = getCurrentModel()) {
	c_datamodel <- assert_datamodel(model)
	c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
	c_method <- as(c_task$getMethod(), "_p_COptMethod")

	ret <- opt_get_settings(c_task)
	ret$method <- get_method_settings(c_method, with_name = TRUE)

	ret
	}

	#' @rdname runOptimization
	#' @export
	runOpt <- runOptimization
	#' @rdname setOptimizationSettings
	#' @export
	setOpt<- setOptimizationSettings
	#' @rdname getOptimizationSettings
	#' @export
	getOpt <- getOptimizationSettings

	new_corc_opt_parm <- function(x, start, lower, upper) {
	ret <- structure(
	list(
	ref = x,
	start = start,
	lower = lower,
	upper = upper
	),
	class = "corc_opt_parm"
	)

	validate_corc_opt_parm(ret)

	ret
	}

	#' @export
	validate_corc_opt_parm <- function(x) {
	assert_that(
	all(hasName(x, c("ref", "start", "lower", "upper"))),
	is.string(x$ref), noNA(x$ref),
	is.number(x$start), noNA(x$start),
	is.number(x$lower), noNA(x$lower),
	is.number(x$upper), noNA(x$upper),
	x$start < Inf,
	x$start > -Inf,
	x$lower <= x$start,
	x$start <= x$upper
	)
	}

	#' @export
	is.corc_opt_parm <- function(x) {
	inherits(x, "corc_opt_parm")
	}

	#' @export
	corc_opt_parm <- function(ref, start_value = (lower_bound + upper_bound) / 2, lower_bound = 1e-6, upper_bound = 1e6) {
	new_corc_opt_parm(
	ref,
	start = start_value,
	lower = lower_bound,
	upper = upper_bound
	)
	}

	#' Define an optimization parameter
	#'
	#' @param ref value reference
	#' @param start_value start value
	#' @param lower_bound lower value bound
	#' @param upper_bound upper value bound
	#' @return corc_opt_parm object for input into related functions
	#' @seealso \code{\link{addOptimizationParameter}} \code{\link{clearOptimizationParameters}}
	#' @family optimization
	#' @export
	defineOptimizationParameter <- corc_opt_parm

	#' Add an optimization parameter
	#'
	#' @param ... objects as returned by \code{\link{defineOptimizationParameter}}.
	#' Alternatively, the same parameters as used by \code{\link{defineOptimizationParameter}}.
	#' @param model a model object
	#' @seealso \code{\link{defineOptimizationParameter}} \code{\link{clearOptimizationParameters}}
	#' @family optimization
	#' @export
	addOptimizationParameter <- function(..., model = getCurrentModel()) {
	c_datamodel <- assert_datamodel(model)

	# flatten all args into a single list
	# this list can be used to check if the user gave only corc_opt_parm
	arglist_compact <- rlang::squash(unname(list(...)))

	# if not all are corc_opt_parm, try handing the args to define... so we get corc_opt_parm
	if (!every(arglist_compact, is.corc_opt_parm))
	arglist_compact <- list(defineOptimizationParameter(...))

	walk(arglist_compact, validate_corc_opt_parm)

	cl_obj <-
	arglist_compact %>%
	map_chr("ref") %>%
	map(xn_to_object, c_datamodel = c_datamodel)

	# Test if all refs are valid
	# This can probably be a more elaborate and safe test (by using dn_to_object(accepted_types))
	invalid_refs <- map_lgl(cl_obj, is.null)
	assert_that(
	!any(invalid_refs),
	msg = paste0("Given reference(s) ", paste0(which(invalid_refs), collapse = ", "), " are invalid for this model.")
	)

	c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	walk2(
	arglist_compact, cl_obj,
	~ {
	c_optitem <- c_problem$addOptItem(.y$getCN())
	c_optitem$setStartValue(.x$start)
	c_optitem$setLowerBound(CCommonName(tolower(as.character(.x$lower))))
	c_optitem$setUpperBound(CCommonName(tolower(as.character(.x$upper))))
	}
	)

	invisible()
	}

	#' Clear all optimization parameters
	#'
	#' @param model a model object
	#' @seealso \code{\link{addOptimizationParameter}} \code{\link{defineOptimizationParameter}}
	#' @family optimization
	#' @export
	clearOptimizationParameters <- function(model = getCurrentModel()) {
	c_datamodel <- assert_datamodel(model)

	c_task <- as(c_datamodel$getTask("Optimization"), "_p_COptTask")
	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	walk(
	seq_len_0(c_problem$getOptItemSize()),
	~ c_problem$removeOptItem(0L)
	)
	}

	opt_assemble_parameters <- function(parameters, c_problem) {
	assert_that(is.null(parameters) \|\| is.list(parameters) && every(parameters, is.corc_opt_parm) \|\| is.corc_opt_parm(parameters))

	if (is.corc_opt_parm(parameters))
	parameters <- list(parameters)

	if (is_empty(parameters))
	return(list())

	assert_that(
	c_problem$getOptItemSize() == 0L,
	msg = "This function can not set parameters if there are already parameters set in COPASI."
	)

	walk(parameters, validate_corc_opt_parm)

	parameters
	}

	# The following functions should be the basis for implementation of any task
	# They should allow for a common workflow with most tasks

	# does assertions
	# returns a list of settings
	opt_assemble_settings <- function(expression, maximize, subtask, randomize_start_values, calculate_statistics, update_model, executable) {
	assert_that(
	is.null(expression) \|\| is.scalar(expression) && is.cexpression(expression) && noNA(expression),
	is.null(maximize) \|\| is.flag(maximize) && noNA(maximize),
	is.null(subtask) \|\| is.string(subtask),
	is.null(randomize_start_values) \|\| is.flag(randomize_start_values) && noNA(randomize_start_values),
	is.null(calculate_statistics) \|\| is.flag(calculate_statistics) && noNA(calculate_statistics),
	is.null(update_model) \|\| is.flag(update_model) && noNA(update_model),
	is.null(executable) \|\| is.flag(executable) && noNA(executable)
	)

	if (!is.null(subtask)) {
	subtask <- rlang::arg_match(subtask, task_enum)
	}

	if (!is.null(expression))
	expression <- to_cexpr(expression)

	list(
	expression = expression,
	maximize = maximize,
	subtask = subtask,
	randomize_start_values = randomize_start_values,
	calculate_statistics = calculate_statistics,
	update_model = update_model,
	executable = executable
	) %>%
	discard(is.null)
	}

	# does assertions
	# returns a list of method settings
	opt_assemble_method <- function(method, c_task) {
	if (is.null(method))
	return(list())

	assert_that(
	is.string(method) \|\| is.list(method) && (is_empty(method) \|\| !is.null(names(method))),
	msg = "method must be a string (a length one character vector) or a named list."
	)

	if (is_scalar_character(method))
	method <- list(method = method)

	if (hasName(method, "method")) {
	valid_methods <- names(.__E___CTaskEnum__Method)[c_task$getValidMethods() + 1L]
	# hack to get nice error message if method string is not accepted.
	method$method <- args_match(method$method, name = "method", valid_methods)
	}

	method
	}

	# gets full list of settings
	opt_get_settings <- function(c_task) {
	c_datamodel <- c_task$getObjectDataModel()
	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	list(
	expression = read_expr(c_problem$getObjectiveFunction(), c_datamodel),
	maximize = as.logical(c_problem$maximize()),
	subtask = c_problem$getSubtaskType(),
	randomize_start_values = as.logical(c_problem$getRandomizeStartValues()),
	calculate_statistics = as.logical(c_problem$getCalculateStatistics()),
	update_model = as.logical(c_task$isUpdateModel()),
	executable = as.logical(c_task$isScheduled())
	)
	}

	# sets all settings given in list
	opt_set_settings <- function(data, c_task) {
	if (is_empty(data))
	return()

	c_problem <- as(c_task$getProblem(), "_p_COptProblem")

	if (!is.null(data$expression)) {
	c_datamodel <- c_task$getObjectDataModel()
	assert_that(
	grab_msg(c_problem$setObjectiveFunction(write_expr(data$expression, c_datamodel))),
	msg = "Error when setting optimization expression."
	)
	}

	if (!is.null(data$maximize))
	c_problem$setMaximize(data$maximize)

	if (!is.null(data$subtask))
	c_problem$setSubtaskType(data$subtask)

	if (!is.null(data$randomize_start_values))
	c_problem$setRandomizeStartValues(data$randomize_start_values)

	if (!is.null(data$calculate_statistics))
	c_problem$setCalculateStatistics(data$calculate_statistics)

	if (!is.null(data$update_model))
	c_task$setUpdateModel(data$update_model)

	if (!is.null(data$executable))
	c_task$setScheduled(data$executable)
	}

	# gathers all results
	opt_get_results <- function(c_task, settings) {
	c_problem <- as(c_task$getProblem(), "_p_COptProblem")
	c_method <- as(c_task$getMethod(), "_p_COptMethod")

	cl_items <- get_sv(c_problem$getOptItemList()) %>% map(as, Class = "_p_COptItem")

	evals <- c_problem$getFunctionEvaluations()
	evaltime <- c_problem$getExecutionTime()

	main <-
	list(
	"Objective Value" = c_problem$getSolutionValue(),
	"Function Evaluations" = evals,
	"CPU Time [s]" = evaltime,
	"Evaluations/second [1/s]" = evals / evaltime
	) %>%
	transform_names()

	parameters <-
	tibble::tibble(
	"Parameter" = get_key(cl_items),
	"Lower Bound" = map_swig_dbl(cl_items, "getLowerBoundValue"),
	"Start Value" = map_swig_dbl(cl_items, "getStartValue"),
	"Value" = get_cv(c_problem$getSolutionVariables()),
	"Upper Bound" = map_swig_dbl(cl_items, "getUpperBoundValue"),
	"Gradient" = get_cv(c_problem$getVariableGradients()),
	.rows = length(cl_items),
	.name_repair = transform_names_worker
	)

	protocol <- c_method$getMethodLog()$getPlainLog()

	list(
	settings = settings,
	main = main,
	parameters = parameters,
	protocol = protocol
	)
	}