ksdiffusion.h File Reference

#include "ksscan.h"

Data Structures
struct	KSDIFF_CONTROL_DESIGN
struct	KSDIFF_CONTROL

Macros
#define	KSDIFF_MAX_SCHEME_LENGTH   512
#define	KSDIFF_MAXBVALS   10
#define	KSDIFF_INIT_SCHEME   {{0,0,0}}
#define	KSDIFF_INIT_CONTROL_DESIGN   {1, 0, KSDIFF_LOGICAL, KSDIFF_CUBOID, KS_MAT3x3_IDENTITY, 0, {0}, {0}}
#define	KSDIFF_INIT_CONTROL   {1, 0, 0, 0, {0}, {0}, KSDIFF_INIT_SCHEME, 0.0, {0}, {0}}

Typedefs
typedef float	KSDIFF_SCHEME[KSDIFF_MAX_SCHEME_LENGTH][3]

Enumerations
enum	ksdiff_coordinate_system { KSDIFF_LOGICAL, KSDIFF_PHYSICAL }
enum	ksdiff_physical_bound_type { KSDIFF_ISO, KSDIFF_CUBOID }

Functions
STATUS	ksdiff_eval_design (KSDIFF_CONTROL *diff_control, const KSDIFF_CONTROL_DESIGN *design)
s64	ksdiff_schemeloop (const KSDIFF_CONTROL *diff_control, const KSSCAN_LOOP_CONTROL *loop_control, KS_DYNAMIC_STATE *dynamic, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic))
void	ksdiff_plotloop (const KSDIFF_CONTROL *diff_control, KS_CORESLICETIME coreslice(const SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic), const SCAN_INFO *scan_info)

Macro Definition Documentation

KSDIFF_MAX_SCHEME_LENGTH

#define KSDIFF_MAX_SCHEME_LENGTH   512

Maximum 512 diffusion directions

KSDIFF_MAXBVALS

#define KSDIFF_MAXBVALS   10

10 different b-values > 0

KSDIFF_INIT_SCHEME

#define KSDIFF_INIT_SCHEME   {{0,0,0}}

KSDIFF_INIT_CONTROL_DESIGN

#define KSDIFF_INIT_CONTROL_DESIGN   {1, 0, KSDIFF_LOGICAL, KSDIFF_CUBOID, KS_MAT3x3_IDENTITY, 0, {0}, {0}}

KSDIFF_INIT_CONTROL

#define KSDIFF_INIT_CONTROL   {1, 0, 0, 0, {0}, {0}, KSDIFF_INIT_SCHEME, 0.0, {0}, {0}}

Typedef Documentation

KSDIFF_SCHEME

typedef float KSDIFF_SCHEME[KSDIFF_MAX_SCHEME_LENGTH][3]

2D matrix holding the b0 volumes followed by diffusion directions

Enumeration Type Documentation

ksdiff_coordinate_system

enum ksdiff_coordinate_system

Enumerator
KSDIFF_LOGICAL
KSDIFF_PHYSICAL

{KSDIFF_LOGICAL, KSDIFF_PHYSICAL} ksdiff_coordinate_system;

ksdiff_physical_bound_type

enum ksdiff_physical_bound_type

Enumerator
KSDIFF_ISO
KSDIFF_CUBOID

{KSDIFF_ISO, KSDIFF_CUBOID} ksdiff_physical_bound_type;

Function Documentation

ksdiff_eval_design()

STATUS ksdiff_eval_design	(	KSDIFF_CONTROL *	diff_control,
		const KSDIFF_CONTROL_DESIGN *	design
	)

Generate a diffusion control from its design

This function computes the scaling factors needed for the desired diffusion scheme to be executed taking into accout the limits of the gradient system according to design->physical_bound_type. The actual shape and timing of the diffusion gradients are not needed to be known, in fact, this function must be called before setting up the module that includes the diffusion gradients. In particular diff_control->bvalue and diff_control->max_magnitude_amp are to be used as inputs to design the diffusion gradients (see below for an example). Additionally, diff_control->RMS_amp_scale and diff_control->max_power_amp_scale are to be used for setting the diffusion gradients scaling factors for gradient heating calculations for average and maximum power respectively.

NOTE* that it is assumed that the diffusion gradients are generated with a maximum amplitude equal for each board equal to that board's maximum amplitude, possibly scaled down by a common factor. Each board's mximum amplitude is stored in tx, ty and tz from loggrd. In particular, one waveform (trapezoid or wave) per board is needed since those values are not necessarily equal. Specifically, the maximum amplitude of the diffusion gradients on the X logical board should be equal to alpha*loggrd.tx where alpha is a scaling factor (0 < alpha <= 1). Similarly, the maximum amplitude of the diffusion gradients on the Y and Z logical boards should be equal to alpha*loggrd.ty and alpha*loggrd.tz respectively.

For instance, in the case of standard diffusion gradients, the maximum amplitude is achieved during the plateau of the trapezoids. In order to design the shape of those trapezoids, a ramp time must be chosen first. If in doubt ks_syslimits_ramptimemax(loggrd) is always feasible as it represents the time for the slowest board to reach its maximum amplitude. Then the plateau time and the time separation between the two trapezoids should be chosen so that a plateau amplitude equal to alpha*diff_control->max_magnitude_amp results in a b-value equal to diff_control->bvalue. Finally, the actual trapezoids for the X, Y and Z boards need to be generated with a plateau amplitude equal to alpha*loggrd.tx, alpha*loggrd.ty and alpha*loggrd.tz respectively.

Parameters

[out]	diff_control
[in]	design

Returns

STATUS

                                                               {

  STATUS status;
  int i;

  /* TODO: We may want to check for Premier gradients */

  /* Copy fields */
  diff_control->nb0 = design->nb0;
  diff_control->ndirs = design->ndirs;
  diff_control->numbvals = design->numbvals;

  const float maxb = ksdiff_getmaxb(design->bvalues, design->numbvals);
  diff_control->bvalue = maxb;
  for (i=0; i < KSDIFF_MAXBVALS; ++i) {
    diff_control->multib_scale[i] = fabs(design->bvalues[i]) / maxb;
    diff_control->multib_nex[i] = design->multib_nex[i];
  }

  status = ksdiff_compute_scheme_amps(diff_control->diff_amp_scaling,
                                      &diff_control->max_magnitude_amp,
                                      diff_control->RMS_amp_scale,
                                      diff_control->max_power_amp_scale,
                                      NULL, /* Default comparator */
                                      design->ndirs,
                                      design->coordinate_system,
                                      design->physical_bound_type,
                                      design->rot_l2p);
  KS_RAISE(status);

  return SUCCESS;

} /* ksdiff_eval_design() */

ksdiff_schemeloop()

s64 ksdiff_schemeloop	(	const KSDIFF_CONTROL *	diff_control,
		const KSSCAN_LOOP_CONTROL *	loop_control,
		KS_DYNAMIC_STATE *	dynamic,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic
	)

Executes all loops for a diffusion scheme according to the provided loop control

The index dynamic->vol is incremented for each b0 and each diffusion volumes. This corresponds to a total number of sampled volumes equal to nb0 + numbvals*ndirs for each invocation of ksdiff_schemeloop.

Note that dynamic->vol is not reset to zero so that, if the diffusion scheme is repeated, all volumes have different index.

Parameters

[in]	diff_control
[in]	loop_control
[in,out]	dynamic
[in]	coreslice

Returns

s64 Time necessary for performing all relevant loops on the hardware

                                                                                                         {

  s64 time = 0;

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

  /* make a copy of the loop control as we are going to modify some */
  KSSCAN_LOOP_CONTROL loop_control = *orig_loop_control;

  const int numbval_indices = diff_control->nb0 + diff_control->numbvals;
  int board;

  /* Initialize for b0s */
  loop_control.naverages = orig_loop_control->naverages;
  float bvalue_scale = 0;
  int ndirs = 1;

  for (dynamic->b_idx = 0; dynamic->b_idx < numbval_indices; dynamic->b_idx++) {

    if (dynamic->b_idx >= diff_control->nb0) {
      const int bvalue_idx = dynamic->b_idx - diff_control->nb0;
      loop_control.naverages = diff_control->multib_nex[bvalue_idx];
      bvalue_scale = diff_control->multib_scale[bvalue_idx];
      ndirs = diff_control->ndirs;
    }

    for (dynamic->diff_idx = 0; dynamic->diff_idx < ndirs; dynamic->diff_idx++) {
      for (dynamic->pass = 0; dynamic->pass < loop_control.slicetiming.slice_plan.npasses; dynamic->pass++) {

        /* In a single pass scan we should play dummies only once */
        const int play_dda = loop_control.slicetiming.slice_plan.npasses == 1 ?
          (!(dynamic->vol) && !dynamic->b_idx && !dynamic->diff_idx) : 1;
        loop_control.dda = play_dda * orig_loop_control->dda;

        /*
          Set up the diffusion amplitudes

          Note: diff_amp assumes that the diffusion gradients are generated
          with amplitude equal to loggrd.t*
        */
        for (board = 0; board < 3; board++) {
          dynamic->diff_amp[board] = bvalue_scale > 0 ?
            bvalue_scale*diff_control->diff_amp_scaling[dynamic->diff_idx][board] : 0.0f;
        }

        time += ksscan_acqloop(&loop_control, dynamic, coreslice);

        loop_control.dda = 0;
        if (loop_control.play_endofpass) {
          time += GEReq_endofpass();
        }
        ks_plot_slicetime_endofpass(KS_PLOT_PASS_WAS_STANDARD);

      } /* pass loop */

      /* Done with a volume */
      dynamic->vol++;

    } /* diff_idx loop */
  } /* b_idx loop */

  return time; /* in [us] */

} /* ksdiff_schemeloop() */

ksdiff_plotloop()

void ksdiff_plotloop	(	const KSDIFF_CONTROL *	diff_control,
		KS_CORESLICETIME	coresliceconst SCAN_INFO *slice_pos, KS_DYNAMIC_STATE *dynamic,
		const SCAN_INFO *	scan_info
	)

Executes a loop over all diffusion direction for plotting purposes

All loops other than the one over all diffusion directions are collapsed.

Parameters

[in]	diff_control
[in]	coreslice
[in]	scan_info	Optional slice position, can be NULL

Returns

void

                                                 {

  KS_DYNAMIC_STATE dynamic = KS_INIT_DYNAMIC_STATE;

  SCAN_INFO default_scan_info = DEFAULT_AXIAL_SCAN_INFO;
  if (!scan_info) {
    scan_info = &default_scan_info;
  }

  /* Once for b0 */
  coreslice(scan_info, &dynamic);

  int dir, board;
  for (dir = 0; dir < diff_control->ndirs; dir++) {
    for (board = 0; board < 3; board++) {
      dynamic.diff_amp[board] =
        diff_control->diff_amp_scaling[dir][board];
    }

    coreslice(scan_info, &dynamic);
  }

} /* ksdiff_plotloop() */