GERequired.e File Reference

#include "grad_rf_empty.globals.h"
#include "em_psd_ermes.in"
#include "stddef_ep.h"
#include "epicconf.h"
#include "pulsegen.h"
#include "epic_error.h"
#include "epic_loadcvs.h"
#include "InitAdvisories.h"
#include "psdiopt.h"
#include "filter.h"
#include "epicfuns.h"
#include <sokPortable.h>
#include "KSFoundation.h"
#include <psd_proto.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sar_pm.h"
#include "grad_rf_empty.h"
#include <sysDep.h>
#include <sysDepSupport.h>
#include <support_func.h>
#include <math.h>
#include "psdopt.h"
#include "predownload.in"
#include "cvinit.in"
#include <support_func.host.h>

Data Structures
struct	ks_kacq_coord_params_t

Macros
#define	seq_name   ]_set
#define	GEREQUIRED_E
#define	CLINICAL_MODE   0
#define	MAX_ENTRY_POINTS   15
#define	MAX_SEQMODULES_DURATION_DEVIATION_FRACTION   0.0001
#define	DEFAULT_SCAN_INFO_HEAD   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0
#define	DEFAULT_AXIAL_SCAN_INFO
#define	DEFAULT_AX_SCAN_INFO_FREQ_LR   DEFAULT_AXIAL_SCAN_INFO
#define	DEFAULT_AX_SCAN_INFO_FREQ_AP
#define	DEFAULT_SAG_SCAN_INFO_FREQ_SI
#define	DEFAULT_SAG_SCAN_INFO_FREQ_AP
#define	DEFAULT_COR_SCAN_INFO_FREQ_SI
#define	DEFAULT_COR_SCAN_INFO_FREQ_LR
#define	KS_PSD_USE_APX   0

Typedefs
typedef int	bool

Functions
	KS_SEQLENGTH (seq_name, seq_struct)
STATUS	calcPulseParams (int p)
STATUS	simscan (void)
STATUS	GEReq_init_gradspecs (LOG_GRAD *loggrd, PHYS_GRAD *phygrd, float srfact)
STATUS	GEReq_init_accelUI (int integeraccel, int maxaccel)
STATUS	GEReq_eval_TRrange (int *slperpass, int *timetoadd_perTR, int requested_minacqs, int mintr, int maxtr, KS_SEQ_COLLECTION *seqcollection, int(*play_loop)(int, int, void **), int nargs, void **args)
STATUS	GEReq_eval_TR (int *slperpass, int *timetoadd_perTR, int requested_minacqs, KS_SEQ_COLLECTION *seqcollection, int(*play_loop)(int, int, void **), int nargs, void **args)
STATUS	GEReq_eval_rfscaling (KS_SEQ_COLLECTION *seqcollection)
STATUS	GEReq_eval_checkTR_SAR_calcs (KS_SEQ_COLLECTION *seqcollection, s64 intended_time)
STATUS	GEReq_eval_checkTR_SAR (KS_SEQ_COLLECTION *seqcollection, int nslices, int(*play_loop)(int, int, void **), int nargs, void **args)
STATUS	GEReq_predownload_store_sliceplan (KS_SLICE_PLAN slice_plan)
STATUS	GEReq_predownload_store_sliceplan_sms (const KS_SLICE_PLAN slice_plan, int sms_factor)
STATUS	GEReq_predownload_store_sliceplan3D (int slices_in_slab, int slabs)
STATUS	GEReq_predownload_setfilter_or_find_equivalent (FILTER_INFO *myfilter, FILTER_BLOCK_TYPE type)
int	GEReq_get_num_used_slots ()
PSD_FILTER_GEN	GEReq_get_maxsize_finfo (int n_prescan_slots)
STATUS	GEReq_predownload_setfilter (FILTER_INFO *filt)
STATUS	GEReq_echotrain_setfilters (KS_ECHOTRAIN *const echotrain)
STATUS	GEReq_predownload_minimize_ps_filter_slots ()
STATUS	GEReq_setfilters (KS_SEQ_COLLECTION *const seq_collection)
STATUS	GEReq_predownload_genVRGF (const KS_READTRAP *const readtrap)
STATUS	GEReq_predownload_genrowflip (KS_EPI *epi, int blipsign, int assetflag, int dorowflip)
STATUS	GEReq_predownload_setrecon_writekacq (const KS_READTRAP *const readtrap, const KS_PHASER *const phaser, const KS_PHASER *const zphaser)
int	ks_get_unique_y_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_unique_z_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_ynover_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_znover_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_ry_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_rz_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_cal_z_from_pecoords (const KS_KSPACE_ACQ *kacq)
int	ks_get_cal_y_from_pecoords (const KS_KSPACE_ACQ *kacq)
ks_kacq_coord_params_t	GEReq_kacq_get_params (const KS_KSPACE_ACQ *kacq)
STATUS	GEReq_writekacq (const int nrecon_schedule_entries, KS_KACQ_RECONSHEDULE_ENTRY *recon_schedule, const int num_patterns, const KS_KSPACE_ACQ *ks_kacq)
STATUS	GEReq_writekacq_from_coords (const KS_KSPACE_ACQ *kacq, const int nechoes)
STATUS	GEReq_predownload_setrecon_accel_from_coords (const KS_KSPACE_ACQ *kacq, const int is_pf_y, const int nechoes)
STATUS	GEReq_predownload_setrecon_accel (const KS_READTRAP *const readtrap, const KS_PHASER *const phaser, const KS_PHASER *const zphaser, int datadestination)
void	GEReq_predownload_setrecon_phase (const KS_PHASER *const phaser, const float readfov, const int datadestination)
void	GEReq_predownload_setrecon_readwave (const KS_READWAVE *const readwave, const int yres, const int xres, int imsize_policy, int datadestination)
void	GEReq_predownload_setrecon_image (const int xres, const int yres, const float xfov, const float yfov, const ks_enum_imsize imsize_policy)
void	GEReq_predownload_setrecon_readtrap (const KS_READTRAP *const readtrap, int datadestination)
void	GEReq_predownload_setrecon_readphase (const KS_READTRAP *const readtrap, const KS_PHASER *const phaser, const KS_PHASER *const zphaser, int imsize_policy, int datadestination)
void	GEReq_predownload_setrecon_annotations (int tsp, int readdur, int time2center, int echogap)
void	GEReq_predownload_setrecon_annotations_readtrap (KS_READTRAP *readtrap, int echogap)
void	GEReq_predownload_setrecon_annotations_readwave (KS_READWAVE *readwave, int echogap)
void	GEReq_predownload_setrecon_annotations_epi (KS_EPI *epi, int echogap)
void	GEReq_predownload_setrecon_voldata (int numvols, const KS_SLICE_PLAN slice_plan)
STATUS	GEReq_predownload_setrecon_epi (KS_EPI *epi, int numvols2store, const KS_SLICE_PLAN slice_plan, int echogap, int blipsign, int datadestination, int multishotflag, int staticghostcal, int imsize_policy)
STATUS	GEReq_predownload_prescan_options (RG_CAL_MODE_E rg_cal_mode)
STATUS	GEReq_cvinit (void)
STATUS	GEReq_cveval (void)
void	getAPxParam (optval *min, optval *max, optdelta *delta, optfix *fix, float coverage, int algorithm)
int	getAPxAlgorithm (optparam *optflag, int *algorithm)
STATUS	GEReq_cvcheck (void)
STATUS	GEReq_predownload (void)
void	GEReq_pulsegenBegin (void)
void	GEReq_pulsegenEnd (void)
int	GEReq_endofpass ()
int	GEReq_endofscan ()
int	GEReq_endofpassandscan ()
void	dummylinks (void)
void	GEReq_initRSP (void)

Variables
RF_PULSE_INFO	rfpulseInfo [RF_FREE] = { {0, 0} }
int	avail_image_time
ifndef ACT_TR_EXISTS int	act_tr
endif SCAN_INFO	ks_scan_info [SLTAB_MAX] = {DEFAULT_AXIAL_SCAN_INFO}
KS_SLICE_PLAN	ks_slice_plan = KS_INIT_SLICEPLAN
int	ks_sarcheckdone = FALSE
char	ks_psdname [256]
int	ks_perform_slicetimeplot = FALSE
KS_SEQ_CONTROL	seqctrl_passpack = KS_INIT_SEQ_CONTROL
int	obl_debug = 0 with {0, 1, 0, INVIS, "On(=1) to print messages for obloptimize",}
int	obl_method = PSD_OBL_OPTIMAL with {PSD_OBL_RESTRICT, PSD_OBL_OPTIMAL, PSD_OBL_OPTIMAL, INVIS, "On(=1) to optimize the targets based on actual rotation matrices",}
int	filter_echo1 = 0 with {, , , INVIS, "Scan filter slot number needed for prescan",}
int	pw_passpacket = 50ms with {10ms, 1000ms, 50ms, VIS, "Duration of the passpacket sequence",}
int	ks_rfconf = ENBL_RHO1 + ENBL_THETA + ENBL_OMEGA + ENBL_OMEGA_FREQ_XTR1
int	ks_simscan = 1 with {0, 1, 1, VIS, "Simulate slice locations if 1 (and in simulation)",}
float	ks_srfact = 1.0 with {0.01, 3.0, 1.0, VIS, "Slewrate factor (low value = slower gradients)",}
float	ks_qfact = 1.0 with {0.1, 40.0, 1.0, VIS, "Quietness factor",}
int	ks_plot_filefmt = KS_PLOT_MAKEPNG with {KS_PLOT_OFF,KS_PLOT_MAKEPNG,KS_PLOT_MAKEPNG, VIS, "Plot format 0:off 1:PDF 2:SVG 3:PNG"}
int	ks_plot_kstmp = FALSE with {FALSE,TRUE,FALSE, VIS, "0: off 1:Copy plots to mrraw/kstmp"}
int	ks_compress_ps_filter_slots = FALSE with {FALSE,TRUE,FALSE, VIS, "Minimize the number of filterslots for prescan"}
int	ks_clinicalmode = CLINICAL_MODE with {0, 1, CLINICAL_MODE, VIS, "Clinical mode: on=1 / off=0"}
float	maxB1 [MAX_ENTRY_POINTS]
float	maxB1Seq
short	debugstate
short	viewtable [513]
PSD_EXIT_ARG	psdexitarg
int	rspent
int	rspdda
int	rspbas
int	rspvus
int	rspgy1
int	rspasl
int	rspesl
int	rspchp
int	rspnex
int	rspslq
int	rspsct
int	rsprep
short	chopamp
int	seqCount
int	view
int	excitation
int	debug
const CHAR *	entry_name_list [ENTRY_POINT_MAX]

Detailed Description

This file has several sections that should be @inline'd for a main pulse sequence

written entirely in KSFoundation EPIC. See instructions for each section on where to @inline

Macro Definition Documentation

seq_name

#define seq_name   ]_set

GEREQUIRED_E

#define GEREQUIRED_E

CLINICAL_MODE

#define CLINICAL_MODE   0

MAX_ENTRY_POINTS

#define MAX_ENTRY_POINTS   15

MAX_SEQMODULES_DURATION_DEVIATION_FRACTION

#define MAX_SEQMODULES_DURATION_DEVIATION_FRACTION   0.0001

DEFAULT_SCAN_INFO_HEAD

#define DEFAULT_SCAN_INFO_HEAD   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0

DEFAULT_AXIAL_SCAN_INFO

#define DEFAULT_AXIAL_SCAN_INFO

Value:

{ DEFAULT_SCAN_INFO_HEAD, {1.0, 0.0, 0.0, \
                                                           0.0, 1.0, 0.0, \
                                                           0.0, 0.0, 1.0}}

DEFAULT_AX_SCAN_INFO_FREQ_LR

#define DEFAULT_AX_SCAN_INFO_FREQ_LR   DEFAULT_AXIAL_SCAN_INFO

DEFAULT_AX_SCAN_INFO_FREQ_AP

#define DEFAULT_AX_SCAN_INFO_FREQ_AP

Value:

{ DEFAULT_SCAN_INFO_HEAD, {0.0, 1.0, 0.0, \
                                                               -1.0, 0.0, 0.0, \
                                                                0.0, 0.0, 1.0}}

DEFAULT_SAG_SCAN_INFO_FREQ_SI

#define DEFAULT_SAG_SCAN_INFO_FREQ_SI

Value:

{ DEFAULT_SCAN_INFO_HEAD, {0.0, 0.0, 1.0, \
                                                                 0.0, 1.0, 0.0, \
                                                                -1.0, 0.0, 0.0}}

DEFAULT_SAG_SCAN_INFO_FREQ_AP

#define DEFAULT_SAG_SCAN_INFO_FREQ_AP

Value:

{ DEFAULT_SCAN_INFO_HEAD, {0.0, 0.0, 1.0, \
                                                                 1.0, 0.0, 0.0, \
                                                                 0.0, 1.0, 0.0}}

DEFAULT_COR_SCAN_INFO_FREQ_SI

#define DEFAULT_COR_SCAN_INFO_FREQ_SI

Value:

{ DEFAULT_SCAN_INFO_HEAD, {0.0, 1.0, 0.0, \
                                                                 0.0, 0.0, 1.0, \
                                                                 1.0, 0.0, 0.0}}

DEFAULT_COR_SCAN_INFO_FREQ_LR

#define DEFAULT_COR_SCAN_INFO_FREQ_LR

Value:

{ DEFAULT_SCAN_INFO_HEAD, {-1.0, 0.0, 0.0, \
                                                                  0.0, 0.0, 1.0, \
                                                                  0.0, 1.0, 0.0}}

KS_PSD_USE_APX

#define KS_PSD_USE_APX   0

Typedef Documentation

bool

typedef int bool

Function Documentation

KS_SEQLENGTH()

KS_SEQLENGTH	(	seq_name	,
		seq_struct
	)

Creates a hardware sequence for the current sequence module

This EPIC macro is adapted from GE's EPIC macro SEQLENGTH. The seqctrl (KS_SEQ_CONTROL) struct for the current sequence module is passed in as the second argument to this function, where seqctrl.duration holds the information on the duration of the sequence module and passed on to createseq(). During scanning, ks_scan_playsequence(), which takes a KS_SEQ_CONTROL struct as input, internally calls boffset() to make a real-time hardware switch to this sequence module by passing in seqctrl.handle.offset set by KS_SEQLENGTH().

KS_SEQLENGTH() must be called in pulsegen() after the sequence (module) has been layed out using various ks_pg_*** calls. It must also be after GEReq_pulsegenBegin() and before GEReq_pulsegenEnd() and buildinstr(). The first argument to KS_SEQLENGTH() is GE's name of the pulse sequence module, which by convention usually begins with "seq***". The hardware sequence handle is then named off_seq*** and this handle is stored in seqctrl.handle.offset.

EPIC macro Parameters

• arg 1: Name of the sequence module (only used for this function call)
• arg 2: The KS_SEQ_CONTROL struct for the current sequence module

                                   {

  var: {
  #ifndef $[seq_name]_set
  #define $[seq_name]_set
  #else
  #error KS_SEQLENGTH: Sequence name $[seq_name] (arg 1) already taken
  #endif
      SEQUENCE_ENTRIES  off_$[seq_name];
      WF_PULSE $[seq_name];
  #if defined(HOST_TGT)
      int idx_$[seq_name];   /* sequence entry index */
  #endif
    }
  insert: predownload => {
    /* dont indent the closing bracket */
}
  insert: cvinit => {
    /* dont indent the closing bracket */
}

  subst: {
      {
        if ($[seq_struct].duration > 0) {

          if ($[seq_struct].duration - $[seq_struct].ssi_time < 0) {

            ks_error("KS_SEQLENGTH (%s): (.duration - .ssi_time) is negative", $[seq_struct].description);

          } else {

            STATUS status = pulsename(&$[seq_name], "$[seq_name]");
            if (status != SUCCESS) {
              ks_error("KS_SEQLENGTH (%s): pulsename($[seq_name]) failed", $[seq_struct].description);
            }  
            status = createseq(&$[seq_name], $[seq_struct].duration - $[seq_struct].ssi_time, off_$[seq_name]);
            if (status != SUCCESS) {
              ks_error("KS_SEQLENGTH (%s): createseq($[seq_name]) failed", $[seq_struct].description);
            } 

  #if defined(HOST_TGT)
            /* Update sequence counter and get current sequence entry index */
            status = updateIndex( &idx_$[seq_name] );
            if (status != SUCCESS) {
              ks_error("KS_SEQLENGTH (%s): updateIndex($[seq_name]) failed", $[seq_struct].description);
            }
            printDebug( DBLEVEL1, (dbLevel_t)seg_debug, "KS_SEQLENGTH",
                        "idx_$[seq_name] = %d\n", idx_$[seq_name] );
            $[seq_struct].handle.index = idx_$[seq_name];
  #endif
            /* copy seqyence_enties to the KS_SEQ seq_struct */
            $[seq_struct].handle.offset = off_$[seq_name];
            $[seq_struct].handle.pulse = &$[seq_name];
          } /* duration - ssi_time > 0 */

        } /* duration > 0 */
      }
    }

}

calcPulseParams()

STATUS calcPulseParams

(

int

p

)

Mandatory GE function. Includes predownload.in

Return values

STATUS

SUCCESS or FAILURE

                              {

#include "predownload.in" /* include 'canned' predownload code */
  p = 0;
  return SUCCESS;

} /* calcPulseParams() */

simscan()

STATUS simscan

(

void

)

Simulate scan locations in simulation (WTools)

Return values

STATUS

SUCCESS or FAILURE

                     {

#ifndef PSD_HW

  int i, j;
  int num_slice;
  float z_delta;    /* change in z_loc between slices */
  float r_delta;    /* change in r_loc between slices */
  double alpha, beta, gamma; /* rotation angles about x, y, z respectively */

  num_slice = opslquant;

  r_delta = opfov / num_slice;
  z_delta = opslthick + opslspace;

  ks_scan_info[0].optloc = - 0.5 * z_delta * (num_slice - 1);
  ks_scan_info[0].oprloc = 0;

  for (i = 1; i < 9; i++)
    ks_scan_info[0].oprot[i] = 0.0;

  switch (exist(opplane)) {
  case PSD_AXIAL:
    ks_scan_info[0].oprot[0] = 1.0;
    ks_scan_info[0].oprot[4] = 1.0;
    ks_scan_info[0].oprot[8] = 1.0;
    break;
  case PSD_SAG:
    ks_scan_info[0].oprot[2] = 1.0;
    ks_scan_info[0].oprot[4] = 1.0;
    ks_scan_info[0].oprot[6] = 1.0;
    break;
  case PSD_COR:
    ks_scan_info[0].oprot[2] = 1.0;
    ks_scan_info[0].oprot[6] = 1.0;
    ks_scan_info[0].oprot[7] = 1.0;
    break;
  case PSD_OBL:
    alpha = PI / 4.0; /* rotation about x (applied first) */
    beta = 0;   /* rotation about y (applied 2nd) */
    gamma = 0;  /* rotation about z (applied 3rd) */
    ks_scan_info[0].oprot[0] = cos(gamma) * cos(beta);
    ks_scan_info[0].oprot[1] = cos(gamma) * sin(beta) * sin(alpha) -
                            sin(gamma) * cos(alpha);
    ks_scan_info[0].oprot[2] = cos(gamma) * sin(beta) * cos(alpha) +
                            sin(gamma) * sin(alpha);
    ks_scan_info[0].oprot[3] = sin(gamma) * cos(beta);
    ks_scan_info[0].oprot[4] = sin(gamma) * sin(beta) * sin(alpha) +
                            cos(gamma) * cos(alpha);
    ks_scan_info[0].oprot[5] = sin(gamma) * sin(beta) * cos(alpha) -
                            cos(gamma) * sin(alpha);
    ks_scan_info[0].oprot[6] = -sin(beta);
    ks_scan_info[0].oprot[7] = cos(beta) * sin(alpha);
    ks_scan_info[0].oprot[8] = cos(beta) * cos(alpha);
    break;
  }

  for (i = 1; i < num_slice; i++) {
    ks_scan_info[i].optloc = ks_scan_info[i - 1].optloc + z_delta;
    ks_scan_info[i].oprloc = i * r_delta;
    for (j = 0; j < 9; j++)
      ks_scan_info[i].oprot[j] = ks_scan_info[0].oprot[j];
  }

#endif /* ifdef SIM */

  return SUCCESS;

} /* simscan() */

GEReq_init_gradspecs()

STATUS GEReq_init_gradspecs	(	LOG_GRAD *	loggrd,
		PHYS_GRAD *	phygrd,
		float	srfact
	)

Initialize logical and physical gradient specifications

This function calls inittargets() to get the physical gradient characteristics from the MR-system, followed by a call to obloptimize() (slice angulation dependence) to get the logical gradient specifications for the current slice angulation.

The ramp times (loggrd.xrt/yrt/zrt) are quite conservative (and longer than the ramptimes for phygrd). Preliminary testing indicates that the difference between the loggrd and phygrad structs can be reduced by a factor of two (not very scientific!) as a standard measure.

For further control over the slewrate, the srfact argument is passed to ks_init_slewratecontrol(), which can both slow down and increase the gradient slewrate.

Parameters

[out]	loggrd	The global logical gradient specification struct (dependent on slice angulation via global SCAN_INFO scan_info[] struct).
[out]	phygrd	The global physical gradient struct
[in]	srfact

Return values

STATUS

SUCCESS or FAILURE

                                                                               {
  int initnewgeo = 1;

  /* default gradient specs */
  inittargets(loggrd, phygrd);

  /* optimal loggrd based on current slice angulations */
  if (obloptimize_epi(loggrd, phygrd, scan_info, exist(opslquant),
                  ((obl_method==PSD_OBL_RESTRICT) ? 4 /*oblique plane*/ : opphysplane), exist(opcoax), (int) obl_method,
                  exist(obl_debug), &initnewgeo, cfsrmode) == FAILURE) {
    return ks_error("ks_init_loggrd: obloptimize failed");
  }

  /* reduce slewrate if srfact < 1 */
  if (ks_init_slewratecontrol(loggrd, phygrd, srfact) == FAILURE)
    return FAILURE;

  return SUCCESS;

} /* GEReq_init_gradspecs() */

GEReq_init_accelUI()

STATUS GEReq_init_accelUI	(	int	integeraccel,
		int	maxaccel
	)

Sets up the menu for parallel imaging (ARC or ASSET) with max/min range

Parameters

[in]	integeraccel	Flag to make acceleration menu contain only integer acceleration factors enums: KS_ARCMENU_FRACTACCEL (0), KS_ARCMENU_INTACCEL (1)
[in]	maxaccel	Maximum allowed acceleration factor for the sequence

Return values

STATUS

SUCCESS or FAILURE

                                                          {

  /* Acceleration menu */
  cfaccel_ph_maxstride = maxaccel;
  cvmax(opaccel_ph_stride, cfaccel_ph_maxstride);
  avminaccel_ph_stride = 1.0;
  avmaxaccel_ph_stride = cfaccel_ph_maxstride;
  piarccoilrestrict = 1; /* disable ARC option for single-channel coil (cf. epic.h) */

  if (KS_3D_SELECTED) { /* PSD_3D or PSD_3DM */
    cfaccel_sl_maxstride = maxaccel;
    cvmax(opaccel_sl_stride, cfaccel_sl_maxstride);
    avminaccel_sl_stride = 1.0;
    avmaxaccel_sl_stride = cfaccel_sl_maxstride;
  }

  if ((oparc || opasset == ASSET_SCAN) && maxaccel > 1) {
    if (integeraccel) {
      piaccel_phnub = 1 + maxaccel;
      piaccel_phval2 = 1.0;
      piaccel_phval3 = 2.0;
      piaccel_phval4 = 3.0;
      piaccel_phval5 = 4.0;
      piaccel_phval6 = 5.0;
      piaccel_phedit = 0; /* don't allow user to type in value */
    } else {
      piaccel_phnub = IMin(2, 6, maxaccel * 2);
      piaccel_phval2 = 1.0;
      piaccel_phval3 = 1.5;
      piaccel_phval4 = 2.0;
      piaccel_phval5 = 2.5;
      piaccel_phval6 = 3.0;
      piaccel_phedit = 1;
    }
    piaccel_ph_stride = 2.0;
    if (KS_3D_SELECTED) {
      if (integeraccel) {
        piaccel_slnub = 1 + maxaccel;
        piaccel_slval2 = 1.0;
        piaccel_slval3 = 2.0;
        piaccel_slval4 = 3.0;
        piaccel_slval5 = 4.0;
        piaccel_slval6 = 5.0;
        piaccel_sledit = 0; /* don't allow user to type in value */
      } else {
        piaccel_slnub = IMin(2, 6, maxaccel * 2);
        piaccel_slval2 = 1.0;
        piaccel_slval3 = 1.5;
        piaccel_slval4 = 2.0;
        piaccel_slval5 = 2.5;
        piaccel_slval6 = 3.0;
        piaccel_sledit = 1;
      }
      piaccel_sl_stride = 1.0;
    } else {
      piaccel_slnub = 0;
    }
  } else {
    piaccel_phnub = 0;
    piaccel_slnub = 0;
    cvoverride(opaccel_ph_stride, 1.0, PSD_FIX_OFF, PSD_EXIST_OFF);
    cvoverride(opaccel_sl_stride, 1.0, PSD_FIX_OFF, PSD_EXIST_OFF);
  }

  return SUCCESS;

} /* GEReq_init_accelUI() */

GEReq_eval_TRrange()

STATUS GEReq_eval_TRrange	(	int *	slperpass,
		int *	timetoadd_perTR,
		int	requested_minacqs,
		int	mintr,
		int	maxtr,
		KS_SEQ_COLLECTION *	seqcollection,
		int(*)(int, int, void **)	play_loop,
		int	nargs,
		void **	args
	)

Calculate the number of slices per TR and TR padding time (2D imaging)

---

2024 UPDATE: THIS FUNCTION IS ONLY USED BY KSGRE_TUTORIAL.E AND DEPCREATED PSDS.

THE NEW PSDS USE KSSCAN_LOOP_CONTROL CONTAINING KS_PHASEENCODING_PLAN AND KS_SLICETIMING FOR THE SCAN LOOP.

This function calculates the number of slices that can fit in one TR (optr) based on the duration and occurences of the sequence modules in the sequence collection (KS_SEQ_COLLECTION) determined by calling the sequence sliceloop (wrapper) function.

As the number of arguments to the sequence's sliceloop is psd-dependent, the function pointer play_loop must be a wrapper function to the sliceloop function taking standardized input arguments (int) nargs and (void **) args. This sliceloop wrapper function must be on the form: int sliceloop_nargs(int slperpass, int nargs, void **args); returning the duration in [us] to play out slperpass number of slices. If the sliceloop function does not need any additional input arguments, nargs = 0, and args = NULL.

The minimum allowed TR is determined by ks_eval_mintr(), which honors SAR/heating limitations. If opautotr = 1, optr will be updated here, otherwise if optr is too short, an error will be returned to the operator.

The calling function can specify the minimum acqs that are allowed, as well as a minimum and maximum TR interval. Setting maxtr = 0 disables the upper TR limit. Setting requested_minacqs <= 1, disables the min acqs requirement.

This function should be called at the end of cveval() after all sequence modules have been set up and dry-runned on host by calling each sequence module's ****_pg() function. See also the documentation for KS_SEQ_CONTROL and KS_SEQ_COLLECTION.

Parameters

[out]	slperpass	Number of slices that can fit within each TR
[out]	timetoadd_perTR	The total time in [us] that must be distributed manually to one or more sequence modules after the call to GEReq_eval_TR() in order to meet the desired TR
[in]	requested_minacqs	The desired minimum number of acquisitions (passes)
[in]	mintr	Lowest allowed TR in [us]
[in]	maxtr	Highest allowed TR in [us]. 0: Disabled
[in,out]	seqcollection	Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules
[in]	play_loop	Function pointer to (the wrapper function to) the sliceloop function of the sequence
[in]	nargs	Number of extra input arguments to the sliceloop wrapper function.
[in]	args	Void pointer array pointing to the variables containing the actual values needed for the sequence's sliceloop function

Return values

STATUS

SUCCESS or FAILURE

                                                                                                    {
  STATUS status;
  int numacqs = 0;
  int i;
  int numrfexclocations = (KS_3D_SELECTED) ? exist(opvquant) : exist(opslquant);
  int slicetime;
  int nslices_perTR = KS_NOTSET;
  int nslices_shortest_scantime = KS_NOTSET;
  int lowest_scantime = KS_NOTSET;
  int singleslice_time = KS_NOTSET;
  int requested_maxslices = KS_NOTSET;
  int maxslices_time = KS_NOTSET;

  /* check if the hardware limts have already been checked */
  if (seqcollection->hwlimitsdone != TRUE) {
    return ks_error("%s: hardware limits must be checked before calling this function", __FUNCTION__);
  }

  if (seqcollection == NULL || seqcollection->numseq == 0) {
    return ks_error("%s: Please add pulse sequence modules to the sequence collection before calling this function", __FUNCTION__);
  }

  if (mintr < 0 || maxtr < 0) {
    return ks_error("%s: min/max TR cannot be negative", __FUNCTION__);
  } else if ((maxtr > 0) && (maxtr <= mintr)) {
    return ks_error("%s: max TR must be > minTR, or 0 (disabled)", __FUNCTION__);
  }

  /* make sure seqctrl.duration at least equal to seqctrl.min_duration */
  status = ks_eval_seqcollection_durations_atleastminimum(seqcollection);
  KS_RAISE(status);

  singleslice_time = ks_eval_mintr(1, seqcollection, play_loop, nargs, args);
  if (singleslice_time <= 0) return FAILURE;

  if ((maxtr > 0) && (maxtr < singleslice_time)) {
    return ks_error("%s: Max TR must be > %.1f ms", __FUNCTION__, singleslice_time / 1000.0);
  }
  if ((mintr > 0) && (mintr < singleslice_time)) {
    return ks_error("%s: Min TR must be > %.1f ms", __FUNCTION__, singleslice_time / 1000.0);
  }
    if ((maxtr > 0) && ((maxtr - mintr) < singleslice_time)) {
    return ks_error("%s: The TR interval must be > %.1f ms", __FUNCTION__, singleslice_time / 1000.0);
  }

  /* #acqs cannot exceed #slices. If sequential scanning, #acqs = #slices */
  if (requested_minacqs < 1) {
    requested_minacqs = 1;
  } else if ((requested_minacqs > numrfexclocations) || (opirmode == TRUE)) {
    requested_minacqs = numrfexclocations;
  }
  requested_maxslices = CEIL_DIV(numrfexclocations, requested_minacqs);
  maxslices_time = ks_eval_mintr(requested_maxslices, seqcollection, play_loop, nargs, args);



  if (opautotr) {  /* AutoTR: User selected pitrval2 = PSD_MINIMUMTR */

    if (maxtr > 0 || mintr > 0) { /* in-range autoTR */

      /* Check which combination that results in the lowest scan time, and max/min # slices in range */
      for (i = 1; i <= numrfexclocations; i++) {
        numacqs = CEIL_DIV(numrfexclocations, i);
        slicetime = ks_eval_mintr(i, seqcollection, play_loop, nargs, args);
        if (slicetime >= mintr && (maxtr == 0 || slicetime <= maxtr) && (numacqs >= requested_minacqs)) {
          if (lowest_scantime == KS_NOTSET) {
            nslices_shortest_scantime = i;
            lowest_scantime = slicetime * numacqs;
          } else if (slicetime * numacqs <= lowest_scantime * 1.01) {
            /* 1.01 to avoid round-off effects of slicetime and to slightly favor fewer acqs and longer TRs
            when the scantime is nearly identical */
            nslices_shortest_scantime = i;
            lowest_scantime = slicetime * numacqs;
          }
        }
      }

      if (lowest_scantime == KS_NOTSET) {
        /* failed to find solution within the interval, the range is probably too high for the set
           of slices.  Need to add padding to reach mintr. This
             is done by setting optr = avmintr = mintr (see also timetoadd_perTR below)*/
        if (maxslices_time < mintr) {
          nslices_perTR = requested_maxslices;
          avmintr = mintr;
        } else {
          return ks_error("%s: Programming error", __FUNCTION__);
        }
      } else {
        nslices_perTR = nslices_shortest_scantime;
        avmintr = ks_eval_mintr(nslices_perTR, seqcollection, play_loop, nargs, args);
      }

    } else { /* minimum TR (using requested_minacqs) */

      nslices_perTR = requested_maxslices;
      avmintr = ks_eval_mintr(nslices_perTR, seqcollection, play_loop, nargs, args);

    }

    avmaxtr = avmintr;
    cvoverride(optr, avmintr, PSD_FIX_ON, PSD_EXIST_ON);

  } else { /* Manual TR */

    avmintr = singleslice_time;
    avmaxtr = _optr.maxval;

    /* how many slices can we MAXIMALLY fit in one TR ? */
    if (opirmode == 1) { /* sequential */
      nslices_perTR = 1;
    } else {
      if (existcv(optr)) {
        if (optr < avmintr)
          return ks_error("%s: Increase the TR to %.1f ms", __FUNCTION__, avmintr / 1000.0);
        if ((mintr > 0) && (optr < mintr))
          return ks_error("%s: Increase the TR to %.1f ms", __FUNCTION__, mintr / 1000.0);
        if ((maxtr > 0) && (optr > maxtr))
          return ks_error("%s: Decrease the TR to %.1f ms", __FUNCTION__, maxtr / 1000.0);
      }      
      nslices_perTR = ks_eval_maxslicespertr(exist(optr), seqcollection, play_loop, nargs, args);
      nslices_perTR = IMax(2, 1, nslices_perTR); /* safeguard against < 1 */
    }

  } /* Auto/Manual TR */


  /* how many acqs (runs) do we need to get all prescribed slices ? */
  numacqs = CEIL_DIV(numrfexclocations, nslices_perTR);

  /* how many slices SHOULD we play out per pass (keeping numrfexclocations and numacqs)?
     This may be less than nslices_perTR depending on divisibility */
  *slperpass = CEIL_DIV(numrfexclocations, numacqs); /* round up */

  /* run once more with the actual number of slices per TR, mostly so that ks_eval_hwlimits()->ks_eval_rflimits() will set the
  description of `optr` correctly */
  ks_eval_mintr(*slperpass, seqcollection, play_loop, nargs, args);

  /* run before each call to function pointer `play_loop()` (next line) to set all `seqctrl.ninst` to 0 */
  ks_eval_seqcollection_resetninst(seqcollection);

  /* Update seqcollection.seqctrl[*].ninst given '*slperpass' number of slices
     time [us] for one sequence playout incl. the SSI time and necessary dead time to
     make up the expected TR. To be used in KS_SEQLENGTH() in pulsegen() */
  *timetoadd_perTR = exist(optr) - play_loop(*slperpass, nargs, args);

  /* prevent further addition of new sequence modules */
  seqcollection->mode = KS_SEQ_COLLECTION_LOCKED;

  /* Flag that we have completed this function */
  /* seqcollection->evaltrdone = TRUE; */



  /* Set UI and advisory panel variables */
  avail_image_time = RDN_GRD(exist(optr));
  act_tr = avail_image_time;
  ihtr = act_tr; /* image header TR */

  avminslquant = 1;
  if (KS_3D_SELECTED == FALSE) {
  avmaxslquant = nslices_perTR; /* UI value ("Max # Slices:") */
  avmaxacqs = numacqs; /* UI value ("# of Acqs:") */
  } else {
    avmaxslquant = 2048;
    avmaxacqs = 1;
  }

  return SUCCESS;

} /* GEReq_eval_TRrange() */

GEReq_eval_TR()

STATUS GEReq_eval_TR	(	int *	slperpass,
		int *	timetoadd_perTR,
		int	requested_minacqs,
		KS_SEQ_COLLECTION *	seqcollection,
		int(*)(int, int, void **)	play_loop,
		int	nargs,
		void **	args
	)

Calculate the number of slices per TR and TR padding time (2D imaging)

---

2024 UPDATE: THIS FUNCTION IS ONLY USED BY KSGRE_TUTORIAL.E AND DEPCREATED PSDS.

THE NEW PSDS USE KSSCAN_LOOP_CONTROL CONTAINING KS_PHASEENCODING_PLAN AND KS_SLICETIMING FOR THE SCAN LOOP.

                                                                                                    {

  return GEReq_eval_TRrange(slperpass, timetoadd_perTR, requested_minacqs, 0, 0, seqcollection, play_loop, nargs, args);

} /* GEReq_eval_TR() */

GEReq_eval_rfscaling()

STATUS GEReq_eval_rfscaling

(

KS_SEQ_COLLECTION *

seqcollection

)

Performs RF scaling of all RF pulses in the KS_SEQ_COLLECTION and Prescan

RF scaling is a complicated process across RF pulses in scan (multiple sequence modules) and prescan, where the desired flip angles should be met partly using the maxB1 info for each RF pulse and scale it relative to the prescan result. This is done via a combination of scan and prescan attenuation factors (xmtaddScan) in the entry_point_table[], an extra global scaling factor, and change of the (instruction) amplitude of each RF pulse.

This function performs all these tasks using a KS_SEQ_COLLECTION as input. The sequence collection struct contains one KS_SEQ_CONTROL struct for each sequence module, which via the field gradrf.rfptr[] has access to all KS_RF objects in the sequence module. As the ***_pg() function for each sequence module should have been called prior to this function, the number of occurrences of each RF pulse is known. Moreover, the rfstat specification for every RF pulse is located in: seqcollection->seqctrl[]->gradrf->rfptr[]->rf.rfpulse which is used by ks_eval_seqcollection2rfpulse() to rewrite the global rfpulse[] struct array required by GE's RF scaling functions peakB1() and setScale().

At the end of this function, the seqcollection mode is locked, preventing accidental addition of new sequence modules to the seqcollection using ks_eval_addtoseqcollection(). Moreover, each sequence module will have its rfscalingdone field set to TRUE to signal to ks_pg_rf() that the RF pulse belonging to that sequence module has indeed been RF scaled properly. This extra safety mechanism makes it difficult to use ks_pg_rf() without first passing through this function and have the seqcollection struct set up.

Parameters

[in,out]

seqcollection

Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules

Return values

STATUS

SUCCESS or FAILURE

                                                              {
  int i;
  STATUS status;


  if (seqcollection == NULL || seqcollection->numseq == 0) {
    return ks_error("%s: Please add pulse sequence modules to the sequence collection before calling this function", __FUNCTION__);
  }

  /* use global rfpulse[] array (that is also featuring in Prescan.e) */
  for (i = 0; i < KS_MAXUNIQUE_RF; i++) {
    rfpulse[i].activity = 0;
  }

  /* Update the global RF pulse array rfpulse[] with the contents of the RF pulses in the sequence modules.
     This also includes resetting all .activity fields to zero for the first KS_MAXUNIQUE_RF elements in rfpulse[] */
  status = ks_eval_seqcollection2rfpulse(rfpulse, seqcollection);
  KS_RAISE(status);


  /* find the peak B1 for each entry point and the max B1 across all entry points */
  status = findMaxB1Seq(&maxB1Seq, maxB1, MAX_ENTRY_POINTS, rfpulse, RF_FREE);
  if (status != SUCCESS) {
    return ks_error("%s: findMaxB1Seq() failed", __FUNCTION__);
  }

  /* RF: How much do we need to attenuate the RF pulses in scan. */
  double my_xmtaddScan = -200 * log10(maxB1[L_SCAN] / maxB1Seq) + getCoilAtten();
  if (my_xmtaddScan > cfdbmax) {
    extraScale = (float) pow(10.0, (cfdbmax - my_xmtaddScan) / 200.0); /* N.B.: 'extraScale' is declared as CV in Prescan.e */
    my_xmtaddScan = cfdbmax;
  } else {
    extraScale = 1.0;
  }

  /* RF: Scale the rfpulse amplitudes */
  status = setScale(L_SCAN, RF_FREE, rfpulse, maxB1[L_SCAN], extraScale);
  if (status != SUCCESS) {
    return ks_error("%s: setScale failed", __FUNCTION__);
  }

  /* fill entry_point_table */
  status = entrytabinit(entry_point_table, (int)ENTRY_POINT_MAX);
  if (status != SUCCESS) {
    return ks_error("%s: entrytabinit() failed", __FUNCTION__);
  }
  strcpy( entry_point_table[L_SCAN].epname, "scan");
  entry_point_table[L_SCAN].epxmtadd = (short)rint( (double) my_xmtaddScan);
  entry_point_table[L_SCAN].epstartrec = rhdab0s;
  entry_point_table[L_SCAN].ependrec = rhdab0e;
#if EPIC_RELEASE < 29
  entry_point_table[L_SCAN].epfastrec = 0;
#endif
  entry_point_table[L_APS2] = entry_point_table[L_MPS2] = entry_point_table[L_SCAN];
  strcpy(entry_point_table[L_APS2].epname, "aps2");
  strcpy(entry_point_table[L_MPS2].epname, "mps2");

  /* Prescan: Final RF scaling of the Prescan entries, using the maxB1[] and maxB1Seq values computed above */

  /* prevent further addition of new sequence modules */
  seqcollection->mode = KS_SEQ_COLLECTION_LOCKED;

  /* Flag each sequence module that RF scaling has been done */
  for (i = 0; i < seqcollection->numseq; i++) {
    seqcollection->seqctrlptr[i]->rfscalingdone = TRUE;
  }

  return SUCCESS;

} /* GEReq_eval_rfscaling() */

GEReq_eval_checkTR_SAR_calcs()

STATUS GEReq_eval_checkTR_SAR_calcs	(	KS_SEQ_COLLECTION *	seqcollection,
		s64	intended_time
	)

Checks that sequence modules sum up to TR, honoring SAR/heating limits

---

2024 UPDATE: THE NEW HEATING MODEL IN KSFOUNDATION (2024) USES ks_eval_hwlimit() INSTEAD OF GEReq_eval_checkTR_SAR()

AND ksinv_eval_checkTR_SAR(), AFTER WHICH THIS FUNCTION IS CALLED TO UPDATE THE UI WITH SAR VALUES.

This function is called to check that the sequence modules played out in the slice loop sum up to the specified TR (optr) accounting for SAR/heating limits. Moreover, the SAR values are updated in the UI, and the CV ks_sarcheckdone is set to TRUE. This CV is set to FALSE in GEReq_cvinit() and check whether it is TRUE in GEReq_predownload() to make sure SAR calculation have been performed before scanning.

Parameters

[in,out]	seqcollection	Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules
[in]	intended_time	Usually repetition time (optr), should correspond to the intended time to play the corresponding number of sequence instances now set in seqcollection[]->seqctrl.ninst

Return values

STATUS

SUCCESS or FAILURE

                                                                                         {
  KS_SAR sar;
  int duration_withinlimits;
  s64 nettime;
  STATUS status;

  /* Print out the sequence collection time table. In simulation it appears in the WTools main window */
#ifdef PSD_HW
    FILE *fp = fopen("/usr/g/mrraw/seqcollection.txt", "w");
    ks_print_seqcollection(seqcollection, fp);
    fclose(fp);
#else
    ks_print_seqcollection(seqcollection, stderr);
#endif

  /*
  The duration based on the sequence collection struct, which is the product .nseqinstances and .duration fields in each sequence
  modules, summed over all sequence modules.
  The .nseqinstances field becomes > 0 by the call to: GEReq_eval_TR()->ks_eval_mintr()->play_loop()->ks_scan_playsequence()
  The .duration field is initially set to .min_duration by GEReq_eval_TR()->ks_eval_seqcollection_durations_atleastminimum(), but the
  .duration field of at least one sequence module should have been set larger than its .min_duration based on the amount of
  timetoadd_perTR returned by GEReq_eval_TR()  */
  nettime = ks_eval_seqcollection_gettotalduration(seqcollection);
  if (nettime <= 0) {
    return ks_error("%s: Nettime = %lld", __FUNCTION__, nettime);
  }

  /* duration_withinlimits = nettime + grad/RF SAR/heat penalty time */
  duration_withinlimits = ks_eval_rflimits(&sar, seqcollection);
  if (duration_withinlimits == KS_NOTSET) {
    return FAILURE;
  }

  /* Make sure the global RF pulse array rfpulse[] is updated with the contents of the RF pulses in the sequence modules.
     This also includes resetting all .activity fields to zero for the first KS_MAXUNIQUE_RF elements in rfpulse[] */
  status = ks_eval_seqcollection2rfpulse(rfpulse, seqcollection);
  KS_RAISE(status);


  /* report to UI */
  piasar = (float) sar.average;
  picasar = (float) sar.coil;
  pipsar = (float) sar.peak;
  pib1rms = (float) sar.b1rms;

  if (existcv(opslquant) == FALSE) {
    /* if #slices has not been set yet, hold on complaining */
    return SUCCESS;
  }

  if (nettime < duration_withinlimits) {
    return ks_error("%s: Duration of seq. modules (" S64_FMT ") < grad/rf limits (%d)", __FUNCTION__,
                    nettime, duration_withinlimits);
  }

  double rel_timing_error = 0; 
  if (intended_time > 0 && nettime > 0) {
    rel_timing_error = ((double) (intended_time - nettime)) / ((double) nettime);
  }

  /* Any timing error is recorded in ks_debug.txt */
  if (fabs(rel_timing_error) > 0) {
    ks_dbg("%s: relative timing error %g. intended_time = %lld nettime  = %lld", __FUNCTION__, rel_timing_error, intended_time, nettime);
  }

  /* Timing errors > 0.01 percent is reported to the UI */
  if (-rel_timing_error > MAX_SEQMODULES_DURATION_DEVIATION_FRACTION) { /* intended_time smaller than nettime */
    /* small excess in nettime is expected due to roundups of .duration to nearest 4us, but we cannot accept too much */
    return ks_error("%s: Duration of seq. modules (" S64_FMT ") " S64_FMT " us too long", __FUNCTION__,
                    nettime, (nettime - intended_time));
  }
  if (rel_timing_error > MAX_SEQMODULES_DURATION_DEVIATION_FRACTION) {  /* intended_time larger than nettime */
    return ks_error("%s: Duration of seq. modules (" S64_FMT ") " S64_FMT " us too short", __FUNCTION__,
                    nettime, (intended_time - nettime));
  }



#if EPIC_RELEASE >= 27
  status = setupPowerMonitor(&entry_point_table[L_SCAN], sar.average);
#else  
  status = setupPowerMonitor(&entry_point_table[L_SCAN], L_SCAN, RF_FREE, rfpulse,
                             nettime, sar.average, sar.coil, sar.peak);
#endif                             
  if (status != SUCCESS) {
    return ks_error("%s: setupPowerMonitor failed", __FUNCTION__);
  }

  /* prevent further addition of new sequence modules */
  seqcollection->mode = KS_SEQ_COLLECTION_LOCKED;


  /* Flag that SAR check has been done */
  ks_sarcheckdone = TRUE;

  return SUCCESS;

} /* GEReq_eval_checkTR_SAR_calcs() */

GEReq_eval_checkTR_SAR()

STATUS GEReq_eval_checkTR_SAR	(	KS_SEQ_COLLECTION *	seqcollection,
		int	nslices,
		int(*)(int, int, void **)	play_loop,
		int	nargs,
		void **	args
	)

Runs the slice loop and validates TR and SAR/hardware limits

---

2024 UPDATE: THIS FUNCTION IS ONLY USED BY KSGRE_TUTORIAL.E AND DEPCREATED PSDS.

THE NEW PSDS USE KSSCAN_LOOP_CONTROL CONTAINING KS_PHASEENCODING_PLAN AND KS_SLICETIMING FOR THE SCAN LOOP.

This function first makes sure that the .nseqinstances field for each sequence module in the sequence collection corresponds to the number of times played out in the sequence's sliceloop function.

In simulation (WTools), ks_print_seqcollection() will print out a table of the sequence modules in the sequence collection in the WToolsMgd window.

Finally, GEReq_eval_checkTR_SAR_calcs() is called to check that the TR is correct and within SAR/hardware limits.

N.B.: For inversion sequences, ksinv_eval_checkTR_SAR() is used to do the same thing, with the difference that ksinv_scan_sliceloop() is used instead.

Parameters

[in]	seqcollection	Pointer to the KS_SEQ_COLLECTION struct holding all sequence modules
[in]	nslices	Number of slices in TR
[in]	play_loop	Function pointer to (the wrapper function to) the sliceloop function
[in]	nargs	Number of extra input arguments to the sliceloop wrapper function.
[in]	args	Void pointer array pointing to the variables containing the actual values needed for the sliceloop function

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                {

  if (seqcollection == NULL || seqcollection->numseq == 0) {
    return ks_error("%s: Please add pulse sequence modules to the sequence collection before calling this function", __FUNCTION__);
  }

  /* set all `seqctrl.nseqinstances` to 0 */
  ks_eval_seqcollection_resetninst(seqcollection);
  play_loop(nslices, nargs, args); /* => seqctrl.nseqinstances = # times each seq. module has been played out */

  return GEReq_eval_checkTR_SAR_calcs(seqcollection, optr);

} /* GEReq_eval_checkTR_SAR() */

GEReq_predownload_store_sliceplan()

STATUS GEReq_predownload_store_sliceplan

(

KS_SLICE_PLAN

slice_plan

)

Sets mandatory global GE arrays for data acquisition

The following global GE arrays are set based on slperpass (arg 1) and global op** variables:

• data_acq_order[]: Critical for scanning
• rsp_info[]: Copied from scan_info[] (the graphically prescibed slices), for conformance. Is a temporally sorted version of scan_info[] with integer rotation matrices. Not needed for scanning.
• rsptrigger[]: Set to TRIG_INTERN for now.

data_acq_order[] is only available on HOST, why this function also copies data_acq_order[] to ks_data_acq_order[], which is an ipgexport array accessible on both HOST and TGT. This can be used by ks_scan_getsliceloc() to be independent on rsp_info[] during scan.

The slice plan is stored as a text file ("ks_sliceplan.txt") in the current directory in simulation and in /usr/g/mrraw on the MR scanner by calling ks_print_sliceplan().

Parameters

[in]

slice_plan

The current slice plan (KS_SLICE_PLAN) set up for the sequence (see ks_calc_sliceplan())

Return values

STATUS

SUCCESS or FAILURE

                                                                   {
  int i, j, time;

  if (slice_plan.npasses == 0) {
    return KS_THROW("#acqs (.npasses) cannot be 0");
  }

  if (CEIL_DIV(slice_plan.nslices, slice_plan.nslices_per_pass) != slice_plan.npasses) {
    return KS_THROW("inconsistent slice plan - #acqs");
  }

  if (!KS_3D_SELECTED && slice_plan.nslices != exist(opslquant)) {
    return KS_THROW("inconsistent slice plan - #slices");
  }

  /* initialize rsp_info, rtsprot and rsptrigger */
  for (i = 0; i < DATA_ACQ_MAX; i++) {
    rsp_info[i].rsptloc = 0;
    rsp_info[i].rsprloc = 0;
    rsp_info[i].rspphasoff = 0;
    rsptrigger[i] = TRIG_INTERN;
    for (j = 0; j < 9; j++)
      rsprot[i][j] = 0;
  }

  /* copy to global data_acq_order, which must be correct for main sequence or scan will not start */
  for (i = 0; i < slice_plan.nslices; i++) {
    data_acq_order[i].slloc = slice_plan.acq_order[i].slloc;
    data_acq_order[i].slpass = slice_plan.acq_order[i].slpass;
    data_acq_order[i].sltime = slice_plan.acq_order[i].sltime;
  } /* for slice locations */

  for (i = slice_plan.nslices; i < SLICE_FACTOR*DATA_ACQ_MAX; i++) {
    data_acq_order[i].slloc = data_acq_order[i % slice_plan.nslices].slloc;
    data_acq_order[i].slpass = data_acq_order[i % slice_plan.nslices].slpass;
    data_acq_order[i].sltime = data_acq_order[i % slice_plan.nslices].sltime;
#ifdef UNDEF    
    data_acq_order[i].slloc = 0;
    data_acq_order[i].slpass = 0;
    data_acq_order[i].sltime = 0;  
#endif  
  } /* for rest of data_acq_order */

  time = 0;
  for (i = 0; i < slice_plan.npasses; ++i) {
    for (j = 0; j < slice_plan.nslices_per_pass; ++j) {
      int slloc = ks_scan_getsliceloc(&slice_plan, i, j);
      if (slloc == KS_NOTSET) {continue;}

      rsp_info[time].rsptloc = scan_info[slloc].optloc;
      rsp_info[time].rsprloc = scan_info[slloc].oprloc;
      rsp_info[time].rspphasoff = scan_info[slloc].opphasoff;

      scale(&scan_info[slloc].oprot, &rsprot[time], 1, &loggrd, &phygrd, 0);

      /* Future: here we could change to a variable to support gating. TRIG_ECG, TRIG_AUX etc */
      rsptrigger[time] = TRIG_INTERN;

      ++time;
    }
  }

  /* Save acquisition table to disk for debugging */
  FILE* daqfp = ks_open_file_in_embed("sliceplan.txt", "w");
  ks_print_sliceplan(slice_plan, daqfp);
  fclose(daqfp);

  STATUS status = calcChecksumScanInfo(&chksum_scaninfo, scan_info, slice_plan.nslices, psdcrucial_debug);
  if (status != SUCCESS) {
    epic_error(1, "GEReq...sliceplan(): PSD data integrity violation detected in PSD",
               EM_PSD_PSDCRUCIAL_DATA_FAILURE, EE_ARGS(1), SYSLOG_ARG);
    return status;
  }

  /* set GE acqs and slquant1 CVs for look and feel */
  _slquant1.fixedflag = 0;
  _acqs.fixedflag = 0;
  slquant1 = slice_plan.nslices_per_pass;
  acqs = slice_plan.npasses;
  /* prescan */
  picalmode = 0;
  pislquant = slquant1;

  return SUCCESS;

} /* GEReq_predownload_store_sliceplan() */

GEReq_predownload_store_sliceplan_sms()

STATUS GEReq_predownload_store_sliceplan_sms	(	const KS_SLICE_PLAN	slice_plan,
		int	sms_factor
	)

                                                                                             {
  int i, j, time;

  if (slice_plan.npasses == 0) {
    return ks_error("%s: #acqs (.npasses) cannot be 0", __FUNCTION__);
  }

  if (CEIL_DIV(slice_plan.nslices, slice_plan.nslices_per_pass) != slice_plan.npasses) {
    return ks_error("%s: inconsistent slice plan - #acqs", __FUNCTION__);
  }

  if (!KS_3D_SELECTED && slice_plan.nslices * sms_factor != exist(opslquant)) {
    return ks_error("%s: inconsistent slice plan - #slices", __FUNCTION__);
  }

  /* initialize rsp_info, rtsprot and rsptrigger */
  for (i = 0; i < DATA_ACQ_MAX; i++) {
    rsp_info[i].rsptloc = 0;
    rsp_info[i].rsprloc = 0;
    rsp_info[i].rspphasoff = 0;
    rsptrigger[i] = TRIG_INTERN;
    for (j = 0; j < 9; j++)
      rsprot[i][j] = 0;
  }

  /* copy to global data_acq_order, which must be correct for main sequence or scan will not start */
  for (i = 0; i < slice_plan.nslices; i++) {
    data_acq_order[i].slloc = slice_plan.acq_order[i].slloc;
    data_acq_order[i].slpass = slice_plan.acq_order[i].slpass;
    data_acq_order[i].sltime = slice_plan.acq_order[i].sltime;
  } /* for slice locations */

  for (i = slice_plan.nslices; i < SLICE_FACTOR*DATA_ACQ_MAX; i++) {
    data_acq_order[i].slloc = i;
    data_acq_order[i].slpass = data_acq_order[i % slice_plan.nslices].slpass;
    data_acq_order[i].sltime = data_acq_order[i % slice_plan.nslices].sltime;
  } /* for rest of data_acq_order */

  time = 0;
  for (i = 0; i < slice_plan.npasses; ++i) {
    for (j = 0; j < slice_plan.nslices_per_pass; ++j) {
      int slloc = ks_scan_getsliceloc(&slice_plan, i, j);
      if (slloc == KS_NOTSET) {continue;}

      rsp_info[time].rsptloc = scan_info[slloc].optloc;
      rsp_info[time].rsprloc = scan_info[slloc].oprloc;
      rsp_info[time].rspphasoff = scan_info[slloc].opphasoff;

      scale(&scan_info[slloc].oprot, &rsprot[time], 1, &loggrd, &phygrd, 0);

      /* Future: here we could change to a variable to support gating. TRIG_ECG, TRIG_AUX etc */
      rsptrigger[time] = TRIG_INTERN;

      ++time;
    }
  }

  /* Save acquisition table to disk for debugging */
  FILE* daqfp = ks_open_file_in_embed("sliceplan.txt", "w");
  ks_print_sliceplan(slice_plan, daqfp);
  fclose(daqfp);

  STATUS status = calcChecksumScanInfo(&chksum_scaninfo, scan_info, slice_plan.nslices*sms_factor, psdcrucial_debug);
  if (status != SUCCESS) {
    epic_error(1, "GEReq...sliceplan(): PSD data integrity violation detected in PSD",
               EM_PSD_PSDCRUCIAL_DATA_FAILURE, EE_ARGS(1), SYSLOG_ARG);
    return status;
  }

  /* set GE acqs and slquant1 CVs for look and feel */
  _slquant1.fixedflag = 0;
  _acqs.fixedflag = 0;
  slquant1 = slice_plan.nslices_per_pass;
  acqs = slice_plan.npasses;
  /* prescan */
  picalmode = 0;
  pislquant = slquant1;

  return SUCCESS;

} /* GEReq_predownload_store_sliceplan_sms() */

GEReq_predownload_store_sliceplan3D()

STATUS GEReq_predownload_store_sliceplan3D	(	int	slices_in_slab,
		int	slabs
	)

Sets mandatory global GE arrays for data acquisition (3D imaging)

The following global GE arrays are set based on slperpass (arg 1) and global op** variables:

• data_acq_order[]: Critical for scanning
• rsp_info[]: Copied from scan_info[] (the graphically prescibed slices), for conformance. Is a temporally sorted version of scan_info[] with integer rotation matrices. Not needed for scanning.
• rsptrigger[]: Set to TRIG_INTERN for now.

data_acq_order[] is only available on HOST, why this function also copies data_acq_order[] to ks_data_acq_order[], which is an ipgexport array accessible on both HOST and TGT. This can be used by ks_scan_getsliceloc() to be independent on rsp_info[] during scan.

GEReq_predownload_store_sliceplan3D() has different input args compared to the 2D version. Here, a temporary slice plan is created based on slices_in_slab and slabs in order to create the proper content of data_acq_order[]. Note that it wouldn't have worked to pass ks_slice_plan for 3D. This is because we need a ks_slice_plan that is consistent with RF excitations for 2D, 3D, 3DMS in each sequence's looping structure in scan. For 3D, this very ks_slice_plan can then not also create the proper data_acq_order array here. This is why we pass in slices_in_slab and slabs instead and create e temp slice plan solely for the purpose of data_acq_order.

Parameters

[in]	slices_in_slab	Number of slices in a slab
[in]	slabs	Number slabs

Return values

STATUS

SUCCESS or FAILURE

                                                                          {
  KS_SLICE_PLAN slice_plan;

  /* TODO: unclear for 3D MS, inteleaved and sequential */
  ks_calc_sliceplan_interleaved(&slice_plan, slices_in_slab * slabs, slices_in_slab, 1);

  return GEReq_predownload_store_sliceplan(slice_plan);

} /* GEReq_predownload_store_sliceplan3D() */

GEReq_predownload_setfilter_or_find_equivalent()

STATUS GEReq_predownload_setfilter_or_find_equivalent	(	FILTER_INFO *	myfilter,
		FILTER_BLOCK_TYPE	type
	)

Assigns a global filter slot for a main sequence

This function must be called in predownload() after GE's initfilter() function, which resets all filter slots for scan and prescan entry points. The initfilter() function is called in GEReq_cvinit().

Given the FILTER_INFO of the acquisition window for the main pulse sequence (arg 1), this function assigns a new slot number (that matches one of the hardware slots in the data receive chain.

The .epfilter and .epprexres of GE's global struct array entry_point_table[] is also set.

Parameters

[in]	myfilter	Pointer to FILTER_INFO struct (.filt field in KS_READ)
[in]	type	Choose between SCAN & PRESCAN

Return values

STATUS

SUCCESS or FAILURE

                                                                                                     {
  int i;
  /* PSD_FILTER_GEN psd_filt_spec --> setfilter.cpp */

  /* Filter has been set before, inititlization value for filter_slot = -1 (KS_NOTSET) in KS_INIT_FINFO */
  if (myfilter->fslot != KS_NOTSET){
    return SUCCESS;
  }

  for (i=0; i < PSD_FILTER_MAX; i++){
    if (psd_filt_spec[i].filter_slot == -1){
      /* psd_filt_spec is initialized with -1 for all slots, slots are filled in order, -1 indicates this one and all subsequent are unused yet */
      break;
    }

    if (psd_filt_spec[i].outputs == myfilter->outputs && (int) psd_filt_spec[i].filfrq*1000 == (int) myfilter->bw*1000){
      myfilter->fslot = i;
      /*ks_dbg("Existing filter slot %d found for outputs = %d, bw = %.1f", i, myfilter->outputs, myfilter->bw);*/
      return SUCCESS;
    }
  }

  if (i >= PSD_FILTER_MAX){
    ks_error("Requested filter slot %d (zero indexed) > PSD_FILTER_MAX (%d); outputs = %d, bw = %.1f ...", i, PSD_FILTER_MAX, myfilter->outputs, myfilter->bw);
    return FAILURE;
  }

  if (setfilter( myfilter, type) == FAILURE) {
      epic_error(use_ermes, "%s failed", EM_PSD_SUPPORT_FAILURE,
                EE_ARGS(1), STRING_ARG, "setfilter");
      return FAILURE;
  }

  /*ks_dbg("New filter slot %d taken for outputs = %d, bw = %.1f", myfilter->fslot , myfilter->outputs, myfilter->bw);*/

  return SUCCESS;

} /* GEReq_predownload_setfilter_or_find_equivalent() */

GEReq_get_num_used_slots()

int GEReq_get_num_used_slots

(

)

                               {
  int i;
  for (i=0; i < PSD_FILTER_MAX; i++){
    if (psd_filt_spec[i].filter_slot == -1){
      /* psd_filt_spec is initialized with -1 for all slots, slots are filled in order, -1 indicates this one and all subsequent are unused yet */
      break;
    }
  }
  return i;

} /* GEReq_get_num_used_slots() */

GEReq_get_maxsize_finfo()

PSD_FILTER_GEN GEReq_get_maxsize_finfo

(

int

n_prescan_slots

)

                                                            {
  int i;
  PSD_FILTER_GEN max_length_finfo = {0};
  max_length_finfo.outputs = 0;
  for (i = n_prescan_slots; i < PSD_FILTER_MAX; i++) {
    if(psd_filt_spec[i].outputs > max_length_finfo.outputs) {
      max_length_finfo = psd_filt_spec[i];
    }
    if (psd_filt_spec[i].filter_slot == -1){
      break;
    }
  }
  return max_length_finfo;

} /* GEReq_get_maxsize_finfo() */

GEReq_predownload_setfilter()

STATUS GEReq_predownload_setfilter

(

FILTER_INFO *

filt

)

                                                      {

  setfilter(filt, SCAN);

  entry_point_table[L_SCAN].epfilter = (unsigned char) filt->fslot;
  entry_point_table[L_SCAN].epprexres = filt->outputs;

  return SUCCESS;

} /* GEReq_predownload_setfilter() */

GEReq_echotrain_setfilters()

STATUS GEReq_echotrain_setfilters

(

KS_ECHOTRAIN *const

echotrain

)

                                                                 {
  STATUS status;
  int i, object_index;
  for (i = 0; i < echotrain->numreadouts; i++) {
    object_index = echotrain->controls[i].pg.object_index;
    if (echotrain->controls[i].pg.read_type == KS_READ_TRAP) {
      status = GEReq_predownload_setfilter_or_find_equivalent(&echotrain->readtraps[object_index].acq.filt, SCAN);
    } else {
      status = GEReq_predownload_setfilter_or_find_equivalent(&echotrain->readwaves[object_index].acq.filt, SCAN);
    }
    KS_RAISE(status);
  }
  return SUCCESS;

} /* GEReq_echotrain_setfilters() */

GEReq_predownload_minimize_ps_filter_slots()

STATUS GEReq_predownload_minimize_ps_filter_slots

(

)

                                                    {
  STATUS status;

  echo1cfl.fslot = KS_NOTSET; /*GE filter fslot is uninitialized, GEReq_predownload_setfilter_or_find_equivalent returns early if fslot is not -1 */
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1cfl, PRESCAN);
  KS_RAISE(status);
  filter_cfl_fid = echo1cfl.fslot;

  echo1rcvn.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1rcvn, PRESCAN);
  KS_RAISE(status);
  filter_rcvn_fid = echo1rcvn.fslot;

  echo1cfh.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1cfh, PRESCAN);
  KS_RAISE(status);
  filter_cfh_fid = echo1cfh.fslot;

  echo1mps1_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1mps1_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1mps1 = echo1mps1_filt.fslot;

  echo1ftg_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1ftg_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1ftg = echo1ftg_filt.fslot;
  filter_echo2ftg =  filter_echo1ftg; /* from prescan.e */

  echo1xtg_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1xtg_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1xtg = echo1xtg_filt.fslot;

  echo1as_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1as_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1as = echo1as_filt.fslot;

  echo1rs_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1rs_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1rs = echo1rs_filt.fslot;

  echo1dtg_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1dtg_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1dtg = echo1dtg_filt.fslot;

#if EPIC_RELEASE > 26
  echo1cal_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1cal_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1cal = echo1cal_filt.fslot;

  echo1coil_filt.fslot = KS_NOTSET;
  status = GEReq_predownload_setfilter_or_find_equivalent(&echo1coil_filt, PRESCAN);
  KS_RAISE(status);
  filter_echo1coil = echo1coil_filt.fslot;
#endif

  if(psddebugcode)  {
    dump_runtime_filter_info(psd_filt_spec);
  }

  return SUCCESS;

} /* GEReq_predownload_minimize_ps_filter_slots() */

GEReq_setfilters()

STATUS GEReq_setfilters

(

KS_SEQ_COLLECTION *const

seq_collection

)

                                                                 {
  STATUS status;
  int i_seqctrlptr, i_reads; 

  for (i_seqctrlptr = 0; i_seqctrlptr < seq_collection->numseq; i_seqctrlptr++) {

    KS_GRADRFCTRL* gradrf = &seq_collection->seqctrlptr[i_seqctrlptr]->gradrf; 

    for (i_reads = 0; i_reads < gradrf->numacq; i_reads++) {
      FILTER_INFO* filt = &gradrf->readptr[i_reads]->filt;
      status = GEReq_predownload_setfilter_or_find_equivalent(filt, SCAN);
      KS_RAISE(status);
    }

  }
  return SUCCESS;

} /* GEReq_setfilters() */

GEReq_predownload_genVRGF()

STATUS GEReq_predownload_genVRGF

(

const KS_READTRAP *const

readtrap

)

Generates the vrgf.param file for rampsampling correction

When the .rampsampling field of a KS_READTRAP is set to 1, 1D gridding in the frequency encoding direction is necessary before FFT to obtain an equidistant k-space. GE's product reconstruction uses a file (vrgf.param) for this, which is generated by this function.

See also GEReq_predownload_setrecon_readphase(), which sets VRGF-specific global variables.

Parameters

[in]

readtrap

Return values

STATUS

SUCCESS or FAILURE

                                                                     {
  FILE *fpVRGF = NULL;
  float beta = 1.0;
  float alpha = 2.0 / (beta + 1.0);
#ifdef SIM
  fpVRGF = fopen("./vrgf.param", "w");
#else
  #if EPIC_RELEASE > 29
    fpVRGF = fopen("/srv/nfs/psd/var/psddata/vrgf.param", "w");
  #else
    fpVRGF = fopen("/usr/g/bin/vrgf.param", "w");
  #endif
#endif

  if (fpVRGF == NULL) {
    return KS_THROW("Can't create vrgf.param");
  }

  /* based on: /ESE.../.../psdsupport/genVRGF.c  */

  /* NOTE: The static file /usr/g/bin/vrgf.param2, i.e. with a trailing "2", containing the following 
     must exist on the system in order for the executable /usr/g/bin/vrgf to generate vrgf.dat from 
     the vrgf.param we are about to write:
     VRGFNORM=   1
     GAIN=     1.0
     VRGFWN=     1
     ALPHA=   0.46
     BETA=     1.0
     VRGFODS=  0.0
     VRGFCC=     0
     VRGFGS=     1
     VRGFSGG=    0
     VRGFBWF= -1.0
  */


  fprintf(fpVRGF, "VRGFIP=    %d\n", readtrap->acq.filt.outputs);
  fprintf(fpVRGF, "VRGFOP=    %d\n", readtrap->res);
  fprintf(fpVRGF, "PERIOD=    %f\n", readtrap->acq.filt.tsp);
  fprintf(fpVRGF, "WAVE_CHOICE=  %d\n", 1);
  fprintf(fpVRGF, "G1=        %d\n", 1);
  fprintf(fpVRGF, "G2=        %f\n", readtrap->grad.amp);
  fprintf(fpVRGF, "G3=        %f\n", (readtrap->grad.plateautime / 2) / 1.0e6);
  fprintf(fpVRGF, "G4=        %f\n", readtrap->grad.ramptime / 1.0e6);
  fprintf(fpVRGF, "G5=        %f\n", alpha);
  fprintf(fpVRGF, "G6=        %f\n", beta);
  fprintf(fpVRGF, "G7=        %f\n", 0.0);
  fprintf(fpVRGF, "G8=        %f\n", readtrap->acq.rbw * 1.0e3);
  fprintf(fpVRGF, "G9=        %f\n", 0.0);

  if (fclose(fpVRGF) != 0) {
    return KS_THROW("Can't close vrgf.param");
  }

  return SUCCESS;

} /* GEReq_predownload_genVRGF() */

GEReq_predownload_genrowflip()

STATUS GEReq_predownload_genrowflip	(	KS_EPI *	epi,
		int	blipsign,
		int	assetflag,
		int	dorowflip
	)

Generates the rowflip.param file for KS_EPI

GE's reconstruction (and data dumping) of EPI data (where every other readout is negative) needs to know which k-space lines that have been acquired with a negative gradient to perform a row flip on these lines before proceeding with Pfile writing and FFT processing.

Parameters

[in]	epi	Pointer to KS_EPI
[in]	blipsign	KS_EPI_POSBLIPS or KS_EPI_NEGBLIPS
[in]	assetflag	Flag for ASSET mode or not (0: off, 2: ASSET_SCAN (on))
[in]	dorowflip	If 0, write just ones to let rowflipping process for Pfiles being executed without actual flipping

Return values

STATUS

SUCCESS or FAILURE

                                                                                             {
  FILE *rowflipfp = NULL;
  int i = 0;
  int j = 0;
  int kyview = 0;
  int view1st, viewskip;
  int readsign = 1;
  int rowskip, res;
#ifdef SIM
  rowflipfp = fopen("./rowflip.param", "w");
#else
  #if EPIC_RELEASE > 29
    rowflipfp = fopen("/srv/nfs/psd/var/psddata/rowflip.param", "w");
  #else
    rowflipfp = fopen("/usr/g/bin/rowflip.param", "w");
  #endif
#endif

  if (rowflipfp == NULL) {
    ks_error("Can't create rowflip.param");
  }


  fprintf(rowflipfp, "# EPI recon control\n");
  fprintf(rowflipfp, "#\n");
  fprintf(rowflipfp, "# ky line number/flip operation\n");
  fprintf(rowflipfp, "%d %d\n", 0, 1);

  if (assetflag == ASSET_SCAN) {
    rowskip = 1;
    res = epi->blipphaser.res / epi->blipphaser.R;
  } else {
    rowskip = epi->blipphaser.R;
    res = epi->blipphaser.res;
  }

  for (i = 0; i < epi->etl; i++) {
    for (j = 0; j < rowskip; j++) {
      kyview = i * rowskip + j;
      readsign = (i % 2) ? -1 : 1;
      if (blipsign == KS_EPI_POSBLIPS && (epi->etl % 2 == 0)) {
        readsign *= -1;
      }
      fprintf(rowflipfp, "%d %d\n", kyview + 1, (dorowflip) ? readsign : 1);
    }
  }
  for (kyview = i * rowskip + j; kyview < res; kyview++)
    fprintf(rowflipfp, "%d %d\n", kyview + 1, 1);

  fprintf(rowflipfp, "#\n#\n#intleave 1stview skip gpol bpol gy1f rfpol tf nechoes init_echo_pol\n" );

  for (j = 0; j < rowskip; j++) {
    if (blipsign == KS_EPI_POSBLIPS && (epi->etl % 2 == 0)) {
      view1st = (assetflag == ASSET_SCAN) ? (epi->blipphaser.numlinestoacq - 1) : (epi->blipphaser.linetoacq[(epi->blipphaser.numlinestoacq - 1)] + j);
      viewskip = -rowskip;
    } else {
      view1st = (assetflag == ASSET_SCAN) ? 0 : (epi->blipphaser.linetoacq[0] + j);
      viewskip = rowskip;
    }
    fprintf(rowflipfp, "%d %d %d %d %d %d %d %d %d %d\n", j, view1st + 1, viewskip, 1, blipsign, 0 /* max int dephaser */, 1 /* rfpol*/, 0 /* tf */, epi->etl, 1);
  }

  fprintf(rowflipfp, "# esp (usec)\n");
  fprintf(rowflipfp, "%d \n", epi->read.grad.duration);
  fprintf(rowflipfp, "# tsp (usec)\n");
  fprintf(rowflipfp, "%f \n", epi->read.acq.filt.tsp);
  fprintf(rowflipfp, "# input samples\n");
  fprintf(rowflipfp, "%d \n", epi->read.acq.filt.outputs);
  fprintf(rowflipfp, "# readout amplitude (G/cm)\n");
  fprintf(rowflipfp, "%f \n", epi->read.grad.amp);
  fprintf(rowflipfp, "# Row FT size\n");
  fprintf(rowflipfp, "%d \n", epi->read.res);
  fprintf(rowflipfp, "# rhhnover \n");
  fprintf(rowflipfp, "%d \n", epi->blipphaser.nover);
  fprintf(rowflipfp, "# etl\n");
  fprintf(rowflipfp, "%d \n", epi->etl);
  fprintf(rowflipfp, "# number of interleaves\n");
  fprintf(rowflipfp, "%d \n", epi->blipphaser.R);
  fprintf(rowflipfp, "# low pass filter setting (kHz), or -1 for std. rcvr.\n");
  fprintf(rowflipfp, "%d \n", -1);
  fprintf(rowflipfp, "# total number of images\n");
  fprintf(rowflipfp, "%d \n", opslquant);
  fprintf(rowflipfp, "# end of file");

  fclose(rowflipfp);

  return SUCCESS;

} /* GEReq_predownload_genrowflip() */

GEReq_predownload_setrecon_writekacq()

STATUS GEReq_predownload_setrecon_writekacq	(	const KS_READTRAP *const	readtrap,
		const KS_PHASER *const	phaser,
		const KS_PHASER *const	zphaser
	)

Writes a kacq_yz.txt.***** file for use with GE's product ARC recon

If phaser.R > 1, a file is written to disk with phase encoding steps in an ARC accelerated scan ("kacq_yz.txt.*****"). This function has been adapted from GE's ARC.e, but supports only 2D (i.e. 1D-acceleration)

Parameters

[in]	readtrap	Pointer to readout trapezoid. Used to determine k-space peak along kx
[in]	phaser	Pointer to phase encoding object (KS_PHASER) with acceleration
[in]	zphaser	Pointer to z phase encoding object (KS_PHASER) with acceleration. NULL for 2D

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                 {

  FILE *fp;
  CHAR kacqFilename[BUFSIZ];
  int view;
  int arc_kx_peak_pos = 0; /* sample point units */
  /* int arc_ky_peak_pos = -1; */
  const CHAR kacqArcFilename[BUFSIZ] = "kacq_yz.txt";
  int num_echoes = 1; /* we don't understand what a value > 1 would mean. cf. ARC.e */
  int echo_index, slice;
  int numzencodes = (zphaser != NULL) ? zphaser->numlinestoacq : 1;

#ifdef PSD_HW
  #if EPIC_RELEASE > 29
    const CHAR kacqPath[BUFSIZ] = "/srv/nfs/psd/var/psddata/";
  #else
    const CHAR kacqPath[BUFSIZ] = "/usr/g/psddata/";
  #endif
  sprintf(kacqFilename, "%s%s.%d", kacqPath, kacqArcFilename, rhkacq_uid);
#else
  const CHAR kacqPath[BUFSIZ] = "./";
  sprintf(kacqFilename, "%s%s", kacqPath, kacqArcFilename);
#endif

  fp = fopen(kacqFilename, "w");

  /* position of k-space center in sample points along kx
     time2center - acqdelay is the time in [us] from start of acq window to the center of k-space
     acq.filt.tsp is the time in [us] for one sample point (with or without ramp sampling */
  arc_kx_peak_pos = (readtrap->time2center - readtrap->acqdelay) / readtrap->acq.filt.tsp;

  /* kacq header */
  fprintf(fp, "GE_KTACQ\t201\t0\n");
  fprintf(fp, "num_sampling_patterns\t%d\n", num_echoes);
  fprintf(fp, "num_mask_patterns\t%d\n", 0);
  fprintf(fp, "kx_peak_pos\t%d\n", arc_kx_peak_pos);
  /* fprintf(fp, "ky_peak_pos\t%d\n", arc_ky_peak_pos); */
  fprintf(fp, "---\n");

  /* Reconstruction schedule */
  fprintf(fp, "# Reconstruction schedule\n");
  fprintf(fp, "# t, Echo, Cal Table, Cal Pass, Accel Table, Accel Pass, Mask Table\n");
  fprintf(fp, "RECON_SCHEDULE\t%d\t%d\n", num_echoes, 7);
  fprintf(fp, "---\n");
  for (echo_index = 0; echo_index < num_echoes; echo_index++) {
    fprintf(fp,"%d\t%d\t%d\t%d\t%d\t%d\t%d\n", 0, echo_index, -1, 0, echo_index, 0, -1);
  }

  /* Accelerated sampling pattern */
for (echo_index = 0; echo_index < num_echoes; echo_index++) {

  fprintf(fp, "# Sampling Pattern 0 (Accel)\n");
  fprintf(fp, "# View Offset, Pass Offset, ky, kz\n");

    fprintf(fp, "SAMPLING_PATTERN\t%d\t%d\n", phaser->numlinestoacq * numzencodes, 4);
    fprintf(fp, "max_stride\t%d\t%d\n", phaser->R, (zphaser != NULL) ? zphaser->R : 1);
  int dimy;
  if (phaser->nover != 0) {
    dimy = phaser->res / 2 + abs(phaser->nover); /* half nex */
  } else {
    dimy = phaser->res;
  }
  fprintf(fp, "pattern_dimensions\t%d\t%d\n", dimy, (zphaser != NULL) ? exist(opslquant) : 1);
  fprintf(fp, "---\n");
    for (slice = 0; slice < numzencodes; slice++) {
  for (view = 0; view < phaser->numlinestoacq; view++) {
        if (zphaser != NULL)
          fprintf(fp, "%d\t%d\t%d\t%d\n", phaser->linetoacq[view] + 1 + (zphaser->linetoacq[view] * num_echoes + echo_index) * rhdayres, 0, phaser->linetoacq[view], zphaser->linetoacq[slice]);
        else
          fprintf(fp, "%d\t%d\t%d\t%d\n", phaser->linetoacq[view] + 1 + echo_index * rhdayres, 0, phaser->linetoacq[view], 0);
  }
    }

  } /* echo */

  fclose(fp);


  return SUCCESS;

} /* GEReq_predownload_setrecon_writekacq() */

ks_get_unique_y_from_pecoords()

int ks_get_unique_y_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                             {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_y_z);

  int num_unique = 1;
  int prev_y = kacq->coords[0].y;
  int i;

  /* Count unique coordinates */
  for (i = 1; i < kacq->num_coords; i++) {
      if (kacq->coords[i].y != prev_y) {
          num_unique++;
          prev_y = kacq->coords[i].y;
      }
  }

  return num_unique;

} /* ks_get_unique_y_from_pecoords() */

ks_get_unique_z_from_pecoords()

int ks_get_unique_z_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                             {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_z_y);

  int num_unique = 1;
  int prev_y = kacq->coords[0].z;
  int i;

  for (i = 1; i < kacq->num_coords; i++) {
      if (kacq->coords[i].z != prev_y) {
          num_unique++;
          prev_y = kacq->coords[i].z;
      }
  }

  return num_unique;

} /* ks_get_unique_z_from_pecoords() */

ks_get_ynover_from_pecoords()

int ks_get_ynover_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                           {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_y_z);

  /* Shift coordinates */
  int nover_y_pre = kacq->coords[0].y;
  int nover_y_post = kacq->coords[kacq->num_coords-1].y + 1;


  return IMin(2, abs(nover_y_pre), abs(nover_y_post));

} /* ks_get_ynover_from_pecoords() */

ks_get_znover_from_pecoords()

int ks_get_znover_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                           {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_z_y);

  /* Shift coordinates */
  int nover_z_pre = kacq->coords[0].z;
  int nover_z_post = kacq->coords[kacq->num_coords-1].z + 1;


  return IMin(2, abs(nover_z_pre), abs(nover_z_post));

} /* ks_get_znover_from_pecoords() */

ks_get_ry_from_pecoords()

int ks_get_ry_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                       {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  int r = 1;
  int i;
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_z_y);
  for (i = 0; i < (kacq->num_coords-1); i++) {
    KS_KCOORD* cur_coord = kacq->coords + i;
    KS_KCOORD* next_coord = cur_coord + 1;
    if (cur_coord->z == next_coord->z) {
      r = IMax(2, r, next_coord->y - cur_coord->y);
    }
  }
  return r;

} /* ks_get_ry_from_pecoords() */

ks_get_rz_from_pecoords()

int ks_get_rz_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                        {
  int r = 1;
  int i;

  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }

  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_y_z);
  for (i = 0; i < (kacq->num_coords-1); i++) {
    KS_KCOORD* cur_coord = kacq->coords + i;
    KS_KCOORD* next_coord = cur_coord + 1;
    if (cur_coord->y == next_coord->y) {
      r = IMax(2, r, next_coord->z - cur_coord->z);
    }
  }
  return r;

} /* ks_get_rz_from_pecoords() */

ks_get_cal_z_from_pecoords()

int ks_get_cal_z_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                          {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  int max_contiguous = 1;
  int cur_contiguous = 1;
  int i;
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_y_z);
  for (i = 1; i < kacq->num_coords; i++) {
    KS_KCOORD* cur_coord = kacq->coords + i;
    KS_KCOORD* prev_coord = cur_coord - 1;
    if ( (cur_coord->y == prev_coord->y) &&
         (cur_coord->z == prev_coord->z + 1) ) {
      cur_contiguous++;
    } else {
      max_contiguous = IMax(2, max_contiguous, cur_contiguous);
      cur_contiguous = 1;
    }

  }
  return max_contiguous;

} /* ks_get_cal_z_from_pecoords() */

ks_get_cal_y_from_pecoords()

int ks_get_cal_y_from_pecoords

(

const KS_KSPACE_ACQ *

kacq

)

                                                          {
  if (kacq->coords == NULL) {
    KS_THROW("kacq->coords is NULL");
    return 0;
  }
  int max_contiguous = 1;
  int cur_contiguous = 1;
  int i;
  qsort(kacq->coords, kacq->num_coords, sizeof(KS_KCOORD), &ks_comp_kcoord_z_y);
  for (i = 1; i < kacq->num_coords; i++) {
    KS_KCOORD* cur_coord = kacq->coords + i;
    KS_KCOORD* prev_coord = cur_coord - 1;
    if ( (cur_coord->z == prev_coord->z) &&
         (cur_coord->y == prev_coord->y + 1) ) {
      cur_contiguous++;
    } else {
      max_contiguous = IMax(2, max_contiguous, cur_contiguous);
      cur_contiguous = 1;
    }

  }
  return max_contiguous;

} /* ks_get_cal_y_from_pecoords() */

GEReq_kacq_get_params()

ks_kacq_coord_params_t GEReq_kacq_get_params

(

const KS_KSPACE_ACQ *

kacq

)

                                                                        {
  ks_kacq_coord_params_t out;

  out.max_stride_phase = ks_get_ry_from_pecoords(kacq);
  out.max_stride_slice = ks_get_rz_from_pecoords(kacq);

  out.max_contigous_phase = ks_get_cal_y_from_pecoords(kacq);
  out.max_contigous_slice = ks_get_cal_z_from_pecoords(kacq);


  out.nover_phase = ks_get_ynover_from_pecoords(kacq);
  out.nover_slice = ks_get_znover_from_pecoords(kacq);
  out.extent_phase = kacq->matrix_size[YGRAD];
  out.extent_slice = IMax(2, kacq->matrix_size[ZGRAD], 1);
  out.unique_phase = ks_get_unique_y_from_pecoords(kacq);
  out.unique_slice = ks_get_unique_z_from_pecoords(kacq);

  return out;

} /* GEReq_kacq_get_params() */

GEReq_writekacq()

STATUS GEReq_writekacq	(	const int	nrecon_schedule_entries,
		KS_KACQ_RECONSHEDULE_ENTRY *	recon_schedule,
		const int	num_patterns,
		const KS_KSPACE_ACQ *	ks_kacq
	)

                                                       {

  const int nmask_patterns = 0;
  /* start off getting a file pointer */
  const CHAR *kacqFilenameBase = "kacq_yz.txt";
  FILE *kacq;
  CHAR kacqFilename[1024];
  CHAR kacqFilenameFull[1024];
#ifdef PSD_HW
  #if EPIC_RELEASE > 29
    const CHAR kacqPath[BUFSIZ] = "/srv/nfs/psd/var/psddata/";
  #else
    const CHAR kacqPath[BUFSIZ] = "/usr/g/psddata/";
  #endif
    sprintf(kacqFilename, "%s.%d", kacqFilenameBase, rhkacq_uid);
#else
    const CHAR *kacqPath = "./";
    sprintf(kacqFilename, "%s", kacqFilenameBase);
#endif
    sprintf(kacqFilenameFull, "%s%s", kacqPath, kacqFilename);

    kacq = fopen(kacqFilenameFull, "w");

    ks_dbg("Print things to %s", kacqFilename);

    /* next, we write a header */
    fprintf(kacq, "GE_KTACQ\t%d\t%d\n", 201 /*KACQ_REV_MAJOR*/, 0/*KACQ_REV_MINOR*/);
    fprintf(kacq, "num_sampling_patterns\t%d\n", num_patterns);
    fprintf(kacq, "num_mask_patterns\t%d\n", nmask_patterns);

    /* Not required 
    fprintf(kacq, "kx_peak_pos\t%d\n", kx_peak_pos);
    */
    fprintf(kacq, "---\n");

    /* print out reconstruction schedule */
    fprintf(kacq, "# Reconstruction schedule\n");
    fprintf(kacq, "# t, Echo, Cal Table, Cal Pass, Accel Table, Accel Pass, Mask Table\n");
    fprintf(kacq, "RECON_SCHEDULE\t%d\t%d\n", nrecon_schedule_entries, 7);
    fprintf(kacq, "---\n"); 

    const int TAB_DEPTH = 256;
    if (nrecon_schedule_entries > TAB_DEPTH) {
      return KS_THROW("Wow, you'll need to increase the reconschedule table depth to at least %d", nrecon_schedule_entries);
    }
    int acq_table_mapping[TAB_DEPTH];
    int cal_table_mapping[TAB_DEPTH];
    int msk_table_mapping[TAB_DEPTH];
    int num_acq_patterns = 0;
    int num_cal_patterns = 0;
    int num_msk_patterns = 0;
    int i;
    int num_echos = 0;
    for (i = 0; i < nrecon_schedule_entries; i++) {

      KS_KACQ_RECONSHEDULE_ENTRY entry = recon_schedule[i];
      int acq_table_pos;
      if (entry.sampling_pattern_offset == KS_NOTSET) {
        return KS_THROW("All reconshedule entries require a valid sampling pattern.");
      } else {
        acq_table_pos = num_acq_patterns; /* direct mapping entry_index->acq_index */
        acq_table_mapping[num_acq_patterns] = entry.sampling_pattern_offset;
        num_acq_patterns++;
      }
      int cal_table_pos;
      if (entry.calibration_pattern_offset == KS_NOTSET) {
        cal_table_pos = KS_NOTSET;
      } else {
        cal_table_pos = nrecon_schedule_entries + num_cal_patterns; /* after the acq patterns */
        cal_table_mapping[num_cal_patterns] = entry.calibration_pattern_offset;
        num_cal_patterns++;
      }
      int mask_table_pos;
      if (entry.mask_pattern_offset == KS_NOTSET) {
        mask_table_pos = KS_NOTSET;
      } else {
        mask_table_pos = num_msk_patterns; /* seperate table */
        msk_table_mapping[num_msk_patterns] = entry.mask_pattern_offset;
        num_msk_patterns++;
      }
      fprintf(kacq, "%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
            /*t, Echo,              Cal Table,     Cal Pass, Accel Table,   Accel Pass, Mask Table\*/
              i, entry.echo_index,  cal_table_pos, i,        acq_table_pos, i,          mask_table_pos);

      if (num_echos < entry.echo_index) {
        num_echos = entry.echo_index;
      }

    }
    /* does this match what we said? */
    if (num_echos != (rhnecho-1)) {
      return KS_THROW("There appears to be a mismatch between the recon schedule and the nechoes in the psd (%d != %d)", num_echos, rhnecho-1);
    } else {
      num_echos++; /* +1 for the number of echos not the index */
    }

    /* write out the acq "sampling patterns" one for each recon entry */
    int pattern;
    for (i = 0; i < num_acq_patterns; i++) {
        pattern = acq_table_mapping[i];
        /* intialise some variables */
        ks_kacq_coord_params_t params = GEReq_kacq_get_params(ks_kacq + pattern);

        /* time to write to the file */
        fprintf(kacq, "# Sampling Pattern %d (Accel)\n", i);
        fprintf(kacq, "# View Offset, Pass Offset, ky, kz\n");
        fprintf(kacq, "SAMPLING_PATTERN\t%d\t%d\n", ks_kacq[pattern].num_coords, 4);
        fprintf(kacq, "max_stride\t%d\t%d\n", params.max_stride_phase, params.max_stride_slice);
        const int dim_y = rhhnover == 0 ? params.extent_phase
                                        : params.extent_phase/2 + params.nover_phase + params.max_stride_phase -1 /* Expect R-1 blank lines */;
        fprintf(kacq, "pattern_dimensions\t%d\t%d\n", dim_y, params.extent_slice);
        fprintf(kacq, "---\n");
        int coord;
        for (coord = 0; coord < ks_kacq[pattern].num_coords; coord++) {
          KS_KCOORD kcoord = ks_kacq[pattern].coords[coord];
          kcoord.y += params.extent_phase / 2;
          kcoord.z += params.extent_slice / 2;
          int frame = kcoord.y + 1 + (params.extent_phase + 1) * (num_echos * kcoord.z + recon_schedule[i].echo_index);
          if ((kcoord.y != KS_NOTSET) && (kcoord.z != KS_NOTSET)) {
            fprintf(kacq, "%d\t%d\t%d\t%d\n", frame, 0, kcoord.y, kcoord.z);
          }
        }
    }

    /* write out the cal "sampling patterns" offset by nrecon_schedule_entries */
    for (i = 0; i < num_cal_patterns; i++) {
        pattern = cal_table_mapping[i];
        /* intialise some variables */
        ks_kacq_coord_params_t params = GEReq_kacq_get_params(ks_kacq + pattern);

        /* time to write to the file */
        fprintf(kacq, "# Sampling Pattern %d (Calibration)\n", i + nrecon_schedule_entries);
        fprintf(kacq, "# View Offset, Pass Offset, ky, kz\n");
        fprintf(kacq, "SAMPLING_PATTERN\t%d\t%d\n", ks_kacq[pattern].num_coords, 4);
        fprintf(kacq, "pattern_dimensions\t%d\t%d\n",
                params.extent_phase, params.extent_slice);
        fprintf(kacq, "cal_apodization_kasier_bessel_beta\t%f\t%f\n", 1.0, 1.0);
        /* Some extra options ---
        fprintf(kacq, "fully_sampled_start\t%d\t%d\n",
                    calRegion.phaseCutoffLower, calRegion.sliceCutoffLower);
        fprintf(kacq, "fully_sampled_length\t%d\t%d\n",
                calRegion.phaseCutoffUpper - calRegion.phaseCutoffLower + 1,
                calRegion.sliceCutoffUpper - calRegion.sliceCutoffLower + 1);*/
        fprintf(kacq, "---\n");
        int coord;
        for (coord = 0; coord < ks_kacq[pattern].num_coords; coord++) {
          KS_KCOORD kcoord = ks_kacq[pattern].coords[coord];
          kcoord.y += params.extent_phase / 2;
          kcoord.z += params.extent_slice / 2;
          int frame = kcoord.y + 1 + (params.extent_phase + 1) * (num_echos * kcoord.z + recon_schedule[pattern].echo_index);
          if ((kcoord.y != KS_NOTSET) && (kcoord.z != KS_NOTSET)) {
            fprintf(kacq, "%d\t%d\t%d\t%d\n", frame, 0, kcoord.y, kcoord.z);
          }
        }
    }

    /* write out the mask patterns at the end */
    for (i = 0; i < num_msk_patterns; i++) {
      pattern = msk_table_mapping[i];
      ks_kacq_coord_params_t params = GEReq_kacq_get_params(ks_kacq + pattern);

      fprintf(kacq, "# Mask pattern %d\n", i);
      fprintf(kacq, "# ky, kz\n");
      fprintf(kacq, "MASK_PATTERN\t%d\t%d\n", ks_kacq[pattern].num_coords, 2);
      fprintf(kacq, "pattern_dimensions\t%d\t%d\n",
                params.extent_phase, params.extent_slice);
      fprintf(kacq, "---\n");
      int coord;
      for (coord = 0; coord < ks_kacq[pattern].num_coords; coord++) {
        KS_KCOORD kcoord = ks_kacq[pattern].coords[coord];
        kcoord.y += params.extent_phase / 2;
        kcoord.z += params.extent_slice / 2;
        fprintf(kacq, "%d\t%d\n", kcoord.y, kcoord.z);
      }
    }

    /* close the file */
    fclose(kacq);


    return SUCCESS;

} /* GEReq_writekacq() */

GEReq_writekacq_from_coords()

STATUS GEReq_writekacq_from_coords	(	const KS_KSPACE_ACQ *	kacq,
		const int	nechoes
	)

                                                                                 {
  KS_KACQ_RECONSHEDULE_ENTRY recon_table[16];
  int echo;
  for (echo = 0; echo < nechoes; echo++) {
    recon_table[echo].sampling_pattern_offset = 0;
    recon_table[echo].calibration_pattern_offset = KS_NOTSET;
    recon_table[echo].mask_pattern_offset = KS_NOTSET;
    recon_table[echo].echo_index = echo;
  }
  return GEReq_writekacq(nechoes, recon_table, nechoes, kacq);

} /* GEReq_writekacq_from_coords() */

GEReq_predownload_setrecon_accel_from_coords()

STATUS GEReq_predownload_setrecon_accel_from_coords	(	const KS_KSPACE_ACQ *	kacq,
		const int	is_pf_y,
		const int	nechoes
	)

Sets rh*** variables related to parallel imaging using kSpace coordinates

Parameters

[in]	kacq	k-Space coordinates.
[in]	is_pf_y	Flag if partial Fourier along Y.
[in]	nechoes	Number of echoes. Only relevant for kacq file, i.e. ARC + online recon

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                     {

  ks_kacq_coord_params_t params = GEReq_kacq_get_params(kacq);

  if ((params.max_stride_phase < 1) || (params.max_stride_slice < 1))  {
    return KS_THROW("Max stride cannot be negative (Ry == %d, Rz == %d)", params.max_stride_phase, params.max_stride_slice);
  }

  /* make sure we will be able to set all these CVs */
  _rhasset.fixedflag = FALSE;
  _rhasset_R.fixedflag = FALSE;
  _rhhnover.fixedflag = FALSE;
  _rhnframes.fixedflag = FALSE;
  _rhdayres.fixedflag = FALSE;

  rhtype1 |= RHTYP1BAM0FILL; /* zero fill bam before start of acq */

  int nover_y = 0;
  int nframes = params.extent_phase;
  if (is_pf_y) {
    nover_y = RUP_FACTOR(params.nover_phase, 2); /* Note that rhhnover must be even but it's fine to scan with odd */
    nframes /= 2;
    rhtype |= RHTYPFRACTNEX;
  } else {
    rhtype &= ~RHTYPFRACTNEX;
  }


  rhasset_R = 1.0 / params.max_stride_phase;
  rhassetsl_R = 1.0 / params.max_stride_slice;

  if (params.max_stride_phase > 1) {
    if (params.max_contigous_phase > 1) {
      rhasset = ACCEL_ARC;
    } else {
      rhasset = ASSET_SCAN; /* There are no ACS lines */
    }
  } else {
    rhasset = 0;
  }
  if (rhasset == ASSET_SCAN) {
    /* ASSET uses compressed BAM, i.e. stores only the acquired lines */
    rhhnover = nover_y / params.max_stride_phase;
    rhnframes = nframes / params.max_stride_phase;
    rhdayres = rhnframes + rhhnover + 1;
  } else {
    rhhnover = nover_y;
    if (rhasset == ACCEL_ARC) {
      rhnframes = params.unique_phase; /* Previously numlinestoacq */
      if (nover_y == 0) {
        rhdayres = params.extent_phase + 1;
      } else {
        rhdayres = rhhnover + params.extent_phase/2 + 1;
      }
    } else {
      rhnframes = nframes;
      rhdayres = rhhnover + rhnframes + 1; /* As given by Abel */
    }
  }

  return GEReq_writekacq_from_coords(kacq, nechoes);

} /* GEReq_predownload_setrecon_accel_from_coords() */

GEReq_predownload_setrecon_accel()

STATUS GEReq_predownload_setrecon_accel	(	const KS_READTRAP *const	readtrap,
		const KS_PHASER *const	phaser,
		const KS_PHASER *const	zphaser,
		int	datadestination
	)

Sets rh*** variables related to parallel imaging acceleration

Parameters

[in]	readtrap	Pointer to KS_READTRAP
[in]	phaser	Pointer to KS_PHASER (phase)
[in]	zphaser	Pointer to KS_PHASER (slice). NULL for 2D
[in]	datadestination	Value to assign to rhexecctrl (c.f. epic.h)

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                                  {
  STATUS status;

  /* make sure we will be able to set all these CVs */
  _rhasset.fixedflag = FALSE;
  _rhasset_R.fixedflag = FALSE;
  _rhhnover.fixedflag = FALSE;
  _rhnframes.fixedflag = FALSE;
  _rhdayres.fixedflag = FALSE;

  if (phaser->R <= 1 && (zphaser == NULL || zphaser->R <= 1)) {
    rhasset = 0;
    rhasset_R = 1.0;
    rhassetsl_R = 1.0;
    return SUCCESS;
  }

  rhtype1 |= RHTYP1BAM0FILL; /* once more, just in case */

  if (datadestination & RHXC_XFER_IM) {
    /* if we are going to use GE recon (RHXC_XFER_IM = 8) */

    if (phaser->nacslines > 0) { /* ARC */

      /* ARC uses full BAM, i.e. stores the acquired lines at their proper locations in k-space with zero lines in between */
      rhhnover = abs(phaser->nover);
      rhnframes = phaser->numlinestoacq; /* # of acquired lines */
      rhdayres = (phaser->nover != 0) ? (phaser->res/2 + abs(phaser->nover) + 1) : (phaser->res + 1);

      rhasset = ACCEL_ARC; /* tell recon we are doing ARC only if we have ACS lines  */
      status = GEReq_predownload_setrecon_writekacq(readtrap, phaser, zphaser);
      KS_RAISE(status);

    } else { /* ASSET */

      /* ASSET uses compressed BAM, i.e. stores only the acquired lines */
      rhhnover = abs(phaser->nover) / phaser->R;
      rhnframes = (phaser->nover != 0) ? (phaser->res / (2 * phaser->R)) : (phaser->res / phaser->R);
      rhdayres = rhnframes + rhhnover + 1;

      rhasset = ASSET_SCAN; /* if we don't have ACS lines, we will need to recon the data using some external calibration */
    }

  } else {

    /* store data as ARC (full BAM) */
    rhhnover = abs(phaser->nover);
    rhnframes = phaser->numlinestoacq; /* # of acquired lines */
    rhdayres = (phaser->nover != 0) ? (phaser->res / 2 + abs(phaser->nover) + 1) : (phaser->res + 1);

    rhasset = 0; /* we are going to do the reconstruction offline */
  }

  rhasset_R = 1.0 / phaser->R; /* inverse of acceleration factor */
  rhassetsl_R = (zphaser != NULL) ? (1.0 / zphaser->R) : 1;

  return SUCCESS;

} /* GEReq_predownload_setrecon_accel() */

GEReq_predownload_setrecon_phase()

void GEReq_predownload_setrecon_phase	(	const KS_PHASER *const	phaser,
		const float	readfov,
		const int	datadestination
	)

                                                                                                                       {
  /* make sure we will be able to set all these CVs */
  _rhasset.fixedflag = FALSE;
  _rhasset_R.fixedflag = FALSE;
  _rhhnover.fixedflag = FALSE;
  _rhnframes.fixedflag = FALSE;
  _rhdayres.fixedflag = FALSE;

  if (phaser->nover != 0) { /* partial Fourier ky */
    rhnframes = phaser->res / 2;
    rhtype |= RHTYPFRACTNEX;
  } else {
    rhnframes = phaser->res;
    rhtype &= ~RHTYPFRACTNEX;
  }

  rhhnover = abs(phaser->nover);
  rhdayres = rhnframes + rhhnover + 1;


  rhexecctrl = datadestination;
  if (op3dgradwarp && !(rhexecctrl & RHXC_XFER_IM)) {
    /* 3D gradwarp requires at least one of the following bits set:
       #define RHXC_XFER_IM                    0x0008  8 (GE online recon)
       #define RHXC_SAVE_IM                    0x0010  16
    */
    (rhexecctrl) |= RHXC_SAVE_IM; /* parentheses around rhexecctrl prevents EPIC preprocessor to add fixedflag check */
  }

  rhphasescale = phaser->fov / readfov;
  if (phaser->R <= 1) {
    rhasset = 0;
    rhasset_R = 1.0;
    return;
  }

  rhtype1 |= RHTYP1BAM0FILL; /* once more, just in case */

  if (datadestination & RHXC_XFER_IM) {
    /* if we are going to use GE recon (RHXC_XFER_IM = 8) */
    if (phaser->nacslines > 0) { /* ARC */
      /* ARC uses full BAM, i.e. stores the acquired lines at their proper locations in k-space with zero lines in between */
      rhhnover = abs(phaser->nover);
      rhnframes = phaser->numlinestoacq; /* # of acquired lines */
      rhdayres = (phaser->nover != 0) ? (phaser->res/2 + abs(phaser->nover) + 1) : (phaser->res + 1);
      rhasset = ACCEL_ARC; /* tell recon we are doing ARC only if we have ACS lines  */
    } else { /* ASSET */
      /* ASSET uses compressed BAM, i.e. stores only the acquired lines */
      rhhnover = abs(phaser->nover) / phaser->R;
      rhnframes = (phaser->nover != 0) ? (phaser->res / (2 * phaser->R)) : (phaser->res / phaser->R);
      rhdayres = rhnframes + rhhnover + 1;
      rhasset = ASSET_SCAN; /* if we don't have ACS lines, we will need to recon the data using some external calibration */
    }
  } else {
    /* store data as ARC (full BAM) */
    rhhnover = abs(phaser->nover);
    rhnframes = phaser->numlinestoacq; /* # of acquired lines */
    rhdayres = (phaser->nover != 0) ? (phaser->res / 2 + abs(phaser->nover) + 1) : (phaser->res + 1);
    rhasset = 0; /* we are going to do the reconstruction offline */
  }

  rhasset_R = 1.0 / phaser->R; /* inverse of acceleration factor */

} /* GEReq_predownload_setrecon_phase() */

GEReq_predownload_setrecon_readwave()

void GEReq_predownload_setrecon_readwave	(	const KS_READWAVE *const	readwave,
		const int	yres,
		const int	xres,
		int	imsize_policy,
		int	datadestination
	)

                                                                                                                                                    {
  int max_xy;

  /* make sure we will be able to set all these CVs */
  _rhfrsize.fixedflag = FALSE;
  _rhdaxres.fixedflag = FALSE;
  _rhvrgf.fixedflag = FALSE;
  _rhvrgfxres.fixedflag = FALSE;

  /* raw data freq (x) size (works for both non-VRGF and VRGF) */
  rhfrsize = readwave->acq.filt.outputs;
  rhdaxres = xres;


  piforkvrgf = 0; /* 1 causes scan to spawn the vrgf process upon download */
  rhtype1 &= ~(RHTYP1FVRGF + RHTYP1PCORVRGF);
  rhuser32 = 0.0;
  rhuser33 = 0.0;
  rhuser34 = 0.0;
  rhuser35 = 0.0;

  /* image size */
  max_xy = IMax(2, xres, yres);

  rhmethod = 1; /* enable reduced image size, so we are in control */
  if (imsize_policy == KS_IMSIZE_MIN256) {
    max_xy = IMax(2, max_xy, 256);
  } else if (imsize_policy == KS_IMSIZE_POW2) {
    max_xy = ks_calc_nextpow2((unsigned int) max_xy); /* round up to nearest power of 2 if imsize_policy = KS_IMSIZE_POW2 */
  }

  /* recon image size with optional zerofilling */
  if (opzip512 && max_xy < 512) {
    max_xy = 512;
  } else if (opzip1024 && max_xy < 1024) {
    max_xy = 1024;
  }
  rhimsize = max_xy;
  rhrcxres = rhimsize;
  rhrcyres = rhimsize;

  /* freq. partial Fourier */
  if (abs(readwave->nover) > 0) {
    /* fractional echo (partial Fourier kx) */
    pitfeextra = rhfrsize * abs(readwave->nover) / (float)(readwave->res/2 + abs(readwave->nover));
  } else {
    pitfeextra = 0;
  }
  /* rhheover = pitfeextra; */
  rhfeextra = abs(readwave->nover);

  /* chopping control */
  rhtype |= RHTYPCHP; /* ( |= 1) no chopping processing needed in recon */

  /* 3D recon flag */
  if(opimode == PSD_3D || opimode == PSD_3DM)
    rhtype |= RHTYP3D;
  else
    rhtype &= ~RHTYP3D;


} /* GEReq_predownload_setrecon_readwave() */

GEReq_predownload_setrecon_image()

void GEReq_predownload_setrecon_image	(	const int	xres,
		const int	yres,
		const float	xfov,
		const float	yfov,
		const ks_enum_imsize	imsize_policy
	)

                                                                                                                                              {
   /* image size */
  int max_xy = IMax(2, xres, yres);

  rhmethod = 1; /* enable reduced image size, so we are in control */
  if (imsize_policy == KS_IMSIZE_MIN256) {
    max_xy = (max_xy > 256) ? (IMax(2, 512, max_xy))
                            : 256; /* final image size is either 256, 512, or higher than 512 */
  } else if (imsize_policy == KS_IMSIZE_POW2) {
    max_xy = ks_calc_nextpow2((unsigned int) max_xy);
  }

  /* recon image size with optional zerofilling */
  if (opzip512 && max_xy < 512) {
    max_xy = 512;
  } else if (opzip1024 && max_xy < 1024) {
    max_xy = 1024;
  }
  rhimsize = max_xy;
  rhrcxres = rhimsize;
  rhrcyres = rhimsize;

  rhphasescale = yfov / xfov;

} /* GEReq_predownload_setrecon_image() */

GEReq_predownload_setrecon_readtrap()

void GEReq_predownload_setrecon_readtrap	(	const KS_READTRAP *const	readtrap,
		int	datadestination
	)

                                                                                                  {

  /* make sure we will be able to set all these CVs */
  _rhfrsize.fixedflag = FALSE;
  _rhdaxres.fixedflag = FALSE;
  _rhvrgf.fixedflag = FALSE;
  _rhvrgfxres.fixedflag = FALSE;

  /* raw data freq (x) size (works for both non-VRGF and VRGF) */
  rhfrsize = readtrap->acq.filt.outputs;
  rhdaxres = readtrap->acq.filt.outputs;

  /* ramp sampling */
  rhvrgf = readtrap->rampsampling;
  rhvrgfxres = readtrap->res;

  if (readtrap->rampsampling) {
    piforkvrgf = 1; /* 1 causes scan to spawn the vrgf process upon download */
    rhtype1 |= (RHTYP1FVRGF + RHTYP1PCORVRGF); /* VRGF and VRGFafterPC */

    /* write vrgf.param */
    GEReq_predownload_genVRGF(readtrap);

    /* VRGF (rampsampling): Store shape of the read lobe to determine the k-space travel along kx (freq. dir.) for offline VRGF correction */
    rhuser32 = readtrap->acq.filt.tsp; /* time between sample points [often 2us] */
    rhuser33 = readtrap->grad.amp; /* Readout gradient amplitude */
    rhuser34 = (float) (readtrap->grad.plateautime / 2) / 1.0e6; /* half plateau time */
    rhuser35 = (float) (readtrap->grad.ramptime) / 1.0e6; /* attack/decay time */
  } else {
    piforkvrgf = 0;
    rhtype1 &= ~(RHTYP1FVRGF + RHTYP1PCORVRGF);
  }

  /* freq. partial Fourier */
  if (abs(readtrap->nover) > 0) {
    /* fractional echo (partial Fourier kx) */
    pitfeextra = rhfrsize - readtrap->res / 2;
  } else {
    pitfeextra = 0;
  }
  rhfeextra = pitfeextra;

  /* chopping control */
  rhtype |= RHTYPCHP; /* ( |= 1) no chopping processing needed in recon */

  /* 3D recon flag */
  if (KS_3D_SELECTED)
    rhtype |= RHTYP3D;
  else
    rhtype &= ~RHTYP3D;

  rhexecctrl = datadestination;
  if (op3dgradwarp && !(rhexecctrl & RHXC_XFER_IM)) {
    /* 3D gradwarp requires at least one of the following bits set:
        #define RHXC_XFER_IM                    0x0008  8 (GE online recon)
        #define RHXC_SAVE_IM                    0x0010  16
    */
    (rhexecctrl) |= RHXC_SAVE_IM; /* parentheses around rhexecctrl prevents EPIC preprocessor to add fixedflag check */
  }

  if (datadestination & RHXC_XFER_IM) {
    rhdacqctrl &= ~8192; /* enable GE's Orchestra Live recon */
  } else {
    rhdacqctrl |= 8192; /* disable GE's Orchestra Live recon */
  }


} /* GEReq_predownload_setrecon_readtrap() */

GEReq_predownload_setrecon_readphase()

void GEReq_predownload_setrecon_readphase	(	const KS_READTRAP *const	readtrap,
		const KS_PHASER *const	phaser,
		const KS_PHASER *const	zphaser,
		int	imsize_policy,
		int	datadestination
	)

Sets required global rh*** variables for Cartsian imaging

For Cartesian pulse sequences, using one KS_READTRAP and one KS_PHASER (each of which may have multiple instances), the required rh*** variables are set based on the content of the sequence objects KS_READTRAP (arg 1) and KS_PHASER (arg 2). The fields in each sequence object, including e.g. partial Fourier and rampsampling, controls the setting of GE's rh*** variables. In addition, the third argument specifies the desired upsampling policy for small matrix sizes.

Parameters

[in]	readtrap	Pointer to KS_READTRAP
[in]	phaser	Pointer to KS_PHASER
[in]	zphaser	Pointer to KS_PHASER (slice). NULL for 2D
[in]	imsize_policy	Choose between KS_IMSIZE_NATIVE, KS_IMSIZE_POW2, KS_IMSIZE_MIN256
[in]	datadestination	Value for the rhexecctrl variable. Bitmasks for: KS_SAVEPFILES (dump Pfiles) and KS_GERECON (product recon)

Returns

void

                                                                                                                                                                                       {
  int max_xy;

  /* make sure we will be able to set all these CVs */
  _rhfrsize.fixedflag = FALSE;
  _rhdaxres.fixedflag = FALSE;
  _rhdayres.fixedflag = FALSE;
  _rhnframes.fixedflag = FALSE;
  _rhhnover.fixedflag = FALSE;
  _rhvrgf.fixedflag = FALSE;
  _rhvrgfxres.fixedflag = FALSE;
  _rhasset.fixedflag = FALSE;
  _rhasset_R.fixedflag = FALSE;

  /* raw data freq (x) size (works for both non-VRGF and VRGF) */
  rhfrsize = readtrap->acq.filt.outputs;
  rhdaxres = readtrap->acq.filt.outputs;

  /* ramp sampling */
  rhvrgf = readtrap->rampsampling;
  rhvrgfxres = readtrap->res;

  if (readtrap->rampsampling) {
    piforkvrgf = 1; /* 1 causes scan to spawn the vrgf process upon download */
    rhtype1 |= (RHTYP1FVRGF + RHTYP1PCORVRGF); /* VRGF and VRGFafterPC */

    /* write vrgf.param */
    GEReq_predownload_genVRGF(readtrap);

    /* VRGF (rampsampling): Store shape of the read lobe to determine the k-space travel along kx (freq. dir.) for offline VRGF correction */
    rhuser32 = readtrap->acq.filt.tsp; /* time between sample points [often 2us] */
    rhuser33 = readtrap->grad.amp; /* Readout gradient amplitude */
    rhuser34 = (float) (readtrap->grad.plateautime / 2) / 1.0e6; /* half plateau time */
    rhuser35 = (float) (readtrap->grad.ramptime) / 1.0e6; /* attack/decay time */
  } else {
    piforkvrgf = 0; /* 1 causes scan to spawn the vrgf process upon download */
    rhtype1 &= ~(RHTYP1FVRGF + RHTYP1PCORVRGF);
    rhuser32 = 0.0;
    rhuser33 = 0.0;
    rhuser34 = 0.0;
    rhuser35 = 0.0;
  }


  /* image size */
  if (phaser != NULL) {
    max_xy = IMax(2, readtrap->res, phaser->res);
  } else {
    max_xy = readtrap->res;
  }

  rhmethod = 1; /* enable reduced image size, so we are in control */
  if (imsize_policy == KS_IMSIZE_MIN256) {
    max_xy = (max_xy > 256) ? 512 : 256; /* final image size is either 512 or 256 */
  } else if (imsize_policy == KS_IMSIZE_POW2) {
    max_xy = ks_calc_nextpow2((unsigned int) max_xy); /* round up to nearest power of 2 if imsize_policy = KS_IMSIZE_POW2 */
  }

  /* recon image size with optional zerofilling */
  if (opzip512 && max_xy < 512) {
    max_xy = 512;
  } else if (opzip1024 && max_xy < 1024) {
    max_xy = 1024;
  }
  rhimsize = max_xy;
  rhrcxres = rhimsize;
  rhrcyres = rhimsize;

  /* freq. partial Fourier */
  if (abs(readtrap->nover) > 0) {
    /* fractional echo (partial Fourier kx) */
    pitfeextra = rhfrsize - readtrap->res / 2;
  } else {
    pitfeextra = 0;
  }
  rhfeextra = pitfeextra;

  /* chopping control */
  rhtype |= RHTYPCHP; /* ( |= 1) no chopping processing needed in recon */

  /* 3D recon flag */
  if (KS_3D_SELECTED)
    rhtype |= RHTYP3D;
  else
    rhtype &= ~RHTYP3D;

  /* phase encoding (see also GEReq_predownload_setrecon_accel(), which may override these values) */
  if (phaser != NULL) {
    if (phaser->nover != 0) { /* partial Fourier ky */
      rhnframes = phaser->res / 2;
      rhtype |= RHTYPFRACTNEX;
    } else {
      rhnframes = phaser->res;
      rhtype &= ~RHTYPFRACTNEX;
    }

    rhhnover = abs(phaser->nover);
    rhdayres = rhnframes + rhhnover + 1;

    rhexecctrl = datadestination;
    if (op3dgradwarp && !(rhexecctrl & RHXC_XFER_IM)) {
      /* 3D gradwarp requires at least one of the following bits set:
         #define RHXC_XFER_IM                    0x0008  8 (GE online recon)
         #define RHXC_SAVE_IM                    0x0010  16
      */
      (rhexecctrl) |= RHXC_SAVE_IM; /* parentheses around rhexecctrl prevents EPIC preprocessor to add fixedflag check */
    }

    if (datadestination & RHXC_XFER_IM) {
      rhdacqctrl &= ~8192; /* enable GE's Orchestra Live recon */
    } else {
      rhdacqctrl |= 8192; /* disable GE's Orchestra Live recon */
    }

    /* Set up ARC/ASSET flags if R > 1 otherwise shut them off */
    GEReq_predownload_setrecon_accel(readtrap, phaser, zphaser, datadestination);

    rhphasescale = phaser->fov / readtrap->fov;

  } /* phaser != NULL */

} /* GEReq_predownload_setrecon_readphase() */

GEReq_predownload_setrecon_annotations()

void GEReq_predownload_setrecon_annotations	(	int	tsp,
		int	readdur,
		int	time2center,
		int	echogap
	)

Sets ih*** variables for TE and rBW annotation

Uses the global UI CVs opnecho, opnex, opte and opte2

Parameters

[in]	tsp	Dwell time in [us], i.e. the duration of one sample (which is also 1/rBW)
[in]	readdur	Duration in [us] of the readout window
[in]	time2center	Time in [us] to the center of the echo
[in]	echogap	Gap between two echoes

Returns

void

                                                                                                {

  int duration1, duration2;
  int echo_timeoffset2evenecho, echo_timeoffset2oddecho;
  int roundinglimit = 40ms;

  /* rBW annotation */
  ihvbw1 = 1.0e3 / (tsp * 2.0);
  ihvbw2 = ihvbw1;
  ihvbw3 = ihvbw1;
  ihvbw4 = ihvbw1;
  ihvbw5 = ihvbw1;
  ihvbw6 = ihvbw1;
  ihvbw7 = ihvbw1;
  ihvbw8 = ihvbw1;
  ihvbw9 = ihvbw1;
  ihvbw10 = ihvbw1;
  ihvbw11 = ihvbw1;
  ihvbw12 = ihvbw1;
  ihvbw13 = ihvbw1;
  ihvbw14 = ihvbw1;
  ihvbw15 = ihvbw1;
  ihvbw16 = ihvbw1;

  /* NEX annotation */
  ihnex = opnex;

  /* TE */
  ihte1 = (opte > roundinglimit) ? ks_calc_roundupms(opte) : opte;

  duration1 = (readdur - time2center) * 2 + echogap; /* 2x (time from k-space center to edge for 1st echo) + additional echo gap */
  duration2 = time2center * 2 + echogap; /* 2x (time from start to k-space center for 1st echo) + additional echo gap */

  if ((eeff == 1 && oeff == 0) || (eeff == 0 && oeff == 1) || (acq_type == TYPSPIN)) { /* alternating readout gradient polarity across echoes (like often in GRE), or SpinEcho */
    echo_timeoffset2evenecho = duration1; /* between 1 and 2, 3 and 4 etc. */
    echo_timeoffset2oddecho  = duration2; /* between 2 and 3, 4 and 5 etc. */
  } else { /* same readout gradient polarity across echoes */
    /* we have a GRE sequence, and there are likely flyback gradients
       between each readout to allow for the readout gradient polarity to have the same sign for all echoes */
    echo_timeoffset2evenecho = readdur + echogap; /* between 1 and 2, 3 and 4 etc. */
    echo_timeoffset2oddecho  = readdur + echogap; /* between 2 and 3, 4 and 5 etc. */
  }

  if (opnecho == 2) {
    if (pite2nub && existcv(opte2) && opte2 > 0) { /* use opte2 if the button is visible and it was selected */
      ihte2 = opte2;
    } else {
      /* partial Fourier note: 2nd readout will have its relative k-space center mirrored */
      ihte2 = opte + echo_timeoffset2evenecho;
    }
  } else if (opnecho > 2) {
    int pos = opte + echo_timeoffset2evenecho;
    ihte2 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte3 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte4 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte5 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte6 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte7 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte8 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte9 =  (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte10 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte11 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte12 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte13 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte14 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte15 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos; pos += echo_timeoffset2oddecho;
    ihte16 = (pos > roundinglimit) ? ks_calc_roundupms(pos) : pos;
  }

  /* rhte/rhte2 end up in the raw section of the rawdata header (rdb_hdr_te, rdb_hdr_te2)
     while opte/opte in the image section (te,te2). For opnecho > 2, the te2 field is sometimes 0, why
     we also need to rely on rdb_hdr_te2 for offline reconstruction */
  rhte = ihte1;
  rhte2 = ihte2;


  /* Flip Angle */
  ihflip = opflip;

} /* GEReq_predownload_setrecon_annotations() */

GEReq_predownload_setrecon_annotations_readtrap()

void GEReq_predownload_setrecon_annotations_readtrap	(	KS_READTRAP *	readtrap,
		int	echogap
	)

Sets ih*** variables for TE and rBW annotation based on a KS_READTRAP

This is a wrapper function to GEReq_predownload_setrecon_annotations() using a KS_READTRAP

Parameters

[in]	readtrap	Pointer to KS_READTRAP
[in]	echogap	Gap between two echoes

Returns

void

                                                                                         {

  GEReq_predownload_setrecon_annotations(readtrap->acq.filt.tsp, readtrap->grad.duration, readtrap->time2center, echogap);

} /* GEReq_predownload_setrecon_annotations_readtrap() */

GEReq_predownload_setrecon_annotations_readwave()

void GEReq_predownload_setrecon_annotations_readwave	(	KS_READWAVE *	readwave,
		int	echogap
	)

Sets ih*** variables for TE and rBW annotation based on a KS_READWAVE

This is a wrapper function to GEReq_predownload_setrecon_annotations() using a KS_READWAVE

Parameters

[in]	readwave	Pointer to KS_READWAVE
[in]	echogap	Gap between two echoes

Returns

void

                                                                                         {

  GEReq_predownload_setrecon_annotations(readwave->acq.filt.tsp, readwave->grad.duration, readwave->time2center, echogap);

} /* GEReq_predownload_setrecon_annotations_readwave() */

GEReq_predownload_setrecon_annotations_epi()

void GEReq_predownload_setrecon_annotations_epi	(	KS_EPI *	epi,
		int	echogap
	)

Sets ih*** variables for TE and rBW annotation based on a KS_EPI

This is a wrapper function to GEReq_predownload_setrecon_annotations() using a KS_EPI

Parameters

[in]	epi	Pointer to KS_EPI
[in]	echogap	Gap between two EPI trains

Returns

void

                                                                          {
  int maxtime_dephasers = IMax(2, epi->readphaser.duration, epi->blipphaser.grad.duration);
  int maxtime_rephasers = IMax(2, epi->readphaser.duration, epi->blipphaser.grad.duration);
  int halfkspace_duration = ((epi->read.grad.duration + epi->read_spacing) * epi->etl / 2) - epi->read_spacing / 2;
  /* time for extra lines beyond half-kspace for partial Fourier in ky */
  int overscan_duration = ((epi->read.grad.duration + epi->read_spacing) * (epi->blipphaser.nover / epi->blipphaser.R)) - epi->read_spacing / 2;
  int epiduration, time2center;

  if (opautote == PSD_MINTE) {
    epiduration = (maxtime_dephasers + overscan_duration + halfkspace_duration + maxtime_rephasers);
    time2center = maxtime_dephasers + overscan_duration;
  } else {
    epiduration = (maxtime_dephasers + 2 * halfkspace_duration + maxtime_rephasers);
    time2center = maxtime_dephasers + halfkspace_duration;
  }
  GEReq_predownload_setrecon_annotations(epi->read.acq.filt.tsp, epiduration, time2center, echogap);


} /* GEReq_predownload_setrecon_annotations_epi() */

GEReq_predownload_setrecon_voldata()

void GEReq_predownload_setrecon_voldata	(	int	numvols,
		const KS_SLICE_PLAN	slice_plan
	)

Sets rh*** variables related to multi-volume imaging

The combination of rh*** variables allow for 50,000 image planes in GE's database.

However, Pfile data stops writing after 512 planes. To store more than 512 image planes as rawdata, RDS (Raw Data Server) or multivolume Pfiles can be used instead. It is possible that other mechanisms will be available through GE's upcoming Orchestra Live in the future.

Parameters

[in]	numvols	Number of volumes (opfphases)
[in]	slice_plan	The slice plan (KS_SLICE_PLAN), set up using ks_calc_sliceplan() or similar

Returns

void

                                                                                     {
  int numechoes;

  if (numvols < 1)
    numvols = 1;

  /* GE's CVs for #slices/TR and #passes (acqs) */
  _slquant1.fixedflag = 0;
  _acqs.fixedflag = 0;
  slquant1 = slice_plan.nslices_per_pass;
  acqs = slice_plan.npasses;
  /* prescan */
  picalmode = 0;
  pislquant = slquant1;

  /* rhscnframe and rhpasframe are used when scanning in auto-pass mode w/o specific pass-packets (like GEendpass).
  To enable auto-pass mode, set rhtype1 |= RHTYP1AUTOPASS and set these variables to the proper value.
  It is unclear how this would work with partial Fourier and ARC, and has not been tested. */
  rhscnframe = 0 /* rhnslices*ceil(opnex)*rhdayres */;
  rhpasframe = 0 /* slquant1*ceil(opnex)*rhdayres */;
  rhtype1 &= ~RHTYP1AUTOPASS; /* diable auto-pass. I.e. require the use of pass packets (which is standard anyway) in scan to dump Pfiles */

  /* raw size */
  numechoes = IMax(2, rhnecho, opnecho);
  if (!KS_3D_SELECTED) {
    rhrawsize = slquant1 * numechoes * (2 * rhptsize) * rhdaxres * rhdayres;
  } else {
    rhrawsize = opslquant * numechoes * (2 * rhptsize) * rhdaxres * rhdayres;
  }

  {
    char tmpstr[100];
    sprintf(tmpstr, "rhrawsize = %d bytes/channel (KSFoundation)", (int) rhrawsize);
    cvdesc(rhrawsizeview, tmpstr);
  }

  /* Volumes & total size */
  rhnphases = numvols;  /* must be = numvols (not numvols*acqs=#pfiles !!)
         - if 1 when numvols >1:
         Prep Action failed: error please try again. ErrorLog="The integer value for ps_to_rs[0] in the header = 0 "
         - if numvols*acqs when acqs > 1 and numvols == 1:
         Scan failed (after few secs, no images)  */
  rhnpasses = rhnphases * slice_plan.npasses;  /* must be == # volumes (Pfiles) dumped or system hangs and needs rebooting ! */
  rhreps    = rhnphases;
  if (!KS_3D_SELECTED) {
    rhnslices = slice_plan.nslices * rhnphases;
  } else {
    rhnslices = opslquant * opvquant * rhnphases;
  }
  rhmphasetype = 0; /* Interleaved multiphase */

  rhtype1 |= RHTYP1BAM0FILL ; /* zerofill BAM for clean Pfiles */
  rhformat &= ~RHF_ZCHOP; /* no z chopping by default */
  rhformat |= RHF_SINGLE_PHASE_INFO;

#ifdef REV
  /* converts the define REV which is a GITSHA, consisting of 7 hexadecimals (16 base), */
  /* to a float and sets rhuser46 accordingly                                           */
    char revChar[7];
    int revNum;
    strncpy(revChar,REV,7);
    sscanf(revChar, "%x", &revNum);
    rhuser46 = (float) revNum;
#endif

  /* Gradwarp Mode */
  rhuser47 = cfgradcoil;

  /* copy useful variables to raw header for recon */
  /* rhuser32-35 are reserved for off-line VRGF correction (Karolinska) */
  rhuser48 = pitscan; /* scan time */

} /* GEReq_predownload_setrecon_voldata() */

GEReq_predownload_setrecon_epi()

STATUS GEReq_predownload_setrecon_epi	(	KS_EPI *	epi,
		int	numvols2store,
		const KS_SLICE_PLAN	slice_plan,
		int	echogap,
		int	blipsign,
		int	datadestination,
		int	multishotflag,
		int	staticghostcal,
		int	imsize_policy
	)

Wrapper function that set up rh*** variable for a KS_EPI object using other functions

Calls GEReq_predownload_setrecon_readphase(), GEReq_predownload_setrecon_voldata() and GEReq_predownload_setrecon_annotations_epi(), and GEReq_predownload_genrowflip(). Additionally, some rh*** variables are overridden for EPI.

Parameters

[in]	epi	Pointer to KS_EPI
[in]	numvols2store	Number of volumes to store (including calibration vols such as ghostcorr)
[in]	slice_plan	The slice plan (KS_SLICE_PLAN) set up using ks_slice_plan() or similar
[in]	echogap	Gap between two EPI trains in [us]
[in]	blipsign	KS_EPI_POSBLIPS or KS_EPI_NEGBLIPS
[in]	datadestination	Value passed on to GEReq_predownload_setrecon_readphase() to set rhexecctrl
[in]	multishotflag	0: Parallel imaging mode 1: Multishot mode
[in]	staticghostcal	Integrated refscan (Nyquist ghost correction). 0:Off, 1:On
[in]	imsize_policy	Choice between KS_IMSIZE_NATIVE, KS_IMSIZE_POW2, KS_IMSIZE_MIN256

Return values

STATUS

SUCCESS or FAILURE

                                                                                                                                                                                                                {

  if (datadestination & RHXC_XFER_IM) {
    return ks_error("%s: Online recon not supported for KS_EPI data on DV26 or later", __FUNCTION__); 
  }

  GEReq_predownload_setrecon_readphase(&epi->read, &epi->blipphaser, NULL, imsize_policy, datadestination); /* also sets rhasset when R > 1 */
  GEReq_predownload_setrecon_voldata(numvols2store, slice_plan); /* opfphases = number of volumes */
  GEReq_predownload_setrecon_annotations_epi(epi, echogap);


  /* EPI specific rh* vars  */
  rhileaves = epi->blipphaser.R;
  rhkydir = (blipsign == KS_EPI_POSBLIPS) ? 2 : 0;
  rhmphasetype = 0; /* Interleaved multiphase */

  if (multishotflag > 0) {
    /* .R for multi-shot. Override values set in GEReq_predownload_setrecon_readphase()->GEReq_predownload_setrecon_accel() */
    _rhasset.fixedflag = FALSE;
    _rhasset_R.fixedflag = FALSE;
    rhasset = 0;
    rhasset_R = 1.0;
  }

  /* Turn on row-flipping if ETL > 1 */
  if (epi->etl > 1) {
    rhformat |= RHF_USE_FLIPTABLE;
    if (datadestination & RHXC_XFER_IM) {
      /* Online recon: Single-shot w/ or w/o ASSET */
      GEReq_predownload_genrowflip(epi, blipsign, rhasset, TRUE);
    } else {
      /* Offline recon, say we do rowflip in rhformat, because otherwise GERecon('EPI.ComputeCoefficients') does not
      work (requires RHF_USE_FLIPTABLE to be set).
      But let's not set any negative entries in the file for offline use to avoid rowflipping to actually occur:
      DV26+: This file is ignored for scan archives
      Pre DV26: We don't want the rows to be flipped correctly in the Pfile currently since we don't understand
      why the lines are flipped wrong for mulitshot EPI. We deal with rowflipping ourselves in the recon
      */
      GEReq_predownload_genrowflip(epi, blipsign, rhasset, FALSE);      
    }
  } else {
    rhformat &= ~RHF_USE_FLIPTABLE;
  }

  /* fermi filter */
  rhfermr = opxres/2;


  /* override flip control set in GEReq_predownload()->{@inline loadrheader.e rheaderinit} */
  eepf = 0;
  eeff = 0;
  oepf = 0;
  oeff = 0;
  set_echo_flip(&rhdacqctrl, &chksum_rhdacqctrl, eepf, oepf, eeff, oeff); /* clear bit 1 - flips image in phase dir */

  rhdacqctrl |= 8192; /* disable Orchestra recon */

  /* save echo spacing value into rhesp */
  rhesp = epi->read.grad.duration;



  /* default but see below */
  rhpctemporal = 1;
  rhpccoil = 0;
  rhref = (staticghostcal) ? 5 : 0;

  /* Diffusion or not */
  if (opdiffuse || optensor) {
    rhtype1 |= RHTYP1DIFFUSIONEPI; 
  } else {
    rhtype1 &= ~RHTYP1DIFFUSIONEPI;
  }

  return SUCCESS;

} /* GEReq_predownload_setrecon_epi() */

GEReq_predownload_prescan_options()

STATUS GEReq_predownload_prescan_options

(

RG_CAL_MODE_E

rg_cal_mode

)

Prescan options

Parameters

[in]

rg_cal_mode

RG_CAL_MODE_E

Return values

STATUS

SUCCESS or FAILURE

                                                                    {

  /* cvoverride(psd_pscall, -1, PSD_FIX_ON, PSD_EXIST_ON); */ /* disable all prescan? */

  /* Transmit Gain (TG) Auto always */
  cvoverride(psd_psctg, 0,  PSD_FIX_ON, PSD_EXIST_ON); /* 0: Auto TG */
  pidotg = psd_psctg;


#if EPIC_RELEASE > 26
  /* Gradient shim. Stop sequence specific overrides from Prescan.e so Shim menu reflects what is going
  to happen, regardless of EPI/diffusion modes */
  opgradshim = 2; /* Grad Shim (Auto). Default, will be changed by Shim menu */
  if (opgradshim == 2) { /* Auto */
    cvoverride(psd_pscshim, 0, PSD_FIX_ON, PSD_EXIST_ON);
  } else if (opgradshim == 1) { /* Force ON */
    cvoverride(psd_pscshim, 1, PSD_FIX_ON, PSD_EXIST_ON);
  } else if (opgradshim == 0) { /* Force OFF */
    cvoverride(psd_pscshim, -1, PSD_FIX_ON, PSD_EXIST_ON);
  }
  pidoshim = psd_pscshim;
#endif

  /* Receive gain (R1/R2) control:
  epic_ui_control.h:
  typedef enum RG_CAL_MODE {
    RG_CAL_MODE_MIN = 0,
    RG_CAL_MODE_MEASURED = 0,
    RG_CAL_MODE_HIGH_FIXED = 1,
    RG_CAL_MODE_LOW_FIXED = 2,
    RG_CAL_MODE_AUTO = 3,
    RG_CAL_MODE_MAX = 3
  } RG_CAL_MODE_E; 
 */
  cvoverride(oprgcalmode, rg_cal_mode, PSD_FIX_ON, PSD_EXIST_ON);

  return SUCCESS;

} /* GEReq_predownload_prescan_options() */

GEReq_cvinit()

STATUS GEReq_cvinit

(

void

)

Helper function to be called at the beginning of cvinit()

In the beginning of cvinit() the following lines should be added:

STATUS status = GEReq_cvinit();
KS_RAISE(status);

This function sets up various global GE stuff, including e.g. the gradient specs. The gradient specs are controlled by ks_srfact and ks_qfact. ks_srfact Should have a value that will allow scanning on all MR systems without PNS effects. Also, ks_srfact does not affect the EPI train in ksepi.e, since it controls the slewrate and gradient max separately. ks_qfact is supposed to be 1 by default, with the purpose to from an optimal setting reduce the slewrate to reduce the acoustic noise. A default value of 1.0 will make the system perform best but with high acoustic noise. A value of about 8-10 may be a good trade-off between acoustic noise reduction and reasonable image quality.

In this function, ks_sarcheckdone is set to FALSE. This CV is checked in GEReq_predownload() and ks_pg_rf(), which both will complain if it is not has been set to TRUE. GEReq_eval_checkTR_SAR_calcs() sets this CV to TRUE.

It is important that an error returned from GEReq_cvinit() also results in an error in cvinit(), otherwise it will not show up in the UI.

Return values

STATUS

SUCCESS or FAILURE

                          {

  /* ART: Acoustic noise reduction
    Imaging option button "Acoustic reduction":
      - PSD_IOPT_MILDNOTE in sequence_iopts[]
      - Sets CV opsilent = TRUE
    When acoustic noise reduction (ART) imaging option is checked, enable the ART tab in the UI too
    by forcing cfnumartlevels = 2
    - "Moderate" radio button on ART tab: CV opsilentlevel = 1
    - "High" radio button on ART tab: CV opsilentlevel = 2
   */
  cvoverride(cfnumartlevels, 2, PSD_FIX_OFF, PSD_EXIST_ON);
  pinumartlevels = cfnumartlevels;

#if EPIC_RELEASE >= 28
  /* always derate slewrate for cal scan (Prescan.e) if < 5.0 */
  if (cal_sr_derate < 5.0) {
    cvoverride(cal_sr_derate, 5.0, PSD_FIX_ON, PSD_EXIST_ON);
  }
#endif

  if (opsilent) {
    _ks_qfact.existflag = TRUE;
    if (opsilentlevel == 1) {
      /* moderate */
      ks_qfact = 3.0;
#if EPIC_RELEASE >= 28
      cvoverride(cal_sr_derate, 15.0, PSD_FIX_ON, PSD_EXIST_ON);
#endif      
    } else {
      /* high */
      ks_qfact = 6.0;
#if EPIC_RELEASE >= 28
      cvoverride(cal_sr_derate, 15.0, PSD_FIX_ON, PSD_EXIST_ON);
#endif
    }
  } else {
    ks_qfact = 1.0;
  }


  {


  }

  EpicConf();

  /* set gradient limitations (calling GEs obloptimize() & further ramptime modifications) */
  GEReq_init_gradspecs(&loggrd, &phygrd, ks_srfact / ks_qfact);

  /* resets all filter #. From this point, ok to call setfilter() */
  initfilter();

  /* setsysparams() sets psd_grd_wait and psd_rf_wait for the system */
  setsysparms();
#ifdef SIM
  /* In simulation, we don't want them to confuse the timing in WTools */
  _psd_grd_wait.fixedflag = 0;
  _psd_rf_wait.fixedflag = 0;
  psd_grd_wait = 0;
  psd_rf_wait = 0;
#endif

#include "cvinit.in"  /* Runs the code generated by macros in preproc.*/

  /* GE CVs that could use a wider min/max range: */
  cvmax(rhfrsize, 32768);
  cvmax(rhdaxres, 32768);
  cvmax(opphasefov, 5); /* to allow larger FOV in phase enc dir that freq */
  cvmax(rhnslices, 50000); /* 50,000, which is 5x of RHF_MAX_IMAGES_MULTIPHASE = 10000 */
  cvmax(rhreps, 2048); /* max 2048 vols */
  cvmax(rhnphases, 2048); /* max 2048 vols */
  cvmax(opfphases, 2048); /* max 2048 vols */
  cvmax(opyres, 1024); /* max 1024 yres */
  cvmax(opslthick, 200); /* max 200 mm slice thickness */
  cvmax(optr, 60s); /* max 60s TR */
  cvmax(ihtr, 60s);
  cvmax(rhref, 5); /* Allow 1st-volume ghost correction as GE's diffusion EPI (only works for single shot) */
  cvmax(opbval, 30000);
  cvmax(opileave, 1);

#if EPIC_RELEASE > 29 || (EPIC_RELEASE == 29 && EPIC_SUBRELEASE == 1)
  cvset(opzres, 0, 100, 100, "");
  setexist(opzres, TRUE);
#endif

  /* activate Advisory panel */
  piadvise = PSD_ON;
  piadvmin  = (1 << PSD_ADVTE); /* TE Advisory on */
  piadvmin |= (1 << PSD_ADVTR);  /* TR Advisory on */
  piadvmin |= (1 << PSD_ADVRCVBW);/* rBW Advisory on */
  piadvmin |= (1 << PSD_ADVFOV);/* FOV Advisory on */
  piadvmax = piadvmin;

  {


  }

  /* KSFoundation indicator variable for completed SAR checks (c.f. GEReq_eval_checkTR_SAR_calcs(), which sets it to TRUE) */
  ks_sarcheckdone = FALSE;

 /* GE's psd_name seems not be available on TGT, to let's copy this one */
#if EPIC_RELEASE >= 27
  /* Since RX27R02, GE's psd_name no longer exists */
  {
    strcpy(ks_psdname, get_psd_name());
  }
#else
  strcpy(ks_psdname, psd_name);
#endif

#if EPIC_RELEASE > 29 || (EPIC_RELEASE == 29 && EPIC_SUBRELEASE == 1)
  pizresnub = 0; /* 3D Don't show slice res menu by default */
#endif

  /* populate a global KS_SEQ_CONTROL for pass packet. Used to make TR timing sum up correctly */
  seqctrl_passpack.min_duration = pw_passpacket;
  seqctrl_passpack.duration = seqctrl_passpack.min_duration;
  strcpy(seqctrl_passpack.description, "passpack");

  return SUCCESS;

} /* GEReq_cvinit() */

GEReq_cveval()

STATUS GEReq_cveval

(

void

)

Helper function to be called at the beginning of cveval()

In the beginning of cveval() the following lines should be added:

STATUS status = GEReq_cveval();
KS_RAISE(status);

This function up various global GE stuff, and copies also the struct array scan_info, holding the prescribed slice locations to ks_scan_info, the latter which can also be accessible on TGT.

Simulation (WTools): If we have ks_simscan = 1 (default), simscan() will have make up slice locations in ks_scan_info based on opslthick, opslspace and opslquant. Note, GE clears scan_info between cvcheck() and predownload() when in simulation. Hence, we now have the opposite case, i.e. we have some slice info data in ks_scan_info but nothing in scan_info.

It is important that an error returned from GEReq_cveval() also results in an error in cveval(), otherwise it will not show up in the UI.

Return values

STATUS

SUCCESS or FAILURE

                          {

  {


  }

 InitAdvPnlCVs();


#if EPIC_RELEASE > 29 || (EPIC_RELEASE == 29 && EPIC_SUBRELEASE == 1)
 rhacqslthick = opslthick;
#endif

#ifdef PSD_HW
 /* MR scanner (hardware): copy scan_info to ks_scan_info, so we can use this data on TGT */
 memcpy(ks_scan_info, scan_info, opslquant*sizeof(SCAN_INFO));
#else
  /* WTools (sim) */
  if (ks_simscan)
    simscan();
#endif

  return SUCCESS;

} /* GEReq_cveval() */

getAPxParam()

void getAPxParam	(	optval *	min,
		optval *	max,
		optdelta *	delta,
		optfix *	fix,
		float	coverage,
		int	algorithm
	)

Mandatory APx functions for PSDs from DV26

DV26 requires getAPxAlgorithm() and getAPxParam() functions to exist in each PSD. Empty getAPxAlgorithm() and getAPxParam() functions are declared below in GERequired.e to allow compilation on DV26. If a PSD wants to use this new functionality in DV26 it should add the following line: #define KS_PSD_USE_APX 1 in its @global section, so that KS_PSD_USE_APX is not set to 0 here, and hence getAPxAlgorithm() and getAPxParam() wont be redeclared here in GERequired.e.

                                {
    /* Need to be filled when APx is supported in this PSD */
}

getAPxAlgorithm()

int getAPxAlgorithm	(	optparam *	optflag,
		int *	algorithm
	)

                                                       {
    return APX_CORE_NONE;

} /* getAPxAlgorithm() */

GEReq_cvcheck()

STATUS GEReq_cvcheck

(

void

)

Helper function to be called at the beginning of cvcheck()

In the beginning of cvcheck() the following lines should be added:

STATUS status = GEReq_cveval();
KS_RAISE(status);

It is important that an error returned from GEReq_cvcheck() also results in an error in cvcheck(), otherwise it will not show up in the UI.

Return values

STATUS

SUCCESS or FAILURE

                           {

  if (existcv(opslspace) && existcv(opslthick) && (opslspace < 0) && (opslthick <= fabs(opslspace))) {
    return KS_THROW("Slice overlap must be less than %.2f mm", opslthick);
  }
  if (existcv(optr) && optr < avmintr) {
    return KS_THROW("The minimum TR is %-d ms", (avmintr / 1ms));
  }
  if (existcv(optr) && optr > avmaxtr) {
    return KS_THROW("The maximum TR is %-d ms", (avmaxtr / 1ms));
  }  
  if ((exist(opte) < avminte) && existcv(opte)) {
    return KS_THROW("The minimum TE is %-d ms", (avminte / 1ms));
  }
  if ((exist(opte) > avmaxte) && existcv(opte)) {
    return KS_THROW("The maximum TE is %-d ms", (avmaxte / 1ms));
  }

  return SUCCESS;

} /* GEReq_cvcheck() */

GEReq_predownload()

STATUS GEReq_predownload

(

void

)

Helper function to be called at the beginning of predownload()

In the beginning of predownload() the following lines should be added:

STATUS status = GEReq_predownload();
KS_RAISE(status);

This function up various global GE stuff related to recon and data filters. Also, ks_sarcheckdone is checked to make sure that GEReq_eval_checkTR_SAR_calcs() has been called to monitor SAR/heating limits.

It is important that an error returned from GEReq_predownload() also results in an error in predownload(), otherwise it will not show up in the UI.

Return values

STATUS

SUCCESS or FAILURE

                               {

  {
  }

  nex = ceil(opnex); /* nex is used in rheaderinit instead of opnex, so must set it here. otherwise prescan fails */


  /* UsePgenOnHost() (Imakefile) likes calling calcPulseParams() at this spot, containing "predownload.in" */
  calcPulseParams(0);

  {


    /* the compiler flag "MINIMIZE_PSFILTERS" will try to minimize the number of filter slots used in precan, sum code from prescan.e will be replaced */
    if (ks_compress_ps_filter_slots == TRUE){

      GEReq_predownload_minimize_ps_filter_slots();

    } else {


    }




  }

  /* Set rhkacq_uid for ARC support and linking plots */
  int uid;
  struct tm now;
  time_t now_epoch = time(NULL);
  /* Generate unique ID for this scan for naming kacq files and
     debug files.  Use the current date and time (MMDDHHMMSS).
     Cannot include the year because this is larger than a
     signed 32-bit integer */
  localtime_r(&now_epoch, &now);
  uid = now.tm_sec +
        now.tm_min  * 100 +
        now.tm_hour * 10000 +
        now.tm_mday * 1000000 +
        (now.tm_mon + 1) * 100000000;
  rhkacq_uid = uid;

 /* Check that SAR calculations have been performed */
  if (ks_sarcheckdone != TRUE) {
#ifdef SIM
    if (existcv(optr) == TRUE && existcv(opte) == TRUE && existcv(opslquant) == TRUE) {
      /* In simulation (WTools), predownload is called every time a CV is changed but
      ks_sarcheckdone will not be set to TRUE in GEReq_eval_checkTR_SAR_calcs() unless
      optr, opte and opslquant have all been set (existcv() != FALSE). Hence, in simulation,
      we cannot throw an error before these have been set */
      return ks_error("%s: Missing call to GEReq_eval_checkTR_SAR()", __FUNCTION__);
    }
#else
    return ks_error("%s: Missing call to GEReq_eval_checkTR_SAR()", __FUNCTION__);
#endif
  }

 return SUCCESS;

} /* GEReq_predownload() */

GEReq_pulsegenBegin()

void GEReq_pulsegenBegin

(

void

)

Helper function to be called at the beginning of pulsegen()

In the beginning of pulsegen() the following lines should be added:

GEReq_pulsegenBegin();

This function up various global GE stuff related to pulsegen()

                               {

  sspinit(psd_board_type);

  {


  }

} /* GEReq_pulsegenBegin() */

GEReq_pulsegenEnd()

void GEReq_pulsegenEnd

(

void

)

Helper function to be called at the end of pulsegen()

In the end of pulsegen(), but before buildinstr(), the following lines should be added:

GEReq_pulsegenEnd();

This function up prescan pulsegen and adds a PASSPACK sequence ("GEendpass"), which is used to dump rawdata and mark the end of scan. See GEReq_endofpass() and GEReq_endofscan() and how they are used in a psd.

                             {

#ifdef IPG
  {
  }

PASSPACK(GEendpass, pw_passpacket-1ms);
SEQLENGTH(GEpass, pw_passpacket, GEpass);

#endif

} /* GEReq_pulsegenEnd() */

GEReq_endofpass()

int GEReq_endofpass

(

)

Sets SSP word in sequence off_GEpass() to trigger data (Pfile) writing and reconstruction

After calling this function, the parent function must switch back to the previous/main sequence using ks_scan_playsequence() (or boffset()).

                      {
#ifdef IPG
  boffset(off_GEpass);
  setwamp(SSPD + DABPASS, &GEendpass, 2 ); /* end of pass */
  startseq(0, (short) MAY_PAUSE);
#else
  /* HOST */
  ks_plot_slicetime(&seqctrl_passpack, 1, NULL, KS_NOTSET, KS_PLOT_STANDARD);

  KS_DESCRIPTION slicegroup_desc;
  sprintf(slicegroup_desc, "endofpass");
  ks_plot_slicetime_endofslicegroup_tagged(slicegroup_desc, KS_PLOT_SG_ACQUISITION);

  seqctrl_passpack.nseqinstances++;
#endif
  return pw_passpacket;

} /* GEReq_endofpass() */

GEReq_endofscan()

int GEReq_endofscan

(

)

Sets SSP word in sequence off_GEpass() to tell system that scan is done

                      {
#ifdef IPG
  boffset(off_GEpass);
  setwamp(SSPD + DABSCAN, &GEendpass, 2 ); /* end of scan */
  startseq(0, (short) MAY_PAUSE);
#else
  /* HOST */
  strcpy(seqctrl_passpack.description, "passpack_endofscan");
  ks_plot_slicetime(&seqctrl_passpack, 1, NULL, KS_NOTSET, KS_PLOT_STANDARD);

  KS_DESCRIPTION slicegroup_desc;
  sprintf(slicegroup_desc, "endofscan");
  ks_plot_slicetime_endofslicegroup_tagged(slicegroup_desc, KS_PLOT_SG_ACQUISITION);

  seqctrl_passpack.nseqinstances++;
  strcpy(seqctrl_passpack.description, "passpack");
#endif
  return pw_passpacket;

} /* GEReq_endofscan() */

GEReq_endofpassandscan()

int GEReq_endofpassandscan

(

)

Sets SSP word in sequence off_GEpass() to tell system that scan is done

                             {
  #ifdef IPG
    boffset(off_GEpass);
    setwamp(SSPD + DABPASS + DABSCAN, &GEendpass, 2 ); /* end of scan */
    startseq(0, (short) MAY_PAUSE);
  #else
    /* HOST */
    strcpy(seqctrl_passpack.description, "passpack_endofpassandscan");
    ks_plot_slicetime(&seqctrl_passpack, 1, NULL, KS_NOTSET, KS_PLOT_STANDARD);

    KS_DESCRIPTION slicegroup_desc;
    sprintf(slicegroup_desc, "endofpassandscan");
    ks_plot_slicetime_endofslicegroup_tagged(slicegroup_desc, KS_PLOT_SG_ACQUISITION);

    seqctrl_passpack.nseqinstances++;
    strcpy(seqctrl_passpack.description, "passpack");
  #endif
  return pw_passpacket;

} /* GEReq_endofpassandscan() */

dummylinks()

void dummylinks

(

void

)

Not sure what this function does, but it exists in all product psds.

                      {
  epic_loadcvs( "thefile" ); /* for downloading CVs */

} /* dummylinks() */

GEReq_initRSP()

void GEReq_initRSP

(

void

)

RSP Init. To be inserted in the psdinit() function (or scan()) in the main sequence

                         {

  /* Initialize everything to a known state */
  setrfconfig((short) ks_rfconf);   /* ENBL_RHO1 + ENBL_THETA + ENBL_OMEGA + ENBL_OMEGA_FREQ_XTR1 = 141 */
  rspqueueinit(200);  /* Initialize to 200 entries */
  syncoff(&GEpass);   /* Deactivate sync during pass */

} /* GEReq_initRSP() */

Variable Documentation

rfpulseInfo

RF_PULSE_INFO rfpulseInfo[RF_FREE] = { {0, 0} }

avail_image_time

int avail_image_time

act_tr

ifndef ACT_TR_EXISTS int act_tr

ks_scan_info

endif SCAN_INFO ks_scan_info[SLTAB_MAX] = {DEFAULT_AXIAL_SCAN_INFO}

N.B.: this file should contain includes and definitions common for host, target and sim that are private to KSFoundation. If in doubt always try to add here first instead of KSFoundation.h since that contains the public interface.

ks_slice_plan

KS_SLICE_PLAN ks_slice_plan = KS_INIT_SLICEPLAN

ks_sarcheckdone

int ks_sarcheckdone = FALSE

ks_psdname

char ks_psdname[256]

ks_perform_slicetimeplot

int ks_perform_slicetimeplot = FALSE

seqctrl_passpack

KS_SEQ_CONTROL seqctrl_passpack = KS_INIT_SEQ_CONTROL

obl_debug

int obl_debug = 0 with {0, 1, 0, INVIS, "On(=1) to print messages for obloptimize",}

obl_method

int obl_method = PSD_OBL_OPTIMAL with {PSD_OBL_RESTRICT, PSD_OBL_OPTIMAL, PSD_OBL_OPTIMAL, INVIS, "On(=1) to optimize the targets based on actual rotation matrices",}

filter_echo1

int filter_echo1 = 0 with {, , , INVIS, "Scan filter slot number needed for prescan",}

pw_passpacket

int pw_passpacket = 50ms with {10ms, 1000ms, 50ms, VIS, "Duration of the passpacket sequence",}

ks_rfconf

int ks_rfconf = ENBL_RHO1 + ENBL_THETA + ENBL_OMEGA + ENBL_OMEGA_FREQ_XTR1

ks_simscan

int ks_simscan = 1 with {0, 1, 1, VIS, "Simulate slice locations if 1 (and in simulation)",}

ks_srfact

float ks_srfact = 1.0 with {0.01, 3.0, 1.0, VIS, "Slewrate factor (low value = slower gradients)",}

ks_qfact

float ks_qfact = 1.0 with {0.1, 40.0, 1.0, VIS, "Quietness factor",}

ks_plot_filefmt

int ks_plot_filefmt = KS_PLOT_MAKEPNG with {KS_PLOT_OFF,KS_PLOT_MAKEPNG,KS_PLOT_MAKEPNG, VIS, "Plot format 0:off 1:PDF 2:SVG 3:PNG"}

ks_plot_kstmp

int ks_plot_kstmp = FALSE with {FALSE,TRUE,FALSE, VIS, "0: off 1:Copy plots to mrraw/kstmp"}

ks_compress_ps_filter_slots

int ks_compress_ps_filter_slots = FALSE with {FALSE,TRUE,FALSE, VIS, "Minimize the number of filterslots for prescan"}

ks_clinicalmode

int ks_clinicalmode = CLINICAL_MODE with {0, 1, CLINICAL_MODE, VIS, "Clinical mode: on=1 / off=0"}

maxB1

float maxB1[MAX_ENTRY_POINTS]

maxB1Seq

float maxB1Seq

debugstate

short debugstate

viewtable

short viewtable[513]

psdexitarg

PSD_EXIT_ARG psdexitarg

rspent

int rspent

rspdda

int rspdda

rspbas

int rspbas

rspvus

int rspvus

rspgy1

int rspgy1

rspasl

int rspasl

rspesl

int rspesl

rspchp

int rspchp

rspnex

int rspnex

rspslq

int rspslq

rspsct

int rspsct

rsprep

int rsprep

chopamp

short chopamp

seqCount

int seqCount

view

int view

excitation

int excitation

debug

int debug

entry_name_list

const CHAR* entry_name_list[ENTRY_POINT_MAX]

Initial value:

= {
  "scan",
  "mps2",
  "aps2",
}