SIMPSON version 3.1

Zdenek Tosner, Rasmus Andersen, Niels Chr. Nielsen, and Thomas Vosegaard

Released: March 25, 2011

Downloads:

• SIMPSON 3.1.0 for Mac. Read the installation instructions for help with the installation.
• SIMPSON 3.1.0 for Linux. Read the installation instructions for help with the installation.
• SIMPSON 3.1.0 for Windows. Read the installation instructions for help with the installation.
• Source 3.1.0 - Note that the source code has been reorganized omitting the configure script. Now it is just a simple makefile.

New features in version 3.0:

This section describes add-ons to the functionality of SIMPSON. All previous features are kept without any change except everything executes much faster for larger spin systems (more than 2 spins). Such speed up was gained thanks to replacing original matrix manipulations hard coded in SIMPSON by full use of BLAS and LAPACK pre-built (and performance optimized) libraries. Extra speed is achieved by implementing fast acquisition algorithms and parallelization.

Parallel calculations

There are implemented two ways of parallel calculations. The first one makes use of fork mechanism supported on linux and mac (not MS windows). The program automatically detects number of processor cores and starts appropriate number of instances. This number can be modified by setting the environment variable SIMPSON_NUM_CORES to a given number.

The second way is based on MPI and needs SIMPSON properly built from sources.  Before installing form sources, make sure the following prerequisites are installed:

• BLAS/CBLAS
• LAPACK
• TCL
• OpenMPI

According to the specific versions and flavors of these prerequisites, it may be necessary to adjust the makefile. The makefile directives below show how to include and link to these packages. To enable MPI, add '-I/path/to/mpi/include' to the include list, '-lmpi' to the library list, and '-DMPI' to the flags list, i.e.:

INCLUDES = -I/usr/include/tcl8.5 -I/usr/lib/openmpi/include
LIBRARIES = -lm -lgslcblas -llapack -ltcl8.5 -lmpi
FLAGS = -DMPI -c -O3

Now, type make to build SIMPSON. Once built, SIMPSON can be run with MPI using mpirun. Make sure to start as many MPI processes as there are processor cores. For instance, in a cluster setup with 8 machines, each equipped with 4 processor cores, one should start 8*4 processes (the fork mechanism from above is not used when using MPI):
mpirun -np 32 simpson <inputfile>

New direct acquisition method

Works for static as well as MAS simulations. Pulse sequence includes new command
acq_block {...}
which defines the whole acquisition period of the simulated experiment. It calculates the whole fid at once. In the curly braces one can define any pulse sequence applied during the acquisition. The sequence is coded using standard simpson commands but must obey certain rules.

• Static spectra: durations of pulses and delays must sum up to one dwell-time. (this may be released in coming versions, was not priority this time). Propagator of the dwell-time is diagonalized and re-used in the diagonal form.
• MAS: pulses and delays must be separable into durations of the dwell-time. Simpson then uses variant of COMPUTE algorithm for fid calculations (making use of Hamiltonian periodicity).

In the input file, use coding like this:

par {
      ...
      method   idirect
      ...
   }

proc pulseq {} {
    global par

   pulse ...
      ...

   acq_block { delay $dw }
   }

 for free precession, or

   acq_block { pulse $dw ...}

for decoupling on some channel, or

   acq_block { 
                 pulse dw/2 rf1 ...
                 pulse dw/2 rf2 ...
                 pulse dw/2 rf3 ...
                 pulse dw/2 rf4 ...
      }

for some periodic rf pulse sequence (rf1, rf2, rf3, rf4) repeated every two dwell-time periods (and that would work just for MAS at the moment). Here one should be careful with synchronization, when the pulse sequence has to be repeated many times to match MAS, efficiency is lost.

New version of g-COMPUTE

The original simpson did not allow for preparation of density matrix before acquisition. The spin state had to be independent of the g-angle when acquisition starts. This is now released, again using acq_block {} command. Pulse sequence in parenthesis has to have duration of one rotor period divided by the number of g-angles (this originates from ideas behind g-COMPUTE, only then efficient averaging can be used). However, spectral width does not need to be spin_rate*gamma_angles - it just needs to stay simply synchronized like in the example. The following code is possible

par {
      ...
      method           igcompute
      gamma_angles     10
      spin_rate        12000
      sw               spin_rate*gamma_angles/3
      ...
   }

proc pulseq {} {
      global par

   pulse ...
      ...
      acq_block { 
         delay [expr 1.0e6/$par(spin_rate) \
          /$par(gamma_angles)]
      }
   }

Some tricks cutting unnecessary operations has been used and this implementation is not only more general but also slightly faster (20% for 5 spins) than the original gcompute code.

General notes

• For safe calculations, use only one acq_block inside the pulseq. Think of applications where you would like to use it repeatedly and tell me. One obvious candidate is calculation of 2D spectra which is not implemented yet.
• Do not use acq_block inside any loop.
• At the moment, there are no error checks for pulseq code. Combinations of acq_block with original direct, gcompute and gammarep as well as combining idirect  and igcompute with original acq leads to undefined behavior.
• Inside the parenthesis of acq_block one can use also any variables defined in previous lines of pulseq code (I hope). This example should work:

  pulseq {} {
      global par
      set dw [expr 1.0e6/$par(sw)]
      acq_block { delay $dw }
   }

as well as this (but there is no advantage of doing it like this, actually it is recommended not to do so due to propagator synchronization with MAS)

   pulseq {} {
      global par
      delay [expr 1.0e6/$par(sw)]
      store 1
      reset
      acq_block { prop 1}
   }

• The new algorithms were developed with method names direct_new and gcompute2_new. It may be scrambled in error messages or even in input files. Please be patient, the SIMPSON code is not yet ready for stable 3.0 release…