Package 'ruminate'

Description

Used to convert nonstandard dose route values (i.e. "IV") to standard values ("intravascular").

Usage

apply_route_map(route_map = list(), route_col = NULL, DS = NULL)

Arguments

Value

Dataset with the route mapping applied.

Examples

if(system.file(package="readxl") !=""){
library(readxl)
#loading a dataset
data_file =  system.file(package="formods","test_data","TEST_DATA.xlsx")
myDS = readxl::read_excel(path=data_file, sheet="DATA")

 route_map = list(
   intravascular = c("^(?i)iv$"),
   extravascular = c("^(?i)sc$", "^(?i)oral")
 )

utils::head(myDS[["ROUTE"]])

myDS = apply_route_map(route_map = route_map,
                       route_col = "ROUTE",
                       DS        = myDS)

utils::head(myDS[["ROUTE"]])
}

Description

Takes the ui elements in the module state and processes the covariate elements for addition.

Usage

CTS_add_covariate(state, element)

Arguments

Details

This depends on the following UI values in the state

• state[["CTS"]][["ui"]][["covariate_value"]]

• state[["CTS"]][["ui"]][["covariate_type_selected"]]

• state[["CTS"]][["ui"]][["selected_covariate"]]

Value

Element with the results of adding the covariate. The cares list element can be used to determine the exit status of the function.

• COV_IS_GOOD If TRUE if the covariate was good and added, and FALSE if there were any issues.

• msgs Vector of messages.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes the ui elements in the state and element and attempts to add a rule.

Usage

CTS_add_rule(state, element)

Arguments

Details

This depends on the following UI values in the state and element

• state[["CTS"]][["ui"]][["rule_name"]]

• state[["CTS"]][["ui"]][["rule_condition"]]

• state[["CTS"]][["ui"]][["rule_type"]]

  • For rule type "dose"

    • state[["CTS"]][["ui"]][["action_dosing_state"]]

    • state[["CTS"]][["ui"]][["action_dosing_values"]]

    • state[["CTS"]][["ui"]][["action_dosing_times"]]

    • state[["CTS"]][["ui"]][["action_dosing_durations"]]

  • For rule type "set state"

    • state[["CTS"]][["ui"]][["action_set_state_state"]]

    • state[["CTS"]][["ui"]][["action_set_state_values"]]

  • For rule type "manual code"

    • state[["CTS"]][["ui"]][["action_manual_code"]]

Value

Element with the results of adding the rule. The rares list element can be used to determine the exit status of the function.

• RULE_IS_GOOD If true it indicates that the pieces of the rule from the UI check out.

• RULE_UPDATED If RULE_IS_GOOD and RULE_UPDATED is true then a previous rule definition was overwritten. If RULE_IS_GOOD is TRUE and RULE_UPDATED is FALSE then a new rule was added.

• notify_text Text for notify message

• notify_id Notification ID

• notify_type Notification type

• msgs Vector of messages.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Appends report elements to a formods report.

Usage

CTS_append_report(state, rpt, rpttype, gen_code_only = FALSE)

Arguments

Value

list containing the following elements

• isgood: Return status of the function.

• hasrptele: Boolean indicator if the module has any reportable elements.

• code: Code to generate reporting elements.

• msgs: Messages to be passed back to the user.

• rpt: Report with any additions passed back to the user.

See Also

formods::FM_generate_report() and onbrand::template_details()

Description

Takes the ui elements in the state and element and processes any changes to the source model and updates the element accordingly.

Usage

CTS_change_source_model(state, element)

Arguments

Details

This depends on the following UI values in the state.

• state[["CTS"]][["ui"]][["source_model"]]

Value

Element with the necessary changes to the source model.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes a CTS state and deletes the current cohort. If that is the last element, then a new default will be added.

Usage

CTS_del_current_element(state)

Arguments

Value

CTS state object with the current cohort deleted.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Fetches the code to generate results seen in the app

Usage

CTS_fetch_code(state)

Arguments

Value

Character object vector with the lines of code

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes a CTS state and returns the current active cohort

Usage

CTS_fetch_current_element(state)

Arguments

Value

List containing the details of the active data view. The structure of this list is the same as the structure of state$CTS$elements in the output of CTS_fetch_state().

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Fetches the datasets produced by the module. For each cohort this will be the simulation timecourse and the event table

Usage

CTS_fetch_ds(state)

Arguments

Value

Character object vector with the lines of code

list containing the following elements

• isgood: Return status of the function.

• hasds: Boolean indicator if the module has any datasets

• msgs: Messages to be passed back to the user.

• ds: List with datasets. Each list element has the name of the R-object for that dataset. Each element has the following structure:

  • label: Text label for the dataset

  • MOD_TYPE: Short name for the type of module.

  • id: module ID

  • DS: Dataframe containing the actual dataset.

  • DSMETA: Metadata describing DS

  • code: Complete code to build dataset.

  • checksum: Module checksum.

  • DSchecksum: Dataset checksum.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

This provides meta information about simulatino options. This includes option names, text descriptions, ui_names used, etc.

Usage

CTS_fetch_sc_meta(
  MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")
)

Arguments

Value

List with the following elements:

• config List from the YAML->MC->sim_config.

• summary: Dataframe with elements of config in tabular format.

• ui_config Vector of all the ui_ids for configuration options.

Examples

CTS_fetch_sc_meta()

Description

Merges default app options with the changes made in the UI

Usage

CTS_fetch_state(
  id,
  id_ASM,
  id_MB,
  input,
  session,
  FM_yaml_file,
  MOD_yaml_file,
  react_state
)

Arguments

Value

list containing the current state of the app including default values from the yaml file as well as any changes made by the user. The list has the following structure:

• yaml: Full contents of the supplied yaml file.

• MC: Module components of the yaml file.

• CTS:

  • isgood: Boolean object indicating if the file was successfully loaded.

  • checksum: This is an MD5 sum of the contents element and can be used to detect changes in the state.

• MOD_TYPE: Character data containing the type of module "CTS"

• id: Character data containing the module id module in the session variable.

• FM_yaml_file: App configuration file with FM as main section.

• MOD_yaml_file: Module configuration file with MC as main section.

Examples

# Within shiny both session and input variables will exist,
# this creates examples here for testing purposes:
sess_res = MB_test_mksession()
session = sess_res$session
input   = sess_res$input

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

# Creating an empty state object
state = CTS_fetch_state(id              = "CTS",
                       id_ASM          = "ASM",
                       id_MB           = "MB",
                       input           = input,
                       session         = session,
                       FM_yaml_file    = FM_yaml_file,
                       MOD_yaml_file   = MOD_yaml_file,
                       react_state     = NULL)

Description

When a source model changes this will update information about that model like the default dvcols and selection information about the dvcols

Usage

CTS_init_element_model(state, element)

Arguments

Value

CTS state object with the current cohort ui elements initialized based on the current model selected

Description

Creates a list of the initialized module state

Usage

CTS_init_state(FM_yaml_file, MOD_yaml_file, id, id_MB, session)

Arguments

Value

list containing an empty CTS state

Examples

# Within shiny both session and input variables will exist,
# this creates examples here for testing purposes:
sess_res = MB_test_mksession()
session = sess_res$session
input   = sess_res$input

state = CTS_init_state(
   FM_yaml_file  = system.file(package = "formods",
                               "templates",
                               "formods.yaml"),
   MOD_yaml_file = system.file(package = "ruminate",
                               "templates",
                               "CTS.yaml"),
   id              = "CTS",
   id_MB           = "MB",
   session         = session)

state

Description

Appends a new empty cohort to the CTS state object and makes this new cohort the active cohort.

Usage

CTS_new_element(state)

Arguments

Value

CTS state object containing a new cohort and that cohort is set as the current active cohort. See the help for CTS_fetch_state() for ===ELEMENT== format.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes a CTS state and element and simulates the current set of rules.

Usage

CTS_plot_element(state, element)

Arguments

Value

Simulation element with plot results stored in the '"plotres" element.

• isgood Boolean value indicating the state of the figure generation code.

• msgs Any messages to be passed to the user.

• capture Captured figure generation output from plot_sr_tc()

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Populates the supplied session variable with information from list of sources.

Usage

CTS_preload(
  session,
  src_list,
  yaml_res,
  mod_ID = NULL,
  react_state = list(),
  quickload = FALSE
)

Arguments

Value

list with the following elements

• isgood: Boolean indicating the exit status of the function.

• msgs: Messages to be passed back to the user.

• session: Session object

• input: The value of the shiny input at the end of the session initialization.

• state: App state.

• react_state: The react_state components.

Description

Server function for the Clinical Trial Simulator Shiny Module

Usage

CTS_Server(
  id,
  id_ASM = "ASM",
  id_MB = "MB",
  FM_yaml_file = system.file(package = "formods", "templates", "formods.yaml"),
  MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml"),
  deployed = FALSE,
  react_state = NULL
)

Arguments

Value

UD Server object

Description

Takes a CTS state and returns the current active cohort

Usage

CTS_set_current_element(state, element)

Arguments

Value

CTS state object with the current cohort set using the supplied value.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes the supplied element and determines if the underlying simulation is in a good state or not.

Usage

CTS_sim_isgood(state, element)

Arguments

Value

List with the following elements:

• isgood: Boolean object indicating if the file was successfully loaded.

• msgs: Text description of failure.

Description

Takes a CTS state and element and simulates the current set of rules.

Usage

CTS_simulate_element(state, element)

Arguments

Value

Simulation element with simulation results stored in the "simres" element.

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Populates the supplied session variable for testing.

Usage

CTS_test_mksession(session = list())

Arguments

Value

The CTS portion of the all_sess_res returned from ASM_set_app_state

See Also

ASM_set_app_state

Examples

sess_res = CTS_test_mksession()

Description

Takes a CTS state and updates the checksum used to trigger downstream updates

Usage

CTS_update_checksum(state)

Arguments

Value

CTS state object with the checksum updated

Examples

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){

# This will populate the session variable with the model building (MB) module
sess_res = MB_test_mksession()
session = sess_res[["session"]]

id     = "CTS"
id_ASM = "ASM"
id_MB  = "MB"
input  = list()

# Configuration files
FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
MOD_yaml_file = system.file(package = "ruminate", "templates", "CTS.yaml")

state = CTS_fetch_state(id              = id,
                        id_ASM          = id_ASM,
                        id_MB           = id_MB,
                        input           = input,
                        session         = session,
                        FM_yaml_file    = FM_yaml_file,
                        MOD_yaml_file   = MOD_yaml_file,
                        react_state     = NULL)


# Fetch a list of the current element
current_ele = CTS_fetch_current_element(state)

# You can modify the element
current_ele[["element_name"]] = "A more descriptive name"

# Defining the source model
state[["CTS"]][["ui"]][["source_model"]] = "MB_obj_1_rx"
current_ele = CTS_change_source_model(state, current_ele)

# Single visit
current_ele[["ui"]][["visit_times"]]                 = "0"
current_ele[["ui"]][["cts_config_nsteps"]]           = "5"

# Creating a dosing rule
state[["CTS"]][["ui"]][["rule_condition"]]           = "time == 0"
state[["CTS"]][["ui"]][["rule_type"]]                = "dose"
state[["CTS"]][["ui"]][["action_dosing_state"]]      = "central"
state[["CTS"]][["ui"]][["action_dosing_values"]]     = "c(1)"
state[["CTS"]][["ui"]][["action_dosing_times"]]      = "c(0)"
state[["CTS"]][["ui"]][["action_dosing_durations"]]  = "c(0)"
state[["CTS"]][["ui"]][["rule_name"]]                = "Single_Dose"

# Adding the rule:
current_ele = CTS_add_rule(state, current_ele)

# Appending the plotting details as well
current_ele[["ui"]][["fpage"]]             = "1"
current_ele[["ui"]][["dvcols"]]            = "Cc"

# Reducing the number of subjects and steps to speed things up on CRAN
current_ele[["ui"]][["nsub"]]              = "2"
current_ele[["ui"]][["cts_config_nsteps"]] = "5"

# Putting the element back in the state forcing code generation
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# Now we pull out the current element, and simulate it
current_ele = CTS_fetch_current_element(state)
#current_ele = CTS_simulate_element(state, current_ele)

# Next we plot the element
current_ele = CTS_plot_element(state, current_ele)

# Now we save those results back into the state:
state = CTS_set_current_element(
  state   = state,
  element = current_ele)

# This will extract the code for the current module
code = CTS_fetch_code(state)
code

# This will update the checksum of the module state
state = CTS_update_checksum(state)


# Access the datasets generated from simulations
ds = CTS_fetch_ds(state)

# CTS_add_covariate
state[["CTS"]][["ui"]][["covariate_value"]]            = "70, .1"
state[["CTS"]][["ui"]][["covariate_type_selected"]]    = "cont_lognormal"
state[["CTS"]][["ui"]][["selected_covariate"]]         = "WT"
current_ele = CTS_add_covariate(state, current_ele)

# Creates a new empty element
state = CTS_new_element(state)

# Delete the current element
state = CTS_del_current_element(state)
}

Description

Takes information about columns in dataset and constructs the dosing records.

Usage

dose_records_builder(
  NCA_DS = NULL,
  dose_from = NULL,
  col_id = NULL,
  col_time = NULL,
  col_ntime = NULL,
  col_route = NULL,
  col_dose = NULL,
  col_cycle = NULL,
  col_dur = NULL,
  col_evid = NULL,
  col_analyte = NULL,
  col_group = NULL
)

Arguments

Value

list containing the following elements

• isgood: Return status of the function.

• msgs: Messages to be passed back to the user.

• dose_rec:

Examples

if(system.file(package="readxl") !=""){
library(dplyr)
library(readxl)
library(stringr)

# Example data file:
data_file =  system.file(package="formods","test_data","TEST_DATA.xlsx")

# Dataset formatted to extract dosing from columns
DS_cols = readxl::read_excel(path=data_file, sheet="DATA")        |>
 dplyr::filter(EVID == 0)                                |>
 dplyr::filter(DOSE %in% c(3))                           |>
 dplyr::filter(str_detect(string=Cohort, "^MD"))         |>
 dplyr::filter(CMT == "C_ng_ml")

drb_res = dose_records_builder(
 NCA_DS     = DS_cols,
 dose_from  = "cols",
 col_id     = "ID",
 col_time   = "TIME_DY",
 col_ntime  = "NTIME_DY",
 col_route  = "ROUTE",
 col_cycle  = "DOSE_NUM",
 col_dose   = "DOSE",
 col_group  = "Cohort")

utils::head(drb_res$dose_rec)

# Dataset formatted to extract dosing from rows (records)
DS_rows = readxl::read_excel(path=data_file, sheet="DATA")        |>
 dplyr::filter(DOSE %in% c(3))                                   |>
 dplyr::filter(str_detect(string=Cohort, "^MD"))                 |>
 dplyr::filter(CMT %in% c("Ac", "C_ng_ml"))

drb_res = dose_records_builder(
 NCA_DS     = DS_rows,
 dose_from  = "rows",
 col_id     = "ID",
 col_time   = "TIME_DY",
 col_ntime  = "NTIME_DY",
 col_route  = "ROUTE",
 col_dose   = "AMT",
 col_evid   = "EVID",
 col_group  = "Cohort")

utils::head(drb_res$dose_rec)
}

Description

This will provide information like parameter names, covriates, etc from an rxode2 object.

Usage

fetch_rxinfo(object)

Arguments

Value

List with the following elements.

• isgood: Boolean variable indicating if the model is good.

• msgs: Any messages from parsing the model.

• elements: List with names of simulation elements:

  • covariates: Names of the covariates in the system.

  • parameters: Names of the parameters (subject level) in the system.

  • iiv: Names of the iiv parameters in the system.

  • states: Names of the states/compartments in the system.

• txt_info: Summary information in text format.

• list_info: Summary information in list format used with onbrand reporting.

• ht_info: Summary information in HTML formot.

Examples

library(formods)
library(ggplot2)

# For more information see the Clinical Trial Simulation vignette:
# https://ruminate.ubiquity.tools/articles/clinical_trial_simulation.html

# None of this will work if rxode2 isn't installed:
if(is_installed("rxode2")){
library(rxode2)
set.seed(8675309)
rxSetSeed(8675309)

my_model = function () 
{
    description <- "One compartment PK model with linear clearance using differential equations"
    ini({
        lka <- 0.45
        label("Absorption rate (Ka)")
        lcl <- 1
        label("Clearance (CL)")
        lvc <- 3.45
        label("Central volume of distribution (V)")
        propSd <- c(0, 0.5)
        label("Proportional residual error (fraction)")
        etalcl ~ 0.1
    })
    model({
        ka <- exp(lka)
        cl <- exp(lcl + etalcl)
        vc <- exp(lvc)
        kel <- cl/vc
        d/dt(depot) <- -ka * depot
        d/dt(central) <- ka * depot - kel * central
        Cc <- central/vc
        Cc ~ prop(propSd)
    })
}

# This creates an rxode2 object
object  = rxode(my_model)

# If you want details about the parameters, states, etc
# in the model you can use this:
rxdetails = fetch_rxinfo(object)

rxdetails$elements

# Next we will create subjects. To do that we need to 
# specify information about covariates:
nsub = 2
covs = list(
  WT         = list(type     = "continuous",
                    sampling = "log-normal",
                    values   = c(70, .15))
)

subs = mk_subjects(object = object,
                   nsub   = nsub,
                   covs   = covs)

head(subs$subjects)

rules = list(
  dose = list(
    condition = "TRUE",
    action    = list(
      type  = "dose",
      state     = "central", 
      values    = "c(1)",
      times     = "c(0)",
      durations = "c(0)")
    )
)

# We evaulate the rules for dosing at time 0
eval_times =  0

# Stop 2 months after the last dose
output_times = seq(0, 56, 1)

# This runs the rule-based simulations
simres = 
  simulate_rules(
    object        = object,
    subjects      = subs[["subjects"]],
    eval_times    = eval_times,
    output_times  = output_times, 
    rules         = rules)

# First subject data:
sub_1 = simres$simall[simres$simall$id == 1, ]

# First subjects events
evall = as.data.frame(simres$evall)
ev_sub_1 = evall[evall$id ==1, ]

# All of the simulation data
simall = simres$simall
simall$id = as.factor(simall$id)

# Timecourse
psim = 
  plot_sr_tc(
    sro    = simres,
    dvcols = "Cc")
psim$fig

# Events
pev = 
  plot_sr_ev(
    sro    = simres,
    ylog   = FALSE)
pev$fig

}

Description

Takes the output of rxSolve() and merges in any missing covariates that are present in params but not in sim

Usage

fetch_rxtc(rx_details, sim)

Arguments

Value

Dataframe of the simulated time course.

Description

Appends report elements to a formods report.

Usage

MB_append_report(state, rpt, rpttype, gen_code_only = FALSE)

Arguments

Value

list containing the following elements

• isgood: Return status of the function.

• hasrptele: Boolean indicator if the module has any reportable elements.

• code: Code to generate reporting elements.

• msgs: Messages to be passed back to the user.

• rpt: Report with any additions passed back to the user.

See Also

formods::FM_generate_report()

Description

Takes the function definition from an rxode object, a function object name and an rxode object name and creates the code to build those objects.

Usage

MB_build_code(
  state,
  session,
  fcn_def,
  time_scale,
  fcn_obj_name,
  rx_obj_name,
  ts_obj_name
)

Arguments

Value

List with the following elements

• model_code Block of code to create the model in the context of a larger script.

• model_code_sa Same as the model_code element but meant to stand alone.

Examples

#library(ruminate)
# This will get the full session:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){
  sess_res = MB_test_mksession()
  # This is just for CRAN
  #sess_res = MB_test_mksession(session=list())
  session = sess_res$session
  input   = sess_res$input
  
  # Configuration files
  FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
  MOD_yaml_file = system.file(package = "ruminate", "templates", "MB.yaml")
  
  # Creating an empty state object
  state = MB_fetch_state(id              = "MB",
                         input           = input,
                         session         = session,
                         FM_yaml_file    = FM_yaml_file,
                         MOD_yaml_file   = MOD_yaml_file,
                         react_state     = NULL)
  
  # This will provide a list of the available models
  models = MB_fetch_catalog(state)
  # This is a summary of the tables in the model:
  models$summary
  
  # This will test the models in the catalog, set as_cran
  # to FALSE to test all the models.
  mtres = MB_test_catalog(state, as_cran=TRUE)
  mtres$isgood
  
  
  # Creates a new empty element
  state = MB_new_element(state)
  
  # Delete the current element
  state = MB_del_current_element(state)
  
  # Fetch a list of the current element
  element = MB_fetch_current_element(state)
  
  # This will attach a model to it:
  # Pulling the first model from the catalog
  fcn_def  = models[["summary"]][1, ][["Model"]]
  fcn_obj  = models[["summary"]][1, ][["Object"]]
  mdl_type = models[["summary"]][1, ][["Type"]]
  fcn_desc = models[["summary"]][1, ][["Description"]]
  
  # This will build the rxode2 object from the model
  mk_rx_res = mk_rx_obj(
    type  = mdl_type,
    model = list(fcn_def = fcn_def,
                 fcn_obj = fcn_obj))
  
  # This will attach the model to the current element
  element = MB_update_model(
    state       = state,
    session     = session,
    current_ele = element,
    rx_obj      = mk_rx_res[["capture"]][["rx_obj"]],
    note        = fcn_desc,
    reset       = TRUE)
  
  # You can now place element back in the state
  state = MB_set_current_element(state, element)
  
  # This will fetch the current component
  component = MB_fetch_component(state, element)
  
  
  fares = MB_fetch_appends(state, element) 
  
  # You can use the component to build the code to generate the model:
  gen_code =
    MB_build_code(state        = state, session = session,
                fcn_def        = component[["fcn_def"]],
                time_scale     = element[["ui"]][["time_scale"]],
                fcn_obj_name   = "my_fcn_obj",
                rx_obj_name    = "my_obj_name",
                ts_obj_name    = "my_ts_name")
  
  # Model code to be included in a larger script
  message(paste0(gen_code$model_code, collapse="\n"))
  
  # Stand-alone model code
  message(paste0(gen_code$model_code_sa, collapse="\n"))
  
  # This will fetch the code to regenerate all of the components of this module
  message(MB_fetch_code(state))
}

Description

Takes a MB state and deletes the current model. If that is the last element, then a new default will be added.

Usage

MB_del_current_element(state)

Arguments

Value

MB state object with the current model deleted.

Examples

#library(ruminate)
# This will get the full session:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){
  sess_res = MB_test_mksession()
  # This is just for CRAN
  #sess_res = MB_test_mksession(session=list())
  session = sess_res$session
  input   = sess_res$input
  
  # Configuration files
  FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
  MOD_yaml_file = system.file(package = "ruminate", "templates", "MB.yaml")
  
  # Creating an empty state object
  state = MB_fetch_state(id              = "MB",
                         input           = input,
                         session         = session,
                         FM_yaml_file    = FM_yaml_file,
                         MOD_yaml_file   = MOD_yaml_file,
                         react_state     = NULL)
  
  # This will provide a list of the available models
  models = MB_fetch_catalog(state)
  # This is a summary of the tables in the model:
  models$summary
  
  # This will test the models in the catalog, set as_cran
  # to FALSE to test all the models.
  mtres = MB_test_catalog(state, as_cran=TRUE)
  mtres$isgood
  
  
  # Creates a new empty element
  state = MB_new_element(state)
  
  # Delete the current element
  state = MB_del_current_element(state)
  
  # Fetch a list of the current element
  element = MB_fetch_current_element(state)
  
  # This will attach a model to it:
  # Pulling the first model from the catalog
  fcn_def  = models[["summary"]][1, ][["Model"]]
  fcn_obj  = models[["summary"]][1, ][["Object"]]
  mdl_type = models[["summary"]][1, ][["Type"]]
  fcn_desc = models[["summary"]][1, ][["Description"]]
  
  # This will build the rxode2 object from the model
  mk_rx_res = mk_rx_obj(
    type  = mdl_type,
    model = list(fcn_def = fcn_def,
                 fcn_obj = fcn_obj))
  
  # This will attach the model to the current element
  element = MB_update_model(
    state       = state,
    session     = session,
    current_ele = element,
    rx_obj      = mk_rx_res[["capture"]][["rx_obj"]],
    note        = fcn_desc,
    reset       = TRUE)
  
  # You can now place element back in the state
  state = MB_set_current_element(state, element)
  
  # This will fetch the current component
  component = MB_fetch_component(state, element)
  
  
  fares = MB_fetch_appends(state, element) 
  
  # You can use the component to build the code to generate the model:
  gen_code =
    MB_build_code(state        = state, session = session,
                fcn_def        = component[["fcn_def"]],
                time_scale     = element[["ui"]][["time_scale"]],
                fcn_obj_name   = "my_fcn_obj",
                rx_obj_name    = "my_obj_name",
                ts_obj_name    = "my_ts_name")
  
  # Model code to be included in a larger script
  message(paste0(gen_code$model_code, collapse="\n"))
  
  # Stand-alone model code
  message(paste0(gen_code$model_code_sa, collapse="\n"))
  
  # This will fetch the code to regenerate all of the components of this module
  message(MB_fetch_code(state))
}

Description

Creates a catalog of the models available in the system file.

Usage

MB_fetch_appends(state, current_ele)

Arguments

Value

List with the following attributes:

• isgood: Boolean variable indicating success or failure.

• msgs: Messages to be passed back to the user.

• hasappends: Boolean variable indicating if appendable models were found.

• select_plain: Flat list with the models (ungrouped).

• choicesOpt List witht he subtext filled out.

Examples

#library(ruminate)
# This will get the full session:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){
  sess_res = MB_test_mksession()
  # This is just for CRAN
  #sess_res = MB_test_mksession(session=list())
  session = sess_res$session
  input   = sess_res$input
  
  # Configuration files
  FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
  MOD_yaml_file = system.file(package = "ruminate", "templates", "MB.yaml")
  
  # Creating an empty state object
  state = MB_fetch_state(id              = "MB",
                         input           = input,
                         session         = session,
                         FM_yaml_file    = FM_yaml_file,
                         MOD_yaml_file   = MOD_yaml_file,
                         react_state     = NULL)
  
  # This will provide a list of the available models
  models = MB_fetch_catalog(state)
  # This is a summary of the tables in the model:
  models$summary
  
  # This will test the models in the catalog, set as_cran
  # to FALSE to test all the models.
  mtres = MB_test_catalog(state, as_cran=TRUE)
  mtres$isgood
  
  
  # Creates a new empty element
  state = MB_new_element(state)
  
  # Delete the current element
  state = MB_del_current_element(state)
  
  # Fetch a list of the current element
  element = MB_fetch_current_element(state)
  
  # This will attach a model to it:
  # Pulling the first model from the catalog
  fcn_def  = models[["summary"]][1, ][["Model"]]
  fcn_obj  = models[["summary"]][1, ][["Object"]]
  mdl_type = models[["summary"]][1, ][["Type"]]
  fcn_desc = models[["summary"]][1, ][["Description"]]
  
  # This will build the rxode2 object from the model
  mk_rx_res = mk_rx_obj(
    type  = mdl_type,
    model = list(fcn_def = fcn_def,
                 fcn_obj = fcn_obj))
  
  # This will attach the model to the current element
  element = MB_update_model(
    state       = state,
    session     = session,
    current_ele = element,
    rx_obj      = mk_rx_res[["capture"]][["rx_obj"]],
    note        = fcn_desc,
    reset       = TRUE)
  
  # You can now place element back in the state
  state = MB_set_current_element(state, element)
  
  # This will fetch the current component
  component = MB_fetch_component(state, element)
  
  
  fares = MB_fetch_appends(state, element) 
  
  # You can use the component to build the code to generate the model:
  gen_code =
    MB_build_code(state        = state, session = session,
                fcn_def        = component[["fcn_def"]],
                time_scale     = element[["ui"]][["time_scale"]],
                fcn_obj_name   = "my_fcn_obj",
                rx_obj_name    = "my_obj_name",
                ts_obj_name    = "my_ts_name")
  
  # Model code to be included in a larger script
  message(paste0(gen_code$model_code, collapse="\n"))
  
  # Stand-alone model code
  message(paste0(gen_code$model_code_sa, collapse="\n"))
  
  # This will fetch the code to regenerate all of the components of this module
  message(MB_fetch_code(state))
}

Description

Creates a catalog of the models available in the system file.

Usage

MB_fetch_catalog(state)

Arguments

Value

List with the following attributes:

• summary: Dataframe with a summary of the models in the catlog

• sources: Same information a that found in the summary table but in list form.

• select_group: List with the models grouped by source.

• select_plain: Flat list with the models (ungrouped).

• select_subtext: Subtext for pulldown menus.

• msgs: Messages to be passed back to the user.

• hasmdl: Boolean value indicating if any models were found.

• isgood: Boolean variable indicating success or failure.

Examples

#library(ruminate)
# This will get the full session:
library(formods)
if( Sys.getenv("ruminate_rxfamily_found") == "TRUE"){
  sess_res = MB_test_mksession()
  # This is just for CRAN
  #sess_res = MB_test_mksession(session=list())
  session = sess_res$session
  input   = sess_res$input
  
  # Configuration files
  FM_yaml_file  = system.file(package = "formods", "templates", "formods.yaml")
  MOD_yaml_file = system.file(package = "ruminate", "templates", "MB.yaml")
  
  # Creating an empty state object
  state = MB_fetch_state(id              = "MB",
                         input           = input,
                         session         = session,
                         FM_yaml_file    = FM_yaml_file,
                         MOD_yaml_file   = MOD_yaml_file,
                         react_state     = NULL)
  
  # This will provide a list of the available models
  models = MB_fetch_catalog(state)
  # This is a summary of the tables in the model:
  models$summary
  
  # This will test the models in the catalog, set as_cran
  # to FALSE to test all the models.
  mtres = MB_test_catalog(state, as_cran=TRUE)
  mtres$isgood
  
  
  # Creates a new empty element
  state = MB_new_element(state)
  
  # Delete the current element
  state = MB_del_current_element(state)
  
  # Fetch a list of the current element
  element = MB_fetch_current_element(state)
  
  # This will attach a model to it:
  # Pulling the first model from the catalog
  fcn_def  = models[["summary"]][1, ][["Model"]]
  fcn_obj  = models[["summary"]][1, ][["Object"]]
  mdl_type = models[["summary"]][1, ][["Type"]]
  fcn_desc = models[["summary"]][1, ][["Description"]]
  
  # This will build the rxode2 object from the model
  mk_rx_res = mk_rx_obj(
    type  = mdl_type,
    model = list(fcn_def = fcn_def,
                 fcn_obj = fcn_obj))
  
  # This will attach the model to the current element
  element = MB_update_model(
    state       = state,
    session     = session,
    current_ele = element,
    rx_obj      = mk_rx_res[["capture"]][["rx_obj"]],
    note        = fcn_desc,
    reset       = TRUE)
  
  # You can now place element back in the state
  state = MB_set_current_element(state, element)
  
  # This will fetch the current component
  component = MB_fetch_component(state, element)
  
  
  fares = MB_fetch_appends(state, element) 
  
  # You can use the component to build the code to generate the model:
  gen_code =
    MB_build_code(state        = state, session = session,
                fcn_def        = component[["fcn_def"]],
                time_scale     = element[["ui"]][["time_scale"]],
                fcn_obj_name   = "my_fcn_obj",
                rx_obj_name    = "my_obj_name",
                ts_obj_name    = "my_ts_name")
  
  # Model code to be included in a larger script
  message(paste0(gen_code$model_code, collapse="\n"))
  
  # Stand-alone model code
  message(paste0(gen_code$model_code_sa, collapse="\n"))
  
  # This will fetch the code to regenerate all of the components of this module
  message(MB_fetch_code(state))
}