Sequence-independent RF & slicetiming for sequence generators (ksdesign.[h,cc])

Data Structures
struct	KS_SELRF_DESIGN
struct	KS_KSPACE_DESIGN
struct	KS_READWAVE_DESIGN
struct	KS_ECHOTRAIN_DESIGN

Macros
#define	KS_INIT_SELRF_EXCDESIGN   {KS_INIT_DESC, KS_NOTSET, 90, 0.9, 1.0, 0, 0, 0.0, 0.0, EXC_2D, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}
#define	KS_INIT_SELRF_REFDESIGN   {KS_INIT_DESC, KS_NOTSET, 180, 0.9, 1.0, 2.0, 1, 0.0, 0.0, REF_2D, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}
#define	KS_INIT_SELRF_INVDESIGN   {KS_INIT_DESC, KS_NOTSET, 180, 0.9, 1.0, 0, 0, 0.0, 0.0, INV_STD, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}
#define	KS_SPACE_DESIGN_VERSION   1
#define	KS_INIT_KSPACE_2D_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,KS_NOTSET}, {320,320,KS_NOTSET}, 0, {0,0,0}, {1,1,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 31.25, KS_EPI_POSBLIPS, 0, 0, 1}
#define	KS_INIT_KSPACE_3D_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,160}, {240,240,160}, 0, {0,0,0}, {1,1,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 62.5, KS_EPI_POSBLIPS, 0, 0, 1}
#define	KS_INIT_KSPACE_EPI_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,KS_NOTSET}, {180,180,KS_NOTSET}, 1, {0,0,0}, {1,2,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 250.0, KS_EPI_POSBLIPS, 0, 0, 1}
#define	KS_INIT_READWAVE_DESIGN   {NULL, 0, 1, 0.0, KS_NOTSET, KS_INIT_CRUSHER_CONSTRAINT, KS_INIT_CRUSHER_CONSTRAINT}
#define	KS_INIT_ECHOTRAIN_DESIGN   {KS_INITVALUE(KS_MAXUNIQUE_READ,KS_INIT_READ_CONTROL), {KS_INIT_READWAVE_DESIGN}, 0}

Enumerations
enum	RFEXC_SELECTION {   EXC_2D, EXC_FAST_2D, EXC_3D, EXC_FAST_3D,   EXC_SPSP, EXC_SPSP_3D, EXC_FAST_SPSP_3D, EXC_HARD,   EXC_HARD_LOWFAT, EXC_BINO_2, EXC_LOWSAR, EXC_CUSTOM }
enum	RFREF_SELECTION {   REF_SHARP_2D, REF_2D_FIRST, REF_2D, REF_FAST_2D,   REF_EXTREM_FAST_2D, REF_HARD, REF_LOWSAR, REF_CUSTOM }
enum	RFINV_SELECTION { INV_STD, INV_ADIABATIC, INV_LOWSAR, INV_CUSTOM }
enum	KSPACE_DESIGN_COMPRESSED_BAM_MODE { KSPACE_DESIGN_COMPRESSED_BAM_OFF, KSPACE_DESIGN_COMPRESSED_BAM_ON }
enum	KS_MULTISHOT_MODE { KS_MULTISHOT_OFF, KS_MULTISHOT_ALLVOLS, KS_MULTISHOT_1STVOL, KS_MULTISHOT_B0VOLS }

Functions
STATUS	ks_init_design_kdesign (KS_KSPACE_DESIGN *kdesign)
void	ks_init_design_readwave (KS_READWAVE_DESIGN *readwave_design)
STATUS	ks_init_design_selrfexc (KS_SELRF_DESIGN *excdesign)
STATUS	ks_init_design_selrfref (KS_SELRF_DESIGN *refdesign)
STATUS	ks_init_design_selrfinv (KS_SELRF_DESIGN *invdesign)
STATUS	ks_eval_validate_kspacedesign (const KS_KSPACE_DESIGN *kdesign, const char *desc)
STATUS	ks_eval_design_readtrap (KS_READTRAP *trap, const KS_KSPACE_DESIGN *kdesign, const float crusher_area, const char *desc)
STATUS	ks_eval_design_readwave (KS_READWAVE *readwave, const KS_READWAVE_DESIGN *design, const KS_KSPACE_DESIGN *kdesign, const char *desc)
STATUS	ks_eval_design_echotrain (KS_ECHOTRAIN *echotrain, const KS_ECHOTRAIN_DESIGN *design, const KS_KSPACE_DESIGN *kdesign, const char *desc)
STATUS	ks_eval_design_selrfexc (KS_SELRF *selrfexc, const KS_SELRF_DESIGN excdesign)
STATUS	ks_eval_design_selrfref (KS_SELRF *selrfref, const KS_SELRF_DESIGN refdesign)
STATUS	ks_eval_design_selrfinv (KS_SELRF *selrfinv, const KS_SELRF_DESIGN invdesign)
void	ks_print_kdesign (const KS_KSPACE_DESIGN *const kdesign, const char *suffix, int rhkacq_uid)

Detailed Description

Macro Definition Documentation

KS_INIT_SELRF_EXCDESIGN

#define KS_INIT_SELRF_EXCDESIGN   {KS_INIT_DESC, KS_NOTSET, 90, 0.9, 1.0, 0, 0, 0.0, 0.0, EXC_2D, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}

Default values for KS_SELRF_DESIGN for excitation pulses

KS_INIT_SELRF_REFDESIGN

#define KS_INIT_SELRF_REFDESIGN   {KS_INIT_DESC, KS_NOTSET, 180, 0.9, 1.0, 2.0, 1, 0.0, 0.0, REF_2D, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}

Default values for KS_SELRF_DESIGN for excitation pulses

KS_INIT_SELRF_INVDESIGN

#define KS_INIT_SELRF_INVDESIGN   {KS_INIT_DESC, KS_NOTSET, 180, 0.9, 1.0, 0, 0, 0.0, 0.0, INV_STD, 1, 0.0, KS_SELRF_SMS_PHAS_MOD_PHAS, NULL, NULL}

Default values for KS_SELRF_DESIGN for excitation pulses

KS_SPACE_DESIGN_VERSION

#define KS_SPACE_DESIGN_VERSION   1

KS_INIT_KSPACE_2D_DESIGN

#define KS_INIT_KSPACE_2D_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,KS_NOTSET}, {320,320,KS_NOTSET}, 0, {0,0,0}, {1,1,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 31.25, KS_EPI_POSBLIPS, 0, 0, 1}

Default values for KS_KSPACE_DESIGN for 2D scans

KS_INIT_KSPACE_3D_DESIGN

#define KS_INIT_KSPACE_3D_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,160}, {240,240,160}, 0, {0,0,0}, {1,1,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 62.5, KS_EPI_POSBLIPS, 0, 0, 1}

Default values for KS_KSPACE_DESIGN for 3D scans

KS_INIT_KSPACE_EPI_DESIGN

#define KS_INIT_KSPACE_EPI_DESIGN   {KS_SPACE_DESIGN_VERSION, KS_INIT_DESC, {240,240,KS_NOTSET}, {180,180,KS_NOTSET}, 1, {0,0,0}, {1,2,1}, 1, 0, {KS_NOTSET,0,0}, {KS_NOTSET,0,0}, KSPACE_DESIGN_COMPRESSED_BAM_OFF, 250.0, KS_EPI_POSBLIPS, 0, 0, 1}

Default values for KS_KSPACE_DESIGN for 2D EPI scans

KS_INIT_READWAVE_DESIGN

#define KS_INIT_READWAVE_DESIGN   {NULL, 0, 1, 0.0, KS_NOTSET, KS_INIT_CRUSHER_CONSTRAINT, KS_INIT_CRUSHER_CONSTRAINT}

KS_INIT_ECHOTRAIN_DESIGN

#define KS_INIT_ECHOTRAIN_DESIGN   {KS_INITVALUE(KS_MAXUNIQUE_READ,KS_INIT_READ_CONTROL), {KS_INIT_READWAVE_DESIGN}, 0}

Enumeration Type Documentation

RFEXC_SELECTION

enum RFEXC_SELECTION

Enumerator
EXC_2D
EXC_FAST_2D
EXC_3D
EXC_FAST_3D
EXC_SPSP
EXC_SPSP_3D
EXC_FAST_SPSP_3D
EXC_HARD
EXC_HARD_LOWFAT
EXC_BINO_2
EXC_LOWSAR
EXC_CUSTOM

{EXC_2D, EXC_FAST_2D, EXC_3D, EXC_FAST_3D, EXC_SPSP, EXC_SPSP_3D, EXC_FAST_SPSP_3D, EXC_HARD, EXC_HARD_LOWFAT, EXC_BINO_2, EXC_LOWSAR, EXC_CUSTOM} RFEXC_SELECTION; 

RFREF_SELECTION

enum RFREF_SELECTION

Enumerator
REF_SHARP_2D
REF_2D_FIRST
REF_2D
REF_FAST_2D
REF_EXTREM_FAST_2D
REF_HARD
REF_LOWSAR
REF_CUSTOM

{REF_SHARP_2D, REF_2D_FIRST, REF_2D, REF_FAST_2D, REF_EXTREM_FAST_2D, REF_HARD, REF_LOWSAR, REF_CUSTOM} RFREF_SELECTION; 

RFINV_SELECTION

enum RFINV_SELECTION

Enumerator
INV_STD
INV_ADIABATIC
INV_LOWSAR
INV_CUSTOM

{INV_STD, INV_ADIABATIC, INV_LOWSAR, INV_CUSTOM} RFINV_SELECTION;  

KSPACE_DESIGN_COMPRESSED_BAM_MODE

enum KSPACE_DESIGN_COMPRESSED_BAM_MODE

Enumerator
KSPACE_DESIGN_COMPRESSED_BAM_OFF
KSPACE_DESIGN_COMPRESSED_BAM_ON

{KSPACE_DESIGN_COMPRESSED_BAM_OFF, KSPACE_DESIGN_COMPRESSED_BAM_ON} KSPACE_DESIGN_COMPRESSED_BAM_MODE; 

KS_MULTISHOT_MODE

enum KS_MULTISHOT_MODE

Enums to switch between multishot vs. parallel imaging modes (EPI sequences, ksepi_scan_domultishot()). May be discontinued in the future, solely using FLEET calibration

Enumerator
KS_MULTISHOT_OFF	0: All volumes are undersampled by R = #shots
KS_MULTISHOT_ALLVOLS	1: All volumes are fully sampled (multi-shot)
KS_MULTISHOT_1STVOL	2: 1st volume is fully sampled (multi-shot), remaining are undersampled by R = #shots
KS_MULTISHOT_B0VOLS	Diffusion only: b=0 volumes are fully sampled (multi-shot), DWIs are undersampled by R = #shots

             {
  KS_MULTISHOT_OFF, 
  KS_MULTISHOT_ALLVOLS, 
  KS_MULTISHOT_1STVOL, 
  KS_MULTISHOT_B0VOLS, 
} KS_MULTISHOT_MODE;

Function Documentation

ks_init_design_kdesign()

STATUS ks_init_design_kdesign

(

KS_KSPACE_DESIGN *

kdesign

)

Clear the contents of KS_KSPACE_DESIGN

                                                         {
  KS_KSPACE_DESIGN default_kdesign = KS_INIT_KSPACE_2D_DESIGN;
  *kdesign = default_kdesign;

  return SUCCESS;

} /* ks_init_design_kdesign() */

ks_init_design_readwave()

void ks_init_design_readwave

(

KS_READWAVE_DESIGN *

readwave_design

)

ADDTITLEHERE

ADDDESCHERE

Parameters

readwave_design

ADDTEXTHERE

Returns

void

                                                                  {
  KS_READWAVE_DESIGN default_readwave_design = KS_INIT_READWAVE_DESIGN;
  *readwave_design = default_readwave_design;

} /* ks_init_design_readwave() */

ks_init_design_selrfexc()

STATUS ks_init_design_selrfexc

(

KS_SELRF_DESIGN *

excdesign

)

Clear the contents of KS_SELRF_DESIGN and use excitation defaults

                                                           {
  KS_SELRF_DESIGN default_excdesign = KS_INIT_SELRF_EXCDESIGN;
  *excdesign = default_excdesign;

  return SUCCESS;

} /* ks_init_design_selrfexc() */

ks_init_design_selrfref()

STATUS ks_init_design_selrfref

(

KS_SELRF_DESIGN *

refdesign

)

Clear the contents of KS_SELRF_DESIGN and use refocusing defaults

                                                           {
  KS_SELRF_DESIGN default_refdesign = KS_INIT_SELRF_REFDESIGN;
  *refdesign = default_refdesign;

  return SUCCESS;

} /* ks_init_design_selrfref() */

ks_init_design_selrfinv()

STATUS ks_init_design_selrfinv

(

KS_SELRF_DESIGN *

invdesign

)

Clear the contents of KS_SELRF_DESIGN and use inversion defaults

                                                           {
  KS_SELRF_DESIGN default_invdesign = KS_INIT_SELRF_INVDESIGN;
  *invdesign = default_invdesign;

  return SUCCESS;

} /* ks_init_design_selrfinv() */

ks_eval_validate_kspacedesign()

STATUS ks_eval_validate_kspacedesign	(	const KS_KSPACE_DESIGN *	kdesign,
		const char *	desc
	)

Function that performs range checks for the fields in KS_KSPACE_DESIGN before it is used

Parameters

[in]	kdesign	Pointer to KS_KSPACE_DESIGN
[in]	desc	Description for error messages

Return values

STATUS

SUCCESS or FAILURE

                                                                                        {

  if (kdesign->res[XGRAD] % 2 || kdesign->res[XGRAD] < 2) {
    KS_THROW("res[XGRAD] (%d) cannot be odd or negative", kdesign->res[XGRAD]);
    return ADVISORY_FAILURE;
  }
  if (kdesign->res[ZGRAD] == 0) {
    KS_THROW("res[ZGRAD] cannot be 0. Set to KS_NOTSET for 2D");
    return ADVISORY_FAILURE;
  }
  if (kdesign->res[ZGRAD] < KS_NOTSET) {
    KS_THROW("res[ZGRAD] cannot be %d. Set to KS_NOTSET for 2D", kdesign->res[ZGRAD]);
    return ADVISORY_FAILURE;
  }
  if ((kdesign->nover[XGRAD] != 0) + (kdesign->nover[YGRAD] != 0) + (kdesign->nover[ZGRAD] != 0) > 1) {
    KS_THROW("cannot do partial fourier in more than one direction at a time.");
    return ADVISORY_FAILURE;
  }
  if ((kdesign->nover[XGRAD] + kdesign->nover[YGRAD] + kdesign->nover[ZGRAD]) % 2 != 0) {
    KS_THROW("nover must be a multiple of 2");
    return ADVISORY_FAILURE;
  }
  if (kdesign->R_epi_ky > 1 && kdesign->R[YGRAD] > 1 && (kdesign->R[YGRAD] < kdesign->R_epi_ky || kdesign->R[YGRAD] % kdesign->R_epi_ky)) {
    KS_THROW("R[Y] (%d) not divisible with R_epi_ky (%d)", kdesign->R[YGRAD], kdesign->R_epi_ky);
    return ADVISORY_FAILURE;
  }

  return SUCCESS;

} /* ks_eval_validate_kspacedesign() */

ks_eval_design_readtrap()

STATUS ks_eval_design_readtrap	(	KS_READTRAP *	trap,
		const KS_KSPACE_DESIGN *	kdesign,
		const float	crusher_area,
		const char *	desc
	)

Function that sets up a KS_READTRAP struct based on an KS_KSPACE_DESIGN

Parameters

[out]	trap	Pointer to KS_READTRAP
[in]	kdesign	Pointer to KS_KSPACE_DESIGN struct
[in]	crusher_area	Minimum padding area before acq starts
[in]	desc	Description of readtrap

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                 {

  trap->fov = kdesign->fov[XGRAD]*kdesign->readout_oversampling_factor;
  trap->res = RUP_FACTOR(kdesign->res[XGRAD], 2)*kdesign->readout_oversampling_factor;
  trap->acq.rbw = kdesign->rbw*kdesign->readout_oversampling_factor;
  trap->acq.override_R1 = kdesign->override_R1;
  trap->paddingarea = crusher_area;
  trap->rampsampling = kdesign->rampsampling;
  trap->nover = kdesign->nover[XGRAD];

  return ks_eval_readtrap(trap, desc);

} /* ks_eval_design_readtrap() */

ks_eval_design_readwave()

STATUS ks_eval_design_readwave	(	KS_READWAVE *	readwave,
		const KS_READWAVE_DESIGN *	design,
		const KS_KSPACE_DESIGN *	kdesign,
		const char *	desc
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	readwave	ADDTEXTHERE
[in]	design	ADDTEXTHERE
[in]	kdesign	ADDTEXTHERE
[in]	desc	ADDTEXTHERE

Return values

STATUS

SUCCESS or FAILURE

                                                 {

  ks_init_readwave(readwave);
  readwave->fov = kdesign->fov[XGRAD];
  readwave->res = RUP_FACTOR(kdesign->res[XGRAD], 2);
  readwave->acq.override_R1 = kdesign->override_R1;
  if (fabs(design->pf) >= 0.5 && fabs(design->pf) < 1.0) {
    readwave->nover = readwave->res * (fabs(design->pf) - 0.5);
      /* Keep track of sign as it signals early/late pf */
    if (design->pf < 0) {
      readwave->nover *= -1;
    }
  }

  readwave->acq.rbw = design->rbw; /* If KS_NOTSET, then rbw will be automatically calculated later */
  STATUS s = ks_eval_readwave_constrained(readwave,
                                          design->acq_waves,
                                          design->numstates,
                                          design->flag_symmetric_padding,
                                          design->pre_crusher,
                                          design->post_crusher);
  free(design->acq_waves);
  KS_RAISE(s);
  return SUCCESS;
}

ks_eval_design_echotrain()

STATUS ks_eval_design_echotrain	(	KS_ECHOTRAIN *	echotrain,
		const KS_ECHOTRAIN_DESIGN *	design,
		const KS_KSPACE_DESIGN *	kdesign,
		const char *	desc
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	echotrain	ADDTEXTHERE
[in]	design	ADDTEXTHERE
[in]	kdesign	ADDTEXTHERE
[in]	desc	ADDTEXTHERE

Return values

STATUS

SUCCESS or FAILURE

                                                  {

  int i;
  STATUS status;
  KS_DESCRIPTION tmp_desc;

  ks_init_echotrain(echotrain);

  /* copy controls */
  for (i = 0; i < KS_MAXUNIQUE_READ; ++i) {
    echotrain->controls[i] = design->controls[i];
  }

  /* compute number of traps and waves */
  status = ks_eval_echotrain(echotrain);
  KS_RAISE(status);


  /* readtraps */
  for (i = 0; i < echotrain->numtraps; ++i) {
    ks_create_suffixed_description(tmp_desc,  desc, "_readtrap%03d", i);
    status = ks_eval_design_readtrap(&echotrain->readtraps[i],
                                     kdesign,
                                     design->readtrap_crusher_area,
                                     tmp_desc);
    KS_RAISE(status);
  }

  /* readwaves */
  for (i = 0; i < echotrain->numwaves; ++i) {
    ks_create_suffixed_description(tmp_desc,  desc, "_readwave%03d", i);
    status = ks_eval_design_readwave(&echotrain->readwaves[i],
                                     &design->readwave_designs[i],
                                     kdesign,
                                     tmp_desc);
    KS_RAISE(status);
  }


  return SUCCESS;
}

ks_eval_design_selrfexc()

STATUS ks_eval_design_selrfexc	(	KS_SELRF *	selrfexc,
		const KS_SELRF_DESIGN	excdesign
	)

Function that sets up a KS_SELRF struct for selective RF excitation based on an KS_SELRF_DESIGN

Parameters

[out]	selrfexc	Pointer to KS_SELRF (slice selective excitation)
[in]	excdesign	KS_SELRF_DESIGN struct with desired excitation characteristics

Return values

STATUS

SUCCESS or FAILURE

                                                                                    {
  STATUS status;
  float rfstretchfactor = 1.0;
  int allowcustomstretch = TRUE;

  /* clear RF pulse */
  ks_init_selrf(selrfexc);

  if (excdesign.description == NULL || strlen(excdesign.description) == 0) {
    return KS_THROW("empty description");
  }

  float offsetFreq = 421.5420;
  if (cffield != 30000) {
    offsetFreq *= 0.5;
  }

  switch (excdesign.rfpulse_choice) {
    case EXC_2D: /* 0 */
      selrfexc->rf = exc_fse90; /* 800 Hz */
      break;
    case EXC_FAST_2D: /* 1 */
      selrfexc->rf = exc_ssfse90new;
      break;
    case EXC_3D: /* 2 */
      selrfexc->rf = exc_3d8min; /* 14403 Hz */
      break;
    case EXC_FAST_3D: /* 3 */
      selrfexc->rf = exc_tbw6_01_001_150; /* 20000 Hz */
      break;
    case EXC_SPSP: /* 4 */
      if (cffield == 15000) {
        selrfexc->rf = spsp_ss1528822; /* 1.5T SPSP. 2571 Hz */
        selrfexc->gradwave = spsp_ss1528822_gz; /* normalized to 1 G/cm */
      } else {
        selrfexc->rf = spsp_ss30260334; /* 3T SPSP. 4040 Hz */
        selrfexc->gradwave = spsp_ss30260334_gz; /* normalized to 1 G/cm */
      }
      allowcustomstretch = FALSE;
      break;
    case EXC_SPSP_3D: /* 5 */
      if (cffield == 30000) {
        selrfexc->rf = spsp_spsp30104233; /* 3T SPSP. 17797 Hz */
        selrfexc->gradwave = spsp_spsp30104233_gz; /* normalized to 1 G/cm */
      } else {
        /* same as EXC_FAST_SPSP_3D at 1.5 T for now */
        if (excdesign.slthick < 100) {
          selrfexc->rf = spsp_ss1528822; /* 1.5T SPSP. 2571 Hz */
          selrfexc->gradwave = spsp_ss1528822_gz; /* normalized to 1 G/cm */
        } else {
          selrfexc->rf = exc_SPSP3D_15T_100mm_stbw10_2b_min_bin;
          selrfexc->gradwave = exc_SPSP3D_15T_100mm_stbw10_2b_min_bin_gz; 
        }
      }
      allowcustomstretch = FALSE;
      break;
    case EXC_FAST_SPSP_3D: /* 6 */
      if (cffield == 30000) {
        if (excdesign.slthick < 100) {
          selrfexc->rf = spsp_ss30260334; /* 3T SPSP. 4040 Hz */
          selrfexc->gradwave = spsp_ss30260334_gz; /* normalized to 1 G/cm */
        } else {
          selrfexc->rf = exc_SPSP3D_100mm_stbw1_2b_min_bin;
          selrfexc->gradwave = exc_SPSP3D_100mm_stbw1_2b_min_bin_gz;
        }
      } else {
        if (excdesign.slthick < 100) {
          selrfexc->rf = spsp_ss1528822; /* 1.5T SPSP. 2571 Hz */
          selrfexc->gradwave = spsp_ss1528822_gz; /* normalized to 1 G/cm */
        } else {
          selrfexc->rf = exc_SPSP3D_15T_100mm_stbw10_2b_min_bin;
          selrfexc->gradwave = exc_SPSP3D_15T_100mm_stbw10_2b_min_bin_gz;
        }
      }
      allowcustomstretch = FALSE;
      break;
    case EXC_HARD: /* 7 */
      selrfexc->rf = excnonsel_fermi100;
      rfstretchfactor = 4; /* Make it 400us to get bit more FA */
      break;
    case EXC_HARD_LOWFAT: /* 8 */
      status = ks_eval_rf_binomial(&selrfexc->rf, "MT binomial 1-1", 
                                   0 /* select water */,
                                   2, 
                                   excdesign.flip,
                                   offsetFreq,
                                   1);
      KS_RAISE(status);
      selrfexc->rf.role = KS_RF_ROLE_EXC;
      allowcustomstretch = TRUE;
      break;
    case EXC_BINO_2: /* 9 */
      status = ks_eval_rf_binomial(&selrfexc->rf, "binomial 1-1", 
                                   0 /* select water */,
                                   2, /* number of subpulses */
                                   excdesign.flip, /* flip angle */
                                   offsetFreq, /* fat center freq. */
                                   0); /* MT reduction on/off*/
      KS_RAISE(status);
      selrfexc->rf.role = KS_RF_ROLE_EXC;
      allowcustomstretch = FALSE;
      break;
    case EXC_LOWSAR: /* 10 */
      selrfexc->rf  = ref_fse1601; /* (4000 Hz) */
      selrfexc->rf.role = KS_RF_ROLE_EXC;
      rfstretchfactor = 2.5; /* 4000/rfstretchfactor = 800 Hz */
      break;
    case EXC_CUSTOM: /* 11 */
      if (excdesign.customrf == NULL) {
        return KS_THROW("Missing pointer to custom RF pulse");
      }
      selrfexc->rf = *(excdesign.customrf);
      selrfexc->rf.role = KS_RF_ROLE_EXC;
      if (excdesign.customgrad != NULL) {
        selrfexc->gradwave = *(excdesign.customgrad);
      }
      break;
     default:
      return KS_THROW("KS_SELRF_DESIGN field rfpulse_choice out of range");
  } /* switch */

  selrfexc->rf.flip = excdesign.flip;
  selrfexc->slthick = excdesign.slthick / excdesign.gscale;

  selrfexc->pregrad_area_offset = excdesign.pregrad_area_offset;
  selrfexc->postgrad_area_offset = excdesign.postgrad_area_offset;

  /* RF pulse stretching */
  if (allowcustomstretch && !areSame(excdesign.rfstretch, 0)) {
    rfstretchfactor *= excdesign.rfstretch;
  }
  status = ks_eval_stretch_rf(&selrfexc->rf, rfstretchfactor);
  KS_RAISE(status);

  status = ks_eval_selrf1(selrfexc, excdesign.description);
  KS_RAISE(status);

  if (excdesign.sms_factor > 1) {

    status = ks_eval_sms_make_multiband(selrfexc,
                                        selrfexc,
                                        excdesign.sms_factor,
                                        excdesign.sms_factor == 2 ? KS_SELRF_SMS_PHAS_MOD_OFF
                                                                  : excdesign.sms_phase_modulation_mode,
                                        excdesign.sms_slice_gap, 0);
    KS_RAISE(status);
  }

  return SUCCESS;

} /* ks_eval_design_selrfexc() */

ks_eval_design_selrfref()

STATUS ks_eval_design_selrfref	(	KS_SELRF *	selrfref,
		const KS_SELRF_DESIGN	refdesign
	)

Function that sets up a KS_SELRF struct for selective RF refocusing based on an KS_SELRF_DESIGN

Parameters

[out]	selrfref	Pointer to KS_SELRF (slice selective refocusing)
[in]	refdesign	KS_SELRF_DESIGN struct with desired refocusing characteristics

Return values

STATUS

SUCCESS or FAILURE

                                                                                    {
  STATUS status;
  float rfstretchfactor = 1.0;

  /* clear RF pulse */
  ks_init_selrf(selrfref);

  if (refdesign.description == NULL || strlen(refdesign.description) == 0) {
    return KS_THROW("empty description");
  }

  switch (refdesign.rfpulse_choice) {
    case REF_SHARP_2D:
      selrfref->rf = ref_se1b4; /* 905 Hz */
      break;
    case REF_2D_FIRST:
      selrfref->rf = ref_fse1601; /* 800 Hz */
      break;
    case REF_2D:
      selrfref->rf = ref_fse160n; /* 800 Hz */
      break;
    case REF_FAST_2D:
      selrfref->rf = ref_ssfse155; /* 1280 Hz */
      break;
    case REF_EXTREM_FAST_2D:
      selrfref->rf = ref_tbw2_1_01; /* 4000 Hz */
      rfstretchfactor = 5;
      break;
    case REF_HARD:
      selrfref->rf = refnonsel_fermi124;
      rfstretchfactor = 2;
      break;
    case REF_LOWSAR:
      selrfref->rf = ref_fse160n; /* (800 Hz) */
      rfstretchfactor = 2.5; /* 800/rfstretchfactor = 267 Hz */
      break;
    case REF_CUSTOM:
      if (refdesign.customrf == NULL) {
        return KS_THROW("Missing pointer to custom RF pulse");
      }
      selrfref->rf = *(refdesign.customrf);
      selrfref->rf.role = KS_RF_ROLE_REF;
      if (refdesign.customgrad != NULL) {
        selrfref->gradwave = *(refdesign.customgrad);
      }
      break;
    default:
      return KS_THROW("KS_SELRF_DESIGN field rfpulse_choice out of range");
  } /* switch */  

  selrfref->rf.flip = refdesign.flip;
  selrfref->slthick = refdesign.slthick / refdesign.gscale;
  selrfref->crusher_dephasing = refdesign.crusher_dephasing;
  selrfref->pregrad_area_offset = refdesign.pregrad_area_offset;
  selrfref->postgrad_area_offset = refdesign.postgrad_area_offset;
  selrfref->bridge_crushers = refdesign.bridge_crushers;

  /* RF pulse stretching */
  rfstretchfactor *= refdesign.rfstretch; /* '*=' so that we use the base stretch factor for REF_HARD & REF_LOWSAR above */
  status = ks_eval_stretch_rf(&selrfref->rf, rfstretchfactor);
  KS_RAISE(status);

  status = ks_eval_selrf(selrfref, refdesign.description);
  KS_RAISE(status);

  if (refdesign.sms_factor > 1) {

    status = ks_eval_sms_make_multiband(selrfref,
                                        selrfref,
                                        refdesign.sms_factor,
                                        refdesign.sms_factor == 2 ? KS_SELRF_SMS_PHAS_MOD_OFF
                                                                  : refdesign.sms_phase_modulation_mode,
                                        refdesign.sms_slice_gap, 0);
    KS_RAISE(status);
  }

  return SUCCESS;

} /* ks_eval_design_selrfref() */

ks_eval_design_selrfinv()

STATUS ks_eval_design_selrfinv	(	KS_SELRF *	selrfinv,
		const KS_SELRF_DESIGN	invdesign
	)

Function that sets up a KS_SELRF struct for selective RF inversion based on an KS_SELRF_DESIGN

Parameters

[out]	selrfinv	Pointer to KS_SELRF (slice selective inversion)
[in]	invdesign	KS_SELRF_DESIGN struct with desired inversion characteristics

Return values

STATUS

SUCCESS or FAILURE

                                                                                    {
  STATUS status;
  float rfstretchfactor = 1.0;

  /* clear RF pulse */
  ks_init_selrf(selrfinv);

  if (invdesign.description == NULL || strlen(invdesign.description) == 0) {
    return KS_THROW("empty description");
  }

  switch (invdesign.rfpulse_choice) {
    case INV_STD:
      selrfinv->rf = inv_invI0;
      break;
    case INV_ADIABATIC:
      selrfinv->rf = adinv_shNvrg5b;
      break;
    case INV_LOWSAR:
      selrfinv->rf = ref_fse160n; /* take a refocusing RF pulse ... */
      selrfinv->rf.role = KS_RF_ROLE_INV; /* ...and make it act as an inversion pulse */
      break;
    case INV_CUSTOM:
      if (invdesign.customrf == NULL) {
        return KS_THROW("Missing pointer to custom RF pulse");
      }
      selrfinv->rf = *invdesign.customrf; 
      selrfinv->rf.role = KS_RF_ROLE_INV;
      if (invdesign.customgrad != NULL) {
        selrfinv->gradwave = *(invdesign.customgrad);
      }     
      break;      
    default:
      return KS_THROW("KS_SELRF_DESIGN field rfpulse_choice out of range");
  } /* switch */

  selrfinv->rf.flip = invdesign.flip;
  selrfinv->slthick = invdesign.slthick / invdesign.gscale;
  selrfinv->pregrad_area_offset = invdesign.pregrad_area_offset;
  selrfinv->postgrad_area_offset = invdesign.postgrad_area_offset;

  /* RF pulse stretching */
  if (invdesign.rfpulse_choice != INV_ADIABATIC) {
    rfstretchfactor *= invdesign.rfstretch;
    status = ks_eval_stretch_rf(&selrfinv->rf, rfstretchfactor);
    KS_RAISE(status);
  }

  status = ks_eval_selrf1(selrfinv, invdesign.description);
  KS_RAISE(status);

  if (invdesign.sms_factor > 1) {

    status = ks_eval_sms_make_multiband(selrfinv,
                                        selrfinv,
                                        invdesign.sms_factor,
                                        invdesign.sms_phase_modulation_mode,
                                        invdesign.sms_slice_gap, 0);
    KS_RAISE(status);
  }

  return SUCCESS;

} /* ks_eval_design_selrfinv() */

ks_print_kdesign()

void ks_print_kdesign	(	const KS_KSPACE_DESIGN *const	kdesign,
		const char *	suffix,
		int	rhkacq_uid
	)

Function printing out a KS_KSPACE_DESIGN struct to disk

File is being written to:

• /usr/g/mrraw/kstmp/<rhkacq_uid>/embed/kdesign_<suffix>.bin (on MR scanner)
• ./kdesign_<suffix>.bin (in simulation)

Parameters

[in]	kdesign	Pointer to KS_KSPACE_DESIGN
[in]	suffix	Filename suffix (char array)
[in]	rhkacq_uid	GE's global CV with the same name as input argument to uniquely identify scan instances

Returns

void

                                                                                                 {

  char filename[512];
#ifdef PSD_HW /* on MR-scanner (host) */
  char outputdir_uid[512];
  char cmd[512];
  sprintf(outputdir_uid, "/usr/g/mrraw/kstmp/%010d/embed/", rhkacq_uid);
  sprintf(filename, "%s/kdesign_%s.bin", outputdir_uid, suffix);
  sprintf(cmd, "mkdir -p %s > /dev/null", outputdir_uid);
  system(cmd);
#else /* e.g. WTools */
  sprintf(filename, "./kdesign_%s.bin", suffix);
#endif
  FILE* fp = fopen(filename, "wb");
  fwrite(kdesign, sizeof(KS_KSPACE_DESIGN), 1, fp);
  fflush(fp);
  fclose(fp);

} /* ks_print_kdesign() */