R functions to run Monolix

On the use of the R-functions

We now propose to use Monolix via R-functions. The package lixoftConnectors provides access to the project exactly in the same way as you would do with the interface. All the installation guidelines and initialization procedure can be found here. All the functions of lixoftConnectors are described below. To go beyond what the interface allows, the Rsmlx package provides additional functions for automatic PK model building, bootstrap simulation and likelihood profiling, among others.

Note: Due to possible conflicts, the package mlxR, whose function simulx can be used to perform simulations with Monolix, should not be loaded at the same time as lixoftConnectors.

• Installation guidelines and initialization procedure
• Examples using R functions
  • Load and run a project
  • Convergence assessment
  • Profile likelihood
  • Bayesian individual dynamic predictions
  • Covariate search
  • Generate plots in R
  • Handling of warning/error/info messages
• List of the R functions
  • Description of the functions concerning the algorithm settings
  • Description of the functions concerning the bootstrap
  • Description of the functions concerning the convergence assessment
  • Description of the functions concerning the covariate model
  • Description of the functions concerning the dataset
  • Description of the functions concerning the individual model
  • Description of the functions concerning the initial values and estimation method
  • Description of the functions concerning the initialization and path to demo projects
  • Description of the functions concerning the model building tasks
  • Description of the functions concerning the observation model
  • Description of the functions concerning the plots
  • Description of the functions concerning the project management
  • Description of the functions concerning the project settings and preferences
  • Description of the functions concerning the reporting
  • Description of the functions concerning the results
  • Description of the functions concerning the scenario

List of the R functions

Description of the functions concerning the algorithm settings

• getConditionalDistributionSamplingSettings: Get the conditional distribution sampling settings for the current project.
• getConditionalModeEstimationSettings: Get the conditional mode (EBEs) estimation settings for the current project.
• getGeneralSettings: Get a summary of the settings related to chains for Monolix algorithms for the current project.
• getLogLikelihoodEstimationSettings: Get the log-likelihood estimation settings of the current project.
• getMCMCSettings: Get the MCMC algorithm settings of the current project.
• getPopulationParameterEstimationSettings: Get the population parameter estimation settings for the current project.
• getStandardErrorEstimationSettings: Get the standard error estimation settings for the current project.
• setConditionalDistributionSamplingSettings: Set the value of one or more of the conditional distribution sampling settings for the current project.
• setConditionalModeEstimationSettings: Set the value of one or more of the conditional mode (EBEs) estimation settings for the current project.
• setGeneralSettings: Set the value of one or more of the settings related to chains for Monolix algorithms for the current project.
• setLogLikelihoodEstimationSettings: Set the value of the log-likelihood estimation settings for the current project.
• setMCMCSettings: Set the value of one or more of the MCMC algorithm settings related to transition kernels of the current project.
• setPopulationParameterEstimationSettings: Set the value of one or more of the population parameter estimation settings for the current project.
• setStandardErrorEstimationSettings: Set the value of one or more of the standard error estimation settings for the current project.

Description of the functions concerning the bootstrap

• getBootstrapResults: Get the results of boostrap.
• getBootstrapSettings: Get the settings that will be used during the run of bootstrap.
• runBootstrap: Run boostrap.

Description of the functions concerning the convergence assessment

• getAssessmentResults: Get the results of the convergence assessment.
• getAssessmentSettings: Get the current settings for running the convergence assessment.
• runAssessment: Run assessment.

Description of the functions concerning the covariate model

• addCategoricalTransformedCovariate: Create a new categorical covariate by transforming an existing one.
• addContinuousTransformedCovariate: Create a new continuous covariate by transforming an existing one.
• addMixture: Add a new latent covariate to the current model giving its name and its modality number (how many subpopulations).
• removeCovariate: Remove any of the transformed covariates (discrete and continuous) and/or latent covariates.

Description of the functions concerning the dataset

• addAdditionalCovariate: Create an additional covariate for stratification purpose.
• applyFilter: Apply a filter on the current data.
• createFilter: Create a new filtered data set by applying a filter on an existing one and/or complementing it.
• deleteAdditionalCovariate: Delete a created additinal covariate.
• deleteFilter: Delete a data set.
• editFilter: Edit the definition of an existing filtered data set.
• formatData: Adapt and export a data file as a MonolixSuite formatted data set.
• getAvailableData: Get information about the data sets and filters defined in the project.
• getCovariateInformation: Get the name, the type and the values of the covariates present in the project.
• getFormatting: Get data formatting settings from a loaded project.
• getObservationInformation: Get the name, the type and the values of the observations present in the project.
• getTreatmentsInformation: Get information about doses present in the loaded dataset.
• removeFilter: Remove the last filter applied on the current data set.
• renameAdditionalCovariate: Rename an existing additional covariate.
• renameFilter: Rename an existing filtered data set.
• selectData: Select the new current data set within the previously defined ones (original and filters).

Description of the functions concerning the individual model

• getIndividualParameterModel: Get a summary of the individual parameter model.
• getVariabilityLevels: Get a summary of the variability levels (inter-individual and/or intra-individual variability, i.
• setCorrelationBlocks: Define the correlation block structure associated to some of the variability levels of the current project.
• setCovariateModel: Set which are the covariates influencing individual parameters present in the project.
• setIndividualLogitLimits: Set the minimum and the maximum values for an individual parameter.
• setIndividualParameterDistribution: Set the distribution of the estimated parameters.
• setIndividualParameterModel: Update the individual parameter model.
• setIndividualParameterVariability: Add or remove inter-individual and/or intra-individual variability (i.

Description of the functions concerning the initial values and estimation method

• getFixedEffectsByAutoInit: Compute initial values for fixed-effect population parameters.
• getPopulationParameterInformation: Get population parameters information.
• setInitialEstimatesToLastEstimates: Set the initial value of all the population parameters in the current project to the ones previously estimated.
• setPopulationParameterInformation: Set population parameters initialization and estimation method.

Description of the functions concerning the initialization and path to demo projects

• initializeLixoftConnectors: Initialize lixoftConnectors API for a given software.
• getDemoPath: Get the path to the demo projects.

Description of the functions concerning the model building tasks

• getModelBuildingResults: Get the results of automatic covariate model building or automatic statistical model building.
• getModelBuildingSettings: Get the current settings for running model building.
• runModelBuilding: Run model building for automatic covariate model building or automatic statistical model building.

Description of the functions concerning the observation model

• getContinuousObservationModel: Get a summary of the information concerning the continuous observation statistical model(s) in the project.
• setAutocorrelation: Add or remove auto-correlation from the error model used on some of the observation models.
• setErrorModel: Set the error model type to be used for the observation model(s).
• setObservationDistribution: Set observation model distribution.
• setObservationLimits: Set observation model distribution limits for logitNormal observations.

Description of the functions concerning the plots

• plotBivariateDataViewer: Plot the bivariate viewer.
• plotCovariates: Plot the covariates.
• plotObservedData: Plot the observed data.
• plotImportanceSampling: Plot iterations of the likelihood estimation by importance sampling.
• plotMCMC: Plot iterations and convergence for the conditional distribution task.
• plotSaem: Plot iterations and convergence for the SAEM algorithm (population parameters estimation).
• plotParametersDistribution: Plot the distribution of the individual parameters.
• plotParametersVsCovariates: Plot individual parameters vs covariates.
• plotRandomEffectsCorrelation: Plot correlations between random effects.
• plotStandardizedRandomEffectsDistribution: Plot the distribution of the standardized random effects.
• plotIndividualFits: Plot the individual fits.
• plotObservationsVsPredictions: Plot the observation vs the predictions.
• plotResidualsDistribution: Plot the distribution of the residuals.
• plotResidualsScatterPlot: Plot the scatter plots of the residuals.
• plotBlqPredictiveCheck: Plot the BLQ predictive checks.
• plotNpc: Plot the numerical predictive checks.
• plotPredictionDistribution: Plot the prediction distribution.
• plotVpc: Plot the visual predictive checks.
• getPlotPreferences: Define the preferences to customize plots.
• resetPlotPreferences: Reset plot preferences to go back to default preferences.
• setPlotPreferences: Set preferences to customize plots.

Description of the functions concerning the project management

• exportProject: Export the current project to another application of the MonolixSuite, and load the exported project.
• getData: Get a description of the data used in the current project.
• getInterpretedData: Get data after interpretation done by the software, as it is displayed in the Data tab in the interface.
• getLibraryModelContent: Get the content of a library model.
• getLibraryModelName: Get the name of a library model given a list of library filters.
• getMapping: Get mapping between data and model.
• getStructuralModel: Get the model file for the structural model used in the current project.
• importProject: Import a Monolix or a PKanalix project into the currently running application initialized in the connectors.
• isProjectLoaded: Get a logical saying if a project is currently loaded.
• loadProject: Load a project in the currently running application initialized in the connectors.
• newProject: Create a new project.
• saveProject: Save the current project as a file that can be reloaded in the connectors or in the GUI.
• setData: Set project data giving a data file and specifying headers and observations types.
• setMapping: Set mapping between data and model.
• setStructuralModel: Set the structural model.
• shareProject: Create a zip archive file from current project and its results.

Description of the functions concerning the project settings and preferences

• getConsoleMode: Get console mode, ie volume of output after running estimation tasks.
• getPreferences: Get a summary of the project preferences.
• getProjectSettings: Get a summary of the project settings.
• setConsoleMode: Set console mode, ie volume of output after running estimation tasks.
• setPreferences: Set the value of one or several of the project preferences.
• setProjectSettings: Set the value of one or several of the settings of the project.

Description of the functions concerning the reporting

• generateReport: Generate a project report with default options or from a custom Word template.

Description of the functions concerning the results

• exportChartDataSet: Export the data of a chart into Lixoft suite compatible data set format.
• getCorrelationOfEstimates: Get the inverse of the last estimated Fisher matrix computed either by all the Fisher methods used during the last scenario run or by the specific one passed in argument.
• getEstimatedConfidenceIntervals: Get the confidence interval of population parameters computed either by all the Fisher methods used during the last scenario run or by the specific one passed in argument.
• getEstimatedIndividualParameters: Get the last estimated values for each subject of the individual parameters present within the current project.
• getEstimatedLogLikelihood: Get the values computed by using a log-likelihood algorithm during the last scenario run, with or without a method-based filter.
• getEstimatedPopulationParameters: Get the last estimated value of some of the population parameters present within the current project (fixed effects + individual variances + correlations + latent probabilities + error model parameters).
• getEstimatedRandomEffects: Get the random effects for each subject of the individual parameters present within the current project.
• getEstimatedStandardErrors: Get the last estimated standard errors of population parameters computed either by all the Fisher methods used during the last scenario run or by the specific one passed in argument.
• getEtaShrinkage: Get the shrinkage values for each individual parameter.
• getLaunchedTasks: Get a list of the tasks which have available results.
• getSAEMiterations: Retrieve the successive values of some of the population parameters present within the current project (fixed effects + individual variances + correlations + latent probabilities + error model parameters) during the previous run of the SAEM algorithm.
• getSimulatedIndividualParameters: Get the simulated values for each replicate of each subject of some of the individual parameters present within the current project.
• getSimulatedRandomEffects: Get the simulated values for each replicate of each subject of some of the individual random effects present within the current project.
• getTests: Get the results of performed statistical tests.

Description of the functions concerning the scenario

• computeChartsData: Compute (if needed) and export the charts data of a given plot or, if not specified, all the available project plots.
• getLastRunStatus: Return an execution report about the last run with a summary of the error which could have occurred.
• getScenario: Get the list of tasks that will be run at the next call to runScenario.
• runScenario: Run the scenario that has been set with setScenario.
• setScenario: Clear the current scenario and build a new one from a given list of tasks.
• runConditionalDistributionSampling: Estimate the conditional distribution which can be sampled from (i.
• runConditionalModeEstimation: Estimate the individual parameters using the conditional mode estimation algorithm (EBEs).
• runLogLikelihoodEstimation: Run the log-likelihood estimation algorithm.
• runPopulationParameterEstimation: Estimate the population parameters with the SAEM algorithm.
• runStandardErrorEstimation: Estimate the Fisher Information Matrix (FIM) and the standard errors of the population parameters.

[Monolix] Get conditional distribution sampling settings

Description

Get the conditional distribution sampling settings for the current project.
Associated settings are:

Usage

getConditionalDistributionSamplingSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setConditionalDistributionSamplingSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve all the conditional distribution sampling settings

getConditionalDistributionSamplingSettings() 

# retrieve only certain settings 

getConditionalDistributionSamplingSettings("ratio", "nbMinIterations") 

[Monolix] Get conditional mode estimation settings

Description

Get the conditional mode (EBEs) estimation settings for the current project.
Associated settings are:

Usage

getConditionalModeEstimationSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setConditionalModeEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve a list of all the conditional mode estimation settings

getConditionalModeEstimationSettings() 

# retrieve only the one setting value

getConditionalModeEstimationSettings("nbOptimizationIterationsMode") 

[Monolix] Get project general settings for chains

Description

Get a summary of the settings related to chains for Monolix algorithms for the current project.
Associated settings are:

Usage

getGeneralSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setGeneralSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve a list of all chain settings

getGeneralSettings() 

# retrieve only specified settings

getGeneralSettings("nbChains", "autoChains") 

[Monolix] Get Log-likelihood algorithm settings

Description

Get the log-likelihood estimation settings of the current project. Associated settings are:

Usage

getLogLikelihoodEstimationSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setLogLikelihoodEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve a list of all the loglikelihood estimation settings

getLogLikelihoodEstimationSettings() 

# retrieve only certain settings values

getLogLikelihoodEstimationSettings("nbFixedIterations", "samplingMethod") 

[Monolix] Get settings for transition kernels of the MCMC algorithm

Description

Get the MCMC algorithm settings of the current project.
Associated settings are:

Usage

getMCMCSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setMCMCSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

getMCMCSettings() # retrieve a list of all the MCMC settings

getMCMCSettings("strategy") # retrieve only the strategy setting

[Monolix] Get population parameter estimation settings

Description

Get the population parameter estimation settings for the current project.
Associated settings are:

Usage

getPopulationParameterEstimationSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setPopulationParameterEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve a list of all the population parameter estimation settings

getPopulationParameterEstimationSettings() 

# retrieve only the setting related to the smoothing phase

getPopulationParameterEstimationSettings("nbSmoothingIterations", "smoothingAutoStop", "smoothingAlpha", "smoothingRatio")

[Monolix] Get standard error estimation settings

Description

Get the standard error estimation settings for the current project.
Associated settings are:

Usage

getStandardErrorEstimationSettings(...)

Arguments

Value

A list with each setting name mapped to its current value.

See Also

setStandardErrorEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

# retrieve a list of all the standard error estimation settings

getStandardErrorEstimationSettings() 

# retrieve only certain settings

getStandardErrorEstimationSettings("minIterations","maxIterations") 

[Monolix] Set conditional distribution sampling settings

Description

Set the value of one or more of the conditional distribution sampling settings for the current project.
Associated settings are:

Usage

setConditionalDistributionSamplingSettings(...)

Arguments

See Also

getConditionalDistributionSamplingSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setConditionalDistributionSamplingSettings(ratio = 0.1, nbSimulatedParameters = 20)

getConditionalDistributionSamplingSettings()

[Monolix] Set conditional mode estimation settings

Description

Set the value of one or more of the conditional mode (EBEs) estimation settings for the current project.
Associated settings are:

Usage

setConditionalModeEstimationSettings(...)

Arguments

See Also

getConditionalModeEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setConditionalModeEstimationSettings(nbOptimizationIterationsMode = 100, 

                                     optimizationToleranceMode = 0.001)

getConditionalModeEstimationSettings()

[Monolix] Set project general settings for chains

Description

Set the value of one or more of the settings related to chains for Monolix algorithms for the current project.
Associated settings are:

Usage

setGeneralSettings(...)

Arguments

See Also

getGeneralSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setGeneralSettings(autoChains = FALSE, nbchains = 10)

getGeneralSettings()

[Monolix] Set log-likelihood estimation settings

Description

Set the value of the log-likelihood estimation settings for the current project.
Associated settings are:

Usage

setLogLikelihoodEstimationSettings(...)

Arguments

See Also

getLogLikelihoodEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setLogLikelihoodEstimationSettings(nbFixedIterations = 20000)

getLogLikelihoodEstimationSettings()

[Monolix] Set settings for transition kernels of the MCMC algorithm

Description

Set the value of one or more of the MCMC algorithm settings related to transition kernels of the current project.
Associated settings are:

Usage

setMCMCSettings(...)

Arguments

See Also

getMCMCSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setMCMCSettings(strategy = c(2,1,2))

getMCMCSettings()

[Monolix] Set population parameter estimation settings

Description

Set the value of one or more of the population parameter estimation settings for the current project.

Associated settings are:

Usage

setPopulationParameterEstimationSettings(...)

Arguments

See Also

getPopulationParameterEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setPopulationParameterEstimationSettings(exploratoryAutoStop = TRUE, nbexploratoryiterations = 200)

getPopulationParameterEstimationSettings()

[Monolix] Set standard error estimation settings

Description

Set the value of one or more of the standard error estimation settings for the current project.
Associated settings are:

Usage

setStandardErrorEstimationSettings(...)

Arguments

See Also

getStandardErrorEstimationSettings

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setStandardErrorEstimationSettings(minIterations = 20, maxIterations = 500, intervalLevel = 99)

getStandardErrorEstimationSettings()

[Monolix] Get the results of boostrap

Description

Get the results of boostrap.

Usage

getBootstrapResults(removeFailedRuns = FALSE)

Arguments

Value

The results of boostrap as a list of dataframes:

• populationEstimates: the population parameters estimated in all bootstrap runs
• populationSummary: the summary table of population parameter estimates
• logLikelihoodEstimates: if logLikelihood=TRUE in the bootstrap settings, the log-likelihood (OFV) and information criteria estimated in all bootstrap runs
• logLikelihoodSummary: if logLikelihood=TRUE in the bootstrap settings, the summary table of the OFV and information criteria
• standardErrorsEstimates: if standardErrors=TRUE in the bootstrap settings, the relative standard errors of population parameters estimated in all bootstrap runs
• standardErrorsSummary: if standardErrors=TRUE in the bootstrap settings, the summary table of relative standard errors

See Also

runBootstrap

#

# get bootstrap results using all runs

getBootstrapResults()

# get bootstrap results using only runs that converged (during the population parameter estimation, the autostop criterion was triggered before reaching the maximum number of iterations)

getBootstrapResults(removeFailedRuns=TRUE)

## End(Not run)

[Monolix] Get bootstrap settings

Description

Get the settings that will be used during the run of bootstrap.

Usage

getBootstrapSettings()

Value

The list of settings

• nbRuns [optional] (integer) number of bootstrap replicates (default=200)
• method [optional] (character) sampling method: "parametric" or "nonparametric" (default: nonparametric)
• initialValues [optional] (character) initial values used in the boostrap runs for the estimation of the population parameters: "initial" or "final (default: "initial")
• cens [optional] (list) if method="nonparametric" and there are censored observations in the dataset. A list, or a list of lists with elements obsid, type ("left,"right" or "interval") and limit (single value or vector of two values). Ex: list(list(obsid="y1",type="left", limit=0.1), list(obsid="y2", type="interval", limit=c(0.2,10))
• tasks [optional] (list of character) tasks to perform in bootstrap runs in addition to population parameter estimation. Available tasks: "standardErrorEstimation", "logLikelihoodEstimation" (default=list())
• useLin [optional] (logical) calculation method to estimate standard errors and log-likelihood (default = FALSE). If TRUE, they are estimated via linearization. If FALSE, standard errors are estimated via stochastic approximation and log-likelihood via importance sampling.
• sampleSize [optional] (integer) the number of individuals in each bootstrap data set (default value is the number of individuals in the original data set).
• covStrat [optional] (list of character) one or several categorical covariates of the project. The original distribution of this covariate is maintained in each resampled data set if covStrat is defined (default=list()). Notice that if the categorical covariate is varying within the subject (in case of occasions), it will not be taken into account.
• level [optional] (numeric) level of the bootstrap confidence intervals (default = 0.95)
• saveResultsFolders [optional] (logical) to choose if bootstrap projects results folders should be saved or deleted (default = FALSE)
• saveDatasets [optional] (logical) to choose if bootstrap datasets and mlxtran files (Monolix project) should be saved or deleted (default = FALSE)
• replaceFailedRuns [optional] (logical) to choose if bootstrap runs with failed convergence (maximum number of iterations reached before the autostop criterion) should be replaced by new runs (default=FALSE)
• maxNbFailedRuns [optional] (integer) if replaceFailedRuns=TRUE, maximum number of runs with failed convergence that can be replaced before bootstrap is stopped (default=20)

See Also

runBootstrap

#

# run parametric bootstrap with 100 runs

set = getBootstrapSettings()

set$nbRuns = 100

set$method = "parametric"

runBootstrap(set)

# run nonparametric bootstrap with 500 runs, stratified resampling by STUDY and DOSEGROUP categorical covariates, standard errors and log-likelihood estimated via linearization, and bootstrap datasets and mlxtran files saved in the results.

runBootstrap(nbRuns=500, method="nonparametric", covStrat=list("STUDY", "DOSEGROUP"), tasks=list("standardErrorEstimation", "logLikelihoodEstimation"), useLin=FALSE, saveDatasets=TRUE)

## End(Not run)

[Monolix] Run boostrap

Description

Run boostrap.
If no argument is given, it uses the previously used settings if bootstrap has already run in the project, or the default settings otherwise.
In both cases, use getBootstrapSettings to receive all the settings.

Usage

runBootstrap(...)

Arguments

See Also

getBootstrapSettings getBootstrapResults

#

# run bootstrap with default settings

runBootstrap()

# run non-parametric bootstrap with 1000 runs that include the estimation of standard errors and likelihood via linearization, with resampled datasets containing 20 individuals stratified by "group" covariate. Each bootstrap run is saved with its dataset and results folder.

runBootstrap(nbRuns = 1000, tasks= list("standardErrorEstimation", "logLikelihoodEstimation"), useLin = TRUE, sampleSize = 20, covStrat = "group", level = 90, saveResultsFolders = T, saveDatasets = T)

# run parametric bootstrap with 100 runs

set = getBootstrapSettings()

set$nbRuns = 100

set$method = "parametric"

runbootstrap(settings = set)

## End(Not run)

[Monolix] Get the results of the convergence assessment

Description

Get the results of the convergence assessment. The populationParameters are always included and standardErrors and logLikelihood
are included when extendedEstimation is TRUE in the assessment settings.

Usage

getAssessmentResults()

Value

A vector of lists containing, for each assessment run:

• populationParameters: results of population parameter estimation using SAEM:
  • nbexploratoryiterations (integer) number of iterations during exploratory phase
  • nbsmoothingiterations (integer) number of iterations during smoothing phase
  • convergence (data.frame) convergence history of estimated population parameters and convergence indicator (-2*log-likelihood)
• standardErrors: [optional] results of standard errors estimation:
  • method (character) fisher method used (stochasticApproximation or linearization)
  • values (vector) standard error associated to each population parameter
• loglikelihood: [optional] results of log-likelihood estimation
  • method (character) fisher method used (importanceSampling or linearization)
  • AIC (double) Akaike Information Criterion
  • BIC (double) Bayesian Information Criterion
  • BICc (double) modified BIC
  • LL (double) log likelihood
  • chosenDegree (integer) [importanceSampling]
  • standardError (double) [importanceSampling]
  • convergence (data.frame) [importanceSampling]

See Also

runAssessment to run the assessment

#

initializeLixoftConnectors("monolix")

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

assesSettings <- getAssessmentSettings()

assesSettings$initialParameters$fixed <- rep(FALSE, 3)

assesSettings$initialParameters$min <- rep(0, 3)

assesSettings$initialParameters$max <- c(1.5, 1, 0.5)

assesSettings$extendedEstimation <- TRUE

runAssessment(settings = assesSettings) 

res = getAssessmentResults()

## End(Not run)

[Monolix] Get convergence assessment settings

Description

Get the current settings for running the convergence assessment. These are the settings that will be used if runAssessment
is called without argument, or they can be used as a template to update and pass to runAssessment in order to change the settings.
Note that ‘fixed’ in the initialParameters data.frame refers to whether the the initial value of the parameter is fixed for the assessment or
whether it should be sampled for each run, not whether the parameter is fixed for estimation purposes.

Usage

getAssessmentSettings()

Value

The list of settings

• nbRuns: (integer) number of runs
• extendedEstimation: (logical) if TRUE, standard errors and log-likelihood are estimated
• useLin: (logical) if TRUE, use linearization to estimate standard errors and log-likelihood instead of stochastic approximation (sd) and importance sampling (ll)
• initialParameters: (data.frame) a data.frame with columns parameters (name of each parameter), fixed (logical TRUE if its initial value is fixed or else FALSE),
  min, and max (the bounds within which the initial value is drawn for non-fixed parameters)

See Also

runAssessment to run the assesment

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

getAssessmentSettings()

[Monolix] Run convergence assessment

Description

Run assessment.
To change the initialization before a run, use getAssessmentSettings to receive all the settings. See example.

Usage

runAssessment(settings = NULL)

Arguments

See Also

getAssessmentSettings to get the settings
getAssessmentResults to get the results of the run

#

initializeLixoftConnectors("monolix")

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

assesSettings <- getAssessmentSettings()

assesSettings$initialParameters$fixed <- rep(FALSE, 3)

assesSettings$initialParameters$min <- rep(0, 3)

assesSettings$initialParameters$max <- c(1.5, 1, 0.5)

runAssessment(settings = assesSettings) 

res = getAssessmentResults()

## End(Not run)

[Monolix] Add transformed categorical covariate

Description

Create a new categorical covariate by transforming an existing one. Transformed covariates cannot be use to produce new covariates.
Call getCovariateInformation to find out which covariates can be transformed.Those of type "categorical" can be used.

Usage

addCategoricalTransformedCovariate(...)

Arguments

See Also

getCovariateInformation get current covariates in the model
addContinuousTransformedCovariate to add a transformation of a continuous covariate
addMixture to add a latent covariate
removeCovariate to remove added covariates

#

project_file <- file.path(getDemoPath(), "0.data_formatting", "DoseAndLOQ_byCategory.mlxtran")

loadProject(project_file)

addCategoricalTransformedCovariate( AGG_STUDY = list(from = "STUDY", 

                                                     reference = "SD_low", 

                                                     transformed = list( SD_low = c("SD_400mg", "SD_500mg"), SD_high = c("SD_600mg"))) ) 

getCovariateInformation()

[Monolix] Add transformed continuous covariate

Description

Create a new continuous covariate by transforming an existing one. Transformed covariates cannot be use to produce new covariates.
Call getCovariateInformation to find out which covariates can be transformed. Those of type "continuous" can be used.

Usage

addContinuousTransformedCovariate(...)

Arguments

See Also

getCovariateInformation get current covariates in the model
addCategoricalTransformedCovariate to add a transformation of a categorical covariate
addMixture to add a latent covariate
removeCovariate remove added covariates

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

addContinuousTransformedCovariate( logtWEIGHT = "log(WEIGHT/70)"  )

getCovariateInformation()

[Monolix] Add latent covariate to the model for a finite mixture model

Description

Add a new latent covariate to the current model giving its name and its modality number (how many subpopulations).

Usage

addMixture(...)

Arguments

See Also

getCovariateInformation get current covariates in the model
addContinuousTransformedCovariate to add a transformation of a continuous covariate
addCategoricalTransformedCovariate to add a transformation of a categorical covariate
removeCovariate to remove added covariates

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.3.mixture_of_distributions", "PKgroup_project.mlxtran")

loadProject(project_file)

addMixture(lcat = 2)

getCovariateInformation()

[Monolix] Remove covariate

Description

Remove any of the transformed covariates (discrete and continuous) and/or latent covariates.
Call getCovariateInformation to know which covariates can be removed (only those with type "categoricaltransformed",
"continuoustransformed" or "latent").

Usage

removeCovariate(...)

Arguments

See Also

getCovariateInformation get current covariates in the model
addContinuousTransformedCovariate to add a transformation of a continuous covariate
addCategoricalTransformedCovariate to add a transformation of a categorical covariate
addMixture to add a latent covariate

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

addContinuousTransformedCovariate( logtWEIGHT = "log(WEIGHT/70)"  )

getCovariateInformation()

removeCovariate("logtWEIGHT")

getCovariateInformation()

[Monolix – PKanalix] Add an additional covariate

Description

Create an additional covariate for stratification purpose. Notice that these covariates are available only if they are not
contant through the dataset.
Available column transformations are:

Usage

addAdditionalCovariate(transformation, base = "", name = "")

Arguments

See Also

deleteAdditionalCovariate

#

addAdditionalCovariate("firstDoseAmount")

addAdditionalCovariate(transformation = "observationNumberPerIndividual", headerName = "CONC")

## End(Not run)

[Monolix – PKanalix] Apply filter

Description

Apply a filter on the current data.

Usage

applyFilter(filter, name = "")

Arguments

Details

The possible actions are line selection (selectLines), line removal (removeLines), Ids selection (selectIds) or removal (removeIds).
The selection is a string containing the header name, a comparison operator and a value
selection = <character> "headerName*-comparator**-value" (ex: "id==’100’", "WEIGHT<70", "SEX!=’M’")
Notice that :
– The headerName corresponds to the data set header or one of the header aliases defined in MONOLIX software preferences
– The comparator possibilities are "==", "!=" for all types of value and "<=", "<", ">=", ">" only for numerical types

Syntax:
* apply a simple filter:
applyFilter( filter = list(act = sel)), e.g. applyFilter( filter = list(removeIds = "WEIGHT<50"))
=> apply a filter with the action act on the selection sel. In this example, we apply a filter that removes all subjects with a weight less than 50.
* apply a filter with several concurrent conditions, i.e AND condition:
applyFilter( list(act1 = sel1, act2 = sel2)), e.g. applyFilter( filter = list(removeIds = "WEIGHT<50", removeIds = " AGE<20"))
=> apply a filter with both the action act1 on sel1 AND the action act2 on sel2. In this example, we apply a filter that removes all subjects with a weight less than 50 and an age less than 20.
It corresponds to the intersecton of the subjects with a weight less than 50 and the subjects with an age less than 20.
* apply a filter with several non-concurrent conditions, i.e OR condition:
applyFilter(filter = list(list(act1 = sel1), list(act2 = sel2)) ), e.g. applyFilter( filter = list(list(removeIds = "WEIGHT<50"),list(removeIds = " AGE<20")))
=> apply a filter with the action act1 on sel1 OR the action act2 on sel2. In this example, we apply a filter that removes all subjects with a weight less than 50 and an age less than 20.
It corresponds to the union of the subjects with a weight less than 50 and the subjects with an age less than 20.
* It is possible to have any combination:

applyFilter(filter = list(list(act1 = sel1), list(act2 = sel2, act3 = sel3)) ) <=> act1,sel1 OR ( act2,sel2 AND act3,sel3 )

* It is possible to apply the complement of an existing filter:

applyFilter(filter = "complement")

See Also

getAvailableData createFilter removeFilter

#

----------------------------------------------------------------------------------------

LINE [ integer ]

applyFilter( filter = list(removeLines = "line>10") ) # keep only the 10th first rows

----------------------------------------------------------------------------------------

ID [ character | integer ]

If there are only integer identifiers within the data set, ids will be considered as integers. On the contrary, they will be treated as character data.

applyFilter( filter = list(selectIds = "id==100") ) # select the subject called '100'

applyFilter( filter = list(list(removeIds = "id!='id_2'")) ) # select all the subjects excepted the one called 'id_2'

----------------------------------------------------------------------------------------

ID INDEX [integer]

applyFilter( filter = list(list(removeIds = "idIndex!=2"), list(selectIds = "id<5")) ) # select the 4 first subjects excepted the second one

----------------------------------------------------------------------------------------

OCC [ integer ]

applyFilter( filter = list(selectIds = "occ1==1", removeIds = "occ2!=3") ) # select the subjects whose first occasion level is '1' and whose second one is different from '3'

----------------------------------------------------------------------------------------

TIME [ double ]

applyFilter( filter = list(removeIds='TIME>120') ) # remove the subjects who have time over 120

applyFilter( filter = list(selectLines='TIME>120') ) # remove the all the lines where the time is over 120

----------------------------------------------------------------------------------------

OBSERVATION [ double ]

applyFilter( filter = list(selectLines = "CONC>=5.5", removeLines = "CONC>10")) # select the lines where CONC value superior or equal to 5.5 or strictly higher than 10

applyFilter( filter = list(removeIds = "CONC<0") ) # remove subjects who have negative CONC values

applyFilter( filter = list(removeIds = "E==0") ) # remove subjects for who E equals 0

----------------------------------------------------------------------------------------

OBSID [ character ]

applyFilter( filter = list(removeIds = "y1==1") ) # remove subject who have at least one observation for y1

applyFilter( filter = list(selectLines = "y1!=2") ) # select all lines corresponding to observations exepected those for y2

----------------------------------------------------------------------------------------

AMOUNT [ double ]

applyFilter( filter = list(selectIds = "AMOUT==10") ) # select subjects who have a dose equals to 10

----------------------------------------------------------------------------------------

INFUSION RATE AND INFUSION DURATION [ double ]

applyFilter( filter = list(selectIds = "RATE<10") ) # select subjects who have dose with a rate less than 10

----------------------------------------------------------------------------------------

COVARIATE [ character (categorical) | double (continuous) ]

applyFilter( filter = list(selectIds = "SEX==M", selectIds = "WEIGHT<80") ) # select subjects who are men and whose weight is lower than 80kg

----------------------------------------------------------------------------------------

REGERSSOR [ double ]

applyFilter( filter = list(selectLines = "REG>10") ) # select the lines where the regressor value is over 10

----------------------------------------------------------------------------------------

COMPLEMENT

applyFilter(origin = "data_filtered", filter = "complement" )

## End(Not run)

[Monolix – PKanalix] Create filter

Description

Create a new filtered data set by applying a filter on an existing one and/or complementing it.

Usage

createFilter(filter, name = "", origin = "")

Arguments

Details

The possible actions are line selection (selectLines), line removal (removeLines), Ids selection (selectIds) or removal (removeIds).
The selection is a string containing the header name, a comparison operator and a value
selection = <character> "headerName*-comparator**-value" (ex: "id=='100'", "WEIGHT<70", "SEX!='M'")
Notice that :
– The headerName corresponds to the data set header or one of the header aliases defined in MONOLIX software preferences
– The comparator possibilities are "==", "!=" for all types of value and "<=", "<", ">=", ">" only for numerical types

Syntax:
* create a simple filter:
createFilter( filter = list(act = sel)), e.g. createFilter( filter = list(removeIds = "WEIGHT<50"))
=> create a filter with the action act on the selection sel. In this example, we create a filter that removes all subjects with a weight less than 50.
* create a filter with several concurrent conditions, i.e AND condition:
createFilter( list(act1 = sel1, act2 = sel2)), e.g. createFilter( filter = list(removeIds = "WEIGHT<50", removeIds = " AGE<20"))
=> create a filter with both the action act1 on sel1 AND the action act2 on sel2. In this example, we create a filter that removes all subjects with a weight less than 50 and an age less than 20.
It corresponds to the intersecton of the subjects with a weight less than 50 and the subjects with an age less than 20.
* create a filter with several non-concurrent conditions, i.e OR condition:
createFilter(filter = list(list(act1 = sel1), list(act2 = sel2)) ), e.g. createFilter( filter = list(list(removeIds = "WEIGHT<50"),list(removeIds = " AGE<20")))
=> create a filter with the action act1 on sel1 OR the action act2 on sel2. In this example, we create a filter that removes all subjects with a weight less than 50 and an age less than 20.
It corresponds to the union of the subjects with a weight less than 50 and the subjects with an age less than 20.
* It is possible to have any combinaison:

createFilter(filter = list(list(act1 = sel1), list(act2 = sel2, act3 = sel3)) ) <=> act1,sel1 OR ( act2,sel2 AND act3,sel3 )

* It is possible to create the complement of an existing filter:

createFilter(filter = "complement")

See Also

applyFilter

#

----------------------------------------------------------------------------------------

LINE [ integer ]

createFilter( filter = list(removeLines = "line>10") ) # keep only the 10th first rows

----------------------------------------------------------------------------------------

ID [ character | integer ]

If there are only integer identifiers within the data set, ids will be considered as integers. On the contrary, they will be treated as character data.

createFilter( filter = list(selectIds = "id==100") ) # select the subject called '100'

createFilter( filter = list(list(removeIds = "id!='id_2'")) ) # select all the subjects excepted the one called 'id_2'

----------------------------------------------------------------------------------------

ID INDEX [integer]

createFilter( filter = list(list(removeIds = "idIndex!=2"), list(selectIds = "id<5")) ) # select the 4 first subjects excepted the second one

----------------------------------------------------------------------------------------

OCC [ integer ]

createFilter( filter = list(selectIds = "occ1==1", removeIds = "occ2!=3") ) # select the subjects whose first occasion level is '1' and whose second one is different from '3'

----------------------------------------------------------------------------------------

TIME [ double ]

createFilter( filter = list(removeIds='TIME>120') ) # remove the subjects who have time over 120

createFilter( filter = list(selectLines='TIME>120') ) # remove the all the lines where the time is over 120

----------------------------------------------------------------------------------------

OBSERVATION [ double ]

createFilter( filter = list(selectLines = "CONC>=5.5", removeLines = "CONC>10")) # select the lines where CONC value superior or equal to 5.5 or strictly higher than 10

createFilter( filter = list(removeIds = "CONC<0") ) # remove subjects who have negative CONC values

createFilter( filter = list(removeIds = "E==0") ) # remove subjects for who E equals 0

----------------------------------------------------------------------------------------

OBSID [ character ]

createFilter( filter = list(removeIds = "y1==1") ) # remove subject who have at least one observation for y1

createFilter( filter = list(selectLines = "y1!=2") ) # select all lines corresponding to observations exepected those for y2

----------------------------------------------------------------------------------------

AMOUNT [ double ]

createFilter( filter = list(selectIds = "AMOUT==10") ) # select subjects who have a dose equals to 10

----------------------------------------------------------------------------------------

INFUSION RATE AND INFUSION DURATION [ double ]

createFilter( filter = list(selectIds = "RATE<10") ) # select subjects who have dose with a rate less than 10

----------------------------------------------------------------------------------------

COVARIATE [ character (categorical) | double (continuous) ]

createFilter( filter = list(selectIds = "SEX==M", selectIds = "WEIGHT<80") ) # select subjects who are men and whose weight is lower than 80kg

----------------------------------------------------------------------------------------

REGERSSOR [ double ]

createFilter( filter = list(selectLines = "REG>10") ) # select the lines where the regressor value is over 10

----------------------------------------------------------------------------------------

COMPLEMENT

createFilter(origin = "data_filtered", filter = "complement" )

## End(Not run)

[Monolix – PKanalix] Delete additional covariate

Description

Delete a created additinal covariate.

Usage

deleteAdditionalCovariate(name)

Arguments

See Also

addAdditionalCovariate

#

deleteAdditionalCovariate("firstDoseAmount")\cr

deleteAdditionalCovariate("observationNumberPerIndividual_y1")

## End(Not run)

[Monolix – PKanalix] Delete filter

Description

Delete a data set. Only filtered data set which are not active and whose children are not active either can be deleted.

Usage

deleteFilter(name)

Arguments

See Also

createFilter

#

deleteFilter(name = "filter2")

## End(Not run)

[Monolix – PKanalix] Edit filter

Description

Edit the definition of an existing filtered data set. Refere to createFilter for more details about syntax, allowed parameters and examples.
Notice that all the filtered data set which depend on the edited one will be deleted.

Usage

editFilter(filter, name = "")

Arguments

See Also

createFilter

[Monolix – PKanalix] Adapt and export a data file as a MonolixSuite formatted data set.

Description

Adapt and export a data file as a MonolixSuite formatted data set.

Usage

formatData(
  dataFile,
  formattedFile,
  headerLines = 1,
  headers,
  linesToExclude = NULL,
  observationSettings = NULL,
  observations = NULL,
  treatmentSettings = NULL,
  treatments = NULL,
  additionalColumns = NULL,
  sheet = NULL
)

Arguments

Details

Data formatting can be performed as in the Data Formatting Tab of Monolix and PKanalix interface. Look at the examples to see how each data formatting demo project could be created with the connectors.

See Also

getFormatting

#

initializeLixoftConnectors(software = "pkanalix")

FormattedDataPath = tempfile("formatted_data", fileext = ".csv")

formatData(paste0(getDemoPath(),"/0.data_formatting/data/units_BLQ_tags_data.csv"),

           formattedFile = FormattedDataPath,

           headerLines = c(1,2),

           headers = c(id="ID", time="TIME"),

           observations = list(header="CONC",

                               censoring = list(type="interval", tags = c("BLQ"), 

                                                limits=list(0,"LLOQ"))),

           treatments = list(times=0, amount=100))

colnames(read.csv(FormattedDataPath)) # to check column names of the generated file and tag them as desired

newProject(data = list(dataFile = FormattedDataPath, headerTypes = c("id","time","observation","contcov","contcov","catcov","ignore","amount","cens","limit")))

plotObservedData()

# demo merge_occ_ParentMetabolite.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/parent_metabolite_data.csv"),

           formattedFile = FormattedDataPath,

           headers = c(id="ID", time="TIME"),

           observations = list(list(header="PARENT",

                                    censoring = list(type="interval", tags = c("BLQ"), limits=list(0,0.01))),

                               list(header="METABOLITE")),

           observationSettings = list(distinguishWithObsId = FALSE),

           treatments = list(times=0, amount="DOSE"))

# demo merge_obsID_ParentMetabolite.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/parent_metabolite_data.csv"),

           formattedFile = FormattedDataPath,

           headers = c(id="ID", time="TIME"),

           observations = list(list(header="PARENT",

                                    censoring = list(type="interval", tags = c("BLQ"), limits=list(0,0.01))),

                               list(header="METABOLITE")),

           treatments = list(times=0, amount="DOSE"))

# demo DoseAndLOQ_byCategory.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/units_BLQ_tags_data.csv"),

           formattedFile = FormattedDataPath,

           headerLines = c(1,2),

           headers = c(id="ID", time="TIME"),

           observations = list(header="CONC",

                               censoring = list(type="interval", tags = c("BLQ"), 

                                                limits=list(0,list(category="STUDY",

                                                                   values=list("SD_400mg"=0.01, "SD_500mg"=0.1, "SD_600mg"=0.1))))),

           treatments = list(times=0, amount=list(category="STUDY",

                                                  values=list("SD_400mg"=400, "SD_500mg"=500, "SD_600mg"=600))))

# demo DoseAndLOQ_fromData.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/units_BLQ_tags_data.csv"),

           formattedFile = FormattedDataPath,

           headerLines = c(1,2),

           headers = c(id="ID", time="TIME"),

           observations = list(header="CONC",

                               censoring = list(type="interval", tags = c("BLQ"), 

                                                limits=list(0,"LLOQ"))),

           treatments = list(times=0, amount="STUDY"))

# demo DoseAndLOQ_manual.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/units_multiple_BLQ_tags_data.csv"),

           formattedFile = FormattedDataPath,

           headerLines = c(1,2),

           headers = c(id="ID", time="TIME"),

           observations = list(header="CONC",

                               censoring = list(list(type="interval", tags = c("BLQ1"), limits=list(0,0.06)),

                                                list(type="interval", tags = c("BLQ2"), limits=list(0,0.1)))),

           treatments = list(times=0, amount=600))

# demo Urine_LOQinObs.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/urine_LOQinObs_data.csv"),

           formattedFile = FormattedDataPath,

           headers = c(id="ID", start="START TIME", end="END TIME", volume="VOLUME"),

           observations = list(header="CONC", 

                               censoring=list(type="LLOQ", tags="<LOQ=1>", limits="CONC")),

           treatments = list(paste0(getDemoPath(),"/0.data_formatting/data/urine_data_doses.csv")))

# demo CreateOcc_AdmIdbyCategory.pkx

formatData(paste0(getDemoPath(),"/0.data_formatting/data/two_formulations_data.csv"),

           formattedFile = FormattedDataPath,

           linesToExclude = 1, headerLines = c(2,3),

           headers = c(id="ID", time="TIME", sort="FORM"),

           observations = list(header="CONC",

                               censoring=list(type="LLOQ", tags="BLQ", limits=0.06)),

           treatments = list(times=0, amount=600, admId=list(category="FORM", values=list("ref"=1,"test"=2))))

# MONOLIX EXAMPLES

initializeLixoftConnectors(software = "monolix")

FormattedDataPath = tempfile("formatted_data")

# demo doseIntervals_as_Occ.mlxtran

formatData(paste0(getDemoPath(),"/0.data_formatting/data/data_multidose.csv"),

           formattedFile = FormattedDataPath,

           headers = c(id="ID", time="TIME"),

           observations = list(header="CONC"),

           treatments = list(times=seq(0,by=12,length=7), amount=40),

           treatmentSettings = list(doseIntervalsAsOccasions = TRUE))

# demo warfarin_PKPDseq_project.mlxtran

formatData(paste0(getDemoPath(),"/0.data_formatting/data/warfarin_data.csv"),

           formattedFile = FormattedDataPath,

           headers = c(id="id", time="time"),

           additionalColumns = paste0(getDemoPath(),"/0.data_formatting/data/warfarinPK_regressors.txt"))

[Monolix – PKanalix] Get data sets descriptions

Description

Get information about the data sets and filters defined in the project.

Usage

getAvailableData()

Value

A list containing a list containing elements that describe the data set:

• name: (character) the name of the data set
• file: (character) the path of the data set file
• current: a logical indicating if the data set is applied (currently in use)
• children: a list containing lists with information about data sets created from this one using filters
• filter (only if the dataset was created using filters): a list containing name of the parent and details about filter definition

#

getAvailableData()

## End(Not run)

[Monolix – PKanalix] Get covariates information

Description

Get the name, the type and the values of the covariates present in the project.

Usage

getCovariateInformation()

Value

A list containing the following fields :

• name (vector<character>): covariate names
• type (vector<character>): covariate types. Existing types are "continuous", "continuoustransformed", "categorical", "categoricaltransformed"./
  In Monolix mode, "latent" covariates are also allowed.

• range (vector<pair<double>>): continuous covariate ranges
• categories (vector<vector<character>>): discrete covariates modalities
• [Monolix] modalityNumber (vector<integer>): number of modalities (for latent covariates only)
• covariate: a data frame giving the values of continuous and categorical covariates for each subject.
  Latent covariate values exist only if they have been estimated, ie if the covariate is used and if the population parameters have been estimated.
  Call getEstimatedIndividualParameters to retrieve them.

#

info = getCovariateInformation() # Monolix mode with latent covariates

info

  -> $name

     c("sex","wt","lcat")

  -> $type

     c(sex = "categorical", wt = "continuous", lcat = "latent")

  -> $range

     list(wt = c(55, 73.5))

  -> $categories

     c(sex = c("F", "M"))

  -> $modalityNumber

     c(lcat = 2)

  -> $covariate

     id   sex    wt

      1    M   66.7

      .    .      .

      N    F   59.0

## End(Not run)

[Monolix – PKanalix] Get data formatting from a loaded project

Description

Get data formatting settings from a loaded project.
It returns a list with the same items as the arguments of formatData, where the header items correspond to formatted headers if they have been changed by Data Formatting, and in addition:

• originalHeaders (character) – list of original names of the columns used for data formatting.

Usage

getFormatting()

See Also

formatData

#

initializeLixoftConnectors(software = "pkanalix")

loadProject(paste0(getDemoPath(),"/0.data_formatting/DoseAndLOQ_manual.pkx"))

getFormatting()

}

[Monolix – PKanalix] Get observations information

Description

Get the name, the type and the values of the observations present in the project.

Usage

getObservationInformation()

Value

A list containing the following fields :

• name (vector<character>): observation names.
• type (vector<character>): observation generic types. Existing types are "continuous", "discrete", "event".
• [Monolix] detailedType (vector<character>): observation specialized types set in the structural model. Existing types are "continuous", "bsmm", "wsmm", "categorical", "count", "exactEvent", "intervalCensoredEvent".
• [Monolix] mapping (vector<character>): mapping between the observation names (defined in the mlxtran project) and the name of the corresponding entry in the data set.
• ["obsName"] (data.frame): observation values for each observation id.

In PKanalix mode, the observation type is not provided as only continuous observations are allowed. Neither do the mapping as dataset names are always used.

#

info = getObservationInformation()

info

  -> $name

     c("concentration")

  -> $type # [Monolix]

     c(concentration = "continuous")

  -> $detailedType # [Monolix]

     c(concentration = "continuous")

  -> $mapping # [Monolix]

     c(concentration = "CONC")

  -> $concentration

       id   time concentration

        1    0.5     0.0

        .    .      .

        N    9.0    10.8

## End(Not run)

[Monolix – PKanalix] Get treatments information

Description

Get information about doses present in the loaded dataset.

Usage

getTreatmentsInformation()

Value

A dataframe whose columns are:

• id and occasion level names (character)
• time (double)
• amount (double)
• [optional] administrationType (integer)
• [optional] infusionTime (logical)
• [optional] isArtificial (logical): is created from SS or ADDL column
• [optional] isReset (logical): IOV case only

#

## Not run: 

initializeLixoftConnectors("monolix")

project_name <- file.path(getDemoPath(), "6.PK_models", "6.3.multiple_doses", "ss1_project.mlxtran")

loadProject(project_name)

getTreatmentsInformation()

## End(Not run)

}

[Monolix – PKanalix] Remove filter

Description

Remove the last filter applied on the current data set.

Usage

removeFilter()

See Also

applyFilter selectData

#

removeFilter()

## End(Not run)

[Monolix – PKanalix] Rename additional covariate

Description

Rename an existing additional covariate.

Usage

renameAdditionalCovariate(oldName, newName)

Arguments

See Also

addAdditionalCovariate

#

renameAdditionalCovariate(oldName = "observationNumberPerIndividual_y1", newName = "nbObsForY1")

## End(Not run)

[Monolix – PKanalix] Rename filter

Description

Rename an existing filtered data set.

Usage

renameFilter(newName, oldName = "")

Arguments

See Also

createFilter editFilter

#

renameFilter("newFilter")\cr

renameFilter(oldName = "filter", newName = "newFilter")  

## End(Not run)

[Monolix – PKanalix] Select data set

Description

Select the new current data set within the previously defined ones (original and filters).

Usage

selectData(name)

Arguments

See Also

getAvailableData

#

selectData(name = "filter1")

## End(Not run)

[Monolix] Get individual parameter model

Description

Get a summary of the individual parameter model. The available information is the following:

• name: (character) vector of names of the individual parameters
• distribution: (character) vector giving the probability distribution of each parameter. The distribution can be one of
  "normal", "logNormal", or "logitNormal".

• limits: (double) a list giving the distribution limits for each parameter with a "logitNormal" distribution
• formula: (character) the formula used for each parameter
• variability: (logical) a list giving, for each variability level, a vector with TRUE for each individual parameter that has variability or FALSE if not.
• covariateModel: (logical) a list giving, for each individual parameter, a vector with TRUE for each covariate that is included in the model for that parameter or FALSE if not.
  If there are no covariates in the model, this is an empty list.

• correlationBlocks: (character) a list with, for each variability level, a list of correlations, where each correlation block is a vector of the parameter names included in that correlation.
  If there are no correlations in the model, this is omitted.

Usage

getIndividualParameterModel()

Value

A list containing the individual parameter model elements

See Also

setIndividualParameterModel to change the individual parameter model

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setIndividualParameterVariability to update just the individual parameter variability
setCovariateModel to update just the covariate model
setCorrelationBlocks to update just the correlation structure

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.1.probability_distribution", "warfarin_distribution3_project.mlxtran")

loadProject(project_file)

indivModel <- getIndividualParameterModel()

[Monolix] Get variability levels

Description

Get a summary of the variability levels (inter-individual and/or intra-individual variability, i.e. random effects)
present in the current project.

Usage

getVariabilityLevels()

Value

A vector of the variability levels present in the currently loaded project.

See Also

getIndividualParameterModel to see the current individual parameter model settings

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.4.inter_occasion_variability", "iov1_project.mlxtran")

loadProject(project_file)

getVariabilityLevels()

[Monolix] Set correlation block structure

Description

Define the correlation block structure associated to some of the variability levels of the current project.
Call getVariabilityLevels to get a list of the variability levels and getIndividualParameterModel
to get a list of the available individual parameters within the current project.

Usage

setCorrelationBlocks(...)

Arguments

See Also

getVariabilityLevels to see the variability levels
getIndividualParameterModel to see the current individual parameter model settings
setIndividualParameterModel to change the individual parameter model

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setIndividualParameterVariability to update just the individual parameter variability
setCovariateModel to update just the covariate model

#

# creating multiple correlation blocks

loadProject( file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPK_project.mlxtran") )

setCorrelationBlocks(id = list(  c("ka","Cl"), c("Tlag","V") ) )

getIndividualParameterModel()$correlationBlocks

# creating blocks at multiple variability levels

loadProject( file.path(getDemoPath(), "5.models_for_individual_parameters", "5.4.inter_occasion_variability", "iov1_project.mlxtran") )

setIndividualParameterVariability(list(OCC = c(Cl = TRUE))) # parameter must have variability to be included in correlation

setCorrelationBlocks(id = list( c("ka","V", "Cl") ), OCC = list( c("Cl","V") ) )

getIndividualParameterModel()$correlationBlocks

[Monolix] Set covariate model

Description

Set which are the covariates influencing individual parameters present in the project.
Call getIndividualParameterModel to get a list of the individual parameters present within the current project.
and getCovariateInformation to know which are the available covariates for a given level of variability and a given individual parameter.

Usage

setCovariateModel(...)

Arguments

See Also

getCovariateInformation to see available covariates
getIndividualParameterModel to see the current individual parameter model settings
setIndividualParameterModel to change the individual parameter model

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setIndividualParameterVariability to update just the individual parameter variability
setCorrelationBlocks to update just the correlation structure

#

loadProject( file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran") )

setCovariateModel( ka = c( SEX = TRUE, WEIGHT = TRUE),

                   V = c( WEIGHT = TRUE ) )

getIndividualParameterModel()$covariateModel

[Monolix] Set individual parameter distribution limits

Description

Set the minimum and the maximum values for an individual parameter.
Limits only apply to parameters with a "logitNormal" distribution.
Call getIndividualParameterModel to get a list of the available
parameters within the current project. The initial estimate of the
parameter must be inside the limits, which can be set with setPopulationParameterInformation.

Usage

setIndividualLogitLimits(...)

Arguments

See Also

getIndividualParameterModel to see the current individual parameter model settings
setIndividualParameterModel to change the individual parameter model
getPopulationParameterInformation to see the parameter initial values
setPopulationParameterInformation to change the parameter initial values

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualParameterVariability to update just the individual parameter variability
setCovariateModel to update just the covariate model
setCorrelationBlocks to update just the correlation structure

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.1.probability_distribution", "warfarin_distribution3_project.mlxtran")

loadProject(project_file)

setIndividualParameterDistribution(V = "logitNormal", ka = "logitNormal")

setPopulationParameterInformation(V_pop  = list(initialValue = 0.5))

setIndividualLogitLimits( V = c(0, 1), ka = c(-1, 2) )

getIndividualParameterModel()$limits

[Monolix] Set individual parameter distribution

Description

Set the distribution of the estimated parameters.
Available distributions are "normal", "logNormal" and "logitNormal".
Call getIndividualParameterModel to get a list of the available individual parameters within the current project.

Usage

setIndividualParameterDistribution(...)

Arguments

See Also

getIndividualParameterModel to see the current individual parameter model settings
setIndividualParameterModel to change the individual parameter model

The components of the individual parameter model can be updated individually:
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setIndividualParameterVariability to update just the individual parameter variability
setCovariateModel to update just the covariate model
setCorrelationBlocks to update just the correlation structure

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.1.probability_distribution", "warfarin_distribution3_project.mlxtran")

loadProject(project_file)

setIndividualParameterDistribution(V = "normal")

setIndividualParameterDistribution(Cl = "normal", V = "logNormal")

getIndividualParameterModel()$distribution

[Monolix] Set individual parameter model

Description

Update the individual parameter model. The following information is editable:

• distribution: (character) vector giving the probability distribution of each parameter.
  The distribution can be one of "normal", "logNormal", or "logitNormal".

• limits: (double) a list giving the distribution limits for each parameter with a
  "logitNormal" distribution

• variability: (logical) a list giving, for each variability level, a vector
  with TRUE for each individual parameter that has variability or FALSE if not.

• covariateModel: (logical) a list giving, for each individual parameter,
  a vector with TRUE for each covariate that is included in the model for that parameter or FALSE if not.

• correlationBlocks: a list with, for each variability level, a list of correlations,
  where each correlation block is a vector of the parameter names included in that correlation.
  Parameters must have random effects to be included in correlations.

Usage

setIndividualParameterModel(...)

Arguments

See Also

getIndividualParameterModel to see the current individual parameter model settings

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setIndividualParameterVariability to update just the individual parameter variability
setCovariateModel to update just the covariate model
setCorrelationBlocks to update just the correlation structure

#

project_file <- file.path(getDemoPath(), "5.models_for_individual_parameters", "5.1.probability_distribution", "warfarin_distribution3_project.mlxtran")

loadProject(project_file)

# change the distribution of parameter V to be a logitNormal between 0 and 30

setIndividualParameterModel(list(distribution = c(V = "logitNormal"), limits = list(V = c(0, 30))))

getIndividualParameterModel()

# remove correlation and add covariate wt on Cl

setIndividualParameterModel(list( correlationBlocks = list(id = list()), 

                                  covariateModel = list(Cl = c(sex = FALSE, age = FALSE, wt = TRUE))) )

getIndividualParameterModel()

# remove variability (random effects) on parameter ka

setIndividualParameterModel(list(variability = list(id = c(ka = FALSE))))

getIndividualParameterModel()

[Monolix] Individual variability management

Description

Add or remove inter-individual and/or intra-individual variability (i.e. random effects) from some of the individual parameters present in the project.
Call getIndividualParameterModel to get a list of the available parameters within the current project.

Usage

setIndividualParameterVariability(...)

Arguments

See Also

getIndividualParameterModel to see the current individual parameter model settings
getVariabilityLevels to get a list of the variability levels
setIndividualParameterModel to change the individual parameter model

The components of the individual parameter model can be updated individually:
setIndividualParameterDistribution to update just the individual parameter distributions
setIndividualLogitLimits to update just the limits for parameters with a logit distribution
setCovariateModel to update just the covariate model
setCorrelationBlocks to update just the correlation structure

#

loadProject( file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran") )

setIndividualParameterVariability(ka = TRUE, V = FALSE)

getIndividualParameterModel()$variability

# multiple variability levels

loadProject( file.path(getDemoPath(), "5.models_for_individual_parameters", "5.4.inter_occasion_variability", "iov1_project.mlxtran") )

setIndividualParameterVariability(id = list(ka = FALSE, V = FALSE), OCC = list(ka = TRUE))

getIndividualParameterModel()$variability

[Monolix] Automatically estimate initial parameter values

Description

Compute initial values for fixed-effect population parameters. The values are returned in the same format
as getPopulationParameterInformation and can be passed to setPopulationParameterInformation to
set the inital values.

Usage

getFixedEffectsByAutoInit(ids = NULL)

Arguments

See Also

getPopulationParameterInformation to get the current population parameter information, including initial values
setPopulationParameterInformation to set the population parameter information (e.g. with the results of this method)
setInitialEstimatesToLastEstimates to set the population parameter initial values to the last estimated values

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

initValues <- getFixedEffectsByAutoInit()

setPopulationParameterInformation(initValues)

# restrict initial value estimation to only certain individuals

# (most useful when there are many similar individuals and estimation takes a long time)

initValues <- getFixedEffectsByAutoInit(ids = 1:10)

[Monolix] Get population parameters information

Description

Get population parameters information.
Get the name, the initial value, the estimation method and, if relevant, MAP (Maximum A Posteriori) parameter values
of the population parameters in the project.
Information is available for fixed effects (with suffix "_pop"), random effects (with prefix "omega_"),
error model parameters (i.e. a, b, c), covariates (with prefix "beta_") including latent covariate
probabilities (with prefix "p" and numeric suffix), and correlations (with prefix "corr_").

Usage

getPopulationParameterInformation()

Details

Available estimation methods are:

Value

A data frame giving, for each population parameter, the following information:

• name: (character) parameter name
• initialValue: (double) initial value
• method: (character) estimation method (see Details)
• priorValue: (double) [MAP only] typical value for prior
• priorSD: (double) [MAP only] standard deviation for prior

See Also

setPopulationParameterInformation to set the population parameter information
getEstimatedPopulationParameters to get the population parameters estimated values
setInitialEstimatesToLastEstimates to set the population parameter initial values to the last estimated values
getFixedEffectsByAutoInit to estimate initial values for the population parameters

#

# simple model (MLE/FIXED)

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

getPopulationParameterInformation()

# model with MAP

loadProject(file.path(getDemoPath(), "7.miscellaneous", "7.2.bayesian_estimation", "theobayes1_project.mlxtran"))

getPopulationParameterInformation()

[Monolix] Initialize population parameters with the last estimated ones

Description

Set the initial value of all the population parameters in the current project to the ones previously estimated.
These the values will be used in the population parameter estimation algorithm the next time the scenario is run.
WARNING: If there are changes to the model after the last run, it will not be possible to set the
initial values, as the structure of the project has changed since the last results. Call runPopulationParameterEstimation
to rerun the estimates before calling this method.

Usage

setInitialEstimatesToLastEstimates(fixedEffectsOnly = FALSE)

Arguments

See Also

getEstimatedPopulationParameters to get the population parameters estimated values
(that values that will be used by this method_)
getPopulationParameterInformation to get the current population parameter information, including initial values
runPopulationParameterEstimation to estimate the population parameters
setPopulationParameterInformation to set the population parameter information
getFixedEffectsByAutoInit to estimate initial values for the population parameters

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

getPopulationParameterInformation()

runPopulationParameterEstimation()

# set only initial values for fixed effects to the last estimated values

setInitialEstimatesToLastEstimates(fixedEffectsOnly = TRUE)

getPopulationParameterInformation()

# set all parameter initial values to last estimated values

setInitialEstimatesToLastEstimates() 

getPopulationParameterInformation()

[Monolix] Set population parameters initialization and estimation method

Description

Set population parameters initialization and estimation method.
Set the initial value, the estimation method and, if relevant, the MAP parameters of one or more
of the population parameters present within the current project. This includes fixed effects,
random effects, error model, covariate, and correlation parameters.

Usage

setPopulationParameterInformation(...)

Arguments

Details

Available estimation methods are:

Call getPopulationParameterInformation to get a list of the initializable population parameters present within the current project.

For the "MAP" estimation method, the user can specify the associated typical value and standard deviation values by using additional list elements:

paramName = list( initialValue = (double), method = "MAP", priorValue = (double), priorSD = (double) )

By default, the prior value corresponds to the the population parameter and the prior standard deviation is set to 1. See example.

See Also

getPopulationParameterInformation to get the population parameter information
setInitialEstimatesToLastEstimates to set the population parameter initial values to the last estimated values
getFixedEffectsByAutoInit to estimate initial values for the population parameters which can be passed to this method

#

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

setPopulationParameterInformation(Cl_pop = list(initialValue = 0.5, method = "FIXED"), 

                                  V_pop  = list(initialValue = 1),

                                  ka_pop = list(method = "MAP", priorValue = 1, priorSD = 0.1))

getPopulationParameterInformation()

[Monolix – PKanalix – Simulx] Initialize lixoftConnectors API

Description

Initialize lixoftConnectors API for a given software.

Usage

initializeLixoftConnectors(software = "monolix", path = "", force = FALSE)

Arguments

Value

A logical equaling TRUE if the initialization has been successful and FALSE if not.

#

initializeLixoftConnectors(software = "monolix", path = "/path/to/lixoftRuntime/")

## End(Not run)

[Monolix – PKanalix – Simulx] Get Lixoft demos path

Description

Get the path to the demo projects. The path depends on the software used to initialize the connectors with initializeLixoftConnectors.

Usage

getDemoPath()

Value

The Lixoft demos path corresponding to the currently active software.

#

  getDemoPath()

## End(Not run)

[Monolix] Get the results of the model building

Description

Get the results of automatic covariate model building or automatic statistical model building. The exact details
of what is returned depend on the strategy used when running the model building.

Usage

getModelBuildingResults()

Value

A list containing the results of model building with one element for each model run.
For all strategies, each list item contains the following:

• LL: result of -2*Log-Likelihood
• BICc: modified BIC
• individualModels: (data.frame of logical values) where the rows are the parameters
  in the model and the columns are the covariates, and the TRUE/FALSE value indicates if a covariate is used for that parameter

COSSAC returns two additional fields:

• tested: (vector<character>) which parameter-covariate pair was testing in this run with respect to the
  previous model, where the first element is the individual model parameter and the second one is the covariate

• bestModel: (logical) whether this model is the best model amongst all the tested models according to the chosen criterion

SAMBA returns the error model and covariance model information if they exist:

• errorModels: (data.frame) onservation model where each row specifies the observation id and the error model chosen
• covarianceModels: list with one element for each variability level consisting of two elements: level, specifying the
  variability level, and correlations, a list of the chosen correlations between individual model parameters in the groups element

See Also

getModelBuildingSettings for a description of settings
runModelBuilding to run model building

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

runModelBuilding(strategy = "samba")

res <- getModelBuildingResults()

[Monolix] Get model building settings

Description

Get the current settings for running model building. These are the settings that will be used if runModelBuilding
is called without argument, or they can be used as a template to update and pass to runModelBuilding in order to change the settings.

Usage

getModelBuildingSettings()

Value

The list of settings (default values indicated by square brackets)

• covariates: (vector<character>) covariate names to be considered in the model building
• parameters: (vector<character>) parameters names to be considered in the model building
• strategy: (character) strategy to use for model building
  (["cossac"], "samba", "covsamba", "scm"), where cossac, covsamba, and scm are algorithms for
  automatic covariate model building and samba is an algorithm for automatic statistical model building,
  which includes the residual error model and correlations between random effects in addition to the covariate effects

• criterion: (character) criterion to determine best model (["BIC"], "LRT")
• relationships: (data.frame with columns: parameters, covariates, locked)
  Use to force specific parameter-covariate relationships to be included (locked = TRUE) or excluded (locked = FALSE),
  See runModelBuilding for an example. By default, all the combinations are possible (i.e. this data.frame is empty).

• threshold$lrt: threshold used by criterion LRT whether or not to continue to improve the model
  (first element is for forward and the second one is for the backward method)

• threshold$correlation: threshold used by cossac to choose what combinations (parameter-covariate)
  must be tried as next candidate model (first element is for forward and the second one is for the backward method)

• useLin: (logical) computation done using linearization ([TRUE]) or importance sampling (FALSE)

See Also

runModelBuilding to run model building

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

getModelBuildingSettings()

[Monolix] Run model building

Description

Run model building for automatic covariate model building or automatic statistical model building.
The current settings for running model building can been seen by calling getModelBuildingSettings
and the returned settings can be modified and used for the settings argument. See example.

Usage

runModelBuilding(...)

Arguments

See Also

getModelBuildingSettings for a description of settings
getModelBuildingResults to get results

#

project_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran")

loadProject(project_file)

## Not run: 

# these two lines are equivalent

runModelBuilding()

runModelBuilding(settings = getModelBuildingSettings())

## End(Not run)

# settings can be set individually as name-value pairs

runModelBuilding(useLin = FALSE, covariates = "SEX", strategy = "cossac")

# or settings can be modified in the list returned from getModelBuildingSettings, then passed to runModelBuilding

mbSettings <- getModelBuildingSettings()

# for example, to force including the covariate SEX on parameter ka, 

# and to exclude the covaraite WEIGHT from parameter V

mbSettings$covariates <- c("SEX", "WEIGHT")

mbSettings$relationships[1,] = c("ka", "SEX", TRUE)

mbSettings$relationships[2,] = c("V", "WEIGHT", FALSE)

mbSettings$relationships

runModelBuilding(settings = mbSettings)

getModelBuildingResults()

[Monolix] Get continuous observation statistical model information

Description

Get a summary of the information concerning the continuous observation statistical model(s) in the project.
The following information is returned for each continuous observation:

• prediction: (vector<character>) name of the associated prediction (i.e. variable in the structural model).
• formula: (vector<character>) formula applied to the observations, which depends on the mapping and error model chosen.
• distribution: (vector<character>) distribution of the observations in the Gaussian space.
  The distribution type can be "normal", "logNormal", or "logitNormal".

• limits: (vector< pair<double,double> >) lower and upper limits imposed on the observation.
  Used only if the distribution is "logitNormal", otherwise this field is not included.

• errormodel: (vector<character>) type of the associated error model.
  The error model type can be "constant", "proportional", "combined1", or "combined2".

• parameters: (vector<character>) a vector of parameters for the residual error model.
• autocorrelation: (vector<logical>) "TRUE" to estimate autocorrelation, or "FALSE" otherwise
  (legacy only and not recommended to enable for new projects).

Usage

getContinuousObservationModel()

Value

A list specifying the statistical model properties for each continuous observation model.

See Also

getObservationInformation to get the continuous observations present in the current project

Set components of the continuous observation model(s):
setObservationDistribution
setObservationLimits
setErrorModel

#

# single observation

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "theophylline_project.mlxtran"))

getContinuousObservationModel()

# multiple observations

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPKPD_project.mlxtran"))

getContinuousObservationModel()

[Monolix] Set auto-correlation

Description

Add or remove auto-correlation from the error model used on some of the observation models. This is a legacy feature
and not recommended for new projects.

Usage

setAutocorrelation(...)

Arguments

See Also

getContinuousObservationModel get the current observation model for the current project
getObservationInformation to get the continuous observations present in the current project
setPopulationParameterInformation to update error model parameters to be estimated

Set components of the continuous observation model:
setObservationDistribution
setObservationLimits
setErrorModel

[Monolix] Set error model

Description

Set the error model type to be used for the observation model(s).
Call getObservationInformation to get a list of
the available observation names within the current project.

Usage

setErrorModel(...)

Arguments

Details

Available error model types are :

where a, b, and c are parameters, obs is the observed data, pred is the prediction from the structural model,
and err is normally distributed with mean 0 and variance 1.
Error model parameters will be initialized to 1 by default.
Call setPopulationParameterInformation to modify their initial value.
The value of the exponent parameter c is fixed by default when using the "combined1" and "combined2" models.
Use setPopulationParameterInformation to enable its estimation.

See Also

getContinuousObservationModel get the current observation model for the current project
getObservationInformation to get the continuous observations present in the current project
setPopulationParameterInformation to update error model parameters to be estimated

Set components of the continuous observation model(s):
setObservationDistribution
setObservationLimits

#

project <- file.path(getDemoPath(), "1.creating_and_using_models",  "1.1.libraries_of_models", "warfarinPKPD_project.mlxtran")

loadProject(project)

# get observation model names available in the current project, how they are mapped to the data,

# and how they are mapped to the predictions

getObservationInformation()$name

getObservationInformation()$mapping

getContinuousObservationModel()$prediction

# update the error model

setErrorModel(y1 = "proportional", y2 = "combined1")

getContinuousObservationModel()$errorModel

getContinuousObservationModel()$formula

[Monolix] Set observation model distribution

Description

Set observation model distribution.
Set the distribution in the Gaussian space for the observation
model(s). Available distribution types are "normal", "logNormal", or
"logitNormal". Call getObservationInformation to get a list of
the available observation model names within the current project. Only specified
observation models will be changed. Call setObservationLimits to set
limits for any logitNormal distributions.

Usage

setObservationDistribution(...)

Arguments

See Also

getContinuousObservationModel get the current observation model for the current project
getObservationInformation to get the continuous observations present in the current project

Set components of the continuous observation model(s):
setObservationDistribution
setErrorModel

#

project <- file.path(getDemoPath(), "1.creating_and_using_models",  "1.1.libraries_of_models", "warfarinPKPD_project.mlxtran")

loadProject(project)

# get observation model names available in the current project

getObservationInformation()$name

# set the distributions and the limits for the logitNormal distribution

setObservationDistribution(y1 = "logNormal", y2 = "logitNormal")

setObservationLimits(y2 = c(0, 100))

getContinuousObservationModel()$distribution

[Monolix] Set observation model distribution limits for logitNormal observations

Description

Set observation model distribution limits for logitNormal observations.
Set the minimum and the maximum values between which observations
must fall. Used only if the distribution of the error model is
"logitNormal". To set the observation distribution to "logitNormal", use
setObservationDistribution. Call getObservationInformation to get the
observation model names present in the current project. Only specified observations will be changed.

Usage

setObservationLimits(...)

Arguments

See Also

getContinuousObservationModel get the current observation model for the current project
getObservationInformation to get the continuous observations present in the current project

Set components of the continuous observation model:
setObservationDistribution
setErrorModel

#

project <- file.path(getDemoPath(), "1.creating_and_using_models",  "1.1.libraries_of_models", "warfarinPKPD_project.mlxtran")

loadProject(project)

# get observation model names available in the current project

getObservationInformation()$name

# set the distribution to logitNormaland then set the limits

setObservationDistribution(y2 = "logitNormal")

setObservationLimits(y2 = c(0, 100))

getContinuousObservationModel()$limits

[Monolix – PKanalix] Generate Bivariate observations plots

Description

Plot the bivariate viewer.

Usage

plotBivariateDataViewer(
  obs1 = NULL,
  obs2 = NULL,
  settings = list(),
  stratify = list(),
  preferences = list()
)

Arguments

Value

A ggplot object

See Also

getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "warfarinPKPD_project.mlxtran")

  loadProject(project)

  plotBivariateDataViewer(obs1 = "y1", obs2 = "y2")

  plotBivariateDataViewer(settings = list(lines = FALSE))

  # stratification

  plotBivariateDataViewer(obs1 = "y1", obs2 = "y2", stratify = list(individualSelection = list(indices = 10)))

  plotBivariateDataViewer(stratify = list(split = "age",

                                          filter = list("sex", "1"),

                                          groups = list(name = "age", definition = c(25))))

  plotBivariateDataViewer(stratify = list(color = "wt",

                                          groups = list(name = "wt", definition = 75)))

  plotBivariateDataViewer(stratify = list(split = c("age", "sex"),

                                          groups = list(name = "age", definition = 25)))

  # update plot settings or preferences

  plotBivariateDataViewer(preferences = list(obs = list(color = "#32CD32")))

[Monolix – PKanalix] Generate Covariate plots

Description

Plot the covariates.

Usage

plotCovariates(
  covariatesRows = NULL,
  covariatesColumns = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Details

Generate scatterplots between two continuous covariates or bar plot between categorical covariates.

Value

• A ggplot object if one element in covariatesRows and covariatesColumns,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getPlotPreferences

#

  project <- file.path(getDemoPath(), "2.case_studies/project_Theo_extravasc_SD.pkx")

  loadProject(project)

  # covariate distribution when only one covariate is specified

  plotCovariates(covariatesRows = "HT", settings = list(bins = 10))

  # scatter plot when both covariates are continuous

  plotCovariates(covariatesRows = "HT", covariatesColumns = "AGE", settings = list(spline = TRUE))

  plotCovariates(covariatesRows = "HT", covariatesColumns = c("AGE", "FORM"))

  # box plot when one covariate is categorical and the othe one is continuous

  preferences <- list(boxplot = list(fill = "#2075AE"), boxplotOutlier = list(shape = 3))

  plotCovariates(covariatesRows = "FORM", covariatesColumns = "AGE", preferences = preferences)

  # histogram when covariate on column is categorical

  plotCovariates(covariatesRows = "FORM", covariatesColumns = "SEQ",

                 settings = list(histogramColors = c("#5DC088", "#DBA92B")))

  plotCovariates(covariatesRows = "AGE", covariatesColumns = "SEQ",

                 settings = list(histogramColors = c("#5DC088", "#DBA92B")))

  # stratification

  plotCovariates(covariatesRows = "HT", covariatesColumns = "WT",

                 stratify = list(split = "AGE",

                                 filter = list("Period", 1),

                                 groups = list(name = "AGE", definition = 25)))

  preferences <- list(regressionLine = list(color = "#E5551B"))

  plotCovariates(covariatesRows = "AGE", covariatesColumns = "WT",

                 stratify = list(color = "HT",

                                 groups = list(name = "HT", definition = 181),

                                 colors = c("#2BB9DB", "#DD6BD2")),

                 preferences = preferences)

  plotCovariates(covariatesRows = "HT", covariatesColumns = "WT",

                 stratify = list(split = c("AGE", "SEQ"),

                                 groups = list(name = "AGE", definition = 25)))

  # Mulitple covariates

  plotCovariates()

  plotCovariates(covariatesRows = c("AGE", "SEQ", "HT"), covariatesColumns = c("AGE", "SEQ", "HT"))

  plotCovariates(stratify = list(filter = list("AGE", 2),

                                 groups = list(name = "AGE", definition = c(25, 30))))

[Monolix – PKanalix] Generate Observed data plot

Description

Plot the observed data.

Usage

plotObservedData(
  obsName = NULL,
  settings = list(),
  stratify = list(),
  preferences = list()
)

Arguments

Value

A ggplot object

See Also

getPlotPreferences

#

  project <- paste0(getDemoPath(), "/2.case_studies/project_aPCSK9_SAD.pkx")

  loadProject(project)

  # by default, individual profiles and mean curve are displayed

  plotObservedData()

  # displaying dots and mean curve by dose group, merged on a single plot

  plotObservedData(settings=list(lines=F,

                            mean=T,

                            meanMethod="geometric",

                            ylog=T,

                            ylab="mAb concentration (ug/mL)"),

              stratify=list(split="DOSE_mg",

                            mergedSplits=T),

              preferences=list(observationStatistics=list(lineWidth=0.8),

                               obs=list(radius=2)))

  # coloring by ID, without mean curve

  plotObservedData(settings=list(mean=F,error=F),

              stratify = list(color=c("id")))

  # changing the settings to display only the mean curve with SE, with bin limits and dosing times

  plotObservedData(settings=list(dots=F,

                            lines=F,

                            mean=T,

                            error=T,

                            meanMethod="geometric",

                            errorMethod="standardError",

                            useCensored=T,

                            binLimits=T,

                            binsSettings=list(criteria="leastsquare", is.fixedNbBins=T, nbBins=20),

                            cens=F,

                            dosingTimes=T,

                            legend=T,

                            grid=F,

                            xlog=F,ylog=T,

                            xlab="Time since first dose (days)",

                            ylab="mAb concentration (ug/mL)",

                            xlim=c(0,96),

                            ylim=c(0.1,70),

                            fontsize=12,

                            units=F))

  # changing preferences for observations, censored observations and bin limits

  plotObservedData(settings=list(dots=T, lines=T, legend=T, dosingTimes=T, mean=F, error=F, ylog=T, cens=T),

              preferences=list(obs=list(color="#161617",

                                        radius=2,

                                        shape=18,

                                        lineWidth=0.2,

                                        lineType="dashed",

                                        legend="Observations"),

                               censObs=list(color="#cdced1",

                                            radius=2,

                                            shape=16,

                                            legend="Censored observations"),

                               dosingTimes=list(color="#fcba03",

                                                lineWidth=0.5,

                                                lineType="solid",

                                                legend="Time of doses")))

  # changing preferences for mean and bin limits

  plotObservedData(settings=list(dots=F, lines=F, legend=T, binLimits=T, grid=F),

              preferences=list(observationStatistics=list(color="#161617",

                                                          whiskersWidth=3,

                                                          lineWidth=0.7,

                                                          lineType="solid",

                                                          legend="mean and standard deviation over bins"),

                               binsValues=list(color="#cdced1",

                                               lineWidth=0.5,

                                               lineType="dashed",

                                               legend="bins")))

  # color and split by DOSE_mg but grouping two doses levels together

  plotObservedData(settings=list(mean=F,error=F,ylim=c(0,120)),

              stratify = list(groups=list(name="DOSE_mg",definition=list(c("150mg"), c("300mg","800mg"))),

                              color="DOSE_mg",

                              split="DOSE_mg"))

  # selecting only one individual

  plotObservedData(settings=list(mean=F,error=F),

                   stratify = list(individualSelection=list(indices=1)))

  plotObservedData(settings=list(mean=F,error=F),

                   stratify = list(individualSelection=list(ids="1")))

  #============= projects with several covariates to stratify

initializeLixoftConnectors(software = "pkanalix", force=T)

project <- file.path(getDemoPath(), "/2.case_studies/project_Theo_extravasc_SD.pkx")

loadProject(project)

# defining groups for AGE and HT, coloring by HT and filtering by AGE

plotObservedData(settings=list(mean=F,error=F),

            stratify = list(groups=list(list(name="AGE", definition=c(24, 34)),

                                        list(name="HT", definition=c(184.5))),

                            color="HT",

                            colors=c("#cdced1","#161617"),

                            filter=list("AGE",c(1,3))))

# filter to keep only second sequence (TR) and FORM=test

plotObservedData(settings=list(mean=F,error=F),

            stratify = list(filter=list(list("SEQ",2),list("FORM","test"))))

  #============= project with time-to-event data

initializeLixoftConnectors(software = "monolix", force=T)

project <- file.path(getDemoPath(), "/4.joint_models/4.2.continuous_noncontinuous/PKrtte_project.mlxtran")

loadProject(project)

# survival Kaplan-Meier curve

plotObservedData(obsName="Hemorrhaging")

# mean number of events

plotObservedData(obsName="Hemorrhaging",

                 settings=list(eventPlot="averageEventNumber"))

#============= project with categorical data

initializeLixoftConnectors(software = "monolix", force=T)

project <- file.path(getDemoPath(), "/4.joint_models/4.2.continuous_noncontinuous/warfarin_cat_project.mlxtran")

loadProject(project)

# display is the same as for continuous data by default

plotObservedData(obsName="Level")

# display as stacked or as grouped

plotObservedData(obsName="Level", settings=list(plot="stacked"))

plotObservedData(obsName="Level", settings=list(plot="grouped"))

# splitting by sex

plotObservedData(obsName="Level", 

                 settings=list(plot="stacked", ylim=c(0,30), legend=T),

                 stratify=list(split="sex"))

#============== project with multiple-dose to show timeAfterLastDose

initializeLixoftConnectors(software = "monolix", force=T)

project <- file.path(getDemoPath(), "/6.PK_models/6.3.multiple_doses/addl_project.mlxtran")

loadProject(project)

# with "time after first dose" by default

plotObservedData()

# with "time since previous dose"

plotObservedData(settings=list(timeAfterLastDose=T))

#============= project with regressor to show regressor on x-axis

initializeLixoftConnectors(software = "monolix", force=T)

project <- file.path(getDemoPath(), "/7.miscellaneous/7.1.regression_variables/reg3_warfarinPD_linearInterp_project.mlxtran")

loadProject(project)

# with "time" on x-axis by default

plotObservedData()

# with regressor "Cc" (concentration) on x-axis

plotObservedData(settings=list(xvariable="Cc"))

#============= project with nominal time on x-axis

initializeLixoftConnectors(software = "pkanalix", force=T)

project <- file.path(getDemoPath(), "/1.basic_examples/project_nominal_time.pkx")

loadProject(project)

# with "actual time" by default

plotObservedData()

# with nominal time on x-axis

plotObservedData(settings=list(xvariable="nominalTime"))

[Monolix] Plot Importance sampling convergence.

Description

Plot iterations of the likelihood estimation by importance sampling.

Usage

plotImportanceSampling(settings = list())

Arguments

Value

A ggplot object

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runLogLikelihoodEstimation()

  plotImportanceSampling()

[Monolix] Plot MCMC convergence

Description

Plot iterations and convergence for the conditional distribution task.

Usage

plotMCMC(settings = list())

Arguments

Value

A TableGrob object if multiple plots (output of grid.arrange)

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  plotMCMC()

[Monolix] Plot SAEM convergence

Description

Plot iterations and convergence for the SAEM algorithm (population parameters estimation).

Usage

plotSaem(settings = list())

Arguments

Value

A TableGrob object if multiple plots (output of grid.arrange)

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotSaem()

[Monolix] Distribution of the individual parameters computed by Monolix

Description

Plot the distribution of the individual parameters.

Usage

plotParametersDistribution(
  parameters = NULL,
  plot = "pdf",
  settings = list(),
  preferences = NULL,
  stratify = list()
)

Arguments

Value

• A ggplot object if one parameter,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  plotParametersDistribution(parameters = "ka")

  plotParametersDistribution(parameters = "Cl", plot = "pdf")

  plotParametersDistribution(parameters = "ka", plot = "cdf")

  plotParametersDistribution(parameters = "ka", plot = "cdf",

                             settings = list(indivEstimate = "simulated"))

  plotParametersDistribution(parameters = "Cl", plot = "pdf",

                             settings = list(theoretical = F))

  # stratification

  plotParametersDistribution(stratify = list(filter = list("WEIGHT", 1),

                                             groups = list(name = "WEIGHT", definition = 75)))

  plotParametersDistribution(parameters = "Cl", stratify = list(split = "SEX"))

  # update preferences

  preferences = list(theoretical = list(color = "#B4468A", lineType = "solid", lineWidth = 0.8))

  plotParametersDistribution(parameters = "ka", plot = "cdf", preferences = preferences)

  # multiple plots

  plotParametersDistribution(parameters = c("ka", "Cl"))

  plotParametersDistribution(plot = "pdf")

  plotParametersDistribution(plot = "cdf")

  plotParametersDistribution(plot = "cdf", settings = list(indivEstimate = "simulated"))

  plotParametersDistribution(plot = "pdf", settings = list(theoretical = F))

[Monolix] Individual monolix parameter vs covariate plot.

Description

Plot individual parameters vs covariates.

Usage

plotParametersVsCovariates(
  parameters = NULL,
  covariates = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

• A ggplot object if one covariate and one parameter in argument,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  # Individual parameters

  plotParametersVsCovariates(covariates = "SEX", parameters = "Cl")

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "V", settings = list(spline = T))

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "V",

                             settings = list(indivEstimate = "simulated"))

  # Random effects

  plotParametersVsCovariates(covariates = "SEX", parameters = "V",

                             settings = list(parameterType = "randomEffect"))

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "V",

                             settings = list(indivEstimate = "simulated", parameterType = "randomEffect"))

  # Stratification

  plotParametersVsCovariates(covariates = "SEX", parameters = "ka",

                             stratify = list(filter = list("WEIGHT", 1),

                                             groups = list(name = "WEIGHT", definition = 75)))

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "ka",

                             stratify = list(split = "SEX"))

  plotParametersVsCovariates(covariates = "SEX", parameters = "Cl",

                             stratify = list(color = "WEIGHT",

                                             groups = list(name = "WEIGHT", definition = 75)))

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "V",

                             stratify = list(color = "SEX"))

  plotParametersVsCovariates(covariates = "WEIGHT", parameters = "V",

                             stratify = list(color = c("SEX", "WEIGHT"),

                                             groups = list(name = "WEIGHT", definition = 70)))

  # multiple plots

  plotParametersVsCovariates()

  plotParametersVsCovariates(covariates = "WEIGHT")

  plotParametersVsCovariates(settings = list(indivEstimate = "simulated"))

  plotParametersVsCovariates(settings = list(parameterType = "randomEffect"))

  plotParametersVsCovariates(settings = list(parameterType = "randomEffect", indivEstimate = "simulated"))

  plotParametersVsCovariates(stratify = list(color = "WEIGHT",

                                             groups = list(name="WEIGHT", definition = 75)))

  plotParametersVsCovariates(stratify = list(color = "SEX"))

[Monolix] Correlations between random effect.

Description

Plot correlations between random effects.

Usage

plotRandomEffectsCorrelation(
  parametersRows = NULL,
  parametersColumns = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

• A ggplot object if one element in parametersRows and parametersColumns,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  plotRandomEffectsCorrelation()

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               settings = list(indivEstimate = "simulated"))

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               settings = list(spline = TRUE))    

  plotRandomEffectsCorrelation(settings = list(indivEstimate = "mean"))

  plotRandomEffectsCorrelation(parametersRows = c("ka", "V"))

  # stratification

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               stratify = list(filter = list("SEX", "M")))

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               stratify = list(color = "WEIGHT",

                                               groups = list(name = "WEIGHT", definition = 75),

                                               colors = c("#46B4AF", "#B4468A")))

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               stratify = list(split = "SEX"))

  plotRandomEffectsCorrelation(parametersRows = "ka", parametersColumns = "V",

                               stratify = list(split = c("SEX", "WEIGHT"),

                                               groups = list(name = "WEIGHT", definition = 70)))

[Monolix] Distribution of the standardized random effects.

Description

Plot the distribution of the standardized random effects.

Usage

plotStandardizedRandomEffectsDistribution(
  parameters = NULL,
  plot = "boxplot",
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

• A ggplot object if one parameter,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  runConditionalModeEstimation()

  # Random effect distribution as boxplot

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "boxplot")

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "boxplot",

                                            settings = list(indivEstimate = "mode"))

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "boxplot",

                                            settings = list(quartile = F))

  # Random effect distribution as pdf

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "pdf")

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "pdf",

                                            settings = list(empirical = F))

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "pdf",

                                            settings = list(theoretical = F))

  # Random effect distribution as cdf

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "cdf")

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "cdf",

                                            settings = list(indivEstimate = "simulated"))

  plotStandardizedRandomEffectsDistribution(parameters = "ka", plot = "cdf",

                                            settings = list(theoretical = F))

  # stratification

  plotStandardizedRandomEffectsDistribution(stratify = list(filter = list("WEIGHT", 1),

                                                            groups = list(name = "WEIGHT", definition = 75)))

  plotStandardizedRandomEffectsDistribution(parameters = "Cl",

                                            stratify = list(split = "SEX"))

  plotStandardizedRandomEffectsDistribution(parameters = c("ka", "Cl"))

  plotStandardizedRandomEffectsDistribution(plot = "boxplot")

  plotStandardizedRandomEffectsDistribution(plot = "pdf")

  plotStandardizedRandomEffectsDistribution(plot = "cdf")

  plotStandardizedRandomEffectsDistribution(plot = "pdf", settings = list(theoretical = F))

[Monolix] Plot Monolix Individual Fits

Description

Plot the individual fits.

Usage

plotIndividualFits(
  obsName = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Details

Only available for Continuous data.

Value

A ggplot object

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  runConditionalModeEstimation()

  plotIndividualFits()

  plotIndividualFits(settings=list(popFits = T))

  plotIndividualFits(settings=list(obsLines = T, obsDots = F, predInterval = T))

  plotIndividualFits(settings=list(dosingTimes = T))

  # stratification options

  plotIndividualFits(stratify = list(individualSelection = list(ids = c(1, 2, 3, 4))))

  plotIndividualFits(stratify = list(individualSelection = list(indices = c(1, 4), isRange = TRUE)))

  plotIndividualFits(stratify = list(filter = list("WEIGHT", 2),

                                     groups = list(name = "WEIGHT", definition = c(60, 75))))

  plotIndividualFits(stratify = list(filter = list("SEX", "F")))

  plotIndividualFits(stratify = list(color = "SEX",

                                     colors=c("#5DC088", "#DBA92B")))

  plotIndividualFits(settings = list(legend = T),

                     stratify = list(color = c("SEX", "WEIGHT"),

                                     groups = list(name = "WEIGHT", definition = 70)))

  # settings and preferences options

  plotIndividualFits(settings = list(ylog = T, ylim = c(0.8, 11)))

  preferences <- list(popFits = list(lineType = "solid", legend = "Population fits"))

  plotIndividualFits(settings = list(popFits = T), preferences = preferences)

[Monolix] Plot Observation VS Prediction

Description

Plot the observation vs the predictions.

Usage

plotObservationsVsPredictions(
  obsName = NULL,
  predictions = c("indiv"),
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

• A ggplot object if one prediction type,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  runConditionalModeEstimation()

  plotObservationsVsPredictions()

  plotObservationsVsPredictions(predictions = "pop")

  plotObservationsVsPredictions(prediction = "indiv", settings = list(indivEstimate = "simulated"))

  plotObservationsVsPredictions(settings = list(indivEstimate = "mean", spline = TRUE))

  plotObservationsVsPredictions(settings = list(indivEstimate = "mode", predInterval = TRUE))

  plotObservationsVsPredictions(settings = list(ylog = TRUE, xlog = TRUE))

  # stratification

  plotObservationsVsPredictions(stratify = list(filter = list("SEX", "F")))

  plotObservationsVsPredictions(stratify = list(split = "WEIGHT",

                                                groups = list(name = "WEIGHT", definition = 75)))

  plotObservationsVsPredictions(stratify = list(color = "WEIGHT",

                                                groups = list(name = "WEIGHT", definition = 75)))

  plotObservationsVsPredictions(settings = list(legend = T),

                                stratify = list(color = c("SEX", "WEIGHT"),

                                                groups = list(name = "WEIGHT", definition = 70)))

  # display multiple predictions

  plotObservationsVsPredictions(predictions = c("pop", "indiv"))

[Monolix] Generate Distribution of the residuals

Description

Plot the distribution of the residuals.

Usage

plotResidualsDistribution(
  obsName = NULL,
  residuals = c("indiv", "npde"),
  plots = c("pdf", "cdf"),
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

• A ggplot object if one prediction type,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  plotResidualsDistribution()

  plotResidualsDistribution(residuals = "indiv", settings = list(indivEstimate = "simulated"))

  plotResidualsDistribution(residuals = "indiv", settings = list(indivEstimate = "mode"))

  plotResidualsDistribution(residuals = "pop", plots = "pdf")

  plotResidualsDistribution(residuals = "npde", plots = "cdf")

  plotResidualsDistribution(stratify = list(filter=list("SEX", "F")))

  plotResidualsDistribution(stratify = list(split = "WEIGHT",

                                            groups = list(name = "WEIGHT", definition = c(75))))

  plotResidualsDistribution(residuals = "indiv", settings = list(legend = T),

                            stratify = list(split = c("SEX", "WEIGHT"),

                                            groups = list(name = "WEIGHT", definition = 70)))

  plotResidualsDistribution()

  plotResidualsDistribution(residuals = c("indiv", "npde"), settings = list(indivEstimate = "simulated"))

  plotResidualsDistribution(residuals = c("pop", "indiv"), settings = list(indivEstimate = "mode"))

  plotResidualsDistribution(plots = c("pdf", "cdf"))

  plotResidualsDistribution(plots = c("cdf"))

  plotResidualsDistribution(residuals = "npde")

[Monolix] Generate Scatter plots of the residuals

Description

Plot the scatter plots of the residuals.

Usage

plotResidualsScatterPlot(
  obsName = NULL,
  residuals = c("indiv"),
  xaxis = c("time", "prediction"),
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Details

Note that ‘prediction interval’ setting is not available in 2021 version for this connector.

Value

• A ggplot object if one prediction type,
• A TableGrob object if multiple plots (output of grid.arrange)

See Also

getChartsData getPlotPreferences

#

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  runConditionalDistributionSampling()

  runConditionalModeEstimation()

  plotResidualsScatterPlot()

  plotResidualsScatterPlot(residuals = "indiv", settings = list(indivEstimate = "simulated"))

  plotResidualsScatterPlot(residuals = "indiv", settings = list(indivEstimate = "mode"))

  plotResidualsScatterPlot(xaxis = "prediction", residuals = "pop")

  plotResidualsScatterPlot(xaxis = "time", residuals = "pop")

  plotResidualsScatterPlot(residuals = "npde")

  plotResidualsScatterPlot(settings = list(spline = T))

  plotResidualsScatterPlot(settings = list(empPercentiles = T, level = 90,

                                           binsSettings = list(is.fixedNbBins = T, nbBins = 5),

                                           binLimits = T))

  plotResidualsScatterPlot(residuals = c("indiv", "pop"),

                           settings = list(indivEstimate = "simulated"))

  plotResidualsScatterPlot(residuals = "indiv", xaxis = c("prediction"),

                           settings = list(indivEstimate = "mode"))

  plotResidualsScatterPlot(xaxis = c("prediction"), residuals = c("indiv", "pop"))

  plotResidualsScatterPlot(residuals = "npde")

  # Stratification

  plotResidualsScatterPlot(stratify = list(filter = list("SEX", "F")))

  plotResidualsScatterPlot(stratify = list(split = "WEIGHT",

                                           groups = list(name = "WEIGHT", definition = c(75))))

  plotResidualsScatterPlot(stratify = list(color = "WEIGHT",

                                           groups = list(name = "WEIGHT", definition = c(75))))

[Monolix] Plot BLQ predictive checks

Description

Plot the BLQ predictive checks.

Usage

plotBlqPredictiveCheck(
  obsName = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

a ggplot2 object

See Also

getPlotPreferences

#

  # continuous data

  project <- file.path(getDemoPath(), "2.models_for_continuous_outcomes",

                       "2.2.censored_data", "censoring1_project.mlxtran")

  loadProject(project)

  runScenario()

  plotBlqPredictiveCheck(obsName = "Y")

[Monolix] Plot Numerical predictive checks

Description

Plot the numerical predictive checks.

Usage

plotNpc(
  obsName = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

a ggplot2 object

See Also

getChartsData getPlotPreferences

#

  # continuous data

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotNpc(obsName = "CONC")

[Monolix] Plot distribution of the predictions

Description

Plot the prediction distribution.

Usage

plotPredictionDistribution(
  obsName = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Details

Note that computation settings are not available for this connector in 2021 version:
Number of bands is set to 9 and Level is set to 90

Note that stratification options are not available for this connector in 2021 version:

Value

a ggplot2 object

See Also

getChartsData getPlotPreferences

#

  # continuous data

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotPredictionDistribution()

  plotPredictionDistribution(stratify = list(color = "SEX"), settings = list(obs = TRUE))

  plotPredictionDistribution(stratify = list(split = "SEX"))

[Monolix] Plot Visual predictive checks

Description

Plot the visual predictive checks.

Usage

plotVpc(
  obsName = NULL,
  eventPlot = NULL,
  settings = list(),
  preferences = list(),
  stratify = list()
)

Arguments

Value

a ggplot2 object

See Also

getPlotPreferences

#

  # continuous data

  project <- file.path(getDemoPath(), "1.creating_and_using_models",

                       "1.1.libraries_of_models", "theophylline_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotVpc(obsName = "CONC",

          settings = list(outlierDots = FALSE, grid = FALSE,

                          ylab = "Concentration", xlab = "time (in hour)"))

  plotVpc(obsName = "CONC",

          settings = list(outlierDots = FALSE, grid = FALSE,

                          ylab = "Concentration", xlab = "time (in hour)"),

          stratify = list(split = "SEX"))

  plotVpc(obsName = "CONC",

          settings = list(outlierDots = FALSE, grid = FALSE, obs = TRUE,

                          ylab = "Concentration", xlab = "time (in hour)"),

          stratify = list(color = "SEX"))

  # categorical data

  project <- file.path(getDemoPath(), "3.models_for_noncontinuous_outcomes",

                       "3.1.categorical_data_model", "categorical1_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotVpc(obsName = "level",

          settings = list(theoretical = TRUE, outlierDots = FALSE))

  # countable data

  project <- file.path(getDemoPath(), "3.models_for_noncontinuous_outcomes",

                       "3.2.count_data_model", "count1a_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotVpc(obsName = "Y")

  # time to event data

  project <- file.path(getDemoPath(), "3.models_for_noncontinuous_outcomes",

                       "3.3.time_to_event_data_model", "tte1_project.mlxtran")

  loadProject(project)

  runPopulationParameterEstimation()

  plotVpc(obsName = "Event", eventPlot = "survivalFunction")

[Monolix – PKanalix] Define Preferences to customize plots

Description

Define the preferences to customize plots.

Usage

getPlotPreferences(plotName = NULL, update = NULL, ...)

Arguments

Details

This function creates a theme that customizes how a plot looks, i.e. legend, colors
fills, transparencies, linetypes an sizes, etc.
For each curve, list of available customizations:

• color: color (when lines or points)
• fill: color (when surfaces)
• opacity: color transparency
• radius: size of points
• shape: shape of points
• lineType: linetype
• lineWidth: line size
• legend: name of the legend (if NULL, no legend is displayed for the element)

Value

A list with theme specifiers

See Also

setPlotPreferences resetPlotPreferences

#

  preferences <- getPlotPreferences(update = list(

    obs = list(color = "red", legend = "Observations"),

    obsCens = list(color = rgb(70, 130, 180, maxColorValue = 255))

  ))

  # preferences that are used by default in the plots

  preferences <- getPlotPreferences()

  # preferences that are used by default in plotObservedData

  preferences <- getPlotPreferences(plotName = "plotObservedData")

## End(Not run)

[Monolix – PKanalix] Reset plot preferences to go back to default preferences

Description

Reset plot preferences to go back to default preferences.

Usage

resetPlotPreferences()

See Also

getPlotPreferences setPlotPreferences

#

  getPlotPreferences()$obs[c("color", "legend")]

  update = list(obs = list(color = "green", legend = "Observation"))

  setPlotPreferences(update = update)

  getPlotPreferences()$obs[c("color", "legend")]

  resetPlotPreferences()

  getPlotPreferences()$obs[c("color", "legend")]

## End(Not run)

[Monolix – PKanalix] Set preferences to customize plots

Description

Set preferences to customize plots.
When preferences are set, the updated preferences will used in all the plots.

Usage

setPlotPreferences(update = NULL)

Arguments

Details

This function creates a theme that customizes how a plot looks, i.e. legend, colors
fills, transparencies, linetypes an sizes, etc.
For each curve, list of available customizations:

• color: color (when lines or points)
• fill: color (when surfaces)
• opacity: color transparency
• radius: size of points
• shape: shape of points
• lineType: linetype
• lineWidth: line size
• legend: name of the legend (if NULL, no legend is displayed for the element)

See Also

getPlotPreferences resetPlotPreferences

#

  getPlotPreferences()$obs[c("color", "legend")]

  update = list(obs = list(color = "green", legend = "Observation"))

  setPlotPreferences(update = update)

  getPlotPreferences()$obs[c("color", "legend")]

## End(Not run)

[Monolix – PKanalix – Simulx] Export current project to Monolix, PKanalix or Simulx

Description

Export the current project to another application of the MonolixSuite, and load the exported project.
NOTE: This action switches the current session to the target software. Current unsaved modifications will be lost.
The extensions are .mlxtran for Monolix, .pkx for PKanalix, .smlx for Simulx and .dxp for Datxplore.
WARNING: R is sensitive between ‘\’ and ‘/’, only ‘/’ can be used.

Usage

exportProject(settings, force = F)

Arguments

Details

At export, a new project is created in a temporary folder. By default, the file is created with a project setting filesNextToProject = TRUE, which means that file dependencies such as data and model files are copied and kept next to the new project (or in the result folder for Simulx). This new project can be saved to the desired location withsaveProject.

Exporting a Monolix or a PKanalix project to Simulx automatically creates elements that can be used for simulation, exactly as in the GUI.

To see which elements of some type have been created in the new project, you can use the get..Element functions: getOccasionElements, getPopulationElements, getPopulationElements, getIndividualElements, getCovariateElements, getTreatmentElements, getOutputElements, getRegressorElements.

See Also

newProject, loadProject, importProject

#

[PKanalix only]

exportProject(settings = list(targetSoftware = "monolix", filesNextToProject = F))

exportProject(settings = list(targetSoftware = "monolix", filesNextToProject = F, exportedUnusedCovariates = list(all = FALSE, name = c("sex", "weight"))))

[Monolix only]

exportProject(settings = list(targetSoftware = "simulx", filesNextToProject = T, dataFilePath = "data.txt", dataFileType = "vpc"))

exportProject(settings = list(targetSoftware = "simulx", filesNextToProject = F, dataFilePath = "/path/to/data/data.txt"))

[Simulx only]

exportProject(settings = list(targetSoftware = "pkanalix", dataFilePath = "data.txt", modelFileName = "model.txt"))

exportProject(settings = list(targetSoftware = "pkanalix", dataFilePath = "/path/to/data/data.txt"))

## End(Not run)

# Working example to export a Monolix project to Simulx. The resulting .smlx file can be opened from Simulx GUI.

initializeLixoftConnectors(software = "monolix", force = TRUE)

loadProject(file.path(getDemoPath(),"1.creating_and_using_models","1.1.libraries_of_models","warfarinPK_project.mlxtran"))

runScenario()

exportProject(settings = list(targetSoftware = "simulx"), force = TRUE)

saveProject("importFromMonolix.smlx")

[Monolix – PKanalix] Get project data

Description

Get a description of the data used in the current project. Available informations are:

• dataFile (character): Path to the data file (csv, xlsx, xlsx, sas7bdat, xpt or txt). Can be absolute or relative to the current working directory.
• header (vector<character>): vector of header names
• headerTypes (vector<character>): vector of header types
• observationNames (vector<character>): vector of observation names
• observationTypes (vector<character>): vector of observation types
• nbSSDoses (integer): number of doses (if there is a SS column)
• regressorsSettings (character): regressors interpolation method (either last carried forward or linear)
• sheet (character): Name of the sheet in xlsx/xls file. If not provided, the first sheet is used.

Usage

getData()

Value

A list describing project data.

See Also

setData

#

data = getData()

data

-> $dataFile

     "/path/to/data/file.txt"

   $header

     c("ID","TIME","CONC","SEX","OCC")

   $headerTypes

     c("ID","TIME","OBSERVATION","CATEGORICAL COVARIATE","IGNORE")

   $observationNames

     c("concentration")

   $observationTypes

     c(concentration = "continuous")

   $sheet

     "sheet1"

## End(Not run)

[Monolix – PKanalix] Get interpreted project data

Description

Get data after interpretation done by the software, as it is displayed in the Data tab in the interface.
Interpretation of data includes, but is not limited to, data formatting, filters, addition of doses through the ADDL column and steady state settings, addition of additional covariates, interpolation of regressors.
It returns as dataframe with all columns of type "character".

Usage

getInterpretedData()

[Monolix – PKanalix – Simulx] Get a library model’s content.

Description

Get the content of a library model.

Usage

getLibraryModelContent(filename, print = TRUE)

Arguments

Value

The model’s content as a single string.

#

getLibraryModelContent("oral1_1cpt_kaVCl")

model <- getLibraryModelContent(filename = "lib:oral1_1cpt_kaVCl.txt", print = FALSE)

## End(Not run)

[Monolix – PKanalix – Simulx] Get the name of a library model given a list of library filters.

Description

Get the name of a library model given a list of library filters.

Usage

getLibraryModelName(library, filters = list())

Arguments

Details

Models can be loaded from a library based on a selection of filters as in PKanalix, Monolix and Simulx GUI. For a complete description of each model library, and guidelines on how to select models, please visit https://mlxtran.lixoft.com/model-libraries/.

getLibraryModelName enables to get the name of the model to be loaded. You can then use it in setStructuralModel or newProject to load the model in an existing or in a new project.

All possible keys and values for each of the libraries are listed below.

PK library

PD library

PKPD library

PK double absorption library

Parent-metabolite library

TMDD library

TTE library

Count library

TGI library

Value

Name of the filtered model, or vector of names of the available models if not all filters were selected. Names start with "lib:".

#

getLibraryModelName(library = "pk", filters = list(administration = "oral", delay = "lagTime", absorption = "firstOrder", distribution = "1compartment", elimination = "linear", parametrization = "clearance"))

# returns "lib:oral1_1cpt_TlagkaVCl.txt"

getLibraryModelName("pd", list(response = "turnover", drugAction = "productionStimulation"))

# returns c("lib:turn_input_Emax.txt", "lib:turn_input_gammaEmax.txt")

## End(Not run)

[Monolix – PKanalix] Get mapping

Description

Get mapping between data and model.

Usage

getMapping()

Value

A list of mapping information:

• mapping (list<list>) A list of lists representing a link between data and model. Each list contains:
  • obsId (character) Name of observation id present in the dataset. It corresponds to the content of column tagged as "obsid" in case of several obs ids, or to the header of the column tagged as "observation" otherwise
  • modelOutput (character) Name of the model prediction listed in the output= line of the structural model
  • observationName [Monolix] (character) Model observation name (for continuous observations only)
  • type (character) Type of linked data ("continuous" | "discrete" | "event")
• freeData (list<list>) A list of lists describing not mapped data:
  • obsId (character) Name of observation id present in the dataset
  • type (character) Data type
• freePredictions (list<list>) A list of lists describing not mapped predictions:
  • modelOutput (character) Name of the model prediction listed in the output= line of the structural model
  • type (character) Prediction type

See Also

setMapping

#

f = getMapping()

f$mapping

  -> list( list(obsId = "1", modelOutput = "Cc", observationName = "concentration", type = "continuous"),

           list(obsId = "2", modelOutput = "Level", type = "discrete") )

f$freeData

  -> list( list(obsId = "3", type = "event") )

f$freePredictions

  -> list( list(modelOutput = "Effect", type = "continuous") )

## End(Not run)

[Monolix – PKanalix – Simulx] Get structural model file

Description

Get the model file for the structural model used in the current project.

Usage

getStructuralModel()

Details

For Simulx, this function will return the path to the structural model only if the project was imported from Monolix, and the path to the full custom model otherwise.
Note that a custom model in Simulx may include also a statistical part.
For Simulx, there is no associated function getStructuralModel() because setting a new model is equivalent to creating a new project. Use newProject instead.

If a model was loaded from the libraries, the returned character is not a path,
but the name of the library model, such as "lib:model_name.txt". To see the content of a library model, use getLibraryModelContent.

Value

The path to the structural model file.

See Also

For Monolix and PKanalix only: setStructuralModel

#

getStructuralModel() => "/path/to/model/inclusion/modelFile.txt"

## End(Not run)

# Get the name and see the content of the model used in warfarin demo project

initializeLixoftConnectors("monolix", force = TRUE)

loadProject(file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPK_project.mlxtran"))

libModelName <- getStructuralModel()

getLibraryModelContent(libModelName)

# Get the name of the model file used in Simulx

initializeLixoftConnectors("simulx", force = TRUE)

project_name <- file.path(getDemoPath(), "1.overview", "newProject_TMDDmodel.smlx")

loadProject(project_name)

getStructuralModel()

# Get the name of the model file imported to Simulx

initializeLixoftConnectors("monolix", force = TRUE)

project_name <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPK_project.mlxtran")

loadProject(project_name)

getStructuralModel()

initializeLixoftConnectors("simulx", force = TRUE)

importProject(project_name)

getStructuralModel()

[Monolix – PKanalix – Simulx] Import project from Datxplore, Monolix or PKanalix

Description

Import a Monolix or a PKanalix project into the currently running application initialized in the connectors.
The extensions are .mlxtran for Monolix, .pkx for PKanalix, .smlx for Simulx and .dxp for Datxplore.
WARNING: R is sensitive between ‘\’ and ‘/’, only ‘/’ can be used.
Allowed import sources are:

Usage

importProject(projectFile)

Arguments

Details

At import, a new project is created in a temporary folder with a project setting filesNextToProject = TRUE,
which means that file dependencies such as data and model files are copied and kept next to the new project
(or in the result folder for Simulx). This new project can be saved to the desired location withsaveProject.

Simulx projects can only be exported, not imported. To export a Simulx project to another application,
please load the Simulx project with the Simulx connectors and use exportProject.

Importing a Monolix or a PKanalix project into Simulx automatically creates elements that can be used for
simulation, exactly as in the GUI.

To see which elements of some type have been created in the new project, you can use the get..Element functions:
getOccasionElements, getPopulationElements, getPopulationElements, getIndividualElements,
getCovariateElements, getTreatmentElements, getOutputElements, getRegressorElements.

See Also

saveProject, exportProject

#

initializeLixoftConnectors(software = "simulx", force = TRUE)

importProject("/path/to/project/file.mlxtran") 

importProject("/path/to/project/file.pkx") 

initializeLixoftConnectors(software = "monolix", force = TRUE)

importProject("/path/to/project/file.pkx") 

initializeLixoftConnectors(software = "pkanalix", force = TRUE)

importProject("/path/to/project/file.mlxtran") 

## End(Not run)

# working example to import a Monolix demo project into Simulx. The resulting .smlx file can be opened from Simulx GUI.

initializeLixoftConnectors(software = "monolix", force = TRUE)

MonolixDemoPath = file.path(getDemoPath(),"1.creating_and_using_models","1.1.libraries_of_models","warfarinPK_project.mlxtran")

initializeLixoftConnectors(software = "simulx", force = TRUE)

importProject(MonolixDemoPath)

saveProject("importFromMonolix.smlx")

[Monolix – PKanalix – Simulx] Get current project load status.

Description

Get a logical saying if a project is currently loaded.

Usage

isProjectLoaded()

Value

TRUE if a project is currently loaded, FALSE otherwise

#

project_name <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPK_project.mlxtran")

loadProject(project_name)

isProjectLoaded()

initializeLixoftConnectors("pkanalix")

isProjectLoaded()

[Monolix – PKanalix – Simulx] Load project from file

Description

Load a project in the currently running application initialized in the connectors.
The extensions are .mlxtran for Monolix, .pkx for PKanalix, and .smlx for Simulx.
WARNING: R is sensitive between ‘\’ and ‘/’, only ‘/’ can be used.

Usage

loadProject(projectFile)

Arguments

See Also

saveProject, importProject, exportProject, newProject

#

loadProject("/path/to/project/file.mlxtran") for Linux platform

loadProject("C:/Users/path/to/project/file.mlxtran") for Windows platform

## End(Not run)

# Load a Monolix project

initializeLixoftConnectors("monolix")

project_name <- file.path(getDemoPath(), "8.case_studies", "hiv_project.mlxtran")

loadProject(project_name)

# Load a PKanalix project

initializeLixoftConnectors("pkanalix")

project_name <- file.path(getDemoPath(), "1.basic_examples", "project_censoring.pkx")

loadProject(project_name)

# Load a Simulx project

initializeLixoftConnectors("simulx")

project_name <- file.path(getDemoPath(), "2.models", "longitudinal.smlx")

loadProject(project_name)

[Monolix – PKanalix – Simulx] Create a new project

Description

Create a new project. New projects can be created in the connectors as in PKanalix, Monolix or Simulx GUI. The creation of a new project requires a dataset in PKanalix, a dataset and a model in Monolix, and a model in Simulx.

Usage

newProject(modelFile = NULL, data = NULL, mapping = NULL)

Arguments

Details

Note: instead of creating a project from scratch, it is also possible in Monolix and PKanalix to load an existing project with loadProject or importProject and change the dataset or the model with setData or setStructuralModel.

See Also

newProject saveProject

#

initializeLixoftConnectors("monolix")

data_file <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "data", "warfarin_data.csv")

newProject(data = list(dataFile = data_file, 

                       headerTypes = c("id", "time", "amount", "observation", "obsid", "contcov", "catcov", "contcov")),

           modelFile = "lib:oral1_1cpt_IndirectModelInhibitionKin_TlagkaVClR0koutImaxIC50.txt",

           mapping = list(list(obsId = "1",

                               modelOutput = "Cc",

                               observationName = "y1"),

                          list(obsId = "2",

                               modelOutput = "R",

                               observationName = "y2")))

# Create a new PKanalix project

initializeLixoftConnectors("pkanalix")

data_file <- file.path(getDemoPath(), "1.basic_examples", "data", "data_BLQ.csv")

newProject(data = list(dataFile = data_file,

                       headerTypes = c("id", "time", "amount", "observation", "cens", "catcov")))

# Create a new Simulx project

initializeLixoftConnectors("simulx")

newProject(modelFile = "lib:oral1_1cpt_IndirectModelInhibitionKin_TlagkaVClR0koutImaxIC50.txt")

[Monolix – PKanalix – Simulx] Save current project

Description

Save the current project as a file that can be reloaded in the connectors or in the GUI.

Usage

saveProject(projectFile = "")

Arguments

Details

The extensions are .mlxtran for Monolix, .pkx for PKanalix, and .smlx for Simulx.
WARNING: R is sensitive between ‘\’ and ‘/’, only ‘/’ can be used.

If the project setting "userfilesnexttoproject" is set to TRUE with setProjectSettings, all file dependencies such as model, data or external files are saved next to the project for Monolix and PKanalix, and in the result folder for Simulx.

See Also

newProject loadProject

#

[PKanalix only]

saveProject("/path/to/project/file.pkx") # save a copy of the model

[Monolix only]

saveProject("/path/to/project/file.mlxtran") # save a copy of the model

[Simulx only]

saveProject("/path/to/project/file.smlx") # save a copy of the model

[Monolix - PKanalix - Simulx] 

saveProject() # update current model

## End(Not run)

# Load, change and save a PKanalix project under a new name

initializeLixoftConnectors("pkanalix")

project_name <- file.path(getDemoPath(), "1.basic_examples", "project_censoring.pkx")

loadProject(project_name)

setNCASettings(blqMethodAfterTmax = "missing")

saveProject("~/changed_project.pkx")

# Load, change and save a Monolix project under a new name

initializeLixoftConnectors("monolix")

project_name <- file.path(getDemoPath(), "1.creating_and_using_models", "1.1.libraries_of_models", "warfarinPK_project.mlxtran")

loadProject(project_name)

addContinuousTransformedCovariate(tWt = "3*exp(wt)")

saveProject("~/changed_project.mlxtran")

# Load, change and save a Simulx project under a new name

initializeLixoftConnectors("simulx")

project_name <- file.path(getDemoPath(), "2.models", "longitudinal.smlx")

loadProject(project_name)

defineTreatmentElement(name = "trt", element = list(data = data.frame(time = 0, amount = 100)))

saveProject("~/changed_project.smlx")

[Monolix – PKanalix] Set project data

Description

Set project data giving a data file and specifying headers and observations types.

Usage

setData(
  dataFile,
  headerTypes,
  observationTypes = NULL,
  nbSSDoses = NULL,
  regressorsSettings = NULL,
  sheet = NULL
)

Arguments

See Also

getData

#

setData(dataFile = "/path/to/data/file.txt", 

        headerTypes = c("IGNORE", "OBSERVATION"), observationTypes = "continuous")

setData(dataFile = "/path/to/data/file.txt", 

        headerTypes = c("IGNORE", "OBSERVATION", "YTYPE"), 

       observationTypes = list(Concentration = "continuous", Level = "discrete"))

setData(dataFile = "/path/to/data/file.xlsx", sheet = "sheet2",

        headerTypes = c("IGNORE", "OBSERVATION", "YTYPE"), 

       observationTypes = list(Concentration = "continuous", Level = "discrete"))

## End(Not run)

[Monolix – PKanalix] Set mapping

Description

Set mapping between data and model.

Usage

setMapping(mapping)

Arguments

See Also

getMapping

#

[Monolix] setMapping(list(list(obsId = "1", modelOutput = "Cc", observationName = "concentration"), list(obsId = "2", modelOutput = "Level")))

[PKanalix] setMapping(list(list(obsId = "1", modelOutput = "Cc"), list(obsId = "2", modelOutput = "Level")))

## End(Not run)

[Monolix – PKanalix] Set structural model file

Description

Set the structural model.

Usage

setStructuralModel(modelFile)

Arguments

Details

To use a model from the libraries, you can find the model name with getLibraryModelName
and set modelFile = "lib:modelName.txt" with the name obtained.

See Also

getStructuralModel

#

setStructuralModel("/path/to/model/file.txt")

setStructuralModel("'lib:oral1_2cpt_kaClV1QV2.txt'")

# working example to set a model from the library:

initializeLixoftConnectors("monolix",force = TRUE)

loadProject(file.path(getDemoPath(),"1.creating_and_using_models","1.1.libraries_of_models","warfarinPK_project.mlxtran"))

#check model currently loaded:

getStructuralModel()

#get the name for a model from the library with 2 compartments:

LibModel2cpt = getLibraryModelName(library = "pk", filters = list(administration = "oral", delay = "lagTime", absorption = "firstOrder", distribution = "2compartments", elimination = "linear", parametrization = "clearance"))

#check model content:

getLibraryModelContent(LibModel2cpt)

#set this new model in the project:

setStructuralModel(LibModel2cpt)

# check that the project has now the new model instead of the previous one:

getStructuralModel()

## End(Not run)

[Monolix – PKanalix – Simulx] Share project.

Description

Create a zip archive file from current project and its results.

Usage

shareProject(archiveFile)

Arguments

#

shareProject("/path/to/archive.zip")

## End(Not run)

[Monolix – PKanalix – Simulx] Get console mode

Description

Get console mode, ie volume of output after running estimation tasks. Possible verbosity levels are:

Usage

getConsoleMode()

Value

A string corresponding to current console mode

See Also

setConsoleMode

[Monolix – PKanalix – Simulx] Get project preferences

Description

Get a summary of the project preferences. Preferences are: