HowTo - Hardware Limits

Home

The hardware limits interface was updated in the latest KSFoundation update. This was done in order to switch to a less conservative gradient heating model, the same that GE is using in the product sequences.

In the new interface the user is expected to write a function with a standard signature that will configure and play, using ks_scan_playsequence(), a series of modules representative of the heating load of the whole sequence. For instance, the implementation in ksfse.e looks like the following

STATUS ksfse_gradheat_play(const INT max_encode_mode, int nargs, void **args) {
  (void) nargs;
  (void) args;

  /* Sat */
  ks_scan_playsequence(&kssat.seqctrl);

  /* Inversion */
  if (ANYINVERSION) {
    ks_scan_playsequence(&ksfse_inv.seqctrl);
  }

  /* main */
  if (max_encode_mode == AVERAGE_POWER) {
    ks_scan_phaser_average(&ksfse.phaseenc, INSTRALL);
  } else {
    ks_scan_phaser_max(&ksfse.phaseenc, INSTRALL);
  }
  ks_scan_playsequence(&ksfse.seqctrl);

  return SUCCESS;
}

where up to three modules are played. Depending on the value of max_encode_mode, the various modules need to be configured differently. If it is equal to AVERAGE_POWER all gradients need to be scaled to the root mean square amplitude scaling calculated over the whole scan. Otherwise, when max_encode_mode is equal to MAXIMUM_POWER, all modules need to be configured in such a way to represent the maximum load on the gradient subsystem. In the case of KS_PHASER, these operations can be done with the helper functions: ks_scan_phaser_average and ks_scan_phaser_max. Note that, the same module can be played more than once with different gradient configurations if needed.

The above function is then used in the following way:

int newtime = 0;
const int time = ks_eval_getduration(seqcollection, ksfse_gradheat_play, 0, NULL);
status = ks_eval_hwlimits(&newtime, seqcollection, &loggrd, ksfse_gradheat_play, 0, NULL);
KS_RAISE(status);

if (newtime > time) {
  ks_eval_seqctrl_setduration(&ksfse.seqctrl, ksfse.seqctrl.duration + newtime - time);
  ks_dbg("hw limits active: %d -> %d", time, newtime);
}

Here, we calculate the total duration of all modules played in ksfse_gradheat_play(). Then we run the hardware models, both greadient heat and SAR, and get back a minimum time for all modules to be played without exceeding the hardware limits. If necessary, we increase the durations of one or more of the modules of interest in order to meet this minimum duration. In this case the whole penalty, if any, is added to the main module's duration. Note that, the hardware limits need to be evaluated after all relevant modules are set up (both eval and pg) but before any calculation regarding sequence timing like TR, number of slices per TR or inversion time. If using the generic looping modules (ksscan.h, ksinversion.h), those need to be evaluated after also.

Home