Feature module: Propeller (ksprop.[h,cc])

Data Structures
struct	KSPROP2_METADATA
struct	KSPROP_DESIGN
struct	KSPROP_STATE
struct	KSPROP_SETTINGS

Macros
#define	KSPROP_MAXBLADES   256
#define	GOLDEN_SECTION   1.618
#define	KSPROP2_INIT_METADATA   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
#define	KSPROP_INIT_DESIGN   {KSPROP_LINEAR_ANGLE, KSPROP_LOOPMODE_INNER_BLADE, KSPROP_COLORED_NOISE, 1.0f, 0, 1}
#define	KSPROP_INIT_STATE   {KS_NOTSET, KS_INITVALUE(KSPROP_MAXBLADES,0)}
#define	KSPROP_DEFAULT_SETTINGS   {KSPROP_INIT_DESIGN, KSPROP_INIT_STATE}

Enumerations
enum	KSPROP_MODE { KSPROP_GOLDEN_ANGLE = 0, KSPROP_LINEAR_ANGLE = 1 }
enum	KSPROP_LOOPMODE { KSPROP_LOOPMODE_INNER_PASS = 0, KSPROP_LOOPMODE_INNER_BLADE = 1 }
enum	KSPROP_NOISEMODE { KSPROP_COLORED_NOISE = 0, KSPROP_WHITE_NOISE_RADIAL = 1, KSPROP_WHITE_NOISE_SIMPLE_RADIAL = 2, KSPROP_WHITE_NOISE_TAILORED = 3 }

Functions
float	ksprop_bladeangle_golden (int bladeidx)
STATUS	ksprop_eval_bladeangles (KSPROP_SETTINGS *prop)
int	ksprop_eval_numblades (float bladefactor, int xres, int yres, const int crosscal, const unsigned int averages)
STATUS	ksprop_eval_validatedesign (KSPROP_SETTINGS *prop, KS_KSPACE_DESIGN *kdesign)
STATUS	ksprop_eval (KSPROP_SETTINGS *prop, KS_KSPACE_DESIGN *kdesign)
STATUS	eval_white_prop_readwave (KS_READWAVE *readwave, const int nsamples, const KS_WAVEFORM half_acq_waveform, const float sampling_area, const KS_KSPACE_DESIGN *kdesign, const float xcrusher_area, const char *desc)
float	get_blade_intersection (const float theta, const float kv, const float kv_max)
void	get_blade_intersections (float *blade_intersections, const float kv, const float kv_max, const float *blade_angles, const int nblades)
int	num_intersections_beyond_k (const float *blade_intersections, const int nblades, const float k)
float	radial_curve (const float ku, const float ku_max, const float kv_max)
void	get_half_wave (KS_WAVEFORM acq_waveform, const int nsamples, const float scale, const float *blade_intersections, const int nblades, const float ku_max, const float kv_max, const float slew_limit, const float amp_limit)
float	get_area (KS_WAVEFORM waveform, const int nsamples, const float dwell)
void	optimize (KS_WAVEFORM acq_waveform, const int nsamples, const float *blade_intersections, const int nblades, const float ku_max, const float kv_max, const float slew_limit, const float amp_limit)
void	ksprop_init_settings (KSPROP_SETTINGS *const prop)
s64	ksprop_scan_singlepass (const KSPROP_SETTINGS *prop, KSSCAN_LOOP_CONTROL *loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
s64	ksprop_scan_singlepass_inv (const KSPROP_SETTINGS *prop, 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	ksprop_scan_scanloop (const KSPROP_SETTINGS *prop, KSSCAN_LOOP_CONTROL *loopctrl, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
s64	ksprop_scan_scanloop_inv (const KSPROP_SETTINGS *prop, 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	ksprop_attach_metadata (WF_PULSE_ADDR echo, const KS_DYNAMIC_STATE *dynamic, const char *custom)

Detailed Description

Macro Definition Documentation

KSPROP_MAXBLADES

#define KSPROP_MAXBLADES   256

GOLDEN_SECTION

#define GOLDEN_SECTION   1.618

KSPROP2_INIT_METADATA

#define KSPROP2_INIT_METADATA   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

KSPROP_INIT_DESIGN

#define KSPROP_INIT_DESIGN   {KSPROP_LINEAR_ANGLE, KSPROP_LOOPMODE_INNER_BLADE, KSPROP_COLORED_NOISE, 1.0f, 0, 1}

KSPROP_INIT_STATE

#define KSPROP_INIT_STATE   {KS_NOTSET, KS_INITVALUE(KSPROP_MAXBLADES,0)}

KSPROP_DEFAULT_SETTINGS

#define KSPROP_DEFAULT_SETTINGS   {KSPROP_INIT_DESIGN, KSPROP_INIT_STATE}

Enumeration Type Documentation

KSPROP_MODE

enum KSPROP_MODE

Enumerator
KSPROP_GOLDEN_ANGLE
KSPROP_LINEAR_ANGLE

             {KSPROP_GOLDEN_ANGLE = 0,
              KSPROP_LINEAR_ANGLE = 1
} KSPROP_MODE;

KSPROP_LOOPMODE

enum KSPROP_LOOPMODE

Enumerator
KSPROP_LOOPMODE_INNER_PASS
KSPROP_LOOPMODE_INNER_BLADE

             {KSPROP_LOOPMODE_INNER_PASS = 0,
              KSPROP_LOOPMODE_INNER_BLADE = 1
} KSPROP_LOOPMODE;

KSPROP_NOISEMODE

enum KSPROP_NOISEMODE

Enumerator
KSPROP_COLORED_NOISE
KSPROP_WHITE_NOISE_RADIAL
KSPROP_WHITE_NOISE_SIMPLE_RADIAL
KSPROP_WHITE_NOISE_TAILORED

             {KSPROP_COLORED_NOISE = 0,
              KSPROP_WHITE_NOISE_RADIAL = 1,
              KSPROP_WHITE_NOISE_SIMPLE_RADIAL = 2,
              KSPROP_WHITE_NOISE_TAILORED = 3
} KSPROP_NOISEMODE;

Function Documentation

ksprop_bladeangle_golden()

float ksprop_bladeangle_golden

(

int

bladeidx

)

                                             {
  /* golden angle with crosscal */

  /* for each pair of blades the first will follow increments of the golden section of 90°
     the second will be at +90° from the first to allow cross calibration.
  */
  int pairidx = bladeidx/2;

  /* it seems VxWorks implementation of fmod is broken... */
  float linear_angle = 90.0f*pairidx/GOLDEN_SECTION;
  int num_quadrants = ((int)linear_angle) / 90;
  float base_angle = linear_angle - 90.0f*num_quadrants;

  return base_angle + (bladeidx%2 ? 90.0f : 0);

} /* ksprop_bladeangle_golden() */

ksprop_eval_bladeangles()

STATUS ksprop_eval_bladeangles

(

KSPROP_SETTINGS *

prop

)

                                                      {

  const unsigned int n_averages = prop->design.averages;
  const unsigned int n_unique_blades = prop->state.nblades / n_averages;
  if (n_unique_blades == 0) {
    return KS_THROW("Requested 0 blades");
  }
  if (n_averages * n_unique_blades > KSPROP_MAXBLADES) {
    return KS_THROW("Request too many blades (%d > %d)", n_averages * n_unique_blades, KSPROP_MAXBLADES);
  }

  const float delta_theta = 180.0f / n_unique_blades;
  unsigned int avg, bladeidx;

  for (bladeidx = 0; bladeidx < n_unique_blades; bladeidx++) {
    switch (prop->design.mode) {
    case KSPROP_GOLDEN_ANGLE:
      for (avg = 0; avg < n_averages; avg++) {
        prop->state.angle[bladeidx*n_averages + avg] = ksprop_bladeangle_golden(bladeidx);
      }
      break;
    case KSPROP_LINEAR_ANGLE:
      if (prop->design.crosscal) {
        const float base_angle = delta_theta/2.0f * bladeidx;
        for (avg = 0; avg < n_averages; avg++) {
          prop->state.angle[bladeidx*n_averages + avg] = base_angle;
        }
        bladeidx++;
        for (avg = 0; avg < n_averages; avg++) {
          prop->state.angle[bladeidx*n_averages + avg] = base_angle + 90.0f;
        }
      } else {
        for (avg = 0; avg < n_averages; avg++) {
          prop->state.angle[bladeidx*n_averages + avg] = delta_theta * bladeidx;
        }
      } 
      break;
    default:
      break;
    }
  }
  return SUCCESS;

} /* ksprop_eval_bladeangles() */

ksprop_eval_numblades()

int ksprop_eval_numblades	(	float	bladefactor,
		int	xres,
		int	yres,
		const int	crosscal,
		const unsigned int	averages
	)

                                                                                                                  {

  float nyquistblades = (float) (xres) * PI / (2 * yres);
  if (xres == yres)
    nyquistblades = 1;
  else if ((float) xres / 1.5 < yres)
    nyquistblades = 2;
  else if ((float) xres / 2 < yres)
    nyquistblades = 3;

  int numblades = (int) (bladefactor * nyquistblades + 0.5); /* round up*/
  if ((crosscal == TRUE) && (numblades % 2)) {
    numblades++;
  }

  numblades *= averages;

  return numblades > 0 ? numblades : 1;

} /* ksprop_eval_numblades() */

ksprop_eval_validatedesign()

STATUS ksprop_eval_validatedesign	(	KSPROP_SETTINGS *	prop,
		KS_KSPACE_DESIGN *	kdesign
	)

                                                                                    {
  /* This check is disabled for now to allow SMS with ksneuromix.

  if (!areSame(kdesign->fov[XGRAD], kdesign->fov[YGRAD])) {
    return KS_THROW("Rectangular FOV is not compatible with PROPELLER");
  }
  */

  if ((prop->design.mode == KSPROP_GOLDEN_ANGLE) && (prop->design.crosscal == FALSE)) {
    return KS_THROW("KSPROP_DESIGN Golden angle ordering must be used in combination with crosscal");
  }

  if (prop->design.averages <= 0) {
    return KS_THROW("KSPROP_DESIGN averages is %d", prop->design.averages);
  }

  return SUCCESS;

} /* ksprop_eval_validatedesign() */

ksprop_eval()

STATUS ksprop_eval	(	KSPROP_SETTINGS *	prop,
		KS_KSPACE_DESIGN *	kdesign
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

prop	ADDTEXTHERE
kdesign	ADDTEXTHERE

Return values

STATUS

SUCCESS or FAILURE

                                                                     {
  STATUS status;
  status = ksprop_eval_validatedesign(prop, kdesign);
  KS_RAISE(status);

  prop->state.nblades = ksprop_eval_numblades(prop->design.bladefactor,
                                              kdesign->res[XGRAD],
                                              kdesign->res[YGRAD],
                                              prop->design.crosscal,
                                              prop->design.averages);
  status = ksprop_eval_bladeangles(prop);
  KS_RAISE(status);

  return SUCCESS;

} /* ksprop_eval() */

eval_white_prop_readwave()

STATUS eval_white_prop_readwave	(	KS_READWAVE *	readwave,
		const int	nsamples,
		const KS_WAVEFORM	half_acq_waveform,
		const float	sampling_area,
		const KS_KSPACE_DESIGN *	kdesign,
		const float	xcrusher_area,
		const char *	desc
	)

                                                                                                                                                                                                                         {
  STATUS status;

  /* eval waveform to wave */
  KS_WAVE acq_wave;
  status = ks_eval_wave(&acq_wave, desc, nsamples, GRAD_UPDATE_TIME * nsamples, half_acq_waveform);
  KS_RAISE(status);

  /* Scale amplitude to get prescribed area */
  ks_wave_multiplyval(&acq_wave, sampling_area / acq_wave.area);

  /* mirror and append half wave */
  KS_WAVE rightside = acq_wave;
  status = ks_eval_mirrorwave(&acq_wave);
  KS_RAISE(status);
  status = ks_eval_append_two_waves(&acq_wave, &rightside);
  KS_RAISE(status);

  readwave->res = kdesign->res[XGRAD];
  readwave->fov = kdesign->fov[XGRAD];
  readwave->nover = kdesign->nover[XGRAD];
  status = ks_eval_readwave(readwave, &acq_wave, xcrusher_area, xcrusher_area, 1, KS_CRUSHER_STRATEGY_FASTEST, KS_CRUSHER_STRATEGY_FASTEST);
  KS_RAISE(status);

  return SUCCESS;

} /* eval_white_prop_readwave() */

get_blade_intersection()

float get_blade_intersection	(	const float	theta,
		const float	kv,
		const float	kv_max
	)

                                                                                    {
  if areSameRelative(theta, M_PI / 2.0, 1e-4) { /* orthogonal blade */
    return kv_max;
  }
  return fabs((kv_max + kv * cos(theta)) / sin(theta));

} /* get_blade_intersection() */

get_blade_intersections()

void get_blade_intersections	(	float *	blade_intersections,
		const float	kv,
		const float	kv_max,
		const float *	blade_angles,
		const int	nblades
	)

                                                                                                                                           {
  int blade;
  for (blade = 1; blade < nblades; blade++) {
    float theta = (blade_angles[blade] - blade_angles[0]) * M_PI / 180.0; /* [radians] */
    blade_intersections[blade-1] = get_blade_intersection(theta, kv, kv_max);
  }  
  qsort(blade_intersections, nblades-1, sizeof(float), ks_compare_float);

} /* get_blade_intersections() */

num_intersections_beyond_k()

int num_intersections_beyond_k	(	const float *	blade_intersections,
		const int	nblades,
		const float	k
	)

                                                                                                   {
  int res = 1;
  int intersection;
  for (intersection=0; intersection < nblades-1; intersection++) {
    if (blade_intersections[intersection] > k) {
      res++;
    }
  }
  return res;

} /* num_intersections_beyond_k() */

radial_curve()

float radial_curve	(	const float	ku,
		const float	ku_max,
		const float	kv_max
	)

                                                                           {
  if (fabs(ku) > kv_max) {
    return ku_max / kv_max * asin(kv_max / fabs(ku));
  } else {
    return ku_max / kv_max * (M_PI / 2.0);
  }

} /* radial_curve() */

get_half_wave()

void get_half_wave	(	KS_WAVEFORM	acq_waveform,
		const int	nsamples,
		const float	scale,
		const float *	blade_intersections,
		const int	nblades,
		const float	ku_max,
		const float	kv_max,
		const float	slew_limit,
		const float	amp_limit
	)

                                                                                                                                                                                                                                {
  float dGmax = slew_limit * GRAD_UPDATE_TIME; /* [G/cm] */
  float ku = ku_max;
  float G;
  int sample;
  for (sample = (nsamples-1); sample >= 0; sample--) { /* Go k-space edge->center (conservative approach) */
    if (ku > kv_max) { /* spoke */
      if (blade_intersections == NULL) {
        G = scale * radial_curve(ku, ku_max, kv_max); /* radial waveform */
      } else {
        G = scale * num_intersections_beyond_k(blade_intersections, nblades, ku); /* tailored waveform */
      }
      G = FMin(2, G, amp_limit); /* respect amplitude limit */
      if (sample < (nsamples-1)) {
        G = FMin(2, G, acq_waveform[sample+1] + dGmax); /* respect slew limit */
      }
    } else { /* hub */
      G = acq_waveform[sample+1];
    }
    acq_waveform[sample] = G;
    ku -= GAM * G * GRAD_UPDATE_TIME * 1e-4; /* [1/m] = [Hz/G] * [G/cm] * [us] * [1e-4] */
  }

} /* get_half_wave() */

get_area()

float get_area	(	KS_WAVEFORM	waveform,
		const int	nsamples,
		const float	dwell
	)

                                                                            {
  float area = 0.0;
  int sample;
  for (sample=0; sample<nsamples; sample++) {
    area += waveform[sample];
  }
  return area * dwell;

} /* get_area() */

optimize()

void optimize	(	KS_WAVEFORM	acq_waveform,
		const int	nsamples,
		const float *	blade_intersections,
		const int	nblades,
		const float	ku_max,
		const float	kv_max,
		const float	slew_limit,
		const float	amp_limit
	)

                                                                                                                                                                                                        {
  float prev_scale = ku_max / (GAM * 2 * nsamples * GRAD_UPDATE_TIME * 1e-4); /* [G/cm] = [1/m] / ([Hz/G] * [us] * [1e-4]) */
  get_half_wave(acq_waveform, nsamples, prev_scale, blade_intersections, nblades, ku_max, kv_max, slew_limit, amp_limit);
  float area = get_area(acq_waveform, nsamples, (float) GRAD_UPDATE_TIME); /* [G/cm*us] */
  float target_area = ku_max / (GAM * 1e-4); /* [1/m] / ([Hz/G] * [1e-4]) = [G/cm*us] */
  float err = area - target_area;
  float scale = prev_scale * 0.99;
  int i = 0;
  int max_iter = 20;
  float tol = 1e-5;
  while ((i < max_iter) && (fabs(scale-prev_scale)>tol)) {
    get_half_wave(acq_waveform, nsamples, scale, blade_intersections, nblades, ku_max, kv_max, slew_limit, amp_limit);
    area = get_area(acq_waveform, nsamples, (float) GRAD_UPDATE_TIME); /* [G/cm*us] */
    float prev_err = err;
    err = area - target_area;
    float err_dev = (err-prev_err) / (scale-prev_scale); /* derivative of error */
    prev_scale = scale;
    scale -= err/err_dev;
    i++;
  }

} /* optimize() */

ksprop_init_settings()

void ksprop_init_settings

(

KSPROP_SETTINGS *const

prop

)

ADDTITLEHERE

ADDDESCHERE

Parameters

prop	ADDTEXTHERE

Returns

void

                                                        {
  KSPROP_SETTINGS default_settings = KSPROP_DEFAULT_SETTINGS;
  *prop = default_settings;

} /* ksprop_init_settings() */

ksprop_scan_singlepass()

s64 ksprop_scan_singlepass	(	const KSPROP_SETTINGS *	prop,
		KSSCAN_LOOP_CONTROL *	loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	prop	ADDTEXTHERE
	loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	KS_CORESLICETIME playing one or more sequence modules for a single playout

Return values

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

                                                                                                                     {
  s64 time = 0;

  const int dda = loopctrl->dda;

  for (dynamic->vol = 0; dynamic->vol < prop->state.nblades; dynamic->vol++) {

    ks_mat4_setgeometry(dynamic->Mlogical, 0, 0, 0, 0, 0, -prop->state.angle[dynamic->vol]);

    time += ksscan_acqloop(loopctrl, dynamic, coreslice);

    /* Play dummies only once */
    loopctrl->dda = 0;    

    /* TODO: put this here or in scanloop? */
    if (loopctrl->play_endofpass) {
      time += GEReq_endofpass();
    }

  }

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

  return time; /* in [us] */

} /* ksprop_scan_singlepass() */

ksprop_scan_singlepass_inv()

s64 ksprop_scan_singlepass_inv	(	const KSPROP_SETTINGS *	prop,
		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

	prop	ADDTEXTHERE
	inv_loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	KS_CORESLICETIME playing one or more sequence modules for a single playout
[in]	irslice	KS_CORESLICETIME 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

                                                                                                                   {
  s64 time = 0;

#ifndef IPG
  if (inv_loopctrl == NULL) {
    KS_THROW("KSINV_LOOP_CONTROL (2nd arg) is NULL");
    return KS_NOTSET;
  }
  if (inv_loopctrl->irmode == 0) {
    KS_THROW("KSINV_LOOP_CONTROL (2nd arg) .irmode is 0");
    return KS_NOTSET;
  }
#endif

  const int dda = inv_loopctrl->loopctrl.dda;

  for (dynamic->vol = 0; dynamic->vol < prop->state.nblades; dynamic->vol++) {

    ks_mat4_setgeometry(dynamic->Mlogical, 0, 0, 0, 0, 0, -prop->state.angle[dynamic->vol]);

    const int inv_rampup = dynamic->vol == 0; 
    const int inv_rampdown = dynamic->vol == prop->state.nblades-1; 
    time += ksinv_scan_acqloop(inv_loopctrl, dynamic,
                                      coreslice, irslice,
                                      inv_rampup, inv_rampdown);

    /* Play dummies only once */
    inv_loopctrl->loopctrl.dda = 0;    

    /* TODO: put this here or in scanloop? */
    if (inv_loopctrl->loopctrl.play_endofpass) {
      time += GEReq_endofpass();
    }

  }

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

  return time; /* in [us] */

} /* ksprop_scan_singlepass_inv() */

ksprop_scan_scanloop()

s64 ksprop_scan_scanloop	(	const KSPROP_SETTINGS *	prop,
		KSSCAN_LOOP_CONTROL *	loopctrl,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

	prop	ADDTEXTHERE
	loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	KS_CORESLICETIME playing one or more sequence modules for a single playout

Return values

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;
  }

  /* TODO: Restore this option? */
  /* (prop->design.loop_mode == KSPROP_LOOPMODE_INNER_PASS) */

  /* Inner loop over blades */
  for (dynamic->pass = 0; dynamic->pass < loopctrl->slicetiming.slice_plan.npasses; dynamic->pass++) {

    time += ksprop_scan_singlepass(prop, loopctrl, dynamic, coreslice);

    /* TODO: put this here or in passloop? */
    ks_plot_slicetime_endofpass(KS_PLOT_PASS_WAS_STANDARD);

  } /* pass loop */

  return time; /* in [us] */

} /* ksprop_scan_scanloop() */

ksprop_scan_scanloop_inv()

s64 ksprop_scan_scanloop_inv	(	const KSPROP_SETTINGS *	prop,
		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

	prop	ADDTEXTHERE
	inv_loopctrl	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
[in]	coreslice	KS_CORESLICETIME playing one or more sequence modules for a single playout
[in]	irslice	KS_CORESLICETIME playing an inversion (and optionally more) modules for a single inversion slice playout. Can be NULL

Return values

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;
  }

  /* TODO: Restore this option? */
  /* (prop->design.loop_mode == KSPROP_LOOPMODE_INNER_PASS) */

  /* Inner loop over blades */
  for (dynamic->pass = 0; dynamic->pass < inv_loopctrl->loopctrl.slicetiming.slice_plan.npasses; dynamic->pass++) {

    time += ksprop_scan_singlepass_inv(prop, inv_loopctrl, dynamic, coreslice, irslice);

    /* TODO: put this here or in passloop? */
    ks_plot_slicetime_endofpass(KS_PLOT_PASS_WAS_STANDARD);

  } /* pass loop */

  return time; /* in [us] */

} /* ksprop_scan_scanloop_inv() */

ksprop_attach_metadata()

void ksprop_attach_metadata	(	WF_PULSE_ADDR	echo,
		const KS_DYNAMIC_STATE *	dynamic,
		const char *	custom
	)

ADDTITLEHERE

ADDDESCHERE

Parameters

[in]	echo	ADDTEXTHERE
	dynamic	Pointer to KS_DYNAMIC_STATE struct, which has elements being automatically updated by the scan looping functions
	custom	ADDTEXTHERE

Returns

void