This quick-start guide is for users who wish to start using Beatbox in their cardiac simulation project. This quick-start provides an easy to read and follow document using which the user can start using Beatbox immediately.
A full manual is available HERE.
A full manual for making BBG files is available HERE.
Beatbox is a Unix-based piece of software. Thus, it will also work on
Mac (tested on Leopard and Snow Leopard OS X) and standard Linux:
tested on Fedora and Red Hat Linux, though any other Linux
distribution should work. The preferred working shell for Beatbox is
the bash shell. This choice of shell will assist in
easily executing the examples described below. For larger
non-interactive simulations, you may wish to choose tcsh
or bash.
Beatbox requires gcc (sequential) and mpicc
(MPI parallel) C compilers. Beatbox also requires standard math and
X11 libraries.
To obtain the Beatbox source code off the project repository, you need a client program for Subversion (SVN). You can also obtain a copy of the distribution source code from the authors.
These are a standard installation procedures assuming your
computer satisfies requirements stated previously. These instruction
assume that you are using bash or a similar command-line
shell.
To obtain a BeatBox release, download the most recent tarball from
the repository, which at the moment of writing this is at
http://empslocal.ex.ac.uk/people/staff/vnb262/software/BeatBox/
, and unpack it. Chose the place at your convenience. It could be
your home directory or any other directory in your space.
Say, if you downloaded the file
beatbox-1.1-417.tar.gz into your
$HOME directory, then you can do
cd $HOME gunzip -c beatbox-1.1-417.tar.gz | tar xvf - cd beatbox-1.1-417and you will be in what we shall call the "beatbox package directory".
Developers and more experienced users may prefer to get the most recent versions of the package under development. For that, a Subversion (SVN) client should be working on your computer. Methods of obtaining SVN are detailed on their web page:
Your flavour of Linux may also support updating the SVN package using
yum, apt-get, or similar.
Assuming you have
SVN client on, you can create the beatbox directory and
download the package into it using the following commands:
cd $HOME mkdir beatbox cd beatbox svn co --username=anonymous --password=beatbox https://beatbox-trac.epcc.ed.ac.uk/svn/trunk . cd beatboxand you will be in the BeatBox package directory.
Note the '.' at the end of the svn command. If you are already familiar
with SVN you may note that this will given you a read-only copy of the
directory; if you would like to contribute to the package, you are
welcome to
contact the authors (see below).
For the impatient: the basic commands for compiling on local machines (including standard MPI clusters) as well as on HECToR (the UK National Supercomputing facility) have been collected into two bash shell scripts. To check if your download contains these install scripts, and that their permissions are execute permissions, use the following command in the BeatBox package directory:
ls -l bbx_compile*sh
which should produce something like the following:
-rwxrwxr-x. 1 user group 195 Aug 3 17:01 bbx_compile_hector.sh -rwxrwxr-x. 1 user group 77 Aug 10 17:15 bbx_compile_local.shSimply running these shell scripts from the BeatBox package directory will compile and install Beatbox, correspondingly on Hector:
./bbx_compile_hector.shor on a typical ("local") computer:
./bbx_compile_local.shNote that these scripts will install the executables into
$HOME/bin;
naturally, for this to work, that directory have to exist.
Details and variations:
--prefix flag which points the
installation to the directory you specify. Say if you do
./configure --prefix=$HOME/somewherethen the executables will be installed into $HOME/somewhere/bin/ directory.
./configure CFLAGS="-g -O0" --prefix=$HOME/somewhere
The compile and installation procedure outlined in the previous section will
produce two executables Beatbox_SEQ
and Beatbox in the directory $HOME/bin
(or another directory if you opted for that).
This can be checked using the command:
ls -l $HOME/bin
which should give something similar to the following:
total 1836 -rwxr-xr-x. 1 usrname yourgroup 835665 Aug 10 17:23 Beatbox -rwxr-xr-x. 1 usrname yourgroup 1036636 Aug 10 17:23 Beatbox_SEQ
Beatbox_SEQ is the sequential executable,
and Beatbox is the parallel executable. To make the
binaries accessible from anywhere on your machine, the
$HOME/bin directory should be added to your path.
Alternatively, you may copy the executables to a directory already
in your path, or you can call them using their full path name.
Sequential and parallel test scripts are provided to test Beatbox. The sequential test scripts are basically for execution on a single processor on your local computer. The provided examples of parallel test scripts are for execution on HECToR.
A typical Beatbox simulation is constructed using the bbs
high level scripting language specific to Beatbox. The bulk of
the bbs script represents what should be computed during
one time step. Other parts of the bbs script dictate the
duration of simulated activity, stimulation protocols, output, and run
time measurements. Thus, a bbs script serves as an input
for the Beatbox executables Beatbox_SEQ
and Beatbox, see examples below.
On a local machine, usually in the sequential mode,
the bbs scripts can be run directly from the command
line.
To help run the bbs scripts with variable input
arguments, or for multiple runs, or in a batch mode on a cluster,
examples of bash shell scripts are provided.
Examples of sequential scripts are provided in the
directory $HOME/beatbox/data/scripts/sequential.
Here we consider examples of Beatbox bbs scripts for 0D
individual cell simulation, 1D fiber, and 2D sheet of cells simulation
with Fitz-Hugh-Nagumo (FHN) cell kinetics model. For every simulation
script, we discuss the inputs, the simulation script, what it does,
the outputs, and how the outputs could be visualised. To run these
simulations, go to the Beatbox directory which contains the sequential
scripts:
cd $HOME/beatbox/data/scripts/sequential/FitzHughNagumo_model
The Fitz-Hugh Nagumo cell model Action Potential (AP) is simulated
using the bbs program fhn0.bbs.
If the $HOME/bin directory containing
the Beatbox_SEQ executable is in your path,
a bbs script can be run directly from the command line
using the command:
Beatbox_SEQ fhn0.bbsor you will need to specify the full path to the
Beatbox_SEQ executable otherwise:
$HOME/bin/Beatbox_SEQ fhn0.bbs
In this example, the sequential Beatbox
binary, Beatbox_SEQ is called with the input of
the bbs script fhn0.bbs. Here we give just a
brief outline of the 0D FHN simulation script, please see the detailed
comments in the file fhn0.bbs.
fhn0.bbs script starts with the use
of state device to define the size xmax*ymax*zmax
of the medium and the number of dynamic variables vmax,
followed by a series of variable and parameter declarations to prepare
Beatbox simulation.
k_func device defines timing variables for feedback
stimulation to generate an Action Potential.
euler device is used to update the ODE model at
each time step.
record
device into the file called fhn0.rec, which can be
visualised using gnuplot.
The log of the program run is automatically saved into the
file fhn0.log which replicates what you will have
seen the output produced when you run the sequential code.
The output file fhn0.rec will be used to generate initial
conditions for the 1D fiber simulation by the fhn1.bbs
script, which is discussed next.
The FHN 1D model simulates a propagation of an AP through a 1D fiber
of connected cells using the bbs script
fhn1.bbs.
The script fhn1.bbs makes use of including the parameter
file fhn.par, and uses the 0D output
file fhn0.rec to generate initial conditions for the 1D
simulation via the phase distribution method.
Then, the FHN 1D script fhn1.bbs can be run as an
input file for the sequential binary Beatbox_SEQ from the
command line
$HOME/bin/Beatbox_SEQ fhn1.bbs
The log of the program run will be automatically saved into the file
fhn1.log with the output that will have been produced
by the execution of the program.
Here we give just a brief outline of the simulation script, please see
the detailed comments in the file fhn1.bbs.
fhn1.bbs script starts with the inclusion of the
model parameter file fhn.par, please see the file for
details,
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
beginning, ending, and pacing.
Are these equivalent to the simulation start time, end time and the output interval? Not sure what pacing is in this context.
fhn0.bbs simulation, that is
the fhn0.rec file is used to generate the initial
conditions for the 1D simulation via the phase distribution method.
diff device is used to compute the Laplacian and
update the Neumann boundary conditions.
euler device is used to update the ODE model at each
time step.
fhn1.rec, which can be visualised using gnuplot.
fhn1.rec will be used to generate initial
conditions for the 2D sheet of connected cells simulation by the
fhn2.bbs script, which is discussed next.
The FHN 2D model is simulated using the bbs
script fhn2.bbs. It can be run at command line using the
command:
$HOME/bin/Beatbox_SEQ fhn2.bbs
In this example, the sequential Beatbox
binary, Beatbox_SEQ is called with the bbs
script fhn2.bbs.
The fhn2.bbs program consists of a series of variable and
parameter declarations, and the use of the state device
to prepare Beatbox for the simulation. Several input parameters are
conveniently included in a file called fhn.par, which is
included in the bbs program using <fhn.par>.
As before the schedule of the simulation is set up using parameters
used for beginning, ending,
and pacing (among other actions) of the simulation. The
function of the diffusion device diff and the ODE
solver euler is explained in the comments.
Re-entry is initiated using a series of k_func devices to
set the appropriate values of variables to facilitate inducing of
re-entry in the 2D medium. The protocol for initiating re-entry is by
means of cross-field stimulation. The actual computation for the
diffusion is carried out using the diff device, while the
ODE is solved using the euler device. Consecutive frames
from the 2D simulation are stored in a series of ppm files in
the ppm/ sub-directory. The ppm files consist of 3 layers
as a rule, and are given red, green, and blue values. The 2D ppm files
can be converted to jpegs, tiffs, pngs using
standard netpbm programs (see the Visualisation section
of the main documentation for details on
how to do this).
fhn2.bbs.
fhn2.bbs script starts with the inclusion of the
model parameter file fhn.par, please see the file for
details.
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
begin and end are defined
using k_func device
to be used to for beginning and ending of simulation.
k_func device is used to define
the cross-field stimulation protocol to induce re-entry.
diff device is used to compute the Laplacian and
update the Neumann boundary conditions.
euler device is used to update the ODE model at each
time step.
PPM files consisting
of periodic snapshots of the simulation.
netpbm or any other suitable
visualisation tool.
The FHN 3D box model is simulated using the bbs
script fhn3.bbs. It can be run at command line using the
command:
$HOME/bin/Beatbox_SEQ fhn3.bbs
This should work even on small computers. Though note that you will
need to ensure that the fhn.par located
in $HOME/beatbox/data/parameters is in the same directory
for this to run. If you did not create a ppm subdirectory
for the last example be sure to create it for this example as well
otherwise it will not run.
In this example, the sequential Beatbox
binary, Beatbox_SEQ is called with input of the bbs
script fhn3.bbs. The fhn3.bbs script
consists of a series of variable and parameter declarations, and the
use of state device to prepare Beatbox for the
simulation. Several input parameters are conveniently included in a
file called fhn.par. So you need to
have fhn.par in your working directory. The schedule of
the simulation is set up using parameters used for beginning, ending,
and pacing (among other actions) of the simulation. The format,
function, output of fhn3.bbs is exactly the same as in
the 2D case. After setting up the schedule parameters using
the k_func device, another set of k_func are
used to provide the cross-field stimulus. The diff device
is then used to compute the diffusion of voltage throughout the 3D
model. The euler device then computes the ODE
(fhncubpar in this case) at all points of the finite
difference grid. The ppmout device outputs ppm files at
each time step. These ppm files are produced in a sub-directory
called ppm/ which is presumed to exist in the working
directory. The ppm output of this fhn3.bbs can be
visualised using EZView, a Beatbox related piece of
software (see below).
fhn3.bbs.
fhn3.bbs script starts with the inclusion of the
model parameter file fhn.par, please see the file for
details.
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
begin and end are defined
using k_func device
to be used to for beginning and ending of simulation.
k_func device is used to define
the cross-field stimulation protocol to induce re-entry.
diff device is used to compute the Laplacian and
update the Neumann boundary conditions.
euler device is used to update the ODE model at each
time step.
PPM files consisting
of periodic snapshots of the simulation.
netpbm or any other suitable
visualisation tool.
In the previous section, we saw how to run bbs scripts using the command line. The bbs scripts themselves were simple in that they did not take any inputs. Often in cardiac simulation projects, the same program must be executed with a series of parameter values. In this section, we will see how to accomplish this using bash scripting. You may wish to use Perl or Python instead if you are already familiar with those scripting languages.
We use cell, 1D and 2D models based on the CRN human atrial cell model and discuss the inputs, the simulation script, what it does, the outputs, and how to visualise/what to do with the outputs. To run these simulations, we can go to the following directory in the Beatbox installation:
cd $HOME/beatbox/data/scripts/sequential/CRN_model
First, we run the CRN cell model to produce a train of action potentials. To do this, a bash script command is provided:
./runcrn0.sh
The above bash shell script (as with all bash shell scripts) is a text file consisting of various commands used to run our program. The above bash script contains the command:
$HOME/bin/Beatbox_SEQ crn0.bbs
This is the most basic of commands that will be used for running a
Beatbox simulation. However, as of now, lets discuss the function and
output of crn0.bbs. The bbs script stimulates the cell
model using 10 current pulses. It consists of calling the
binary $HOME/bin/Beatbox_SEQ and passing to it the bbs
simulation script, in this case
crn0.bbs. This bbs script declares the state
of the simulation, which consists of 1 cell. The periodic
stimulation, by means of a user defined current, is defined using
the k_func device. Each time step is solved using
the euler ODE solver device. The ASCII output for time
and voltage is generated using the sample device, and put
into an output file called crn0.vtg. The output from
this bbs script (called crn0.vtg, but you can rename it
to anything you want by editing the crn0.bbs file) is a 2
column record of the time and voltage. This output can be plotted
using gnuplot,
or SigmaPlot.
As you will see below, and in the full manual, arguments can be given
to the bbs script.
crn0.bbs.
crn0.bbs script starts with declaring and assigning values to
several simulation variables like neqn (number of equations in the cell
model), time step ht and others.
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
k_func device defines timing variables begin
(beginning of simulation), output (often and seldom), end (end of simulation),
and the time T in physical units.
k_func device defines the priodic pacing.
euler device is used to update the ODE model at
each time step.
sample device and written to a file
by the k_print device into the file called crn0.vtg, which can be
visualised using gnuplot.
Often, action potential or Ca2+ transient restitution is required in simulation studies. Action potential restitution consists of stimulating a cell model with several conditioning stimuli at a give basic cycle length, and then a final premature stimulus. The diastolic interval and action potential duration of the final excitation is recorded and AP features measured. To illustrate how action potential restitution can be computed, a bash shell script that loops over the premature stimulus interval is provided. To run the Beatbox restitution script, use the following bash script:
./restitutioncrn.sh
We now discuss the above shell script, as well as the Beatbox bbs
scripts for restitution that it uses
called crn0_rest.bbs. The above shell script,
unlike runcrn0.sh, introduces several aspects of how
Beatbox works. Firstly, several simulation variables, like the number
of conditioning stimuli (Nstim), and various file names
can be defined in the shell script in preparation of passing it to the
bbs program. Importantly, cell model parameters like gk1
and gcaL can also be defined here. Once all the
parameters are defined, they can be easily passed to the bbs script
as indicated in the restitutioncrn.sh shell script:
$HOME/bin/Beatbox_SEQ crn0_rest.bbs $Nstim $Period $fileName $fileName2 $repolarisation $gk1 $gcal
Now that the contents of the shell script are clear, let us discuss
the actual Beatbox bbs script, crn0_rest.bbs.
Firstly, it has been constructed to take several parameters as
input. The inputs to this specific bbs script are the number of
conditioning stimuli, the pacing period, the file name for voltage
trace, the file name for APD data, the amount of repolarisation at
which restitution is to be computed, and model parameters
(gk1 and gcaL). Passing of the
electrophysiological parameters is to show how diseased related to
electrophysiological can be simulated using Beatbox. The
program crn0_rest.bbs takes all these parameters and sets
up the simulation.
The stimulation protocol for the restitution is set up by means of a
k_func device where several pacing parameters are
defined. Further, the stimulus current amplitude and time profile are
defined using another call to k_func device. It then
solves the CRN model using the euler device. In
the .vtg files, output from voltage, and intra-cellular
ionic concentration profiles is provided using a combination
of sample and k_print devices. Then using a
combination of k_func, k_print,
and k_poincare devices, the APD at the user defined
repolarisation is measured as well as output to file. It is then
appended to the specified output data file. The output of the above
simulation can be visualised using gnuplot (or any other plotting
software). Contents of the vtg files (providing time traces of
voltage) are visualised using gnuplot as:
plot 'crn_basal0.vtg' u 1:2 w l
and those of the restitution as (.apd file):
plot 'crn_basal.apd' u 1:2 w lpHere we give just a brief outline of the 0D CRN restitution simulation script, please see the detailed comments in the file
crn0_rest.bbs.
crn0_rest.bbs script starts by assigning the input values to the script
to variables to be used in the simulation. For e.g. Nstim is assigned the second input
at command line.
crn0_rest.bbs script then declares and assigns values to
several simulation variables like neqn (number of equations in the cell
model), time step ht and others.
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
k_func device defines timing variables begin
(beginning of simulation), output (often and seldom), end (end of simulation),
time T in physical units, as well as stimulation flags stim and
penult.
k_func device defines the priodic pacing.
euler device is then used to update the ODE model at
each time step.
sample device and written to a file
by the k_print device into a user defined file which can be
visualised using gnuplot.
k_poincare device is used to measure the APD. The APD measurements are
written to file using k_print device which can be visualised using gnuplot.
Now we look at how to construct a 1D strand and initiate propagations
through the strand. Since we already know a few things about shell
scripting (see above), we will learn how to conduct conduction
velocity restitution in a 1D human atrial strand. Conduction velocity
restitution involves pacing the 1D strand with conditioning pulses (1
or more) and then applying a premature pulse. The conduction velocity
of this premature propagating excitation is then measured. To see how
this is done using Beatbox, use the bash
script runcrn1.sh and the bbs
script crn1.bbs. To simply run the simulation, use the
bash script command:
./runcrn1.sh
The contents of the above script are straightforward. You can set the
smallest and largest S2 (premature pulse), as well as the
output filename and values of a couple of model parameters if
simulating electrophysiologically diseased CV restitution. In this
shell script, the simulation actually runs with the command
$HOME/bin/Beatbox_SEQ crn1.bbs $S2 $fileName 0.09 0.1235
where the Beatbox_SEQ binary is given the crn1.bbs bbs
script, the value of S2, the output filename, and values of a couple
of model parameters, in this case gK1 and
gCaL. The crn1.bbs bbs program takes these
input parameters and starts by setting up the 1D model using
the state device. Several variables and parameters
required for the simulation are defined using the k_func
device. The actual computation for the diffusion is carried out using
the diff device, while the ODE is solved using
the euler device. A combination
of sample, k_poincare,
and k_func devices is used to measure the CV in the 1D
strand. The measured CV is written to a file with name crn1.cv.
This output can be examined easily as it is an ASCII text
file. Another output file, with file name specified by the user and
also in ASCII, is used to record the voltage distribution along the
strand. If this output file is called say crn1d500.vtg,
then it can be examined using gnuplot using the following commands:
set pm3d map splot 'crn1d500.vtg' matrix
Here we give just a brief outline of the simulation script, please see
the detailed comments in the file crn1.bbs.
crn1.bbs script starts with assigning input parameters
to simulation parameters.
state device to define the size
xmax*ymax*zmax of the medium and the number of dynamic
variables vmax that are going to be used.
beginning, ending, and pacing.
fhn0.bbs simulation, that is
the fhn0.rec file is used to generate the initial
conditions for the 1D simulation via the phase distribution method.
diff device is used to compute the Laplacian and
update the Neumann boundary conditions.
euler device is used to update the ODE model at each
time step.
sample, k_poincare and k_func
devices.
.cv file using the
record device.
An important part of cardiac simulations is to study the evolution of re-entrant waves. Beatbox has a unique method for inducing spiral and scroll waves precisely at a desired location in 2D and 3D models. Although this method may seem cumbersome at first sight, it saves an enormous amount of time and effort once the basics are set up. In comparison to the S1-S2 method which requires experimenting in case case (e.g. control, AF, HF, ...) to initiate spiral in the middle of the sheet, the phase distribution method can be used universally once the following cell and 1D records are established. The phase distribution method, allows the inducing of re-entry at a prescribed location. The details of the method can be found in the senior authors publications. The way in which Beatbox can be used to implement this method in sequential mode is as follows. The parallel variant is discussed in the next section.
First, the cell model is stimulated at a sufficiently rapid pacing
rate, and all dynamical variables during the last few excitations
recorded. In the scripts provided, the cell model is encoded in
pd_crn0.bbs and the bash script for running this bbs script is
pd_runcrn0.sh. It is run as:
./pd_crn0.sh
Running the above script will show some graphics output on screen at run time. Graphics output in sequential mode is another feature of Beatbox which allows examination of output visually at run time. The above shell script itself is quite simple and calls the Beatbox sequential program as:
$HOME/bin/Beatbox_SEQ pd_crn0.bbs
We now look at the bbs script pd_crn0.bbs.
In this bbs script, relevant parameters and variables are first
declared and initialised. The model is constructed using
the state device. The phase distribution method requires
fast pacing of the cell model, which is done by raising the voltage to
a high value each time it reaches close to its resting potential.
Such feedback stimulation ensures that all cell model variables are in
the oscillating state. The graphics window depicts the phase space
plot of voltage and gating variable oi in the CRN model
on the left, and the successive AP profiles on the right. The
graphical output is done using a combination
of screen, clock,
k_clock, k_draw and update
devices. The model is integrated using the euler
device. The output of this simulation is a record of all the model
variables for several pulses. It will appear as a data file
named pd_crn0.rec.
This pd_crn0.rec file forms input to the 1D strand model
simulation, which is run as:
./pd_crn1.sh
The 1D bbs script pd_crn1.bbs starts by setting up all
the relevant parameters and variables in the simulation, and also the
sets up the 1D model in Beatbox using the state
device. As in the 0-D simulation above, this bbs program is also set
up to show graphical output at run time. It shows the propagating
voltage distribution and the variable oi in the CRN model
as functions of space. The graphical output is generated using a
combination of screen, clock,
k_clock, k_plot and update
devices. The 1D record from the middle cell of the strand is generated
using sample, k_poincare
and k_func devices. It is written to file using the
record device. The output of this 1D simulation is a
record file called pd_crn1.rec.
The record of all dynamical variables from the middle of the strand during the final propagating excitation is used to distribute the phase of 1 excitation in an Archemedian spiral in a 2D setting, thus instantly initiating re-entry. After the 1D simulation executes successfully, the 2D simulation is executed using the script:
./pd_crn2.sh
This script creates output sub-directories as well as calls the bbs
program pd_crn2.bbs using the sequential Beatbox binary,
Beatbox_SEQ. The contents of pd_crn2.bbs
illustrates several features of the package. In common with all other
bbs scripts, pd_crn2.bbs starts by setting up the
simulation using variables, parameters, and the state
device. In particular, phase distribution method based initial
conditions are imposed using the 1D record data to initiate a spiral
wave at a desired location. The diffusion part of the problem is
solved using the diff device, while the ODE part is
solved using the euler device. Consecutive frames from the 2D
simulation are stored in a series of ppm files in
the ppm/ sub-directory.
The spiral wave tip at each time step is recorded in the file
spiral_tips.dat using the singz device. The
contents of this file can be visualised using gnuplot. Representative
AP profiles from various locations in the 2D sheet are provided in the
output file pd_crn2.samples, and the contents can again
be seen using gnuplot. Frames from the simulation are recorded in
sequentially numbered PPM files. The ppm files generated by the above
2D simulation are in a subdirectory called ppm. To
visualise the contents, of say crn2d_0001.ppm, we can use
netpbm as follows:
ppmtojpeg crn2_0001.ppm crn2_0001.jpg
The above command can also be put into a loop using shell scripting, or any other suitable method.
Each of these runs should exit legally without any error messages. If there are error messages, check:
$HOME/bin path is in your environment path (you
can use .bashrc for this if you are using the bash shell);
$HOME/beatbox/data/scripts/sequential/ directory.
./RunTest.sh
HECToR is really a subclass of the parallel platforms that you could run on - why make it so specific to HECToR?
To run tests on HECToR, you will need:
Beatbox;
The scripts are not generic enough - for instance they assume that whoever is running them will have access to the account id e203. I think it would be much better to tell people how to run the code as opposed to hiding it all in scripts.
All the scripts are provided in the directory:
$HOME/beatbox/data/scripts/parallel_Hector
Further, the submission of the test jobs is facilitated by means of 3 bash scripts that should be run interactively. To simulate a large 3D box using CRN kinetics, just run the bash script:
./bigbox_crn.sh
This bash script will:
$HOME/bin/Beatbox) to your work space in directories
called bigboxcrn_run2 and bigboxcrn_run2;
bigbox_crn.bbs to the two newly
created directories;
#PBS -A e203 and specify your
own valid account against which the execution time will be charged;
The status of your jobs can be checked using:
qstat -u my_user_name
Bash scripts for FHN and LRD kinetics are also provided
(bigbox_fhn.sh and bigbox_lrd.sh
respectively).
$HOME/beatbox/data/scripts/parallel_Hector/phasedbn_parallel/Using the submission assistant script given, submit the job to Hector queues as:
./submit_pdcrn2.sh
Visualisation of the 3D output is by means of the visualisation
package EZView. EZView can be obtained from:
The script for EZView is given in the Beatbox distribution:
$HOME/beatbox/data/scripts/viz3d/ppmz.task12
After working through this quick start guide, you may want to read the full manual. A full manual is available HERE. You can get in touch with the authors for support and provide your feedback:
You can also use this feedback form.