pulsesequence()
{
double seqtime,tr_delay,sign1,sign2;
sign1 = getval("sign1"); // first gradient multiplier, -1 to 1
sign2 = getval("sign2"); // second gradient multiplier, -1 to 1
/* Initialize paramaters **********************************/
init_mri();
/* Gradient calculations **********************************/
init_generic(&spoil_grad,"gtest",gspoil,tspoil);
calc_generic(&spoil_grad,WRITE,"","");
seqtime = 2*(tspoil + d2) + at;
tr_delay = tr - seqtime;
if (tr_delay < 0.0)
abort_message("gradtest: TR too short, minimum TR = %6.1f msec",1000*seqtime);
/* PULSE SEQUENCE *************************************/
rotate(); // Initialize default orientation
sp1on(); delay(4e-6); sp1off(); // TTL scope trigger
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,sign1*gspoil,0,0,WAIT);
delay(d2);
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,sign2*gspoil,0,0,WAIT);
delay(d2);
delay(tr_delay);
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
MPSEQ dec = getblew("blewH",0,0.0,0.0,0,1);
strncpy(dec.ch,"dec",3);
putCmd("chHblew='dec'\n");
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHX") + getval("rd") + getval("ad") + at;
d.dutyoff = d1 + 4.0e-6;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,4,table1);
settable(phXhx,4,table2);
settable(phHhx,4,table3);
settable(phRec,4,table4);
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
// Begin Acquisition
_mpseqon(dec, phHhx);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_mpseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Define Variables and Objects and Get Parameter Values
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwX90");
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phX90,4,table1);
settable(phRec,4,table2);
setreceiver(phRec);
// Begin Sequence
txphase(phX90); decphase(zero);
obspwrf(getval("aX90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// X Direct Polarization
rgpulse(getval("pwX90"),phX90,0.0,0.0);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence()
{
double sign,currentlimit,RMScurrentlimit,dutycycle;
int calcpower;
/* Initialize paramaters **********************************/
init_mri();
calcpower=(int)getval("calcpower");
dutycycle=getval("dutycycle");
currentlimit=getval("currentlimit");
RMScurrentlimit=getval("RMScurrentlimit");
if (gspoil>0.0) sign = 1.0;
else sign = -1.0;
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
if (calcpower) calc_rf(&p1_rf,"tpwr1","tpwr1f");
if (tspoil>0.0) {
gspoil = sqrt(dutycycle/100.0)*gmax*RMScurrentlimit/currentlimit;
init_generic(&spoil_grad,"spoil",gspoil,tspoil);
spoil_grad.rollOut=FALSE;
calc_generic(&spoil_grad,WRITE,"gspoil","tspoil");
}
xgate(ticks);
rotate();
status(A);
mod4(ct,oph);
delay(d1);
/* TTL scope trigger **********************************/
sp1on(); delay(4e-6); sp1off();
if (calcpower) {
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
}
else obspower(tpwr1);
delay(4e-6);
if (tspoil>0.0) {
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,0,0,spoil_grad.amp*sign,WAIT);
delay(d2);
}
shapedpulse(p1pat,p1,ct,rof1,rof2);
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
initval(getval("periods"),v2);
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Set Phase Tables
settable(phX90,4,table1);
settable(phRec,4,table2);
setreceiver(phRec);
// Begin Sequence
txphase(phX90); decphase(zero);
obspwrf(getval("aX90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
xgate(1.0);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// Apply a Rotorsync Delay
rgpulse(getval("pwX90"),phX90,0.0,0.0);
rotorsync(v2);
rgpulse(getval("pwX90"),phX90,0.0,0.0);
xgate(getval("xperiods"));
rgpulse(getval("pwX90"),phX90,0.0,0.0);
delay(10.0e-6);
// X Direct Polarization
rgpulse(getval("pwX90"),phX90,0.0,0.0);
// Begin Acquisition
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence(){
//Define Variables and Get Parameter Values
double pwTune = getval("pwTune");
pwTune = pwTune*6.0;
at = pwTune*2.0;
char atval[MAXSTR];
sprintf(atval,"at = %f\n", at);
putCmd(atval);
int chTune = (int) getval("chTune");
if ((chTune < 1) || (chTune > 4)) {
abort_message("chTune(%d) must be between 1 and 4\n", chTune);
}
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Set Phase Tables
settable(phTune,4,table1);
settable(phRec,4,table2);
setreceiver(t2);
//Begin Sequence
obspwrf(getval("aTune"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2e-6); sp1off(); delay(2.0e-6);
//Begin Phase Detected Pulse
set4Tune(chTune,getval("gain"));
delay(1.0e-4);
ShapedXmtNAcquire("phtran",pwTune,phTune,6.0e-6,chTune);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
double pw1Xstmas = getval("pw1Xstmas");
double pw2Xstmas = getval("pw2Xstmas");
double tXzfselinit = getval("tXzfsel");
double tXzfsel = tXzfselinit - 3.0e-6;
if (tXzfsel < 0.0) tXzfsel = 0.0;
double d2init = getval("d2");
double d2 = d2init - pw1Xstmas/2.0 - pw2Xstmas/2.0;
if (d2 < 0.0) d2 = 0.0;
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pw1Xstmas") + getval("pw2Xstmas") + getval("pwXzfsel");
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = d2_ + tXzfsel + getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = d2_ + tXzfsel + getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1Xstmas,4,table1);
settable(ph2Xstmas,4,table2);
settable(phXzfsel,8,table3);
settable(phRec,8,table4);
if (phase1 == 2) {
tsadd(ph1Xstmas,1,4);
}
setreceiver(phRec);
// Begin Sequence
txphase(ph1Xstmas); decphase(zero);
obspower(getval("tpwr"));
obspwrf(getval("aXstmas"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H Decoupler on Before STMAS
_dseqon(dec);
// Two-Pulse STMAS
rgpulse(getval("pw1Xstmas"),ph1Xstmas,0.0,0.0);
txphase(ph2Xstmas);
delay(d2);
rgpulse(getval("pw2Xstmas"),ph2Xstmas,0.0,0.0);
// Z-filter Pulse
txphase(phXzfsel);
obsblank();
obspower(getval("dbXzfsel"));
obspwrf(getval("aXzfsel"));
delay(3.0e-6);
obsunblank();
delay(tXzfsel);
rgpulse(getval("pwXzfsel"),phXzfsel,0.0,0.0);
// Begin Acquisition
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
/* Internal variable declarations *************************/
int shapelist90,shapelist180,shapelistIR;
double nseg;
double seqtime,tau1,tau2,tau3,
te1_delay,te2_delay,te3_delay,
iti_delay, ti_delay,
tr_delay;
double kzero;
double freq90[MAXNSLICE], freq180[MAXNSLICE], freqIR[MAXNSLICE];
/* Real-time variables used in this sequence **************/
int vpe_ctr = v2; // PE loop counter
int vpe_mult = v3; // PE multiplier, ranges from -PE/2 to PE/2
int vms_slices = v4; // Number of slices
int vms_ctr = v5; // Slice loop counter
int vseg = v6; // Number of ETL segments
int vseg_ctr = v7; // Segment counter
int vetl = v8; // Echo train length
int vetl_ctr = v9; // Echo train loop counter
int vssc = v10; // Compressed steady-states
int vtrimage = v11; // Counts down from nt, trimage delay when 0
int vacquire = v12; // Argument for setacqvar, to skip steady state acquires
int vphase180 = v13; // phase of 180 degree refocusing pulse
/* Initialize paramaters **********************************/
init_mri();
/* Load external PE table ********************************/
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
} else {
abort_message("petable undefined");
}
seqtime = 0.0;
espmin = 0.0;
kzero = getval("kzero");
/* RF Power & Bandwidth Calculations **********************/
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2);
calc_rf(&p1_rf,"tpwr1","tpwr1f");
calc_rf(&p2_rf,"tpwr2","tpwr2f");
/* Initialize gradient structures *************************/
init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro);
init_readout_refocus(&ror_grad,"ror");
init_phase(&pe_grad,"pe",lpe,nv);
init_slice(&ss_grad,"ss",thk); /* NOTE assume same band widths for p1 and p2 */
init_slice_butterfly(&ss2_grad,"ss2",thk,gcrush,tcrush);
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,WRITE,"gpe","tpe");
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice(&ss2_grad,&p1_rf,WRITE,"");
calc_slice_refocus(&ssr_grad,&ss_grad,NOWRITE,"gssr");
/* Equalize refocus and PE gradient durations *************/
calc_sim_gradient(&ror_grad,&null_grad,&ssr_grad,0.0,WRITE);
/* Create optional prepulse events ************************/
if (sat[0] == 'y') create_satbands();
if (fsat[0] == 'y') create_fatsat();
if (mt[0] == 'y') create_mtc();
if (ir[0] == 'y') {
init_rf(&ir_rf,pipat,pi,flipir,rof1,rof2);
calc_rf(&ir_rf,"tpwri","tpwrif");
init_slice_butterfly(&ssi_grad,"ssi",thk,gcrushir,tcrushir);
calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi");
}
/* Set up frequency offset pulse shape list ********/
offsetlist(pss,ss_grad.ssamp, 0,freq90, ns,seqcon[1]);
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
offsetlist(pss,ssi_grad.ssamp,0,freqIR, ns,seqcon[1]);
shapelist90 = shapelist(p1pat,ss_grad.rfDuration, freq90, ns,0,seqcon[1]);
shapelist180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]);
shapelistIR = shapelist(pipat,ssi_grad.rfDuration,freqIR, ns,0,seqcon[1]);
/* same slice selection gradient and RF pattern used */
if (ss_grad.rfFraction != 0.5)
abort_message("ERROR %s: RF pulse must be symmetric (RF fraction = %.2f)",
seqfil,ss_grad.rfFraction);
if (ro_grad.echoFraction != 1)
abort_message("ERROR %s: Echo Fraction must be 1",seqfil);
/* Find sum of all events in each half-echo period ********/
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + ss2_grad.rfCenterFront;
tau2 = ss2_grad.rfCenterBack + pe_grad.duration + ro_grad.timeToEcho;
tau3 = ro_grad.timeFromEcho + pe_grad.duration + ss2_grad.rfCenterFront;
espmin = 2*MAX(MAX(tau1,tau2),tau3); // Minimum echo spacing
if (minesp[0] == 'y') {
esp = espmin + 8e-6; // ensure at least 4us delays in both TE periods
putvalue("esp",esp);
}
else if (((espmin+8e-6)-esp) > 12.5e-9) {
abort_message("ERROR %s: Echo spacing too small, minimum is %.2fms\n",seqfil,(espmin+8e-6)*1000);
}
te1_delay = esp/2.0 - tau1; // Intra-esp delays
te2_delay = esp/2.0 - tau2;
te3_delay = esp/2.0 - tau3;
te = kzero*esp; // Return effective TE
putvalue("te",te);
/* Minimum TR **************************************/
/* seqtime is total time per slice */
seqtime = 2*4e-6 + ss_grad.rfCenterFront + etl*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;
if (ir[0] == 'y') {
/* Inter-IR delay */
if (ns > 1)
iti_delay = seqtime - ssi_grad.duration;
/* it is probably safe to assume that seqtime is always > the pulse widths */
else
iti_delay = 0;
/* Inversion Recovery */
timin = ssi_grad.rfCenterBack + ss_grad.rfCenterFront;
timin += 8e-6; // from sp1on/off and after 90 pulse power setting
timin += seqtime*(ns-1) + iti_delay;
if (ti < timin + 4e-6) // ensure at least a 4us delay
abort_message("%s: ti too short, minimum is %.2fms",seqfil,timin*1000);
/* Delay after the last IR pulse */
ti_delay = ti - timin;
/* force all slices to be acquired back-to-back, with a single TR delay at end */
trtype = 1;
}
else {
iti_delay = ti_delay = 0;
}
trmin = ns*(seqtime + 4e-6);
if (ir[0] == 'y') {
trmin += (4e-6 + ssi_grad.rfCenterFront + ti);
}
if (mintr[0] == 'y'){
tr = trmin;
putvalue("tr",tr);
}
if ((trmin-tr) > 12.5e-9) {
abort_message("TR too short. Minimum TR = %.2fms\n",trmin*1000);
}
tr_delay = (tr - trmin)/ns;
/* Set number of segments for profile or full image **********/
nseg = prep_profile(profile[0],nv/etl,&pe_grad,&per_grad);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* Calculate total acquisition time */
g_setExpTime(tr*(nt*nseg*getval("arraydim") + ssc) + trimage*getval("arraydim"));
/* 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);
/* PULSE SEQUENCE *************************************/
initval(fabs(ssc),vssc); // Compressed steady-state counter
assign(one,vacquire); // real-time acquire flag
/* 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);
loop(vseg,vseg_ctr);
/* TTL scope trigger **********************************/
sp1on(); delay(4e-6); sp1off();
/* 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);
setacqvar(vacquire); // Turn on acquire when vacquire is zero
if (ticks) {
xgate(ticks);
grad_advance(gpropdelay);
delay(4e-6);
}
if(ir[0] == 'y') { /* IR for all slices prior to data acquisition */
obspower(ir_rf.powerCoarse);
obspwrf(ir_rf.powerFine);
delay(4e-6);
msloop(seqcon[1],ns,vms_slices,vms_ctr);
obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0,0,ssi_grad.amp,NOWAIT);
delay(ssi_grad.rfDelayFront);
shapedpulselist(shapelistIR,ssi_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ssi_grad.rfDelayBack);
delay(iti_delay);
endmsloop(seqcon[1],vms_ctr);
delay(ti_delay);
}
msloop(seqcon[1],ns,vms_slices,vms_ctr);
/* 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,ror_grad.amp,0.0,-ssr_grad.amp,WAIT);
/* First half-TE delay ********************************/
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(te1_delay);
peloop(seqcon[2],etl,vetl,vetl_ctr);
mult(vseg_ctr,vetl,vpe_ctr);
add(vpe_ctr,vetl_ctr,vpe_ctr);
getelem(t1,vpe_ctr,vpe_mult);
/* 180 degree pulse *******************************/
/* Note, ss2_grad.amp is max gradient for butterfly shape; flat top = _.ssamp */
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);
/* Phase-encode gradient ******************************/
pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,-pe_grad.increment,vpe_mult,WAIT);
/* Second half-TE period ******************************/
delay(te2_delay);
/* Readout gradient ************************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront);
/* Acquire data ****************************************/
startacq(alfa);
acquire(np,1.0/sw);
endacq();
delay(ro_grad.atDelayBack);
/* Rewinding phase-encode gradient ********************/
/* Phase encode, refocus, and dephase gradient ******************/
pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,pe_grad.increment,vpe_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);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
}
pulsesequence()
{
/* Internal variable declarations *********************/
char txphase[MAXSTR];
char rxphase[MAXSTR];
char blankmode[MAXSTR]={0};
double postDelay;
double rfDuration;
double acqt;
int i,ret=-1;
static int phs1[4] = {0,2,1,3}; /* from T1meas.c */
/*************************************************/
/* Initialize paramter **************************/
i = 0;
postDelay = 0.5;
acqt = 0.0;
getstr("rxphase",rxphase);
getstr("txphase",txphase);
ret = P_getstring(GLOBAL,"blankmode",blankmode,1,MAXSTR);
//getparm("blankmode","string",GLOBAL,blankmode,MAXSTR);
postDelay = tr - at;
//printf("blankmode=%s\n",blankmode);
/*************************************************/
/* check phase setting ***************************/
if ( (txphase[0] =='n') && (rxphase[0] =='n') )
{
abort_message("ERROR - Select at least one phase [Tx or Rx]\n");
}
/**************************************************/
/* check pulse width *****************************/
rfDuration = shapelistpw(p1pat, p1); /* assign exitation pulse duration */
acqt = rfDuration + rof1 - alfa;
if (FP_GT(acqt, at))
{
abort_message("Pulse duration too long. max [%.3f] ms\n",(at-rof1+alfa)*1000.0);
}
if(ret==0 && blankmode[0]=='u')
obsunblank();
delay(postDelay);
settable(t1,4,phs1); /*from T1meas.c */
getelem(t1,ct,v11); /*from T1meas.c */
setreceiver(t1);
/*==============================================*/
/* START LOOPBACK PULSE SEQUENCE */
/*==============================================*/
status(A);
obsoffset(resto);
/* TTL trigger to scope sequence ****************************/
sp1on();
/* Relaxation delay ***********************************/
xgate(ticks);
/* RF pulse *******************************************/
obspower(tpwr);
obspwrf(tpwrf);
ShapedXmtNAcquire(p1pat, rfDuration, v11, rof1, OBSch);
endacq();
sp1off();
if(ret==0 && blankmode[0]=='u')
obsunblank();
}
void pulsesequence() {
//
// Set the Maximum Dynamic Table Number
//
settablenumber(10);
setvvarnumber(30);
//Define Variables and Objects and Get Parameter Values
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
WMPA cpmg = getcpmg("cpmgX");
strncpy(cpmg.ch,"obs",3);
putCmd("chXcpmg='obs'\n");
double aXecho = getval("aXecho"); // define the echoX group in the sequence
double t1Xechoinit = getval("t1Xecho");
double pwXecho = getval("pwXecho");
double t2Xechoinit = getval("t2Xecho");
double t1Xecho = t1Xechoinit - pwXecho/2.0 - getval("pwX90")/2.0;
if (t1Xecho < 0.0) t1Xecho = 0.0;
double t2Xecho = t2Xechoinit - pwXecho/2.0 - cpmg.r1 - cpmg.t2 - getval("ad");
if (t2Xecho < 0.0) t2Xecho = 0.0;
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHX") + pwXecho + (cpmg.cycles - 1)*cpmg.pw;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = t1Xecho + t2Xecho + getval("rd") + getval("ad") +
at - (cpmg.cycles - 1)*cpmg.pw;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = t1Xecho + t2Xecho + getval("rd") + getval("ad") +
at - (cpmg.cycles - 1)*cpmg.pw;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,64,table1);
settable(phXhx,64,table2);
settable(phHhx,64,table3);
settable(phXecho,64,table4);
settable(phXcpmg,64,table5);
settable(phRec,64,table6);
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
// H Decoupling On
decphase(zero);
_dseqon(dec);
// X Hahn Echo
txphase(phXecho);
obspwrf(aXecho);
delay(t1Xecho);
rgpulse(pwXecho,phXecho,0.0,0.0);
delay(t2Xecho);
// Apply CPMG Cycles
obsblank(); _blank34();
delay(cpmg.r1);
startacq(getval("ad"));
_cpmg(cpmg,phXcpmg);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pw1Hhytrap") + getval("pw2Hhytrap") + getval("tHX");
d.dutyoff = d1 + 4.0e-6 + getval("t1HYtrap") + getval("t2HYtrap");
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1Hhytrap,4,table1);
settable(phYhytrap,4,table2);
settable(ph2Hhytrap,4,table3);
settable(phXhx,4,table4);
settable(phHhx,4,table5);
settable(phRec,4,table6);
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(ph1Hhytrap); dec2phase(phYhytrap);
obspwrf(getval("aXhx")); decpwrf(getval("aHhytrap")); dec2pwrf(getval("aYhytrap"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// TRAPDOR on H with Y Modulation
decrgpulse(getval("pw1Hhytrap"),ph1Hhytrap,0.0,0.0);
decphase(ph2Hhytrap);
decunblank();
dec2on();
delay(getval("t1HYtrap"));
dec2off();
decrgpulse(getval("pw2Hhytrap"),ph2Hhytrap,0.0,0.0);
decphase(phHhx);
decunblank();
decphase(phHhx);
decpwrf(getval("aHhx"));
delay(getval("t2HYtrap"));
// H to X Cross Polarization
_cp_(hx,phHhx,phXhx);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Set the Maximum Dynamic Table Number
settablenumber(10);
setvvarnumber(30);
// Define Variables and Objects and Get Parameter Values
WMPA xx = getxx("xxX");
strncpy(xx.ch,"obs",3);
putCmd("chXxx='obs'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwXprep") + 2.0*xx.cycles*xx.pw;
d.dutyoff = d1 + 4.0e-6 + 5.0e-6 + xx.r1 + xx.r2 +
at - 2.0*xx.cycles*xx.pw;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phXprep,4,table1);
settable(phXxx,4,table2);
settable(phRec,4,table3);
setreceiver(phRec);
// Set the Small-Angle Prep Phase
double obsstep = 360.0/(PSD*8192);
obsstepsize(obsstep);
int phfXprep = initphase(getval("phXprep"), obsstep);
int phXzero = initphase(0.0, obsstep);
// Begin Sequence
xmtrphase(phfXprep); txphase(phXprep);
obspwrf(getval("aXprep"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// Preparation Pulse with Initial Point
startacq(5.0e-6);
rcvroff();
delay(xx.r1);
rgpulse(getval("pwXprep"), phXprep, 0.0, 0.0);
xmtrphase(phXzero);
// Apply Semi-windowless WHH4 Cycles
decblank(); _blank34();
_xx(xx, phXxx);
endacq();
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Define Variables and Objects and Get Parameter Values
double aXhxpto2 = getval("aXhxpto2");
double pw1Xhxpto2 = getval("pw1Xhxpto2");
double pw2Xhxpto2 = getval("pw2Xhxpto2");
double t1HXpto2init = getval("t1HXpto2");
double tau1 = t1HXpto2init - pw1Xhxpto2/2.0;
double t2HXpto2init = getval("t2HXpto2");
double tau2 = t2HXpto2init - pw1Xhxpto2/2.0 - pw2Xhxpto2/2.0;
double t3HXpto2init = getval("t3HXpto2");
double tau3 = t3HXpto2init - pw2Xhxpto2/2.0;
MPSEQ r18 = getr1825("r18H",0,0.0,0.0,0,1);
MPSEQ r18ref = getr1825("r18H",r18.iSuper,r18.phAccum,r18.phInt,1,1);
strncpy(r18.ch,"dec",3);
strncpy(r18ref.ch,"dec",3);
putCmd("chHr18='dec'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = tau1 + tau2 + pw1Xhxpto2 + tau3 + pw2Xhxpto2;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1Hhxpto2,4,table1);
settable(ph2Hhxpto2,4,table2);
settable(ph1Xhxpto2,4,table3);
settable(ph2Xhxpto2,4,table4);
settable(phHdec,4,table5);
settable(phRec,4,table6);
setreceiver(phRec);
// Begin Sequence
txphase(ph1Xhxpto2); decphase(ph1Hhxpto2);
obspwrf(aXhxpto2); decpwrf(r18.a);
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization with PRESTO1
_mpseqon(r18,ph1Hhxpto2);
delay(tau1);
rgpulse(pw1Xhxpto2/2.0,ph1Xhxpto2,0.0,0.0);
_mpseqoff(r18);
_mpseqon(r18ref,ph2Hhxpto2);
rgpulse(pw1Xhxpto2/2.0,ph1Xhxpto2,0.0,0.0);
delay(tau2);
_mpseqoff(r18ref);
decphase(zero);
_dseqon(dec);
rgpulse(pw2Xhxpto2,ph2Xhxpto2,0.0,0.0);
delay(tau3);
decphase(zero);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
PBOXPULSE shp1 = getpboxpulse("sft1A",0,1);
PBOXPULSE shp2 = getpboxpulse("sft2A",0,1);
PBOXPULSE shp3 = getpboxpulse("sft3A",0,1);
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwX90") + shp1.pw + shp2.pw + shp3.pw;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phX90,4,table1);
settable(phAsft1,4,table2);
settable(phAsft2,4,table3);
settable(phAsft3,4,table4);
settable(phRec,4,table5);
setreceiver(phRec);
// Begin Sequence
txphase(phX90); decphase(zero);
obspwrf(getval("aX90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// X Direct Polarization
rgpulse(getval("pwX90"),phX90,0.0,0.0);
delay(20.0e-6);
// X Shaped Pulse
_pboxpulse(shp1, phAsft1);
delay(20.0e-6);
// X Simultaneous Shaped Pulse
_pboxsimpulse(shp1,shp2,phAsft1,phAsft2);
delay(20.0e-6);
// X 3-channel Simultaneous Shaped Pulse
delay(20.0e-6);
_pboxsim3pulse(shp1,shp2,shp3,phAsft1,phAsft2,phAsft3);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Set the Maximum Dynamic Table Number
settablenumber(10);
setvvarnumber(30);
// Define Variables and Objects and Get Parameter Values
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
WMPA toss = gettoss5("tossX");
strncpy(toss.ch,"obs",3);
putCmd("chXtoss='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHX") + 5.0*toss.pw;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = toss.rtau - 5.0*toss.pw + getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = toss.rtau - 5.0*toss.pw + getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,22,table1);
settable(phfXhx,11,table2);
settable(phXhx,44,table3);
settable(phHhx,4,table4);
settable(phHdec,4,table5);
settable(phXtoss,44,table6);
settable(phRec,44,table7);
setreceiver(phRec);
obsstepsize(360.0/(PSD*8192));
// Begin Sequence
xmtrphase(phfXhx); txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization - Shifted by -6COG11
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
decphase(phHdec);
// TOSS5 Sideband Suppression with included
// (-6,-5,-6,-5,-6)COG11 Cycle
_dseqon(dec);
_toss5(toss, phXtoss);
// Begin Acquisition with Quadrature Phase
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence()
{
/* Internal variable declarations *************************/
double freqEx[MAXNSLICE];
double maxgradtime,spoilMoment,perTime,tau1,te_delay,tr_delay;
double te2=0.0,te3=0.0,te2min,te3min,tau2,tau3,te2_delay,te3_delay=0;
char minte2[MAXSTR],minte3[MAXSTR],spoilflag[MAXSTR];
int sepSliceRephase,sepReadRephase=0,readrev,table,shapeEx;
int i;
/* Real-time variables used in this sequence **************/
int vpe_steps = v1; // Number of PE steps
int vpe_ctr = v2; // PE loop counter
int vms_slices = v3; // Number of slices
int vms_ctr = v4; // Slice loop counter
int vpe_offset = v5; // PE/2 for non-table offset
int vpe_mult = v6; // PE multiplier, ranges from -PE/2 to PE/2
int vper_mult = v7; // PE rewinder multiplier; turn off rewinder when 0
int vssc = v8; // Compressed steady-states
int vacquire = v9; // Argument for setacqvar, to skip steady state acquires
int vrfspoil_ctr = v10; // RF spoil counter
int vrfspoil = v11; // RF spoil multiplier
int vtrimage = v12; // Counts down from nt, trimage delay when 0
int vne = v13; // Number of echoes
int vne_ctr = v14; // Echo loop counter
int vneindex = v15; // Echo index, odd or even
int vnelast = v16; // Check for last echo
int vtrigblock = v17; // Number of slices per trigger block
/* Initialize paramaters **********************************/
init_mri();
getstr("spoilflag",spoilflag);
te2=getval("te2");
te3=getval("te3");
getstr("minte2",minte2);
getstr("minte3",minte3);
readrev=(int)getval("readrev");
/* Check for external PE table ***************************/
table = 0;
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
table = 1;
}
/* Set Rcvr/Xmtr phase increments for RF Spoiling ********/
/* Ref: Zur, Y., Magn. Res. Med., 21, 251, (1991) *******/
if (rfspoil[0] == 'y') {
rcvrstepsize(rfphase);
obsstepsize(rfphase);
}
/* Initialize gradient structures *************************/
shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2 ); // excitation pulse
init_slice(&ss_grad,"ss",thk); // slice select gradient
init_slice_refocus(&ssr_grad,"ssr"); // slice refocus gradient
init_readout(&ro_grad,"ro",lro,np,sw); // readout gradient
ro_grad.pad1=alfa; ro_grad.pad2=alfa;
init_readout_refocus(&ror_grad,"ror"); // dephase gradient
init_phase(&pe_grad,"pe",lpe,nv); // phase encode gradient
init_dephase(&spoil_grad,"spoil"); // optimized spoiler
init_dephase(&ref_grad,"ref"); // readout rephase
/* RF Calculations ****************************************/
calc_rf(&p1_rf,"tpwr1","tpwr1f");
/* Gradient calculations **********************************/
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice_refocus(&ssr_grad, &ss_grad,WRITE,"gssr");
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_dephase(&ref_grad,WRITE,ro_grad.m0,"","");
spoilMoment = ro_grad.acqTime*ro_grad.roamp; // Optimal spoiling is at*gro for 2pi per pixel
spoilMoment -= ro_grad.m0def; // Subtract partial spoiling from back half of readout
calc_dephase(&spoil_grad,WRITE,spoilMoment,"gspoil","tspoil");
/* Is TE long enough for separate slice refocus? ******/
maxgradtime = MAX(ror_grad.duration,pe_grad.duration);
if (spoilflag[0] == 'y')
maxgradtime = MAX(maxgradtime,spoil_grad.duration);
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + maxgradtime + ro_grad.timeToEcho + GRADIENT_RES;
/* Equalize refocus and PE gradient durations *********/
if ((te >= tau1) && (minte[0] != 'y')) {
sepSliceRephase = 1; // Set flag for separate slice rephase
calc_sim_gradient(&ror_grad,&pe_grad,&spoil_grad,tpemin,WRITE);
} else {
sepSliceRephase = 0;
calc_sim_gradient(&ror_grad,&pe_grad,&ssr_grad,tpemin,WRITE);
calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,NOWRITE);
}
perTime = 0.0;
if ((perewind[0] == 'y') || (spoilflag[0] == 'y'))
perTime = spoil_grad.duration;
if (spoilflag[0] == 'n')
spoil_grad.amp = 0.0;
/* Create optional prepulse events ************************/
if (sat[0] == 'y') create_satbands();
if (fsat[0] == 'y') create_fatsat();
if (mt[0] == 'y') create_mtc();
if (ir[0] == 'y') create_inversion_recovery();
/* Set up frequency offset pulse shape list ********/
offsetlist(pss,ss_grad.ssamp,0,freqEx,ns,seqcon[1]);
shapeEx = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freqEx,ns,ss_grad.rfFraction,seqcon[1]);
/* Check that all Gradient calculations are ok ************/
sgl_error_check(sglerror);
/* Min TE ******************************************/
tau1 = ss_grad.rfCenterBack + pe_grad.duration + ro_grad.timeToEcho;
tau1 += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event
temin = tau1 + GRADIENT_RES; /* ensure that te_delay is at least GRADIENT_RES */
te = granularity(te,GRADIENT_RES);
if (minte[0] == 'y') {
te = temin;
putvalue("te",te);
}
if (FP_LT(te,temin)) {
abort_message("TE too short. Minimum TE= %.3fms\n",temin*1000);
}
te_delay = te - tau1;
/* Min TE2 *****************************************/
tau2 = (readrev) ? 2*ro_grad.timeFromEcho : ro_grad.duration+ref_grad.duration;
te2min = tau2 + GRADIENT_RES;
te2 = granularity(te2,GRADIENT_RES);
if (minte2[0] == 'y') {
te2 = te2min;
putvalue("te2",te2);
}
if (FP_LT(te2,te2min)) {
abort_message("TE2 too short. Minimum TE2= %.3fms\n",te2min*1000);
}
if (readrev) te2_delay = te2 - tau2;
else {
tau2 = ro_grad.duration + 3*ror_grad.duration;
if (te2 >= tau2) {
sepReadRephase = 1; // Set flag for separate read rephase
te2_delay = te2 - ro_grad.duration - 2*ror_grad.duration;
} else {
sepReadRephase = 0;
if (te2 > te2min+GRADIENT_RES) {
ref_grad.duration = granularity(te2-ro_grad.duration-2*GRADIENT_RES,GRADIENT_RES);
ref_grad.calcFlag = AMPLITUDE_FROM_MOMENT_DURATION;
calc_dephase(&ref_grad,WRITE,ro_grad.m0,"","");
}
te2_delay = te2 - ro_grad.duration - ref_grad.duration;
}
}
/* Min TE3 *****************************************/
if (readrev) {
tau3 = 2*ro_grad.timeToEcho;
te3min = tau3 + GRADIENT_RES;
te3 = granularity(te3,GRADIENT_RES);
if (minte3[0] == 'y') {
te3 = te3min;
putvalue("te3",te3);
}
if (FP_LT(te3,te3min)) {
abort_message("TE3 too short. Minimum TE3= %.3fms\n",te3min*1000);
}
te3_delay = te3 - tau3;
}
/* Now set the TE array accordingly */
putCmd("TE = 0"); /* Re-initialize TE */
putCmd("TE[1] = %f",te*1000);
if (readrev) {
for (i=1;i<ne;i++) {
if (i%2 == 0) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te3*1000);
else putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000);
}
} else {
for (i=1;i<ne;i++) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000);
}
/* Check nsblock, the number of slices blocked together
(used for triggering and/or inversion recovery) */
check_nsblock();
/* Min TR ******************************************/
trmin = ss_grad.duration + te_delay + pe_grad.duration + ne*ro_grad.duration + perTime + 2*GRADIENT_RES;
trmin += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event
if (readrev) trmin += (ne/2)*te2_delay + ((ne-1)/2)*te3_delay;
else trmin += (sepReadRephase) ? (ne-1)*(te2_delay+2*ror_grad.duration) : (ne-1)*(te2_delay+ref_grad.duration);
/* Increase TR if any options are selected *********/
if (sat[0] == 'y') trmin += satTime;
if (fsat[0] == 'y') trmin += fsatTime;
if (mt[0] == 'y') trmin += mtTime;
if (ticks > 0) trmin += GRADIENT_RES;
/* Adjust for all slices ***************************/
trmin *= ns;
/* Inversion recovery *********************************/
if (ir[0] == 'y') {
/* tauti is the additional time beyond IR component to be included in ti */
/* satTime, fsatTime and mtTime all included as those modules will be after IR */
tauti = satTime + fsatTime + mtTime + GRADIENT_RES + ss_grad.rfCenterFront;
/* calc_irTime checks ti and returns the time of all IR components */
trmin += calc_irTime(tauti,trmin,mintr[0],tr,&trtype);
}
if (mintr[0] == 'y') {
tr = trmin;
putvalue("tr",tr);
}
if (FP_LT(tr,trmin)) {
abort_message("TR too short. Minimum TR = %.3fms\n",trmin*1000);
}
/* Calculate tr delay */
tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES);
/* Set pe_steps for profile or full image **********/
pe_steps = prep_profile(profile[0],nv,&pe_grad,&per_grad);
F_initval(pe_steps/2.0,vpe_offset);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* Adjust experiment time for VnmrJ *********************/
if (ssc<0) {
if (seqcon[2] == 'c') g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*arraydim));
else g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*pe_steps*arraydim));
}
else g_setExpTime(trmean*ntmean*pe_steps*arraydim + tr*ssc);
/* PULSE SEQUENCE ***************************************/
status(A);
rotate();
triggerSelect(trigger); // Select trigger input 1/2/3
obsoffset(resto);
delay(GRADIENT_RES);
initval(fabs(ssc),vssc); // Compressed steady-state counter
if (seqcon[2]=='s') assign(zero,vssc); // Zero for standard peloop
assign(zero,vrfspoil_ctr); // RF spoil phase counter
assign(zero,vrfspoil); // RF spoil multiplier
assign(one,vacquire); // real-time acquire flag
setacqvar(vacquire); // Turn on acquire when vacquire is zero
/* trigger */
if (ticks > 0) F_initval((double)nsblock,vtrigblock);
/* Begin phase-encode loop ****************************/
peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr);
if (trtype) delay(ns*tr_delay); // relaxation delay
/* Compressed steady-states:
1st array & transient, all arrays if ssc is negative */
if ((ix > 1) && (ssc > 0))
assign(zero,vssc);
sub(vpe_ctr,vssc,vpe_ctr); // vpe_ctr counts up from -ssc
assign(zero,vssc);
if (seqcon[2] == 's')
assign(zero,vacquire); // Always acquire for non-compressed loop
else {
ifzero(vpe_ctr);
assign(zero,vacquire); // Start acquiring when vpe_ctr reaches zero
endif(vpe_ctr);
}
/* Set rcvr/xmtr phase for RF spoiling *******************/
if (rfspoil[0] == 'y') {
incr(vrfspoil_ctr); // vrfspoil_ctr = 1 2 3 4 5 6
add(vrfspoil,vrfspoil_ctr,vrfspoil); // vrfspoil = 1 3 6 10 15 21
xmtrphase(vrfspoil);
rcvrphase(vrfspoil);
}
/* Read external kspace table if set ******************/
if (table)
getelem(t1,vpe_ctr,vpe_mult);
else {
ifzero(vacquire);
sub(vpe_ctr,vpe_offset,vpe_mult);
elsenz(vacquire);
sub(zero,vpe_offset,vpe_mult); // Hold PE mult at initial value for steady states
endif(vacquire);
}
/* PE rewinder follows PE table; zero if turned off ***/
if (perewind[0] == 'y') assign(vpe_mult,vper_mult);
else assign(zero,vper_mult);
/* Begin multislice loop ******************************/
msloop(seqcon[1],ns,vms_slices,vms_ctr);
if (!trtype) delay(tr_delay); // Relaxation delay
if (ticks > 0) {
modn(vms_ctr,vtrigblock,vtest);
ifzero(vtest); // if the beginning of an trigger block
xgate(ticks);
grad_advance(gpropdelay);
delay(GRADIENT_RES);
elsenz(vtest);
delay(GRADIENT_RES);
endif(vtest);
}
/* TTL scope trigger **********************************/
sp1on(); delay(GRADIENT_RES); sp1off();
/* Prepulse options ***********************************/
if (ir[0] == 'y') inversion_recovery();
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
/* Slice select RF pulse ******************************/
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(GRADIENT_RES);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shapeEx,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Phase encode, refocus, and dephase gradient ********/
if (sepSliceRephase) { // separate slice refocus gradient
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT);
delay(te_delay); // delay between slab refocus and pe
pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0,
-pe_grad.increment,vpe_mult,WAIT);
} else {
pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,-ssr_grad.amp,
-pe_grad.increment,vpe_mult,WAIT);
delay(te_delay); // delay after refocus/pe
}
F_initval(ne,vne);
loop(vne,vne_ctr);
if (readrev) {
mod2(vne_ctr,vneindex);
ifzero(vneindex);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* Readout gradient ********************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront-alfa);
/* Acquisition ***************************************/
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
sub(vne,vne_ctr,vnelast);
sub(vnelast,one,vnelast);
ifzero(vnelast);
elsenz(vnelast);
delay(te2_delay);
endif(vnelast);
elsenz(vneindex);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,-ro_grad.roamp);
/* Readout gradient ********************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,-ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront-alfa);
/* Acquisition ***************************************/
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
sub(vne,vne_ctr,vnelast);
sub(vnelast,one,vnelast);
ifzero(vnelast);
elsenz(vnelast);
delay(te3_delay);
endif(vnelast);
endif(vneindex);
} else {
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* Readout gradient ********************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront-alfa);
/* Acquisition ***************************************/
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
sub(vne,vne_ctr,vnelast);
sub(vnelast,one,vnelast);
ifzero(vnelast);
elsenz(vnelast);
if (sepReadRephase) {
obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT);
delay(te2_delay);
obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT);
} else {
obl_shapedgradient(ref_grad.name,ref_grad.duration,-ref_grad.amp,0,0,WAIT);
delay(te2_delay);
}
endif(vnelast);
}
endloop(vne_ctr);
/* Rewind / spoiler gradient **************************/
if ((perewind[0] == 'y') || (spoilflag[0] == 'y')) {
pe_shapedgradient(pe_grad.name,pe_grad.duration,spoil_grad.amp,0,0,pe_grad.increment,vper_mult,WAIT);
}
endmsloop(seqcon[1],vms_ctr);
endpeloop(seqcon[2],vpe_ctr);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
double aYxy8 = getval("aYxy8");
double pwYxy8 = getval("pwYxy8");
double nYxy8 = getval("nYxy8");
int cycles = (int) nYxy8/2.0;
nYxy8 = 2.0*cycles;
int counter = (int) (nYxy8 - 1.0);
initval((nYxy8 - 1.0),v8);
double onYxy8 = getval("onYxy8");
double srate = getval("srate");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
DSEQ mix = getdseq("Hmix");
strncpy(mix.t.ch,"dec",3);
putCmd("chHmixtppm='mix'\n");
strncpy(mix.s.ch,"dec",3);
putCmd("chHmixspinal='mix'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwX90") + 4.0*nYxy8*pwYxy8 + getval("pwX180");
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d.c3 = d.c3 + (!strcmp(mix.seq,"tppm"));
d.c3 = d.c3 + ((!strcmp(mix.seq,"tppm")) && (mix.t.a > 0.0));
d.t3 = 2.0*nYxy8*(1.0/srate - 2.0*pwYxy8) + 1.0/srate - getval("pwX180");
d.c4 = d.c4 + (!strcmp(mix.seq,"spinal"));
d.c4 = d.c4 + ((!strcmp(mix.seq,"spinal")) && (mix.s.a > 0.0));
d.t4 = 2.0*nYxy8*(1.0/srate - 2.0*pwYxy8) + 1.0/srate - getval("pwX180");
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phX90,4,table1);
settable(ph1Yxy8,8,table2);
settable(ph2Yxy8,4,table3);
settable(phX180,4,table4);
settable(phRec,4,table5);
if (counter < 0) tsadd(phRec,2,4);
setreceiver(phRec);
// Begin Sequence
txphase(phX90); decphase(zero);
obspwrf(getval("aX90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// X Single Pulse
rgpulse(getval("pwX90"),phX90,0.0,0.0);
// xy8Y Period One
obspwrf(getval("aX180"));
txphase(phX180);
if (counter >= 0) {
_dseqon(mix);
delay(pwYxy8/2.0);
dec2pwrf(aYxy8);
sub(v1,v1,v1);
if (counter >= 1) {
if (counter > 1) loop(v8,v9);
getelem(ph1Yxy8,v1,v4);
incr(v1);
getelem(ph2Yxy8,ct,v2);
add(v4,v2,v2);
dec2phase(v2);
delay(0.5/srate - pwYxy8);
if (onYxy8 == 2)
dec2rgpulse(pwYxy8,v2,0.0,0.0);
else
delay(pwYxy8);
if (counter > 1) endloop(v9);
}
// X Refocussing Pulse
delay(0.5/srate - pwYxy8/2.0 - getval("pwX180")/2.0);
rgpulse(getval("pwX180"),phX180,0.0,0.0);
dec2pwrf(aYxy8);
delay(0.5/srate - pwYxy8/2.0 - getval("pwX180")/2.0);
// xy8Y Period Two
if (counter >= 1) {
if (counter > 1) loop(v8,v9);
if (onYxy8 == 2)
dec2rgpulse(pwYxy8,v2,0.0,0.0);
else
delay(pwYxy8);
getelem(ph1Yxy8,v1,v4);
incr(v1);
getelem(ph2Yxy8,ct,v2);
add(v4,v2,v2);
dec2phase(v2);
delay(0.5/srate - pwYxy8);
if (counter > 1) endloop(v9);
}
delay(pwYxy8/2.0);
_dseqoff(mix);
}
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
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()
{
/* Internal variable declarations *********************/
double freq90[MAXNSLICE],freq180[MAXNSLICE];
double te_delay1,te_delay2,tr_delay,tau1,tau2,thk2fact,te_delay3=0.0,te_delay4=0.0,navTime=0.0;
double crushm0,pem0,gcrushr,gcrushp,gcrushs,pecrush;
double refsign=1,crushsign=1,navsign=1;
int shape90,shape180,table=0,sepRefocus;
char slprofile[MAXSTR];
/* sequence dependent diffusion variables */
double Gro,Gss; // "gdiff" for readout/readout refocus and slice/slice refocus
double dgro,dgss; // "delta" for readout/readout refocus and slice/slice refocus
double Dgro,Dgss; // "DELTA" for readout/readout refocus and slice/slice refocus
double dcrush,dgss2; // "delta" for crusher and gss2 gradients
double Dcrush,Dgss2; // "DELTA" for crusher and gss2 gradients
int i;
/* Real-time variables used in this sequence **********/
int vpe_steps = v1; // Number of PE steps
int vpe_ctr = v2; // PE loop counter
int vms_slices = v3; // Number of slices
int vms_ctr = v4; // Slice loop counter
int vpe_offset = v5; // PE/2 for non-table offset
int vpe_mult = v6; // PE multiplier, ranges from -PE/2 to PE/2
int vph180 = v7; // Phase of 180 pulse
int vph2 = v8; // alternate phase of 180 on odd transients
int vssc = v9; // Compressed steady-states
int vtrimage = v10; // Counts down from nt, trimage delay when 0
int vacquire = v11; // Argument for setacqvar, to skip steady state acquires
int vtrigblock = v12; // Number of slices per trigger block
/* Initialize paramaters *****************************/
init_mri();
thk2fact=getval("thk2fact");
pecrush=getval("pecrush");
sepRefocus=getvalnwarn("sepRefocus");
getstrnwarn("slprofile",slprofile);
/* Check for external PE table ***********************/
init_tablepar("pelist"); // Initialize pelist parameter
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
writetabletopar(t1,"pelist"); // Write t1 table to pelist parameter
table = 1;
}
/* RF Power & Bandwidth Calculations ******************/
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_slice(&ss_grad,"ss",thk);
init_slice(&ss2_grad,"ss2",thk*thk2fact);
init_dephase(&crush_grad,"crush");
init_slice_refocus(&ssr_grad,"ssr");
if (FP_LT(tcrushro,alfa)) tcrushro=alfa;
init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro);
init_readout_refocus(&ror_grad,"ror");
init_phase(&pe_grad,"pe",lpe,nv);
init_generic(&spoil_grad,"spoil",gspoil,tspoil);
/* Gradient calculations ******************************/
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");
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2");
calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr");
calc_generic(&spoil_grad,WRITE,"","");
/* Make sure crushing in PE dimension does not refocus signal from 180 */
crushm0=fabs(gcrush*tcrush);
pem0=0.0; gcrushp=0.0;
if (pecrush) pem0=pe_grad.m0;
calc_dephase(&crush_grad,WRITE,crushm0+pem0,"","");
gcrushr = crush_grad.amp*crushm0/crush_grad.m0;
if (pecrush) gcrushp = crush_grad.amp;
gcrushs = crush_grad.amp*crushm0/crush_grad.m0;
/* Allow phase encode and read dephase to be separated from slice refocus */
if (sepRefocus) {
/* Equalize read dephase and PE gradient durations */
calc_sim_gradient(&ror_grad,&pe_grad,&null_grad,0,WRITE);
crushsign=-1;
} else {
if (slprofile[0] == 'y') {
/* Combined slice refocusing and read dephasing,
reverse gradient sign if ror > ssr integral */
refsign = (ss_grad.m0ref > ro_grad.m0ref) ? 1.0 : -1.0;
ss_grad.m0ref -= ro_grad.m0ref;
calc_slice_refocus(&ssr_grad,&ss_grad,NOWRITE,"gssr");
}
/* Equalize both refocus and PE gradient durations */
calc_sim_gradient(&ror_grad,&pe_grad,&ssr_grad,0,WRITE);
}
/* Create optional prepulse events ********************/
if (fsat[0] == 'y') create_fatsat();
if (sat[0] == 'y') create_satbands();
if (mt[0] == 'y') create_mtc();
if (ir[0] == 'y') create_inversion_recovery();
if (diff[0] == 'y') init_diffusion(&diffusion,&diff_grad,"diff",gdiff,tdelta);
sgl_error_check(sglerror);
/* Min TE *********************************************/
te = granularity(te,2*GRADIENT_RES);
/* tau1, tau2 are the sum of events in each half echo period */
/* tau1, tau2 include a GRADIENT_RES as this is minimum delay time */
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + 2*GRADIENT_RES;
tau2 = ss2_grad.rfCenterBack + crush_grad.duration + ro_grad.timeToEcho + GRADIENT_RES;
if (sepRefocus) tau2 += ror_grad.duration;
temin = 2*MAX(tau1,tau2);
/* Diffusion ******************************************/
if (diff[0] == 'y') {
/* granulate tDELTA */
tDELTA = granularity(tDELTA,GRADIENT_RES);
/* taudiff is the duration of events between diffusion gradients */
taudiff = ss2_grad.duration + 2*crush_grad.duration + GRADIENT_RES;
/* set minimum diffusion structure requirements for gradient echo: taudiff, tDELTA, te and minte[0] */
set_diffusion(&diffusion,taudiff,tDELTA,te,minte[0]);
/* set additional diffusion structure requirements for spin echo: tau1 and tau2 */
set_diffusion_se(&diffusion,tau1,tau2);
/* calculate the diffusion structure delays.
address &temin is required in order to update temin accordingly */
calc_diffTime(&diffusion,&temin);
}
/* TE delays ******************************************/
if (minte[0] == 'y') {
te = temin;
putvalue("te",te);
}
if (FP_LT(te,temin)) {
abort_message("TE too short, minimum TE = %.3f ms\n",temin*1000);
}
te_delay1 = te/2 - tau1 + GRADIENT_RES;
te_delay2 = te/2 - tau2 + GRADIENT_RES;
if (navigator[0] == 'y') {
/* tau1, tau2 are the sum of events in each half echo period */
tau1 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront;
tau2 = ss2_grad.rfCenterBack + crush_grad.duration + ro_grad.timeToEcho;
if (FP_GT(tau1,tau2)) {
te_delay3 = GRADIENT_RES;
te_delay4 = tau1-tau2+GRADIENT_RES;
} else {
te_delay3 = tau2-tau1+GRADIENT_RES;
te_delay4 = GRADIENT_RES;
}
navTime = te_delay3 + ss2_grad.duration + 2*crush_grad.duration + ro_grad.duration + te_delay4 + 2*GRADIENT_RES;
}
/* Check nsblock, the number of slices blocked together
(used for triggering and/or inversion recovery) */
check_nsblock();
/* Min TR *********************************************/
trmin = ss_grad.rfCenterFront + te + ro_grad.timeFromEcho + pe_grad.duration + 2*GRADIENT_RES;
/* Increase TR if any options are selected ************/
if (spoilflag[0] == 'y') trmin += spoil_grad.duration;
if (navigator[0] == 'y') trmin += navTime;
if (sat[0] == 'y') trmin += satTime;
if (fsat[0] == 'y') trmin += fsatTime;
if (mt[0] == 'y') trmin += mtTime;
if (ticks > 0) trmin += GRADIENT_RES;
/* Adjust for all slices ******************************/
trmin *= ns;
/* Inversion recovery *********************************/
if (ir[0] == 'y') {
/* tauti is the additional time beyond IR component to be included in ti */
/* satTime, fsatTime and mtTime all included as those modules will be after IR */
tauti = satTime + fsatTime + mtTime + GRADIENT_RES + ss_grad.rfCenterFront;
/* calc_irTime checks ti and returns the time of all IR components */
trmin += calc_irTime(tauti,trmin,mintr[0],tr,&trtype);
}
if (mintr[0] == 'y') {
tr = trmin;
putvalue("tr",tr);
}
if (FP_LT(tr,trmin)) {
abort_message("TR too short, minimum TR = %.3f ms\n",trmin*1000);
}
/* TR delay *******************************************/
tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES);
/* Calculate B values *********************************/
if (ix == 1) {
/* Calculate bvalues according to main diffusion gradients */
calc_bvalues(&diffusion,"dro","dpe","dsl");
/* Add components from additional diffusion encoding imaging gradients peculiar to this sequence */
/* Initialize variables */
dgro = 0.5*(ror_grad.duration+ro_grad.timeToEcho);
Gro = ro_grad.m0ref/dgro; Dgro = dgro;
if (!sepRefocus) Dgro = te-ss_grad.rfCenterBack-ro_grad.timeToEcho;
dgss = 0.5*(ss_grad.rfCenterBack+ssr_grad.duration);
Gss = ss_grad.m0ref/dgss; Dgss = dgss;
dgss2 = ss2_grad.duration/2; Dgss2 = dgss2;
dcrush = crush_grad.duration-crush_grad.tramp; Dcrush = crush_grad.duration+ss2_grad.duration;
for (i = 0; i < diffusion.nbval; i++) {
/* set droval, dpeval and dslval */
set_dvalues(&diffusion,&droval,&dpeval,&dslval,i);
/* Readout */
diffusion.bro[i] += bval(Gro,dgro,Dgro);
diffusion.bro[i] += bval(crushsign*gcrushr,dcrush,Dcrush);
diffusion.bro[i] += bval_nested(gdiff*droval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush);
if (!sepRefocus) {
diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,gdiff*droval,tdelta,tDELTA);
diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,crushsign*gcrushr,dcrush,Dcrush);
}
/* Phase */
if (pecrush) {
diffusion.bpe[i] += bval(gcrushp,dcrush,Dcrush);
diffusion.bpe[i] += bval_nested(gdiff*dpeval,tdelta,tDELTA,gcrushp,dcrush,Dcrush);
}
/* Slice */
diffusion.bsl[i] += bval(Gss,dgss,Dgss);
diffusion.bsl[i] += bval(gcrushs,dcrush,Dcrush);
diffusion.bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,gcrushs,dcrush,Dcrush);
diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
diffusion.bsl[i] += bval_nested(gcrushs,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2);
/* Readout/Phase Cross-terms */
diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush);
diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush);
if (pecrush) diffusion.brp[i] += bval_cross(gdiff*droval,tdelta,tDELTA,gcrushp,dcrush,Dcrush);
if (!sepRefocus) {
diffusion.brp[i] += bval_cross(Gro,dgro,Dgro,gdiff*dpeval,tdelta,tDELTA);
if (pecrush) diffusion.brp[i] += bval_cross(Gro,dgro,Dgro,gcrushp,dcrush,Dcrush);
}
/* Readout/Slice Cross-terms */
diffusion.brs[i] += bval2(crushsign*gcrushr,gcrushs,dcrush,Dcrush);
diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,gcrushs,dcrush,Dcrush);
diffusion.brs[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush);
diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
if (!sepRefocus) {
diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gdiff*dslval,tdelta,tDELTA);
diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gcrushs,dcrush,Dcrush);
diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,ss2_grad.ssamp,dgss2,Dgss2);
}
/* Slice/Phase Cross-terms */
diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,gcrushs,dcrush,Dcrush);
diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
if (pecrush) {
diffusion.bsp[i] += bval2(gcrushs,gcrushp,dcrush,Dcrush);
diffusion.bsp[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,gcrushp,dcrush,Dcrush);
diffusion.bsp[i] += bval_cross(gcrushp,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2);
}
} /* End for-all-directions */
/* Write the values */
write_bvalues(&diffusion,"bval","bvalue","max_bval");
}
/* Generate phase-ramped pulses ***********************/
offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]);
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shape90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freq90,ns,ss_grad.rfFraction,seqcon[1]);
shape180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,ss2_grad.rfFraction,seqcon[1]);
/* Set pe_steps for profile or full image *************/
pe_steps = prep_profile(profile[0],nv,&pe_grad,&null_grad);
F_initval(pe_steps/2.0,vpe_offset);
/* Shift DDR for pro **********************************/
roff = -poffset(pro,ro_grad.roamp);
/* Adjust experiment time for VnmrJ *******************/
if (ssc<0) {
if (seqcon[2] == 'c') g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*arraydim));
else g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*pe_steps*arraydim));
}
else g_setExpTime(trmean*ntmean*pe_steps*arraydim + tr*ssc);
/* Slice profile **************************************/
if (slprofile[0] == 'y' && !sepRefocus) ror_grad.amp = 0;
/* Set phase cycle table ******************************/
if (sepRefocus) settable(t2,1,ph180); // Phase encode is just before readout
else settable(t2,2,ph180);
/* PULSE SEQUENCE *************************************/
status(A); // Set status A
rotate(); // Set gradient rotation according to psi, phi and theta
triggerSelect(trigger); // Select trigger input 1/2/3
obsoffset(resto); // Set spectrometer frequency
delay(GRADIENT_RES); // Delay for frequency setting
initval(fabs(ssc),vssc); // Compressed steady-state counter
if (seqcon[2]=='s') assign(zero,vssc); // Zero for standard peloop
assign(one,vacquire); // real-time acquire flag
setacqvar(vacquire); // Turn on acquire when vacquire is zero
/* trigger */
if (ticks > 0) F_initval((double)nsblock,vtrigblock);
/* Begin phase-encode loop ****************************/
peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr);
if (trtype) delay(ns*tr_delay); // relaxation delay
/* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */
if ((ix > 1) && (ssc > 0))
assign(zero,vssc);
sub(vpe_ctr,vssc,vpe_ctr); // vpe_ctr counts up from -ssc
assign(zero,vssc);
if (seqcon[2] == 's')
assign(zero,vacquire); // Always acquire for non-compressed loop
else {
ifzero(vpe_ctr);
assign(zero,vacquire); // Start acquiring when vpe_ctr reaches zero
endif(vpe_ctr);
}
/* Read external kspace table if set ******************/
if (table)
getelem(t1,vpe_ctr,vpe_mult);
else {
ifzero(vacquire);
sub(vpe_ctr,vpe_offset,vpe_mult);
elsenz(vacquire);
sub(zero,vpe_offset,vpe_mult); // Hold PE mult at initial value for steady states
endif(vacquire);
}
/* Phase cycle ****************************************/
getelem(t2,vpe_ctr,vph180); // For phase encoding with slice rephase
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 (!trtype) delay(tr_delay); // Relaxation delay
if (ticks > 0) {
modn(vms_ctr,vtrigblock,vtest);
ifzero(vtest); // if the beginning of an trigger block
xgate(ticks);
grad_advance(gpropdelay);
delay(GRADIENT_RES);
elsenz(vtest);
delay(GRADIENT_RES);
endif(vtest);
}
sp1on(); delay(GRADIENT_RES); sp1off(); // Scope trigger
/* Prepulse options ***********************************/
if (ir[0] == 'y') inversion_recovery();
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
/* Slice select RF pulse ******************************/
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(GRADIENT_RES);
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);
/* Slice refocus gradient *****************************/
if (sepRefocus)
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT);
else
/* Include phase encode and readout dephase gradient if refocus gradients not separated */
pe_shapedgradient(pe_grad.name,pe_grad.duration,ror_grad.amp,0,-ssr_grad.amp*refsign,pe_grad.increment,vpe_mult,WAIT);
if (diff[0] == 'y') {
delay(diffusion.d1);
diffusion_dephase(&diffusion,dro,dpe,dsl);
delay(diffusion.d2);
}
else
delay(te_delay1);
/* Refocusing RF pulse ********************************/
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(GRADIENT_RES);
obl_shapedgradient(crush_grad.name,crush_grad.duration,crushsign*gcrushr,gcrushp,gcrushs,WAIT);
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);
obl_shapedgradient(crush_grad.name,crush_grad.duration,crushsign*gcrushr,gcrushp,gcrushs,WAIT);
if (diff[0] == 'y') {
delay(diffusion.d3);
diffusion_rephase(&diffusion,dro,dpe,dsl);
delay(diffusion.d4);
}
else
delay(te_delay2);
/* Readout dephase, phase encode & readout gradients **/
roff = -poffset(pro,ro_grad.roamp); // incase inverted navigator is acquired
if (slprofile[0] == 'y') {
/* Readout gradient only if refocus gradients not separated */
if (sepRefocus)
obl_shapedgradient(ror_grad.name,ror_grad.duration,0,0,-ror_grad.amp,WAIT);
obl_shapedgradient(ro_grad.name,ro_grad.duration,0,0,ro_grad.amp,NOWAIT);
} else {
/* Readout gradient only if refocus gradients not separated */
if (sepRefocus)
pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0,-pe_grad.increment,vpe_mult,WAIT);
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);
}
/* Acquisition ****************************************/
delay(ro_grad.atDelayFront-alfa);
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_mult,WAIT);
/* Navigator acquisition ******************************/
if (navigator[0] == 'y') {
delay(te_delay3);
obl_shapedgradient(crush_grad.name,crush_grad.duration,-crushsign*gcrushr,0,-gcrushs,WAIT);
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);
obl_shapedgradient(crush_grad.name,crush_grad.duration,-crushsign*gcrushr,0,-gcrushs,WAIT);
delay(te_delay4);
obl_shapedgradient(ro_grad.name,ro_grad.duration,navsign*ro_grad.amp,0,0,NOWAIT);
delay(ro_grad.atDelayFront-alfa);
startacq(alfa);
acquire(np,1.0/sw);
delay(ro_grad.atDelayBack);
endacq();
}
if (spoilflag[0] == 'y') {
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,navsign*spoil_grad.amp,0,spoil_grad.amp,WAIT);
}
endmsloop(seqcon[1],vms_ctr);
endpeloop(seqcon[2],vpe_ctr);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
/* Duty cycle *****************************************/
calc_grad_duty(tr);
}
pulsesequence()
{
/* Internal variable declarations *************************/
double freqEx[MAXNSLICE], freqIR[MAXNSLICE];
double pe_steps,pespoil_amp;
double perTime, seqtime, tau1, tauIR=0, te_delay, tr_delay, ti_delay=0;
int table, shapeEx, shapeIR=0;
char spoilflag[MAXSTR],per_name[MAXSTR];
/* Real-time variables used in this sequence **************/
int vpe_steps = v1; // Number of PE steps
int vpe_ctr = v2; // PE loop counter
int vms_slices = v3; // Number of slices
int vms_ctr = v4; // Slice loop counter
int vpe_offset = v5; // PE/2 for non-table offset
int vpe_mult = v6; // PE multiplier, ranges from -PE/2 to PE/2
int vper_mult = v7; // PE rewinder multiplier; turn off rewinder when 0
int vssc = v8; // Compressed steady-states
int vacquire = v9; // Argument for setacqvar, to skip steady state acquires
int vrfspoil_ctr = v10; // RF spoil counter
int vrfspoil = v11; // RF spoil multiplier
int vtrimage = v12; // Counts down from nt, trimage delay when 0
/* Initialize paramaters **********************************/
get_parameters();
get_ovsparameters();
getstr("spoilflag",spoilflag);
/* Check for external PE table ***************************/
table = 0;
if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) {
loadtable(petable);
table = 1;
}
/* Set Rcvr/Xmtr phase increments for RF Spoiling ********/
/* Ref: Zur, Y., Magn. Res. Med., 21, 251, (1991) *******/
if (rfspoil[0] == 'y') {
rcvrstepsize(rfphase);
obsstepsize(rfphase);
}
/* Initialize gradient structures *************************/
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2 ); // excitation pulse
init_slice(&ss_grad,"ss",thk); // slice select gradient
init_slice_refocus(&ssr_grad,"ssr"); // slice refocus gradient
init_readout(&ro_grad,"ro",lro,np,sw); // readout gradient
init_readout_refocus(&ror_grad,"ror"); // dephase gradient
init_phase(&pe_grad,"pe",lpe,nv); // phase encode gradient
init_phase(&per_grad,"per",lpe,nv); // phase encode gradient
init_generic(&spoil_grad,"spoil",gspoil,tspoil); // spoiler gradient
/* RF Calculations ****************************************/
calc_rf(&p1_rf,"tpwr1","tpwr1f");
/* Gradient calculations **********************************/
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice_refocus(&ssr_grad, &ss_grad, NOWRITE,"gssr");
calc_readout(&ro_grad, WRITE, "gro","sw","at");
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,tpemin, WRITE);
/* Calculate phase-rewind & spoiler gradients *************/
pespoil_amp = 0.0;
perTime = 0.0;
if ((perewind[0] == 'y') && (spoilflag[0] == 'n')) { // Rewinder, no spoiler
calc_phase(&per_grad,WRITE,"","");
strcpy(per_name,per_grad.name);
perTime = per_grad.duration;
spoil_grad.amp = 0.0;
}
else if ((perewind[0] == 'n') && (spoilflag[0] == 'y')) { // Spoiler, no rewinder
calc_generic(&spoil_grad,WRITE,"","");
strcpy(per_name,spoil_grad.name);
perTime = spoil_grad.duration;
pespoil_amp = spoil_grad.amp; // Apply spoiler on PE axis if no rewinder
}
else if ((perewind[0] == 'y') && (spoilflag[0] == 'y')) { // Rewinder and spoiler
calc_phase(&per_grad,NOWRITE,"","");
calc_generic(&spoil_grad,NOWRITE,"","");
calc_sim_gradient(&per_grad,&spoil_grad,&null_grad,0.0,WRITE);
strcpy(per_name,per_grad.name);
perTime = per_grad.duration;
}
/* Create optional prepulse events ************************/
if (sat[0] == 'y') create_satbands();
if (fsat[0] == 'y') create_fatsat();
if (mt[0] == 'y') create_mtc();
if (ovs[0] == 'y') {
/* Must set up a few voxel specific parameters for create_ovsbands() to function */
vox1_grad.thickness = vox1;
vox2_grad.thickness = vox2;
vox3_grad.thickness = vox3;
vox1_grad.rfBandwidth = vox2_grad.rfBandwidth = vox3_grad.rfBandwidth = p1_rf.bandwidth;
create_ovsbands();
}
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,gcrush,tcrush);
calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi");
tauIR = ss_grad.duration - ss_grad.rfCenterBack; // Duration of ss_grad before RF center
ti_delay = ti - (ssi_grad.rfCenterFront + tauIR);
if (ti_delay < 0) {
abort_message("TI too short, Minimum TI = %.2fms\n",(ti-ti_delay)*1000);
}
irTime = 4e-6 + ti + ssi_grad.duration - ssi_grad.rfCenterBack; // Time to add to TR
}
/* Check that all Gradient calculations are ok ************/
sgl_error_check(sglerror);
/* Min TE ******************************************/
tau1 = ss_grad.rfCenterBack + pe_grad.duration + alfa + ro_grad.timeToEcho;
temin = tau1 + 4e-6; /* ensure that te_delay is at least 4us */
if (minte[0] == 'y') {
te = temin;
putvalue("te",te);
}
if (te < temin) {
abort_message("TE too short. Minimum TE= %.2fms\n",temin*1000+0.005);
}
te_delay = te - tau1;
/* Min TR ******************************************/
seqtime = ss_grad.duration + te_delay + pe_grad.duration
+ ro_grad.duration + perTime + tep + alfa;
/* Increase TR if any options are selected ****************/
if (sat[0] == 'y') seqtime += satTime;
if (fsat[0] == 'y') seqtime += fsatTime;
if (mt[0] == 'y') seqtime += mtTime;
if (ovs[0] == 'y') seqtime += ovsTime;
if (ir[0] == 'y') {
seqtime += irTime;
seqtime -= tauIR; /* subtract out ss_grad which was already included in TR */
}
trmin = seqtime + 4e-6; /* ensure that tr_delay is at least 4us */
trmin *= ns;
if (mintr[0] == 'y') {
tr = trmin;
putvalue("tr",tr);
}
if (tr < trmin) {
abort_message("TR too short. Minimum TR= %.2fms\n",trmin*1000+0.005);
}
tr_delay = (tr - seqtime*ns)/ns;
/* Set up frequency offset pulse shape list ********/
offsetlist(pss,ss_grad.ssamp,0,freqEx,ns,seqcon[1]);
shapeEx = shapelist(p1pat,ss_grad.rfDuration,freqEx,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,&per_grad);
initval(pe_steps/2.0,vpe_offset);
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
g_setExpTime(tr*(nt*pe_steps*arraydim + ssc));
/* PULSE SEQUENCE *************************************/
status(A);
rotate();
obsoffset(resto);
delay(4e-6);
initval(fabs(ssc),vssc); // Compressed steady-state counter
assign(zero,vrfspoil_ctr); // RF spoil phase counter
assign(zero,vrfspoil); // RF spoil multiplier
assign(one,vacquire); // real-time acquire flag
setacqvar(vacquire); // Turn on acquire when vacquire is zero
/* Delay all channels except gradient *****************/
sub(ssval,ssctr,v30);
add(v30,ct,v30);
if (ix == 1) { ifzero(v30); grad_advance(tep); endif(v30); }
/* Begin phase-encode loop ****************************/
peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr);
/* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */
if ((ix > 1) && (ssc > 0))
assign(zero,vssc);
sub(vpe_ctr,vssc,vpe_ctr); // vpe_ctr counts up from -ssc
assign(zero,vssc);
if (seqcon[2] == 's')
assign(zero,vacquire); // Always acquire for non-compressed loop
else {
ifzero(vpe_ctr);
assign(zero,vacquire); // Start acquiring when vpe_ctr reaches zero
endif(vpe_ctr);
}
/* Set rcvr/xmtr phase for RF spoiling *******************/
if (rfspoil[0] == 'y') {
incr(vrfspoil_ctr); // vrfspoil_ctr = 1 2 3 4 5 6
add(vrfspoil,vrfspoil_ctr,vrfspoil); // vrfspoil = 1 3 6 10 15 21
xmtrphase(vrfspoil);
rcvrphase(vrfspoil);
}
/* Read external kspace table if set ******************/
if (table)
getelem(t1,vpe_ctr,vpe_mult);
else {
ifzero(vacquire);
sub(vpe_ctr,vpe_offset,vpe_mult);
elsenz(vacquire);
sub(zero,vpe_offset,vpe_mult); // Hold PE mult at initial value for steady states
endif(vacquire);
}
/* PE rewinder follows PE table; zero if turned off ***/
if (perewind[0] == 'y')
assign(vpe_mult,vper_mult);
else
assign(zero,vper_mult);
/* Begin multislice loop ******************************/
msloop(seqcon[1],ns,vms_slices,vms_ctr);
triggerSelect(trigger); // Selectable trigger input
delay(4e-6);
if (ticks) {
xgate(ticks);
grad_advance(tep); // Gradient propagation delay
}
/* TTL scope trigger **********************************/
sp1on(); delay(4e-6); sp1off();
/* Prepulse options ***********************************/
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
if (ovs[0] == 'y') {ovsbands(); rotate();}
/* 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,rof2,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(shapeEx,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,-ror_grad.amp,0,-ssr_grad.amp,
-pe_grad.increment,vpe_mult,WAIT);
/* TE delay *******************************************/
delay(te_delay);
/* Readout gradient and acquisition ********************/
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 / spoiler gradient *********************************/
if ((perewind[0] == 'y') || (spoilflag[0] == 'y')) {
pe_shapedgradient(per_name,perTime,spoil_grad.amp,pespoil_amp,spoil_grad.amp,
per_grad.increment,vper_mult,WAIT);
}
/* Relaxation delay ***********************************/
if (!trtype)
delay(tr_delay);
endmsloop(seqcon[1],vms_ctr);
if (trtype)
delay(ns*tr_delay);
endpeloop(seqcon[2],vpe_ctr);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
}
void pulsesequence() {
//======================================================
// Define Variables and Objects and Get Parameter Values
//======================================================
// --------------------------------
// Acquisition Decoupling
// -------------------------------
char Xseq[MAXSTR];
getstr("Xseq",Xseq);
DSEQ dec = getdseq("X");
strncpy(dec.t.ch,"dec",3);
putCmd("chXtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chXspinal='dec'\n");
//-------------------------------------
// Homonuclear Decoupling During Echo
//-------------------------------------
MPDEC homo1 = getmpdec("hdec1H",0,0.0,0.0,0,1);
strncpy(homo1.mps.ch,"obs",3);
putCmd("chHhdec1='obs'\n");
// --------------------
// H echo calculation
// --------------------
double t1Hecho = getval("t1Hecho") - getval("pwHecho")/2.0 -
((!strcmp(homo1.dm,"y"))?getval("pwHshort1")*2.:0.0);
if (t1Hecho < 0.0) t1Hecho = 0.0;
double t2Hecho = getval("t2Hecho") - getval("pwHecho")/2.0 -
((!strcmp(homo1.dm,"y"))?getval("pwHshort1")*2.:0.0) -
getval("rd")- getval("ad");
if (t2Hecho < 0.0) t2Hecho = 0.0;
double t1H_echo = 0.0;
double t2H_echo = 0.0;
double t1H_left = 0.0;
double t2H_left = 0.0;
if (!strcmp(homo1.dm,"y")) {
t2H_echo = homo1.mps.t*((int)(t2Hecho/homo1.mps.t));
t2H_left = t2Hecho - t2H_echo;
t1H_echo = t2H_echo;
t1H_left = t1Hecho - t1H_echo;
}
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
//----------------------
// Dutycycle Protection
//----------------------
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90");
d.dutyoff = d1 + 4.0e-6;
if (!strcmp(homo1.dm,"y"))
d.dutyon += t1H_echo + t2H_echo;
else
d.dutyoff += t1H_echo + t2H_echo;
d.c1 = d.c1 + (!strcmp(Xseq,"tppm"));
d.c1 = d.c1 + ((!strcmp(Xseq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(Xseq,"spinal"));
d.c2 = d.c2 + ((!strcmp(Xseq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
//------------------------
// Set Phase Tables
//-----------------------
settable(phH90,4,table1);
settable(phHecho,8,table2);
settable(phRec,4,table3);
setreceiver(phRec);
//=======================
// Begin Sequence
//=======================
txphase(phH90); decphase(zero);
obspwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
//------------------------
// H Direct Polarization
//------------------------
rgpulse(getval("pwH90"),phH90,0.0,0.0);
obsunblank(); decunblank(); _unblank34();
// -----------------------------
// H Hahn Echo
// -----------------------------
if (!strcmp(homo1.dm,"y")) {
delay (t1H_left);
if (getval("pwHshort1") > 0.0 ) {
obspwrf(getval("aHhdec1"));
rgpulse(getval("pwHshort1"),three,0.0,0.0);
obsunblank();
}
if (!strcmp(homo1.dm,"y")) _mpseqon(homo1.mps,zero);
delay(t1H_echo);
if (!strcmp(homo1.dm,"y")) _mpseqoff(homo1.mps);
if (getval("pwHshort1") > 0.0 ) {
obspwrf(getval("aHhdec1")); txphase(one);
rgpulse(getval("pwHshort1"),one,0.0,0.0);
obsunblank();
}
}
else delay(t1Hecho);
txphase(phHecho);
obspwrf(getval("aHecho"));
rgpulse(getval("pwHecho"),phHecho,0.0,0.0);
obsunblank();
if (!strcmp(homo1.dm,"y")) {
if (getval("pwHshort1") > 0.0 ) {
obspwrf(getval("aHhdec1"));
rgpulse(getval("pwHshort1"),three,0.0,0.0);
obsunblank();
}
if (!strcmp(homo1.dm,"y")) _mpseqon(homo1.mps,zero);
delay(t2H_echo);
if (!strcmp(homo1.dm,"y")) _mpseqoff(homo1.mps);
if(getval("pwHshort1")>0 ) {
obspwrf(getval("aHhdec1"));
rgpulse(getval("pwHshort1"),one,0.0,0.0);
obsunblank();
}
delay(t2H_left);
}
else delay(t2Hecho);
//====================
// Begin Acquisition
//====================
_dseqon(dec);
obsblank(); decblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
DSEQ xdec = getdseq("X");
strncpy(xdec.t.ch,"obs",3); // These four statements assure
strncpy(xdec.s.ch,"obs",3); // that the X decoupling will
putCmd("chXtppm='obs'\n"); // be on X for either TPPM or
putCmd("chXspinal='obs'\n"); // SPINAL.
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = 3.0*getval("pwH90") + getval("pwHtilt") + getval("tHX");
d.dutyoff = d1 + 4.0e-6 + getval("tHmix");
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d.c3 = d.c3 + (!strcmp(xdec.seq,"tppm"));
d.c3 = d.c3 + ((!strcmp(xdec.seq,"tppm")) && (xdec.t.a > 0.0));
d.t3 = d2_;
d.c4 = d.c4 + (!strcmp(xdec.seq,"spinal"));
d.c4 = d.c4 + ((!strcmp(xdec.seq,"spinal")) && (xdec.s.a > 0.0));
d.t4 = d2_;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,16,table1);
settable(phHmix1,16,table2);
settable(phHmix2,4,table3);
settable(phHtilt,4,table4);
settable(phXhx,4,table5);
settable(phHhx,4,table6);
settable(phRec,4,table7);
if (phase1 == 2) tsadd(phH90,1,4);
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H Preparation and tilt
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decunblank();
// Delay for 1H Wideline T2
_dseqon(xdec);
delay(d2);
_dseqoff(xdec);
// Mix period for Spin Diffison
decrgpulse(getval("pwH90"),phHmix1,0.0,0.0);
delay(getval("tHmix"));
decrgpulse(getval("pwH90"),phHmix2,0.0,0.0);
// Tilt Pulse and Ramped H to X Cross Polarization with LG Offset
decrgpulse(getval("pwHtilt"),phHtilt,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
// Begin Acquisition
obsblank(); _blank34();
_dseqon(dec);
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence()
{
/* declaration of SGL kernel structures */
SGL_KERNEL_INFO_T read, phase, slice, ss_pre, ss_post;
/* declaration of internal variables */
double freqlist[MAXNSLICE];
double pe_steps;
int shapelist1, table;
double xtime, grad_duration, ror_pad,rod_pad;
double temp_tr;
double readAmp, phaseAmp, sliceAmp;
double tepad, tepad2, temin2, htrmin, delayToRF, delayRFToAcq, delayAcqToRF;
double rof_pad, delRof;
double sliceRephTrim, sliceDephTrim;
double readRephTrim, readDephTrim;
int rfPhase[2] = {0,2};
/* declaration of realtime 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 vss = v7;
int vssc = v8;
int vacquire = v9;
int vphase = v10;
settable(t2,2,rfPhase);
/* setup phase encoding order */
table = set_pe_order();
init_mri();
if( (sliceRephTrim = getvalnwarn("sliceRephTrim")) == 0.0 ) {
sliceRephTrim = 1.0;
}
if( (sliceDephTrim = getvalnwarn("sliceDephTrim")) == 0.0 ) {
sliceDephTrim = 1.0;
}
if( (readRephTrim = getvalnwarn("readRephTrim")) == 0.0 ) {
readRephTrim = 1.0;
}
if( (readDephTrim = getvalnwarn("readDephTrim")) == 0.0 ) {
readDephTrim = 1.0;
}
shape_rf( &p1_rf, "p1", p1pat, p1, flip1, rof1, rof2 ); // excitation pulse
init_slice( &ss_grad, "ss", thk ); // slice gradient
init_slice_refocus( &ssr_grad, "ssr" ); // slice refocus
init_slice_refocus( &ssd_grad, "ssd" ); // slice refocus
init_readout( &ro_grad, "ro", lro, np, sw ); // read gradient
init_readout_refocus( &ror_grad, "ror" ); // read dephase
init_readout_refocus( &rod_grad, "ror" ); // read dephase
init_phase( &pe_grad, "pe", lpe, nv ); // phase gradient
ss_grad.maxGrad = gmax * 0.57;
ssr_grad.maxGrad = gmax * 0.57;
ssd_grad.maxGrad = gmax * 0.57;
ro_grad.maxGrad = gmax * 0.57;
ror_grad.maxGrad = gmax * 0.57;
rod_grad.maxGrad = gmax * 0.57;
pe_grad.maxGrad = glimpe < 0.57? gmax*glimpe : gmax * 0.57;
/* calculate the RF pulses, gradient pulses and their interdependencies */
calc_rf( &p1_rf, "tpwr1", "tpwr1f" );
calc_slice( &ss_grad, &p1_rf, NOWRITE, "gss" );
ssr_grad.amp = ss_grad.amp;
ssr_grad.gmult = sliceRephTrim;
ssr_grad.calcFlag = DURATION_FROM_MOMENT_AMPLITUDE;
calc_slice_refocus( &ssr_grad, &ss_grad, NOWRITE, "gssr" );
ssd_grad.amp = ss_grad.amp;
ssd_grad.gmult = sliceDephTrim;
ssd_grad.calcFlag = DURATION_FROM_MOMENT_AMPLITUDE;
calc_slice_dephase( &ssd_grad, &ss_grad, NOWRITE, "gssd" );
calc_readout( &ro_grad, NOWRITE, "gro", "sw", "at" );
ror_grad.amp = ro_grad.amp;
ror_grad.calcFlag = DURATION_FROM_MOMENT_AMPLITUDE;
rod_grad.amp = ro_grad.amp;
rod_grad.calcFlag = DURATION_FROM_MOMENT_AMPLITUDE;
ror_grad.gmult = readRephTrim;
calc_readout_refocus( &ror_grad, &ro_grad, NOWRITE, "gror" );
rod_grad.gmult = readDephTrim;
calc_readout_rephase( &rod_grad, &ro_grad, NOWRITE, "grod" );
calc_phase( &pe_grad, NOWRITE, "gpe", "tpe" );
/* work out the position of the markers */
/* markerA */
/* ss_grad.rfDelayFront indicates the starting point of the
RF pulse measured from the start of the slice gradient
( rof1:pulse length:rof2 ) */
double granulatedRFDelayFront = granularity( ss_grad.rfDelayFront, GRADIENT_RES );
if( granulatedRFDelayFront > ss_grad.rfDelayFront ) {
granulatedRFDelayFront -= GRADIENT_RES;
}
/* ss_grad.rfDelayBack indicates the end point of the
RF pulse measured to the end of the slice gradient
( rof1:pulse length:rof2 ) */
double granulatedRFDelayBack = granularity( ss_grad.rfDelayBack, GRADIENT_RES );
if( granulatedRFDelayBack > ss_grad.rfDelayBack ) {
granulatedRFDelayBack -= GRADIENT_RES;
}
double granulatedRFDelay = granulatedRFDelayFront < granulatedRFDelayBack ? granulatedRFDelayFront : granulatedRFDelayBack;
double markerADelay = granulatedRFDelay;
/* read and phase gradients can overlap the start or end of the slice gradient by max of granulatedRFDElay */
double granulatedATDelayFront = granularity(ro_grad.atDelayFront, GRADIENT_RES);
if( granulatedATDelayFront > ro_grad.atDelayFront ) {
granulatedATDelayFront -= GRADIENT_RES;
}
double granulatedATDelayBack = granularity(ro_grad.atDelayBack, GRADIENT_RES);
if( granulatedATDelayBack > ro_grad.atDelayBack ) {
granulatedATDelayBack -= GRADIENT_RES;
}
double granulatedATDelay = granulatedATDelayFront < granulatedATDelayBack ? granulatedATDelayFront : granulatedATDelayBack;
/* longest gradient between RF pulse and acquire dominates */
xtime = ssr_grad.duration + granulatedRFDelay;
xtime = xtime > ssd_grad.duration + granulatedRFDelay ? xtime : ssd_grad.duration + granulatedRFDelay;
xtime = xtime > ror_grad.duration + granulatedATDelay ? xtime : ror_grad.duration + granulatedATDelay;
xtime = xtime > rod_grad.duration + granulatedATDelay ? xtime : rod_grad.duration + granulatedATDelay;
xtime = xtime > pe_grad.duration ? xtime : pe_grad.duration;
ror_pad = xtime - ror_grad.duration - granulatedATDelay;
rod_pad = xtime - rod_grad.duration - granulatedATDelay;
/* make a gradient list */
start_kernel( &sk );
add_gradient( (void*)&ss_grad, "slice", SLICE, START_TIME, "", 0.0, PRESERVE );
add_gradient( (void*)&ssr_grad, "sliceReph", SLICE, BEHIND, "slice", 0.0, INVERT );
add_gradient( (void*)&ror_grad, "readDeph", READ, BEHIND, "slice", -granulatedRFDelay + ror_pad, INVERT );
add_gradient( (void*)&ro_grad, "read", READ, BEHIND, "readDeph", 0.0, PRESERVE );
add_gradient( (void*)&pe_grad, "phase", PHASE, SAME_START, "readDeph", 0.0, PRESERVE );
add_gradient( (void*)&rod_grad, "readReph", READ, BEHIND, "read", 0.0, INVERT );
add_gradient( (void*)&pe_grad, "rewind", PHASE, SAME_END, "readReph", 0.0, INVERT );
add_gradient( (void*)&ss_grad, "nextSlice", SLICE, BEHIND, "readReph", rod_pad - granulatedRFDelay, PRESERVE );
add_gradient( (void*)&ssd_grad, "sliceDeph", SLICE, BEFORE, "nextSlice", 0, INVERT );
add_marker( "markerA", SAME_START, "slice", granulatedRFDelay );
add_marker( "markerB", SAME_START, "nextSlice", granulatedRFDelay );
/* get the minimum echo time */
temin = get_timing( FROM_RF_CENTER_OF, "slice", TO_ECHO_OF, "read" );
temin2 = get_timing( FROM_ECHO_OF, "read", TO_RF_CENTER_OF, "nextSlice" );
htrmin = MAX( temin, temin2 );
if( minte[0] == 'y' ){
te = htrmin;
}
tepad = granularity( te - temin, GRADIENT_RES );
tepad2 = granularity( te - temin2, GRADIENT_RES );
te = temin + tepad;
putCmd("setvalue('te', %f, 'current')\n", te );
if( tepad>0.0 ) change_timing( "readDeph", tepad );
if( tepad2>0.0 ) change_timing( "nextSlice", tepad2 );
tr = get_timing( FROM_START_OF, "slice", TO_START_OF, "nextSlice" );
putvalue("tr", tr );
delayRFToAcq = get_timing( FROM_RF_PULSE_OF, "slice", TO_ACQ_OF, "read" );
delayAcqToRF = get_timing( FROM_ACQ_OF, "read", TO_RF_PULSE_OF, "nextSlice" );
set_comp_info( &ss_pre, "ss_pre" );
write_comp_grads_snippet( NULL, NULL, &ss_pre, "START_OF_KERNEL", "markerA" );
set_comp_info( &read, "ro" );
set_comp_info( &phase, "pe" );
set_comp_info( &slice, "ss" );
write_comp_grads_snippet( &read, &phase, &slice, "markerA", "markerB" );
set_comp_info( &ss_post, "ss_post" );
write_comp_grads_snippet( NULL, NULL, &ss_post, "markerB", "END_OF_KERNEL" );
/* Set up frequency offset pulse shape list ********/
offsetlist(pss,ss_grad.ssamp,0,freqlist,ns,seqcon[1]);
shapelist1 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freqlist,ns,ss_grad.rfFraction, seqcon[1]);
/* Set pe_steps for profile or full image **********/
pe_steps = prep_profile(profile[0],nv,&pe_grad,&pe_grad);/* profile[0] is n y or r */
F_initval(pe_steps/2.0,vpe_offset);
g_setExpTime(trmean*(ntmean*pe_steps*arraydim + (1+fabs(ssc))*arraydim));
/* Shift DDR for pro *******************************/
roff = -poffset(pro,ro_grad.roamp);
/* PULSE SEQUENCE */
status( A );
rotate();
triggerSelect(trigger);
obsoffset( resto );
delay( GRADIENT_RES );
initval( 1+fabs( ssc ), vss );
obspower( p1_rf.powerCoarse );
obspwrf( p1_rf.powerFine );
delay( GRADIENT_RES );
assign(one,vacquire); // real-time acquire flag
setacqvar(vacquire); // Turn on acquire when vacquire is zero
obl_shapedgradient(ss_pre.name,ss_pre.dur,0,0,ss_pre.amp,NOWAIT);
sp1on();
delay(GRADIENT_RES);
sp1off();
delay(ss_pre.dur-GRADIENT_RES );
msloop( seqcon[1], ns, vms_slices, vms_ctr );
assign(vss,vssc);
peloop( seqcon[2], pe_steps, vpe_steps, vpe_ctr );
sub(vpe_ctr,vssc,vpe_ctr); // vpe_ctr counts up from -ssc
assign(zero,vssc);
if (seqcon[2] == 's')
assign(zero,vacquire); // Always acquire for non-compressed loop
else {
ifzero(vpe_ctr);
assign(zero,vacquire); // Start acquiring when vpe_ctr reaches zero
endif(vpe_ctr);
}
if (table)
getelem(t1,vpe_ctr,vpe_index);
else {
ifzero(vacquire);
sub(vpe_ctr,vpe_offset,vpe_index);
elsenz(vacquire);
sub(zero,vpe_offset,vpe_index);
endif(vacquire);
}
pe_shaped3gradient( read.name, phase.name, slice.name,
read.dur, read.amp, 0, slice.amp,
-pe_grad.increment, vpe_index, NOWAIT );
delay(ss_grad.rfDelayFront - granulatedRFDelay);
shapedpulselist( shapelist1, ss_grad.rfDuration, oph, rof1, rof2, seqcon[1], vms_ctr );
delay( delayRFToAcq - alfa );
startacq(alfa);
acquire( np, 1/ro_grad.bandwidth );
endacq();
delay( delayAcqToRF - ss_grad.rfDelayFront + granulatedRFDelay - GRADIENT_RES );
sp1on();
delay(GRADIENT_RES);
sp1off();
endpeloop( seqcon[2], vpe_ctr );
endmsloop( seqcon[1], vms_ctr );
obl_shapedgradient(ss_post.name,ss_post.dur,0,0,ss_post.amp,WAIT);
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
double aXecho = getval("aXecho");
double t1Xechoinit = getval("t1Xecho");
double pwXecho = getval("pwXecho");
double t2Xechoinit = getval("t2Xecho");
double t1Xecho = t1Xechoinit - pwXecho/2.0;
if (t1Xecho < 0.0) t1Xecho = 0.0;
double t2Xecho = t2Xechoinit - pwXecho/2.0 - getval("rd");
if (t2Xecho < 0.0) t2Xecho = 0.0;
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHX") + pwXecho;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,4,table1);
settable(phXhx,4,table2);
settable(phHhx,4,table3);
settable(phXecho,16,table4);
settable(phRec,8,table5);
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
// sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhx);
sp1on();
_cp_(hx,phHhx,phXhx);
sp1off();
// Begin Decoupling
_dseqon(dec);
// X Hahn Echo
txphase(phXecho);
obspwrf(aXecho);
delay(t1Xecho);
rgpulse(pwXecho,phXecho,0.0,0.0);
delay(t2Xecho);
// Begin Acquisition
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Set the Maximum Dynamic Table and v-var Numbers
settablenumber(10);
setvvarnumber(30);
// Define Variables and Objects and Get Parameter Values
double aXprep1 = getval("aXprep1"); // Define Tilted Pulses using "prep1X".
double pw1Xprep1 = getval("pw1Xprep1");
double pw2Xprep1 = getval("pw2Xprep1");
double phXprep1 = getval("phXprep1");
WMPA wpmlg = getwpmlg("wpmlgX");
strncpy(wpmlg.ch,"obs",3);
putCmd("chXwpmlg='obs'\n");
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pw1Xprep1") + getval("pw2Xprep1") + 2.0*wpmlg.q*wpmlg.cycles*wpmlg.pw;
d.dutyoff = d1 + 4.0e-6 + 5.0e-6 + wpmlg.r1 + wpmlg.r2 +
at - 2.0*wpmlg.q*wpmlg.cycles*wpmlg.pw;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1Xprep1,4,table1);
settable(ph2Xprep1,4,table2);
settable(phXwpmlg,4,table3);
settable(phRec,4,table4);
setreceiver(phRec);
// Set the Small-Angle Step
double obsstep = 360.0/(PSD*8192);
obsstepsize(obsstep);
int phfXprep1 = initphase(phXprep1, obsstep);
int phXzero = initphase(0.0, obsstep);
// Begin Sequence
xmtrphase(phfXprep1); txphase(ph1Xprep1);
obspwrf(aXprep1);
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// Tilted Preparation Pulse for FSLG or PMLG "prep1X"
startacq(5.0e-6);
rcvroff();
delay(wpmlg.r1);
rgpulse(pw1Xprep1, ph1Xprep1, 0.0, 0.0);
rgpulse(pw2Xprep1, ph2Xprep1, 0.0, 0.0);
xmtrphase(phXzero);
delay(wpmlg.r2);
// Apply WPMLG Cycles
decblank(); _blank34();
_wpmlg(wpmlg, phXwpmlg);
endacq();
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
SHAPE p1 = getpulse("90H",0.0,0.0,1,0);
strncpy(p1.pars.ch,"dec",3);
putCmd("chH90='dec'\n");
p1.pars.array = disarry("xx", p1.pars.array);
p1 = update_shape(p1,0.0,0.0,1);
MPSEQ ph = getpmlgxmx("pmlgH",0,0.0,0.0,1,0);
strncpy(ph.ch,"dec",3);
putCmd("chHpmlg='dec'\n");
double pwHpmlg = getval("pwHpmlg");
ph.nelem = (int) (d2/(2.0*pwHpmlg) + 0.1);
ph.array = disarry("xx", ph.array);
ph = update_mpseq(ph,0,p1.pars.phAccum,p1.pars.phInt,1);
SHAPE p2 = getpulse("90H",0.0,0.0,2,0);
strncpy(p2.pars.ch,"dec",3);
putCmd("chH90='dec'\n");
p2.pars.array = disarry("xx", p2.pars.array);
p2 = update_shape(p2,ph.phAccum,ph.phInt,2);
double pwX180 = getval("pwX180");
double d22 = ph.t/2.0 - pwX180/2.0;
if (d22 < 0.0) d22 = 0.0;
// CP hx and DSEQ dec Return to the Reference Phase
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = p1.pars.t + d2_ + p2.pars.t + getval("pwH90") + getval("pwHtilt") +
getval("tHX");
d.dutyoff = d1 + 4.0e-6 + getval("tHmix");
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1H90,4,table1);
settable(phHpmlg,4,table2);
settable(ph2H90,4,table3);
settable(ph3H90,4,table4);
settable(phHtilt,4,table5);
settable(phXhx,4,table6);
settable(phHhx,4,table7);
settable(phRec,4,table8);
//Add STATES TPPI ("States with "FAD")
tsadd(phRec,2*d2_index,4);
if (phase1 == 2) {
tsadd(ph2H90,2*d2_index+3,4);
}
else {
tsadd(ph2H90,2*d2_index,4);
}
setreceiver(phRec);
// Begin Sequence
txphase(phXhx); decphase(ph1H90);
obspwrf(getval("aX180")); decpwrf(getval("aH90"));
obsunblank();decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// Offset H Preparation with a Tilt Pulse
_shape(p1,ph1H90);
// Offset SAMn Spinlock on H During F1 with Optional pwX180
_mpseqon(ph,phHpmlg);
delay(d22);
rgpulse(pwX180,zero,0.0,0.0);
obspwrf(getval("aX90"));
txphase(phXhx);
delay(d22);
_mpseqoff(ph);
// Offset 90-degree Pulse to Zed and Spin-Diffusion Mix
_shape(p2,ph2H90);
decpwrf(getval("aH90"));
delay(getval("tHmix"));
// H90, 35-degree Tilt and H-to-X Cross Polarization with LG Offset
decrgpulse(getval("pwH90"),ph3H90,0.0,0.0);
decunblank();
decrgpulse(getval("pwHtilt"),phHtilt,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
// Begin Acquisition
obsblank(); _blank34();
_dseqon(dec);
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
double aXfam2 = getval("aXfam2");
double pw1Xfam2 = getval("pw1Xfam2");
double pw2Xfam2 = getval("pw2Xfam2");
double pw3Xfam2 = getval("pw3Xfam2");
double pw4Xfam2 = getval("pw4Xfam2");
double nXfam2 = getval("nXfam2");
initval(nXfam2,v4);
putCmd("pw2Xmqmas=pwXfam1"); // Sequence uses pwXfam1 and sets pw2Xmqmas
double d2init = getval("d2"); // Define the Split d2 in the Pulse Sequence
double ival = getval("ival");
double d20 = 1.0;
double d21 = 0.0;
double d22 = 0.0;
if (ival == 1.5) {
d20 = 9.0*d2init/16.0;
d21 = 7.0*d2init/16.0;
d22 = 0.0;
}
else if (ival == 2.5) {
d20 = 12.0*d2init/31.0;
d21 = 0.0*d2init/31.0;
d22 = 19.0*d2init/31.0;
}
else {
d20 = 1.0*d2init;
d21 = 0.0*d2init;
d22 = 0.0*d2init;
}
double tXechselinit = getval("tXechsel"); // Adjust the selective echo delay for the
double tXechsel = tXechselinit - 3.0e-6; // attenuator switch time.
if (tXechsel < 0.0) tXechsel = 0.0;
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pw1Xmqmas") + nXfam2*(pw1Xfam2 + pw2Xfam2 + pw3Xfam2 +pw4Xfam2) +
getval("pwXechsel");
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = d2_ + tXechselinit + getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = d2_ + tXechselinit + getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
if (phase1 == 0) {
settable(phf1Xmqmas,12,table1);
settable(ph1Xfam2,6,table2);
settable(ph2Xfam2,6,table3);
settable(phfXechsel,96,table4);
settable(phRec,48,table5);
}
else {
settable(phf1Xmqmas,6,table6);
settable(ph1Xfam2,6,table7);
settable(ph2Xfam2,6,table8);
settable(phfXechsel,48,table9);
settable(phRec,24,table10);
if (phase1 == 2) {
tsadd(phf1Xmqmas,30,360);
}
}
setreceiver(phRec);
obsstepsize(1.0);
// Begin Sequence
xmtrphase(phf1Xmqmas); decphase(zero);
obspower(getval("tpwr"));
obspwrf(getval("aXmqmas"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H Decoupler on Before MQMAS
_dseqon(dec);
// Two-Pulse MQMAS with DFS Conversion
rgpulse(getval("pw1Xmqmas"),zero,0.0,0.0);
xmtrphase(zero); txphase(ph1Xfam2);
obspwrf(aXfam2);
delay(d20);
// X FAM2 Pulse
loop(v4,v5);
xmtron();
delay(pw1Xfam2);
xmtroff();
txphase(ph2Xfam2);
delay(pw2Xfam2);
xmtron();
delay(pw3Xfam2);
xmtroff();
txphase(ph2Xfam2);
delay(pw4Xfam2);
endloop(v5);
// Tau Delay and Second Selective Echo Pulse
xmtrphase(phfXechsel);
obsblank();
obspower(getval("dbXechsel"));
obspwrf(getval("aXechsel"));
delay(3.0e-6);
obsunblank();
delay(d21 + tXechsel);
rgpulse(getval("pwXechsel"),zero,0.0,0.0);
delay(d22);
// Begin Acquisition
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Define Variables and Objects and Get Parameter Values
CP hx = getcp("HX",0.0,0.0,0,1);
strncpy(hx.fr,"dec",3);
strncpy(hx.to,"obs",3);
putCmd("frHX='dec'\n");
putCmd("toHX='obs'\n");
MPSEQ spc5 = getspc5("spc5X",0,0.0,0.0,0,1);
MPSEQ spc5ref = getspc5("spc5X",spc5.iSuper,spc5.phAccum,spc5.phInt,1,1);
strncpy(spc5.ch,"obs",3);
putCmd("chXspc5='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHX") + getval("pwX90") +
spc5.t + spc5ref.t;
d.dutyoff = d1 + 4.0e-6 + 2.0*getval("tZF");
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = d2_ + getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = d2_ + getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Create Phasetables
settable(phH90,4,table1);
settable(phHhx,4,table2);
settable(phXhx,4,table3);
settable(phXmix1,4,table4);
settable(phXmix2,4,table5);
settable(phRec,4,table6);
setreceiver(phRec);
if (phase1 == 2)
tsadd(phXhx,1,4);
// Begin Sequence
txphase(phXhx); decphase(phH90);
obspwrf(getval("aXhx")); decpwrf(getval("aH90"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to X Cross Polarization
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhx);
_cp_(hx,phHhx,phXhx);
// F2 Indirect Period for X
obspwrf(getval("aX90"));
_dseqon(dec);
delay(d2);
_dseqoff(dec);
// Mixing with SPC5 Recoupling
rgpulse(getval("pwX90"),phXmix1,0.0,0.0);
obspwrf(getval("aXspc5"));
xmtrphase(v1); txphase(phXmix1);
delay(getval("tZF"));
decpwrf(getval("aHmix"));
decon();
_mpseq(spc5, phXmix1);
xmtrphase(v2); txphase(phXmix2);
_mpseq(spc5ref, phXmix2);
decoff();
obspwrf(getval("aX90"));
xmtrphase(zero); txphase(phXmix2);
delay(getval("tZF"));
rgpulse(getval("pwX90"),phXmix2,0.0,0.0);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
pulsesequence() {
// Define Variables and Objects and Get Parameter Values
CP hy = getcp("HY",0.0,0.0,0,1);
strncpy(hy.fr,"dec",3);
strncpy(hy.to,"dec2",4);
putCmd("frHY='dec'\n");
putCmd("toHY='dec2'\n");
GP inept = getinept("ineptYX");
strncpy(inept.ch1,"dec2",4);
strncpy(inept.ch2,"obs",3);
putCmd("ch1YXinept='dec2'\n");
putCmd("ch2YXinept='obs'\n");
DSEQ dec = getdseq("H");
strncpy(dec.t.ch,"dec",3);
putCmd("chHtppm='dec'\n");
strncpy(dec.s.ch,"dec",3);
putCmd("chHspinal='dec'\n");
DSEQ mix = getdseq("Hmix");
strncpy(mix.t.ch,"dec",3);
putCmd("chHmixtppm='dec'\n");
strncpy(mix.s.ch,"dec",3);
putCmd("chHmixspinal='dec'\n");
// Dutycycle Protection
double simpw1 = inept.pw1;
if (inept.pw2 > inept.pw1) simpw1 = inept.pw2;
double simpw2 = inept.pw3;
if (inept.pw4 > inept.pw3) simpw2 = inept.pw4;
DUTY d = init_dutycycle();
d.dutyon = getval("pwH90") + getval("tHY") + 2.0*simpw1 + 2.0*simpw2;
d.dutyoff = d1 + 4.0e-6;
d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));
d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));
d.t1 = inept.t1 + inept.t2 + inept.t3 + inept.t4 +
getval("rd") + getval("ad") + at;
d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));
d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));
d.t2 = inept.t1 + inept.t2 + inept.t3 + inept.t4 +
getval("rd") + getval("ad") + at;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(phH90,16,table1);
settable(phHhy,4,table2);
settable(phYhy,4,table3);
settable(ph1Yyxinept,4,table4);
settable(ph1Xyxinept,4,table5);
settable(ph2Yyxinept,4,table6);
settable(ph2Xyxinept,16,table7);
settable(ph3Yyxinept,8,table8);
settable(ph3Xyxinept,4,table9);
settable(phRec,8,table10);
setreceiver(phRec);
// Begin Sequence
txphase(ph1Xyxinept); decphase(phH90); dec2phase(phYhy);
obspwrf(getval("aXyxinept")); decpwrf(getval("aH90")); dec2pwrf(getval("aYhy"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// H to Y Cross Polarization
decrgpulse(getval("pwH90"),phH90,0.0,0.0);
decphase(phHhy);
_cp_(hy,phHhy,phYhy);
decphase(zero);
// INEPT Transfer from Y to X
_dseqon(mix);
_ineptref(inept,ph1Yyxinept,ph1Xyxinept,ph2Yyxinept,ph2Xyxinept,ph3Yyxinept,ph3Xyxinept);
_dseqoff(mix);
// Begin Acquisition
_dseqon(dec);
obsblank(); _blank34();
delay(getval("rd"));
startacq(getval("ad"));
acquire(np, 1/sw);
endacq();
_dseqoff(dec);
obsunblank(); decunblank(); _unblank34();
}
void pulsesequence() {
// Set the Maximum Dynamic Table and v-var Numbers
settablenumber(20);
setvvarnumber(30);
// Define Variables and Objects and Get Parameter Values
MPSEQ dumbo = getdumbogen("dumboX","dcf1X",0,0.0,0.0,0,1);
strncpy(dumbo.ch,"obs",3);
putCmd("chXdumbo='obs'\n");
MPSEQ c7 = getpostc7("c7X",0,0.0,0.0,0,1);
MPSEQ c7ref = getpostc7("c7X",c7.iSuper,c7.phAccum,c7.phInt,1,1);
strncpy(c7.ch,"obs",3);
putCmd("chXc7='obs'\n");
WMPA wdumbo = getwdumbogen("wdumboX","dcfX");
strncpy(wdumbo.ch,"obs",3);
putCmd("chXwdumbo='obs'\n");
double tXzfinit = getval("tXzf"); //Define the Z-filter delay in the sequence
double tXzf = tXzfinit - 5.0e-6 - wdumbo.r1;
// Set Constant-time Period for d2.
if (d2_index == 0) d2_init = getval("d2");
double d2_ = (ni - 1)/sw1 + d2_init;
putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9));
putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9));
//--------------------------------------
// Copy Current Parameters to Processed
//-------------------------------------
putCmd("groupcopy('current','processed','acquisition')");
// Dutycycle Protection
DUTY d = init_dutycycle();
d.dutyon = c7.t + getval("pwXtilt") + d2_ + getval("pwXtilt") + c7ref.t + getval("pwX90") +
+ wdumbo.q*wdumbo.cycles*wdumbo.pw;
d.dutyoff = 4.0e-6 + d1 + tXzfinit + wdumbo.r2 + at - wdumbo.q*wdumbo.cycles*wdumbo.pw;
d = update_dutycycle(d);
abort_dutycycle(d,10.0);
// Set Phase Tables
settable(ph1Xc7,4,table1);
settable(phXdumbo,4,table2);
settable(ph2Xc7,4,table3);
settable(phX90,16,table4);
settable(phXwdumbo,4,table5);
settable(phRec,16,table6);
settable(ph1Xtilt,4,table7);
settable(ph2Xtilt,4,table8);
// Set the Small-Angle Prep Phase
double obsstep = 360.0/(PSD*8192);
obsstepsize(obsstep);
int phfX90 = initphase(0.0, obsstep);
//Add STATES Quadrature Phase
if (phase1 == 2)
initval((45.0/obsstep),v1);
else
initval(0.0,v1);
initval((d2*c7.of[0]*360.0/obsstep),v2);
initval(0.0,v3);
obsstepsize(obsstep);
setreceiver(phRec);
// Begin Sequence
xmtrphase(v1); txphase(ph1Xc7);
obspwrf(getval("aXc7"));
obsunblank(); decunblank(); _unblank34();
delay(d1);
sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);
// C7 Recoupling of 2Q coherence
_mpseq(c7, ph1Xc7);
// F1 Evolution With DUMBO
xmtrphase(v3);
if (!getval("scXdcf1")){
obspwrf(getval("aX90"));
rgpulse(getval("pwXtilt"),ph1Xtilt,0.0,0.0);
}
obspwrf(getval("aXdumbo"));
obsunblank();
_mpseqon(dumbo,phXdumbo);
delay(d2);
_mpseqoff(dumbo);
if (!getval("scXdcf1")){
obspwrf(getval("aX90"));
rgpulse(getval("pwXtilt"),ph2Xtilt,0.0,0.0);
}
obspwrf(getval("aX90"));
obsunblank();
// C7 Transfer to 1Q Coherence
xmtrphase(v2);
_mpseq(c7ref, ph2Xc7);
// Z-filter Delay
delay(tXzf);
// Detection Pulse
txphase(phX90);
obspwrf(getval("aX90"));
startacq(5.0e-6);
rcvroff();
delay(wdumbo.r1);
rgpulse(getval("pwX90"), phX90, 0.0, 0.0);
obsunblank();
xmtrphase(v3);
delay(wdumbo.r2);
// Apply WPMLG Cycles During Acqusition
decblank(); _blank34();
_wdumbo(wdumbo,phXwdumbo);
endacq();
obsunblank(); decunblank(); _unblank34();
}
