KSFoundation_tgt.c File Reference

#include <RtpPsd.h>
#include <PromoCommon.h>
#include "stddef_ep.h"
#include "pulsegen.h"
#include "epic.global.h"
#include "epicfuns.h"
#include "epicmsg.h"
#include "epicconf.h"
#include "ca_filt.h"
#include "psdutil.h"

Data Structures
union	Indices

Functions
STATUS	scale (FLOAT(*inrotmat)[9], long(*outrotmat)[9], INT slquant, LOG_GRAD *lgrad, PHYS_GRAD *pgrad, INT contdebug)
void	ks_scan_omegawave_hz (KS_WAVE *wave, int instanceno, float Hz)
void	ks_scan_omegatrap_hz (KS_TRAP *trp, int instanceno, float Hz)
void	ks_scan_wait (KS_WAIT *wait, int waitperiod)
void	ks_scan_trap_ampscale (KS_TRAP *trp, int instanceno, float ampscale)
void	ks_scan_trap_ampscale_slice (KS_TRAP *trp, int start, int skip, int count, float ampscale)
void	ks_scan_phaser_kmove (KS_PHASER *phaser, int instanceno, double pixelunits)
void	ks_scan_phaser_toline (KS_PHASER *phaser, int instanceno, int view)
void	ks_scan_phaser_fromline (KS_PHASER *phaser, int instanceno, int view)
void	ks_scan_rf_ampscale (KS_RF *rf, int instanceno, float ampscale)
void	ks_scan_rf_on (KS_RF *rf, int instanceno)
void	ks_scan_rf_on_chop (KS_RF *rf, int instanceno)
void	ks_scan_rf_off (KS_RF *rf, int instanceno)
unsigned int	ks_cycles_to_iphase (double cycles)
unsigned int	ks_degrees_to_iphase (double degrees)
unsigned int	ks_radians_to_iphase (double radians)
void	ks_scan_selrf_setfreqphase_pins (KS_SELRF *selrf, int instanceno, SCAN_INFO sliceinfo, int sms_multiband_factor, float sms_slice_gap, float rfphase)
void	ks_scan_selrf_setfreqphase (KS_SELRF *selrf, int instanceno, SCAN_INFO sliceinfo, float rfphase)
void	ks_scan_rf_setphase (KS_RF *rf, int instanceno, float rfphase)
void	ks_scan_wave2hardware (KS_WAVE *wave, const KS_WAVEFORM newwave)
void	ks_scan_offsetfov_iso (KS_READTRAP *readtrap, int instanceno, SCAN_INFO sliceinfo, double ky, double kz, double rcvphase)
void	ks_scan_offsetfov_iso_readwave (KS_READWAVE *readwave, int instanceno, SCAN_INFO sliceinfo, double ky, double kz, double rcvphase)
void	ks_scan_offsetfov (KS_READTRAP *readtrap, int instanceno, SCAN_INFO sliceinfo, float ky, float phasefovratio, float rcvphase)
void	ks_scan_offsetfov3D (KS_READTRAP *readtrap, int instanceno, SCAN_INFO sliceinfo, float ky, float phasefovratio, float kz, float zphasefovratio, float rcvphase)
void	ks_scan_offsetfov_readwave (KS_READWAVE *readwave, int instanceno, SCAN_INFO sliceinfo, float ky, float phasefovratio, float rcvphase)
void	ks_scan_rotate (SCAN_INFO slice_info)
void	ks_scan_isirotate (KS_ISIROT *isirot)
int	ks_scan_getsliceloc (const KS_SLICE_PLAN *slice_plan, int passindx, int sltimeinpass)
int	ks_scan_getslicetime (const KS_SLICE_PLAN *slice_plan, int passindx, int slloc)
ks_enum_epiblipsign	ks_scan_epi_verify_phaseenc_plan (KS_EPI *epi, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot)
void	ks_scan_epi_shotcontrol (KS_EPI *epi, int echo, SCAN_INFO sliceinfo, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot, int exc, float rcvphase)
void	ks_scan_epi_loadecho_with_tag (KS_EPI *epi, int echo, int storeecho, int slice, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot, KSEPI_DATATAG *datatag, KS_DATASTORETAG *datastoretag)
void	ks_scan_epi_loadecho_with_datastoretag (KS_EPI *epi, int echo, int storeecho, int slice, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot, KS_DATASTORETAG *datastoretag)
void	ks_scan_epi_loadecho_with_epidatatag (KS_EPI *epi, int echo, int storeecho, int slice, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot, KSEPI_DATATAG *datatag)
void	ks_scan_epi_loadecho (KS_EPI *epi, int echo, int storeecho, int slice, KS_PHASEENCODING_PLAN *phaseenc_plan, int shot)
void	ks_loaddab (WF_PULSE_ADDR echo, char *custom_dab_array)
void	ks_loaddab_datastoretag (WF_PULSE_ADDR echo, KS_DATASTORETAG *datastoretag)
void	ks_scan_acq_to_rtp (KS_READ *acq, TYPDAB_PACKETS dabacqctrl, float fatoffset)
STATUS	boffset (long *offsets)
void	ks_scan_switch_to_sequence (KS_SEQ_CONTROL *ctrl)
STATUS	setssitime (long)
STATUS	startseq (s16, s16)
int	ks_scan_playsequence (KS_SEQ_CONTROL *ctrl)
STATUS	ks_scan_loaddabwithindices_nex (WF_PULSE_ADDR pulse, LONG slice, LONG echo, LONG view, uint8_t acq, uint8_t vol, LONG operation, TYPDAB_PACKETS acqon_flag)
STATUS	ks_scan_loaddabwithindices (WF_PULSE_ADDR pulse, LONG slice, LONG echo, LONG view, uint8_t acq, uint8_t vol, TYPDAB_PACKETS acqon_flag)
int	ks_scan_wait_for_rtp (void *rtpmsg, int maxmsgsize, int maxwait, KS_SEQ_CONTROL *waitctrl)
void	ks_copy_and_reset_obj (void *pobj)
void	ks_tgt_reset_gradrfctrl (KS_GRADRFCTRL *gradrfctrl)
void	ks_show_clock (FLOAT scantime)
STATUS	acqq_longdab (WF_PULSE_ADDR pulse, LONG pos_ref, LONG dab_ref, LONG xtr_ref, LONG fslot_value)

Variables
float	GAM
int	cfreceiveroffsetfreq
int	rspent
int	pscR1
int	cfcoilswitchmethod
int	cfswgut
int	cfswrfut
int	rhasset
int	cfhwgut
int	piviews
int	opslicecnt

Detailed Description

This file contains functions only accessible on TGT.

Function Documentation

scale()

STATUS scale	(	FLOAT(*)	inrotmat[9],
		long(*)	outrotmat[9],
		INT	slquant,
		LOG_GRAD *	lgrad,
		PHYS_GRAD *	pgrad,
		INT	contdebug
	)

ks_scan_omegawave_hz()

void ks_scan_omegawave_hz	(	KS_WAVE *	wave,
		int	instanceno,
		float	Hz
	)

Updates a KS_WAVE object on the OMEGA board to produce a frequency offset

A KS_WAVE object on OMEGA can be used to perform a dynamic frequency offset

1. while an RF pulse is played out. One example is Spectral-Spatial RF pulses
2. during data acquisition

Parameters

[in,out]	wave	Pointer to KS_WAVE
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	Hz	Desired frequency offset in [Hz] for the point in the KS_WAVE with the largest absolute amplitude

Return values

STATUS

SUCCESS or FAILURE

                                                                   {
  int iamp;
  float omega_scale = 256.0;

  iamp = (int) (Hz / (TARDIS_FREQ_RES * omega_scale));

  if (abs(iamp) > 32768) {
    ks_error("ks_scan_omegawave_hz(%s): the integer amplitude is too large (%d) for instance %d", wave->description, iamp, instanceno);
    return;
  }

#ifdef IPG

  if (wave->wfi[instanceno].loc.board != OMEGA) {
    ks_error("ks_scan_omegawave_hz(%s): Only omega board is supported", wave->description);
    return;
  }

  /* input validation */
  if (instanceno < 0 || instanceno >= wave->base.ngenerated) {
    ks_error("ks_scan_omegawave_hz(%s): instanceno (%d) out of range [0,%d)", wave->description, instanceno, wave->base.ngenerated);
    return;
  }

  if (setiamp((short) iamp, wave->wfi[instanceno].wf, wave->wfi[instanceno].boardinstance) != SUCCESS) {
    ks_error("ks_scan_omegawave_hz(%s): An error occurred calling 'setiampt()'", wave->description);
    return;
  }

#else
  int numplaced = wave->base.ninst;
  if (!numplaced) {
    return;
  }
  float* tmp = (float*)realloc(wave->rtscale, numplaced * sizeof(float));
  if (!tmp) {
    ks_error("%s: rtscale realloc failed", __FUNCTION__);
    return;
  }
  wave->rtscale = tmp;
  wave->rtscale[instanceno] = Hz;

#endif

} /* ks_scan_omegawave_hz */

ks_scan_omegatrap_hz()

void ks_scan_omegatrap_hz	(	KS_TRAP *	trap,
		int	instanceno,
		float	Hz
	)

Updates a KS_TRAP object on the OMEGA board to produce a frequency offset

A KS_TRAP object on OMEGA is used for rampsampled acquisitions and is placed out using ks_pg_readtrap() for a KS_READTRAP object if the field .rampsampling = 1. This will cause a trapezoidal frequency shift during the readout instead of a fixed frequency offset when rampsampling is not used. An error is returned if the current instance of the KS_TRAP is on another board than OMEGA

For Cartesian applications, there is no need to call this function directly, since ks_scan_offsetfov() already calls this function

Special note for OMEGA: Neither the .amp field nor the .ampscale field passed in to ks_pg_trap() has an effect. Only the Hz argument controls the frequency shift

Parameters

[in,out]	trap	Pointer to KS_TRAP
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	Hz	Desired frequency offset in [Hz] at the plateau of the trapezoid

Return values

STATUS

SUCCESS or FAILURE

                                                                  {
  int iamp;
  float omega_scale = 256.0;

  iamp = (int) (Hz / (TARDIS_FREQ_RES * omega_scale));
  if (abs(iamp) > 32768) {
    ks_error("ks_scan_omegatrap_hz(%s): the integer amplitude is too large (%d) for instance %d", trp->description, iamp, instanceno);
    return;
  }

#ifdef IPG

  if (trp->wfi[instanceno].loc.board != OMEGA) {
    ks_error("ks_scan_omegatrap_hz(%s): Wrong function - use ks_scan_trap_ampscale() KS_TRAPs on XGRAD, YGRAD, ZGRAD", trp->description);
    return;
  }

  /* input validation */
  if (instanceno < 0 || instanceno >= trp->base.ngenerated) {
    ks_error("ks_scan_omegatrap_hz(%s): instanceno (%d) out of range [0,%d)", trp->description, instanceno, trp->base.ngenerated);
    return;
  }

  if (setiampt((short) iamp, trp->wfi[instanceno].wf, trp->wfi[instanceno].boardinstance) != SUCCESS) {
    ks_error("ks_scan_omegatrap_hz(%s): An error occurred calling 'setiampt()'", trp->description);
    return;
  }

#else
  int numplaced = trp->base.ninst;
  if (!numplaced) {
    return;
  }
  float* tmp = (float*)realloc(trp->rtscale, numplaced * sizeof(float));
  if (!tmp) {
    ks_error("%s: rtscale realloc failed", __FUNCTION__);
    return;
  }
  trp->rtscale = tmp;
  trp->rtscale[instanceno] = Hz;
#endif

} /* ks_scan_omegatrap_hz */

ks_scan_wait()

void ks_scan_wait	(	KS_WAIT *	wait,
		int	waitperiod
	)

Updates the wait period of all instances of a KS_WAIT sequence object. The value of waitperiod must not exceed

.duration.

Parameters

[in,out]	wait	Pointer to KS_WAIT
[in]	waitperiod	Time in [us] to wait

Return values

STATUS

SUCCESS or FAILURE

                                                 {

#ifdef IPG
  int i;
  int numplaced = wait->base.ngenerated;
#else
  int numplaced = wait->base.ninst;
#endif

  if (numplaced == 0) {
    return;
  }

  /* input validation */
  if (waitperiod < 0) {
    ks_error("ks_scan_wait(%s): wait period %d is negative", wait->description, waitperiod);
    return;
  }
  if (waitperiod < GRAD_UPDATE_TIME) {
    waitperiod = GRAD_UPDATE_TIME;
  }
  if (waitperiod % GRAD_UPDATE_TIME) {
    ks_error("ks_scan_wait(%s): waitperiod (3rd arg) on gradient boards must be divisible by 4", wait->description);
    return;
  }

#ifdef IPG

  if (wait->wfi == NULL) {
    ks_error("ks_scan_wait(%s): WF_INSTANCE of trap is NULL", wait->description);
  }

  /* set amplitude(s) */
  for (i = 0; i < numplaced; i++) {

    if (setperiod(waitperiod, wait->wfi[i].wf, wait->wfi[i].boardinstance) != SUCCESS) {
      ks_error("ks_scan_wait(%s): An error occurred calling 'setperiod()'", wait->description);
      return;
    }
  }

#endif

} /* ks_scan_wait */

ks_scan_trap_ampscale()

void ks_scan_trap_ampscale	(	KS_TRAP *	trap,
		int	instanceno,
		float	ampscale
	)

Updates the amplitude of one or all instances of a KS_TRAP sequence object

This function multiplies one instance of a KS_TRAP object with an amplitude scale factor (3rd arg) that should be in range [-1.0,1.0] to avoid slewrate issues. To change all instances of a KS_TRAP object, use INSTRALL as the 2nd argument.

The actual amplitude for an instance of a KS_TRAP object is the multiplication of the three factors:

1. The designed amplitude [G/cm]
2. The per-instance .ampscale in the KS_SEQLOC struct passed to ks_pg_trap()
3. The ampscale value passed in as 3rd argument to this function.

Parameters

[in,out]	trap	Pointer to KS_TRAP
[in]	instanceno	Instance of KS_TRAP to change (INSTRALL changes all instances)
[in]	ampscale	Gradient amplitude scale factor, normally in range [-1.0,1.0], but the range [-1.2, 1.2] is allowed to allow certain run-time gradient corrections

Return values

STATUS

SUCCESS or FAILURE

                                                                         {
  int firstinstance, lastinstance, i;
#ifdef IPG
  int iamp;
  float gradmax;
  int numplaced = trp->base.ngenerated;
#else
  int numplaced = trp->base.ninst;
  if (!numplaced) {
    return;
  }
  float* tmp = (float*)realloc(trp->rtscale, numplaced * sizeof(float));
  if (!tmp) {
    ks_error("%s: rtscale realloc failed", __FUNCTION__);
    return;
  }
  trp->rtscale = tmp;
#endif

  if (instanceno == INSTRALL) {
    firstinstance = 0;
    lastinstance = numplaced - 1;
  } else {
    firstinstance = instanceno;
    lastinstance = instanceno;
  }

  /* input validation */
  if (numplaced == 0) {
    return;
  }
  if (firstinstance < 0 || lastinstance >= numplaced) {
    ks_error("ks_scan_trap_ampscale(%s): instanceno (%d) out of range [0,%d]", trp->description, instanceno, numplaced - 1);
    return;
  }

  /* Allow ampscale to be 20% larger than 1. This, to allow future minor runtime changes of trapezoid amplitudes
     for e.g. (future possible implementations):
     - oblique ghost correction for EPI, where odd/even blip amps need to be made smaller/larger depending on slice angle and delays
     - eddy current correction for DW-EPI, where readout lobe amp needs to be changed per diffusion direction etc.
     If 'ampscale' is larger than 1.0 (i.e. between 1.0 and 1.2), the trapezoid must have been designed with a slewrate that is slightly
     under the very limit of the system (and the dB/dt limits for PNS). Use with caution. */

  if (fabs(ampscale) > sqrt(3)) {
    ks_error("ks_scan_trap_ampscale(%s): ampscale too large (%f)", trp->description, ampscale);
    return;
  }

  /*
    - trp->amp: The amplitude that was initially designed for the KS_TRAP. Should never be exceeded, or slew rate issues will occur
    - trp->wfi[i].loc.ampscale: -1.0 -> +1.0. Amp scale factor for each instance of the KS_TRAP placed in the sequence.
    - ampscale (3rd input arg): -1.0 -> +1.0 (in normal cases). The dynamic amp scale (i.e. over time, or TRs).
   The product [trp->wfi[i].loc.ampscale * ampscale] should be in range [-1, 1] to avoid slew rate issues.
  */

#ifdef IPG

  if (trp->wfi == NULL) {
    ks_error("ks_scan_trap_ampscale(%s): WF_INSTANCE of trap is NULL", trp->description);
    return;
  }

  /* set amplitude(s) */
  for (i = firstinstance; i <= lastinstance; i++) {
    gradmax = ks_syslimits_gradtarget(loggrd, trp->wfi[i].loc.board);
    iamp = (int)((ampscale * trp->wfi[i].loc.ampscale * trp->amp / gradmax) * MAX_PG_IAMP);

    if (abs(iamp) > 32768) {
      ks_error("ks_scan_trap_ampscale(%s): the integer amplitude is too large (%d) for instance %d", trp->description, iamp, i);
      return;
    }
    if (trp->wfi[i].loc.board == OMEGA) {
      ks_error("ks_scan_trap_ampscale(%s): Instance %d on board OMEGA. Please use ks_scan_omegatrap_hz() instead", trp->description, i);
      return;
    }
    if (setiampt((short) iamp, trp->wfi[i].wf, trp->wfi[i].boardinstance) != SUCCESS) {
      ks_error("ks_scan_trap_ampscale(%s): An error occurred calling 'setiampt()'", trp->description);
      return;
    }

  }

#else
  for (i = firstinstance; i <= lastinstance; i++) {
    trp->rtscale[i] = ampscale;
  }
#endif
} /* ks_scan_trap_ampscale */

ks_scan_trap_ampscale_slice()

void ks_scan_trap_ampscale_slice	(	KS_TRAP *	trap,
		int	start,
		int	skip,
		int	count,
		float	ampscale
	)

Updates the amplitude of a selection of instances of a KS_TRAP sequence object

This function multiplies some instances of a KS_TRAP object with an amplitude scale factor (5th arg) that should be in range [-1.0,1.0] to avoid slewrate issues.

The instances to change are start + i * skip, where i goes from 0 to count. FAILURE is returned if either start or start + count * skip out of range or count is negative

Parameters

[in,out]	trap	Pointer to KS_TRAP
[in]	start	First instance number of the KS_TRAP
[in]	skip	Difference in instance number between consecutive instances
[in]	count	Number of instances to change in total
[in]	ampscale	Gradient amplitude scale factor, normally in range [-1.0,1.0], but the range [-1.2, 1.2] is allowed to allow certain run-time gradient corrections

Return values

STATUS

SUCCESS or FAILURE

                                                                                               {
  int i;
#ifdef IPG
  int numplaced = trp->base.ngenerated;
#else
  int numplaced = trp->base.ninst;
#endif

  if (numplaced == 0) {
    return;
  }
  
  /* check range */
  const int end = start + (count - 1) * skip;

  if (start < 0 || start >= numplaced || end < 0 || end >= numplaced || count < 0) {
    ks_error("ks_scan_trap_ampscale_slice(%s): slice with start = %d, skip = %d and count = %d has endpoints outside [0,%d)", trp->description, start, skip, count, numplaced);
    return;
  }

  for (i = 0; i < count; ++i) {
    ks_scan_trap_ampscale(trp, start + i * skip, ampscale);
  }

} /* ks_scan_trap_ampscale_slice */

ks_scan_phaser_kmove()

void ks_scan_phaser_kmove	(	KS_PHASER *	phaser,
		int	instanceno,
		double	pixelunits
	)

Updates the amplitude of a KS_PHASER sequence object to move some arbitrary distance in k-space

This function sets the amplitude of the gradient for a KS_PHASER object so that a shift in k-space of pixelunits number of pixels is produced. If pixelunits is 1.0, the gradient area corresponds to one pixel shift in a fully sampled k-space (no parallel imaging) along the board the KS_PHASER object is placed on. pixelunits is of type float and any non-integer value is accepted, and the sign of pixelunits determines the direction of k-space shift

Parameters

[in,out]	phaser	Pointer to KS_PHASER
[in]	instanceno	Instance of KS_TRAP to change (INSTRALL changes all instances)
[in]	pixelunits	Non-integer pixel units in a fully sampled k-space to move

Return values

STATUS

SUCCESS or FAILURE

                                                                                {
  double phasepixelarea = (double) ks_calc_fov2gradareapixel(phaser->fov);
  double newarea = pixelunits * phasepixelarea + (double) phaser->areaoffset;
  double ampscale = newarea / phaser->grad.area;

  if (phaser == NULL)
    return;

  if (fabs(ampscale) > 1.00003) {  /* 1.00003 corresponds to 32768 / 32767, i.e. excess of one short int */
#ifndef IPG
    ks_error("ks_scan_phaser_kmove(%s): Too large value (%g) in 3rd arg", phaser->grad.description, pixelunits);
#endif
  } else if (fabs(ampscale) > 1.0) {
    /* small round-off fix when ampscale is in range [1.0, 1.00003] */
    ampscale = ampscale < 0 ? -1.0 : 1.0;
  }

  ks_scan_trap_ampscale(&phaser->grad, instanceno, ampscale);

} /* ks_scan_phaser_kmove */

ks_scan_phaser_toline()

void ks_scan_phaser_toline	(	KS_PHASER *	phaser,
		int	instanceno,
		int	view
	)

Updates the amplitude of a KS_PHASER sequence object to move from the k-space center to a desired k-space line

This function sets the amplitude of the gradient for a KS_PHASER object to produce a k-space shift from the center of k-space to the view number (3rd arg). The view number must be an integer in range [0, .res-1], and the number refers to a fully sampled k-space (without parallel imaging)

Parameters

[in,out]	phaser	Pointer to KS_PHASER
[in]	instanceno	Instance of KS_TRAP to change (INSTRALL changes all instances)
[in]	view	Phase encoding line to acquire with index corresponding to a fully sampled k-space [0, res-1]

Return values

STATUS

SUCCESS or FAILURE

                                                                        {
  double kmax;

  if (phaser == NULL)
    return;

  if (view < 0 || view >= phaser->res) {
    ks_scan_phaser_kmove(phaser, instanceno, 0.0);
    return;
  }

  /* KSFoundation 'view' is always 0-based: e.g. res = 256: view = 0->255. */
  kmax = ((phaser->res - 1.0) / 2.0);
  ks_scan_phaser_kmove(phaser, instanceno, kmax - view);

} /* ks_scan_phaser_toline */

ks_scan_phaser_fromline()

void ks_scan_phaser_fromline	(	KS_PHASER *	phaser,
		int	instanceno,
		int	view
	)

Updates the amplitude of a KS_PHASER sequence object to move from a k-space line to the k-space center

This function sets the amplitude of the gradient for a KS_PHASER object to produce a k-space shift from the view number (3rd arg) to the k-space center. The view number must be an integer in range [0, .res-1], and the number refers to a fully sampled k-space (without parallel imaging)

Parameters

[in,out]	phaser	Pointer to KS_PHASER
[in]	instanceno	Instance of KS_TRAP to change (INSTRALL changes all instances)
[in]	view	Phase encoding line to acquire with index corresponding to a fully sampled k-space [0, res-1]

Return values

STATUS

SUCCESS or FAILURE

                                                                          {
  double kmax;

  if (phaser == NULL)
    return;

  if (view < 0 || view >= phaser->res) {
    ks_scan_phaser_kmove(phaser, instanceno, 0.0);
    return;
  }

  /* KSFoundation 'view' is always 0-based: e.g. res = 256: view = 0->255. */
  kmax = ((phaser->res - 1.0) / 2.0);
  ks_scan_phaser_kmove(phaser, instanceno, view - kmax);

} /* ks_scan_phaser_fromline */

ks_scan_rf_ampscale()

void ks_scan_rf_ampscale	(	KS_RF *	rf,
		int	instanceno,
		float	ampscale
	)

Changes the amplitude of one or all instances of an RF pulse (KS_RF)

This function multiplies one instance of a KS_RF object with an amplitude scale factor (3rd arg) that must be in range [-1.0,1.0]. To change all instances of a KS_RF object, use INSTRALL as the 2nd argument.

The actual flip angle for an instance of a KS_RF object is the multiplication of the three factors:

1. The designed flip angle
2. The per-instance .ampscale in the KS_SEQLOC struct passed to ks_pg_rf()
3. The ampscale value passed in as 3rd argument to this function. Since both ampscale factors are forced to be in range [-1.0,1.0], it is not possible to increase the flip angle beyond the designed value (.flip)

Parameters

[in,out]	rf	Pointer to KS_RF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	ampscale	RF amplitude scale factor in range [-1.0,1.0]

                                                                    {
  int firstinstance, lastinstance, i;
#ifdef IPG
  int instramp;
  KS_WFINSTANCE *wfi;
  int numplaced = rf->rfwave.base.ngenerated;
#else
  int numplaced = rf->rfwave.base.ninst;
  if (!numplaced) {
    return;
  }
  float* tmp = (float*)realloc(rf->rfwave.rtscale, numplaced * sizeof(float));
  if (!tmp) {
    ks_error("%s: rtscale realloc failed", __FUNCTION__);
    return;
  }
  rf->rfwave.rtscale = tmp;
#endif

  if (instanceno == INSTRALL) {
    firstinstance = 0;
    lastinstance = numplaced - 1;
  } else {
    firstinstance = instanceno;
    lastinstance = instanceno;
  }

  /* input validation */
  if (numplaced == 0) {
    return;
  }

  if (firstinstance < 0 || lastinstance >= numplaced) {
    ks_error("ks_scan_rf_ampscale(%s): instanceno (%d) out of range [0,%d]", rf->rfwave.description, instanceno, numplaced - 1);
    return;
  }

  if (fabs(ampscale) > 1.0) {
    ks_error("ks_scan_rf_ampscale(%s): ampscale too large (%f)", rf->rfwave.description, ampscale);
    return;
  }

#ifdef IPG

  /* set amplitude(s) */
  for (i = firstinstance; i <= lastinstance; i++) {
    wfi = &rf->rfwave.wfi[i];
    instramp = (int)(rf->amp * wfi->loc.ampscale * ampscale * MAX_PG_IAMP);
    setiamp(instramp, wfi->wf, wfi->boardinstance);
  } /* for */

#else
  for (i = firstinstance; i <= lastinstance; i++) {
    rf->rfwave.rtscale[i] = ampscale;
  }
#endif

} /* ks_scan_rf_ampscale */

ks_scan_rf_on()

void ks_scan_rf_on	(	KS_RF *	rf,
		int	instanceno
	)

Resets the amplitude of one or all instances of an RF pulse (KS_RF)

This function (re)sets the RF amplitude to the state given by ks_pg_rf()

Parameters

[in,out]	rf	Pointer to KS_RF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)

                                              {

  ks_scan_rf_ampscale(rf, instanceno, 1.0);

}

ks_scan_rf_on_chop()

void ks_scan_rf_on_chop	(	KS_RF *	rf,
		int	instanceno
	)

Resets the amplitude of one or all instances of an RF pulse (KS_RF) and toggles the sign (chopping)

Everytime this function is called, the magnitude of the RF amplitude will be (re)set the RF amplitude to the state given by ks_pg_rf() and the polarity of the RF amplitude will be changed. If this function is called each TR (RF chopping) for a linear single-line k-space acquisition, a FOV/2 shift will occur in the image with any DC component shifted out to the edges of the image FOV.

Parameters

[in,out]	rf	Pointer to KS_RF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)

                                                   {
  static float chopsign = 1.0;

  ks_scan_rf_ampscale(rf, instanceno, chopsign);

  chopsign *= -1.0;

}

ks_scan_rf_off()

void ks_scan_rf_off	(	KS_RF *	rf,
		int	instanceno
	)

Sets the amplitude of one or all instances of an RF pulse (KS_RF) to zero

This can be undone by calling ks_scan_rf_on(), ks_scan_rf_on_chop(), or ks_scan_rf_ampscale()

Parameters

[in,out]	rf	Pointer to KS_RF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)

                                               {

  ks_scan_rf_ampscale(rf, instanceno, 0.0);

}

ks_cycles_to_iphase()

unsigned int ks_cycles_to_iphase

(

double

cycles

)

                                                {
    /* Actual period for u14 */
    static const unsigned int FS_2PI_u14 = (1<<14); 
    /* Want the fractional part */
    cycles -= (long)cycles; 
    /* Force positive */
    cycles++; 
    /* Scale to u14 domain then shift two bits to the 
       left for compatibility with FS_2PI [u16] period. */
    return (unsigned int)(cycles * (double)FS_2PI_u14 + 0.5) % FS_2PI_u14 << 2;
} /* ks_cycles_to_iphase */

ks_degrees_to_iphase()

unsigned int ks_degrees_to_iphase

(

double

degrees

)

                                                  {
  return ks_cycles_to_iphase(degrees / 360.0);
} /* wrapper for ks_cycles_to_iphase */

ks_radians_to_iphase()

unsigned int ks_radians_to_iphase

(

double

radians

)

                                                  {
  return ks_cycles_to_iphase(radians / (2.0 * PI));
} /* wrapper for ks_cycles_to_iphase */

ks_scan_selrf_setfreqphase_pins()

void ks_scan_selrf_setfreqphase_pins	(	KS_SELRF *	selrf,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		int	sms_multiband_factor,
		float	sms_slice_gap,
		float	rfphase
	)

Updates the off-center phase-modulation of one or all instances of a PINS RF pulse (KS_SELRF)

This function alters the phase of the PINS RF pulse in a KS_SELRF object to excite spatial locations corresponding to the information in sliceinfo.tloc.

Parameters

[in,out]	selrf	Pointer to KS_SELRF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	sms_multiband_factor
[in]	sms_slice_gap	in [mm]
[in]	rfphase	Phase of the RF pulse in [degrees]

Return values

STATUS

SUCCESS or FAILURE

                                                      {

  int firstinstance, lastinstance, j;
  int phaseIndex = 1;
  KS_WAVE newwave = KS_INIT_WAVE;
  float locOffset;
  float phaseIncrement;
#ifdef IPG
  int i;
  int numplaced = selrf->rf.rfwave.base.ngenerated;
#else
  int numplaced = selrf->rf.rfwave.base.ninst;
#endif

  if (instanceno == INSTRALL) {
    firstinstance = 0;
    lastinstance = numplaced - 1;
  } else {
    firstinstance = instanceno;
    lastinstance = instanceno;
  }

  if (numplaced == 0) {
    return;
  }

  if (firstinstance < 0 || lastinstance >= numplaced) {
    ks_error("ks_scan_selrf_setfreqphase_pins(%s): instanceno (%d) out of range [0,%d]", selrf->rf.rfwave.description, instanceno, numplaced - 1);
    return;
  }

  newwave = selrf->rf.thetawave;

  locOffset = sliceinfo.optloc;
  phaseIncrement = (360.0 / sms_slice_gap) * locOffset;

  /* If the MB-factor is even, center the slice group */
  if (sms_multiband_factor % 2 == 0) {
    phaseIncrement += 180.0;
  }

  for (j = 0; j < selrf->rf.thetawave.res; j++) {

    if (!areSame(selrf->rf.rfwave.waveform[j], 0.0)) {
      newwave.waveform[j] = selrf->rf.thetawave.waveform[j] + ((float)phaseIndex * phaseIncrement) + rfphase;
    }

    if (j < selrf->rf.thetawave.res - 1) {
      if (!areSame(selrf->rf.rfwave.waveform[j], 0.0) && areSame(selrf->rf.rfwave.waveform[j + 1], 0.0)) {
        phaseIndex++;
      }
    }
  }

#ifdef IPG

  for (i = firstinstance; i <= lastinstance; i++) {
    /* set RF frequency & phase offset to zero */
    setfrequency(0, selrf->rf.rfwave.wfi[i].wf, selrf->rf.rfwave.wfi[i].boardinstance);
    setphase(0.0, selrf->rf.rfwave.wfi[i].wf, selrf->rf.rfwave.wfi[i].boardinstance);

    /* move modified thetawave to hardware */
    ks_scan_wave2hardware(&selrf->rf.thetawave, newwave.waveform);
  }

#endif

} /* ks_scan_selrf_setfreqphase_pins */

ks_scan_selrf_setfreqphase()

void ks_scan_selrf_setfreqphase	(	KS_SELRF *	selrf,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		float	rfphase
	)

Updates the frequency and phase of one or all instances of a slice selective RF pulse (KS_SELRF)

This function alters the frequency of the RF pulse in a KS_SELRF object to excite a spatial location corresponding to the information in sliceinfo.tloc. The phase of the RF pulse is also updated

Parameters

[in,out]	selrf	Pointer to KS_SELRF
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	rfphase	Phase of the RF pulse in [degrees]

Return values

STATUS

SUCCESS or FAILURE

                                                                                                       {
  int firstinstance, lastinstance;
  int i;
  float freqoffHz, hertzPerMm, ampscale;
#ifdef IPG
  float tloc = sliceinfo.optloc;
  int numplaced = selrf->rf.rfwave.base.ngenerated;
#else
  float tloc = 1.0; /* Simulate offset of 1 mm for plotting in units of [Hz/mm] */
  int numplaced = selrf->rf.rfwave.base.ninst;
#endif

  if (instanceno == INSTRALL) {
    firstinstance = 0;
    lastinstance = numplaced - 1;
  } else {
    firstinstance = instanceno;
    lastinstance = instanceno;
  }

  if (numplaced == 0) {
    return;
  }
  if (firstinstance < 0 || lastinstance >= numplaced) {
    ks_error("ks_scan_selrf_setfreqphase(%s): instanceno (%d) out of range [0,%d]", selrf->rf.rfwave.description, instanceno, numplaced - 1);
    return;
  }

  /* set frequency */
  for (i = firstinstance; i <= lastinstance; i++) {
#ifdef IPG
  if (!(i < selrf->rf.rfwave.base.ngenerated &&
        selrf->rf.rfwave.wfi[i].wf->wavegen_type == TYPRHO1 &&
        selrf->rf.rfwave.wfi[i].wf->assoc_pulse->tag == SSPFREQ)) { /* make sure it has been set up properly */
    ks_error("ks_scan_rf_setfreqphase(%s): RF pulse not properly set up or instance # too high", selrf->rf.rfwave.description);
    return;
  }
  if (selrf->gradwave.res > 0) {
    /* gradwave */
    if (selrf->gradwave.wfi != NULL) {
      ampscale = selrf->gradwave.wfi[i].loc.ampscale;
    } else {
      ks_error("ks_scan_rf_setfreqphase(%s): no gradwave has been set up, setting ampscale = 0", selrf->rf.rfwave.description);
      ampscale = 0;
    }
  } else {
    /* trapezoid */
    if (selrf->grad.wfi != NULL) {
      ampscale = selrf->grad.wfi[i].loc.ampscale;
    } else {
      ks_error("ks_scan_rf_setfreqphase(%s): no grad has been set up, setting ampscale = 0", selrf->rf.rfwave.description);
      ampscale = 0; /* protect against wfi[i] = NULL, then return 0 amp */
    }
  }
#else
  ampscale = (selrf->gradwave.res > 0) ? selrf->gradwave.locs[i].ampscale
                                             : selrf->grad.locs[i].ampscale;
#endif

    /* ampscale (a.u.) * GAM [Hz/G] / 10.0 [cm->mm] * gradamp [G/cm] = [Hz/mm] */
    hertzPerMm = ampscale * GAM / 10.0 *
                 ((selrf->gradwave.res > 0) ? ks_calc_selgradamp(selrf->rf.bw, selrf->slthick) /* gradwave slice selection */
                                             : selrf->grad.amp); /* trapezoid slice selection */
    freqoffHz = selrf->rf.cf_offset; /* [Hz] */

    /* optloc-dependent freq offset */
    if (selrf->rf.omegawave.res > 0) {
      ks_scan_omegawave_hz(&selrf->rf.omegawave, i, hertzPerMm * tloc /* [Hz] */);
    } else {
      freqoffHz += hertzPerMm * tloc; /* [Hz] */
    }

#ifdef IPG
    /* set RF frequency offset */
    setfrequency((int)(freqoffHz / TARDIS_FREQ_RES), selrf->rf.rfwave.wfi[i].wf, selrf->rf.rfwave.wfi[i].boardinstance);

    /* calculate phase */
    {
      double ftime_delay;           /* floating point time delay in seconds */
      double temp_freq;             /* frequency offset */
      long tmpphase;
      int syncpos, rfstartpos, time_delay;

      /* start of RF pulse wave form (for 1st boardinstance) */
      rfstartpos = selrf->rf.rfwave.wfi[i].wf->inst_hdr_tail->start;
      /* start of RF SSP frq pulse  (for 1st boardinstance) */
      syncpos = selrf->rf.rfwave.wfi[i].wf->assoc_pulse->inst_hdr_tail->start;

      /* time difference between SSP frq and isocenter of RF pulse */
      time_delay = rfstartpos - syncpos - 9 /* frq2sync_dly */ + RUP_FACTOR(selrf->rf.rfwave.duration - selrf->rf.iso2end, 2);

      /*** Modified from GE's setupphases() ***/
      ftime_delay = ((double)time_delay) / ((double) 1.0e6);
      temp_freq = (double) freqoffHz;
      tmpphase = (ks_degrees_to_iphase(rfphase) /* deg->iphase */ + ks_cycles_to_iphase( - temp_freq * ftime_delay )) % FS_2PI; /* radians */
      setiphase(tmpphase,  selrf->rf.rfwave.wfi[i].wf, selrf->rf.rfwave.wfi[i].boardinstance);
    }
#endif
  } /* for each instance */
} /* ks_scan_selrf_setfreqphase */

ks_scan_rf_setphase()

void ks_scan_rf_setphase	(	KS_RF *	rf,
		int	instanceno,
		float	rfphase
	)

Updates the phase of one or all instances of an RF pulse (KS_RF)

This function sets the phase of an RF pulse object (KS_RF). Can be used for RF spoiling

Parameters

[in,out]	rf	Pointer to KS_SEL
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	rfphase	Phase of the RF pulse in [degrees]

                                                                     {
  int firstinstance, lastinstance;
  #ifdef IPG
    int i;
    int numplaced = rf->rfwave.base.ngenerated;
  #else
    int numplaced = rf->rfwave.base.ninst;
  #endif

  if (instanceno == INSTRALL) {
    firstinstance = 0;
    lastinstance = numplaced - 1;
  } else {
    firstinstance = instanceno;
    lastinstance = instanceno;
  }

  if (numplaced == 0) {
    return;
  }
  if (firstinstance < 0 || lastinstance >= numplaced) {
    ks_error("%s(%s): instanceno (%d) out of range [0,%d]", __FUNCTION__, rf->rfwave.description, instanceno, numplaced - 1);
    return;
  }

  #ifdef IPG
  /* set frequency */
  for (i = firstinstance; i <= lastinstance; i++) {
    /* calculate phase */
    {
      double ftime_delay;           /* floating point time delay in seconds */
      double cf_offset = (double) rf->cf_offset;             /* frequency offset */
      long tmpphase;
      int syncpos, rfstartpos, time_delay;

      /* start of RF pulse wave form (for 1st boardinstance) */
      rfstartpos = rf->rfwave.wfi[i].wf->inst_hdr_tail->start;
      /* start of RF SSP frq pulse  (for 1st boardinstance) */
      syncpos = rf->rfwave.wfi[i].wf->assoc_pulse->inst_hdr_tail->start;

      /* time difference between SSP frq and isocenter of RF pulse */
      time_delay = rfstartpos - syncpos - 9 /* frq2sync_dly */ + RUP_FACTOR(rf->rfwave.duration - rf->iso2end, 2);

      /*** Modified from GE's setupphases() ***/
      ftime_delay = ((double)time_delay) / ((double) 1.0e6);
      tmpphase = (ks_degrees_to_iphase(rfphase) /* deg->iphase */ + ks_cycles_to_iphase( - cf_offset * ftime_delay )) % FS_2PI; /* radians */
      setiphase(tmpphase,  rf->rfwave.wfi[i].wf, rf->rfwave.wfi[i].boardinstance);
    }

  } /* for each instance */

  #endif


} /* ks_scan_rf_setphase */

ks_scan_wave2hardware()

void ks_scan_wave2hardware	(	KS_WAVE *	wave,
		const KS_WAVEFORM	newwave
	)

Moves a waveform belonging to a KS_WAVE sequence object to hardware

This function copies a waveform to one of the two hardware waveform buffers (belonging to the KS_WAVE object) that is currently not in use for the current sequence playout. The selection of which buffer to update is handled automatically by the function, which will also change the waveform pointer to the updated buffer so it will be used for the next sequence playout

If the 2nd argument (newwave, of type KS_WAVEFORM (float array)) is

1. not NULL, the content of newwave is used
2. NULL, it is assumed that the .waveform field of KS_WAVE has been updated with new contents and is copied to hardware instead of newwave

Parameters

[in,out]	wave	Pointer to KS_WAVE
[in]	newwave	KS_WAVEFORM to copy to hardware (if NULL, the .waveform field in KS_WAVE will be used instead)

                                                                     {
#ifdef IPG
  KS_IWAVE iwave;
  WF_PULSE *wfpulse;
  LONG current_wave_ptrs[KS_WF_SIZE];
  LONG wave_ptr;
  int i,j;
  STATUS status;
  int numplaced = wave->base.ngenerated;
#else
  int numplaced = wave->base.ninst;
#endif

  if (numplaced == 0) {
    return;
  }

#ifdef IPG

  for (i = 0; i < 7; i++) {

    wfpulse = wave->wfpulse[i];

    if (!wfpulse) {
      continue;
    }

    if (newwave != NULL) {
      /* use the new float array passed in as 3rd argument */
      status = ks_waveform2iwave(iwave, newwave, wave->res, i);
    } else {
      /* use the data in the `.waveform` field of the KS_WAVE (1st arg) */
      status = ks_wave2iwave(iwave, wave, i); /* iwave is waveform memory */
    }

    /* Extract current wave pointers */
    for (j = KS_WF_MAIN; j < KS_WF_SIZE; j++) {
      getwave(&current_wave_ptrs[j], &wfpulse[j]);
    }

    /* Compare the main pointer with the buffers and find wich buffer was used 
       last time, then move the new waveform to the other one. Also, get the new pointer. 
       movewaveimm might take some time to compute if the wave is long, consider increasing
       the SSI-time if you expericence any problems */
    if (current_wave_ptrs[KS_WF_MAIN] == current_wave_ptrs[KS_WF_BUF2]) {
      movewaveimm(iwave, &wfpulse[KS_WF_BUF1], (int) 0, wave->res, TOHARDWARE);
      getwave(&wave_ptr, &wfpulse[KS_WF_BUF1]);
    } else {
      movewaveimm(iwave, &wfpulse[KS_WF_BUF2], (int) 0, wave->res, TOHARDWARE);
      getwave(&wave_ptr, &wfpulse[KS_WF_BUF2]);
    }

    /* Make the new pointer the main one */
    setwave(wave_ptr, &wfpulse[KS_WF_MAIN], -1);

  } /* for */

#endif

} /* ks_scan_wave2hardware */

ks_scan_offsetfov_iso()

void ks_scan_offsetfov_iso	(	KS_READTRAP *	readtrap,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		double	ky,
		double	kz,
		double	rcvphase
	)

Updates the frequency and phase to create a FOV shift assuming that the k-space voxels/pixels are isometric

Parameters

[in,out]	readtrap	Pointer to KS_READTRAP
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	ky	phase offset in k-space measured in voxels/pixels
[in]	kz	phase offset in k-space measured in voxels/pixels
[in]	rcvphase	Receiver phase in [degrees] of the acquisition window corresponding to the KS_READTRAP and instanceno

                                                                                                                              {
  /* Warning: We never have more than one instance (i.e. instruction) per readtrap.echo[i] (see ks_pg_readtrap())
     unlike KS_TRAP and KS_RF. This means that the 2nd input arg here ('instanceno') means the instanceno'th echo. */

#ifdef IPG
    const int numplaced = readtrap->acq.base.ngenerated;
#else
    const int numplaced = readtrap->acq.base.ninst;
#endif

  int firstreadout, lastreadout;
  if (instanceno == INSTRALL) {
    firstreadout = 0;
    lastreadout = numplaced - 1;
  } else {
    firstreadout = instanceno;
    lastreadout = instanceno;
  }
  
  if (numplaced == 0) {
    return;
  }

  if (firstreadout < 0 || lastreadout >= numplaced) {
    ks_error("ks_scan_offsetfov(%s): readout instance (%d) out of range [0,%d]", readtrap->grad.description, instanceno, numplaced - 1);
    return;
  }

  int i;
  for (i = firstreadout; i <= lastreadout; i++) {
#ifdef IPG
    /* gradient amplitude for this instance -> Hz */
    const double mmtoHz = readtrap->grad.amp * readtrap->grad.wfi[i].loc.ampscale * GAM / 10.0; /* [Hz/mm]. designed amp [G/cm] * instance amp * GAM [Hz/G] / 10.0 [cm->mm] */
    float rloc = sliceinfo.oprloc;
#else
    const double mmtoHz = readtrap->grad.amp * readtrap->grad.locs[i].ampscale * GAM / 10.0;
    float rloc = 1;
#endif
    

    /* omega offset for rampsampled cases */
    if (readtrap->omega.duration > 0) {
      ks_scan_omegatrap_hz(&readtrap->omega, i,  mmtoHz * rloc /* [Hz] */);
    }

#ifdef IPG

    const int gradsign = (mmtoHz >= 0) ? 1 : -1;
    /* Frequency offsets [Hz]:
       - cfreceiveroffsetfreq: GE's standard frequency offset
       - readtrap->freqoffHz: Additional frequency offset for current KS_READTRAP. This value is multiplied with the gradient polarity sign
       - mmtoHz * sliceinfo.oprloc: Slice-dependent and gradient polarity dependent frequency offset (when omega is off) */
    const double freqoffHz = cfreceiveroffsetfreq + readtrap->freqoffHz * gradsign + (readtrap->omega.duration == 0) * (mmtoHz * rloc); /* [Hz] */

    /* set readout frequency offset */
    if (i < readtrap->acq.base.ngenerated && readtrap->acq.echo[i].tag == SSPDAB) { /* make sure it has been set up properly */
      setfrequency((int)(freqoffHz / TARDIS_FREQ_RES), &readtrap->acq.echo[i], 0);
    }
    /* set phase offset */
    if (i < readtrap->acq.base.ngenerated && readtrap->acq.echo[i].tag == SSPDAB) {

      const double time2echo = (double)(readtrap->time2center - readtrap->acqdelay);
      /* The clock source at setfrequency() starts before the first readout of the ADC, we need to account for the phase that accunmulates during this time.
         acqq.cpp - the RBA packet [ADC sync time?] has a fixed delay of RBA_length[PSD_XCVR2] which is set in EpicConf.cpp to RBA_LENGTH (= 4)
         It seems that all known hardware uses PSD_XCVR2 as the index and RBA_length isn't included in the scope of this file.*/
      int adcstartpos = readtrap->acq.echo[i].assoc_pulse->assoc_pulse->inst_hdr_tail->start + RBA_LENGTH;
      /* start of ADC SSP frq pulse  (for 1st boardinstance) */
      int syncpos = readtrap->acq.echo[i].assoc_pulse->inst_hdr_tail->start;
      /* time difference between SSP frq and start of the ADC readout */
      int time_delay = adcstartpos - syncpos - 10;

      const unsigned int iphase_due_to_freqoffset = ks_cycles_to_iphase(- freqoffHz * ((double)time_delay + time2echo) * 1e-6);
      const unsigned int iphase_ky = ks_cycles_to_iphase(- ky * sliceinfo.opphasoff / readtrap->fov);
      const unsigned int iphase_kz = ks_cycles_to_iphase(- kz * sliceinfo.optloc / readtrap->fov);
      const unsigned int ircvphase = ks_degrees_to_iphase(rcvphase);
      long iphase = (iphase_ky + iphase_kz + ircvphase + iphase_due_to_freqoffset) % FS_2PI;
      setiphase(iphase,  &readtrap->acq.echo[i], 0);

    }
#endif

  } /* for */
} /* ks_scan_offsetfov_iso */

ks_scan_offsetfov_iso_readwave()

void ks_scan_offsetfov_iso_readwave	(	KS_READWAVE *	readwave,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		double	ky,
		double	kz,
		double	rcvphase
	)

                                                                                                                                       {

  /* Warning: We never have more than one instance (i.e. instruction) per readwave.acq.echo[i] (see ks_pg_readwave())
     unlike KS_TRAP and KS_RF. This means that the 2nd input arg here ('instanceno') means the instanceno'th echo. */
#ifdef IPG
    const int numplaced = readwave->acq.base.ngenerated;
    const double halfreadoutdur = ((readwave->acq.filt.outputs - 1) * readwave->acq.filt.tsp / 2.0) * 1e-6; /* [s] */
#else
    const int numplaced = readwave->acq.base.ninst;
#endif
  if (numplaced == 0) {
    return;
  }

  int firstreadout, lastreadout;
  if (instanceno == INSTRALL) {
    firstreadout = 0;
    lastreadout = numplaced - 1;
  } else {
    firstreadout = instanceno;
    lastreadout = instanceno;
  }

  if (firstreadout < 0 || lastreadout >= numplaced) {
    ks_error("%s: readout instance (%d) out of range [0,%d]", __FUNCTION__, instanceno, numplaced - 1);
    return;
  }

  const float read_max = ks_wave_max(&readwave->grads[0]);
  const float read_min = ks_wave_min(&readwave->grads[0]);
  const float read_amp = read_max > -read_min ? read_max : read_min; /* Contains sign */

  int i;
  for (i = firstreadout; i <= lastreadout; i++) {
#ifdef IPG
    /* gradient amplitude for this instance -> Hz */
    const double hertzPerMm = read_amp * readwave->grads[0].wfi[i].loc.ampscale * GAM / 10.0; /* [Hz/mm]. designed amp [G/cm] * instance amp * GAM [Hz/G] / 10.0 [cm->mm] */
    float rloc = sliceinfo.oprloc;
#else
    const double hertzPerMm = read_amp * readwave->grads[0].locs[i].ampscale * GAM / 10.0;
    float rloc = 1;
#endif

#ifdef IPG
  const int gradsign = (hertzPerMm >= 0) ? 1 : -1;
    /* Frequency offsets [Hz]:
       - cfreceiveroffsetfreq: GE's standard frequency offset
       - readwave->freqoffHz: Additional frequency offset for current KS_WAVE. This value is multiplied with the gradient polarity sign
       - hertzPerMm * rloc: Slice-dependent and gradient polarity dependent frequency offset (when omega is off) */
    const double freqoffHz = cfreceiveroffsetfreq + readwave->freqoffHz * gradsign + (readwave->omega.duration == 0) * (hertzPerMm * rloc); /* [Hz] */

    /* set readout frequency offset */
    if (i < readwave->acq.base.ngenerated && readwave->acq.echo[i].tag == SSPDAB) {/* make sure it has been set up properly */
      setfrequency((int)(freqoffHz / TARDIS_FREQ_RES), &readwave->acq.echo[i], 0);
    }
#endif

    /* omega offset for rampsampled cases */
    if (readwave->omega.duration > 0) {
      ks_scan_omegawave_hz(&readwave->omega, i,  hertzPerMm * rloc /* [Hz] */);
    }

#ifdef IPG
    /* set phase offset */
    if (i < readwave->acq.base.ngenerated && readwave->acq.echo[i].tag == SSPDAB) {
      const unsigned int iphase_due_to_freqoffset = ks_cycles_to_iphase(- hertzPerMm * rloc * halfreadoutdur);
      const unsigned int iphase_ky = ks_cycles_to_iphase(- ky * sliceinfo.opphasoff / readwave->fov);
      const unsigned int iphase_kz = ks_cycles_to_iphase(- kz * sliceinfo.optloc / readwave->fov);
      const unsigned int ircvphase = ks_degrees_to_iphase(rcvphase);
      long iphase = (iphase_ky + iphase_kz + ircvphase + iphase_due_to_freqoffset) % FS_2PI;
      setiphase(iphase,  &readwave->acq.echo[i], 0);
    }
#endif

  } /* for */
} /* ks_scan_offsetfov_iso_readwave */

ks_scan_offsetfov()

void ks_scan_offsetfov	(	KS_READTRAP *	readtrap,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		float	view,
		float	phasefovratio,
		float	rcvphase
	)

Updates the frequency and phase of one or all instances of a KS_READTRAP to create a FOV shift

This function can be used by 2D Cartesian pulse sequences to build up the phase ramp in k-space necessary to shift the image FOV. The desired image FOV shift is given by the SCAN_INFO struct passed in as 3rd argument. The view field and the phasefovratio arguments are necessary to know where in the physical k-space the acquired data is placed. Knowing this and the FOV offset in the phase encoding direction, the necessary receiver phase for the current view can be set. After this function has been called for all view numbers, the necessary phase ramp has been set up in k-space to perform the phase FOV shift in the image domain. The rcvphase is added to the receive phase required for the FOV shift. In general, the rcvphase should be the same as the phase of the RF excitation pulse.

For rampsampled acquisitions (.rampsampling = 1 in KS_READTRAP), the ks_scan_offsetfov_iso() function called will internally call ks_scan_omegatrap_hz() for FOV shifts in the readout direction. Both ks_scan_offsetfov() and ks_scan_offsetfov3D() calls the same ks_scan_offsetfov_iso() function after performing unit conversions of the input arguments.

Parameters

[in,out]	readtrap	Pointer to KS_READTRAP
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	view	Phase encoding line to acquire with index corresponding to a fully sampled k-space [0, res-1]
[in]	phasefovratio	The ratio of FOVphase/FOVfreq (as opphasefov)
[in]	rcvphase	Receiver phase in [degrees] of the acquisition window corresponding to the KS_READTRAP and instanceno

                                                                                                                                    {
  const double koffset = (double)(ky) / phasefovratio;
  ks_scan_offsetfov_iso(readtrap, instanceno, sliceinfo, koffset, 0, rcvphase);
}

ks_scan_offsetfov3D()

void ks_scan_offsetfov3D	(	KS_READTRAP *	readtrap,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		float	kyview,
		float	phasefovratio,
		float	kzview,
		float	zphasefovratio,
		float	rcvphase
	)

Updates the frequency and phase of one or all instances of a KS_READTRAP to create a FOV shift

This function can be used by 3D Cartesian pulse sequences to build up the phase ramp in k-space necessary to shift the image FOV. The desired image FOV shift is given by the SCAN_INFO struct passed in as 3rd argument. The kyview/kzview field and the phasefovratio/zphasefovratio arguments are necessary to know where in the physical k-space the acquired data is placed. Knowing this and the FOV offset in both phase encoding directions, the necessary receiver phase for the current kyview/kzview can be set. After this function has been called for all kyview/kzview numbers, the necessary phase ramp has been set up in k-space to perform the phase FOV shift in the image domain. The rcvphase is added to the receive phase required for the FOV shift. In general, the rcvphase should be the same as the phase of the RF excitation pulse.

For rampsampled acquisitions (.rampsampling = 1 in KS_READTRAP), the ks_scan_offsetfov_iso() function called will internally call ks_scan_omegatrap_hz() for FOV shifts in the readout direction. Both ks_scan_offsetfov() and ks_scan_offsetfov3D() calls the same ks_scan_offsetfov_iso() function after performing unit conversions of the input arguments.

Parameters

[in,out]	readtrap	Pointer to KS_READTRAP
[in]	instanceno	Instance of KS_RF to change (INSTRALL changes all instances)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	kyview	Phase encoding line to acquire with index corresponding to a fully sampled k-space [0, res-1] (YGRAD)
[in]	phasefovratio	The ratio of FOVphase/FOVfreq (as opphasefov)
[in]	kzview	Z Phase encoding line to acquire with index corresponding to a fully sampled k-space [0, res-1] (ZGRAD)
[in]	zphasefovratio	The ratio of FOVslice/FOVfreq (as (opslquant * opslthick) / opfov)
[in]	rcvphase	Receiver phase in [degrees] of the acquisition window corresponding to the KS_READTRAP and instanceno

                                                                                                                                                                      {
  const double kyoffset = (double)(ky) / phasefovratio;
  const double kzoffset = (double)(kz) / zphasefovratio;
  ks_scan_offsetfov_iso(readtrap, instanceno, sliceinfo, kyoffset, kzoffset, rcvphase);
}

ks_scan_offsetfov_readwave()

void ks_scan_offsetfov_readwave	(	KS_READWAVE *	readwave,
		int	instanceno,
		SCAN_INFO	sliceinfo,
		float	ky,
		float	phasefovratio,
		float	rcvphase
	)

                                                                                                                                           {
  const double koffset = (double)(ky) / phasefovratio;
  ks_scan_offsetfov_iso_readwave(readwave, instanceno, sliceinfo, koffset, 0, rcvphase);
}

ks_scan_rotate()

void ks_scan_rotate

(

SCAN_INFO

slice_info

)

Performs a rotation of the logical system on hardware (WARP)

The field .oprot (9-element array) in the SCAN_INFO struct holds the rotation matrix that should be played out

This function performs the necessary scaling of the rotation matrix using loggrd and phygrd and then calls setrotatearray(), which performs the actual rotation on hardware during the next SSI time.

See ks_scan_update_slice_location() for detail on how to create new SCAN_INFO structs in run-time

Parameters

[in]

slice_info

SCAN_INFO struct holding new slice information

Returns

void

                                          {
#ifdef IPG

  /* scale to long int rotation matrix (accounting for gradient scaling) */
  scale(&slice_info.oprot, &rsprot[0], 1, &loggrd, &phygrd, 0);

  setrotatearray(1, rsprot[0]);

#endif
}

ks_scan_isirotate()

void ks_scan_isirotate

(

KS_ISIROT *

isirot

)

Performs an immediate rotation of the logical system on hardware (WARP)

This function needs a psd-specific wrapper function to execute (see ks_pg_isirot()) since the ISI interupt routine is calling a void function without input arguments. This psd-specific wrapper function should only contain the call to ks_scan_isirotate() with the psd-specific KS_ISIROT set up in pulsegen().

For N number of calls to ks_pg_isirot() in the sequence module's pg-function, the field isirot.numinstances will be set to N, and this many ISI interrupt with a corresponding isirot.isinumber exist in the sequence module. Valid ISI numbers are 4-7, and one available number should be linked to one specific wrapper function using ks_eval_isirot() and ks_pg_isirot().

In real-time, ks_scan_isirotate() will increment the isirot.counter field by 1 and restart at 0 after isirot->numinstances. isirot.counter is set to 0 in ks_pg_isirot(). Based on the value of the .counter field, it will assign a pre-stored SCAN_INFO struct corresponding to this counter value. Again, this connection is done by ks_pg_isirot().

ks_scan_isirotate() takes the current SCAN_INFO and converts it to long int, and then calls setrotateimm(..., WARP_UPDATE_ON_SSP_INT);

Parameters

[in]

isirot

Pointer to the KS_ISIROT struct set up by ks_pg_isirot()

Returns

void

                                          {
#ifdef IPG

  if (isirot == NULL || isirot->numinstances < 1)
    return;

  /* wrap around after numinstances interupts */
  isirot->counter = isirot->counter % isirot->numinstances;

  /* scale to long int rotation matrix (accounting for gradient scaling) */
  scale(&isirot->scan_info[isirot->counter++].oprot, &rsprot[0], 1, &loggrd, &phygrd, 0);

  /* rotate on SSP interrupt */
  setrotateimm(rsprot[0], WARP_UPDATE_ON_SSP_INT);

#endif
}

ks_scan_getsliceloc()

int ks_scan_getsliceloc	(	const KS_SLICE_PLAN *	slice_plan,
		int	passindx,
		int	sltimeinpass
	)

Returns the spatially sorted slice index from a DATA_ACQ_ORDER struct array

This function finds the spatially sorted slice index (.slloc) in range [0, nslices-1] given the sequence's DATA_ACQ_ORDER struct array (in slice_plan.acq_order)

Parameters

[in]	slice_plan	Pointer to the slice plan (KS_SLICE_PLAN) for the sequence
[in]	passindx	Current pass index ([0, acqs-1])
[in]	sltimeinpass	Temporal index of the n slices acquired in each pass ([0, n-1])

Return values

slloc

Spatially sorted slice index

                                                                                         {
  int i;
  for (i = 0; i < slice_plan->nslices; i++) {
    if (slice_plan->acq_order[i].slpass == passindx && slice_plan->acq_order[i].sltime == sltimeinpass) {
      return slice_plan->acq_order[i].slloc;
    }
  }

  return KS_NOTSET;

}

ks_scan_getslicetime()

int ks_scan_getslicetime	(	const KS_SLICE_PLAN *	slice_plan,
		int	passindx,
		int	slloc
	)

Returns the temporally sorted slice index from a DATA_ACQ_ORDER struct array

This function finds the temporally sorted slice index (.sltime) in range [0, nslices-1] given the sequence's DATA_ACQ_ORDER struct array (in slice_plan.acq_order)

Parameters

[in]	slice_plan	Pointer to the slice plan (KS_SLICE_PLAN) for the sequence
[in]	passindx	Current pass index ([0, acqs-1])
[in]	slloc	Spatially sorted slice index [0, nslices-1]

Return values

sltimeinpass

Temporal index of the n slices acquired in each pass ([0, n-1])

                                                                                   {
  int i;
  for (i = 0; i < slice_plan->nslices; i++) {
    if (slice_plan->acq_order[i].slpass == passindx && slice_plan->acq_order[i].slloc == slloc) {
      return slice_plan->acq_order[i].sltime;
    }
  }

  return KS_NOTSET;

}

ks_scan_epi_verify_phaseenc_plan()

ks_enum_epiblipsign ks_scan_epi_verify_phaseenc_plan	(	KS_EPI *	epi,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot
	)

                                                                                                                  {
  int i;
  int kystep[epi->etl];
  ks_enum_epiblipsign blipsign = KS_EPI_NOBLIPS;
  KS_PHASEENCODING_COORD coord = KS_INIT_PHASEENCODING_COORD;

  if (phaseenc_plan == NULL) {
    return blipsign;
  }

  /* verify phase encoding plan has equidistant ky step size */
  /* first store ky coords */
  for (i = 0; i < epi->etl; i++) {
    coord = ks_phaseencoding_get(phaseenc_plan, i, shot);
    kystep[i] = coord.ky;
  }

  for (i = 0; i < epi->etl-1; i++) {
    kystep[i] = kystep[i+1] - kystep[i]; /* calculate ky step */
    if (i > 0) {
      /* check that kystep is consistent */
      if (kystep[i] != kystep[0]) {
        ks_error("%s(%s): KS_EPI does not support varying ky step size", __FUNCTION__, phaseenc_plan->description);
        return KS_EPI_NOBLIPS;
      }
    }
  }

  if (kystep[0] < 0) {
    blipsign = KS_EPI_POSBLIPS;
  } else if (kystep[0] > 0) {
    blipsign = KS_EPI_NEGBLIPS;
  }

  return blipsign;
}

ks_scan_epi_shotcontrol()

void ks_scan_epi_shotcontrol	(	KS_EPI *	epi,
		int	echo,
		SCAN_INFO	sliceinfo,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot,
		int	exc,
		float	rcvphase
	)

Changes the gradient state of a KS_EPI object for the given slice information

This function has two different tasks. First, it controls the EPI blips and sets the EPI dephaser and rephaser amplitude given the current phaseshot and blipsign. If phaseshot is outside the valid range ([0, .blipphaser.R-1], all gradient amplitudes on the blip (phase encoding) axis will be zero. This can be useful to acquire a refscan for Nyquist ghost correction. Second, it sets up the proper frequency and phase modulation per readout lobe to produce the desired FOV offset in both the frequency and phase encoding directions

Parameters

[in,out]	epi	Pointer to KS_EPI
[in]	echo	EPI echo index (up to 16 EPI trains supported)
[in]	sliceinfo	SCAN_INFO struct for the current slice to be played out
[in]	phaseenc_plan	Pointer to the phase encoding plan
[in]	shot	Linear ky kz shot index in range [0, (phaseenc_plan.num_shots-1)]
[in]	exc	Zero-based NEX index
[in]	rcvphase	Receiver phase in degrees, for RF spoiling.

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                  {
  float blipampscale = 1.0;
  float yfovratio, zfovratio;
  int i, readindx, blipindx, kyview, kzview;
  int numblips = (epi->etl - 1);
  int isrefscan = (exc < 0);  /* exc < 0 => data acquisition ON, EPI blips OFF (to make RefScan for Nyquist ghost correction) */
  KS_PHASEENCODING_COORD coord = KS_INIT_PHASEENCODING_COORD;

  ks_enum_epiblipsign blipsign = ks_scan_epi_verify_phaseenc_plan(epi, phaseenc_plan, shot);

  if (phaseenc_plan != NULL && (epi->etl != phaseenc_plan->etl)) {
    ks_error("%s(%s): ETL of KS_EPI (%d) and KS_PHASEENCODING_PLAN (%d) do not match", __FUNCTION__, phaseenc_plan->description, epi->etl, phaseenc_plan->etl);
    blipsign = KS_EPI_NOBLIPS;
  }

  if (isrefscan) {
    blipsign = KS_EPI_NOBLIPS;
  }

  /* EPI read & blips for current 'echo' = EPI train. */
  for (i = 0; i < epi->etl; i++) {
    coord = ks_phaseencoding_get(phaseenc_plan, i, shot);
    kyview = (blipsign != KS_EPI_NOBLIPS) ? coord.ky : KS_NOTSET;
    kzview = (blipsign != KS_EPI_NOBLIPS) ? coord.kz : KS_NOTSET;

    if (i == 0) { /* EPI dephaser. From k-space center to this line */
      ks_scan_phaser_toline(&epi->blipphaser, 0 + 2 * echo, kyview); /* KS_NOTSET => zero amplitude */
      if (epi->zphaser.grad.duration > 0) {
        /* 3D epi z dephaser(s) for even instances '2*echo' */
        ks_scan_phaser_toline(&epi->zphaser, 0 + 2 * echo, kzview);
      }
    }
    
    if (i == epi->etl-1) { /* EPI rephaser. From this line to k-space center */
      ks_scan_phaser_fromline(&epi->blipphaser, 1 + 2 * echo, kyview); /* KS_NOTSET => zero amplitude */
      if (epi->zphaser.grad.duration > 0) {
        /* 3D epi z rephaser(s) for odd instances '1+2*echo' */
        ks_scan_phaser_fromline(&epi->zphaser, 1 + 2 * echo, kzview);
      }
    }

    readindx = i + echo * epi->etl; /* ETL# of readouts */
    blipindx = i + echo * numblips;  /* (ETL-1)# of blips */

    if (i < numblips) {
      /* FUTURE: at this point, we could increase/decrease blipampscale for odd/even blips for oblique ghost correction */
      blipampscale = blipsign / epi->blipoversize;
      ks_scan_trap_ampscale(&epi->blip, blipindx, blipampscale);
    }

    /* FOV offsets (by changing freq/phase of epi.read) */
    float ky_centred, kz_centred;
    if (kyview < 0) {
      ky_centred = 0.0f;
    } else {
      ky_centred = (float)kyview - ((epi->blipphaser.res - 1) / 2.0f);
    }
    yfovratio = epi->blipphaser.fov / epi->read.fov;
    if (epi->zphaser.grad.duration > 0) {
      if (kzview < 0) {
        kz_centred = 0.0f;
      } else {
        kz_centred = (float)kzview - ((epi->zphaser.res - 1) / 2.0f);
      }
      zfovratio = epi->zphaser.fov / epi->read.fov;
      ks_scan_offsetfov3D(&epi->read, readindx, sliceinfo, ky_centred, yfovratio, kz_centred, zfovratio, rcvphase);
    } else {
      ks_scan_offsetfov(&epi->read, readindx, sliceinfo, ky_centred, yfovratio, rcvphase);
    }

  } /* for etl */

} /* ks_scan_epi_shotcontrol */

ks_scan_epi_loadecho_with_tag()

void ks_scan_epi_loadecho_with_tag	(	KS_EPI *	epi,
		int	echo,
		int	storeecho,
		int	slice,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot,
		KSEPI_DATATAG *	datatag,
		KS_DATASTORETAG *	datastoretag
	)

Loads the data storage information to hardware for the acquisition windows in a KS_EPI sequence object

This function specifies where to store the data acquired for each readout lobe in the KS_EPI train given current:

• echo: First instance of the KS_EPI train is 0
• slice: Slice index, 0-based
• shot: Linear ky kz shot index in range [0, (phaseenc_plan.num_shots-1)]
• phaseenc_plan: phaseenc_plan Pointer to the phase encoding plan

If shot is outside the valid range, a baseline view (view 0 in loaddab()) will be acquired.

If slice is < 0, data acquisition is turned off in loaddab()

Parameters

[in,out]	epi	Pointer to KS_EPI
[in]	echo	EPI echo index to work on (up to 16 EPI trains supported)
[in]	storeecho	EPI echo index for storing (usually the same as echo)
[in]	slice	Slice index where to store the data (0-based)
[in]	phaseenc_plan	Pointer to the phase encoding plan
[in]	shot	Linear ky kz shot index in range [0, (phaseenc_plan.num_shots-1)]
[in]	datastoretag	Tag (unsigned int) passed to loaddabwithangle(). This can be filled with whatever content to inform recon. Will be a part of each control packet on the recon side.

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                                                           {
  if ((datastoretag != NULL) && (datatag != NULL)) {
    ks_error("%s: either datastoretag or custom_dab_array must be NULL, but both were supplied.", __FUNCTION__);
    return;
  }
  
  int i, readindx;
#ifdef IPG
  int validsliceindx = (slice >= 0 && slice < 2048);
  int validshotindx = (shot >= 0 && (phaseenc_plan == NULL || shot < phaseenc_plan->num_shots));
  KS_PHASEENCODING_COORD coord = KS_INIT_PHASEENCODING_COORD;
  ks_enum_epiblipsign blipsign = ks_scan_epi_verify_phaseenc_plan(epi, phaseenc_plan, shot);
  int centerecho = epi->time2center / epi->read.grad.duration; /* etl index corresponding to k-space center */
  int numplaced = epi->read.acq.base.ngenerated;

  /* 'pscR1' is the R1 receive gain made by prescan */
  int currentR1 = (epi->read.acq.override_R1 > 0 && epi->read.acq.override_R1 <= 11) ? epi->read.acq.override_R1 : pscR1;

  TYPDAB_PACKETS dabacqctrl;
  if (validsliceindx && validshotindx) {
    dabacqctrl = DABON; /* turn receiver on */
  } else {
    dabacqctrl = DABOFF; /* turn receiver off */
    slice = 0; /* necessary? */
  }
#else
  int numplaced = epi->read.acq.base.ninst;
#endif

  if (numplaced == 0) {
    return;
  }
  if (storeecho < 0 || storeecho > 15) {
    ks_error("%s: storeecho must be in range [0:15]", __FUNCTION__);
    return;
  }
  if (echo < 0 || (echo + 1) * epi->etl > numplaced) {
    ks_error("%s: echo (%d) must be in range [0:%d]", __FUNCTION__, echo, numplaced/epi->etl-1);
    return;
  }
  
  for (i = 0; i < epi->etl; i++) {

    readindx = i + echo * epi->etl; /* N.B.: 'echo' is # of EPI trains, not EPI readout lobes (up to 16 possible, set by opnecho) */

    if (readindx >= numplaced) {
      ks_error("%s(%s): Readout lobe index %d has not been placed in PG", __FUNCTION__, epi->read.grad.description, readindx);
      return;
    }

#ifdef IPG
    int kyview = KS_NOTSET;
    if (validshotindx && (blipsign != KS_EPI_NOBLIPS)) {
      coord = ks_phaseencoding_get(phaseenc_plan, i, shot);
      kyview = coord.ky;
      if (rhasset == ASSET_SCAN && epi->blipphaser.R > 1 && epi->blipphaser.nacslines == 0) {
        /* Auto-detect ASSET scan, which uses compressed storage of accelerated data, i.e. only
           storing the acquired lines, without inteleaving with blank unacquired lines */
        if (blipsign == KS_EPI_POSBLIPS) {
          kyview = epi->etl-1 - i;
        } else if (blipsign == KS_EPI_NEGBLIPS) {
          kyview = i;
        }
      }
    }

    if (rspent == L_APS2 || rspent == L_MPS2) {
      /* Prescan (R1 & R2) */
      if (readindx == centerecho && echo == 0) {
        loaddab(&epi->read.acq.echo[readindx], slice, storeecho, DABSTORE, 0, dabacqctrl, PSD_LOAD_DAB_ALL); /* turn on acquisition for center echo of 1st EPI train */
      } else {
        loaddab(&epi->read.acq.echo[readindx], slice, storeecho, DABSTORE, 0, DABOFF, PSD_LOAD_DAB_ALL); /* turn off acquisition for all other lobes (and all later EPI trains) */
      }
    } else {
      if (datastoretag != NULL) {
        /* Storing additional data in the dab pulse, in datastoretag.dab_array is space for up to KS_CUSTOM_DATASTORE_LENGTH byte */
        ks_loaddab_datastoretag(&epi->read.acq.echo[readindx], datastoretag);
      }
      if (datatag != NULL) {
        datatag->readout = i;
        ks_loaddab(&epi->read.acq.echo[readindx], (char*) datatag);
      }
      /* N.B.: kyview = KS_NOTSET (-1) if shot = KS_NOTSET. Hence kyview + 1 = dabview = 0 without phase encodes */      
      loaddab_hub_r1(&epi->read.acq.echo[readindx], slice, storeecho, DABSTORE, kyview + 1 /* GE's views are 1-based */, 0, currentR1, dabacqctrl, PSD_LOAD_DAB_ALL_WITH_HUB_R1);
    }
#endif

  } /* per acq window (readout lobe) */

} /* ks_scan_epi_loadecho_with_tag */

ks_scan_epi_loadecho_with_datastoretag()

void ks_scan_epi_loadecho_with_datastoretag	(	KS_EPI *	epi,
		int	echo,
		int	storeecho,
		int	slice,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot,
		KS_DATASTORETAG *	datastoretag
	)

Wrappers around ks_scan_epi_loadecho_withtag_or_dabarray.

                                                                                                                                                                            {
  ks_scan_epi_loadecho_with_tag(epi, echo, storeecho, slice, phaseenc_plan, shot, NULL, datastoretag);
}

ks_scan_epi_loadecho_with_epidatatag()

void ks_scan_epi_loadecho_with_epidatatag	(	KS_EPI *	epi,
		int	echo,
		int	storeecho,
		int	slice,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot,
		KSEPI_DATATAG *	datatag
	)

                                                                                                                                                                   {
  ks_scan_epi_loadecho_with_tag(epi, echo, storeecho, slice, phaseenc_plan, shot, datatag, NULL);
}

ks_scan_epi_loadecho()

void ks_scan_epi_loadecho	(	KS_EPI *	epi,
		int	echo,
		int	storeecho,
		int	slice,
		KS_PHASEENCODING_PLAN *	phaseenc_plan,
		int	shot
	)

                                                                                                                           {
  ks_scan_epi_loadecho_with_tag(epi, echo, storeecho, slice, phaseenc_plan, shot, NULL, NULL);
}

ks_loaddab()

void ks_loaddab	(	WF_PULSE_ADDR	echo,
		char *	custom_dab_array
	)

                                                            {
  int i;
  static const int dab_indices[KS_CUSTOM_DATASTORE_LENGTH] = {2,3,4,5,6,7,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29};

  for (i=0; i<KS_CUSTOM_DATASTORE_LENGTH; i++){
    short dabbyte = custom_dab_array[i];
#ifdef IPG
    sspload(&dabbyte, echo, dab_indices[i], 1, (HW_DIRECTION)TOHARDWARE, (SSP_S_ATTRIB)SSPS1);
#else
    (void) dabbyte;
    (void) dab_indices;
#endif
  }
}

ks_loaddab_datastoretag()

void ks_loaddab_datastoretag	(	WF_PULSE_ADDR	echo,
		KS_DATASTORETAG *	datastoretag
	)

                                                                                {
  if (datastoretag == NULL) {
    return;
  }

  if (datastoretag->info.load_custom_dab_array == TRUE) {
    /* if the psd provides  */
    if (datastoretag->fill_dab_array_fct != NULL){
      datastoretag->fill_dab_array_fct(datastoretag);
    }
    ks_loaddab(echo, datastoretag->dab_array);
  }
}

ks_scan_acq_to_rtp()

void ks_scan_acq_to_rtp	(	KS_READ *	read,
		TYPDAB_PACKETS	dabacqctrl,
		float	fatoffset
	)

Data routing control for RTP

Parameters

[in,out]	read	Pointer to KS_READ
[in]	dabacqctrl	DABON or DABOFF
[in]	fatoffset	Frequency offset in [Hz] for the current data acquisition window

Returns

void

                                                                                  {
#ifdef IPG

  WF_PULSE *echo_ptr;
  WF_PULSE *xtr_ptr;
  WF_PULSE *rba_ptr;

  int i;
  for (i = 0; i < acq->base.ngenerated; ++i) {
    echo_ptr = &acq->echo[i];
    setrfltrs((int) acq->filt.fslot, echo_ptr);

    getssppulse(&rba_ptr, echo_ptr, "rba", 0);
    getssppulse(&xtr_ptr, echo_ptr, "xtr", 0);
    acqctrl(dabacqctrl, (RECEIVER_SPEED_E)0, rba_ptr);

    setfreqphase((int)(fatoffset / TARDIS_FREQ_RES), /* freq ctrl */
                 0, /* phase ctrl */
                 xtr_ptr);

    /* TODO: Add r1 scaling here! */
    /*if (r1_scale != 1.0 && (rspent==L_SCAN)) {
      newR1 = ceil(pscR1 * r1_scale);
      if (newR1 > 13)
    newR1 = 13;
      else if (newR1 < 1)
    newR1 = 1;

      loaddab_hub_r1(echo_ptr, dabslice, dabecho, DABSTORE, dabview, 0, newR1, dabacqctrl, PSD_LOAD_DAB_ALL | PSD_LOAD_DAB_R1);
      }*/ /* if R1 change */
    routeDataFrameDab(echo_ptr, ROUTE_TO_RTP, cfcoilswitchmethod);
  }

#endif

}

boffset()

STATUS boffset

(

long *

offsets

)

ks_scan_switch_to_sequence()

void ks_scan_switch_to_sequence

(

KS_SEQ_CONTROL *

ctrl

)

                                                      {
#ifdef IPG
  if (ctrl->duration > 0) {
    boffset(ctrl->handle.offset);
  }
#endif
}

setssitime()

STATUS setssitime

(

long

)

startseq()

STATUS startseq	(	s16	,
		s16
	)

ks_scan_playsequence()

int ks_scan_playsequence

(

KS_SEQ_CONTROL *

ctrl

)

                                               {

  if (ctrl->duration > 0) {

#ifdef IPG
    {
      ks_scan_switch_to_sequence(ctrl);
      setssitime(ctrl->ssi_time / cfhwgut);
      startseq(0, (short) MAY_PAUSE); /* play out the sequence in real time */
    }
#else
    /* HOST */
    ctrl->nseqinstances++;
#endif
  } /* ctrl->duration > 0 */

  return ctrl->duration;
}

ks_scan_loaddabwithindices_nex()

STATUS ks_scan_loaddabwithindices_nex	(	WF_PULSE_ADDR	pulse,
		LONG	slice,
		LONG	echo,
		LONG	view,
		uint8_t	acq,
		uint8_t	vol,
		LONG	operation,
		TYPDAB_PACKETS	acqon_flag
	)

loaddab() with extra arguments for current acquisition and image volume and current excitation (NEX)

Parameters

[in]	pulse	Pointer to WF_PULSE in a KS_READ
[in]	slice	0-based temporal slice index (2D) or kz encoding step typically (3D)
[in]	echo	0-based echo in the echo train
[in]	view	1-based ky view number
[in]	acq	0-based acquisition index (always 0 if all slices fit in one TR)
[in]	vol	0-based volume index (always 0 if only one volume)
[in]	operation	DABSTORE, DABADD (for 2nd to last excitation)
[in]	acqon_flag	DABON or DABOFF

Return values

STATUS

SUCCESS or FAILURE

                                                             {

  union Indices idx;
  idx.c[0] = acq;
  idx.c[1] = vol;
  return loaddabwithangle(pulse, idx.i, slice, echo, operation, view, acqon_flag, PSD_LOAD_DAB_ALL);
}

ks_scan_loaddabwithindices()

STATUS ks_scan_loaddabwithindices	(	WF_PULSE_ADDR	pulse,
		LONG	slice,
		LONG	echo,
		LONG	view,
		uint8_t	acq,
		uint8_t	vol,
		TYPDAB_PACKETS	acqon_flag
	)

loaddab() with extra arguments for current acquisition and image volume

Parameters

[in]	pulse	Pointer to WF_PULSE in a KS_READ
[in]	slice	0-based temporal slice index (2D) or kz encoding step typically (3D)
[in]	echo	0-based echo in the echo train
[in]	view	1-based ky view number
[in]	acq	0-based acquisition index (always 0 if all slices fit in one TR)
[in]	vol	0-based volume index (always 0 if only one volume)
[in]	acqon_flag	DABON or DABOFF

Return values

STATUS

SUCCESS or FAILURE

                                                             {
  return ks_scan_loaddabwithindices_nex(pulse, slice, echo, view, acq, vol, DABSTORE, acqon_flag);
}

ks_scan_wait_for_rtp()

int ks_scan_wait_for_rtp	(	void *	rtpmsg,
		int	maxmsgsize,
		int	maxwait,
		KS_SEQ_CONTROL *	waitctrl
	)

play a wait sequence in a loop untill a RTP message is received.

Parameters

[out]	rtpmsg	pointer to memory that will be filled by the RTP message
[in]	maxmsgsize	size in bytes of the memory pointed by rtpmsg
[in]	maxwait	timing out period in [ms]
[in]	waitctrl	pointer to the KS_SEQ_CONTROL of a wait sequence. If NULL, the provided maxwait is ignored and a value of zero used instead.

Return values

size	of the received message, zero if timed out

                                                                                              {
  int maxplayouts;
  int nBytes = 0;
  int i;
  n32 packed = 1;
#ifdef IPG
  setscantimestop();
#endif

  maxplayouts =  waitctrl ? maxwait / waitctrl->duration : 0;
  if (maxplayouts < 1) {
    waitctrl = NULL;
    maxplayouts = 0;
  }

  for (i = 0; i <= maxplayouts; i++) {

#ifdef IPG
    if (i != 0 && waitctrl) {
      ks_scan_playsequence(waitctrl);
    }
#endif

    nBytes = 0;

#if defined(MGD_TGT) && defined(PSD_HW)


  nBytes = rtp_get_feedback_data(rtpmsg, maxmsgsize, &packed, 2, RTP_QUEUE_NEWEST);  /*according to RTP_RESULT_PROMO=2, defined in lx/include/PromoCommon.h*/


#endif

    if (nBytes>0 && !packed) {
      break;
    }
  }

#ifdef IPG
  setscantimestart();
#endif

  return nBytes;
}

ks_copy_and_reset_obj()

void ks_copy_and_reset_obj

(

void *

pobj

)

Create a copy of any sequence object with a KS_BASE as first member

Create a copy of the object pointed by pobj and insert it into the linked list in second position. finally reset the (base part of) original object.

It is required that pobj can be casted to (KS_BASE *), which is the pointed object should have a KS_BASE as first member. Note that other, object-specific, actions may need to be performed to finalize the reset. This includes calls to ks_instancereset_***() functions on each member of the current pobj

Parameters

[in]

pobj

Pointer to a sequence object of some kind

Returns

void

                                       {

  KS_BASE *head = (KS_BASE*) pobj;

  /* create a copy */
  KS_BASE *copy = (KS_BASE*) AllocNode(head->size);
  memcpy(copy, head, head->size);

  /* link to the copy */
  head->next = copy;

  /* reset the count of generated instances */
  head->ngenerated = 0;
}

ks_tgt_reset_gradrfctrl()

void ks_tgt_reset_gradrfctrl

(

KS_GRADRFCTRL *

gradrfctrl

)

Clears KS_GRADRFCTRL on TGT. Called in ks_pg_trap, ks_pg_wave, and ks_pg_rf if the field is_cleared_on_tgt is false.

Parameters

gradrfctrl

[pointer to KS_GRADRFCTRL]

                                                        {
  int i = 0;
  for (i = 0; i < gradrfctrl->numrf; ++i) {
    gradrfctrl->rfptr[i] = NULL;
  }
  for (i = 0; i < gradrfctrl->numtrap; ++i) {
    gradrfctrl->trapptr[i] = NULL;
  }
  for (i = 0; i < gradrfctrl->numwave; ++i) {
    gradrfctrl->waveptr[i] = NULL;
  }
  for (i = 0; i < gradrfctrl->numacq; ++i) {
    gradrfctrl->readptr[i] = NULL;
  }
  gradrfctrl->numrf = 0;
  gradrfctrl->numtrap = 0;
  gradrfctrl->numwave = 0;
  gradrfctrl->numacq = 0;
  gradrfctrl->is_cleared_on_tgt = TRUE;
}

ks_show_clock()

void ks_show_clock

(

FLOAT

scantime

)

Show the clock in the UI with the remaining scan time

                                   {
#ifdef IPG
  setscantimestop();
  setscantimeimm(PSD_CLOCK_NORM, (float)scantime, piviews, (float)pitslice, opslicecnt);
  setscantimestart();
#endif
}

acqq_longdab()

STATUS acqq_longdab	(	WF_PULSE_ADDR	pulse,
		LONG	pos_ref,
		LONG	dab_ref,
		LONG	xtr_ref,
		LONG	fslot_value
	)

{
    static const CHAR *routine = "acqq_longdab";
    CHAR *basename = NULL;
    INT start;                   /* Start of the pulse */
    WF_PULSE_ADDR newpulse;      /* Pointer to new pulse */
    INT pack_ix = 0;           /* CERD change */
    INT LONG_DAB_length = 31; /* Maximum is 31, hardware limitation */
    SHORT LONG_DAB_bits[31]; /* Maximum is 31, hardware limitation */
#ifdef PGEN_TIMING
    extern INT time_pgen;
    if (time_pgen == 1) {
        start_timer(&_PGEN_start_time);
    }
#endif

    pack_ix = PSD_XCVR2;

#ifdef SIM_IO
    if (psdtrace3)
    {
        CHAR tmpname[50];
        if (pulse->pulsename == NULL)
            strcpy(tmpname,"");
        else
            strcpy(tmpname,pulse->pulsename);

        fprintf(stderr,"%s  pulse: %s  posref %d xtrref %d dabref %d fslot %d\n",
                routine,
                tmpname,
                pos_ref,
                xtr_ref,
                dab_ref,
                fslot_value);
        fflush(stderr);
    }
#endif

    LONG_DAB_bits[0] = SSPDS + DABDC;        /* CAPM , CERD change: new opcode */
    LONG_DAB_bits[1] = SSPOC + DXCT;         /* Excitation , CERD change: ew opcode */
    LONG_DAB_bits[2] = SSPD;
    LONG_DAB_bits[3] = SSPD;
    LONG_DAB_bits[4] = SSPD;
    LONG_DAB_bits[5] = SSPD;
    LONG_DAB_bits[6] = SSPD;
    LONG_DAB_bits[7] = SSPD + DABIS; /* if DABIS is really needed is unclear, we leave it for the moment */
    LONG_DAB_bits[8] = SSPD;
    LONG_DAB_bits[9] = SSPD;
    LONG_DAB_bits[10] = SSPD;
    LONG_DAB_bits[11] = SSPD;
    LONG_DAB_bits[12] = SSPD;
    LONG_DAB_bits[13] = SSPD;
    LONG_DAB_bits[14] = SSPD;
    LONG_DAB_bits[15] = SSPD;
    LONG_DAB_bits[16] = SSPD;
    LONG_DAB_bits[17] = SSPD;
    LONG_DAB_bits[18] = SSPD;
    LONG_DAB_bits[19] = SSPD;
    LONG_DAB_bits[20] = SSPD;
    LONG_DAB_bits[21] = SSPD;
    LONG_DAB_bits[22] = SSPD;
    LONG_DAB_bits[23] = SSPD;
    LONG_DAB_bits[24] = SSPD;
    LONG_DAB_bits[25] = SSPD;
    LONG_DAB_bits[26] = SSPD;
    LONG_DAB_bits[27] = SSPD;
    LONG_DAB_bits[28] = SSPD;
    LONG_DAB_bits[29] = SSPD;
    LONG_DAB_bits[30] = SSPDS; /* Last field must be SSPDS, max number of fields = 31 */

    /* Make sure packets are ordered properly (dab->xtr->rba) and that
       the dab packet doesn't collide with xtr packet. */
    if ((dab_ref != DEFAULTPOS) && (xtr_ref != DEFAULTPOS) &&
        (dab_ref + LONG_DAB_length > xtr_ref))
        MsgHndlr(routine, 
                 MSG_PULSE, pulse,
                 MSG_FORMAT,
                 CODING_PBM, 
                 EMT_INVLD_INSTR_START, 
                 dab_ref);

    /* Make sure there is enough room for xtr packet */
    if ((xtr_ref != DEFAULTPOS) &&
        (pos_ref - xtr_ref < (XTR_length[pack_ix] + RBA_length[pack_ix])))
        MsgHndlr(routine, 
                 MSG_PULSE, pulse,
                 MSG_FORMAT,
                 CODING_PBM, 
                 EMT_INVLD_INSTR_START, 
                 xtr_ref);

    if ((xtr_ref == DEFAULTPOS) && (RBA_length[pack_ix] > XTRSETLNG))
        MsgHndlr(routine, 
                 MSG_PULSE, pulse,
                 MSG_FORMAT,
                 CODING_PBM, 
                 EMT_INVLD_INSTR_START, 
                 pos_ref);

    /* This routine assumes that the user has created the
     *  the pulse passed into this routine with the pre-processor
     */

    /***** The bits will be created first ****/
    /* The first thing this routine will do will be to verify if
     *  any bits have been created or no.
     */

    if (pulse-> ninsts == 0)
    {

        /***************************************/
        /**** Create DAB 'bits' Pulse **********/
        /***************************************/

        if (!(basename = (CHAR *)AllocNode(strlen(pulse->  pulsename)+1)))
        {
            MsgHndlr(routine,  MSG_FORMAT, HARDWARE_PBM,
                     EMT_ALLOC, pulse->  pulsename);
        }
        strcpy(basename, pulse-> pulsename);

        char* dabname = (char *)AllocNode(strlen(basename)+4);
        /* Create Name For Pulse */
        if (!dabname)
        {
            MsgHndlr(routine, MSG_PULSE, pulse, 
                     MSG_FORMAT, HARDWARE_PBM,
                     EMT_ALLOC, "DAB Bits Pulse Name");
        }

        /* Append "dab" suffix for loaddab... routines */
        sprintf(dabname,"%sdab",basename);
        pulse-> pulsename = dabname;

        createbits(pulse, (WF_PROCESSOR)TYPSSP,
                   LONG_DAB_length,
                   LONG_DAB_bits);

        /***************************************/
        /**** Create XTR 'bits' Pulse **********/
        /***************************************/

        if (!(newpulse = (WF_PULSE *)AllocNode(sizeof(WF_PULSE))))
        {

            MsgHndlr(routine, MSG_FORMAT,
                     HARDWARE_PBM, EMT_ALLOC, "Receive Bits");

        }

        char* xtrname = (char *)AllocNode(strlen(basename)+4);
        /* Create Name For Pulse */
        if (!xtrname)
        {
            MsgHndlr(routine, MSG_PULSE, pulse,
                     MSG_FORMAT, 
                     HARDWARE_PBM,
                     EMT_ALLOC, 
                     "Xtr Bits Pulse Name"); 
        }

        /* Attach to dab pulse */
        pulse-> assoc_pulse = newpulse;

        /* Append xtr for use by other routines */
        sprintf(xtrname,"%sxtr",basename);
        newpulse-> pulsename = xtrname;

        /* Verify the parameters for the pulse */

        /* Begin LxMGD - RJF 12/6/00 */

        /* For MGD, there is a maximum of 8 filters with slot numbers 0 thru 7. 
           The filter block is terminated with a slot number of -1.
           So the valid filter slots are from 0 to 7 - RJF */

        if ((fslot_value < MIN_FILTER_SLOT) || (fslot_value > MAX_FILTER_SLOT) )
        {
            MsgHndlr(routine,
                     MSG_PULSE, newpulse,
                     MSG_FORMAT,
                     CODING_PBM,
                     EMT_DAB_SLOT_NO,
                     fslot_value);
        }

        /* Begin LxMGD - RJF, 12/6/00 */
        /*   The way XTR bits was set up for CERD was wrong 
             (see sspinit.c, which initializes the 
             packet.) The receiver values should have been at offset 10
             and the filter slot value should be at offset 11. */

        XTR_bits[pack_ix][10] = SSPOC + RFLTRS;
        XTR_bits[pack_ix][11] = SSPD + fslot_value;

        /* End CERD change */

        /* Insert EOS */
        XTR_bits[pack_ix][XTR_length[pack_ix]-1] = SSPDS;

        createbits(newpulse, 
                   (WF_PROCESSOR)TYPSSP,  
                   XTR_length[pack_ix], 
                   XTR_bits[pack_ix]);


        /*************************************/
        /**** Create Receive 'bits' Pulse ****/
        /*************************************/

        if (!(newpulse = (WF_PULSE *)AllocNode(sizeof(WF_PULSE))))
        {

            MsgHndlr(routine, MSG_FORMAT,
                     HARDWARE_PBM, EMT_ALLOC, "Receive Bits");

        }

        char* rbaname = (char *)AllocNode(strlen(basename)+4);
        /* Create Name For Pulse */
        if (!rbaname)
        {
            MsgHndlr(routine, MSG_PULSE, pulse,
                     MSG_FORMAT, 
                     HARDWARE_PBM,
                     EMT_ALLOC, 
                     "Receive Bits Pulse Name");
        }
        sprintf(rbaname,"%srba",basename);
        newpulse-> pulsename = rbaname;

        /* Attach to exciter pulse */
        pulse-> assoc_pulse -> assoc_pulse = newpulse;


        createbits(newpulse, 
                   (WF_PROCESSOR)TYPSSP,  
                   RBA_length[pack_ix], 
                   RBA_bits[pack_ix]);
        /* End CERD change */

    }

    /********** End of creating bits *******************/

    /***************************************/
    /**** Create XTR Instruction ***********/
    /***************************************/

    /* Back off for settling time of exciter */
    if (xtr_ref == DEFAULTPOS) {
        start = pos_ref - (XTRSETLNG + XTR_length[pack_ix]); 
    } else {
        start = xtr_ref;
    }
    createinstr(pulse -> assoc_pulse,
                start,
                XTR_length[pack_ix],
                0);

    pulse->assoc_pulse-> tag = SSPXTR;

    /***************************************/
    /**** Create DAB Instruction ***********/
    /***************************************/
    /* The DAB needs at least DABSETUP set-up time. */
    if (dab_ref == DEFAULTPOS) {
        if (xtr_ref == DEFAULTPOS) {
            start = pos_ref - IMax(2, DABSETUP, 
                                   XTRSETLNG + XTR_length[pack_ix] + LONG_DAB_length);
        } else {
            start = IMin(2, pos_ref-DABSETUP,xtr_ref-LONG_DAB_length);
        }

    } else {
        start = dab_ref;
    }

    /* For DAB packet */
    createinstr(pulse, start, LONG_DAB_length, 0);

    pulse->tag = SSPDAB;

    /***************************************/
    /**** Create RBA Instruction ***********/
    /***************************************/
    /* Back off by length of RBA packet */

    start = pos_ref - RBA_length[pack_ix];

    createinstr(pulse -> assoc_pulse -> assoc_pulse, 
                start + RBA_start, 
                RBA_length[pack_ix], 
                0);

    pulse-> assoc_pulse-> assoc_pulse-> tag = SSPRBA;
    /* End of CERD change */  
    FreeNode(basename);   /* Arg must be a LONG  : pradeep */
#ifdef PGEN_TIMING
    if (time_pgen == 1) {

        end_timer(_PGEN_start_time,acqq_ix,"acqq");

    }
#endif

    return SUCCESS;
}

Variable Documentation

GAM

float GAM

cfreceiveroffsetfreq

int cfreceiveroffsetfreq

rspent

int rspent

pscR1

int pscR1

cfcoilswitchmethod

int cfcoilswitchmethod

cfswgut

int cfswgut

cfswrfut

int cfswrfut

rhasset

int rhasset

cfhwgut

int cfhwgut

piviews

int piviews

opslicecnt

int opslicecnt