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 pulsesequence()
{
double ss,
arraydim,
p1lvl,
trim,
mix,
window,
cycles,
phase;
int iphase;
char sspul[MAXSTR];
/* LOAD AND INITIALIZE VARIABLES */
ni = getval("ni");
arraydim = getval("arraydim");
mix = getval("mix");
trim = getval("trim");
phase = getval("phase");
iphase = (int) (phase + 0.5);
p1lvl = getval("p1lvl");
ss = getval("ss");
window=getval("window");
getstr("sspul", sspul);
if (iphase == 3)
{
initval((double)((int)((ix-1)/(arraydim/ni)+1.0e-6)), v14);
}
else
{
assign(zero, v14);
}
/* CHECK CONDITIONS */
if ((iphase != 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);
}
/* 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);
/* 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 (iphase == 2)
incr(v1);
if (iphase == 3)
add(v1, v14, 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);}
/* 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);
rlpower(p1lvl, TODEV);
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 (getflag("wet")) wet4(zero,one);
rlpower(p1lvl, TODEV);
if (satmode[A] == 'y')
{ rlpower(satpwr,TODEV);
rgpulse(satdly,zero,rof1,rof2);
rlpower(p1lvl,TODEV);}
status(B);
rgpulse(p1, v1, rof1, 1.0e-6);
if (satmode[B] =='y')
{
if (d2 > 0.0)
{
rlpower(satpwr,TODEV);
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();
rlpower(tpwr,TODEV);
txphase(v13);
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();
status(C);
}
pulsesequence()
{
double gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gstab = getval("gstab"),
del = getval("del"),
tweek = getval("tweek"),
prgtime = getval("prgtime"),
prgpwr = getval("prgpwr"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
wrefpwr = getval("wrefpwr"),
wrefpw = getval("wrefpw"),
wrefpwrf = getval("wrefpwrf"),
dosytimecubed,dosyfrq,Ddelta;
char delflag[MAXSTR],lkgate_flg[MAXSTR],alt_grd[MAXSTR],prg_flg[MAXSTR];
char satmode[MAXSTR],sspul[MAXSTR],wrefshape[MAXSTR];
getstr("delflag",delflag);
getstr("lkgate_flg",lkgate_flg);
getstr("alt_grd",alt_grd);
getstr("prg_flg",prg_flg);
getstr("satmode",satmode);
getstr("sspul",sspul);
getstr("wrefshape", wrefshape);
//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);
if (del<(3*gt1+3.0*gstab+2.0*rof1+pw*2.0))
{ abort_message("DgcsteSL error: del is less than %f, too short!",
(3*gt1+3.0*gstab+2.0*rof1+pw*2.0));
}
/* Safety check for the duration of the purge pulse */
if (prgtime > 4.0e-2)
{ text_error("prgtime has been reset to a maximum of 2 ms");
prgtime = 2.0e-3;
}
dosyfrq=sfrq;
Ddelta=gt1; /* the diffusion-encoding pulse width is gt1 */
dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* phase cycling calculation */
if (delflag[0]=='y')
{ hlv(ct,v4);
mod2(v4,v2);
mod2(ct,v1);
dbl(v1,v1);
add(v2,v1,v1);
mod4(v1,v1); /* 0 2 1 3 , 1st 90 */
hlv(v4,v4);
mod2(v4,v3);
dbl(v3,v3); /* (0)4 (2)4 */
hlv(v4,v4);
mod2(v4,v2);
dbl(v2,v2); /* (0)8 (2)8 */
hlv(v4,v4);
mod2(v4,v5);
add(v5,v3,v3);
mod4(v3,v3); /* {(0)4 (2)4}2 {(1)4 (3)4}2, 3rd 90 */
hlv(v4,v4);
assign(v4,v6);
mod2(v4,v4);
add(v4,v2,v2);
mod4(v2,v2); /* {(0)8 (2)8}2 {(1)8 (3)8}2, 2nd 90 */
mod2(ct,v10); /* gradients change sign every increment */
assign(v3,oph);
add(oph,v2,oph);
sub(oph,v1,oph);
mod4(oph,oph);
assign(oph,v5);
add(one,v5,v5);
mod2(ct,v7);
dbl(v7,v7);
hlv(v6,v6);
mod2(v6,v6);
dbl(v6,v6);
add(v7,v5,v5); /* the purge pulse is 90 deg. off the receiver phase */
add(v6,v5,v5); /* it is phase alternated every increment */
mod4(v5,v5); /* and also every 64 increments */
}
else
{
assign(ct,v4);
assign(oph,v4); /*v4 used only for normal s2pul- type sequence */
}
add(v3,two,v9);
if (ni > 1.0)
{ abort_message("DgcsteSL is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
/* equilibrium period */
status(A);
obspower(tpwr);
if (sspul[A] == 'y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0)
delay(d1 - satdly);
else delay(0.02);
obspower(satpwr);
txphase(v1);
rgpulse(satdly,zero,rof1,rof1);
obspower(tpwr);
delay(1.0e-5);
}
else
{ delay(d1); }
obspower(tpwr);
status(B);
/* first part of bppdel sequence */
if(delflag[0] == 'y')
{ 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);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else
zgradpulse(gzlvl1,gt1);
delay(gstab);
rgpulse(pw, v2, rof1, 0.0); /* second 90, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v10); /* compensating AND CPS gradient */
zgradpulse(-1.0*gzlvl1*(1.0-tweek),gt1);
elsenz(v10);
zgradpulse(gzlvl1*(1.0-tweek),gt1);
endif(v10);
}
else /* compensating AND CPS gradient */
zgradpulse(-1.0*gzlvl1*(1.0-tweek),gt1);
delay(gstab);
if (satmode[B] == 'y')
{ obspower(satpwr);
rgpulse(del-3.0*(gt1+gstab)-2.0*rof1-pw*2.0,zero,rof1,rof1);
obspower(tpwr);
}
else
delay(del-3.0*(gt1+gstab)-2.0*rof1-pw*2.0); /* diffusion delay */
if (alt_grd[0] == 'y')
{
ifzero(v10);
zgradpulse(-1.0*gzlvl1*(1.0+tweek),gt1);
elsenz(v10);
zgradpulse(gzlvl1*(1.0+tweek),gt1);
endif(v10);
}
else
zgradpulse(-1.0*gzlvl1*(1.0+tweek),gt1);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* third 90, v3 */
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(-gzlvl2,gt2); endif(v10);}
else zgradpulse(gzlvl2,gt2);
obspower(wrefpwr+6); obspwrf(wrefpwrf);
delay(gstab);
shaped_pulse(wrefshape,wrefpw,v9,rof1,0.0);
obspower(tpwr); obspwrf(4095.0);
rgpulse(2.0*pw,v3,rof1,0.0);
if (alt_grd[0] == 'y')
{ ifzero(v10); zgradpulse(gzlvl2,gt2);
elsenz(v10); zgradpulse(-gzlvl2,gt2); endif(v10);}
else zgradpulse(gzlvl2,gt2);
obspower(wrefpwr+6); obspwrf(wrefpwrf);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10); zgradpulse(1.2*gzlvl2,gt2);
elsenz(v10); zgradpulse(-1.2*gzlvl2,gt2); endif(v10); }
else zgradpulse(1.2*gzlvl2,gt2);
delay(gstab);
shaped_pulse(wrefshape,wrefpw,v9,rof1,0.0);
obspower(tpwr); obspwrf(4095.0);
rgpulse(2.0*pw,v3,rof1,rof1);
if (alt_grd[0] == 'y')
{ ifzero(v10); zgradpulse(1.2*gzlvl2,gt2);
elsenz(v10); zgradpulse(-1.2*gzlvl2,gt2); endif(v10); }
else zgradpulse(1.2*gzlvl2,gt2);
delay(gstab+2.0*pw/3.14);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
/* purge pulse to scramble any magnetisation that
is not in phase with the receiver */
if (prg_flg[0] == 'y')
{ obspower(prgpwr);
rgpulse(prgtime, v5, rof1, 0.0);
}
}
else
rgpulse(pw, v4, rof1, rof2); /* first 90, v1 */
status(C);
}
pulsesequence()
{
double hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
satpwr = getval("satpwr"),
satdly = getval("satdly");
int prgcycle = (int)(getval("prgcycle")+0.5);
char sspul[MAXSTR],satmode[MAXSTR],wet[MAXSTR];
getstr("satmode",satmode);
getstr("sspul", sspul);
getstr("wet",wet);
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); getelem(t1,v17,v1);
settable(t2,8,ph2); getelem(t2,v17,v2);
assign(v1,oph);
add(oph,v18,oph);
add(oph,v19,oph);
/* BEGIN ACTUAL 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,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/2);
rgpulse(2.0*pw, v2, rof1, 2*rof1);
delay(d2/2 + 2*pw/PI);
status(C);
}
pulsesequence ()
{
double gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
mix = getval("mix"),
wrefpw = getval("wrefpw"),
wrefpwr = getval("wrefpwr"),
wrefpwrf = getval("wrefpwrf"),
phincr1 = getval("phincr1"),
flippwr = getval("flippwr"),
flippwrf = getval("flippwrf"),
flippw = getval("flippw"),
trimpwr = getval("trimpwr"),
gt0 = getval("gt0"),
gzlvl0 = getval("gzlvl0"),
trim = getval("trim"),
satpwr = getval("satpwr"),
satfrq = getval("satfrq"),
satfrqref = getval("satfrqref"),
satpw = getval("satpw"),
d3 = getval("d3"),
xferdly = getval("xferdly"),
h1freq_local = getval("h1freq_local"),
gcal_local = getval("gcal_local"),
coil_size = getval("coil_size"),
swfactor = 9.0, /* do the adiabatic sweep over 9.0*sw */
zqpwr=getval("zqpwr"), zqpw=getval("zqpw"),
gzlvlzq,invsw,cycles;
int iphase = (int) (getval("phase") + 0.5);
char sspul[MAXSTR], trim_flg[MAXSTR], wrefshape[MAXSTR],flipback[MAXSTR],
zqshape[MAXSTR],
zqflg[MAXSTR], alt_grd[MAXSTR],flipshape[MAXSTR],satshape[MAXSTR];
getstr("sspul", sspul);
getstr("trim_flg", trim_flg);
getstr("wrefshape", wrefshape);
getstr("flipshape", flipshape);
getstr("flipback", flipback);
getstr("zqflg", zqflg);
getstr("zqshape", zqshape);
getstr("alt_grd",alt_grd);
getstr("satshape",satshape);
rof1 = getval("rof1"); if(rof1 > 2.0e-6) rof1=2.0e-6;
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v13);
cycles = xferdly/(d3+satpw) + 0.5;
initval(cycles,v14);
if (coil_size == 0) coil_size=16;
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 */
if ((zqflg[0] == 'y') && (mix < 0.051))
{
printf("Mixing time should be more than 51 ms for zero quantum suppression\n");
psg_abort(1);
}
gzlvlzq=(invsw*h1freq_local*2349)/(gcal_local*coil_size*sfrq*1e+6);
sub(ct,ssctr,v12);
settable(t1,32,phi1); getelem(t1,v12,v1);
settable(t2,32,phi2); getelem(t2,v12,v2);
settable(t3,32,phi3); getelem(t3,v12,v3);
settable(t4,32,phi4); getelem(t4,v12,v4);
settable(t5,32,phi5); getelem(t5,v12,v5);
settable(t7,32,phi7); getelem(t7,v12,v7);
/* settable(t8,32,phi8); getelem(t8,v12,v8); */
settable(t6,32,rec); getelem(t6,v12,oph);
settable(t9,32,phi9); getelem(t9,v12,v6);
if (zqflg[0] == 'y') add(oph,two,oph);
hlv(ct,v10); mod2(v10,v10); /*changing gradient sign between sanc1-2 and 3-4 etc. */
if (iphase == 2)
{ incr(v1); incr(v6); }
/* HYPERCOMPLEX MODE USES REDFIELD TRICK TO MOVE AXIAL PEAKS TO EDGE */
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v9);
if ((iphase == 1)||(iphase == 2)) {add(v1,v9,v1); add(oph,v9,oph), add(v6,v9,v6);}
status(A);
obspower(tpwr); obspwrf(4095.0); decpower(dpwr);
if (sspul[A] == 'y')
{
zgradpulse(gzlvl0,gt0);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvl0,gt0);
}
if (d1 > xferdly) delay(d1-xferdly);
/* set saturation frequencies */
mod2(ct,v8); /* 0 1 0 1 0 1 0 1 ..frequency switch
on every second transient */
ifzero(v8); obsoffset(satfrq);
elsenz(v8); obsoffset(satfrqref);
endif(v8);
/* Start the selective saturation of protein */
obspower(satpwr);
if (cycles > 0.0)
{
starthardloop(v14);
delay(d3);
shaped_pulse(satshape,satpw,zero,rof1,rof1);
endhardloop();
}
obspower(tpwr); obsoffset(tof);
status(B);
settable(t8,32,phi8); getelem(t8,v12,v8);
obsstepsize(45.0);
initval(7.0,v11);
xmtrphase(v11);
rgpulse(pw,v1,rof1,rof1);
if (trim_flg[0] == 'y')
{ obspower(trimpwr);
rgpulse(trim,v6,rof1,rof1);
obspower(tpwr);
}
xmtrphase(zero);
if (trim_flg[0] == 'y')
{
if (d2-2.0*pw/3.14 - 2.0*rof1 - SAPS_DELAY - 2.0*POWER_DELAY> 0)
delay(d2-2.0*pw/3.14-2.0*rof1-SAPS_DELAY - 2.0*POWER_DELAY);
else
delay(0.0);
}
else
{
if (d2-4.0*pw/3.14 - 2.0*rof1 - SAPS_DELAY> 0)
delay(d2-4.0*pw/3.14-2.0*rof1-SAPS_DELAY);
else
delay(0.0);
}
rgpulse(pw,v7,rof1,rof1);
if (zqflg[0] == 'y')
{
ifzero(v10); rgradient('z',gzlvlzq);
elsenz(v10); rgradient('z',-1.0*gzlvlzq); endif(v10);
obspower(zqpwr);
shaped_pulse(zqshape,zqpw,zero,rof1,rof1);
obspower(tpwr);
rgradient('z',0.0);
delay((mix-0.050-gt1)*0.7);
if (alt_grd[0] == 'y')
{
ifzero(v10); zgradpulse(gzlvl1,gt1);
elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (flipback[0] == 'n')
delay((mix-0.05-gt1)*0.3);
else
{ delay((mix-0.05-gt1)*0.3 - flippw - rof1);
obsstepsize(1.0);
xmtrphase(v13);
add(v8,two,v8);
obspower(flippwr+6); obspwrf(flippwrf);
shaped_pulse(flipshape,flippw,v8,rof1,rof1);
xmtrphase(zero);
add(v8,two,v8);
obspower(tpwr); obspwrf(4095.0);
}
}
else
{
delay(mix*0.7);
if (alt_grd[0] == 'y')
{
ifzero(v10); zgradpulse(gzlvl1,gt1);
elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (flipback[0] == 'n')
delay(mix*0.3-gt2);
else
{ delay(mix*0.3 - flippw - rof1);
obsstepsize(1.0);
xmtrphase(v13);
add(v8,two,v8);
obspower(flippwr+6); obspwrf(flippwrf);
shaped_pulse(flipshape,flippw,v8,rof1,rof1);
xmtrphase(zero);
add(v8,two,v8);
obspower(tpwr); obspwrf(4095.0);
}
}
obspower(tpwr);
rgpulse(pw,v8,rof1,rof1);
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);
obspower(wrefpwr+6); obspwrf(wrefpwrf);
shaped_pulse(wrefshape,wrefpw,v5,rof1,rof1);
obspower(tpwr); obspwrf(4095.0);
rgpulse(2.0*pw,v4,rof1,rof1);
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(1.2*gzlvl2,gt2);
elsenz(v10); zgradpulse(-1.2*gzlvl2,gt2); endif(v10);
}
else zgradpulse(1.2*gzlvl2,gt2);
delay(gstab);
obspower(wrefpwr+6); obspwrf(wrefpwrf);
shaped_pulse(wrefshape,wrefpw,v3,rof1,rof1);
obspower(tpwr); obspwrf(4095.0);
rgpulse(2.0*pw,v2,rof1,rof2);
if (alt_grd[0] == 'y')
{
ifzero(v10); zgradpulse(1.2*gzlvl2,gt2);
elsenz(v10); zgradpulse(-1.2*gzlvl2,gt2); endif(v10);
}
else zgradpulse(1.2*gzlvl2,gt2);
delay(gstab);
status(C);
}
pulsesequence()
{
double hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
tau,
taug,
evolcorr,
pwx180 = getval("pwx180"),
pwxlvl180 = getval("pwxlvl180"),
pwx180r = getval("pwx180r"),
pwxlvl180r = getval("pwxlvl180r"),
mult = getval("mult"),
null = getval("null");
int phase1 = (int)(getval("phase")+0.5),
prgcycle = (int)(getval("prgcycle")+0.5),
ZZgsign;
char pwx180ad[MAXSTR],
pwx180adR[MAXSTR],
pwx180ref[MAXSTR];
getstr("pwx180ad", pwx180ad);
getstr("pwx180adR", pwx180adR);
getstr("pwx180ref", pwx180ref);
tau = 1/(4*(getval("j1xh")));
evolcorr = (4*pwx/PI) + 2*pw + 8.0e-6;
if (mult > 0.5)
taug = 2*tau + getval("tauC");
else
taug = 0.0;
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);
if (phase1 == 2)
incr(v2);
/*
mod2(id2,v14);
dbl(v14, v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),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);
decpower(pwxlvl);
status(B);
if ((getflag("PFGflg")) && (getflag("nullflg")))
{
rgpulse(0.5 * pw, zero, rof1, rof1);
delay(2 * tau);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(2 * tau + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
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);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(2 * tau + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
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);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(tau + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
rgpulse(pw, v1, rof1, rof1);
if (getflag("PFGflg"))
{
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);
if (mult>0.5)
{
delay(taug);
decpower(pwxlvl180r);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
rgpulse(mult * pw, zero, rof1, rof1);
delay(taug - mult*pw - 2*rof1 + 2*POWER_DELAY + evolcorr);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
}
else
{
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
delay(2*POWER_DELAY + evolcorr);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
}
decpower(pwxlvl);
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);
decpower(pwxlvl180);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(dpwr);
delay(tau - 2*rof1 - (2*pw/PI));
rgpulse(2 * pw, zero, rof1, rof2);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
decpower(dpwr);
delay(tau);
status(C);
}
void 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"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
tauA=getval("tauA"), //compensation for tauB and tauD
tauB=getval("tauB"), //effect of rof2
tauD=getval("tauD"), //effect of alfa
tBal=getval("tBal"), //supports inova console if ~1/(fb*1.3)
pwr_XBIP = getval("pwr_XBIP"),
pw_XBIP = getval("pw_XBIP"),
pwr_HBIP = getval("pwr_HBIP"),
pw_HBIP = getval("pw_HBIP"),
gzlvlcr = getval("gzlvlcr"),
gtcr = getval("gtcr"), //crusher gradient in BIRD
npoints = getval("npoints"), // npoints should be an integer multiple of np
tau, evolcorr, taug,cycles;
int prgcycle = (int)(getval("prgcycle")+0.5),
phase1 = (int)(getval("phase")+0.5),
icosel, ZZgsign;
char pwx180ad[MAXSTR], pwx180adR[MAXSTR], pwx180ref[MAXSTR],
shp_XBIP[MAXSTR], shp_HBIP[MAXSTR], BIRD[MAXSTR], BIRDmode[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("pwx180adR", pwx180adR);
getstr("pwx180ref", pwx180ref);
getstr("shp_XBIP",shp_XBIP);
getstr("shp_HBIP",shp_HBIP);
getstr("BIRD",BIRD);
getstr("BIRDmode",BIRDmode);
tau = 1 / (4*(getval("j1xh")));
evolcorr = (4*pwx/PI)+2*pw+8.0e-6;
cycles=np/npoints;
cycles = (double)((int)((cycles)));
initval(cycles,v20);
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);
}
}
if (BIRD[0]=='n') //gHSQC phases
{
settable(t1,4,ph1);
settable(t2,2,ph2);
settable(t3,8,ph3);
settable(t4,16,ph4);
settable(t5,16,ph5);
}
else //rtgHSQC-BIRD phases
{
settable(t1,8,ph11);
settable(t2,2,ph12);
settable(t3,16,ph13);
settable(t4,32,ph14);
settable(t5,32,ph15);
settable(t7,4,ph17);
settable(t8,4,ph18);
settable(t9,4,ph19);
getelem(t7, v17, v7);
getelem(t8, v17, v8);
getelem(t9, v17, v9);
}
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);
add(v2, v14, v2);
add(oph, v14, oph);
status(A);
obspower(tpwr); decpower(pwxlvl);
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);
status(B);
/****** null flag starts here *****/
if (getflag("nullflg"))
{
rgpulse(0.5 * pw, zero, rof1, rof1);
delay(2 * tau);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(2 * tau + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
rgpulse(1.5 * pw, two, rof1, rof1);
zgradpulse(hsglvl, hsgt);
delay(1e-3);
}
/*********gHSQC or gHSQC part of pure shift starts here *****/
if (getflag("cpmgflg"))
{
rgpulse(pw, v6, rof1, 0.0);
cpmg(v6, v15);
}
else
rgpulse(pw, v6, rof1, rof1);
delay(tau);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
rgpulse(2.0 * pw, zero, rof1, rof1);
delay(tau + 2 * POWER_DELAY);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(pwxlvl);
rgpulse(pw, v1, 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(taug - POWER_DELAY);
if (mult > 0.5)
{
decpower(pwxlvl180r);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
rgpulse(mult * pw, zero, rof1, rof1);
delay(taug - mult * pw - 2 * rof1 + POWER_DELAY - gtE - gstab - 2 * GRADIENT_DELAY+evolcorr);
zgradpulse(gzlvlE, gtE);
delay(gstab);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
}
else
{
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
delay(taug + POWER_DELAY - gtE - gstab - 2 * GRADIENT_DELAY+evolcorr);
zgradpulse(gzlvlE, gtE);
delay(gstab);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
}
decpower(pwxlvl);
decrgpulse(pwx, v4, 2.0e-6, rof1);
zgradpulse(ZZgsign*0.6 * hsglvl, 1.2 * hsgt);
delay(1e-3);
rgpulse(pw, v3, rof1, rof1);
decpower(pwxlvl180);
decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1);
decpower(dpwr);
delay(tau - (2 * pw / PI) - 2*rof1);
rgpulse(2 * pw, zero, rof1, rof2);
decpower(pwxlvl180);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
decpower(dpwr);
zgradpulse(icosel * 2.0*gzlvlE/EDratio, gtE/2.0);
delay(tau - gtE/2.0 - 2 * GRADIENT_DELAY);
/********gHSQC part stops and BIRD Acquisition starts here*************/
// delay(tBal);
//filter delay (Hoult) for inova; adjust tBal manually for the same effect
//delay(1.0/(getval("fb")*1.3))
if (BIRD[0]=='y')
{
#ifdef NVPSG
setacqmode(WACQ|NZ); //use this line only for vnmrs console; comment this out in inova
#endif
obsblank();
// delay(rof2);
startacq(alfa);
}
/*----------------------------------------------------------------------------
Observe the 1st half chunk
-----------------------------------------------------------------------------*/
if (BIRD[0]=='y')
{
status(C);
acquire(npoints/2.0,1.0/sw);
rcvroff();
status(B);
obspower(tpwr);
/*------------------------------------------------------------------------
Using hard 13C inversion pulse in BIRD
--------------------------------------------------------------------------*/
if (BIRDmode[0]== 'h')
{
rgpulse(pw,v7,rof1,rof1);
decpower(pwxlvl);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
simpulse(2.0*pw,2.0*pwx,v8,v8,rof1,rof1);
decpower(dpwr);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
rgpulse(pw,v9,rof1,rof1);
}
/*---------------------------------------------------------------------------
Using BIP 13C inversion pulse in BIRD
----------------------------------------------------------------------------*/
if (BIRDmode[0]== 'b')
{
rgpulse(pw,v7,rof1,rof1);
if (pwr_XBIP!=pwxlvl) decpower(pwr_XBIP); else decpower(pwxlvl);
if (pwr_HBIP!=tpwr) obspower(pwr_HBIP);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
simshaped_pulse(shp_HBIP,shp_XBIP,2.0*pw,pw_XBIP,v8,v8,rof1,rof1);
if (pwr_HBIP!=tpwr) obspower(tpwr);
decpower(dpwr);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
rgpulse(pw,v9,rof1,rof1);
}
delay(tauA);
rgpulse(pw*2.0,v7,rof1,rof1); // hard 180 degree refocusing pulse
obsblank();
delay(tauB);
rcvron(); //this includes rof3
delay(tauD);
decr(v20);
/*------------------------------------------------------------------------------
Loops for more chunks
------------------------------------------------------------------------------*/
starthardloop(v20);
status(C);
acquire(npoints,1.0/sw);
rcvroff();
status(B);
obspower(tpwr);
/*------------------------------------------------------------------------
Using hard 13C inversion pulse in BIRD
--------------------------------------------------------------------------*/
if (BIRDmode[0]== 'h')
{
rgpulse(pw,v7,rof1,rof1);
decpower(pwxlvl);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
simpulse(2.0*pw,2.0*pwx,v8,v8,rof1,rof1);
decpower(dpwr);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
rgpulse(pw,v9,rof1,rof1);
}
/*---------------------------------------------------------------------------
Using BIP 13C inversion pulse in BIRD
----------------------------------------------------------------------------*/
// if (BIRDmode[0]== 'b')
if (BIRDmode[0]== 'b')
{
rgpulse(pw,v7,rof1,rof1);
if (pwr_XBIP!=pwxlvl) decpower(pwr_XBIP); else decpower(pwxlvl);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
simshaped_pulse(shp_HBIP,shp_XBIP,2*pw,pw_XBIP,v8,v8,rof1,rof1);
decpower(dpwr);
delay(tau);
zgradpulse(gzlvlcr,gtcr);
delay(tau-gtcr);
rgpulse(pw,v9,rof1,rof1);
}
delay(tauA);
rgpulse(pw*2.0,v7,rof1,rof1); // hard 180 degree refocusing pulse
obsblank();
delay(tauB);
rcvron(); //this includes rof3
delay(tauD);
endhardloop();
/*----------------------------------------------------------------
Acquisition of last half chunk
----------------------------------------------------------------*/
status(C);
acquire(npoints/2.0,1.0/sw);
rcvroff();
endacq();
incr(v20);
}
/****** BIRD ends here for all *****/
/***************** ACQ for conventional gHSQC ******************************/
else
status(C);
}
pulsesequence()
{
char normal[MAXSTR],
focus[MAXSTR];
double pp, mult, j, d3;
/* GATHER AND INTIALIZE */
getstr("focus", focus);
getstr("normal", normal);
pp = getval("pp");
mult = getval("mult");
j = getval("j");
/* if mult is zero, then do normal s2pul sequence */
if (mult == 0.0)
{
/* calculate phases */
mod2(ct,v1); /* v1 = 01010101 */
dbl(v1,v2); /* v2 = 02020202 */
hlv(ct,v3); /* v3 = 00112233 */
mod2(v3,v3); /* v3 = 00110011 */
add(v2,v1,v4); /* v4 = 02130213 */
assign(v4,oph);
status(A);
hsdelay(d1);
pulse(p1, zero);
status(B);
delay(d2);
status(C);
pulse(pw,v4);
}
else
{
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);
}
}
/* setup phases */
hlv(oph, v1); /* 0011 */
dbl(v1, v1); /* 0022 */
mod2(oph, v2); /* 0101 */
/* 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);
status(A);
delay(d1);
/* excitation transfer */
status(B);
decrgpulse(pp, v1, rof1, rof1);
delay(d3/2 - 2*rof1 - 3*pp/2);
simpulse(2*pw, 2*pp, zero, zero, rof1, rof1);
delay(d3/2 - 2*rof1 - 3*pp/2);
simpulse(pw, pp, v2, one, rof1, rof2);
/* make decision on refocussing */
if ((focus[A] == 'y') || (dm[C] == 'y'))
{
delay(d2/2 - rof1 - pp); /* refocussing delay varied for 2d */
simpulse(2*pw, 2*pp, v2, zero, rof1, rof2);
delay(d2/2 - rof2 - pp);
}
else if (normal[A] == 'y')
{
decrgpulse(pp, v1, 1.0e-6, 0.0);
}
if (declvlonoff)
declvloff();
else
decpower(dpwr);
status(C);
}
}
pulsesequence()
{
char N15edit[MAXSTR], C13edit[MAXSTR]; /* C13 editing*/
double tpwrs,pwC,d2,tau,d3,d4,d5,d6,
gt2,gt3,gt0,gzlvl0,gzlvl2,gzlvl3,phincr1,tpwrsf_u,tpwrsf_d,pwHs,compH,
pwN,pwNlvl,ref_pwr,ref_pw90,pwZa,pwClvl,JXH;
pwC=getval("pwC");
pwClvl=getval("pwClvl");
ref_pw90=getval("ref_pw90");
ref_pwr=getval("ref_pwr");
pwHs=getval("pwHs");
gt2=getval("gt2");
gt3=getval("gt3");
gt0=getval("gt0");
/* tau=getval("tau"); */
d2=getval("d2");
d3=getval("d3");
d4=getval("d4");
d5=getval("d5");
gzlvl2=getval("gzlvl2");
gzlvl3=getval("gzlvl3");
gzlvl0=getval("gzlvl0");
phincr1 = getval("phincr1");
d6=getval("d6");
JXH = getval("JXH");
tpwrsf_u = getval("tpwrsf_u"); /* fine power adjustment */
tpwrsf_d = getval("tpwrsf_d"); /* fine power adjustment */
pwHs = getval("pwHs"); /* H1 90 degree pulse length at tpwrs2 */
compH = getval("compH");
pwNlvl = getval("pwNlvl"); /* power for N15 pulses */
pwN = getval("pwN"); /* N15 90 degree pulse length at pwNlvl */
getstr("N15edit",N15edit);
getstr("C13edit",C13edit);
pwZa=pw; /* initialize variable */
/* optional editing for C13 enriched samples */
if ((N15edit[A]=='y') && (C13edit[A]=='n'))
{
pwC = 0.0;
if (2.0*pw > 2.0*pwN) pwZa = pw;
else pwZa = pwN;
}
if ((C13edit[A]=='y')&& (N15edit[A]=='n'))
{
pwN = 0.0;
if (2.0*pw > 2.0*pwC) pwZa = pw;
else pwZa = pwC;
}
if ((C13edit[A]=='y') && (N15edit[A]=='y'))
{
if (2.0*pw > 2.0*pwN) pwZa = pw; /*pwN always longer than pwC*/
else pwZa = pwN;
}
tau = 1/(2*(JXH));
printf("tau is %f\n",tau);
printf("pwZa is %f\n",pwZa);
/* set pwZa to either pw or pwX depending on which is the largest (for calculating delays) */
/*calculate phase cycle for WATERGATE*/
hlv(ct,v1);
hlv(v1,v2);
mod2(v2,v3);
dbl(v3,v4);
assign(two,v5);
add(v4,v5,v6);
obsstepsize(1.0);
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v7);
settable(t1,16,ph1);
settable(t2,16,ph2);
settable(t3,16,ph3);
settable(t4,16,ph4);
settable(t5,16,ph5);
settable(t6,16,ph6);
settable(t7,16,ph7);
settable(t8,16,ph8);
settable(t9,16,ph9);
settable(t10,2,ph10);
tpwrs=tpwr-20.0*log10(pwHs/(compH*pw*1.69)); /* sinc pulse */
tpwrs = (int) (tpwrs) +6.0; /* to permit finepower ~2048 */
/* START THE PULSE SEQUENCE */
status(A);
decpower(pwClvl);
delay(d1);
obsoffset(tof);
/*zgradpulse(gzlvl2,gt2);
delay(d3+d5-pwHs);*/
obspower(tpwrs); obspwrf(tpwrsf_d);
shaped_pulse("H2Osinc_d",pwHs,t2,rof1,rof1);
status(B);
obspower(tpwr); obspwrf(4095.0);
rgpulse(pw,t1,3.0e-6,0.0);
delay(d2);
zgradpulse(gzlvl2,gt2);
delay(d5);
rgpulse(pw,t3,3.0e-6,3.0e-6);
obspower(tpwrs); obspwrf(tpwrsf_u);
shaped_pulse("H2Osinc_u",pwHs,t4,rof1,rof1);
zgradpulse(gzlvl3,gt3);
delay(d3); obspwrf(tpwrsf_d);
shaped_pulse("H2Osinc_d",pwHs,t6,rof1,rof1);
obspower(tpwr); obspwrf(4095.0);
rgpulse(pw,t5,3.0e-6,3.0e-6);
delay(d2);
zgradpulse(gzlvl2,gt2);
delay(d5);
delay(d6);
zgradpulse(gzlvl0,gt0);
obspower(tpwrs);
obspwrf(tpwrsf_d);
xmtrphase(v7);
delay(tau-pwHs-pwZa-gt0-d6-pwN);
shaped_pulse("H2Osinc_d",pwHs,v6,rof1,rof1);
obspower(tpwr);
obspwrf(4095.0);
xmtrphase(zero);
dec2power(pwNlvl);
dec2rgpulse(pwN,zero,1.0e-6,1.0e-6);
decrgpulse(pwC,zero,1.0e-6,1.0e-6);
rgpulse(2*pw,t7,1.0e-6, 1.0e-6);
decrgpulse(pwC,t10,1.0e-6,1.0e-6);
dec2rgpulse(pwN,t10,1.0e-6,1.0e-6);
obspower(tpwrs);
obspwrf(tpwrsf_u);
shaped_pulse("H2Osinc_u",pwHs,t9,rof1,rof1);
delay(tau-pwHs-pwZa-gt0-d6-pwN);
zgradpulse(gzlvl0,gt0);
dec2power(dpwr2);
decpower(dpwr);
delay(d6);
setreceiver(t8);
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,
prgcycle = (int)(getval("prgcycle")+0.5),
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;
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) || (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);
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("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,v6,rof1,rof1);
delay(tau);
simpulse(2*pw,2*pwx,zero,zero,rof1,rof1);
delay(tau);
rgpulse(pw,v1,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,v4,2.0e-6,rof1);
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);
zgradpulse(icosel*2.0*gzlvlE/EDratio,gtE/2.0);
delay(tau - gtE/2.0 - 2*GRADIENT_DELAY - POWER_DELAY);
status(C);
}
pulsesequence()
{
int mult = (0.5 + getval("mult"));
char focus[MAXSTR];
double tau1, tau2,
pp = getval("pp"),
pplvl = getval("pplvl"),
j = getval("j");
getstr("focus", focus);
if (dm[C] == 'y') focus[A]='y';
if (j < 0.1) j = 140.0;
if (rof1 < 1.0e-6) rof1 = 1.0e-6;
tau1 = 0.25/j;
tau2 = tau1;
if (mult == 2) tau2 = 0.125/j;
if (mult == 3) tau2 = 0.1/j;
/* setup phases */
hlv(oph, v1); /* 0011 */
dbl(v1, v1); /* 0022 */
mod2(oph, v2); /* 0101 */
if ((dm[A] == 'y') || (dm[B] == 'y'))
{
(void) printf("Decoupler must be set as dm=nny or n\n");
psg_abort(1);
}
status(A);
delay(d1);
decpower(pplvl);
status(B); /* excitation transfer */
decrgpulse(pp, v1, rof1, rof1);
delay(tau1);
simpulse(2*pw, 2*pp, zero, zero, rof1, rof1);
delay(tau1);
if (focus[A] == 'y') /* refocussing */
{
simpulse(pw, pp, v2, one, rof1, rof1);
delay(tau2);
simpulse(2*pw, 2*pp, v2, zero, rof1, rof1);
delay(tau2 - pp - POWER_DELAY);
decrgpulse(pp, v1, rof1, rof2);
}
else
simpulse(pw, pp, v2, one, rof1, rof2);
decpower(dpwr);
status(C);
}
pulsesequence()
{
double j1min = getval("j1min"),
j1max = getval("j1max"),
pwx180 = getval("pwx180"),
pwxlvl180 = getval("pwxlvl180"),
pwx180r = getval("pwx180r"),
pwxlvl180r = getval("pwxlvl180r"),
mult = getval("mult"),
gzlvl0 = getval("gzlvl0"),
gt0 = getval("gt0"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gstab = getval("gstab"),
tauA,
tauB,
tau,
taumb,
taug,
grad1,
grad2,
grad3,
grad4;
char pwx180ad[MAXSTR],
pwx180ref[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);
getstr("pwx180ref", pwx180ref);
tauA = 1/(2*(j1min + 0.146*(j1max - j1min)));
tauB = 1/(2*(j1max - 0.146*(j1max - j1min)));
tau = 1/(j1max + j1min);
taumb = 1 / (2 * (getval("jnxh")));
taug = tau + getval("tauC");
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, 8, ph2);
settable(t3, 16, ph3);
settable(t4, 2, ph4);
getelem(t1, v17, v1);
getelem(t2, v17, v2);
getelem(t3, v17, v3);
getelem(t4, v17, oph);
add(oph,v18,oph);
add(oph,v19,oph);
assign(zero,v6);
/*
mod2(id2, v14);
dbl(v14,v14);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
add(v2, v14, v2);
add(oph, v14, oph);
if ((phase1 == 2) || (phase1 == 5))
{
icosel = -1;
}
grad2 = gzlvlE;
grad3 = -1.5*gzlvlE;
grad1 = -1.0*grad2*(EDratio + icosel)/EDratio;
grad4 = -1.0*grad3*(EDratio - icosel)/EDratio;
if (mult > 0.5)
{
grad4 = -1.0*grad3*(EDratio + icosel)/EDratio;
}
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(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(pwxlvl);
status(B);
rgpulse(pw, v6, rof1, rof2);
/* Start of J filter */
if (getflag("jfilter"))
{
zgradpulse(gzlvl0,gt0);
delay(tauA - gt0);
decrgpulse(pwx, zero, rof1, rof1);
zgradpulse(-gzlvl0*2/3,gt0);
delay(tauB - gt0);
decrgpulse(pwx, zero, rof1, rof1);
zgradpulse(-gzlvl0/3,gt0);
}
/* End of J filter */
delay(taumb);
zgradpulse(grad1,gtE);
delay(gstab);
decrgpulse(pwx, v2, rof1, rof1);
if (mult > 0.5)
{
decpower(pwxlvl180r);
zgradpulse(grad2,gtE);
delay(taug-gtE-2*GRADIENT_DELAY);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
delay(d2/2);
rgpulse(2*pw,v3,rof1,rof1);
delay(d2/2);
delay(taug-(gtE+gstab+2*GRADIENT_DELAY)+(4*pwx/PI+2*rof1+2*POWER_DELAY-2*pw-2*rof1));
zgradpulse(grad3,gtE);
delay(gstab);
decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1);
}
else
{
decpower(pwxlvl180);
zgradpulse(grad2,gtE);
delay(taug/2+(pwx180r-pwx180)/2- gtE - 2*GRADIENT_DELAY);
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
delay(taug/2+(pwx180r-pwx180)/2.0);
delay(d2/2);
rgpulse(2*pw,v3,rof1,rof1);
delay(d2/2);
delay(taug/2+(pwx180r-pwx180)/2.0+(4*pwx/PI+2*rof1+2*POWER_DELAY-2*pw-2*rof1));
decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1);
delay(taug/2+(pwx180r-pwx180)/2-gtE-gstab-2*GRADIENT_DELAY);
zgradpulse(grad3,gtE);
delay(gstab);
}
decpower(pwxlvl);
decrgpulse(pwx, v1, rof1, rof2);
decpower(dpwr);
zgradpulse(grad4,gtE);
delay(gstab);
status(C);
}
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"),
gstab = getval("gstab"),
slpwrR = getval("slpwrR"),
slpwR = getval("slpwR"),
mixR = getval("mixR"),
gzlvlz = getval("gzlvlz"),
gtz = getval("gtz"),
alfa1,
t1dly,
zfphinc = getval("zfphinc");
char slpatR[MAXSTR],
selshapeA[MAXSTR],
selshapeB[MAXSTR];
int phase1 = (int)(getval("phase")+0.5),
prgcycle = (int)(getval("prgcycle")+0.5);
//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);
/* LOAD AND INITIALIZE PARAMETERS */
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("slpatR",slpatR);
alfa1 = POWER_DELAY + (2*pw/PI) + rof1;
if (getflag("homodec"))
alfa1 = alfa1 + 2.0e-6 + 2*pw;
t1dly = d2-alfa1;
if (t1dly > 0.0)
t1dly = t1dly;
else
t1dly = 0.0;
if (strcmp(slpatR,"cw") &&
strcmp(slpatR,"troesy") &&
strcmp(slpatR,"dante"))
abort_message("SpinLock pattern %s not supported!.\n", slpatR);
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); getelem(t1,v17,v1);
settable(t2,8,ph2); getelem(t2,v17,v20);
settable(t3,8,ph3);
settable(t8,4,ph8); getelem(t8,v17,v8);
settable(t6,8,ph6); getelem(t6,v17,v6);
assign(v1,oph);
if (getflag("zfilt"))
getelem(t3,v17,oph);
assign(v20,v9);
if (!strcmp(slpatR,"troesy"))
assign(v20,v21);
else
add(v20,one,v21);
add(oph,v18,oph);
add(oph,v19,oph);
if (getflag("prgflg") && (satmode[0] == 'y'))
assign(v1,v6);
if (phase1 == 2)
{incr(v1); incr(v6);} /* hypercomplex method */
assign(v1,v11);
add(v11,two,v12);
assign(oph,v14);
/*
mod2(id2,v13);
dbl(v13,v13);
*/
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v13);
if (getflag("fadflg"))
{
add(v1,v13,v1);
add(v6,v13,v6);
add(oph,v13,oph);
}
if (getflag("homodec"))
add(oph,two,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);
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);
decpower(dpwr);
status(B);
rgpulse(pw, v1, rof1, rof1);
if (getflag("homodec"))
{
delay(t1dly/2);
rgpulse(2*pw,v14,1.0e-6,1.0e-6);
}
else
delay(t1dly);
zgradpulse(gzlvlA,gtA);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v11,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlA,gtA);
delay(gstab);
if (getflag("homodec"))
delay(t1dly/2);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v12,rof1,rof1);
obspower(tpwr);
zgradpulse(gzlvlB,gtB);
delay(gstab);
obspower(slpwrR);
if (mixR > 0.0)
{
if (dps_flag)
rgpulse(mixR,v21,0.0,0.0);
else
SpinLock(slpatR,mixR,slpwR,v21);
}
if ((getflag("zfilt")) && (getflag("PFGflg")))
{
obspower(tpwr);
rgpulse(pw,v9,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 satdly = getval("satdly");
int prgcycle=(int)(getval("prgcycle")+0.5);
char satmode[MAXSTR],
sspul[MAXSTR];
getstr("satmode",satmode);
getstr("sspul",sspul);
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,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") && (satmode[0] == 'y'))
assign(v3,v2);
/* equilibrium period */
status(A);
delay(5.0e-5);
if (sspul[0] == 'y')
steadystate();
if (satmode[0] == 'y')
{
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);
status(B);
pulse(p1,zero);
hsdelay(d2);
rgpulse(pw,v1,rof1,rof2);
status(C);
}
pulsesequence()
{
double j1min = getval("j1min"),
j1max = getval("j1max"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
mult = getval("mult"),
pwx180 = getval("pwx180"),
pwxlvl180 = getval("pwxlvl180"),
pw180 = getval("pw180"),
pwx180r = getval("pwx180r"),
pwxlvl180r = getval("pwxlvl180r"),
tpwr180 = getval("tpwr180"),
EDratio = getval("EDratio"),
hsglvl = getval("hsglvl"),
hsgt = getval("hsgt"),
gstab = getval("gstab"),
dmfct = getval("dmfct"),
dpwrct = getval("dpwrct"),
tau,
tau1,
tau3,
taug,
bigT = getval("BigT");
char pwx180ad[MAXSTR],
pw180ad[MAXSTR],
dmct[MAXSTR],
bipflg[MAXSTR],
pwx180ref[MAXSTR],
dmmct[MAXSTR];
int icosel,
igcorr,
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);
getstr("pw180ad",pw180ad);
getstr("dmct",dmct);
getstr("pwx180ref", pwx180ref);
getstr("dmmct", dmmct);
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);
}
tau1 = 1/(2*(j1min + 0.07*(j1max - j1min)));
tau3 = 1/(2*(j1max - 0.07*(j1max - j1min)));
tau = 1 / (j1min+j1max);
taug = tau + getval("tauC");
icosel = 1;
igcorr = 2;
if (mult > 0.5)
igcorr = 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, 8, ph2);
settable(t3, 16, ph3);
settable(t6, 2, ph6);
getelem(t1, v17, v1);
getelem(t3, v17, v3);
getelem(t2, v17, v2);
getelem(t6, v17, oph);
assign(zero, v4);
assign(zero,v6);
add(oph,v18,oph);
add(oph,v19,oph);
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
/*
mod2(id2, v14);
dbl(v14,v14);
*/
add(v2, v14, v2);
add(v4, v14, v4);
add(oph, v14, oph);
if ((phase1 == 2) || (phase1 == 5))
icosel = -1;
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(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(pwxlvl);
if (getflag("nullflg"))
{
decpower(pwxlvl180);
rgpulse(0.5 * pw, zero, rof1, rof1);
obspower(tpwr180);
delay(tau/2.0);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1);
delay(tau/2.0+POWER_DELAY+rof1);
delay(tau/2.0+POWER_DELAY+rof1);
simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,two,two,rof1,rof1);
obspower(tpwr);
delay(tau/2.0);
rgpulse(0.5 * pw, zero, rof1, rof1);
decpower(pwxlvl);
zgradpulse(hsglvl, 1.4*hsgt);
delay(1e-3);
}
status(B);
rgpulse(pw, zero, rof1, rof1);
if (getflag("dmct"))
{
decpower(dpwrct);
decprgon("garp1",1/dmfct,1.0);
/*
setstatus(DECch, FALSE, 'g', FALSE, dmfct);
*/
decunblank();
decon();
}
obspower(tpwr180);
delay(bigT/2 - d2/2 - tau - taug - pwx180r);
delay(pw180+WFG_START_DELAY+WFG_STOP_DELAY);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
delay(bigT/2 - d2/2 - tau - taug - pwx180r);
delay(4*pw/PI+2*rof1+POWER_DELAY+4*pwx/PI+2*POWER_DELAY);
if (getflag("dmct"))
{
decoff();
decblank();
decprgoff();
/*
setstatus(DECch, FALSE, 'c', FALSE, dmf);
*/
decpower(pwxlvl);
}
if (mult > 0.5)
{
delay(tau-gtE-2*GRADIENT_DELAY-gstab);
zgradpulse(icosel*gzlvlE,gtE);
delay(gstab);
}
else
{
delay(tau);
}
decrgpulse(pwx,v2,rof1,rof1);
if (mult > 0.5)
{
decpower(pwxlvl180r);
delay(taug);
decshaped_pulse(pwx180ref, pwx180r, v4, rof1, rof1);
delay(d2/2);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
delay(d2/2);
zgradpulse(icosel*gzlvlE,gtE);
delay(taug-gtE-2*GRADIENT_DELAY+(4*pwx/PI+2*rof1+2*POWER_DELAY-(WFG_START_DELAY+pw180+WFG_STOP_DELAY+2*rof1)));
decshaped_pulse(pwx180ref, pwx180r, v3, rof1, rof1);
}
else
{
decpower(pwxlvl180);
delay(taug/2+(pwx180r-pwx180)/2);
decshaped_pulse(pwx180ad, pwx180, v4, rof1, rof1);
delay(taug/2+(pwx180r-pwx180)/2.0-gtE-2*GRADIENT_DELAY-gstab);
zgradpulse(icosel*gzlvlE,gtE);
delay(gstab);
delay(d2/2);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
delay(d2/2);
zgradpulse(icosel*gzlvlE,gtE);
delay(taug/2+(pwx180r-pwx180)/2.0+(4*pwx/PI+2*rof1+2*POWER_DELAY-WFG_START_DELAY-pw180-WFG_STOP_DELAY-2*rof1)-gtE-2*GRADIENT_DELAY);
decshaped_pulse(pwx180ad, pwx180, v3, rof1, rof1);
delay(taug/2+(pwx180r-pwx180)/2);
}
decpower(pwxlvl);
decrgpulse(pwx,v1,rof1,rof1);
obspower(tpwr);
delay(tau);
rgpulse(pw,one,rof1,rof2);
decrgpulse(pwx,zero,rof1,rof1);
obspower(tpwr180);
zgradpulse(igcorr*3*gzlvlE/(10*EDratio),gtE);
delay(tau3 - gtE - 2*GRADIENT_DELAY);
decrgpulse(pwx,zero,rof1,rof1);
zgradpulse(igcorr*7*gzlvlE/(10*EDratio),gtE);
delay(tau - gtE - 2*GRADIENT_DELAY);
decrgpulse(pwx,zero,rof1,rof1);
shaped_pulse(pw180ad,pw180,zero,rof1,rof1);
zgradpulse(igcorr*2*gzlvlE/EDratio,gtE);
delay(tau1 - gtE - 2*GRADIENT_DELAY - POWER_DELAY);
decpower(dpwr);
status(C);
delay(tau+tau3+3*pwx+6*rof1-tau1+WFG_START_DELAY+WFG_STOP_DELAY);
}
void pulsesequence()
{
double base,
qlvl;
char sspul[MAXSTR];
/* LOAD VARIABLES AND CHECK CONDITIONS */
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)
add(id2, v1, v1); /* TPPI increment */
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
if (newtrans)
obsstepsize(base);
status(A);
if (sspul[A] == 'y')
{
rgpulse(200*pw, zero, rof1,0.0e-6);
rgpulse(200*pw, one, 0.0e-6, rof1);
}
if (satmode[A] == 'y')
{
obspower(satpwr);
rgpulse(satdly,zero,rof1,rof1);
obspower(tpwr);
}
status(B);
if (newtrans)
xmtrphase(v10); /* hardware digital phaseshift */
rgpulse(pw, v1, rof1, 1.0e-6);
if (satmode[B] == 'y')
{
obspower(satpwr);
if (d2>0.0) rgpulse(d2 -9.4e-6 -rof1 -(4*pw)/3.1416,zero,0.0,0.0);
obspower(tpwr);
}
else
{
if (d2>0.0) delay(d2 -1.0e-6 -rof1 -(4*pw)/3.1416);
}
rcvroff();
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()
{
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()
{
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"),
phincr1 = getval("phincr1");
char slpatT[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat1[MAXSTR],
zqfpat2[MAXSTR], flipback[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("slpatT",slpatT);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat1",zqfpat1);
getstr("zqfpat2",zqfpat2);
getstr("flipback", flipback);
getstr("alt_grd",alt_grd);
/* alternate gradient sign on every 2nd transient */
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 */
assign(ct,v17);
ifzero(ssctr);
assign(v17,v13);
elsenz(ssctr);
/* purge option does not adjust v13 during steady state*/
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,v21);
add(one,v21,v21);
add(two,v21,v12);
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v5);
mod2(ct,v2); /* 01 01 */
hlv(ct,v4); hlv(v4,v4); mod2(v4,v4); dbl(v4,v4); /* 0000 2222 */
add(v4,v2,v4); mod4(v4,v4); /* 0101 2323 first echo in Excitation Sculpting */
hlv(ct,v7); mod2(v7,v7); /* 0011 */
hlv(ct,v9); hlv(v9,v9); hlv(v9,v9); dbl(v9,v9); add(v9,v7,v9);
mod4(v9,v9); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */
dbl(v2,v2); /* 0202 */
dbl(v7,v7); /* 0022 */
add(v2,v7,v7); /* 0220 correct oph for Excitation Sculpting */
add(oph,v7,oph); mod4(oph,oph);
if (alt_grd[0] == 'y') mod2(ct,v10); /* alternate gradient sign on every 2nd transient */
/* 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);
rgpulse(pw, v14, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v10); zgradpulse(gzlvlA,gtA);
elsenz(v10); zgradpulse(-gzlvlA,gtA); endif(v10);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v1,rof1,rof1);
obspower(tpwr);
ifzero(v10); zgradpulse(gzlvlA,gtA);
elsenz(v10); zgradpulse(-gzlvlA,gtA); endif(v10);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v10); zgradpulse(gzlvlB,gtB);
elsenz(v10); zgradpulse(-gzlvlB,gtB); endif(v10);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v11,rof1,rof1);
obspower(tpwr);
ifzero(v10); zgradpulse(gzlvlB,gtB);
elsenz(v10); zgradpulse(-gzlvlB,gtB); endif(v10);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
rgpulse(pw, v14, rof1, rof1);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr1);
ifzero(v10); rgradient('z',gzlvlzq1);
elsenz(v10); rgradient('z',-gzlvlzq1); endif(v10);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,v14,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
}
obspower(slpwrT);
ifzero(v10); zgradpulse(gzlvl1,gt1);
elsenz(v10); zgradpulse(-gzlvl1,gt1); endif(v10);
delay(gstab);
if (mixT > 0.0)
{
if (dps_flag)
rgpulse(mixT,v21,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v21);
}
if (getflag("Gzqfilt"))
{
obspower(zqfpwr2);
ifzero(v10); rgradient('z',gzlvlzq2);
elsenz(v10); rgradient('z',-gzlvlzq2); endif(v10);
delay(100.0e-6);
shaped_pulse(zqfpat2,zqfpw2,v14,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
}
obspower(tpwr);
ifzero(v10); zgradpulse(gzlvl2,gt2);
elsenz(v10); zgradpulse(-gzlvl2,gt2); endif(v10);
delay(gstab);
if (flipback[A] == 'y')
FlipBack(v14,v5);
rgpulse(pw,v14,rof1,2.0e-6);
ExcitationSculpting(v4,v9,v10);
delay(rof2);
status(C);
}
pulsesequence()
{
char normal[MAXSTR],
focus[MAXSTR];
int rxgate;
double pp,
pplvl,
j,
mult;
rxgate = (rof1 == 0.0);
if (rxgate)
rof1 = 1.0e-6; /* phase switching time */
j = getval("j");
pp = getval("pp");
mult = getval("mult");
getstr("focus", focus);
getstr("normal", normal);
if (newdecamp)
{
if (rxgate)
rof1 = 40.0e-6;
}
/* 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);
settable(t1,4,phasecycle);
pulse(pw,t1);
setreceiver(t1);
}
else
{
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);
}
}
/* setup phases */
hlv(oph, v1); /* 0011 */
dbl(v1, v1); /* 0022 */
mod2(oph, v2); /* 0101 */
/* 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);
}
else
{
if (newdecamp)
{
pplvl = getval("pplvl");
decpower(pplvl); /* sets DEC atten = pplvl */
}
else
{
declvlon(); /* sets dhp = 255 level */
}
}
status(A);
if (rxgate)
rcvroff();
delay(d1);
/* excitation transfer */
status(B);
decrgpulse(pp, v1, rof1, rof1);
delay(d3/2 - 2*rof1 - 3*pp/2);
simpulse(2*pw, 2*pp, zero, zero, rof1, rof1);
delay(d3/2 - 2*rof1 - 3*pp/2);
simpulse(pw, pp, v2, one, rof1, rof2);
/* make decision on refocussing */
if ((focus[A] == 'y') || (dm[C] == 'y'))
{
delay(d2/2 - rof1 - pp); /* refocussing delay varied for 2d */
simpulse(2*pw, 2*pp, v2, zero, rof1, rof2);
delay(d2/2 - rof2 - pp);
}
else if (normal[A] == 'y')
{
decrgpulse(pp, v1, 1.0e-6, 0.0);
}
if (newdecamp)
{
decpower(dpwr); /* set DEC attten = dpwr */
}
else
{
declvloff();
}
status(C);
if (rxgate)
rcvron();
}
}
void pulsesequence()
{
double mix;
char sspul[MAXSTR];
/* LOAD VARIABLES */
mix = getval("mix");
getstr("sspul", sspul);
if (phase1 == 3)
initval( (double)d2_index, v14);
else
assign(zero, v14);
/* CHECK CONDITIONS */
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);
mod2(ct, v2);
hlv(ct, v3);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
mod2(v12, v2);
hlv(v12, v3);
endif(ssctr);
/* CALCULATE PHASECYCLE */
dbl(v2, v2);
hlv(v3, v10);
hlv(v10, v10);
if (phase1 == 0)
{
assign(v10, v9);
hlv(v10, v10);
mod2(v9, v9);
}
else
{
assign(zero, v9);
}
assign(v10,v1);
hlv(v10, v10);
mod2(v1, v1);
dbl(v1, v1);
add(v9, v2, v2);
mod2(v10, v10);
add(v1, v2, oph);
add(v3, oph, oph);
add(v10, oph, oph);
add(v10, v1, v1);
add(v10, v2, v2);
add(v10, v3, v3);
add(v10,v14,v5);
if (phase1 == 2)
{ incr(v2); incr(v5); }
if (phase1 == 3)
add(v2, v14, v2); /* TPPI phase increment */
/*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(v2,v6,v2); add(oph,v6,oph); add(v5,v6,v5);
}
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (sspul[A] == 'y')
{
obspower(tpwr-12);
rgpulse(200*pw, zero, rof1, 0.0e-6);
rgpulse(200*pw, one, 0.0e-6, rof1);
obspower(tpwr);
}
if (d1>hst) hsdelay(d1);
if (satmode[A] == 'y')
{
obspower(satpwr);
rgpulse(satdly,v5,rof1,rof1);
obspower(tpwr);
}
status(B);
rgpulse(pw, v2, rof1, 1.0e-6);
if (satmode[B] =='y')
{
if (d2 > 0.0)
{
obspower(satpwr);
rgpulse(d2 - (2*POWER_DELAY) - rof1 - 11.0e-6 - (4.0*pw/3.14159),zero,5.0e-6,5.0e-6);
obspower(tpwr);
}
}
else
{
if (d2 > 0.0)
delay(d2 - 1.0e-6 - rof1 - (4.0*pw/3.14159));
}
rgpulse(pw, v1, rof1, 1.0e-6);
if (satmode[B] == 'y')
{
hsdelay(hst);
obspower(satpwr);
rgpulse(mix-hst,zero,2.0e-6,rof1);
obspower(tpwr);
}
else
hsdelay(mix);
rgpulse(pw, v3, rof1, rof2);
status(C);
/* Phase cycle: ...satdly(v5)...pw(v2)..d2..pw(v1)..mix...pw(v3)..at(oph)
(for phase=1. for phase = 2 incr(v2) and incr(v5) )
v2 =[02] for axial peaks
v1 =[02]16 for axial peaks
v3 =[0123]2 "4 step phase cycle selection"
v10 =[01]8 for quad image
oph = v1+v2+v3+v10
v5: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
v2: 0 2 0 2 0 2 0 2 0 2 0 2 0 2 0 2 1 3 1 3 1 3 1 3 1 3 1 3 1 3 1 3
v1: 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3
v3: 0 0 1 1 2 2 3 3 0 0 1 1 2 2 3 3 1 1 2 2 3 3 0 0 1 1 2 2 3 3 0 0
oph:0 2 1 3 2 0 3 1 2 0 3 1 0 2 1 3 1 3 2 0 3 1 0 2 3 1 0 2 1 3 2 0 */
}
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 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 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);
}
if (getflag("cpmgflg"))
{
rgpulse(pw, v6, rof1, 0.0);
cpmg(v6, v15);
}
else
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 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);
}
