pulsesequence()
{
double gzlvl1;
double td;
char gradaxis[MAXSTR];
dbl(oph,v1); mod4(v1,v1); hlv(v1,v1);
hlv(ct,v2); hlv(v2,v2); mod4(v2,v2); dbl(v2,v2); add(v1,v2,v1);
getstrnwarn("gradaxis",gradaxis);
if (( gradaxis[0] != 'x') && ( gradaxis[0] != 'y') && ( gradaxis[0] != 'z') )
strcpy(gradaxis,"z");
gzlvl1 = getval("gzlvl1");
at = getval("at");
status(A);
delay(d1);
status(B);
td = (d2-at/2.0)/2.0;
if (td < 0.0)
td = 0.0;
rgpulse(p1,oph,rof1,rof2);
delay(td);
rgradient(gradaxis[0],gzlvl1);
delay(at/2.0);
rgradient(gradaxis[0],0.0);
delay(td);
status(C);
pulse(pw,v1);
delay(d2-at/2.0);
rgradient(gradaxis[0],gzlvl1);
delay(0.0001); /* let gradient stabilize */
/* rely on psg safety to turn off gradient */
}
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);
}
void setphases()
{
mod2(ct, v1); dbl(v1,v1); /* 0202 */
hlv(ct,v2); mod2(v2,v2); dbl(v2,v2); /* 0022 */
add(v1,v2,v3); mod4(v3,oph); /* 0220 */
add(one,oph,oph);
}
int main ()
{
if (div1 (-(1 << 7)) != 1 << 7)
abort ();
if (div2 (-(1 << 15)) != 1 << 15)
abort ();
if (div3 (-(1 << 7), -1) != 1 << 7)
abort ();
if (div4 (-(1 << 15), -1) != 1 << 15)
abort ();
if (mod1 (-(1 << 7)) != 0)
abort ();
if (mod2 (-(1 << 15)) != 0)
abort ();
if (mod3 (-(1 << 7), -1) != 0)
abort ();
if (mod4 (-(1 << 15), -1) != 0)
abort ();
if (mod5 (0x50000000, 2) != 0)
abort ();
if (mod6 (0x50000000, 2) != 0)
abort ();
exit (0);
}
void setphases()
{
mod4(ct, oph); /* 0123 */
mod2(ct,v1);
dbl(v1,v1); /* 0202 */
add(v1,oph,v3); /* 0321 */
add(one,v3,v2); /* 1032 */
add(two,oph,oph);
}
pulsesequence()
{
double sign,currentlimit,RMScurrentlimit,dutycycle;
int calcpower;
/* Initialize paramaters **********************************/
init_mri();
calcpower=(int)getval("calcpower");
dutycycle=getval("dutycycle");
currentlimit=getval("currentlimit");
RMScurrentlimit=getval("RMScurrentlimit");
if (gspoil>0.0) sign = 1.0;
else sign = -1.0;
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
if (calcpower) calc_rf(&p1_rf,"tpwr1","tpwr1f");
if (tspoil>0.0) {
gspoil = sqrt(dutycycle/100.0)*gmax*RMScurrentlimit/currentlimit;
init_generic(&spoil_grad,"spoil",gspoil,tspoil);
spoil_grad.rollOut=FALSE;
calc_generic(&spoil_grad,WRITE,"gspoil","tspoil");
}
xgate(ticks);
rotate();
status(A);
mod4(ct,oph);
delay(d1);
/* TTL scope trigger **********************************/
sp1on(); delay(4e-6); sp1off();
if (calcpower) {
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
}
else obspower(tpwr1);
delay(4e-6);
if (tspoil>0.0) {
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,0,0,spoil_grad.amp*sign,WAIT);
delay(d2);
}
shapedpulse(p1pat,p1,ct,rof1,rof2);
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
int computePowerOf2(bigNumber a) {
/*computes the last digit of power of two involved in resul */
int power = 0;
bigNumber p1;
if(a[0] == 1 && a[1] == 1) return 1;
copyNumber(p1, a);
while (!isZero(p1)) {
divide(p1, 2);
power = (power + mod4(p1)) % 4;
}
copyNumber(p1, a);
while (!isZero(p1)) {
divide(p1, 5);
power =(power - mod4(p1) + 4)%4;
}
return power2[power];
}
pulsesequence()
{
double pwx1;
double pwx2;
double pwx3;
double jtau;
char jname[MAXSTR];
char jval[MAXSTR];
pwx1 = getval("pwx1");
pwx2 = getval("pwx2");
pwx3 = getval("pwx3");
getstr("jname",jname);
strcpy(jval,"j");
strcat(jval,jname);
jtau = 1.0 / (2.0 * getval(jval) );
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);
status(B);
rgpulse(pw, v2, rof1, rof2);
jtau -= pw + rof2;
delay(jtau - rof1);
sim4pulse(0.0, pwx1, pwx2, pwx3, v1, zero, zero, zero, rof1, rof2);
status(C);
}
int compute379(bigNumber p) {
/* computes the last digit of product of
all numbers smaller then p and ending in 3, 7 a 9 */
bigNumber p1;
int r, poc, result;
copyNumber(p1, p);
r = divide(p1, 10);
poc = mod4(p1);
result = (power3[poc] * power7[poc] * power9[poc]) % 10;
if (r >= 3) result *= 3;
if (r >= 7) result *= 7;
if (r >= 9) result *= 9;
return result % 10;
}
void pulsesequence()
{
char c1d[MAXSTR]; /* option to record only 1D C13 spectrum */
int ncyc;
double tau1 = 0.002, /* t1 delay */
post_del = 0.0,
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
compC = getval("compC"),
compH = getval("compH"),
mixpwr = getval("mixpwr"),
jCH = getval("jCH"),
gt0 = getval("gt0"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gzlvl0 = getval("gzlvl0"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
grec = getval("grec"),
phase = getval("phase");
getstr("c1d",c1d);
ncyc=1;
if(jCH > 0.0)
tau1 = 0.25/jCH;
dbl(ct, v1); /* v1 = 0 */
mod4(v1,oph);
hlv(ct,v2);
add(v2,v1,v2);
if (phase > 1.5)
incr(v1); /* hypercomplex phase increment */
initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v10);
add(v1,v10,v1);
add(oph,v10,oph);
mod4(v1,v1); mod4(v2,v2); mod4(oph,oph);
assign(zero,v3);
if(FIRST_FID)
{
HHmix = pbox_mix("HHmix", "DIPSI2", mixpwr, pw*compH, tpwr);
if(c1d[A] == 'n')
{
opx("CHdec"); setwave("WURST2 30k/1.2m"); pbox_par("steps","600"); cpx(pwC*compC, pwClvl);
CHdec = getDsh("CHdec");
}
}
ncyc = (int) (at/HHmix.pw) + 1;
post_del = ncyc*HHmix.pw - at;
/* BEGIN PULSE SEQUENCE */
status(A);
zgradpulse(gzlvl0, gt0);
rgpulse(pw, zero, 0.0, 0.0); /* destroy H-1 magnetization*/
zgradpulse(gzlvl0, gt0);
delay(1.0e-4);
obspower(tpwr);
txphase(v1);
decphase(zero);
dec2phase(zero);
presat();
obspower(tpwr);
delay(1.0e-5);
status(B);
if(c1d[A] == 'y')
{
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
delay(d2);
rgpulse(pw,two,0.0,0.0); /* 1H pulse excitation */
assign(oph,v3);
}
else
{
decunblank(); pbox_decon(&CHdec);
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
delay(d2);
pbox_decoff(); decblank();
decpower(pwClvl); decpwrf(4095.0);
delay(tau1 - POWER_DELAY);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
txphase(one); decphase(one); dec2phase(one);
delay(tau1);
simpulse(pw, pwC, one, one, 0.0, 0.0);
txphase(zero); decphase(zero); dec2phase(zero);
delay(tau1);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
delay(tau1);
simpulse(0.0, pwC, zero, zero, 0.0, 0.0);
}
zgradpulse(gzlvl1, gt1);
delay(grec);
simpulse(0.0, pwC, zero, v3, 0.0, rof2);
txphase(v2);
obsunblank(); pbox_xmtron(&HHmix);
status(C);
setactivercvrs("ny");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
delay(post_del);
pbox_xmtroff(); obsblank();
zgradpulse(gzlvl2, gt2);
obspower(tpwr);
delay(grec);
rgpulse(pw,zero,0.0,rof2); /* 1H pulse excitation */
status(D);
setactivercvrs("yn");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
pulsesequence()
{
double 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 del = getval("del"),
gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
prgtime = getval("prgtime"),
prgpwr = getval("prgpwr"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
d3 = getval("d3"),
Dtau,Ddelta,dosytimecubed, dosyfrq;
char delflag[MAXSTR],satmode[MAXSTR],prg_flg[MAXSTR],alt_grd[MAXSTR],
sspul[MAXSTR],lkgate_flg[MAXSTR];
getstr("delflag",delflag);
getstr("satmode",satmode);
getstr("prg_flg",prg_flg);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
gt2 = syncGradTime("gt2","gzlvl2",1.0);
gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0);
/* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */
if (del < (4*pw+3.0*rof1+gt1+2.0*gstab))
{ abort_message("Dbppste error: 'del' is less than %g, too short!",
(4.0*pw+3*rof1+gt1+2.0*gstab));
}
Ddelta=gt1;
Dtau=2.0*pw+rof1+gstab+gt1/2.0;
dosyfrq = sfrq;
dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* phase cycling calculation */
mod2(ct,v1); dbl(v1,v1); hlv(ct,v2);
mod2(v2,v3); dbl(v3,v3); hlv(v2,v2);
mod2(v2,v4); add(v1,v4,v1); /* v1 */
hlv(v2,v2); add(v2,v3,v4); /* v4 */
hlv(v2,v2); mod2(v2,v3); dbl(v3,v5);
hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */
hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */
hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/
add(v1,v3,v7); add(v4,v7,v7);
add(two,v7,v8);
mod2(ct,v10); /* gradients change sign at odd transients */
if (ni > 1.0)
{ abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
/* equilibrium period */
status(A);
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0)
delay(d1 - satdly);
obspower(satpwr);
txphase(zero);
rgpulse(satdly,zero,rof1,rof1);
obspower(tpwr);
}
else
delay(d1);
status(B);
/* first part of bppdel sequence */
if (delflag[0]=='y')
{ if (gt1>0 && gzlvl1>0)
{ rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */
if (satmode[1] == 'y')
{
obspower(satpwr);
rgpulse(del-4.0*pw-3.0*rof1-gt1-2.0*gstab,zero,rof1,rof1);
obspower(tpwr);
}
else
{
delay(del-4.0*pw-3.0*rof1-gt1-2.0*gstab);/*diffusion delay */
}
rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else
zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
if (prg_flg[0] == 'y')
{
add(one,v7,v9);
obspower(prgpwr);
rgpulse(prgtime, v9, rof1, rof1);
obspower(tpwr);
}
}
zgradpulse(gzlvl2,gt2);
delay(gstab);
rgpulse(pw*0.231,v7,rof1,rof1);
delay(d3);
rgpulse(pw*0.692,v7,rof1,rof1);
delay(d3);
rgpulse(pw*1.462,v7,rof1,rof1);
delay(d3);
rgpulse(pw*1.462,v8,rof1,rof1);
delay(d3);
rgpulse(pw*0.692,v8,rof1,rof1);
delay(d3);
rgpulse(pw*0.231,v8,rof1,rof1);
zgradpulse(gzlvl2,gt2);
delay(gstab);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on */
}
else
rgpulse(pw,oph,rof1,rof2);
/* --- observe period --- */
status(C);
}
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()
{
double gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gt2 = getval("gt2"),
gzlvl2 = getval("gzlvl2"),
del=getval("del"),
del2=getval("del2"),
dosyfrq=getval("sfrq"),
phase = getval("phase"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
Ddelta,dosytimecubed,icosel,delcor1,delcor2,delcor3;
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);
/* phase cycling calculation */
icosel=1; /* Default to N-type experiment */
if (phase == 2.0)
{ icosel=-1;
mod4(ct,v1);
hlv(ct,v2);
hlv(v2,v2);
mod4(v2,v2);
if (ix==1) fprintf(stdout,"P-type COSY\n");
}
else
{ mod4(ct,v1);
hlv(ct,v2);
hlv(v2,v2);
mod4(v2,v2);
dbl(v2,v3);
sub(v3,v1,oph);
mod4(oph,oph);
if (ix==1) fprintf(stdout,"N-type COSY\n");
}
mod2(ct,v10); /* gradients change sign at odd transients */
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));
if (phase==2.0)
putCmd("makedosyparams(%e,%e) dosy3Dproc='ptype'\n",dosytimecubed,dosyfrq);
else
putCmd("makedosyparams(%e,%e) dosy3Dproc='ntype'\n",dosytimecubed,dosyfrq);
delcor1=(del+del2)/4.0-gt1;
delcor2=(del-del2)/4.0-gt1;
if ((del < 4.0*gt1)&&(convcomp[0] == 'y'))
{
abort_message("Dcosyidosy: increase diffusion delay at least to %f seconds",
(gt1*4.0));
}
if ((delcor2 < 0.0)&&(convcomp[0] == 'y'))
{
abort_message("Dcosyidosy: decrease del2 to less than %f to fit into the diffusion delay",
(del-gt1*4.0));
}
delcor3=(del-gt1-2*rof1-pw)/2;
if ((delcor3 < 0.0)&&(convcomp[0] == 'n'))
{
abort_message("Dcosyidosy: increase the diffusion delay at least to %f second",
(gt1*2+rof1+pw));
}
/* BEGIN ACTUAL PULSE 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 (convcomp[A]=='y')
{
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (icosel > 0)
{
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl2,2*gt2);
elsenz(v10);
zgradpulse(gzlvl2,2*gt2);
endif(v10);
}
else zgradpulse(-gzlvl2,2*gt2);
delay(gstab);
}
rgpulse(pw,v1,rof1,rof1);
delay(d2+gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-gzlvl1,gt1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor2,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor2);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-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);
delay(gstab);
rgpulse(pw,v2,rof1,rof2);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(icosel*gzlvl2,gt2);
elsenz(v10);
zgradpulse(-1.0*icosel*gzlvl2,gt2);
endif(v10);
}
else zgradpulse(icosel*gzlvl2,gt2);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor2,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor2);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-gzlvl1,gt1);
delay(gstab);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor1,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor1);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
delay(gstab);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on */
}
else
{
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock off */
if (icosel > 0)
{
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-gzlvl1,2.0*gt1);
elsenz(v10);
zgradpulse(gzlvl1,2.0*gt1);
endif(v10);
}
else zgradpulse(-gzlvl1,2.0*gt1);
delay(gstab);
}
rgpulse(pw,v1,rof1,rof1);
delay(d2);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor3,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor3);
rgpulse(pw,v2,rof1,rof2);
if (satmode[1] == 'y')
{ obspower(satpwr);
rgpulse(delcor3,zero,rof1,rof1);
obspower(tpwr);
}
else delay(delcor3);
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(icosel*gzlvl1,gt1);
elsenz(v10);
zgradpulse(-icosel*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(icosel*gzlvl1,gt1);
delay(gstab);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on */
}
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()
{
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);
}
pulsesequence()
{
double jtau,dosytimecubed,Ddelta,taumb,delcor,delcor2,
j1xh = getval("j1xh"),
jnxh = getval("jnxh"),
pwx = getval("pwx"),
pwxlvl = getval("pwxlvl"),
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvlE = getval("gzlvlE"),
gtE = getval("gtE"),
EDratio = getval("EDratio"),
gzlvl3 = getval("gzlvl3"),
gt3 = getval("gt3"),
del = getval("del"),
gstab = getval("gstab"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
satdly = getval("satdly"),
satpwr = getval("satpwr"),
satfrq = getval("satfrq"),
dosyfrq = sfrq;
char sspul[MAXSTR],lkgate_flg[MAXSTR],
mbond[MAXSTR],c180[MAXSTR],alt_grd[MAXSTR];
//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("mbond", mbond);
getstr("c180", c180);
getstr("sspul",sspul);
getstr("satmode",satmode);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
if (j1xh>0)
jtau=1/(2.0*j1xh);
else
jtau=1/(2.0*140.0);
if (jnxh>0)
taumb=1/(2.0*jnxh);
else
taumb=1/(2.0*8.0);
Ddelta=gt1; /*the diffusion-encoding pulse width is gt1*/
dosytimecubed=Ddelta*Ddelta*(del - (Ddelta/3.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
if (jtau < (gt3+gstab))
{ text_error("j1xh must be less than 1/(2*(gt3)+gstab)\n");
psg_abort(1);
}
/* Phase cycle */
/* The phase cycle favours the following coherence pathway :
|90H| (-1 H;0 C) |90H| (0 H;0 C) |180C;90H| (+1 H;0 C) |90C| (+1 H;+1 C) |180H| (-1 H;+1 C) |90C| (-1 H;0 C)
*/
mod2(ct,v1);
dbl(v1,v1);
assign(v1,v5); /* 0 2, first carbon 90 */
hlv(ct,v3);
hlv(v3,v8);
mod2(v3,v2);
mod2(v8,v8);
dbl(v2,v2);
add(v2,v8,v2); /* 0 0 2 2 1 1 3 3, 2nd proton 90 */
hlv(v3,v6);
hlv(v6,v6);
mod2(v6,v6);
dbl(v6,v6); /* (0)8 (2)8, proton 180 */
assign(zero,v1);
assign(zero,v3);
assign(one,v9);
add(v1,v9,v9);
mod4(v9,v9);
assign(zero,v7);
assign(zero,v4);
assign(zero,v8);
assign(v5,oph);
sub(oph,v2,oph);
dbl(v6,v11);
add(oph,v11,oph);
sub(oph,v7,oph);
mod4(oph,oph);
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
add(v14, v5, v5);
add(v14, oph, oph);
mod2(ct,v10); /* gradients change sign at odd transients */
status(A);
obspower(tpwr);
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);
decpower(pwxlvl);
rgpulse(pw,v1,rof1,0.0); /* 1st H 90 */
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y') /* defoc. diff. gradient */
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
delay(jtau/2.0-gt1-pw-rof1);
rgpulse(pw,v2,rof1,0.0); /* 2nd H 90 */
if (alt_grd[0] == 'y') /* 1st compensating gradient */
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
delay(gstab);
delcor=del-pw-2.0*rof1-4.0*pwx-4.0e-6-3.0*(gt1+gstab);
delcor2=del-pw-2.0*rof1-2.0*pwx-3.0*(gt1+gstab);
if (c180[0] == 'y')
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(delcor,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(delcor);
else
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(delcor2,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(delcor2);
if (alt_grd[0] == 'y') /* 2nd compensating gradient */
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1);
elsenz(v10);
zgradpulse(gzlvl1,gt1);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1);
delay(gstab);
/* 3rd 1H 90 + 13C 180 */
if (c180[0] == 'y')
{
decrgpulse(pwx,v4,rof1,0.0);
simpulse(pw, 2.0 * pwx, v3, v9, 2.0e-6, 0.0); /* Composite 180 C pulse */
decrgpulse(pwx,v4,2.0e-6,0.0);
}
else
simpulse(pw, 2.0 * pwx, v3, v4, rof1, 0.0);
if (alt_grd[0] == 'y') /* refoc. diff. gradient */
{ ifzero(v10);
zgradpulse(gzlvl1,gt1);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1);
endif(v10);
}
else zgradpulse(gzlvl1,gt1);
if (c180[0] == 'y')
delay(jtau/2.0-gt1-(2*pwx+rof1));
else
delay(jtau/2.0-gt1-(pwx+rof1));
if (mbond[0] == 'y') /* one-bond J(CH)-filter */
{ decrgpulse(pwx, v8, rof1, 0.0);
delay(taumb - jtau - rof1 - pwx);
}
decrgpulse(pwx, v5,rof1,rof1); /* C 90 */
delay(d2/2);
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);
rgpulse(pw*2.0, v6,rof1,rof1); /* H 180 */
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);
delay(d2/2);
decrgpulse(pwx, v7,rof1,rof2); /* C 90 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(2.0*gzlvlE/EDratio,gtE);
elsenz(v10);
zgradpulse(-1.0*2.0*gzlvlE/EDratio,gtE);
endif(v10);
}
else zgradpulse(2.0*gzlvlE/EDratio,gtE);
decpower(dpwr);
if (mbond[0]=='n') delay(jtau-gtE);
else delay(gstab);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on sampling */
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, fbcorr,
phincr1 = getval("phincr1"),
flippw = getval("flippw"),
sweeppw = getval("sweeppw"),
sweeppwr = getval("sweeppwr");
char sweepshp[MAXSTR],alt_grd[MAXSTR],
selshapeA[MAXSTR],flipback[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);
getstr("flipback", flipback);
getstr("alt_grd",alt_grd);
/* alternate gradient sign on every 2nd transient */
if (flipback[A] == 'y') fbcorr = flippw + 2.0*rof1;
else fbcorr = 0.0; /* correck for flipback if used */
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v12);
mixNcorr = fbcorr;
if (getflag("Gzqfilt"))
mixNcorr += zqfpw3 + 2.0*rof1 + 4.0e-4;
mixN = mixN-mixNcorr;
assign(ct,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);
mod2(ct,v5); /* 01 01 */
hlv(ct,v7); hlv(v7,v7); mod2(v7,v7); dbl(v7,v7); /* 0000 2222 */
add(v7,v5,v7); mod4(v7,v7); /* 0101 2323 first echo in Excitation Sculpting */
hlv(ct,v11); mod2(v11,v11); /* 0011 */
hlv(ct,v8); hlv(v8,v8); hlv(v8,v8); dbl(v8,v8); add(v8,v11,v8);
mod4(v8,v8); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */
dbl(v5,v5); /* 0202 */
dbl(v11,v11); /* 0022 */
add(v5,v11,v11); /* 0220 correct oph for Excitation Sculpting */
add(oph,v11,oph);
mod4(oph,oph);
if (alt_grd[0] == 'y') mod2(ct,v10);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
delay(d1);
if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */
status(B);
if (getflag("cpmgflg"))
{
rgpulse(pw, v1, rof1, 0.0);
cpmg(v1, v15);
}
else
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v10); zgradpulse(gzlvlA,gtA);
elsenz(v10); zgradpulse(-gzlvlA,gtA); endif(v10);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v2,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,v3,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,v1,rof1,rof1);
obspower(sweeppwr);
delay(0.31*mixN);
ifzero(v10); zgradpulse(gzlvlC,gtC);
elsenz(v10); zgradpulse(-gzlvlC,gtC); endif(v10);
delay(gstab);
shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1);
delay(gstab);
ifzero(v10); zgradpulse(-gzlvlC,gtC);
elsenz(v10); zgradpulse(gzlvlC,gtC); endif(v10);
delay(0.49*mixN);
ifzero(v10); zgradpulse(-gzlvlC,2.0*gtC);
elsenz(v10); zgradpulse(gzlvlC,2.0*gtC); endif(v10);
delay(gstab);
if (getflag("Gzqfilt"))
{
obspower(zqfpwr3);
ifzero(v10); rgradient('z',gzlvlzq3);
elsenz(v10); rgradient('z',-gzlvlzq3); endif(v10);
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);
ifzero(v10); zgradpulse(gzlvlC,2.0*gtC);
elsenz(v10); zgradpulse(-gzlvlC,2.0*gtC); endif(v10);
delay(0.2*mixN);
obspower(tpwr);
if (flipback[A] == 'y')
FlipBack(v1,v12);
rgpulse(pw,v1,rof1,2.0e-6);
ExcitationSculpting(v7,v8,v10);
delay(rof2);
status(C);
}
void pulsesequence()
{
/* VARIABLE DECLARATION */
char sspul[MAXSTR];
/* INITIALIZE VARIABLES */
getstr("sspul",sspul);
if (p1 == 0.0)
p1 = pw;
/* CHECK CONDITIONS */
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, v9);
mod4(ct, v2);
mod2(ct, v1);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
hlv(v12, v9);
mod4(v12, v2);
mod2(v12, v1);
endif(ssctr);
/* CALCULATE PHASECYCLE */
hlv(v9, v8);
add(v8, v9, v9);
mod2(v9, v9); /* 00111100 */
dbl(v1, v1);
add(v1, v9, v1); /* 0202+00111100 */
initval(4.0, v10);
sub(v10, v2, v2); /* 0321 */
if ((phase1 == 1) || (phase1 == 2))
assign(zero, v2);
add(v2, v9, v2); /* 0321+00111100 or 0+00111100 */
mod4(v1, oph);
if (phase1 == 2)
incr(v1);
if (phase1 == 3)
add(v1, id2, v1);
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
if (sspul[A]=='y')
{
obspower(tpwr-12);
rgpulse(200*pw,zero,rof1,0.0);
rgpulse(300*pw,one,0.0,rof1);
obspower(tpwr);
}
if (satmode[A]=='y')
{
obspower(satpwr);
rgpulse(satdly,zero,rof1,rof2);
obspower(tpwr);
}
hsdelay(d1);
status(B);
rgpulse(p1, v1, rof1, 1.0e-6);
if (satmode[B]=='y')
{
if (d2>0)
{
obspower(satpwr);
rgpulse(d2-3.0*rof1-9.4e-6-4*pw/3.1414,zero,rof1,rof1);
obspower(tpwr);
}
}
else
delay(d2 - rof1 - 1.0e-6 - 4*pw/3.1414);
rgpulse(pw, v2, rof1, rof2);
status(C);
}
void pulsesequence()
{
double Dtau,Ddelta,dosytimecubed,dosyfrq,delcor,
del = getval("del"),
gstab = getval("gstab"),
gt1 = getval("gt1"),
gzlvl1 = getval("gzlvl1"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
satfrq = getval("satfrq");
char delflag[MAXSTR],sspul[MAXSTR],
alt_grd[MAXSTR],satmode[MAXSTR],lkgate_flg[MAXSTR];
getstr("delflag",delflag);
getstr("satmode",satmode);
getstr("alt_grd",alt_grd);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
/* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */
if (del < (4*pw+3.0*rof1+gt1+2.0*gstab))
{ abort_message("Dbppste error: 'del' is less than %g, too short!",
(4.0*pw+3*rof1+gt1+2.0*gstab));
}
Ddelta=gt1;
Dtau=2.0*pw+rof1+gstab+gt1/2.0;
dosyfrq = sfrq;
dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* Check for the validity of the number of transients selected !
if ( (nt != 4) && ((int)nt%16 != 0) )
{ abort_message("Dbppste error: nt must be 4, 16, 64 or n*16 (n: integer)!");
} */
/* phase cycling calculation */
mod2(ct,v1); dbl(v1,v1); hlv(ct,v2);
mod2(v2,v3); dbl(v3,v3); hlv(v2,v2);
mod2(v2,v4); add(v1,v4,v1); /* v1 */
hlv(v2,v2); add(v2,v3,v4); /* v4 */
hlv(v2,v2); mod2(v2,v3); dbl(v3,v5);
hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */
hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */
hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/
add(two,oph,oph);
mod2(ct,v10); /* gradients change sign at odd transients */
if (ni > 1.0)
{ abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
/* equilibrium period */
status(A);
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
if (satmode[0] == 'y')
{
if (d1 - satdly > 0) delay(d1 - satdly);
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(satdly,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
delay(1.0e-5);
}
else
{ delay(d1); }
if (getflag("wet"))
wet4(zero,one);
status(B);
/* first part of bppdel sequence */
if (delflag[0]=='y')
{ if (gt1>0 && gzlvl1>0)
{ rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */
delcor = del-4.0*pw-3.0*rof1-gt1-2.0*gstab;
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof) obsoffset(satfrq);
rgpulse(delcor,zero,rof1,rof1);
if (satfrq != tof) obsoffset(tof);
obspower(tpwr);
}
else delay(delcor); /*diffusion delay */
rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */
if (alt_grd[0] == 'y')
{ ifzero(v10);
zgradpulse(-1.0*gzlvl1,gt1/2.0);
elsenz(v10);
zgradpulse(gzlvl1,gt1/2.0);
endif(v10);
}
else zgradpulse(-1.0*gzlvl1,gt1/2.0);
delay(gstab+2*pw/PI);
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
}
else
rgpulse(pw,oph,rof1,rof2);
/* --- observe period --- */
status(C);
}
pulsesequence()
{
char Cdseq[MAXSTR], refoc[MAXSTR], sspul[MAXSTR];
int mult = (0.5 + getval("mult"));
double rg1 = 2.0e-6,
j1xh = getval("j1xh"),
gt0 = getval("gt0"),
gzlvl0 = getval("gzlvl0"),
pp = getval("pp"),
pplvl = getval("pplvl"),
compH = getval("compH"),
Cdpwr = getval("Cdpwr"),
Cdres = getval("Cdres"),
tau1 = 0.002,
tau2 = 0.002,
Cdmf = getval("Cdmf");
shape hdx;
/* Get new variables from parameter table */
getstr("Cdseq", Cdseq);
getstr("refoc", refoc);
getstr("sspul", sspul);
if (j1xh < 1.0) j1xh = 150.0;
hdx = pboxHT_F1i("gaus180", pp*compH, pplvl); /* HADAMARD stuff */
if (getval("htcal1") > 0.5) /* Optional fine power calibration */
hdx.pwr = getval("htpwr1");
if(j1xh > 0.0)
tau1 = 0.25/j1xh;
tau2 = tau1;
if (mult > 2) tau2=tau1/2.5;
else if ((mult == 0) || (mult == 2)) tau2=tau1/2.0;
dbl(ct, v1); /* v1 = 02 */
add(two,v1,oph);
mod4(oph,oph); /* oph = 02 */
/* Calculate delays */
if (dm[0] == 'y')
{
abort_message("decoupler must be set as dm=nny\n");
}
if(refoc[A]=='n' && dm[C]=='y')
{
abort_message("with refoc=n decoupler must be set as dm=nnn\n");
}
/* Relaxation delay */
status(A);
delay(0.05);
zgradpulse(gzlvl0,gt0);
if (sspul[0] == 'y')
{
obspower(tpwr); decpower(pplvl);
simpulse(pw, pp, zero, zero, rg1, rg1); /* destroy H and C magnetization */
zgradpulse(gzlvl0,gt0);
}
delay(d1);
status(B);
obspower(Cdpwr);
obsunblank(); xmtron();
obsprgon(Cdseq, 1.0/Cdmf, Cdres);
pbox_decpulse(&hdx, zero, rg1, rg1);
obsprgoff(); xmtroff(); obsblank();
obspower(tpwr); decpower(pplvl);
delay(2.0e-4);
decrgpulse(pp, v1, rg1, rg1);
delay(tau1 - POWER_DELAY);
simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1);
txphase(one); decphase(one);
delay(tau1);
simpulse(pw, pp, one, one, rg1, rg1);
if(refoc[A]=='y')
{
txphase(zero); decphase(zero);
delay(tau2);
simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1);
delay(tau2 - rof2 - POWER_DELAY);
decrgpulse(pp, zero, rg1, rof2);
}
decpower(dpwr);
status(C);
}
void pulsesequence()
{
double gzlvl1, gzlvl2, gzlvl3;
double gt1, gt2, gt3;
double grise, gstab;
double mix, phase;
int icosel;
/* GATHER AND INITALIZE VARIABLES */
gzlvl1 = getval("gzlvl1");
gt1 = getval("gt1");
gzlvl2 = getval("gzlvl2");
gt2 = getval("gt2");
gzlvl3 = getval("gzlvl3");
gt3 = getval("gt3");
grise = getval("grise");
gstab = getval("gstab");
mix = getval("mix");
phase = getval("phase");
if (phase == 1.0) icosel = 1;
if (phase == 2.0) icosel = -1;
/* CALCULATE PHASES */
/* ct = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 */
mod2(ct,v1); /*v1 = 0 1 0 1 0 1 0 1 */
dbl(v1,v1); /* = 0 2 0 2 0 2 0 2 */
hlv(ct,v2); /*v2 = 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 */
hlv(ct,v2); /* = 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 */
dbl(v2,v2); /* = 0 0 0 0 2 2 2 2 4 4 4 4 6 6 6 6 */
add(ct,v2,v4); /*v4 = 0 1 2 3 6 7 8 9 12 13 14 15 18 19 20 21 */
hlv(v2,v2); /*v2 = 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 */
hlv(v2,v2); /* = 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 */
mod2(v2,v2); /* = 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 */
dbl(v2,v2); /* = 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 2 */
hlv(ct,v3); /*v3 = 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 */
mod4(v3,v3); /* = 0 0 1 1 2 2 3 3 0 0 1 1 2 2 3 3 */
mod4(v4,v4); /* = 0 1 2 3 2 3 0 1 0 1 2 3 2 3 0 1 */
mod2(ct,v5); /*v5 = 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 */
add(ct,v5,v5); /* = 0 1 3 4 4 5 7 8 8 9 11 12 12 13 15 16 */
mod4(v5,v5); /* = 0 1 3 0 0 1 3 0 0 1 3 0 0 1 3 0 */
add(v5,v4,v4); /*v4 = 0 2 5 3 2 4 3 1 0 2 5 3 2 4 3 1 */
mod4(v4,v4); /* = 0 2 1 3 2 0 3 1 0 2 1 3 2 0 3 1 */
/* CHECK CONDITIONS */
if ((rof1 < 9.9e-6) && (ix == 1))
printf("Warning: ROF1 is less than 10 us\n");
/* BEGIN PULSE SEQUENCE */
status(A);
delay(d1);
status(B);
rgpulse(pw, v1, rof1, 1.0e-6);
delay(gt1 + grise + grise + 24.4e-6 - 1.0e-6 - rof1);
rgpulse(pw*2.0, v1, rof1, 1.0e-6);
if (d2 > 0.0)
delay(d2 - 1.0e-6 - rof1 - (4.0*pw/3.14159));
zgradpulse(gzlvl1,gt1+grise);
delay(grise);
rgpulse(pw, v2, rof1, 1.0e-6);
status(C);
zgradpulse(gzlvl2,gt2+grise);
delay(grise);
hsdelay(mix-gt2);
status(D);
rgpulse(pw, v3, rof1, rof2);
delay(gt3 + grise + grise + gstab + 24.4e-6 - rof2 - rof1);
rgpulse(pw*2.0, v3, rof1, rof2);
zgradpulse(gzlvl3*icosel,gt3+grise);
delay(grise);
delay(gstab);
assign(v4,oph);
}
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()
{
int selectCTP = getval("selectCTP");
double kappa = getval("kappa"),
gzlvl1 = getval("gzlvl1"),
gzlvl3 = getval("gzlvl3"),
gzlvl_max = getval("gzlvl_max"),
gt1 = getval("gt1"),
gt3 = getval("gt3"),
del = getval("del"),
gstab = getval("gstab"),
gss = getval("gss"),
tweak = getval("tweak"),
gzlvl_read=getval("gzlvl_read"),
num=getval("num"),
hsgt = getval("hsgt"),
gzlvlhs = getval("gzlvlhs"),
avm,gzlvl4,gt4,Dtau,Ddelta,dosytimecubed,dosyfrq;
char alt_grd[MAXSTR],avflag[MAXSTR],delflag[MAXSTR],STEflag[MAXSTR],sspul[MAXSTR];
gt4 = 2.0*gt1;
getstr("alt_grd",alt_grd);
getstr("delflag",delflag);
getstr("avflag",avflag);
getstr("STEflag",STEflag);
getstr("sspul",sspul);
avm=0.0;
if(avflag[0]=='y')
{
avm=1.0;
}
/* Decrement gzlvl4 as gzlvl1 is incremented, to ensure constant
energy dissipation in the gradient coil
Current through the gradient coil is proportional to gzlvl */
gzlvl4=sqrt(2.0*gt1*(1+3.0*kappa*kappa)/gt4)*sqrt(gzlvl_max*gzlvl_max/((1+kappa)*(1+kappa))-gzlvl1*gzlvl1);
/* In pulse sequence, del>4.0*pw+3*rof1+2.0*gt1+5.0*gstab+gt3 */
if ((del-(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3)) < 0.0)
{ del=(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3);
printf("Warning: del too short; reset to minimum value\n");}
if ((d1 - (gt3+gstab) -2.0*(gt4/2.0+gstab)) < 0.0)
{ d1 = (gt3+gstab) -2.0*(gt4/2.0+gstab);
printf("Warning: d1 too short; reset to minimum value\n");}
if ((abs(gzlvl1)*(1+kappa)) > gzlvl_max)
{ abort_message("Max. grad. amplitude exceeded: reduce either gzlvl1 or kappa\n");
}
if (ni > 1.0)
{ abort_message("This is a 2D, not a 3D dosy sequence: please set ni to 0 or 1\n");
}
Ddelta=gt1;
Dtau=2.0*pw+gstab+gt1/2.0+rof1;
dosyfrq = getval("sfrq");
dosytimecubed=del+(gt1*((kappa*kappa-2)/6.0))+Dtau*((kappa*kappa-1.0)/2.0);
dosytimecubed=(gt1*gt1)*dosytimecubed;
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* This section determines the phase calculation for any number of transients */
initval(num,v14);
add(v14,ct,v13);
/* phase cycling calculation */
if(delflag[0]=='y')
{
mod4(v13,v3); /* 1st 180, 0 1 2 3 */
hlv(v13,v9);
hlv(v9,v9);
mod4(v9,v4); /* 2nd 90, (0)4 (1)4 (2)4 (3)4 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v1); /* 2nd 180, (0)16 (1)16 (2)16 (3)16 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v2); /* 1st 90, (0)64 (1)64 (2)64 (3)64 */
hlv(v9,v9);
hlv(v9,v9);
mod4(v9,v5); /* 3rd 90, (0)256 (1)256 (2)256 (3)256 */
if(STEflag[0]=='y')
{
dbl(v2,v6); assign(v6,oph); sub(oph,v1,oph);
sub(oph,v3,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /* receiver phase for STE */
}
else
{
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /* receiver phase for STAE */
}
}
mod2(ct,v7); /* change sign of gradients on alternate transients */
status(A);
if(delflag[0]=='y')
{
if (sspul[0]=='y')
{
zgradpulse(gzlvlhs,hsgt);
rgpulse(pw,zero,rof1,rof1);
zgradpulse(gzlvlhs,hsgt);
}
delay(d1 - (gt3+gstab) -2.0*(gt4/2.0+gstab)-gss); /* Move d1 to here */
zgradpulse(-1.0*gzlvl4,gt4/2.0); /* 1st dummy heating pulse */
delay(gstab);
zgradpulse(gzlvl4,gt4/2.0); /* 2nd dummy heating pulse */
delay(gstab);
delay(gss); /* Short delay to acheive steady state */
if (alt_grd[0] == 'y')
{
ifzero(v7);
zgradpulse(-1.0*gzlvl3,gt3);
elsenz(v7);
zgradpulse(gzlvl3,gt3);
endif(v7);
}
else zgradpulse(-1.0*gzlvl3,gt3); /* Spoiler gradient balancing pulse */
delay(gstab);
}
else delay(d1);
status(B); /* first part of sequence */
if(delflag[0]=='y')
{
if(gt1>0 && abs(gzlvl1)>0)
{
if(selectCTP==2)
{
rgpulse(0.0, v1, rof1, rof2); /* first 90, v1 */
}
else
rgpulse(pw, v1, rof1, rof2); /* first 90, v1 */
zgradpulse(gzlvl1*(1.0+kappa),gt1/2.0); /*1st main gradient pulse*/
delay(gstab);
if(selectCTP==2)
{
rgpulse(0.0, v2, rof1, rof2); /* first 180, v2 */
}
else
rgpulse(pw*2.0, v2, rof1, rof2); /* first 180, v2 */
zgradpulse(-1.0*gzlvl1*(1.0-kappa),gt1/2.0); /*2nd main grad. pulse*/
delay(gstab);
if((selectCTP==1)||(selectCTP==2))
{
rgpulse(0.0, v3, rof1, rof2); /* second 90, v3 */
}
else
rgpulse(pw, v3, rof1, rof2); /* second 90, v3 */
zgradpulse(-gzlvl1*2.0*kappa,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
if (alt_grd[0] == 'y')
{
ifzero(v7);
zgradpulse(gzlvl3,gt3); /* Spoiler gradient */
elsenz(v7);
zgradpulse(-1.0*gzlvl3,gt3);
endif(v7);
}
else zgradpulse(gzlvl3,gt3); /* Spoiler gradient */
delay(gstab);
delay(del-4.0*pw-3.0*rof1-2.0*gt1-5.0*gstab-gt3); /* diffusion delay */
if(STEflag[0]=='y')
{
zgradpulse(2.0*kappa*gzlvl1,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
}
else
{
zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0); /*Lock refocussing pulse*/
delay(gstab);
}
if(selectCTP==1)
{
rgpulse(0.0, v4, rof1, rof2); /* third 90, v4 */
}
else
rgpulse(pw, v4, rof1, rof2); /* third 90, v4 */
if(STEflag[0]=='y')
{
zgradpulse(-gzlvl1*(1.0+kappa),gt1/2.0); /*3rd main gradient pulse*/
delay(gstab);
}
else
{
zgradpulse(gzlvl1*(1.0+kappa),gt1/2.0); /*3rd main gradient pulse*/
delay(gstab);
}
rgpulse(pw*2.0, v5, rof1, rof2); /* second 180, v5 */
rcvron();
if(STEflag[0]=='y')
{
zgradpulse(1.0*(1.0-kappa)*gzlvl1+tweak-avm*at*gzlvl_read/gt1,gt1/2.0); /*4th main grad. pulse*/
delay(gstab);
}
else
{
zgradpulse(-1.0*(1.0-kappa)*gzlvl1-tweak-avm*at*gzlvl_read/gt1,gt1/2.0); /*4th main grad. pulse*/
delay(gstab);
}
rgradient('z',gzlvl_read);
}
}
else rgpulse(pw,oph,rof1,rof2);
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 slpwrT = getval("slpwrT"),
slpwT = getval("slpwT"),
trim = getval("trim"),
mixT = getval("mixT"),
gzlvlz = getval("gzlvlz"),
gtz = getval("gtz"),
flippw = getval("flippw"),
phincr1 = getval("phincr1");
char slpatT[MAXSTR], alt_grd[MAXSTR], flipback[MAXSTR];
int phase1 = (int)(getval("phase")+0.5);
/* LOAD AND INITIALIZE VARIABLES */
// (void) set_RS(0); /* set up random sampling */
getstr("slpatT",slpatT);
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);
assign(ct,v17);
initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14);
settable(t1,4,ph1); getelem(t1,v17,v6);
settable(t2,4,ph2); getelem(t2,v17,v1);
settable(t3,8,ph3);
settable(t4,4,ph4); getelem(t4,v17,v13);
settable(t5,4,ph5); getelem(t5,v17,v21);
settable(t7,8,ph7); getelem(t7,v17,v7);
settable(t8,4,ph8); getelem(t8,v17,v8);
settable(t11,16,phs8); getelem(t11,v6,v3); /* 1st echo in ES */
settable(t12,16,phs9); getelem(t12,v6,v4); /* 2nd exho in ES */
settable(t13,4,rec_cor); getelem(t13,v6,v9);
assign(v1,oph);
if (getflag("zfilt"))
getelem(t3,v17,oph);
if (phase1 == 2)
{incr(v1); }
add(v1, v14, v1);
add(v6, v14, v6);
add(oph,v14,oph);
add(oph,v9,oph); mod4(oph,oph); /* correct oph for Excitation Sculpting */
/* The following is for flipback pulse */
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v10);
if (alt_grd[0] == 'y') mod2(ct,v2); /* alternate gradient sign on even scans */
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
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, 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,v21,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v21);
}
if ((getflag("zfilt")) && (getflag("PFGflg")))
{
obspower(tpwr);
rgpulse(pw,v7,1.0e-6,rof1);
ifzero(v2); zgradpulse(gzlvlz,gtz);
elsenz(v2); zgradpulse(-gzlvlz,gtz); endif(v2);
delay(gtz/3);
if (getflag("flipback"))
FlipBack(v8,v10);
rgpulse(pw,v8,rof1,2.0e-6);
}
ExcitationSculpting(v3,v4,v2);
delay(rof2);
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],
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("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);
assign(ct,v17);
assign(v17,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(t5,4,ph5); getelem(t5,v6,v5);
settable(t2,4,ph2); getelem(t2,v6,v2);
settable(t7,8,ph7); getelem(t7,v6,v7);
settable(t8,4,ph8); getelem(t8,v6,v8);
settable(t11,16,phs8); getelem(t11,v6,v3); /* 1st echo in ES */
settable(t12,16,phs9); getelem(t12,v6,v4); /* 2nd exho in ES */
if (getflag("zqfilt"))
getelem(t4,v6,oph);
else
assign(v1,oph);
add(oph,v5,oph); mod4(oph,oph);
sub(v2,one,v21);
add(v21,two,v23);
mod4(ct,v10);
if (alt_grd[0] == 'y') mod2(ct,v12); /* 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, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v12); zgradpulse(gzlvlA,gtA);
elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v1,rof1,rof1);
obspower(tpwr);
ifzero(v12); zgradpulse(gzlvlA,gtA);
elsenz(v12); zgradpulse(-gzlvlA,gtA); endif(v12);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v12); zgradpulse(gzlvlB,gtB);
elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v2,rof1,rof1);
obspower(slpwrT);
ifzero(v12); zgradpulse(gzlvlB,gtB);
elsenz(v12); zgradpulse(-gzlvlB,gtB); endif(v12);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixT > 0.0)
{
rgpulse(trim,v11,0.0,0.0);
if (dps_flag)
rgpulse(mixT,v21,0.0,0.0);
else
SpinLock(slpatT,mixT,slpwT,v21);
}
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,2.0e-6);
}
ExcitationSculpting(v3,v4,v12);
delay(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();
}
pulsesequence()
{
double slpwrR = getval("slpwrR"),
slpwR = getval("slpwR"),
mixR = getval("mixR"),
selpwrA = getval("selpwrA"),
selpwA = getval("selpwA"),
gzlvlA = getval("gzlvlA"),
gtA = getval("gtA"),
selpwrB = getval("selpwrB"),
selpwB = getval("selpwB"),
gzlvlB = getval("gzlvlB"),
gtB = getval("gtB"),
gstab = getval("gstab"),
selfrq = getval("selfrq"),
gzlvl1 = getval("gzlvl1"),
gt1 = getval("gt1"),
gzlvl2 = getval("gzlvl2"),
gt2 = getval("gt2"),
zqfpw1 = getval("zqfpw1"),
zqfpwr1 = getval("zqfpwr1"),
gzlvlzq1 = getval("gzlvlzq1"),
phincr1 = getval("phincr1");
char selshapeA[MAXSTR],selshapeB[MAXSTR], slpatR[MAXSTR],
zqfpat1[MAXSTR], alt_grd[MAXSTR];
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gtA = syncGradTime("gtA","gzlvlA",1.0);
gzlvlA = syncGradLvl("gtA","gzlvlA",1.0);
gtB = syncGradTime("gtB","gzlvlB",1.0);
gzlvlB = syncGradLvl("gtB","gzlvlB",1.0);
getstr("slpatR",slpatR);
getstr("selshapeA",selshapeA);
getstr("selshapeB",selshapeB);
getstr("zqfpat1",zqfpat1);
getstr("alt_grd",alt_grd);
if (strcmp(slpatR,"cw") &&
strcmp(slpatR,"troesy") &&
strcmp(slpatR,"dante"))
abort_message("SpinLock pattern %s not supported!.\n", slpatR);
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */
assign(ct,v17);
ifzero(ssctr);
assign(v17,v13);
elsenz(ssctr);
/* purge option does not adjust v13 during steady state */
sub(ssval, ssctr, v13);
endif(ssctr);
/* Beginning phase cycling */
dbl(v13,v1); /* v1 = 0 2 */
hlv(v13,v13);
dbl(v13,v20); /* v20 = 00 22 */
hlv(v13,v13);
dbl(v13,v6); /* v6 = 0000 2222 */
hlv(v13,v13);
dbl(v13,v7); /* v7 = 00000000 22222222 */
assign(v1,oph);
if (getflag("Gzqfilt"))
add(v7,oph,oph);
/* CYCLOPS */
assign(v13,v14); /* v14 = 8x0 8x1 8x2 8x3 */
if (getflag("Gzqfilt"))
hlv(v13,v14); /* v14 = 16x0 16x1 16x2 16x3 */
add(v1,v14,v1);
add(v20,v14,v20);
add(v6,v14,v6);
add(v7,v14,v7);
add(oph,v14,oph);
/* add(oph,v18,oph);
add(oph,v19,oph); */
assign(zero,v9);
mod2(ct,v2); /* 01 01 */
hlv(ct,v11); hlv(v11,v11); mod2(v11,v11); dbl(v11,v11); /* 0000 2222 */
add(v11,v2,v11); mod4(v11,v11); /* 0101 2323 first echo in Excitation Sculpting */
hlv(ct,v4); mod2(v4,v4); /* 0011 */
hlv(ct,v12); hlv(v12,v12); hlv(v12,v12); dbl(v12,v12); add(v12,v4,v12);
mod4(v12,v12); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */
dbl(v2,v2); /* 0202 */
dbl(v4,v4); /* 0022 */
add(v2,v4,v4); /* 0220 correct oph for Excitation Sculpting */
add(oph,v4,oph); mod4(oph,oph);
if (!strcmp(slpatR,"troesy"))
assign(v20,v21);
else
add(v20,one,v21);
if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign on even scans */
/* The following is for flipback pulse */
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v5);
/* BEGIN THE ACTUAL PULSE SEQUENCE */
status(A);
if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */
obspower(tpwr);
delay(5.0e-5);
if (getflag("sspul"))
steadystate();
delay(d1);
if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */
status(B);
rgpulse(pw, v1, rof1, rof1);
if (selfrq != tof)
obsoffset(selfrq);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
obspower(selpwrA);
shaped_pulse(selshapeA,selpwA,v14,rof1,rof1);
obspower(tpwr);
ifzero(v8); zgradpulse(gzlvlA,gtA);
elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8);
delay(gstab);
if (selfrq != tof)
delay(2*OFFSET_DELAY);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
obspower(selpwrB);
shaped_pulse(selshapeB,selpwB,v6,rof1,rof1);
obspower(slpwrR);
ifzero(v8); zgradpulse(gzlvlB,gtB);
elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8);
delay(gstab);
if (selfrq != tof)
obsoffset(tof);
if (mixR > 0.0)
{
if (dps_flag)
rgpulse(mixR,v21,0.0,0.0);
else
SpinLock(slpatR,mixR,slpwR,v21);
}
if (getflag("Gzqfilt"))
{
obspower(tpwr);
rgpulse(pw,v7,rof1,rof1);
ifzero(v8); zgradpulse(gzlvl1,gt1);
elsenz(v8); zgradpulse(-gzlvl1,gt1); endif(v8);
delay(gstab);
obspower(zqfpwr1);
ifzero(v8); rgradient('z',gzlvlzq1);
elsenz(v8); rgradient('z',-gzlvlzq1); endif(v8);
delay(100.0e-6);
shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1);
delay(100.0e-6);
rgradient('z',0.0);
delay(gstab);
ifzero(v8); zgradpulse(-gzlvl2,gt2);
elsenz(v8); zgradpulse(gzlvl2,gt2); endif(v8);
obspower(tpwr);
delay(gstab);
if (getflag("flipback"))
FlipBack(v14,v5);
rgpulse(pw,v14,rof1,2.0e-6);
}
ExcitationSculpting(v11,v12,v8);
delay(rof2);
status(C);
}
pulsesequence()
{
double delcor,initdel,gzlvl4,gt4,Dtau,Ddelta,dosytimecubed,dosyfrq,
kappa = getval("kappa"),
gzlvl1 = getval("gzlvl1"),
gzlvl3 = getval("gzlvl3"),
gzlvl_max = getval("gzlvl_max"),
gt1 = getval("gt1"),
gt3 = getval("gt3"),
del = getval("del"),
gstab = getval("gstab"),
satpwr = getval("satpwr"),
satdly = getval("satdly"),
satfrq = getval("satfrq"),
gzlvlhs = getval("gzlvlhs"),
hsgt = getval("hsgt"),
startflip = getval("startflip");
char delflag[MAXSTR], sspul[MAXSTR],
satmode[MAXSTR],alt_grd[MAXSTR],lkgate_flg[MAXSTR],oneshot45_flg[MAXSTR];
gt4 = 2.0*gt1;
getstr("delflag",delflag);
getstr("alt_grd",alt_grd);
getstr("oneshot45_flg",oneshot45_flg);
getstr("satmode",satmode);
getstr("lkgate_flg",lkgate_flg);
getstr("sspul",sspul);
//synchronize gradients to srate for probetype='nano'
// Preserve gradient "area"
gt1 = syncGradTime("gt1","gzlvl1",0.5);
gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5);
/* Decrement gzlvl4 as gzlvl1 is incremented, to ensure constant
energy dissipation in the gradient coil
Current through the gradient coil is proportional to gzlvl */
gzlvl4 = sqrt(2.0*gt1*(1+3.0*kappa*kappa)/gt4) *
sqrt(gzlvl_max*gzlvl_max/((1+kappa)*(1+kappa))-gzlvl1*gzlvl1);
/* In pulse sequence, del>4.0*pw+3*rof1+2.0*gt1+5.0*gstab+gt3 */
if ((del-(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3)) < 0.0)
{ del=(4*pw+3.0*rof1+2.0*gt1+5.0*gstab+gt3);
text_message("Warning: del too short; reset to minimum value");
}
if ((d1 - (gt3+gstab) -2.0*(gt4/2.0+gstab)) < 0.0)
{ d1 = (gt3+gstab) -2.0*(gt4/2.0+gstab);
text_message("Warning: d1 too short; reset to minimum value");
}
if ((gzlvl1*(1+kappa)) > gzlvl_max)
{ abort_message("Max. grad. amplitude exceeded: reduce either gzlvl1 or kappa");
}
if (ni > 1.0)
{ abort_message("This is a 2D, not a 3D dosy sequence: please set ni to 0 or 1");
}
if (delflag[0]=='y')
{ initdel=(gt3+gstab) -2.0*(gt4/2.0+gstab); }
else
{ initdel=0; }
Ddelta=gt1;
Dtau=2.0*pw+gstab+rof1;
dosyfrq = sfrq;
dosytimecubed = Ddelta*Ddelta*(del+(Ddelta/6.0) *
(kappa*kappa-2.0) +
(Dtau/2.0)*(kappa*kappa-1.0));
putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq);
/* phase cycling calculation */
if(delflag[0]=='y')
{
mod2(ct,v1); dbl(v1,v1); hlv(ct,v2);
mod2(v2,v3); dbl(v3,v3); hlv(v2,v2);
mod2(v2,v4); add(v1,v4,v1); /* v1 */
hlv(v2,v2); add(v2,v3,v4); /* v4 */
hlv(v2,v2); mod2(v2,v3); dbl(v3,v5);
hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */
hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */
hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */
assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph);
add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6);
add(v6,oph,oph); mod4(oph,oph); /* receiver phase */
mod2(ct,v6); dbl(v6,v6); /* 02 */
hlv(ct,v8); hlv(v8,v8); dbl(v8,v8); mod4(v8,v8); /* 00002222 */
add(oph,v8,v8);
add(v8,v6,v6);
add(v6,one,v6); /*Optional 45-degree pulse before acquisition- used when oneshot45_flg='y'*/
}
mod2(ct,v7); /* gradients change sign with every scan */
status(A);
if(delflag[0]=='y')
{ zgradpulse(-1.0*gzlvl4,gt4/2.0); /* 1st dummy heating pulse */
delay(gstab);
zgradpulse(gzlvl4,gt4/2.0); /* 2nd dummy heating pulse */
delay(gstab);
}
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);
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-initdel); }
if (getflag("wet")) wet4(zero,one);
if (delflag[0]=='y')
{
if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */
if (alt_grd[0] == 'y')
{
ifzero(v7); zgradpulse(-1.0*gzlvl3,gt3); /* Spoiler gradient balancing pulse */
elsenz(v7); zgradpulse(1.0*gzlvl3,gt3);
endif(v7);
}
else zgradpulse(-1.0*gzlvl3,gt3);
delay(gstab);
}
status(B); /* first part of sequence */
if (delflag[0]=='y')
{
if (gt1>0 && gzlvl1>0)
{
rgpulse(startflip*pw/90.0, v1, rof1, 0.0); /* first 90, v1 */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(gzlvl1*(1.0-kappa),gt1/2.0); /*1st main gradient pulse*/
elsenz(v7); zgradpulse(-1.0*gzlvl1*(1.0-kappa),gt1/2.0);
endif(v7);
}
else zgradpulse(gzlvl1*(1.0-kappa),gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(-1.0*gzlvl1*(1.0+kappa),gt1/2.0); /*2nd main grad. pulse*/
elsenz(v7); zgradpulse(1.0*gzlvl1*(1.0+kappa),gt1/2.0);
endif(v7);
}
else zgradpulse(-1.0*gzlvl1*(1.0+kappa),gt1/2.0);
delay(gstab);
rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(gzlvl1*2.0*kappa,gt1/2.0); /* Lock refocussing pulse*/
elsenz(v7); zgradpulse(-1.0*gzlvl1*2.0*kappa,gt1/2.0);
endif(v7);
}
else zgradpulse(gzlvl1*2.0*kappa,gt1/2.0);
delay(gstab);
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(gzlvl3,gt3); /* Spoiler gradient balancing pulse */
elsenz(v7); zgradpulse(-1.0*gzlvl3,gt3);
endif(v7);
}
else zgradpulse(gzlvl3,gt3);
delay(gstab);
delcor = del-4.0*pw-3.0*rof1-2.0*gt1-5.0*gstab-gt3;
if (satmode[1] == 'y')
{
obspower(satpwr);
if (satfrq != tof)
obsoffset(satfrq);
rgpulse(delcor,zero,rof1,rof1);
if (satfrq != tof)
obsoffset(tof);
obspower(tpwr);
}
else delay(del-4.0*pw-3.0*rof1-2.0*gt1-5.0*gstab-gt3); /* diffusion delay */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(2.0*kappa*gzlvl1,gt1/2.0); /*Lock refocussing pulse*/
elsenz(v7); zgradpulse(-2.0*kappa*gzlvl1,gt1/2.0);
endif(v7);
}
else zgradpulse(2.0*kappa*gzlvl1,gt1/2.0);
delay(gstab);
rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(gzlvl1*(1.0-kappa),gt1/2.0); /*3rd main gradient pulse*/
elsenz(v7); zgradpulse(-1.0*gzlvl1*(1.0-kappa),gt1/2.0);
endif(v7);
}
else zgradpulse(gzlvl1*(1.0-kappa),gt1/2.0);
delay(gstab);
rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */
if (alt_grd[0] == 'y')
{ifzero(v7); zgradpulse(-1.0*(1.0+kappa)*gzlvl1,gt1/2.0); /*4th main grad. pulse*/
elsenz(v7); zgradpulse(1.0*(1.0+kappa)*gzlvl1,gt1/2.0);
endif(v7);
}
else zgradpulse(-1.0*(1.0+kappa)*gzlvl1,gt1/2.0);
if (oneshot45_flg[0] == 'y')
{
delay(gstab);
rgpulse(0.5*pw,v6,rof1,rof2); /* 45-degree pulse, orthogonal to the last 90 */
}
else
delay(gstab+2*pw/PI);
}
if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */
}
else
rgpulse(pw,oph,rof1,rof2);
status(C);
}