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] |

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:

`.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)`.res`

: The number of pixels within the FOV`.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.`.R`

: The parallel imaging acceleration factor`.nacslines`

: If`.R > 1`

,`.nacslines`

is the number of calibration lines around k-space center for parallel imaging calibration.`.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.

@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)

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)

}

KS_TRAP grad |

Trapezoid set up by ks_eval_phaser()

float fov |

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

int res |

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

int nover |

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

int R |

1 [default]: Parallel imaging acceleration factor

int nacslines |

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

int acsshift |

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)

int numlinestoacq |

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

int linetoacq[KS_MAX_PHASEDYN] |

Array holding the phase encoding lines to acquire. 0:first line, (`.res`

- 1): last line

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