MUX EPI

Simultaneous Multi-Slice EPI at CNI

NOTE: This page is a stub. Please help us flesh it out!

Overview

The CNI, in collaboration with GE, has implemented simultaneous multi-slice EPI (also known as multiband EPI, multiplexed EPI, or, as we like to call it, "mux EPI"). We have functioning sequences for both gradient-echo (GRE) and spin-echo (SE) EPI. GRE-EPI is useful for BOLD imaging and SE-EPI is useful for diffusion imaging and other quantitative anatomical methods.

General Issues

Useful Parameters

• number of simultaneously-acquired bands (mux factor): How many slices to acquire simultaneously.
• inplane acceleration (arc factor): Determines the ky undersampling. Currently limited to an integer. E.g., 2 will acquire every other ky line.
• slice separation (mm): For a contiguous set of slices, this must equal (slice_thickness + gap) * num_slices. (Note that setting this to zero will automatically compute the separation needed for contiguous slices.)
• CAIPI z-blip flag: enables CAIPI z-blips (see Setsompop et. al. 2012)
• CAIPI FOV shift: controls the CAIPI field shift. In general, this should be set to 3 (or maybe 4 for higher mux factors)

Reference Images

The first few acquired images are fully-sampled and used as reference images for the reconstruction. It is critical that the subject not move during this calibration phase, or the whole dataset may be impossible to reconstruct without significant artifacts (if at all). The number of reference images depends on the mux and arc factors as well as the CV that controls the number of reference scan repetitions (stop_mux_cycling_rf1, exposed in the User CVs as "Number of calibration scans"). The number of TRs needed for the reference images is: arc * mux * num_mux_cycle. (num_mux_cycle default is 2).

Timing and Number of TRs

Here are some useful equations to keep in mind if you are setting up a mux sequence for an fMRI experiment that is n TRs long per run, not including calibration time (i.e., you want to have n usable TRs from a scan run):

• total number of TRs acquired = n + calibration TRs
• number of calibration TRs = mux * arc * num_mux_cycle (see Reference Images section)
• number of TRs in nifti = n + num_mux_cycle
• number in the phases per location field: n + mux * n_mux_cycle

For example, in order to have 100 usable TRs from a run with mux=3, arc=2, and num_mux_cycle=2, you would manually enter 106 in the phases per location field, the total scan time would automatically adjust to be 112 TRs, and your experiment should begin 12 TRs after you trigger the scan to begin. The nifti for this run would contain 102 volumes, the first two of which are the reconstructed calibration scans that should be skipped for bold analysis.

Reconstruction

The mux epi recon is started automatically by NIMS at the end of a mux scan. It can take anywhere from a few minutes to an hour per scan, depending on the resolution and number of TRs acquired.

(Describe Kangrong's recon: reference images, virtual coils, GRAPPA vs. SENSE)

Slice acquisition order

The multiband sequences acquire slices in either ascending or descending interleaved order, depending on which direction the slices were prescribed (the nifti header should indicate whether it's ascending or descending-- see the nifti faq for a description of the two orders). And, of course, for mux>1, multiple slices are acquired simultaneously. E.g., for a mux 3 scan with 14 muxed slices (that will result in 14*3=42 unmuxed slices), the acq. order is [1,3,5,7,9,11,13,2,4,6,8,10,12,14]. And mux slice 1 will get reconstructed as unmuxed slices [1,15,29], which are all acquired simultaneously. Likewise, mux slice 2 will get deconvolved into unmuxed slices [2,16,30]. And so on.

Here's an algorithm to compute the relative slice acquisition time within the TR:

   mux = 3
   nslices = 8
   tr = 1.0
   mux_slice_acq_order = range(0,nslices,2) + range(1,nslices,2)
   mux_slice_acq_time = [float(s)/nslices*tr for s in xrange(nslices)]
   unmux_slice_acq_order = [nslices*m+s for m in xrange(mux) for s in mux_slice_acq_order]
   unmux_slice_acq_time = mux_slice_acq_time * 3
   for acq,slice in zip(unmux_slice_acq_time,unmux_slice_acq_order):
       print "    slice %02d acquired at time %.3f sec" % (slice+1,acq)

   slice 01 acquired at time 0.000 sec
   slice 03 acquired at time 0.125 sec
   slice 05 acquired at time 0.250 sec
   slice 07 acquired at time 0.375 sec
   slice 02 acquired at time 0.500 sec
   slice 04 acquired at time 0.625 sec
   slice 06 acquired at time 0.750 sec
   slice 08 acquired at time 0.875 sec
   slice 09 acquired at time 0.000 sec
   slice 11 acquired at time 0.125 sec
   slice 13 acquired at time 0.250 sec
   slice 15 acquired at time 0.375 sec
   slice 10 acquired at time 0.500 sec
   slice 12 acquired at time 0.625 sec
   slice 14 acquired at time 0.750 sec
   slice 16 acquired at time 0.875 sec
   slice 17 acquired at time 0.000 sec
   slice 19 acquired at time 0.125 sec
   slice 21 acquired at time 0.250 sec
   slice 23 acquired at time 0.375 sec
   slice 18 acquired at time 0.500 sec
   slice 20 acquired at time 0.625 sec
   slice 22 acquired at time 0.750 sec
   slice 24 acquired at time 0.875 sec

SMS-GRE-EPI (muxarcepi)

(more here)

SMS-SE-EPI (muxepi2)

(more here)

Gallery of horrors

(show some common mux artifacts with suggested solutions)