KS_PHASER Struct Reference

#include <KSFoundation.h>

Data Fields
KS_TRAP	grad
float	fov
int	res
int	nover
int	R
int	nacslines
int	acsshift
float	areaoffset
int	numlinestoacq
int	linetoacq [KS_MAX_PHASEDYN]
int	shotresalign

Detailed Description

Composite sequence object for phase encoding using a trapezoid gradient

KS_PHASER

KS_PHASER is a composite sequence object that is used for phase encoding. 2D Cartesian imaging requires one KS_PHASER, while 3D Cartesian imaging requires two different KS_PHASER objects, each with its own FOV, resolution and acceleration. The KS_PHASER object is set up by calling ks_eval_phaser(), but before calling this function, the following fields in KS_PHASER must be set up:

1. .fov: The desired image Field-of-View (FOV) in [mm] along the sequence board one intends to place the KS_PHASER on (typically YGRAD, for 3D also ZGRAD)
2. .res: The number of pixels within the FOV
3. .nover: Number of overscans. If 0, a full-Fourier k-space will be set up. If > 0, partial Fourier will be set up (shorter scan time) where .nover number of extra k-space lines beyond .res/2. If < 0, partial Fourier will be set up, but with flipped k-space coverage. The total number of samples will be .res/2 + .nover. Values of .nover between 1 and about 16 should be avoided since half Fourier reconstruction methods will likely have difficulties.
4. .R: The parallel imaging acceleration factor
5. .nacslines: If .R > 1, .nacslines is the number of calibration lines around k-space center for parallel imaging calibration.
6. .areaoffset: It is possible to embed a static gradient area in the phase encoding functionality of KS_PHASER. This is useful for 3D imaging, where the area needed for the rephaser of the slice select gradient can be put into .areaoffset. This makes the KS_PHASER object to act as both slice rephaser and slice phaser encoding gradient, which can shorten TE.

If the KS_PHASER object is initialized with KS_INIT_PHASER, .nover, .nacslines and .areaoffset will be zero, and .R will be 1 (steps 3-6 can be skipped)

Based on the information in the KS_PHASER object, ks_eval_phaser() will set up the .grad trapezoid (KS_TRAP), .numlinestoacq, and the array .linetoacq[]. The field .numlinestoacq is an integer corresponding to the actual number of lines to acquire, which is also the number of relevant elements in .linetoacq[], containing the complete list of phase encoding lines to acquire (honoring partial Fourier, parallel imaging acceleration and ACS lines).

In the @pg section, the ks_pg_phaser() function is used to place the KS_PHASER object on a certain board at some position in time (.ampscale must be 1.0 for ks_pg_phaser()).

To acquire a given phase encoding line in scan(), ks_scan_phaser_toline() is called. For a rephaser gradient, which should undo the phase encoding gradient after the readout, the function ks_scan_phaser_fromline() is used.

It is a requirement that there is a (sequence generating) function in the @pg section (containing the ks_pg_phaser() call(s)) that can be run on both HOST and TGT. This function should be called once in cveval() (after ks_eval_phaser() and other ks_eval_***() functions). ks_pg_phaser() will throw an error on TGT if this has not been done.

Example

@ipgexport (HOST)

KS_SEQ_CONTROL seqctrl;
KS_PHASER myphaseenc = KS_INIT_PHASER;

cveval() {

  myphaseenc.fov = opfov * opphasefov; // opfov is the FOV menu ([mm]), and opphasefov the phase/freq FOV ratio in the UI
  myphaseenc.res = opyres * opphasefov; // opyres is the Phase resolution menu in the UI (usually defined as resolution for a full FOV)

  ks_eval_phaser(&myphaseenc, "myphaseenc");
}

@pg

KS_SEQLOC tmploc = KS_INIT_SEQLOC;

tmploc.pos = 3ms; // place the KS_PHASER object at position 3ms
tmploc.board = YGRAD;
ks_pg_phaser(&myphaseenc, tmploc, &seqctrl); // instance #0 of this KS_PHASER (used as phase encoding before the readout)

tmploc.pos = 12ms; // place the KS_PHASER object at position 12ms (after some readout not shown here)
ks_pg_phaser(&myphaseenc, tmploc, &seqctrl); // instance #1 of this KS_PHASER (used to rewind the phase after the readout)


@rsp (TGT)
for (i = 0; i < myphaseenc.numlinestoacq; i++) {
  ks_scan_phaser_toline(  &myphaseenc, 0, myphaseenc.linetoacq[i]); // 0th instance of KS_PHASER (from k-space center TO the desired line)
  ks_scan_phaser_fromline(&myphaseenc, 1, myphaseenc.linetoacq[i]); // 1st instance of KS_PHASER (from the desired line back to k-space center)
}

Field Documentation

grad

KS_TRAP grad

Trapezoid set up by ks_eval_phaser()

fov

float fov

Field-of-View (FOV) in the phase encoding direction, in [mm]. Must be set before calling ks_eval_phaser()

res

int res

Number of pixels in the FOV. Must be set before calling ks_eval_phaser()

nover

int nover

Number of overscan lines without parallel imaging (i.e. # lines beyond half k-space for partial Fourier). (default: 0)

R

int R

1 [default]: Parallel imaging acceleration factor

nacslines

int nacslines

Number of extra lines around k-space center for calibration, when R > 1

acsshift

int acsshift

areaoffset

float areaoffset

Shift of the ACS region along the phase encoding direction For embedding e.g. a static slice rephaser in the phase encoding gradient (useful in 3D imaging)

numlinestoacq

int numlinestoacq

Number of lines to acquire (honoring partial Fourier and parallel imaging acceleration (R >= 1). Number of values in linetoacq[]

linetoacq

int linetoacq[KS_MAX_PHASEDYN]

Array holding the phase encoding lines to acquire. 0:first line, (.res - 1): last line

shotresalign

int shotresalign

For e.g. EPI, we want 'res' to be divisible by 2*R so that it becomes divisible by #interleaves and each ETL becomes even

---

The documentation for this struct was generated from the following file:

• KSFoundation.h