This software package consists of three separate but compatible programs written in Microsoft BASIC and running on IBM-PC-compatibles:
******************************
* *
* GRANULES 1.1 *
* *
* USERS' MANUAL *
* *
******************************
Copyright (C) 1989
D.K. Hartline and R.W. Newcomb
Bekesy Lab
1993 East-West Rd
Honolulu, HI 96822
(808) 956-8003
Programs covered by this manual:
GRANULES version 1.1 mod Q3O 4/21/89
PROCESS version 1.0 mod B2B 4/17/89
PROCON version 1.0 mod B2A 4/21/89
* Produced with the support of NIH grant NS15314
--------------------------------------------------------------------
TABLE OF CONTENTS
GETTING STARTED
A. Overview 1
B. Hardware/Software Requirements 1
C. Checking the Distribution Package 2
USING THE MODELS
GRANULES
A. Running GRANULES 3
B. Main Menu Options 6
C. Parameter File 7
D. Output Files 8
E. Save File 9
F. GRANULES.INI File 9
PROCESS
A. Running PROCESS 10
B. Main Menu Options 11
C. Parameter File (.PRM) 12
D. Fragment Distribution Output File 12
PROCON
A. Running PROCON 13
B. Output File 14
PROGRAM DESCRIPTIONS
GRANULES MODEL DESCRIPTION
A. General 15
B. Initializations 15
C. One Day's Kinetics 15
D. Output Options 18
PROCESS MODEL DESCRIPTION
A. General 19
B. Initializations and Main Menu 19
C. Compute P(I,J)s Subroutine 20
PROCON MODEL DESCRIPTION
A. Initializations 21
B. Compute Fragment Distributions 21
C. Convolution 21
APPENDICES
I. Screen for GRANULES Test Run
II. GRANTST.PRN listing
III. Key Variables
---------------------------------------------------------------------
GETTING STARTED
A. OVERVIEW
This document gives details on the structure and usage of the
models (GRANULES, PROCESS, and PROCON) described in Hartline, D.K. and
Newcomb, R.N. (1989) "Computer models for simulation of peptide
processing, compartmentation, and release in neurosecretory cells",
(J. Biol. Chem., submitted). The software package models processes
occurring in a neurosecretory cell according to the following schema
(features are for the GRANULES model unless otherwise indicated):
1. A secretory granule is synthesized with a certain amount of
prohormone and a certain amount of processing enzyme.
2. The granule is freed into a terminal represented by multiple
diffusionally-connected compartments corresponding to different
physical regions.
3. As the granule ages, the prohormone it contains is processed
into a series of intermediates, leading ultimately to a mixture of
peptide end-products (as a practical matter, GRANULES computes age
distributions, PROCESS computes peptide mixtures for a series of ages,
and PROCON combines the two results to give product distribution for a
terminal).
4. The processing enzyme may optionally inactivate with a
specified first-order rate constant.
5. Linear growth of terminal volume over time may be specified.
6. Release of secretory granules may occur from any of the
compartments. Release probability may optionally be made to decay
exponentially with age of the granule.
B. HARDWARE/SOFTWARE REQUIREMENTS
GRANULES 1.1 and its associated programs should run as is in
their compiled forms (.EXE versions) or as sources (.BAS versions)
under GWBASIC (very slowly) on an IBM PC/XT/AT compatible. Exact
memory requirements depend on the maximum number of granules being
simulated (some 16,000 can be, althogh for more than 6,300, the run-
time enzymatic processing option is eliminated). For hard-copy of
output, the LPRINT statement of BASIC must be supported. No special
graphics have been implemented in this version.
C. CHECKING THE DISTRIBUTION PACKAGE
Check to be sure the distribution package is complete. In
addition to this file (GRANULES.DOC) the following files should be on
the distribution diskette:
GRANULES.BAS - The main source program for the GRANULES model
GRANULES.EXE - A compiled form using QuickBASIC. Requires BRUN30.EXE
GRANULES.INI - Initialization file for GRANULES
GRANTST.PRM - A test parameter file (see appendix)
GRANTSCS.TST - Comparison output file from GRANTST
GRANTSAT.TST - " " " " "
GRANTSBT.TST - " " " " "
PROCESS.BAS - Source for PROCESS model
PROCESS.EXE - Compiled PROCESS.BAS
PROCTST.PRM - Test parameter file for PROCESS
PROCON.BAS - Source for PROCON combinatorial program
PROCON.EXE - Compiled PROCON.BAS
BRUN30.EXE - The QuickBASIC run-time module (needed by .EXE files)
READ.ME - Updated information on your particular distribution
Print or screen-examine READ.ME to find if any alterations that
might affect your use of the model have been made. Then copy all of
the .PRM files and either the .BAS files (if you want to run the
source versions) or the .EXE files (if you want to run the compiled
versions) to your C: drive. The compiled programs can be invoked by
typing their names (without the ".EXE"). The source programs can
either be compiled with your own BASIC compiler, or run under GWBASIC
(BASICA).
As a suggested first test of the functioning of the program on
your system, we suggest you run through the procedures "RUNNING
GRANULES", "RUNNING PROCESS", and "RUNNING PROCON" using the test
files provided. If these work properly (as they should), you can
start modifying conditions or parameter files to suit your own
conditions. The authors stand ready to help (as far as they can) in
any special problems you may have.
****************
* GRANULES *
****************
A. RUNNING GRANULES
To run the GRANULES model you must have a copy of GRANULES.EXE
(or .BAS) and GRANULES.INI (a file containing initialization options)
on your logged drive, and a parameter file of appropriate format (see
Section C) on drive C:. The parameter file GRANTST.PRM is supplied as
an example, and the following steps illustrate program operation using
this test file:
1. Type "GRANULES" followed by the "Enter" key () to start
the more rapid compiled version (alternatively, type "GWBASIC GRANULES
" for running the source under GWBASIC). Shortly the screen
should display:
GRANULES 1.1 mod Q3O 4/10/89
MAX NBR OF GRANULES (default=6300)?
This query permits specifying either up to the largest possible number
of granules (ca 16,000) or a smaller number (up to 6,300) but with
ongoing calculation of degradation of peptide precursor and printouts
of processing ratios (B/A0). Answer by pressing the "Enter" key
() to elect using the default number 6,300.
2. The program will now print:
OUTPUT DATA DISK=.
This tells you that the program will write the output files on the
logged (".") drive. The selection can be modified to write on some
other drive or subdirectory by editing the ASCII file GRANULES.INI
(see Appendix II).
3. The program will ask which of three output options you wish:
output to the screen only, to the printer (and screen) or to disk
files:
OUTPUT MODE: 0=SCREEN, 1=PRINTER, 2=DISK?
For the full treatment, answer "2 ", and be sure you have a
formatted floppy disk on your A: drive (use the other options if you
don't want as detailed or permanent output; a higher-numbered
selection always includes the lower-numbered options as well).
4. Providing output mode 1 or 2 was selected, the program should
print:
DATE?
Answer with the date (any character string without terminators is OK,
such as 1/1/01 or 1-Jan-0001, or one with terminators if enclosed in
quotes: "January 1, 0001"). This can actually be used for any
information you wish printed on the permanent protocol (as can the
answer to the next query).
5. Next it asks:
RUN #?
Answer with another character string.
6. Next, a parameter input file will be requested:
PARAMETER SOURCE (FILENAME.EXT)
Answer by pressing the "Enter" key () to elect using the test
parameter file GRANTST.PRM (this default can be changed by editing
GRANULES.INI). Alternatively, specify the name of your own parameter
file (parameter files need not have a ".PRM" extension, so if yours
has an extension, you must specify it as part of the file name). At
the , the program will start printing out on the screen the
various parameters found in the parameter file. See Section C for a
description and Appendix I for a listing. The printer will also be
printing out a list of these parameters, and will as well print the
information:
OUTPUT FILES NAMED GRANTSxy.PRN where xy=
CS= Compartment stats
AT= Age histo, total terminal A#= Age histo, Cmpt# AR=Age histo, Rlse
BT= B/A0 histo, total terminal B#= B/A0 histo, Cmpt# BR=B/a0 histo, Rlse
(these will be explained below).
7. Next the Main Menu will be displayed:
MAIN MENU: 0=EXIT TO BASIC 1=GO (NEW TREATMENT) 2=CONT (OLD TREATMENT)
3=PRELOAD FROM DISK 4=SAVE STATE ON DISK 5=COMPARTMENT STATS
6=AGE-HISTOGRAM 7=B/A0 HISTOGRAM 8=GRANULE ENUMERATION
9=SET OPTION FLAGS 10=(unassigned) 11=RESEED RANDOMIZER
12=CHANGE PARAMETERS
?
Most of these options will be explained below. Select "1 " to run
the model.
8. The program will now ask for a specific set of parameters to
be used for a specified length of time (in days; the name of the unit
of time can be altered by editing GRANULES.INI) called a "treatment".
In the following dialog, the numbers shown are those you should enter
to generate a run that can be compared to the .TST files accompanying
this distribution:
RELEASE RATE FACTOR, RF? 1
[multiplies all release rate constants in the parameter file; can
be used to modulate all release rates from all compartments
simultaneously]
SYNTHESIS RATE FACTOR, SF? 1
[same multiplier for synthesis rates]
# TIME INCREMENTS PER DAY? 5
[this determines how fine a time-slice will be used for the
numerical integration routines. The larger the number selected, the
greater the accuracy of the model, but the more slowly it will run;
several per shortest time constant are needed for stability; to assure
accuracy, one should routinely test the affect of doubling this number
from time to time to be sure results do not change much]
TREATMENT DURATION (DAYS)? 10
[here you specify how long you want the particular "treatment"
consisting of the parameters typed in above]
9. The program will print "SYNTHESIS= 200 GRANULES PER DAY",
then start executing and updating an information line of the form:
POOL SIZE= ### T%= #
where ### and # stand for integers. The first item indicates how many
granule spaces have been created in memory (these spaces are reused as
released granules are returned to the unused pool). The second item
indicates which time-division within the current day the model is
calculating. It will run from 1 to 5 in the example being used here.
10. When T% finishes with the last pass (5 in the GRANTST
example being used here), the results of the first day's calculations
("stats") will be displayed on the screen and printed on the printer.
This will include:
1) the number of granules;
2) their mean age;
3) their processing ratio, B/(A0*N) [frequently shortened to
"B/A0"; B= amount of processed peptide; A0= initial peptide content of
each granule; N= total number of granules in the terminal]
... and will be printed for:
1) granules in the whole terminal (the sum of all compartments);
2) granules in each compartment [3 in the test case];
3) granules released during the current day.
11. Next two histograms will be printed designated "AGES:" and
"B/A0:". In addition to row-labels (TOTAL, 1, 2, 3, and RLSE), each
row will have 21 numbers [mostly 0 at this stage] indicating the
occupancy of each of two sets of 20 histogram bins plus overflow bins
[the number can be changed by changing parameters NT% and NA%, the
next-to-last and last in the parameter file: see below].
12. The program will do 10 days of such calculations, printing
out compartment stats and histograms for each day, and end with:
END OF TREATMENT: Press any key
Use to get back to the main menu.
13. Select option "0" to exit the program (closing the open
files you have just created, etc). Your logged drive, should now have
several new files which contain the same information that was printed
on the screen and the printer during the output phases of the program:
GRANTSCS.PRN
GRANTSAT.PRN GRANTSA1.PRN GRANTSA2.PRN GRANTSA3.PRN GRANTSAR.PRN
GRANTSBT.PRN GRANTSB1.PRN GRANTSB2.PRN GRANTSB3.PRN GRANTSBR.PRN
These files can be examined by TYPEing them directly to the screen, or
using a text editor or word-processing program. The three ".TST"
files provided with this distribution should be identical with the
three ".PRN" files of the left column. Output files are directly
Lotus-123 compatible, and may be Imported into a worksheet, from which
they can be edited, plotted, etc (see section D below).
B. MAIN MENU OPTIONS
Following is a brief description of the options available under
the Main Menu:
0=EXIT TO BASIC: Self-explanatory. This closes all open files
and returns to BASIC (from .BAS file) or MSDOS (from .EXE file).
1=GO (NEW TREATMENT): Starts or restarts the model after
querying for a new set of treatment parmeters.
2=CONT (OLD TREATMENT): Continues the model with the former
parameters. An additional treatment duration will be asked for.
3=PRELOAD FROM DISK: Retrieves the state of the model from a
specified file bearing the extension ".SAV" (see Appendix II for the
organization of this file).
4=SAVE STATE ON DISK: Saves the current state of the model on
disk file with the extension ".SAV".
5=COMPARTMENT STATS: Prints "statistics" (# of granules, mean
age, etc) of present state.
6=AGE-HISTOGRAM: Prints age histogram.
7=B/A0 HISTOGRAM: Prints histogram of B/(N%*A0).
8=GRANULE ENUMERATION: Prints state variables for every granule
as follows:
CP% = compartment assignment [CP%(H%) for granule # H%]
A = fractional amount of remaining precursor [A(H%)/A0]
AGE = age of each (non-released) granule since synthesis [T-T(H%)]
or "RELEASED xx DAYS OLD" (for released granules)
9=SET OPTION FLAGS: Permits activation of a debugging mode
printing more information; supression of compartment stats output.
11=RESEED RANDOMIZER: Allows a choice of a new seed number for
the BASIC pseudorandom number generator. The initial seed is taken
from the parameter file (RN%).
12=CHANGE PARAMETERS: Permits changing individually most model
parameters without editing the original parameter file.
C. PARAMETER FILE
In order to create your own model, you must generate you own
parameter file. Following is a list, in order, of the entires which
must appear in the parameter file. The list may be typed with an
editor or word-processing program with a non-document mode (i.e. no
funny control bits: e.g. WordStar), either with one parameter to a
line, or with parameters separated by spaces or commas (see sample
listing of GRANTST.PRM in Appendix II) :
ID$ - Identifying string (in quotes) (e.g. "MY FILE")
GRANULESQ3N - File format code for version QW30 (PID$: checked for
compatibility
KE - Processing enzyme decay rate constant (1/days)
CF - Conversion-rate scaling factor: multiplies all C()'s to
allow simulation of altered enzyme activity
KF - Transport-rate scaling factor: a parameter which multiplies all
K(I%,J%)'s and can be used to change them as a block.
KREL - Rate constant for decay of release probability: controls
the age-dependent decay rate of the probability of
granule release. If KREL=0, no age-dependent decay
occurs.
NC%-1 Number of compartments (NC% includes the release
compartment)
K(1,1), K(1,2),.. K(1,NC%-1) - Diffusion K'S into compartment 1
K(2,1), K(2,2),.. K(2,NC%-1) - Diffusion K'S into compartment 2
etc
K(RLSE,1),K(RLSE,2),.. K(RLSE,NC%-1) - Release K'S from each cmpt
S(1),S(2),.. S(NC%-1) - Synthesis to each cmpt
[typically 1 for base rate]
C(1),C(2),.. C(NC%-1) - Conversion rate factors in each cmpt
[typically 1; use mainly for cmpt-dep
differences in enzyme packaging]
V(1),V(2),.. V(NC%-1) - Volumes of each cmpt [typically 1]
T0 - Initial age (normally would be 0, but this can be used to
give an arbitrary time origin to the model print-outs).
VF - Initial volume factor. The volume factor multiplies all
compartment volumes (normally this would =1.0, but it
can be used to provide a true volume, or a volume of
1.0 at some other calculated time, as needed).
DVF - Growth rate: daily increment to the volume factor (DVF/DAY)
A0 - Initial amount of precursor in each granule (e.g. pmoles)
RN% - Randomizer seed for the pseudorandom number generator;
use of different seeds will result in different runs
due to different pseudorandom number sequences.
TH - Age histogram span (i.e. time represented by the specified
number of bins).
TH0 - Age histogram origin FOR LOG HISTOGRAMS ONLY (see D below).
NT% - Age histogram number of bins.
NA% - B/A0 histogram number of bins.
END - Parameter file termination string. If this character string is
not found in the expected position, an error message is
generated, and the computer waits for the name of a valid
parameter file.
D. THE OUTPUT FILES
Three types of files are outputted by GRANULES, a "compartment
stats" file, age histogram files, and processing-ratio (B/A0)
histogram files. These files are coded by the two characters in the
last positions of the file name. "CS" specifies the compartment stats
file. For the histogram files, the first character specifies the file
type: "A" for age histogram, "B" for B/A0 histogram; the second
character specifies the compartment.
Age Histogram Files
Both of the two types of histogram files use the same second code
characters of the name to indicate data from total terminal (T), each
of the compartments (a numeral), or releasate (R)(if more than 9
compartments are required, file names must be shortened to leave space
for 2 compartment digits). They are Lotus-compatible ASCII files with
two more columns than the number of histogram bins. The first column
contains the model-day to which the rest of the data belong, then
comes the number of granules in each equally-spaced bin (linear or log
bins), and at the end, an overflow bin for granules exceeding the span
of the histogram. Each histogram file also has an identifying row of
titles which varies slightly depending on the particular histogram.
The histogram xxxxAT.PRN is arranged as follows:
AGE-HISTO:_TOTAL NT% TH TH0
DAY (1*w) (2*w) (3*w) (4*w) ..... OVERFLOW
(where w represents the bin width; "TOTAL" is replaced by "1", "2",
"3", ... etc and "RLSE" for files xxxxA1.PRN, xxxxA2.PRN, xxxxA3.PRN,
etc ..., xxxxAR.PRN).
If TH0=0, the histogram will be linear in age, with the first bin
containing granules with ages between 0 and TH/NT% time units. If TH0
is not = 0, then for each granule, LOG(age) [base e] is computed, TH0
is subtracted from it, and the result used in a histogram of TH log
unit span. Log histogramming is useful for PROCON.
Processing Ratio Histogram Files
The B/A0 histogram files are similar to the age histogram ones.
The
except that the string "B/A0_" is in the first column of the first
title row, NA% the second, and the third and fourth are blank. The
span of the histogram is fixed at 1.0, since that is the largest value
this ratio can assume.
Compartment Stats File
The columns of the "stats" file (xxxxCS.PRN) are first a granule
count, then mean age of granules, and finally mean value of processing
ratio (B/(A0*N). The sequence repeats, first for total terminal
content, then for each compartment in ascending sequence, and finally
for the release compartment:
DAY #TOTAL MEAN-AGE B/(A0*N) #1 MEAN-AGE B/(A0*N) ... #RLSE MEAN-AGE B/A0
E. .SAV FILE
When the model state is being saved, the .SAV file contains
parameters listed for the Parameter File in exactly the same sequence
(this allows the file to be used as a parameter file by adding the
"END" between NA% and DATE$). The current model time variable (T)
will be stored in the "Initial Age" parameter location (T0).
Following NA% are 4 additional saved parameters:
DATE$ - Run date (any valid string)
RUN$ - Run number (any valid string)
NI% - Number of time increments per day
NH% - Number of granules in pool
The next 4xNH% (or 2xNH% if B/A0 histograms are not generated)
entries contain values for four (or two) state variables (see also
entry under Program Descriptions).
CP%(H%) - Compartment assignment for granule H%
T(H%) - Birth date of granule H% (for released granules,
this will be the age at release instead)
IF NA%>0 then also:
CF(H%) - Conversion rate factor for granule H%
A(H%) - Amount of remaining precursor in H%
F. GRANULES.INI FILE
GRANULES.INI is a short ASCII file giving default infomation to
the program. It may be edited to change these options. Entries are
in the following sequence:
DDSK$ - the drive to receive the output file
PDFLT$ - name of default parameter file
TI$ - name of time units (e.g. "DAY")
TIS$ - plural name of time unit (e.g. "DAYS")
CONC$ - name of amount unit (e.g. "pMoles")
*****************
* PROCESS *
*****************
A. RUNNING PROCESS
To run the PROCESS model you must have a copy of PROCESS.EXE (or
PROCESS.BAS) on your logged drive, and a parameter file of appropriate
format (see Section C) on drive C:. The parameter file PROCTST.PRM is
supplied as an example, and the following steps illustrate program
operation using this test file:
1. Type "PROCESS " to start the compiled version. Shortly
the screen should display:
PROCESS 1.0 mod B2B 4/17/89
INPUT/OUTPUT DATA DISK (A:, B:, C:) =
Answer this query with "C:".
2. The next queries (answers at right) will be very similar to
GRANULES:
OUTPUT MODE: 0=SCREEN, 1=PRINTER, 2=DISK? 2
DATE? [today's date]
RUN #? 1
PARAMETER FILE ( for default: PROCTST.PRM)?
OUTPUT FILE NAME (8 characters; no ext.)? PROCTST
The last query, as for GRANULES, results in an output file with an
extension ".PRN", being in Lotus-compatible format. Since there is
only 1 such file, all 8 characters of the file name (instead of just
6) can be user-specified. The file for this example will be named
PROCTST.PRN.
3. The program will next print:
FILE ID=1 - 4 SITE PROCESS.B2B TEST DATA
NUMBER OF CLEAVAGE SITES= 2
K(121)= 1
K(131)= .3 K(132)= 1
K(232)= .1
KE'S= 1 1
MAIN MENU:
0 = RETURN TO BASIC 1 = KINETIC: PULSE-CHASE (S=R=0)
2 = KINETIC: CONSTANT S,R 3 = SS: VARIABLE R
4 = SS: VARIABLE K
5 = CHANGE NORMALIZATION 6 = CHANGE OPTION FLAGS
?
The first line is a file identifier from the parameter file (to help
you remember what the file was all about); the next gives the number
of cleavage sites; then several lines list the rate constants of
processing for each substrate molecule; finally a line giving the rate
constants of processing enzyme decay (in order; for this particular
example, there are two cleavage sites and hence two decay rates, both
equal in this case). The main menu gives several options, discussed
in more detail in Section B. For this example, we will choose
selection 1, the standard pulse-chase kinetics of peptide rise and
fall for a granule initially containing only prohormone [P(1,N+1)]
followed over time.
4. Following selection of "1", the program will ask for values
for the duration and time-slice of the model run (suggested answers
are the responses shown; note that these will be used in the PROCON
simulation, so it is suggested that they be followed exactly):
MAX T=? 32
TIME INCREMENT? .2
5. Computations will begin, printing out the amount of each
intermediate on the screen and the printer for each time increment in
the following format:
T=.2
P: 1 2 3
1 P(1,1) P(1,2) P(1,3)
2 P(2,2) P(2,3)
3 P(3,3)
The .PRN file will contain this same information in a slightly
different arrangement (see Section D below).
6. Computation and print-out continue through the last day
specified by MAX T; then the program returns to the Main Menu.
B. MAIN MENU OPTIONS
This section describes the other Main Menu options:
0 = RETURN TO BASIC: Self evident
1 = KINETIC: PULSE-CHASE (S=R=0) as described in Section A.
2 = KINETIC: CONSTANT S,R. The second type of kinetic model
permits starting with a specified amount of precursor (arbitrary
units), then continues to synthesize prohormone [i.e. P(1,N+1)] into a
single compartment at a rate of S units per day (or other time unit)
and releasing all compounds with a fixed first-order rate constant, R.
Since only a single compartment is involved, individual granules do
not have to be dealt with, but only the total amount in the
compartment. As for the pulse-chase, print-out gives the amounts of
each peptide at each time increment.
3 = SS: VARIABLE R. This is the first of the steady state
options, in which synthesis of new prohormone is balanced by release
(from a single compartment) of a mixture of peptides. The release
rate constant can be varied in equal increments between any set of
values desired. The program asks for the initial and final values,
and the increment (for example, running R from .2 to 5.2 in increments
of 1 in the test case provided will demonstrate the option). Print-
out will be of the same format as for the kinetic cases, except that R
replaces T as the independent variable.
4 = SS: VARIABLE K. This option allows steady-state calculation
of the effects of multiplying the processing rate constant(s) at any
one site by any set of evely-spaced numbers. The program asks for the
site, initial and final values, and the increment. This multiplier
multiplies the base level of K originally given for a site. For
example, running K from .2 to 5.2 (e.g. with increments of 1) for site
1 in the test case will cause K(121) to run from .2 to 5.2 while
K(131) runs from .06 to 1.56
5 = CHANGE NORMALIZATION. Not implemented in this version
6 = CHANGE OPTION FLAGS. This allows selection of enzyme-
degradation option. Answer "1" at the query to activate degradation
of the processing enzyme for the kinetic situations.
C. THE PARAMETER FILE
This file contains parameters in the following order:
File identifier (in quotes)
"PROCESSB2A" - a string used as a file-compatibility check
N% - the number of cleavage sites
K(1,2,1) - site-specific processing rate constants
K(1,3,1), K(1,3,2)
K(2,3,2)
K(1,4,1), K(1,4,2), K(1,4,3)
K(2,4,2), K(2,4,3)
K(3,4,3)
etc
E(1), E(2) ... E(N) - KE's for processing enzymes for sites 1 - N
The number of entries on each line is immaterial. The arrangement
shown is for convenience in keeping track of the cleavage sites. Note
that the arrangement lends itself to studies of different lengths of
prohormones, since the first K(i,j,m) is for a 2-segment chain, the
next 3 cover a 3-segment chain, the next 6 a 4-segment chain, etc.
Only an appropriate set of E(m)'s must be patched into the middle of
the file, and the value of N% changed, to alter the chain length.
D. FRAGMENT DISTRIBUTION OUTPUT FILE
As for the output file of GRANULES, that of PROCESS is a Lotus-
compatible ASCII file, the first column being the value of the
independent variable (e.g. model time) for the row and the rest being
the P(i,j)s calculated by the model. The output file for the test
case, PROCTST.PRM, will serve to illustrate the format for this file
type. The first three lines are:
"PROCESSB2A2" 2 32 .2 2
"T","P(11)" "P(12)" "P(13)" "P(22)" "P(23)" "P(33)"
0.20 0.0600 0.2000 0.7400 0.0000 0.0600 0.2000
Line 1 contains a file-format code (the parameter file code with the
character "2" appended). The next three entries are the number of
cleavage sites (N%), the run duration (MAXT), the time increment (DT)
and the menu selection code used in generating the run (MM%). Line 2
contains column headers which will go into the second row of a Lotus
work sheet when the file is imported. These identify the first column
as time and subsequent columns as the different P(i,j)s. Starting
line 3 are the numbers calculated by the model.
************
* PROCON *
************
The GRANULES model generates histograms for age distributions of
granules in various parts of a nerve terminal. The PROCESS model
provides a direct way to calculate the concentrations of all peptide
fragments in a granule as a function of its age alone, with or without
an inactivation mechanism for the processing reactions. Together
these provide a means for calculating the fragment mixture in a
terminal or a compartment thereof. This is done by numerically
convolving the granule age distribution with the time course of
peptide fragment concentration change with age.
A. RUNNING PROCON
To run PROCON, you must have a copy of PROCON.EXE (or .BAS) on
your logged drive. Also available must be an appropriate Age
Histogram .PRN file from GRANULES (drive may be specified in the file
name) and a Fragment Distribution .PRN file produced by the PULSE-
CHASE option of PROCESS (Main Menu selection 2). In the test example,
the file GRANTSAT.PRN will be convolved with PROCTST.PRN to produce an
output file that will be called "CONTST.PRN", and it will be assumed
that both of these are on your logged drive.
1. Type "PROCON". The screen should display:
PROCON 1.0 mod B2A 4/21/89
OUTPUT DISK (A:, B:, ... etc)?
Answer "C:" to put output on your hard disk, or "A:" or "B:" for one
of the floppies.
2. In parallel fashion to GRANULES and PROCESS, various other
inputs will be requested, including TWO input files (responses you
should make are to the right of the "?"s):
PRINT MODE (0=SCREEN; 1= PRINTER; 2=PRINTER with Processed distrib)? 1
NAME OF PROCESS FILE (No ext.; Format=PROCESSB2A2)? "PROCTST"
NAME OF OUTPUT FILE (No ext.)? "CONTST"
NAME OF AGE-HISTO FILE (No ext.; Format=GRANULESQ3N)? "GRANTSAT"
3. The screen will clear and the program will start to read in
the PROCESS Fragment Distribution File. After this, it calculates and
prints on the screen and (if Print Mode 2 is selected) printer the
fragment distribution corresponding to each of the age histogram bins.
This distribution is a normalized one, referred to the original amount
of precursor (=1.0), and hence indicates the relative proportion of
each peptide fragment that is present in granules of a given age bin.
4. Finally, the age histogram file will be read in one day at a
time, and the total amount of each fragment will be calculated and
printed in a format similar to that used by PROCESS:
1 2 3
1 P(1,1) P(1,2) P(1,3)
2 P(2,2) P(2,3)
3 P(3,3)
5. The program finishes with the message "NORMAL TERMINATION"
B. OUTPUT FILE
The output file for PROCON is also a Lotus-compatible ASCII file
with the following structure for the first 4 lines:
PROCONB01 N% - a compatibility code, and the number of cleavage sites
First row of PROCESS fragment distribution file
Second row of PROCESS fragment distribution file
Fragment distribution for first time-point
Subsequent lines contain the fragment distributions at each following
time point.
***************************
* PROGRAM DESCRIPTIONS *
***************************
The following descriptions of the three model programs are
referenced to the accompanying flow diagrams (in part from Hartline
and Newcomb 1989).
GRANULES MODEL PROGRAM
A. GENERAL
Granules are represented by four 1-dimensional state-arrays:
CP%(H%) stores an integer representing the compartment
assignment for granule H% (numbered consecutively from
1 to NC%).
T(H%) stores the birth date (value of the model time
variable T at the time of synthesis) for each granule.
A(H%) stores the amount of UNPROCESSED peptide for each
granule. This amount is decremented with the rate
constant CF(H%).
CF(H%) stores the current conversion rate constant for the
granule. This is set to C(I%) at the time of granule
synthesis, where C(I%) is the compartment-specific
initial conversion rate constant.
These last two options are deleted if the number of granules
specified exceeds 6300, in order to make room for the large CP%() and
T() arrays required.
Release of a granule is represented by an additional compartment
above and beyond the number, NC%-1, that represent physical regions of
the terminal. Thus there are NC% compartments in all, although there
is no "diffusion" out of the last one (number NC%).
A single day's calculations entails looping 1/DT (where DT is the
size of the integration "time slice") times through the set of
calculations described in 2 through :
A. INITIALIZATIONS [line 300] etc.
The initializations of variables, selection of output to screen,
screen and printer, or screen, printer and files, the read-in of
parameters from the specified parameter file (defaulted to
GRANTST.PRM), and the set-up of output files (named as described at
the end of section B above) are mostly straight forward. The program
uses the variable containing the number of bins for the B/A0 histogram
as a flag for omitting the histogram if the number of granules exceeds
6,300 [line 308]. A string variable, FORM$, is filled with a file-
compatibility string that is later checked against parameter files
being read in [line 315]. Arrays are dimensioned in part according to
parameters in the parameter file, but the maximum size of the
histograms is fixed at 5 compartments [line 320], and limitations of
20 buffers in the usual MSDOS implementation forces limitation of the
number of compartments to 4 if B/A0 histograms are being generated,
and to 11 if they are not [line 309]. There is some obscure coding
following line 500 in order to write appropriate column headers for
the Lotus-compatible output files.
Having finished the set ups, the program enters the main menu
[line 1000], the primary options for which have been described above
(Section B). The primary program flow proceeds via Option 1, "New
Treatment", which asks for treatment parameters from the keyboard
[line 1100] and then enters the subroutine for calculating one day's
kinetics.
B. ONE DAY'S KINETICS
1. RESTORING FREE POOL [line 3000]. Upon entry to the One
Days's Kinetics subroutine, granules released in the previous day
(those with CP%()=NC%) are returned to the "free" pool: their CP%()
is set =0. In examining the granule list, a count is kept for
unassigned granules which were not reused in the previous day, and if
this count rises above 50, the granule array is squeezed down to
eliminate empty granules. This greatly speeds program execution when
going from a full terminal to one which is greatly depleted (e.g. by a
large increase in R or decrease in S).
2. GRANULE SYNTHESIS IN EACH COMPARTMENT [line 3100]. At each
time increment, the number of new granules to be added to each
compartment is calculated from the synthesis rate specified for that
compartment, and empty places in the granules arrays are filled with
compartment assignment and birth date. Fractional granules are held
over and summed until a value greater than 1 accumulates, whereupon an
extra granule is synthesized. The integer number, MS%, of granules
synthesized into each compartment, I%, is:
MS% = S(I%)*SF*VF*DT/A0 + MS(I%)
where:
S(I%) = compartment-specific rate of synthesis into
compartment I% (e.g. pmoles/day)
SF = a synthesis scale factor allowing all syntheses
to be changed as a unit.
VF = a volume factor, determined by terminal growth
DT = the model time-step (e.g. in days)
A0 = amount of precursor in each granule (e.g. pmoles)
The integer designation ("%") implies truncation of the number
generated by the right side of the above expression. The remainder
from this truncation is saved in the array MS(I%) and added to the
right side for the following time-increment.
3. DEGRADATION OF PRECURSOR AND PROCESSING ENZYME [line 3480].
A simple peptide processing scheme is included in the model. In this,
the processing rate constant can be individually initialized in each
compartment, to simulate differences in packaging of processing enzyme
(if the simpler assumption is made that the rate is independent of
compartment the same processing states could be calculated from the
granule age distributions generated by the model).
dA(H%) =-CF(H%)* A(H%)*DT
Where:
A(H%) = amount of precursor remaining in granule H%
CF(H%)= CF*C(I%) where
CF= a conversion scaling factor (to allow all
conversion rates to be altered simultaneously)
C(I%)= the base conversion rate constant (1/days) for
granules synthesized into compartment I%
4. GRANULE REDISTRIBUTION BY DIFFUSION [line 3540]. Granules
already in compartments are randomly selected, in numbers proportional
to total compartment occupancy and inter-compartmental diffusion
constants, for transfer to connected compartments. To assure full
(pseudo-) randomness, the full array of active granules fors the
selection pool for each selection. The compartment assignment of
randomly selected granules is tested and is retained only if it
matches the current target compartment.
Granules moved in this way are tagged so that they cannot be
moved again in the time increment (this prevents granules from moving
faster than the speed of light). Tagging consists of adding the
integer NC% (the number of compartments including the release
compartment) to the granules' compartment assignment number [CP%(H%)].
are not supposed to, they are "tagged". This consists of adding the
number NC% to the granule's compartment assignment number [CP%(H%)].
Tags are removed by subtracting NC% from any compartment assignment
greater than NC%.
For each compartment (I%), the integer number (M%) of granules
reassigned to it from each other compartment (J%) is:
M% = K(I%,J%)*KF*N%(J%)*DT/V(J%)/QRVF + M(I%,J%)
where:
N%(I%) = the number of granules in compartment I%
V(I%) = basic volume of compartment I%
QRVF = the cube root of the accumulated growth volume
factor, VF (see below)
As was the case for synthesis, the right side of the above expression
in general gives a non-integer value, so the remainder from the
truncation is saved in the array M(I%,J%) and added to the right side
in the following time-increment.
(this is the implementation of Eq. 1 of Hartline and Newcomb 1989)
5. RELEASE OF GRANULES [line 3570; 3645]. An extra compartment,
with no back diffusion, represents release of granules from the
terminal. In addition to the usual computation of granule flux "into"
the compartment (i.e. released), an age-specific release probability
can be applied to modify the effective diffusion coefficient. Thus RF
replaces KF in the last equation when I%=NC%. Further, each granule
candidate for release "spins the roulette wheel" and is not released
if:
EXP(KREL*AGE)< a random number from 0 to 1,
where KREL = decay rate of release probability. If KREL=0, then the
granule is released obligatorily.
6. COMPARTMENT TALLIES AND TAG REMOVAL [line 3700]. At the end
of each time slice, the ages for each released granule are calculated
and replace the birth date in the array T(). Ages of granules
remaining in the terminal (i.e. not released) are tallied, to provide
"concentration" values for the next time increment. Granules which
were moved within the time slice and hence tagged with a
pseudocompartment assignment NC% too high, have the tag removed (NC%
subtracted from CP%()) so they can be moved again in the next time
slice.
7. TIME SLICE LOOP [line 3760 - 3100]. The program loops 1/DT
times to bring model time up to a 1 day (or other time unit) boundary.
8. VOLUME GROWTH [line 3765]. At the end of each day, provision
is made for a linear growth in volume, in which the geometry of the
cell is assumed to expand uniformly. Since for a given initial number
of granules the flux of granules from one compartment into another is
proportional to the area of the interface between the compartments and
inversely proportional to the volume of the compartment of origin, and
since under the assumption the area grows as the square of the linear
dimension and the volume as the cube, the effective diffusion constant
is made inversely proportional to the linear dimension or the cube
root of the volume. The synthetic apparatus of the cell is assumed to
function in direct proportion to its volume as well. To implement
this, a volume factor, VF, is incremented each day by an amount DVF.
This volume factor multiplies all volumes in the model, wherever they
appear. The cube root of this volume factor, QRVF, divides the right
sides for the diffusion equation above (this can be disabled by
setting VFLG% >0 using menu selection 12, in which case the
compartments grow in size but the diffusion and release rate constants
do not change).
C. OUTPUT OPTIONS
After return from the One Day's Calculations subroutine, three
types of output are usually generated:
1. "STATS" will be displayed on the screen and printed on the
printer, giving (as described above) the number of granules; their
mean age; and their processing ratio, for all granules in the whole
terminal; granules in each compartment; and granules released during
the current day; [line 1500]. Set CSF%=1 using Menu Selection 9 to
suppress this.
2. Age Histogram, giving the granule counts for a specified
number of age bins for granules in the whole terminal, in each
compartment, and released; (line 1600). Set NT%=0 to suppress age
histogram generation.
3. Processing Ratio Histogram, like the age histogram,
indicating the distribution of enzymatic degradation of granules;
[line 1600]. Set NA%=0 to suppress B/A0 histogram generation
(automatically done if >6,300 granules is specified initially).
These go to the screen, to the printer, and to disk files, as
described above in RUNNING GRANULES,
----------------------------------------------------------------
PROCESS MODEL DESCRIPTION
A. GENERAL
Different options in PROCESS require solving two slightly
different equations:
KINETIC OPTIONS (those computing time-varying quantities) have at
their heart the equation for synthesis and degradation of any
intermediate, P(i,j) (for a more accurate representation and
discussion, see Hartline and Newcomb 1989; also see diagram at the
beginning of the source program):
dP(i,j)/dt = S1 + S2 + S3 P(i,j)
where:
i-1 "Left-side cleavage":
S1 = SIGMA K(m,j,i-1) E(i-1) P(m,j) cleavage at site i-1 of chains
m=1 ending at segment j.
N+1 "Right-side cleavage":
S2 = SIGMA K(i,m,j) P(i,m) cleavage at site j of chains
m=j+1 beginning at segment i.
j-1 Internal cleavage:
S3 = R + SIGMA K(i,j,m) rate constant of cleavage of
m=i P(i,j) and release.
P(i,j) = peptide including segments i through j
K(i,j,m) = rate constant for cleavage at site m of P(i,j)
R = rate constant of release from a single compartment
STEADY STATE: In the non-kinetic case, with ongoing release rate
R from a single compartment, the above equation becomes:
P(i,j) = (S1 + S2)/S3
The first (kinetic) equation requires numerical integration. The
second (steady state), if calculations are done in the right order, is
directly computable.
B. INITIALIZATIONS [line 300] and MAIN MENU [line 600]
Initializations and the main manu are similar to GRANULES. There
are four primary selections of model run-types from the main menu, but
these all end up calling the same "COMPUTE P(I,J)s" and print-out
subroutines for the core modeling. The two kinetic selections use
different precursor amounts and release and synthesis rates, but then
execute the same loop (beginning line 805) for numerical integration
of the P(I,J)s. The two steady state selections input different
parameter types to scan (R or K), but execution loops are essentially
identical.
C. COMPUTE P(I,J)s SUBROUTINE [line 2000]
1. RATE OF P(I,J) CHANGE [line 2000]. This section of the
subroutine calculates the partial sums S1, S2, and S3. The key to
properly calculating these for the steady state is to do them in the
right order (for the kinetic condition, order is immaterial). A few
examples will illustrate the approach:
Calculating the right cleavage input, S2, for any peptide
P(i,j) requires that all P(i,m) have already been calculated for m>j.
The example of P(1,5) can be diagrammed as follows:
1 2 3 4 5 6 7 8
* * * * # 1,6 1,7 1,8
In the diagram, the peptides with i=1 are laid out in order of
increasing length. For the target peptide, P(1,5) (designated by
"#"), only those to the right are precursors, producing P(1,5) by
cleavage at site 5. To get these precursors, the other peptides have
to be calculated first. However, P(1,8) (the "prohormone") is
calculated without precursors. P(1,7) is calculated from the known
P(1,8); P(1,6) from P(1,7) and P(1,8), etc. Thus as long as
calculations occur from a higher second index to a lower one (longer
peptides to shorter ones), all precursors will have been calculated.
Next consider peptide P(4,5):
i\j 1 2 3 4 5 6 7 8
1 * * * * 1,5 1,6 1,7 1,8
2 * * * 2,5 2,6 2,7 2,8
3 * * 3,5 3,6 3,7 3,8
4 * # 4,6 4,7 4,8
As for P(1,5), only peptides to the right in the same row are right-
cleavage precursors, so only these need be known to generate S2. S1,
however, is generated from left side cleavage, which means all of the
precursors in the vertical column above #: P(3,5), P(2,5), and P(1,5).
The last we already have. P(2,5) we obtain from P(1,5) (which we
have) and (as for P(1,5)) the peptides to its right, beginning with
P(2,8), which in turn comes directly from P(1,8). P(3,5), in its
turn, derives directly from peptides above it and those to its right
in the diagram, and so forth. Thus in general any peptide on the
diagram derives directly from peptides above it (its S1 contributors)
and those to its right (its S2 contributors), and hence indirectly
from ALL peptides above and to its right. If we start with i=1 we
have all the precursors to calculate P(1,j) if we start with j=N+1 (=8
in this example) and work backward. Then we increment i to 2 and
calculate P(2,j), again starting with j=N+1, and so forth.
In the program, this is extremely simple: an outer loop
increments i (=I%) and an inner loop decrements j (=J%). S1's and
S2's at any point are complete and can be used to calculate steady
state peptide levels.
2. KINETIC INTEGRATION [line 2160]. In steady state models,
answers are obtained directly from S1, S2, and S3, so the subroutine
exits at line 2155. In kinetic models, these numbers contribute to
the CHANGEs in P(i,j), and hence must be numerically integrated (i.e.
[S1(i,j) + S2(i,j) - S3(i,j)*P(i,j)] is multiplied by DT and added to
P(i,j)). Processing enzymes are degraded (inactivated) if the
appropriate flag is set (using Menu option 6). Then the subroutine
returns.
PROCON MODEL DESCRIPTION
A. INITIALIZATIONS [line 100]
The program starts with basic keyboard input of options, opening
an output file and reading the initial lines of the GRANULES (Age
Histogram) and PROCESS (Fragment Distribution) files to obtain size
and type (log or linear) of data set and to obtain column titles to
write to the output file.
B. COMPUTE FRAGMENT DISTRIBUTIONS [line 300]
For each time-bin interval of the age histogram, a normalized
fragment distribution is calculated for the mid-point of the bin.
This is achieved by taking each mid-point time in turn (calculated
from the span and the number of bins) and reading in PROCESS time
points until that time has been exceeded. A linear interpolation is
then made between the distributions from the current and previous
time-points, and placed in the array PP(I%,J%,T%) where I% and J%
index the first and last segments of a fragment, and T% indexes the
histogram bins. Note that it is essential that the time-span of the
PROCESS data set exceeds that of the histogram.
C. CONVOLUTION [line 400]
The program takes up each day of the GRANULES model histogram in
turn, looping back [line 440] at the end of each day. For each day,
the number of granules in each age bin is read in, the fragment
content of those granules is calculated from the PP(I%,J%,T%) array,
and this is added to the cumulative fragment totals for the day [loop
starting line 500]. The number of granules in the bin are also
tallied. The overflow bin is discarded (note that this produces
potential inaccuracies if there is much occupancy of this bin!). When
all bins have been calculated, the final totals are divided by the
granule total for the day and printed and written to disk [line 600]
============================ APPENDICES ===========================
APPENDIX I
GRANULES parameter dump to screen for GRANTST.PRM:
PARAMETERS FOR TESTING vrs Q3N
INACTIVATION RATE CONSTATN FOR CONVERSION ENZYME (KE): .14
CONVERSION RATE FACTOR (CF): 1
DIFFUSION RATE FACTOR (KF): 1
RELEASE RATE DECAY (KREL): 0
K(TO,FROM)'S FOR 3 COMPARTMENTS:
0 1 0
1 0 1
0 1 0
RELEASE RATES: 0 0 1
SYNTHESIS RATES: 1 0 0
CONVERSION RATES: .1 .1 .1
VOLUMES: 1 1 1
INITIAL AGE= 0 VOLUME FACTOR= 1 GROWTH/DAY= 0 x PER DAY
INITIAL CONC OF PRECURSOR PER GRANULE= .005 PMOLE
AGE-HISTOGRAM SPAN & # BINS= 60 , 20 BIN WIDTH= 3
B/A0 HISTOGRAM # BINS= 20
-----------------------------------------------------------------
APPENDIX II - File organization
1. GRANTST.PRM
"PARAMETERS FOR TESTING vrs Q3N"
GRANULESQ3N
0.14, 1.0, 1.0, 0, 3
0.0, 1.0, 0.0
1.0, 0.0, 1.0
0.0, 1.0, 0.0
0.0, 0.0, 1.0
1.0, 0.0, 0.0
0.1, 0.1, 0.1
1, 1, 1
0,1,0,.005,5,60,0,20,20
END
Explanation:
"PARAMETERS FOR TESTING vrs Q3N" - Identifying string (in quotes)
GRANULESQ3N - File-compatibility string
KE - processing enzyme decay rate constant (1/days)
| CF - conversion-rate scaling factor
| | KF - diffusion-rate scaling factor
| | | KREL - release probability age-dependence rate constant
| | | | NC%-1 - number of compartments
| | | | |
0.14, 1.0, 1.0, 0, 3
0.0, 1.0, 0.0 - K(1,1); K(1,2); K(1,3) - diffusion rate constants (1/days)
1.0, 0.0, 1.0 - K(2,1); K(2,2); K(2,3) (note K(i,i) must = 0)
0.0, 1.0, 0.0 - K(3,1); K(3,2); K(3,3)
0.0, 0.0, 1.0 - K(RLSE,1); K(RLSE,2); K(RLSE,3) - release rate constants
1.0, 0.0, 0.0 - S(1), S(2), S(3) - compartment synthesis rates
0.1, 0.1, 0.1 - C(1), C(2), C(3) - compartment cnvrsn rate factors
1, 1, 1 - V(1), V(2), V(3) - compartment volumes
T0 - Initial age (days, or other base unit chosen)
| VF - Initial volume factor
| | DVF - Growth rate (growth is DVF per day)
| | | A0 - Initial amount of precursor in each granule (pmole)
| | | | RN% - Randomizer seed
| | | | | TH - Age histogram span (days)
| | | | | | TH0 - Age histogram origin (if log histo)
| | | | | | | NT% - Number of bins in age histogram
| | | | | | | | NA% - Number of bins in B/A0 histogram
| | | | | | | | |
0,1,0,.005,5,60,0,20,20
END - obligatory termination string
2. .SAV FILES - for saving model state (see Menu Selection 4):
First 16 + N%*(N%+4) locations [call this "n": identical to .PRN file
Next 4*NH% locations (where NH%= number of active granules):
CP%(H%) - Compartment assignment for granule H%
T(H%) - Birth date for granule H% (value of T at synthesis)
CF(H%) - Present enzymatic conversion rate in granule
A(H%) - Amount of unconverted precursor remaining in granule
If more than 6300 granules have been requested, the last two
location types are not generated. Granule storage then requires 2*NH%
locations.
Note that since the initial locations are identical with those
for the parameter file, a .SAV file can be used as a parameter file
after inserting "END" just before the granule storage area.
-----------------------------------------------------------------
APPENDIX III. KEY VARIABLES
[excluding parameters read from files]
[g=GRANULES; p=PROCESS; c=PROCON]
A(h) g Amount of precursor in granule h
AGE% c Logical unit for age histogram storage
C(h) g Conversion activity (enzyme conc) in granule h
CP% g Dimension of compartment array
CP%(h) g Compartment assignment of granule h
CONV% p Logical unit for output of PROCON
CONV$ p Name of output file for PROCON
CSF% g Compartment Stats Flag: set=1 to suppress Stats print
DDSK$ gpc Disk drive for output file ("A:", "B:", etc)
DF% gc Debug flag: if set, prints out intermediate steps
E(m) p Enzyme activity factor for site m
FMT$ gpc File format identifier read from stored input file
FORM$ gpc File format identifier for current program version
H% g Index usually reserved for granule arrays
I% g Usually reserved to index destination compartments
pc Index usually reserved for first segment of a peptide
J% g Usually reserved to index source compartments
pc Index usually reserved for last segment of a peptide
K(i,j) g Diffusion rate constants from cmpt j into cmpt i
K(i,j,m) p Cleavage rate constant for P(i,j) at site m
M(i,j) g Fractional remainder of granules to be moved j to i
MM% gp Active main menu selection number
MS(i) g Fractional remainder of granules for synthesis to i
N% g Total terminal granule count (= sum of N%(i)s)
pc Number of cleavage sites on prohormone
N%(i) g Granule count for compartment i
NH% g Number of active granules in granule arrays
NI% g Number of time increments per day (=1/DT)
NTOT% c Total granule count
P(i,j) pc Amount of peptide that starts segment i, ends j
PF% gpc Print flag. Controls output. 0=screen only;
1=screen and printer; 3=screen, printer, and disk file.
PDSK$ gp Disk drive holding parameter file ("A:", "B:", etc)
PFILE$ gp Name of parameter file
PFM$ p Print format string for output
PP(i,j,t) c Amount of P(i,j) at time t as calculated by PROCESS
PRM% p Logical unit (file #) for parameter file
PROC% pc Logical unit (file #) for output file of PROCESS
PROC$ c Name for output file of PROCESS
SZ% g Dimension of granules arrays
T gp Model time
T% g Time-increment index used within a single day
c
T(h) g Birth date of granule h
Note that in the versions of BASIC these programs are compatible with,
(Microsoft QuickBASIC) it is legal to use the same name for two
variables of different types, e.g. N$, a string variable; N%, an
integer variable; and N%(i), an integer column vector. Not all
BASICs allow this.