pulsesequence()
{
/* Internal variable declarations *************************/
double freq90[MAXNSLICE],freq180[MAXNSLICE],freqIR[MAXNSLICE];
int shape90=0, shape180=0, shapeIR=0;
double te_delay1, te_delay2, tr_delay, ti_delay = 0;
double del1=0, del2=0, del3=0, del4=0;
double tau1=0, tau2=0, difftime=0, tetime=0;
int table=0;
/* Diffusion parameters */
#define MAXDIR 1024 /* Will anybody do more than 1024 directions or b-values? */
double roarr[MAXDIR], pearr[MAXDIR], slarr[MAXDIR];
int nbval, /* Total number of bvalues*directions */
nbro, nbpe, nbsl,
i;
double bro[MAXDIR], bpe[MAXDIR], bsl[MAXDIR], /* b-values along RO, PE, SL */
brs[MAXDIR], brp[MAXDIR], bsp[MAXDIR], /* and the cross-terms */
btrace[MAXDIR], /* and the trace */
max_bval=0,
dcrush, dgss2, /* "delta" for crusher and gss2 gradients */
Dro, Dcrush, Dgss2; /* "DELTA" for readout, crusher and gss2 gradients */
/* Real-time variables ************************************/
int vpe_steps = v1;
int vpe_ctr = v2;
int vms_slices = v3;
int vms_ctr = v4;
int vpe_offset = v5;
int vpe_index = v6;
int vph180 = v7; // Phase of 180 pulse
int vph2 = v8; // alternate phase of 180 on odd transients
/* Initialize paramaters *********************************/
init_mri();
/* Check for external PE table ***************************/
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
table = 1;
}
if ((diff[0] == 'y') && (gcrush < 4))
warn_message("Advisory: set gcrush to higher value to avoid image artifacts");
/* Initialize gradient structures *************************/
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
init_rf(&p2_rf,p2pat,p2,flip2,rof2,rof2);
init_slice(&ss_grad,"ss",thk);
init_slice_butterfly(&ss2_grad,"ss2",thk*1.1,gcrush,tcrush);
init_slice_refocus(&ssr_grad,"ssr");
init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro);
init_readout_refocus(&ror_grad,"ror");
init_phase(&pe_grad,"pe",lpe,nv);
/* RF Calculations ****************************************/
calc_rf(&p1_rf,"tpwr1","tpwr1f");
calc_rf(&p2_rf,"tpwr2","tpwr2f");
if (p2_rf.header.rfFraction != 0.5)
abort_message("RF pulse for refocusing (%s) must be symmetric",p2pat);
/* Gradient calculations **********************************/
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2");
calc_slice_refocus(&ssr_grad, &ss_grad, NOWRITE,"gssr");
calc_readout(&ro_grad, WRITE, "gro","sw","at");
ro_grad.m0ref *= grof;
calc_readout_refocus(&ror_grad, &ro_grad, NOWRITE, "gror");
calc_phase(&pe_grad, NOWRITE, "gpe","tpe");
/* Equalize refocus and PE gradient durations *************/
calc_sim_gradient(&ror_grad, &pe_grad, &ssr_grad,0,WRITE);
/* Set up diffusion gradient */
if (diff[0] == 'y') {
init_generic(&diff_grad,"diff",gdiff,tdelta);
calc_generic(&diff_grad,NOWRITE,"","");
/* adjust duration, so tdelta is from start ramp up to start ramp down */
if (ix == 1) diff_grad.duration += diff_grad.tramp;
calc_generic(&diff_grad,WRITE,"","");
}
/* Min TE *************************************************/
tau1 = ss_grad.rfCenterBack + pe_grad.duration + 4e-6 + ss2_grad.rfCenterFront;
tau2 = ss2_grad.rfCenterBack + ror_grad.duration + ro_grad.timeToEcho + alfa;
temin = 2*(MAX(tau1,tau2) + 2*4e-6); /* have at least 4us between gradient events */
/* Calculate te_delays with the current TE, then later see how diffusion fits */
if ((minte[0] == 'y') || (te < temin)) {
te_delay1 = temin/2 - tau1;
te_delay2 = temin/2 - tau2;
}
else {
te_delay1 = te/2 - tau1;
te_delay2 = te/2 - tau2;
}
if (diff[0] =='y') {
/* Is tDELTA long enough for RF refocusing gradient? */
if (tDELTA < diff_grad.duration + ss2_grad.duration)
abort_message("DELTA too short, increase to %.2fms",
(diff_grad.duration + ss2_grad.duration)*1000+0.005);
/* Is tDELTA too long for TE dead time? */
difftime = tDELTA + diff_grad.duration; // tDELTA + front & back half diff_grad
tetime = ss2_grad.duration + te_delay1 + te_delay2;
if (difftime > tetime) {
temin += (difftime - tetime);
}
}
/* We now know the minimum TE incl. diffusion */
if (minte[0] == 'y') {
te = temin;
putvalue("te",ceil(te*1e6)*1e-6); /* round up to nearest us */
}
if (te < temin) {
if (diff[0] == 'n') {
abort_message("TE too short. Minimum TE = %.2fms\n",temin*1000);
}
else {
abort_message("TE too short, increase to %.2fms or reduce DELTA to %.2fms",
temin*1000,(tetime-diff_grad.duration)*1000);
}
}
te_delay1 = te/2 - tau1;
te_delay2 = te/2 - tau2;
/* Set up delays around diffusion gradients */
/* RF1 - del1 - diff - del2 - RF2 - del3 - diff - del4 - ACQ */
if (diff[0] == 'y') {
del1 = (tetime - difftime)/2;
del4 = del1;
del2 = te_delay1 - diff_grad.duration;
del3 = te_delay2 - diff_grad.duration;
if (del3 < 0.0) { // shift diff block to right
del1 += del3;
del2 -= del3;
del4 -= del3;
del3 = 0;
} else if (del2 < 0.0) { // shift diff block to left
del1 -= del2;
del3 -= del2;
del4 += del2;
del2 = 0;
}
}
else { /* No diffusion */
del1 = 0;
del3 = 0;
del2 = te_delay1;
del4 = te_delay2;
}
/* Min TR *************************************************/
trmin = (ss_grad.duration - ss_grad.rfCenterBack) + te + ro_grad.timeFromEcho;
if (navigator[0] == 'y')
trmin += (pe_grad.duration + ro_grad.duration);
/* Optional prepulse calculations *************************/
if (sat[0] == 'y') {
create_satbands();
trmin += satTime;
}
if (fsat[0] == 'y') {
create_fatsat();
trmin += fsatTime;
}
if (mt[0] == 'y') {
create_mtc();
trmin += mtTime;
}
if (ir[0] == 'y') {
init_rf(&ir_rf,pipat,pi,flipir,rof2,rof2);
calc_rf(&ir_rf,"tpwri","tpwrif");
init_slice_butterfly(&ssi_grad,"ssi",thk,gcrushir,tcrushir);
calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi");
tau1 = ss_grad.duration - ss_grad.rfCenterBack; /* duration of ss_grad before RF center */
ti_delay = ti - (ssi_grad.rfCenterBack + tau1);
if (ti_delay < 0) {
abort_message("TI too short, Minimum TI = %.2fms\n",(ti-ti_delay)*1000);
}
irTime = ti + ssi_grad.duration - ssi_grad.rfCenterBack; /* time to add to TR */
trmin += irTime;
trmin -= tau1; /* but subtract out ss_grad which was already included in TR */
}
trmin *= ns;
if (mintr[0] == 'y'){
tr = trmin + ns*4e-6;
putvalue("tr",tr);
}
if (tr < trmin) {
abort_message("TR too short. Minimum TR= %.2fms\n",trmin*1000);
}
tr_delay = (tr - trmin)/ns > 4e-6 ? (tr - trmin)/ns : 4e-6;
/***************************************************/
/* CALCULATE B VALUES ******************************/
if (diff[0] == 'y') {
/* Get multiplication factors and make sure they have same # elements */
/* All this is only necessary because putCmd only work for ix==1 */
nbro = (int) getarray("dro",roarr); nbval = nbro;
nbpe = (int) getarray("dpe",pearr); if (nbpe > nbval) nbval = nbpe;
nbsl = (int) getarray("dsl",slarr); if (nbsl > nbval) nbval = nbsl;
if ((nbro != nbval) && (nbro != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (readout)",seqfil);
if ((nbpe != nbval) && (nbpe != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (phase)",seqfil);
if ((nbsl != nbval) && (nbsl != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (slice)",seqfil);
if (nbro == 1) for (i = 1; i < nbval; i++) roarr[i] = roarr[0];
if (nbpe == 1) for (i = 1; i < nbval; i++) pearr[i] = pearr[0];
if (nbsl == 1) for (i = 1; i < nbval; i++) slarr[i] = slarr[0];
}
else {
nbval = 1;
roarr[0] = 0;
pearr[0] = 0;
slarr[0] = 0;
}
for (i = 0; i < nbval; i++) {
/* Readout */
Dro = ror_grad.duration;
bro[i] = bval(gdiff*roarr[i],tdelta,tDELTA);
bro[i] += bval(ro_grad.amp,ro_grad.timeToEcho,Dro);
/* Slice */
dgss2 = Dgss2 = ss_grad.rfCenterFront;
dcrush = tcrush; //"delta" for crusher part of butterfly
Dcrush = dcrush + ss_grad.rfDuration; //"DELTA" for crusher
bsl[i] = bval(gdiff*slarr[i],tdelta,tDELTA);
bsl[i] += bval(gcrush,dcrush,Dcrush);
bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval_nested(gcrush,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2);
/* Phase */
bpe[i] = bval(gdiff*pearr[i],tdelta,tDELTA);
/* Readout/Slice Cross-terms */
brs[i] = bval2(gdiff*roarr[i],gdiff*slarr[i],tdelta,tDELTA);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
/* Readout/Phase Cross-terms */
brp[i] = bval2(gdiff*roarr[i],gdiff*pearr[i],tdelta,tDELTA);
/* Slice/Phase Cross-terms */
bsp[i] = bval2(gdiff*slarr[i],gdiff*pearr[i],tdelta,tDELTA);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
btrace[i] = (bro[i]+bsl[i]+bpe[i]);
if (max_bval < btrace[i]) {
max_bval = (bro[i]+bsl[i]+bpe[i]);
}
} /* End for-all-directions */
putarray("bvalrr",bro,nbval);
putarray("bvalpp",bpe,nbval);
putarray("bvalss",bsl,nbval);
putarray("bvalrp",brp,nbval);
putarray("bvalrs",brs,nbval);
putarray("bvalsp",bsp,nbval);
putarray("bvalue",btrace,nbval);
putvalue("max_bval",max_bval);
/* Generate phase-ramped pulses: 90, 180, and IR */
offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]);
shape90 = shapelist(p1pat,ss_grad.rfDuration,freq90,ns,0,seqcon[1]);
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shape180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]);
if (ir[0] == 'y') {
offsetlist(pss,ssi_grad.ssamp,0,freqIR,ns,seqcon[1]);
shapeIR = shapelist(pipat,ssi_grad.rfDuration,freqIR,ns,0,seqcon[1]);
}
/* Set pe_steps for profile or full image **********/
pe_steps = prep_profile(profile[0],nv,&pe_grad,&null_grad);
initval(pe_steps/2.0,vpe_offset);
sgl_error_check(sglerror);
/* Return parameters to VnmrJ */
putvalue("rgss",ss_grad.tramp); //90 slice ramp
if (ss2_grad.enableButterfly) { //180 slice ramps
putvalue("rcrush",ss2_grad.crusher1RampToCrusherDuration);
putvalue("rgss2",ss2_grad.crusher1RampToSsDuration);
}
else {
putvalue("rgss2",ss2_grad.tramp);
}
if (ro_grad.enableButterfly) {
putvalue("rgro",ro_grad.crusher1RampToSsDuration);
}
else {
putvalue("rgro",ro_grad.tramp); //RO ramp
}
putvalue("tror",ror_grad.duration); //ROR duration
putvalue("rgror",ror_grad.tramp); //ROR ramp
putvalue("gpe",pe_grad.peamp); //PE max amp
putvalue("gss",ss_grad.ssamp);
putvalue("gro",ro_grad.roamp);
g_setExpTime(tr*(nt*pe_steps*arraydim + ssc));
/* PULSE SEQUENCE *************************************/
rotate();
obsoffset(resto);
roff = -poffset(pro,ro_grad.roamp);
delay(4e-6);
/* Begin phase-encode loop ****************************/
peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr);
/* Read external kspace table if set ******************/
if (table)
getelem(t1,vpe_ctr,vpe_index);
else
sub(vpe_ctr,vpe_offset,vpe_index);
settable(t2,2,ph180); // initialize phase tables and variables
getelem(t2,vpe_ctr,vph180);
add(oph,vph180,vph180); // 180 deg pulse phase alternates +/- 90 from receiver
mod2(ct,vph2);
dbl(vph2,vph2);
add(vph180,vph2,vph180); // Alternate phase for 180 on odd transients
/* Begin multislice loop ******************************/
msloop(seqcon[1],ns,vms_slices,vms_ctr);
if (ticks) {
xgate(ticks);
grad_advance(gpropdelay);
}
/* TTL scope trigger **********************************/
sp1on(); delay(5e-6); sp1off();
/* Prepulses ******************************************/
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
/* Optional IR pulse **********************************/
if (ir[0] == 'y') {
obspower(ir_rf.powerCoarse);
obspwrf(ir_rf.powerFine);
delay(4e-6);
obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0,0,ssi_grad.amp,NOWAIT);
delay(ssi_grad.rfDelayFront);
shapedpulselist(shapeIR,ssi_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ssi_grad.rfDelayBack);
delay(ti_delay);
}
/* Slice select RF pulse ******************************/
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(4e-6);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shape90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Phase encode, refocus, and dephase gradient ********/
pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,-ssr_grad.amp,
pe_grad.increment,vpe_index,WAIT);
delay(del1); // delay to start of first diffusion gradient
if (diff[0] == 'y') {
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
}
delay(del2); // delay from end of diffusion to slice refocusing
/* Refocusing RF pulse ********************************/
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(4e-6);
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shape180,ss2_grad.rfDuration,vph180,rof2,rof2,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
delay(del3); // delay from slice refocusing to second diffusion gradient
if (diff[0] == 'y') {
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
}
delay(del4); // delay from end of diffusion gradient to readout event
/* Readout gradient and acquisition ********************/
roff = -poffset(pro,ro_grad.roamp);
obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT);
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront);
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
/* Rewind Phase encoding ******************************/
pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,
pe_grad.increment,vpe_index,WAIT);
if (navigator[0] == 'y') {
roff = -poffset(pro,-ro_grad.roamp);
obl_shapedgradient(ro_grad.name,ro_grad.duration,-ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront);
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
}
/* Relaxation delay ***********************************/
delay(tr_delay);
endmsloop(seqcon[1],vms_ctr);
endpeloop(seqcon[2],vpe_ctr);
}
pulsesequence() {
/* Acquisition variables */
double dw; /* nominal dwell time, = 1/sw */
double aqtm = getval("aqtm");
/* Delay variables */
double tref,
te_delay1, te_delay2, tr_delay, ti_delay,
del1, del2, del3, del4, del5, /* before and after diffusion gradients */
busy1, busy2, /* time spent on rf pulses etc. in TE periods */
seqtime, invTime;
int use_minte;
/* RF and receiver frequency variables */
double freq90[MAXNSLICE],freq180[MAXNSLICE],freqIR[MAXNSLICE]; /* frequencies for multi-slice */
int shape90=0, shape180=0, shapeIR=0; /* List ID for RF shapes */
double roff1, roff2, roffn; /* Receiver offsets when FOV is offset along readout */
/* Gradient amplitudes, may vary depending on "image" parameter */
double peramp, perinc, peamp, roamp, roramp;
/* diffusion variables */
#define MAXDIR 1024 /* Will anybody do more than 1024 directions or b-values? */
int diff_in_one = 0;
double tmp, tmp_ss2;
double roarr[MAXDIR], pearr[MAXDIR], slarr[MAXDIR];
int nbval, /* Total number of bvalues*directions */
nbro, nbpe, nbsl; /* bvalues*directions along RO, PE, and SL */
double bro[MAXDIR], bpe[MAXDIR], bsl[MAXDIR], /* b-values along RO, PE, SL */
brs[MAXDIR], brp[MAXDIR], bsp[MAXDIR], /* the cross-terms */
btrace[MAXDIR], /* and the trace */
max_bval=0,
dcrush, dgss2, /* "delta" for crusher and gss2 gradients */
Dro, Dcrush, Dgss2; /* "DELTA" for readout, crusher and gss2 gradients */
/* loop variable */
int i;
/* Real-time variables used in this sequence **************/
int vms_slices = v3; // Number of slices
int vms_ctr = v4; // Slice loop counter
int vnseg = v5; // Number of segments
int vnseg_ctr = v6; // Segment loop counter
int vetl = v7; // Number of choes in readout train
int vetl_ctr = v8; // etl loop counter
int vblip = v9; // Sign on blips in multi-shot experiment
int vssepi = v10; // Number of Gradient Steady States lobes
int vssepi_ctr = v11; // Steady State counter
int vacquire = v12; // Argument for setacqvar, to skip steady states
/******************************************************/
/* VARIABLE INITIALIZATIONS ***************************/
/******************************************************/
get_parameters();
euler_test();
if (tep < 0) { // adjust by reducing gpropdelay by that amount
gpropdelay += tep;
tep = 0;
}
setacqmode(WACQ|NZ); // Necessary for variable rate sampling
use_minte = (minte[0] == 'y');
/******************************************************/
/* CALCULATIONS ***************************************/
/******************************************************/
if (ix == 1) {
/* Calculate RF pulse */
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
calc_rf(&p1_rf,"tpwr1","tpwr1f");
/* Calculate gradients: */
init_slice(&ss_grad,"ss",thk);
calc_slice(&ss_grad, &p1_rf,WRITE,"gss");
init_slice_refocus(&ssr_grad,"ssr");
calc_slice_refocus(&ssr_grad, &ss_grad, WRITE,"gssr");
if (spinecho[0] == 'y') {
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof1);
calc_rf(&p2_rf,"tpwr2","tpwr2f");
init_slice_butterfly(&ss2_grad,"ss2",thk,gcrush,tcrush);
calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2");
}
else ss2_grad.duration = 0; /* used for diffusion calculations */
init_readout(&epiro_grad,"epiro",lro,np,sw);
init_readout_refocus(&ror_grad,"ror");
init_phase(&epipe_grad, "epipe",lpe,nv);
init_phase(&per_grad,"per",lpe,nv);
init_readout(&nav_grad,"nav",lro,np,sw);
init_epi(&epi_grad);
if (!strcmp(orient,"oblique")) {
if ((phi != 90) || (psi != 90) || (theta != 90)) {
/* oblique slice - this should take care of most cases */
epiro_grad.slewRate /= 3; /* = gmax/trise */
epipe_grad.slewRate /= 3;
}
}
calc_epi(&epi_grad,&epiro_grad,&epipe_grad,&ror_grad,&per_grad,&nav_grad,NOWRITE);
/* Make sure the slice refocus, readout refocus,
and phase dephaser fit in the same duration */
tref = calc_sim_gradient(&ror_grad, &per_grad, &null_grad, getval("tpe"), WRITE);
if (sgldisplay) displayEPI(&epi_grad);
/* calc_sim_gradient recalculates per_grad, so reset its
base amplitude for centric ordering or fractional k-space*/
switch(ky_order[0]) {
case 'l':
per_grad.amp *= (fract_ky/(epipe_grad.steps/2));
break;
case 'c':
per_grad.amp = (nseg/2-1)*per_grad.increment;
break;
}
if (ir[0] == 'y') {
init_rf(&ir_rf,pipat,pi,flipir,rof1,rof1);
calc_rf(&ir_rf,"tpwri","tpwrif");
init_slice_butterfly(&ssi_grad,"ssi",thk,gcrush,tcrush);
calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi");
}
if (fsat[0] == 'y') {
create_fatsat();
}
if (diff[0] == 'y') {
init_generic(&diff_grad,"diff",gdiff,tdelta);
diff_grad.maxGrad = gmax;
calc_generic(&diff_grad,NOWRITE,"","");
/* adjust duration, so tdelta is from start ramp up to start ramp down */
if (ix == 1) {
diff_grad.duration += diff_grad.tramp;
calc_generic(&diff_grad,WRITE,"","");
}
}
/* Acquire top-down or bottom-up ? */
if (ky_order[1] == 'r') {
epipe_grad.amp *= -1;
per_grad.amp *= -1;
per_grad.increment *= -1;
}
} /* end gradient setup if ix == 1 */
/* Load table used to determine multi-shot direction */
settable(t2,(int) nseg,epi_grad.table2);
/* What is happening in the 2 TE/2 periods (except for diffusion)? */
busy1 = ss_grad.rfCenterBack + ssr_grad.duration;
busy2 = tep + nav_grad.duration*(epi_grad.center_echo + 0.5);
if (navigator[0] == 'y')
busy2 += (tep + nav_grad.duration + per_grad.duration);
/* How much extra time do we have in each TE/2 period? */
if (spinecho[0] == 'y') {
busy1 += (GDELAY + ss2_grad.rfCenterFront);
busy2 += ss2_grad.rfCenterBack;
temin = MAX(busy1,busy2)*2;
if (use_minte) te = temin;
te_delay1 = te/2 - busy1;
te_delay2 = te/2 - busy2;
if (temin > te) { /* Use min TE and try and catch further violations of min TE */
te_delay1 = temin/2 - busy1;
te_delay2 = temin/2 - busy2;
}
}
else { /* Gradient echo */
temin = (busy1 + busy2);
if (use_minte) te = temin;
te_delay1 = te - temin;
te_delay2 = 0;
if (temin > te) te_delay1 = 0;
}
/* Now fill in the diffusion delays:
del1 = between 90 and 1st diffusion gradient
del2 = after 1st diffusion gradient
del3 = before 2nd diffusion gradient when both in same TE/2 period
del4 = before 2nd diffusion gradient when in different TE/2 period
del5 = before acquisition
Ie, the order is:
90 - del1 - diff - del2 - (diff - del3) - 180 - (del4 - diff) - del5 - acq
where one and only one of the two options (diff - del3) or (del4 - diff) is used
*/
if (diff[0] == 'y') {
tmp_ss2 = GDELAY + ss2_grad.duration; /* ss2 grad + 4us delay */
del1 = del2 = del3 = del4 = del5 = 0;
if (tDELTA < (diff_grad.duration + tmp_ss2)) /* Minimum DELTA */
abort_message("ERROR %s: tDELTA is too short, minimum is %.2fms\n",
seqfil,(diff_grad.duration + tmp_ss2)*1000+0.005);
if (tDELTA + diff_grad.duration > te_delay1 + tmp_ss2 + te_delay2) {
if (!use_minte) {
abort_message("ERROR %s: Maximum tDELTA is %.2fms",
seqfil,te_delay1 + ss2_grad.duration + te_delay2 - diff_grad.duration);
}
else {
tmp = (tDELTA + diff_grad.duration) - (te_delay1 + tmp_ss2 + te_delay2);
if (spinecho[0] == 'y') {
te_delay1 += (tmp/2);
te_delay2 += (tmp/2);
}
else
te_delay1 += tmp;
temin += tmp;
}
}
if (spinecho[0] == 'y') {
if (te_delay1 >= (tDELTA + diff_grad.duration)) { /* Put them both in 1st TE/2 period, */
diff_in_one = (diff[0] == 'y'); /* no need to increase temin */
del2 = tDELTA - diff_grad.duration; /* time between diffusion gradients */
del3 = te_delay1 - (tDELTA+diff_grad.duration); /* time after diffusion gradients */
del5 = te_delay2; /* delay in second TE/2 period */
}
else { /* put them on each side of the 180 */
diff_in_one = 0;
busy1 += diff_grad.duration;
busy2 += diff_grad.duration;
temin = 2*MAX(busy1,busy2);
/* Optimally, the 2nd diff grad is right after the 180 */
del2 = tDELTA - diff_grad.duration - tmp_ss2; /* This is always > 0, or we would have aborted above */
del1 = te_delay1 - (diff_grad.duration + del2);
if (del1 < 0) {
del1 = 0; /* Place the 1st right after the 90 and push the 2nd out */
del4 = tDELTA - te_delay1 - ss2_grad.duration;
}
del5 = te_delay2 - (del4 + diff_grad.duration);
/* del5 could still be < 0, when te_delay2 < diff_grad.duration */
if (del5 < 0) {
del1 += fabs(del5); /* Increase each TE/2 period by abs(del5) */
del5 = 0;
}
}
}
else { /* gradient echo */
diff_in_one = (diff[0] == 'y');
del1 = 0;
del2 = tDELTA - diff_grad.duration; /* time between diffusion gradients */
del3 = 0;
del4 = 0;
if (!use_minte) /* user defined TE */
del5 = te_delay1 - (tDELTA + diff_grad.duration);
}
} /* End of Diffusion block */
else {
del1 = te_delay1;
del5 = te_delay2;
del2 = del3 = del4 = 0;
}
if (sgldisplay) {
text_message("busy1/2, temin = %f, %f, %f",busy1*1e3, busy2*1e3, temin*1e3);
text_message("te_delay1/2 = %f, %f",te_delay1*1e3, te_delay2*1e3);
text_message("delays 1-5: %.2f, %.2f, %.2f, %.2f, %.2fms\n",del1*1000,del2*1000,del3*1000,del4*1000,del5*1000);
}
/* Check if TE is long enough */
temin = ceil(temin*1e6)/1e6; /* round to nearest us */
if (use_minte) {
te = temin;
putvalue("te",te);
}
else if (temin > te) {
abort_message("TE too short, minimum is %.2f ms\n",temin*1000);
}
if (ir[0] == 'y') {
ti_delay = ti - (pi*ssi_grad.rfFraction + rof2 + ssi_grad.rfDelayBack)
- (ss_grad.rfDelayFront + rof1 + p1*(1-ss_grad.rfFraction));
if (ti_delay < 0) {
abort_message("TI too short, minimum is %.2f ms\n",(ti-ti_delay)*1000);
}
}
else ti_delay = 0;
invTime = GDELAY + ssi_grad.duration + ti_delay;
/* Minimum TR per slice, w/o options */
seqtime = GDELAY + ss_grad.rfCenterFront // Before TE
+ te
+ (epiro_grad.duration - nav_grad.duration*(epi_grad.center_echo+0.5)); // After TE
/* Add in time for options outside of TE */
if (ir[0] == 'y') seqtime += invTime;
if (fsat[0] == 'y') seqtime += fsatTime;
trmin = seqtime + 4e-6; /* ensure a minimum of 4us in tr_delay */
trmin *= ns;
if (tr - trmin < 0.0) {
abort_message("%s: Requested tr too short. Min tr = %.2f ms\n",
seqfil,ceil(trmin*100000)/100.00);
}
/* spread out multi-slice acquisition over total TR */
tr_delay = (tr - ns*seqtime)/ns;
/******************************************************/
/* Return gradient values to VnmrJ interface */
/******************************************************/
putvalue("etl",epi_grad.etl+2*ssepi);
putvalue("gro",epiro_grad.amp);
putvalue("rgro",epiro_grad.tramp);
putvalue("gror",ror_grad.amp);
putvalue("tror",ror_grad.duration);
putvalue("rgror",ror_grad.tramp);
putvalue("gpe",epipe_grad.amp);
putvalue("rgpe",epipe_grad.tramp);
putvalue("gped",per_grad.amp);
putvalue("tped",per_grad.duration);
putvalue("rgped",per_grad.tramp);
putvalue("gss",ss_grad.amp);
putvalue("gss2",ss2_grad.ssamp);
putvalue("rgss",ss_grad.tramp);
putvalue("gssr",ssr_grad.amp);
putvalue("tssr",ssr_grad.duration);
putvalue("rgssr",ssr_grad.tramp);
putvalue("rgss2",ss2_grad.crusher1RampToSsDuration);
putvalue("rgssi",ssi_grad.crusher1RampToSsDuration);
putvalue("rgcrush",ssi_grad.crusher1RampToCrusherDuration);
putvalue("at_full",epi_grad.duration);
putvalue("at_one",nav_grad.duration);
putvalue("rcrush",ss2_grad.crusher1RampToCrusherDuration);
putvalue("np_ramp",epi_grad.np_ramp);
putvalue("np_flat",epi_grad.np_flat);
if (diff[0] == 'y') { /* CALCULATE B VALUES */
/* Get multiplication factors and make sure they have same # elements */
/* All this is only necessary because putCmd only work for ix==1 */
nbro = (int) getarray("dro",roarr); nbval = nbro;
nbpe = (int) getarray("dpe",pearr); if (nbpe > nbval) nbval = nbpe;
nbsl = (int) getarray("dsl",slarr); if (nbsl > nbval) nbval = nbsl;
if ((nbro != nbval) && (nbro != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (readout)",seqfil);
if ((nbpe != nbval) && (nbpe != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (phase)",seqfil);
if ((nbsl != nbval) && (nbsl != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (slice)",seqfil);
if (nbro == 1) for (i = 1; i < nbval; i++) roarr[i] = roarr[0];
if (nbpe == 1) for (i = 1; i < nbval; i++) pearr[i] = pearr[0];
if (nbsl == 1) for (i = 1; i < nbval; i++) slarr[i] = slarr[0];
}
else {
nbval = 1;
roarr[0] = 0;
pearr[0] = 0;
slarr[0] = 0;
}
for (i = 0; i < nbval; i++) {
/* We need to worry about slice gradients & crushers for slice gradients */
/* Everything else is outside diffusion gradients, and thus constant */
/* for all b-values/directions */
/* Readout */
bro[i] = bval(gdiff*roarr[i],tdelta,tDELTA);
/* Phase */
bpe[i] = bval(gdiff*pearr[i],tdelta,tDELTA);
/* Slice */
dgss2 = p2/2; Dgss2 = dgss2;
dcrush = tcrush; Dcrush = dcrush + p2;
bsl[i] = bval(gdiff*slarr[i],tdelta,tDELTA);
if (spinecho[0] == 'y') {
bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval(gcrush,dcrush,Dcrush);
bsl[i] += bval_nested(gcrush,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2);
}
if (!diff_in_one) {
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
}
/* Readout/Slice Cross-terms */
brs[i] = bval2(gdiff*roarr[i],gdiff*slarr[i],tdelta,tDELTA);
if (spinecho[0] == 'y') {
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
}
/* Readout/Phase Cross-terms */
brp[i] = bval2(gdiff*roarr[i],gdiff*pearr[i],tdelta,tDELTA);
/* Slice/Phase Cross-terms */
bsp[i] = bval2(gdiff*slarr[i],gdiff*pearr[i],tdelta,tDELTA);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
btrace[i] = (bro[i]+bsl[i]+bpe[i]);
if (max_bval < btrace[i]) {
max_bval = (bro[i]+bsl[i]+bpe[i]);
}
} /* End for-all-directions */
putarray("bvalrr",bro,nbval);
putarray("bvalpp",bpe,nbval);
putarray("bvalss",bsl,nbval);
putarray("bvalrp",brp,nbval);
putarray("bvalrs",brs,nbval);
putarray("bvalsp",bsp,nbval);
putarray("bvalue",btrace,nbval);
putvalue("max_bval",max_bval);
/* Set all gradients depending on whether we do */
/* Use separate variables, because we only initialize & calculate gradients for ix==1 */
peamp = epipe_grad.amp;
perinc = per_grad.increment;
peramp = per_grad.amp;
roamp = epiro_grad.amp;
roramp = ror_grad.amp;
switch ((int)image) {
case 1: /* Real image scan, don't change anything */
break;
case 0: /* Normal reference scan */
peamp = 0;
perinc = 0;
peramp = 0;
roamp = epiro_grad.amp;
roramp = ror_grad.amp;
break;
case -1: /* Inverted image scan */
roamp = -epiro_grad.amp;
roramp = -ror_grad.amp;
break;
case -2: /* Inverted reference scan */
peamp = 0;
perinc = 0;
peramp = 0;
roamp = -epiro_grad.amp;
roramp = -ror_grad.amp;
break;
default: break;
}
/* Generate phase-ramped pulses: 90, 180, and IR */
offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]);
shape90 = shapelist(p1pat,ss_grad.rfDuration,freq90,ns,0,seqcon[1]);
if (spinecho[0] == 'y') {
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shape180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]);
}
if (ir[0] == 'y') {
offsetlist(pss,ssi_grad.ssamp,0,freqIR,ns,seqcon[1]);
shapeIR = shapelist(pipat,ssi_grad.rfDuration,freqIR,ns,0,seqcon[1]);
}
sgl_error_check(sglerror);
roff1 = -poffset(pro,epi_grad.amppos);
roff2 = -poffset(pro,epi_grad.ampneg);
roffn = -poffset(pro,nav_grad.amp);
roff1 = -poffset(pro,epi_grad.amppos*roamp/epiro_grad.amp);
roff2 = -poffset(pro,epi_grad.ampneg*roamp/epiro_grad.amp);
roffn = -poffset(pro,nav_grad.amp);
dw = granularity(1/sw,1/epi_grad.ddrsr);
/* Total Scan Time */
g_setExpTime(tr*nt*nseg*arraydim);
/******************************************************/
/* PULSE SEQUENCE *************************************/
/******************************************************/
rotate();
F_initval(epi_grad.etl/2, vetl);
/* vetl is the loop counter in the acquisition loop */
/* that includes both a positive and negative readout lobe */
F_initval(nseg, vnseg);
/* NB. F_initval(-ssepi,vssepi); currently gives errors */
initval(-ssepi,vssepi); /* gradient steady state lobes */
obsoffset(resto); delay(GDELAY);
ifzero(rtonce); grad_advance(gpropdelay); endif(rtonce);
loop(vnseg,vnseg_ctr); /* Loop through segments in segmented EPI */
msloop(seqcon[1],ns,vms_slices,vms_ctr); /* Multislice loop */
assign(vssepi,vssepi_ctr);
sp1on(); delay(4e-6); sp1off(); /* Output trigger to look at scope */
if (ticks) {
xgate(ticks);
grad_advance(gpropdelay);
delay(4e-6);
}
getelem(t2,vnseg_ctr,vblip); /* vblip = t2[vnseg_ctr]; either 1 or -1 for pos/neg blip */
/* Optional FAT SAT */
if (fsat[0] == 'y') {
fatsat();
}
/* Optional IR + TI delay */
if (ir[0] == 'y') {
obspower(ir_rf.powerCoarse);
obspwrf(ir_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0.0,0.0,ssi_grad.amp,NOWAIT);
delay(ssi_grad.rfDelayBack);
shapedpulselist(shapeIR,ssi_grad.rfDuration,oph,rof1,rof1,seqcon[1],vms_ctr);
delay(ssi_grad.rfDelayBack);
delay(ti_delay);
}
/* 90 ss degree pulse */
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0.0,0.0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shape90,p1_rf.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Slice refocus */
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT);
delay(del1);
if (diff[0] == 'y')
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del2);
if (diff_in_one)
obl_shapedgradient(diff_grad.name,diff_grad.duration,
-diff_grad.amp*dro,-diff_grad.amp*dpe,-diff_grad.amp*dsl,WAIT);
delay(del3);
/* Optional 180 ss degree pulse with crushers */
if (spinecho[0] == 'y') {
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0.0,0.0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shape180,ss2_grad.rfDuration,oph,rof1,rof1,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
}
delay(del4);
if ((diff[0] == 'y') && !diff_in_one)
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del5);
/* Optional navigator echo */
if (navigator[0] == 'y') {
obl_shapedgradient(ror_grad.name,ror_grad.duration,roramp,0,0,WAIT);
obl_shapedgradient(nav_grad.name,nav_grad.duration,
-nav_grad.amp,0,0,NOWAIT);
delay(tep);
roff = roffn; /* Set receiver offset for navigator gradient */
delay(epi_grad.skip-alfa); /* ramp up */
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw);
delay((epi_grad.dwell[i] - dw));
}
sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
/* Phase encode dephaser here if navigator echo was acquired */
var_shapedgradient(per_grad.name,per_grad.duration,0,-peramp,0,perinc,vnseg_ctr,WAIT);
}
else {
var_shapedgradient(per_grad.name,per_grad.duration,
-roramp,-peramp,0,perinc,vnseg_ctr,WAIT);
}
/* Start readout and phase encode gradient waveforms, NOWAIT */
/* If alternating ky-ordering, get polarity on blips from table */
var_shaped3gradient(epiro_grad.name,epipe_grad.name,"", /* patterns */
epiro_grad.duration, /* duration */
roamp,0,0, /* amplitudes */
peamp,vblip, /* step and multiplier */
NOWAIT); /* Don't wait */
delay(tep);
/* Acquisition loop */
assign(one,vacquire); // real-time acquire flag
nowait_loop(epi_grad.etl/2 + ssepi,vetl,vetl_ctr);
ifzero(vssepi_ctr); //vssepi_ctr = -ssepi, -ssepi+1, ..., 0, 1,2,...
assign(zero,vacquire); // turn on acquisition after all ss lobes
endif(vssepi_ctr);
incr(vssepi_ctr);
setacqvar(vacquire); // Set acquire flag
roff = roff1; /* Set receiver offset for positive gradient */
delay(epi_grad.skip-alfa); /* ramp up */
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw); //dw = 1/sw
delay((epi_grad.dwell[i] - dw));
}
if (aqtm > at) sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
roff = roff2; /* Set receiver offset for negative gradient */
delay(epi_grad.skip-alfa);
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw);
delay((epi_grad.dwell[i] - dw));
}
if (aqtm > at) sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
nowait_endloop(vetl_ctr);
delay(tr_delay);
endmsloop(seqcon[1],vms_ctr); /* end multislice loop */
endloop(vnseg_ctr); /* end segments loop */
} /* end pulsesequence */
void processLightMenu_three(int option) {
switch (option) {
case 0:
//off
glDisable(GL_LIGHT2);
//you could alternatively use the color code for no_light
break;
case 1:
//white
putarray(amb3,white_light);
putarray(diff3,white_light);
putarray(spec3,white_light);
glEnable(GL_LIGHT2);
if (specflag== 1) {
glLightfv(GL_LIGHT2, GL_SPECULAR, spec3);
} else if (specflag==0) {
glLightfv(GL_LIGHT2, GL_SPECULAR, offspec3);
};
if (difflag ==1) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, diff3);
} else if(difflag ==0) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, offdiff3);
}
glLightfv(GL_LIGHT2, GL_AMBIENT, amb3);
break;
case 2:
//red
putarray(amb3,red_light);
putarray(diff3,red_light);
putarray(spec3,red_light);
glEnable(GL_LIGHT2);
if (specflag== 1) {
glLightfv(GL_LIGHT2, GL_SPECULAR, spec3);
} else if (specflag==0) {
glLightfv(GL_LIGHT2, GL_SPECULAR, offspec3);
};
if (difflag ==1) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, diff3);
} else if(difflag ==0) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, offdiff3);
}
glLightfv(GL_LIGHT2, GL_AMBIENT, amb3);
break;
case 3:
//blue
putarray(amb3,blue_light);
putarray(diff3,blue_light);
putarray(spec3,blue_light);
glEnable(GL_LIGHT2);
if (specflag== 1) {
glLightfv(GL_LIGHT2, GL_SPECULAR, spec3);
} else if (specflag==0) {
glLightfv(GL_LIGHT2, GL_SPECULAR, offspec3);
};
if (difflag ==1) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, diff3);
} else if(difflag ==0) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, offdiff3);
}
glLightfv(GL_LIGHT2, GL_AMBIENT, amb3);
break;
case 4:
//green
putarray(amb3,green_light);
putarray(diff3,green_light);
putarray(spec3,green_light);
glEnable(GL_LIGHT2);
if (specflag== 1) {
glLightfv(GL_LIGHT2, GL_SPECULAR, spec3);
} else if (specflag==0) {
glLightfv(GL_LIGHT2, GL_SPECULAR, offspec3);
};
if (difflag ==1) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, diff3);
} else if(difflag ==0) {
glLightfv(GL_LIGHT2, GL_DIFFUSE, offdiff3);
}
glLightfv(GL_LIGHT2, GL_AMBIENT, amb3);
break;
};
glutPostRedisplay();
}
void pulsesequence() {
/* Internal variable declarations *************************/
int shapelist90,shapelist180;
double seqtime,tau1,tau2,tau3,te1_delay,te2_delay,te3_delay,tr_delay;
double freq90[MAXNSLICE], freq180[MAXNSLICE];
/* Diffusion variables */
double te1, te1min, del1, del2, del3, del4;
double te_diff1, te_diff2, tmp1, tmp2;
double diffamp;
char diffpat[MAXSTR];
/* Navigator variables */
double etlnav;
/* Variable crushers */
double cscale;
double vcrush; // flag
/* Diffusion parameters */
#define MAXDIR 1024 /* Will anybody do more than 1024 directions or b-values? */
double roarr[MAXDIR], pearr[MAXDIR], slarr[MAXDIR];
int nbval, /* Total number of bvalues*directions */
nbro, nbpe, nbsl,
i;
double bro[MAXDIR], bpe[MAXDIR], bsl[MAXDIR], /* b-values along RO, PE, SL */
brs[MAXDIR], brp[MAXDIR], bsp[MAXDIR], /* and the cross-terms */
btrace[MAXDIR], /* and the trace */
max_bval=0,
dcrush, dgss2, /* "delta" for crusher and gss2 gradients */
Dro, Dcrush, Dgss2; /* "DELTA" for readout, crusher and gss2 gradients */
/* Real-time variables used in this sequence **************/
int vpe_ctr = v1; // PE loop counter
int vpe_mult = v2; // PE multiplier, ranges from -PE/2 to PE/2
int vpe2_ctr = v3; // PE loop counter
int vpe2_mult = v4; // PE multiplier, ranges from -PE/2 to PE/2
int vpe2_offset = v5;
int vpe2_steps = v6;
int vms_slices = v7; // Number of slices
int vms_ctr = v8; // Slice loop counter
int vseg = v9; // Number of ETL segments
int vseg_ctr = v10; // Segment counter
int vetl = v11; // Echo train length
int vetl_ctr = v12; // Echo train loop counter
int vssc = v13; // Compressed steady-states
int vtrimage = v14; // Counts down from nt, trimage delay when 0
int vacquire = v15; // Argument for setacqvar, to skip steady state acquires
int vphase180 = v16; // phase of 180 degree refocusing pulse
int vetl_loop = v17; // Echo train length MINUS ONE, used on etl loop
int vnav = v18; // Echo train length
int vcr_ctr = v19; // variable crusher, index into table
int vcr1 = v20; // multiplier along RO
int vcr2 = v21; // multiplier along PE
int vcr3 = v22; // multiplier along SL
int vetl1 = v23; // = etl-1, determine navigator echo location in echo loop
int vcr_reset = v24; // check for navigator echoes, reset crushers
/* Initialize paramaters **********************************/
get_parameters();
te1 = getval("te1"); /* te1 is the echo time for the first echo */
cscale = getval("cscale"); /* Scaling factor on first 180 crushers */
vcrush = getval("vcrush"); /* Variable crusher or set amplitude? */
getstr("diffpat",diffpat);
/* Load external PE table ********************************/
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
} else {
abort_message("petable undefined");
}
/* Hold variable crushers in tables 5, 6, 7 */
settable(t5,8,crro);
settable(t6,8,crpe);
settable(t7,8,crss);
seqtime = 0.0;
espmin = 0.0;
/* RF Power & Bandwidth Calculations **********************/
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2);
// shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2);
// shape_rf(&p2_rf,"p2",p2pat,p2,flip2,rof1,rof2);
calc_rf(&p1_rf,"tpwr1","tpwr1f");
calc_rf(&p2_rf,"tpwr2","tpwr2f");
/* Initialize gradient structures *************************/
init_readout(&ro_grad,"ro",lro,np,sw);
init_readout_refocus(&ror_grad,"ror");
init_phase(&pe_grad,"pe",lpe,nv);
init_phase(&pe2_grad,"pe2",lpe2,nv2);
init_slice(&ss_grad,"ss",thk); /* NOTE assume same band widths for p1 and p2 */
init_slice(&ss2_grad,"ss2",thk); /* not butterfly, want to scale crushers w/ echo */
init_slice_refocus(&ssr_grad,"ssr");
/* Gradient calculations **********************************/
calc_readout(&ro_grad,WRITE,"gro","sw","at");
calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror");
calc_phase(&pe_grad,NOWRITE,"gpe","tpe");
calc_phase(&pe2_grad,NOWRITE,"gpe2","tpe2");
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice(&ss2_grad,&p1_rf,WRITE,"");
calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr");
/* Equalize refocus and PE gradient durations *************/
calc_sim_gradient(&ror_grad,&pe_grad,&pe2_grad,0.0,WRITE);
/* Variable crusher */
init_generic(&crush_grad,"crush",gcrush,tcrush);
calc_generic(&crush_grad,WRITE,"","");
/* Create optional prepulse events ************************/
if (sat[0] == 'y') create_satbands();
if (fsat[0] == 'y') create_fatsat();
if (mt[0] == 'y') create_mtc();
/* Optional Diffusion gradient */
if (diff[0] == 'y') {
init_generic(&diff_grad,"diff",gdiff,tdelta);
if (!strcmp("sine",diffpat)) {
diff_grad.shape = SINE;
diffamp = gdiff*1;
}
/* adjust duration, so tdelta is from start ramp up to start ramp down */
if ((ix == 1) && (diff_grad.shape == TRAPEZOID)) {
calc_generic(&diff_grad,NOWRITE,"","");
diff_grad.duration += diff_grad.tramp;
}
calc_generic(&diff_grad,WRITE,"","");
}
/* Set up frequency offset pulse shape list ********/
offsetlist(pss,ss_grad.amp,0,freq90,ns,seqcon[1]);
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shapelist90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration, freq90, ns,0,seqcon[1]);
shapelist180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]);
/* same slice selection gradient and RF pattern used */
if (ss_grad.rfFraction != 0.5)
abort_message("RF pulse must be symmetric (RF fraction = %.2f)",ss_grad.rfFraction);
if (ro_grad.echoFraction != 1)
abort_message("Echo Fraction must be 1");
/*****************************************************/
/* TIMING FOR ECHOES *********************************/
/*****************************************************/
/* First echo time, without diffusion */
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront;
tau2 = ss2_grad.rfCenterBack + crush_grad.duration + pe_grad.duration + ro_grad.timeToEcho;
te1min = 2*MAX(tau1,tau2);
if (te1 < te1min + 2*4e-6) {
abort_message("First echo time too small, minimum is %.2fms\n",(te1min+2*4e-6)*1000);
}
/* Each half-echo period in the ETL loop ********/
tau3 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront;
espmin = 2*MAX(tau2,tau3); // Minimum echo spacing
if (minesp[0] == 'y') {
esp = espmin + 2*4e-6;
putvalue("esp",esp);
}
if (esp - (espmin + 2*4e-6) < -12.5e-9) {
abort_message("Echo spacing too small, minimum is %.2fms\n",(espmin+2*4e-6)*1000);
}
te1_delay = te1/2.0 - tau1;
te2_delay = esp/2.0 - tau2;
te3_delay = esp/2.0 - tau3;
/*****************************************************/
/* TIMING FOR DIFFUSION ******************************/
/*****************************************************/
del1 = te1/2.0 - tau1;
del2 = 0;
del3 = te1/2.0 - tau2;
del4 = 0;
if (diff[0] == 'y') {
tau1 += diff_grad.duration;
tau2 += diff_grad.duration;
te1min = 2*MAX(tau1,tau2);
if (te1 < te1min + 4*4e-6) { /* te1 is split into 4 delays, each of which must be >= 4us */
abort_message("ERROR %s: First echo time too small, minimum is %.2fms\n",seqfil,te1min*1000);
}
/* te1 is the echo time for the first echo */
te_diff1 = te1/2 - tau1; /* Available time in first half of first echo */
te_diff2 = te1/2 - tau2; /* Available time in second half of first echo */
tmp1 = ss2_grad.duration + 2*crush_grad.duration; /* duration of 180 block */
/* Is tDELTA long enough? */
if (tDELTA < diff_grad.duration + tmp1)
abort_message("DELTA too short, increase to %.2fms",
(diff_grad.duration + tmp1)*1000);
/* Is tDELTA too long? */
tmp2 = diff_grad.duration + te_diff1 + tmp1 + te_diff2;
if (tDELTA > tmp2) {
abort_message("DELTA too long, increase te1 to %.2fms",
(te1 + (tDELTA-tmp2))*1000);
}
/* First attempt to put lobes right after slice select, ie del1 = 0 */
del1 = 4e-6; /* At least 4us after setting power for 180 */
del2 = te_diff1 - del1;
del3 = tDELTA - (diff_grad.duration + del2 + tmp1);
if (del3 < 4e-6) { /* shift diffusion block towards acquisition */
del3 = 4e-6;
del2 = tDELTA - (diff_grad.duration + tmp1 + del3);
}
del1 = te_diff1 - del2;
del4 = te_diff2 - del3;
if (fabs(del4) < 12.5e-9) del4 = 0;
}
te = te1 + (kzero-1)*esp; // Return effective TE
putvalue("te",te);
/* How many echoes in the echo loop, including navigators? */
etlnav = (etl-1)+(navigator[0]=='y')*2.0;
/* Minimum TR **************************************/
seqtime = 4e-6 + 2*nseg*ns*4e-6; /* count all the 4us delays */
seqtime += ns*(ss_grad.duration/2 + te1 + (etlnav)*esp + ro_grad.timeFromEcho + pe_grad.duration + te3_delay);
/* Increase TR if any options are selected****************/
if (sat[0] == 'y') seqtime += ns*satTime;
if (fsat[0] == 'y') seqtime += ns*fsatTime;
if (mt[0] == 'y') seqtime += ns*mtTime;
trmin = seqtime + ns*4e-6; /* Add 4us to ensure that tr_delay is always >= 4us */
if (mintr[0] == 'y'){
tr = trmin;
putvalue("tr",tr+1e-6);
}
if (tr < trmin) {
abort_message("TR too short. Minimum TR = %.2fms\n",trmin*1000);
}
tr_delay = (tr - seqtime)/ns;
/* Set number of segments for profile or full image **********/
nseg = prep_profile(profile[0],nv/etl,&pe_grad,&per_grad);
pe2_steps = prep_profile(profile[1],nv2,&pe2_grad,&pe2r_grad);
/* Calculate total scan time */
g_setExpTime(tr*(nt*nseg*pe2_steps*arraydim + ssc));
/***************************************************/
/* CALCULATE B VALUES ******************************/
if (diff[0] == 'y') {
/* Get multiplication factors and make sure they have same # elements */
/* All this is only necessary because putCmd only work for ix==1 */
nbro = (int) getarray("dro",roarr); nbval = nbro;
nbpe = (int) getarray("dpe",pearr); if (nbpe > nbval) nbval = nbpe;
nbsl = (int) getarray("dsl",slarr); if (nbsl > nbval) nbval = nbsl;
if ((nbro != nbval) && (nbro != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (readout)",seqfil);
if ((nbpe != nbval) && (nbpe != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (phase)",seqfil);
if ((nbsl != nbval) && (nbsl != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (slice)",seqfil);
if (nbro == 1) for (i = 1; i < nbval; i++) roarr[i] = roarr[0];
if (nbpe == 1) for (i = 1; i < nbval; i++) pearr[i] = pearr[0];
if (nbsl == 1) for (i = 1; i < nbval; i++) slarr[i] = slarr[0];
}
else {
nbval = 1;
roarr[0] = 0;
pearr[0] = 0;
slarr[0] = 0;
}
for (i = 0; i < nbval; i++) {
dcrush = crush_grad.duration; //"delta" for crusher
Dcrush = dcrush + ss_grad.duration; //"DELTA" for crusher
/* Readout */
Dro = ror_grad.duration;
bro[i] = bval(gdiff*roarr[i],tdelta,tDELTA);
bro[i] += bval(ro_grad.amp,ro_grad.timeToEcho,Dro);
bro[i] += bval(crush_grad.amp,dcrush,Dcrush);
bro[i] += bval_nested(gdiff*roarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
/* Slice */
dgss2 = Dgss2 = ss_grad.rfCenterFront;
bsl[i] = bval(gdiff*slarr[i],tdelta,tDELTA);
bsl[i] += bval(crush_grad.amp,dcrush,Dcrush);
bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval_nested(ss2_grad.ssamp,dgss2,Dgss2,
crush_grad.amp,dcrush,Dcrush);
/* Phase */
bpe[i] = bval(gdiff*pearr[i],tdelta,tDELTA);
bpe[i] += bval(crush_grad.amp,dcrush,Dcrush);
bpe[i] += bval_nested(gdiff*pearr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
/* Readout/Slice Cross-terms */
brs[i] = bval2(gdiff*roarr[i],gdiff*slarr[i],tdelta,tDELTA);
brs[i] += bval2(crush_grad.amp,
crush_grad.amp,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*slarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,
ss2_grad.ssamp,dgss2,Dgss2);
brs[i] += bval_cross(crush_grad.amp,dcrush,Dcrush,
ss2_grad.ssamp,dgss2,Dgss2);
/* Readout/Phase Cross-terms */
brp[i] = bval2(gdiff*roarr[i],gdiff*pearr[i],tdelta,tDELTA);
brp[i] += bval2(crush_grad.amp,
crush_grad.amp,dcrush,Dcrush);
brp[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
brp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
/* Slice/Phase Cross-terms */
bsp[i] = bval2(gdiff*pearr[i],gdiff*slarr[i],tdelta,tDELTA);
bsp[i] += bval2(crush_grad.amp,
crush_grad.amp,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*slarr[i],tdelta,tDELTA,
crush_grad.amp,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,
ss2_grad.ssamp,dgss2,Dgss2);
bsp[i] += bval_cross(crush_grad.amp,dcrush,Dcrush,
ss2_grad.ssamp,dgss2,Dgss2);
btrace[i] = (bro[i]+bsl[i]+bpe[i]);
if (max_bval < btrace[i]) {
max_bval = (bro[i]+bsl[i]+bpe[i]);
}
} /* End for-all-directions */
putarray("bvalrr",bro,nbval);
putarray("bvalpp",bpe,nbval);
putarray("bvalss",bsl,nbval);
putarray("bvalrp",brp,nbval);
putarray("bvalrs",brs,nbval);
putarray("bvalsp",bsp,nbval);
putarray("bvalue",btrace,nbval);
putvalue("max_bval",max_bval);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* PULSE SEQUENCE *************************************/
if (ix == 1) grad_advance(tep);
initval(fabs(ssc),vssc); // Compressed steady-state counter
setacqvar(vacquire); // Control acquisition through vacquire
assign(one,vacquire); // Turn on acquire when vacquire is zero
/* Phase cycle: Alternate 180 phase to cancel residual FID */
mod2(ct,vphase180); // 0101
dbl(vphase180,vphase180); // 0202
add(vphase180,one,vphase180); // 1313 Phase difference from 90
add(vphase180,oph,vphase180);
obsoffset(resto);
delay(4e-6);
initval(nseg,vseg);
initval(pe2_steps/2.0,vpe2_offset);
initval(etl,vetl);
initval(etl-1,vetl1);
peloop2(seqcon[3],pe2_steps,vpe2_steps,vpe2_ctr);
/* Use standard encoding order for 2nd PE dimension */
sub(vpe2_ctr,vpe2_offset,vpe2_mult);
loop(vseg,vseg_ctr);
/* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */
if ((ix > 1) && (ssc > 0))
assign(zero,vssc);
sub(vseg_ctr,vssc,vseg_ctr); // vpe_ctr counts up from -ssc
assign(zero,vssc);
ifzero(vseg_ctr);
assign(zero,vacquire); // Start acquiring when vseg_ctr reaches zero
endif(vseg_ctr);
msloop(seqcon[1],ns,vms_slices,vms_ctr);
if (ticks) {
xgate(ticks);
grad_advance(tep);
}
sp1on(); delay(4e-6); sp1off(); // Scope trigger
/* Prepulse options ***********************************/
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
/* 90 degree pulse ************************************/
rotate();
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(4e-6);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shapelist90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Read dephase and Slice refocus *********************/
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0.0,0.0,-ssr_grad.amp,WAIT);
/* First half-TE delay ********************************/
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(del1);
/* DIFFUSION GRADIENT */
if (diff[0] == 'y')
obl_shapedgradient(diff_grad.name,diff_grad.duration,diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del2);
/*****************************************************/
/* FIRST ECHO OUTSIDE LOOP ***************************/
/*****************************************************/
ifzero(vacquire); // real acquisition, get PE multiplier from table
mult(vseg_ctr,vetl,vpe_ctr);
getelem(t1,vpe_ctr,vpe_mult);
elsenz(vacquire); // steady state scan
assign(zero,vpe_mult);
endif(vacquire);
/* Variable crusher */
assign(zero,vcr_ctr);
getelem(t5,vcr_ctr,vcr1);
getelem(t6,vcr_ctr,vcr2);
getelem(t7,vcr_ctr,vcr3);
if(vcrush)
phase_encode3_oblshapedgradient(crush_grad.name,crush_grad.name,crush_grad.name,
crush_grad.duration,
(double)0,(double)0,(double)0, // base levels
crush_grad.amp*cscale,crush_grad.amp*cscale,crush_grad.amp*cscale, // step size
vcr1,vcr2,vcr3, // multipliers
(double)1.0,(double)1.0,(double)1.0, // upper limit on multipliers
1,WAIT,0);
else
obl_shapedgradient(crush_grad.name,crush_grad.duration,
crush_grad.amp,crush_grad.amp,crush_grad.amp,WAIT);
/* 180 degree pulse *******************************/
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shapelist180,ss2_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
if (vcrush)
phase_encode3_oblshapedgradient(crush_grad.name,crush_grad.name,crush_grad.name,
crush_grad.duration,
(double)0,(double)0,(double)0, // base levels
crush_grad.amp*cscale,crush_grad.amp*cscale,crush_grad.amp*cscale, // step size
vcr1,vcr2,vcr3, // multipliers
(double)1.0,(double)1.0,(double)1.0, // upper limit on multipliers
1,WAIT,0);
else
obl_shapedgradient(crush_grad.name,crush_grad.duration,
crush_grad.amp,crush_grad.amp,crush_grad.amp,WAIT);
delay(del3);
/* DIFFUSION GRADIENT */
if (diff[0] == 'y')
obl_shapedgradient(diff_grad.name,diff_grad.duration,diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del4);
/* Phase-encode gradient ******************************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0,
-pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Readout gradient ************************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.roamp,0,0,NOWAIT);
delay(ro_grad.atDelayFront);
/* Acquire data ****************************************/
startacq(10e-6);
acquire(np,1.0/sw);
endacq();
delay(ro_grad.atDelayBack);
/* Rewinding phase-encode gradient ********************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,
pe_grad.increment,pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Second half-TE delay *******************************/
delay(te3_delay);
/*****************************************************/
/* LOOP THROUGH THE REST OF ETL **********************/
/*****************************************************/
peloop(seqcon[2],etlnav,vetl_loop,vetl_ctr);
ifzero(vacquire); // real acquisition, get PE multiplier from table
mult(vseg_ctr,vetl,vpe_ctr);
add(vpe_ctr,vetl_ctr,vpe_ctr);
add(vpe_ctr,one,vpe_ctr);
getelem(t1,vpe_ctr,vpe_mult);
elsenz(vacquire); // steady state scan
assign(zero,vpe_mult);
endif(vacquire);
/* But don't phase encode navigator echoes */
ifrtGE(vetl_ctr,vetl1,vnav);
assign(zero,vpe_mult);
endif(vnav);
/* Variable crusher */
incr(vcr_ctr); /* Get next crusher level */
/* Except if we're doing navigators, start over */
sub(vetl1,vetl_ctr,vcr_reset);
ifzero(vcr_reset);
assign(zero,vcr_ctr);
endif(vcr_reset);
getelem(t5,vcr_ctr,vcr1);
getelem(t6,vcr_ctr,vcr2);
getelem(t7,vcr_ctr,vcr3);
phase_encode3_oblshapedgradient(crush_grad.name,crush_grad.name,crush_grad.name,
crush_grad.duration,
(double)0,(double)0,(double)0, // base levels
crush_grad.amp,crush_grad.amp,crush_grad.amp, // step size
vcr1,vcr2,vcr3, // multipliers
(double)1.0,(double)1.0,(double)1.0, // upper limit on multipliers
1,WAIT,0);
/* 180 degree pulse *******************************/
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shapelist180,ss2_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
/* Variable crusher */
phase_encode3_oblshapedgradient(crush_grad.name,crush_grad.name,crush_grad.name,
crush_grad.duration,
(double)0,(double)0,(double)0, // base levels
crush_grad.amp,crush_grad.amp,crush_grad.amp, // step size
vcr1,vcr2,vcr3, // multipliers
(double)1.0,(double)1.0,(double)1.0, // upper limit on multipliers
1,WAIT,0);
/* Phase-encode gradient ******************************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,
-pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Second half-TE period ******************************/
delay(te2_delay);
/* Readout gradient ************************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.roamp,0,0,NOWAIT);
delay(ro_grad.atDelayFront);
startacq(10e-6);
acquire(np,1.0/sw);
endacq();
delay(ro_grad.atDelayBack);
/* Rewinding phase-encode gradient ********************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,
pe_grad.increment,pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Second half-TE delay *******************************/
delay(te3_delay);
endpeloop(seqcon[2],vetl_ctr);
/* Relaxation delay ***********************************/
if (!trtype)
delay(tr_delay);
endmsloop(seqcon[1],vms_ctr);
if (trtype)
delay(ns*tr_delay);
endloop(vseg_ctr);
endpeloop(seqcon[3],vpe2_ctr);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
}
