void pulsesequence()
{
/* DECLARE & READ IN NEW PARAMETERS */
char compshape[MAXSTR];
getstr("compshape",compshape); /* Composit pulse shape */
loadtable("lc1d"); /* Phase table */
/* PULSE SEQUENCE */
status(A);
hsdelay(d1);
status(B);
if (getflag("wet")) wet4(t1,t2);
status(C);
if (getflag("composit"))
{
if (rfwg[OBSch-1] == 'y')
shaped_pulse(compshape,4.0*pw+0.8e-6,t3,rof1,rof2);
else
composite_pulse(pw,t3,rof1,rof2,v1);
}
else
rgpulse(pw,t3,rof1,rof2);
setreceiver(t4);
}
void pulsesequence()
{
double jc13,jtau;
jc13 = getval("jc13");
jtau = 1.0 / (2.0 * jc13);
mod4(ct, v1); /* v1 = 0 1 2 3 */
dbl(v1, v10); /* v10 = 0 2 0 2 */
hlv(ct, v2);
hlv(v2, v2);
mod4(v2, v2); /* v2 = 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 */
add(v2, v1, v1);
assign(v2, oph);
add(v10, oph, oph);
status(A);
hsdelay(d1);
if (getflag("wet")) wet4(zero,one);
status(C);
rgpulse(pw, v2, rof1, rof2);
jtau -= pw + rof2;
delay(jtau - rof1);
simpulse(2*pw, pwx, v1, zero, rof1, rof2);
delay(jtau);
status(C);
}
pulsesequence()
{
double gzlvl1,
gt1,
gstab,
hsglvl,
hsgt;
char sspul[MAXSTR];
gzlvl1 = getval("gzlvl1");
gt1 = getval("gt1");
gstab = getval("gstab");
hsglvl = getval("hsglvl");
hsgt = getval("hsgt");
getstr("sspul",sspul);
settable(t1,4,ph1);
settable(t2,4,ph2);
settable(t3,4,ph3);
getelem(t1,ct,v1);
getelem(t2,ct,v2);
getelem(t3,ct,oph);
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10);
add(v1,v10,v1);
add(oph,v10,oph);
status(A);
delay(5.0e-5);
if (sspul[0] == 'y')
{
zgradpulse(hsglvl,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(hsglvl,hsgt);
}
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
rgpulse(pw, v1, rof1, rof1);
delay(d2);
zgradpulse(gzlvl1,gt1);
delay(gstab);
rgpulse(pw, v2, rof1, rof2);
zgradpulse(gzlvl1,gt1);
delay(gstab);
status(C);
}
pulsesequence()
{
double cmult = getval("cmult");
settable(t1,8,ph1);
settable(t2,8,ph2);
settable(t3,8,ph3);
getelem(t1,ct,v1);
getelem(t2,ct,v2);
getelem(t3,ct,oph);
/*
mod2(id2,v10);
dbl(v10,v10);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10);
add(v1,v10,v1);
add(oph,v10,oph);
assign(v1,v4);
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);
satpulse(satdly,v4,rof1,rof1);
}
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);
}
void pulsesequence()
{
char compshape[MAXSTR],
sspul[MAXSTR],
wet[MAXSTR],
composit[MAXSTR];
getstr("compshape",compshape);
getstr("composit",composit);
getstr("sspul",sspul);
getstr("wet",wet);
settable(t1,4,phs1);
settable(t2,8,phs2);
getelem(t1,ct,oph);
getelem(t2,ct,v2);
assign(oph,v1);
/* equilibrium period */
status(A);
delay(5.0e-5);
if (sspul[0] == 'y')
steadystate();
delay(d1);
if (wet[0] == 'y')
wet4(zero,one);
status(B);
pulse(p1,zero);
hsdelay(d2);
if (composit[0] == 'y')
{
if (rfwg[OBSch-1] == 'y')
shaped_pulse(compshape,4.0*pw+0.8e-6,v1,rof1,rof2);
else
comp90pulse(pw,v1,rof1,rof2);
}
else
rgpulse(pw,v1,rof1,rof2);
status(C);
}
void pulsesequence()
{
double j1min = getval("j1min"),
j1max = getval("j1max"),
gzlvl0 = getval("gzlvl0"),
gt0 = getval("gt0"),
tau,
tauA,
tauB,
taumb;
int phase1 = (int)(getval("phase")+0.5);
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);
settable(t1,1,ph1);
settable(t2,2,ph2);
settable(t3,4,ph3);
settable(t4,1,ph4);
settable(t5,8,ph5);
settable(t6,8,ph6);
settable(t7,4,ph7);
if (getflag("jfilter"))
{
if (getflag("PFGflg"))
{
getelem(t2,ct,v3);
getelem(t7,ct,oph);
getelem(t3,ct,v4);
}
else
{
getelem(t3,ct,v3);
getelem(t6,ct,oph);
getelem(t5,ct,v4);
}
}
else
{
getelem(t2,ct,v3);
getelem(t7,ct,oph);
getelem(t3,ct,v4);
}
if (phase1 == 2)
incr(v3);
/*
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);
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);
satpulse(satdly,zero,rof1,rof1);
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
decpower(pwxlvl);
status(B);
rgpulse(pw,t1,rof1,rof2);
/* Start of J filter */
if (getflag("jfilter"))
{
if (getflag("PFGflg"))
{
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(gt0/3);
}
else
{
delay(tau - rof2 - rof1);
decrgpulse(pwx,t2,rof1,rof1);
}
}
/* End of J filter */
delay(taumb);
decrgpulse(pwx,v3,rof1,2.0e-6);
if (d2/2 > 0.0)
delay(d2/2 - 2*pwx/PI - pw - 4.0e-6);
else
delay(d2/2);
rgpulse(pw*2.0,t4,2.0e-6,2.0e-6);
if (d2/2 > 0.0)
delay(d2/2 - 2*pwx/PI - pw - 4.0e-6);
else
delay(d2/2);
decrgpulse(pwx,v4,2.0e-6,rof2);
decpower(dpwr);
status(C);
}
pulsesequence()
{
double slpwrT = getval("slpwrT"),
slpwT = getval("slpwT"),
mixT = getval("mixT"),
trim = getval("trim"),
tauz1 = getval("tauz1"),
tauz2 = getval("tauz2"),
tauz3 = getval("tauz3"),
tauz4 = getval("tauz4"),
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");
char selshapeA[MAXSTR],
selshapeB[MAXSTR],
slpatT[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);
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);
assign(ct,v6);
if (getflag("zqfilt"))
{ hlv(v6,v6); hlv(v6,v6); }
settable(t1,4,ph1); getelem(t1,v6,v1);
settable(t3,8,ph3); getelem(t3,v6,v11);
settable(t4,8,ph4);
settable(t2,4,ph2); getelem(t2,v6,v2);
settable(t7,8,ph7); getelem(t7,v6,v7);
settable(t8,4,ph8); getelem(t8,v6,v8);
if (getflag("zqfilt"))
getelem(t4,v6,oph);
else
assign(v1,oph);
sub(v2,one,v3);
add(v2,two,v4);
add(v3,two,v5);
mod4(ct,v10);
/* 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, v1, 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,v2,rof1,rof1);
obspower(slpwrT);
zgradpulse(gzlvlB,gtB);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixT > 0.0)
{
rgpulse(trim,v11,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v3,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9);
}
if (getflag("zqfilt"))
{
obspower(tpwr);
rgpulse(pw,v7,1.0e-6,rof1);
ifzero(v10); delay(tauz1); endif(v10);
decr(v10);
ifzero(v10); delay(tauz2); endif(v10);
decr(v10);
ifzero(v10); delay(tauz3); endif(v10);
decr(v10);
ifzero(v10); delay(tauz4); endif(v10);
rgpulse(pw,v8,rof1,rof2);
}
else
delay(rof2);
status(C);
}
void pulsesequence()
{
double tpwr180r = getval("tpwr180r"),
pw180r = getval("pw180r"),
pwx180 = getval("dnbippw"),
pwxlvl180 = getval("dnbippwr"),
pp = getval("pp"),
pplvl = getval("pplvl"),
tauC = getval("tauC"),
tau;
int prgcycle=(int)(getval("prgcycle")+0.5);
char pw180ref[MAXSTR],
dnbipshp[MAXSTR],
bipflg[MAXSTR];
getstr("pw180ref", pw180ref);
getstr("dnbipshp", dnbipshp);
getstr("bipflg",bipflg);
tau = 1.0 / (2.0 * (getval("j1xh")));
assign(ct,v17);
assign(zero,v18);
assign(zero,v19);
if (getflag("prgflg") && getflag("satmode") && (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,phs1);
settable(t2,8,phs2);
settable(t3,4,phs3);
getelem(t1,v17,v1);
getelem(t2,v17,v2);
getelem(t3,v17,v3);
assign(v1,oph);
add(oph,v18,oph);
add(oph,v19,oph);
if (getflag("prgflg") && getflag("satmode"))
assign(v3,v2);
/* equilibrium period */
status(A);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
if (getflag("satmode"))
{
if ((d1-satdly) > 0.02)
delay(d1-satdly);
else
delay(0.02);
if (getflag("slpsat"))
{
shaped_satpulse("relaxD",satdly,v2);
if (getflag("prgflg"))
shaped_purge(v1,v2,v18,v19);
}
else
{
satpulse(satdly,v2,rof1,rof1);
if (getflag("prgflg"))
purge(v1,v2,v18,v19);
}
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
obspower(tpwr);
if (bipflg[1] == 'y')
decpower(pwxlvl180);
else
decpower(pplvl);
rgpulse(pw,v1,rof1,rof1);
if (bipflg[1] == 'y')
{
decshaped_pulse(dnbipshp,pwx180,zero,2.0e-6,2.0e-6);
delay(tau+tauC);
}
else
{
decrgpulse(2*pp,zero,2.0e-6,2.0e-6);
delay(tau);
}
obspower(tpwr180r);
shaped_pulse(pw180ref,pw180r,v1,rof1,rof1);
if (bipflg[1] == 'y')
{
decshaped_pulse(dnbipshp,pwx180,zero,2.0e-6,2.0e-6);
delay(tau+tauC);
}
else
{
decrgpulse(2*pp,zero,2.0e-6,2.0e-6);
delay(tau);
}
shaped_pulse(pw180ref,pw180r,v1,rof1,rof2);
decpower(dpwr);
obspower(tpwr);
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);
}
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 slpwrR = getval("slpwrR"),
slpwR = getval("slpwR"),
mixR = getval("mixR"),
gzlvlz = getval("gzlvlz"),
gtz = getval("gtz"),
zfphinc = getval("zfphinc");
char slpatR[MAXSTR];
int phase1 = (int)(getval("phase")+0.5);
/* LOAD AND INITIALIZE PARAMETERS */
getstr("slpatR",slpatR);
if (strcmp(slpatR,"cw") &&
strcmp(slpatR,"troesy") &&
strcmp(slpatR,"dante"))
abort_message("SpinLock pattern %s not supported!.\n", slpatR);
sub(ct,ssctr,v7);
settable(t1,4,ph1); getelem(t1,v7,v1);
settable(t2,8,ph2); getelem(t2,v7,v2);
settable(t3,8,ph3);
settable(t8,4,ph8); getelem(t8,v7,v8);
settable(t6,8,ph6); getelem(t6,v7,v6);
assign(v1,oph);
if (getflag("zfilt"))
getelem(t3,v7,oph);
add(v2,one,v3);
add(v2,two,v4);
add(v2,three,v5);
if (phase1 == 2)
{incr(v1); incr(v6);} /* hypercomplex method */
/*
mod2(id2,v13);
dbl(v13,v13);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v13);
add(v1,v13,v1);
add(v6,v13,v6);
add(oph,v13,oph);
/* The following is for flipback pulse */
zfphinc=zfphinc+180;
if (zfphinc < 0) zfphinc=zfphinc+360;
initval(zfphinc,v10);
/* BEGIN 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);
decpower(dpwr);
status(B);
rgpulse(pw, v1, rof1, rof1);
if (d2 > 0.0)
delay(d2 - POWER_DELAY - (2*pw/PI) - rof1);
else
delay(d2);
obspower(slpwrR);
if (mixR > 0.0)
{
if (dps_flag)
{
if (!strcmp(slpatR,"troesy"))
rgpulse(mixR,v2,0.0,0.0);
else
rgpulse(mixR,v3,0.0,0.0);
}
else
SpinLock(slpatR,mixR,slpwR,v2,v3,v4,v5, v9);
}
if ((getflag("zfilt")) && (getflag("PFGflg")))
{
obspower(tpwr);
rgpulse(pw,v2,1.0e-6,rof1);
zgradpulse(gzlvlz,gtz);
delay(gtz/3);
if (getflag("flipback"))
FBpulse(v8,v10);
rgpulse(pw,v8,rof1,rof2);
}
else
delay(rof2);
status(C);
}
pulsesequence()
{
double Dtau,Ddelta,dosytimecubed,dosyfrq,CORR,del2check,del2max,
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
gzlvl3 = getval("gzlvl3"),
gt3 = getval("gt3"),
del = getval("del"),
del2 = getval("del2"),
gstab = getval("gstab"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
kappa = getval("kappa"),
gzlvlmax = getval("gzlvlmax"),
satdly = getval("satdly"),
satpwr = getval("satpwr"),
satfrq = getval("satfrq");
char delflag[MAXSTR],sspul[MAXSTR],satmode[MAXSTR],
triax_flg[MAXSTR],alt_grd[MAXSTR],lkgate_flg[MAXSTR];
nt = getval("nt");
getstr("delflag",delflag);
getstr("sspul",sspul);
getstr("triax_flg",triax_flg);
getstr("satmode",satmode);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
CORR=1.5*gt1+3*gstab+3.0*pw+5*rof1;
if (ni > 1.0)
abort_message("This is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
/* check the shortest executable delay in the sequence */
if ((del-2.0*CORR-gt2-gt3)< 0.0)
abort_message("The minimum value of del is %.6f seconds", 2*CORR+gt2+gt3);
del2check = del/2.0-CORR-fabs(del2)-gt3;
del2max = del/2.0-CORR-gt3;
if (del2check< 0.0)
abort_message("del2 in absolute value cannot exceed %.6f seconds",del2max);
if (gzlvl1*(1+kappa)>gzlvlmax)
abort_message("Warning: 'gzlvl1*(1+kappa)>gzlvlmax");
Ddelta = gt1;
Dtau = 2.0*pw+2.0*rof1+gstab+gt1/2.0;
dosyfrq = getval("sfrq");
dosytimecubed = Ddelta*Ddelta*(del-2.0*(Ddelta/3.0)-2.0*(Dtau/2.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* phase cycling calculation */
settable(t1, 8, phi1);
settable(t2, 8, phi2);
settable(t3, 1, phi3);
settable(t4, 4, phi4);
settable(t5,16, phi5);
settable(t6, 1, phi6);
settable(t7, 1, phi7);
settable(t8,32, phi8);
settable(t9, 1, phi9);
settable(t10, 1, phi10);
settable(t11, 16, rec);
sub(ct,ssctr,v12);
getelem(t1,v12,v1);
getelem(t2,v12,v2);
getelem(t3,v12,v3);
getelem(t4,v12,v4);
getelem(t5,v12,v5);
getelem(t6,v12,v6);
getelem(t7,v12,v7);
getelem(t8,v12,v8);
getelem(t9,v12,v9);
getelem(t10,v12,v10);
getelem(t11,v12,oph);
mod2(ct,v11); /* gradients change sign at odd transients */
/* 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) delay(d1-satdly);
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(satdly,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(d1);
if (getflag("wet"))
wet4(zero,one);
status(B);
/* first part of bppste sequence */
if(delflag[0]=='y')
{
if(gt1>0 && gzlvl1!=0)
{
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(2*kappa*gzlvl1,gt1/2.0); /* comp. gradient */
elsenz(v11);
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0); /* comp. gradient */
endif(v11);
}
else zgradpulse(2*kappa*gzlvl1,gt1/2.0); /* comp. gradient */
delay(gstab);
if (triax_flg[0] == 'y') /* homospoil grad */
{ rgradient('x',-1.0*gzlvl2); /* along x if available */
delay(gt2);
rgradient('x',0.0); }
else
{
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*gzlvl2,gt2); /*spoiler comp. gradient*/
elsenz(v11);
zgradpulse(1.0*gzlvl2,gt2); /*spoiler comp. gradient*/
endif(v11);
}
else zgradpulse(-1.0*gzlvl2,gt2); /*spoiler comp. gradient*/
}
rgpulse(pw, v1, rof1, rof1); /* first 90, v1 */
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-1.0*(1-kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2, v2, rof1, rof1); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse((1+kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, rof1); /* second 90, v3 */
if (triax_flg[0] == 'y') /* homospoil grad */
{ rgradient('x',gzlvl2); /* along x if available */
delay(gt2);
rgradient('x',0.0); }
else
{
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(gzlvl2,gt2); /*spoiler gradient*/
elsenz(v11);
zgradpulse(-1.0*gzlvl2,gt2); /*spoiler gradient*/
endif(v11);
}
else zgradpulse(gzlvl2,gt2); /*spoiler gradient*/
}
delay(gstab);
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(del/2.0-CORR+del2-gt2-gstab-2*rof1,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(del/2.0-CORR+del2-gt2-gstab);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v4, rof1, rof1); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-1.0*(1-kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-1.0*(1-kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(2*pw,v5,rof1,rof1);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse((1+kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse((1+kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw,v6,rof1,rof1);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(del/2.0-CORR-del2-gt3-2*rof1,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(del/2.0-CORR-del2-gt3);
if (triax_flg[0] == 'y') /* homospoil grad */
{ rgradient('y',gzlvl3); /* along y if available */
delay(gt3);
rgradient('y',0.0); }
else
{
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(gzlvl3,gt3); /* 2nd spoiler gradient */
elsenz(v11);
zgradpulse(-1.0*gzlvl3,gt3); /* 2nd spoiler gradient */
endif(v11);
}
else zgradpulse(gzlvl3,gt3); /* 2nd spoiler gradient */
}
delay(gstab);
rgpulse(pw,v7,rof1,rof1);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-1.0*(1-kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse((1-kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2, v8, rof1, rof1); /* second 180, v8 */
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse((1+kappa)*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(-1.0*(1+kappa)*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw,v9,rof1,rof1); /* z- filter */
if (triax_flg[0] == 'y') /* homospoil grad */
{ rgradient('y',-1.0*gzlvl3); /* along y if available */
delay(gt3);
rgradient('y',0.0); }
else
{
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(-1.0*gzlvl3,gt3); /* 2nd spoiler comp. gradient */
elsenz(v11);
zgradpulse(gzlvl3,gt3); /* 2nd spoiler comp. gradient */
endif(v11);
}
else zgradpulse(-1.0*gzlvl3,gt3); /* 2nd spoiler comp. gradient */
}
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v11);
zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
elsenz(v11);
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0);
endif(v11);
}
else zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw,v10,rof1,rof2);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
}
else rgpulse(pw, oph,rof1,rof2);
/* --- observe period --- */
status(C);
}
pulsesequence()
{
double gzlvl1,qlvl,grise,gstab,gt1,ss,phase;
int icosel,iphase;
ss = getval("ss");
grise=getval("grise");
gstab=getval("gstab");
gt1=getval("gt1");
gzlvl1=getval("gzlvl1");
qlvl=getval("qlvl");
phase=getval("phase");
iphase = (int) (phase + 0.5);
/* DETERMINE STEADY-STATE MODE */
if (ss < 0) ss = (-1) * ss;
else
if ((ss > 0) && (ix == 1)) ss = ss;
else
ss = 0;
initval(ss, ssctr);
initval(ss, ssval);
assign(oph,v2);
assign(oph,v1);
if (iphase == 2)
incr(v1);
/* HYPERCOMPLEX MODE */
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v6);
if ((iphase==1) || (iphase==2))
{add(v1,v6,v1); add(oph,v6,oph);}
status(A);
rcvroff();
delay(d1);
if (getflag("wet")) wet4(zero,one);
rlpower(tpwr,TODEV);
rgpulse(pw,v1,rof1,rof2);
status(B);
if (d2 > rof1 + 4.0*pw/3.1416)
delay(d2 - rof1 - 4.0*pw/3.1416);
status(C);
rgpulse(pw,v2,rof1,rof2);
delay(gt1+2.0*grise+24.4e-6);
rgpulse(2.0*pw,v2,rof1,rof2);
icosel=-1;
rgradient('z',gzlvl1*(double)icosel);
delay(gt1+grise);
rgradient('z',0.0);
txphase(oph);
delay(grise);
rgpulse(pw,v2,rof1,rof2);
rgradient('z',gzlvl1*qlvl);
delay(gt1+grise);
rgradient('z',0.0);
delay(grise);
rcvron();
delay(gstab);
status(D);
}
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);
}
pulsesequence()
{
double gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
slpwT = getval("slpwT"),
slpwrT = getval("slpwrT"),
trim = getval("trim"),
mixT = getval("mixT"),
mult = getval("mult"),
tau,
gtau;
int icosel,
phase1 = (int)(getval("phase")+0.5);
char slpatT[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",0.5);
gzlvlE = syncGradLvl("gtE","gzlvlE",0.5);
getstr("slpatT",slpatT);
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);
tau = 1/(4*(getval("j1xh")));
gtau = 2*gstab + 2*GRADIENT_DELAY;
icosel = 1;
settable(t1,2,ph1);
settable(t2,4,ph2);
settable(t3,4,ph3);
assign(zero,v6);
getelem(t1,ct,v1);
getelem(t3,ct,oph);
assign(two,v3);
sub(v3,one,v2);
add(v3,one,v4);
add(v3,two,v5);
/*
mod2(id2,v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
if ((phase1 == 2) || (phase1 == 5))
icosel = -1;
add(v1,v14,v1);
add(v6,v14,v6);
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);
satpulse(satdly,zero,rof1,rof1);
}
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*tau);
simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(1.5*pw,two,rof1,rof1);
zgradpulse(hsglvl,hsgt);
delay(1e-3);
}
rgpulse(pw,zero,rof1,rof1);
delay(2*tau - 2*rof1 - (2*pw/PI));
decrgpulse(pwx,v1,rof1,1.0e-6);
delay(gtE/2.0+gtau - (2*pwx/PI) - pwx - 1.0e-6 - rof1);
decrgpulse(2*pwx,v6,rof1,1.0e-6);
delay(gstab - pwx - 1.0e-6);
zgradpulse(gzlvlE,gtE/2.0);
delay(gstab - rof1 - pw);
delay(d2/2);
rgpulse(2.0*pw,zero,rof1,rof1);
delay(d2/2);
delay(gstab - rof1 - pw);
zgradpulse(gzlvlE,gtE/2.0);
delay(gstab - pwx - rof1);
decrgpulse(2*pwx,zero,rof1,1.0e-6);
delay(gtE/2.0+gtau - (2*pwx/PI) - pwx - 1.0e-6 - rof1);
decrgpulse(pwx,t2,rof1,rof1);
delay(2*tau - rof1 - POWER_DELAY);
obspower(slpwrT);
if (mixT > 0.0)
{
rgpulse(trim,v5,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v3,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5,v9);
}
obspower(tpwr);
if (mult > 0.5)
delay(2*tau - rof1);
else
delay(gtE/2 + gstab + 2*GRADIENT_DELAY - rof1);
simpulse(2*pw,mult*pwx,one,zero,rof1,rof2);
decpower(dpwr);
zgradpulse(icosel*2*gzlvlE/EDratio,gtE/2.0);
if (mult > 0.5)
delay(2*tau - gtE/2 - 2*GRADIENT_DELAY);
else
delay(gstab);
status(C);
}
pulsesequence()
{
double gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
mult = getval("mult"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
tau,
evolcorr,
taug;
int icosel,
phase1 = (int)(getval("phase")+0.5),
ZZgsign;
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtE = syncGradTime("gtE","gzlvlE",0.5);
gzlvlE = syncGradLvl("gtE","gzlvlE",0.5);
tau = 1/(4*(getval("j1xh")));
evolcorr = 2*pw+4.0e-6;
if (mult > 0.5)
taug = 2*tau;
else
taug = gtE + gstab + 2*GRADIENT_DELAY;
ZZgsign=-1;
if (mult == 2) ZZgsign=1;
icosel = 1;
settable(t1,4,ph1);
settable(t2,2,ph2);
settable(t3,8,ph3);
settable(t4,16,ph4);
settable(t5,16,ph5);
getelem(t2,ct,v2);
getelem(t5,ct,oph);
/*
mod2(id2,v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
if ((phase1 == 2) || (phase1 == 5))
icosel = -1;
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);
satpulse(satdly,zero,rof1,rof1);
}
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*tau);
simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(1.5*pw,two,rof1,rof1);
zgradpulse(hsglvl,hsgt);
delay(1e-3);
}
rgpulse(pw,zero,rof1,rof1);
delay(tau);
simpulse(2*pw,2*pwx,zero,zero,rof1,rof1);
delay(tau);
rgpulse(pw,t1,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);
zgradpulse(gzlvlE,gtE);
delay(taug - gtE - 2*GRADIENT_DELAY);
simpulse(mult*pw,2*pwx,zero,zero,rof1,rof1);
delay(taug + evolcorr);
decrgpulse(pwx,t4,2.0e-6,rof1);
zgradpulse(ZZgsign*0.6*hsglvl,1.2*hsgt);
delay(1e-3);
rgpulse(pw,t3,rof1,rof1);
delay(tau - (2*pw/PI) - 2*rof1);
simpulse(2*pw,2*pwx,zero,zero,rof1, rof2);
decpower(dpwr);
zgradpulse(icosel*2.0*gzlvlE/EDratio,gtE/2.0);
delay(tau - gtE/2.0 - 2*GRADIENT_DELAY - POWER_DELAY);
status(C);
}
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()
{
double tau, rg1 = 2.0e-6,
jXH = getval("jXH"),
mult = getval("mult"),
gt0 = getval("gt0"),
gzlvl0 = getval("gzlvl0"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
gt3 = getval("gt3"),
gzlvl3 = getval("gzlvl3"),
Gratio = getval("Gratio"),
gstab = getval("gstab"),
compH = getval("compH"),
compX = getval("compX"),
Hpwr = getval("Hpwr"),
jevol = 0.25 / 140.0; /* default for C-13 */
char pshape[MAXSTR], zz[MAXSTR], ad180[MAXSTR], sspul[MAXSTR];
shape hdx; /* HADAMARD stuff */
void setphases();
getstr("pshape", pshape); /* pulse shape as in wavelib */
getstr("sspul", sspul);
getstr("zz", zz);
getstr("ad180", ad180);
if (jXH > 0.0) jevol = 0.25 / jXH;
tau = gt3 + gstab;
if (mult > 0.5)
tau = 2*jevol;
setphases();
/* MAKE PBOX SHAPES */
if (FIRST_FID)
{
ad180sh = pbox_ad180("ad180", pwx, pwxlvl); /* make adiabatic 180 */
if (strcmp(pwpat,"Hdec") == 0)
{
/* make H decoupling shape */
Hdec = pboxHT_dec(pwpat, pshape, jXH, 20.0, pw, compH, tpwr);
Hpwr = Hdec.pwr;
}
}
hdx = pboxHT_F1i(pshape, pwx*compX, pwxlvl); /* HADAMARD stuff */
if (getval("htcal1") > 0.5) /* enable manual power calibration */
hdx.pwr += getval("htpwr1");
/* THE PULSE PROGRAMM STARTS HERE */
status(A);
delay(5.0e-5);
zgradpulse(gzlvl0,gt0);
if (sspul[0] == 'y')
{
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvl0,gt0);
}
pre_sat();
if (getflag("wet"))
wet4(zero,one);
decoffset(dof);
decpower(pwxlvl);
obspower(tpwr);
obsoffset(tof);
delay(2.0e-5);
status(B);
rgpulse(pw, v2, rg1, rg1);
delay(jevol - ad180sh.pw/2.0 - 3.0*rg1); /* +rg on both sides */
decshaped_pulse(ad180sh.name, ad180sh.pw, zero, rg1, rg1);
rgpulse(2.0*pw, zero, rg1, rg1);
delay(jevol + ad180sh.pw/2.0 - rg1);
rgpulse(pw, one, rg1, rg1);
zgradpulse(-gzlvl2, gt2);
delay(gstab);
decpower(hdx.pwr);
if (strcmp(pwpat,"") == 0)
decshaped_pulse(hdx.name, hdx.pw, zero, rg1, rg1);
else
{
obspower(Hpwr);
simshaped_pulse(pwpat, hdx.name, hdx.pw, hdx.pw, zero, zero, rg1, rg1);
}
zgradpulse(gzlvl2*1.4, gt2);
decpower(pwxlvl); obspower(tpwr);
if((zz[A] == 'y') && (mult == 0))
{
ifzero(v1);
decshaped_pulse(ad180sh.name, ad180sh.pw, zero, rg1, rg1);
elsenz(v1);
delay(0.5e-3);
endif(v1);
}
else
{
delay(0.5e-3);
decrgpulse(pwx,v1,rg1,rg1);
if(ad180[A]=='y')
decshaped_pulse(ad180sh.name, ad180sh.pw, zero, rg1, rg1);
if(zz[A] == 'y')
delay(tau);
else
{
zgradpulse(gzlvl1,gt1);
delay(tau - gt1 - 2*GRADIENT_DELAY);
}
if(ad180[A]=='y')
{
rgpulse(mult*pw, zero, rg1, rg1);
decshaped_pulse(ad180sh.name, ad180sh.pw, zero, rg1, rg1);
}
else
simpulse(mult*pw,2*pwx,zero,one,rg1,rg1);
delay(tau);
decrgpulse(pwx,zero,rg1,rg1);
}
zgradpulse(gzlvl2/1.7, gt2);
delay(gstab);
rgpulse(pw, zero, rg1, rg1);
delay(jevol - ad180sh.pw/2.0 - 3.0*rg1); /* +rg on both sides */
decshaped_pulse(ad180sh.name, ad180sh.pw, zero, rg1, rg1);
rgpulse(2.0*pw, zero, rg1, rg1);
if(zz[A] == 'y')
{
delay(jevol + ad180sh.pw/2.0 - rg1);
rgpulse(pw, one, rg1, rg1);
zgradpulse(-gzlvl3, gt3);
decpower(dpwr);
delay(gstab);
rgpulse(pw, three, rg1, rof2);
}
else
{
zgradpulse(2.0*gzlvl1/Gratio, gt1/2.0);
decpower(dpwr);
delay(jevol + ad180sh.pw/2.0 - rg1 - gt1/2.0 - 2*GRADIENT_DELAY - POWER_DELAY + rof2);
}
status(C);
}
void pulsesequence()
{
double gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gzlvl_max = getval("gzlvl_max"),
del = getval("del"),
dosyfrq=getval("sfrq"),
gstab = getval("gstab"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
gtau,tauc,gt4,gzlvl4,Ddelta,dosytimecubed;
char convcomp[MAXSTR],sspul[MAXSTR],lkgate_flg[MAXSTR],satmode[MAXSTR],
alt_grd[MAXSTR],arraystring[MAXSTR];
int iphase, icosel;
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",1.0);
gzlvl1 = syncGradLvl("gt1","gzlvl1",1.0);
gtE = syncGradTime("gtE","gzlvlE",1.0);
gzlvlE = syncGradLvl("gtE","gzlvlE",1.0);
getstr("sspul",sspul);
getstr("convcomp",convcomp);
getstr("satmode",satmode);
getstr("lkgate_flg",lkgate_flg);
getstr("alt_grd",alt_grd);
getstr("array",arraystring);
iphase = (int)(getval("phase")+0.5);
icosel = 1;
tau = 1/(2*(getval("jnxh")));
gtau = 2*gstab + GRADIENT_DELAY;
tauc = gtau+gtE-gstab;
if (strcmp(arraystring,"gzlvl1,phase")!=0)
fprintf(stdout,"Warning: array should be 'gzlvl1,phase' for this experiment");
Ddelta=gt1; /* the diffusion-encoding pulse width is gt1 */
if (convcomp[0] == 'y') dosytimecubed=2.0*Ddelta*Ddelta*(del-2.0*(Ddelta/3.0));
else dosytimecubed=2.0*Ddelta*Ddelta*(del-(Ddelta/3.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
if (ni>1) putCmd("dosy3Dproc=\'y\'\n");
else putCmd("dosy3Dproc=\'n\'");
if (tau < (gtE+gstab))
{
abort_message("0.5/jnxh must be greater than gtE+gstab");
}
if (tau < (1.0*(gt1+gstab)+del))
{
abort_message("0.5/jnxh must be greater than del+gt1+gstab");
}
settable(t1,2,ph1);
settable(t2,4,ph2);
settable(t3,4,ph3);
assign(zero,v4);
getelem(t1,ct,v1);
getelem(t3,ct,oph);
if (iphase == 2) icosel = -1;
initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v11);
add(v1,v11,v1);
add(v4,v11,v4);
add(oph,v11,oph);
mod2(ct,v10); /* gradients change sign at odd transients */
status(A);
decpower(pwxlvl);
if (sspul[0] == 'y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (lkgate_flg[0]=='y') lk_sample(); /* turn lock sampling on */
if (convcomp[0]=='y')
gt4=gt1*2.0;
else
gt4=gt1;
gzlvl4=sqrt(gzlvl_max*gzlvl_max-gzlvl1*gzlvl1);
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);
if (lkgate_flg[0]=='y') lk_hold(); /* turn lock sampling off */
status(B);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl4,gt4);
elsenz(v10);
zgradpulse(-1.0*gzlvl4,gt4);
endif(v10);
}
else zgradpulse(gzlvl4,gt4);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl4,gt4);
elsenz(v10);
zgradpulse(gzlvl4,gt4);
endif(v10);
}
else zgradpulse(-1.0*gzlvl4,gt4);
delay(gstab);
rgpulse(pw,zero,rof1,1.0e-6);
if (convcomp[0]=='y')
{
delay((tau - 1.0e-6 - (2*pw/PI)-del-2.333*gt1-2.0*gstab)/2.0);
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/2.0-5.0*gt1/6.0-2.0*rof1,zero,rof1,rof1);
}
else delay(del/2.0-5.0*gt1/6.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);
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')
{ rgpulse(del/2.0-5.0*gt1/6.0-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(del/2.0-5.0*gt1/6.0);
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((tau - 1.0e-6 - (2*pw/PI)-del-2.333*gt1)/2.0);
}
else
{
delay((tau - 1.0e-6 - (2*pw/PI)-del-gt1-gstab)/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);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(del-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(del-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((tau - 1.0e-6 - (2*pw/PI)-del-gt1-gstab)/2.0);
}
decrgpulse(pwx,v1,1.0e-6,1.0e-6);
delay(gtE+gtau);
decrgpulse(2*pwx,v4,1.0e-6,1.0e-6);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvlE,gtE);
elsenz(v10);
zgradpulse(-1.0*gzlvlE,gtE);
endif(v10);
}
else zgradpulse(gzlvlE,gtE);
delay(gstab);
if (d2/2 > pw)
delay(d2/2 - pw);
else
delay(d2/2);
rgpulse(2.0*pw,zero,1.0e-6,1.0e-6);
if (d2/2 > pw)
delay(d2/2 - pw);
else
delay(d2/2);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvlE,gtE);
elsenz(v10);
zgradpulse(-1.0*gzlvlE,gtE);
endif(v10);
}
else zgradpulse(gzlvlE,gtE);
delay(gstab);
decrgpulse(2*pwx,zero,1.0e-6,1.0e-6);
delay(gtE+gtau);
decrgpulse(pwx,t2,1.0e-6,1.0e-6);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(icosel*2.0*gzlvlE/EDratio,gtE);
elsenz(v10);
zgradpulse(-1.0*icosel*2.0*gzlvlE/EDratio,gtE);
endif(v10);
}
else zgradpulse(icosel*2.0*gzlvlE/EDratio,gtE);
if (convcomp[0]=='y')
{
delay((tau-tauc - 1.0e-6 - (2*pw/PI)-del-2.333*gt1-2.0*gstab)/2.0);
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/2.0-5.0*gt1/6.0-2.0*rof1,zero,rof1,rof1);
}
else delay(del/2.0-5.0*gt1/6.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);
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')
{ rgpulse(del/2.0-5.0*gt1/6.0-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(del/2.0-5.0*gt1/6.0);
zgradpulse(-gzlvl1,gt1);
delay((tau-tauc - 1.0e-6 - (2*pw/PI)-del-2.333*gt1)/2.0);
if (lkgate_flg[0]=='y') lk_sample();
}
else
{
delay((tau-tauc - 1.0e-6 - (2*pw/PI)-del-gt1-gstab)/2.0);
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-gt1-2.0*rof1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(del-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((tau-tauc - 1.0e-6 - (2*pw/PI)-del-gt1-gstab)/2.0);
if (lkgate_flg[0]=='y') lk_sample();
}
decpower(dpwr);
delay(rof2 - POWER_DELAY);
status(C);
}
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);
}
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);
}
pulsesequence()
{
double gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
satdly = getval("satdly"),
pwxlvl = getval("pwxlvl"),
pwx = getval("pwx"),
jFH = getval("jFH"),
dly1, dly2;
char sspul[MAXSTR],
satmode[MAXSTR];
int icosel;
getstr("satmode",satmode);
getstr("sspul",sspul);
if (jFH == 0.0) jFH=7.0;
dly1 = 1.0 / (2.0*jFH);
dly2 = 1.0 / (3.0*jFH);
icosel = -1;
settable(t1,4,ph1);
settable(t2,4,ph2);
settable(t3,8,ph3);
settable(t4,32,ph4);
settable(t5,16,ph5);
getelem(t1,ct,v1);
getelem(t2,ct,v2);
getelem(t3,ct,v3);
getelem(t4,ct,v4);
getelem(t5,ct,oph);
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10);
{
add(v1,v10,v1);
add(oph,v10,oph);
}
decpower(pwxlvl); decpwrf(4095.0);
status(A);
if (sspul[0] == 'y')
{
zgradpulse(hsglvl,hsgt);
rgpulse(pw,zero,rof1,rof1);
decrgpulse(pwx,zero,rof1,rof1);
zgradpulse(hsglvl,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0) delay(d1 - satdly);
else delay(0.02);
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);
decrgpulse(pwx, v1, rof1, rof1);
if (d2/2.0==0.0) delay(d2);
else delay(d2/2.0-2*rof1-pw);
rgpulse(2.0*pw,v3,rof1,rof1);
if (d2/2.0==0.0) delay(d2);
else delay(d2/2.0-2*rof1-pw);
delay(dly1 - gtE-gstab);
zgradpulse(gzlvlE*EDratio,gtE);
delay(gstab);
decrgpulse(pwx,v2,rof1,rof1);
rgpulse(pw, v4, rof1, rof1);
zgradpulse(icosel*gzlvlE,gtE);
decpower(dpwr);
delay(dly2 - gtE);
status(C);
}
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()
{
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);
}
pulsesequence()
{
char mixpat[MAXSTR], pshape[MAXSTR], httype[MAXSTR], sspul[MAXSTR];
double rg1 = 2.0e-6,
mix = getval("mix"), /* mixing time */
mixpwr = getval("mixpwr"), /* mixing pwr */
compH = getval("compH"),
gt0 = getval("gt0"), /* gradient pulse in sspul */
gt2 = getval("gt2"), /* gradient pulse preceding mixing */
gzlvl0 = getval("gzlvl0"), /* gradient level for gt0 */
gzlvl2 = getval("gzlvl2"), /* gradient level for gt2 */
gstab = getval("gstab"); /* delay for gradient recovery */
shape hdx;
void setphases();
getstr("sspul", sspul);
getstr("pshape", pshape);
getstr("httype", httype);
getstr("mixpat", mixpat);
setlimit("mixpwr", mixpwr, 48.0);
(void) setphases();
if (httype[0] == 'i')
assign(zero,v2);
/* MAKE PBOX SHAPES */
if (FIRST_FID)
hhmix = pbox_mix("HHmix", mixpat, mixpwr, pw*compH, tpwr);
/* HADAMARD stuff */
if(httype[0] == 'e') /* excitation */
hdx = pboxHT_F1e(pshape, pw*compH, tpwr);
else if(httype[0] == 'r') /* refocusing */
hdx = pboxHT_F1r(pshape, pw*compH, tpwr);
else if(httype[0] == 'd') /* DPFGSE */
{
hdx = pboxHT_F1r(pshape, pw*compH, tpwr);
if (FIRST_FID)
ref180 = hdx;
}
else /* httype[0] == 'i' */ /* inversion */
hdx = pboxHT_F1i(pshape, pw*compH, tpwr);
if (getval("htcal1") > 0.5) /* Optional fine power calibration */
hdx.pwr += getval("htpwr1");
/* THE PULSE PROGRAMM STARTS HERE */
status(A);
delay(5.0e-5);
zgradpulse(gzlvl0,gt0);
if (sspul[A] == 'y')
{
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvl0,gt0);
}
pre_sat();
if (getflag("wet"))
wet4(zero,one);
delay(1.0e-5);
obspower(tpwr);
delay(1.0e-5);
status(B);
if (httype[0] == 'i') /* longitudinal encoding */
{
ifzero(v1);
delay(2.0*(pw+rg1));
zgradpulse(gzlvl2,gt2);
delay(gstab);
elsenz(v1);
rgpulse(2.0*pw,v3,rg1,rg1);
zgradpulse(gzlvl2,gt2);
delay(gstab);
endif(v1);
pbox_pulse(&hdx, zero, rg1, rg1);
zgradpulse(gzlvl2,gt2);
delay(gstab);
}
else /* transverse encoding */
{
if (httype[0] == 'e')
pbox_pulse(&hdx, oph, rg1, rg1);
else
{
rgpulse(pw,oph,rg1,rg1);
if (httype[0] == 'd') /* DPFGSE */
{
zgradpulse(2.0*gzlvl2,gt2);
delay(gstab);
pbox_pulse(&ref180, oph, rg1, rg1);
zgradpulse(2.0*gzlvl2,gt2);
delay(gstab);
}
zgradpulse(gzlvl2,gt2);
delay(gstab);
pbox_pulse(&hdx, v2, rg1, rof2);
zgradpulse(gzlvl2,gt2);
delay(gstab - POWER_DELAY);
}
}
if (mix)
pbox_spinlock(&hhmix, mix, v2);
if (httype[0] == 'i')
{
zgradpulse(0.87*gzlvl2,gt2);
delay(gstab);
obspower(tpwr);
txphase(v3);
rgpulse(pw,v3,rg1,rof2);
}
status(C);
}
pulsesequence()
{
double slpwrT = getval("slpwrT"),
slpwT = getval("slpwT"),
trim = getval("trim"),
mixT = getval("mixT"),
gzlvlz = getval("gzlvlz"),
gtz = getval("gtz"),
zfphinc = getval("zfphinc");
char slpatT[MAXSTR];
int phase1 = (int)(getval("phase")+0.5);
/* LOAD AND INITIALIZE VARIABLES */
getstr("slpatT",slpatT);
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);
/*
mod2(id2,v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
sub(ct,ssctr,v12);
settable(t1,4,ph1); getelem(t1,v12,v6);
settable(t2,4,ph2); getelem(t2,v12,v1);
settable(t3,8,ph3);
settable(t4,4,ph4); getelem(t4,v12,v13);
settable(t5,4,ph5); getelem(t5,v12,v2);
settable(t7,8,ph7); getelem(t7,v12,v7);
settable(t8,4,ph8); getelem(t8,v12,v8);
assign(v1,oph);
if (getflag("zfilt"))
getelem(t3,v12,oph);
sub(v2, one, v3);
add(two, v2, v4);
add(two, v3, v5);
if (phase1 == 2)
{incr(v1); incr(v6);}
add(v1, v14, v1);
add(v6, v14, v6);
add(oph,v14,oph);
/* The following is for flipback pulse */
zfphinc=zfphinc+180;
if (zfphinc < 0) zfphinc=zfphinc+360;
initval(zfphinc,v10);
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
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, v1, rof1, rof1);
obspower(slpwrT);
txphase(v13);
if (d2 > 0.0)
delay(d2 - rof1 - POWER_DELAY - (2*pw/PI));
else
delay(d2);
if (mixT > 0.0)
{
rgpulse(trim,v13,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v3,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9);
}
if ((getflag("zfilt")) && (getflag("PFGflg")))
{
obspower(tpwr);
rgpulse(pw,v7,1.0e-6,rof1);
zgradpulse(gzlvlz,gtz);
delay(gtz/3);
if (getflag("flipback"))
FBpulse(v8,v10);
rgpulse(pw,v8,rof1,rof2);
}
else
delay(rof2);
status(C);
}
pulsesequence()
{
double gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
zqfpw1 = getval("zqfpw1"),
zqfpwr1 = getval("zqfpwr1"),
gzlvlzq1 = getval("gzlvlzq1"),
gstab = getval("gstab"),
h1freq_local = getval("h1freq_local"),
flip1 = getval("flip1"),
flip2 = getval("flip2"),
swfactor = 9.0, /* do the adiabatic sweep over 9.0*sw */
gzlvlzq,invsw;
int iphase = (int) (getval("phase") + 0.5),
prgcycle = (int)(getval("prgcycle")+0.5);
char satmode[MAXSTR],
zqfpat1[MAXSTR],
wet[MAXSTR],
antiz_flg[MAXSTR],
alt_grd[MAXSTR];
getstr("satmode",satmode);
getstr("wet",wet);
getstr("zqfpat1",zqfpat1);
getstr("antiz_flg", antiz_flg);
getstr("alt_grd",alt_grd);
invsw = sw*swfactor;
if (invsw > 60000.0) invsw = 60000.0; /* do not exceed 60 kHz */
invsw = invsw/0.97; /* correct for end effects of the cawurst-20 shape */
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);
}
}
// sub(ct,ssctr,v12);
settable(t1,8,ph1); getelem(t1,v17,v1);
settable(t2,8,ph2); getelem(t2,v17,v2);
settable(t3,8,ph3); getelem(t3,v17,v3);
settable(t4,8,ph4); getelem(t4,v17,oph);
add(oph,v18,oph);
add(oph,v19,oph);
if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign */
if (getflag("Gzqfilt")) add(oph,two,oph);
if (iphase == 2) incr(v1);
/* HYPERCOMPLEX MODE USES REDFIELD TRICK TO MOVE AXIAL PEAKS TO EDGE */
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v6);
if ((iphase==1)||(iphase==2))
{add(v1,v6,v1); add(oph,v6,oph);}
/* BEGIN THE ACTUAL PULSE SEQUENCE */
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,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 (wet[0] == 'y')
wet4(zero,one);
obsstepsize(45.0);
initval(7.0,v7);
xmtrphase(v7);
status(B);
if (antiz_flg[0] == 'n') rgpulse(flip1*pw/90.0,v1,rof1,1.0e-6);
else rgpulse(flip1*pw/90.0+2.0*pw,v1,rof1,1.0e-6);
xmtrphase(zero);
if (d2 > 0.0)
{
if (antiz_flg[0] == 'n')
delay(d2-1.0e-6-rof1-SAPS_DELAY-(2.0*pw/3.14159)*(flip1+flip2)/90.0);
else
delay(d2-1.0e-6-rof1-SAPS_DELAY-(2.0*pw/3.14159)*(flip1+flip2)/90.0+4.0*pw);
}
else delay(0.0);
if (antiz_flg[0] == 'n') rgpulse(flip2*pw/90.0,v2,rof1,1.0e-6);
else rgpulse(flip2*pw/90.0+2.0*pw,v2,rof1,1.0e-6);
status(C);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr1);
rgradient('z',gzlvlzq1);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
obspower(tpwr);
}
ifzero(v8); zgradpulse(gzlvl1,gt1);
elsenz(v8); zgradpulse(-1.0*gzlvl1,gt1); endif(v8);
delay(gstab);
status(D);
rgpulse(flip2*pw/90.0,v3,rof1,rof2);
}
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 hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
tau,
evolcorr,
taug,
mult = getval("mult"),
null = getval("null");
int phase1 = (int)(getval("phase")+0.5),
prgcycle = (int)(getval("prgcycle")+0.5),
ZZgsign;
tau = 1/(4*(getval("j1xh")));
if (mult > 0.5)
taug = 2*tau;
else
taug = 0.0;
evolcorr=2*pw+4.0e-6;
ZZgsign=-1;
if (mult == 2) ZZgsign=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);
/*
mod2(id2,v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
if (phase1 == 2)
incr(v2);
add(v2,v14,v2);
add(oph,v14,oph);
if (mult > 0.5)
add(oph,two,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);
decpower(pwxlvl);
status(B);
if ((getflag("PFGflg")) && (getflag("nullflg")))
{
rgpulse(0.5*pw,zero,rof1,rof1);
delay(2*tau);
simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(1.5*pw,two,rof1,rof1);
zgradpulse(hsglvl,hsgt);
delay(1e-3);
}
else if (null != 0.0)
{
rgpulse(pw,zero,rof1,rof1);
delay(2*tau);
simpulse(2*pw,2*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(pw,two,rof1,rof1);
if (satmode[1] == 'y')
{
if (getflag("slpsat"))
shaped_satpulse("BIRDnull",null,zero);
else
satpulse(null,zero,rof1,rof1);
}
else
delay(null);
}
rgpulse(pw,v6,rof1,rof1);
delay(tau);
simpulse(2*pw,2*pwx,zero,zero,rof1,rof1);
delay(tau);
rgpulse(pw,v1,rof1,rof1);
if (getflag("PFGflg"))
{
zgradpulse(hsglvl,2*hsgt);
delay(1e-3);
}
decrgpulse(pwx,v2,rof1,2.0e-6);
if (mult > 0.5)
{
delay(d2/2);
rgpulse(2*pw,zero,2.0e-6,2.0e-6);
delay(d2/2);
delay(taug);
simpulse(mult*pw,2*pwx,zero,zero,rof1,rof1);
delay(taug + evolcorr);
}
else
{
if (d2/2 > 0.0)
delay(d2/2 - (2*pwx/PI) - pw - 4.0e-6);
else
delay(d2/2);
rgpulse(2*pw,zero,2.0e-6,2.0e-6);
if (d2/2 > 0.0)
delay(d2/2 - (2*pwx/PI) - pw - 4.0e-6);
else
delay(d2/2);
}
decrgpulse(pwx,v4,2.0e-6,rof1);
if (getflag("PFGflg"))
{
zgradpulse(ZZgsign*0.6*hsglvl,1.2*hsgt);
delay(1e-3);
}
rgpulse(pw,v3,rof1,rof1);
delay(tau - (2*pw/PI) - 2*rof1);
simpulse(2*pw,2*pwx,zero,zero,rof1, rof2);
decpower(dpwr);
delay(tau - POWER_DELAY);
status(C);
}
pulsesequence()
{
double hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
slpwT = getval("slpwT"),
slpwrT = getval("slpwrT"),
trim = getval("trim"),
mixT = getval("mixT"),
mult = getval("mult"),
tau,
null = getval("null");
char slpatT[MAXSTR];
int phase1 = (int)(getval("phase")+0.5);
tau = 1/(4*(getval("j1xh")));
getstr("slpatT",slpatT);
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);
settable(t1,8,phs1);
settable(t2,8,phs2);
settable(t3,2,phs3);
settable(t4,1,phs4);
settable(t5,4,phs5);
getelem(t3,ct,v6);
getelem(t2,ct,oph);
assign(two,v3);
sub(v3,one,v2);
add(v3,one,v4);
add(v3,two,v5);
/*
mod2(id2,v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
if (phase1 == 2)
incr(v6);
add(v14, v6, v6);
add(v14, oph, oph);
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
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,zero,rof1,rof1);
}
else
delay(d1);
if (getflag("wet"))
wet4(zero,one);
decpower(pwxlvl);
status(B);
if ((getflag("PFGflg")) && (getflag("nullflg")))
{
rgpulse(0.5*pw,zero,rof1,rof1);
delay(2*tau);
simpulse(2.0*pw,2.0*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(1.5*pw,two,rof1,rof1);
zgradpulse(hsglvl,hsgt);
delay(1e-3);
}
else if (null != 0.0)
{
rgpulse(pw,zero,rof1,rof1);
delay(2*tau);
simpulse(2*pw,2*pwx,zero,zero,rof1,rof1);
delay(2*tau);
rgpulse(pw,two,rof1,rof1);
if (satmode[1] == 'y')
satpulse(null,zero,rof1,rof1);
else
delay(null);
}
rgpulse(pw, t1, rof1, rof1);
delay(2*tau - (2*pw/PI) - 2*rof1);
decrgpulse(pwx, v6, rof1, 1.0e-6);
if (d2 > 0.0)
delay(d2/2.0 - pw - 3.0e-6 - (2*pwx/PI));
else
delay(d2/2.0);
rgpulse(2.0*pw, t4, 2.0e-6, 2.0e-6);
if (d2 > 0.0)
delay(d2/2.0 - pw - 3.0e-6 - (2*pwx/PI));
else
delay(d2/2.0);
decrgpulse(pwx, t5, 1.0e-6, rof1);
obspower(slpwrT);
decpower(dpwr);
delay(2*tau - rof1 - 2*POWER_DELAY);
if (mixT > 0.0)
{
rgpulse(trim,v5,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v3,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5,v9);
}
if (mult > 0.5)
{
obspower(tpwr);
obspower(pwxlvl);
delay(2*tau - POWER_DELAY - rof1);
simpulse(2*pw,mult*pwx,zero,zero,rof1,rof2);
decpower(dpwr);
delay(2*tau);
}
else
delay(rof2);
status(C);
}
