KSFoundation  [April-2021]
A platform for simpler EPIC programming on GE MR systems
KS_SELRF Struct Reference

#include <KSFoundation.h>

Data Fields

KS_RF rf
float slthick
float crusherscale
KS_TRAP pregrad
KS_TRAP grad
KS_TRAP postgrad
KS_WAVE gradwave
KS_SMS_INFO sms_info

Detailed Description

Composite sequence object for slice-selective RF


The KS_SELRF composite sequence object contains a KS_RF object and three KS_TRAP objects and an optional KS_WAVE object. The purpose of the KS_SELRF object is to provide a complete functionality for slice selection. Depending on the declared role (.rf.role), and the fields like .slthick, the KS_TRAP objects will be set up differently in ks_eval_selrf(). The KS_TRAP fields in KS_SELRF are:

  • .pregrad: A gradient that may be present before the RF slice selection
  • .grad: The slice selection gradient that is applied at the same time as the KS_RF RF pulse
  • .postgrad: A gradient that may be present after the RF slice selection

The following values of .rf.role are allowed:

  • KS_RF_ROLE_EXC, indicating an RF excitation role. ks_eval_selrf() will in this case:
    • disable .pregrad
    • make .grad to have a plateautime equal to the RF duration (.rf.rfwave.duration) and the gradient amplitude (.grad.amp [G/cm]) will be set to the proper value, depending on the BW (.rf.bw) and slice thickness (.slthick). Note that the slice thickness often needs to be made larger to compensate from slice narrowing due to multiple RF pulses. GE uses gscale_rfX CVs with values often between 0.8-0.9. Dividing with this number gives a thicker slice in the calculations. The field .grad.description will have a ".trap" suffix added to it
    • make .postgrad to have a gradient area that rephases the slice. This is dependent on the isodelay of the RF pulse (.rf.iso2end) and the slice select gradient amplitude (.grad.amp). The field .postgrad.description will have a ".reph" suffix added to it
  • KS_RF_ROLE_REF, indicating an RF refocusing role. ks_eval_selrf() will in this case:
    • use .pregrad to make the left crusher (never bridged with slice selection). The size of the crusher can be controlled by .crusherscale. The field .pregrad.description will have a ".LC" suffix added to it
    • do the same with .grad as done for KS_RF_ROLE_EXC
    • use .postgrad to make the right crusher (never bridged with slice selection). The size of the crusher can be controlled by .crusherscale. The field .postgrad.description will have a ".RC" suffix added to it
  • KS_RF_ROLE_INV, indicating an RF inversion role. ks_eval_selrf() will in this case:
    • disable .pregrad
    • do the same with .grad as done for KS_RF_ROLE_EXC
    • disable .postgrad
  • KS_RF_ROLE_SPSAT, indicating a spatial RF saturation. ks_eval_selrf() will in this case:
    • disable .pregrad
    • do the same with .grad as done for KS_RF_ROLE_EXC
    • use .postgrad to make a gradient spoiler (never bridged with slice selection). The size of the spoiler can be controlled by .crusherscale. The field .postgrad.description will have a ".spoiler" suffix added to it

The role KS_RF_ROLE_CHEMSAT, indicates a non-slice selective, chemically selective, RF (usually fat-sat). ks_eval_selrf() will in this case throw an error since no gradients should be used

With ks_eval_selrf(), the default slewrate and maximum gradient amplitude are used for the KS_TRAP objects, and it is possible (with few applications) to play out three simultaneous gradients during slice selection. For oblique slices, the maximum gradient strength will however be reduced. For high-bandwidth RF pulses and thin slices, it may be beneficial to allow for a larger maximum gradient strength for oblique slice planes. This can be done by instead calling:

  • ks_eval_selrf1(): where one promises that only one (1) gradient (trapezoid) will be played out at a time during slice selection (i.e. no other gradients are active on other boards during this time). This is usually the case anyway for slice selection, hence the ks_eval_selrf1() function could be used as standard
  • ks_eval_selrf2(): where one promises that maximum two (2) gradients will be played out at a time during slice selection. This gives a maxiumum gradient amplitude that lies in between that of ks_eval_selrf() and ks_eval_selrf1()
  • ks_eval_selrf_constrained(): where full control is given to the slewrate and the maximum gradient strength

Using a custom gradient wave for slice selection

To support e.g. VERSEd RF excitations, a custom gradient wave can be used.

If .gradwave.res > 0, ks_eval_selrf() will disable .grad and use .gradwave instead. When .rf.role = KS_RF_ROLE_EXC, the rephasing gradient area (in .postgrad) will also be calculated by integrating the gradient waveform from the RF isocenter to the end. .gradwave must be created before calling ks_eval_selrf() using either ks_eval_wave() or ks_eval_wave_file(), and the units must be in [G/cm]. To further scale the amplitude of .gradwave before calling ks_pg_selrf(), consider e.g. ks_wave_multiplyval(), ks_wave_absmax(), and possibly ks_wave_addval().

In the @pg section, if .gradwave.res > 0, ks_pg_selrf() will place out the .gradwave instead of .grad. As all KS_WAVE objects are double buffered, it is possible to swap out the gradient waveform in `scan() if necessary.

It is a requirement that there is a (sequence generating) function in the @pg section (containing the ks_pg_selrf() call(s)) that can be run on both HOST and TGT. This function should be called once in cveval() (after ks_eval_selrf() and other ks_eval_***() functions). ks_pg_selrf() will throw an error on TGT if this has not been done. An error will also occur on TGT if the RF pulse and the associated KS_SEQ_CONTROL struct governing the sequence (module) has not undergone RF scaling using GEReq_eval_rfscaling().


@ipgexport (HOST)
cveval() {
myselexc.rf = exc_3dfgre; // const KS_RF in KSFoundation_GERF.h. .role already set to KS_RF_ROLE_EXC in exc_3dfgre
myselexc.rf.flip = opflip; // FA value from UI
myselexc.slthick = opslquant; // Slice thickness value from UI
ks_eval_selrf(&myselexc, "myselexc"); // selective RF excitation, including the slice rephaser
// ... see KS_SEQ_CONTROL and KS_SEQ_COLLECTION for details on RF scaling and SAR ...
tmploc.pos = 1ms; // Place the beginning of the first gradient belonging to the KS_SELRF object here
tmploc.board = ZGRAD; // Place the gradients on ZGRAD
ks_pg_selrf(&myselexc, tmploc, &seqctrl); // instance #0 of the RF pulse, beginning at 1ms into the sequence
@rsp (TGT)
// Change frequency of the RF pulse to excite the correct slice location (scan_info[].tloc contains the mm offset from isocenter)
ks_scan_selrf_setfreqphase(&myselexc, 0, scan_info[slice], myrfphase);

Field Documentation

◆ rf

KS_RF rf


◆ slthick

float slthick

Slice thickness in [mm] (often needs to be scaled up 10-15% to really achieve the expected thickness, depending on number of RF pulses)

◆ crusherscale

float crusherscale

Relative area of the refocusing crusher gradients. Only used when .rf.role = KS_RF_ROLE_REF. Default: 1.0

◆ pregrad

KS_TRAP pregrad

Pre Slice Select gradient. KS_RF_ROLE_REF: Left Crusher. KS_RF_ROLE_EXC/KS_RF_ROLE_INV: Off (Off state given by pregrad.duration = 0)

◆ grad

KS_TRAP grad

Slice Select gradient

◆ postgrad

KS_TRAP postgrad

Post Slice Select gradient. KS_RF_ROLE_REF: Right Crusher. KS_RF_ROLE_EXC: Slice rephaser. KS_RF_ROLE_SPSAT: Spoiler. KS_RF_ROLE_INV: Off. (Off state given by postgrad.duration = 0)

◆ gradwave

KS_WAVE gradwave

Optional external gradient instead of using .grad. Default: Off (Off state given by gradwave.res = 0)

◆ sms_info

KS_SMS_INFO sms_info

Information about the pulses SMS properties

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