Prep sequence module: Inversion (ksinversion.h)

Data Structures
struct	KSINV_DESIGN
struct	KSINV_MODULE
struct	KSINV_LOOP_CONTROL_DESIGN
struct	KSINV_LOOP_CONTROL
struct	KSINV_CHAIN_DESIGN
struct	KSINV_MULTI_INV_VOL
struct	KSINV_CHAIN

Macros
#define	KSINV_DEFAULT_FLIP   180
#define	KSINV_DEFAULT_SPOILERAREA   5000
#define	KSINV_MINTR_T2FLAIR   8000000
#define	KSINV_MINTR_T1FLAIR   1400000
#define	KSINV_MAXTR_T1FLAIR   2800000
#define	T1_CSF_3T   4400000
#define	T1_CSF_1_5T   3600000
#define	T1_GM_3T   1400000
#define	T1_GM_1_5T   1100000
#define	T1_WM_3T   750000
#define	T1_WM_1_5T   600000
#define	T1_FAT_3T   340000
#define	T1_FAT_1_5T   260000
#define	KSINV_SPOILX   1
#define	KSINV_SPOILY   2
#define	KSINV_SPOILZ   4
#define	KSINV_INIT_DESIGN   {"inversion", KS_INIT_SELRF_INVDESIGN, 0, KSINV_GSCALE_NONOVERLAP, 1000.0, KSINV_SPOILX + KSINV_SPOILY + KSINV_SPOILZ, 0, KS_DEFAULT_SSI_TIME}
#define	KSINV_INIT_MODULE   {KS_INIT_SEQ_CONTROL, KS_INIT_SELRF, KS_INIT_TRAP, KSINV_SPOILX + KSINV_SPOILY + KSINV_SPOILZ, 0}
#define	KSINV_INIT_LOOP_CONTROL_DESIGN   {KSINV_OFF, KS_NOTSET, KS_NOTSET, FALSE, KS_DEFAULT_SSI_TIME, KSSCAN_INIT_LOOP_CONTROL_DESIGN}
#define	KSINV_INIT_LOOP_CONTROL   {KSINV_OFF, KS_NOTSET, KS_NOTSET, KS_NOTSET, KS_NOTSET, KS_NOTSET, 0, KSSCAN_INIT_LOOP_CONTROL, KS_INIT_SEQ_CONTROL}
#define	KSINV_MULTI_INV_MAX_NUM_VOLS   16
#define	KSINV_INIT_CHAIN_DESIGN   {0, {0}, {KS_INIT_PHASEENCODING_PLAN_DESIGN}, {0}}
#define	KSINV_INIT_CHAIN   {0, {{0, KS_INIT_PHASEENCODING_PLAN, 0, 0}}}

Enumerations
enum	KSINV_MODE { KSINV_OFF, KSINV_ON_INTERLEAVED, KSINV_ON_FLAIR_BLOCK }
enum	KSINV_LOOP_MODE { KSINV_LOOP_NORMAL, KSINV_LOOP_SLICEAHEAD_FIRST, KSINV_LOOP_SLICEAHEAD_LAST }
enum	KSINV_GSCALE_POLICY { KSINV_GSCALE_SET, KSINV_GSCALE_NONOVERLAP, KSINV_GSCALE_MAXWIDTH }

Functions
void	ksinv_init_loopcontrol (KSINV_LOOP_CONTROL *loop_control)
void	ksinv_init_design (KSINV_DESIGN *design, const char *desc)
void	ksinv_init_sequence (KSINV_MODULE *seq)
STATUS	ksinv_eval_validatedesign (KSINV_DESIGN *design)
STATUS	ksinv_eval_setupobjects (KSINV_MODULE *seq, const KSINV_DESIGN *design)
STATUS	ksinv_pg (KSINV_MODULE *seq)
STATUS	ksinv_scan_seqstate (KSINV_MODULE *seq, const SCAN_INFO *slice_pos)
KS_CORESLICETIME	ksinv_scan_irslice (KSINV_MODULE *seq, const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic)
float	ksinv_eval_gscale (float slice_thickness, float slice_spacing, int numacqs, KSINV_GSCALE_POLICY gscale_policy)
STATUS	ksinv_eval_design (KSINV_MODULE *invseq, KSINV_DESIGN *invseq_design, int npasses, KS_SEQ_COLLECTION *seqcollection)
STATUS	ksinv_loop_control_eval_design (KSINV_LOOP_CONTROL *inv_loopctrl, KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_SEQ_CONTROL *invseq_seqctrl_ptr, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_SEQ_CONTROL *mainseq_seqctrl_ptr, const KSINV_LOOP_CONTROL_DESIGN *design, KS_SEQ_COLLECTION *seqcollection)
STATUS	ksinv_eval_duration_simple (KSINV_LOOP_CONTROL *inv_loopctrl, KS_CORESLICETIME irslicetime, KS_CORESLICETIME coreslicetime, KS_SEQ_CONTROL *invseq_seqctrl_ptr, const KSINV_LOOP_CONTROL_DESIGN *design)
int	ksinv_eval_nullti (int TR, int T1value, int seqdur)
int	ksinv_eval_nulltr (int TI, int T1value, int seqdur)
STATUS	ksinv_eval_duration_interleaved (KSINV_LOOP_CONTROL *inv_loopctrl, KS_CORESLICETIME irslicetime, KS_CORESLICETIME coreslicetime, KS_SEQ_CONTROL *invseq_seqctrl_ptr, KS_SEQ_CONTROL *mainseq_seqctrl_ptr, const KSINV_LOOP_CONTROL_DESIGN *design)
STATUS	ksinv_eval_duration_flairblock (KSINV_LOOP_CONTROL *inv_loopctrl, KS_CORESLICETIME irslicetime, KS_CORESLICETIME coreslicetime, KS_SEQ_CONTROL *invseq_seqctrl_ptr, KS_SEQ_CONTROL *mainseq_seqctrl_ptr, const KSINV_LOOP_CONTROL_DESIGN *design)
STATUS	ksinv_eval_duration_setfilltr (KS_SEQ_CONTROL *filltr, int duration)
STATUS	ksinv_check ()
STATUS	ksinv_predownload_setrecon ()
s64	ksinv_scan_sliceloop (KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KSINV_LOOP_MODE ksinv_loop_mode, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
s64	ksinv_scan_sliceloop_flairblock (KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
s64	ksinv_scan_sliceloop_sliceahead (KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), int nslicesahead_current, int nslicesahead_next, int play_core)
s64	ksinv_scan_acqloop (KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), const int inv_rampup, const int inv_rampdown)
s64	ksinv_scan_scanloop (KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
void	ksinv_prescanloop (KSINV_LOOP_CONTROL *inv_loopctrl, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), int nloops, int dda)
STATUS	ksinv_eval_chain_design (KSINV_CHAIN *inv_chain, KSINV_CHAIN_DESIGN *inv_chain_design, const KSINV_LOOP_CONTROL *inv_loopctrl)
s64	ksinv_scan_acqloop_chain (const KSINV_CHAIN *inv_chain, KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
s64	ksinv_scan_scanloop_chain (const KSINV_CHAIN *inv_chain, KSINV_LOOP_CONTROL *inv_loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), KS_CORESLICETIME irslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))

Detailed Description

Macro Definition Documentation

KSINV_DEFAULT_FLIP

#define KSINV_DEFAULT_FLIP   180

default inversion flip angle

KSINV_DEFAULT_SPOILERAREA

#define KSINV_DEFAULT_SPOILERAREA   5000

default spoiler area [(G/cm)*us]

KSINV_MINTR_T2FLAIR

#define KSINV_MINTR_T2FLAIR   8000000

default minTR [us] for T2FLAIR, 8 [s]

KSINV_MINTR_T1FLAIR

#define KSINV_MINTR_T1FLAIR   1400000

default minTR [us] for T1FLAIR, 1.4 [s]

KSINV_MAXTR_T1FLAIR

#define KSINV_MAXTR_T1FLAIR   2800000

default maxTR [us] for T1FLAIR, 2.8 [s]

T1_CSF_3T

#define T1_CSF_3T   4400000

Approximate T1 value for CSF at 3T [us]

T1_CSF_1_5T

#define T1_CSF_1_5T   3600000

Approximate T1 value for CSF at 1.5T [us]

T1_GM_3T

#define T1_GM_3T   1400000

Approximate T1 value for gray matter at 3T [us]

T1_GM_1_5T

#define T1_GM_1_5T   1100000

Approximate T1 value for gray matter at 1.5T [us]

T1_WM_3T

#define T1_WM_3T   750000

Approximate T1 value for white matter at 3T [us]

T1_WM_1_5T

#define T1_WM_1_5T   600000

Approximate T1 value for white matter at 1.5T [us]

T1_FAT_3T

#define T1_FAT_3T   340000

Approximate T1 value for fat at 3T [us]

T1_FAT_1_5T

#define T1_FAT_1_5T   260000

Approximate T1 value for fat at 1.5T [us]

KSINV_SPOILX

#define KSINV_SPOILX   1

Bitmask for KSINV_DESIGN spoileraxes to activate spoiling on the logical X-axis

KSINV_SPOILY

#define KSINV_SPOILY   2

Bitmask for KSINV_DESIGN spoileraxes to activate spoiling on the logical Y-axis

KSINV_SPOILZ

#define KSINV_SPOILZ   4

Bitmask for KSINV_DESIGN spoileraxes to activate spoiling on the logical Z-axis

KSINV_INIT_DESIGN

#define KSINV_INIT_DESIGN   {"inversion", KS_INIT_SELRF_INVDESIGN, 0, KSINV_GSCALE_NONOVERLAP, 1000.0, KSINV_SPOILX + KSINV_SPOILY + KSINV_SPOILZ, 0, KS_DEFAULT_SSI_TIME}

Default KSINV_DESIGN values

KSINV_INIT_MODULE

#define KSINV_INIT_MODULE   {KS_INIT_SEQ_CONTROL, KS_INIT_SELRF, KS_INIT_TRAP, KSINV_SPOILX + KSINV_SPOILY + KSINV_SPOILZ, 0}

Default values for KSINV_MODULE

KSINV_INIT_LOOP_CONTROL_DESIGN

#define KSINV_INIT_LOOP_CONTROL_DESIGN   {KSINV_OFF, KS_NOTSET, KS_NOTSET, FALSE, KS_DEFAULT_SSI_TIME, KSSCAN_INIT_LOOP_CONTROL_DESIGN}

Default KSINV_LOOP_CONTRO_DESIGN values

KSINV_INIT_LOOP_CONTROL

#define KSINV_INIT_LOOP_CONTROL   {KSINV_OFF, KS_NOTSET, KS_NOTSET, KS_NOTSET, KS_NOTSET, KS_NOTSET, 0, KSSCAN_INIT_LOOP_CONTROL, KS_INIT_SEQ_CONTROL}

Default KSINV_LOOP_CONTROL values

KSINV_MULTI_INV_MAX_NUM_VOLS

#define KSINV_MULTI_INV_MAX_NUM_VOLS   16

KSINV_INIT_CHAIN_DESIGN

#define KSINV_INIT_CHAIN_DESIGN   {0, {0}, {KS_INIT_PHASEENCODING_PLAN_DESIGN}, {0}}

KSINV_INIT_CHAIN

#define KSINV_INIT_CHAIN   {0, {{0, KS_INIT_PHASEENCODING_PLAN, 0, 0}}}

Enumeration Type Documentation

KSINV_MODE

enum KSINV_MODE

Enumerator
KSINV_OFF
KSINV_ON_INTERLEAVED
KSINV_ON_FLAIR_BLOCK

{KSINV_OFF, KSINV_ON_INTERLEAVED, KSINV_ON_FLAIR_BLOCK} KSINV_MODE; 

KSINV_LOOP_MODE

enum KSINV_LOOP_MODE

Enumerator
KSINV_LOOP_NORMAL
KSINV_LOOP_SLICEAHEAD_FIRST
KSINV_LOOP_SLICEAHEAD_LAST

{KSINV_LOOP_NORMAL, KSINV_LOOP_SLICEAHEAD_FIRST, KSINV_LOOP_SLICEAHEAD_LAST} KSINV_LOOP_MODE; 

KSINV_GSCALE_POLICY

enum KSINV_GSCALE_POLICY

Enumerator
KSINV_GSCALE_SET
KSINV_GSCALE_NONOVERLAP
KSINV_GSCALE_MAXWIDTH

{KSINV_GSCALE_SET, KSINV_GSCALE_NONOVERLAP, KSINV_GSCALE_MAXWIDTH} KSINV_GSCALE_POLICY; 

Function Documentation

ksinv_init_loopcontrol()

void ksinv_init_loopcontrol

(

KSINV_LOOP_CONTROL *

loop_control

)

Initialize an inversion loop control

Parameters

[out]

loop_control

Pointer to the inversion loop control to be initialized

Returns

void

                                                              {
  KSINV_LOOP_CONTROL loop_init = KSINV_INIT_LOOP_CONTROL;
  *loop_control = loop_init;

} /* ksinv_init_loopcontrol() */

ksinv_init_design()

void ksinv_init_design	(	KSINV_DESIGN *	design,
		const char *	desc
	)

Resets the design of the standard inversion module

This function should be called from an sequence (*.e file) that uses ksinversion.h:KSINV_MODULE before setting up its design struct.

Parameters

[out]	design	Pointer to the design struct
[in]	desc	Description of the sequence

Returns

void

                                                               {
  KSINV_DESIGN default_design = KSINV_INIT_DESIGN;
  *design = default_design;

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

  ks_create_suffixed_description(design->invdesign.description, "%s_selrfinv", design->description);

} /* ksinv_init_design() */

ksinv_init_sequence()

void ksinv_init_sequence

(

KSINV_MODULE *

seq

)

[Internal ksinversion.cc] Resets the KSINV_MODULE struct (arg 1) to KSINV_INIT_MODULE

Parameters

[out]

seq

Pointer to KSINV_MODULE

Returns

void

                                            {
  KSINV_MODULE default_seq = KSINV_INIT_MODULE;

  *seq = default_seq;

  /* init seqctrl */
  ks_init_seqcontrol(&seq->seqctrl);
  seq->seqctrl.ssi_time = KS_DEFAULT_SSI_TIME;

} /* ksinv_init_sequence() */

ksinv_eval_validatedesign()

STATUS ksinv_eval_validatedesign

(

KSINV_DESIGN *

design

)

[Internal ksinversion.cc] Checks for limits in the design structures of KSINV_DESIGN

This function is called by ksinv_eval_design() to make sure the user's input design stuctures are valid

Parameters

[in]

design

KSINV_DESIGN to be validated

Return values

STATUS

SUCCESS or FAILURE

ksinv_eval_setupobjects()

STATUS ksinv_eval_setupobjects	(	KSINV_MODULE *	seq,
		const KSINV_DESIGN *	design
	)

[Internal ksinversion.cc] Sets up gradients & RF for the KSINV_MODULE

This function is called by ksinv_eval() to set up the specs (amplitudes and durations) for the sequence objects (gradients, RF, ...) in KSINV_MODULE

Parameters

[out]	seq	Pointer to the inversion module
[in]	design	Pointer to the design struct

Return values

STATUS

SUCCESS or FAILURE

                                                                              {
  STATUS status;
  KS_DESCRIPTION tmpdesc;

  /* set up RF excitation */
  status = ks_eval_design_selrfinv(&seq->selrfinv, design->invdesign);
  KS_RAISE(status);

  /* set up spoiler */
  seq->spoiler.area = design->spoiler_area;
  ks_create_suffixed_description(tmpdesc, design->description, "_spoiler");
  /* since minimum IR seq duration is not time critical */
  status = ks_eval_trap_rotation_invariant_75_max_slewrate(&seq->spoiler, tmpdesc);
  KS_RAISE(status);

  /* Copy fields */
  seq->spoileraxes = design->spoileraxes;
  seq->inversion_pulse_shift = design->inversion_pulse_shift;
  seq->seqctrl.ssi_time = design->ssi_time;

  return SUCCESS;

} /* ksinv_eval_setupobjects() */

ksinv_pg()

STATUS ksinv_pg

(

KSINV_MODULE *

seq

)

Generation of the waveforms for the waveform of the standard inversion module

Parameters

[in,out]

seq

Pointer to the inversion module

Return values

STATUS

SUCCESS or FAILURE

                                   {
  STATUS status;
  KS_SEQLOC tmploc = KS_INIT_SEQLOC;

#ifdef IPG
  /* TGT (IPG) only: return early if sequence module duration is zero */
  if (seq->seqctrl.duration == 0)
    return SUCCESS;
#endif

  /*******************************************************************************************************
   *  RF Excitation
   *******************************************************************************************************/
  tmploc.ampscale = 1.0;
  tmploc.pos = 16 + RUP_GRD(KS_RFSSP_PRETIME) + seq->inversion_pulse_shift;
  tmploc.board = ZGRAD;

  status = ks_pg_selrf(&seq->selrfinv, tmploc, &seq->seqctrl);
  KS_RAISE(status);

  /* Save absolute time in sequence for moment start (this is otherwise only done for excitation pulses automatically in ks_pg_selrf() */
  seq->seqctrl.momentstart = tmploc.pos + seq->selrfinv.grad.ramptime + seq->selrfinv.rf.start2iso;


 /*******************************************************************************************************
   *  Gradient spoilers on Y and Z (at the same time)
   *******************************************************************************************************/
  tmploc.ampscale = 1.0;
  tmploc.pos += (seq->selrfinv.grad.duration > 0) ? seq->selrfinv.grad.duration : seq->selrfinv.gradwave.duration;

  if (seq->spoileraxes & KSINV_SPOILX){
    tmploc.board = XGRAD;
    status = ks_pg_trap(&seq->spoiler, tmploc, &seq->seqctrl);
    KS_RAISE(status);
  }

  if (seq->spoileraxes & KSINV_SPOILY){
    tmploc.board = YGRAD;
    status = ks_pg_trap(&seq->spoiler, tmploc, &seq->seqctrl);
    KS_RAISE(status);
  }

  if (seq->spoileraxes & KSINV_SPOILZ){
    tmploc.board = ZGRAD;
    status = ks_pg_trap(&seq->spoiler, tmploc, &seq->seqctrl);
    KS_RAISE(status);
  }

  tmploc.pos += seq->spoiler.duration;


 /*******************************************************************************************************
   *  Set the minimal sequence duration (seq->seqctrl.min_duration) by calling
   *  ks_eval_seqctrl_setminduration()
   *******************************************************************************************************/

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


  return SUCCESS;

} /* ksinv_pg() */

ksinv_scan_seqstate()

STATUS ksinv_scan_seqstate	(	KSINV_MODULE *	seq,
		const SCAN_INFO *	slice_pos
	)

[Internal ksinversion.cc] Sets the current state of a KSINV_MODULE during scanning

This function sets the current state of all ksinv sequence objects being part of KSINV_MODULE, specifically slice-dependent RF freq/phases changes.

The idea of having a 'seqstate' function is to be able to come back to a certain sequence state at any time and possibly play it out once more. This could for example be useful when certain lines or slices need to be rescanned due to image artifacts detected during scanning.

Parameters

[in]	seq	Pointer to KSINV_MODULE
[in]	slice_pos	Pointer to position of the slice to be played out (one element in the ks_scan_info[] array)

Return values

STATUS

SUCCESS or FAILURE

                                                                           {

  if (seq->seqctrl.duration == 0)
    return SUCCESS;

  if (slice_info != NULL) {

    ks_scan_rotate(*slice_info);

    ks_scan_rf_on(&seq->selrfinv.rf, 0);

    if (seq->selrfinv.sms_info.pulse_type == KS_SELRF_SMS_PINS_DANTE) {
      ks_scan_selrf_setfreqphase_pins(&seq->selrfinv, 0, *slice_info,
                                      seq->selrfinv.sms_info.mb_factor, seq->selrfinv.sms_info.slice_gap, 0.0);
    } else {
      ks_scan_selrf_setfreqphase(&seq->selrfinv, 0, *slice_info, 0);
    }

  } else {

    ks_scan_rf_off(&seq->selrfinv.rf, 0);

  }

  return SUCCESS;

} /* ksinv_scan_seqstate() */

ksinv_scan_irslice()

KS_CORESLICETIME ksinv_scan_irslice	(	KSINV_MODULE *	seq,
		const SCAN_INFO *	slice_pos,
		KS_DYNAMIC_STATE *	dynamic
	)

Plays out one inversion slice of the standard inversion module

On TGT on the MR system (PSD_HW), this function sets up (ksinv_scan_seqstate()) and plays out one KSINV_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 += ...).

On HOST only the timing informations are returned. These are used for to compute inversion timing and total scan time.

Parameters

[in]	seq	Pointer to KSINV_MODULE
[in]	slice_pos	Pointer to position of the slice to be played out (one element in the ks_scan_info[] array)
[in]	dynamic	Pointer to KS_DYNAMIC_STATE

Return values

KS_CORESLICETIME

Time taken in [us] to play out one inversion slice (.duration) and time to center of inversion pulse (.referencetimepoint)

                                                               {
  SCAN_INFO slice_pos_updated;
  int time = 0;
  float tloc = 0.0;
  KS_CORESLICETIME coreslicetime = KS_INIT_CORESLICETIME;

  if (seq == NULL) {
    return coreslicetime;
  }

  if (seq->seqctrl.duration > 0) {

    if (slice_pos != NULL) {
      /* TODO: We do have Mlogical too. shall we use it? */
      ks_scan_update_slice_location(&slice_pos_updated, *slice_pos, dynamic->Mphysical, NULL);
      tloc = slice_pos_updated.optloc;
      ksinv_scan_seqstate(seq, &slice_pos_updated);
    } else {
      ksinv_scan_seqstate(seq, slice_pos);
    }

    /* since the center freq. is changed and multiple slices are imaged with SMS */
    float sms_slice_positions[seq->selrfinv.sms_info.mb_factor];
    int slice = 0;
    for (slice = 0; slice < seq->selrfinv.sms_info.mb_factor; ++slice) {
        sms_slice_positions[slice] = tloc + seq->selrfinv.sms_info.slice_gap * (0.5 + slice - (seq->selrfinv.sms_info.mb_factor / 2.0));
    }

    /* coreslicetime.referencetimepoint assignment must be right *before* ks_scan_playsequence() of the KSINV_MODULE */
    coreslicetime.referencetimepoint = time + seq->seqctrl.momentstart; /* time from start of the irslice function to the iso point of the inversion pulse */
    time += ks_scan_playsequence(&seq->seqctrl);

    ks_plot_slicetime(&seq->seqctrl,
                      seq->selrfinv.sms_info.mb_factor,
                      sms_slice_positions,
                      seq->selrfinv.slthick,
                      slice_pos == NULL ? KS_PLOT_NO_EXCITATION : KS_PLOT_STANDARD);

    /* turn on RF again for HTML plotting, so we see the RF even though the slice loop ends with false slices */
    ks_scan_rf_on(&seq->selrfinv.rf, 0);
  }

  /* coreslicetime.duration assignment must be placed at the very end of this function */
  coreslicetime.duration = time; /* in [us] */

  return coreslicetime;

} /* ksinv_scan_irslice() */

ksinv_eval_gscale()

float ksinv_eval_gscale	(	float	slice_thickness,
		float	slice_spacing,
		int	numacqs,
		KSINV_GSCALE_POLICY	gscale_policy
	)

[Internal ksinversion.cc] Sets up the slice wideing of the inversion

This function is called by ksinv_eval_design() to set seq->design.invdesign.gscale based on other design fields

Parameters

[in]	slice_thickness	Slice thickness in [mm]
[in]	slice_spacing	Slice spacing in [mm]
[in]	numacqs	Number of acquistions (passes) for the scan (usually 2+ for inversion sequences)
[in]	gscale_policy	KSINV_GSCALE_FIXED (uses .gscale), KSINV_GSCALE_NONOVERLAP (IR slices may never overlap regardless of interleaving) or KSINV_GSCALE_MAXWIDTH (IR slice may overlap)

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                    {
  float inv_gscale = 1.0;

  if (slice_thickness <= 0.0) {
    return 1.0;
  }

  if (slice_spacing < 0.0) {
    slice_spacing = 0.0;
  }

  if (gscale_policy == KSINV_GSCALE_MAXWIDTH) {
    inv_gscale = 1.0 / ((numacqs * 2.0 * (slice_thickness + slice_spacing) - slice_thickness) / slice_thickness);
  } else if (gscale_policy == KSINV_GSCALE_NONOVERLAP) {
    inv_gscale = 1.0 / (numacqs * (slice_thickness + slice_spacing) / slice_thickness);
  }

  return inv_gscale;

} /* ksinv_eval_gscale() */

ksinv_eval_design()

STATUS ksinv_eval_design	(	KSINV_MODULE *	invseq,
		KSINV_DESIGN *	invseq_design,
		int	npasses,
		KS_SEQ_COLLECTION *	seqcollection
	)

Standard setup function for KSINV_MODULE to be executed on HOST (cveval()) by the parent sequence (*.e)

This function should be called in the cveval() function of a main sequence (*.e) that uses ksinversion.h/ksinversion.cc to generate a standard inversion module.

                                                           {

  STATUS s;

  ksinv_init_sequence(invseq);
  strncpy(invseq->seqctrl.description, invseq_design->description, KS_DESCRIPTION_LENGTH);

  /* Inversion slice scale factor based on policy */
  switch (invseq_design->gscale_policy) {
    case KSINV_GSCALE_NONOVERLAP: 
    case KSINV_GSCALE_MAXWIDTH:
      invseq_design->invdesign.gscale = ksinv_eval_gscale(invseq_design->invdesign.slthick,
                                                          invseq_design->slice_gap,
                                                          npasses,
                                                          invseq_design->gscale_policy);
      break;
    default:
      break;
  }

  s = ksinv_eval_setupobjects(invseq, invseq_design);
  KS_RAISE(s);

  s = ksinv_pg(invseq);
  KS_RAISE(s);

  s = ks_eval_addtoseqcollection(seqcollection, &invseq->seqctrl);
  KS_RAISE(s);

  return SUCCESS;

} /* ksinv_eval_design() */

ksinv_loop_control_eval_design()

STATUS ksinv_loop_control_eval_design	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_SEQ_CONTROL *	invseq_seqctrl_ptr,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_SEQ_CONTROL *	mainseq_seqctrl_ptr,
		const KSINV_LOOP_CONTROL_DESIGN *	design,
		KS_SEQ_COLLECTION *	seqcollection
	)

Generate an inversion loop control given both custom core acquisition and inversion

This function is the most general way to generate an inversion loop control. Recall that the objective of an inversion module is to interweave two different blocks of one or more modules (sequence entries). The first block is responsible for sampling the desired k-space data while the second is needed for prepare the magnetization via inversion. Here the two blocks are handled via two function pointer that play a series of modules configured to excite at a specific slice location.

Parameters

[out]	inv_loopctrl	Inversion loop control to be generated
[in]	irslice	Coreslice function playing an inversion (and optionally more) modules for a single inversion slice playout
[out]	invseq_seqctrl_ptr	Pointer to the sequence entry among those played in irslice to be inflated if it is needed to fix the timing. Note that it is assumed that this module is played exactly once in irslice.
[in]	coreslice	Pointer to function playing one or more sequence modules for a single playout
[out]	mainseq_seqctrl_ptr	Pointer to the sequence entry among those played in coreslice to be inflated if it is needed to fix the timing. Note that it is assumed that this module is played exactly once in coreslice.
[in]	design	Design for the inversion loop control
[in,out]	seqcollection	Sequence collection to which all modules played in irslice and coreslice ought to have been registered with ks_eval_addtoseqcollection.

Return values

STATUS

SUCCESS or FAILURE

                                                                               {
  STATUS status;

  ks_init_seqcontrol(&inv_loopctrl->seqctrl_filltr);

  if (design->irmode == KSINV_OFF || design->loopctrl_design.slicetiming_design.nslices < 1) {
    ksinv_init_loopcontrol(inv_loopctrl);
    return SUCCESS;
  }

  KS_DYNAMIC_STATE dynamic = KS_INIT_DYNAMIC_STATE;
  KS_CORESLICETIME irslicetime = irslice(NULL, &dynamic);
  KS_CORESLICETIME coreslicetime = coreslice(NULL, &dynamic);

  /* validate design stuct */
  status = ksinv_validate_loopcontroldesign(design);
  KS_RAISE(status);

  /* copy fields */
  inv_loopctrl->irmode = design->irmode;
  inv_loopctrl->loopctrl.dda = design->loopctrl_design.dda;
  inv_loopctrl->loopctrl.nvols = design->loopctrl_design.nvols;
  inv_loopctrl->loopctrl.naverages = design->loopctrl_design.naverages;
  inv_loopctrl->loopctrl.play_endofpass = design->loopctrl_design.play_endofpass;
  inv_loopctrl->seqctrl_filltr.ssi_time = design->filltr_ssi_time;

  /* generate the phase encoding plan */
  status = ksscan_phaseencoding_plan_eval_design(&inv_loopctrl->loopctrl.phaseenc_plan, &design->loopctrl_design.phaseenc_design);
  KS_RAISE(status);

  /* generate the dummy phase encoding plan */
  if (design->loopctrl_design.phaseenc_design_dummies.kacq.coords) {
    status = ksscan_phaseencoding_plan_eval_design(&inv_loopctrl->loopctrl.phaseenc_plan_dummies, &design->loopctrl_design.phaseenc_design_dummies);
    KS_RAISE(status);
  }

  /* check against too low maxTR regardless of IR type before continuing */
  if ((design->loopctrl_design.slicetiming_design.maxTR > 0) && (design->loopctrl_design.slicetiming_design.maxTR < (invseq_seqctrl_ptr->duration + mainseq_seqctrl_ptr->duration))) {
    return KS_THROW("design.maxTR (%d) too low to fit any slices in", design->loopctrl_design.slicetiming_design.maxTR);
  }

  status = ksscan_eval_setup_rf_slices(&inv_loopctrl->loopctrl.slicetiming,
                                       &design->loopctrl_design.slicetiming_design,
                                       !design->loopctrl_design.slicetiming_design.is3D);
  KS_RAISE(status);

  /* Number of slices per TR. May be updated in ksinv_eval_duration_interleaved() */
  inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass = CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices,
                                                                            design->loopctrl_design.slicetiming_design.minacqs);

  if (design->irmode == KSINV_ON_FLAIR_BLOCK) {

    status = ksinv_eval_duration_flairblock(inv_loopctrl,
                                            irslicetime, coreslicetime,
                                            invseq_seqctrl_ptr, mainseq_seqctrl_ptr,
                                            design);
    KS_RAISE(status);

    status = ks_eval_addtoseqcollection(seqcollection, &inv_loopctrl->seqctrl_filltr);
    KS_RAISE(status);

  } else if (design->irmode == KSINV_ON_INTERLEAVED) {

    if (design->T1value != KS_NOTSET) { /* AutoTR in range [.minTR, .maxTR] */
      status = ksinv_eval_duration_interleaved(inv_loopctrl,
                                               irslicetime, coreslicetime,
                                               invseq_seqctrl_ptr, mainseq_seqctrl_ptr,
                                               design);
      KS_RAISE(status);
    } else {
      status = ksinv_eval_duration_simple(inv_loopctrl,
                                          irslicetime, coreslicetime,
                                          invseq_seqctrl_ptr,
                                          design);
      KS_RAISE(status);
    }

  }

  /* If SMS, check that nslices_per_pass is an odd number (can some times be helped by adjusting #interleaves) */
  int inpass_interleaves = design->loopctrl_design.slicetiming_design.inpass_interleaves;
  status = ks_sms_check_divisibility(&inpass_interleaves,
                                      design->loopctrl_design.slicetiming_design.sms_factor,
                                      inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass,
                                      inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices);
  KS_RAISE(status);

  /* setup the slice plan for the sequence */
  ks_calc_sliceplan_interleaved(&inv_loopctrl->loopctrl.slicetiming.slice_plan,
                                inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices,
                                inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass,
                                inpass_interleaves);


  inv_loopctrl->loopctrl.slicetiming.maxslices_per_TR = 2048; /* GEs normal slice max value */


  return SUCCESS;

} /* ksinv_eval_custom() */

ksinv_eval_duration_simple()

STATUS ksinv_eval_duration_simple	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_CORESLICETIME	irslicetime,
		KS_CORESLICETIME	coreslicetime,
		KS_SEQ_CONTROL *	invseq_seqctrl_ptr,
		const KSINV_LOOP_CONTROL_DESIGN *	design
	)

[Internal ksinversion.cc] Sets the inversion timing and slice timing for a simple inversion case with fixed TI (.T1value = KS_NOTSET)

For simple main sequences consisting of only one sequence module each time it is played out (i.e. without additional fatsat or spatial sat sequences attached before each main sequence), coreslicetime.referencetimepoint is typically a small value of a few [ms] indicating the isocenter of the excitation pulse of the main sequence measured from the start of the main sequence. When e.g. a fatsat pulse sequence module is added before each main sequence module, this needs to be taken into account to get the correct inversion time. In these cases coreslicetime.referencetimepoint should be larger (to also include any leading extra sequence module between the inversion module and the main sequence module, and consequently the duration of the inversion module becomes proportionally smaller. If .design.TI is short in relation to coreslicetime.referencetimepoint this function will return an error.

If design->dosliceahead > 0, then the inversion duration is attempted to be reduced by playing the IR module in a slice-ahead fashion (like T1-FLAIR). Even for STIR sequences (depending on the ETL of the main sequence) it can be possible to get very low time penalty with the IR pulse, provided that the main sequence can fit in the dead space of the inversion duration.

Parameters

[out]	inv_loopctrl	Pointer to the inversion loop control to be generated
[in]	irslicetime	KS_CORESLICETIME returned by the irslice function (usually ksinv_scan_irslice())
[in]	coreslicetime	KS_CORESLICETIME returned by the coreslice function of the main sequence (cf. ksfse.cc:ksfse_scan_coreslice(), ksepi.cc:ksepi_scan_coreslice())
[in,out]	invseq_seqctrl_ptr	Pointer to KS_SEQ_CONTROL of the inversion sequence to be used. Note that the duration might be altered to adjust the timing
[in]	design	Pointer to inverion loop control design

Return values

STATUS

SUCCESS or FAILURE

                                                                           {

  if (design->irmode != KSINV_ON_INTERLEAVED) {
       return KS_THROW("design.irmode must be KSINV_ON_INTERLEAVED for this function");
  }
  if (design->TI <= 5000) {
    return KS_THROW("design.TI must be > 5 ms");
  }
  if (design->T1value != KS_NOTSET) {
    return KS_THROW("AutoTI not supported .design.T1value must be KS_NOTSET (-1)");
  }
  if (irslicetime.referencetimepoint < 0 || irslicetime.duration <= 0) {
    return KS_THROW("irslicetime field .referencetimepoint and .duration must be > 0");
  }
  if (coreslicetime.referencetimepoint < 0 || coreslicetime.duration <= 0) {
    return KS_THROW("corslicetime field .referencetimepoint and .duration must be > 0");
  }

  /* Initialize with no sliceahead */
  inv_loopctrl->nslicesahead = 0;  

  int inversiongap = RUP_GRD(design->TI - coreslicetime.referencetimepoint + irslicetime.referencetimepoint - irslicetime.duration);
  if (inversiongap < 0) {
    return KS_THROW("TI = %d resulted in a too short inv. seq. duration", design->TI/1000);
  }

  if (design->dosliceahead && inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass > 1 &&
      inversiongap > (irslicetime.duration + coreslicetime.duration)) {

    inv_loopctrl->nslicesahead = inversiongap / (irslicetime.duration + coreslicetime.duration);
    if (inv_loopctrl->nslicesahead > inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass - 1) {
      inv_loopctrl->nslicesahead = inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass - 1;      /* Don't exceed #slices per pass - 1 */
    }
    int timeleft = inversiongap - (inv_loopctrl->nslicesahead * (irslicetime.duration + coreslicetime.duration));
    irslicetime.duration += RUP_GRD(timeleft / (inv_loopctrl->nslicesahead + 1));
  } else {
    irslicetime.duration += inversiongap;
  }

  /* TI & TR states. Adjust duration of IR sequence (played in irslice) and main sequence (played in coreslice) */
  inv_loopctrl->TI = design->TI;
  inv_loopctrl->loopctrl.slicetiming.TR = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass;
  if (irslicetime.duration > invseq_seqctrl_ptr->duration) {
    invseq_seqctrl_ptr->duration = RUP_GRD(irslicetime.duration);
  } 

  return SUCCESS;

} /* ksinv_eval_duration_simple() */

ksinv_eval_nullti()

int ksinv_eval_nullti	(	int	TR,
		int	T1value,
		int	seqdur
	)

[Internal ksinversion.cc] Calculates the TI value necessary to null the signal from a tissue with a given T1 value,

the TR of the sequence and the main sequence duration, all in [us]

Parameters

[in]	TR	Repetition time in [us]
[in]	T1value	The T1 value of the tissue to be nulled in [us]
[in]	seqdur	The duration of the main sequence in [us]

Returns

TItime Inversion time in [us]

                                                       {

  return (int) ((double) T1value * ( log(2.0) - log(1.0 + exp(-((double) TR - (double) seqdur)/((double) T1value))) ));

} /* ksinv_eval_nullti() */

ksinv_eval_nulltr()

int ksinv_eval_nulltr	(	int	TI,
		int	T1value,
		int	seqdur
	)

[Internal ksinversion.cc (currently not used)] Calculates the TR value corresponding to a given T1 value,

the TI of the sequence and the main sequence duration, all in [us]

Parameters

[in]	TI	Inversion time in [us]
[in]	T1value	The T1 value of the tissue to be nulled in [us]
[in]	seqdur	The duration of the main sequence in [us]

Returns

TR Repetition time in [us]

                                                       {

  return (int) ((double) -T1value * log(2.0 * exp(-((double) TI)/((double) T1value)) - 1.0) + seqdur);

} /* ksinv_eval_nulltr() */

ksinv_eval_duration_interleaved()

STATUS ksinv_eval_duration_interleaved	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_CORESLICETIME	irslicetime,
		KS_CORESLICETIME	coreslicetime,
		KS_SEQ_CONTROL *	invseq_seqctrl_ptr,
		KS_SEQ_CONTROL *	mainseq_seqctrl_ptr,
		const KSINV_LOOP_CONTROL_DESIGN *	design
	)

[Internal ksinversion.cc] Sets the sequence module duration of a KSINV_MODULE as well as TI and TR (slice-ahead IR) for a T1-FLAIR type of scan

This function will set up the TI and TR (within seq.slicetiming.design.minTR/maxTR) and set the .seqctrl.duration for both the inversion and main sequence accordingly. It is a requirement for this function to work with AutoTR (some range given bydesign.minTR/maxTR differences) and AutoTI (.T1value > 0 and .TI = KS_NOTSET).

The inversion time will be approximated by the number of slices that can be played slice-aheaed but efforts are made to shift time between the inversion and main sequence to come as close to the optimal TI as possible. This is easier for main sequences with short ETL, many slices and long T1values (CSF), which is the typical case for T1-FLAIR.

This function will be used for STIR cases (with short TI) when AutoTI (.T1value > 0 and .TI = KS_NOTSET) in ksinv_eval() is selecting this function over ksinv_eval_duration_simple().

Parameters

[in,out]	inv_loopctrl	Pointer to the inversion loop control
[in]	irslicetime	KS_CORESLICETIME returned by the irslice function (usually ksinv_scan_irslice())
[in]	coreslicetime	KS_CORESLICETIME returned by the coreslice function of the main sequence (cf. ksfse.cc:ksfse_scan_coreslice(), ksepi.cc:ksepi_scan_coreslice())
[in]	invseq_seqctrl_ptr	Pointer to the inversion sequence control to be used
[in]	mainseq_seqctrl_ptr	Pointer to the main sequence control to be used
[in]	design	Pointer to inverion loop control design

Return values

STATUS

SUCCESS or FAILURE

                                                                                {

  if (design->irmode != KSINV_ON_INTERLEAVED) {
    return KS_THROW("design.irmode must be KSINV_ON_INTERLEAVED for this function");
  }

  if (design->TI != KS_NOTSET) {
    return KS_THROW("design.TI must be KS_NOTSET (-1)");
  }
  if (design->T1value <= 5000) {
    return KS_THROW("AutoTI required .design.T1value must be > 5ms");
  }
  if (coreslicetime.referencetimepoint == KS_NOTSET || coreslicetime.duration == KS_NOTSET) {
    return KS_THROW("Passed coreslice must have .referencetimepoint > 0 and .duration > 0");
  }
  if (irslicetime.referencetimepoint == KS_NOTSET || irslicetime.duration == KS_NOTSET) {
    return KS_THROW("Passed irslice must have .referencetimepoint > 0 and .duration > 0");
  }

  int TR, max_nslicesahead;
  int approxTI, TI, TIdiff, TRsum;
  int numacqs_needed = KS_NOTSET;
  const KS_CORESLICETIME irslicetime_orig = irslicetime;
  const KS_CORESLICETIME coreslicetime_orig = coreslicetime;
  const int shrinklimit_mainseq = mainseq_seqctrl_ptr->duration - mainseq_seqctrl_ptr->min_duration;
  const int shrinklimit_irseq = invseq_seqctrl_ptr->duration - invseq_seqctrl_ptr->min_duration; 

  if (design->loopctrl_design.slicetiming_design.nslices < 1) {
    return KS_THROW("nslices must be positive");
  }


  /* Step 1 - Find out how many acqs we need to not exceed design->loopctrl_design.slicetiming_design.maxTR (for approxTI = 0, we need one more IR+main as margin) */
  if  (design->loopctrl_design.slicetiming_design.maxTR > 0) { /* maxTR is limited */

    /* sum or TRs for all slices */
    TRsum = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices;

    /* Number of acqs (passes) needed to keep TR below .maxTR */
    numacqs_needed = IMax(2, CEIL_DIV(TRsum, design->loopctrl_design.slicetiming_design.maxTR), design->loopctrl_design.slicetiming_design.minacqs);

    /* Number of slices that fit within the valid TR (< .maxTR) */
    inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass = CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices, numacqs_needed);

  } else { /* TR has no upper limit */

    inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass = CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices, design->loopctrl_design.slicetiming_design.minacqs); 

  }


  /* Step 2 - Inflate the duration of the main sequence *if* the number of slices don't reach up to .design.minTR */
  TR = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass;
  if (TR < design->loopctrl_design.slicetiming_design.minTR) {
    int timetoadd_perTR = (design->loopctrl_design.slicetiming_design.minTR - TR);
    coreslicetime.duration += RUP_GRD(CEIL_DIV(timetoadd_perTR, inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass));
    TR = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass;
  }
  TI = ksinv_eval_nullti(TR, design->T1value, mainseq_seqctrl_ptr->min_duration);

  int inversiongap = RDN_GRD(TI - coreslicetime.referencetimepoint + irslicetime.referencetimepoint - irslicetime.duration);
  if (inversiongap < 0) {
    return KS_THROW("TI = %d resulted in a too short inv. seq. duration", TI/1000);
  }


  /* Step 3 - # slices that the IR sequence should be (temporally) ahead of the main sequence (to effectively create all/most of the TI time) */
  max_nslicesahead = inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass - 1;
  if (design->dosliceahead) {
    inv_loopctrl->nslicesahead = inversiongap / (irslicetime.duration + coreslicetime.duration);
    if (inv_loopctrl->nslicesahead > max_nslicesahead) {
      inv_loopctrl->nslicesahead = max_nslicesahead;
    }
    if (inv_loopctrl->nslicesahead < 0) {
      inv_loopctrl->nslicesahead = 0;
    }
  } else {
    inv_loopctrl->nslicesahead = 0;
  }


  /* Step 4 - Approximate TI */
  int shrinklimit_coreslice = 0;
  int shrinklimit_irslice = 0;
  int irslicetime_temp_duration[2];
  int coreslice_temp_duration[2];
  int napprox_directions = (inv_loopctrl->nslicesahead < max_nslicesahead) ? 2 : 1; /* if we can add one more sliceahead, then try also to round up TI */
  int adjust_amount[2] = {0, 0};
  int approx_dir;
  double errTI[2];


  for (approx_dir = 0; approx_dir < napprox_directions; approx_dir++) {
    /* 0: approx down 1: approx up */

    TR = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass;
    TI = ksinv_eval_nullti(TR, design->T1value, mainseq_seqctrl_ptr->min_duration);

    approxTI = (inv_loopctrl->nslicesahead + approx_dir) * (irslicetime.duration + coreslicetime.duration) + irslicetime.duration - irslicetime.referencetimepoint + coreslicetime.referencetimepoint;    

    if (approx_dir == 0) {
      TIdiff = TI - approxTI;
    } else {
      TIdiff = approxTI - TI;
    }

    if (TIdiff < 0) {
      return KS_THROW("APPROX TI PROGRAMMING ERROR");
    }

    if (approx_dir == 0) {
      /* move time from coreslice to irslice. This increases approxTI by 'adjust_amount' with TR unchanged, hence previous target 'TI' is still valid */

      shrinklimit_coreslice = shrinklimit_mainseq + (coreslicetime.duration - coreslicetime_orig.duration);
      adjust_amount[approx_dir] = IMin(2, shrinklimit_coreslice, TIdiff);

      coreslice_temp_duration[approx_dir]   = coreslicetime.duration - RUP_GRD(adjust_amount[approx_dir]);
      irslicetime_temp_duration[approx_dir] = irslicetime.duration   + RUP_GRD(adjust_amount[approx_dir]);
    } else {
      /* move time from irslice to coreslice. This decreases approxTI by 'adjust_amount' with TR unchanged, hence previous target 'TI' is still valid */

      shrinklimit_irslice = shrinklimit_irseq + (irslicetime.duration - irslicetime_orig.duration);
      adjust_amount[approx_dir] = IMin(2, shrinklimit_irslice, TIdiff);

      coreslice_temp_duration[approx_dir]   = coreslicetime.duration + RUP_GRD(adjust_amount[approx_dir]);
      irslicetime_temp_duration[approx_dir] = irslicetime.duration   - RUP_GRD(adjust_amount[approx_dir]);      
    }

    approxTI = (inv_loopctrl->nslicesahead + approx_dir) * (irslicetime_temp_duration[approx_dir] + coreslice_temp_duration[approx_dir]) + irslicetime_temp_duration[approx_dir] - irslicetime.referencetimepoint + coreslicetime.referencetimepoint;    

    errTI[approx_dir] = fabs(((double) TI - (double) approxTI) / (double) TI);

  } /* approx up or down */


  if ((errTI[0] < errTI[1]) || (napprox_directions == 1)) {
    irslicetime.duration   += adjust_amount[0];
    coreslicetime.duration -= adjust_amount[0];
  } else {
    inv_loopctrl->nslicesahead++;
    irslicetime.duration   -= adjust_amount[1];
    coreslicetime.duration += adjust_amount[1];
  }


  /* Update TI & TR again after duration changes */
  TR = (irslicetime.duration + coreslicetime.duration) * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass;
  TI = ksinv_eval_nullti(TR, design->T1value, mainseq_seqctrl_ptr->min_duration);
  approxTI = (inv_loopctrl->nslicesahead) * (irslicetime.duration + coreslicetime.duration) + irslicetime.duration - irslicetime.referencetimepoint + coreslicetime.referencetimepoint;

  /* TI & TR states. Adjust duration of IR sequence (played in irslice) and main sequence (played in coreslice) */
  inv_loopctrl->TI = approxTI;
  inv_loopctrl->errorTI = approxTI - TI;
  inv_loopctrl->loopctrl.slicetiming.TR = TR;
  invseq_seqctrl_ptr->duration += RUP_GRD(irslicetime.duration - irslicetime_orig.duration);
  mainseq_seqctrl_ptr->duration += RUP_GRD(coreslicetime.duration - coreslicetime_orig.duration);


  return SUCCESS;


} /* ksinv_eval_duration_interleaved() */

ksinv_eval_duration_flairblock()

STATUS ksinv_eval_duration_flairblock	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_CORESLICETIME	irslicetime,
		KS_CORESLICETIME	coreslicetime,
		KS_SEQ_CONTROL *	invseq_seqctrl_ptr,
		KS_SEQ_CONTROL *	mainseq_seqctrl_ptr,
		const KSINV_LOOP_CONTROL_DESIGN *	design
	)

[Internal ksinversion.cc] Sets the sequence module duration of a KSINV_MODULE for a FLAIR block design

This function sets the duration for an KSINV_MODULE module in a FLAIR block design, where seq.state.nflairslices number of inversion pulses are played first (at different slice locations) followed by equally many 'coreslice' playouts (main sequence + optional other sequence modules attached to the main sequence).

For few slices, the TR is increased by a separate empty pulse sequnce (seq.seqctrl_filltr) to reach slicetiming.design.minTR.

Parameters

[in,out]	inv_loopctrl	Pointer to the inversion loop control
[in]	irslicetime	KS_CORESLICETIME returned by the irslice function (usually ksinv_scan_irslice())
[in]	coreslicetime	KS_CORESLICETIME returned by the coreslice function of the main sequence (cf. ksfse.cc:ksfse_scan_coreslice(), ksepi.cc:ksepi_scan_coreslice())
[in]	invseq_seqctrl_ptr	Pointer to the inversion sequence control to be used
[in]	mainseq_seqctrl_ptr	Pointer to the main sequence control to be used
[in]	design	Pointer to inverion loop control design

Return values

STATUS

SUCCESS or FAILURE

                                                                               {
  STATUS status;

  if (design->irmode != KSINV_ON_FLAIR_BLOCK) {
    return KS_THROW("design.irmode must be KSINV_ON_FLAIR_BLOCK for this function");
  }
  if (invseq_seqctrl_ptr->min_duration <= 0) {
    return KS_THROW("min_duration of the inversion sequence (arg 1) must be > 0");
  }
  if (mainseq_seqctrl_ptr->min_duration <= 0) {
    return KS_THROW("min_duration of the main sequence must be > 0");
  }
  if (mainseq_seqctrl_ptr->duration < mainseq_seqctrl_ptr->min_duration) {
    return KS_THROW("main sequence's duration of the main sequence must be > %d us", mainseq_seqctrl_ptr->min_duration);
  }
  if (invseq_seqctrl_ptr->duration < invseq_seqctrl_ptr->min_duration) {
    return KS_THROW("inversion sequence's duration of the main sequence must be > %d us", invseq_seqctrl_ptr->min_duration);
  }
  if (design->dosliceahead) {
    return KS_THROW("dosliceahead must be 0");
  } else {
    inv_loopctrl->nslicesahead = 0;
  }
  if (design->TI != KS_NOTSET && design->TI <= 10000) {
    return KS_THROW("TI must be > 10 ms");
  }
  if (design->T1value > 0 && design->T1value <= 10000) {
    return KS_THROW("T1value must be > 10 ms");
  }
  if (coreslicetime.referencetimepoint == KS_NOTSET || coreslicetime.duration == KS_NOTSET) {
    return KS_THROW("Passed coreslice must have .referencetimepoint > 0 and .duration > 0");
  }
  if (irslicetime.referencetimepoint == KS_NOTSET || irslicetime.duration == KS_NOTSET) {
    return KS_THROW("Passed irslice must have .referencetimepoint > 0 and .duration > 0");
  }

  int avail_flairseqtime;
  int lastTR = KS_NOTSET;
  int TR = KS_NOTSET;
  int TI = KS_NOTSET;
  int timetoadd_perTR;
  const float TRtol = 0.01;
  const int itermax = 20;
  int iter = 0;
  const KS_CORESLICETIME irslicetime_orig = irslicetime;
  const KS_CORESLICETIME coreslicetime_orig = coreslicetime;
  const int shrinklimit_mainseq = mainseq_seqctrl_ptr->duration - mainseq_seqctrl_ptr->min_duration;

  if (design->loopctrl_design.slicetiming_design.nslices < 1) {
    return KS_THROW("nslices must be positive");
  }

  inv_loopctrl->seqctrl_filltr.duration = 0;
  TR = 20000000; /* 20 s to start with */

  for (iter = 0; iter < itermax; iter++) {

    coreslicetime.duration = IMax(2, coreslicetime_orig.duration, irslicetime_orig.duration); /* Blocks must be equal to max of them for FLAIR */
    irslicetime.duration = coreslicetime.duration;

    /* Step 1 - Get the minimum possible TR (incl SAR/heating and design.minTR) and the resulting TI */
    if (design->T1value > 0) {
      /* autoTI */
      TI = ksinv_eval_nullti(IMax(2, TR, design->loopctrl_design.slicetiming_design.minTR), design->T1value, mainseq_seqctrl_ptr->min_duration); 
    } else {
      TI = design->TI;
    }


    /* Step 2 - Get the number of FLAIR slices per block and number of blocks */
    avail_flairseqtime = irslicetime.referencetimepoint + TI - coreslicetime.referencetimepoint;
    if (avail_flairseqtime < 0) {
      return KS_THROW("TI too short to allow inversion");
    }
    inv_loopctrl->nflairslices = avail_flairseqtime / coreslicetime.duration; /* how many slices that can be fitted within 'TI' */
    if (inv_loopctrl->nflairslices == 0) {
      /* round-up (fall back to simple IR style). We have already checked that TI is long enough to fit one IR playout */
      inv_loopctrl->nflairslices = 1;
    }
    if (inv_loopctrl->nflairslices > inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass) {
      inv_loopctrl->nflairslices = inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass; /* don't exceed the total number of slices per pass */
    }
    inv_loopctrl->nflairslices -= inv_loopctrl->nflairslices % design->loopctrl_design.slicetiming_design.sms_factor; /* SMS compatibility (mb_factor = 1 for non-SMS) */
    inv_loopctrl->nflairblocks = CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass, inv_loopctrl->nflairslices); /* number of FLAIR blocks needed to play inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass slices */


    /* Step 3 - Adjust the IR seq duration and main sequence, then get new actual TR */
    irslicetime.duration = RUP_GRD(avail_flairseqtime / inv_loopctrl->nflairslices);
    if (irslicetime.duration < (coreslicetime_orig.duration - shrinklimit_mainseq) && inv_loopctrl->nflairslices > 1) {
      return KS_THROW("FLAIR slice duration became shorter than shortest possible coreslice duration");
    } else {
      coreslicetime.duration = irslicetime.duration;
    }
    TR = (irslicetime.duration * inv_loopctrl->nflairslices * inv_loopctrl->nflairblocks) + (coreslicetime.duration * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass); /* without seqctrl_filltr this time */


    /* Step 4 - If TR < design->loopctrl_design.slicetiming_design.minTR, add this duration to the fillTR sequence module */
    if (TR < design->loopctrl_design.slicetiming_design.minTR) {
      timetoadd_perTR = design->loopctrl_design.slicetiming_design.minTR - TR;
      status = ksinv_eval_duration_setfilltr(&inv_loopctrl->seqctrl_filltr, RUP_GRD(timetoadd_perTR / inv_loopctrl->nflairblocks));
    } else {
      status = ksinv_eval_duration_setfilltr(&inv_loopctrl->seqctrl_filltr, 0);
    }
    KS_RAISE(status);


    TR = (irslicetime.duration * inv_loopctrl->nflairslices * inv_loopctrl->nflairblocks) + (coreslicetime.duration * inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass) + inv_loopctrl->seqctrl_filltr.duration;

    if (((float) abs(lastTR - TR) / (float) TR) < TRtol) {
      break;
    } else {
      lastTR = TR;
    }

  } /* for iter */



  /* TI & TR states. Adjust duration of IR sequence (played in irslice) and main sequence (played in coreslice) */
  inv_loopctrl->TI = TI;
  inv_loopctrl->loopctrl.slicetiming.TR = TR;
  invseq_seqctrl_ptr->duration += RUP_GRD(irslicetime.duration - irslicetime_orig.duration);
  mainseq_seqctrl_ptr->duration += RUP_GRD(coreslicetime.duration - coreslicetime_orig.duration);

  return SUCCESS;

} /* ksinv_eval_duration_flairblock() */

ksinv_eval_duration_setfilltr()

STATUS ksinv_eval_duration_setfilltr	(	KS_SEQ_CONTROL *	filltr,
		int	duration
	)

[Internal ksinversion.cc] Creates an empty sequence for the purpose of reaching up to TR for FLAIR block inversion

Parameters

[in,out]	filltr	Pointer to KS_SEQ_CONTROL for the empty sequence
[in]	duration	Duration in [us] for the empty fill sequence

Return values

STATUS

SUCCESS or FAILURE

                                                                           {

  if (filltr->ssi_time <= 0) {
    return KS_THROW("filltr.ssi_time must be positive");
  }

  if (duration >= filltr->ssi_time) {
    sprintf(filltr->description, "filltr");
    filltr->min_duration = RUP_GRD(filltr->ssi_time);
    filltr->duration = RUP_GRD(duration);
  } else {
    ks_init_seqcontrol(filltr);
    sprintf(filltr->description, "filltr_disabled");
  }

  return SUCCESS;

} /* ksinv_eval_duration_setfilltr() */

ksinv_check()

STATUS ksinv_check

(

)

Checks related to inversion

Return values

STATUS

SUCCESS or FAILURE

                     {

  return SUCCESS;

} /* ksinv_check() */

ksinv_predownload_setrecon()

STATUS ksinv_predownload_setrecon

(

)

Sets IR-related recon variables in predownload

Return values

STATUS

SUCCESS or FAILURE

                                    {

  return SUCCESS;

} /* ksinv_predownload_setrecon() */

ksinv_scan_sliceloop()

s64 ksinv_scan_sliceloop	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KSINV_LOOP_MODE	ksinv_loop_mode,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

Plays a single repetition of an inversion sequence

Parameters

[in]	inv_loopctrl	Inversion loop control that describe the looping patterns
[in,out]	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions and which is ultimately used to set the state for all modules
[in]	ksinv_loop_mode	Type of TR to played if the inversions are interleaved (irmode = KSINV_ON_INTERLEAVED)
[in]	coreslice	Pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Pointer to function playing an inversion (and optionally more) modules for a single inversion slice playout

Return values

time	Duration in [us] to play out the scope of the function in real time

                                                                                                                 {
  if (inv_loopctrl->irmode == KSINV_ON_FLAIR_BLOCK) {
    return ksinv_scan_sliceloop_flairblock(inv_loopctrl,
                                           dynamic,
                                           coreslice,
                                           irslice);
  }

  const int nslicesahead_current = ksinv_loop_mode == KSINV_LOOP_SLICEAHEAD_FIRST ?
    KS_NOTSET : inv_loopctrl->nslicesahead;
  const int nslicesahead_next = ksinv_loop_mode == KSINV_LOOP_SLICEAHEAD_LAST ?
    KS_NOTSET : inv_loopctrl->nslicesahead;
  const int play_core = ksinv_loop_mode != KSINV_LOOP_SLICEAHEAD_FIRST;
  
  return ksinv_scan_sliceloop_sliceahead(inv_loopctrl,
                                         dynamic,
                                         coreslice,
                                         irslice,
                                         nslicesahead_current,
                                         nslicesahead_next,
                                         play_core);

} /* ksinv_scan_sliceloop() */

ksinv_scan_sliceloop_flairblock()

s64 ksinv_scan_sliceloop_flairblock	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

[Internal ksinversion.cc] Plays out one repetition for an inversion scan

Parameters

[in]	inv_loopctrl	Pointer to the inversion loop control
	dynamic	Pointer to KS_DYNAMIC_STATE
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing the inversion function

Returns

slicelooptime Time taken in [us] to play out seq->slicetiming.state.slice_plan.nslices_per_pass slices

                                                                                                                     {
  s64 time = 0;
  int i;
  int sltimeinpass = 0;
  const SCAN_INFO *slpos;

#ifndef IPG
  if (inv_loopctrl == NULL) {
    KS_THROW("inversion seq (1st arg) cannot be NULL");
    return KS_NOTSET;
  }
  if (inv_loopctrl->irmode == KSINV_OFF) {
    return 0;  /* if the IR mode for the 1st IR is off, return quietly */
  }
  if (inv_loopctrl->nflairslices <= 0) {
    KS_THROW("nflairslices must be > 0");
    return KS_NOTSET;
  }
#endif

  /* For classic T2-FLAIR, we often end up with 2 sets of FLAIR+core per TR
     Here is a generalization, where number of sets is equal to:
     CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass, inv_loopctrl->nflairslices), where inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass = CEIL_DIV(inv_loopctrl->loopctrl.slicetiming.slice_plan->nslices, inv_loopctrl->loopctrl.slicetiming.slice_plan->npasses)
  */

  /* make sure the step is positive, or else we will be stuck here as sltimeinpass will remain at 0 forever */
  const int slice_step = IMax(2, inv_loopctrl->nflairslices, 1);

  sltimeinpass = 0;

  while (sltimeinpass < inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass) {

    /*--------- inversion sequence module as FLAIR block -----------*/
    for (i = 0; i < inv_loopctrl->nflairslices; i++) {
      dynamic->slloc = ks_scan_getsliceloc(&inv_loopctrl->loopctrl.slicetiming.slice_plan, dynamic->pass, sltimeinpass + i);
      slpos = (dynamic->slloc != KS_NOTSET) ? &inv_loopctrl->loopctrl.slicetiming.rf_scan_info[dynamic->slloc] : NULL;
      time += irslice(slpos, dynamic).duration; /* if slpos = NULL, shut off RF */
    }

    for (i = 0; (i < inv_loopctrl->nflairslices) && ((sltimeinpass + i) < inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass); i++) {

      dynamic->slloc = ks_scan_getsliceloc(&inv_loopctrl->loopctrl.slicetiming.slice_plan, dynamic->pass, sltimeinpass + i);
      slpos = (dynamic->slloc != KS_NOTSET) ? &inv_loopctrl->loopctrl.slicetiming.rf_scan_info[dynamic->slloc] : NULL;

      /*--------- "coreslice": main sequence module (may include e.g. GRx Sat, FatSat etc.) -----------*/

      dynamic->sltimeinpass = (sltimeinpass + i); 
      time += coreslice(slpos, dynamic).duration;
    }

    sltimeinpass += slice_step;

    if (inv_loopctrl->seqctrl_filltr.duration > 0) {
      /*--------- fillTR sequence module (to fill up to manual TR in CEIL_DIV(nslices_per_pass, inv_loopctrl->nflairslices) chunks) -----------*/
      time += ks_scan_playsequence(&inv_loopctrl->seqctrl_filltr);
      ks_plot_slicetime(&inv_loopctrl->seqctrl_filltr, 1, NULL, KS_NOTSET, KS_PLOT_NO_EXCITATION); /* Add a filler to slicetime plot */
    }      

  } /* while */

  return time;

} /* ksinv_scan_sliceloop_flairblock() */

ksinv_scan_sliceloop_sliceahead()

s64 ksinv_scan_sliceloop_sliceahead	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		int	nslicesahead_current,
		int	nslicesahead_next,
		int	play_core
	)

[Internal ksinversion.cc] Plays a single repetition of an interleaved inversion sequence

Parameters

	inv_loopctrl	Pointer to the inversion loop control
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing an inversion (and optionally more) modules for a single inversion slice playout
[in]	nslicesahead_current	Offset of the slice index used for inversion module(s) with respect to the one used for the core module(s). This is used only for inversions that will be sampled within the same repetition
[in]	nslicesahead_next	Offset of the slice index used for inversion module(s) with respect to the one used for the core module(s). This is used only for inversions that will be sampled in the next repetition. Note that it is requred that nslicesahead_next <= nslicesahead_next.
[in]	play_core	Flag indicating whether to turn on the acquisition of the core module

Return values

time	Duration in [us] to play out the scope of the function in real time

                                                         {
  s64 time = 0;
  int sltimeinpass = 0;
  const SCAN_INFO *slpos;

#ifndef IPG
  if (inv_loopctrl == NULL) {
    KS_THROW("inversion seq (1st arg) cannot be NULL");
    return KS_NOTSET;
  }
  if (inv_loopctrl->irmode == KSINV_OFF) {
    return 0;  /* if the IR mode for the 1st IR is off, return quietly */
  }
  if (nslicesahead_current > inv_loopctrl->nslicesahead) {
    KS_THROW("nslicesahead_current (%d) can not be higher than the evaluated nslicesahead (inv_loopctrl->nslicesahead = %d)",
             nslicesahead_current, inv_loopctrl->nslicesahead);
    return KS_NOTSET;
  }  
  if (nslicesahead_next > nslicesahead_current && nslicesahead_current > 0) {
    KS_THROW("nslicesahead_next (%d) can not be higher than nslicesahead_current (%d)",
             nslicesahead_next, nslicesahead_current);
    return KS_NOTSET;
  }
#endif
  const int total_slices_per_pass = inv_loopctrl->loopctrl.slicetiming.slice_plan.nslices_per_pass + inv_loopctrl->ndummy_slices_per_pass;
  const int sltime_start = (!play_core && nslicesahead_current < 0) ?
    (total_slices_per_pass - nslicesahead_next) : 0;
  const int current_pass_inv_end = nslicesahead_current < 0 ? 0 :
    total_slices_per_pass - nslicesahead_current;
  const int next_pass_inv_start = total_slices_per_pass -
    (nslicesahead_next < 0 ? 0 : nslicesahead_next);

  for (sltimeinpass = sltime_start; sltimeinpass < total_slices_per_pass; sltimeinpass++) {

    /*--------- inversion sequence module -----------*/
    dynamic->slloc = KS_NOTSET;
    if (sltimeinpass < current_pass_inv_end) {
      const int sltime_adjusted = sltimeinpass + nslicesahead_current - inv_loopctrl->ndummy_slices_per_pass;
      dynamic->slloc = ks_scan_getsliceloc(&inv_loopctrl->loopctrl.slicetiming.slice_plan, dynamic->pass, sltime_adjusted);
    }
    if (sltimeinpass >= next_pass_inv_start) {
      const int sltime_adjusted = (sltimeinpass + nslicesahead_next) % total_slices_per_pass - inv_loopctrl->ndummy_slices_per_pass;
      dynamic->slloc = ks_scan_getsliceloc(&inv_loopctrl->loopctrl.slicetiming.slice_plan, dynamic->pass, sltime_adjusted);
    }
    slpos = (dynamic->slloc != KS_NOTSET) ? &inv_loopctrl->loopctrl.slicetiming.rf_scan_info[dynamic->slloc] : NULL;        
    time += irslice(slpos, dynamic).duration; /* if slpos = NULL, shut off RF */

    /*--------- "coreslice": main sequence module (may include e.g. GRx Sat, FatSat etc.) -----------*/
    dynamic->slloc = ks_scan_getsliceloc(&inv_loopctrl->loopctrl.slicetiming.slice_plan, dynamic->pass, sltimeinpass - inv_loopctrl->ndummy_slices_per_pass);
    slpos = (dynamic->slloc != KS_NOTSET) ? &inv_loopctrl->loopctrl.slicetiming.rf_scan_info[dynamic->slloc] : NULL;
    slpos = play_core ? slpos : NULL;
    dynamic->sltimeinpass = sltimeinpass - inv_loopctrl->ndummy_slices_per_pass;
    time += coreslice(slpos, dynamic).duration; 

  } /* slice in pass */

  return time;

} /* ksinv_scan_sliceloop_sliceahead() */

ksinv_scan_acqloop()

s64 ksinv_scan_acqloop	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		const int	inv_rampup,
		const int	inv_rampdown
	)

Plays out one pass/acquisition for an inversion scan

It affords the option to ramp up/down the inversions

Parameters

[in]	inv_loopctrl	Pointer to the inversion loop control
[in,out]	dynamic	Pointer to KS_DYNAMIC_STATE
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing an inversion (and optionally more) modules for a single inversion slice playout
[in]	inv_rampup	Flag for turning on the ramp up of the inversions at the beginning of the acquisition/pass
[in]	inv_rampdown	Flag for turning on the ramp down of the inversions at the end of the acquisition/pass

Return values

time	Duration in [us] to play out the scope of the function in real time

                                                                            {

  if (inv_loopctrl->irmode == KSINV_ON_FLAIR_BLOCK) {
    return ksinv_scan_acqloop_flairblock(inv_loopctrl,
                                         dynamic,
                                         coreslice,
                                         irslice);
  }

  const int nslicesahead_current = inv_loopctrl->nslicesahead;
  const int nslicesahead_next = inv_rampdown ? KS_NOTSET : inv_loopctrl->nslicesahead;
  return ksinv_scan_acqloop_sliceahead(inv_loopctrl,
                                       dynamic,
                                       coreslice,
                                       irslice,
                                       nslicesahead_current,
                                       nslicesahead_next,
                                       inv_rampup);
} /* ksinv_scan_acqloop() */

ksinv_scan_scanloop()

s64 ksinv_scan_scanloop	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

Plays the entire scan for an inversion loop control

Parameters

[in]	inv_loopctrl	Pointer to the inversion loop control
[in,out]	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing the inversion function

Returns

time Duration in [us] to play out the scope of the function in real time

In a single pass scan we should ramp up/down only once. NOTE: this holds only if all sequences have the same slice encoding plan. – E.A.

                                                                                                                {
  s64 time = 0;
  const int dda = inv_loopctrl->loopctrl.dda;

  KS_DYNAMIC_STATE default_dynamic = KS_INIT_DYNAMIC_STATE;
  if (!dynamic) {
    dynamic = &default_dynamic;
  }

  for (dynamic->vol = 0; dynamic->vol < inv_loopctrl->loopctrl.nvols; dynamic->vol++) {

    const int inv_rampup =
      (inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses == 1 && dynamic->vol == 0)
      || inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses != 1;

    const int inv_rampdown =
      (inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses == 1 && dynamic->vol == inv_loopctrl->loopctrl.nvols - 1)
      || inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses != 1;

    for (dynamic->pass = 0; dynamic->pass < inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses; dynamic->pass++) {

      /* In a single pass scan we should play dummies only once */
      inv_loopctrl->loopctrl.dda = inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses == 1 ?
        (!dynamic->vol)*dda :
        dda;

        time += ksinv_scan_acqloop(inv_loopctrl, dynamic,
                                          coreslice, irslice,
                                          inv_rampup, inv_rampdown);

      inv_loopctrl->loopctrl.dda = 0;
      if (inv_loopctrl->loopctrl.play_endofpass) {
        time += GEReq_endofpass();
      }
      ks_plot_slicetime_endofpass(KS_PLOT_PASS_WAS_STANDARD);

    } /* pass loop */

  } /* volume loop */

  /* restore #dummies */
  inv_loopctrl->loopctrl.dda = dda;

  return time; /* in [us] */

} /* ksinv_scan_scanloop() */

ksinv_prescanloop()

void ksinv_prescanloop	(	KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		int	nloops,
		int	dda
	)

Prescan loop for inversion

Parameters

[in]	inv_loopctrl	Pointer to the inversion loop control
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing the inversion function
[in]	nloops	ADDTEXTHERE
[in]	dda	ADDTEXTHERE

Returns

void

Prescan loop for inversion

                                                   {

  const KS_PHASEENCODING_SHOTCOORDS fake_shot = KS_INIT_PHASEENCODING_SHOTCOORDS;
  KS_DYNAMIC_STATE dynamic = KS_INIT_DYNAMIC_STATE;
  dynamic.prescan = 1;
  dynamic.shot_coords = fake_shot;

  if (inv_loopctrl->nslicesahead) {
    /* sliceahead inversion prologue (KSINV_LOOP_SLICEAHEAD_FIRST) */

    KS_DYNAMIC_STATE dynamic_sliceahead = KS_INIT_DYNAMIC_STATE; /* Everything is KS_NOTSET */
    ksinv_scan_sliceloop(inv_loopctrl, &dynamic_sliceahead, KSINV_LOOP_SLICEAHEAD_FIRST, coreslice, irslice);
  }

  int i;
  for (i = -dda; i < nloops; i++) {
    /* negative shot always closes data receiver during prescan */
    dynamic.shot = (dda < 0) * KS_NOTSET;
    ksinv_scan_sliceloop(inv_loopctrl, &dynamic, KSINV_LOOP_NORMAL, coreslice, irslice);
  } /* for nloops */

} /* ksscan_prescanloop_custom() */

ksinv_eval_chain_design()

STATUS ksinv_eval_chain_design	(	KSINV_CHAIN *	inv_chain,
		KSINV_CHAIN_DESIGN *	inv_chain_design,
		const KSINV_LOOP_CONTROL *	inv_loopctrl
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

inv_chain	ADDTEXTHERE
inv_chain_design	ADDTEXTHERE
inv_loopctrl	ADDTEXTHERE

Return values

STATUS

SUCCESS or FAILURE

                                                                       {

  STATUS status;

  if (!inv_chain || !inv_chain_design || !inv_loopctrl) {
    return KS_THROW("NULL input");
  }

  if (inv_loopctrl->irmode == KSINV_OFF || inv_chain_design->num_vols < 1) {
    return SUCCESS;
  }

  if (inv_loopctrl->nslicesahead < 1 || inv_loopctrl->irmode == KSINV_ON_FLAIR_BLOCK) {
    return KS_THROW("Inversion chain is only compatible with slice ahead mode (KSINV_ON_INTERLEAVED)");
  }

  /* TODO: sort the individual volume designs so that T2w always come first and then nslicesahead is decreasing? */

  /* Copy fields */
  inv_chain->num_vols = inv_chain_design->num_vols;

  int i;
  for (i=0; i<inv_chain->num_vols; ++i) {
    if (inv_chain_design->nslicesaheads[i] > inv_loopctrl->nslicesahead) {
      return KS_THROW("A requested nslicesahead can not exceed the value from inv_loopctrl");
    }

    inv_chain->inv_vols[i].nslicesahead = inv_chain_design->nslicesaheads[i];
    inv_chain->inv_vols[i].dda = inv_chain_design->ddas[i];
    inv_chain->inv_vols[i].echo_offset = inv_chain_design->echo_offsets[i];

    if (inv_chain_design->phaseenc_plan_designs[i].kacq.coords) {

      /* TODO: check if num_encodes is the same for all vols? */

      status = ksscan_phaseencoding_plan_eval_design(&inv_chain->inv_vols[i].phaseenc_plan,
                                                     &inv_chain_design->phaseenc_plan_designs[i]);
      KS_RAISE(status);
    } else {
      /* Copy from the inversion loop control */
      inv_chain->inv_vols[i].phaseenc_plan = inv_loopctrl->loopctrl.phaseenc_plan;
    }
  }

  return SUCCESS;
}

ksinv_scan_acqloop_chain()

s64 ksinv_scan_acqloop_chain	(	const KSINV_CHAIN *	inv_chain,
		KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	inv_chain	ADDTEXTHERE
	inv_loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing the inversion function

Returns

time Duration in [us] to play out the scope of the function in real time

                                                                                                              {

  s64 time = 0;

  /* Save fields that need to be updated */
  const int orig_dda = inv_loopctrl->loopctrl.dda;
  const KS_PHASEENCODING_PLAN orig_phaseenc_plan = inv_loopctrl->loopctrl.phaseenc_plan;
  const int orig_echo_offset = dynamic->echo_offset;

  int inv_rampup = inv_chain->inv_vols[0].nslicesahead > 0;

  int i = 0;
  for (; i < inv_chain->num_vols; ++i) {

    /* Update fields */
    inv_loopctrl->loopctrl.dda = inv_chain->inv_vols[i].dda;
    inv_loopctrl->loopctrl.phaseenc_plan = inv_chain->inv_vols[i].phaseenc_plan;
    dynamic->echo_offset = orig_echo_offset + inv_chain->inv_vols[i].echo_offset;    

    const int nslicesahead_next = i+1 == inv_chain->num_vols ? KS_NOTSET : inv_chain->inv_vols[i+1].nslicesahead;

    time += ksinv_scan_acqloop_sliceahead(inv_loopctrl,
                                          dynamic,
                                          coreslice,
                                          irslice,
                                          inv_chain->inv_vols[i].nslicesahead,
                                          nslicesahead_next,
                                          inv_rampup);

    inv_rampup = 0;
  }

  /* Restore fields that need to be updated */
  inv_loopctrl->loopctrl.dda = orig_dda;
  inv_loopctrl->loopctrl.phaseenc_plan = orig_phaseenc_plan;
  dynamic->echo_offset = orig_echo_offset;

  return time;

} /* ksinv_scan_acqloop_chain() */

ksinv_scan_scanloop_chain()

s64 ksinv_scan_scanloop_chain	(	const KSINV_CHAIN *	inv_chain,
		KSINV_LOOP_CONTROL *	inv_loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		KS_CORESLICETIME	irsliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	inv_chain	ADDTEXTHERE
	inv_loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	Function pointer to function playing one or more sequence modules for a single playout
[in]	irslice	Function pointer to function playing the inversion function

Returns

time Duration in [us] to play out the scope of the function in real time

                                                                                                               {

  s64 time = 0;

  KS_DYNAMIC_STATE default_dynamic = KS_INIT_DYNAMIC_STATE;
  if (!dynamic) {
    dynamic = &default_dynamic;
  }

  for (dynamic->vol = 0; dynamic->vol < inv_loopctrl->loopctrl.nvols; dynamic->vol++) {
    for (dynamic->pass = 0; dynamic->pass < inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses; dynamic->pass++) {

      time += ksinv_scan_acqloop_chain(inv_chain,
                                       inv_loopctrl,
                                       dynamic,
                                       coreslice,
                                       irslice);

      if (inv_loopctrl->loopctrl.play_endofpass) {
        time += GEReq_endofpass();
      }
      ks_plot_slicetime_endofpass(KS_PLOT_PASS_WAS_STANDARD);
    }
  }

  return time;

} /* ksinv_scan_scanloop_chain() */