GNU MCSim User’s Manual

e.g. · GNU MCSim

Reference Manual

Appendices

Index Table

Copyright © 2000,2001,2002 Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

./configure
make
make check

make install

./configure prefix=/home/me

./configure --with-mpi=no

States = {Q_fat,   # Quantity of PERC in the fat (mg)
          Q_wp,    #   ...   in the well-perfused compartment (mg)
          Q_pp,    #   ...   in the poorly-perfused compartment (mg)
          Q_liv,   #   ...   in the liver (mg)
          Q_exh,   #   ...   exhaled (mg)
          Q_met}   # Quantity of metabolite formed (mg)

Outputs = {C_liv,           # mg/l in the liver
           C_alv,           # ... in the alveolar air
           C_exh,           # ... in the exhaled air
           C_ven,           # ... in the venous blood
           Pct_metabolized, # % of the dose metabolized
           C_exh_ug}        # ug/l in the exhaled air

Inputs = {C_inh,   # Concentration inhaled (ppm)
          Q_ing};  # Quantity ingested (mg)

LeanBodyWt = 55; # lean body weight (kg)

mod [input-file [output-file]]

makemcsim [model-file]

# Model description file (this is a comment)
<Declarations of global variables>
Initialize {
  <Equations for initializing or scaling model parameters>
}
Dynamics {
  <Equations for computing derivatives of the state variables>
}
Jacobian {
  <Equation for the Jacobian of the state derivatives>
}
CalcOutputs {
  <Equations for computing output variables>
}
End. # mandatory ending keyword

<variable-name> '=' <constant-value-or-expression> ';'

<variable-name> = (<test> ? <value-if-true> : <value-if-false>);

Adjusted_Param = (Input_Var > 0.0 ? Param * 1.1 : Param);

<variable-name> '[' <integer> ']'
<variable-name> '[' <integer> '-' <integer> ']'

States = {y[0-9]};
alpha[0-2] = 1;
beta[0] = 1;
beta[1] = 2;
beta[2-4];

<variable-name> '[' <integer> ']'

Outputs = {x[0-1]};
beta[0] = 0;
beta[1] = beta[0] + 1;
CalcOutputs {
  x[0] = beta[0] * t;
  x[1] = beta[1] * t;
}

<var-name>'['<integer>'-'<integer>']' = <vectorized-expression>;

CalcOutputs {
  x[0-1] = beta[i] * t;
}

Outputs{x[1-10]};
CalcOutputs {
  x[1] = 0;
  x[2-10] = x[i-1] + 1;
}

Outputs{x[1-10]};
CalcOutputs {
  x[1] = 0;
  x[2] = x[1] + 1;
  ...
  x[10] = x[9] + 1;
}

<variable-name>'_'<integer>

States =   {Qb_fat,  # Benzene in the fat
            Qb_bm,   # ...     in the bone marrow
            Qb_liv}; # ...     in the liver and others

Inputs =   {Q_gav,   # Gavage dose
            C_inh};  # Inhalation concentration

Outputs =  {Cb_exp,  # Concentration in expired air
            Cb_ven}; # ...           in venous blood

Qb = 0.1; # Default initial value for state variable Qb

# Input variable assigned a periodic exponential input function
Q = PerExp(1, 60, 0, 1); # Magnitude of 1.0,
                         # period of 60 time units,
                         # T0 in period is 0,
                         # Rate constant is 1.0

Wind_speed; # (m/s) Local wind speed

BodyWt = 65.0 + sqrt(15.0); # Weight of the subject (in kg)

rdm_seed = 87239;
Inline( SetSeed(rdm_seed); );

<input variable> = PerDose(<magnitude>, <period>, <initial-time>,
                           <exposure-time>);

<input variable> = PerExp(<magnitude>, <period>, <initial-time>,
                          <decay-constant>);

((K_tr * t)^n) * exp(-K_tr * t) / n!

<input variable> = PerTransit(<magnitude>, <period>,
                              <initial-time-in-period>,
                              <transfer-rate-constant>,
                              <number-of-input-compartments>);

<input variable> = NDoses(<n>, <list-of-magnitudes>,
                          <list-of-initial-times>);

My_input = NDoses(10, My_magnitudes[1-10], My_initial_times[1-10]);

<input variable> = Spikes(<n>, <list-of-magnitudes>,
                          <list-of-times>);

Q_in = PerExp(Mag, 60, 0, RateConst);

Inline( printf("hello/n"); );

Inline( \#include <gsl/gsl_interp.h> );

Error: State variable 'Q_foo' has no dynamics.

dt(state-variable) '=' constant-value-or-expression ';'

dt(Qm_in) = Qmetabolized - dt(Qm_out);

dt(Qm_in) = Qmetabolized - t;

Error: line 48: 'YourParm' used in invalid context.
Parameters cannot be defined in Dynamics{} section.

  CalcDelay (<variable>, <delay>);

  tau = 100;
  dt (Q1) = k * CalcDelay(Q3, tau);
  dt (Q2) = k * CalcDelay(Q3, 10);

Error: line 56: 'Qb_fat' used in invalid context.
Only output and local variables can be defined in CalcOutputs section.

a = a + b;

Qx_out = DQx * t;

#---------------------------------------------------------
# SBML_List.in
# Use it as "mod SBML_List.in"
#---------------------------------------------------------

SBMLModels = {useID, "default", "C_central.xml", "C_periph.xml"};

End.

#---------------------------------------------------------
# SBML_List.in
# Use it as "mod SBML_List.in"
#---------------------------------------------------------

PKTemplate = {"input_f/2cpt_PBPK.model"};

SBMLModels = {"C_central.xml", "C_periph.xml"};

End.

#---------------------------------------------------------
# Template for pharmacokinetic modeling
#---------------------------------------------------------

States = {_central, _periph};
Inputs = {_Dose_rate};
Outputs = {_Q_total};
Compartments = {central, peripheral};

# Species-dependent parameters
_PC = 2;
_K_urine;

# Species-independent parameters
V_central;
V_periph;

Initialize { _K_urine = _K_urine * 2; }

Dynamics {
  _Q_rate_c_p = 5 * (_central - _periph / _PC);

  # Central compartment quantity
  _pk_central  = (_Dose_rate - _Q_rate_c_p -
                  _K_urine * _central) / V_central;
  dt(_central) = _pk_central;

  # Peripheral compartment quantity
  _pk_periph  = _Q_rate_c_p / V_periph;
  dt(_periph) = _pk_periph;
 }

CalcOutputs { _Q_total = _central / V_central + _periph / V_periph; }

End.

  mod -R perc.model

mcsim_a [run-time options] [input-file [output-file]]

mpirun -np 50 mcsim_a [run-time options] [input-file [output-file]]

# Input file (text after # are comments)
<Global assignments and specifications>
Simulation {
  <Specifications for first simulation>
}
Simulation {
  <Specifications for second simulation>
}
# Unlimited number of simulation specifications
End. # Mandatory End keyword. Everything after this line is ignored

# Input file
<Global assignments and specifications>
Level {
  # Up to 10 levels of hierarchy
  Simulation {
    <Specifications and data for first simulation>
  }
  Simulation {
    <Specifications and data for second simulation>
  }
  # Unlimited number of simulation specifications
} # end Level
End. # Mandatory keyword.

Simulation {
  y[1-10] = 1.00;
  PrintStep (y[1-5],  0, 10, 0.5);
  Print     (y[6-10], 0, 5, 10);
}

PerDose(<magnitude>, <period>, <initial-time>, <exposure-time>);

PerExp(<magnitude>, <period>, <initial-time>, <decay-constant>);

PerTransit(<magnitude>, <period>, <initial-time-in-period>,
           <decay-constant>, <number-of-input-compartments>);

NDoses(<n>, <list-of-magnitudes>, <list-of-initial-times>);

Spikes(<n>, <list-of-magnitudes>, <list-of-times>);

x = 10; # set the initial value if x is a state variable
Pi = 3; # to stop worrying about little decimals...

OutputFile("<OutputFilename>");

Integrate(Lsodes, <rtol>, <atol>, <method>);

Integrate(Cvodes, <rtol>, <atol>, <maxsteps>, <maxnef>, <maxcor>,
          <maxncf>, <nlscoef>);

Integrate(Cvodes, 1E-6, 1E-6, 500, 7, 3, 10, 0.1);

Integrate(Euler, <time-step>);

MonteCarlo("<OutputFilename>", <nRuns>, <RandomSeed>);

MonteCarlo("percsimmc.out", 50000, 9386);

MCMC("<OutputFilename>", "<RestartFilename>", "<DataFilename>",
     <nRuns>, <simTypeFlag>, <printFrequency>, <itersToPrint>,
     <RandomSeed>);

InvTemperature(<nValues>, <value 1>, <...>, <value n>);

SetPoints("<OutputFilename>", "<SetPointsFilename>", <nRuns>,
          <parameter identifier>, <parameter identifier>, ...);

OptimalDesign("<OutputFilename>", "<ParameterSampleFilename>",
              <nSamples>, <RandomSeed>, <Style>,
              <parameter identifier>, <parameter identifier>, ...);

Distrib(<parameter identifier>, <distribution-name>,
        [<shape parameters>]);

Distrib(Var, TruncLogNormal, 1, 2.718, 0.01, 10);

Likelihood(LL, UserSpecifiedLL, Prediction(LL));
...
Print (LL, 1);
Data  (LL, 1);

Distrib(A, Normal, 0, 1);
Distrib(B, Normal, A, 2);

Level {                      # upper level
  Distrib(A_1, Normal,   0, 1);
  Distrib(B_1, InvGamma, 2, 2);
  Level {                    # sub-level
    Distrib(A_2, Normal_v, A_1, B_1);
    ...
  }                          # end sub-level
}                            # end upper level

Data(<identifier>)

Likelihood (Data(y), Normal,   Prediction(y), 0.01);
...
Data (y, 0.1, 2,  5,  3,  9.2);
Print(y, 10,  20, 40, 60, 100);

Likelihood (Data(y), Normal,   Prediction(y), Prediction(sigma));
...
Data (y, 1.01, 1.20, 0.97, 0.80, 1.02);
PrintStep(y,     10, 50, 10);
PrintStep(sigma, 10, 50, 10);

Likelihood (Data(R), Binomial, Prediction(P), Data(N));
...
Data (R, 0,  2,  5, 5,  8, 9, 10, 10);
Data (N, 10, 10, 9, 10, 9, 9, 11, 10);
Print(P, 10, 20, 30,40, 50,60,70, 80);

SimType(<keyword>);

Speed = 83.2;

Q_in = PerExp(InMag, 60, 0, RateConst);

<input variable> = Events(<state variable>, <n>, <list-of-times>,
                          <list-of-operation>, <list-of-scalars>);

Inputs = {events_v1, events_v2};

events_v1 = Events (v1, 2, 1,   9,
                           Add, Add,
                           1,   4);

events_v2 = Events (v2, 2, 1,        5,
                           Multiply, Replace,
                           2,        6);

StartTime(<initial-time>);

T0 = 20;
StartTime(T0);

Print(<identifier1>, <identifier2>, ..., <time1>, <time2>, ...);
Prediction(<identifier3>, <identifier4>, ..., <time1>, <time2>, ...);

PrintStep(<identifier1>, <identifier2>, ..., <start-time>, <end-time>,
          <time-step>);

# ---------------------------------------------
# Model definition file for a linear model
# ---------------------------------------------
Outputs = {y};

# Structural model parameters
Alpha = 0;
Beta = 0;
x_bar = 0;

# Statistical parameter
Sigma2 = 1;

CalcOutputs { y = Alpha + Beta * (t - x_bar); }
# ---------------------------------------------

# ---------------------------------------------------------------
# Simulation input file for a linear regression
# ---------------------------------------------------------------
MCMC ("linear.MCMC.out", "", "", 50000, 0, 5, 40000, 63453.1961);
Level {
  Distrib(Alpha,  Normal_v, 0, 10000);
  Distrib(Beta,   Normal_v, 0, 10000);
  Distrib(Sigma2, InvGamma, 0.01, 0.01);
  Likelihood(Data(y), Normal_v, Prediction(y), Sigma2);
  Simulation {
    x_bar = 3.0;
    PrintStep (y, 1, 5, 1);
    Data (y, 1, 3, 3, 3, 5);
  }
} # end Level
End.
# ---------------------------------------------------------------

MCMC("samp.out", "", "", 1, 1, 1, 1, 1); # we are in an MCMC context
Level { # this is the top level
  Distrib(A_top, Uniform, 0, 1);
  Likelihood(Data(y), Normal, Prediction(y), 1);
  Level { # sub-level 1
    Distrib(A, Normal, A_top, 1);
    Simulation { ... } # simulation 1
    Simulation { ... } # simulation 2
  } # End sub-level 1
} # End top, end file
End.

A = 2.0;

Data(<variable identifier>, <value1>, <value2>, ...);

<# of run> <parameters> <outputs for Exp 1> <outputs for Exp2> ...

# Linear Model with a random component
# y = A + B * time + N(0,SD_true)
# Setting SD_true to zero gives the deterministic version
#---------------------------------------------------------

# Outputs
Outputs = {y};

# Model Parameters
A = 0;
B = 1;
SD_true = 0;
SD_esti = 0;

CalcOutputs { y = A + B * t + NormalRandom(0,SD_true); }

# One Compartment Model
# First order input and output
#---------------------------------------------------------

# Inputs
Inputs = {Dose};

# Outputs
Outputs = {C_central, AUC, ln_C_central, ln_AUC,
           SD_C_computed, SD_A_computed};

# Model Parameters
ka = 1;
ke = 0.5;
F  = 1;
V  = 2;

# Statistical Parameters
SDb_ka = 0;
SDw_ka = 0;
SDb_ke = 0;
SDw_ke = 0;
SDb_V  = 0;
min_F  = 0;
max_F  = 0;
SD_C_central = 0;
SD_AUC       = 0;
CV_C_cen     = 0;
CV_AUC       = 0;
CV_C_cen_true = 0;
CV_AUC_true   = 0;

# Calculate Outputs
CalcOutputs {

  # algebraic equation for C_central
  C_central = (ka != ke ?
               (exp(-ke * t) - exp(-ka * t)) *
               F * ka * Dose / (V * (ka - ke))):
               exp(-ka * t) * ka * t * F * Dose / V);

  # algebraic equation for AUC
  AUC = (ka != ke ?
         ((1 - exp(-ke * t)) / ke -
          (1 - exp(-ka * t)) / ka) * F * ka * Dose / (V * (ka - ke))) :
         F * Dose * (1 - (1 + ka * t) * exp(-ka * t)) / (V * ke));

  C_central = C_central + NormalRandom(0, C_central * CV_C_cen_true);
  AUC       = AUC + NormalRandom(0, AUC * CV_AUC_true);

  ln_C_central = (C_central > 0 ? log (C_central) : -100);
  ln_AUC = (AUC > 0 ? log (AUC) : -100);

  SD_C_computed = (C_central > 0 ? C_central * CV_C_cen : 1e-10);
  SD_A_computed = (AUC > 0 ? AUC * CV_AUC : 1e-10);

} # End of output calculations

End.

#---------------------------------------------------------
# perc.model
# A four compartment model of Tetrachloroethylene (PERC)
# and total metabolites.
#---------------------------------------------------------
# States are quantities of PERC and metabolite formed, they can be
# output

States = {Q_fat,        # Quantity of PERC in the fat
          Q_wp,         #   ...   in the well-perfused compartment
          Q_pp,         #   ...   in the poorly-perfused compartment
          Q_liv,        #   ...   in the liver
          Q_exh,        #   ...   exhaled
          Qmet};        # Quantity of metabolite formed

# Extra outputs are concentrations at various points

Outputs = {C_liv,               # mg/l in the liver
           C_alv,               # ... in the alveolar air
           C_exh,               # ... in the exhaled air
           C_ven,               # ... in the venous blood
           Pct_metabolized,     # % of the dose metabolized
           C_exh_ug};           # ug/l in the exhaled air

Inputs = {C_inh}                # Concentration inhaled

# Constants
# Conversions from/to ppm: 72 ppm = .488 mg/l

PPM_per_mg_per_l = 72.0 / 0.488;
mg_per_l_per_PPM = 1/PPM_per_mg_per_l;

#---------------------------------------------------------
# Nominal values for parameters
# Units:
# Volumes: liter
# Vmax:    mg / minute
# Weights: kg
# Km:      mg / minute
# Time:    minute
# Flows:   liter / minute
#---------------------------------------------------------

InhMag = 0.0;
Period = 0.0;
Exposure = 0.0;

C_inh = PerDose (InhMag, Period, 0.0, Exposure);

LeanBodyWt = 55;    # lean body weight

# Percent mass of tissues with ranges shown

Pct_M_fat  = .16;   # % total body mass
Pct_LM_liv = .03;   # liver, % of lean mass
Pct_LM_wp  = .17;   # well perfused tissue, % of lean mass
Pct_LM_pp  = .70;   # poorly perfused tissue, recomputed in scale

# Percent blood flows to tissues

Pct_Flow_fat = .09;
Pct_Flow_liv = .34;
Pct_Flow_wp  = .50; # will be recomputed in scale
Pct_Flow_pp  = .07;

# Tissue/blood partition coeficients

PC_fat = 144;
PC_liv = 4.6;
PC_wp  = 8.7;
PC_pp  = 1.4;
PC_art = 12.0;

Flow_pul   = 8.0;    # Pulmonary ventilation rate (minute volume)
Vent_Perf = 1.14;    # ventilation over perfusion ratio

sc_Vmax = .0026;     # scaling coeficient of body weight for Vmax

Km = 1.0;

# The following parameters are calculated from the above values in
# the Scale section before the start of each simulation.
# They are left uninitialized here.

BodyWt = 0;

V_fat = 0;           # Actual volume of tissues
V_liv = 0;
V_wp  = 0;
V_pp  = 0;

Flow_fat = 0;        # Actual blood flows through tissues
Flow_liv = 0;
Flow_wp  = 0;
Flow_pp  = 0;

Flow_tot = 0;        # Total blood flow
Flow_alv = 0;        # Alveolar ventilation rate

Vmax = 0;            # kg/minute

#---------------------------------------------------------
# Dynamics
# Define the dynamics of the simulation. This section is
# calculated with each integration step. It includes
# specification of differential equations.
#---------------------------------------------------------

Dynamics {

# Venous blood concentrations at the organ exit

Cout_fat = Q_fat / (V_fat * PC_fat);
Cout_wp  = Q_wp  / (V_wp  * PC_wp);
Cout_pp  = Q_pp  / (V_pp  * PC_pp);
Cout_liv = Q_liv / (V_liv * PC_liv);

# Sum of Flow * Concentration for all compartments

dQ_ven = Flow_fat * Cout_fat + Flow_wp * Cout_wp
         + Flow_pp * Cout_pp + Flow_liv * Cout_liv;

# Venous blood concentration

C_ven =  dQ_ven / Flow_tot;

# Arterial blood concentration
# Convert input given in ppm to mg/l to match other units

C_art = (Flow_alv * C_inh / PPM_per_mg_per_l +  dQ_ven) /
        (Flow_tot + Flow_alv / PC_art);

# Alveolar air concentration

C_alv = C_art / PC_art;

# Exhaled air concentration

C_exh = 0.7 * C_alv + 0.3 * C_inh / PPM_per_mg_per_l;

# Differentials

dt (Q_exh) = Flow_alv * C_alv;
dt (Q_fat) = Flow_fat * (C_art - Cout_fat);
dt (Q_wp)  = Flow_wp  * (C_art - Cout_wp);
dt (Q_pp)  = Flow_pp  * (C_art - Cout_pp);

# Quantity metabolized in liver

dQmet_liv = Vmax * Q_liv / (Km + Q_liv);
dt (Q_liv) = Flow_liv * (C_art - Cout_liv) - dQmet_liv;

# Metabolite formation

dt (Qmet)  = dQmet_liv;

} # End of Dynamics

#---------------------------------------------------------
# Scale
# Scale certain model parameters and resolve dependencies
# between parameters. Generally the scaling involves a
# change of units, or conversion from percentage to actual
# units.
#---------------------------------------------------------

Scale {

# Volumes scaled to actual volumes

BodyWt = LeanBodyWt/(1 - Pct_M_fat);

V_fat = Pct_M_fat  * BodyWt/0.92;        # density of fat = 0.92 g/ml
V_liv = Pct_LM_liv * LeanBodyWt;
V_wp  = Pct_LM_wp  * LeanBodyWt;
V_pp  = 0.9 * LeanBodyWt - V_liv - V_wp; # 10% bones

# Calculate Flow_alv from total pulmonary flow

Flow_alv = Flow_pul * 0.7;

# Calculate total blood flow from the alveolar ventilation rate and
# the V/P ratio.

Flow_tot = Flow_alv / Vent_Perf;

# Calculate actual blood flows from total flow and percent flows

Flow_fat = Pct_Flow_fat * Flow_tot;
Flow_liv = Pct_Flow_liv * Flow_tot;
Flow_pp  = Pct_Flow_pp  * Flow_tot;
Flow_wp  = Flow_tot - Flow_fat - Flow_liv - Flow_pp;

# Vmax (mass/time) for Michaelis-Menten metabolism is scaled
# by multiplication of bdw^0.7

Vmax = sc_Vmax * exp (0.7 * log (LeanBodyWt));

} # End of model scaling

#---------------------------------------------------------
# CalcOutputs
# The following outputs are only calculated just before values
# are saved.  They are not calculated with each integration step.
#---------------------------------------------------------

CalcOutputs {

# Fraction of TCE metabolized per day

Pct_metabolized = (InhMag ?
                   Qmet / (1440 * Flow_alv * InhMag * mg_per_l_per_PPM):
                   0);

C_exh_ug  = C_exh * 1000; # milli to micrograms

} # End of output calculation

End.

#---------------------------------------------------------
# perc.lsodes.in
#
#---------------------------------------------------------

Integrate (Lsodes, 1e-4, 1e-6, 1);

#---------------------------------------------------------
# The following is a simulation of one of Dr. Monster's
# exposure experiments described in "Kinetics of Tetracholoroethylene
# in Volunteers; Influence of Exposure Concentration and Work Load,"
# A.C. Monster, G. Boersma, and H. Steenweg,
# Int. Arch. Occup. Environ. Health, v42, 1989, pp303-309
#
# The paper documents measurements of levels of TCE in blood and
# exhaled air for a group of 6 subjects exposed to
# different concentrations of PERC in air.
#
# Inhalation is specified as a dose of magnitude InhMag for the
# given Exposure time.
#
# Inhalation is given in ppm
#---------------------------------------------------------

Simulation {

InhMag = 72;            # ppm
Period = 1e10;          # Only one dose
Exposure = 240;         # 4 hour exposure

# measurements before end of exposure
# and at [5' 30'] 2hr 18 42 67 91 139 163

Print (C_exh_ug, 239.9 245 270 360 1320 2760 4260 5700 8580 10020 );
Print (C_ven, 239.9 360 1320 2760 4260 5700 8580 10020 );

}

END.


• Table of Contents:
Reference Manual
• Licenses:		GNU MCSim is under GNU General Public License
• Overview:		the gist of it
• Installation:		for GNU/Linux, Unix and other platforms
• Working Through an Example:		highly recommended!
• Writing and Compiling Structural Models:		syntax and compilation of models
• Running Simulations:		syntax of simulation specification files
• Common Pitfalls:		errors you will make one day or the other...
• XMCSim:		a graphical user’s interface to GNU MCSim
• Bibliographic References:		examples of applications
Appendices
• Keywords List:		a list of the reserved keywords
• Examples:		examples of models and input files
Index Table
• Concept Index:

• Using mod:		how to preprocess a model definition file
• Using makemcsim:		a simple command to preprocess and compile a model
• Syntax of mod files:		how to write a model definition file
• Reading SBML models:		how to specify a list of SBML models and template model
• Working with deSolve:		how to use an MCSim model compiler for R deSolve

• General syntax:
• Declarations of global variables:
• Model types:
• Special functions:
• Input functions:
• In line functions:
• Model initialization:
• Dynamics section:
• Delay differentials:
• Output calculations:
• Comments on style:

• Using the compiled program:		how to process a simulation file
• Syntax of simulation files:		how to write a simulation file
• Analyzing simulation output:		beyond GNU MCSim...
• Error handling:

• General input file syntax:
• Input functions revisited:
• Global specifications:
• Specifying basic conditions to simulate:
• Setting-up statistical models:
• Analyzing simulation output:
• Error handling:

• OutputFile() specification:
• Integrate() specification:
• MonteCarlo() specification:
• MCMC() specification:
• SetPoints() specification:
• OptimalDesign() specification:
• Distrib() specification:
• SimType() specification:

• Simulation sections:
• Events() specification:
• StartTime() specification:
• Print() specification:
• PrintStep() specification:

• linear.model:		a simple algebraic model
• 1cpt.model:		a one-compartment pharmacokinetic model
• perc.model:		a multi-compartment pharmacokinetic model
• perc.lsodes.in:		an example simulation input file

	Index Entry	Section

'
	’!=’ operator:	General syntax
	’#’ sign:	General syntax
	’-’ (hyphen) sign:	General syntax
	’:’ sign:	General syntax
	’;’ sign:	General syntax
	’<’ operator:	General syntax
	’<=’ operator:	General syntax
	’<>’ operator:	General syntax
	’=’ sign:	General syntax
	’==’ operator:	General syntax
	’>’ operator:	General syntax
	’>=’ operator:	General syntax
	’?’ sign:	General syntax
	’[]’ (square brackets) notation:	General syntax
	’_’ (underscore) in templates:	Reading SBML models
	’_’ (underscore) vector notation:	General syntax

A
	Algebraic models:	Model types
	Analyzing simulation output:	Analyzing simulation output
	Arrays:	General syntax
	Assignment:	General syntax

B
	`Beta` distribution:	Distrib() specification
	`BetaRandom()` function:	Special functions
	Bibliographic references:	Bibliographic References
	`Binomial` distribution:	Distrib() specification
	`BinomialBetaRandom()` function:	Special functions
	`BinomialRandom()` function:	Special functions
	Blank lines:	General syntax

C
	`CalcOutputs`, output section:	Output calculations
	`Cauchy` distribution:	Distrib() specification
	Cauchy distribution:	Distrib() specification
	`CauchyRandom()` function:	Special functions
	`CDFNormal()` function:	Special functions
	Chi-square distribution:	Distrib() specification
	`Chi2` distribution:	Distrib() specification
	`Chi2Random()` function:	Special functions
	Colon conditional assignment:	General syntax
	command-line options:	Using the compiled program
	Comments:	General syntax
	Common pitfalls:	Common Pitfalls
	Comparison operators:	General syntax
	`Compartment` keyword:	Reading SBML models
	Complementary error function:	Special functions
	Conditional assignment:	General syntax
	Cumulative density function, Normal:	Special functions
	`Cvodes` integrator:	Integrate() specification

D
	`Data()` qualifier, for use in `Distrib()`:	Distrib() specification
	`Data()` specification:	Data() specification
	Default:	Overview
	Defining models:	Writing and Compiling Structural Models
	Delay differential equations:	Delay differentials
	Density function, Normal:	Special functions
	`Density()` specification:	Distrib() specification
	Derivative specification:	Dynamics section
	Differential models:	Model types
	Discrete-time models:	Model types
	`Distrib()` specification:	Distrib() specification
	Distribution, `Beta`:	Distrib() specification
	Distribution, `Binomial`:	Distrib() specification
	Distribution, `Cauchy`:	Distrib() specification
	Distribution, Cauchy:	Distrib() specification
	Distribution, Chi-square:	Distrib() specification
	Distribution, `Chi2`:	Distrib() specification
	Distribution, `Exponential`:	Distrib() specification
	Distribution, `Gamma`:	Distrib() specification
	Distribution, `HalfCauchy`:	Distrib() specification
	Distribution, `HalfNormal`:	Distrib() specification
	Distribution, inverse-gamma:	Distrib() specification
	Distribution, `InvGamma`:	Distrib() specification
	Distribution, `LogNormal`:	Distrib() specification
	Distribution, `LogNormal_v`:	Distrib() specification
	Distribution, `Loguniform`:	Distrib() specification
	Distribution, `NegativeBinomial`:	Distrib() specification
	Distribution, `Normal`:	Distrib() specification
	Distribution, `Normal_cv`:	Distrib() specification
	Distribution, `Normal_v`:	Distrib() specification
	Distribution, `Piecewise`:	Distrib() specification
	Distribution, `Poisson`:	Distrib() specification
	Distribution, `StudentT`:	Distrib() specification
	Distribution, triangular:	Distrib() specification
	Distribution, truncated inverse-gamma:	Distrib() specification
	Distribution, truncated lognormal:	Distrib() specification
	Distribution, truncated normal:	Distrib() specification
	Distribution, `TruncInvGamma`:	Distrib() specification
	Distribution, `TruncLogNormal`:	Distrib() specification
	Distribution, `TrunclogNormal_v`:	Distrib() specification
	Distribution, `TruncNormal`:	Distrib() specification
	Distribution, `Truncnormal_cv`:	Distrib() specification
	Distribution, `Truncnormal_v`:	Distrib() specification
	Distribution, `Uniform`:	Distrib() specification
	Distribution, `UserSpecifiedLL`:	Distrib() specification
	Documentation license:	Licenses
	`Dt()` operator:	Dynamics section
	Dynamics section:	Dynamics section

E
	End keyword:	General syntax
	`erfc()` function:	Special functions
	Error function, complementary:	Special functions
	Error handling:	Error handling
	`Euler` integrator:	Integrate() specification
	`Events` specification:	Events() specification
	Examples:	Writing and Compiling Structural Models
	Examples:	Examples
	`Experiment` sections:	Simulation sections
	Experimental design optimization:	Overview
	`Exponential` distribution:	Distrib() specification
	`ExpRandom()` function:	Special functions

F
	Function, `BetaRandom()`:	Special functions
	Function, `BinomialBetaRandom()`:	Special functions
	Function, `BinomialRandom()`:	Special functions
	Function, `CauchyRandom()`:	Special functions
	Function, `CDFNormal()`:	Special functions
	Function, `Chi2Random()`:	Special functions
	Function, `erfc()`:	Special functions
	Function, `ExpRandom()`:	Special functions
	Function, `GammaRandom()`:	Special functions
	Function, `GetSeed()`:	Special functions
	Function, `GGammaRandom()`:	Special functions
	Function, Inline, in line:	In line functions
	Function, input:	General syntax
	Function, `InvGGammaRandom()`:	Special functions
	Function, `lnDFNormal()`:	Special functions
	Function, `lnGamma()`:	Special functions
	Function, `LogNormalRandom()`:	Special functions
	Function, `LogUniformRandom()`:	Special functions
	Function, `NDoses()`:	Input functions
	Function, `NDoses()`:	Input functions revisited
	Function, `NegativeBinomialRandom()`:	Special functions
	Function, `NormalRandom()`:	Special functions
	Function, `PerDose()`:	Input functions
	Function, `PerDose()`:	Input functions revisited
	Function, `PerExp()`:	Input functions
	Function, `PerExp()`:	Input functions revisited
	Function, `PerTransit()`:	Input functions
	Function, `PerTransit()`:	Input functions revisited
	Function, `PiecewiseRandom()`:	Special functions
	Function, `PoissonRandom()`:	Special functions
	Function, `SetSeed()`:	Special functions
	Function, special:	General syntax
	Function, `Spikes()`:	Input functions
	Function, `Spikes()`:	Input functions revisited
	Function, `StudentTRandom()`:	Special functions
	Function, `TruncInvGGammaRandom()`:	Special functions
	Function, `TruncLogNormalRandom()`:	Special functions
	Function, `TruncNormalRandom()`:	Special functions
	Function, `UniformRandom()`:	Special functions
	Functions, input:	Input functions
	Functions, input:	Input functions revisited
	Functions, special:	Special functions

G
	`Gamma` distribution:	Distrib() specification
	Gamma function:	Special functions
	`GammaRandom()` function:	Special functions
	General input file syntax:	General input file syntax
	`GetSeed()` function:	Special functions
	`GGammaRandom()` function:	Special functions
	Global specifications:	Global specifications

H
	`HalfCauchy` distribution:	Distrib() specification
	`HalfNormal` distribution:	Distrib() specification

I
	Initialize, initialization section,:	Model initialization
	Inline, in line functions:	In line functions
	Input functions:	General syntax
	Input functions:	Input functions
	Input functions:	Input functions revisited
	Input variables:	Declarations of global variables
	Installation:	Installation
	`Integrate()` specification:	Integrate() specification
	Integration routine, `Cvodes`:	Integrate() specification
	Integration routine, `Euler`:	Integrate() specification
	Integration routine, `Lsodes`:	Integrate() specification
	Integration variable:	Dynamics section
	Inverse-gamma distribution:	Distrib() specification
	`InvGamma` distribution:	Distrib() specification
	`InvGGammaRandom()` function:	Special functions
	`InvTemperature()` specification:	MCMC() specification

K
	Keyword, `Compartment`:	Reading SBML models
	Keywords list:	Keywords List

L
	`Level` sections:	Level sections
	Licenses:	Licenses
	`Likelihood()` specification:	Distrib() specification
	`lnDFNormal()` function:	Special functions
	`lnGamma()` function:	Special functions
	Logical tests:	General syntax
	`LogNormal` distribution:	Distrib() specification
	`LogNormalRandom()` function:	Special functions
	`LogNormal_v` distribution:	Distrib() specification
	`LogUniform` distribution:	Distrib() specification
	`LogUniformRandom()` function:	Special functions
	`Lsodes` integrator:	Integrate() specification

M
	Major changes in the next version:	Overview
	Major changes in version 5.4.0:	Overview
	Major changes in version 5.5.0:	Overview
	Major changes in version 5.6.0:	Overview
	Major changes in version 6.0.0:	Overview
	Major changes in version 6.1.0:	Overview
	Major changes in version 6.2.0:	Overview
	`makemcsim` script:	Using makemcsim
	`makemcsimd` script:	Using makemcsim
	`makemcsimp` script:	Using makemcsim
	`makemcsims` script:	Using makemcsim
	Markov-chain Monte Carlo simulations:	Overview
	Markov-chain Monte Carlo simulations:	MCMC() specification
	`MCMC` simulations:	Overview
	`MCMC` simulations:	MCMC() specification
	`MCMC()` specification:	MCMC() specification
	`mod` syntax:	Syntax of mod files
	`mod` usage:	Using mod
	Model definition files:	Writing and Compiling Structural Models
	Model types:	Model types
	Models, algebraic:	Model types
	Models, differential:	Model types
	Models, discrete-time:	Model types
	Models, statistical:	Setting-up statistical models
	Monte Carlo simulations:	Overview
	Monte Carlo simulations:	MonteCarlo() specification
	`MonteCarlo()` specification:	MonteCarlo() specification
	MPI:	Using makemcsim

N
	`NDoses()` function:	Input functions
	`NDoses()` function:	Input functions revisited
	`NegativeBinomial` distribution:	Distrib() specification
	`NegativeBinomialRandom()` function:	Special functions
	Normal cumulative density function:	Special functions
	Normal density function:	Special functions
	`Normal` distribution:	Distrib() specification
	`NormalRandom()` function:	Special functions
	`Normal_cv` distribution:	Distrib() specification
	`Normal_v` distribution:	Distrib() specification

O
	`OptimalDesign()` specification:	OptimalDesign() specification
	Output specification:	Output calculations
	Output variables:	Declarations of global variables
	`OutputFile()` specification:	OutputFile() specification
	Overview:	Overview

P
	Parallelization:	Installation
	Parallelized code:	Using makemcsim
	Parameter declaration:	Declarations of global variables
	Parameter scaling:	Model initialization
	`PerDose()` function:	Input functions
	`PerDose()` function:	Input functions revisited
	`PerExp()` function:	Input functions
	`PerExp()` function:	Input functions revisited
	`PerTransit()` function:	Input functions
	`PerTransit()` function:	Input functions revisited
	`Piecewise` distribution:	Distrib() specification
	`PiecewiseRandom()` function:	Special functions
	Pitfalls:	Common Pitfalls
	`Poisson` distribution:	Distrib() specification
	`PoissonRandom()` function:	Special functions
	`Prediction()` qualifier, for use in `Distrib()`:	Distrib() specification
	`Prediction()` specification (in `Simulation` context):	Print() specification
	`Print()` specification:	Print() specification
	`PrintStep()` specification:	PrintStep() specification

Q
	Qualifier, `Data()`:	Distrib() specification
	Qualifier, `Prediction()`:	Distrib() specification

R
	R deSolve:	Working with deSolve
	Random number, beta:	Special functions
	Random number, binomial:	Special functions
	Random number, binomial-beta:	Special functions
	Random number, Cauchy:	Special functions
	Random number, Chi-squared:	Special functions
	Random number, exponential:	Special functions
	Random number, gamma:	Special functions
	Random number, general-gamma:	Special functions
	Random number, inverse-gamma:	Special functions
	Random number, lognormal:	Special functions
	Random number, loguniform:	Special functions
	Random number, negative binomial:	Special functions
	Random number, normal:	Special functions
	Random number, piecewise:	Special functions
	Random number, Poisson:	Special functions
	Random number, Student t:	Special functions
	Random number, truncated inverse-gamma:	Special functions
	Random number, truncated lognormal:	Special functions
	Random number, truncated normal:	Special functions
	Random number, uniform:	Special functions
	Random seed, reading its value:	Special functions
	Random seed, setting its value:	Special functions
	Reserved keywords:	Keywords List
	Running GNU MCSim:	Using the compiled program
	Running simulations:	Running Simulations

S
	SBML models:	Reading SBML models
	Scale, scaling section:	Model initialization
	Semi-colon:	General syntax
	`SetPoints` simulations:	Overview
	`SetPoints()` specification:	SetPoints() specification
	`SetSeed()` function:	Special functions
	Setting-up statistical models:	Setting-up statistical models
	`SimType()` specification:	SimType() specification
	Simulation definition files:	Running Simulations
	Simulation file, syntax:	Syntax of simulation files
	`Simulation` sections:	Simulation sections
	Software license:	Licenses
	Special functions:	General syntax
	Special functions:	Special functions
	Specification, `Data()`:	Data() specification
	Specification, `Density()`:	Distrib() specification
	Specification, `Distrib()`:	Distrib() specification
	Specification, `Integrate()`:	Integrate() specification
	Specification, `InvTemperature()`:	MCMC() specification
	Specification, `Likelihood()`:	Distrib() specification
	Specification, `MCMC()`:	MCMC() specification
	Specification, `MonteCarlo()`:	MonteCarlo() specification
	Specification, `OptimalDesign()`:	OptimalDesign() specification
	Specification, `OutputFile()`:	OutputFile() specification
	Specification, `Print()`:	Print() specification
	Specification, `PrintStep()`:	PrintStep() specification
	Specification, `SetPoints()`:	SetPoints() specification
	Specification, `SimType()`:	SimType() specification
	Specification, `StartTime()`:	StartTime() specification
	Specifications, global:	Global specifications
	Specifying simulations:	Running Simulations
	`Spikes()` function:	Input functions
	`Spikes()` function:	Input functions revisited
	Square brackets:	General syntax
	`StartTime()` specification:	StartTime() specification
	State discontinuities:	Events() specification
	State variables:	Declarations of global variables
	Statistical models:	Setting-up statistical models
	Structural models:	Writing and Compiling Structural Models
	Structural models:	Model types
	`StudentT` distribution:	Distrib() specification
	`StudentTRandom()` function:	Special functions
	Style:	Comments on style
	Syntax for `mod`:	Syntax of mod files
	Syntax of simulation files:	Syntax of simulation files

T
	Tempered MCMC:	MCMC() specification
	Template models:	Reading SBML models
	Tests, logical:	General syntax
	Triangular distribution:	Distrib() specification
	Truncated Inverse-gamma distribution:	Distrib() specification
	Truncated lognormal distribution:	Distrib() specification
	Truncated normal distribution:	Distrib() specification
	`TruncInvGamma` distribution:	Distrib() specification
	`TruncInvGGammaRandom()` function:	Special functions
	`TruncLogNormal` distribution:	Distrib() specification
	`TruncLogNormalRandom()` function:	Special functions
	`TruncLogNormal_v` distribution:	Distrib() specification
	`TruncNormal` distribution:	Distrib() specification
	`TruncNormalRandom()` function:	Special functions
	`TruncNormal_cv` distribution:	Distrib() specification
	`TruncNormal_v` distribution:	Distrib() specification

U
	Underscore syntax for vectors:	General syntax
	Underscore use for template models:	Reading SBML models
	`Uniform` distribution:	Distrib() specification
	`UniformRandom()` function:	Special functions
	`UserSpecifiedLL` distribution:	Distrib() specification
	Using deSolve:	Working with deSolve

V
	Variable names:	General syntax
	Vectorization:	General syntax
	Vectors:	General syntax

W
	Working Through an Example:	Working Through an Example
	Writing and Compiling structural models:	Writing and Compiling Structural Models

X
	`xmcsim`:	XMCSim

GNU MCSim User’s Manual

Top

Table of Contents

Table of Contents

1 Software and Documentation Licenses

1.1 Software license

1.2 Documentation license

2 Overview

2.1 General procedure

2.2 Types of simulations

2.3 Major changes introduced with version 5.4.0

2.4 Major changes introduced with version 5.5.0

2.5 Major changes introduced with version 5.6.0

2.6 Major changes introduced with version 6.0.0

2.7 Major changes introduced with version 6.1.0

2.8 Major changes introduced with version 6.2.0

2.9 Coming soon

3 Installation

3.1 System requirements

3.2 Distribution

3.3 Machine-specific installation

3.3.1 Unix and GNU/Linux operating systems

3.3.2 Other operating systems

4 Working Through an Example

5 Writing and Compiling Structural Models

5.1 Using mod to preprocess model description files

5.2 Using makemcsim to preprocess and compile model files

5.3 Syntax of the model description file

5.3.1 General syntax

5.3.2 Declarations of global variables

5.3.3 Model types

5.3.4 Special functions

5.3.5 Input functions

5.3.6 In line functions

5.3.7 Model initialization

5.3.8 Dynamics section

5.3.9 Delay differential equations

5.3.10 Output calculations

5.3.11 Comments on style

5.4 Reading SBML models and applying a template

5.5 Working with the R package deSolve

6 Running Simulations

6.1 Using the compiled program

6.2 Syntax of the simulation definition file

6.2.1 General input file syntax

6.2.2 Input functions (revisited)

6.2.3 Global specifications

OutputFile() specification

Integrate() specification

MonteCarlo() specification

MCMC() specification

SetPoints() specification

OptimalDesign() specification

Distrib() specification

SimType() specification

6.2.4 Specifying basic conditions to simulate

Simulation sections

Events() specification for state discontinuities

StartTime() specification

Print() specification

PrintStep() specification

6.2.5 Setting-up statistical models

Level sections

Data() specification

6.3 Analyzing simulation output

6.4 Error handling

7 Common Pitfalls

8 XMCSim

Bibliographic References

Appendix A Keywords List

Appendix B Examples

B.1 linear.model

B.2 1cpt.model: A example model description file

B.3 perc.model: A example model description file

B.4 perc.lsodes.in

Concept Index

5.1 Using `mod` to preprocess model description files

5.2 Using `makemcsim` to preprocess and compile model files

`OutputFile()` specification

`Integrate()` specification

`MonteCarlo()` specification

`MCMC()` specification

`SetPoints()` specification

`OptimalDesign()` specification

`Distrib()` specification

`SimType()` specification

`Simulation` sections

`Events()` specification for state discontinuities

`StartTime()` specification

`Print()` specification

`PrintStep()` specification

`Level` sections

`Data()` specification

B.1 `linear.model`

B.2 `1cpt.model`: A example model description file

B.3 `perc.model`: A example model description file

B.4 `perc.lsodes.in`