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 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.
• getConditionalModeEstimationSettings : Get the conditional mode estimation settings.
• getGeneralSettings : Get a summary of the common settings for Monolix algorithms.
• getLogLikelihoodEstimationSettings : Get the loglikelihood estimation settings.
• getMCMCSettings : Get the MCMC algorithm settings of the current project.
• getPopulationParameterEstimationSettings : Get the population parameter estimation settings.
• getStandardErrorEstimationSettings : Get the standard error estimation settings.
• setConditionalDistributionSamplingSettings : Set the value of one or several of the conditional distribution sampling settings.
• setConditionalModeEstimationSettings : Set the value of one or several of the conditional mode estimation settings.
• setGeneralSettings : Set the value of one or several of the common settings for Monolix algorithms.
• setLogLikelihoodEstimationSettings : Set the value of the loglikelihood estimation settings.
• setMCMCSettings : Set the value of one or several of the MCMC algorithm specific settings of the current project.
• setPopulationParameterEstimationSettings : Set the value of one or several of the population parameter estimation settings.
• setStandardErrorEstimationSettings : Set the value of one or several of the standard error estimation settings.

Description of the functions concerning the convergence assessment

• getAssessmentResults : Get the results of the assessment.
• getAssessmentSettings : Get the settings that will be used during the run of 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.
• removeCovariate : Remove some 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 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 information concerning the individual parameter model.
• getVariabilityLevels : Get a summary of the variability levels (inter-individual and/or intra-individual variability) present in the current project.
• 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 between the individual parameter can be used.
• setIndividualParameterDistribution : Set the distribution of the estimated parameters.
• setIndividualParameterModel : Set the information concerning the individual parameter model.
• setIndividualParameterVariability : Add or remove inter-individual and/or intra-individual variability from some of the individual parameters present in the project.

Description of the functions concerning the initial values and estimation method

• getFixedEffectsByAutoInit : Compute optimized values for initial population parameters.
• getPopulationParameterInformation : Get the name, the initial value, the estimation method and, if relevant, MAP parameters value of the population parameters present in the project.
• setInitialEstimatesToLastEstimates : Set the initial value of all the population parameters present within the current project to the ones previously estimated.
• setPopulationParameterInformation : Set the initial value, the estimation method and, if relevant, the MAP parameters of one or several of the population parameters present within the current project (fixed effects + individual variances + error model parameters).

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 (detailed models) of the model building.
• getModelBuildingSettings : Get the settings that will be used during the run of model building.
• runModelBuilding : Run model building.

Description of the functions concerning the observation model

• getContinuousObservationModel : Get a summary of the information concerning the continuous observation models 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 with some of the observation models.
• setObservationDistribution : Set the distribution in the Gaussian space of some of the observation models.
• setObservationLimits : Set the minimum and the maximum values between which some of the observations can be found.

Description of the functions concerning the plots

• getChartsData : Compute Charts data with custom stratification options and custom computation settings.

• 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.

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, how 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 boolean 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.

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.
• getEstimatedIndividualParameters : Get the last estimated values for each subject of some 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 some 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.
• getLaunchedTasks : Get a list of the tasks which have results to provide.
• 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 individual parameters using conditional distribution sampling algorithm.
• 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 method.
• runStandardErrorEstimation : Estimate the Fisher Information Matrix and the standard errors of the population parameters.

[Monolix] Get conditional distribution sampling settings

Description

Get the conditional distribution sampling settings. Associated settings are:

Usage

getConditionalDistributionSamplingSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setConditionalDistributionSamplingSettings

#

## Not run: 

getConditionalDistributionSamplingSettings() 

# retrieve all the conditional distribution sampling settings

getConditionalDistributionSamplingSettings("ratio","nbMinIterations") 

# retrieve only the ratio and nbMinIterations settings values

## End(Not run)

[Monolix] Get conditional mode estimation settings

Description

Get the conditional mode estimation settings. Associated settings are:

Usage

getConditionalModeEstimationSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setConditionalModeEstimationSettings

#

## Not run: 

getConditionalModeEstimationSettings() 

# retrieve a list of all the conditional mode estimation settings

getConditionalModeEstimationSettings("nbOptimizationIterationsMode") 

# retrieve only the nbOptimizationIterationsMode setting value

## End(Not run)

[Monolix] Get project general settings

Description

Get a summary of the common settings for Monolix algorithms. Associated settings are:

Usage

getGeneralSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setGeneralSettings

#

## Not run: 

getGeneralSettings() # retrieve a list of all the general settings

getGeneralSettings("nbChains","autoChains")

# retrieve only the nbChains and autoChains settings values.

## End(Not run)

[Monolix] Get LogLikelihood algorithm settings

Description

Get the loglikelihood estimation settings. Associated settings are:

Usage

getLogLikelihoodEstimationSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setLogLikelihoodEstimationSettings

#

## Not run: 

getLogLikelihoodEstimationSettings() # retrieve a list of all the loglikelihood estimation settings

getLogLikelihoodEstimationSettings("nbFixedIterations","samplingMethod") 

# retrieve only nbFixedIterations and samplingMethod settings values

## End(Not run)

[Monolix] Get MCMC algorithm settings

Description

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

Usage

getMCMCSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setMCMCSettings

#

## Not run: 

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

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

## End(Not run)

[Monolix] Get population parameter estimation settings

Description

Get the population parameter estimation settings. Associated settings are:

Usage

getPopulationParameterEstimationSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setPopulationParameterEstimationSettings

#

## Not run: 

getPopulationParameterEstimationSettings() 

# retrieve a list of all the population parameter estimation settings

getPopulationParameterEstimationSettings("nbBurningIterations","smoothingInterval")

# retrieve only the nbBurningIterations and smoothingInterval settings values

## End(Not run)

[Monolix] Get standard error estimation settings

Description

Get the standard error estimation settings. Associated settings are:

Usage

getStandardErrorEstimationSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setStandardErrorEstimationSettings

#

## Not run: 

getStandardErrorEstimationSettings() 

# retrieve a list of all the standard error estimation settings

getStandardErrorEstimationSettings("minIterations","maxIterations") 

# retrieve only minIterations and maxIterations settings values

## End(Not run)

[Monolix] Set conditional distribution sampling settings

Description

Set the value of one or several of the conditional distribution sampling settings. Associated settings are:

Usage

setConditionalDistributionSamplingSettings(...)

Arguments

See Also

getConditionalDistributionSamplingSettings

#

## Not run: 

setConditionalDistributionSamplingSettings(ratio = 0.05, nbMinIterations = 50)

## End(Not run)

[Monolix] Set conditional mode estimation settings

Description

Set the value of one or several of the conditional mode estimation settings. Associated settings are:

Usage

setConditionalModeEstimationSettings(...)

Arguments

See Also

getConditionalModeEstimationSettings

#

## Not run: 

setConditionalModeEstimationSettings(nbOptimizationIterationsMode = 20, 

                                     optimizationToleranceMode = 0.1)

## End(Not run)

[Monolix] Set common settings for algorithms

Description

Set the value of one or several of the common settings for Monolix algorithms. Associated settings are:

Usage

setGeneralSettings(...)

Arguments

See Also

getGeneralSettings

#

## Not run: 

setGeneralSettings(autoChains = FALSE, nbchains = 10)

## End(Not run)

[Monolix] Set loglikelihood estimation settings

Description

Set the value of the loglikelihood estimation settings. Associated settings are:

Usage

setLogLikelihoodEstimationSettings(...)

Arguments

See Also

getLogLikelihoodEstimationSettings

#

## Not run: 

setLogLikelihoodEstimationSettings(nbFixedIterations = 20000)

## End(Not run)

[Monolix] Set settings associated to the MCMC algorithm

Description

Set the value of one or several of the MCMC algorithm specific settings of the current project. Associated settings are:

Usage

setMCMCSettings(...)

Arguments

See Also

getMCMCSettings

#

## Not run: 

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

## End(Not run)

[Monolix] Set population parameter estimation settings

Description

Set the value of one or several of the population parameter estimation settings. Associated settings are:

Usage

setPopulationParameterEstimationSettings(...)

Arguments

See Also

getPopulationParameterEstimationSettings

#

## Not run: 

setPopulationParameterEstimationSettings(exploratoryAutoStop = TRUE, tauOmega = 0.95)

## End(Not run)

[Monolix] Set standard error estimation settings

Description

Set the value of one or several of the standard error estimation settings. Associated settings are:

Usage

setStandardErrorEstimationSettings(...)

Arguments

See Also

getStandardErrorEstimationSettings

#

## Not run: 

setStandardErrorEstimationSettings(minIterations = 20, maxIterations = 250)

## End(Not run)

[Monolix] Get the results of the assessment

Description

Get the results of the assessment.

Usage

getAssessmentResults()

Value

A vector of lists containing, for each assessment run:

• populationParameters: results of population parameter estimation using SAEM:
  • nbexploratoryiterations (int) number of iterations during exploratory phase
  • nbsmoothingiterations (int) 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 (string) fisher method used (stochasticApproximation or linearization)
  • values (vector) standard error associated to each population parameter
• loglikelihood: [optional] results of log-likelihood estimation
  • method (string) fisher method used (importanceSampling or linearization)
  • AIC (double)
  • BIC (double)
  • BICc (double) modified BIC
  • LL (double)
  • chosenDegree (int) [importanceSampling]
  • standardError (double) [importanceSampling]
  • convergence (data.frame) [importanceSampling]

See Also

runAssessment

#

## Not run: 

getAssessmentResults()

## End(Not run)

[Monolix] Get assessment settings

Description

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

Usage

getAssessmentSettings()

Value

The list of settings

• nbRuns: (int) number of runs
• extendedEstimation: (boolean) if TRUE, standard errors and log-likelihood are estimated
• useLin: (boolean) if TRUE, use linearization to estimate standard errors and log-likelihood instead of stochastic approximation (sd) and importance sampling (ll)
• initialParameters: (list) a list giving, for each parameter, if its initial value is fixed (fixed = [FALSE]|TRUE) and, if is it not the case, the bounds within which the initial value is drawn (min = double, max = double)

See Also

runAssessment

#

## Not run: 

set = getAssessmentSettings()

set$nbRuns = 5

set$extendedEstimation = TRUE

set$useLin = FALSE

set$initialParameters

  parameters  fixed  min   max

1         ka  FALSE  0.5  0.75

2          V   TRUE  NaN   NaN

runAssessment(settings = set) 

## End(Not run)

[Monolix] Run 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 getAssessmentResults

#

## Not run: 

runAssessment()

set = getAssessmentSettings()

runAssessment(set)

## End(Not run)

[Monolix] Add categorical transformed covariate

Description

Create a new categorical covariate by transforming an existing one. Transformed covariates cannot be use to produce new covariates.
Call getCovariateInformation to know which covariates can be transformed.

Usage

addCategoricalTransformedCovariate(...)

Arguments

See Also

getCovariateInformation removeCovariate

#

## Not run: 

addCategoricalTransformedCovariate( Country2 = list(reference = "A1", 

          from = "Country", transformed = list( A1 = c("A","B"), A2 = c("C"))) 

          ) 

## End(Not run)

[Monolix] Add continuous transformed covariate

Description

Create a new continuous covariate by transforming an existing one. Transformed covariates cannot be use to produce new covariates.
Call getCovariateInformation to know which covariates can be transformed.

Usage

addContinuousTransformedCovariate(...)

Arguments

See Also

getCovariateInformation removeCovariate

#

## Not run: 

addContinuousTransformedCovariate( tWt2 = "3*exp(Wt)"  )

## End(Not run)

[Monolix] Add mixture to the covariate model

Description

Add a new latent covariate to the current model giving its name and its modality number.

Usage

addMixture(...)

Arguments

See Also

getCovariateInformation removeCovariate

#

## Not run: 

addMixture(lcat = 2)

## End(Not run)

[Monolix] Remove covariate

Description

Remove some of the transformed covariates (discrete and continuous) and/or latent covariates.
Call getCovariateInformation to know which covariates can be removed.

Usage

removeCovariate(...)

Arguments

See Also

getCovariateInformation addContinuousTransformedCovariate addCategoricalTransformedCovariate
addMixture

#

## Not run: 

removeCovariate("tWt","lcat1")

## End(Not run)

[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

#

## Not run: 

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 = <string> "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

#

## Not run: 

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

LINE [ int ]

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

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

ID [ string | int ]

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

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 [int]

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

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

OCC [ int ]

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 [ string ]

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 [ string (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 = <string> "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

#

## Not run: 

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

LINE [ int ]

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

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

ID [ string | int ]

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

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 [int]

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

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

OCC [ int ]

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 [ string ]

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 [ string (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

#

## Not run: 

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

#

## Not run: 

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
)

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.

#

# example: create a new project with a dataset to format:

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_h"),

           observations = list(header="CONC_mg_L",

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

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

           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_h"),

           observations = list(header="CONC_mg_L",

                               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_h"),

           observations = list(header="CONC_mg_L",

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

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

           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_h"),

           observations = list(header="CONC_mg_L",

                               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_h", sort="FORM"),

           observations = list(header="CONC_mg_L", 

                               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: a string, the name of the data set
• file: a string, the path of the data set file
• current: a boolean 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

#

## Not run: 

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<string>): covariate names
• type (vector<string>): covariate types. Existing types are "continuous", "continuoustransformed", "categorical", "categoricaltransformed"./
  In Monolix mode, "latent" covariates are also allowed.

• [Monolix] modalityNumber (vector<int>): 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.

#

## Not run: 

info = getCovariateInformation() # Monolix mode with latent covariates

info

  -> $name

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

  -> $type

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

  -> $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 from a loaded project.

Usage

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<string>): observation names.
• type (vector<string>): observation generic types. Existing types are "continuous", "discrete", "event".
• [Monolix] detailedType (vector<string>): observation specialized types set in the structural model. Existing types are "continuous", "bsmm", "wsmm", "categorical", "count", "exactEvent", "intervalCensoredEvent".
• [Monolix] mapping (vector<string>): 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.

#

## Not run: 

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 (string)
• time (double)
• amount (double)
• [optional] administrationType (int)
• [optional] infusionTime (double)
• [optional] isArtificial (bool): is created from SS or ADDL column
• [optional] isReset (bool): 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

#

## Not run: 

removeFilter()

## End(Not run)

[Monolix – PKanalix] Rename additional covariate

Description

Rename an existing additional covariate.

Usage

renameAdditionalCovariate(oldName, newName)

Arguments

See Also

addAdditionalCovariate

#

## Not run: 

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

#

## Not run: 

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

#

## Not run: 

selectData(name = "filter1")

## End(Not run)

[Monolix] Get individual parameter model

Description

Get a summary of the information concerning the individual parameter model. The available informations are:

• name: (string) name of the individual parameter
• distribution: (string) distribution of the parameter values. The distribution type can be "normal", "logNormal", or "logitNormal".
• formula: (string) formula applied on individual parameters distribution
• variability: a list giving, for each variability level, if individual parameters have variability or not
• covariateModel: a list giving, for each individual parameter, if the related covariates are used or not.
  If no covariate is used, this field is empty.

• correlationBlocks : a list giving, for each variability level, the blocks of the correlation matrix of the random effects.
  A block is represented by a vector of individual parameter names. If there is no block, this field is empty.

Usage

getIndividualParameterModel()

Value

A list of individual parameter model properties.

See Also

setIndividualParameterDistribution setIndividualParameterVariability setCovariateModel

#

## Not run: 

indivModel = getIndividualParameterModel()

indivModel

 -> $name

      c("ka","V","Cl")

    $distribution

      c(ka = "logNormal", V = "normal", Cl = "logNormal")

    $formula

      "\\tlog(ka) = log(ka_pop) + eta_ka\\n\\n

       \\tlog(V) = V_pop + eta_V\\n\\n

       \\tlog(Cl) = log(Cl_pop) + eta_Cl\\n\\n"

    $variability

      list( id = c(ka = TRUE, V = FALSE, Cl = TRUE) )

    $covariateModel

      list( ka = c(age = TRUE, sex = FALSE, wt = TRUE),

            V = c(age = FALSE, sex = FALSE, wt = FALSE),

            Cl = c(age = FALSE, sex = FALSE, wt = FALSE) )

    $correlationBlocks

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

## End(Not run)

[Monolix] Get variability levels

Description

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

Usage

getVariabilityLevels()

Value

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

#

## Not run: 

getVariabilityLevels()

## End(Not run)

[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 getIndividualParameterModel

#

## Not run: 

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

## End(Not run)

[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

#

## Not run: 

setCovariateModel( ka = c( Wt = FALSE, tWt = TRUE, lcat2 = TRUE),

                   Cl = c( SEX = TRUE )

                   )

## End(Not run)

[Monolix] Set individual parameter distribution limits

Description

Set the minimum and the maximum values between the individual parameter can be used.
Used only if the distribution of the parameter is "logitNormal", else wise it will not be taken into account

Usage

setIndividualLogitLimits(...)

Arguments

See Also

getIndividualParameterModel

#

## Not run: 

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

## End(Not run)

[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

#

## Not run: 

setIndividualParameterDistribution(V = "logNormal")

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

## End(Not run)

[Monolix] Set individual parameter model

Description

Set the information concerning the individual parameter model. The editable informations are:

• distribution: (string) distribution of the parameter values. The distribution type can be "normal", "logNormal", or "logitNormal".
• limits: a list giving the distribution limits for each parameter following a "logitNormal" distribution
• variability: a list giving, for each variability level, if individual parameters have variability or not
• covariateModel: a list giving, for each individual parameter, if the related covariates are used or not.
• correlationBlocks : a list giving, for each variability level, the blocks of the correlation matrix of the random effects.
  A block is represented by a vector of individual parameter names.

Usage

setIndividualParameterModel(...)

Arguments

[Monolix] Individual variability management

Description

Add or remove inter-individual and/or intra-individual variability 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

#

## Not run: 

setIndividualParameterVariability(ka = TRUE, V = FALSE)

setIndividualParameterVariability(id = list(ka = TRUE), iov1 = list(ka = FALSE))

## End(Not run)

[Monolix] Automatically estimate initial parameters value

Description

Compute optimized values for initial population parameters. The values are returned in the same format as getPopulationParameterInformation.

Usage

getFixedEffectsByAutoInit(parameters = NULL)

#

## Not run: 

getFixedEffectsByAutoInit() -> optimizedParameters

setPopulationParameterInformation(optimizedParameters)

## End(Not run)

[Monolix] Get population parameters information

Description

Get the name, the initial value, the estimation method and, if relevant, MAP parameters value of the population parameters present in the project.
It is available for fixed effects, random effects, error model parameters, and latent covariates probabilities.

Usage

getPopulationParameterInformation()

Value

A data frame giving, for each population parameter, the corresponding :

• initialValue : (double) initial value
• method : (string) estimation method
• priorValue : (double) [MAP] typical value
• priorSD : (double) [MAP] standard deviation

See Also

setPopulationParameterInformation

#

## Not run: 

info = getPopulationParameterInformation()

info

    name      initialValue   method   typicalValue  stdDeviation

  ka_pop           1.0      MLE             NA            NA

  V_pop           10.0      MAP           10.0           0.5

  omega_ka         1.0     FIXED            NA            NA

## End(Not run)

[Monolix] Initialize population parameters with the last estimated ones

Description

Set the initial value of all the population parameters present within the current project to the ones previously estimated.
These the values will be used in the population parameter estimation algorithm during the next scenario run.
WARNING: If there is any set after a run, it will not be possible to set the initial values as the structure of the project has changed since last results.

Usage

setInitialEstimatesToLastEstimates(fixedEffectsOnly = FALSE)

Arguments

See Also

getEstimatedPopulationParameters getPopulationParameterInformation

#

## Not run: 

setInitialEstimatesToLastEstimates() # fixedEffectsOnly = FALSE by default

setInitialEstimatesToLastEstimates(TRUE)

## End(Not run)

[Monolix] Population parameters initialization and estimation method

Description

Set the initial value, the estimation method and, if relevant, the MAP parameters of one or several of the population parameters present within the current project (fixed effects + individual variances + error model parameters).
Available methods are:

• "FIXED": Fixed
• "MLE": Maximum Likelihood Estimation
• "MAP": Maximum A Posteriori

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

Usage

setPopulationParameterInformation(...)

Arguments

See Also

getPopulationParameterInformation

#

## Not run: 

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

                                  V_pop  = list(initialValue = 1),

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

## End(Not run)

[Monolix – PKanalix – Simulx] Initialize lixoftConnectors API

Description

Initialize lixoftConnectors API for a given software.

Usage

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

Arguments

Value

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

#

## Not run: 

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

A string corresponding to Lixoft demos path corresponding to the currently active software.

#

## Not run: 

  getDemoPath()

## End(Not run)

[Monolix] Get the results of the model building

Description

Get the results (detailed models) of the model building.

Usage

getModelBuildingResults()

Value

The results of model building
All the detailed tried models are returned

• LL: result of -2*Log-Likelihood
• BICc: modified BIC.
• individualModels: (data.frame) individual model for each individual parameter.
  The columns are the covariates and the elements of the data.frame notes if a covariate is used or not for the current parameter.

COSSAC send 2 additional fields:

• tested: (vector<string>) first element is the individual parameter and the second one is the covariate.
  This combination notes if the covariate is tested or not with respect to the previous model.

• bestModel (boolean) best model amongst all the tried models according to the chosen criterion.

SAMBA send the error model and covariance model information if there are exist

• errorModels: chosen type for each error model
• covarianceModels: chosen correlations between individual parameters

See Also

runModelBuilding

#

## Not run: 

getModelBuildingResults()

## End(Not run)

[Monolix] Get model building settings

Description

Get the settings that will be used during the run of model building.

Usage

getModelBuildingSettings()

Value

The list of settings

• covariates: (list<string>) covariate names
• parameters: (list<string>) parameters names
• strategy: (string) strategy to search best model ([cossac], samba, covsamba, scm)
• criterion: (string) crtierion to search best model ([BIC], LRT)
• relationships: (data.frame<parameters, covariates, locked>) Use to lock relationships between parameters and covariates.
  By default, all the combinations are possible. This parameter forces the use or not of some combinations.
  See example where ka must have SEX and V must not have WEIGHT

• threshold$lrt: threshold used by criterion LRT to continue or not 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: (boolean) computes linearization ([TRUE]) or the Importance Sampling (FALSE)

See Also

runModelBuilding

#

## Not run: 

set = getModelBuildingSettings()

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

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

-> set$relationships

  parameters covariates locked

1         ka        SEX   TRUE

2          V     WEIGHT  FALSE

runModelBuilding(settings = set) 

## End(Not run)

[Monolix] Run model building

Description

Run model building.
To change the initialization before a run, use getModelBuildingSettings to receive all the settings. See example.

Usage

runModelBuilding(...)

Arguments

See Also

getModelBuildingSettings getModelBuildingResults

#

## Not run: 

runModelBuilding()

set = getModelBuildingSettings()

runModelBuilding(settings = set)

## End(Not run)

[Monolix] Get continuous observation models information

Description

Get a summary of the information concerning the continuous observation models in the project. The following informations are provided.

• prediction: (vector<string>) name of the associated prediction
• formula: (vector<string>) formula applied on the observation
• distribution: (vector<string>) distribution of the observation in the Gaussian space. The distribution type can be "normal", "logNormal", or "logitNormal".
• limits: (vector< pair<double,double> >) lower and upper limits imposed to the observation.
  Used only if the distribution is logitNormal. If there is no logitNormal distribution, this field is empty.

• errormodel: (vector<string>) type of the associated error model
• autocorrelation: (vector<bool>) defines if there is auto correlation

Call getObservationInformation to get a list of the continuous observations present in the current project.

Usage

getContinuousObservationModel()

Value

A list associating each continuous observation to its model properties.

See Also

getObservationInformation setObservationDistribution setObservationLimits
setErrorModel setAutocorrelation

#

## Not run: 

obsModels = getContinuousObservationModel()

obsModels

 -> $prediction

      c(Conc = "Cc")

    $formula

      c(Conc = "Conc = Cc + (a+b*Cc)*e")

    $distribution

      c(Conc = "logitNormal")

    $limits

      list(Conc = c(0,11.5))

    $errormodel

      c(Conc = "combined1")

    $autocorrelation

      c(Conc = TRUE)

## End(Not run)

[Monolix] Set auto-correlation

Description

Add or remove auto-correlation from the error model used on some of the observation models.
Call getObservationInformation to get a list of the observation models present in the current project.

Usage

setAutocorrelation(...)

Arguments

See Also

getContinuousObservationModel

#

## Not run: 

setAutocorrelation(Conc = TRUE)

setAutocorrelation(Conc = TRUE, Effect = FALSE)

## End(Not run)

[Monolix] Set error model

Description

Set the error model type to be used with some of the observation models.
Call getObservationInformation to get a list of the observation models present in the current project.

Usage

setErrorModel(...)

Arguments

Details

Available error model types are :

Error model parameters will be initialized to 1 by default.
Call setPopulationParameterInformation to modify their initial value.
The value of the exponent parameter is fixed by default when using the "combined1" and "combined2" models.

Use setPopulationParameterInformation to enable its estimation.

See Also

getContinuousObservationModel setPopulationParameterInformation

#

## Not run: 

setErrorModel(Conc = "constant", Effect = "combined1")

## End(Not run)

[Monolix] Set observation model distribution

Description

Set the distribution in the Gaussian space of some of the observation models.
Available distribution types are "normal", "logNormal", or "logitNormal".
Call getObservationInformation to get a list of the available observation models within the current project.

Usage

setObservationDistribution(...)

Arguments

See Also

getContinuousObservationModel

#

## Not run: 

setObservationDistribution(Conc = "normal")

setObservationDistribution(Conc = "normal", Effect = "logNormal")

## End(Not run)

[Monolix] Set observation model distribution limits

Description

Set the minimum and the maximum values between which some of the observations can be found.
Used only if the distribution of the error model is "logitNormal", else wise it will not be taken into account

Usage

setObservationLimits(...)

Arguments

See Also

getContinuousObservationModel getObservationInformation

#

## Not run: 

setObservationLimits( Conc = c(-Inf,Inf), Effect = c(0,Inf) )

## End(Not run)

[Monolix – PKanalix] Compute Charts data with custom stratification options and
custom computation settings

Description

Compute Charts data with custom stratification options and custom computation settings.

Usage

getChartsData(
  plotName,
  computeSettings = NULL,
  ids = NULL,
  splitGroup = NULL,
  colorGroup = NULL,
  filter = NULL
)

Arguments

Value

A dataframe object or a list of dataframe object to pass to "data" argument
of plot functions

#

## Not run: 

  initializeLixoftConnectors(software = "pkanalix")

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

  loadProject(project)

  data <- getChartsData(plotName = "plotObservedData", ids = c(1, 2, 3, 4))

  data <- getChartsData(plotName = "plotNCAParametersCorrelation")

  initializeLixoftConnectors(software = "monolix")

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

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

  loadProject(project)

  xBinsSettings <- list(is.fixedNbBins = TRUE, nbBins = 10)

  data <- getChartsData(plotName = "plotVpc",

                        computeSettings = list(xBinsSettings = xBinsSettings))

  data <- getChartsData(plotName = "plotVpc", computeSettings = list(level = 75))

  splitGroup <- list(name = "WEIGHT", breaks = c(75))

  filter <- list(name = "WEIGHT", interval = c(75, 100))

  data <- getChartsData(plotName = "plotVpc", splitGroup = splitGroup)

  data <- getChartsData(plotName = "plotVpc", filter = filter)

## End(Not run)

[Monolix – PKanalix] Generate Bivariate observations plots

Description

Plot the bivariate viewer.

Usage

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

Arguments

Value

A ggplot object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  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(ids = "10"))

  plotBivariateDataViewer(stratify = list(splitGroup = list(name = "age", breaks = 25),

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

  plotBivariateDataViewer(stratify = list(colorGroup = list(name = "wt", breaks = 75)))

  plotBivariateDataViewer(stratify = list(splitGroup = list(list(name = "age", breaks = 25),

                                                            list(name = "sex"))))

  # 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,
  data = 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

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "pkanalix")

  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(

                 splitGroup = list(name = "AGE", breaks = 25),

                 filter = list(name = "Period", cat = 1)))

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

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

                 colorGroup = list(name = "HT", breaks = 181),

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

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

                 stratify = list(splitGroup = list(list(name = "AGE", breaks = 25),

                                                   list(name = "SEQ"))))

  # Mulitple covariates

  plotCovariates()

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

  plotCovariates(stratify = list(filter = list(name = "AGE", interval = c(20, 30))))

  plotCovariates(stratify = list(splitGroup = list(name = "AGE", breaks = c(25))))

  plotCovariates(stratify = list(colorGroup = list(name = "AGE", breaks = c(25))))

[Monolix – PKanalix] Generate Observation plots

Description

Plot the observed data.

Usage

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

Arguments

Value

A ggplot object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "pkanalix")

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

  loadProject(project)

  plotObservedData()

  plotObservedData(settings = list(binLimits = TRUE))

  plotObservedData(settings = list(dosingTimes = TRUE))

  plotObservedData(settings = list(meanMethod = "geometric", mean = TRUE))

  plotObservedData(settings = list(mean = TRUE, error = TRUE, dots = FALSE, lines = TRUE))

  # stratification

  plotObservedData(stratify = list(splitGroup = list(name = "AGE", breaks = 25),

                                   filter = list(name = "Period", cat = 1)))

  plotObservedData(stratify = list(colorGroup = list(name = "HT", breaks = 181)))

  plotObservedData(stratify = list(splitGroup = list(list(name = "AGE", breaks = 25),

                                                     list(name = "Period"))))

  # update plot theme or preferences

  plotObservedData(settings = list(xlab = "Time", ylab = "Plasma Concentration"))

  plotObservedData(preferences = list(obs = list(color = "#32CD32"),

                                      observationStatistics = list(lineType = "dashed")))

[Monolix] Plot Importance sampling convergence.

Description

Plot iterations of the likelihood estimation by importance sampling.

Usage

plotImportanceSampling(settings = list(), data = NULL)

Arguments

Value

A ggplot object

See Also

getChartsData

#

  initializeLixoftConnectors(software = "monolix")

  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(), data = NULL)

Arguments

Value

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

See Also

getChartsData

#

  initializeLixoftConnectors(software = "monolix")

  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(), data = NULL)

Arguments

Value

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

See Also

getChartsData

#

  initializeLixoftConnectors(software = "monolix")

  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(),
  data = NULL
)

Arguments

Value

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

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software="monolix")

  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(name="WEIGHT", interval=c(0, 75))))

  plotParametersDistribution(parameters="Cl", stratify=list(splitGroup=list(name="SEX")))

  colorGroup <- list(name="WEIGHT", breaks=c(75))

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

                             stratify=list(colorGroup=colorGroup, colors=c("#46B4AF", "#B4468A")))

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

                             stratify=list(colorGroup=colorGroup, colors=c("#46B4AF", "#B4468A")))

  # update preferences

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

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

  # pre compute dataset

  data <- getChartsData(plotName="plotParametersDistribution",

                        computeSettings=list(indivEstimate="simulated"))

  plotParametersDistribution(data=data)

  # 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(),
  data = NULL
)

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

#

  initializeLixoftConnectors(software="monolix")

  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(name="WEIGHT", interval=c(0, 75))))

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

                             stratify=list(splitGroup=list(name="SEX")))

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

                             stratify=list(colorGroup=list(name="WEIGHT", breaks=75)))

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

                             stratify=list(colorGroup=list(name="SEX")))

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

                             stratify = list(colorGroup = list(list(name = "SEX"),

                                                               list(name="WEIGHT", breaks=70))))

  # pre process dataset

  data <- getChartsData(plotName="plotParametersVsCovariates",

                        computeSettings=list(indivEstimate="simulated"))

  plotParametersVsCovariates(data=data)

  # 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(colorGroup=list(name="WEIGHT", breaks=75)))

  plotParametersVsCovariates(stratify=list(colorGroup=list(name="SEX")))

[Monolix] Correlations between random effect.

Description

Plot correlations between random effects.

Usage

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

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

#

  initializeLixoftConnectors(software = "monolix")

  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(parametersRows = c("ka", "V"))

  # stratification

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

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

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

                               stratify = list(

                                 colorGroup = list(name = "WEIGHT", breaks = 75),

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

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

                               stratify = list(splitGroup = list(name = "SEX")))

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

                               stratify = list(splitGroup = list(list(name = "SEX"),

                                                                 list(name="WEIGHT", breaks=70))))

  # pre compute dataset

  data <- getChartsData(plotName = "plotRandomEffectsCorrelation",

                        computeSettings = list(indivEstimate = "simulated"))

  plotRandomEffectsCorrelation(data = data)

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

[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(),
  data = NULL
)

Arguments

Value

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

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software="monolix")

  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(name="WEIGHT", interval=c(0, 75)))

  )

  plotStandardizedRandomEffectsDistribution(parameters="Cl",

                                            stratify=list(splitGroup=list(name="SEX")))

  colorGroup <- list(name="WEIGHT", breaks=c(75))

  plotStandardizedRandomEffectsDistribution(

    parameters="Cl", plot="pdf",

    stratify=list(colorGroup=colorGroup, colors=c("#46B4AF", "#B4468A"))

  )

  plotStandardizedRandomEffectsDistribution(

    parameters="Cl", plot="cdf",

    stratify=list(colorGroup=colorGroup, colors=c("#46B4AF", "#B4468A"))

  )

  plotStandardizedRandomEffectsDistribution(

    parameters="Cl", settings=list(plot="boxplot"),

    stratify=list(colorGroup=colorGroup, colors=c("#46B4AF", "#B4468A"))

  )

  data <- getChartsData(plotName="plotStandardizedRandomEffectsDistribution",

                        computeSettings=list(indivEstimate="simulated"))

  plotStandardizedRandomEffectsDistribution(data=data)

  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(),
  data = NULL
)

Arguments

Details

Only available for Continuous data.

Value

A ggplot object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  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(ids=c(1, 2, 3, 4)))

  plotIndividualFits(stratify=list(filter=list(name="WEIGHT", interval=c(75, 100))))

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

  plotIndividualFits(stratify=list(colorGroup=list(name="SEX"), colors=c("#5DC088", "#DBA92B")))

  plotIndividualFits(

    settings=list(legend=T),

    stratify = list(colorGroup=list(list(name = "SEX"),

                                    list(name = "WEIGHT", breaks = 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)

  data <- getChartsData(plotName="plotIndividualFits",

                        computeSettings=list(indivEstimate="mean"),

                        ids=c(1, 2, 3, 4))

  plotIndividualFits(data=data)

[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(),
  data = NULL
)

Arguments

Value

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

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  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))

  # stratification

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

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

  plotObservationsVsPredictions(stratify = list(splitGroup = list(name = "WEIGHT", breaks = c(75))))

  plotObservationsVsPredictions(stratify = list(colorGroup = list(name = "WEIGHT", breaks = c(75))))

  plotObservationsVsPredictions(

    settings=list(legend=T),

    stratify = list(colorGroup=list(list(name = "SEX"),

                                    list(name = "WEIGHT", breaks = 70)))

  )

  data <- getChartsData(plotName = "plotObservationsVsPredictions",

                        computeSettings = list(indivEstimate = "simulated"),

                        colorGroup = list(name = "WEIGHT", breaks = c(75)))

  plotObservationsVsPredictions(data = data)

  # 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(),
  data = NULL
)

Arguments

Value

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

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software="monolix")

  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(name="SEX", cat="F")))

  plotResidualsDistribution(stratify=list(splitGroup=list(name="WEIGHT", breaks=c(75))))

  plotResidualsDistribution(

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

    stratify = list(splitGroup=list(list(name = "SEX"),

                                    list(name = "WEIGHT", breaks = 70)))

  )

  data <- getChartsData(plotName="plotResidualsDistribution",

                        computeSettings=list(indivEstimate="simulated"))

  plotResidualsDistribution(data=data)

  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(),
  data = NULL
)

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

#

  initializeLixoftConnectors(software="monolix")

  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))

  # Stratification

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

  plotResidualsScatterPlot(stratify=list(splitGroup=list(name="WEIGHT", breaks=c(75))))

  plotResidualsScatterPlot(stratify=list(colorGroup=list(name="WEIGHT", breaks=c(75))))

  data <- getChartsData(plotName="plotResidualsScatterPlot",

                        computeSettings=list(indivEstimate="simulated"))

  plotResidualsScatterPlot(data=data)

  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")

[Monolix] Plot BLQ predictive checks

Description

Plot the BLQ predictive checks.

Usage

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

Arguments

Value

a ggplot2 object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  # 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(),
  data = NULL
)

Arguments

Value

a ggplot2 object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  # 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(),
  data = NULL
)

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

#

  initializeLixoftConnectors(software = "monolix")

  # continuous data

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

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

  loadProject(project)

  runPopulationParameterEstimation()

  plotPredictionDistribution()

[Monolix] Plot Visual predictive checks

Description

Plot the visual predictive checks.

Usage

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

Arguments

Value

a ggplot2 object

See Also

getChartsData getPlotPreferences

#

  initializeLixoftConnectors(software = "monolix")

  # continuous data

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

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

  loadProject(project)

  runPopulationParameterEstimation()

  data <- getChartsData("plotVpc")

  p <- plotVpc(data = data, obsName = "CONC",

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

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

  # categorical data

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

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

  loadProject(project)

  runPopulationParameterEstimation()

  data <- getChartsData(plotName = "plotVpc")

  p <- plotVpc(data = data, 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()

  data <- getChartsData(plotName = "plotVpc")

  p <- plotVpc(data = data, 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()

  data <- getChartsData(plotName = "plotVpc")

  plotVpc(data = data, 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

#

## Not run: 

  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 – 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

#

## Not run: 

[PKanalix only]

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

[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 (string): path to the data file
• header (array<character>): vector of header names
• headerTypes (array<character>): vector of header types
• observationNames (vector<string>): vector of observation names
• observationTypes (vector<string>): vector of observation types
• nbSSDoses (int): number of doses (if there is a SS column)

Usage

getData()

Value

A list describing project data.

See Also

setData

#

## Not run: 

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")

## End(Not run)

[Monolix – PKanalix] Get interpreted project data

Description

Get data after interpretation done by the software, how it is displayed in the Data tab in the interface.
Interpretation of data includes, but is not limited to, data formatting, addition of doses through the ADDL column and steady state settings, addition of additional covariates, interpolation of regressors.

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 raw string.

#

## Not run: 

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:".

#

## Not run: 

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:
  • data (string) Data name
  • prediction (string) Prediction name
  • model [Monolix] (string) Model observation name (for continuous observations only)
  • type (string) Type of linked data ("continuous" | "discrete" | "event")
• freeData (list<list>) A list of lists describing not mapped data:
  • data (string) Data name
  • type (string) Data type
• freePredictions (list<list>) A list of lists describing not mapped predictions:
  • prediction (string) Prediction name
  • type (string) Prediction type

See Also

setMapping

#

## Not run: 

f = getMapping()

f$mapping

  -> list( list(data = "1", prediction = "Cc", model = "concentration", type = "continuous"),

           list(data = "2", prediction = "Level", type = "discrete") )

f$freeData

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

f$freePredictions

  -> list( list(prediction = "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

A string corresponding to the path to the structural model file.

See Also

For Monolix and PKanalix only: setStructuralModel

#

## Not run: 

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

#

## Not run: 

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 boolean saying if a project is currently loaded.

Usage

isProjectLoaded()

Value

TRUE if a project is currently loaded, FALSE otherwise

#

initializeLixoftConnectors("monolix")

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

#

## Not run: 

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)

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

#

# Create a new Monolix project

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"), 

                       observationTypes = list("1" = "continuous", "2" = "continuous"),

                       mapping = list(list(data = "1",

                                           prediction = "Cc",

                                           model = "y1"),

                                      list(data = "2",

                                           prediction = "R",

                                           model = "y2"))),

           modelFile = "lib:oral1_1cpt_IndirectModelInhibitionKin_TlagkaVClR0koutImaxIC50.txt")                                     

# 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

#

## Not run: 

[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, nbSSDoses = NULL)

Arguments

See Also

getData

#

## Not run: 

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"))

## End(Not run)

[Monolix – PKanalix] Set mapping

Description

Set mapping between data and model.

Usage

setMapping(mapping)

Arguments

See Also

getMapping

#

## Not run: 

[Monolix] setMapping(list(list(data = "1", prediction = "Cc", model = "concentration"), list(data = "2", prediction = "Level")))

[PKanalix] setMapping(list(list(data = "1", prediction = "Cc"), list(data = "2", prediction = "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

#

## Not run: 

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] 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:

Usage

getPreferences(...)

Arguments

Value

An array which associates each preference name to its current value.

#

## Not run: 

getPreferences() # retrieve a list of all the general settings

getPreferences("imageFormat","exportCharts") 

# retrieve only the imageFormat and exportCharts settings values

## End(Not run)

[Monolix – PKanalix – Simulx] Get project settings

Description

Get a summary of the project settings.
Associated settings for Monolix projects are:

Associated settings for PKanalix projects are:

Associated settings for Simulx projects are:

Usage

getProjectSettings(...)

Arguments

Value

An array which associates each setting name to its current value.

See Also

setProjectSettings

#

## Not run: 

getProjectSettings() # retrieve a list of all the project settings

## End(Not run)

[Monolix – Pkanalix – Simulx] Set console mode

Description

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

Usage

setConsoleMode(mode)

Arguments

See Also

getConsoleMode

[Monolix – PKanalix – Simulx] Set preferences

Description

Set the value of one or several of the project preferences. Prefenreces are:

Usage

setPreferences(...)

Arguments

See Also

getPreferences

#

## Not run: 

setPreferences(exportCharts = FALSE, delimiter = ",")

## End(Not run)

[Monolix – PKanalix – Simulx] Set project settings

Description

Set the value of one or several of the settings of the project.
Associated settings for Monolix projects are:

Associated settings for PKanalix projects are:

Associated settings for Simulx projects are:

Usage

setProjectSettings(...)

Arguments

See Also

getProjectSettings

#

## Not run: 

setProjectSettings(directory = "/path/to/export/directory", seed = 12345)

## End(Not run)

[Monolix – PKanalix] Generate report

Description

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

Usage

generateReport(
  templateFile = NULL,
  tablesStyle = NULL,
  watermark = NULL,
  reportFile = NULL
)

Arguments

Details

Reports can be generated as in the GUI, either by using the default reporting or by using a custom template. Placeholders for tables can be used in the template, and they are replaced by result tables. It is not possible to replace plots placeholders with the connector, because this requires an interface to be open. If plots placeholders are present in the template, they will be replaced by nothing in the generated report.

#

## Not run: 

generateReport()

generateReport(templateFile = "/path/to/template.docx")

generateReport(templateFile = "/path/to/template.docx", tablesStyle = "Plain Table 1", watermark = list(text = "watermark", fontSize = 15))

## End(Not run)

# Working example to generate a default report ###

initializeLixoftConnectors("monolix")

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

runScenario()

reportPath = tempfile("report", fileext = ".docx")

generateReport(reportFile = list(nextToProject = FALSE, path = reportPath))

file.show(reportPath)

# Working example to generate a report with a custom template###

# Note that only tables get replaced. It is not possible to add plots to a report via connectors, but it can be done in the GUI.

initializeLixoftConnectors("pkanalix")

loadProject(file.path(getDemoPath(),"2.case_studies","project_aPCSK9_SAD.pkx"))

runScenario()

reportPath = tempfile("report", fileext = ".docx")

generateReport(templateFile = file.path(getDemoPath(),"2.case_studies","report_templates","PK_report_template_aPCSK9.docx"), reportFile = list(nextToProject = FALSE, path = reportPath))

file.show(reportPath)

[Monolix] Export chart dataset

Description

Export the data of a chart into Lixoft suite compatible data set format.
It can be generated only if the concerned chart has been built.
The file is written in the results folder of the current project.

Usage

exportChartDataSet(type, filePath = "")

Arguments

See Also

computeChartsData runScenario

#

## Not run: 

 exportChartDataSet(type = "vpc")

 exportChartDataSet(type = "indfits", filePath = "/path/to/exported/file.txt")

## End(Not run)

[Monolix] Get the inverse of the Fisher Matrix

Description

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.
WARNING: The Fisher matrix cannot be accessible until the Fisher algorithm has been launched once.
The user can choose to display only the Fisher matrix estimated with a specific method.
Existing Fisher methods :

WARNING: Only the methods which have been used during the last scenario run can provide results.

Usage

getCorrelationOfEstimates(method = "")

Arguments

Value

A list whose each field contains the Fisher matrix computed by one of the available Fisher methods used during the ast scenario run.
A matrix is defined as a structure containing the following fields :

#

## Not run: 

getCorrelationOfEstimates("linearization")

 -> list( linearization = list(data = c(1,0,0,0,1,-0.06,0,-0.06,1),

                               rownumber = 3, 

                               rownames = c("Cl_pop","omega_Cl","a"), 

                               columnnames = c("Cl_pop","omega_Cl","a")))

getCorrelationOfEstimates() 

 -> list(linearization = list(...), stochasticApproximation = list(...) )

## End(Not run)

[Monolix] Get last estimated individual parameter values

Description

Get the last estimated values for each subject of some of the individual parameters present within the current project.
WARNING: Estimated individual parameters values cannot be accessible until the individual estimation algorithm has been launched once.
NOTE: The user can choose to display only the individual parameter values estimated with a specific method.
Existing individual estimation methods :

WARNING: Only the methods which have been used during the last scenario run can provide estimation results.

Usage

getEstimatedIndividualParameters(..., method = "")

Arguments

Value

A data frame giving, for each wanted method, the last estimated values of the individual parameters of interest for each subject with the corresponding standard deviation values.

See Also

getEstimatedRandomEffects

#

## Not run:  

indivParams = getEstimatedIndividualParameters() 

# retrieve the values of all the available individual parameters for all methods

  -> $saem

      id   Cl     V      ka

      1   0.28  7.71   0.29

      .   ...    ...    ...

      N   0.1047.62   1.51

indivParams = getEstimatedIndividualParameters("Cl", "V", method = "conditionalMean") 

# retrieve the values of the individual parameters "Cl" and "V" 

# estimated by the conditional mode method

## End(Not run)

[Monolix] Get Log-Likelihood values

Description

Get the values computed by using a log-likelihood algorithm during the last scenario run, with or without a method-based filter.
WARNING: The log-likelihood values cannot be accessible until the log-likelihood algorithm has been launched once.
The user can choose to display only the log-likelihood values computed with a specific method.
Existing log-likelihood methods :

WARNING: Only the methods which have been used during the last scenario run can provide results.

Usage

getEstimatedLogLikelihood(method = "")

Arguments

Value

A list associating the name of each method passed in argument to the corresponding log-likelihood values computed by during the last scenario run.

#

## Not run: 

getEstimatedLogLikelihood()

 -> list(  linearization = [LL = -170.505, AIC = 350.280, BIC = 365.335] ,

           importanceSampling = [...] )

getEstimatedLogLikelihood("linearization")

 -> list(  linearization = [LL = -170.505, AIC = 350.280, BIC = 365.335] )

## End(Not run)

[Monolix] Get last estimated population parameter value

Description

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).
WARNING: Estimated population parameters values cannot be accessible until the SAEM algorithm has been launched once.

Usage

getEstimatedPopulationParameters(..., coefficientsOfVariation = FALSE)

Arguments

Value

A named vector containing the last estimated value of each one of the population parameters passed in argument.

#

## Not run: 

getEstimatedPopulationParameters("V_pop") -> [V_pop = 0.5]

getEstimatedPopulationParameters("V_pop","Cl_pop") -> [V_pop = 0.5, Cl_pop = 0.25]

getEstimatedPopulationParameters() -> [V_pop = 0.5, Cl_pop = 0.25, ka_pop = 0.05]

## End(Not run)

[Monolix] Get estimated the random effects

Description

Get the random effects for each subject of some of the individual parameters present within the current project.
WARNING: Estimated random effects cannot be accessible until the individual estimation algorithm has been launched once.
The user can choose to display only the random effects estimated with a specific method.
NOTE: The random effects are defined in the gaussian referential, e.g. if ka is lognormally distributed around ka_pop, eta_i = log(ka_i)-log(ka_pop)
Existing individual estimation methods :

WARNING: Only the methods which have been used during the last scenario run can provide estimation results. Please call getLaunchedTasks to get a list of the methods whose results are available.

Usage

getEstimatedRandomEffects(..., method = "")

Arguments

Value

A data frame giving, for each wanted method, the last estimated eta values of the individual parameters of interest for each subject with the corresponding standard deviation values.

See Also

getEstimatedIndividualParameters

#

## Not run:  

etaParams = getEstimatedRandomEffects() 

# retrieve the values of all the available random effects for all methods

# without the associated standard deviations

  -> $saem

     id    Cl     V      ka

      1   0.28  7.71   0.29

      .   ...    ...    ...

      N   0.1047.62   1.51

etaParams = getEstimatedRandomEffects("Cl", "V", method = "conditionalMode") 

# retrieve the values of the individual parameters "Cl" and "V" 

# estimated by the conditional mean from SAEM algorithm

## End(Not run)

[Monolix] Get standard errors of population parameters

Description

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.
WARNING: The standard errors cannot be accessible until the Fisher algorithm has been launched once.
Existing Fisher methods :

WARNING: Only the methods which have been used during the last scenario run can provide results.

Usage

getEstimatedStandardErrors(method = "")

Arguments

Value

A list associating each retrieved Fisher algorithm method to a data frame containing the standard errors and relative standard errors (

#

## Not run: 

getEstimatedStandardErrors() -> 

  $linearization 

     parameter          se       rse

        ka_pop 0.313449586 20.451556

         V_pop 0.020422507  4.483500

       omega_V 0.037975960 30.072470

      omega_Cl 0.062976601 23.270939

  $stochasticApproximation

     parameter          se       rse

        ka_pop 0.311284296 20.310278

         V_pop 0.020424882  4.484022

       omega_V 0.161053665 24.000077

      omega_Cl 0.035113095 27.805419

## End(Not run)

[Monolix] Get tasks with results

Description

Get a list of the tasks which have results to provide. A task is the association of:

• an algorithm (string)
• a vector of methods (string) relative to this algorithm for the standardErrorEstimation and the loglikelihoodEstimation, TRUE or FALSE for the other one.

Usage

getLaunchedTasks()

Value

The list of tasks with results, indexed by algorithm names.

#

## Not run: 

tasks = getLaunchedTasks()

tasks

 -> $populationParameterEstimation = TRUE

    $conditionalModeEstimation = TRUE

	   $standardErrorEstimation = "linearization"

## End(Not run)

[Monolix] Get SAEM algorithm iterations

Description

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.
WARNING: Convergence history of population parameters values cannot be accessible until the SAEM algorithm has been launched once.

Usage

getSAEMiterations(...)

Arguments

Value

A list containing a pair composed by the number of exploratory and smoothing iterations and a data frame which associates each wanted population parameter to its successive values over SAEM algorithm iterations.

#

## Not run:  

report = getSAEMiterations()

report

  -> $iterationNumbers

       c(50,25)

     $estimates

          V    Cl

       0.25     0

        0.3   0.5

          .     .

       0.35  0.25

## End(Not run)

[Monolix] Get simulated individual parameters

Description

Get the simulated values for each replicate of each subject of some of the individual parameters present within the current project.
WARNING: Simulated individual parameters values cannot be accessible until the individual estimation with conditional mean algorithm has been launched once.

Usage

getSimulatedIndividualParameters(...)

Arguments

Value

A list giving the last simulated values of the individual parameters of interest for each replicate of each subject.

See Also

getSimulatedRandomEffects

#

## Not run:  

simParams = getSimulatedIndividualParameters() 

# retrieve the values of all the available individual parameters

simParams

     rep   id    Cl     V     ka

      1    1   0.022  0.37  1.79

      1    2   0.033  0.42  -0.92

      .    .    ...    ...  ...

      2    1   0.021  0.33  1.47

      .    .    ...    ...  ...

## End(Not run)

[Monolix] Get simulated random effects

Description

Get the simulated values for each replicate of each subject of some of the individual random effects present within the current project.
WARNING: Simulated individual random effects values cannot be accessible until the individual estimation algorithm with conditional mean has been launched once.

Usage

getSimulatedRandomEffects(...)

Arguments

Value

A list giving the last simulated values of the individual random effects of interest for each replicate of each subject.

See Also

getIndividualParameterModel

#

## Not run:  

simEtas = getSimulatedRandomEffects() 

# retrieve the values of all the available individual random effects

simEtas

     rep   id    Cl     V     ka

      1    1   0.022  0.37  1.79

      1    2   0.033  0.42  -0.92

      .    .    ...    ...  ...

      2    1   0.021  0.33  1.47

      .    .    ...    ...  ...

## End(Not run)

[Monolix] Get statistical tests results

Description

Get the results of performed statistical tests.
Existing tests: Wald, Individual parameters normality, individual parameters marginal distribution, random effects normality,
random effects correlation, individual parameters vs covariates correlation, random effects vs covariates correlation,
residual normality and residual symmetry.
WARNING: Only the tests performed during the last scenario run can provide results.

Usage

getTests()

Value

A list associating the name of the test to the corresponding results values computed during the last scenario run.

#

## Not run: 

getTests()

 -> list(  wald = [...] ,

           individualParametersNormality = [...] ,

           ... )

## End(Not run)

[Monolix – PKanalix – Simulx] Compute the charts data

Description

Compute (if needed) and export the charts data of a given plot or, if not specified, all the available project plots.

Usage

computeChartsData(plot = NULL, output = NULL, exportVPCSimulations = NULL)

Arguments

Details

computeChartsData can be used to compute and export the charts data for plots available in the graphical user interface as in Monolix, PKanalix or Simulx, when you export > export charts data.

The exported charts data is saved as txt files in the result folder, in the ChartsData subfolder.

Notice that it does not impact the current scenario.

To get a ggplot equivalent to the plot in the GUI, but customizable in R with the ggplot2 library, better use one of the plot… functions available in the connectors for Monolix and PKanalix (not available for Simulx). To get the charts data for one of these plot functions as a dataframe, you can use getChartsData.

See Also

getChartsData

#

## Not run: 

computeChartsData() # Monolix - PKanalix - Simulx

computeChartsData(plot = "vpc", output = "y1") # Monolix

## End(Not run)

[Monolix – PKanalix] Get last run status

Description

Return an execution report about the last run with a summary of the error which could have occurred.

Usage

getLastRunStatus()

Value

A structure containing

1. a boolean which equals TRUE if the last run has successfully completed,
2. a summary of the errors which could have occurred.

#

## Not run: 

lastRunInfo = getLastRunStatus()

lastRunInfo$status

 -> TRUE

lastRunInfo$report

 -> ""

## End(Not run)

[Monolix – PKanalix – Simulx] Get current scenario

Description

Get the list of tasks that will be run at the next call to runScenario. For Monolix, get in addition the associated method (linearization true or false), and the associated list of plots.

Usage

getScenario()

Details

For Monolix, getScenario returns a given list of tasks, the linearization option and the list of plots.
Every task in the list is associated to a boolean.
NOTE: Within a MONOLIX scenario, the order according to which the different algorithms are run is fixed:

For PKanalix, getScenario returns a given list of tasks.
Every task in the list is associated to a boolean.
NOTE: Within a PKanalix scenario, the order according to which the different algorithms are run is fixed:

For Simulx, setScenario returns a given list of tasks.
Every task in the list is associated to a boolean.
NOTE: Within a Simulx scenario, the order according to which the different algorithms are run is fixed:

Note: every task can also be run separately with a specific function, such as runSimulation in Simulx, runEstimation in Monolix. The CA task in PKanalix cannot be part of a scenario, it must be run with runCAEstimation.

Value

The list of tasks that corresponds to the current scenario, indexed by task names.

See Also

setScenario

#

## Not run: 

[MONOLIX]

scenario = getScenario()

scenario

 -> $tasks 

    populationParameterEstimation conditionalDistributionSampling conditionalModeEstimation standardErrorEstimation logLikelihoodEstimation plots

    TRUE                          TRUE							 TRUE                      FALSE                   FALSE                   FALSE 

    $linearization = T

    $plotList = "outputplot", "vpc"

[PKANALIX]

scenario = getScenario()

scenario

    nca     be 

   TRUE  FALSE

[SIMULX]

scenario = getScenario()

scenario

  simulation  endpoints 

        TRUE      FALSE

## End(Not run) 

[Monolix – PKanalix – Simulx] Run scenario

Description

Run the scenario that has been set with setScenario.

Usage

runScenario()

Details

A scenario is a list of tasks to be run. Setting the scenario is equivalent to selecting tasks in Monolix, PKanalix or Simulx GUI that will be performed when clicking on RUN.

Note: every task can also be run separately with a specific function, such as runSimulation in Simulx, runEstimation in Monolix. The CA task in PKanalix cannot be part of a scenario, it must be run with runCAEstimation.

See Also

setScenario getScenario

#

## Not run: 

runScenario()

## End(Not run)

[Monolix – PKanalix – Simulx] Set scenario

Description

Clear the current scenario and build a new one from a given list of tasks.

Usage

setScenario(...)

Arguments

Details

A scenario is a list of tasks to be run by runScenario. Setting the scenario is equivalent to selecting tasks in Monolix, PKanalix or Simulx GUI that will be performed when clicking on RUN.