KS_SELRF Struct Reference

#include <KSFoundation.h>

Data Fields
KS_RF	rf
float	slthick
float	crusher_dephasing
int	bridge_crushers
float	pregrad_area_offset
float	postgrad_area_offset
KS_TRAP	pregrad
KS_TRAP	grad
KS_TRAP	postgrad
KS_WAVE	gradwave
int	grad2rf_start
int	rf2grad_end
KS_SMS_INFO	sms_info

Detailed Description

Composite sequence object for slice-selective RF

KS_SELRF

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. 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. 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. .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().

Example

@ipgexport (HOST)

KS_SEQ_CONTROL seqctrl;
KS_SELRF myselexc = KS_INIT_SELRF;

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

}

@pg

  KS_SEQLOC tmploc = KS_INIT_SEQLOC;

  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

See KS_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)

crusher_dephasing

float crusher_dephasing

Crusher gradient dephasing over slice thickness [cycles]. Only used when .rf.role = KS_RF_ROLE_REF. Default: 2.0. If = -1 then negative flowcomp z crushing is implemented

bridge_crushers

int bridge_crushers

Bridges crushers for refocusing pulses by creating a single gradwave containing both crushers and slice-select gradients (1=on, 0=off)

pregrad_area_offset

float pregrad_area_offset

[(G/cm)*us], pregrad.area - pregrad_area_offset

postgrad_area_offset

float postgrad_area_offset

[(G/cm)*us], postgrad.area - postgrad_area_offset

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)

grad2rf_start

int grad2rf_start

time [us] from start of gradients to start of rf

rf2grad_end

int rf2grad_end

time [us] from end of rf to end of gradients

sms_info

KS_SMS_INFO sms_info

Information about the pulses SMS properties

---

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

• KSFoundation.h