Prep sequence module: Spatial Saturation (ksspsat.[h,cc,e])

Data Structures
struct	KSSPSAT_VOLBORDER
struct	KSSPSAT_LOC
struct	KSSPSAT_DESIGN
struct	KSSPSAT_STATE
struct	KSSPSAT_MODULE

Macros
#define	KSSPSAT_DESIGN_EXPLICIT_ON   1
#define	KSSPSAT_MAXNUMSAT_IMPLICIT   6
#define	KSSPSAT_MAXNUMSAT_EXPLICIT   6
#define	KSSPSAT_DEFAULT_FLIP   95
#define	KSSPSAT_DEFAULT_SPOILERAREA   3000
#define	KSSPSAT_DEFAULT_SPOILALLAXES   1
#define	KSSPSAT_DEFAULT_RFSTRETCH   1
#define	KSSPSAT_EXPLICITSAT_DISABLED   9990.0 /* Set by UI on MR-scanner */
#define	KSSPSAT_IMPLICITSAT_DISABLED   9999.0 /* Set by UI on MR-scanner */
#define	KSSPSAT_DEFAULT_SSITIME   1000 /* try to reduce this value */
#define	KSSPSAT_INIT_VOLBORDER   {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}
#define	KSSPSAT_INIT_LOC   {DEFAULT_AXIAL_SCAN_INFO, 0.0, KS_NOTSET, KSSPSAT_OFF}
#define	KSSPSAT_INIT_LOC6   {KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC}
#define	KSSPSAT_INIT_LOC12   {KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC}
#define	KSSPSAT_INIT_IMPLICIT_ARRAY   KS_INITVALUE(KSSPSAT_MAXNUMSAT_IMPLICIT, 0.0)
#define	KSSPSAT_INIT_EXPLICIT_ARRAY   KS_INITVALUE(KSSPSAT_MAXNUMSAT_IMPLICIT, KSSPSAT_OFF)
#define	KSSPSAT_INIT_DESIGN   {KS_INIT_DESC, KSSPSAT_INIT_IMPLICIT_ARRAY /*slthick*/, KSSPSAT_INIT_IMPLICIT_ARRAY /*slthick*/, KSSPSAT_INIT_LOC6, KSSPSAT_DEFAULT_FLIP, KSSPSAT_RF_COMPLEX, KSSPSAT_DEFAULT_RFSTRETCH, KSSPSAT_DEFAULT_SPOILERAREA, KSSPSAT_DEFAULT_SPOILALLAXES, PSD_ON, PSD_OBL_RESTRICT, KSSPSAT_DEFAULT_SSITIME, KS_INIT_LOGGRD}
#define	KSSPSAT_INIT_STATE   {KS_INIT_DESC, KSSPSAT_INIT_VOLBORDER, KSSPSAT_INIT_LOC12, 0, 0, 0, 0}
#define	KSSPSAT_INIT_SELRF6   {KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF}
#define	KSSPSAT_INIT_TRAP6   {KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP}
#define	KSSPSAT_INIT_MODULE   {KSSPSAT_INIT_DESIGN, KSSPSAT_INIT_STATE, KSSPSAT_INIT_SELRF6, KSSPSAT_INIT_TRAP6, 0}

Typedefs
typedef float	KSSPSAT_IMPLICIT_ARRAY[KSSPSAT_MAXNUMSAT_IMPLICIT]
typedef int	KSSPSAT_EXPLICIT_ARRAY[KSSPSAT_MAXNUMSAT_EXPLICIT]

Enumerations
enum	KSSPSAT_MODE { KSSPSAT_OFF, KSSPSAT_IMPLICIT, KSSPSAT_EXPLICIT }
enum	KSSPSAT_MODE_LOCS {   KSSPSAT_IMPL_FREQ_NEG, KSSPSAT_IMPL_FREQ_POS, KSSPSAT_IMPL_PHASE_NEG, KSSPSAT_IMPL_PHASE_POS,   KSSPSAT_IMPL_SLICE_NEG, KSSPSAT_IMPL_SLICE_POS, KSSPSAT_EXPL1, KSSPSAT_EXPL2,   KSSPSAT_EXPL3, KSSPSAT_EXPL4, KSSPSAT_EXPL5, KSSPSAT_EXPL6,   KSSPSAT_MAXNUMSAT }
enum	KSSPSAT_RF_TYPES { KSSPSAT_RF_STD, KSSPSAT_RF_COMPLEX, KSSPSAT_RF_MAXRFTYPES }
enum	KSSPSAT_RF_SIDES { KSSPSAT_NEG =1, KSSPSAT_POS, KSSPSAT_HAD, KSSPSAT_PARA }

Functions
void	ksspsat_init_design (KSSPSAT_DESIGN *ksspsat_design, const char *desc)
void	ksspsat_init_state (KSSPSAT_STATE *ksspsat_state)
STATUS	ksspsat_eval_design_satplacements (KSSPSAT_DESIGN *spsat_design, KSSPSAT_STATE *spsat_state, const SCAN_INFO *ref_scan_info)
STATUS	ksspsat_eval_satplacements_dump (KSSPSAT_STATE *spsat_state)
int	ksspsat_any_implicit (KSSPSAT_DESIGN *spsat_design)
int	ksspsat_any_explicit (KSSPSAT_DESIGN *spsat_design)
int	ksspsat_any_satpulses (KSSPSAT_DESIGN *spsat_design)
STATUS	ksspsat_eval_volborder (KSSPSAT_VOLBORDER *v, SCAN_INFO my_scan_info[KS_MAX_RF_SCANINFO], int nslices, float freq_fov, float phase_fov, float slthick)
STATUS	ksspsat_eval_validatedesign (KSSPSAT_DESIGN *spsat_design)
STATUS	ksspsat_eval_design (KSSPSAT_MODULE *spsat_module, KS_KSPACE_DESIGN *kspace_design, KS_SLICETIMING_DESIGN *slicetiming_design, float slthick)
STATUS	ksspsat_eval (KSSPSAT_MODULE *spsat_module, KS_KSPACE_DESIGN *kspace_design, KS_SLICETIMING_DESIGN *slicetiming_design, float slthick)
STATUS	ksspsat_pg (KSSPSAT_MODULE *spsat_module, int start_time, KS_SEQ_CONTROL *ctrl)
void	ksspsat_scan_seqstate (const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic, KSSPSAT_MODULE *spsat_module)
void	ksspsat_set_design_implicit_from_UI (KSSPSAT_IMPLICIT_ARRAY implicit_slthick)
STATUS	ksspsat_set_design_explicit_from_UI (KSSPSAT_LOC *explicit_locs)
STATUS	ksspsat_set_design_from_UI (KSSPSAT_DESIGN *spsat_design)

Variables
SCAN_INFO	scan_info []
KSSPSAT_MODULE	ksspsat = KSSPSAT_INIT_MODULE

Detailed Description

Macro Definition Documentation

KSSPSAT_DESIGN_EXPLICIT_ON

#define KSSPSAT_DESIGN_EXPLICIT_ON   1

KSSPSAT_MAXNUMSAT_IMPLICIT

#define KSSPSAT_MAXNUMSAT_IMPLICIT   6

KSSPSAT_MAXNUMSAT_EXPLICIT

#define KSSPSAT_MAXNUMSAT_EXPLICIT   6

KSSPSAT_DEFAULT_FLIP

#define KSSPSAT_DEFAULT_FLIP   95

Default flip angle for a saturation pulse

KSSPSAT_DEFAULT_SPOILERAREA

#define KSSPSAT_DEFAULT_SPOILERAREA   3000

Default spoiler area

KSSPSAT_DEFAULT_SPOILALLAXES

#define KSSPSAT_DEFAULT_SPOILALLAXES   1

By default, spoil on all boards

KSSPSAT_DEFAULT_RFSTRETCH

#define KSSPSAT_DEFAULT_RFSTRETCH   1

By default, do not stretch RF pulses

KSSPSAT_EXPLICITSAT_DISABLED

#define KSSPSAT_EXPLICITSAT_DISABLED   9990.0 /* Set by UI on MR-scanner */

KSSPSAT_IMPLICITSAT_DISABLED

#define KSSPSAT_IMPLICITSAT_DISABLED   9999.0 /* Set by UI on MR-scanner */

KSSPSAT_DEFAULT_SSITIME

#define KSSPSAT_DEFAULT_SSITIME   1000 /* try to reduce this value */

KSSPSAT_INIT_VOLBORDER

#define KSSPSAT_INIT_VOLBORDER   {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}

KSSPSAT_INIT_LOC

#define KSSPSAT_INIT_LOC   {DEFAULT_AXIAL_SCAN_INFO, 0.0, KS_NOTSET, KSSPSAT_OFF}

KSSPSAT_INIT_LOC6

#define KSSPSAT_INIT_LOC6   {KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC}

KSSPSAT_INIT_LOC12

#define KSSPSAT_INIT_LOC12   {KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC, KSSPSAT_INIT_LOC}

KSSPSAT_INIT_IMPLICIT_ARRAY

#define KSSPSAT_INIT_IMPLICIT_ARRAY   KS_INITVALUE(KSSPSAT_MAXNUMSAT_IMPLICIT, 0.0)

KSSPSAT_INIT_EXPLICIT_ARRAY

#define KSSPSAT_INIT_EXPLICIT_ARRAY   KS_INITVALUE(KSSPSAT_MAXNUMSAT_IMPLICIT, KSSPSAT_OFF)

KSSPSAT_INIT_DESIGN

#define KSSPSAT_INIT_DESIGN   {KS_INIT_DESC, KSSPSAT_INIT_IMPLICIT_ARRAY /*slthick*/, KSSPSAT_INIT_IMPLICIT_ARRAY /*slthick*/, KSSPSAT_INIT_LOC6, KSSPSAT_DEFAULT_FLIP, KSSPSAT_RF_COMPLEX, KSSPSAT_DEFAULT_RFSTRETCH, KSSPSAT_DEFAULT_SPOILERAREA, KSSPSAT_DEFAULT_SPOILALLAXES, PSD_ON, PSD_OBL_RESTRICT, KSSPSAT_DEFAULT_SSITIME, KS_INIT_LOGGRD}

KSSPSAT_INIT_STATE

#define KSSPSAT_INIT_STATE   {KS_INIT_DESC, KSSPSAT_INIT_VOLBORDER, KSSPSAT_INIT_LOC12, 0, 0, 0, 0}

KSSPSAT_INIT_SELRF6

#define KSSPSAT_INIT_SELRF6   {KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF, KS_INIT_SELRF}

KSSPSAT_INIT_TRAP6

#define KSSPSAT_INIT_TRAP6   {KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP, KS_INIT_TRAP}

KSSPSAT_INIT_MODULE

#define KSSPSAT_INIT_MODULE   {KSSPSAT_INIT_DESIGN, KSSPSAT_INIT_STATE, KSSPSAT_INIT_SELRF6, KSSPSAT_INIT_TRAP6, 0}

Typedef Documentation

KSSPSAT_IMPLICIT_ARRAY

typedef float KSSPSAT_IMPLICIT_ARRAY[KSSPSAT_MAXNUMSAT_IMPLICIT]

KSSPSAT_EXPLICIT_ARRAY

typedef int KSSPSAT_EXPLICIT_ARRAY[KSSPSAT_MAXNUMSAT_EXPLICIT]

Enumeration Type Documentation

KSSPSAT_MODE

enum KSSPSAT_MODE

Enumerator
KSSPSAT_OFF
KSSPSAT_IMPLICIT
KSSPSAT_EXPLICIT

{KSSPSAT_OFF, KSSPSAT_IMPLICIT, KSSPSAT_EXPLICIT} KSSPSAT_MODE;

KSSPSAT_MODE_LOCS

enum KSSPSAT_MODE_LOCS

Enumerator
KSSPSAT_IMPL_FREQ_NEG
KSSPSAT_IMPL_FREQ_POS
KSSPSAT_IMPL_PHASE_NEG
KSSPSAT_IMPL_PHASE_POS
KSSPSAT_IMPL_SLICE_NEG
KSSPSAT_IMPL_SLICE_POS
KSSPSAT_EXPL1
KSSPSAT_EXPL2
KSSPSAT_EXPL3
KSSPSAT_EXPL4
KSSPSAT_EXPL5
KSSPSAT_EXPL6
KSSPSAT_MAXNUMSAT

{KSSPSAT_IMPL_FREQ_NEG, KSSPSAT_IMPL_FREQ_POS, KSSPSAT_IMPL_PHASE_NEG, KSSPSAT_IMPL_PHASE_POS, KSSPSAT_IMPL_SLICE_NEG, KSSPSAT_IMPL_SLICE_POS, KSSPSAT_EXPL1, KSSPSAT_EXPL2, KSSPSAT_EXPL3, KSSPSAT_EXPL4, KSSPSAT_EXPL5, KSSPSAT_EXPL6, KSSPSAT_MAXNUMSAT} KSSPSAT_MODE_LOCS;

KSSPSAT_RF_TYPES

enum KSSPSAT_RF_TYPES

Enumerator
KSSPSAT_RF_STD
KSSPSAT_RF_COMPLEX
KSSPSAT_RF_MAXRFTYPES

{KSSPSAT_RF_STD, KSSPSAT_RF_COMPLEX, KSSPSAT_RF_MAXRFTYPES} KSSPSAT_RF_TYPES; 

KSSPSAT_RF_SIDES

enum KSSPSAT_RF_SIDES

Enumerator
KSSPSAT_NEG
KSSPSAT_POS
KSSPSAT_HAD
KSSPSAT_PARA

{KSSPSAT_NEG=1, KSSPSAT_POS, KSSPSAT_HAD, KSSPSAT_PARA} KSSPSAT_RF_SIDES; 

Function Documentation

ksspsat_init_design()

void ksspsat_init_design	(	KSSPSAT_DESIGN *	ksspsat_design,
		const char *	desc
	)

Initialize the design for a spatial sat module

Parameters

[out]	ksspsat_design	Pointer to the design to be initialized
[in]	desc	Destriction

Return values

void

                                                                         {
  KSSPSAT_DESIGN default_ksspsat_design = KSSPSAT_INIT_DESIGN;
  *spsat_design = default_ksspsat_design;

  if (desc != NULL && strlen(desc) > 0) {
    strcpy(spsat_design->description, desc);
  }

} /* ksspsat_init_design() */

ksspsat_init_state()

void ksspsat_init_state

(

KSSPSAT_STATE *

ksspsat_state

)

Initialize the state for a spatial sat module

Parameters

[out]

ksspsat_state

Pointer to the state to be initialized

Returns

void

                                                      {
  KSSPSAT_STATE default_ksspsat_state = KSSPSAT_INIT_STATE;
  *ksspsat_state = default_ksspsat_state;

} /* ksspsat_init_state() */

ksspsat_eval_design_satplacements()

STATUS ksspsat_eval_design_satplacements	(	KSSPSAT_DESIGN *	spsat_design,
		KSSPSAT_STATE *	spsat_state,
		const SCAN_INFO *	ref_scan_info
	)

Populate the sat band locations according to the design

Parameters

[in]	spsat_design	Pointer to the design
[out]	spsat_state	Pointer to the state whose locations will be populated
[in]	ref_scan_info	Reference slice orientation used for the implicit sat bands

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                     {
  /*STATUS status;
  int j, index;*/
  int i;

  /***************** IMPLICIT SAT (at the FOV edges) *****************/

  /* Init all sat bands to off state */
  for (i = 0; i < KSSPSAT_MAXNUMSAT; i++)
    ksspsat_state->satlocation[i].active = KSSPSAT_OFF;

  /* Init all sat rotations to scan plane */
  for (i = 0; i < KSSPSAT_MAXNUMSAT_IMPLICIT; i++)
    memcpy(ksspsat_state->satlocation[i].loc.oprot, ref_scan_info->oprot, 9 * sizeof(float));

  /* Implicit Sat(s) - Frequency encoding direction */
  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_FREQ_POS] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_POS].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_FREQ_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_POS].active = KSSPSAT_IMPLICIT; 
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_POS].loc.optloc = ksspsat_state->volborder.freq_max + ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_POS].thickness / 2.0 + spsat_design->implicit_shift[KSSPSAT_IMPL_FREQ_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_POS].gradboard = XGRAD;
  }

  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_FREQ_NEG] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_NEG].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_FREQ_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_NEG].active = KSSPSAT_IMPLICIT;
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_NEG].loc.optloc = ksspsat_state->volborder.freq_min - ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_NEG].thickness / 2.0 - spsat_design->implicit_shift[KSSPSAT_IMPL_FREQ_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_FREQ_NEG].gradboard = XGRAD;
  }

  /* Implicit Sat(s) - Phase encoding direction */
  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_PHASE_POS] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_POS].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_PHASE_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_POS].active = KSSPSAT_IMPLICIT;
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_POS].loc.optloc = ksspsat_state->volborder.phase_max + ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_POS].thickness / 2.0 + spsat_design->implicit_shift[KSSPSAT_IMPL_PHASE_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_POS].gradboard = YGRAD;
  }

  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_PHASE_NEG] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_NEG].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_PHASE_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_NEG].active = KSSPSAT_IMPLICIT;
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_NEG].loc.optloc = ksspsat_state->volborder.phase_min - ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_NEG].thickness / 2.0 - spsat_design->implicit_shift[KSSPSAT_IMPL_PHASE_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_PHASE_NEG].gradboard = YGRAD;
  }

  /* Implicit Sat(s) - Slice encoding direction */
  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_SLICE_POS] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_POS].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_SLICE_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_POS].active = KSSPSAT_IMPLICIT;
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_POS].loc.optloc = ksspsat_state->volborder.slice_max + ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_POS].thickness / 2.0 + spsat_design->implicit_shift[KSSPSAT_IMPL_SLICE_POS];
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_POS].gradboard = ZGRAD;
  }

  if (spsat_design->implicit_slthick[KSSPSAT_IMPL_SLICE_NEG] > 0) {
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_NEG].thickness = spsat_design->implicit_slthick[KSSPSAT_IMPL_SLICE_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_NEG].active = KSSPSAT_IMPLICIT;
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_NEG].loc.optloc = ksspsat_state->volborder.slice_min - ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_NEG].thickness / 2.0 - spsat_design->implicit_shift[KSSPSAT_IMPL_SLICE_NEG];
    ksspsat_state->satlocation[KSSPSAT_IMPL_SLICE_NEG].gradboard = ZGRAD;
  }


  /* Explicit Sat(s) */
  for (i = 0; i < KSSPSAT_MAXNUMSAT_EXPLICIT; i++) {
    ksspsat_state->satlocation[KSSPSAT_EXPL1 + i] = spsat_design->explicit_locs[i];
  }

  return SUCCESS;

} /* ksspsat_eval_design_satplacements() */

ksspsat_eval_satplacements_dump()

STATUS ksspsat_eval_satplacements_dump

(

KSSPSAT_STATE *

spsat_state

)

Writes out the geometric information of the active sat bands to spsat.txt

On the MR system (PSD_HW), this file will be located in /usr/g/mrraw, while in simulation it will be located in the current psd directory.

Return values

STATUS

SUCCESS or FAILURE

                                                                     {
  float *rot;
  int i;

#ifdef PSD_HW
#ifdef IPG
  return SUCCESS;
#endif
  FILE *fp = fopen("/usr/g/mrraw/ksspsat.txt", "w");
#else
  FILE *fp = fopen("./ksspsat.txt", "w");
#endif

  for (i = 0; i < KSSPSAT_MAXNUMSAT; i++) {
    fprintf(fp, "Sat Pulse #%d: ", i);
    if (ksspsat_state->satlocation[i].active == KSSPSAT_OFF)
      fprintf(fp, "Off\n");
    else if (ksspsat_state->satlocation[i].active == KSSPSAT_EXPLICIT)
      fprintf(fp, "Explicit\n");
    else if (ksspsat_state->satlocation[i].active == KSSPSAT_IMPLICIT)
      fprintf(fp, "Implicit\n");

    fprintf(fp, "Grad: ");
    if (ksspsat_state->satlocation[i].gradboard == XGRAD)
      fprintf(fp, "XGRAD (Freq)");
    else if (ksspsat_state->satlocation[i].gradboard == YGRAD)
      fprintf(fp, "YGRAD (Phase)");
    else if (ksspsat_state->satlocation[i].gradboard == ZGRAD)
      fprintf(fp, "ZGRAD (Slice)");

    fprintf(fp, "\nThickness: %.2f\n", ksspsat_state->satlocation[i].thickness);
    fprintf(fp, "Location: %.2f\n", ksspsat_state->satlocation[i].loc.optloc);

    rot = ksspsat_state->satlocation[i].loc.oprot;
    fprintf(fp, "Rotation:\n");
    fprintf(fp, "%.3f %.3f %.3f\n%.3f %.3f %.3f\n%.3f %.3f %.3f\n\n", rot[0], rot[3], rot[6], rot[1], rot[4], rot[7], rot[2], rot[5], rot[8]);
  }

  fprintf(fp, "Volume borders:\n-  Freq: %.2f %.2f\n- Phase: %.2f %.2f\n- Slice: %.2f %.2f\n", ksspsat_state->volborder.freq_min, ksspsat_state->volborder.freq_max, ksspsat_state->volborder.phase_min, ksspsat_state->volborder.phase_max, ksspsat_state->volborder.slice_min, ksspsat_state->volborder.slice_max);

  rot = scan_info[0].oprot;
  fprintf(fp, "\nSlice rotation:\n");
  fprintf(fp, "%.3f %.3f %.3f\n%.3f %.3f %.3f\n%.3f %.3f %.3f\n\n", rot[0], rot[3], rot[6], rot[1], rot[4], rot[7], rot[2], rot[5], rot[8]);



  fclose(fp);

  return SUCCESS;

} /* ksspsat_eval_satplacements_dump() */

ksspsat_any_implicit()

int ksspsat_any_implicit

(

KSSPSAT_DESIGN *

spsat_design

)

Returns if any implicit sat bands is active

Parameters

[in]

spsat_design

Pointer to the design

Return values

TRUE	(1) or FALSE (0)

                                                       {
  return (spsat_design->implicit_slthick[0] > 0 ||
            spsat_design->implicit_slthick[1] > 0 ||
            spsat_design->implicit_slthick[2] > 0 ||
            spsat_design->implicit_slthick[3] > 0 ||
            spsat_design->implicit_slthick[4] > 0 ||
            spsat_design->implicit_slthick[5] > 0);

} /* ksspsat_any_implicit() */

ksspsat_any_explicit()

int ksspsat_any_explicit

(

KSSPSAT_DESIGN *

spsat_design

)

Returns if any explicit sat bands is active

Parameters

[in]

spsat_design

Pointer to the design

Return values

TRUE	(1) or FALSE (0)

                                                       {
  return (spsat_design->explicit_locs[0].active != KSSPSAT_OFF ||      
            spsat_design->explicit_locs[1].active != KSSPSAT_OFF ||
            spsat_design->explicit_locs[2].active != KSSPSAT_OFF ||
            spsat_design->explicit_locs[3].active != KSSPSAT_OFF ||
            spsat_design->explicit_locs[4].active != KSSPSAT_OFF ||
            spsat_design->explicit_locs[5].active != KSSPSAT_OFF);

} /* ksspsat_any_explicit() */

ksspsat_any_satpulses()

int ksspsat_any_satpulses

(

KSSPSAT_DESIGN *

spsat_design

)

Returns if any sat bands is active

Parameters

[in]

spsat_design

Pointer to the design

Return values

TRUE	(1) or FALSE (0)

                                                        {
  return (ksspsat_any_implicit(spsat_design) || ksspsat_any_explicit(spsat_design));

} /* ksspsat_any_satpulses() */

ksspsat_eval_volborder()

STATUS ksspsat_eval_volborder	(	KSSPSAT_VOLBORDER *	v,
		SCAN_INFO	my_scan_info[KS_MAX_RF_SCANINFO],
		int	nslices,
		float	freq_fov,
		float	phase_fov,
		float	slthick
	)

Get the FOV volume borders in mm from the isocenter

The FOV volume depends on the positions and thickness of the slices to be excited by the main module. This assumes that all slices have the same orientation.

Parameters

[out]	v	The calculated FOV volume
[in]	my_scan_info	The locations for the slices
[in]	nslices	The number of slices
[in]	freq_fov	FOV along the frequency encoding direction
[in]	phase_fov	FOV along the phase encoding direction
[in]	slthick	Slice thickness

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                             {
  int i;

  v->freq_min = my_scan_info[0].oprloc;
  v->freq_max = my_scan_info[0].oprloc;
  v->phase_min = my_scan_info[0].opphasoff;
  v->phase_max = my_scan_info[0].opphasoff;
  v->slice_min = my_scan_info[0].optloc;
  v->slice_max = my_scan_info[0].optloc;

  for (i = 1; i < nslices; i++) {
    if (my_scan_info[i].oprloc > v->freq_max)
      v->freq_max = my_scan_info[i].oprloc;
    else if (my_scan_info[i].oprloc < v->freq_min)
      v->freq_min = my_scan_info[i].oprloc;

    if (my_scan_info[i].opphasoff > v->phase_max)
      v->phase_max = my_scan_info[i].opphasoff;
    else if (my_scan_info[i].opphasoff < v->phase_min)
      v->phase_min = my_scan_info[i].opphasoff;

    if (my_scan_info[i].optloc > v->slice_max)
      v->slice_max = my_scan_info[i].optloc;
    else if (my_scan_info[i].optloc < v->slice_min)
      v->slice_min = my_scan_info[i].optloc;
  }


  v->freq_min -= freq_fov / 2.0;
  v->freq_max += freq_fov / 2.0;
  v->phase_min -= phase_fov / 2.0;
  v->phase_max += phase_fov / 2.0;
  v->slice_min -= slthick / 2.0;
  v->slice_max += slthick / 2.0;

  return SUCCESS;

} /* ksspsat_eval_volborder() */

ksspsat_eval_validatedesign()

STATUS ksspsat_eval_validatedesign

(

KSSPSAT_DESIGN *

spsat_design

)

Validate the design

Parameters

[in]

spsat_design

Pointer to the design to be validated

Return values

STATUS

SUCCESS or FAILURE, the latter means the design is not valid

                                                                 {

  if (areSame(spsat_design->rfstretch, 1.0) == FALSE && spsat_design->rftype == KSSPSAT_RF_COMPLEX){
    return KS_THROW("You cannot stretch rfpulse type KSSPSAT_RF_COMPLEX (spsatc_satqptbw12) since it is phase modulated");
  }

  return SUCCESS;

} /* ksspsat_eval_validatedesign() */

ksspsat_eval_design()

STATUS ksspsat_eval_design	(	KSSPSAT_MODULE *	spsat_module,
		KS_KSPACE_DESIGN *	kspace_design,
		KS_SLICETIMING_DESIGN *	slicetiming_design,
		float	slthick
	)

Evaluate the design of the spatial sat module in order to calculate its state

Parameters

[out]	spsat_module	Pointer to the spatial sat module to be evaluated
[in]	kspace_design	Pointer to the k-space design of the main module, needed for FOV and resolution
[in]	slicetiming_design	Pointer to the slice timing design, needed for the slice locations
[in]	slthick	Slice thickness

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                    {
  STATUS status;
  KS_DESCRIPTION tmpdesc;
  int i;

  int nslices = kspace_design->res[ZGRAD] > 0 ? 1 : IMax(2, slicetiming_design->nslices, kspace_design->res[ZGRAD]); /* 3D multislab not implemented */
  spsat_module->state.N_impl_sat_pulses = 0;
  spsat_module->state.N_expl_sat_pulses = 0; 

  status = ksspsat_eval_volborder(&spsat_module->state.volborder, slicetiming_design->scan_info, nslices, kspace_design->fov[XGRAD], kspace_design->fov[YGRAD], slthick);
  KS_RAISE(status);

  status = ksspsat_eval_design_satplacements(&spsat_module->design, &spsat_module->state, &slicetiming_design->scan_info[0]);
  KS_RAISE(status);

  /* up to 6 (KSSPSAT_MAXNUMSAT) selective RF pulses */
  for (i = 0; i < KSSPSAT_MAXNUMSAT; i++) {
    if (spsat_module->state.satlocation[i].active == KSSPSAT_OFF) {
      continue;
    }

    if (spsat_module->state.satlocation[i].active == KSSPSAT_IMPLICIT) {
      spsat_module->state.N_impl_sat_pulses += 1;
    } else {
      spsat_module->state.N_expl_sat_pulses += 1;
    }

    if (spsat_module->design.rftype == KSSPSAT_RF_COMPLEX){
      /* Theta modulated pulse NOT stretchable */
      spsat_module->selrf[i].rf = spsatc_satqptbw12; /* KSFoundation_GERF.h */
    } else {
      spsat_module->selrf[i].rf = spsat_dblsatl0; /* KSFoundation_GERF.h */
    }

    ks_eval_stretch_rf(&spsat_module->selrf[i].rf, spsat_module->design.rfstretch);

    spsat_module->selrf[i].rf.flip = spsat_module->design.flip;
    spsat_module->selrf[i].slthick = spsat_module->state.satlocation[i].thickness;
    ks_create_suffixed_description(tmpdesc, spsat_module->design.description, "_selrf%d", i);

    status = ks_eval_selrf_constrained(&spsat_module->selrf[i], tmpdesc,
                                       ks_syslimits_ampmax(spsat_module->design.loggrad),
                                       ks_syslimits_slewrate(spsat_module->design.loggrad));
    KS_RAISE(status);

    /* spoiler */
    spsat_module->spoiler[i].area = spsat_module->design.spoilerarea;
    ks_create_suffixed_description(tmpdesc, spsat_module->design.description, "_spoiler%d", i);
    status = ks_eval_trap_rotation_invariant_75_max_slewrate(&spsat_module->spoiler[i], tmpdesc);
    KS_RAISE(status);
  }

  return SUCCESS;

} /* ksspsat_eval_design() */

ksspsat_eval()

STATUS ksspsat_eval	(	KSSPSAT_MODULE *	spsat_module,
		KS_KSPACE_DESIGN *	kspace_design,
		KS_SLICETIMING_DESIGN *	slicetiming_design,
		float	slthick
	)

Helper function that performs all eval functions in order

Initialize the state, validate the design, evaluate the design and log the sat band's location

Parameters

[out]	spsat_module	Pointer to the spatial sat module to be evaluated
[in]	kspace_design	Pointer to the k-space design of the main module, needed for FOV and resolution
[in]	slicetiming_design	Pointer to the slice timing design, needed for the slice locations
[in]	slthick	Slice thickness

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                             {
  STATUS status;

  ksspsat_init_state(&spsat_module->state);

  /* return early if spsat turned off */
  if (ksspsat_any_satpulses(&spsat_module->design) == FALSE) {
    return SUCCESS;
  }

  status = ksspsat_eval_validatedesign(&spsat_module->design);
  KS_RAISE(status);

  status = ksspsat_eval_design(spsat_module, kspace_design, slicetiming_design, slthick);
  KS_RAISE(status);

  status = ksspsat_eval_satplacements_dump(&spsat_module->state);
  KS_RAISE(status);

  return SUCCESS;

} /* ksspsat_eval() */

ksspsat_pg()

STATUS ksspsat_pg	(	KSSPSAT_MODULE *	spsat_module,
		int	start_time,
		KS_SEQ_CONTROL *	ctrl
	)

Place all waveforms for the spatial sat module

Parameters

[out]	spsat_module	Pointer to the spatial sat module
[in]	start_time	Start time within the relevant KS_SEQ_CONTROL, mostly used when embadding the spsat module into an external KS_SEQ_CONTROL
[in,out]	ctrl	Pointer to the KS_SEQ_CONTROL the spsat module will be embedded into. If NULL, it is assumed that the spsat module is indipendet and will use its own internal KS_SEQ_CONTROL.

Return values

STATUS

SUCCESS or FAILURE

                                                                                      {
  STATUS status;
  KS_SEQLOC tmploc = KS_INIT_SEQLOC;
  int i, j;

  /* return early if no spsat pulses active */
  if (spsat_module->state.N_impl_sat_pulses + spsat_module->state.N_expl_sat_pulses == 0) {
    spsat_module->state.duration = 0;
    spsat_module->end_time = start_time;
    return SUCCESS;
  }

  tmploc.pos = RUP_GRD(IMax(2, KS_RFSSP_PRETIME + 32, start_time));

  /* up to 12 selective RF */
  for (i = 0; i < KSSPSAT_MAXNUMSAT; i++) {
    if (spsat_module->state.satlocation[i].active == KSSPSAT_OFF) {
      continue;
    }

    /* SelRF */
    tmploc.board = spsat_module->state.satlocation[i].gradboard;
    status = ks_pg_selrf(&spsat_module->selrf[i], tmploc, ctrl);      
    KS_RAISE(status);

    if (spsat_module->state.satlocation[i].active == KSSPSAT_EXPLICIT) {
      for (j = XGRAD; j<=ZGRAD; ++j) {
        if (j == spsat_module->state.satlocation[i].gradboard) {
          continue;
        }
        tmploc.board = j;
        status = ks_pg_trap(&spsat_module->selrf[i].grad, tmploc, ctrl);
        KS_RAISE(status);
      }        
    }

    tmploc.pos += spsat_module->selrf[i].grad.duration;

    /* Spoiler */
    for (j = XGRAD; j<=ZGRAD; ++j) {
      if (j != ZGRAD && !spsat_module->design.spoilallaxes) {
        continue;
      }
      tmploc.board = j;
      status = ks_pg_trap(&spsat_module->spoiler[i], tmploc, ctrl);
      KS_RAISE(status);
    }

    tmploc.pos += IMax(2, KS_RFSSP_PRETIME + KS_RFSSP_POSTTIME, spsat_module->spoiler[i].duration);
  }

  spsat_module->state.duration = tmploc.pos-start_time;
  spsat_module->end_time = tmploc.pos;
#ifdef HOST_TGT
  ctrl->ssi_time = spsat_module->design.ssi_time;
  ks_eval_seqctrl_setminduration(ctrl, spsat_module->end_time);
#endif

  return SUCCESS;

} /* ksspsat_pg() */

ksspsat_scan_seqstate()

void ksspsat_scan_seqstate	(	const SCAN_INFO *	slice_pos,
		KS_DYNAMIC_STATE *	dynamic,
		KSSPSAT_MODULE *	spsat_module
	)

Change the dynamic state for a spatial sat module

Parameters

[in]	slice_pos	Slice orientation for the current slice
	dynamic	Dynamic parameters, used for updating the sat band locations according to the Mphysical and Mlogical transformations. The former is used for prospective motion correction while the latter is used for, e.g, rotating the blades in a PROPELLER sequence.
[in,out]	spsat_module	Pointer to the spatial sat module

Returns

void

                                                  {
#ifdef IPG
  int i, j;
  float rfphase = 0;

  if (spsat->state.N_impl_sat_pulses == 0 && spsat->state.N_expl_sat_pulses == 0) {
    return;
  }

  /* Rotation */
  SCAN_INFO slice_info_updated = slice_info != NULL ? *slice_info : spsat->state.satlocation[0].loc;
  if (dynamic != NULL) {
    ks_scan_update_slice_location(&slice_info_updated, slice_info_updated, dynamic->Mphysical, dynamic->Mlogical);
  }
  ks_scan_rotate(slice_info_updated);

  if (spsat->design.rf_spoiling_flag == PSD_ON){
    rfphase = ks_scan_rf_phase_spoiling(spsat->state.rf_counter);
    spsat->state.rf_counter++;
  }

  for (i = 0; i < KSSPSAT_MAXNUMSAT; i++) {
    if (spsat->state.satlocation[i].active == KSSPSAT_OFF) { continue; }

    ks_scan_selrf_setfreqphase(&spsat->selrf[i], 0, spsat->state.satlocation[i].loc, rfphase);

    if (spsat->state.satlocation[i].active == KSSPSAT_EXPLICIT) {
      /* rotate manually by scaling the slice selection gradients */
      float v[] = {0, 0, 1};
      float w[3];
      ks_mat3f_apply(w, spsat->state.satlocation[i].loc.oprot, v);
      ks_mat3f_invapply(v, slice_info_updated.oprot, w);
      for (j=0; j<3; ++j) {
        ks_scan_trap_ampscale(&spsat->selrf[i].grad, j, v[j]);
      }
    }
  }
#endif
}

ksspsat_set_design_implicit_from_UI()

void ksspsat_set_design_implicit_from_UI

(

KSSPSAT_IMPLICIT_ARRAY

implicit_slthick

)

Populate an array of implict sat band's thickness values according to the scanner's UI

Parameters

[out]

implicit_slthick

Array of implict sat band's thickness values

                                                                                  {

  if ((opsatx == KSSPSAT_POS || opsatx == KSSPSAT_PARA || opsatx == KSSPSAT_HAD) && exist(opdfsathick2) > 0) {
    implicit_slthick[KSSPSAT_IMPL_FREQ_POS] = opdfsathick2;
  }
  if ((opsatx == KSSPSAT_NEG || opsatx == KSSPSAT_PARA || opsatx == KSSPSAT_HAD) && exist(opdfsathick1) > 0) {
    implicit_slthick[KSSPSAT_IMPL_FREQ_NEG] = opdfsathick1;
  }

  if ((opsaty == KSSPSAT_POS || opsaty == KSSPSAT_PARA || opsaty == KSSPSAT_HAD) && exist(opdfsathick4) > 0) {
    implicit_slthick[KSSPSAT_IMPL_PHASE_POS] = opdfsathick4;
  }
  if ((opsaty == KSSPSAT_NEG || opsaty == KSSPSAT_PARA || opsaty == KSSPSAT_HAD) && exist(opdfsathick3) > 0) {
    implicit_slthick[KSSPSAT_IMPL_PHASE_NEG] = opdfsathick3;
  }

  if ((opsatz == KSSPSAT_POS || opsatz == KSSPSAT_PARA || opsatz == KSSPSAT_HAD) && exist(opdfsathick6) > 0) {
    implicit_slthick[KSSPSAT_IMPL_SLICE_POS] = opdfsathick6;
  }
  if ((opsatz == KSSPSAT_NEG || opsatz == KSSPSAT_PARA || opsatz == KSSPSAT_HAD) && exist(opdfsathick5) > 0) {
    implicit_slthick[KSSPSAT_IMPL_SLICE_NEG] = opdfsathick5;
  }

} /* ksspsat_set_design_implicit_from_UI() */

ksspsat_set_design_explicit_from_UI()

STATUS ksspsat_set_design_explicit_from_UI

(

KSSPSAT_LOC *

explicit_locs

)

Populate an array of explicit sat band locations according to the scanner's UI

Parameters

[out]

explicit_locs

Array of explicit sat band locations

Return values

STATUS

SUCCESS or FAILURE

                                                                       {
  if (!explicit_locs) {
    KS_THROW("null input");
  }

  int i = 0;
  int exsat_mask = 1;
  for (; i < KSSPSAT_MAXNUMSAT_EXPLICIT; ++i, exsat_mask = exsat_mask << 1) {
    if (!(opexsatmask & exsat_mask)) {
      continue;
    }

    explicit_locs[i].active = KSSPSAT_EXPLICIT;
    explicit_locs[i].gradboard = ZGRAD;

    /* Copy the rotation matrix */
    explicit_locs[i].loc.oprot[0] = eg_sat_rot[i][0];
    explicit_locs[i].loc.oprot[1] = eg_sat_rot[i][3];
    explicit_locs[i].loc.oprot[2] = eg_sat_rot[i][6];
    explicit_locs[i].loc.oprot[3] = eg_sat_rot[i][1];
    explicit_locs[i].loc.oprot[4] = eg_sat_rot[i][4];
    explicit_locs[i].loc.oprot[5] = eg_sat_rot[i][7];
    explicit_locs[i].loc.oprot[6] = eg_sat_rot[i][2];
    explicit_locs[i].loc.oprot[7] = eg_sat_rot[i][5];
    explicit_locs[i].loc.oprot[8] = eg_sat_rot[i][8];
  }

  explicit_locs[0].thickness = opexsathick1;
  explicit_locs[0].loc.optloc = opexsatloc1;
  explicit_locs[1].thickness = opexsathick2;
  explicit_locs[1].loc.optloc = opexsatloc2;
  explicit_locs[2].thickness = opexsathick3;
  explicit_locs[2].loc.optloc = opexsatloc3;
  explicit_locs[3].thickness = opexsathick4;
  explicit_locs[3].loc.optloc = opexsatloc4;
  explicit_locs[4].thickness = opexsathick5;
  explicit_locs[4].loc.optloc = opexsatloc5;
  explicit_locs[5].thickness = opexsathick6;
  explicit_locs[5].loc.optloc = opexsatloc6;

  return SUCCESS;

} /* ksspsat_set_design_explicit_from_UI() */

ksspsat_set_design_from_UI()

STATUS ksspsat_set_design_from_UI

(

KSSPSAT_DESIGN *

spsat_design

)

Set the design values of a spatial sat module according to the scanner's UI

Parameters

[out]

spsat_design

Pointer to a spatial sat's design

Return values

STATUS

SUCCESS or FAILURE

                                                                {
  STATUS status;

  ksspsat_init_design(spsat_design, "SpSat");

  ksspsat_set_design_implicit_from_UI(spsat_design->implicit_slthick);

  status = ksspsat_set_design_explicit_from_UI(spsat_design->explicit_locs);
  KS_RAISE(status);

  int initnewgeo = 1;
  status = obloptimize_epi(&spsat_design->loggrad, &phygrd, scan_info, 1, spsat_design->oblmethod, exist(opcoax), PSD_ON, 0, &initnewgeo, cfsrmode);
  KS_RAISE(status);

  return SUCCESS;

} /* ksspsat_set_design_from_UI() */

Variable Documentation

scan_info

SCAN_INFO scan_info[]

ksspsat

KSSPSAT_MODULE ksspsat = KSSPSAT_INIT_MODULE