# Single route of administration

**Demos:** bolusLinear_project, bolusMM_project, bolusMixed_project, infusion_project, oral1_project, oral0_project, sequentialOral0Oral1_project, simultaneousOral0Oral1_project, oralAlpha_project, oralTransitComp_project

## Introduction

Once a drug is administered, we usually describe subsequent processes within the organism by the pharmacokinetics (PK) process known as *ADME*: absorption, distribution, metabolism, excretion. A PK model is a dynamical system mathematically represented by a system of *ordinary differential equations* (ODEs) which describes transfers between compartments and elimination from the central compartment.

Mlxtran is remarkably efficient for implementing simple and complex PK models:

The function

`pkmodel`

can be used for standard PK models. The model is defined according to the provided set of named arguments. The`pkmodel`

function enables different parametrizations, different models of absorption, distribution and elimination, defined here and summarized in the following..Alternatively, PK macros can be used to define the different components of a compartmental model. Combining such PK components provide a high degree of flexibility for more complex PK models. They can also be combined with an ODE system.

A system of ordinary differential equations (ODEs) can also be implemented very easily.

Note that the dataset is completely independent from the model: the same datset (with one dose line per actual dose) can be used to model a simple first-order absorption, transit compartments or a double absorption mechanism with two dose fractions going via different routes. In particular, we make a clear distinction between administration (related to the data) and absorption (related to the model).

We will first explain how the pkmodel macro works and then show examples of its usage.

### The pkmodel function

The PK model is defined by the names of the input parameters of the `pkmodel`

function. These names are **reserved keywords**.

Absorption

`p`

: Fraction of dose which is absorbed`ka`

: absorption constant rate (first order absorption)or,

`Tk0`

: absorption duration (zero order absorption)`Tlag`

: lag time before absorptionor,

`Mtt, Ktr`

: mean transit time & transit rate constant

Distribution

`V`

: Volume of distribution of the central compartment`k12, k21`

: Transfer rate constants between compartments 1 (central) & 2 (peripheral)or

`V2, Q2`

: Volume of compartment 2 (peripheral) & inter compartment clearance, between compartments 1 and 2,`k13, k31`

: Transfer rate constants between compartments 1 (central) & 3 (peripheral)or

`V3, Q3`

: Volume of compartment 3 (peripheral) & inter compartment clearance, between compartments 1 and 3.

Elimination

`k`

: Elimination rate constantor

`Cl`

: Clearance`Vm, Km`

: Michaelis Menten elimination parameters

Effect compartment

`ke0`

: Effect compartment transfer rate constant

In the background, the pkmodel macro is replaced by the analytical solution (when it exists) or by the correspondin ODE system (when using Mtt,Ktr and/or Vm,Km).

## Intravenous bolus injection

### Linear elimination

**bolusLinear_project**

A single iv bolus is administered at time 0 to each patient. The data file `bolus1_data.txt`

contains 4 columns: id, time, amt (the amount of drug in mg) and y (the measured concentration). After loading the dataset, the columns are automatically tagged by Monolix:

In this example, a row contains either a dose record (in which case `y = "."`

) or a observation record (in which case `amt = "."`

). Dose lines and Observation lines are detected automatically based on the dots `"."`

. We could equivalently use the data file `bolus2_data.txt`

which contains 2 additional columns: `EVID`

(in the green frame) and `IGNORED OBSERVATION`

(in the blue frame) to mark dose and observation lines:

Here, the EVENT ID column allows the identification of an event: EVID=1 means that this record describes a dose while EVID=0 means that this record contains an observed value.

On the other hand, the IGNORED OBSERVATION column enables to tag lines for which the information in the OBSERVATION column-type is missing. MDV=1 means that the observed value of this record should be ignored while MDV=0 means that this record contains an observed value. The two data files bolus1_data.txt and bolus2_data.txt contain exactly the same information and provide exactly the same results.

To model this dateset, we want to use a one compartment model with linear elimination. The ODE system of this model is:

Here, and are, respectively, the amount and the concentration of drug in the central compartment at time t. When a dose arrives in the central compartment at time an iv bolus administration assumes that the amount of drug in the central

where (resp. ) is the amount of drug in the central compartment just before (resp. after) . Parameters of this model are V and k. We therefore use the model `bolus_1cpt_Vk`

from the Monolix PK library:

```
[LONGITUDINAL]
input = {V, k}
EQUATION:
Cc = pkmodel(V, k)
OUTPUT:
output = Cc
```

We could equivalently use the model `bolusLinearMacro.txt`

(click on the button Model and select the new PK model in the library `6.PK_models/model`

)

```
[LONGITUDINAL]
input = {V, k}
PK:
compartment(cmt=1, amount=Ac)
iv(cmt=1)
elimination(cmt=1, k)
Cc = Ac/V
OUTPUT:
output = Cc
```

These two implementations generate exactly the same C++ code and then provide exactly the same results. Here, the ODE system is linear and Monolix uses its analytical solution. Of course, it is also possible (but not recommended with this model) to use the ODE based PK model `bolusLinearODE.txt`

:

```
[LONGITUDINAL]
input = {V, k}
PK:
depot(target = Ac)
EQUATION:
ddt_Ac = - k*Ac
Cc = Ac/V
OUTPUT:
output = Cc
```

Results obtained with this model are slightly different from the ones obtained with the previous implementations since a numeric scheme is used here for solving the ODE. Moreover, the computation time is longer (between 3 and 4 time longer in that case) when using the ODE compared to the analytical solution. Individual fits obtained with this model look nice:

but the VPC show some misspecification in the elimination process:

### Michaelis Menten elimination

**bolusMM_project**

A non linear elimination is used with this project:

This model is available in the Monolix PK library as `bolus_1cpt_VVmKm`

:

```
[LONGITUDINAL]
input = {V, Vm, Km}
PK:
Cc = pkmodel(V, Vm, Km)
OUTPUT:
output = Cc
```

Instead of this model, we could equivalently use PK macros with `bolusNonLinearMacro.txt`

from the library `6.PK_models/model`

:

```
[LONGITUDINAL]
input = {V, Vm, Km}
PK:
compartment(cmt=1, amount=Ac, volume=V)
iv(cmt=1)
elimination(cmt=1, Vm, Km)
Cc = Ac/V
OUTPUT:
output = Cc
```

or an ODE with `bolusNonLinearODE`

:

```
[LONGITUDINAL]
input = {V, Vm, Km}
PK:
depot(target = Ac)
EQUATION:
ddt_Ac = -Vm*Ac/(V*Km+Ac)
Cc=Ac/V
OUTPUT:
output = Cc
```

Results obtained with these three implementations are identical since no analytical solution is available for this non linear ODE. We can then check that this PK model seems to describe much better the elimination process of the data:

### Mixed elimination

**bolusMixed_project**

THe `Monolix`

PK library contains “standard” PK models. More complex models should be implemented by the user in a model file. For instance, we assume in this project that the elimination process is a combination of linear and nonlinear elimination processes:

This model is not available in the Monolix PK library. It is implemented in `bolusMixed.txt`

:

```
[LONGITUDINAL]
input = {V, k, Vm, Km}
PK:
depot(target = Ac)
EQUATION:
ddt_Ac = -Vm*Ac/(V*Km+Ac) - k*Ac
Cc=Ac/V
OUTPUT:
output = Cc
```

This model, with a combined error model, seems to describe very well the data:

## Intravenous infusion

**infusion_project**

Intravenous infusion assumes that the drug is administrated intravenously with a constant rate (infusion rate), during a given time (infusion time). Since the amount is the product of infusion rate and infusion time, an additional column INFUSION RATE or INFUSION DURATION is required in the data file: Monolix can use both indifferently. Data file infusion_rate_data.txt has an additional column rate:

It can be replaced by infusion_tinf_data.txt which contains exactly the same information:

We use with this project a 2 compartment model with non linear elimination and parameters , , , , :

This model is available in the Monolix PK library as `infusion_2cpt_V1QV2VmKm`

:

```
[LONGITUDINAL]
input = {V1, Q, V2, Vm, Km}
PK:
V = V1
k12 = Q/V1
k21 = Q/V2
Cc = pkmodel(V, k12, k21, Vm, Km)
OUTPUT:
output = Cc
```

## Oral administration

### first-order absorption

**oral1_project**

This project uses the data file `oral_data.txt`

. For each patient, information about dosing is the time of administration and the amount. A one compartment model with first order absorption and linear elimination is used with this project. Parameters of the model are ka, V and Cl. we will then use model `oral1_kaVCl.txt`

from the `Monolix`

PK library

```
[LONGITUDINAL]
input = {ka, V, Cl}
EQUATION:
Cc = pkmodel(ka, V, Cl)
OUTPUT:
output = Cc
```

Both the individual fits and the VPCs show that this model doesn’t describe the absorption process properly.

Many options for implementing this PK model with Mlxtran exists:

using PK macros: oralMacro.txt:

```
[LONGITUDINAL]
input = {ka, V, Cl}
PK:
compartment(cmt=1, amount=Ac)
oral(cmt=1, ka)
elimination(cmt=1, k=Cl/V)
Cc=Ac/V
OUTPUT:
output = Cc
```

using a system of two ODEs as in

`oralODEb.txt`

:

```
[LONGITUDINAL]
input = {ka, V, Cl}
PK:
depot(target=Ad)
EQUATION:
k = Cl/V
ddt_Ad = -ka*Ad
ddt_Ac = ka*Ad - k*Ac
Cc = Ac/V
OUTPUT:
output = Cc
```

combining PK macros and ODE as in

`oralMacroODE.txt`

(macros are used for the absorption and ODE for the elimination):

```
[LONGITUDINAL]
input = {ka, V, Cl}
PK:
compartment(cmt=1, amount=Ac)
oral(cmt=1, ka)
EQUATION:
k = Cl/V
ddt_Ac = - k*Ac
Cc = Ac/V
OUTPUT:
output = Cc
```

or equivalently, as in

`oralODEa.txt`

:

```
[LONGITUDINAL]
input = {ka, V, Cl}
PK:
depot(target=Ac, ka)
EQUATION:
k = Cl/V
ddt_Ac = - k*Ac
Cc = Ac/V<
OUTPUT:
output = Cc
```

Only models using the pkmodel function or PK macros use an analytical solution of the ODE system.

### zero-order absorption

**oral0_project**

A one compartment model with zero order absorption and linear elimination is used to fit the same PK data with this project. Parameters of the model are Tk0, V and Cl. We will then use model `oral0_1cpt_Tk0Vk.txt`

from the Monolix PK library

```
[LONGITUDINAL]
input = {Tk0, V, Cl}
EQUATION:
Cc = pkmodel(Tk0, V, Cl)
OUTPUT:
output = Cc
```

Implementing a zero-order absorption process using ODEs is not easy… on the other hand, it becomes extremely easy to implement using either the `pkmodel`

function or the PK macro `oral(Tk0)`

.

The duration of a zero-order absorption has nothing to do with an infusion time: it is a parameter of the PK model (exactly as the absorption rate constant ka for instance), it is not part of the data.

### Sequential zero-order first-order absorption

**sequentialOral0Oral1_project**

More complex PK models can be implemented using `Mlxtran`

. A sequential zero-order first-order absorption process assumes that a fraction `Fr`

of the dose is first absorbed during a time `Tk0`

with a zero-order process, then, the remaining fraction is absorbed with a first-order process. This model is implemented in `sequentialOral0Oral1.txt`

using PK macros:

```
[LONGITUDINAL]
input = {Fr, Tk0, ka, V, Cl}
PK:
compartment(amount=Ac)
absorption(Tk0, p=Fr)
absorption(ka, Tlag=Tk0, p=1-Fr)
elimination(k=Cl/V)
Cc=Ac/V
OUTPUT:
output = Cc
```

Both the individual fits and the VPCs show that this PK model describes very well the whole ADME process for the same PK data:

### Simultaneous zero-order first-order absorption

**simultaneousOral0Oral1_project**

A simultaneous zero-order first-order absorption process assumes that a fraction `Fr`

of the dose is absorbed with a zero-order process while the remaining fraction is absorbed simultaneously with a first-order process. This model is implemented in `simultaneousOral0Oral1.txt`

using PK macros:

```
[LONGITUDINAL]
input = {Fr, Tk0, ka, V, Cl}
PK:
compartment(amount=Ac)
absorption(Tk0, p=Fr)
absorption(ka, p=1-Fr)
elimination(k=Cl/V)
Cc=Ac/V
OUTPUT:
output = Cc
```

### alpha-order absorption

**oralAlpha_project**

An -order absorption process assumes that the rate of absorption is proportional to some power of the amount of drug in the depot compartment:

This model is implemented in `oralAlpha.txt`

using ODEs:

```
[LONGITUDINAL]
input = {r, alpha, V, Cl}
PK:
depot(target = Ad)
EQUATION:
dAd = Ad^alpha
ddt_Ad = -r*dAd
ddt_Ac = r*Ad - (Cl/V)*Ac
Cc = Ac/V
OUTPUT:
output = Cc
```

### transit compartment model

**oralTransitComp_project**

A PK model with a transit compartment of transit rate Ktr and mean transit time Mtt can be implemented using the PK macro `oral(ka, Mtt, Ktr)`

, or using the `pkmodel`

function, as in `oralTransitComp.txt`

:

```
[LONGITUDINAL]
input = {Mtt, Ktr, ka, V, Cl}
EQUATION:
Cc = pkmodel(Mtt, Ktr, ka, V, Cl)
OUTPUT:
output = Cc
```

## Using different parametrizations

The PK macros and the function `pkmodel`

use some preferred parametrizations and some reserved names as input arguments: `Tlag, ka, Tk0, V, Cl, k12, k21`

. It is however possible to use another parametrization and/or other parameter names. As an example, consider a 2-compartment model for oral administration with a lag, a first order absorption and a linear elimination. We can use the `pkmodel`

function with, for instance, parameters ka, V, k, k12 and k21:

```
[LONGITUDINAL]
input = {ka, V, k, k12, k21}
PK:
Cc = pkmodel(ka, V, k, k12, k21)
OUTPUT:
output = Cc
```

Imagine now that we want i) to use the clearance Cl instead of the elimination rate constant k, ii) to use capital letters for the parameter names. We can still use the pkmodel function as follows:

```
[LONGITUDINAL]
input = {KA, V, CL, K12, K21}
PK:
Cc = pkmodel(ka=KA, V, k=CL/V, k12=K12, k21=K21)
OUTPUT:
output = Cc
```