Nothing
R/ModelAnalyticInfusion.R
In PFIM: Population Fisher Information Matrix
#' Class "ModelAnalyticInfusion"
#'
#' @description The class \code{Model} defines information concerning the construction of an analytical model in infusion.
#' The class \code{ModelAnalyticInfusion} inherits from the class \code{ModelInfusion}.
#'
#' @name ModelAnalyticInfusion-class
#' @aliases ModelAnalyticInfusion
#' @docType class
#' @include ModelInfusion.R
#' @include ModelODE.R
#' @export
ModelAnalyticInfusion = setClass(
Class = "ModelAnalyticInfusion",
contains = "ModelInfusion",
prototype = prototype(
initialConditions = list(NULL),
odeSolverParameters = list(NULL)))
#' initialize
#' @param .Object .Object
#' @param name name
#' @param description description
#' @param equations equations
#' @param outcomes outcomes
#' @param parameters parameters
#' @param modelError modelError
#' @return ModelAnalyticInfusion
#' @export
#'
setMethod( f="initialize",
signature="ModelAnalyticInfusion",
definition= function (.Object, name, description, equations, outcomes, parameters, modelError)
{
if(!missing(name))
{
.Object@name = name
}
if(!missing(description))
{
.Object@description = description
}
if(!missing(equations))
{
.Object@equations = equations
}
if(!missing(outcomes))
{
.Object@outcomes = outcomes
}
if(!missing(parameters))
{
.Object@parameters = parameters
}
if(!missing(modelError))
{
.Object@modelError = modelError
}
validObject(.Object)
return (.Object )
}
)
# ======================================================================================================
#' @rdname defineModelEquationsFromStringToFunction
#' @export
setMethod("defineModelEquationsFromStringToFunction",
signature("ModelAnalyticInfusion"),
function( object, parametersNames, outcomesWithAdministration, outcomesWithNoAdministration )
{
# get all the outcomes model & for evaluation
outcomesForEvaluation = getOutcomesForEvaluation( object )
outcomesForEvaluationWithAdministration = outcomesForEvaluation[1:length(outcomesWithAdministration)]
outcomesForEvaluationWithNoAdministration = outcomesForEvaluation[(1+length(outcomesWithAdministration)):length(outcomesForEvaluation)]
# get the equations
equationsDuringInfusionModel = getEquationsDuringInfusion( object )
equationsAfterInfusionModel = getEquationsAfterInfusion( object )
# arguments for the function
doseNames = paste( "dose_", outcomesWithAdministration, sep = "" )
TinfNames = paste( "Tinf_", outcomesWithAdministration, sep = "" )
argsOutcomesWithAdministration = c( doseNames, TinfNames, parametersNames, "t" )
# =========================================================
# equations for outcomesWithAdministration
# =========================================================
# equations during infusion for outcomesWithAdministration
equationsDuringInfusion = equationsDuringInfusionModel[outcomesWithAdministration]
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) gsub("[ \n]", "", x) )
equationsDuringInfusionBody = list()
for ( name in names( equationsDuringInfusion ) )
{
equationDuringInfusion = equationsDuringInfusion[[name]]
equationsDuringInfusionBody = c( equationsDuringInfusionBody, sprintf( "%s = %s", name, equationDuringInfusion ) )
}
functionBody = paste( equationsDuringInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithAdministration, collapse = ", "), functionBody )
modelFunctionDuringInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithAdministration = lapply( argsOutcomesWithAdministration, as.symbol )
modelFunctionDuringInfusionOutcomesWithAdministration = list( modelFunctionDuringInfusionOutcomesWithAdministration =
modelFunctionDuringInfusion,
argsOutcomesWithAdministration = argsOutcomesWithAdministration,
argsSymbolOutcomesWithAdministration = argsSymbolOutcomesWithAdministration )
# equations after infusion for outcomesWithAdministration
equationsAfterInfusionBody = list()
equationsAfterInfusion = equationsAfterInfusionModel[outcomesWithAdministration]
for ( name in names( equationsAfterInfusion ) )
{
equationAfterInfusion = equationsAfterInfusion[[name]]
equationsAfterInfusionBody = c( equationsAfterInfusionBody, sprintf( "%s = %s", name, equationAfterInfusion ) )
}
functionBody = paste( equationsAfterInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithAdministration, collapse = ", "), functionBody )
modelFunctionAfterInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithAdministration = lapply( argsOutcomesWithAdministration, as.symbol )
modelFunctionAfterInfusionOutcomesWithAdministration = list( modelFunctionAfterInfusionOutcomesWithAdministration =
modelFunctionAfterInfusion,
argsOutcomesWithAdministration = argsOutcomesWithAdministration,
argsSymbolOutcomesWithAdministration = argsSymbolOutcomesWithAdministration )
# =========================================================
# equations after infusion for outcomesWithNoAdministration
# after eqs = during eqs
# =========================================================
equationsAfterInfusionBody = list()
argsOutcomesWithNoAdministration = c( outcomesWithAdministration, parametersNames, "t" )
equationsAfterInfusion = equationsAfterInfusionModel[outcomesWithNoAdministration]
for ( name in names( equationsAfterInfusion ) )
{
equationAfterInfusion = equationsAfterInfusion[[name]]
equationsAfterInfusionBody = c( equationsAfterInfusionBody, sprintf( "%s = %s", name, equationAfterInfusion ) )
}
functionBody = paste( equationsAfterInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithNoAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithNoAdministration, collapse = ", "), functionBody )
modelFunctionAfterInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithNoAdministration = lapply( argsOutcomesWithNoAdministration, as.symbol )
modelFunctionAfterInfusionOutcomesWithNoAdministration = list( modelFunctionAfterInfusionOutcomesWithNoAdministration =
modelFunctionAfterInfusion,
argsOutcomesWithNoAdministration = argsOutcomesWithNoAdministration,
argsSymbolOutcomesWithNoAdministration =
argsSymbolOutcomesWithNoAdministration )
return( c( modelFunctionDuringInfusionOutcomesWithAdministration,
modelFunctionAfterInfusionOutcomesWithAdministration,
modelFunctionAfterInfusionOutcomesWithNoAdministration ) )
})
# ======================================================================================================
#' @rdname setDataForModelEvaluation
#' @export
setMethod("setDataForModelEvaluation",
signature("ModelAnalyticInfusion"),
function( object, arm )
{
dataForArmEvaluation = getDataForArmEvaluation( arm )
inputsModel = list()
data = list()
indexTime = list()
outcomes = dataForArmEvaluation$modelOutcomes
outcomesWithAdministration = dataForArmEvaluation$outcomesWithAdministration
samplingTimesModel = dataForArmEvaluation$samplingTimesModel
samplingTimesOutcome = dataForArmEvaluation$samplingTimesOutcome
# indicator in the dataframe for infusion
duringAndAfter = rep("After",length( samplingTimesModel ) )
duringAndAfter[1] = "No calcul"
# data for evaluation
for ( outcome in outcomesWithAdministration )
{
administration = getAdministration( arm, outcome )
tau = getTau( administration )
inputsModel$dose[[outcome]] = getDose( administration )
inputsModel$Tinf[[outcome]] = getTinf( administration )
inputsModel$timeDose[[outcome]] = getTimeDose( administration )
if ( tau !=0 )
{
maxSamplingTimeOutcome = max( samplingTimesOutcome[[outcome]] )
inputsModel$timeDose[[outcome]] = seq( 0, maxSamplingTimeOutcome, tau )
inputsModel$Tinf[[outcome]] = rep( inputsModel$Tinf[[outcome]], length( inputsModel$timeDose[[outcome]] ) )
inputsModel$dose[[outcome]] = rep( inputsModel$dose[[outcome]], length( inputsModel$timeDose[[outcome]] ) )
}
inputsModel$timeMatrix[[outcome]] = matrix( ( c( inputsModel$timeDose[[outcome]],
inputsModel$timeDose[[outcome]] + inputsModel$Tinf[[outcome]] ) ),
length( inputsModel$timeDose[[outcome]] ), 2 )
# indices for doses and Tinf
indicesDoses = c()
indicesDoses[1] = 1
timeDoseInfusionEnd = c()
timeDoseInfusion = samplingTimesModel
vec = c( inputsModel$timeDose[[outcome]], max( sort( unique( c( samplingTimesModel,
inputsModel$Tinf[[outcome]] ) ) ) ) )
# indices for doses
for (k in 1:length(vec))
{
indicesDoses[samplingTimesModel >= vec[k] & samplingTimesModel <=vec[k+1]] = k
}
# during and after
iterk=1
for ( t in samplingTimesModel )
{
assign("t", t)
indexTime[[outcome]] = which( apply( inputsModel$timeMatrix[[outcome]], 1, findInterval, x = t ) == 1)
if ( length( indexTime[[outcome]] ) != 0 )
{
duringAndAfter[iterk] = "duringInfusion"
}else{
duringAndAfter[iterk] = "afterInfusion"
}
iterk=iterk+1
}
# number of does
numberOfDoses = length( inputsModel$dose[[outcome]] )
# sampling times for dose infusion
samplingTimeDose = matrix( 0.0, length( samplingTimesModel ), numberOfDoses )
for ( i in 1:numberOfDoses )
{
samplingTimeDose[,i] = pmax( samplingTimesModel - inputsModel$timeDose[[outcome]][i], 0 )
}
samplingTimeDose = as.matrix( samplingTimeDose )
data[[outcome]] = data.frame( samplingTimesModel = samplingTimesModel,
duringAndAfter = duringAndAfter,
indicesDoses = indicesDoses,
outcome = outcome,
samplingTimeDose = I(samplingTimeDose) )
}
data = do.call( "rbind", data )
data = data[ order( data$samplingTimesModel ), ]
rownames( data ) = 1:dim( data )[1]
dataForModelEvaluation = c( dataForArmEvaluation,
list( inputsModel = inputsModel,
data = data ) )
return( dataForModelEvaluation )
})
# ======================================================================================================
#' @rdname EvaluateModel
#' @export
setMethod(f="EvaluateModel",
signature = "ModelAnalyticInfusion",
definition = function( object, dataForModelEvaluation, arm )
{
data = dataForModelEvaluation$data
samplingTimesModel = dataForModelEvaluation$samplingTimesModel
equationFunction = dataForModelEvaluation$equationFunction
inputsModel = dataForModelEvaluation$inputsModel
samplingTimesOutcome = dataForModelEvaluation$samplingTimesOutcome
outcomes = dataForModelEvaluation$modelOutcomes
outcomesWithAdministration = dataForModelEvaluation$outcomesWithAdministration
outcomesWithNoAdministration = dataForModelEvaluation$outcomesWithNoAdministration
numberOfOutcomesWithAdministration = length( outcomesWithAdministration )
numberOfOutcomesWithNoAdministration = length( outcomesWithNoAdministration )
# equations for outcomesWithAdministration
modelFunctionDuringInfusionOutcomesWithAdministration = equationFunction$modelFunctionDuringInfusionOutcomesWithAdministration
modelFunctionAfterInfusionOutcomesWithAdministration = equationFunction$modelFunctionAfterInfusionOutcomesWithAdministration
parameterNamesOutcomesWithAdministration = equationFunction$argsOutcomesWithAdministration
parameterSymbolsOutcomesWithAdministration = equationFunction$argsSymbolOutcomesWithAdministration
# equations for outcomesWithNoAdministration
modelFunctionAfterInfusionOutcomesWithNoAdministration = equationFunction$modelFunctionAfterInfusionOutcomesWithNoAdministration
parameterNamesOutcomesWithNoAdministration = equationFunction$argsOutcomesWithNoAdministration
parameterSymbolsOutcomesWithNoAdministration = equationFunction$argsSymbolOutcomesWithNoAdministration
# values for modelParameters
modelParameters = getParameters( object )
for( modelParameter in modelParameters )
{
modelParameterName = getName( modelParameter )
modelParameterValue = getMu( modelParameter )
assign( modelParameterName, modelParameterValue )
}
# model evaluation
modelEvaluation = as.data.frame( matrix( 0.0,length( samplingTimesModel ),length( outcomesWithAdministration ) ) )
colnames ( modelEvaluation ) = outcomesWithAdministration
for( iterTime in 1:dim( data )[1] )
{
duringAndAfter = data$duringAndAfter[iterTime]
indicesDoses = data$indicesDoses[iterTime]
samplings = data[iterTime,5:dim( data )[2]]
outcome = data$outcome[iterTime]
# evaluation infusion during
if( duringAndAfter == "duringInfusion")
{
# first dose
if ( indicesDoses == 1 )
{
assign("t",samplings[indicesDoses] )
assign( paste0("dose_",outcome ), inputsModel$dose[[outcome]][indicesDoses] )
assign( paste0("Tinf_",outcome ), inputsModel$Tinf[[outcome]][indicesDoses] )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionDuringInfusionOutcomesWithAdministration, setNames(
parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
}
# after the first dose
if ( indicesDoses > 1)
{
samplings = samplings[1:indicesDoses]
samplingDuring= tail( samplings, 1 )
samplingAfter = samplings[1:(indicesDoses-1)]
doseDuring = inputsModel$dose[[outcome]][indicesDoses]
dosesAfter = inputsModel$dose[[outcome]][1:(indicesDoses-1)]
tinfDuring = inputsModel$Tinf[[outcome]][indicesDoses]
tinfAfter = inputsModel$Tinf[[outcome]][1:(indicesDoses-1)]
assign("t",samplingDuring )
assign( paste0("dose_",outcome ), doseDuring )
assign( paste0("Tinf_",outcome ), tinfDuring )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionDuringInfusionOutcomesWithAdministration, setNames(
parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
for ( i in 1:(indicesDoses-1) )
{
assign("t",samplingAfter[i] )
assign( paste0("dose_",outcome ), dosesAfter[i] )
assign( paste0("Tinf_",outcome ), tinfAfter[i] )
output = unlist( do.call( modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] =
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] +
output[1:numberOfOutcomesWithAdministration]
}
}
}
else if( duringAndAfter == "afterInfusion")
{
# first dose
if ( indicesDoses == 1)
{
assign("t",samplings[indicesDoses] )
assign( paste0("dose_",outcome ), inputsModel$dose[[outcome]][indicesDoses] )
assign( paste0("Tinf_",outcome ), inputsModel$Tinf[[outcome]][indicesDoses] )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
}
# after the first dose
if ( indicesDoses > 1)
{
samplings = samplings[1:indicesDoses]
samplingDuring= tail( samplings, 1 )
samplingAfter = samplings[1:(indicesDoses-1)]
doseDuring = inputsModel$dose[[outcome]][indicesDoses]
dosesAfter = inputsModel$dose[[outcome]][1:(indicesDoses-1)]
tinfDuring = inputsModel$Tinf[[outcome]][indicesDoses]
tinfAfter = inputsModel$Tinf[[outcome]][1:(indicesDoses-1)]
assign("t",samplingDuring )
assign( paste0("dose_",outcome ), doseDuring )
assign( paste0("Tinf_",outcome ), tinfDuring )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration,parameterNamesOutcomesWithAdministration ) ) )
for ( i in 1:(indicesDoses-1) )
{
assign("t",samplingAfter[i] )
assign( paste0("dose_",outcome ), dosesAfter[i] )
assign( paste0("Tinf_",outcome ), tinfAfter[i] )
output = unlist( do.call( modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration,
parameterNamesOutcomesWithAdministration ) ) )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] =
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] +
output[1:numberOfOutcomesWithAdministration]
}
}
}
# for responses without administration (ie response PD)
if ( numberOfOutcomesWithNoAdministration > 0 )
{
assign( outcome, modelEvaluation[iterTime,outcome] )
modelEvaluation[iterTime,(1+numberOfOutcomesWithAdministration):(2*numberOfOutcomesWithAdministration)] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithNoAdministration, setNames( parameterSymbolsOutcomesWithNoAdministration,
parameterNamesOutcomesWithNoAdministration ) ) )
colnames( modelEvaluation ) = outcomes
}
} # end iter time
evaluationOutcomes = list()
for ( outcome in outcomes )
{
indexSamplingTimesOutcome = match( samplingTimesOutcome[[outcome]], samplingTimesModel )
evaluationOutcomes[[ outcome ]] = cbind( samplingTimesModel[indexSamplingTimesOutcome],
modelEvaluation[indexSamplingTimesOutcome, outcome ] )
colnames( evaluationOutcomes[[ outcome ]] ) = c( "time", outcome )
}
return( evaluationOutcomes )
})
# ======================================================================================================
#' @rdname EvaluateModelGradient
#' @export
setMethod(f = "EvaluateModelGradient",
signature = "ModelAnalyticInfusion",
definition = function( object, dataForModelEvaluation, arm )
{
samplingTimesOutcomes = dataForModelEvaluation$samplingTimesOutcomes
samplingTimesModel = dataForModelEvaluation$samplingTimesModel
modelError = dataForModelEvaluation$modelError
inputsModel = dataForModelEvaluation$inputsModel
atol = dataForModelEvaluation$odeSolverParameters$atol
rtol = dataForModelEvaluation$odeSolverParameters$rtol
shiftedParameters = dataForModelEvaluation$parametersGradient$shifted
Xcols = dataForModelEvaluation$parametersGradient$Xcols
Xcols = do.call( "cbind", Xcols )
XcolsInv = as.matrix( solve( Xcols ) )
frac = dataForModelEvaluation$parametersGradient$frac
modelParameters = getParameters( object )
parametersNames = map( modelParameters, ~ getName( .x ) ) %>% unlist()
dataForArmEvaluation = getDataForArmEvaluation( arm )
modelOutcomes = dataForArmEvaluation$modelOutcomes
evaluationModel = map( 1:ncol( shiftedParameters ), function( iterShiftedParameters )
{
modelParameters = map2( modelParameters, 1:length( modelParameters ), ~ setMu(.x, shiftedParameters[.y, iterShiftedParameters] ) )
object = setParameters( object, modelParameters )
dataForModelEvaluation = setDataForModelEvaluation( object, arm )
EvaluateModel( object, dataForModelEvaluation, arm )
})
outcomesGradient = pmap( list( modelOutcome = modelOutcomes,
samplingTimesOutcomes = list( samplingTimesOutcomes ),
parametersNames = list( parametersNames ) ),
function( modelOutcome, parametersNames, samplingTimesOutcomes, samplingTimesModel )
{
evaluationGradient = evaluationModel %>%
map(~ .x[[modelOutcome]][, modelOutcome]) %>%
reduce( cbind )
outcomesGradient = t( XcolsInv %*% t( evaluationGradient ) / frac )
indexColumn = length( parametersNames )
outcomesGradient = as.data.frame( outcomesGradient[, 2:(1 + indexColumn)] )
outcomesGradient = cbind( samplingTimesOutcomes[[modelOutcome]], outcomesGradient )
colnames( outcomesGradient ) = c("time", parametersNames)
return( outcomesGradient )
}
)
outcomesGradient = set_names( outcomesGradient, modelOutcomes )
outcomesAllGradient = list()
for( modelOutcome in modelOutcomes )
{
index = which( sapply( modelError, function (x) getOutcome(x) == modelOutcome ) )
if ( length( index ) != 0 )
{
outcomesAllGradient[[modelOutcome]] = outcomesGradient[[modelOutcome]][, 2:(1+length( modelParameters ) ) ]
}
}
outcomesAllGradient = do.call( rbind, outcomesAllGradient )
rownames( outcomesAllGradient ) = NULL
return( list( outcomesGradient = outcomesGradient,
outcomesAllGradient = outcomesAllGradient ) )
})
# ======================================================================================================
# definePKModel
# ======================================================================================================
#' @rdname definePKModel
#' @export
setMethod("definePKModel",
signature( "ModelAnalyticInfusion"),
function( object, outcomes )
{
model = ModelAnalyticInfusion()
if ( length( outcomes ) != 0 )
{
# ==========================================
# outcomes
# ==========================================
newOutcomes = outcomes
originalOutcomesPKModel = getOutcomes( object )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomes = as.list( c( originalOutcomesPKModel ) )
# ==========================================
# response names old and new
# ==========================================
responsesNames = originalOutcomes
responsesNewNames = newOutcomes
# ==========================================
# model equation
# ==========================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( object )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( object )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion )
names( equationsDuringInfusion ) = responsesNewNames
names( equationsAfterInfusion ) = responsesNewNames
# ==========================================
# dose names
# ==========================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==========================================
# Tinf names
# ==========================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==========================================
# responses names
# ==========================================
responsesNewNames = lapply( responsesNewNames, function(x) parse( text = x ) )
responsesNewNames = lapply( responsesNewNames, function(x) x[[1]] )
names( responsesNewNames ) = responsesNames
# ==========================================
# model equations
# ==========================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNewNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ===========================================
# convert equations from expression to string
# ===========================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ===========================================
# set model outcomes and equations
# ===========================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, outcomes )
}else{
# ======================
# outcomes
# ======================
originalOutcomesPKModel = getOutcomes( object )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomes = as.list( c( originalOutcomesPKModel ) )
# ===========================
# response names old and new
# ===========================
responsesNames = originalOutcomes
# ===========================
# model equation
# ===========================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( object )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( object )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion )
names( equationsDuringInfusion ) = responsesNames
names( equationsAfterInfusion ) = responsesNames
# ===========================
# dose names
# ===========================
doseNewNames = as.list(paste0( "dose_", responsesNames ))
names( doseNewNames ) = rep( "dose",length(responsesNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ===========================
# Tinf names
# ===========================
tinfNewNames = as.list(paste0( "Tinf_", responsesNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ===========================
# model equations
# ===========================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# =============================================
# convert equations from expression to string
# =============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# =============================================
# set model outcomes and equations
# =============================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return(model)
}
)
# ======================================================================================================
# definePKPDModel
# ======================================================================================================
#' @rdname definePKPDModel
#' @export
setMethod("definePKPDModel",
signature( "ModelAnalyticInfusion", "ModelAnalytic" ),
function( PKModel, PDModel, outcomes )
{
model = ModelAnalyticInfusion()
# =============================================
# with new outcomes
# =============================================
if ( length( outcomes ) != 0 )
{
# =============================================
# outcomes
# =============================================
newOutcomes = outcomes
originalOutcomesPKModel = getOutcomes( PKModel )
originalOutcomesPDModel = getOutcomes( PDModel )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomesPDModel = unlist( originalOutcomesPDModel )
originalOutcomes = as.list( c( originalOutcomesPKModel, originalOutcomesPDModel ) )
# =============================================
# response names old and new
# =============================================
responsesNames = originalOutcomes
responsesNewNames = newOutcomes
# =============================================
# model equation
# =============================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( PKModel )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion, PDModelEquations )
names( equationsDuringInfusion ) = responsesNewNames
names( equationsAfterInfusion ) = responsesNewNames
# =============================================
# dose names
# =============================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# =============================================
# Tinf names
# =============================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# =============================================
# responses names
# =============================================
responsesNewNames = lapply( responsesNewNames, function(x) parse( text = x ) )
responsesNewNames = lapply( responsesNewNames, function(x) x[[1]] )
names( responsesNewNames ) = responsesNames
# =============================================
# model equations
# =============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNewNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ============================================
# convert equations from expression to string
# ============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ============================================
# set model outcomes and equations
# ============================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, outcomes )
}else{
# ============================================
# outcomes
# ============================================
originalOutcomesPKModel = getOutcomes( PKModel )
originalOutcomesPDModel = getOutcomes( PDModel )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomesPDModel = unlist( originalOutcomesPDModel )
originalOutcomes = as.list( c( originalOutcomesPKModel, originalOutcomesPDModel ) )
# ============================================
# response names old and new
# ============================================
responsesNames = originalOutcomes
# ============================================
# model equation
# ============================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( PKModel )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion, PDModelEquations )
names( equationsDuringInfusion ) = responsesNames
names( equationsAfterInfusion ) = responsesNames
# ============================================
# dose names
# ============================================
doseNewNames = as.list(paste0( "dose_", responsesNames ))
names( doseNewNames ) = rep( "dose",length(responsesNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ============================================
# Tinf names
# ============================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ============================================
# model equations
# ============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model outcomes and equations
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return(model)
}
)
# ======================================================================================================
# definePKPDModel
# ======================================================================================================
#' @rdname definePKPDModel
#' @export
setMethod("definePKPDModel",
signature( "ModelAnalyticInfusion", "ModelODE" ),
function( PKModel, PDModel, outcomes )
{
# ==============================================================
# defines model
# ==============================================================
model = ModelODEInfusionDoseInEquations()
equations = getEquations( model )
originalOutcomes = list( "RespPK" = "C1", "RespPD" = "E" )
if ( length( outcomes ) != 0 )
{
# ==============================================================
# outcomes
# ==============================================================
newOutcomes = outcomes
# ==============================================================
# variables
# ==============================================================
variablesNames = unlist( originalOutcomes, use.names = FALSE )
variablesNewNames = unlist( newOutcomes, use.names = FALSE )
# ==============================================================
# response
# ==============================================================
responseNames = names( originalOutcomes )
responsesNewNames = names( newOutcomes )
# ==============================================================
# model equations
# ==============================================================
PKModelEquations = convertPKModelAnalyticToPKModelODE( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquations$duringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquations$afterInfusion, PDModelEquations )
# ==============================================================
# model equation
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
names( equationsDuringInfusion ) = paste0( "Deriv_", variablesNewNames )
names( equationsAfterInfusion ) = paste0( "Deriv_", variablesNewNames )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# dose names
# ==============================================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==============================================================
# Tinf names
# ==============================================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==============================================================
# variables substitution
# ==============================================================
variablesNewNames = lapply( variablesNewNames, function(x) parse( text = x ) )
variablesNewNames = lapply( variablesNewNames, function(x) x[[1]] )
# ==============================================================
# RespPK change for PD Model with PK ode Michaelis-Menten
# ==============================================================
variablesNewNames = append( variablesNewNames, variablesNewNames[[1]] )
names( variablesNewNames ) = c( variablesNames, "RespPK" )
for ( iterEquation in 1:length( equationsDuringInfusion ) )
{
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, newOutcomes )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, newOutcomes )
}else{
# ==============================================================
# variables
# ==============================================================
variablesNames = unlist( originalOutcomes, use.names = FALSE )
variablesNewNames = variablesNames
# ==============================================================
# response
# ==============================================================
responseNames = names( originalOutcomes )
responsesNewNames = responseNames
# ==============================================================
# model equations
# ==============================================================
PKModelEquations = convertPKModelAnalyticToPKModelODE( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquations$duringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquations$afterInfusion, PDModelEquations )
# ==============================================================
# model equation
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
names( equationsDuringInfusion ) = paste0( "Deriv_", variablesNewNames )
names( equationsAfterInfusion ) = paste0( "Deriv_", variablesNewNames )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# dose names
# ==============================================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==============================================================
# Tinf names
# ==============================================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==============================================================
# variables substitution
# ==============================================================
variablesNewNames = lapply( variablesNewNames, function(x) parse( text = x ) )
variablesNewNames = lapply( variablesNewNames, function(x) x[[1]] )
# ==============================================================
# RespPK change for PD Model with PK ode Michaelis-Menten
# ==============================================================
variablesNewNames = append( variablesNewNames, variablesNewNames[[1]] )
names( variablesNewNames ) = c( variablesNames, "RespPK" )
for ( iterEquation in 1:length( equationsDuringInfusion ) )
{
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return( model )
})
# ======================================================================================================
# convertPKModelAnalyticToPKModelODE
# ======================================================================================================
#' @rdname convertPKModelAnalyticToPKModelODE
#' @export
setMethod("convertPKModelAnalyticToPKModelODE",
signature("ModelAnalyticInfusion"),
function( object )
{
# ==============================================================
# name, equations and outcome
# ==============================================================
modelName = getName( object )
equations = getEquations( object )
outcome = unlist( getOutcomes( object ) )
output = list()
equationsInfusion = c()
for ( equationName in names( equations ) )
{
equation = parse( text = equations[[equationName]] )
equationPKsubstitute = equation[[1]]
dtEquationPKsubstitute = D( equationPKsubstitute, "t" )
equationPKsubstitute = paste( deparse( equationPKsubstitute ), collapse = "" )
dtEquationPKsubstitute = paste( deparse( dtEquationPKsubstitute ), collapse = "" )
if ( grepl( "Cl", modelName ) == TRUE )
{
equation = paste0( dtEquationPKsubstitute,"+(Cl/V)*", equationPKsubstitute, collapse = "" )
equation = paste0( equation, "- (Cl/V)*RespPK", collapse = "" )
}else{
equation = paste0( dtEquationPKsubstitute,"+k*", equationPKsubstitute, collapse = "" )
equation = paste0( equation, "- k*RespPK", collapse = "" )
}
equation = paste( Simplify( equation ) )
equation = gsub( " ","", equation )
equationsInfusion[[equationName]][[outcome]] = equation
}
return( equationsInfusion )
})
##########################################################################################################
# END Class "ModelAnalyticInfusion"
##########################################################################################################
Try the PFIM package in your browser
Any scripts or data that you put into this service are public.
PFIM documentation built on Oct. 30, 2024, 9:10 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
#' Class "ModelAnalyticInfusion"
#'
#' @description The class \code{Model} defines information concerning the construction of an analytical model in infusion.
#' The class \code{ModelAnalyticInfusion} inherits from the class \code{ModelInfusion}.
#'
#' @name ModelAnalyticInfusion-class
#' @aliases ModelAnalyticInfusion
#' @docType class
#' @include ModelInfusion.R
#' @include ModelODE.R
#' @export
ModelAnalyticInfusion = setClass(
Class = "ModelAnalyticInfusion",
contains = "ModelInfusion",
prototype = prototype(
initialConditions = list(NULL),
odeSolverParameters = list(NULL)))
#' initialize
#' @param .Object .Object
#' @param name name
#' @param description description
#' @param equations equations
#' @param outcomes outcomes
#' @param parameters parameters
#' @param modelError modelError
#' @return ModelAnalyticInfusion
#' @export
#'
setMethod( f="initialize",
signature="ModelAnalyticInfusion",
definition= function (.Object, name, description, equations, outcomes, parameters, modelError)
{
if(!missing(name))
{
.Object@name = name
}
if(!missing(description))
{
.Object@description = description
}
if(!missing(equations))
{
.Object@equations = equations
}
if(!missing(outcomes))
{
.Object@outcomes = outcomes
}
if(!missing(parameters))
{
.Object@parameters = parameters
}
if(!missing(modelError))
{
.Object@modelError = modelError
}
validObject(.Object)
return (.Object )
}
)
# ======================================================================================================
#' @rdname defineModelEquationsFromStringToFunction
#' @export
setMethod("defineModelEquationsFromStringToFunction",
signature("ModelAnalyticInfusion"),
function( object, parametersNames, outcomesWithAdministration, outcomesWithNoAdministration )
{
# get all the outcomes model & for evaluation
outcomesForEvaluation = getOutcomesForEvaluation( object )
outcomesForEvaluationWithAdministration = outcomesForEvaluation[1:length(outcomesWithAdministration)]
outcomesForEvaluationWithNoAdministration = outcomesForEvaluation[(1+length(outcomesWithAdministration)):length(outcomesForEvaluation)]
# get the equations
equationsDuringInfusionModel = getEquationsDuringInfusion( object )
equationsAfterInfusionModel = getEquationsAfterInfusion( object )
# arguments for the function
doseNames = paste( "dose_", outcomesWithAdministration, sep = "" )
TinfNames = paste( "Tinf_", outcomesWithAdministration, sep = "" )
argsOutcomesWithAdministration = c( doseNames, TinfNames, parametersNames, "t" )
# =========================================================
# equations for outcomesWithAdministration
# =========================================================
# equations during infusion for outcomesWithAdministration
equationsDuringInfusion = equationsDuringInfusionModel[outcomesWithAdministration]
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) gsub("[ \n]", "", x) )
equationsDuringInfusionBody = list()
for ( name in names( equationsDuringInfusion ) )
{
equationDuringInfusion = equationsDuringInfusion[[name]]
equationsDuringInfusionBody = c( equationsDuringInfusionBody, sprintf( "%s = %s", name, equationDuringInfusion ) )
}
functionBody = paste( equationsDuringInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithAdministration, collapse = ", "), functionBody )
modelFunctionDuringInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithAdministration = lapply( argsOutcomesWithAdministration, as.symbol )
modelFunctionDuringInfusionOutcomesWithAdministration = list( modelFunctionDuringInfusionOutcomesWithAdministration =
modelFunctionDuringInfusion,
argsOutcomesWithAdministration = argsOutcomesWithAdministration,
argsSymbolOutcomesWithAdministration = argsSymbolOutcomesWithAdministration )
# equations after infusion for outcomesWithAdministration
equationsAfterInfusionBody = list()
equationsAfterInfusion = equationsAfterInfusionModel[outcomesWithAdministration]
for ( name in names( equationsAfterInfusion ) )
{
equationAfterInfusion = equationsAfterInfusion[[name]]
equationsAfterInfusionBody = c( equationsAfterInfusionBody, sprintf( "%s = %s", name, equationAfterInfusion ) )
}
functionBody = paste( equationsAfterInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithAdministration, collapse = ", "), functionBody )
modelFunctionAfterInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithAdministration = lapply( argsOutcomesWithAdministration, as.symbol )
modelFunctionAfterInfusionOutcomesWithAdministration = list( modelFunctionAfterInfusionOutcomesWithAdministration =
modelFunctionAfterInfusion,
argsOutcomesWithAdministration = argsOutcomesWithAdministration,
argsSymbolOutcomesWithAdministration = argsSymbolOutcomesWithAdministration )
# =========================================================
# equations after infusion for outcomesWithNoAdministration
# after eqs = during eqs
# =========================================================
equationsAfterInfusionBody = list()
argsOutcomesWithNoAdministration = c( outcomesWithAdministration, parametersNames, "t" )
equationsAfterInfusion = equationsAfterInfusionModel[outcomesWithNoAdministration]
for ( name in names( equationsAfterInfusion ) )
{
equationAfterInfusion = equationsAfterInfusion[[name]]
equationsAfterInfusionBody = c( equationsAfterInfusionBody, sprintf( "%s = %s", name, equationAfterInfusion ) )
}
functionBody = paste( equationsAfterInfusionBody, collapse = "\n" )
functionBody = sprintf("%s\nreturn(list(%s))", functionBody, paste( outcomesForEvaluationWithNoAdministration, collapse = ", " ) )
functionDefinition = sprintf( "function(%s) { %s }", paste( argsOutcomesWithNoAdministration, collapse = ", "), functionBody )
modelFunctionAfterInfusion = eval( parse( text = functionDefinition ) )
argsSymbolOutcomesWithNoAdministration = lapply( argsOutcomesWithNoAdministration, as.symbol )
modelFunctionAfterInfusionOutcomesWithNoAdministration = list( modelFunctionAfterInfusionOutcomesWithNoAdministration =
modelFunctionAfterInfusion,
argsOutcomesWithNoAdministration = argsOutcomesWithNoAdministration,
argsSymbolOutcomesWithNoAdministration =
argsSymbolOutcomesWithNoAdministration )
return( c( modelFunctionDuringInfusionOutcomesWithAdministration,
modelFunctionAfterInfusionOutcomesWithAdministration,
modelFunctionAfterInfusionOutcomesWithNoAdministration ) )
})
# ======================================================================================================
#' @rdname setDataForModelEvaluation
#' @export
setMethod("setDataForModelEvaluation",
signature("ModelAnalyticInfusion"),
function( object, arm )
{
dataForArmEvaluation = getDataForArmEvaluation( arm )
inputsModel = list()
data = list()
indexTime = list()
outcomes = dataForArmEvaluation$modelOutcomes
outcomesWithAdministration = dataForArmEvaluation$outcomesWithAdministration
samplingTimesModel = dataForArmEvaluation$samplingTimesModel
samplingTimesOutcome = dataForArmEvaluation$samplingTimesOutcome
# indicator in the dataframe for infusion
duringAndAfter = rep("After",length( samplingTimesModel ) )
duringAndAfter[1] = "No calcul"
# data for evaluation
for ( outcome in outcomesWithAdministration )
{
administration = getAdministration( arm, outcome )
tau = getTau( administration )
inputsModel$dose[[outcome]] = getDose( administration )
inputsModel$Tinf[[outcome]] = getTinf( administration )
inputsModel$timeDose[[outcome]] = getTimeDose( administration )
if ( tau !=0 )
{
maxSamplingTimeOutcome = max( samplingTimesOutcome[[outcome]] )
inputsModel$timeDose[[outcome]] = seq( 0, maxSamplingTimeOutcome, tau )
inputsModel$Tinf[[outcome]] = rep( inputsModel$Tinf[[outcome]], length( inputsModel$timeDose[[outcome]] ) )
inputsModel$dose[[outcome]] = rep( inputsModel$dose[[outcome]], length( inputsModel$timeDose[[outcome]] ) )
}
inputsModel$timeMatrix[[outcome]] = matrix( ( c( inputsModel$timeDose[[outcome]],
inputsModel$timeDose[[outcome]] + inputsModel$Tinf[[outcome]] ) ),
length( inputsModel$timeDose[[outcome]] ), 2 )
# indices for doses and Tinf
indicesDoses = c()
indicesDoses[1] = 1
timeDoseInfusionEnd = c()
timeDoseInfusion = samplingTimesModel
vec = c( inputsModel$timeDose[[outcome]], max( sort( unique( c( samplingTimesModel,
inputsModel$Tinf[[outcome]] ) ) ) ) )
# indices for doses
for (k in 1:length(vec))
{
indicesDoses[samplingTimesModel >= vec[k] & samplingTimesModel <=vec[k+1]] = k
}
# during and after
iterk=1
for ( t in samplingTimesModel )
{
assign("t", t)
indexTime[[outcome]] = which( apply( inputsModel$timeMatrix[[outcome]], 1, findInterval, x = t ) == 1)
if ( length( indexTime[[outcome]] ) != 0 )
{
duringAndAfter[iterk] = "duringInfusion"
}else{
duringAndAfter[iterk] = "afterInfusion"
}
iterk=iterk+1
}
# number of does
numberOfDoses = length( inputsModel$dose[[outcome]] )
# sampling times for dose infusion
samplingTimeDose = matrix( 0.0, length( samplingTimesModel ), numberOfDoses )
for ( i in 1:numberOfDoses )
{
samplingTimeDose[,i] = pmax( samplingTimesModel - inputsModel$timeDose[[outcome]][i], 0 )
}
samplingTimeDose = as.matrix( samplingTimeDose )
data[[outcome]] = data.frame( samplingTimesModel = samplingTimesModel,
duringAndAfter = duringAndAfter,
indicesDoses = indicesDoses,
outcome = outcome,
samplingTimeDose = I(samplingTimeDose) )
}
data = do.call( "rbind", data )
data = data[ order( data$samplingTimesModel ), ]
rownames( data ) = 1:dim( data )[1]
dataForModelEvaluation = c( dataForArmEvaluation,
list( inputsModel = inputsModel,
data = data ) )
return( dataForModelEvaluation )
})
# ======================================================================================================
#' @rdname EvaluateModel
#' @export
setMethod(f="EvaluateModel",
signature = "ModelAnalyticInfusion",
definition = function( object, dataForModelEvaluation, arm )
{
data = dataForModelEvaluation$data
samplingTimesModel = dataForModelEvaluation$samplingTimesModel
equationFunction = dataForModelEvaluation$equationFunction
inputsModel = dataForModelEvaluation$inputsModel
samplingTimesOutcome = dataForModelEvaluation$samplingTimesOutcome
outcomes = dataForModelEvaluation$modelOutcomes
outcomesWithAdministration = dataForModelEvaluation$outcomesWithAdministration
outcomesWithNoAdministration = dataForModelEvaluation$outcomesWithNoAdministration
numberOfOutcomesWithAdministration = length( outcomesWithAdministration )
numberOfOutcomesWithNoAdministration = length( outcomesWithNoAdministration )
# equations for outcomesWithAdministration
modelFunctionDuringInfusionOutcomesWithAdministration = equationFunction$modelFunctionDuringInfusionOutcomesWithAdministration
modelFunctionAfterInfusionOutcomesWithAdministration = equationFunction$modelFunctionAfterInfusionOutcomesWithAdministration
parameterNamesOutcomesWithAdministration = equationFunction$argsOutcomesWithAdministration
parameterSymbolsOutcomesWithAdministration = equationFunction$argsSymbolOutcomesWithAdministration
# equations for outcomesWithNoAdministration
modelFunctionAfterInfusionOutcomesWithNoAdministration = equationFunction$modelFunctionAfterInfusionOutcomesWithNoAdministration
parameterNamesOutcomesWithNoAdministration = equationFunction$argsOutcomesWithNoAdministration
parameterSymbolsOutcomesWithNoAdministration = equationFunction$argsSymbolOutcomesWithNoAdministration
# values for modelParameters
modelParameters = getParameters( object )
for( modelParameter in modelParameters )
{
modelParameterName = getName( modelParameter )
modelParameterValue = getMu( modelParameter )
assign( modelParameterName, modelParameterValue )
}
# model evaluation
modelEvaluation = as.data.frame( matrix( 0.0,length( samplingTimesModel ),length( outcomesWithAdministration ) ) )
colnames ( modelEvaluation ) = outcomesWithAdministration
for( iterTime in 1:dim( data )[1] )
{
duringAndAfter = data$duringAndAfter[iterTime]
indicesDoses = data$indicesDoses[iterTime]
samplings = data[iterTime,5:dim( data )[2]]
outcome = data$outcome[iterTime]
# evaluation infusion during
if( duringAndAfter == "duringInfusion")
{
# first dose
if ( indicesDoses == 1 )
{
assign("t",samplings[indicesDoses] )
assign( paste0("dose_",outcome ), inputsModel$dose[[outcome]][indicesDoses] )
assign( paste0("Tinf_",outcome ), inputsModel$Tinf[[outcome]][indicesDoses] )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionDuringInfusionOutcomesWithAdministration, setNames(
parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
}
# after the first dose
if ( indicesDoses > 1)
{
samplings = samplings[1:indicesDoses]
samplingDuring= tail( samplings, 1 )
samplingAfter = samplings[1:(indicesDoses-1)]
doseDuring = inputsModel$dose[[outcome]][indicesDoses]
dosesAfter = inputsModel$dose[[outcome]][1:(indicesDoses-1)]
tinfDuring = inputsModel$Tinf[[outcome]][indicesDoses]
tinfAfter = inputsModel$Tinf[[outcome]][1:(indicesDoses-1)]
assign("t",samplingDuring )
assign( paste0("dose_",outcome ), doseDuring )
assign( paste0("Tinf_",outcome ), tinfDuring )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionDuringInfusionOutcomesWithAdministration, setNames(
parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
for ( i in 1:(indicesDoses-1) )
{
assign("t",samplingAfter[i] )
assign( paste0("dose_",outcome ), dosesAfter[i] )
assign( paste0("Tinf_",outcome ), tinfAfter[i] )
output = unlist( do.call( modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] =
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] +
output[1:numberOfOutcomesWithAdministration]
}
}
}
else if( duringAndAfter == "afterInfusion")
{
# first dose
if ( indicesDoses == 1)
{
assign("t",samplings[indicesDoses] )
assign( paste0("dose_",outcome ), inputsModel$dose[[outcome]][indicesDoses] )
assign( paste0("Tinf_",outcome ), inputsModel$Tinf[[outcome]][indicesDoses] )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration, parameterNamesOutcomesWithAdministration ) ) )
}
# after the first dose
if ( indicesDoses > 1)
{
samplings = samplings[1:indicesDoses]
samplingDuring= tail( samplings, 1 )
samplingAfter = samplings[1:(indicesDoses-1)]
doseDuring = inputsModel$dose[[outcome]][indicesDoses]
dosesAfter = inputsModel$dose[[outcome]][1:(indicesDoses-1)]
tinfDuring = inputsModel$Tinf[[outcome]][indicesDoses]
tinfAfter = inputsModel$Tinf[[outcome]][1:(indicesDoses-1)]
assign("t",samplingDuring )
assign( paste0("dose_",outcome ), doseDuring )
assign( paste0("Tinf_",outcome ), tinfDuring )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration,parameterNamesOutcomesWithAdministration ) ) )
for ( i in 1:(indicesDoses-1) )
{
assign("t",samplingAfter[i] )
assign( paste0("dose_",outcome ), dosesAfter[i] )
assign( paste0("Tinf_",outcome ), tinfAfter[i] )
output = unlist( do.call( modelFunctionAfterInfusionOutcomesWithAdministration,
setNames( parameterSymbolsOutcomesWithAdministration,
parameterNamesOutcomesWithAdministration ) ) )
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] =
modelEvaluation[iterTime,1:numberOfOutcomesWithAdministration] +
output[1:numberOfOutcomesWithAdministration]
}
}
}
# for responses without administration (ie response PD)
if ( numberOfOutcomesWithNoAdministration > 0 )
{
assign( outcome, modelEvaluation[iterTime,outcome] )
modelEvaluation[iterTime,(1+numberOfOutcomesWithAdministration):(2*numberOfOutcomesWithAdministration)] = unlist( do.call(
modelFunctionAfterInfusionOutcomesWithNoAdministration, setNames( parameterSymbolsOutcomesWithNoAdministration,
parameterNamesOutcomesWithNoAdministration ) ) )
colnames( modelEvaluation ) = outcomes
}
} # end iter time
evaluationOutcomes = list()
for ( outcome in outcomes )
{
indexSamplingTimesOutcome = match( samplingTimesOutcome[[outcome]], samplingTimesModel )
evaluationOutcomes[[ outcome ]] = cbind( samplingTimesModel[indexSamplingTimesOutcome],
modelEvaluation[indexSamplingTimesOutcome, outcome ] )
colnames( evaluationOutcomes[[ outcome ]] ) = c( "time", outcome )
}
return( evaluationOutcomes )
})
# ======================================================================================================
#' @rdname EvaluateModelGradient
#' @export
setMethod(f = "EvaluateModelGradient",
signature = "ModelAnalyticInfusion",
definition = function( object, dataForModelEvaluation, arm )
{
samplingTimesOutcomes = dataForModelEvaluation$samplingTimesOutcomes
samplingTimesModel = dataForModelEvaluation$samplingTimesModel
modelError = dataForModelEvaluation$modelError
inputsModel = dataForModelEvaluation$inputsModel
atol = dataForModelEvaluation$odeSolverParameters$atol
rtol = dataForModelEvaluation$odeSolverParameters$rtol
shiftedParameters = dataForModelEvaluation$parametersGradient$shifted
Xcols = dataForModelEvaluation$parametersGradient$Xcols
Xcols = do.call( "cbind", Xcols )
XcolsInv = as.matrix( solve( Xcols ) )
frac = dataForModelEvaluation$parametersGradient$frac
modelParameters = getParameters( object )
parametersNames = map( modelParameters, ~ getName( .x ) ) %>% unlist()
dataForArmEvaluation = getDataForArmEvaluation( arm )
modelOutcomes = dataForArmEvaluation$modelOutcomes
evaluationModel = map( 1:ncol( shiftedParameters ), function( iterShiftedParameters )
{
modelParameters = map2( modelParameters, 1:length( modelParameters ), ~ setMu(.x, shiftedParameters[.y, iterShiftedParameters] ) )
object = setParameters( object, modelParameters )
dataForModelEvaluation = setDataForModelEvaluation( object, arm )
EvaluateModel( object, dataForModelEvaluation, arm )
})
outcomesGradient = pmap( list( modelOutcome = modelOutcomes,
samplingTimesOutcomes = list( samplingTimesOutcomes ),
parametersNames = list( parametersNames ) ),
function( modelOutcome, parametersNames, samplingTimesOutcomes, samplingTimesModel )
{
evaluationGradient = evaluationModel %>%
map(~ .x[[modelOutcome]][, modelOutcome]) %>%
reduce( cbind )
outcomesGradient = t( XcolsInv %*% t( evaluationGradient ) / frac )
indexColumn = length( parametersNames )
outcomesGradient = as.data.frame( outcomesGradient[, 2:(1 + indexColumn)] )
outcomesGradient = cbind( samplingTimesOutcomes[[modelOutcome]], outcomesGradient )
colnames( outcomesGradient ) = c("time", parametersNames)
return( outcomesGradient )
}
)
outcomesGradient = set_names( outcomesGradient, modelOutcomes )
outcomesAllGradient = list()
for( modelOutcome in modelOutcomes )
{
index = which( sapply( modelError, function (x) getOutcome(x) == modelOutcome ) )
if ( length( index ) != 0 )
{
outcomesAllGradient[[modelOutcome]] = outcomesGradient[[modelOutcome]][, 2:(1+length( modelParameters ) ) ]
}
}
outcomesAllGradient = do.call( rbind, outcomesAllGradient )
rownames( outcomesAllGradient ) = NULL
return( list( outcomesGradient = outcomesGradient,
outcomesAllGradient = outcomesAllGradient ) )
})
# ======================================================================================================
# definePKModel
# ======================================================================================================
#' @rdname definePKModel
#' @export
setMethod("definePKModel",
signature( "ModelAnalyticInfusion"),
function( object, outcomes )
{
model = ModelAnalyticInfusion()
if ( length( outcomes ) != 0 )
{
# ==========================================
# outcomes
# ==========================================
newOutcomes = outcomes
originalOutcomesPKModel = getOutcomes( object )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomes = as.list( c( originalOutcomesPKModel ) )
# ==========================================
# response names old and new
# ==========================================
responsesNames = originalOutcomes
responsesNewNames = newOutcomes
# ==========================================
# model equation
# ==========================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( object )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( object )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion )
names( equationsDuringInfusion ) = responsesNewNames
names( equationsAfterInfusion ) = responsesNewNames
# ==========================================
# dose names
# ==========================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==========================================
# Tinf names
# ==========================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==========================================
# responses names
# ==========================================
responsesNewNames = lapply( responsesNewNames, function(x) parse( text = x ) )
responsesNewNames = lapply( responsesNewNames, function(x) x[[1]] )
names( responsesNewNames ) = responsesNames
# ==========================================
# model equations
# ==========================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNewNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ===========================================
# convert equations from expression to string
# ===========================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ===========================================
# set model outcomes and equations
# ===========================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, outcomes )
}else{
# ======================
# outcomes
# ======================
originalOutcomesPKModel = getOutcomes( object )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomes = as.list( c( originalOutcomesPKModel ) )
# ===========================
# response names old and new
# ===========================
responsesNames = originalOutcomes
# ===========================
# model equation
# ===========================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( object )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( object )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion )
names( equationsDuringInfusion ) = responsesNames
names( equationsAfterInfusion ) = responsesNames
# ===========================
# dose names
# ===========================
doseNewNames = as.list(paste0( "dose_", responsesNames ))
names( doseNewNames ) = rep( "dose",length(responsesNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ===========================
# Tinf names
# ===========================
tinfNewNames = as.list(paste0( "Tinf_", responsesNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ===========================
# model equations
# ===========================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# =============================================
# convert equations from expression to string
# =============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# =============================================
# set model outcomes and equations
# =============================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return(model)
}
)
# ======================================================================================================
# definePKPDModel
# ======================================================================================================
#' @rdname definePKPDModel
#' @export
setMethod("definePKPDModel",
signature( "ModelAnalyticInfusion", "ModelAnalytic" ),
function( PKModel, PDModel, outcomes )
{
model = ModelAnalyticInfusion()
# =============================================
# with new outcomes
# =============================================
if ( length( outcomes ) != 0 )
{
# =============================================
# outcomes
# =============================================
newOutcomes = outcomes
originalOutcomesPKModel = getOutcomes( PKModel )
originalOutcomesPDModel = getOutcomes( PDModel )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomesPDModel = unlist( originalOutcomesPDModel )
originalOutcomes = as.list( c( originalOutcomesPKModel, originalOutcomesPDModel ) )
# =============================================
# response names old and new
# =============================================
responsesNames = originalOutcomes
responsesNewNames = newOutcomes
# =============================================
# model equation
# =============================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( PKModel )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion, PDModelEquations )
names( equationsDuringInfusion ) = responsesNewNames
names( equationsAfterInfusion ) = responsesNewNames
# =============================================
# dose names
# =============================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# =============================================
# Tinf names
# =============================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# =============================================
# responses names
# =============================================
responsesNewNames = lapply( responsesNewNames, function(x) parse( text = x ) )
responsesNewNames = lapply( responsesNewNames, function(x) x[[1]] )
names( responsesNewNames ) = responsesNames
# =============================================
# model equations
# =============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNewNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], responsesNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ============================================
# convert equations from expression to string
# ============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ============================================
# set model outcomes and equations
# ============================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, outcomes )
}else{
# ============================================
# outcomes
# ============================================
originalOutcomesPKModel = getOutcomes( PKModel )
originalOutcomesPDModel = getOutcomes( PDModel )
originalOutcomesPKModel = unlist( originalOutcomesPKModel )
originalOutcomesPDModel = unlist( originalOutcomesPDModel )
originalOutcomes = as.list( c( originalOutcomesPKModel, originalOutcomesPDModel ) )
# ============================================
# response names old and new
# ============================================
responsesNames = originalOutcomes
# ============================================
# model equation
# ============================================
PKModelEquationsDuringInfusion = getEquationsDuringInfusion( PKModel )
PKModelEquationsAfterInfusion = getEquationsAfterInfusion( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquationsDuringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquationsAfterInfusion, PDModelEquations )
names( equationsDuringInfusion ) = responsesNames
names( equationsAfterInfusion ) = responsesNames
# ============================================
# dose names
# ============================================
doseNewNames = as.list(paste0( "dose_", responsesNames ))
names( doseNewNames ) = rep( "dose",length(responsesNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ============================================
# Tinf names
# ============================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ============================================
# model equations
# ============================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# change responses and doses names in equations during and after
# ==============================================================
for( iterResponseName in 1:length( responsesNames ) )
{
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsDuringInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsDuringInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], doseNewNames ) ) )
equationsAfterInfusion[[iterResponseName]] =
as.expression( do.call( 'substitute', list( equationsAfterInfusion[[iterResponseName]][[1]], tinfNewNames ) ) )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model outcomes and equations
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return(model)
}
)
# ======================================================================================================
# definePKPDModel
# ======================================================================================================
#' @rdname definePKPDModel
#' @export
setMethod("definePKPDModel",
signature( "ModelAnalyticInfusion", "ModelODE" ),
function( PKModel, PDModel, outcomes )
{
# ==============================================================
# defines model
# ==============================================================
model = ModelODEInfusionDoseInEquations()
equations = getEquations( model )
originalOutcomes = list( "RespPK" = "C1", "RespPD" = "E" )
if ( length( outcomes ) != 0 )
{
# ==============================================================
# outcomes
# ==============================================================
newOutcomes = outcomes
# ==============================================================
# variables
# ==============================================================
variablesNames = unlist( originalOutcomes, use.names = FALSE )
variablesNewNames = unlist( newOutcomes, use.names = FALSE )
# ==============================================================
# response
# ==============================================================
responseNames = names( originalOutcomes )
responsesNewNames = names( newOutcomes )
# ==============================================================
# model equations
# ==============================================================
PKModelEquations = convertPKModelAnalyticToPKModelODE( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquations$duringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquations$afterInfusion, PDModelEquations )
# ==============================================================
# model equation
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
names( equationsDuringInfusion ) = paste0( "Deriv_", variablesNewNames )
names( equationsAfterInfusion ) = paste0( "Deriv_", variablesNewNames )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# dose names
# ==============================================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==============================================================
# Tinf names
# ==============================================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==============================================================
# variables substitution
# ==============================================================
variablesNewNames = lapply( variablesNewNames, function(x) parse( text = x ) )
variablesNewNames = lapply( variablesNewNames, function(x) x[[1]] )
# ==============================================================
# RespPK change for PD Model with PK ode Michaelis-Menten
# ==============================================================
variablesNewNames = append( variablesNewNames, variablesNewNames[[1]] )
names( variablesNewNames ) = c( variablesNames, "RespPK" )
for ( iterEquation in 1:length( equationsDuringInfusion ) )
{
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, newOutcomes )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, newOutcomes )
}else{
# ==============================================================
# variables
# ==============================================================
variablesNames = unlist( originalOutcomes, use.names = FALSE )
variablesNewNames = variablesNames
# ==============================================================
# response
# ==============================================================
responseNames = names( originalOutcomes )
responsesNewNames = responseNames
# ==============================================================
# model equations
# ==============================================================
PKModelEquations = convertPKModelAnalyticToPKModelODE( PKModel )
PDModelEquations = getEquations( PDModel )
equationsDuringInfusion = c( PKModelEquations$duringInfusion, PDModelEquations )
equationsAfterInfusion = c( PKModelEquations$afterInfusion, PDModelEquations )
# ==============================================================
# model equation
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
names( equationsDuringInfusion ) = paste0( "Deriv_", variablesNewNames )
names( equationsAfterInfusion ) = paste0( "Deriv_", variablesNewNames )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) parse( text = x ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) parse( text = x ) )
# ==============================================================
# dose names
# ==============================================================
doseNewNames = as.list(paste0( "dose_", responsesNewNames ))
names( doseNewNames ) = rep( "dose",length(responsesNewNames))
doseNewNames = lapply( doseNewNames, function(x) parse( text = x ) )
doseNewNames = lapply( doseNewNames, function(x) x[[1]] )
# ==============================================================
# Tinf names
# ==============================================================
tinfNewNames = as.list(paste0( "Tinf_", responsesNewNames ))
names( tinfNewNames ) = rep( "Tinf",length(responsesNewNames))
tinfNewNames = lapply( tinfNewNames, function(x) parse( text = x ) )
tinfNewNames = lapply( tinfNewNames, function(x) x[[1]] )
# ==============================================================
# variables substitution
# ==============================================================
variablesNewNames = lapply( variablesNewNames, function(x) parse( text = x ) )
variablesNewNames = lapply( variablesNewNames, function(x) x[[1]] )
# ==============================================================
# RespPK change for PD Model with PK ode Michaelis-Menten
# ==============================================================
variablesNewNames = append( variablesNewNames, variablesNewNames[[1]] )
names( variablesNewNames ) = c( variablesNames, "RespPK" )
for ( iterEquation in 1:length( equationsDuringInfusion ) )
{
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsDuringInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsDuringInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
variablesNewNames ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
doseNewNames[iterEquation] ) ) )
equationsAfterInfusion[[iterEquation]] = as.expression(do.call( 'substitute',
list( equationsAfterInfusion[[iterEquation]][[1]],
tinfNewNames[iterEquation] ) ) )
}
# ==============================================================
# convert equations from expression to string
# ==============================================================
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) x[[1]] )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsDuringInfusion = lapply( equationsDuringInfusion, function(x) str_replace_all( x, " ", "" ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) x[[1]] )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) paste( deparse( x ), collapse = " " ) )
equationsAfterInfusion = lapply( equationsAfterInfusion, function(x) str_replace_all( x, " ", "" ) )
# ==============================================================
# set model equations ans outcomes
# ==============================================================
model = setEquationsDuringInfusion( model, equationsDuringInfusion )
model = setEquationsAfterInfusion( model, equationsAfterInfusion )
model = setOutcomes( model, originalOutcomes )
}
return( model )
})
# ======================================================================================================
# convertPKModelAnalyticToPKModelODE
# ======================================================================================================
#' @rdname convertPKModelAnalyticToPKModelODE
#' @export
setMethod("convertPKModelAnalyticToPKModelODE",
signature("ModelAnalyticInfusion"),
function( object )
{
# ==============================================================
# name, equations and outcome
# ==============================================================
modelName = getName( object )
equations = getEquations( object )
outcome = unlist( getOutcomes( object ) )
output = list()
equationsInfusion = c()
for ( equationName in names( equations ) )
{
equation = parse( text = equations[[equationName]] )
equationPKsubstitute = equation[[1]]
dtEquationPKsubstitute = D( equationPKsubstitute, "t" )
equationPKsubstitute = paste( deparse( equationPKsubstitute ), collapse = "" )
dtEquationPKsubstitute = paste( deparse( dtEquationPKsubstitute ), collapse = "" )
if ( grepl( "Cl", modelName ) == TRUE )
{
equation = paste0( dtEquationPKsubstitute,"+(Cl/V)*", equationPKsubstitute, collapse = "" )
equation = paste0( equation, "- (Cl/V)*RespPK", collapse = "" )
}else{
equation = paste0( dtEquationPKsubstitute,"+k*", equationPKsubstitute, collapse = "" )
equation = paste0( equation, "- k*RespPK", collapse = "" )
}
equation = paste( Simplify( equation ) )
equation = gsub( " ","", equation )
equationsInfusion[[equationName]][[outcome]] = equation
}
return( equationsInfusion )
})
##########################################################################################################
# END Class "ModelAnalyticInfusion"
##########################################################################################################
Try the PFIM package in your browser
Any scripts or data that you put into this service are public.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.