pulsesequence()
{
char Cdseq[MAXSTR], refoc[MAXSTR], sspul[MAXSTR];
int mult = (0.5 + getval("mult"));
double rg1 = 2.0e-6,
j1xh = getval("j1xh"),
gt0 = getval("gt0"),
gzlvl0 = getval("gzlvl0"),
pp = getval("pp"),
pplvl = getval("pplvl"),
compH = getval("compH"),
Cdpwr = getval("Cdpwr"),
Cdres = getval("Cdres"),
tau1 = 0.002,
tau2 = 0.002,
Cdmf = getval("Cdmf");
shape hdx;
/* Get new variables from parameter table */
getstr("Cdseq", Cdseq);
getstr("refoc", refoc);
getstr("sspul", sspul);
if (j1xh < 1.0) j1xh = 150.0;
hdx = pboxHT_F1i("gaus180", pp*compH, pplvl); /* HADAMARD stuff */
if (getval("htcal1") > 0.5) /* Optional fine power calibration */
hdx.pwr = getval("htpwr1");
if(j1xh > 0.0)
tau1 = 0.25/j1xh;
tau2 = tau1;
if (mult > 2) tau2=tau1/2.5;
else if ((mult == 0) || (mult == 2)) tau2=tau1/2.0;
dbl(ct, v1); /* v1 = 02 */
add(two,v1,oph);
mod4(oph,oph); /* oph = 02 */
/* Calculate delays */
if (dm[0] == 'y')
{
abort_message("decoupler must be set as dm=nny\n");
}
if(refoc[A]=='n' && dm[C]=='y')
{
abort_message("with refoc=n decoupler must be set as dm=nnn\n");
}
/* Relaxation delay */
status(A);
delay(0.05);
zgradpulse(gzlvl0,gt0);
if (sspul[0] == 'y')
{
obspower(tpwr); decpower(pplvl);
simpulse(pw, pp, zero, zero, rg1, rg1); /* destroy H and C magnetization */
zgradpulse(gzlvl0,gt0);
}
delay(d1);
status(B);
obspower(Cdpwr);
obsunblank(); xmtron();
obsprgon(Cdseq, 1.0/Cdmf, Cdres);
pbox_decpulse(&hdx, zero, rg1, rg1);
obsprgoff(); xmtroff(); obsblank();
obspower(tpwr); decpower(pplvl);
delay(2.0e-4);
decrgpulse(pp, v1, rg1, rg1);
delay(tau1 - POWER_DELAY);
simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1);
txphase(one); decphase(one);
delay(tau1);
simpulse(pw, pp, one, one, rg1, rg1);
if(refoc[A]=='y')
{
txphase(zero); decphase(zero);
delay(tau2);
simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1);
delay(tau2 - rof2 - POWER_DELAY);
decrgpulse(pp, zero, rg1, rof2);
}
decpower(dpwr);
status(C);
}
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);
}
void pulsesequence()
{
double slpwrR = getval("slpwrR"),
slpwR = getval("slpwR"),
mixR = getval("mixR"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
gstab = getval("gstab"),
selfrq = getval("selfrq"),
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
zqfpw1 = getval("zqfpw1"),
zqfpwr1 = getval("zqfpwr1"),
gzlvlzq1 = getval("gzlvlzq1"),
phincr1 = getval("phincr1");
char selshapeA[MAXSTR],selshapeB[MAXSTR], slpatR[MAXSTR],
zqfpat1[MAXSTR], alt_grd[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("slpatR",slpatR);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat1",zqfpat1);
getstr("alt_grd",alt_grd);
if (strcmp(slpatR,"cw") &&
strcmp(slpatR,"troesy") &&
strcmp(slpatR,"dante"))
abort_message("SpinLock pattern %s not supported!.\n", slpatR);
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */
assign(ct,v17);
ifzero(ssctr);
assign(v17,v13);
elsenz(ssctr);
/* purge option does not adjust v13 during steady state */
sub(ssval, ssctr, v13);
endif(ssctr);
/* Beginning phase cycling */
dbl(v13,v1); /* v1 = 0 2 */
hlv(v13,v13);
dbl(v13,v20); /* v20 = 00 22 */
hlv(v13,v13);
dbl(v13,v6); /* v6 = 0000 2222 */
hlv(v13,v13);
dbl(v13,v7); /* v7 = 00000000 22222222 */
assign(v1,oph);
if (getflag("Gzqfilt"))
add(v7,oph,oph);
/* CYCLOPS */
assign(v13,v14); /* v14 = 8x0 8x1 8x2 8x3 */
if (getflag("Gzqfilt"))
hlv(v13,v14); /* v14 = 16x0 16x1 16x2 16x3 */
add(v1,v14,v1);
add(v20,v14,v20);
add(v6,v14,v6);
add(v7,v14,v7);
add(oph,v14,oph);
/* add(oph,v18,oph);
add(oph,v19,oph); */
assign(zero,v9);
mod2(ct,v2); /* 01 01 */
hlv(ct,v11); hlv(v11,v11); mod2(v11,v11); dbl(v11,v11); /* 0000 2222 */
add(v11,v2,v11); mod4(v11,v11); /* 0101 2323 first echo in Excitation Sculpting */
hlv(ct,v4); mod2(v4,v4); /* 0011 */
hlv(ct,v12); hlv(v12,v12); hlv(v12,v12); dbl(v12,v12); add(v12,v4,v12);
mod4(v12,v12); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */
dbl(v2,v2); /* 0202 */
dbl(v4,v4); /* 0022 */
add(v2,v4,v4); /* 0220 correct oph for Excitation Sculpting */
add(oph,v4,oph); mod4(oph,oph);
if (!strcmp(slpatR,"troesy"))
assign(v20,v21);
else
add(v20,one,v21);
if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign on even scans */
/* The following is for flipback pulse */
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v5);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
delay(d1);
if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */
status(B);
if (getflag("cpmgflg"))
{
rgpulse(pw, v1, rof1, 0.0);
cpmg(v1, v15);
}
else
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v14,rof1,rof1);
obspower(tpwr);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v6,rof1,rof1);
obspower(slpwrR);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixR > 0.0)
{
if (dps_flag)
rgpulse(mixR,v21,0.0,0.0);
else
SpinLock(slpatR,mixR,slpwR,v21);
}
if (getflag("Gzqfilt"))
{
obspower(tpwr);
rgpulse(pw,v7,rof1,rof1);
ifzero(v8); zgradpulse(gzlvl1,gt1);
elsenz(v8); zgradpulse(-gzlvl1,gt1); endif(v8);
delay(gstab);
obspower(zqfpwr1);
ifzero(v8); rgradient('z',gzlvlzq1);
elsenz(v8); rgradient('z',-gzlvlzq1); endif(v8);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
ifzero(v8); zgradpulse(-gzlvl2,gt2);
elsenz(v8); zgradpulse(gzlvl2,gt2); endif(v8);
obspower(tpwr);
delay(gstab);
if (getflag("flipback"))
FlipBack(v14,v5);
rgpulse(pw,v14,rof1,2.0e-6);
}
ExcitationSculpting(v11,v12,v8);
delay(rof2);
status(C);
}
void pulsesequence()
{
char c1d[MAXSTR]; /* option to record only 1D C13 spectrum */
int ncyc;
double tau1 = 0.002, /* t1 delay */
post_del = 0.0,
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
compC = getval("compC"),
compH = getval("compH"),
mixpwr = getval("mixpwr"),
jCH = getval("jCH"),
gt0 = getval("gt0"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gzlvl0 = getval("gzlvl0"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
grec = getval("grec"),
phase = getval("phase");
getstr("c1d",c1d);
ncyc=1;
if(jCH > 0.0)
tau1 = 0.25/jCH;
dbl(ct, v1); /* v1 = 0 */
mod4(v1,oph);
hlv(ct,v2);
add(v2,v1,v2);
if (phase > 1.5)
incr(v1); /* hypercomplex phase increment */
initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v10);
add(v1,v10,v1);
add(oph,v10,oph);
mod4(v1,v1); mod4(v2,v2); mod4(oph,oph);
assign(zero,v3);
if(FIRST_FID)
{
HHmix = pbox_mix("HHmix", "DIPSI2", mixpwr, pw*compH, tpwr);
if(c1d[A] == 'n')
{
opx("CHdec"); setwave("WURST2 30k/1.2m"); pbox_par("steps","600"); cpx(pwC*compC, pwClvl);
CHdec = getDsh("CHdec");
}
}
ncyc = (int) (at/HHmix.pw) + 1;
post_del = ncyc*HHmix.pw - at;
/* BEGIN PULSE SEQUENCE */
status(A);
zgradpulse(gzlvl0, gt0);
rgpulse(pw, zero, 0.0, 0.0); /* destroy H-1 magnetization*/
zgradpulse(gzlvl0, gt0);
delay(1.0e-4);
obspower(tpwr);
txphase(v1);
decphase(zero);
dec2phase(zero);
presat();
obspower(tpwr);
delay(1.0e-5);
status(B);
if(c1d[A] == 'y')
{
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
delay(d2);
rgpulse(pw,two,0.0,0.0); /* 1H pulse excitation */
assign(oph,v3);
}
else
{
decunblank(); pbox_decon(&CHdec);
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
delay(d2);
pbox_decoff(); decblank();
decpower(pwClvl); decpwrf(4095.0);
delay(tau1 - POWER_DELAY);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
txphase(one); decphase(one); dec2phase(one);
delay(tau1);
simpulse(pw, pwC, one, one, 0.0, 0.0);
txphase(zero); decphase(zero); dec2phase(zero);
delay(tau1);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
delay(tau1);
simpulse(0.0, pwC, zero, zero, 0.0, 0.0);
}
zgradpulse(gzlvl1, gt1);
delay(grec);
simpulse(0.0, pwC, zero, v3, 0.0, rof2);
txphase(v2);
obsunblank(); pbox_xmtron(&HHmix);
status(C);
setactivercvrs("ny");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
delay(post_del);
pbox_xmtroff(); obsblank();
zgradpulse(gzlvl2, gt2);
obspower(tpwr);
delay(grec);
rgpulse(pw,zero,0.0,rof2); /* 1H pulse excitation */
status(D);
setactivercvrs("yn");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
pulsesequence()
{
double gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
mult = getval("mult"),
pwx180 = getval("pwx180"),
pwxlvl180 = getval("pwxlvl180"),
pwx180r = getval("pwx180r"),
pwxlvl180r = getval("pwxlvl180r"),
tpwr180 = getval("tpwr180"),
pw180 = getval("pw180"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
gzlvl5 = getval("gzlvl5"),
tau,
taug;
int icosel,
phase1 = (int)(getval("phase")+0.5),
prgcycle = (int)(getval("prgcycle")+0.5),
ZZgsign;
char pwx180ad[MAXSTR],
pwx180ref[MAXSTR],
bipflg[MAXSTR],
pw180ad[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",0.5);
gzlvlE = syncGradLvl("gtE","gzlvlE",0.5);
getstr("pwx180ad", pwx180ad);
getstr("pwx180ref", pwx180ref);
getstr("pw180ad", pw180ad);
getstr("bipflg",bipflg);
if (bipflg[0] == 'y')
{
tpwr180=getval("tnbippwr");
pw180=getval("tnbippw");
getstr("tnbipshp",pw180ad);
}
if (bipflg[1] == 'y')
{
pwxlvl180=getval("dnbippwr");
pwx180=getval("dnbippw");
getstr("dnbipshp",pwx180ad);
}
tau = 1 / (4*(getval("j1xh")));
if (mult > 0.5)
taug = 2*tau + getval("tauC");
else
taug = gtE + gstab + 2 * GRADIENT_DELAY;
ZZgsign=-1;
if (mult == 2) ZZgsign=1;
icosel = 1;
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
settable(t1, 4, ph1);
settable(t2, 2, ph2);
settable(t3, 8, ph3);
settable(t4, 16, ph4);
settable(t5, 16, ph5);
getelem(t1, v17, v1);
getelem(t3, v17, v3);
getelem(t4, v17, v4);
getelem(t2, v17, v2);
getelem(t5, v17, oph);
assign(zero,v6);
add(oph,v18,oph);
add(oph,v19,oph);
if ((phase1 == 2) || (phase1 == 5))
icosel = -1;
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
/*
mod2(id2, v14);
dbl(v14,v14);
*/
add(v2, v14, v2);
add(oph, v14, oph);
status(A);
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,zero);
if (getflag("prgflg"))
shaped_purge(v6,zero,v18,v19);
}
else
{
satpulse(satdly,zero,rof1,rof1);
if (getflag("prgflg"))
purge(v6,zero,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
obspower(tpwr);
decpower(pwxlvl180);
status(B);
if (getflag("nullflg"))
{
rgpulse(0.5 * pw, zero, rof1, rof1);
obspower(tpwr180);
delay(tau);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1);
delay(tau+POWER_DELAY+rof1);
delay(tau+POWER_DELAY+rof1);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1);
obspower(tpwr);
delay(tau);
rgpulse(0.5 * pw, zero, rof1, rof1);
zgradpulse(hsglvl, hsgt);
delay(1e-3);
}
rgpulse(pw, v6, rof1, rof1);
obspower(tpwr180);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
delay(tau+2.0*POWER_DELAY+2.0*rof1);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1);
delay(tau);
obspower(tpwr);
rgpulse(pw, v1, rof1, rof1);
zgradpulse(hsglvl, 2 * hsgt);
decpower(pwxlvl);
obspower(tpwr180);
delay(1e-3);
decrgpulse(pwx, v2, rof1, 2.0e-6);
delay(d2 / 2);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
delay(d2 / 2);
delay(taug - POWER_DELAY);
decpower(pwxlvl180r);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
if(mult < 1.5)
{
obspower(tpwr);
if (mult <0.5)
delay(2*rof1);
else
rgpulse(mult*pw,zero,rof1,rof1);
}
else
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
if(mult < 1.5)
delay(4*pwx/PI + 4.0e-6 + taug - gtE - gstab - 2 * GRADIENT_DELAY + WFG_START_DELAY + pw180 + WFG_STOP_DELAY - mult*pw);
else
delay(4*pwx/PI + 4.0e-6 + POWER_DELAY + taug - gtE - gstab - 2 * GRADIENT_DELAY);
zgradpulse(gzlvlE, gtE);
delay(gstab);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
decpower(pwxlvl);
decrgpulse(pwx, v4, 2.0e-6, rof1);
obspower(tpwr);
decpower(pwxlvl180);
zgradpulse(ZZgsign*0.6 * hsglvl, 1.2 * hsgt);
delay(1e-3);
rgpulse(pw, v3, rof1, rof1);
obspower(tpwr180);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
zgradpulse(gzlvl5,gtE/2.0);
delay(tau-gtE/2.0+2.0*POWER_DELAY);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof2);
zgradpulse(gzlvl5+icosel * 2.0*gzlvlE/EDratio, gtE/2.0);
delay(tau-gtE/2.0);
decpower(dpwr);
status(C);
}
// Return value of constant
dbl FreshEval_d(std::shared_ptr<Variable> const& diff_variable) const override
{
return dbl(double(true_value_real_),double(true_value_imag_));
}
pulsesequence()
{
double gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
del = getval("del"),
del2 = getval("del2"),
dosyfrq = getval("sfrq"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
Ddelta,dosytimecubed;
char convcomp[MAXSTR],satmode[MAXSTR],alt_grd[MAXSTR],lkgate_flg[MAXSTR],
sspul[MAXSTR];
getstr("convcomp",convcomp);
getstr("satmode",satmode);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",1.0);
gzlvl1 = syncGradLvl("gt1","gzlvl1",1.0);
gt2 = syncGradTime("gt2","gzlvl2",1.0);
gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0);
/* CHECK CONDITIONS */
if (p1 == 0.0) p1 = 2*pw;
/* STEADY-STATE PHASECYCLING
This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
dbl(ct, v1);
hlv(ct, v3);
elsenz(ssctr);
sub(ssval, ssctr, v7); /* v7 = 0,...,ss-1 */
dbl(v7, v1);
hlv(v7, v3);
endif(ssctr);
/* PHASECYCLE CALCULATION */
hlv(v3, v2);
mod2(v3, v3);
add(v3, v1, v1);
assign(v1, oph);
dbl(v2, v4);
add(v4, oph, oph);
add(v2, v3, v2);
Ddelta=gt1; /*the diffusion-encoding pulse width is gt1*/
if (convcomp[A]=='y')
dosytimecubed=Ddelta*Ddelta*(del - (4.0*Ddelta/3.0));
else
dosytimecubed=Ddelta*Ddelta*(del - (Ddelta/3.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
mod2(ct,v10); /* gradients change sign at odd transients */
/* BEGIN ACTUAL SEQUENCE */
status(A);
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0) delay(d1 - satdly);
obspower(satpwr);
rgpulse(satdly,zero,rof1,rof1);
obspower(tpwr);
}
else delay(d1);
if (getflag("wet")) wet4(zero,one);
status(B);
if (del>0.0) {
if (convcomp[A]=='y')
{
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl2,2.0*gt2);
elsenz(v10);
zgradpulse(gzlvl2,2.0*gt2);
endif(v10);
}
else zgradpulse(-gzlvl2,2.0*gt2);
delay(gstab);
rgpulse(pw, v1, rof1, rof1);
delay(d2/2.0);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(((del+del2)/4)-gt1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(((del-del2)/4)-gt1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl2,gt2);
elsenz(v10);
zgradpulse(-1.0*gzlvl2,gt2);
endif(v10);
}
else zgradpulse(gzlvl2,gt2);
delay(gstab);
rgpulse(p1, v2, rof1, rof1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl2,gt2);
elsenz(v10);
zgradpulse(-1.0*gzlvl2,gt2);
endif(v10);
}
else zgradpulse(gzlvl2,gt2);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(((del-del2)/4)-gt1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(((del+del2)/4)-gt1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
delay(gstab);
delay(d2/2.0);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
else
{
rgpulse(pw, v1, rof1, rof1);
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
delay(d2/2.0);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay((del-p1-2.0*rof1-gt1)/2.0);
rgpulse(p1, v2, rof1, rof1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay((del-p1-2.0*rof1-gt1)/2.0);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
delay(gstab);
delay(d2/2.0);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
}
else
rgpulse(pw,oph,rof1,rof2);
status(C);
}
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);
}
static inline void add(EcT& R, const EcT& P, const EcT& Q)
{
if (P.isZero()) { R = Q; return; }
if (Q.isZero()) { R = P; return; }
#if MIE_EC_COORD == MIE_EC_USE_JACOBI
Fp r, U1, S1, H, H3;
Fp::square(r, P.z);
Fp::square(S1, Q.z);
Fp::mul(U1, P.x, S1);
Fp::mul(H, Q.x, r);
H -= U1;
r *= P.z;
S1 *= Q.z;
S1 *= P.y;
Fp::mul(r, Q.y, r);
r -= S1;
if (H.isZero()) {
if (r.isZero()) {
dbl(R, P, false);
} else {
R.clear();
}
return;
}
Fp::mul(R.z, P.z, Q.z);
R.z *= H;
Fp::square(H3, H); // H^2
Fp::square(R.y, r); // r^2
U1 *= H3; // U1 H^2
H3 *= H; // H^3
R.y -= U1;
R.y -= U1;
Fp::sub(R.x, R.y, H3);
U1 -= R.x;
U1 *= r;
H3 *= S1;
Fp::sub(R.y, U1, H3);
#elif MIE_EC_COORD == MIE_EC_USE_PROJ
Fp r, PyQz, v, A, vv;
Fp::mul(r, P.x, Q.z);
Fp::mul(PyQz, P.y, Q.z);
Fp::mul(A, Q.y, P.z);
Fp::mul(v, Q.x, P.z);
v -= r;
if (v.isZero()) {
Fp::add(vv, A, PyQz);
if (vv.isZero()) {
R.clear();
} else {
dbl(R, P, false);
}
return;
}
Fp::sub(R.y, A, PyQz);
Fp::square(A, R.y);
Fp::square(vv, v);
r *= vv;
vv *= v;
Fp::mul(R.z, P.z, Q.z);
A *= R.z;
R.z *= vv;
A -= vv;
vv *= PyQz;
A -= r;
A -= r;
Fp::mul(R.x, v, A);
r -= A;
R.y *= r;
R.y -= vv;
#else
Fp t;
Fp::neg(t, Q.y);
if (P.y == t) { R.clear(); return; }
Fp::sub(t, Q.x, P.x);
if (t.isZero()) {
dbl(R, P, false);
return;
}
Fp s;
Fp::sub(s, Q.y, P.y);
Fp::div(t, s, t);
R.inf_ = false;
Fp x3;
Fp::square(x3, t);
x3 -= P.x;
x3 -= Q.x;
Fp::sub(s, P.x, x3);
s *= t;
Fp::sub(R.y, s, P.y);
R.x = x3;
#endif
}
void pulsesequence()
{
double selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
pwx180 = getval("pwx180"),
pwxlvl180 = getval("pwxlvl180"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
tau,
evolcorr,
jdly,
bird;
int icosel,
ijscale,
prgcycle = (int)(getval("prgcycle")+0.5),
phase1=(int)(getval("phase")+0.5);
char selshapeA[MAXSTR],
selshapeB[MAXSTR],
pwx180ad[MAXSTR],
pwx180adR[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",0.5);
gzlvlE = syncGradLvl("gtE","gzlvlE",0.5);
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("pwx180ad", pwx180ad);
getstr("pwx180adR", pwx180adR);
evolcorr=(4*pwx/PI)+2*pw+8.0e-6;
bird = 1 / (4*(getval("j1xh")));
tau = 1/(4*(getval("jnxh")));
ijscale=(int)(getval("jscale") + 0.5);
jdly=(d2*ijscale);
icosel = 1;
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
settable(t1,4,ph1);
settable(t2,2,ph2);
settable(t4,8,ph4);
settable(t5,8,ph5);
getelem(t1,v17,v1);
getelem(t2,v17,v2);
getelem(t4,v17,v4);
getelem(t5,v17,oph);
add(oph,v18,oph);
add(oph,v19,oph);
if ((phase1 == 2) || (phase1 == 5))
icosel = -1;
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
/*
mod2(id2, v14);
dbl(v14,v14);
*/
add(v2, v14, v2);
add(oph, v14, oph);
status(A);
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,zero);
if (getflag("prgflg"))
shaped_purge(v1,zero,v18,v19);
}
else
{
satpulse(satdly,zero,rof1,rof1);
if (getflag("prgflg"))
purge(v1,zero,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
decpower(pwxlvl);
status(B);
if (getflag("nullflg"))
{
rgpulse(0.5 * pw, zero, rof1, rof1);
delay(2 * bird);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(2 * bird + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
rgpulse(1.5 * pw, zero, rof1, rof1);
zgradpulse(hsglvl, hsgt);
delay(1e-3);
}
if (getflag("cpmgflg"))
{
rgpulse(pw, v1, rof1, 0.0);
cpmg(v1, v15);
}
else
rgpulse(pw, v1, rof1, rof1);
delay(tau/2 - gtA - gstab);
delay(jdly/4);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
shaped_pulse(selshapeA,selpwA,zero,rof1,rof1);
zgradpulse(gzlvlA,gtA);
delay(gstab);
delay(tau/2 - gtA - gstab);
delay(jdly/2);
delay(tau/2 - gtB - gstab);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
shaped_pulse(selshapeB,selpwB,two,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
decpower(pwxlvl);
delay(jdly/4);
delay(tau/2 - gtB - gstab);
rgpulse(pw, one, rof1, rof1);
zgradpulse(hsglvl, 2 * hsgt);
delay(1e-3);
decrgpulse(pwx, v2, rof1, 2.0e-6);
delay(d2/2);
rgpulse(2 * pw, zero, 2.0e-6, 2.0e-6);
delay(d2/2);
delay(gtE + gstab + 2*GRADIENT_DELAY - POWER_DELAY);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
zgradpulse(gzlvlE, gtE);
delay(gstab + POWER_DELAY + evolcorr);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
decrgpulse(pwx, v4, 2.0e-6, rof1);
zgradpulse(-0.6 * hsglvl, 1.2 * hsgt);
delay(1e-3);
rgpulse(pw, zero, rof1, rof1);
zgradpulse(icosel * 2.0*gzlvlE/EDratio, gtE/2.0);
delay(gstab);
delay(tau - gtA - 2*gstab - gtE/2);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
shaped_pulse(selshapeA,selpwA,zero,rof1,rof1);
zgradpulse(gzlvlA,gtA);
delay(gstab);
delay(tau - gtA - gstab);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(dpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,two,rof1,rof2);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
status(C);
}
void pulsesequence()
{
double p1lvl,
trim,
mix,
window,
cycles;
char sspul[MAXSTR];
/* LOAD AND INITIALIZE VARIABLES */
mix = getval("mix");
trim = getval("trim");
p1lvl = getval("p1lvl");
window=getval("window");
getstr("sspul", sspul);
/* CHECK CONDITIONS */
if ((phase1 != 3) && (arrayelements > 2))
{
fprintf(stdout, "PHASE=3 is required if MIX is arrayed!\n");
psg_abort(1);
}
if (satdly > 9.999)
{
fprintf(stdout, "Presaturation period is too long.\n");
psg_abort(1);
}
if (!newtransamp)
{
fprintf(stdout, "TOCSY requires linear amplifiers on transmitter.\n");
fprintf(stdout, "Use DECTOCSY with the appropriate re-cabling,\n");
psg_abort(1);
}
if ((p1 == 0.0) && (ix == 1))
fprintf(stdout, "Warning: P1 has a zero value.\n");
if ((rof1 < 9.9e-6) && (ix == 1))
fprintf(stdout,"Warning: ROF1 is less than 10 us\n");
if (satpwr > 40)
{
printf("satpwr too large - acquisition aborted./n");
psg_abort(1);
}
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
hlv(ct, v13);
mod2(ct, v1);
hlv(ct, v2);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
hlv(v12, v13);
mod2(v12, v1);
hlv(v12, v2);
endif(ssctr);
/* CALCULATE PHASES */
/* A 2-step cycle is performed on the first pulse (90 degrees) to suppress
axial peaks in the first instance. Second, the 2-step F2 quadrature image
suppression subcycle is added to all pulse phases and receiver phase.
Finally, a 2-step cycle is performed on the spin-lock pulses. */
mod2(v13, v13);
dbl(v1, v1);
incr(v1);
hlv(v2, v2);
mod2(v2, v2);
dbl(v2, v2);
incr(v2);
add(v13, v2, v2);
sub(v2, one, v3);
add(two, v2, v4);
add(two, v3, v5);
add(v1, v13, v1);
assign(v1, oph);
if (phase1 == 2)
incr(v1);
if (phase1 == 3)
add(v1, id2, v1);
/*HYPERCOMPLEX MODE USES REDFIELD TRICK TO MOVE AXIAL PEAKS TO EDGE*/
if ((phase1==1)||(phase1==2))
{
initval(2.0*(double)(d2_index%2),v6);
add(v1,v6,v1); add(oph,v6,oph);
}
/* CALCULATE AND INITIALIZE LOOP COUNTER */
if (pw > 0.0)
{
cycles = (mix - trim) / (64.66*pw+32*window);
cycles = 2.0*(double) (int) (cycles/2.0);
}
else
{
cycles = 0.0;
}
initval(cycles, v9); /* V9 is the MIX loop count */
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
obspower(p1lvl);
if (sspul[0] == 'y')
{
rgpulse(1000*1e-6, zero, rof1, 0.0e-6);
rgpulse(1000*1e-6, one, 0.0e-6, rof1);
}
hsdelay(d1);
if (satmode[A] == 'y')
{ obspower(satpwr);
rgpulse(satdly,zero,rof1,rof2);
obspower(p1lvl);}
status(B);
rgpulse(p1, v1, rof1, 1.0e-6);
if (satmode[B] =='y')
{
if (d2 > 0.0)
{
obspower(satpwr);
rgpulse(d2 - (2*POWER_DELAY) - 1.0e-6 - (2*p1/3.1416),zero,0.0,0.0);
}
}
else
{
if (d2 > 0.0)
delay(d2 - POWER_DELAY - 1.0e-6 - (2*p1/3.1416));
}
rcvroff();
obsunblank();
obspower(tpwr);
txphase(v3);
xmtron();
delay(trim);
if (cycles > 1.0)
{
starthardloop(v9);
mleva(window); mleva(window); mlevb(window); mlevb(window);
mlevb(window); mleva(window); mleva(window); mlevb(window);
mlevb(window); mlevb(window); mleva(window); mleva(window);
mleva(window); mlevb(window); mlevb(window); mleva(window);
rgpulse(.66*pw,v3,rof1,rof2);
endhardloop();
}
txphase(v13);
xmtroff();
/* detection */
delay(rof2);
rcvron();
obsblank();
status(C);
}
void pulsesequence()
{
double Dtau,Ddelta,dosytimecubed,dosyfrq,delcor,
del = getval("del"),
gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
satfrq = getval("satfrq");
char delflag[MAXSTR],sspul[MAXSTR],
alt_grd[MAXSTR],satmode[MAXSTR],lkgate_flg[MAXSTR];
getstr("delflag",delflag);
getstr("satmode",satmode);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
/* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */
if (del < (4*pw+3.0*rof1+gt1+2.0*gstab))
{ abort_message("Dbppste error: 'del' is less than %g, too short!",
(4.0*pw+3*rof1+gt1+2.0*gstab));
}
Ddelta=gt1;
Dtau=2.0*pw+rof1+gstab+gt1/2.0;
dosyfrq = sfrq;
dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* Check for the validity of the number of transients selected !
if ( (nt != 4) && ((int)nt%16 != 0) )
{ abort_message("Dbppste error: nt must be 4, 16, 64 or n*16 (n: integer)!");
} */
/* phase cycling calculation */
mod2(ct,v1); dbl(v1,v1); hlv(ct,v2);
mod2(v2,v3); dbl(v3,v3); hlv(v2,v2);
mod2(v2,v4); add(v1,v4,v1); /* v1 */
hlv(v2,v2); add(v2,v3,v4); /* v4 */
hlv(v2,v2); mod2(v2,v3); dbl(v3,v5);
hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */
hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */
hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/
add(two,oph,oph);
mod2(ct,v10); /* gradients change sign at odd transients */
if (ni > 1.0)
{ abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
/* equilibrium period */
status(A);
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0) delay(d1 - satdly);
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(satdly,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
delay(1.0e-5);
}
else
{ delay(d1); }
if (getflag("wet"))
wet4(zero,one);
status(B);
/* first part of bppdel sequence */
if (delflag[0]=='y')
{ if (gt1>0 && gzlvl1>0)
{ rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */
delcor = del-4.0*pw-3.0*rof1-gt1-2.0*gstab;
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(delcor,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(delcor); /*diffusion delay */
rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab+2*pw/PI);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
}
else
rgpulse(pw,oph,rof1,rof2);
/* --- observe period --- */
status(C);
}
void pulsesequence()
{
double base,
corr,
presat,
qlvl;
char sspul[MAXSTR];
/* LOAD VARIABLES AND CHECK CONDITIONS */
presat = getval("presat");
qlvl = getval("qlvl");
getstr("sspul", sspul);
base = 180.0 / qlvl;
initval(2.0 * qlvl, v5);
if ((rof1 < 9.9e-6) && (ix == 1))
fprintf(stdout,"Warning: ROF1 is less than 10 us\n");
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
modn(ct, v5, v10);
divn(ct, v5, v12);
mod2(ct, v9);
elsenz(ssctr);
sub(ssval, ssctr, v14); /* v14 = 0,...,ss-1 */
modn(v14, v5, v10);
divn(v14, v5, v12);
mod2(v14, v9);
endif(ssctr);
/* CALCULATE PHASECYCLE */
/* The phasecycle first performs a (2*Q)-step cycle on the third pulse in order
to select for MQC. The phasecycle is then adjusted so that the receiver
goes +- in an alternating fashion. Second, the 2-step QIS cycle is added
in. Third, a 2-step cycle for axial peak suppression is performed on the
first pulse. */
assign(v12, v1);
mod2(v12, v12); /* v12=quad. image suppression */
hlv(v1, v1);
mod2(v1, v1);
dbl(v1, v1);
add(v1, v12, v4);
add(v12, v1, v1);
assign(v12, v2);
assign(v12, v3);
dbl(v9, v9);
add(v9, v4, v4);
assign(v4, oph);
if (phase1 == 2)
incr(v1);
if (phase1 == 3) /* TPPI */
add(id2, v1, v1);
/* FAD added for phase=1 or phase=2 */
if ((phase1 == 1) || (phase1 == 2))
{
initval(2.0*(double)(d2_index%2),v13);
add(v1,v13,v1); add(oph,v13,oph);
}
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
if (newtrans)
obsstepsize(base);
status(A);
if (sspul[0] == 'y')
{
hsdelay(hst + 0.001);
rgpulse(pw, v1, 1.0e-6, 1.0e-6);
hsdelay(hst + 0.001);
}
if ((d1 - presat) <= hst)
{
rcvroff();
decon();
hsdelay(presat);
decoff();
delay(1.0e-6);
rcvron();
}
else
{
hsdelay(d1 - presat);
decon();
rcvroff();
delay(presat);
decoff();
delay(1.0e-6);
rcvron();
}
status(B);
if (newtrans)
xmtrphase(v10); /* hardware digital phaseshift */
rgpulse(pw, v1, rof1, 1.0e-6);
corr = 1.0e-6 + rof1 + 4.0*pw/3.1416;
if (d2 > corr)
delay(d2-corr);
rgpulse(pw, v2, rof1, 0.0);
if (newtrans)
{
xmtrphase(zero); /* resets relative phase to absolute phase */
}
else
{
phaseshift(-base, v10, OBSch); /* software small-angle phaseshift */
}
rgpulse(pw, v3, 1.0e-6, rof2);
status(C);
}
pulsesequence()
{
double j1min = getval("j1min"),
j1max = getval("j1max"),
pwxlvl180 = getval("pwxlvl180"),
pwx180 = getval("pwx180"),
gzlvl0 = getval("gzlvl0"),
gt0 = getval("gt0"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
grad1,
grad2,
tau,
tauA,
tauB,
taumb;
char pwx180ad[MAXSTR];
int icosel,
prgcycle = (int)(getval("prgcycle")+0.5),
phase1 = (int)(getval("phase")+0.5);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",1.0);
gzlvlE = syncGradLvl("gtE","gzlvlE",1.0);
getstr("pwx180ad", pwx180ad);
grad1 = gzlvlE;
grad2 = -1.0*gzlvlE*(EDratio-1)/(EDratio+1);
tauA = 1/(2*(j1min + 0.146*(j1max - j1min)));
tauB = 1/(2*(j1max - 0.146*(j1max - j1min)));
taumb = 1 / (2 * (getval("jnxh")));
tau = 1 / (j1min+j1max);
icosel = 1;
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
settable(t1, 1, ph1);
settable(t2, 1, ph2);
settable(t3, 2, ph3);
settable(t4, 1, ph4);
settable(t5, 4, ph5);
settable(t6, 4, ph6);
getelem(t1, v17,v1);
getelem(t2, v17,v2);
getelem(t3, v17, v3);
getelem(t4, v17, v4);
getelem(t5, v17, v5);
getelem(t6, v17, oph);
add(oph,v18,oph);
add(oph,v19,oph);
/*
mod2(id2, v10);
dbl(v10,v10);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10);
add(v3, v10, v3);
add(oph, v10, oph);
if ((phase1 == 2) || (phase1 == 5))
{
icosel = -1;
grad1 = gzlvlE*(EDratio-1)/(EDratio+1);
grad2 = -1.0*gzlvlE;
}
status(A);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,zero);
if (getflag("prgflg"))
shaped_purge(v1,zero,v18,v19);
}
else
{
satpulse(satdly,zero,rof1,rof1);
if (getflag("prgflg"))
purge(v1,zero,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
decpower(pwxlvl);
status(B);
rgpulse(pw, v1, rof1, rof2);
/* Start of J filter */
if (getflag("jfilter"))
{
zgradpulse(gzlvl0/2,gt0);
delay(tauA - gt0);
decrgpulse(pwx, zero, rof1, rof1);
zgradpulse(-gzlvl0/3,gt0);
delay(tauB - gt0);
decrgpulse(pwx, zero, rof1, rof1);
zgradpulse(-gzlvl0/6,gt0);
delay(gstab);
}
/* End of J filter */
delay(taumb);
decrgpulse(pwx, v3, rof1, rof1);
delay(d2 / 2.0);
rgpulse(2 * pw, v4, rof1, rof1);
delay(d2 / 2.0);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
delay(2 * pw + 2*POWER_DELAY + 4 * rof1 + (4 * pwx / 3.1416));
zgradpulse(icosel * grad1, gtE);
delay(gstab);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
zgradpulse(icosel * grad2, gtE);
decpower(pwxlvl);
delay(gstab);
decrgpulse(pwx, v5, rof1, rof2);
decpower(dpwr);
status(C);
}
// Return value of constant
dbl FreshEval_d(std::shared_ptr<Variable> const& diff_variable) const override
{
return dbl(highest_precision_value_);
}
void pulsesequence()
{
double mixN = getval("mixN"),
gzlvlC = getval("gzlvlC"),
gtC = getval("gtC"),
gstab = getval("gstab"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
selfrq = getval("selfrq"),
zqfpw3 = getval("zqfpw3"),
zqfpwr3 = getval("zqfpwr3"),
gzlvlzq3 = getval("gzlvlzq3"),
mixNcorr,
sweeppw = getval("sweeppw"),
sweeppwr = getval("sweeppwr");
char sweepshp[MAXSTR],
selshapeA[MAXSTR],
selshapeB[MAXSTR],
zqfpat3[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtC = syncGradTime("gtC","gzlvlC",1.0);
gzlvlC = syncGradLvl("gtC","gzlvlC",1.0);
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("sweepshp",sweepshp);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat3",zqfpat3);
mixNcorr=0.0;
if (getflag("Gzqfilt"))
mixNcorr=getval("zqfpw3");
hlv(ct,v1); hlv(v1,v1); hlv(v1,v1); hlv(v1,v1); mod4(v1,v1);
mod4(ct,v2); add(v1,v2,v2);
hlv(ct,v3); hlv(v3,v3); mod4(v3,v3); add(v1,v3,v3); dbl(v3,v4);
dbl(v2,oph); add(oph,v4,oph); add(oph,v1,oph);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr);
delay(5.0e-5);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
satpulse(satdly,zero,rof1,rof1);
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
if (selfrq != tof)
obsoffset(selfrq);
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v2,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlA,gtA);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v3,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
rgpulse(pw,v1,rof1,rof1);
obspower(sweeppwr);
delay(0.31*mixN);
zgradpulse(gzlvlC,gtC);
delay(gstab);
shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1);
delay(gstab);
zgradpulse(-gzlvlC,gtC);
delay(0.49*mixN);
zgradpulse(-gzlvlC,2*gtC);
delay(gstab);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr3);
rgradient('z',gzlvlzq3);
delay(100.0e-6);
shaped_pulse(zqfpat3,zqfpw3,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
}
else
shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1);
delay(gstab);
zgradpulse(gzlvlC,2*gtC);
delay(0.2*mixN);
obspower(tpwr);
rgpulse(pw,v1,rof1,rof2);
status(C);
}
void FreshEval_d(dbl& evaluation_value, std::shared_ptr<Variable> const& diff_variable) const override
{
evaluation_value = dbl(highest_precision_value_);
}
pulsesequence()
{
int i,
relay;
double tau;
/* GET NEW PARAMETERS */
relay = (int) (getval("relay") + 0.5);
tau = getval("tau");
/* CHECK CONDITIONS */
if (p1 == 0.0)
p1 = pw;
/* CALCULATE PHASES */
sub(ct, ssctr, v11); /* v11 = ct-ss */
initval(256.0, v12);
add(v11, v12, v11); /* v11 = ct-ss+256 */
hlv(v11, v1); /* v1 = cyclops = 00112233 */
for (i = 0; i < relay + 1; i++)
hlv(v1, v1); /* cyclops = 2**(relay+2) 0's, 1's, 2's,
3's */
mod4(v11, v2); /* v2 = 0123 0123... */
dbl(v2, oph); /* oph = 0202 0202 */
add(v2, v1, v2); /* v2 = 0123 0123 + cyclops */
add(oph, v1, oph); /* oph = 0202 0202 + cyclops */
hlv(v11, v3); /* v3 = 0011 2233 4455 ... */
/* PULSE SEQUENCE */
status(A);
if (rof1 == 0.0)
{
rof1 = 1.0e-6; /* phase switching time */
rcvroff();
}
hsdelay(d1); /* preparation period */
status(B);
rgpulse(pw, v1, rof1, rof1);
delay(d2); /* evolution period */
status(A);
if (relay == 0)
delay(tau); /* for delayed cosy */
rgpulse(p1, v2, rof1, rof1); /* start of mixing period */
if (relay == 0)
delay(tau); /* for delayed cosy */
for (i = 0; i < relay; i++) /* relay coherence */
{
hlv(v3, v3); /* v3=2**(relay+1) 0's, 1's, 2's, 3's */
dbl(v3, v4); /* v4=2**(relay+1) 0's, 2's, 0's, 2's */
add(v2, v4, v5); /* v5=v4+v2 (including cyclops) */
delay(tau/2);
rgpulse(2.0*pw, v2, rof1, rof1);
delay(tau/2);
rgpulse(pw, v5, rof1, rof1);
}
status(C);
delay(rof2);
rcvron();
}
void FreshEval_d(dbl& evaluation_value, std::shared_ptr<Variable> const& diff_variable) const override
{
evaluation_value = dbl(double(true_value_real_),double(true_value_imag_));
}
pulsesequence()
{
double mixN = getval("mixN"),
gzlvlC = getval("gzlvlC"),
gtC = getval("gtC"),
gstab = getval("gstab"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
selfrq = getval("selfrq"),
zqfpw3 = getval("zqfpw3"),
zqfpwr3 = getval("zqfpwr3"),
gzlvlzq3 = getval("gzlvlzq3"),
mixNcorr,
sweeppw = getval("sweeppw"),
sweeppwr = getval("sweeppwr");
char sweepshp[MAXSTR],
selshapeA[MAXSTR],
selshapeB[MAXSTR],
zqfpat3[MAXSTR];
int prgcycle=(int)(getval("prgcycle")+0.5);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtC = syncGradTime("gtC","gzlvlC",1.0);
gzlvlC = syncGradLvl("gtC","gzlvlC",1.0);
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("sweepshp",sweepshp);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat3",zqfpat3);
mixNcorr=0.0;
if (getflag("Gzqfilt"))
mixNcorr=getval("zqfpw3");
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
assign(zero,v16);
if (getflag("STEP"))
{
mod2(v17,v16);
hlv(v17,v17);
}
hlv(v17,v1); hlv(v1,v1); hlv(v1,v1); hlv(v1,v1); mod4(v1,v1);
mod4(v17,v2); add(v1,v2,v2);
hlv(v17,v3); hlv(v3,v3); mod4(v3,v3); add(v1,v3,v3); dbl(v3,v4);
dbl(v2,oph); add(oph,v4,oph); add(oph,v1,oph);
if (!getflag("NOE"))
assign(v1,oph);
/* if prgflg='n' the next two steps are non-events */
add(oph,v18,oph);
add(oph,v19,oph);
/* if STEP='n', the next two steps are non-events */
add(oph,v16,oph);
add(oph,v16,oph);
add(v1,v16,v16); /*v16 is the phase of first echo pulse in steptrain */
/* example: v1=0,0,2,2 v16=0,1,2,3 oph=0,2,2,0 - if STEP='y'*/
/* v1=0,2 v16=0 oph=0,2 - if STEP='n' */
if (getflag("prgflg") && (satmode[0] == 'y'))
assign(v1,v6);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,v6);
if (getflag("prgflg"))
shaped_purge(v1,v6,v18,v19);
}
else
{
satpulse(satdly,v6,rof1,rof1);
if (getflag("prgflg"))
purge(v1,v6,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
rgpulse(pw,v1,rof1,rof2);
if (getflag("STEP"))
steptrain(v1,v16);
if (getflag("NOE"))
{
if (selfrq != tof)
obsoffset(selfrq);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v2,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlA,gtA);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v3,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
rgpulse(pw,v1,rof1,rof1);
obspower(sweeppwr);
delay(0.31*mixN);
zgradpulse(gzlvlC,gtC);
delay(gstab);
shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1);
delay(gstab);
zgradpulse(-gzlvlC,gtC);
delay(0.49*mixN);
zgradpulse(-gzlvlC,2*gtC);
delay(gstab);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr3);
rgradient('z',gzlvlzq3);
delay(100.0e-6);
shaped_pulse(zqfpat3,zqfpw3,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
}
else
shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1);
delay(gstab);
zgradpulse(gzlvlC,2*gtC);
delay(0.2*mixN);
obspower(tpwr);
rgpulse(pw,v1,rof1,rof2);
}
status(C);
}
void pulsesequence()
{
char sspul[MAXSTR];
/* LOAD VARIABLES AND CHECK CONDITIONS */
getstr("sspul", sspul);
if (satpwr > 40)
{
printf("satpwr too large - acquisition aborted./n");
psg_abort(1);
}
if ((rof1 < 9.9e-6) && (ix== 1))
fprintf(stdout,"Warning: ROF1 is less than 10 us\n");
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
hlv(ct, v4);
mod4(ct, v3);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
hlv(v12, v4);
mod4(v12, v3);
endif(ssctr);
/* CALCULATE PHASECYCLE */
/* The phasecycle first performs a 4-step cycle on the third pulse in order
to select for DQC. Second, the 2-step QIS cycle is added in. Third, a
2-step cycle for axial peak suppression is performed on the second pulse.
Fourth, a 2-step cycle for axial peak suppression is performed on the
first pulse. If P-type peaks only are being selected, the 2-step cycle
for P-type peak selection is performed on the first pulse immediately
after the 4-step cycle on the third pulse. */
hlv(v4, v4);
if (phase1 == 0)
{
assign(v4, v6);
hlv(v4, v4);
mod2(v6, v6); /* v6 = P-type peak selection in w1 */
}
hlv(v4, v2);
mod4(v4, v4); /* v4 = quadrature image suppression */
hlv(v2, v1);
mod2(v1, v1);
dbl(v1, v1);
mod2(v2, v2);
dbl(v2, v2);
dbl(v3, v5);
add(v3, v5, v5);
add(v1, v5, v5);
add(v2, v5, v5);
add(v4, v5, v5);
add(v4, v1, v1);
add(v4, v2, v2);
add(v4, v3, v3);
if (phase1 == 0)
{
add(v6, v1, v1);
add(v6, v5, v5);
}
if (phase1 == 2)
incr(v1);
if (phase1 == 3)
add(id2, v1, v1); /* adds TPPI increment to the phase of the
* first pulse */
assign(v5, oph);
/* FOR HYPERCOMPLEX, USE REDFIED TRICK TO MOVE AXIALS TO EDGE */
if ((phase1==2)||(phase1==1))
{
initval(2.0*(double)(d2_index%2),v9); /* moves axials */
add(v1,v9,v1);
add(oph,v9,oph);
}
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
if (sspul[0] == 'y')
{
rgpulse(200*pw, one, 10.0e-6, 0.0e-6);
rgpulse(200*pw, zero, 0.0e-6, 1.0e-6);
}
hsdelay(d1);
if (satmode[A] == 'y')
{
obspower(satpwr);
rgpulse(satdly,zero,rof1,rof2);
obspower(tpwr);
}
status(B);
rgpulse(pw, v1, rof1, 1.0e-6);
if (satmode[B] == 'y')
{
obspower(satpwr);
if (d2>100.0e-6)
rgpulse(d2-(2*POWER_DELAY)-1.0e-6-rof1-(4*pw)/3.14159,zero,0.0,0.0);
obspower(tpwr);
}
else if (d2>0.0)
{
delay(d2 - rof1 - 1.0e-6 -(4*pw)/3.1416);
}
rgpulse(pw, v2, rof1, 0.0);
rgpulse(pw, v3, 1.0e-6, rof2);
status(C);
}
pulsesequence()
{
int prgcycle = (int)(getval("prgcycle")+0.5);
double cmult = getval("cmult");
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
assign(zero,v4);
settable(t1,8,ph1);
settable(t2,8,ph2);
settable(t3,8,ph3);
getelem(t1,v17,v1);
getelem(t2,v17,v2);
getelem(t3,v17,oph);
if (getflag("prgflg") && (satmode[0] == 'y'))
assign(v1,v4);
add(oph,v18,oph);
add(oph,v19,oph);
/*
mod2(id2,v10);
dbl(v10,v10);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10);
add(v1,v10,v1);
add(v4,v10,v4);
add(oph,v10,oph);
status(A);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,v4);
if (getflag("prgflg"))
shaped_purge(v1,v4,v18,v19);
}
else
{
satpulse(satdly,v4,rof1,rof1);
if (getflag("prgflg"))
purge(v1,v4,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
rgpulse(pw, v1, rof1, rof1);
delay(d2);
rgpulse(cmult*pw, v2, rof1, rof2);
status(C);
}
pulsesequence()
{
double gtE = getval("gtE"),
gzlvlE=getval("gzlvlE"),
selpwrPS = getval("selpwrPS"),
selpwPS = getval("selpwPS"),
gzlvlPS = getval("gzlvlPS"),
droppts=getval("droppts"),
gstab = getval("gstab");
int prgcycle=(int)(getval("prgcycle")+0.5);
char selshapePS[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",1.0);
gzlvlE = syncGradLvl("gtE","gzlvlE",1.0);
getstr("selshapePS",selshapePS);
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
settable(t1,4,ph1);
settable(t2,32,ph2);
settable(t3,8,ph3);
settable(t4,16,ph4);
getelem(t1,v17,v1);
getelem(t2,v17,v2);
getelem(t3,v17,v3);
getelem(t4,v17,v4);
assign(v4,oph);
assign(v1,v6);
add(oph,v18,oph);
add(oph,v19,oph);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,v6);
if (getflag("prgflg"))
shaped_purge(v1,v6,v18,v19);
}
else
{
satpulse(satdly,v6,rof1,rof1);
if (getflag("prgflg"))
purge(v1,v6,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
obspower(tpwr);
rgpulse(pw, v1, rof1, rof2);
delay(d2/2.0);
delay((0.25/sw1) - gtE - gstab - 2*pw/PI - rof2 - 2*GRADIENT_DELAY);
zgradpulse(gzlvlE,gtE);
delay(gstab);
rgpulse(2*pw,v2,rof1,rof1);
delay(0.25/sw1);
delay(gstab);
zgradpulse(-1.0*gzlvlE,gtE);
delay(gstab);
obspower(selpwrPS);
rgradient('z',gzlvlPS);
shaped_pulse(selshapePS,selpwPS,v3,rof1,rof1);
rgradient('z',0.0);
obspower(tpwr);
delay(gstab);
zgradpulse(-2.0*gzlvlE,gtE);
delay(gstab - droppts/sw);
delay(d2/2.0);
status(C);
}
pulsesequence()
{
double del = getval("del"),
gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
prgtime = getval("prgtime"),
prgpwr = getval("prgpwr"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
d3 = getval("d3"),
Dtau,Ddelta,dosytimecubed, dosyfrq;
char delflag[MAXSTR],satmode[MAXSTR],prg_flg[MAXSTR],alt_grd[MAXSTR],
sspul[MAXSTR],lkgate_flg[MAXSTR];
getstr("delflag",delflag);
getstr("satmode",satmode);
getstr("prg_flg",prg_flg);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
gt2 = syncGradTime("gt2","gzlvl2",1.0);
gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0);
/* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */
if (del < (4*pw+3.0*rof1+gt1+2.0*gstab))
{ abort_message("Dbppste error: 'del' is less than %g, too short!",
(4.0*pw+3*rof1+gt1+2.0*gstab));
}
Ddelta=gt1;
Dtau=2.0*pw+rof1+gstab+gt1/2.0;
dosyfrq = sfrq;
dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* phase cycling calculation */
mod2(ct,v1); dbl(v1,v1); hlv(ct,v2);
mod2(v2,v3); dbl(v3,v3); hlv(v2,v2);
mod2(v2,v4); add(v1,v4,v1); /* v1 */
hlv(v2,v2); add(v2,v3,v4); /* v4 */
hlv(v2,v2); mod2(v2,v3); dbl(v3,v5);
hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */
hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */
hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/
add(v1,v3,v7); add(v4,v7,v7);
add(two,v7,v8);
mod2(ct,v10); /* gradients change sign at odd transients */
if (ni > 1.0)
{ abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
/* equilibrium period */
status(A);
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0)
delay(d1 - satdly);
obspower(satpwr);
txphase(zero);
rgpulse(satdly,zero,rof1,rof1);
obspower(tpwr);
}
else
delay(d1);
status(B);
/* first part of bppdel sequence */
if (delflag[0]=='y')
{ if (gt1>0 && gzlvl1>0)
{ rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */
if (satmode[1] == 'y')
{
obspower(satpwr);
rgpulse(del-4.0*pw-3.0*rof1-gt1-2.0*gstab,zero,rof1,rof1);
obspower(tpwr);
}
else
{
delay(del-4.0*pw-3.0*rof1-gt1-2.0*gstab);/*diffusion delay */
}
rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
if (prg_flg[0] == 'y')
{
add(one,v7,v9);
obspower(prgpwr);
rgpulse(prgtime, v9, rof1, rof1);
obspower(tpwr);
}
}
zgradpulse(gzlvl2,gt2);
delay(gstab);
rgpulse(pw*0.231,v7,rof1,rof1);
delay(d3);
rgpulse(pw*0.692,v7,rof1,rof1);
delay(d3);
rgpulse(pw*1.462,v7,rof1,rof1);
delay(d3);
rgpulse(pw*1.462,v8,rof1,rof1);
delay(d3);
rgpulse(pw*0.692,v8,rof1,rof1);
delay(d3);
rgpulse(pw*0.231,v8,rof1,rof1);
zgradpulse(gzlvl2,gt2);
delay(gstab);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on */
}
else
rgpulse(pw,oph,rof1,rof2);
/* --- observe period --- */
status(C);
}
pulsesequence()
{
double slpwrT = getval("slpwrT"),
slpwT = getval("slpwT"),
mixT = getval("mixT"),
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
gstab = getval("gstab"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
selfrq = getval("selfrq"),
zqfpw1 = getval("zqfpw1"),
zqfpwr1 = getval("zqfpwr1"),
zqfpw2 = getval("zqfpw2"),
zqfpwr2 = getval("zqfpwr2"),
gzlvlzq1 = getval("gzlvlzq1"),
gzlvlzq2 = getval("gzlvlzq2");
char slpatT[MAXSTR],
selshapeA[MAXSTR],
selshapeB[MAXSTR],
zqfpat1[MAXSTR],
zqfpat2[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("slpatT",slpatT);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat1",zqfpat1);
getstr("zqfpat2",zqfpat2);
if (strcmp(slpatT,"mlev17c") &&
strcmp(slpatT,"dipsi2") &&
strcmp(slpatT,"dipsi3") &&
strcmp(slpatT,"mlev17") &&
strcmp(slpatT,"mlev16"))
abort_message("SpinLock pattern %s not supported!.\n", slpatT);
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */
ifzero(ssctr);
assign(ct,v13);
elsenz(ssctr);
sub(ssval, ssctr, v13); /* v13 = 0,...,ss-1 */
endif(ssctr);
mod4(v13,v1); /* v1 = 0 1 2 3 */
hlv(v13,v13);
hlv(v13,v13);
mod4(v13,v11); /* v11 = 0000 1111 2222 3333 */
dbl(v1,oph);
add(v11,oph,oph);
add(v11,oph,oph); /* oph = 2v1 + 2v11 */
/* CYCLOPS */
hlv(v13,v13);
hlv(v13,v14);
add(v1,v14,v1);
add(v11,v14,v11);
add(oph,v14,oph);
assign(v14,v3);
add(one,v3,v3);
add(two,v3,v12);
sub(v3,one,v2);
add(v3,one,v4);
add(v3,two,v5);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
satpulse(satdly,v6,rof1,rof1);
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
rgpulse(pw, v14, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v1,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlA,gtA);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v11,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
rgpulse(pw, v14, rof1, rof1);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr1);
rgradient('z',gzlvlzq1);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,v14,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
}
obspower(slpwrT);
zgradpulse(gzlvl1,gt1);
delay(gstab);
if (mixT > 0.0)
{
if (dps_flag)
rgpulse(mixT,v3,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9);
}
if (getflag("Gzqfilt"))
{
obspower(zqfpwr2);
rgradient('z',gzlvlzq2);
delay(100.0e-6);
shaped_pulse(zqfpat2,zqfpw2,v14,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
}
obspower(tpwr);
zgradpulse(gzlvl2,gt2);
delay(gstab);
rgpulse(pw,v14,rof1,rof2);
status(C);
}
double ConfigIni::dbl(const string prop)
{
return dbl(prop, -1.);
}
pulsesequence()
{
char sspul[MAXSTR];
double pwClvl=getval("pwClvl");
/* LOAD VARIABLES AND CHECK CONDITIONS */
getstr("sspul", sspul);
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
hlv(ct, v4);
mod4(ct, v3);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
hlv(v12, v4);
mod4(v12, v3);
endif(ssctr);
/* CALCULATE PHASECYCLE */
/* The phasecycle first performs a 4-step cycle on the third pulse in order
to select for DQC. Second, the 2-step QIS cycle is added in. Third, a
2-step cycle for axial peak suppression is performed on the second pulse.
Fourth, a 2-step cycle for axial peak suppression is performed on the
first pulse. If P-type peaks only are being selected, the 2-step cycle
for P-type peak selection is performed on the first pulse immediately
after the 4-step cycle on the third pulse. */
hlv(v4, v4);
if (phase1 == 0)
{
assign(v4, v6);
hlv(v4, v4);
mod2(v6, v6); /* v6 = P-type peak selection in w1 */
}
hlv(v4, v2);
mod4(v4, v4); /* v4 = quadrature image suppression */
hlv(v2, v1);
mod2(v1, v1);
dbl(v1, v1);
mod2(v2, v2);
dbl(v2, v2);
dbl(v3, v5);
add(v3, v5, v5);
add(v1, v5, v5);
add(v2, v5, v5);
add(v4, v5, v5);
add(v4, v1, v1);
add(v4, v2, v2);
add(v4, v3, v3);
if (phase1 == 0)
{
add(v6, v1, v1);
add(v6, v5, v5);
}
if (phase1 == 2)
incr(v1);
if (phase1 == 3)
add(id2, v1, v1); /* adds TPPI increment to the phase of the
* first pulse */
assign(v5, oph);
/* FOR HYPERCOMPLEX, USE STATES-TPPI TO MOVE AXIALS TO EDGE */
if ((phase1==2)||(phase1==1))
{
initval(2.0*(double)(d2_index%2),v9); /* moves axials */
add(v1,v9,v1); add(oph,v9,oph);
}
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
if (sspul[0] == 'y')
{
obspower(pwClvl-12);
rgpulse(200*pw, one, 10.0e-6, 0.0e-6);
rgpulse(200*pw, zero, 0.0e-6, 1.0e-6);
obspower(pwClvl);
}
delay(d1);
status(B);
rgpulse(pw, v1, rof1, 1.0e-6);
if (d2>0.0)
delay(d2 - rof1 - 1.0e-6 -(4*pw)/3.1416);
rgpulse(pw, v2, rof1, 0.0);
rgpulse(pw, v3, 1.0e-6, rof2);
add(v3,one,v8);
delay(d3);
rgpulse(2.0*pw,v8,rof1,rof1);
delay(d3);
status(C);
}
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()
{
int phase1 = (int)(getval("phase")+0.5),
prgcycle=(int)(getval("prgcycle")+0.5);
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5))
{
hlv(ct,v17);
mod2(ct,v18); dbl(v18,v18);
if (prgcycle > 2.5)
{
hlv(v17,v17);
hlv(ct,v19); mod2(v19,v19); dbl(v19,v19);
}
}
/* CONSTANTS FOR PHASE CALCULATIONS */
initval( 8.0,v13);
initval( 32.0,v12);
initval( 20.0,v11);
initval( 192.0,v10);
/* CALCULATE PHASECYCLE */
assign(zero,v14); /* phase of first pulse */
mod2(v17,v1);
dbl(v1,v1); /* 0202 */
/* even/odd flag */
hlv(v17,v2);
hlv(v2,v3);
dbl(v3,v3); /* 0000222244446666 */
/* phase for transients 3 + 4*n */
/* 1+4*n = 0 */
mod2(v2,v2); /* 0011 */
/* switch for pairs */
assign(v13,v4); /* 8 */
ifzero(v2);
incr(v4);
elsenz(v2);
decr(v4);
endif(v2);
modn(v4,v13,v4); /* 1177 */
/* standard phases for even transients */
/* 1 for 2+4*n, 7 for 4*n */
hlv(v13,v8); /* 4 */
add(v17,v8,v5); /* (ct+4) */
divn(v5,v12,v5); /* (ct+4)/32 */
divn(v17,v12,v6); /* ct/32 */
sub(v5,v6,v5); /* ((ct+4)/32-ct/32 */
/* 00000000 00000000 00000000 00001111 */
add(v17,v11,v6); /* (ct+20) */
divn(v6,v10,v6); /* (ct+20)/192 */
sub(v11,v7,v7); /* 16 */
add(v17,v7,v7); /* (ct+16) */
divn(v7,v10,v7); /* (ct+16)/192 */
add(v5,v6,v5);
sub(v5,v7,v5); /* ((ct+4)/32-ct/32)+((ct+20)/192-(ct+16)/192) */
/* flag for exceptions on even transients */
dbl(v2,v6); /* 0022 */
add(v6,three,v6); /* 3355 */
ifzero(v1); /* for odd transients */
ifzero(v2); /* 1+4n: */
assign(zero,v3); /* 0xxx 0xxx 0xxx 0xxx */
endif(v2); /* 3+4n: xx0x xx2x xx4x xx6x */
elsenz(v1); /* for even transients */
ifzero(v5); /* normal case: */
assign(v4,v3); /* x1x7 */
elsenz(v5); /* exceptions: */
assign(v6,v3); /* x3x5 */
endif(v5); /* v3 = phase of first and second pulse */
/* in 45 degrees steps: */
/* 01070127 01470167 01070127 01470365 */
/* 01070127 01470167 01070127 01470365 */
/* 01070127 01470167 01070127 01470365 */
/* 01070127 01470167 01070127 01470365 */
/* 01070127 01470167 01070127 01470365 */
/* 01070127 01470365 01070127 01470365 */
endif(v1);
assign(two,v4); /* v4 = phase of last 90 degrees pulse */
assign(v1,oph); /* oph = 0202 */
assign(zero,v20);
if (getflag("prgflg") && (satmode[0] == 'y'))
assign(v14,v20);
add(oph,v18,oph);
add(oph,v19,oph);
if (phase1 == 2)
incr(v14); /* States - Habercorn */
/*
mod2(id2,v9);
dbl(v9,v9);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v9);
add(v14,v9,v14);
add(oph,v9,oph);
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
obsstepsize(45.0);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (satmode[0] == 'y')
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
if (getflag("prgflg"))
xmtrphase(v3);
shaped_satpulse("relaxD",satdly,v20);
if (getflag("prgflg"))
{
shaped_purge(v14,v20,v18,v19);
xmtrphase(zero);
}
}
else
{
if (getflag("prgflg"))
xmtrphase(v3);
satpulse(satdly,v20,rof1,rof1);
if (getflag("prgflg"))
{
purge(v14,v20,v18,v19);
xmtrphase(zero);
}
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
xmtrphase(v3);
rgpulse(pw, v14, rof1, 2.0e-6);
if (d2 > 0.0)
delay(d2 - (4.0*pw/PI) - 4.0e-6);
else
delay(d2);
rgpulse(pw, zero, 2.0e-6, rof1);
xmtrphase(zero);
rgpulse(pw, v4, rof1, rof2);
status(C);
}
pulsesequence()
{
char normal[MAXSTR],
focus[MAXSTR];
double spp, spplvl, pp, mult, j, d3;
double gt, gzlvl;
/* GATHER AND INTIALIZE */
getstr("focus", focus);
getstr("normal", normal);
spp = getval("spp");
spplvl = getval("spplvl");
pp = getval("pp");
mult = getval("mult");
j = getval("j");
gt = getval("gt");
gzlvl = getval("gzlvl");
/* calculate phases */
mod2(ct,v1); /* v1 = 01010101 */
dbl(v1,v1); /* v1 = 0 2 */
hlv(ct,v2);
mod2(v2,v2); /* v2 = 0 0 1 1 */
add(v1,v2,oph); /* oph = 0 2 1 3 */
/* if mult is zero, then do normal s2pul sequence */
if (mult == 0.0)
{
status(A);
hsdelay(d1);
pulse(p1, zero);
status(B);
delay(d2);
status(C);
pulse(pw,oph);
}
else /* this is the INEPT part of the sequence */
{
if (j != 0.0)
{ /* calculation of delays */
d3 = 1.0 / (2.0 * j);
if (mult < 2.5)
{
d2 = 1.0 / (2.0 * j);
}
else if (mult < 3.5)
{
d2 = 3.0 / (4.0 * j);
}
else
{
d2 = 1.0 / (3.0 * j);
}
}
else
d3 = getval("d3");
/* do equilibration delay */
if ((dm[A] == 'y') || (dm[B] == 'y'))
{
(void) printf("Decoupler must be set as dm=nny or n\n");
psg_abort(1);
}
if (declvlonoff)
declvlon(); /* use pplvl for pulse */
else
decpower(pplvl);
dec_pw_ovr(FALSE);
status(A);
delay(d1);
/* excitation transfer */
status(B);
decrgpulse(pp, v1, rof1, rof1);
decpower(spplvl);
dec_pw_ovr(TRUE);
delay(d3/2 - 2.0*(gt + spp + 1.0e-4));
/*nominal 1/(4j) corrected for H1 & gradient pulses */
zgradpulse(gzlvl,gt);
delay(1.0e-4);
simpulse(2*pw, 2*spp, zero, zero, rof1, rof1);
delay(1.0e-4);
zgradpulse(gzlvl,2.0*gt);
delay(1.0e-4);
simpulse(2.0*pw, 2.0*spp, zero, two, rof1, rof1);
zgradpulse(gzlvl,gt);
delay(1.0e-4);
decpower(pplvl);
dec_pw_ovr(FALSE);
delay(d3/2 - 2.0*(gt + spp + 1.0e-4));
simpulse(pw, pp, v2, one, 0.0, 0.0);
/* make decision on refocussing */
if ((focus[A] == 'y') || (dm[C] == 'y'))
{
decpower(spplvl);
dec_pw_ovr(TRUE);
delay(d2/2 - rof1 -spp); /* refocussing delay varied for 2d */
simpulse(2*pw, 2*spp, v2, zero, rof1, rof1);
delay(d2/2 - rof1 - spp);
}
else if (normal[A] == 'y')
{
decrgpulse(pp, v1, 1.0e-6, 0.0);
}
if (declvlonoff)
declvloff();
else
decpower(dpwr);
status(C);
}
}
