ksfse.e: FSE sequence

Data Structures
struct	KSFSE_SEQUENCE

Macros
#define	KSFSE_MINHNOVER   6
#define	KSFSE_MIN_SSI_TIME   200
#define	KSFSE_MAXTHICKFACT   3.0
#define	KSFSE_INIT_SEQUENCE   {KS_INIT_SEQ_CONTROL, KS_INIT_READTRAP, KS_INIT_TRAP, KS_INIT_PHASER, KS_INIT_PHASER, KS_INIT_TRAP, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF};
#define	KSFSE_PHASEENCODING_MEMORYPOOL_SIZE   25000

Enumerations
enum	{ KSFSE_RECOVERY_OFF, KSFSE_RECOVERY_T1WOPT, KSFSE_RECOVERY_FAST }

Functions
STATUS	cvinit (void)
STATUS	cveval (void)
STATUS	my_cveval (void)
STATUS	cvcheck (void)
STATUS	predownload (void)
STATUS	pulsegen (void)
STATUS	mps2 (void)
STATUS	aps2 (void)
STATUS	scan (void)
	abstract ("FSE [KSFoundation]")
	psdname ("ksfse")
void	ksfse_eval_TEmenu (int esp, int maxte, int etl, double optechono)
STATUS	ksfse_calc_echo (double *bestecho, double *optecho, KS_PHASER *pe, int TE, int etl, int esp)
STATUS	ksfse_pg (int start_time)
KS_CORESLICETIME	ksfse_scan_coreslice (const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic)
KS_CORESLICETIME	ksfse_scan_coreslicegroup (const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic)
KS_CORESLICETIME	ksfse_scan_irslice (const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic)
s64	ksfse_scan_scanloop ()
STATUS	ksfse_scan_seqstate (SCAN_INFO slice_pos, KS_PHASEENCODING_SHOTCOORDS shot_coords)
const KSSCAN_LOOP_CONTROL *	ksfse_get_loop_ctrl ()
void	ksfse_init_imagingoptions (void)
STATUS	ksfse_init_UI (void)
STATUS	ksfse_eval_UI ()
int	ksfse_eval_esp (int *min90_180, int *min180_echo, int slicecheck, KSFSE_SEQUENCE *seq)
int	ksfse_eval_optimalkxnover (KSFSE_SEQUENCE *seq)
float	ksfse_eval_rfstretchfactor (float patientweight, float flipangle, int tailoredrf_flag)
STATUS	ksfse_eval_setuprfpulses_2D (KSFSE_SEQUENCE *seq, float crusher_dephasing)
STATUS	ksfse_eval_setuprfpulses_3D (KSFSE_SEQUENCE *seq)
STATUS	ksfse_eval_setuprfpulses_recovery (KSFSE_SEQUENCE *seq)
int	ksfse_eval_ssitime ()
STATUS	ksfse_eval_setupobjects ()
STATUS	ksfse_eval_TErange ()
void	ksfse_set_kspace_design (KS_KSPACE_DESIGN *kdesign)
void	ksfse_set_slicetiming_design (KS_SLICETIMING_DESIGN *slicetiming_design)
STATUS	ksfse_set_loop_control_design (KSSCAN_LOOP_CONTROL_DESIGN *loop_design)
STATUS	ksfse_set_inversion_loop_control_design (KSINV_LOOP_CONTROL_DESIGN *invloopctrl_design)
STATUS	ksfse_eval_inversion (KS_SEQ_COLLECTION *seqcollection)
STATUS	ksfse_eval_sat (KS_SEQ_COLLECTION *seqcollection)
STATUS	ksfse_gradheat_play (const INT max_encode_mode, int nargs, void **args)
STATUS	ksfse_eval_loops (KS_SEQ_COLLECTION *seqcollection)
STATUS	ksfse_eval_scantime (KS_SEQ_COLLECTION *seqcollection)
STATUS	ksfse_update_UI ()
STATUS	ksfse_predownload_plot (KS_SEQ_COLLECTION *seqcollection)
STATUS	ksfse_predownload_setrecon ()
void	ksfse_scan_rf_off ()
void	ksfse_scan_rf_on ()
STATUS	ksfse_scan_init (void)
void	ksfse_scan_prescanloop (int nloops, int dda)

Variables
KS_SEQ_COLLECTION	seqcollection
float	ksfse_excthickness = 0
float	ksfse_gscalerfexc = 0.9
float	ksfse_flipexc = 90.0 with {0.0, 180.0, 90.0, VIS, "Excitation flip angle [deg]",}
float	ksfse_spoilerarea = 2000.0 with {0.0, 20000.0, 5000.0, VIS, "ksfse spoiler gradient area",}
float	rf_stretch_rfexc = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF excitation pulse if > 1.0",}
int	ksfse_inflowsuppression = 0 with {0, 1, 0, VIS, "In-flow Suppression [0:OFF, 1:ON]",}
float	ksfse_inflowsuppression_mm = 0.0 with {0.0, 100.0, 0.0, VIS, "In-flow suppression [mm]",}
int	ksfse_vfa = 1 with {0, 1, 1, VIS, "Variable flip angles [0:OFF, 1:ON]",}
float	ksfse_crusher_dephasing = 6.0 with {0.0, 100.0, 6.0, VIS, "scaling of crusher gradient area [cycles]",}
float	ksfse_gscalerfref = 0.9
int	ksfse_slicecheck = 0 with {0, 1, 0, VIS, "move readout to z axis for slice thickness test",}
float	rf_stretch_rfref = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF refocusing pulses if > 1.0",}
float	rf_stretch_all = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch all RF pulses if > 1.0",}
int	ksfse_recovery = KSFSE_RECOVERY_OFF with {KSFSE_RECOVERY_OFF, KSFSE_RECOVERY_FAST, KSFSE_RECOVERY_OFF, VIS, "Recovery. 0:off 1:T1wopt 2:T2fast", }
float	rf_stretch_rfrecovery = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF recovery pulses if > 1.0",}
int	ksfse_kxnover_min = KSFSE_MINHNOVER with {KSFSE_MINHNOVER, 512, KSFSE_MINHNOVER, VIS, "Min mum kx overscans for minTE",}
int	ksfse_kxnover = 32 with {KSFSE_MINHNOVER, 512, 32, VIS, "Num kx overscans for minTE",}
int	ksfse_rampsampling = 0 with {0, 1, 0, VIS, "Rampsampling [0:OFF 1:ON]",}
int	ksfse_extragap = 0 with {0, 100ms, 0, VIS, "extra gap between readout [us]",}
int	ksfse_etlte = 1 with {0, 1, 1, VIS, "ETL controls TE",}
float	ksfse_xcrusherarea = 100.0 with {0.0, 1000.0, 100.0, VIS, "x crusher area for readout",}
int	ksfse_esp = 0 with {0, 1000000, 0, VIS, "View-only: Echo spacing in [us]",}
int	ksfse_noph = 0 with {0, 1, 0, VIS, "Turn OFF phase encoding [0:Disabled 1:Enabled]",}
int	ksfse_minacslines = 12 with {0, 512, 12, VIS, "Minimum ACS lines for ARC",}
int	ksfse_minzacslines = 12 with {0, 512, 12, VIS, "Minimum z ACS lines for ARC",}
int	ksfse_pos_start = KS_RFSSP_PRETIME with {0, , KS_RFSSP_PRETIME, VIS, "us from start until the first waveform begins",}
int	ksfse_ssi_time = KSFSE_MIN_SSI_TIME with {50, , KSFSE_MIN_SSI_TIME, VIS, "time from eos to ssi in intern trig",}
int	ksfse_dda = 2 with {0, 200, 2, VIS, "Number of dummy scans for steady state",}
int	ksfse_debug = 1 with {0, 100, 1, VIS, "Write out e.g. plot files (unless scan on HW)",}
int	ksfse_imsize = KS_IMSIZE_NATIVE with {KS_IMSIZE_NATIVE, KS_IMSIZE_MIN256, KS_IMSIZE_MIN256, VIS, "img. upsamp. [0:native 1:pow2 2:min256]"}
int	ksfse_abort_on_kserror = FALSE with {0, 1, 0, VIS, "Hard program abort on ks_error [0:OFF 1:ON]",}
int	ksfse_mintr = 0 with {0, 20s, 0, VIS, "Min TR (ms) [0: Disabled]",}
int	ksfse_maxtr = 0 with {0, 40s, 0, VIS, "Max TR (ms) [0: Disabled]",}
KSFSE_SEQUENCE	ksfse = KSFSE_INIT_SEQUENCE
KSSCAN_LOOP_CONTROL	ksfse_loopctrl = KSSCAN_INIT_LOOP_CONTROL
KSINV_MODULE	ksfse_inv = KSINV_INIT_MODULE
KSINV_LOOP_CONTROL	ksfse_inv_loopctrl = KSINV_INIT_LOOP_CONTROL
KS_PHASEENCODING_COORD	ksfse_phaseencoding_memorypool [KSFSE_PHASEENCODING_MEMORYPOOL_SIZE] = {KS_INIT_PHASEENCODING_COORD}
KS_KSPACE_ACQ	kacq = KS_INIT_KSPACE_ACQ
int	sequence_iopts []

Detailed Description

MR-contrasts supported

• T1-w
• T2-w
• T1-FLAIR
• T2-FLAIR
• T2-STIR

Features

• ASSET & ARC with GE recon
• SE (etl=1), Multi-shot FSE, Single-shot FSE
• Fat-Sat
• Spatial (Graphical) Sat
• Single & dual inversion (FLAIR-block, sliceahead-IR, simple IR)
• In range auto-TR support
• 2D & 3D data acquisition

Macro Definition Documentation

KSFSE_MINHNOVER

#define KSFSE_MINHNOVER   6

KSFSE_MIN_SSI_TIME

#define KSFSE_MIN_SSI_TIME   200

KSFSE_MAXTHICKFACT

#define KSFSE_MAXTHICKFACT   3.0

KSFSE_INIT_SEQUENCE

#define KSFSE_INIT_SEQUENCE   {KS_INIT_SEQ_CONTROL, KS_INIT_READTRAP, KS_INIT_TRAP, KS_INIT_PHASER, KS_INIT_PHASER, KS_INIT_TRAP, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF};

KSFSE_PHASEENCODING_MEMORYPOOL_SIZE

#define KSFSE_PHASEENCODING_MEMORYPOOL_SIZE   25000

num elements allocated for unique phase encodes

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
KSFSE_RECOVERY_OFF
KSFSE_RECOVERY_T1WOPT
KSFSE_RECOVERY_FAST

{KSFSE_RECOVERY_OFF, KSFSE_RECOVERY_T1WOPT, KSFSE_RECOVERY_FAST};

Function Documentation

cvinit()

STATUS cvinit

(

void

)

                    {
  STATUS status;

  status = GEReq_cvinit();
  KS_RAISE(status);

  /* reset debug file ./ks_debug.txt (SIM) or /usr/g/mrraw/ks_debug.txt (HW) */
  ks_dbg_reset();

  /* Imaging Options buttons */
  ksfse_init_imagingoptions();

  /* Setup UI buttons */
  status = ksfse_init_UI();
  KS_RAISE(status);

  return SUCCESS;

} /* cvinit() */

cveval()

STATUS cveval

(

void

)

                    {
  /*
   cveval() is called 37+ times per UI button push on the MR system, while cvcheck() is only called once.
   For a faster execution we have a my_cveval() function that is called in cvcheck() instead
   */

  return SUCCESS;

} /* cveval() */

my_cveval()

STATUS my_cveval

(

void

)

                       {
  STATUS status;

  ks_init_seqcollection(&seqcollection);

  /* Link the memory pool for the phase encoding plans */
  status = ks_phaseencoding_memorypool_init(ksfse_phaseencoding_memorypool,
                                            KSFSE_PHASEENCODING_MEMORYPOOL_SIZE);
  KS_RAISE(status);

  status = GEReq_cveval();
  KS_RAISE(status);

  /* User Interface updates & opuserCV sync */
  status = ksfse_eval_UI();
  KS_RAISE(status);

  /* Setup sequence objects */
  status = ksfse_eval_setupobjects();
  KS_RAISE(status);

  /* Calculate minimum (and maximum TE), and sometimes ETL */
  status = ksfse_eval_TErange();
  KS_RAISE(status);

  /* Run the sequence once (and only once after ksfse_eval_setupobjects()) in cveval() to
     get the sequence duration and the number of object instances (for grad/rf limits in GEReq...limits()) */
  status = ksfse_pg(ksfse_pos_start);
  KS_RAISE(status);

  status = ks_eval_addtoseqcollection(&seqcollection, &ksfse.seqctrl);
  KS_RAISE(status);

  /* Add the passpacket seqctrl to the seqcollection */
  status = ks_eval_addtoseqcollection(&seqcollection, &seqctrl_passpack);
  KS_RAISE(status);


  /*--------- Begin: Additional sequence modules -----------*/

  /* Sat */
  status = ksfse_eval_sat(&seqcollection);
  KS_RAISE(status);

  /* Inversion */
  status = ksfse_eval_inversion(&seqcollection);
  KS_RAISE(status);

  /*--------- End: Additional sequence modules -----------*/


  /* Min TR, #slices per TR, RF/gradient heating & SAR  */
  status = ksfse_eval_loops(&seqcollection);
  KS_RAISE(status);

  /* RF scaling across sequence modules */
  status = GEReq_eval_rfscaling(&seqcollection);
  KS_RAISE(status);

  /* scan time */
  status = ksfse_eval_scantime(&seqcollection);
  KS_RAISE(status);

  return SUCCESS;

} /* my_cveval() */

cvcheck()

STATUS cvcheck

(

void

)

                     {
  STATUS status;

  status = my_cveval();
  KS_RAISE(status);

  status = GEReq_cvcheck();
  KS_RAISE(status);

  status = ksfse_update_UI();
  KS_RAISE(status);

  abort_on_kserror = ksfse_abort_on_kserror;

  return SUCCESS;

} /* cvcheck() */

predownload()

STATUS predownload

(

void

)

                           {
  STATUS status;

  status = GEReq_predownload();
  KS_RAISE(status);

  status = GEReq_predownload_prescan_options((RG_CAL_MODE_E) RG_CAL_MODE_LOW_FIXED);
  KS_RAISE(status);
  
  /* Set filter slot # for SCAN, APS2, MPS2 */
  GEReq_predownload_setfilter(&ksfse.read.acq.filt);

  const KSSCAN_LOOP_CONTROL *loop_control = ksfse_get_loop_ctrl();

  /* slice ordering */
  /* The following GE globals must be set appropriately:
     data_acq_order[], rsp_info[], rsprot[], rsptrigger[]. This is a must for a main pulse sequence */
  if (KS_3D_SELECTED) {
    status = GEReq_predownload_store_sliceplan3D(opslquant, opvquant);
  } else {
    status = GEReq_predownload_store_sliceplan(loop_control->slicetiming.slice_plan);
  }  
  KS_RAISE(status);

  /* generic rh-vars setup */
  GEReq_predownload_setrecon_readphase(&ksfse.read, &ksfse.phaseenc, KS_3D_SELECTED ? &ksfse.zphaseenc : NULL, \
                                       ksfse_imsize, KS_GERECON * (rhrecon < 1000) /* online recon if rhrecon < 1000 */);
  GEReq_predownload_setrecon_annotations_readtrap(&ksfse.read, ksfse_extragap);
  GEReq_predownload_setrecon_voldata(opfphases, loop_control->slicetiming.slice_plan); /* opfphases = number of volumes */

  /* further sequence specific recon settings that have not been set correctly at this point */
  status = ksfse_predownload_setrecon();
  KS_RAISE(status);

  /* plotting of sequence modules and slice timing to disk */
  ksfse_predownload_plot(&seqcollection);


  return SUCCESS;

} /* predownload() */

pulsegen()

STATUS pulsegen

(

void

)

                        {

  GEReq_pulsegenBegin();

  /* Link the memory pool for the phase encoding plans */
  ks_phaseencoding_memorypool_init(ksfse_phaseencoding_memorypool,
                                   KSFSE_PHASEENCODING_MEMORYPOOL_SIZE);

  /* Main sequence */
  ksfse_pg(ksfse_pos_start);
  KS_SEQLENGTH(seqcore, ksfse.seqctrl);

  /* Sat */
  kssat_pg(&kssat);
  if (kssat.seqctrl.duration > 0) {
    KS_SEQLENGTH(seqsat, kssat.seqctrl);
  }

  /* Inversion sequence modules */
  if (ANYINVERSION) {
    ksinv_pg(&ksfse_inv);
    KS_SEQLENGTH(seqinv, ksfse_inv.seqctrl);
    KS_SEQLENGTH(seqtrfill, ksfse_inv_loopctrl.seqctrl_filltr); /* FLAIR BLOCK requires 2 sequence modules */
  }

  GEReq_pulsegenEnd();

  buildinstr(); /* load the sequencer memory */

  return SUCCESS;

} /* pulsegen() */

mps2()

STATUS mps2

(

void

)

                  {

  rspent = L_MPS2;
  strcpy(psdexitarg.text_arg, "mps2");

  if (ksfse_scan_init() == FAILURE)
    return rspexit();

  ksfse_scan_prescanloop(30000, ksfse_dda);

  rspexit();

  return SUCCESS;

} /* mps2() */

aps2()

STATUS aps2

(

void

)

                  {

  rspent = L_APS2;
  strcpy(psdexitarg.text_arg, "aps2");

  if (ksfse_scan_init() == FAILURE)
    return rspexit();

  ksfse_scan_prescanloop(100, ksfse_dda);

  rspexit();

  return SUCCESS;

} /* aps2() */

scan()

STATUS scan

(

void

)

                  {

  rspent = L_SCAN;
  strcpy(psdexitarg.text_arg, "scan");

  if (ksfse_scan_init() == FAILURE)
    return rspexit();

  ksfse_scan_scanloop();

  GEReq_endofscan();

  rspexit();

  return SUCCESS;

} /* scan() */

abstract()

abstract

(

"FSE "

[KSFoundation]

)

psdname()

psdname

(

"ksfse"

)

ksfse_eval_TEmenu()

void ksfse_eval_TEmenu	(	int	esp,
		int	maxte,
		int	etl,
		double	optechono
	)

Sets up the TE menu based on echo spacing, max TE, ETL and the optimal echo index

optechono is the echo index in range [0, ETL-1] that is in the center of the FSE train. If the TE corresponding to this index is chosen, optimal image quality is achieved with minimal FSE ghosting.

For ETLs > 6, this value is given first in the TE menu, meaning that if the user chooses the first field in the TE menu this will have the same effect as setting "ETL controls TE", and the remaining TE fields in the menu are the ones straddling the optimal TE.

For ETLs in range [2,6], MinFull is the first, followed by the optimal TE.

For ETL = 1, which corresponds to a conventional Spin-Echo, the user can choose only between MinTE (partial kx Fourier) and MinFullTE. Manual type-in is not allowed for ETL = 1.

Parameters

[in]	esp	Echo Spacing in [us]
[in]	maxte	Maximum TE in [us]
[in]	etl	Echo Train Length
[in]	optechono	Optimal echo index in range [0, ETL-1]

Returns

void

                                                                      {
  int allow_typein = 1;

  if (etl > 6) {
    pite1val2 = optechono * esp; /* best TE for image quality (minimal T2-blurring, ghosting) */
    pite1val3 = (optechono - 2) * esp;
    pite1val4 = (optechono - 1) * esp;
    pite1val5 = (optechono + 1) * esp;
    pite1val6 = (optechono + 2) * esp;
  } else if (etl > 1) {
    pite1val2 = PSD_MINFULLTE;
    pite1val3 = (optechono - 2) * esp;
    pite1val4 = (optechono - 1) * esp;
    pite1val5 = optechono * esp;
    pite1val6 = (optechono + 1) * esp;
  } else { /* etl = 1 */
    allow_typein = 0;
    pite1val2 = PSD_MINIMUMTE;
    pite1val3 = PSD_MINFULLTE;
    pite1val4 = 0;
    pite1val5 = 0;
    pite1val6 = 0;
  }

  if (etl > 1) {
    pite1nub = allow_typein + 2 +
               4  * (pite1val3 >= esp && pite1val3 <= maxte) +
               8  * (pite1val4 >= esp && pite1val4 <= maxte) +
               16 * (pite1val5 >= esp && pite1val5 <= maxte) +
               32 * (pite1val6 >= esp && pite1val6 <= maxte);
  } else {
    pite1nub = 6; /* only MinTE & MinFull */
  }

} /* ksfse_eval_TEmenu() */

ksfse_calc_echo()

STATUS ksfse_calc_echo	(	double *	bestecho,
		double *	optecho,
		KS_PHASER *	pe,
		int	TE,
		int	etl,
		int	esp
	)

ksfse_pg()

STATUS ksfse_pg

(

int

start_time

)

The ksfse (main) pulse sequence

This is the main pulse sequence in ksfse.e using the sequence objects in KSFSE_SEQUENCE with the sequence module name "ksfsemain" (= ksfse.seqctrl.description)

Return values

STATUS

SUCCESS or FAILURE

                                {

  STATUS status;
  KS_SEQLOC tmploc = KS_INIT_SEQLOC;
  int readpos_start = KS_NOTSET;
  int spoiler_pos = KS_NOTSET;
  int i;

  if (start_time < KS_RFSSP_PRETIME) {
    return ks_error("%s: 1st arg (pos start) must be at least %d us", __FUNCTION__, KS_RFSSP_PRETIME);
  }


  /*******************************************************************************************************
   *  RF Excitation
   *******************************************************************************************************/
  tmploc.ampscale = 1.0;
  tmploc.pos = RUP_GRD(start_time + KS_RFSSP_PRETIME);
  tmploc.board = ZGRAD;

  /* N.B.: ks_pg_selrf()->ks_pg_rf() detects that ksfse.selrfexc is an excitation pulse
     (ksfse.selrfexc.rf.role = KS_RF_ROLE_EXC) and will also set ksfse.seqctrl.momentstart
     to the absolute position in [us] of the isocenter of the RF excitation pulse */
  status = ks_pg_selrf(&ksfse.selrfexc, tmploc, &ksfse.seqctrl);
  KS_RAISE(status);

  /*******************************************************************************************************
   *  X dephaser (between 90 and 1st 180)
   *******************************************************************************************************/
  if (ksfse_slicecheck) {
    tmploc.pos = ksfse.seqctrl.momentstart + ksfse.selrfexc.rf.iso2end + ksfse.selrfexc.grad.ramptime;
    tmploc.board = ZGRAD;
  } else {
    tmploc.pos = ksfse.seqctrl.momentstart + ksfse.selrfexc.rf.iso2end;
    tmploc.board = XGRAD;
  }
  status = ks_pg_trap(&ksfse.readdephaser, tmploc, &ksfse.seqctrl);
  KS_RAISE(status);

  /*******************************************************************************************************
  *  Generate the refocusing flip angles
  -------------------------------------------------------------------------------------------------------*/
  double flip_angles[512]; /* rad */

  if (ksfse_vfa) {

    STATUS status = ks_pg_fse_flip_angle_taperoff(flip_angles,
                                                  opetl,
                                                  ksfse.selrfref1st.rf.flip, ksfse.selrfref2nd.rf.flip, ksfse.selrfref.rf.flip,
                                                  80.0, /* degrees */
                                                  opflair != OPFLAIR_INTERLEAVED);
    KS_RAISE(status);
  }



  /*******************************************************************************************************
  *  FSE train: Begin
  -------------------------------------------------------------------------------------------------------*/
  for (i = 0; i < opetl; i++) {

    /* Selective RF Refocus with left (pregrad.) and right (postgrad.) crushers */
    tmploc.board = ZGRAD;
    if (i == 0) {
      /* special case for 1st pulse with at least a smaller left crusher */
      tmploc.pos = ksfse.seqctrl.momentstart + i*ksfse_esp + ksfse_esp/2 - ksfse.selrfref1st.rf.start2iso - ksfse.selrfref1st.grad2rf_start;

      if (ksfse_vfa)
        tmploc.ampscale = flip_angles[i] / ksfse.selrfref1st.rf.flip;

      status = ks_pg_selrf(&ksfse.selrfref1st, tmploc, &ksfse.seqctrl);
      KS_RAISE(status);
      tmploc.ampscale = 1;

    } else if (i == 1) {
      tmploc.pos = ksfse.seqctrl.momentstart + i*ksfse_esp + ksfse_esp/2 - ksfse.selrfref2nd.rf.start2iso - ksfse.selrfref2nd.grad2rf_start;

      if (ksfse_vfa)
        tmploc.ampscale = flip_angles[i] / ksfse.selrfref2nd.rf.flip;

      status = ks_pg_selrf(&ksfse.selrfref2nd, tmploc, &ksfse.seqctrl);
      KS_RAISE(status);
      tmploc.ampscale = 1;

    } else {
      tmploc.pos = ksfse.seqctrl.momentstart + i*ksfse_esp + ksfse_esp/2 - ksfse.selrfref.rf.start2iso - ksfse.selrfref.grad2rf_start;

      if (ksfse_vfa)
        tmploc.ampscale = flip_angles[i] / ksfse.selrfref.rf.flip;

      status = ks_pg_selrf(&ksfse.selrfref, tmploc, &ksfse.seqctrl);
      KS_RAISE(status);
      tmploc.ampscale = 1;

    }

    /* ksfse_esp dependent time at beginning of readout ramp */
    readpos_start = ksfse.seqctrl.momentstart + (i + 1) * ksfse_esp - ksfse.read.time2center;

    /*******************************************************************************************************
    *  Readouts
    *******************************************************************************************************/
    tmploc.pos = readpos_start;
    if (ksfse_slicecheck)
      tmploc.board = ZGRAD;
    else
      tmploc.board = XGRAD;
    status = ks_pg_readtrap(&ksfse.read, tmploc, &ksfse.seqctrl);
    KS_RAISE(status);

    /*******************************************************************************************************
    *  Phase encoding dephasers & rephasers
    *******************************************************************************************************/
    tmploc.board = YGRAD;
    tmploc.pos = readpos_start + ksfse.read.acqdelay - ksfse.phaseenc.grad.duration;
    status = ks_pg_phaser(&ksfse.phaseenc, tmploc, &ksfse.seqctrl); /* instance 2*i */
    KS_RAISE(status);
    tmploc.pos = readpos_start + ksfse.read.grad.duration - ksfse.read.acqdelay;
    status = ks_pg_phaser(&ksfse.phaseenc, tmploc, &ksfse.seqctrl); /* instance 2*i + 1 */
    KS_RAISE(status);

    /*******************************************************************************************************
    *  Z phase encoding dephasers & rephasers (3D)
    *******************************************************************************************************/
    if (ksfse.zphaseenc.grad.duration > 0) {
      tmploc.board = ZGRAD;
      tmploc.pos = readpos_start + ksfse.read.acqdelay - ksfse.zphaseenc.grad.duration;
      status = ks_pg_phaser(&ksfse.zphaseenc, tmploc, &ksfse.seqctrl); /* instance 2*i */
      KS_RAISE(status);
      tmploc.pos = readpos_start + ksfse.read.grad.duration - ksfse.read.acqdelay;
      status = ks_pg_phaser(&ksfse.zphaseenc, tmploc, &ksfse.seqctrl); /* instance 2*i + 1 */
      KS_RAISE(status);
    }

  } /* opetl */

  /*------------------------------------------------------------------------------------------------------
   *  FSE train: End
   *******************************************************************************************************/

  /*******************************************************************************************************
   * Post-ETL forced recovery: T1-w Optimization / T2 fast Recovery
   *******************************************************************************************************/
  if (ksfse_recovery) {

    int lastReadoutCenter = ksfse.seqctrl.momentstart + opetl * ksfse_esp;

    /* Place extra refocusing pulse */
    tmploc.board = ZGRAD;
    tmploc.pos = lastReadoutCenter + ksfse_esp/2 - ksfse.selrfrecoverref.rf.start2iso - ksfse.selrfrecoverref.grad2rf_start;
    tmploc.ampscale = (ksfse_vfa) ? flip_angles[opetl-1] / ksfse.selrfrecoverref.rf.flip : 1;

    status = ks_pg_selrf(&ksfse.selrfrecoverref, tmploc, &ksfse.seqctrl);
    KS_RAISE(status);

    /* Place rewinder of previous readout in order to get back to the center of k-space */
    tmploc.pos = lastReadoutCenter + ksfse_esp - ksfse.selrfrecover.rf.start2iso - ksfse.readdephaser.duration;
    tmploc.ampscale = 1;
    if (ksfse_slicecheck) {
      tmploc.board = ZGRAD;
      tmploc.pos -= ksfse.selrfrecover.grad.ramptime;
    } else {
      tmploc.board = XGRAD;
    }
    status = ks_pg_trap(&ksfse.readdephaser, tmploc, &ksfse.seqctrl);
    KS_RAISE(status);

    /* Place excitation pulse */
    tmploc.board = ZGRAD;
    tmploc.pos = lastReadoutCenter + ksfse_esp - ksfse.selrfrecover.rf.start2iso - ksfse.selrfrecover.grad2rf_start;

    if (ksfse_recovery == KSFSE_RECOVERY_FAST) {
      tmploc.ampscale = -1;
    } else { /* = KSFSE_RECOVERY_T1WOPT */
      tmploc.ampscale = 1;
    }
    status = ks_pg_selrf(&ksfse.selrfrecover, tmploc, &ksfse.seqctrl);
    KS_RAISE(status);
    tmploc.ampscale = 1;

    /* spoiler pos */
    spoiler_pos = tmploc.pos + ksfse.selrfrecover.grad2rf_start + ksfse.selrfrecover.rf.rfwave.duration + ksfse.selrfrecover.rf2grad_end;

  } else {

    /* spoiler pos */
    spoiler_pos = ksfse.seqctrl.momentstart + opetl * ksfse_esp + ksfse.read.grad.duration - ksfse.read.time2center - ksfse.read.acqdelay + ksfse.phaseenc.grad.duration;

  } /* ksfse_recovery */

  /*******************************************************************************************************
   *  Gradient spoiler on Y
   *******************************************************************************************************/
  tmploc.board = YGRAD;
  tmploc.pos = spoiler_pos;
  tmploc.ampscale = 1;
  status = ks_pg_trap(&ksfse.spoiler, tmploc, &ksfse.seqctrl);
  KS_RAISE(status);
  tmploc.pos += ksfse.spoiler.duration;


 /*******************************************************************************************************
   *  Set the minimal sequence duration (ksfse.seqctrl.min_duration) by calling
   *  ks_eval_seqctrl_setminduration()
   *******************************************************************************************************/

  /* make sure we are divisible by GRAD_UPDATE_TIME (4us) */
  tmploc.pos = RUP_GRD(tmploc.pos);

#ifdef HOST_TGT
  /* On HOST only: Sequence duration (ksfse.seqctrl.ssi_time must be > 0 and is added to ksfse.seqctrl.min_duration in ks_eval_seqctrl_setminduration() */
  ksfse.seqctrl.ssi_time = ksfse_eval_ssitime();
  ks_eval_seqctrl_setminduration(&ksfse.seqctrl, tmploc.pos); /* tmploc.pos now corresponds to the end of last gradient in the sequence */
#endif

  return SUCCESS;

} /* ksfse_pg() */

ksfse_scan_coreslice()

KS_CORESLICETIME ksfse_scan_coreslice	(	const SCAN_INFO *	slice_pos,
		KS_DYNAMIC_STATE *	dynamic
	)

Plays out one slice for the ksfse sequence module in real time during scanning

This function updates the waveforms, and plays out, the ksfse sequence module. The low-level function call startseq(), which actually starts the realtime sequence playout is called from within ks_scan_playsequence(), which in addition also returns the time to play out that sequence module (see time += ...).

After each call to ks_scan_playsequence(), ks_plot_slicetime() is called to add slice-timing information for later HTML plotting of the sequence. As scanning is performed in real-time and may fail if interrupted, ks_plot_slicetime() will return quietly if it detects both IPG (TGT) and PSD_HW (on the MR scanner).

Common for all coreslice functions for any psd is the return of a KS_CORESLICETIME struct, which contains the time take to play out one slice (.duration) and the time from the start of the coreslice to the (.referencetimepoint) used to define the excitation location of the coreslice. Here this is simply ksfse.seqctrl.momentstart as there are no other embedded sequence modules played out inside this function. If any sequence module is added inside this function before/after ks_scan_playsequence(&ksfse.seqctrl), the KS_CORESLICETIME struct needs be updated accordingly.

Parameters

[in]	slice_pos	Position of the slice to be played out (one element in the global ks_scan_info[] array)
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions

Returns

coreslicetime KS_CORESLICETIME containing the time taken in [us] to play out one slice and the moment start of the slice

                                                                                             {
  int i;
  float tloc = 0.0;
  KS_PHASEENCODING_COORD fake_coord = KS_INIT_PHASEENCODING_COORD;
  SCAN_INFO slice_pos_updated;

  if (slice_pos != NULL) {
    /* uncomment to make transformations in the logical read-phase-slice coordinate system, using your own
    logic (e.g. radial or propeller applications), here just rotating by 30 degrees in-plane
    float rotz = 30.0;
    ks_mat4_setgeometry(dynamic->Mlogical, 0, 0, 0, 0, 0, rotz);
    Mphysical is useful for prospective motion correction implementations as it operates in X-Y-Z coords
    but should be left as the identity matrix otherwise
    */
    ks_scan_update_slice_location(&slice_pos_updated, *slice_pos, dynamic->Mphysical, dynamic->Mlogical);
    tloc = slice_pos_updated.optloc;

    ksfse_scan_rf_on();
    KS_PHASEENCODING_SHOTCOORDS dummy_shotcoords = KS_INIT_PHASEENCODING_SHOTCOORDS;
    ksfse_scan_seqstate(slice_pos_updated, (ksfse_noph != PSD_ON) ? dynamic->shot_coords : dummy_shotcoords);
  } else {
    ksfse_scan_rf_off(); /* false slice, shut off RF pulses */
  }

  /* There is no compressed bam since DV26, however impact on product recon with SENSE is unclear */
  /* ASSET case triggered by R > 1 and no ACS lines */
  const int dabview_factor = (ksfse.phaseenc.R > 1 && ksfse.phaseenc.nacslines == 0) ?
    ksfse.phaseenc.R /* compressed BAM without empty non-acquired lines */ :
    1 /* normal */;

  /* data routing control */
  TYPDAB_PACKETS acqflag = slice_pos != NULL ? DABON : DABOFF;
  if ((dynamic->prescan || !dynamic->force_acq) && (dynamic->shot < 0 || dynamic->average < 0)) {
    acqflag = DABOFF;
  }
  const int dabop = (dynamic->average <= 0) ? DABSTORE : DABADD; /* replace or add to data */
  const int center_echo = opte / ksfse_esp - 1;

  for (i = 0; i < ksfse.read.acq.base.ngenerated; i++) {
    /* N.B.: Looping over ksfse.read.acq.base.ngenerated corresponds to:
       HOST: No looping since ksfse.read.acq.base.ngenerated is 0 on HOST
       TGT: ETL.
       This protects calls to loaddab() on HOST
    */
    KS_PHASEENCODING_COORD coord =
      dynamic->shot_coords.entries || i < dynamic->shot_coords.num_encodes ?
      dynamic->shot_coords.entries[i] : fake_coord;

    const int dabview = coord.ky >= 0 ?
      coord.ky/dabview_factor : KS_NOTSET;    

    TYPDAB_PACKETS psc_acqflag = i == center_echo ? acqflag : DABOFF;

    loaddab(&ksfse.read.acq.echo[i], dynamic->sltimeinpass, 0, dabop, dabview + 1,
            dynamic->prescan ? psc_acqflag : acqflag,
            PSD_LOAD_DAB_ALL); /* see epicfuns.h for alternatives to loaddab() */

  } /* etl */

  KS_CORESLICETIME slicetime = KS_INIT_CORESLICETIME;

  slicetime.referencetimepoint = ksfse.seqctrl.momentstart;
  slicetime.duration += ks_scan_playsequence(&ksfse.seqctrl);

  ks_plot_slicetime(&ksfse.seqctrl, 1, &tloc, opslthick, slice_pos == NULL ? KS_PLOT_NO_EXCITATION : KS_PLOT_STANDARD);

  return slicetime; /* in [us] */

} /* ksfse_scan_coreslice() */

ksfse_scan_coreslicegroup()

KS_CORESLICETIME ksfse_scan_coreslicegroup	(	const SCAN_INFO *	slice_pos,
		KS_DYNAMIC_STATE *	dynamic
	)

Function to run for scan to execute one slice of the ksfse sequence module with optional sat module

With the use of generic scan loops (ksscan.cc:ksscan_scanloop()) performing the actual scan in ksfse_scan_scanloop(), using

• KSSCAN_LOOP_CONTROL (ksfse_loopctrl)
• KS_DYNAMIC_STATE (dynamic)
• KS_CORESLICETIME (coreslice)

one needs to create the psd-specific function in this file to play out one slice of one or more sequence modules This is that function, which must take (const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic) as the two input arguments, and return a KS_CORESLICETIME struct. This to match the various ksscan_****loop() functions in ksscan.cc, used to run the scan.

Unlike ksfse_scan_coreslice(), which only plays the main sequence (ksfse), this function also plays other sequence modules. For now, this is only the kssat sequence module, which is played out before the main sequence, if active.

Parameters

[in]	slice_pos	Pointer to the SCAN_INFO struct corresponding to the current slice to be played out
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions

Returns

coreslicetime KS_CORESLICETIME containing the time taken in [us] to play out one slice and the moment start of the slice

                                                                                                  {
  KS_CORESLICETIME coreslicetime = KS_INIT_CORESLICETIME;
  int premainseq_duration = 0;

  /* Sat */
  premainseq_duration += kssat_scan(slice_pos, dynamic, &kssat);

  /* Main */
  coreslicetime = ksfse_scan_coreslice(slice_pos, dynamic);

  coreslicetime.duration += premainseq_duration;
  coreslicetime.referencetimepoint += premainseq_duration;

  return coreslicetime;

} /* ksfse_scan_coreslicegroup() */

ksfse_scan_irslice()

KS_CORESLICETIME ksfse_scan_irslice	(	const SCAN_INFO *	slice_pos,
		KS_DYNAMIC_STATE *	dynamic
	)

                                                                                           {

  return ksinv_scan_irslice(&ksfse_inv, slice_pos, dynamic);

} /* ksfse_scan_irslice() */

ksfse_scan_scanloop()

s64 ksfse_scan_scanloop

(

)

Plays out all volumes and passes of a single or multi-pass scan

This function is called from ksfse.e:scan(), which corresponds to the actual SCAN button press in the UI.

If inversion is used, the function calls ksinv_scan_scanloop(), where ksfse_inv_loopctrl is used to control the the scan looping. For non-inversion scans, ksscan_scanloop() is called, where ksfse_loopctrl is used to control the scan looping in both cases.

Returns

scantime Total scan time in [us]

                          {
  s64 time = 0;

  if (!ANYINVERSION) {
    time += ksscan_scanloop(&ksfse_loopctrl, NULL, ksfse_scan_coreslicegroup);
  } else {
    time += ksinv_scan_scanloop(&ksfse_inv_loopctrl, NULL, ksfse_scan_coreslicegroup, ksfse_scan_irslice);
  }

  return time; /* in [us] */

} /* ksfse_scan_scanloop() */

ksfse_scan_seqstate()

STATUS ksfse_scan_seqstate	(	SCAN_INFO	slice_pos,
		KS_PHASEENCODING_SHOTCOORDS	shot_coords
	)

Sets the current state of all ksfse sequence objects at every ksfse playout in scan

This function sets the current state of all ksfse sequence objects being part of KSFSE_SEQUENCE, incl. gradient amplitude changes, RF freq/phases and receive freq/phase based on current slice position and phase encoding indices for a given sequence playout in ksfse_scan_coreslice() during scan.

Parameters

[in]	slice_pos	Position of the slice to be played out (one element in the ks_scan_info[] array)
[in]	shot_coords	KS_PHASEENCODING_SHOTCOORDS with list of phase encoding indices for current shot

Return values

STATUS

SUCCESS or FAILURE

                                                                                         {
  (void) slice_pos;
  (void) shot_coords;
  int i;
  float rfphase = 0.0;
  KS_PHASEENCODING_COORD fake_coord = KS_INIT_PHASEENCODING_COORD;

  ks_scan_rotate(slice_pos);

  ks_scan_selrf_setfreqphase(&ksfse.selrfexc,    0,        slice_pos, rfphase /* [deg] */);
  ks_scan_selrf_setfreqphase(&ksfse.selrfref1st, INSTRALL, slice_pos, rfphase + 90 /* [deg] */);
  ks_scan_selrf_setfreqphase(&ksfse.selrfref2nd, INSTRALL, slice_pos, rfphase + 90 /* [deg] */);
  ks_scan_selrf_setfreqphase(&ksfse.selrfref,    INSTRALL, slice_pos, rfphase + 90 /* [deg] */);
  if (ksfse_recovery) {
    ks_scan_selrf_setfreqphase(&ksfse.selrfrecoverref, INSTRALL, slice_pos, rfphase + 90 /* [deg] */);
    ks_scan_selrf_setfreqphase(&ksfse.selrfrecover, 0, slice_pos, rfphase /* [deg] */);
  }

  /* FOV offsets (by changing freq/phase of ksfse.read) */
  for (i = 0; i < opetl; i++) {

    KS_PHASEENCODING_COORD coord =
      shot_coords.entries || i < shot_coords.num_encodes ?
      shot_coords.entries[i] : fake_coord;

    ks_scan_phaser_toline(&ksfse.phaseenc,   0 + 2 * i, coord.ky); /* dephaser */
    ks_scan_phaser_fromline(&ksfse.phaseenc, 1 + 2 * i, coord.ky); /* rephaser */

    float ky_centred;
    if (coord.ky < 0) {
      ky_centred = 0.0f;
    } else {
      ky_centred = (float)coord.ky - (float)(ksfse.phaseenc.res - 1) / 2.0f;
    }

    if (KS_3D_SELECTED) {
     ks_scan_phaser_toline(&ksfse.zphaseenc,  0 + 2 * i, coord.kz); /* dephaser */
     ks_scan_phaser_fromline(&ksfse.zphaseenc, 1 + 2 * i, coord.kz); /* rephaser */

     float zfovratio = (opslquant * opslthick) / opfov;
     float zchop_phase = 0.0;
     float kz_centred;
     if (coord.kz < 0) {
       kz_centred = 0.0f;
     } else {
       kz_centred = (float)coord.kz - (float)(ksfse.zphaseenc.res - 1) / 2.0f;
     }
     if (oparc && (coord.kz % 2)) {
       /* GEs ARC recon ignores RHF_ZCHOP bit in 'rhformat', but expects 3D data to be z-chopped for proper slice sorting.
          In GERequired.e:GEReq_predownload_setrecon_voldata(), RHF_ZCHOP is unset by default. In combination with
          that we do not do zchop for non-ARC scans (incl ASSET), this works well. But for ARC scans, we must zchop. That is,
          we add 180 phase to every odd kz encoded line, which is the same as a final z fftshift in the image domain */
       zchop_phase = 180.0;
     }
     ks_scan_offsetfov3D(&ksfse.read, i, slice_pos, ky_centred, opphasefov, kz_centred, zfovratio, rfphase + zchop_phase);
    } else {
      ks_scan_offsetfov(&ksfse.read, i, slice_pos, ky_centred, opphasefov, rfphase);
    }

  } /* etl */

  /* Turn off T1-w opt. in DDAs */
  if ((ksfse_recovery) && (!shot_coords.entries)) {
    ks_scan_rf_off(&ksfse.selrfrecover.rf, 0);
    ks_scan_rf_off(&ksfse.selrfrecoverref.rf, 0);
  }

  return SUCCESS;

} /* ksfse_scan_seqstate() */

ksfse_get_loop_ctrl()

const KSSCAN_LOOP_CONTROL * ksfse_get_loop_ctrl

(

)

Function to automatically switch between inverision and standard loop control

To save if statments in the code, this function returns the loop control in use depending on inversion is on or off.

Return values

STATUS

SUCCESS or FAILURE

                                                 {
  return ANYINVERSION ?
    &ksfse_inv_loopctrl.loopctrl : &ksfse_loopctrl;

} /* ksfse_get_loop_ctrl() */

ksfse_init_imagingoptions()

void ksfse_init_imagingoptions

(

void

)

Initial handling of imaging options buttons and top-level CVs at the PSD type-in pages

Returns

void

                                     {
  int numopts = sizeof(sequence_iopts) / sizeof(int);

  psd_init_iopt_activity();
  activate_iopt_list(numopts, sequence_iopts);
  enable_iopt_list(numopts, sequence_iopts);

  /* Imaging option control functions (using PSD_IOPT_ZIP_512 as example):
    - Make an option unchecked and not selectable: disable_ioption(PSD_IOPT_ZIP_512)
    - Make an option checked and not selectable:   set_required_disabled_option(PSD_IOPT_ZIP_512)
    - Remove the imaging option:                   deactivate_ioption(PSD_IOPT_ZIP_512)
  */

  cvset(opptsize, 2, 4, 4, ""); /* EDR */
  set_required_disabled_option(PSD_IOPT_EDR); /* always use EDR, don't change */

  cvmax(opimode, PSD_3DM);

  /* Button accept control */
  cvmax(opepi, PSD_OFF); /* don't allow EPI selection */
  cvmax(opfast, PSD_ON);
  cvmax(opssfse, PSD_ON);
  cvmax(opflair, OPFLAIR_INTERLEAVED);
  cvmax(optlrdrf, PSD_ON);
  cvmax(opfr, PSD_ON);

  /* Exlude different inversion types */
  set_incompatible(PSD_IOPT_T2FLAIR, PSD_IOPT_T1FLAIR);
  set_incompatible(PSD_IOPT_IR_PREP, PSD_IOPT_T1FLAIR);
  set_incompatible(PSD_IOPT_T2FLAIR, PSD_IOPT_IR_PREP);

  if (KS_3D_SELECTED) {
    pidefexcitemode = NON_SELECTIVE;
    piexcitemodenub = 1 + 2 /* + 4 FOCUS */;
    cvmax(opexcitemode, NON_SELECTIVE);

    /* For now, 3D is not compatible with: */
    deactivate_ioption(PSD_IOPT_T1FLAIR);
    deactivate_ioption(PSD_IOPT_T2FLAIR);
    deactivate_ioption(PSD_IOPT_IR_PREP);
    deactivate_ioption(PSD_IOPT_TLRD_RF);
  }

#ifdef SIM
  oppseq = PSD_SE;
  setexist(oppseq, PSD_ON);
  opfast = PSD_ON;
  setexist(opfast, PSD_ON);
  opirmode = PSD_OFF; /* default interleaved slices */
  setexist(opirmode, PSD_ON);
#endif

} /* ksfse_init_imagingoptions() */

ksfse_init_UI()

STATUS ksfse_init_UI

(

void

)

Initial setup of user interface (UI) with default values for menus and fields

Return values

STATUS

SUCCESS or FAILURE

                           {

  /* IR always in interleaved mode */
  if (oppseq == PSD_IR) {
    cvoverride(opirmode, PSD_OFF, PSD_FIX_ON, PSD_EXIST_ON);
  }

  acq_type = TYPSPIN; /* loadrheader.e rheaderinit: sets eeff = 1 */

  /* rBW */
  cvmin(oprbw, 2);
  cvmax(oprbw, 250.0);
  pircbnub  = 31; /* number of variable bandwidth */
  if (opssfse == PSD_ON) {
    pidefrbw = 62.50 * (cffield / 30000.0);
  } else {
    pidefrbw = 41.67 * (cffield / 30000.0);
  }
  pircbval2 = 31.25 * (cffield / 30000.0);
  pircbval3 = 41.67 * (cffield / 30000.0);
  pircbval4 = 50.00 * (cffield / 30000.0);
  pircbval5 = 62.50 * (cffield / 30000.0);
  pircbval6 = 83.33 * (cffield / 30000.0);
  cvdef(oprbw, pidefrbw);
  oprbw = _oprbw.defval;
  pircb2nub = 0; /* no second bandwidth option */

  /* NEX */
  pinexnub = 63;
  if (opssfse == PSD_ON) {
    cvdef(opnex, 0.6);
    cvmin(opnex, 0.55);
    cvmax(opnex, 100);
    pinexval2 = 0.55;
    pinexval3 = 0.575;
    pinexval4 = 0.60;
    pinexval5 = 0.625;
    pinexval6 = 0.65;
  } else {
    cvdef(opnex, 1);
    cvmin(opnex, 0.55);
    cvmax(opnex, 100);
    pinexval2 = 0.65;
    pinexval3 = 0.75;
    pinexval4 = 0.85;
    pinexval5 = 1;
    pinexval6 = 2;
  }
  opnex = _opnex.defval;

  /* FOV */
  opfov = 240;
  pifovnub = 4; /* show the first three + type-in */
  pifovval2 = 180;
  pifovval3 = 220;
  pifovval4 = 240;
  pifovval5 = 260;
  pifovval6 = 280;

  /* phase FOV fraction */
  opphasefov = 1;
  piphasfovnub2 = 63;
  piphasfovval2 = 1.0;
  piphasfovval3 = 0.9;
  piphasfovval4 = 0.8;
  piphasfovval5 = 0.7;
  piphasfovval6 = 0.6;

  /* freq (x) resolution */
  cvmin(opxres, 16);
  cvdef(opxres, 64);
  opxres = _opxres.defval;
  pixresnub = 63;
  pixresval2 = 192;
  pixresval3 = 224;
  pixresval4 = 256;
  pixresval5 = 320;
  pixresval6 = 384;

  /* phase (y) resolution */
  cvmin(opyres, 16);
  piyresnub = 63;
  if (opssfse == PSD_ON) {
    piyresval2 = 64;
    piyresval3 = 128;
    piyresval4 = 160;
    piyresval5 = 192;
    piyresval6 = 256;
    cvdef(opyres, 16); /* init low for SSFSE to avoid too long sequence length before proper values have been chosen */
  } else {
    piyresval2 = 192;
    piyresval3 = 224;
    piyresval4 = 256;
    piyresval5 = 320;
    piyresval6 = 384;
    cvdef(opyres, 128);
  }
  opyres = _opyres.defval;

  /* Num echoes */
  piechnub = 0;
  cvdef(opnecho, 1);
  cvmax(opnecho, 1);

  /* ETL */
  avminetl = 1;
  avmaxetl = 256;
  if (opssfse == PSD_ON) {

    if (ksfse.phaseenc.numlinestoacq > 0)
      cvdef(opetl, ksfse.phaseenc.numlinestoacq);
    else
      cvdef(opetl, _opyres.defval);
    opetl = _opetl.defval;
    pietlnub = 0;

  } else {

    if (!KS_3D_SELECTED) {
      /* 2D */

       if (opflair == FALSE) {
        if (optr < 1s) {
          /* T1-w */
          cvdef(opetl, 1);
          opetl = _opetl.defval;
          pietlnub = 63;
          pietlval2 = 1;
          pietlval3 = 2;
          pietlval4 = 3;
          pietlval5 = 4;
          pietlval6 = 8;
        } else {
          /* T2-w */
          cvdef(opetl, 16);
          opetl = _opetl.defval;
          pietlnub = 63;
          pietlval2 = 8;
          pietlval3 = 12;
          pietlval4 = 16;
          pietlval5 = 20;
          pietlval6 = 24;
        }
      } else if (opflair == OPFLAIR_GROUP) { /* T2-FLAIR */
        cvdef(opetl, 24);
        opetl = _opetl.defval;
        pietlnub = 63;
        pietlval2 = 20;
        pietlval3 = 24;
        pietlval4 = 28;
        pietlval5 = 32;
        pietlval6 = 36;
      } else if (opflair == OPFLAIR_INTERLEAVED) { /* T1-FLAIR */
        cvdef(opetl, 8);
        opetl = _opetl.defval;
        pietlnub = 63;
        pietlval2 = 4;
        pietlval3 = 5;
        pietlval4 = 6;
        pietlval5 = 7;
        pietlval6 = 8;
      }

    } else {

      /* 3D */
      cvdef(opetl, 32);
      opetl = _opetl.defval;
      pietlnub = 63;
      pietlval2 = 32;
      pietlval3 = 48;
      pietlval4 = 64;
      pietlval5 = 96;
      pietlval6 = 128;
  }

  } /* non-ssfse ETL menu */


  /* TE */
  pitetype = PSD_LABEL_TE_EFF; /* alt. PSD_LABEL_TE_EFF */
  if (! existcv(opte)) {
    avmaxte = 2s;
    avminte = 0;
    cvmin(opte, avminte);
    cvmax(opte, avmaxte);
    cvdef(opte, 100ms);
    opte = _opte.defval;
    ksfse_eval_TEmenu(10ms /* fake esp */, 200ms /* fake maxte */, opetl, opetl / 2.0);
  }

  /* TE2 */
  pite2nub = 0;

  /* TI */
  cvset(opautoti, 0, 1, 1, "");
  piautoti = 1; /* make 1st menu choice be AutoTI (opautoti = 1) */
  if (opt1flair) {
    pitinub = -1;
    cvoverride(opautoti, 1, PSD_FIX_ON, PSD_EXIST_ON);
  } else if (opt2flair) {
    pitinub = 2;
  } else if (opirprep) {
    pitinub = 5;
    pitival2 = 150ms;
    pitival3 = 200ms;
    pitival4 = 250ms;
    pitival5 = 300ms;
  } else {
    pitinub = 0;
  }
  avminti = 0;
  avmaxti = 100s;
  cvset(opti, avminti, avmaxti, 1s, "Inversion time");

  /* TR */
  cvdef(optr, 5s);
  optr = _optr.defval;
  /*
   If you want values (pitrval) in the dropdown menu, change to pitrnub = 6;. 
   Remember that you can control the minimum and maximum TR-range 
   from the advanced tab using opuser18 & 19. 
  */
  pitrnub = 2;
  pitrval2 = PSD_MINIMUMTR;
  pitrval3 = 500ms;
  pitrval4 = 3000ms;
  pitrval5 = 4000ms;
  pitrval6 = 5000ms;

  /* FA of refocusing pulse */
  cvmax(opflip, 360);
  cvdef(opflip, 125); /* set it low to avoid init errors on sequence selection */
  opflip = _opflip.defval;
#if EPIC_RELEASE >= 24
  pifamode = PSD_FLIP_ANGLE_MODE_REFOCUS;
  pifanub = 5;
  pifaval2 = 110;
  pifaval3 = 125;
  pifaval4 = 140;
  pifaval5 = 160;
#else
  pifanub = 0;
#endif

  /* slice thickness */
  pistnub = 5;
  if (KS_3D_SELECTED) {
    cvdef(opslthick, 1);
    pistval2 = 0.8;
    pistval3 = 0.9;
    pistval4 = 1;
    pistval5 = 1.5;
    pistval5 = 2;
  } else {
    cvdef(opslthick, 4);
    pistval2 = 2;
    pistval3 = 3;
    pistval4 = 4;
    pistval5 = 5;
    pistval6 = 10;
  }
  opslthick = _opslthick.defval;

  /* slice spacing */
  cvdef(opslspace, 0);
  opslspace = _opslspace.defval;
  piisil = PSD_ON;
  if (KS_3D_SELECTED) {
    /* change these to do overlaps */
    piisnub = 0;
    piisval2 = 0;
  } else {
    piisnub = 5;
    piisval2 = 0;
    piisval3 = 0.5;
    piisval4 = 1;
    piisval5 = 2;
    piisval6 = 3;
  }

  /* default # of slices */
  cvdef(opslquant, 30);

  /* 3D slice settings */
  if (KS_3D_SELECTED) { /* PSD_3D or PSD_3DM */
    pimultislab = 0; /* 0: forces only single slab, 1: allow multi-slab (won't work with non-selective refocusing pulses) */
    pilocnub = 4;
    pilocval2 = 28;
    pilocval3 = 60;
    pilocval4 = 124;
    pilocval5 = 252;
    /* opslquant = #slices in slab. opvquant = #slabs */
    cvdef(opslquant, 32);
  }

  opslquant = _opslquant.defval;

  /* Multi phase (i.e. multi volumes) (only active if PSD_IOPT_MPH, not PSD_IOPT_DYNPL) */
  if (opmph) {
    pimphscrn = 1;   /* display Multi-Phase Parameter screen */
    pifphasenub = 6;
    pifphaseval2 = 1;
    pifphaseval3 = 2;
    pifphaseval4 = 5;
    pifphaseval5 = 10;
    pifphaseval6 = 15;
    pisldelnub = 0;
    piacqnub = 0;
    setexist(opacqo, 1);
    pihrepnub = 0;  /* no XRR gating */
  } else {
    cvoverride(opfphases, 1, PSD_FIX_ON, PSD_EXIST_ON);
  }

  /* opuser0: show GIT revision (GITSHA) using REV variable from the Imakefile */
  char userstr[100];
#ifdef REV
  sprintf(userstr, "    %s PSD version: %s", _ksfse_flipexc.descr, REV);
#else
  sprintf(userstr, "%s", _ksfse_flipexc.descr);
#endif
  cvmod(opuser0, _ksfse_flipexc.minval, _ksfse_flipexc.maxval, _ksfse_flipexc.defval, userstr, 0, " ");
  opuser0 = _opuser0.defval;
  piuset |= use0;

  /* opuser1: TE based on ETL. */
  cvmod(opuser1, _ksfse_etlte.minval, _ksfse_etlte.maxval, _ksfse_etlte.defval, _ksfse_etlte.descr, 0, " ");
  opuser1 = _ksfse_etlte.defval;
  ksfse_etlte = _ksfse_etlte.defval;

  if (opssfse) {
    piuset &= ~use1; /* don't show for SSFSE */
  } else {
    piuset |= use1; /* show since not SSFSE */
  }

  cvmod(opuser2, _ksfse_inflowsuppression.minval, _ksfse_inflowsuppression.maxval, _ksfse_inflowsuppression.defval, _ksfse_inflowsuppression.descr, 0, " ");
  piuset |= use2;
  opuser2 = _ksfse_inflowsuppression.defval;


  if (opfr == FALSE && (oppseq != PSD_IR /* 3 */ && opirprep == FALSE && opflair == FALSE) && opssfse == FALSE && exist(opetl) > 1) {
    /* if FSE-XL has been selected, allow T1-w optimization */
    cvmod(opuser3, 0, 1, 0, "T1-w Optimization [0:OFF 1:ON]", 0, " ");
    opuser3 = _opuser3.defval;
    piuset |= use3;
  } else {
    opuser3 = 0;
    piuset &= ~use3;
  }


  /* In-range TR support (but without using GE's opinrangetr, since we don't know
     how to read the AutoTR field values on the Advanced tab. Instead, for now, add two opusers
     for the range. If any of these are = 0, it is disabled */
  cvmod(opuser4, _ksfse_mintr.minval/1000, _ksfse_mintr.maxval/1000, _ksfse_mintr.defval/1000, _ksfse_mintr.descr, 0, " "); /* minTR in [ms] */
  opuser4 = _opuser4.defval;
  piuset |= use4;
  cvmod(opuser5, _ksfse_maxtr.minval/1000, _ksfse_maxtr.maxval/1000, _ksfse_maxtr.defval/1000, _ksfse_maxtr.descr, 0, " "); /* maxTR in [ms] */
  opuser5 = _opuser5.defval;
  if (opflair == OPFLAIR_GROUP) {
    piuset &= ~use5; /* Don't show maxTR limit for T2FLAIR */
  } else {
    piuset |= use5;
  }

  if (opflair != OPFLAIR_GROUP) {
    _rf_stretch_all.defval = 1.5; /* Wider default (except for T2FLAIR which is less SAR heavy) to shorten the scan time (less SAR penalty) */
  } else {
    _rf_stretch_all.defval = 1.0;
  }
  cvmod(opuser6, 1.0, _rf_stretch_all.maxval,  _rf_stretch_all.defval, _rf_stretch_all.descr, 0, " ");
  opuser6 = _rf_stretch_all.defval;
  piuset |= use6;

  /* T1-value */
  float default_t1value;
  if (opt1flair || opt2flair) {
    default_t1value = (cffield >= 30000) ? T1_CSF_3T : T1_CSF_1_5T;
  } else {
    default_t1value = (cffield >= 30000) ? T1_FAT_3T : T1_FAT_1_5T;
  }
  cvset(opuser7, KS_NOTSET, 10000, default_t1value/1000, "T1-value to null [ms]");
  if (ANYINVERSION && opautoti) {
    piuset |= use7;
    if (opuser7 <= 0) {
      (opuser7) = default_t1value/1000;
    }
  } else {
    piuset &= ~use7;
    setfix(opuser7, FALSE);
  }  

  if (oparc) {
    /* Acceleration menu as decimal numbers (max accel = 4) */
    GEReq_init_accelUI(KS_ACCELMENU_FRACT, 4);
  } else {
    /* Acceleration menu as integers (max accel = 4)
       Covers the non-accelerated and ASSET cases */
    GEReq_init_accelUI(KS_ACCELMENU_INT, 4);
  }


  return SUCCESS;

} /* ksfse_init_UI() */

ksfse_eval_UI()

STATUS ksfse_eval_UI

(

)

Gets the current UI and checks for valid inputs

Return values

STATUS

SUCCESS or FAILURE

                       {

  STATUS status;

  status = ksfse_init_UI();
  KS_RAISE(status);



  /*** Copy UserCVs to human readable CVs ***/
  ksfse_flipexc = opuser0;

  ksfse_etlte = (int) opuser1;
  if (ksfse_etlte != PSD_OFF && ksfse_etlte != PSD_ON) {
    return ks_error("'ETL controls TE' flag must be either [0:OFF, 1:ON]"); /* User error */
  }

  if (existcv(opetl)) {
    /* if ETL has been selected, adjust TR menu to either T1-w or T2-w mode */
    if (exist(opetl) < 6) {
      pitrval3 = 450ms;
      pitrval4 = 500ms;
      pitrval5 = 550ms;
      pitrval6 = 600ms;
    } else {
      pitrval3 = 2500ms;
      pitrval4 = 3000ms;
      pitrval5 = 4000ms;
      pitrval6 = 5000ms;
    }
  }

  /* Inflow suppression (only if spacing or multiple acqs) */
  if (existcv(opslquant) && (opslspace > 0.0 || avmaxacqs > 1)) {
    ksfse_inflowsuppression = opuser2;
  } else {
    cvoverride(ksfse_inflowsuppression, 0, PSD_FIX_OFF, PSD_EXIST_ON);
  }
  if (ksfse_inflowsuppression > 0) {
    cvdesc(opuser2, "In-flow suppression 0:OFF [1:ON]"); /* Highlight ON */
  } else {
    cvdesc(opuser2, "In-flow suppression [0:OFF] 1:ON"); /* Highlight OFF */
  }

  /* Fast recovery / T1w optimization */
  if (opuser3 > 0) {
    ksfse_recovery = KSFSE_RECOVERY_T1WOPT;
  } else if (opfr) {
    ksfse_recovery = KSFSE_RECOVERY_FAST;
  } else {
    ksfse_recovery = 0;
  }

  /* Min/Max TR */
  {
  (ksfse_mintr) = IMax(2, 0, RUP_GRD((int) opuser4 * 1000)); /* in [us] */
  (ksfse_maxtr) = IMax(2, 0, RUP_GRD((int) opuser5 * 1000)); /* in [us] */

  char tmpstr[100];
  sprintf(tmpstr, "Min TR (ms) [0: Auto]");
  if (opflair == OPFLAIR_GROUP) {
    /* T2FLAIR */
    cvdesc(opuser4, tmpstr);
    sprintf(tmpstr, "Min TR (ms) [0: Disabled]");
    cvdesc(opuser5, tmpstr);
  } else if (opflair == OPFLAIR_INTERLEAVED) {
    /* T1FLAIR */
    sprintf(tmpstr, "Min TR (ms) [0: Auto]");
    cvdesc(opuser4, tmpstr);
  } else {
    sprintf(tmpstr, "Min TR (ms) [0: Disabled]");
    cvdesc(opuser4, tmpstr);
    cvdesc(opuser5, tmpstr);
  }
  }

  /* overall RF pulse stretching */
  rf_stretch_all = opuser6;


  /* Reserved opusers:
     -----------------
     ksfse_eval_inversion(): opuser26-29
     GE reserves: opuser36-48 (epic.h)
   */

  return SUCCESS;

} /* ksfse_eval_UI() */

ksfse_eval_esp()

int ksfse_eval_esp	(	int *	min90_180,
		int *	min180_echo,
		int	slicecheck,
		KSFSE_SEQUENCE *	seq
	)

Calculates echo spacing for the sequence

Parameters

[out]	min90_180	Pointer to the time between moment start of the excitation pulse to the center of the refocusing pulse in [us]
[out]	min180_echo	Pointer to the time between center of the refocusing pulse to the center of the first echo in [us]
[in]	slicecheck	0: Normal mode 1: Slice check mode, where the readout is moved to the slice axis
[in]	seq	Pointer to KSFSE_SEQUENCE

Return values

echospacing

Echo Spacing in [us]

                                                                                          {
  int echospacing;

  /*** minimum time needed between RF exc center to RF ref center ***/
  /* latter portion of RF pulse incl ramptime of slice sel grad */
  *min90_180 = seq->selrfexc.rf.iso2end;
  if (slicecheck) {
    /* need separate time for read dephaser */
    *min90_180 += seq->selrfexc.rf2grad_end + seq->readdephaser.duration +
                  seq->selrfref1st.grad2rf_start;
  } else {
    /* max of seq->readdephaser and time from end of rfexc grad plateau to beginning of plateau for rfrefocus */
    *min90_180 += IMax(2,
                       seq->readdephaser.duration /* X */,
                       seq->selrfexc.rf2grad_end + seq->selrfref1st.grad2rf_start /* Z */);
  }
  *min90_180 += seq->selrfref1st.rf.start2iso; /* slice selection time until RF center */

  /*** minimum time needed between RF ref center and echo center ***/
  KS_SELRF *selrf[3] = {&seq->selrfref1st, NULL, NULL};
  if (opetl > 1) {
    selrf[1] = &seq->selrfref2nd;
  }
  if (opetl > 2) {
    selrf[2] = &seq->selrfref;
  }

  int i = 0;
  *min180_echo = 0;
  for (; i<3; ++i) {

    if (!selrf[i]) {
      continue;
    }

    int _min180_echo = selrf[i]->rf.iso2end;
    if (slicecheck) {
      _min180_echo += IMax(2,
                           seq->phaseenc.grad.duration - seq->read.acqdelay + seq->read.time2center /* Y */,
                           selrf[i]->rf2grad_end + seq->zphaseenc.grad.duration + seq->read.time2center /* Z */);
    } else {
      _min180_echo += IMax(3,
                           seq->read.acqdelay /* X */,
                           seq->phaseenc.grad.duration /* Y */,
                           selrf[i]->rf2grad_end + seq->zphaseenc.grad.duration /* Z */);
    }
    _min180_echo += seq->read.time2center - seq->read.acqdelay; /* time from start of acquisition to k-space center */

    *min180_echo = IMax(2, *min180_echo, _min180_echo);
  }

  echospacing = IMax(2, *min90_180, *min180_echo) * 2;
  echospacing = RUP_FACTOR(echospacing, 16);

  return echospacing;

} /* ksfse_eval_esp() */

ksfse_eval_optimalkxnover()

int ksfse_eval_optimalkxnover

(

KSFSE_SEQUENCE *

seq

)

Calculates the optimal number of k-space points for partial kx Fourier that does not increase TE

This function plays by the following rules:

1. CV ksfse_kxnover_min is the lowest number of samples allowed
2. ksfse.read.res/2 is the highest number of samples allowed
3. Increase kxnover until an increase in TE results, while staying within above limits

Parameters

[in]

seq

Pointer to the KSFSE_SEQUENCE struct holding all sequence objects

Return values

kxnover

Optimal number of k-space points beyond half k-space for partial kx Fourier scans.

                                                   {

  int min90_180 = 0; /* [us] */
  int min180_echo = 0; /* [us] */
  int kxnover = 0; /* samples */

  ksfse_eval_esp(&min90_180, &min180_echo, ksfse_slicecheck, seq);

  if (seq->read.nover) {
    /* we are currently using partial Fourier, adjust kxnover to balance the time before and after
    the refocusing pulse */
    kxnover = seq->read.nover + ((min90_180 - min180_echo) / ks_calc_bw2tsp(seq->read.acq.rbw));
  } else {
    /* we are currently using full Fourier (read.nover = 0) */
    if (min90_180 > min180_echo) {
      /* more time needed before the 180 anyway, no need to do partial Fourier */
      kxnover = seq->read.res / 2;
    } else {
      kxnover = seq->read.res / 2 - ((min180_echo - min90_180) / ks_calc_bw2tsp(seq->read.acq.rbw));
    }
  }

  /* keep in range */
  if (kxnover < ksfse_kxnover_min) {
    kxnover = ksfse_kxnover_min;
  } else if (kxnover > seq->read.res / 2) {
    kxnover = seq->read.res / 2;
  }

  kxnover = RUP_GRD(kxnover);

  return kxnover;

} /* ksfse_eval_optimalkxnover() */

ksfse_eval_rfstretchfactor()

float ksfse_eval_rfstretchfactor	(	float	patientweight,
		float	flipangle,
		int	tailoredrf_flag
	)

Empricial RF stretch factor for the ksfse refocusing RF pulses based on patient weight and flip angle

This function returns a suitable scale factor for the duration of the RF refocusing pulse to keep the SAR within limits for different patient weights and flip angles.

The function is called from ksfse_eval_setuprfpulses_2D().

Parameters

[in]	patientweight	Patien weight [kg]
[in]	flipangle	Flip angle [degrees]
[in]	tailoredrf_flag	Tailored RF flag

Return values

float

RF stretch factor

                                                                                            {
  float rfstretchfactor = 1.0;
  float flipangle_factor = 1.0;
  float patientweight_factor = FMax(2, 1.0, patientweight * 0.0055 + 0.6); /* 1.0 at around 75 kg, never less than 0 */

  if (tailoredrf_flag) {
    /* Empirical 2D plane as a function of patient weight and flip angle (for RF pulse set ref_fse1601/2/n)
       Important to not let it below ~0.6 when flipangle or patient weight is too small */
    flipangle_factor = FMax(2, 0.6, 0.0035 * flipangle + 0.15);
    rfstretchfactor = flipangle_factor * patientweight_factor;
  } else {
    /* Empirical 2D plane as a function of patient weight and flip angle (for RF pulse set ref_se1b4)
    Important to not let it below ~0.6 when flipangle or patient weight is too small */
    flipangle_factor = FMax(2, 0.6, 0.0080 * flipangle - 0.10);
    rfstretchfactor = flipangle_factor * patientweight_factor;
  }

  if (rfstretchfactor < 0.6)
    rfstretchfactor = 0.6; /* extra level of safety */

  return rfstretchfactor;

} /* ksfse_eval_rfstretchfactor() */

ksfse_eval_setuprfpulses_2D()

STATUS ksfse_eval_setuprfpulses_2D	(	KSFSE_SEQUENCE *	seq,
		float	crusher_dephasing
	)

Sets up the RF objects for the ksfse sequence (2D)

This function attempts to mimick the RF scaling and flip angle varation performed in the product fsemaster.e psd, with and without the tailored RF (optlrdrf) option. It is called from ksfse_eval_setupobjects() to set up the RF pulses.

Parameters

[out]	seq	Pointer to the KSFSE_SEQUENCE struct holding all sequence objects
[in]	crusher_dephasing	The amount of crusher_dephasing in [cycles] for refocusing pulses

Return values

STATUS

SUCCESS or FAILURE

                                                                                 {
  STATUS status;

  /* Clear potential gradient waveforms in the KS_SELRF objects before we choose our RF pulses */
  ks_init_wave(&seq->selrfexc.gradwave);
  ks_init_wave(&seq->selrfref1st.gradwave);
  ks_init_wave(&seq->selrfref2nd.gradwave);
  ks_init_wave(&seq->selrfref.gradwave);

  /*******************************************************************************************************
   *  RF Selections. Flip angle and slice thickness tweaks
   *******************************************************************************************************/

  ksfse_excthickness = opslthick;

  if (optlrdrf == TRUE || opetl > 2) {
    seq->selrfexc.rf = exc_fse90;      /* Excitation */
    seq->selrfref1st.rf = ref_fse1601; /* 1st Refocusing */
    seq->selrfref2nd.rf = ref_fse1602; /* 2nd Refocusing */
    seq->selrfref.rf = ref_fse160n;    /* 3->ETL Refocusing */
    ksfse_gscalerfexc = 0.8;
    ksfse_gscalerfref = (ksfse_inflowsuppression) ? 0.9 : 0.8;
  } else {
    seq->selrfexc.rf = exc_fl901mc;
    seq->selrfref1st.rf = ref_se1b4;
    seq->selrfref2nd.rf = ref_se1b4;
    seq->selrfref.rf = ref_se1b4;
    ksfse_gscalerfexc = 0.9;
    ksfse_gscalerfref = (ksfse_inflowsuppression) ? 1.0 : 0.9;
  }

  /* Stretch factors for RF refocusing pulses */
  rf_stretch_rfref = ksfse_eval_rfstretchfactor(opweight, opflip, optlrdrf);
  rf_stretch_rfexc = rf_stretch_rfref;

#if EPIC_RELEASE >= 26
  if (opsarmode == 0) { /* normal mode */
    rf_stretch_all *= 1.6;
  } else if (opsarmode == 3) { /* low SAR mode */
    rf_stretch_all *= 3;
  }
#endif

  /* Set flip angles */
  if (optlrdrf == TRUE && opetl > 2) {
    seq->selrfref1st.rf.flip = opflip + 0.6032 * (180.0 - opflip);
    seq->selrfref2nd.rf.flip = opflip + 0.1032 * (180.0 - opflip);
    seq->selrfref.rf.flip = opflip;
  } else {
    seq->selrfref1st.rf.flip = opflip;
    seq->selrfref2nd.rf.flip = opflip;
    seq->selrfref.rf.flip = opflip;
  }


  /*******************************************************************************************************
   *  RF Excitation
   *******************************************************************************************************/
  seq->selrfexc.slthick = ksfse_excthickness / ksfse_gscalerfexc;

  /* Optional widening of the excitation pulse when we have slice gap or
     interleaved (opileave) slice mode where odd slices are completed and reconstructed
     before playing out the even slices */
  if (ksfse_inflowsuppression) {
    if (ksfse_inflowsuppression_mm <= 0) {
      /* ksfse_inflowsuppression_mm = 0 => auto thickness */
      int intleavefact = IMax(2, 1, avmaxacqs);
      float newthick = intleavefact * (ksfse_excthickness + opslspace);
      newthick = FMax(2, seq->selrfexc.slthick, newthick); /* to handle case where newthick is smaller */
      /* up to the case where newthick is three times the slice thickness */
      seq->selrfexc.slthick = (newthick <= KSFSE_MAXTHICKFACT * ksfse_excthickness) ? newthick : KSFSE_MAXTHICKFACT * ksfse_excthickness;
    } else {
      /* ksfse_inflowsuppression_mm > 0: the user wants to specify how many mm extra the excitation
      thickness should be */
      seq->selrfexc.slthick += ksfse_inflowsuppression_mm / ksfse_gscalerfexc;
    }
  }

  seq->selrfexc.rf.flip = ksfse_flipexc; /* value from opuser0 */

  status = ks_eval_stretch_rf(&seq->selrfexc.rf, rf_stretch_all * rf_stretch_rfexc);
  KS_RAISE(status);

  status = ks_eval_selrf(&seq->selrfexc, "rfexc");
  KS_RAISE(status);

  /*******************************************************************************************************
   *  RF Refocusing (1st echo)
  *******************************************************************************************************/
  seq->selrfref1st.slthick = ksfse_excthickness / ksfse_gscalerfref;

  status = ks_eval_stretch_rf(&seq->selrfref1st.rf, rf_stretch_all * rf_stretch_rfref);
  KS_RAISE(status);

  /* Left crusher: Merge excitation rephaser into left crusher */
  /* N.B.: Right crusher will be embedded in zphasenc in ksfse_eval_setupobjects() */
  seq->selrfref1st.pregrad_area_offset = seq->selrfexc.postgrad.area; /* note: postgrad.area is negative ! */

  /* disable the rephaser of the excitation */
  seq->selrfexc.rf2grad_end -= seq->selrfexc.postgrad.duration;
  seq->selrfexc.postgrad.duration = 0; 

  seq->selrfref1st.crusher_dephasing = crusher_dephasing;
  status = ks_eval_selrf(&seq->selrfref1st, "rfref1st");
  KS_RAISE(status);

  /*******************************************************************************************************
   *  RF Refocusing (2nd echo)
   *******************************************************************************************************/
  seq->selrfref2nd.slthick = ksfse_excthickness / ksfse_gscalerfref;
  seq->selrfref2nd.crusher_dephasing = crusher_dephasing;

  status = ks_eval_stretch_rf(&seq->selrfref2nd.rf, rf_stretch_all * rf_stretch_rfref);
  KS_RAISE(status);

  status = ks_eval_selrf(&seq->selrfref2nd, "rfref2nd");
  KS_RAISE(status);

  /*******************************************************************************************************
   *  RF Refocusing (3rd-Nth echo)
   *******************************************************************************************************/
  seq->selrfref.slthick = ksfse_excthickness / ksfse_gscalerfref;
  seq->selrfref.crusher_dephasing = crusher_dephasing;

  status = ks_eval_stretch_rf(&seq->selrfref.rf, rf_stretch_all * rf_stretch_rfref);
  KS_RAISE(status);

  status = ks_eval_selrf(&seq->selrfref, "rfref");
  KS_RAISE(status);

  return SUCCESS;

} /* ksfse_eval_setuprfpulses_2D() */

ksfse_eval_setuprfpulses_3D()

STATUS ksfse_eval_setuprfpulses_3D

(

KSFSE_SEQUENCE *

seq

)

Sets up the RF objects for the ksfse sequence (3D)

Parameters

[in]

seq

Pointer to the KSFSE_SEQUENCE struct holding all sequence objects

Return values

STATUS

SUCCESS or FAILURE

                                                        {
  STATUS status;

  /* GE defines (epic.h) for opexcitemode:
    SELECTIVE 0, NON_SELECTIVE 1, FOCUS 2 */
  const float hardpulse_duration = 1ms;

  /* Clear potential gradient waveforms in the KS_SELRF objects before we choose our RF pulses */
  ks_init_wave(&seq->selrfexc.gradwave);
  ks_init_wave(&seq->selrfref1st.gradwave);
  ks_init_wave(&seq->selrfref2nd.gradwave);
  ks_init_wave(&seq->selrfref.gradwave);

  cvoverride(opvthick, exist(opslquant) * exist(opslthick), _opslquant.fixedflag, existcv(opslquant));
  ksfse_excthickness = (exist(opslquant) - 2 * rhslblank) * exist(opslthick);
  ksfse_gscalerfexc = 1.0;


  /*******************************************************************************************************
   *  RF Excitation
   *******************************************************************************************************/
  if (opexcitemode == NON_SELECTIVE) {
    /* Non-selective 90 hard excitaion */
    status = ks_eval_rf_hard(&seq->selrfexc.rf, "rfexc", hardpulse_duration, 90);
    KS_RAISE(status);
    seq->selrfexc.rf.role = KS_RF_ROLE_EXC;
  } else {
    /* Selective 90 using a sharp high-BW minimum phase excitation pulse */
    seq->selrfexc.rf = exc_3dfgre;
    seq->selrfexc.rf.flip = 90.0;
  }

  seq->selrfexc.slthick = ksfse_excthickness / ksfse_gscalerfexc * (opexcitemode != NON_SELECTIVE);

  status = ks_eval_stretch_rf(&seq->selrfexc.rf, rf_stretch_all * rf_stretch_rfexc);
  KS_RAISE(status);

  status = ks_eval_selrf(&seq->selrfexc, "rfexc");
  KS_RAISE(status);

  /*******************************************************************************************************
   *  RF Refocusing (1st echo)
  *******************************************************************************************************/
  status = ks_eval_rf_hard(&seq->selrfref1st.rf, "rfref1st", hardpulse_duration, opflip);
  KS_RAISE(status);
  seq->selrfref1st.rf.role = KS_RF_ROLE_REF;

  seq->selrfref1st.slthick = 0; /* N.B.: sel gradient = 0 if .selrfref1st.slthick = 0 (ks_eval_selrf()) */

  status = ks_eval_stretch_rf(&seq->selrfref1st.rf, rf_stretch_all * rf_stretch_rfref);
  KS_RAISE(status);

  seq->selrfref1st.crusher_dephasing = ksfse_crusher_dephasing;

  /* Left crusher: Merge excitation rephaser into left crusher */
  /* N.B.: Right crusher will be embedded in zphasenc in ksfse_eval_setupobjects() */
  seq->selrfref1st.pregrad_area_offset += seq->selrfexc.postgrad.area; /* note: postgrad.area is negative ! */

  status = ks_eval_selrf(&seq->selrfref1st, "rfref1st");
  KS_RAISE(status);

  /* disable the rephaser of the excitation */
  seq->selrfexc.postgrad.duration = 0; 
  seq->selrfexc.rf2grad_end -= seq->selrfexc.postgrad.duration;

  /*******************************************************************************************************
   *  RF Refocusing (2nd echo)
   *******************************************************************************************************/
  seq->selrfref2nd.rf = seq->selrfref1st.rf;
  seq->selrfref2nd.slthick = seq->selrfref1st.slthick;
  seq->selrfref2nd.crusher_dephasing = seq->selrfref1st.crusher_dephasing;
  status = ks_eval_selrf(&seq->selrfref2nd, "rfref2nd");
  KS_RAISE(status);

  /*******************************************************************************************************
   *  RF Refocusing (3rd-Nth echo)
   *******************************************************************************************************/
  seq->selrfref.rf = seq->selrfref1st.rf;
  seq->selrfref.slthick = seq->selrfref1st.slthick;
  seq->selrfref.crusher_dephasing = seq->selrfref1st.crusher_dephasing;
  status = ks_eval_selrf(&seq->selrfref, "rfref");
  KS_RAISE(status);


  /*******************************************************************************************************
   *  Disable pre/postgrads by setting their duration to 0
   *  The crusher area will be merged in zphaseenc
   *******************************************************************************************************/
  seq->selrfref1st.postgrad.duration = 0; /* right crusher only */
  seq->selrfref2nd.pregrad.duration = 0;
  seq->selrfref2nd.postgrad.duration = 0;
  seq->selrfref.pregrad.duration = 0;
  seq->selrfref.postgrad.duration = 0;

  return SUCCESS;

} /* ksfse_eval_setuprfpulses_3D() */

ksfse_eval_setuprfpulses_recovery()

STATUS ksfse_eval_setuprfpulses_recovery

(

KSFSE_SEQUENCE *

seq

)

Sets up .selrfrecover and .selrfrecoverref for fast T1 recovery based on .selrfexc and .selrfref

Using ksfse.selrfexc and ksfse.selrfref as templates, this function sets up the RF pulses for fast recovery after the FSE train, which is controlled by the CV ksfse_recovery. The .selrfrecover pulse is a mirrored version of .selrfexc.

Parameters

[in,out]

seq

Pointer to KSFSE_SEQUENCE

Return values

STATUS

SUCCESS or FAILURE

                                                              {
  STATUS status;

  ks_init_wave(&seq->selrfrecover.gradwave);
  ks_init_wave(&seq->selrfrecoverref.gradwave);

  /*******************************************************************************************************
   * Post-ETL forced recovery: T1-w Optimization / T2 fast Recovery
   *******************************************************************************************************/

  /* Recovery "negative" excitation (selrfrecover) */
  seq->selrfrecover.rf = seq->selrfexc.rf; /* already potentially RF-stretched */
  seq->selrfrecover.slthick = seq->selrfexc.slthick;

  status = ks_eval_selrf(&seq->selrfrecover, "rfrecover");
  if (status != SUCCESS ) return status;

  /* no postgrad by setting duration = 0 (or pregrad either since KS_RF_ROLE_EXC) */
  seq->selrfrecover.postgrad.duration = 0;

  /* Mirror RF wave using "-1" (negative stretch factor), will mirror the excitation RF pulse waveform */
  status = ks_eval_stretch_rf(&seq->selrfrecover.rf, -1);
  KS_RAISE(status);


  /* Recovery refocusing (selrfrecoverref). Use flip angle and design from 'selrfref.rf' but left crusher
     area from selrfref1st.pregrad.area */
  seq->selrfrecoverref.rf = seq->selrfref.rf;
  seq->selrfrecoverref.slthick = seq->selrfref.slthick;
  seq->selrfrecoverref.crusher_dephasing = seq->selrfref1st.crusher_dephasing;
  status = ks_eval_selrf(&seq->selrfrecoverref, "rfrecoverref");
  KS_RAISE(status);

  if (KS_3D_SELECTED) { 
    seq->selrfrecoverref.pregrad.duration = 0; /* zphaseenc.areaoffset takes over */
  }

  seq->selrfrecoverref.postgrad.area = seq->selrfref1st.pregrad.area;
  status = ks_eval_trap(&seq->selrfrecoverref.postgrad, seq->selrfrecoverref.postgrad.description);
  KS_RAISE(status);

  return SUCCESS;

} /* ksfse_eval_setuprfpulses_recovery() */

ksfse_eval_ssitime()

int ksfse_eval_ssitime

(

)

Set the SSI time for the sequence

Return values

int	SSI time in [us]

                         {

  /* SSI time CV:
     Empirical finding as a function of etl on how much SSI time we need to update.
     But, use a longer SSI time when we write out data to file in scan() */
  ksfse_ssi_time = RUP_GRD(IMax(2, KSFSE_MIN_SSI_TIME + 13 * opetl, _ksfse_ssi_time.minval));

  /* Copy SSI CV to seqctrl field used by setssitime() */
  ksfse.seqctrl.ssi_time = ksfse_ssi_time;

  /* SSI time one-sequence-off workaround:
     We set the hardware ssitime in ks_scan_playsequence(), but it acts on the next sequence module, hence
     we aren't doing this correctly when using multiple sequence modules (as KSChemSat etc).
     One option would be to add a short dummy sequence ks_scan_playsequence(), but need to investigate
     if there is a better way. For now, let's assume the the necessary update time is the longest for
     the main sequence (this function), and let the ssi time for all other sequence modules (KSChemSat etc)
     have the same ssi time as the main sequence. */
  kssat_ssi_time    = ksfse_ssi_time;

  return ksfse_ssi_time;

} /* ksfse_eval_ssitime() */

ksfse_eval_setupobjects()

STATUS ksfse_eval_setupobjects

(

)

Sets up all sequence objects for the main sequence module (KSFSE_SEQUENCE ksfse)

This function will set up all objects for the main sequence module (ksfse) via a mix of UI CVs and other CVs. This effectively sets the shape (amp, ramptimes & duration) of each trapezoid and waveform in the sequence for later placement in ksfse_pg().

For the RF pulse evaluation, this function calls either ksfse_eval_setuprfpulses_3D() or ksfse_eval_setuprfpulses_2D() depending on the 2D/3D mode.

Return values

STATUS

SUCCESS or FAILURE

                                  {
   STATUS status;

  /* phase encoding gradient */
  ksfse.phaseenc.fov = opfov * opphasefov;
  ksfse.phaseenc.res = RUP_FACTOR((int) (opyres * opphasefov), 2); /* round up (RUP) to nearest multiple of 2 */

  if (opnex < 1) {
    int kynover;
    kynover = ksfse.phaseenc.res * (opnex - 0.5);
    kynover = ((kynover + 1) / 2) * 2; /* round to nearest even number */
    if (kynover < KSFSE_MINHNOVER)
      kynover = KSFSE_MINHNOVER; /* protect against too few overscans */
    ksfse.phaseenc.nover = IMin(2, kynover, ksfse.phaseenc.res / 2);
  } else {
    ksfse.phaseenc.nover = 0;
  }

  /* Readout gradient and data acquisition */
  ksfse.read.fov = opfov;
  ksfse.read.res = RUP_FACTOR(opxres, 2); /* Round UP to nearest multiple of 2 */

  ksfse.read.rampsampling = ksfse_rampsampling;
  if (ksfse.read.rampsampling) {
    ksfse.read.acqdelay = 16; /* us on the ramp until acq should begin */
  }
  if (opautote == PSD_MINTE && opnex >= 1) { /* PSD_MINTE = 2 */
    ksfse_kxnover = ksfse_eval_optimalkxnover(&ksfse); /* Partial Fourier */
    ksfse.read.nover = ksfse_kxnover;
  } else {
    ksfse.read.nover = 0; /* Full Fourier */
  }
  ksfse.read.acq.rbw = oprbw;
  ksfse.read.paddingarea = ksfse_xcrusherarea;
  status = ks_eval_readtrap(&ksfse.read, "read");
  KS_RAISE(status);

  /* read dephaser */
  ksfse.readdephaser.area = ksfse.read.area2center;
  status = ks_eval_trap(&ksfse.readdephaser, "readdephaser");
  KS_RAISE(status);

  /* set .R and .nacslines fields of ksfse.phaseenc using ks_eval_phaser_setaccel() before calling ks_eval_phaser() */
  if (opasset) {
    cvoverride(ksfse_minacslines, 0, PSD_FIX_OFF, PSD_EXIST_ON);
  } else if (oparc) {
    ksfse_minacslines = _ksfse_minacslines.defval;
  }
  status = ks_eval_phaser_setaccel(&ksfse.phaseenc, ksfse_minacslines, opaccel_ph_stride);
  KS_RAISE(status);

  status = ks_eval_phaser(&ksfse.phaseenc, "phaseenc");
  KS_RAISE(status);

  /* setup RF pulses in FSE train */
  if (KS_3D_SELECTED) {
    status = ksfse_eval_setuprfpulses_3D(&ksfse);
    KS_RAISE(status);
  } else {
    /* when quietness factor is used, find the crusher_dephasing that minimizes the echo spacing (esp) */
    if (ks_qfact > 1) {
      int dummy1, dummy2;
      float c;
      float optc = 2.0;
      int optesp = 1s;
      int my_esp = KS_NOTSET;
      for (c = 3.0; c < 10.0; c += 1.0) {
        status = ksfse_eval_setuprfpulses_2D(&ksfse, c);
        KS_RAISE(status);
        my_esp = ksfse_eval_esp(&dummy1, &dummy2, FALSE, &ksfse);
        if (my_esp <= optesp) {
          optesp = my_esp;
          optc = c;
        }
      }
      ksfse_crusher_dephasing = optc;
    }
    status = ksfse_eval_setuprfpulses_2D(&ksfse, ksfse_crusher_dephasing);
    KS_RAISE(status);
  }


  /* z phase encoding gradient (N.B. 3D is not yet implemented in this sequence) */
  if (KS_3D_SELECTED) { /* PSD_3D or PSD_3DM */

    /*  Move crushers area from selrf.pregrad/postgrad to zphasenc.areaoffset */
    ksfse.zphaseenc.areaoffset = ksfse.selrfref1st.postgrad.area;
    ksfse.zphaseenc.fov = opvthick;
    ksfse.zphaseenc.res = IMax(2, 1, opslquant);
    ksfse.zphaseenc.nover = 0;

    /* set .R and .nacslines fields of ksfse.zphaseenc using ks_eval_phaser_setaccel() before calling ks_eval_phaser() */
    if (opasset) {
      cvoverride(ksfse_minzacslines, 0, PSD_FIX_OFF, PSD_EXIST_ON);
    } else if (oparc) {
      ksfse_minzacslines = _ksfse_minzacslines.defval;
    }
    status = ks_eval_phaser_setaccel(&ksfse.zphaseenc, ksfse_minzacslines, opaccel_sl_stride);
    KS_RAISE(status);

    /* another call done in ksfse_eval_setuprfpulses_3D() with .areaoffset > 0 */
    status = ks_eval_phaser(&ksfse.zphaseenc, "zphaseenc");
    KS_RAISE(status);
  } else {

    ks_init_phaser(&ksfse.zphaseenc);

  }


  /* Add recovery pulses after the main Echo Train, common for 2D and 3D */
  if (ksfse_recovery) {
    status = ksfse_eval_setuprfpulses_recovery(&ksfse);
    KS_RAISE(status);
  } else {
    ks_init_selrf(&ksfse.selrfrecover);
    ks_init_selrf(&ksfse.selrfrecoverref);
  }

  /* post-read spoiler */
  ksfse.spoiler.area = ksfse_spoilerarea;
  status = ks_eval_trap(&ksfse.spoiler, "spoiler");
  KS_RAISE(status);

  /* init seqctrl */
  ks_init_seqcontrol(&ksfse.seqctrl);
  strcpy(ksfse.seqctrl.description, "ksfsemain");
  ksfse_eval_ssitime();

  return SUCCESS;

} /* ksfse_eval_setupobjects() */

ksfse_eval_TErange()

STATUS ksfse_eval_TErange

(

)

Sets the min/max TE and echo spacing for the FSE train based on rBW, res and ETL

Based on the duration of the sequence objects involved, this function first calculates the minimum echo spacing in the FSE train (ksfse_esp). Then, if the SSFSE flag is set (opssfse), the ETL (opetl) is forced to be equal to the number of phase encoding lines acquired (see ks_eval_phaseviewtable()), otherwise the chosen ETL is used to calculate how many TRs (or shots) is necessary to fill k-space (ksfse.phaseenc_plan.num_shots). This value is used later in scan.

Next, if the user has selected that the "ETL should set TE" (ksfse_etlte = TRUE), the echo time is forced to be equal to the most optimal one in the center of the echo train (optecho). The benefits of setting ksfse_etlte are

• reduced T2-blurring due to faster k-space traversal, and
• no FSE ghosting The drawback is that TE needs to be controlled via changing ETL in the UI, but image quality wise, it may still be worth it. If ksfse_etlte = FALSE, ksfse_calc_echo() will find the bestecho, which is the echo index in the FSE train closest to the desired TE. When bestecho ends up being equal to optecho (as enforced by ksfse_etlte), the image quality improves, however this it not possible, especially for long ETLs with a normal TE of 80-100 ms.

Last, this function calls ksfse_eval_TEmenu() to change the TE menu so the optimal TE is always at the top, followed by other TEs one or more echo spacings from the optimal TE.

N.B.: ksfse_esp is the shortest time allowed between the RF excitation and the first echo, which is also the same time needed between two consecutive echoes in the FSE train. ksfse_esp is used in ksfse_pg(). If the pulse sequence design changes in ksfse_pg() such that more/less time is needed to the first echo, or between consecutive echoes, ksfse_esp must here be updated to avoid gradient overlaps.

Return values

STATUS

SUCCESS or FAILURE

                            {
  int min90_180 = 0;
  int min180_echo = 0;
  double optecho, bestecho;
  int fixed_teflag = _opte.fixedflag;
  int exist_teflag = _opte.existflag;
  STATUS status;


  /* echo spacing (esp) */
  ksfse_esp = ksfse_eval_esp(&min90_180, &min180_echo, ksfse_slicecheck, &ksfse);

  /* ETL */
  if (opssfse == PSD_ON) {
    /* SSFSE case */
    cvoverride(opetl, ksfse.phaseenc.numlinestoacq, PSD_FIX_ON, PSD_EXIST_ON);
  } else {
    if (opetl < 1) {
      cvoverride(opetl, 1, PSD_FIX_ON, PSD_EXIST_ON);
    } else if (opetl > ksfse.phaseenc.numlinestoacq) {
      return ks_error("ksfse_eval_TErange: Please reduce ETL to %d", ksfse.phaseenc.numlinestoacq);
    }
  }

  /* if single shot (2D), ks_phaseencoding_generate_2Dfse() will not allow non-optimal TE, i.e. linear k-space sweep
     is required. Therefore, ETL must control TE via setting ksfse_etlte = TRUE */
  if (CEIL_DIV(ksfse.phaseenc.numlinestoacq, opetl) == 1) {
    cvoverride(ksfse_etlte, TRUE, PSD_FIX_ON, PSD_EXIST_ON);
  } else {
    _ksfse_etlte.fixedflag = FALSE;
  }


  /* calc spacing between RF pulses used for T1-w opt. */
  if (ksfse_recovery) {

    int recovery_min_read2ref = (ksfse.read.grad.duration - ksfse.read.time2center - ksfse.read.acqdelay) +
    ksfse.selrfrecoverref.grad2rf_start +
    ksfse.selrfrecoverref.rf.start2iso;

    int recovery_min_ref2exc = ksfse.selrfrecoverref.rf.iso2end +
    IMax(2, ksfse.readdephaser.duration,
    ksfse.selrfrecoverref.rf2grad_end) +
    ksfse.selrfrecoverref.grad.ramptime +
    ksfse.selrfrecoverref.rf.start2iso;

    if (ksfse_slicecheck) {
      recovery_min_read2ref += ksfse.read.grad.ramptime;
      recovery_min_ref2exc = ksfse.selrfrecoverref.rf.iso2end +
      ksfse.selrfrecoverref.rf2grad_end +
      ksfse.readdephaser.duration +
      ksfse.selrfrecover.grad.ramptime +
      ksfse.selrfrecover.rf.start2iso;
    }

    int ksfse_recovery_spacing = IMax(2, recovery_min_read2ref, recovery_min_ref2exc) * 2;

    ksfse_esp = IMax(2, ksfse_esp, ksfse_recovery_spacing);
  }

  ksfse_esp += GRAD_UPDATE_TIME * 2; /* 8us extra margin */
  ksfse_esp = RUP_FACTOR(ksfse_esp, 8); /* make sure ksfse_esp is divisible by 8us (as we will need to use ksfse_esp/2 on 4us grid) */


  /* protect against too long sequence before we are having trouble in pg */
  if (ksfse_esp * opetl > 2s) {
    return ks_error("%s: Too long sequence duration (%.1f ms)", __FUNCTION__, (ksfse_esp * opetl) / 1000.0);
  }

  /* bestecho: opte rounded off. optecho: ignores 'opte' input */
  int dummy;
  status = ks_fse_calcecho(&bestecho, &optecho, &dummy, &ksfse.phaseenc, KS_PF_EARLY, opte, opetl, ksfse_esp);
  KS_RAISE(status);

  setpopup(opte, PSD_OFF);


  if (ksfse_etlte) {
    /* ETL is controlling the use of an optimal TE to ensure a linear k-space sweep */
    cvoverride(opte, (int) (ksfse_esp * optecho), PSD_FIX_ON, PSD_EXIST_ON);
    pite1nub = 0;
    _opte.defval = opte;
    pite1val2 = opte;
    avminte = opte;
    avmaxte = opte;

    /* must set opautote here so that the TE menu is shaded rather than removed */
    cvoverride(opautote, PSD_MINTEFULL, PSD_FIX_OFF, PSD_EXIST_ON);

  } else {

    /* minimum TE */
    avminte = ksfse_esp;

    if (opautote || (opte < avminte)) {
      cvoverride(opte, avminte, PSD_FIX_ON, PSD_EXIST_ON);
    } else {
      /* round opte to nearest valid value */
      cvoverride(opte, (int) (ksfse_esp * bestecho), fixed_teflag, exist_teflag);
    }

    /* maximum TE */
    avmaxte = ksfse_esp * opetl;

    /* Setup TE menu */
    ksfse_eval_TEmenu(ksfse_esp, avmaxte, opetl, optecho);

  }


  { /* Update opuser1 to show optimal TE and echo spacing) */
    char tmpstr[100];
    sprintf(tmpstr, "%s [opt=%.1f, esp=%d]", _ksfse_etlte.descr, (ksfse_esp * optecho) / 1000.0, ksfse_esp / 1000);
    cvdesc(opuser1, tmpstr);
  }

  return SUCCESS;

} /* ksfse_eval_TErange() */

ksfse_set_kspace_design()

void ksfse_set_kspace_design

(

KS_KSPACE_DESIGN *

kdesign

)

Set the k-space design for use in ksfse_set_loop_control_design() and ksfse_eval_sat()

This function sets up the k-space design for the FSE sequence based on UI CVs, including properties like FOV size, matrix size, parallel imaging factors, receiver bandwidth, and partial Fourier factors.

For acoustic noise reduction scans (opsilent), ramp sampling is enabled to reduce the echo spacing.

It is used by ksfse_set_loop_control_design() and ksfse_eval_sat().

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan

Parameters

[out]

kdesign

KS_KSPACE_DESIGN

Returns

void

                                                        {

  /* k-space design */  
  kdesign->fov[XGRAD] = opfov;
  kdesign->fov[YGRAD] = opfov * opphasefov;
  kdesign->res[XGRAD] = RUP_FACTOR(opxres, 2);
  kdesign->res[YGRAD] = RUP_FACTOR((int) (opyres * opphasefov), 2);
  kdesign->R[YGRAD] = (oparc || opasset) ? opaccel_ph_stride : 1;
  kdesign->R[ZGRAD] = ((oparc || opasset) && KS_3D_SELECTED) ? opaccel_sl_stride : 1;
  kdesign->nacslines[YGRAD] = ksfse_minacslines;
  kdesign->nacslines[ZGRAD] = ksfse_minzacslines;
  kdesign->rbw = oprbw;
  kdesign->override_R1 = 0; /* If non-zero, override the analog receive gain with this value */
  if (opnex < 1) {
    int kynover = kdesign->res[YGRAD] * (opnex - 0.5);
    kynover += kynover % 2; /* round to nearest even number */
    kdesign->nover[YGRAD] = IMax(2, kynover, KSFSE_MINHNOVER);
  } else {
    kdesign->nover[YGRAD] = 0;
  }

  /* rampsampling on for ART (opsilent) */
  kdesign->rampsampling = (opsilent) ? TRUE : FALSE;

} /* ksfse_set_kspace_design() */

ksfse_set_slicetiming_design()

void ksfse_set_slicetiming_design

(

KS_SLICETIMING_DESIGN *

slicetiming_design

)

Set up the number of slices, TR range, and min num acquisitions in KS_SLICETIMING_DESIGN

This function is called from ksfse_eval_loops()->ksfse_set_loop_control_design() to produce a KSSCAN_LOOP_CONTROL_DESIGN, which contains this KS_SLICETIMING_DESIGN struct steering how the final KS_SLICETIMING struct will be set up by ksscan_slicetiming_eval_design(), taking a KS_SLICETIMING_DESIGN as input

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan

Parameters

[out]

slicetiming_design

KS_SLICETIMING_DESIGN to be created

Returns

void

                                                                             {

  /* interleaved slices in slice gap menu, force 2+ acqs */
  int minacqs = (opileave) ? 2 : 1;

  if (opslspace < 0) { /* Because we use overlap (pi_neg_sp) */
    minacqs = IMax(2, minacqs, ceil(opslthick / (opslthick - fabs(opslspace))));
  }

  slicetiming_design->is3D = KS_3D_SELECTED;
  slicetiming_design->nslices = opslquant;
  ksscan_copy_slices(slicetiming_design, ks_scan_info);

  slicetiming_design->minacqs = minacqs;
  if (opautotr) {
    slicetiming_design->minTR = ksfse_mintr;
    slicetiming_design->maxTR = ksfse_maxtr;
  } else {
    slicetiming_design->minTR = optr;
    slicetiming_design->maxTR = optr;
  }

} /* ksfse_set_slicetiming_design() */

ksfse_set_loop_control_design()

STATUS ksfse_set_loop_control_design

(

KSSCAN_LOOP_CONTROL_DESIGN *

loop_design

)

Setup of a KSSCAN_LOOP_CONTROL_DESIGN with desired k-space coordinates, averages, volumes, etc.

This function creates a KSSCAN_LOOP_CONTROL_DESIGN struct, with fields .dda: Number of dummy scans .naverages: Number of averages .nvols: Number of volumes .phaseenc_design: KS_PHASEENCODING_DESIGN (containing coordinates and other phase encoding info) .slicetiming_design: KS_SLICETIMING_DESIGN (containing slice timing info)

This function is called from ksfse_eval_loops() to produce a KSSCAN_LOOP_CONTROL_DESIGN, which is then used in part to create a KSSCAN_LOOP_CONTROL struct used in scan

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan

Parameters

[out]

loop_design

KSSCAN_LOOP_CONTROL_DESIGN to be created

Return values

STATUS

SUCCESS or FAILURE

                                                                              {

  if (optr > 6s || opssfse || opt2flair) {
    ksfse_dda = 0;  /* For long TRs or single-shot FSE, don't use dummies */
  } else if (optr > 2s) {
    ksfse_dda = 1; /* For medium long TRs */
  } else {
    ksfse_dda = 2;
  }

  loop_design->dda = ksfse_dda;
  loop_design->naverages = ceil(opnex);
  loop_design->nvols = opfphases;

  /* Generate the k-space coordinate list */
  KS_KSPACE_DESIGN kdesign = KS_INIT_KSPACE_2D_DESIGN;
  ksfse_set_kspace_design(&kdesign);
  STATUS s = ks_generate_3d_coords_caipi(&kacq,
                                         kdesign.res[YGRAD], kdesign.res[ZGRAD],
                                         kdesign.nover[YGRAD], kdesign.nover[ZGRAD],
                                         kdesign.R[YGRAD], kdesign.R[ZGRAD],
                                         ks_cal_from_nacslines(kdesign.R[YGRAD], kdesign.nacslines[YGRAD]),
                                         ks_cal_from_nacslines(kdesign.R[ZGRAD], kdesign.nacslines[ZGRAD]),
                                         RECTANGULAR, /* calibration shape */
                                         RECTANGULAR, /* kspace coverage, can be ELLIPTICAL as well */
                                         0, 0, 0, 0);
  KS_RAISE(s);

  /* Phase encoding */
  loop_design->phaseenc_design.encodes_per_shot = opetl;
  loop_design->phaseenc_design.center_encode = opte / ksfse_esp - 1;
  loop_design->phaseenc_design.kacq = kacq;

  ksfse_set_slicetiming_design(&loop_design->slicetiming_design);

  return SUCCESS;

} /* ksfse_set_loop_control_design() */

ksfse_set_inversion_loop_control_design()

STATUS ksfse_set_inversion_loop_control_design

(

KSINV_LOOP_CONTROL_DESIGN *

invloopctrl_design

)

Setup of a KSINV_LOOP_CONTROL_DESIGN with inversion related parameters

This function creates a KSSCAN_LOOP_CONTROL_DESIGN struct, which contains the same KSSCAN_LOOP_CONTROL_DESIGN struct as ksfse_set_loop_control_design() in its .loopctrl_design field. This by calling ksfse_set_loop_control_design(&invloopctrl_design->loopctrl_design) here.

In addition, inversion-recovery-related design info is set up in this function, including the type of inversion mode depending on the UI CVs opirprep, opt1flair, opt2flair.

The desired inversion timing is controlled by either the inversion time (TI) xor the T1 value of the tissue

• .T1value = ksfse_t1value_to_null, if the UI CV opautoti is TRUE (makes the final TI change automatically with TR)
• .TI = opti if the UI CV opautoti is FALSE (makes a fixed TI value set by the user)

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan

Parameters

[out]

invloopctrl_design

KSINV_LOOP_CONTROL_DESIGN to be created

Return values

STATUS

SUCCESS or FAILURE

                                                                                              {

  if (!ANYINVERSION) {
    invloopctrl_design->irmode = KSINV_OFF;
    return SUCCESS;
  }

  if (exist(opautotr) == 0 && existcv(optr)) {
    return KS_THROW("MinimumTR (Auto) must be selected for FLAIR");
  }

  if ((opirprep + opt1flair + opt2flair) > 1) {
    return KS_THROW("Mutually exclusive opirprep/opt1flair/opt2flair");
  }

  STATUS s = ksfse_set_loop_control_design(&invloopctrl_design->loopctrl_design);
  KS_RAISE(s);

  invloopctrl_design->irmode = KSINV_OFF;
  if (opirprep) { /* IR prep */
    invloopctrl_design->dosliceahead = 1; /* TODO */
    invloopctrl_design->irmode = KSINV_ON_INTERLEAVED;  
  }
  if (opt1flair) { /* interleaved IR */
    invloopctrl_design->dosliceahead = 1;
    invloopctrl_design->irmode = KSINV_ON_INTERLEAVED;  
    invloopctrl_design->loopctrl_design.slicetiming_design.minTR =
      IMax(2, KSINV_MINTR_T1FLAIR, invloopctrl_design->loopctrl_design.slicetiming_design.minTR);
    invloopctrl_design->loopctrl_design.slicetiming_design.minTR =
      IMin(2, KSINV_MAXTR_T1FLAIR, invloopctrl_design->loopctrl_design.slicetiming_design.maxTR);
  }
  if (opt2flair) { /* FLAIR block */    
    invloopctrl_design->irmode = KSINV_ON_FLAIR_BLOCK;
    invloopctrl_design->loopctrl_design.slicetiming_design.minTR =
      IMax(2, KSINV_MINTR_T2FLAIR, invloopctrl_design->loopctrl_design.slicetiming_design.minTR);
  }

  if (opautoti) { /* use either TI or T1value (XOR). must set the non-used one to KS_NOTSET */
    invloopctrl_design->TI = KS_NOTSET;
    invloopctrl_design->T1value = (int) opuser7 * 1000; /* ms -> us */;
  } else {
    invloopctrl_design->TI = opti;
    invloopctrl_design->T1value = KS_NOTSET;
  }

  invloopctrl_design->filltr_ssi_time = ksfse_ssi_time;

  return SUCCESS;

} /* ksfse_set_inversion_loop_control_design() */

ksfse_eval_inversion()

STATUS ksfse_eval_inversion

(

KS_SEQ_COLLECTION *

seqcollection

)

Setup and evaluation of KSINV_DESIGN and the creation of a KSINV_MODULE module for inversion recovery

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan. Here, the KSINV_DESIGN has local scope and is setup and used only by this function. What remains is the KSINV_MODULE ksfse_inv module, declaread in .

The KS_SEQ_COLLECTION is passed as a pointer to the function, to let the KSINV_MODULE to be registered in the collection for RF scaling, and heating calculations.

Parameters

[in,out]

seqcollection

Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules

Return values

STATUS

SUCCESS or FAILURE

                                                              {

  STATUS status;

  KSINV_DESIGN inv_design = KSINV_INIT_DESIGN;

  ksinv_init_design(&inv_design, "inv"); /* e.g. STIR */
  if (opt1flair) {
    ksinv_init_design(&inv_design, "t1flair");
  }
  if (opt2flair) {
    ksinv_init_design(&inv_design, "t2flair");    
  }

  inv_design.invdesign.slthick = opslthick;
  inv_design.invdesign.flip = 180.0;
  inv_design.invdesign.rfpulse_choice = INV_ADIABATIC; /* TODO */
  inv_design.spoiler_area = ksfse_spoilerarea;
  inv_design.gscale_policy = KSINV_GSCALE_NONOVERLAP; /* TODO */
  inv_design.slice_gap = opslspace;
  inv_design.ssi_time = ksfse_ssi_time;

  const int minacqs = (opileave) ? 2 : 1;
  status = ksinv_eval_design(&ksfse_inv, &inv_design, minacqs, seqcollection);
  KS_RAISE(status);

  return SUCCESS;

} /* ksfse_eval_inversion() */

ksfse_eval_sat()

STATUS ksfse_eval_sat

(

KS_SEQ_COLLECTION *

seqcollection

)

Set up of the KSSAT_MODULE kssat for graphical saturation in the UI

As there can only be one global graphical saturation module that interacts with the UI, this function uses the global kssat struct (KSSAT_MODULE) in kssat.e, which is at the top of ksfse.e

seqcollection is passed as a pointer to the function, to register the KSSAT_MODULE in the collection for later RF scaling, and heating calculations.

Both design structs have local scope, and via ksfse_set_slicetiming_design(), the slice location info is used to control the location of the sat bands in kssat_setup_from_UI()

Parameters

[in,out]

seqcollection

Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules

Return values

STATUS

SUCCESS or FAILURE

                                                        {

  STATUS status;

  KS_KSPACE_DESIGN kdesign = KS_INIT_KSPACE_2D_DESIGN;
  ksfse_set_kspace_design(&kdesign);

  KS_SLICETIMING_DESIGN slicetiming_design = KS_INIT_SLICETIMING_DESIGN;
  ksfse_set_slicetiming_design(&slicetiming_design);

  status = kssat_setup_from_UI(&kssat,
                               &kdesign,
                               &slicetiming_design,
                               opslthick,
                               seqcollection);
  KS_RAISE(status);

  return SUCCESS;

} /* ksfse_eval_sat() */

ksfse_gradheat_play()

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

Play function of a test sequence used for gradient heating calculations

This function

• plays a set of sequence modules that collectively makes a test sequence that attempts to be a good approximation of the average and maxmimum power dissipation of the gradient system.
• is not used for any data collection.
• first plays the saturation sequence (if kssat.seqctrl.duration > 0), then the inversion sequence (if any), then the main sequence based on the max_encode_mode (AVERAGE_POWER or MAXIMUM_POWER).
• is passed as an argument to ks_eval_getduration() to get the playout time and to ks_eval_hwlimits() to get the new minimum time due to hardware heating and SAR calculations.

It should be noted that the content of this function is manual work and needs to be updated if the content of ksfse_pg() or used sequence modules are changed for the gradient heating to be accurate. So if, for example, major dynamic changes of gradient amplitudes or which sequence modules that are used, this function should be updated accordingly.

As ks_eval_getduration() and ks_eval_hwlimits() are common for all psds, this function has to have nargs and args as input arguments, but they are not used here. See ksfse_eval_loops() for more details.

Parameters

[in]	max_encode_mode	The maximum encoding mode, which can be either AVERAGE_POWER or MAXIMUM_POWER.
[in]	nargs	(not used) Number of extra input arguments (# elements of void pointer array **args)
[in]	args	(not used) Void pointer array with nargs elements (may be NULL)

Return values

STATUS

SUCCESS or FAILURE

                                                                              {
  (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;

} /* ksfse_gradheat_play() */

ksfse_eval_loops()

STATUS ksfse_eval_loops

(

KS_SEQ_COLLECTION *

seqcollection

)

Setup of scan loop control structs after heating calculations

This function performs the following tasks:

• Evaluates the SAR and gradient heating using ks_eval_hwlimits(...,ksfse_gradheat_play(),...) and returns newtime
• Increases the main sequence duration (ksfse.seqctrl.duration) if the newtime > time using ks_eval_seqctrl_setduration()
• Sets up
  • loopctrl_design (for main sequence), which is used together with the coreslice function (ksfse_scan_coreslicegroup())
  • ksfse_loopctrl in ksscan_loop_control_eval_design() to control the scan loop for the main sequence
• If inversion is used, inv_loopctrl_design is used to create ksfse_inv_loopctrl, which controls the scan loop instead of ksfse_loopctrl when inversion is on.

Note that all design structs are short-lived and are set up as a receipe for other structures to be used in pulsegen and scan. Here this applies to the local variables loopctrl_design and inv_loopctrl_design.

Parameters

[in,out]

seqcollection

Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules

Return values

STATUS

SUCCESS or FAILURE

                                                          {
  STATUS status;

  /* SAR and gradient heating */
  const int time = ks_eval_getduration(seqcollection, ksfse_gradheat_play, 0, NULL);

  int newtime = 0;
  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);
  }

  /* Loop control evaluation */

  if (!ANYINVERSION) {
    KSSCAN_LOOP_CONTROL_DESIGN loopctrl_design = KSSCAN_INIT_LOOP_CONTROL_DESIGN;
    status = ksfse_set_loop_control_design(&loopctrl_design);
    KS_RAISE(status);

    status = ksscan_loop_control_eval_design(&ksfse_loopctrl,
                                             &ksfse.seqctrl,
                                             ksfse_scan_coreslicegroup, 
                                             &loopctrl_design);
    KS_RAISE(status);
  } else {
    KSINV_LOOP_CONTROL_DESIGN inv_loopctrl_design = KSINV_INIT_LOOP_CONTROL_DESIGN;
    ksfse_set_inversion_loop_control_design(&inv_loopctrl_design);

    status = ksinv_loop_control_eval_design(&ksfse_inv_loopctrl,
                                            ksfse_scan_irslice, &ksfse_inv.seqctrl,
                                            ksfse_scan_coreslicegroup, &ksfse.seqctrl,
                                            &inv_loopctrl_design,
                                            seqcollection);
    KS_RAISE(status);
  }

  /* Fill in the 'tmin' and 'tmin_total'. tmin_total is only like GEs use of the variable when TR = minTR */
  tmin = ksfse.seqctrl.min_duration;
  tmin_total = ksfse.seqctrl.duration;

  return SUCCESS;

} /* ksfse_eval_loops() */

ksfse_eval_scantime()

STATUS ksfse_eval_scantime

(

KS_SEQ_COLLECTION *

seqcollection

)

Sets the scan time and SAR values in the UI and checks that the sequence is within hardware limits

pitscan is the UI variable for the scan clock shown in the top right corner on the MR scanner. The call to GEReq_eval_checkTR_SAR_calcs() also sets up the UI SAR annotation.

Return values

STATUS

SUCCESS or FAILURE

                                                             {
  STATUS status;

  /**** SAR Calcs: Check that we are within SAR/hardware limits ****/

  /* Step 1: set all `seqctrl.nseqinstances` to 0 */
  ks_eval_seqcollection_resetninst(seqcollection);

  /* Step 2: run the scan loop to get total scan time */
  n64 scantime = ksfse_scan_scanloop();

  /* Step 3: Check that the entire sequence (across all sequence modules) is within SAR & hardware limits.
     Also sets up UI SAR annotation */
  status = GEReq_eval_checkTR_SAR_calcs(seqcollection, scantime);
  KS_RAISE(status);

  pitscan = (float) scantime; /* Scan time clock in UI */

  return SUCCESS;

} /* ksfse_eval_scantime() */

ksfse_update_UI()

STATUS ksfse_update_UI

(

)

Update variables for the UI and checks for out of bounds values

This function is called from cvcheck() to update the UI variables based largely on ksfse and ksfse_loopctrl after checks for some out-of-bounds values.

Return values

STATUS

SUCCESS or FAILURE

                         {

  /* Show resolution, BW per pixel & echo spacing in the UI */
  piinplaneres = 1;
  pirbwperpix = 1;
  piesp = 1;
  ihinplanexres = ksfse.read.fov/ksfse.read.res;
  ihinplaneyres = ksfse.phaseenc.fov/ksfse.phaseenc.res;
  ihrbwperpix = (1000.0 * ksfse.read.acq.rbw * 2.0)/ksfse.read.res;
  ihesp = ksfse_esp/1000.0;

  const KSSCAN_LOOP_CONTROL *loopctrl = ksfse_get_loop_ctrl();

  _optr.minval = 0;
  _optr.maxval = 60s;
  if (opautotr) {
    avmintr = loopctrl->slicetiming.TR;
    avmaxtr = loopctrl->slicetiming.TR;
  } else {
    avmintr = _optr.minval;
    avmaxtr = _optr.maxval;
  }
  (optr) = loopctrl->slicetiming.TR; /* ()-parentheses avoids fixedflag expansion */
  act_tr = loopctrl->slicetiming.TR;
  ihtr = optr; /* image header TR */

  avmaxslquant = loopctrl->slicetiming.maxslices_per_TR;
  avmaxacqs = loopctrl->slicetiming.slice_plan.npasses; 

  if (ANYINVERSION) {
    cvoverride(opti, ksfse_inv_loopctrl.TI, PSD_FIX_ON, PSD_EXIST_ON);
    if (opautoti) {
      pitival2 = opti;
    }
  }

  /* Force the user to select the Fast Spin echo button. This error needs to be in cvcheck(), not in
     cvinit()/cveval() to avoid it to trigger also when Fast Spin Echo has been selected */
  if (!((oppseq == PSD_SE || oppseq == PSD_IR) && opfast == PSD_ON && existcv(opfast))) {
    return ks_error("%s: Please first select the 'Fast Spin Echo' button", ks_psdname);
  }

  if (KS_3D_SELECTED && opcube) {
    return ks_error("%s: Please select either FRFSE-XL or FSE", __FUNCTION__);
  }

  if (oparc && KS_3D_SELECTED && (ksfse.zphaseenc.R > ksfse.phaseenc.R)) {
    /* Unclear why, but zR > R leads to corrupted images for ARC and 3D.
    Probably a bug that can be fixed later. Limited experience (July 2018) */
    return ks_error("%s: Need Slice acceleration <= Phase accleration", __FUNCTION__);
  }

  return SUCCESS;

} /* ksfse_update_UI() */

ksfse_predownload_plot()

STATUS ksfse_predownload_plot

(

KS_SEQ_COLLECTION *

seqcollection

)

Plotting of sequence modules and slice timing in HTML files

If a file /usr/g/research/bin/ksdonotplot exists, this function will return SUCCESS without plotting. This is a system-wide way of quickly disabling plotting for all sequences.

Otherwise the function first prints out the textfile: <ks_psdname>_objects.txt, which contains the specs of most sequence components in the sequence.

The rest of the function is the plotting the main sequence diagram as HTML file, and lastly the sequence timing plot, showing slice location on the y-axis and time on the x-axis for all sequence modules at the same time.

The HTML plots will have a slider to show the dynamics of a psd. What is interesting to show dynamics for can vary between psds. In most cases only the shot index might be interesting, skipping non-relevant changes such as change in slice location. One can think of this as recording something in a video, where only the relevant parts are recorded.

"Recording" is first reset by ks_eval_seqcollection_resetninst(). The generic ksscan_plotloop_shots() is used to play a single slice for many shot indices.

Note that ksscan_plotloop_shots() internally copies the loop_control struct (arg 2) and overrides the number of slices in order to play a single slice.

Lastly, ks_plot_psd() is called to write out a JSON file, followed by a system call to the python script psdplot/psdplot.py to create the HTML plots. The HTML files can take 10-20 s to generate, so be patient.

For the slicetiming plot, the three functions ks_plot_slicetime_begin();ksfse_scan_scanloop();ks_plot_slicetime_end(); creates a corresponding JSON file, followed by a system call to the python script psdplot/psdplot_slicetime.py to create the HTML plot.

Return values

STATUS

SUCCESS or FAILURE

                                                                {
  char tmpstr[1000];

  /* System wide (psd independent) option to disable plotting, to e.g. speed up UX on a slow MR show system */
  if (existfile("/usr/g/research/bin/ksdonotplot")) {
    return SUCCESS;
  }

#ifdef PSD_HW
  sprintf(tmpstr, "/usr/g/mrraw/%s_objects.txt", ks_psdname);
#else
  sprintf(tmpstr, "./%s_objects.txt", ks_psdname);
#endif
  FILE *fp  = fopen(tmpstr, "w");

  /* Note: 'fp' can be replaced with 'stdout' or 'stderr' to get these
     values printed out in the WTools window in simulation. However,
     heavy printing may result in that the WTools window closes,
     why we here write to a file ksfse_objects.txt instead */
  ks_print_readtrap(ksfse.read, fp);
  ks_print_trap(ksfse.readdephaser, fp);
  ks_print_phaser(ksfse.phaseenc, fp);
  ks_print_trap(ksfse.zphaseenc.grad, fp);
  ks_print_trap(ksfse.spoiler, fp);
  ks_print_selrf(ksfse.selrfexc, fp);
  ks_print_selrf(ksfse.selrfref1st, fp);
  ks_print_selrf(ksfse.selrfref2nd, fp);
  ks_print_selrf(ksfse.selrfref, fp);
  if (ANYINVERSION) {
    ks_print_selrf(ksfse_inv.selrfinv, fp);
  }
  fclose(fp);

  ks_eval_seqcollection_resetninst(seqcollection);

  /* Main */
  ksscan_plotloop_shots(ksfse_get_loop_ctrl(), ksfse_scan_coreslicegroup);
  ks_plot_psd(&ksfse.seqctrl, ksfse_get_loop_ctrl());

  /* Saturation */
  ks_plot_host_seqctrl(&kssat.seqctrl, NULL);

  /* Sequence timing plot: */
  ks_plot_slicetime_begin();
  ksfse_scan_scanloop();
  ks_plot_slicetime_end();

  return SUCCESS;

} /* ksfse_predownload_plot() */

ksfse_predownload_setrecon()

STATUS ksfse_predownload_setrecon

(

)

Last-resort function to override certain recon variables not set up correctly already

For most cases, the GEReq_predownload_*** functions in predownload() in ksfse.e set up the necessary rh*** variables for the reconstruction to work properly. However, if this sequence is customized, certain rh*** variables may need to be changed. Doing this here instead of in predownload() directly separates these changes from the standard behavior.

Return values

STATUS

SUCCESS or FAILURE

                                    {

  KS_KACQ_RECONSHEDULE_ENTRY recon_table[16];
  int echo;
  for (echo = 0; echo < opnecho; echo++) {
    recon_table[echo].sampling_pattern_offset = 0;
    recon_table[echo].calibration_pattern_offset = KS_NOTSET;
    recon_table[echo].mask_pattern_offset = KS_NOTSET;
    recon_table[echo].echo_index = echo;
  }
  STATUS s = GEReq_writekacq(opnecho, recon_table, 1, &kacq);
  KS_RAISE(s);

  return SUCCESS;

} /* ksfse_predownload_setrecon() */

ksfse_scan_rf_off()

void ksfse_scan_rf_off

(

)

Sets all RF pulse amplitudes to zero

Returns

void

                         {
  ks_scan_rf_off(&ksfse.selrfexc.rf,    INSTRALL);
  ks_scan_rf_off(&ksfse.selrfref1st.rf, INSTRALL);
  ks_scan_rf_off(&ksfse.selrfref2nd.rf, INSTRALL);
  ks_scan_rf_off(&ksfse.selrfref.rf,    INSTRALL);
  ks_scan_rf_off(&ksfse.selrfrecover.rf, INSTRALL);
  ks_scan_rf_off(&ksfse.selrfrecoverref.rf, INSTRALL);

} /* ksfse_scan_rf_off() */

ksfse_scan_rf_on()

void ksfse_scan_rf_on

(

)

Sets all RF pulse amplitudes on

Returns

void

                        {
  ks_scan_rf_on(&ksfse.selrfexc.rf,    INSTRALL);
  ks_scan_rf_on(&ksfse.selrfref1st.rf, INSTRALL);
  ks_scan_rf_on(&ksfse.selrfref2nd.rf, INSTRALL);
  ks_scan_rf_on(&ksfse.selrfref.rf,    INSTRALL);
  ks_scan_rf_on(&ksfse.selrfrecover.rf, INSTRALL);
  ks_scan_rf_on(&ksfse.selrfrecoverref.rf, INSTRALL);

} /* ksfse_scan_rf_on() */

ksfse_scan_init()

STATUS ksfse_scan_init

(

void

)

Common initialization for prescan entry points MPS2 and APS2 as well as the SCAN entry point

Return values

STATUS

SUCCESS or FAILURE

                             {

  GEReq_initRSP();

  /* Here goes code common for APS2, MPS2 and SCAN */

  ks_scan_switch_to_sequence(&ksfse.seqctrl);  /* switch to main sequence */
  scopeon(&seqcore); /* Activate scope for core */
  syncon(&seqcore);  /* Activate sync for core */
  setssitime(ksfse.seqctrl.ssi_time / HW_GRAD_UPDATE_TIME);

  /* can we make these independent on global rsptrigger and rsprot in orderslice? */
  settriggerarray( (short) ksfse_get_loop_ctrl()->slicetiming.slice_plan.nslices_per_pass, rsptrigger);

  return SUCCESS;

} /* ksfse_scan_init() */

ksfse_scan_prescanloop()

void ksfse_scan_prescanloop	(	int	nloops,
		int	dda
	)

Prescan loop called from both APS2 and MPS2 entry points

Return values

STATUS

SUCCESS or FAILURE

                                                 {

  if (!ANYINVERSION) {
    ksscan_prescanloop(&ksfse_loopctrl, ksfse_scan_coreslicegroup, nloops, dda);
  } else {
    ksinv_prescanloop(&ksfse_inv_loopctrl, ksfse_scan_coreslicegroup, ksfse_scan_irslice, nloops, dda);
  }

} /* ksfse_scan_prescanloop() */

Variable Documentation

seqcollection

KS_SEQ_COLLECTION seqcollection

ksfse_excthickness

float ksfse_excthickness = 0

ksfse_gscalerfexc

float ksfse_gscalerfexc = 0.9

ksfse_flipexc

float ksfse_flipexc = 90.0 with {0.0, 180.0, 90.0, VIS, "Excitation flip angle [deg]",}

ksfse_spoilerarea

float ksfse_spoilerarea = 2000.0 with {0.0, 20000.0, 5000.0, VIS, "ksfse spoiler gradient area",}

rf_stretch_rfexc

float rf_stretch_rfexc = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF excitation pulse if > 1.0",}

ksfse_inflowsuppression

int ksfse_inflowsuppression = 0 with {0, 1, 0, VIS, "In-flow Suppression [0:OFF, 1:ON]",}

ksfse_inflowsuppression_mm

float ksfse_inflowsuppression_mm = 0.0 with {0.0, 100.0, 0.0, VIS, "In-flow suppression [mm]",}

ksfse_vfa

int ksfse_vfa = 1 with {0, 1, 1, VIS, "Variable flip angles [0:OFF, 1:ON]",}

ksfse_crusher_dephasing

float ksfse_crusher_dephasing = 6.0 with {0.0, 100.0, 6.0, VIS, "scaling of crusher gradient area [cycles]",}

ksfse_gscalerfref

float ksfse_gscalerfref = 0.9

ksfse_slicecheck

int ksfse_slicecheck = 0 with {0, 1, 0, VIS, "move readout to z axis for slice thickness test",}

rf_stretch_rfref

float rf_stretch_rfref = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF refocusing pulses if > 1.0",}

rf_stretch_all

float rf_stretch_all = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch all RF pulses if > 1.0",}

ksfse_recovery

int ksfse_recovery = KSFSE_RECOVERY_OFF with {KSFSE_RECOVERY_OFF, KSFSE_RECOVERY_FAST, KSFSE_RECOVERY_OFF, VIS, "Recovery. 0:off 1:T1wopt 2:T2fast", }

rf_stretch_rfrecovery

float rf_stretch_rfrecovery = 1.0 with {0.01, 100.0, 1.0, VIS, "Stretch RF recovery pulses if > 1.0",}

ksfse_kxnover_min

int ksfse_kxnover_min = KSFSE_MINHNOVER with {KSFSE_MINHNOVER, 512, KSFSE_MINHNOVER, VIS, "Min mum kx overscans for minTE",}

ksfse_kxnover

int ksfse_kxnover = 32 with {KSFSE_MINHNOVER, 512, 32, VIS, "Num kx overscans for minTE",}

ksfse_rampsampling

int ksfse_rampsampling = 0 with {0, 1, 0, VIS, "Rampsampling [0:OFF 1:ON]",}

ksfse_extragap

int ksfse_extragap = 0 with {0, 100ms, 0, VIS, "extra gap between readout [us]",}

ksfse_etlte

int ksfse_etlte = 1 with {0, 1, 1, VIS, "ETL controls TE",}

ksfse_xcrusherarea

float ksfse_xcrusherarea = 100.0 with {0.0, 1000.0, 100.0, VIS, "x crusher area for readout",}

ksfse_esp

int ksfse_esp = 0 with {0, 1000000, 0, VIS, "View-only: Echo spacing in [us]",}

ksfse_noph

int ksfse_noph = 0 with {0, 1, 0, VIS, "Turn OFF phase encoding [0:Disabled 1:Enabled]",}

ksfse_minacslines

int ksfse_minacslines = 12 with {0, 512, 12, VIS, "Minimum ACS lines for ARC",}

ksfse_minzacslines

int ksfse_minzacslines = 12 with {0, 512, 12, VIS, "Minimum z ACS lines for ARC",}

ksfse_pos_start

int ksfse_pos_start = KS_RFSSP_PRETIME with {0, , KS_RFSSP_PRETIME, VIS, "us from start until the first waveform begins",}

ksfse_ssi_time

int ksfse_ssi_time = KSFSE_MIN_SSI_TIME with {50, , KSFSE_MIN_SSI_TIME, VIS, "time from eos to ssi in intern trig",}

ksfse_dda

int ksfse_dda = 2 with {0, 200, 2, VIS, "Number of dummy scans for steady state",}

ksfse_debug

int ksfse_debug = 1 with {0, 100, 1, VIS, "Write out e.g. plot files (unless scan on HW)",}

ksfse_imsize

int ksfse_imsize = KS_IMSIZE_NATIVE with {KS_IMSIZE_NATIVE, KS_IMSIZE_MIN256, KS_IMSIZE_MIN256, VIS, "img. upsamp. [0:native 1:pow2 2:min256]"}

ksfse_abort_on_kserror

int ksfse_abort_on_kserror = FALSE with {0, 1, 0, VIS, "Hard program abort on ks_error [0:OFF 1:ON]",}

ksfse_mintr

int ksfse_mintr = 0 with {0, 20s, 0, VIS, "Min TR (ms) [0: Disabled]",}

ksfse_maxtr

int ksfse_maxtr = 0 with {0, 40s, 0, VIS, "Max TR (ms) [0: Disabled]",}

ksfse

KSFSE_SEQUENCE ksfse = KSFSE_INIT_SEQUENCE

Main FSE sequence

ksfse_loopctrl

KSSCAN_LOOP_CONTROL ksfse_loopctrl = KSSCAN_INIT_LOOP_CONTROL

Scan loop control for the ksfse sequence (without inversion)

ksfse_inv

KSINV_MODULE ksfse_inv = KSINV_INIT_MODULE

Inversion module

ksfse_inv_loopctrl

KSINV_LOOP_CONTROL ksfse_inv_loopctrl = KSINV_INIT_LOOP_CONTROL

ksfse_phaseencoding_memorypool

KS_PHASEENCODING_COORD ksfse_phaseencoding_memorypool[KSFSE_PHASEENCODING_MEMORYPOOL_SIZE] = {KS_INIT_PHASEENCODING_COORD}

kacq

KS_KSPACE_ACQ kacq = KS_INIT_KSPACE_ACQ

sequence_iopts

int sequence_iopts[]

Initial value:

= {
  PSD_IOPT_ARC, 
  PSD_IOPT_ASSET, 
  PSD_IOPT_EDR, 
  PSD_IOPT_DYNPL, 
  PSD_IOPT_TLRD_RF, 
  PSD_IOPT_MILDNOTE, 
  PSD_IOPT_ZIP_512, 
  PSD_IOPT_FR, 
  PSD_IOPT_T1FLAIR, 
  PSD_IOPT_T2FLAIR, 
  PSD_IOPT_IR_PREP, 








}