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"),
h1freq_local = getval("h1freq_local"),
gcal_local = getval("gcal_local"),
coil_size = getval("coil_size"),
zqpw=getval("zqpw"),
zqpwr=getval("zqpwr"),
swfactor = 9.0, /* do the adiabatic sweep over 9.0*sw */
gzlvlzq,invsw;
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];
getstr("sspul", sspul);
getstr("trim_flg", trim_flg);
getstr("wrefshape", wrefshape);
getstr("flipshape", flipshape);
getstr("flipback", flipback);
getstr("zqshape", zqshape);
getstr("zqflg", zqflg);
getstr("alt_grd",alt_grd);
rof1 = getval("rof1"); if(rof1 > 2.0e-6) rof1=2.0e-6;
if (phincr1 < 0.0) phincr1=360+phincr1;
initval(phincr1,v13);
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);
settable(t1,16,phi1);
settable(t2,16,phi2);
settable(t3,16,phi3);
settable(t4,16,phi4);
settable(t5,16,phi5);
settable(t7,16,phi7);
settable(t8,16,phi8);
settable(t6,16,rec);
settable(t9,16,phi9);
sub(ct,ssctr,v12);
getelem(t1,v12,v1);
getelem(t2,v12,v2);
getelem(t3,v12,v3);
getelem(t4,v12,v4);
getelem(t5,v12,v5);
getelem(t6,v12,oph);
getelem(t7,v12,v7);
getelem(t8,v12,v8);
getelem(t9,v12,v6);
if (zqflg[0] == 'y') add(oph,two,oph);
mod2(ct,v10); /*changing gradient sign on even transitents */
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);
}
delay(d1);
status(B);
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 - POWER_DELAY> 0)
delay(d2-2.0*pw/3.14-2.0*rof1-SAPS_DELAY - 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()
{
/* DECLARE VARIABLES */
char scuba[MAXSTR],
mess_flg[MAXSTR],
imino[MAXSTR],
amino[MAXSTR],
jumpret[MAXSTR],
C13refoc[MAXSTR];
int phase,
t1_counter;
double hscuba, /* length of 1/2 SCUBA delay */
taunh, /* 1/4J(NH) */
tofps, /* water frequency */
tpwrmess, /* power level for Messerlie purge */
dly_pg, /* Messerlie purge delay */
pwClvl, /* power level for 13C hard pulse */
pwNlvl, /* power level for 15N hard pulse */
pwC, /* pulse width for 13C hard pulse */
pwN, /* pulse width for 15N hard pulse */
JNH, /* coupling for NH */
diff, /* freq diff H2O & exit center */
dof2a, /* offset for imino/amino */
tau1, /* t1/2 */
grecov, /* gradient recovery time */
gzlvl0, /* level of grad. for purge */
gzlvl1, /* level of grad. for 1/2J */
gt1, /* grad. duration for 1/2J */
gzlvlr; /* level of RDt1-gradient (0.5G) */
/* LOAD VARIABLES */
JNH = getval("JNH");
diff = getval("diff");
pwC = getval("pwC");
pwN = getval("pwN");
tofps = getval("tofps");
tpwrmess= getval("tpwrmess");
dly_pg = getval("dly_pg");
pwClvl = getval("pwClvl");
pwNlvl = getval("pwNlvl");
hscuba = getval("hscuba");
phase = (int)(getval("phase") + 0.5);
sw1 = getval("sw1");
at = getval("at");
grecov = getval("grecov");
gt1 = getval("gt1");
gzlvl0 = getval("gzlvl0");
gzlvl1 = getval("gzlvl1");
gzlvlr = getval("gzlvlr");
getstr("scuba",scuba);
getstr("mess_flg",mess_flg);
getstr("imino",imino);
getstr("amino",amino);
getstr("jumpret",jumpret);
getstr("C13refoc",C13refoc);
/* CHECK VALIDITY OF PARAMETER RANGE */
if (dm[A] == 'y' || dm[B] == 'y')
{
printf(" dm must be 'nny' or 'nnn' ");
psg_abort(1);
}
if ((dm[C] == 'y' || dm2[C] == 'y') && at > 0.21)
{
printf(" check at time! Don't fry probe \n");
psg_abort(1);
}
if (dm2[A] == 'y' || dm2[B] == 'y')
{
printf(" dm2 must be 'nny' or 'nnn' ");
psg_abort(1);
}
if ( ((imino[A]=='y') && (amino[A]=='y')) )
{
printf(" Choose ONE of imino='y' OR amino='y' ");
psg_abort(1);
}
if ((satmode[A] == 'y') && (jumpret[A] == 'y'))
{
printf(" Choose EITHER presat (satmode='y') OR Jump-Return (jumpret='y') \n");
psg_abort(1);
}
if (satpwr > 12)
{
printf(" satpwr must be less than 13 \n");
psg_abort(1);
}
if (tpwrmess > 55)
{
printf(" tpwrmess must be less than 55 \n");
psg_abort(1);
}
if (dly_pg > 0.010)
{
printf(" dly_pg must be less than 10msec \n");
psg_abort(1);
}
if (dpwr > 50)
{
printf(" dpwr must be less than 49 \n");
psg_abort(1);
}
if (dpwr2 > 50)
{
printf(" dpwr2 must be less than 46 \n");
psg_abort(1);
}
if (gt1 > 5.0e-3)
{
printf(" gti must be less than 5msec \n");
psg_abort(1);
}
if (gzlvl0 > 32768 || gzlvl1 > 32768 || gzlvl0 < -32768 || gzlvl1 < -32768)
{
printf(" gzlvli must be -32768 to 32768 (30G/cm) \n");
psg_abort(1);
}
if (gzlvlr > 500 || gzlvlr < -500)
{
printf(" RDt1-gzlvlr must be -500 to 500 (0.5G/cm) \n");
psg_abort(1);
}
/* LOAD PHASE PARAMETERS */
settable(t1, 8, phi1);
settable(t2, 2, phi2);
settable(t3, 8, phi3);
settable(t4, 1, phi4);
settable(t5, 8, rec);
/* INITIALIZE VARIABLES */
taunh = ((JNH != 0.0) ? 1/(4*(JNH)) : 2.78e-3);
dof2a = dof2;
/* IMINO-region setting of dof2 */
if (imino[A] == 'y')
dof2a = dof2 - 45*dfrq2;
/* AMINO-region setting of dof2 */
else if (amino[A] == 'y')
dof2a = dof2 - 115*dfrq2;
/* Phase incrementation for hyper complex data in t1 */
if (phase == 2)
tsadd(t2, 1, 4);
/* Calculate modification to phase based on current t1 values: States - TPPI acquisition */
if( ix == 1)
d2_init = d2;
t1_counter = (int) ((d2 - d2_init)*sw1 + 0.5);
if (t1_counter %2)
{
tsadd(t2, 2, 4);
tsadd(t5, 2, 4);
}
/* Set up so that you get (90, -180) phase correction in F1 */
tau1 = d2;
tau1 = tau1 -(4.0/PI)*pwN;
tau1 = tau1 / 2.0;
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(satpwr); /* Set power for presaturation */
decpower(pwClvl); /* Set DEC1 power to pwClvl */
dec2power(pwNlvl); /* Set DEC2 power to pwNlvl */
obsoffset(tof);
decoffset(dof);
dec2offset(dof2a);
if (mess_flg[A] == 'y') /* Option for Messerlie purge */
{
obsoffset(tofps);
obspower(tpwrmess);
txphase(zero);
xmtron();
delay(dly_pg);
xmtroff();
txphase(one);
xmtron();
delay(dly_pg/1.62);
xmtroff();
obsoffset(tof);
obspower(satpwr);
}
if (satmode[A] == 'y') /* Presaturation Period */
{
txphase(zero);
xmtron(); /* presaturation using transmitter */
delay(d1);
xmtroff();
obspower(tpwr); /* set power for hard pulse */
if (scuba[A] == 'y') /* SCUBA pulse */
{
hsdelay(hscuba);
rgpulse(pw, zero, rof1, 0.0);
rgpulse(2*pw, one, rof1, 0.0);
rgpulse(pw, zero, rof1, 0.0);
delay(hscuba);
}
}
else
{
obspower(tpwr);
delay(d1);
}
dec2rgpulse(pwN,zero, 0.0, 0.0); /* destroy N15 magnetization */
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
dec2rgpulse(pwN, one, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
decphase(t2);
delay(grecov);
status(B);
if (jumpret[A] == 'y')
{
rgpulse(pw, zero, rof1, rof1); /* jump-return pulse */
delay(0.25 / diff - 2.0*rof1);
rgpulse(pw, two, rof1, rof1);
}
else
rgpulse(pw, zero, rof1, rof1);
zgradpulse(gzlvl1,gt1);
delay(taunh - gt1 - 2.0*GRADIENT_DELAY ); /* delay = 1.0/2J(NH) */
delay(taunh);
dec2rgpulse(pwN, t2, 0.0, 0.0);
dec2phase(t4);
if (jumpret[A] == 'y')
{
tau1 = tau1-(pw+rof1+0.25/diff) ;
if (tau1 < 0.0) tau1 = 0.0;
if (tau1 > 0.001)
{
zgradpulse(gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY)); /* delay = t1/2 */
delay(0.1*tau1);
zgradpulse(-gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY));
delay(0.1*tau1);
}
else
delay(tau1); /* delay = t1/2 */
rgpulse(pw, t1, rof1, rof1);
if (C13refoc[A] == 'y')
{
delay((0.25 / diff) - pwC -rof1 );
decrgpulse(2*pwC, zero, 0.0, 0.0);
delay((0.25 / diff) - pwC -rof1) ;
}
else
{
delay(0.25 / diff);
delay(0.25 / diff);
}
rgpulse(pw, t3, rof1, rof1);
txphase(zero);
if (tau1 > 0.001)
{
zgradpulse(gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY)); /* delay = t1/2 */
delay(0.1*tau1);
zgradpulse(-gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY));
delay(0.1*tau1);
}
else
delay(tau1); /* delay = t1/2 */
}
else
{
if (C13refoc[A] == 'y')
tau1 = tau1-(pwC+rof1) ;
else
tau1 = tau1-(pw+rof1) ;
if (tau1 < 0.0) tau1 = 0.0;
if (tau1 > 0.001)
{
zgradpulse(gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY)); /* delay = t1/2 */
delay(0.1*tau1);
zgradpulse(-gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY));
delay(0.1*tau1);
}
else
delay(tau1); /* delay = t1/2 */
if (C13refoc[A] == 'y')
simpulse(2*pw, 2*pwC, t1, zero, rof1, rof1);
else
rgpulse(2*pw, t1, rof1, rof1);
txphase(zero);
if (tau1 > (4.0*GRADIENT_DELAY + 0.64*pw + rof1))
{
if (tau1 > 0.001)
{
zgradpulse(gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY)); /* delay = t1/2 */
delay(0.1*tau1);
zgradpulse(-gzlvlr,(0.4*tau1-2.0*GRADIENT_DELAY));
delay(0.1*tau1);
}
else
delay(tau1);
}
else
delay(tau1); /* delay = t1/2 */
}
dec2rgpulse(pwN, t4, 0.0, 0.0);
zgradpulse(gzlvl1,gt1);
decpower(dpwr); /* low power for decoupling */
dec2power(dpwr2);
delay(taunh - gt1 - 2.0*GRADIENT_DELAY-2.0*POWER_DELAY); /* delay = 1/2J(NH) */
delay(taunh);
status(C);
setreceiver(t5);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char autocal[MAXSTR], /* auto-calibration flag */
fsat[MAXSTR],
fscuba[MAXSTR],
f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
mess_flg[MAXSTR], /* water purging */
ar180a[MAXSTR], /* waveform shape for aromatic 180 pulse
with C transmitter at dof */
ar180b[MAXSTR], /* waveform shape for aromatic 180 pulse
with C transmitter at dofar */
cb180b[MAXSTR]; /* waveform shape for aliphatic 180 pulse
with C transmitter at dofar */
int phase, ni,
t1_counter; /* used for states tppi in t1 */
double tau1, /* t1 delay */
taua, /* ~ 1/4JCbHb = 1.7 ms */
taub, /* ~ 1/4JCgCd = 2.7 ms */
tauc, /* ~ 1/4JCgCd = 2.1 ms */
tauc2, /* ~ 1/4JCgCd = 2.1 ms */
taud, /* ~ 1/4JCdHd = 1.5 ms */
taue, /* = 1/4JCbHb = 1.8 ms */
tauf, /* ~ 1/2JCdHd = 3.1 ms */
TCb, /* carbon constant time period
for recording the Cb chemical shifts */
dly_pg1, /* delay for water purging */
pwar180a, /* 180 aro pulse at d_ar180a and dof */
pwcb180b, /* 180 cb pulse at d_cb180b and dofar */
pwC, /* 90 c pulse at pwClvl */
pwsel90, /* 90 c pulse at d_sel90 */
pwar180b, /* 180 c pulse at d_ar180b */
d_ar180a,
d_cb180b,
d_sel90,
d_ar180b,
dofar,
tsatpwr, /* low level 1H trans.power for presat */
tpwrmess, /* power level for water purging */
tpwrml, /* power level for 1H decoupling */
pwmlev, /* 90 pulse at tpwrml */
pwClvl, /* power level for high power 13C pulses on dec1 */
sw1, /* sweep width in f1 */
at,
gp11, /* gap between 90-90 for selective 180 of Cb */
fab, /* chemical shift difference of Ca-Cb (Hz) */
compC, /* C-13 RF calibration parameters */
compH,
gstab,
gt0,
gt1,
gt2,
gt3,
gt4,
gt5,
gt5a,
gt6,
gt7,
gzlvl0,
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl4,
gzlvl5,
gzlvl5a,
gzlvl6,
gzlvl7;
/* variables commented out are already defined by the system */
/* LOAD VARIABLES */
getstr("autocal",autocal);
getstr("fsat",fsat);
getstr("f1180",f1180);
getstr("fscuba",fscuba);
getstr("mess_flg",mess_flg);
taua = getval("taua");
taub = getval("taub");
tauc = getval("tauc");
tauc2 = getval("tauc2");
taud = getval("taud");
taue = getval("taue");
tauf = getval("tauf");
TCb = getval("TCb");
pwC = getval("pwC");
dofar = getval("dofar");
dly_pg1 = getval("dly_pg1");
tpwr = getval("tpwr");
tsatpwr = getval("tsatpwr");
tpwrmess = getval("tpwrmess");
tpwrml = getval("tpwrml");
pwClvl = getval("pwClvl");
dpwr = getval("dpwr");
phase = (int) ( getval("phase") + 0.5);
sw1 = getval("sw1");
ni = getval("ni");
at = getval("at");
fab = getval("fab");
gstab = getval("gstab");
gt0 = getval("gt0");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt5a = getval("gt5a");
gt6 = getval("gt6");
gt7 = getval("gt7");
gzlvl0 = getval("gzlvl0");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl5a = getval("gzlvl5a");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
if(autocal[0]=='n')
{
getstr("ar180a",ar180a);
getstr("ar180b",ar180b);
getstr("cb180b",cb180b);
pwar180a = getval("pwar180a");
pwar180b = getval("pwar180b");
pwcb180b = getval("pwcb180b");
pwsel90 = getval("pwsel90");
d_ar180a = getval("d_ar180a");
d_cb180b = getval("d_cb180b");
d_ar180b = getval("d_ar180b");
d_sel90 = getval("d_sel90");
pwmlev = getval("pwmlev");
}
else
{
strcpy(ar180a,"Pg3_off_cb180a");
strcpy(ar180b,"Pg3_off_cb180b");
strcpy(cb180b,"Pg3_on");
if (FIRST_FID)
{
compC = getval("compC");
compH = getval("compH");
sel90 = pbox("cal", SEL90, "", dfrq, compC*pwC, pwClvl);
ar_180a = pbox(ar180a, AR180a, CB180ps, dfrq, compC*pwC, pwClvl);
ar_180b = pbox(ar180b, AR180b, CB180ps, dfrq, compC*pwC, pwClvl);
cb_180b = pbox(cb180b, CB180b, CB180ps, dfrq, compC*pwC, pwClvl);
w16 = pbox_dec("cal", "WALTZ16", tpwrml, sfrq, compH*pw, tpwr);
}
pwsel90 = sel90.pw; d_sel90 = sel90.pwr;
pwar180a = ar_180a.pw; d_ar180a = ar_180a.pwr;
pwar180b = ar_180b.pw; d_ar180b = ar_180b.pwr;
pwcb180b = cb_180b.pw; d_cb180b = cb_180b.pwr;
pwmlev = 1.0/w16.dmf;
}
/* LOAD PHASE TABLE */
settable(t1,1,phi1);
settable(t2,1,phi2);
settable(t3,4,phi3);
settable(t4,8,phi4);
settable(t6,8,rec);
/* CHECK VALIDITY OF PARAMETER RANGES */
if( 0.5*ni*1/(sw1) > TCb - 2*POWER_DELAY
- WFG_START_DELAY - pwar180a - WFG_STOP_DELAY)
{
printf(" ni is too big\n");
psg_abort(1);
}
if((dm[A] == 'y' || dm[B] == 'y' ))
{
printf("incorrect dec1 decoupler flags! ");
psg_abort(1);
}
if(dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y')
{
printf("incorrect dec2 decoupler flags! ");
psg_abort(1);
}
if( tsatpwr > 6 )
{
printf("TSATPWR too large !!! ");
psg_abort(1);
}
if( tpwrml > 53 )
{
printf("tpwrml too large !!! ");
psg_abort(1);
}
if( tpwrmess > 56 )
{
printf("tpwrmess too large !!! ");
psg_abort(1);
}
if( dpwr > 50 )
{
printf("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( dpwr2 > 50 )
{
printf("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( pwClvl > 63 )
{
printf("don't fry the probe, DHPWR too large! ");
psg_abort(1);
}
if( pw > 20.0e-6 )
{
printf("dont fry the probe, pw too high ! ");
psg_abort(1);
}
if( pwcb180b > 500.0e-6 )
{
printf("dont fry the probe, pwcb180b too high ! ");
psg_abort(1);
}
if( pwar180a > 500.0e-6 )
{
printf("dont fry the probe, pwar180a too high ! ");
psg_abort(1);
}
if (pwar180b > 500.0e-6)
{
printf("dont fry the probe, pwsel90 too long !");
psg_abort(1);
}
if (pwsel90 > 100.0e-6)
{
printf("dont fry the probe, pwsel90 too long !");
psg_abort(1);
}
if(d_ar180a > 60)
{
printf("dont fry the probe, d_ar180a too high !");
psg_abort(1);
}
if(d_cb180b > 60)
{
printf("dont fry the probe, d_cb180b too high !");
psg_abort(1);
}
if (d_ar180b > 60)
{
printf("dont fry the probe, d_sel90 too high ! ");
psg_abort(1);
}
if (d_sel90 > 50)
{
printf("dont fry the probe, d_sel90 too high ! ");
psg_abort(1);
}
if( gt0 > 15e-3 || gt1 > 15e-3 || gt2 > 15e-3 || gt3 > 15e-3
|| gt4 > 15e-3 || gt5 > 15e-3 || gt6 > 15e-3 || gt7 > 15e-3
|| gt5a > 15e-3)
{
printf("gradients on for too long. Must be < 15e-3 \n");
psg_abort(1);
}
if( fabs(gzlvl0) > 30000 || fabs(gzlvl1) > 30000 || fabs(gzlvl2) > 30000
||fabs(gzlvl3) > 30000 || fabs(gzlvl4) > 30000 || fabs(gzlvl5) > 30000
||fabs(gzlvl6) > 30000 || fabs(gzlvl7) > 30000)
{
printf("too strong gradient");
psg_abort(1);
}
if( 2*TCb - taue > 0.1 )
{
printf("dont fry the probe, too long TCb");
psg_abort(1);
}
if( at > 0.1 && (dm[C]=='y' || dm2[C]=='y'))
{
printf("dont fry the probe, too long at with decoupling");
psg_abort(1);
}
if( pwC > 30.0e-6)
{
printf("dont fry the probe, too long pwC");
psg_abort(1);
}
if( dly_pg1 > 10.0e-3)
{
printf("dont fry the probe, too long dly_pg1");
psg_abort(1);
}
/* Phase incrementation for hypercomplex 2D data */
if (phase == 2)
tsadd(t2,1,4);
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2 ;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2) {
tsadd(t2,2,4);
tsadd(t6,2,4);
}
/* Set up f1180 tau1 = t1 */
tau1 = d2;
if(f1180[A] == 'y') {
tau1 += ( 1.0 / (2.0*sw1) );
}
tau1 = tau1/2.0;
/* 90-90 pulse for selective 180 of Cb but not Ca */
gp11 = 1/(2*fab) - 4/PI*pwsel90;
if (gp11 < 0.0) {
printf("gap of 90-90 negative, check fab and pwsel90");
psg_abort(1);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
/* Receiver off time */
status(A);
decoffset(dof);
obspower(tsatpwr); /* Set transmitter power for 1H presaturation */
decpower(pwClvl); /* Set Dec1 power for hard 13C pulses */
dec2power(dpwr2); /* Set Dec2 power for 15N decoupling */
/* Presaturation Period */
if(mess_flg[A] == 'y') {
obspower(tpwrmess);
rgpulse(dly_pg1,zero,20.0e-6,20.0e-6);
rgpulse(dly_pg1/1.62,one,20.0e-6,20.0e-6);
obspower(tsatpwr);
}
if (fsat[0] == 'y')
{
delay(2.0e-5);
rgpulse(d1,zero,20.0e-6,20.0e-6);
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
delay(2.0e-5);
if(fscuba[0] == 'y')
{
delay(2.2e-2);
rgpulse(pw,zero,2.0e-6,0.0);
rgpulse(2*pw,one,2.0e-6,0.0);
rgpulse(pw,zero,2.0e-6,0.0);
delay(2.2e-2);
}
}
else
{
delay(d1);
}
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
txphase(zero);
dec2phase(zero);
decphase(zero);
delay(1.0e-5);
/* Begin Pulses */
rcvroff();
delay(10.0e-6);
/* first ensure that magnetization does infact start on H and not C */
decrgpulse(pwC,zero,2.0e-6,2.0e-6);
delay(2.0e-6);
zgradpulse(gzlvl0,gt0);
delay(gstab);
/* this is the real start */
rgpulse(pw,zero,0.0,0.0); /* 90 deg 1H pulse */
delay(2.0e-6);
zgradpulse(gzlvl1,gt1);
delay(2.0e-6);
delay(taua - gt1 - 4.0e-6); /* taua <= 1/4JCH */
simpulse(2*pw,2*pwC,zero,zero,0.0,0.0);
txphase(t1);
delay(2.0e-6);
zgradpulse(gzlvl1,gt1);
delay(2.0e-6);
delay(taua - gt1 - 4.0e-6);
rgpulse(pw,t1,0.0,0.0);
txphase(zero);
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(gstab);
decphase(t2);
decpower(d_sel90);
decrgpulse(pwsel90,t2,2.0e-6,0.0);
decphase(zero);
decpower(d_ar180a);
decshaped_pulse(ar180a,pwar180a,zero,2.0e-6,0.0); /* bs effect */
delay(taue
- POWER_DELAY - WFG_START_DELAY - 2.0e-6 - pwar180a - WFG_STOP_DELAY
- POWER_DELAY - PRG_START_DELAY);
/* H decoupling on */
obspower(tpwrml);
obsprgon("waltz16",pwmlev,90.0);
xmtron(); /* TURN ME OFF DONT FORGET */
/* Hldecoupling on */
delay(TCb + tau1 - taue - POWER_DELAY - 2.0e-6);
decphase(t3);
decpower(d_sel90);
decrgpulse(pwsel90,t3,2.0e-6,0.0);
delay(gp11);
decrgpulse(pwsel90,t3,0.0,0.0);
decphase(zero);
decpower(d_ar180a);
decshaped_pulse(ar180a,pwar180a,zero,2.0e-6,0.0);
delay(TCb - tau1
- POWER_DELAY - WFG_START_DELAY - 2.0e-6 - pwar180a - WFG_STOP_DELAY
- POWER_DELAY - 2.0e-6);
decphase(zero);
decpower(d_sel90);
decrgpulse(pwsel90,zero,2.0e-6,0.0);
/* H decoupling off */
xmtroff();
obsprgoff();
obspower(tpwr);
/* H decoupling off */
decoffset(dofar);
delay(2.0e-6);
zgradpulse(gzlvl3,gt3);
delay(gstab);
decphase(t4);
decpower(d_sel90);
decrgpulse(pwsel90,t4,2.0e-6,0.0);
decphase(zero);
decpower(d_cb180b);
decshaped_pulse(cb180b,pwcb180b,zero,2.0e-6,0.0); /* B.S. */
delay(2.0e-6);
zgradpulse(gzlvl4,gt4);
delay(2.0e-6);
delay(taub
- POWER_DELAY - WFG_START_DELAY - 2.0e-6 - pwcb180b - WFG_STOP_DELAY
- gt4 - 4.0e-6
- POWER_DELAY - 2.0e-6);
decpower(d_ar180b);
decshaped_pulse(ar180b,pwar180b,zero,2.0e-6,0.0);
decpower(d_cb180b);
decshaped_pulse(cb180b,pwcb180b,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl4,gt4);
delay(2.0e-6);
delay(taub
- POWER_DELAY - WFG_START_DELAY - 2.0e-6 - pwcb180b - WFG_STOP_DELAY
- gt4 - 4.0e-6
- POWER_DELAY - 2.0e-6);
decpower(d_sel90);
decrgpulse(pwsel90,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(100.0e-6);
delay(tauc - POWER_DELAY - gt5 - 102.0e-6 - 2.0e-6);
decphase(zero);
decpower(pwClvl);
decrgpulse(2*pwC,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(100.0e-6);
txphase(zero);
delay(tauc
- POWER_DELAY - gt5 - 102.0e-6 - 2.0e-6);
decphase(zero);
decpower(d_sel90);
decrgpulse(pwsel90,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl5a,gt5a);
delay(100.0e-6);
delay(tauc2 - POWER_DELAY - gt5a - 102.0e-6 - 2.0e-6);
decphase(zero);
decpower(pwClvl);
decrgpulse(2*pwC,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl5a,gt5a);
delay(100.0e-6);
txphase(zero);
delay(tauf - gt5a - 102.0e-6);
rgpulse(2*pw,zero,0.0,0.0);
delay(tauc2 - tauf - 2*pw
- POWER_DELAY - 2.0e-6);
decphase(zero);
decpower(d_sel90);
decrgpulse(pwsel90,zero,2.0e-6,0.0);
txphase(zero);
delay(2.0e-6);
zgradpulse(gzlvl6,gt6);
delay(gstab);
rgpulse(pw,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl7,gt7);
delay(2.0e-6);
delay(taud
- gt7 - 4.0e-6
- POWER_DELAY - 2.0e-6);
decphase(zero);
decpower(pwClvl);
simpulse(2*pw,2*pwC,zero,zero,2.0e-6,0.0);
delay(2.0e-6);
zgradpulse(gzlvl7,gt7);
delay(2.0e-6);
delay(taud
- gt7 - 4.0e-6
- 2*POWER_DELAY);
decpower(dpwr); /* Set power for decoupling */
dec2power(dpwr2); /* Set power for decoupling */
rgpulse(pw,zero,0.0,rof2);
/* BEGIN ACQUISITION */
status(C);
setreceiver(t6);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char shape_ss[MAXSTR];
int t1_counter;
double
tau1, /* t1/2 */
taua = getval("taua"), /* 2.25ms */
taub = getval("taub"), /* 2.75ms */
time_T1,
pwN, /* PW90 for N-nuc */
pwNlvl, /* power level for N hard pulses */
ncyc = getval("ncyc"),
compH= getval("compH"),
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrs , /* power for the pwHs ("H2Osinc") pulse */
tpwrsf , /* fine power for the pwHs ("H2Osinc") pulse */
shss_pwr, /* power for cos modulated NH pulses */
pw_shpss=getval("pw_shpss"),
waterdly, /* pw for water pulse */
waterpwrf, /* fine power for water pulse */
waterpwr, /* power for water pulse */
gt0,
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gt6 = getval("gt6"),
gzlvl0 = getval("gzlvl0"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl6 = getval("gzlvl6");
/* LOAD VARIABLES */
pwN = getval("pwN");
pwNlvl = getval("pwNlvl");
tpwrsf = getval("tpwrsf");
waterpwrf = getval("waterpwrf");
waterdly = getval("waterdly");
getstr("shape_ss",shape_ss);
time_T1=ncyc*(2.0*2.5e-3+pw_shpss);
if (ix==1) printf(" ncyc= %f, time_T1= %f \n", ncyc,time_T1);
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /* needs 1.69 times more */
tpwrs = (int) (tpwrs); /* power than a square pulse */
/* selective H20 watergate pulse */
waterpwr = tpwr - 20.0*log10(waterdly/(compH*pw));
waterpwr = (int) (waterpwr);
/* selective cos modulated NH 180 degree pulse */
shss_pwr = tpwr - 20.0*log10(pw_shpss/((compH*2*pw)*2)); /* needs 2 times more */
shss_pwr = (int) (shss_pwr); /* power than a square pulse */
/* check validity of parameter range */
if((dm[A] == 'y' || dm[B] == 'y' ))
{
printf("incorrect Dec1 decoupler flags! ");
psg_abort(1);
}
if (dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y')
{
printf("incorrect Dec2 decoupler flag! dm2 should be 'nnn' ");
psg_abort(1);
}
if (dmm2[A] == 'g' || dmm2[B] == 'g' || dmm2[C] == 'g')
{
printf("incorrect Dec2 decoupler flag! dmm2 should be 'ccc' ");
psg_abort(1);
}
if( dpwr > 50 )
{
printf("don't fry the probe, dpwr too large! ");
psg_abort(1);
}
if( dpwr2 > 50 )
{
printf("don't fry the probe, dpwr2 too large! ");
psg_abort(1);
}
if(gt1 > 15.0e-3 || gt2 > 15.0e-3 || gt3 > 15.0e-3 || gt4 > 15.0e-3)
{
printf("gti must be less than 15 ms \n");
psg_abort(1);
}
/* LOAD VARIABLES */
settable(t1, 8, phi1);
settable(t2, 4, phi2);
settable(t3, 1, phi3);
settable(t10, 8, phi10);
settable(t14, 8, rec);
/* Phase incrementation for hypercomplex data */
if ( phase1 == 2 ) /* Hypercomplex in t1 */
{ ttadd(t14,t10,4);
tsadd(t3,2,4);
}
/* calculate modification to phases based on current t1 values
to achieve States-TPPI acquisition */
if(ix == 1)
d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5);
tau1=0.5*d2;
if(t1_counter %2) {
tsadd(t2,2,4);
tsadd(t14,2,4);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr); /* Set power for pulses */
dec2power(pwNlvl); /* Set decoupler2 power to pwNlvl */
initval(ncyc+0.1,v10); /* for DIPSI-2 */
delay(d1);
status(B);
rcvroff();
/*destroy N15 magnetization*/
dec2rgpulse(pwN, zero, 0.0, 0.0);
zgradpulse(gzlvl1, gt1);
delay(9.0e-5);
/* 1H-15N INEPT */
rgpulse(pw,zero,1.0e-6,0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl2,gt2);
delay(taua -pwN-0.5*pw -gt2 ); /* delay=1/4J(NH) */
sim3pulse(2.0*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0);
txphase(one);
dec2phase(t1);
zgradpulse(gzlvl2,gt2);
delay(taua -1.5*pwN -gt2); /* delay=1/4J(NH) */
sim3pulse(pw,0.0e-6,pwN,one,zero,t1,0.0,0.0);
if (tpwrsf < 4095.0)
{
obspwrf(tpwrsf);
tpwrs=tpwrs+6.0;
}
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, two, 2.0e-6, 0.0);
obspower(tpwr);
obspwrf(4095.0);
tpwrs=tpwrs-6.0;
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl3,gt3);
delay(taub -1.5*pwN -gt3 -pwHs-2.0e-6-2.0*POWER_DELAY-WFG_START_DELAY); /* delay=1/4J(NH) */
sim3pulse(2.0*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0);
dec2phase(one);
zgradpulse(gzlvl3,gt3);
delay(taub -1.5*pwN -gt3 ); /* delay=1/4J(NH) */
dec2phase(one);
dec2rgpulse(pwN,one,0.0,0.0);
/* relaxation recovery */
if (ncyc>0.6)
{
obspower(shss_pwr);
starthardloop(v10);
delay(2.5e-3);
shaped_pulse(shape_ss,pw_shpss,zero,0.0,0.0);
delay(2.5e-3);
endhardloop();
obspower(tpwr);
}
zgradpulse(gzlvl6,gt6);
delay(200.0e-6);
dec2rgpulse(pwN,t2,0.0,0.0);
txphase(t3);
dec2phase(zero);
/* evolution of t1 */
if(d2>0.001)
{
zgradpulse( gzlvl0,(d2/2.0-0.0003-2.0*GRADIENT_DELAY));
delay(300.0e-6);
zgradpulse(-gzlvl0,(d2/2.0-0.0003-2.0*GRADIENT_DELAY));
delay(300.0e-6);
}
else
delay(d2);
/* ST2 */
rgpulse(pw,t3,0.0,0.0);
txphase(t3);
if (waterpwrf < 4095.0)
{
obspwrf(waterpwrf);
waterpwr=waterpwr+6.0;
}
obspower(waterpwr);
rgpulse(waterdly,t3,0.0,rof1);
if (waterpwrf < 4095.0)
{
obspwrf(4095.0);
waterpwr=waterpwr-6.0;
}
obspower(tpwr);
txphase(zero);
zgradpulse(gzlvl4,gt4);
delay(taua -pwN -0.5*pw -gt4-waterdly-rof1);
sim3pulse(2.0*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0);
dec2phase(t3);
zgradpulse(gzlvl4,gt4);
delay(taua -1.5*pwN -gt4 -waterdly-rof1); /* delay=1/4J(NH) */
if (waterpwrf < 4095.0)
{
obspwrf(waterpwrf);
waterpwr=waterpwr+6.0;
}
obspower(waterpwr);
txphase(two);
rgpulse(waterdly,two,rof1,0.0);
if (waterpwrf < 4095.0)
{
obspwrf(4095.0);
waterpwr=waterpwr-6.0;
}
obspower(tpwr);
sim3pulse(pw,0.0e-6,pwN,zero,zero,t3,0.0,0.0);
/* watergate */
zgradpulse(gzlvl5,gt5);
delay(taua-1.5*pwN-waterdly-gt5);
txphase(two);
if (waterpwrf < 4095.0)
{
obspwrf(waterpwrf);
waterpwr=waterpwr+6.0;
}
obspower(waterpwr);
dec2phase(zero);
rgpulse(waterdly,two,0.0,rof1);
if (waterpwrf < 4095.0)
{
obspwrf(4095.0);
waterpwr=waterpwr-6.0;
}
obspower(tpwr);
txphase(zero);
sim3pulse(2.0*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0);
if (waterpwrf < 4095.0)
{
obspwrf(waterpwrf);
waterpwr=waterpwr+6.0;
}
obspower(waterpwr);
txphase(two);
rgpulse(waterdly,two,rof1,0.0);
if (waterpwrf < 4095.0)
{
obspwrf(4095.0);
waterpwr=waterpwr-6.0;
}
zgradpulse(gzlvl5,gt5);
obspwrf(4095.0);
obspower(tpwr);
delay(taua-1.5*pwN-waterdly-gt5);
dec2rgpulse(pwN,zero,0.0,0.0);
/* acquire data */
status(C);
setreceiver(t14);
}
pulsesequence()
{
/*DEFINE LOCAL VARIABLES */
double mix,control,sattime,spacing;
int pattern,times,jj;
char intsub[MAXSTR],cycle[MAXSTR],sspul[MAXSTR];
/* LOAD AND INITIALIZE VARIABLES */
getstr("intsub",intsub);
getstr("cycle",cycle);
getstr("sspul",sspul);
control = getval("control");
sattime = getval("sattime");
spacing = getval("spacing");
pattern = (int)getval("pattern");
mix = getval("mix");
if (pattern == 0) pattern = 1;
if (tau == 0.0) tau = 0.1;
times = (int)(sattime/(pattern*tau));
/* CHECK CONDITIONS */
if (!newtrans)
{
fprintf(stdout,"REQUIRED: direct syn. RF and linear amplifiers.\n");
psg_abort(1);
}
/* CALCULATE PHASES */
if (intsub[0] == 'y') hlv(ct,v1);
else assign(ct,v1);
assign(v1,oph);
if (intsub[0] == 'y')
{
mod2(ct,v14); /* trigger for the alteration of the saturation freq */
ifzero(v14);
add(oph,two,oph);
endif(v14);
}
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
if (sspul[A] == 'y')
{
pulse(200*pw,zero);
pulse(200*pw,one);
}
hsdelay(d1);
obspower(satpwr);
delay(0.2e-6); /*reduce xmtr leakage */
status(B);
/* selective pulse or decoupler saturation */
/* no cycling or interleaved subtraction (make control an array)*/
if ((intsub[0] == 'n') && (cycle[0] == 'n'))
{
obsoffset(satfrq);
rgpulse(sattime,zero,rof1,rof2);
}
/* interleaved subtraction without cycling */
if ((intsub[0] == 'y') && (cycle[0] == 'n'))
{
ifzero(v14);
obsoffset(control);
rgpulse(sattime,zero,rof1,rof2);
elsenz(v14);
obsoffset(satfrq);
rgpulse(sattime,zero,rof1,rof2);
endif(v14);
}
/* no interleaved subtraction but cycling is used (make cycle array)*/
if ((cycle[0] == 'y') && (intsub[0] == 'n'))
{
for (jj = 0; jj < times; jj++)
{
double startfrq;
int i;
startfrq = satfrq - (pattern/2)*spacing;
if ((pattern %2) == 0) startfrq = startfrq + spacing/2.0;
for (i = 0; i < pattern; i++)
{
obsoffset(startfrq);
rgpulse(tau,zero,rof1,rof2);
startfrq = startfrq + spacing;
}
}
}
/* interleaved subtraction with cycling (no array needed for one
value of satfrq. Link array satfrq with pattern and spacing for
multiple noe difference spectra within one experiment. For example
set array = '(satfrq,pattern,spacing)') */
if ((cycle[0] == 'y') && (intsub[0] == 'y'))
{
ifzero(v14);
for (jj = 0; jj < times; jj++)
{
double startfrq;
int i;
startfrq = control - (pattern/2)*spacing;
if ((pattern %2) == 0) startfrq = startfrq + spacing/2.0;
for (i = 0; i < pattern; i++)
{
obsoffset(startfrq);
rgpulse(tau,zero,rof1,rof2);
startfrq = startfrq + spacing;
}
}
elsenz(v14);
for (jj = 0; jj < times; jj++)
{
double startfrq;
int i;
startfrq = satfrq - (pattern/2)*spacing;
if ((pattern %2) == 0) startfrq = startfrq + spacing/2.0;
for (i = 0; i < pattern; i++)
{
obsoffset(startfrq);
rgpulse(tau,zero,rof1,rof2);
startfrq = startfrq + spacing;
}
}
endif(v14);
}
/* restore power levels as controlled by tpwr */
obsoffset(tof);
obspower(tpwr);
status(C);
/* NOE mixing time */
hsdelay(mix);
status(D);
/* sampling pulse */
rgpulse(pw,v1,rof1,rof2);
}
void pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
Cfilter[MAXSTR]; /*do C' Cfilter */
int icosel, /* used to get n and p type */
t1_counter; /* used for states tppi in t1 */
double tCN = getval("tCN"),
kappa, /*semi-constant time scale factor*/
tau1, /* t1 delay */
lambda = 0.91/(4.0*getval("JNH")), /* 1/4J H1 evolution delay */
/* the sech/tanh pulse is automatically calculated by the macro "proteincal", */
/* and is called directly from your shapelib. */
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rf0, /* maximum fine power when using pwC pulses */
pwC3 = getval("pwC3"), /* 180 selective Ca null on C' */
pwC8 = getval("pwC8"), /* 180 selective C' null on Ca */
pwC6 = getval("pwC6"), /* 90 selective C' null on Ca */
rf8,
Ca90power = getval("Ca90power"),
Ca180power = getval("Ca180power"),
compH = getval("compH"), /* adjustment for H1 amplifier compression */
compN = getval("compN"), /* adjustment for N15 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
tpwrsf_n = getval("tpwrsf_n"), /* fine power adustment for first soft pulse*/
tpwrsf_d = getval("tpwrsf_d"), /* fine power adustment for second soft pulse*/
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrs, /* power for the pwHs ("H2Osinc") pulse */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
gt1 = getval("gt1"), /* coherence pathway gradients */
gzcal = getval("gzcal"), /* dac to G/cm conversion */
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gt5 = getval("gt5"),
gstab = getval("gstab"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl5 = getval("gzlvl5");
getstr("f1180",f1180);
getstr("Cfilter",Cfilter);
/* LOAD PHASE TABLE */
settable(t1,2,phi1);
settable(t2,4,phi2);
settable(t3,1,phi3);
settable(t4,2,rec);
/* INITIALIZE VARIABLES */
rf0 = 4095.0;
/* 180 degree one-lobe sinc pulse on CO, null at Ca 118ppm away */
rf8 = (compC*4095.0*pwC*2.0*1.65)/pwC8; /* needs 1.65 times more */
rf8 = (int) (rf8 + 0.5); /* power than a square pulse */
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /*needs 1.69 times more*/
tpwrs = (int) (tpwrs); /*power than a square pulse */
/* CHECK VALIDITY OF PARAMETER RANGES */
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{ text_error("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1); }
if((dm2[A] == 'y' || dm2[B] == 'y'))
{ text_error("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1); }
if( dpwr2 > 50 )
{ text_error("don't fry the probe, DPWR2 too large! "); psg_abort(1); }
if( pw > 50.0e-6 )
{ text_error("dont fry the probe, pw too high ! "); psg_abort(1); }
if( pwN > 100.0e-6 )
{ text_error("dont fry the probe, pwN too high ! "); psg_abort(1); }
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 1) icosel = -1;
else { tsadd(t3,2,4); icosel = +1; }
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t1,2,4); tsadd(t4,2,4); }
kappa = tCN>ni/sw1? 1:tCN/(ni/sw1);
kappa = ((double)((int)(kappa*1000)))/1000;
/* 3 digits after the point, may cause a small decrease in value for safe boundary */
printf("kappa = %f\n", kappa);
/* BEGIN PULSE SEQUENCE */
status(A);
obspower(tpwr);
decpower(pwClvl);
decpwrf(rf0);
dec2power(pwNlvl);
txphase(zero);
decphase(zero);
dec2phase(zero);
delay(d1);
/* xxxxxxxxxxxxxxxxx CONSTANT SAMPLE HEATING FROM N15 RF xxxxxxxxxxxxxxxxx */
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
rcvroff();
/*dec2rgpulse(pwN, zero, 0.0, 0.0); */ /*destroy N15 magnetization*/
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
/*dec2rgpulse(pwN, one, 0.0, 0.0); */
zgradpulse(0.7*gzlvl0, 0.5e-3);
txphase(t1);
delay(5.0e-4);
rgpulse(pw,zero,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero,zero, zero, 0.0, 0.0);
txphase(one);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
rgpulse(pw, three, 0.0, 0.0);
txphase(two);
obspower(tpwrs+6.0);
obspwrf(tpwrsf_n);
shaped_pulse("H2Osinc_n", pwHs, zero, 5.0e-5, 0.0);
obspower(tpwr); obspwrf(4095.0);
zgradpulse(gzlvl3, gt3);
dec2phase(t1);
delay(gstab);
decpower(Ca180power); /* set power for Ca 180 inversion */
dec2rgpulse(pwN, t1, 0.0, 0.0);
txphase(zero);
decphase(zero);
/* xxxxxxxxxxxxxxxxxx OPTIONS FOR N15 EVOLUTION xxxxxxxxxxxxxxxxxxxxx */
txphase(zero);
dec2phase(zero);
/* shared CT for C' Cfilter and N15 chem shift evolution */
delay(tCN/2.0 - kappa*tau1 - gt5 -gstab);
zgradpulse(gzlvl5,gt5);
delay(gstab);
if(Cfilter[A] == 'y' && (1-kappa)*tau1 < pwC3/2) {
sim3shaped_pulse("", "Ca_reburp_180", "", 0.0, pwC3, 2.0*pwN, zero, zero, zero,0.0,0.0);
zgradpulse(gzlvl5,gt5);
delay(tCN/2.0 + (1-kappa)*tau1 -gt5 - pwC3 - pwC8);
}
else if (Cfilter[A] == 'y' ){
dec2rgpulse(2.0*pwN,zero,(pwC3-2.0*pwN)/2.0,(pwC3-2.0*pwN)/2.0);
if( (1-kappa)*tau1 >= gt5 +gstab + pwC3/2){
zgradpulse(gzlvl5,gt5);
delay((1-kappa)*tau1 -pwC3/2.0 - gt5);
decshaped_pulse("Ca_reburp_180", pwC3,zero,0.0,0.0);
delay(tCN/2.0 - pwC8 - 1.5*pwC3);
}
else{
delay((1-kappa)*tau1 -pwC3/2.0);
decshaped_pulse("Ca_reburp_180", pwC3,zero,0.0,0.0);
zgradpulse(gzlvl5,gt5);
delay(tCN/2.0 -gt5 - pwC8 - 1.5*pwC3);
}
}
else{
dec2rgpulse(2.0*pwN,zero,(pwC3-2.0*pwN)/2.0,(pwC3-2.0*pwN)/2.0);
zgradpulse(gzlvl5,gt5);
delay(tCN/2.0 + (1-kappa)*tau1 -gt5 - pwC3 - pwC8);
}
decpower(pwClvl);
decpwrf(rf8); /* C' 180 power */
decshaped_pulse("offC8", pwC8, zero,0.0, 0.0);
decpwrf(rf0);
decpower(Ca180power); /* Ca 180 power */
if(Cfilter[A] == 'y'){
delay(pwC3);
}
else {
decshaped_pulse("Ca_reburp_180", pwC3,zero,0.0,0.0);
}
delay(tau1);
zgradpulse(gzlvl1, gt1);
dec2phase(t2);
delay(pwC6 - 2.0*GRADIENT_DELAY);
dec2rgpulse(2.0*pwN, t2, 0.0, 0.0);
delay(gt1);
decpower(Ca90power); /*Ca 90 power */
decshaped_pulse("Ca_eburp1_90", pwC6, zero, 0.0, 0.0); /* creates MQ */
txphase(three);
txphase(t4);
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
sim3pulse(pw,0.0,pwN, zero,zero, t3, 0.0, 0.0);
if (tpwrsf_d<4095.0)
{
obspwrf(tpwrsf_d); obspower(tpwrs+6.0);
shaped_pulse("H2Osinc_d", pwHs, zero, 5.0e-5, 0.0);
obspower(tpwr); obspwrf(4095.0);
}
else
{
obspower(tpwrs);
shaped_pulse("H2Osinc_d", pwHs, zero, 5.0e-5, 0.0);
obspower(tpwr);
}
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
delay(lambda - 0.65*(pw + pwN) - gt5 - pwHs - 2.0*POWER_DELAY -2.0*PWRF_DELAY -50.0e-6);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
txphase(one);
dec2phase(zero);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(pw, 0.0, pwN, one, zero, zero, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(1.5*gzlvl5, gt5);
delay(lambda - 1.3*pwN - gt5 );
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(one);
zgradpulse(1.5*gzlvl5, gt5);
delay(lambda - 1.6*pwN - gt5);
sim3pulse(pw, 0.0, pwN, one, zero, one, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab - 0.65*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, 0.0);
dec2power(dpwr2); /* POWER_DELAY */
zgradpulse(icosel*gzlvl2, 0.1*gt1); /* 2.0*GRADIENT_DELAY */
delay(gstab);
rcvron();
statusdelay(C,1.0e-4);
setreceiver(t4);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char fsat[MAXSTR],
fscuba[MAXSTR],
f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
codecseq[MAXSTR],
ddseq[MAXSTR],
shca180[MAXSTR],
shca90[MAXSTR];
int phase, ni,
t1_counter, /* used for states tppi in t1 */
tau2;
double tau1, /* t1 delay */
taua, /* ~ 1/4JCH = 1.7 ms */
taub, /* ~ 1/2JCH for AX spin systems */
taud, /* ~ 1/4JCD 12.5 ms for AX spin system */
TC, /* carbon constant time period 1/2JCC */
pwc, /* 90 c pulse at dhpwr */
tsatpwr, /* low level 1H trans.power for presat */
dhpwr, /* power level for high power 13C pulses on dec1 */
sw1, /* sweep width in f1 */
time_T2, /* total relaxation time for T2 measurement */
pwcodec, /* pw90 for C' decoupling */
dressed, /* = 2 for seduce-1 decoupling */
dpwrsed,
pwd, /* pulse width for D decoupling at dpwr3_D */
dresD,
dpwr3_D,
lk_wait, /* delay for lk receiver recovery */
pwd1, /* pulse width for D +/- pulses at dpwr3 */
d_ca180,
pwca180,
pwca90, /* ca selective pulse at 57.5 ppm */
d_ca90, /* power level for pwca90 */
dpwr3_sl, /* D power level for spin locking */
pwd_sl, /* pw for D at dpwr3_sl */
gt1,
gt2,
gt3,
gt4,
gt5,
gt6,
gt7,
gt8,
gstab=getval("gstab"),
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl4,
gzlvl5,
gzlvl6,
gzlvl7,
gzlvl8;
/* variables commented out are already defined by the system */
/* LOAD VARIABLES */
getstr("fsat",fsat);
getstr("f1180",f1180);
getstr("fscuba",fscuba);
getstr("codecseq",codecseq);
getstr("ddseq",ddseq);
getstr("shca180",shca180);
getstr("shca90",shca90);
taua = getval("taua");
taub = getval("taub");
taud = getval("taud");
TC = getval("TC");
pwc = getval("pwc");
tpwr = getval("tpwr");
tsatpwr = getval("tsatpwr");
dhpwr = getval("dhpwr");
dpwr = getval("dpwr");
phase = (int) ( getval("phase") + 0.5);
sw1 = getval("sw1");
ni = getval("ni");
pwcodec = getval("pwcodec");
dressed = getval("dressed");
dpwrsed = getval("dpwrsed");
pwd = getval("pwd");
dresD = getval("dresD");
dpwr3_D = getval("dpwr3_D");
lk_wait = getval("lk_wait");
pwd1 = getval("pwd1");
d_ca180 = getval("d_ca180");
pwca180 = getval("pwca180");
pwca90 = getval("pwca90");
d_ca90 = getval("d_ca90");
dpwr3_sl = getval("dpwr3_sl");
pwd_sl = getval("pwd_sl");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt6 = getval("gt6");
gt7 = getval("gt7");
gt8 = getval("gt8");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
gzlvl8 = getval("gzlvl8");
/* LOAD PHASE TABLE */
settable(t1,16,phi1);
settable(t2,2,phi2);
settable(t3,16,phi3);
settable(t4,4,phi4);
settable(t6,4,phi6);
settable(t7,8,phi7);
settable(t5,16,rec_d);
/* CHECK VALIDITY OF PARAMETER RANGES */
if( TC - 0.50*(ni-1)*1/(sw1) - WFG_STOP_DELAY
- gt6 - 102e-6 - POWER_DELAY
- PRG_START_DELAY - POWER_DELAY
- 4.0e-6 - pwd1 - POWER_DELAY
- PRG_START_DELAY - PRG_STOP_DELAY
- 2.0e-6 - POWER_DELAY - 2.0e-6
< 0.2e-6 )
{
printf(" ni is too big\n");
psg_abort(1);
}
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{
printf("incorrect dec1 decoupler flags! ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y' || dm2[D] == 'y'))
{
printf("incorrect dec2 decoupler flags! ");
psg_abort(1);
}
if( tsatpwr > 6 )
{
printf("TSATPWR too large !!! ");
psg_abort(1);
}
if( dpwr > 48 )
{
printf("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( dpwr2 > 49 )
{
printf("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( dhpwr > 63 )
{
printf("don't fry the probe, DHPWR too large! ");
psg_abort(1);
}
if( pw > 200.0e-6 )
{
printf("dont fry the probe, pw too high ! ");
psg_abort(1);
}
if(gt1 > 15e-3 || gt2 > 15e-3 || gt3 > 15e-3 ||
gt4 > 15e-3 || gt5 > 15e-3 || gt6 > 15e-3 || gt7 > 15e-3
|| gt8 > 15e-3)
{
printf("gradients on for too long. Must be < 15e-3 \n");
psg_abort(1);
}
if(dpwr3_D > 54)
{
printf("D decoupling power is too high\n");
psg_abort(1);
}
if(lk_wait > .015 )
{
printf("lk_wait delay may be too long\n");
psg_abort(1);
}
/* change back to 48 */
if(dpwr3_sl > 53) {
printf("dpwr3_sl is too large; must be less than 53\n");
psg_abort(1);
}
/* change back to 250 */
if(pwd_sl < 170.0e-6) {
printf("pwd_sl is too large; Must be larger than 170 us\n");
psg_abort(1);
}
/* Calculation of IzCzDz relaxation delay */
tau2 = (int) (d3+0.1);
time_T2 = z_array[tau2];
if(time_T2 > 0.030) {
printf("time_T2 is too long; Must be less than 30 ms\n");
psg_abort(1);
}
/* Phase incrementation for hypercomplex 2D data */
if (phase == 2) {
tsadd(t7,1,4);
}
/* Set up f1180 tau1 = t1 */
tau1 = d2;
if(f1180[A] == 'y') {
tau1 += ( 1.0 / (2.0*sw1) );
if(tau1 < 0.4e-6) tau1 = 0.4e-6;
}
tau1 = tau1/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2 ;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2) {
tsadd(t7,2,4);
tsadd(t5,2,4);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
decoffset(dof);
obspower(tsatpwr); /* Set transmitter power for 1H presaturation */
decpower(dhpwr); /* Set Dec1 power for hard 13C pulses */
dec2power(dpwr2); /* Set Dec2 power for 15N decoupling */
/* Presaturation Period */
status(B);
if (fsat[0] == 'y')
{
rgpulse(d1,zero,2.0e-6,2.0e-6); /* presat */
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
delay(2.0e-5);
if(fscuba[0] == 'y')
{
delay(2.2e-2);
rgpulse(pw,zero,2.0e-6,0.0);
rgpulse(2*pw,one,2.0e-6,0.0);
rgpulse(pw,zero,2.0e-6,0.0);
delay(2.2e-2);
}
}
else
{
delay(d1);
}
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
txphase(zero);
dec2phase(zero);
decphase(zero);
delay(1.0e-5);
/* Begin Pulses */
status(C);
/* Prepare for signs of gradients 0 1 0 1 0 1 */
mod2(ct,v1);
rcvroff();
lk_hold();
delay(20.0e-6);
/* first ensure that magnetization does infact start on H and not C */
decrgpulse(pwc,zero,2.0e-6,2.0e-6);
delay(2.0e-6);
zgradpulse(gzlvl1,gt1);
delay(gstab);
/* this is the real start */
rgpulse(pw,zero,0.0,0.0); /* 90 deg 1H pulse */
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(2.0e-6);
delay(taua - gt2 - 4.0e-6); /* taua <= 1/4JCH */
simpulse(2*pw,2*pwc,zero,zero,0.0,0.0);
txphase(one); decphase(t1);
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(2.0e-6);
delay(taua - gt2 - 4.0e-6);
rgpulse(pw,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
zgradpulse(gzlvl3,gt3);
delay(gstab);
/* 2D decoupling on */
dec3phase(one);
dec3power(dpwr3);
dec3rgpulse(pwd1,one,4.0e-6,0.0);
dec3phase(zero);
dec3unblank();
dec3power(dpwr3_D); /* keep power down */
dec3prgon(ddseq,pwd,dresD);
dec3on();
/* 2D decoupling on */
decrgpulse(pwc,t1,2.0e-6,0.0);
decphase(zero);
delay(taub - 2.0*pw - 2.0e-6);
rgpulse(pw,zero,0.0,0.0);
rgpulse(pw,t2,2.0e-6,0.0);
delay(TC - taub
- gt4 - 102e-6
- PRG_STOP_DELAY - POWER_DELAY - pwd1
- 4.0e-6 - POWER_DELAY - 4.0e-6 - WFG_START_DELAY);
/* 2D decoupling off */
dec3off();
dec3prgoff();
dec3blank();
dec3phase(three);
dec3power(dpwr3);
dec3rgpulse(pwd1,three,4.0e-6,0.0);
/* 2D decoupling off */
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl4,gt4);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl4,gt4);
delay(gstab);
endif(v1);
initval(1.0,v3);
decstepsize(353.0);
dcplrphase(v3);
decpower(d_ca180);
decshaped_pulse(shca180,pwca180,zero,4.0e-6,0.0);
dcplrphase(zero);
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl4,gt4);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl4,gt4);
delay(gstab);
endif(v1);
/* 2D decoupling on */
dec3phase(one);
dec3power(dpwr3);
dec3rgpulse(pwd1,one,4.0e-6,0.0);
dec3phase(zero);
dec3unblank();
dec3power(dpwr3_D); /* keep power down */
dec3prgon(ddseq,pwd,dresD);
dec3on();
/* 2D decoupling on */
delay(TC - taud - WFG_STOP_DELAY - gt4 - 102e-6
- POWER_DELAY - 4.0e-6 - pwd1 - POWER_DELAY
- PRG_START_DELAY);
/* 2D decoupling off */
dec3off();
dec3prgoff();
dec3blank();
decphase(three);
dec3power(dpwr3);
dec3rgpulse(pwd1,three,4.0e-6,0.0);
/* 2D decoupling off */
delay(taud - PRG_STOP_DELAY -POWER_DELAY - pwd1 - 4.0e-6
- POWER_DELAY
- WFG_START_DELAY - pwca90 - 4.0e-6
- WFG_STOP_DELAY - POWER_DELAY - 4.0e-6);
decpower(d_ca90);
decshaped_pulse(shca90,pwca90,t3,4.0e-6,0.0);
decpower(dhpwr);
decrgpulse(pwc,one,4.0e-6,0.0);
/* T2 period */
dec3power(dpwr3);
dec3rgpulse(pwd1,t4,2.0e-6,0.0);
dec3phase(one);
dec3power(dpwr3_sl);
dec3rgpulse(time_T2,one,2.0e-6,2.0e-7);
dec3phase(zero);
dec3power(dpwr3);
dec3rgpulse(pwd1,zero,2.0e-6,0.0);
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl5,gt5);
delay(gstab);
endif(v1);
decphase(zero);
decrgpulse(pwc,t7,4.0e-6,0.0);
/* C' decoupling on */
decpower(dpwrsed);
decprgon(codecseq,pwcodec,dressed);
decon();
/* C' decoupling on */
if(taud + 3.0*POWER_DELAY + 2.0*PRG_START_DELAY + pwd1 + 4.0e-6 >= tau1) {
delay(tau1);
rgpulse(2.0*pw,zero,0.0,0.0);
delay(taud + 3.0*POWER_DELAY + 2.0*PRG_START_DELAY + pwd1 + 4.0e-6
- tau1);
/* 2D decoupling on */
dec3phase(t6);
dec3power(dpwr3);
dec3rgpulse(pwd1,t6,4.0e-6,0.0);
dec3phase(zero);
dec3unblank();
dec3power(dpwr3_D); /* keep power down */
dec3prgon(ddseq,pwd,dresD);
dec3on();
/* 2D decoupling on */
delay(TC - taud + tau1 - POWER_DELAY
- PRG_START_DELAY - 2.0*pw
- POWER_DELAY - pwd1 - 4.0e-6 - POWER_DELAY - PRG_START_DELAY
- 3.0*POWER_DELAY - 2.0*PRG_START_DELAY - pwd1 - 4.0e-6
- PRG_STOP_DELAY - POWER_DELAY - pwd1 - 4.0e-6
- PRG_STOP_DELAY
- POWER_DELAY - gt6 - 102e-6
- WFG_START_DELAY);
/* 2D decoupling off */
dec3off();
dec3prgoff();
dec3blank();
dec3power(dpwr3);
dec3rgpulse(pwd1,three,4.0e-6,0.0);
/* 2D decoupler off */
/* C' decoupling off */
decoff();
decprgoff();
decpower(d_ca180); /* set power for reburp */
/* C' decoupling off */
}
else {
delay(taud);
/* 2D decoupling on */
dec3phase(t6);
dec3power(dpwr3);
dec3rgpulse(pwd1,t6,4.0e-6,0.0);
dec3phase(zero);
dec3unblank();
dec3power(dpwr3_D); /* keep power down */
dec3prgon(ddseq,pwd,dresD);
dec3on();
/* 2D decoupling on */
delay(tau1 - taud - POWER_DELAY - PRG_START_DELAY
- POWER_DELAY - pwd1 - 4.0e-6
- POWER_DELAY - PRG_START_DELAY);
rgpulse(2.0*pw,zero,0.0,0.0);
delay(TC
- 2.0*pw - PRG_STOP_DELAY - POWER_DELAY - pwd1 - 4.0e-6
- POWER_DELAY
- PRG_STOP_DELAY - gt6 - 102e-6
- WFG_START_DELAY);
/* 2D decoupling off */
dec3off();
dec3prgoff();
dec3blank();
dec3phase(three);
dec3power(dpwr3);
dec3rgpulse(pwd1,three,4.0e-6,0.0);
/* 2D decoupler off */
/* C' decoupling off */
decoff();
decprgoff();
decpower(d_ca180); /* set power for reburp */
/* C' decoupling off */
}
initval(1.0,v4);
decstepsize(353.0);
dcplrphase(v4);
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl6,gt6);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl6,gt6);
delay(gstab);
endif(v1);
decshaped_pulse(shca180,pwca180,zero,0.0,0.0);
dcplrphase(zero);
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl6,gt6);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl6,gt6);
delay(gstab);
endif(v1);
/* C' decoupling on */
decpower(dpwrsed);
decprgon(codecseq,pwcodec,dressed);
decon();
/* C' decoupling on */
/* 2D decoupling on */
dec3phase(one);
dec3power(dpwr3);
dec3rgpulse(pwd1,one,4.0e-6,0.0);
dec3phase(zero);
dec3unblank();
dec3power(dpwr3_D); /* keep power down */
dec3prgon(ddseq,pwd,dresD);
dec3on();
/* 2D decoupling on */
delay(TC - tau1 - WFG_STOP_DELAY - gt6
- 102e-6 - POWER_DELAY - PRG_START_DELAY - POWER_DELAY - pwd1
- 4.0e-6 - POWER_DELAY - PRG_START_DELAY - PRG_STOP_DELAY
- POWER_DELAY - 4.0e-6);
/* C' decoupling off */
decoff();
decprgoff();
decpower(dhpwr);
/* C' decoupling off */
decrgpulse(pwc,one,4.0e-6,0.0);
/* 2D decoupling off */
dec3off();
dec3prgoff();
dec3blank();
dec3phase(three);
dec3power(dpwr3);
dec3rgpulse(pwd1,three,4.0e-6,0.0);
/* 2D decoupler off */
ifzero(v1);
delay(2.0e-6);
zgradpulse(gzlvl7,gt7);
delay(gstab);
elsenz(v1);
delay(2.0e-6);
zgradpulse(-1.0*gzlvl7,gt7);
delay(gstab);
endif(v1);
delay(lk_wait); /* delay for lk receiver recovery */
rgpulse(pw,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl8,gt8);
decphase(zero);
delay(taua - gt8 - 4.0e-6);
simpulse(2*pw,2*pwc,zero,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl8,gt8);
delay(2.0e-6);
delay(taua - 2*POWER_DELAY - gt8 - 4.0e-6);
decpower(dpwr); /* Set power for decoupling */
dec2power(dpwr2); /* Set power for decoupling */
rgpulse(pw,zero,0.0,rof2);
lk_sample();
/* rcvron(); */ /* Turn on receiver to warm up before acq */
/* BEGIN ACQUISITION */
status(D);
setreceiver(t5);
}
pulsesequence()
{
void makeHHdec(), makeCdec(); /* utility functions */
int ihh=1, /* used in HH decouling to improve water suppression */
t1_counter;
char C13refoc[MAXSTR], /* C13 sech/tanh pulse in middle of t1 */
Hdecflg[MAXSTR], /* HH-h**o decoupling flag */
Cdecflg[MAXSTR], /* low power C-13 decoupling flag */
IPAP[MAXSTR], /* Flag for anti-phase spectrum */
wtg3919[MAXSTR];
double tauxh, tau1,
pwNt = 0.0, /* pulse only active in the TROSY option */
gsign = 1.0,
maxHpwr = 51.0, /* maximum allowed H-H decoupling power */
maxCpwr = 45.0, /* maximum allowed C-H decoupling power */
gzlvl0=getval("gzlvl0"),
gzlvl1=getval("gzlvl1"),
gzlvl2=getval("gzlvl2"),
gzlvl3=getval("gzlvl3"),
gt0=getval("gt0"),
gt1=getval("gt1"),
gt2=getval("gt2"),
gt3=getval("gt3"),
JNH = getval("JNH"),
pwN = getval("pwN"),
pwNlvl = getval("pwNlvl"),
pwHs, tpwrs=0.0, compH, /* H1 90 degree pulse length at tpwrs */
sw1 = getval("sw1"),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rfst = 4095.0, /* fine power for the stCall pulse */
compC = getval("compC"); /* adjustment for C13 amplifier compr-n */
/* INITIALIZE VARIABLES */
getstr("C13refoc",C13refoc);
getstr("IPAP",IPAP); /* IPAP = 'y' for AP; IPAP = 'n' for IP */
getstr("wtg3919",wtg3919);
getstr("Hdecflg", Hdecflg);
getstr("Cdecflg", Cdecflg);
tauxh = ((JNH != 0.0) ? 1/(4*(JNH)) : 2.25e-3);
if (C13refoc[A]=='y') /* 180 degree adiabatic C13 pulse from 0 to 200 ppm */
{
rfst = (compC*4095.0*pwC*4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35));
rfst = (int) (rfst + 0.5);
if ( 1.0/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35)) < pwC )
{
text_error( " Not enough C13 RF. pwC must be %f usec or less.\n",
(1.0e6/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35))) );
psg_abort(1);
}
}
if(wtg3919[0] != 'y') /* selective H20 one-lobe sinc pulse needs 1.69 */
{ pwHs = getval("pwHs"); /* times more power than a square pulse */
compH = getval("compH");
if (pwHs > 1e-6) tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69));
else tpwrs = 0.0;
tpwrs = (int) (tpwrs); }
else
pwHs = pw*2.385+7.0*rof1+d3*2.5;
if(Cdecflg[0] == 'y') makeCdec(maxCpwr); /* make shapes for HH h**o-decoupling */
if(Hdecflg[0] == 'y') makeHHdec(maxHpwr);
if(Hdecflg[0] != 'n') ihh = -3;
/* check validity of parameter range */
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{ text_error("incorrect Dec1 decoupler flags! "); psg_abort(1); }
if((dm2[A] == 'y' || dm2[B] == 'y') )
{ text_error("incorrect Dec2 decoupler flags! "); psg_abort(1); }
if( dpwr > 0 )
{ text_error("don't fry the probe, dpwr too large! "); psg_abort(1); }
if( dpwr2 > 50 )
{ text_error("don't fry the probe, dpwr2 too large! "); psg_abort(1); }
/* LOAD VARIABLES */
if(ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5);
tau1 = d2/2.0;
if(tau1 < 0.0) tau1 = 0.0;
/* LOAD PHASE TABLES */
settable(t1, 2, phi1);
if (IPAP[A]=='y') settable(t2,4,phi2A);
else settable(t2, 4, phi2);
settable(t3, 16, phi3);
settable(t4, 16, phi4);
if (IPAP[A]=='y') settable(t5,8,recA);
else settable(t5, 4, rec);
assign(one,v7);
assign(three,v8);
if ( phase1 == 2 ) /* Hypercomplex in t1 */
{
if (IPAP[A] == 'y')
tsadd(t3,1,4);
tsadd(t2, 1, 4);
}
if(t1_counter %2) /* calculate modification to phases based on */
{ /* current t1 values */
tsadd(t2,2,4);
tsadd(t5,2,4);
if (IPAP[A] == 'y')
tsadd(t3,2,4);
}
if(wtg3919[0] != 'y')
{ add(one,v7,v7); add(one,v8,v8); }
/* sequence starts!! */
status(A);
obspower(tpwr);
dec2power(pwNlvl);
decpower(pwClvl);
decpwrf(rfst);
if(Hdecflg[0] != 'n')
{
delay(5.0e-5);
rgpulse(pw,zero,rof1,0.0);
rgpulse(pw,one,0.0,rof1);
zgradpulse(1.5*gzlvl0, 0.5e-3);
delay(5.0e-4);
rgpulse(pw,zero,rof1,0.0);
rgpulse(pw,one,0.0,rof1);
zgradpulse(-gzlvl0, 0.5e-3);
}
delay(d1);
rcvroff();
status(B);
dec2rgpulse(pwN,zero,rof1,rof1);
zgradpulse(gzlvl0,gt0);
delay(1e-3);
rgpulse(pw, zero, rof1, rof1);
zgradpulse(gzlvl1,gt1);
txphase(zero);
dec2phase(zero);
delay(tauxh-gt1); /* delay=1/4J(XH) */
sim3pulse(2*pw,0.0,2*pwN,zero,zero,zero,rof1,rof1);
zgradpulse(gzlvl1,gt1);
dec2phase(t2);
delay(tauxh-gt1 ); /* delay=1/4J(XH) */
rgpulse(pw, t1, rof1, rof1);
zgradpulse(0.5*gsign*ihh*gzlvl2,gt2);
delay(200.0e-6);
decphase(zero);
txphase(t4);
dec2rgpulse(pwN, t2, rof1, 0.0);
if (IPAP[A] == 'y')
{
delay(tauxh-pwN);
sim3pulse(2*pw,0.0,2*pwN,zero,zero,t3,rof1,rof1);
delay(tauxh-pwN);
rgpulse(pw,t4,rof1,rof1);
}
if ( (C13refoc[A]=='y') && (tau1 > 0.5e-3 + WFG2_START_DELAY) )
{
delay(tau1 - 0.5e-3 - WFG2_START_DELAY);
simshaped_pulse("", "stC200", 0.0, 1.0e-3, zero, zero, 0.0, 0.0);
dec2phase(zero);
delay(tau1 - 0.5e-3 - WFG2_STOP_DELAY);
}
else
delay(2.0*tau1);
dec2rgpulse(pwN, zero, 0.0, 0.0);
zgradpulse(0.5*gzlvl2,gt2);
delay(200.0e-6);
rgpulse(pw, zero, rof1, rof1);
zgradpulse(gzlvl3,gt3);
txphase(v7); dec2phase(zero);
delay(tauxh-gt3-pwHs-rof1+5.0e-5);
if(wtg3919[0] == 'y')
{
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/2-pwN);
dec2rgpulse(2*pwN, zero, rof1, rof1);
txphase(v8);
delay(d3/2-pwN);
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);
}
else
{
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, v7, rof1, 0.0);
obspower(tpwr);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, v8, zero, zero, 0.0, 0.0);
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, v7, rof1, 0.0);
obspower(tpwr);
}
zgradpulse(gzlvl3,gt3);
if(Cdecflg[0] == 'y')
{
delay(tauxh-gt3-pwHs-rof1-pwNt-3.0*POWER_DELAY-PRG_START_DELAY);
dec2rgpulse(pwNt, zero, rof1, rof2);
dec2power(dpwr2);
rcvron();
statusdelay(C,5.0e-5);
setreceiver(t5);
pbox_decon(&Cdseq);
if(Hdecflg[0] == 'y')
homodec(&HHdseq);
}
else
{
delay(tauxh-gt3-pwHs-rof1-pwNt-POWER_DELAY);
dec2rgpulse(pwNt, zero, rof1, rof2);
dec2power(dpwr2);
rcvron();
statusdelay(C,5.0e-5);
setreceiver(t5);
if(Hdecflg[0] == 'y')
homodec(&HHdseq);
}
}
pulsesequence()
{
/* DECLARE VARIABLES */
char satmode[MAXSTR],
fscuba[MAXSTR],
cbdecseq[MAXSTR];
int icosel,
ni = getval("ni"),
t1_counter; /* used for states tppi in t1 */
double tau1, /* t1 delay */
tau2, /* t2 delay */
tau3, /* t3 delay */
taua, /* ~ 1/4JNH = 2.25 ms */
taub, /* ~ 1/4JNH = 2.25 ms */
tauc, /* ~ 1/4JNCa = ~13 ms */
taud, /* ~ 1/4JCaC' = 3~4.5 ms ms */
d2_init=0.0, /* used for states tppi in t1 */
bigTN, /* nitrogen T period */
bigTC, /* carbon T period */
BigT1, /* delay about 200 us */
satpwr, /* low level 1H trans.power for presat */
sw1, /* sweep width in f1 */
sw2, /* sweep width in f2 */
at,
sphase,
cbpwr, /* power level for selective CB decoupling */
cbdmf, /* pulse width for selective CB decoupling */
cbres, /* decoupling resolution of CB decoupling */
pwS1, /* length of 90 on Ca */
pwS2, /* length of 90 on CO */
pwS3, /* length of 180 on Ca */
pwS4, /* length of 180 on CO */
gt1,
gt2,
gt3,
gt4,
gt5,
gt6,
gt7,
gt8,
gt9,
gt10,
gt11,
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl4,
gzlvl5,
gzlvl6,
gzlvl7,
gzlvl8,
gzlvl9,
gzlvl10,
gzlvl11,
compH = getval("compH"), /* adjustment for amplifier compression */
pwHs = getval ("pwHs"), /* H1 90 degree pulse at tpwrs */
tpwrs, /* power for pwHs ("H2osinc") pulse */
waltzB1 = getval("waltzB1"),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
swCa = getval("swCa"),
swCO = getval("swCO"),
swN = getval("swN"),
swTilt, /* This is the sweep width of the tilt vector */
cos_N, cos_CO, cos_Ca,
angle_N, angle_CO, angle_Ca;
angle_N=0.0;
/* LOAD VARIABLES */
getstr("satmode",satmode);
getstr("fscuba",fscuba);
taua = getval("taua");
taub = getval("taub");
tauc = getval("tauc");
taud = getval("taud");
bigTN = getval("bigTN");
bigTC = getval("bigTC");
BigT1 = getval("BigT1");
tpwr = getval("tpwr");
satpwr = getval("satpwr");
dpwr = getval("dpwr");
sw1 = getval("sw1");
sw2 = getval("sw2");
at = getval("at");
sphase = getval("sphase");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt6 = getval("gt6");
gt7 = getval("gt7");
gt8 = getval("gt8");
gt9 = getval("gt9");
gt10 = getval("gt10");
gt11 = getval("gt11");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
gzlvl8 = getval("gzlvl8");
gzlvl9 = getval("gzlvl9");
gzlvl10 = getval("gzlvl10");
gzlvl11 = getval("gzlvl11");
/* Load variable */
cbpwr = getval("cbpwr");
cbdmf = getval("cbdmf");
cbres = getval("cbres");
tau1 = 0;
tau2 = 0;
tau3 = 0;
cos_N = 0;
cos_CO = 0;
cos_Ca = 0;
kappa = 5.4e-3;
getstr("cbdecseq", cbdecseq);
/* LOAD PHASE TABLE */
settable(t1,1,phi1);
settable(t2,4,phi2);
settable(t3,1,phi3);
settable(t4,1,phi4);
settable(t5,4,phi5);
settable(t7,4,phi7);
settable(t6,4,rec);
/* get calculated pulse lengths of shaped C13 pulses */
pwS1 = c13pulsepw("ca", "co", "square", 90.0);
pwS2 = c13pulsepw("co", "ca", "sinc", 90.0);
pwS3 = c13pulsepw("ca","co","square",180.0);
pwS4 = c13pulsepw("co","ca","sinc",180.0);
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /*needs 1.69 times more*/
tpwrs = (int) (tpwrs); /*power than a square pulse */
widthHd = 2.681*waltzB1/sfrq; /* bandwidth of H1 WALTZ16 decoupling */
pwHd = h1dec90pw("WALTZ16", widthHd, 0.0); /* H1 90 length for WALTZ16 */
/* CHECK VALIDITY OF PARAMETER RANGES */
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{
printf("incorrect dec1 decoupler flags! ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'n'))
{
printf("incorrect dec2 decoupler flags! Should be 'nny' ");
psg_abort(1);
}
if( satpwr > 6 )
{
printf("SATPWR too large !!! ");
psg_abort(1);
}
if( dpwr > 46 )
{
printf("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( dpwr2 > 47 )
{
printf("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( pw > 200.0e-6 )
{
printf("dont fry the probe, pw too high ! ");
psg_abort(1);
}
if( pwN > 200.0e-6 )
{
printf("dont fry the probe, pwN too high ! ");
psg_abort(1);
}
if( gt1 > 15e-3 || gt2 > 15e-3 || gt3 > 15e-3
|| gt4 > 15e-3 || gt5 > 15e-3 || gt6 > 15e-3
|| gt7 > 15e-3 || gt8 > 15e-3 || gt9 > 15e-3 || gt10 > 15.0e-3
|| gt11>15.0e-3)
{
printf("gti values must be < 15e-3\n");
psg_abort(1);
}
if( dpwr3 > 56) {
printf("dpwr3 too high\n");
psg_abort(1);
}
/* PHASES AND INCREMENTED TIMES */
/* Set up angles and phases */
angle_CO=getval("angle_CO"); cos_CO=cos(PI*angle_CO/180.0);
angle_Ca=getval("angle_Ca"); cos_Ca=cos(PI*angle_Ca/180.0);
if ( (angle_CO < 0) || (angle_CO > 90) )
{ printf ("angle_CO must be between 0 and 90 degree.\n"); psg_abort(1); }
if ( (angle_Ca < 0) || (angle_Ca > 90) )
{ printf ("angle_Ca must be between 0 and 90 degree.\n"); psg_abort(1); }
if ( 1.0 < (cos_CO*cos_CO + cos_Ca*cos_Ca) )
{
printf ("Impossible angles.\n"); psg_abort(1);
}
else
{
cos_N=sqrt(1.0- (cos_CO*cos_CO + cos_Ca*cos_Ca));
angle_N = 180.0*acos(cos_N)/PI;
}
swTilt=swCO*cos_CO + swCa*cos_Ca + swN*cos_N;
if (ix ==1)
{
printf("\n\nn\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf ("Maximum Sweep Width: \t\t %f Hz\n", swTilt);
printf ("Angle_CO:\t%6.2f\n", angle_CO);
printf ("Angle_Ca:\t%6.2f\n", angle_Ca);
printf ("Angle_N :\t%6.2f\n", angle_N );
}
/* Set up hyper complex */
/* sw1 is used as symbolic index */
if ( sw1 < 1000 ) { printf ("Please set sw1 to some value larger than 1000.\n"); psg_abort(1); }
if (ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if (t1_counter % 2) { tsadd(t1,2,4); tsadd(t6,2,4); }
if (phase1 == 1) { ;} /* CC */
else if (phase1 == 2) { tsadd(t7,1,4);} /* SC */
else if (phase1 == 3) { tsadd(t4,3,4); } /* CS */
else if (phase1 == 4) { tsadd(t7,1,4); tsadd(t4,3,4); } /* SS */
else { printf ("phase1 can only be 1,2,3,4. \n"); psg_abort(1); }
if (phase2 == 2) { tsadd(t3,2,4); icosel = +1; } /* N */
else icosel = -1;
tau1 = 1.0*t1_counter*cos_CO/swTilt;
tau2 = 1.0*t1_counter*cos_Ca/swTilt;
tau3 = 1.0*t1_counter*cos_N/swTilt;
tau1 = tau1/2.0; tau2 = tau2/2.0; tau3 = tau3/2.0;
/* CHECK VALIDITY OF PARAMETER RANGES */
if (bigTN - 0.5*ni*(cos_N/swTilt) + pwS3 < 0.2e-6)
{ printf(" ni is too big. Make ni equal to %d or less.\n",
((int)((bigTN + pwS3)*2.0*swTilt/cos_N))); psg_abort(1);}
if (bigTC - 0.5*ni*(cos_Ca/swTilt) - pwS4
- pwS3/2 - WFG3_START_DELAY - WFG3_STOP_DELAY
-3*POWER_DELAY - PRG_START_DELAY - PRG_STOP_DELAY -
4.0e-6 < 0.2e-6)
{
printf(" ni is too big for Ca. Make ni equal to %d or less.\n",
(int) ((bigTC - pwS4 - pwS3/2 - WFG3_START_DELAY -
WFG3_STOP_DELAY - 3*POWER_DELAY - PRG_START_DELAY -
PRG_STOP_DELAY -4.0e-6 )/(0.5*cos_Ca/swTilt)) );
psg_abort(1);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(satpwr); /* Set transmitter power for 1H presaturation */
obspwrf(4095.0);
decpower(pwClvl); /* Set Dec1 power for hard 13C pulses */
decpwrf(4095.0);
dec2power(pwNlvl); /* Set Dec2 power for hard 15N pulses */
dec2pwrf(4095.0);
set_c13offset("ca");
/* Presaturation Period */
if (satmode[0] == 'y')
{
delay(2.0e-5);
rgpulse(d1,zero,2.0e-6,2.0e-6);
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
delay(2.0e-5);
if(fscuba[0] == 'y')
{
delay(2.2e-2);
rgpulse(pw,zero,2.0e-6,0.0);
rgpulse(2*pw,one,2.0e-6,0.0);
rgpulse(pw,zero,2.0e-6,0.0);
delay(2.2e-2);
}
}
else
{
delay(d1);
}
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
txphase(three);
dec2phase(zero);
delay(1.0e-5);
/* Begin Pulses */
status(B);
rcvroff();
shiftedpulse("sinc", pwHs, 90.0, 0.0, three, 2.0e-6, 2.0e-6);
txphase(zero);
/* xxxxxxxxxxxxxxxxxxxxxx 1HN to 15N TRANSFER xxxxxxxxxxxxxxxxxx */
rgpulse(pw,zero,0.0,0.0); /* 90 deg 1H pulse */
delay(0.2e-6);
zgradpulse(gzlvl1, gt1);
delay(2.0e-6);
delay(taua - gt1 - 2.2e-6); /* taua <= 1/4JNH */
sim3pulse(2*pw,0.0,2*pwN,zero,zero,zero,0.0,0.0);
txphase(one); dec2phase(zero); decphase(zero);
delay(taua - gt1 - 200.2e-6 - 2.0e-6);
delay(0.2e-6);
zgradpulse(gzlvl1, gt1);
delay(200.0e-6);
/* xxxxxxxxxxxxxxxxxxxxxx 15N to 13CA TRANSFER xxxxxxxxxxxxxxxxxx */
rgpulse(pw,one,2.0e-6,0.0);
delay(0.2e-6);
zgradpulse(gzlvl2, gt2);
delay(200.0e-6);
dec2rgpulse(pwN,zero,0.0,0.0);
delay(kappa - POWER_DELAY - PWRF_DELAY - pwHd - 4.0e-6 - PRG_START_DELAY);
/* delays for h1waltzon subtracted */
h1waltzon("WALTZ16", widthHd, 0.0);
decphase(zero);
dec2phase(zero);
delay(tauc - kappa - WFG3_START_DELAY );
dec2rgpulse(2*pwN,zero,0.0,0.0);
c13pulse("ca", "co", "square", 180.0, zero, 0.0, 0.0);
dec2phase(zero);
delay(tauc - pwS3);
dec2rgpulse(pwN,zero,0.0,0.0);
h1waltzoff("WALTZ16", widthHd, 0.0);
decphase(zero);
delay(0.2e-6);
zgradpulse(gzlvl3, gt3);
delay(200.0e-6);
/* xxxxxxxxxxxxxxxxxxxxx 13CA to 13CO TRANSFER xxxxxxxxxxxxxxxxxxxxxxx */
c13pulse("ca", "co", "square", 90.0, zero, 0.0, 0.0);
decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(taud - 2*POWER_DELAY - PRG_START_DELAY - PRG_STOP_DELAY
- 0.5*10.933*pwC);
decoff();
decprgoff();
decpower(pwClvl);
/* CHECK if this freq jump is needed */
set_c13offset("co"); /* change Dec1 carrier to Co */
decrgpulse(pwC*158.0/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*171.2/90.0, two, 0.0, 0.0);
decrgpulse(pwC*342.8/90.0, zero, 0.0, 0.0); /* Shaka 6 composite */
decrgpulse(pwC*145.5/90.0, two, 0.0, 0.0);
decrgpulse(pwC*81.2/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*85.3/90.0, two, 0.0, 0.0);
set_c13offset("ca"); /* change Dec1 carrier to Co */
decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(taud - 2*POWER_DELAY
- PRG_STOP_DELAY - PRG_START_DELAY - 0.5*10.933*pwC);
decoff();
decprgoff();
decpower(pwClvl);
c13pulse("ca", "co", "square", 90.0, one, 0.0, 0.0);
set_c13offset("co"); /* change Dec1 carrier to Co */
delay(2.0e-7);
zgradpulse(gzlvl4, gt4);
delay(100.0e-6);
/* xxxxxxxxxxxxxxxx 13CO CHEMICAL SHIFT EVOLUTION xxxxxxxxxxxxxx */
c13pulse("co", "ca", "sinc", 90.0, t7, 0.0, 0.0);
if ((ni>1.0) && (tau1>0.0))
{
if (tau1-2.0*pwS2/PI-pwN-WFG3_START_DELAY-POWER_DELAY-2.0e-6 > 0.0)
{
delay(tau1-2.0*pwS2/PI-pwN-WFG3_START_DELAY-POWER_DELAY-2.0e-6);
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
initval(1.0,v3);
decstepsize(sphase);
dcplrphase(v3);
delay(tau1-2.0*pwS2/PI-SAPS_DELAY-pwN-WFG3_STOP_DELAY-POWER_DELAY-2.0e-6);
}
else
{
delay(2.0*tau1);
delay(10.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay (10.0e-6);
}
}
else
{
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
}
c13pulse("co", "ca", "sinc", 90.0, zero, 4.0e-6, 0.0);
dcplrphase(zero);
set_c13offset("ca"); /* set carrier to Ca */
decphase(t4);
delay(2.0e-7);
zgradpulse(gzlvl9, gt9);
delay(100.0e-6);
/* xxxxxxxxxxxxxx 13CO to 13CA TRANSFER and 13CA EVOLUTION xxxxxxxxxxxxxxxx */
c13pulse("ca", "co", "square", 90.0, t4, 2.0e-6, 0.0);
decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(bigTC - tau2 - 3*POWER_DELAY - 4.0e-6 - WFG3_START_DELAY
- pwS4 - WFG3_STOP_DELAY - PRG_START_DELAY - PRG_STOP_DELAY
- pwS3/2 - 4.0e-6);
decoff();
decprgoff();
decpower(pwClvl);
c13pulse("co", "ca", "sinc", 180.0, zero, 4.0e-6, 0.0);
decphase(t5);
c13pulse("ca", "co", "square", 180.0, t5, 4.0e-6, 0.0);
decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(bigTC -3*POWER_DELAY - 6.0e-6 -pwS3/2 - 2*pwN
- WFG_START_DELAY- pwS4- WFG_STOP_DELAY - PRG_START_DELAY
- PRG_STOP_DELAY - pwS1/2);
dec2rgpulse(2*pwN,zero,0.0,0.0);
delay(tau2);
decoff();
decprgoff();
decpower(pwClvl);
c13pulse("co", "ca", "sinc", 180.0, zero, 4.0e-6, 0.0);
decphase(one);
c13pulse("ca", "co", "square", 90.0, one, 2.0e-6, 0.0);
txphase(zero);
delay(2.0e-7);
zgradpulse(gzlvl11, gt11);
delay(100.0e-6);
/* Constant 15N period */
h1waltzon("WALTZ16", widthHd, 0.0);
dec2rgpulse(pwN,t1,2.0e-6,0.0);
dec2phase(t2);
delay(bigTN - tau3 + pwS3);
dec2rgpulse(2*pwN,t2,0.0,0.0);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 0.0);
dec2phase(t3);
txphase(zero);
if (tau3 > (kappa + PRG_STOP_DELAY + pwHd + 2.0e-6))
{
delay(bigTN - pwS4 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(tau3 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6 - POWER_DELAY
- PWRF_DELAY);
h1waltzoff("WALTZ16", widthHd, 0.0);
delay(kappa - gt5 - 2.0*GRADIENT_DELAY - 1.0e-4);
zgradpulse(gzlvl5, gt5);
delay(1.0e-4);
}
else if (tau3 > (kappa - pwS4 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6))
{
delay(bigTN + tau3 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6
- POWER_DELAY - PWRF_DELAY);
h1waltzoff("WALTZ16", widthHd, 0.0);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(kappa - pwS4 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6 - gt5 - 2.0*GRADIENT_DELAY - 1.0e-4);
zgradpulse(gzlvl5, gt5);
delay(1.0e-4);
}
else if (tau3 > gt5 + 2.0*GRADIENT_DELAY + 1.0e-4)
{
delay(bigTN + tau3 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6
- POWER_DELAY - PWRF_DELAY);
h1waltzoff("WALTZ16", widthHd, 0.0);
delay(kappa - tau3 - pwS4 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(tau3 - gt5 - 2.0*GRADIENT_DELAY - 1.0e-4);
zgradpulse(gzlvl5, gt5);
delay(1.0e-4);
}
else
{
delay(bigTN + tau3 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6
- POWER_DELAY - PWRF_DELAY);
h1waltzoff("WALTZ16", widthHd, 0.0);
delay(kappa - tau3 - pwS4 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6 - gt5 - 2.0*GRADIENT_DELAY - 1.0e-4);
zgradpulse(gzlvl5, gt5); /* 2.0*GRADIENT_DELAY */
delay(1.0e-4);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(tau3);
}
sim3pulse(pw,0.0,pwN,zero,zero,t3,0.0,0.0);
delay(0.2e-6);
zgradpulse(gzlvl6, gt6);
delay(2.0e-6);
dec2phase(zero);
delay(taub - gt6 - 2.2e-6);
sim3pulse(2*pw,0.0,2*pwN,zero,zero,zero,0.0,0.0);
delay(0.2e-6);
zgradpulse(gzlvl6, gt6);
delay(200.0e-6);
delay(taub - gt6 - 200.2e-6);
txphase(one);
dec2phase(one);
sim3pulse(pw,0.0,pwN,one,zero,one,0.0,0.0);
delay(0.2e-6);
zgradpulse(gzlvl7, gt7);
delay(2.0e-6);
txphase(zero);
dec2phase(zero);
delay(taub - gt7 - 2.2e-6);
sim3pulse(2*pw,0.0,2*pwN,zero,zero,zero,0.0,0.0);
delay(0.2e-6);
zgradpulse(gzlvl7, gt7);
delay(200.0e-6);
delay(taub - gt7 - 200.2e-6);
rgpulse(pw, zero, 0.0, 0.0);
delay(gt8 + 1.0e-4 + 50.2e-6 - 0.3*pw + 2.0*GRADIENT_DELAY
+ POWER_DELAY);
rgpulse(2*pw,zero,0.0,0.0);
dec2power(dpwr2);
decpower(dpwr);
zgradpulse(icosel*gzlvl8, gt8);
delay(50.2e-6);
/* rcvron(); */ /* Turn on receiver to warm up before acq */
/* BEGIN ACQUISITION */
status(C);
setreceiver(t6);
}
pulsesequence()
{
char normal[MAXSTR],
focus[MAXSTR];
double spp, spplvl, pp, mult, j, d3;
double gt, gzlvl;
/* GATHER AND INTIALIZE */
getstr("focus", focus);
getstr("normal", normal);
spp = getval("spp");
spplvl = getval("spplvl");
pp = getval("pp");
mult = getval("mult");
j = getval("j");
gt = getval("gt");
gzlvl = getval("gzlvl");
/* calculate phases */
mod2(ct,v1); /* v1 = 01010101 */
dbl(v1,v1); /* v1 = 0 2 */
hlv(ct,v2);
mod2(v2,v2); /* v2 = 0 0 1 1 */
add(v1,v2,oph); /* oph = 0 2 1 3 */
/* if mult is zero, then do normal s2pul sequence */
if (mult == 0.0)
{
status(A);
hsdelay(d1);
pulse(p1, zero);
status(B);
delay(d2);
status(C);
pulse(pw,oph);
}
else /* this is the INEPT part of the sequence */
{
if (j != 0.0)
{ /* calculation of delays */
d3 = 1.0 / (2.0 * j);
if (mult < 2.5)
{
d2 = 1.0 / (2.0 * j);
}
else if (mult < 3.5)
{
d2 = 3.0 / (4.0 * j);
}
else
{
d2 = 1.0 / (3.0 * j);
}
}
else
d3 = getval("d3");
/* do equilibration delay */
if ((dm[A] == 'y') || (dm[B] == 'y'))
{
(void) printf("Decoupler must be set as dm=nny or n\n");
psg_abort(1);
}
if (declvlonoff)
declvlon(); /* use pplvl for pulse */
else
decpower(pplvl);
dec_pw_ovr(FALSE);
status(A);
delay(d1);
/* excitation transfer */
status(B);
decrgpulse(pp, v1, rof1, rof1);
decpower(spplvl);
dec_pw_ovr(TRUE);
delay(d3/2 - 2.0*(gt + spp + 1.0e-4));
/*nominal 1/(4j) corrected for H1 & gradient pulses */
zgradpulse(gzlvl,gt);
delay(1.0e-4);
simpulse(2*pw, 2*spp, zero, zero, rof1, rof1);
delay(1.0e-4);
zgradpulse(gzlvl,2.0*gt);
delay(1.0e-4);
simpulse(2.0*pw, 2.0*spp, zero, two, rof1, rof1);
zgradpulse(gzlvl,gt);
delay(1.0e-4);
decpower(pplvl);
dec_pw_ovr(FALSE);
delay(d3/2 - 2.0*(gt + spp + 1.0e-4));
simpulse(pw, pp, v2, one, 0.0, 0.0);
/* make decision on refocussing */
if ((focus[A] == 'y') || (dm[C] == 'y'))
{
decpower(spplvl);
dec_pw_ovr(TRUE);
delay(d2/2 - rof1 -spp); /* refocussing delay varied for 2d */
simpulse(2*pw, 2*spp, v2, zero, rof1, rof1);
delay(d2/2 - rof1 - spp);
}
else if (normal[A] == 'y')
{
decrgpulse(pp, v1, 1.0e-6, 0.0);
}
if (declvlonoff)
declvloff();
else
decpower(dpwr);
status(C);
}
}
pulsesequence()
{
char f1180[MAXSTR],
f2180[MAXSTR],
mag_flg[MAXSTR],
flg_3919[MAXSTR],
ref_flg[MAXSTR];
int phase, ni2,
t1_counter,
t2_counter;
double gzcal = getval("gzcal"),
factor = 0.08, /* used for 3-9-19 water gate */
tau_3919 = getval("tau_3919"),
flipphase = getval("flipphase"),
tau1, /* t1 delay */
tau2, /* t2 delay */
taua, /* 1/4JNH ~ 2.3 ms */
taub, /* 1/4JNH ~ 2.3 ms */
bigT, /* ~ 19 ms */
pwNlvl,
pwN,
gt1,
gt2,
gt3,
gt4,
gt5,
gt6,
gt7,
gt8,
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl4,
gzlvl5,
gzlvl6,
gzlvl7,
gzlvl8,
compH = getval("compH"), /* adjustment for C13 amplifier compression */
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrsf = getval("tpwrsf"), /* fine power adjustment for flipback pulse */
tpwrs; /* power for the pwHs ("H2Osinc") pulse */
/* LOAD VARIABLES */
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("flg_3919", flg_3919);
getstr("mag_flg", mag_flg);
getstr("ref_flg", ref_flg);
taua = getval("taua");
taub = getval("taub");
bigT = getval("bigT");
tpwr = getval("tpwr");
pwNlvl = getval("pwNlvl");
pwN = getval("pwN");
dpwr = getval("dpwr");
dpwr2 = getval("dpwr2");
phase = (int)( getval("phase") + 0.5);
phase2 = (int)( getval("phase2") + 0.5);
sw1 = getval("sw1");
sw2 = getval("sw2");
ni = getval("ni");
ni2 = getval("ni2");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt6 = getval("gt6");
gt7 = getval("gt7");
gt8 = getval("gt8");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
gzlvl8 = getval("gzlvl8");
/* LOAD PHASE TABLE */
settable(t1,4,phi1);
settable(t2,2,phi2);
settable(t3,8,phi3);
settable(t4,16, phi4);
if (ref_flg[A] == 'y')
{
settable(t10,8,ref);
}
else
{
settable(t10,8,rec);
}
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /*needs 1.69 times more*/
tpwrs = (int) (tpwrs); /*power than a square pulse */
/* CHECK VALIDITY OF PARAMETER RANGES */
if (ref_flg[A] == 'y' && ni > 1)
{
printf(" Incorrect setting of ni and ref_flg.\n");
printf(" Please choose either ni=1 or ref_flg=n.\n");
psg_abort(1);
}
if (ref_flg[A] == 'y' && dps_flag)
{
printf(" Please use phase2 and ni2 for 2D reference spectrum\n");
if (ni2/sw2 > 2.0*(2.0*bigT - gt5 - 200.0e-6))
{
printf("ni2 is too big, should be < %f\n", 2.0*sw2*(2.0*bigT-gt5-200.0e-6));
psg_abort(1);
}
}
if ((ni2/sw2 > 2.0*(bigT - gt5 - 200.0e-6)) && (ref_flg[A] !='y'))
{
printf(" ni2 is too big, should be < %f\n", 2.0*sw2*(bigT-gt6-200.0e-6));
psg_abort(1);
}
if(dpwr2 > 50)
{
printf("don't fry the probe, dpwr2 is too large! ");
psg_abort(1);
}
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y'))
{
printf("incorrect dec1 decoupler flags! should be 'nnn' ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y' ))
{
printf("incorrect dec2 decoupler flags! Should be 'nny' ");
psg_abort(1);
}
/* Phase incrementation for hypercomplex 2D data */
if (phase == 2)
{
tsadd(t1,1,4);
}
if (phase2 == 2)
{
tsadd(t2,1,4);
}
/* Set up f1180 half_dwell time (1/sw1)/2.0 */
tau1 = d2 - (4.0*pw/PI + 2.0*pwN);
if(f1180[A] == 'y')
{
tau1 += (1.0/(2.0*sw1));
}
if(tau1 < 0.2e-6) tau1 = 0.0;
tau1 = tau1/2.0;
/* Set up f2180 half dwell time (1/sw2)/2.0 */
tau2 = d3;
if(f2180[A] == 'y')
{
tau2 += (1.0/(2.0*sw2));
}
if(tau2 < 0.2e-6) tau2 = 0.0;
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2 ;
t1_counter = (int)((d2-d2_init)*sw1 + 0.5);
if(t1_counter % 2)
{
tsadd(t1,2,4);
tsadd(t10,2,4);
}
if( ix == 1) d3_init = d3 ;
t2_counter = (int)((d3-d3_init)*sw2 + 0.5);
if(t2_counter % 2)
{
tsadd(t2,2,4);
tsadd(t10,2,4);
}
if (flipphase < -0.01) flipphase = flipphase + 360.0;
initval(flipphase, v10);
obsstepsize(0.25);
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(tpwr);
dec2power(pwNlvl);
txphase(zero);
dec2phase(zero);
delay(d1);
if(gt1 > 0.2e-6)
{
dec2rgpulse(pwN, zero, 0.2e-6, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl1, gt1);
delay(0.001);
}
rcvroff();
status(B);
rgpulse(pw, zero,rof1, 0.0);
delay(2.0e-6);
if (gt2 > 0.2e-6)
zgradpulse(gzlvl2,gt2);
delay(taua - gt2 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
delay(taua - gt2 - 400.0e-6);
if (gt2 > 0.2e-6)
{
zgradpulse(gzlvl2,gt2);
}
txphase(one);
dec2phase(t2);
delay(400.0e-6);
rgpulse(pw, one, 0.0, 0.0);
if (gt3 > 0.2e-6)
{
delay(2.0e-6);
zgradpulse(gzlvl3, gt3);
delay(200.0e-6);
}
txphase(zero);
dec2rgpulse(pwN, t2, 0.0, 0.0);
if (ref_flg[A] == 'y')
{
delay(tau2);
rgpulse(2.0*pw, zero, 0.0, 0.0);
dec2phase(t3);
if (gt5 > 0.2e-6)
{
delay(2.0*bigT - gt5 - 2.0*pw - 1.0e-3);
zgradpulse(gzlvl5, gt5);
delay(1.0e-3);
dec2rgpulse(2.0*pwN, t3, 0.0, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl5, gt5);
delay(2.0*bigT - tau2 - gt5 - 2.0e-6);
}
else
{
delay(2.0*bigT - 2.0*pw);
dec2rgpulse(2.0*pwN, t3, 0.0, 0.0);
delay(2.0*bigT - tau2);
}
}
else
{
dec2phase(zero);
if (gt4 > 0.2e-6)
{
delay(2.0e-6);
zgradpulse(gzlvl4, gt4);
delay(bigT - gt4 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, zero, 0.0, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl4, gt4);
delay(1.0e-3 - 2.0e-6);
}
else
{
delay(bigT);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, zero, 0.0, 0.0);
delay(1.0e-3);
gt4 = 0.0;
}
zgradpulse(gzlvl5, gt5);
txphase(t1);
delay(bigT - gt4 - gt5 - 1.0e-3 - 2.0*GRADIENT_DELAY);
rgpulse(pw, t1, 0.0, 0.0);
delay(tau1);
dec2rgpulse(2.0*pwN, t3, 0.0, 0.0);
txphase(zero);
delay(tau1);
rgpulse(pw, zero, 0.0, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl5, gt5);
dec2phase(t4);
if (gt6 > 0.2e-6)
{
delay(tau2 + 100.0e-6);
zgradpulse(gzlvl6, gt6);
delay(bigT - gt5 - gt6 - 100.0e-6 - 2.0*GRADIENT_DELAY);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, t4, 0.0, 0.0);
delay(2.0e-6);
dec2phase(zero);
zgradpulse(gzlvl6, gt6);
delay(bigT - tau2 - gt6 - 2.0e-6);
}
else
{
delay(bigT + tau2 - gt5 - 2.0*GRADIENT_DELAY);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, t4, 0.0, 0.0);
dec2phase(zero);
delay(bigT - tau2);
}
}
if (gt7 > 0.2e-6)
{
dec2rgpulse(pwN, zero, 0.0,2.0e-6);
zgradpulse(gzlvl7, gt7);
txphase(zero);
delay(200.0e-6);
if (pwHs > 0.2e-6)
{
xmtrphase(v10);
if (tpwrsf<4095.0) {obspower(tpwrs+6.0); obspwrf(tpwrsf);}
else obspower(tpwrs);
txphase(two);
shaped_pulse("H2Osinc", pwHs, two, 2.0e-6, 0.0);
xmtrphase(zero);
obspower(tpwr); obspwrf(4095.0);
}
rgpulse(pw, zero, 2.0e-6, 0.0);
}
else
{
sim3pulse(pw,(double)0.0, pwN, zero,zero, zero, 0.0, 0.0);
}
delay(2.0e-6);
if(mag_flg[A] == 'y')
{
magradpulse(gzcal*gzlvl8, gt8);
}
else
{
zgradpulse(gzlvl8, gt8);
}
if (flg_3919[A] == 'y')
{
delay(taub - 31.0*factor*pw - 2.5*tau_3919 - gt8 - 2.0e-6);
rgpulse(pw*factor*3.0, two, 0.0, 0.0);
delay(tau_3919);
rgpulse(pw*factor*9.0, two, 0.0, 0.0);
delay(tau_3919);
rgpulse(pw*factor*19.0, two, 0.0, 0.0);
delay(tau_3919/2.0 - pwN);
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(tau_3919/2.0 - pwN);
rgpulse(pw*factor*19.0, zero, 0.0, 0.0);
delay(tau_3919);
rgpulse(pw*factor*9.0, zero, 0.0, 0.0);
delay(tau_3919);
rgpulse(pw*factor*3.0, zero, 0.0, 0.0);
delay(taub - 31.0*factor*pw - 2.5*tau_3919 - gt8 - POWER_DELAY - 402.0e-6);
}
else
{
if (tpwrsf<4095.0) {obspower(tpwrs+6.0); obspwrf(tpwrsf);}
else obspower(tpwrs);
txphase(two);
xmtrphase(v10);
delay(taub - pwHs - gt8 - 2.0*POWER_DELAY - 2.0e-6);
shaped_pulse("H2Osinc", pwHs, two, 0.0, 0.0);
obspower(tpwr); obspwrf(4095.0);
xmtrphase(zero);
txphase(zero);
sim3pulse(2.0*pw, (double)0.0, 2.0*pwN, zero, zero, zero, 2.0e-6, 0.0);
if (tpwrsf<4095.0) {obspower(tpwrs+6.0); obspwrf(tpwrsf);}
else obspower(tpwrs);
txphase(two);
xmtrphase(v10);
shaped_pulse("H2Osinc", pwHs, two, 2.0e-6, 0.0);
xmtrphase(zero);
obspower(tpwr); obspwrf(4095.0);
dec2power(dpwr2);
delay(taub - pwHs - gt8 - 3.0*POWER_DELAY - 402.0e-6);
}
dec2power(dpwr2);
if(mag_flg[A] == 'y')
{
magradpulse(gzcal*gzlvl8, gt8);
}
else
{
zgradpulse(gzlvl8, gt8);
}
delay(400.0e-6);
status(C);
setreceiver(t10);
rcvron();
}
pulsesequence()
{
char
f1180[MAXSTR],
f2180[MAXSTR],
mag_flg[MAXSTR], /* y for magic angle, n for z-gradient only */
ref_flg[MAXSTR]; /* yes for recording reference spectrum */
int
icosel,
phase,
ni2,
t1_counter,
t2_counter;
double
gzcal = getval("gzcal"),
tau1,
tau2,
taua, /* ~ 1/4JNH = 2.3-2.7 ms] */
taub, /* ~ 2.75 ms */
bigT, /* ~ 12 ms */
bigTCO, /* ~ 25 ms */
bigTN, /* ~ 12 ms */
pwClvl, /* High power level for carbon on channel 2 */
pwC, /* C13 90 degree pulse length at pwClvl */
compC, /* Compression factor for C13 on channel 2 */
pwCa180, /* 180 degree pulse length for Ca */
pwCab180,
pwCO180,
pwNlvl, /* Power level for Nitrogen on channel 3 */
pwN, /* N15 90 degree pulse lenght at pwNlvl */
maxcan, /* The larger of 2.0*pwN and pwCa180 */
dpwrfC = 4095.0,
dfCa180,
dfCab180,
dfCO180,
fac180 = 1.69,
gt1,
gt3,
gt2,
gt0,
gt5,
gt6,
gt7,
gt8,
gt9,
gt10,
gstab,
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl0,
gzlvl5,
gzlvl6,
gzlvl7,
gzlvl8,
gzlvl9,
gzlvl10;
/* LOAD VARIABLES */
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("mag_flg", mag_flg);
getstr("ref_flg", ref_flg);
taua = getval("taua");
taub = getval("taub");
bigT = getval("bigT");
bigTCO = getval("bigTCO");
bigTN = getval("bigTN");
pwClvl = getval("pwClvl");
pwC = getval("pwC");
compC = getval("compC");
pwNlvl = getval("pwNlvl");
pwN = getval("pwN");
pwCa180 = getval("pwCa180");
pwCab180 = getval("pwCab180");
pwCO180 = getval("pwCO180");
maxcan = 2.0*pwN;
if (pwCa180 > maxcan) maxcan = pwCa180;
dpwr = getval("dpwr");
phase = (int) ( getval("phase") + 0.5);
phase2 = (int) ( getval("phase2") + 0.5);
sw1 = getval("sw1");
sw2 = getval("sw2");
ni = getval("ni");
ni2 = getval("ni2");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt0 = getval("gt0");
gt5 = getval("gt5");
gt6 = getval("gt6");
gt7 = getval("gt7");
gt8 = getval("gt8");
gt9 = getval("gt9");
gstab = getval("gstab");
gt10 = getval("gt10");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl5 = getval("gzlvl5");
gzlvl0 = getval("gzlvl0");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
gzlvl8 = getval("gzlvl8");
gzlvl9 = getval("gzlvl9");
gzlvl10 = getval("gzlvl10");
dfCa180 = (compC*4095.0*pwC*2.0*fac180)/pwCa180;
dfCab180 = (compC*4095.0*pwC*2.0*fac180)/pwCab180;
dfCO180 = (compC*4095.0*pwC*2.0*fac180)/pwCO180;
/* LOAD PHASE TABLE */
settable(t1,4,phi1);
settable(t2,2,phi2);
settable(t3,16,phi3);
settable(t4,16,phi4);
settable(t5, 1, phi5);
settable(t10,16,rec);
/* CHECK VALIDITY OF PARAMETER RANGES */
if((ref_flg[A] == 'y') && (dps_flag))
{
printf("ref_flg=y: for 2D HN-CO or 3D HNCO reference spectrum without CO-HB coupling.\n");
}
if(ni2/sw2 > 2.0*(bigTN))
{
printf(" ni2 is too big, should < %f\n", 2.0*sw2*(bigTN));
}
if((ni/sw1 > 2.0*(bigTCO - gt6 - maxcan))&&(ref_flg[A] == 'y'))
{
printf("ni is too big, should < %f\n", 2.0*sw1*(bigTCO-gt6-maxcan));
}
if(( dpwr > 50 ) || (dpwr2 > 50))
{
printf("don't fry the probe, either dpwr or dpwr2 is too large! ");
psg_abort(1);
}
if((gt1 > 5.0e-3) ||(gt2>5e-3)||(gt3>5e-3)|| (gt0 > 5.0e-3))
{
printf("The length of gradients are too long\n");
psg_abort(1);
}
if((taub - 2.0*pw - gt8 - 1.0e-3 - 6.0*GRADIENT_DELAY)<0.0)
{
printf("Shorten gt8 so that preceding delay is not negative\n");
psg_abort(1);
}
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y'))
{
printf("incorrect dec1 decoupler flags! should be 'nnn' ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y' ))
{
printf("incorrect dec2 decoupler flags! Should be 'nny' ");
psg_abort(1);
}
/* Phase incrementation for hypercomplex 2D data */
if (phase == 2)
{
if(ref_flg[A] == 'y') tsadd(t1,3,4);
else tsadd(t1, 1, 4);
}
if (phase2 == 2)
{
tsadd(t5,2,4);
icosel = 1;
}
else icosel = -1;
/* Set up f1180 half_dwell time (1/sw1)/2.0 */
if (ref_flg[A] == 'y') tau1 = d2;
else tau1 = d2 - (4.0*pw/PI);
if(f1180[A] == 'y')
{
tau1 += (1.0/(2.0*sw1));
}
if(tau1 < 0.2e-6) tau1 = 0.0;
tau1 = tau1/4.0;
/* Set up f2180 half dwell time (1/sw2)/2.0 */
tau2 = d3;
if(f2180[A] == 'y')
{
tau2 += (1.0/(2.0*sw2));
}
if(tau2 < 0.2e-6) tau2 = 0.0;
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2 ;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{
tsadd(t1,2,4);
tsadd(t10,2,4);
}
if( ix == 1) d3_init = d3 ;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{
tsadd(t2,2,4);
tsadd(t10,2,4);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
decoffset(dof);
obspower(tpwr);
decpower(pwClvl);
decpwrf(dpwrfC);
dec2power(pwNlvl);
txphase(zero);
dec2phase(zero);
delay(d1);
dec2rgpulse(pwN, zero, 0.2e-6, 0.0);
zgradpulse(gzlvl3, gt3);
delay(0.001);
rcvroff();
status(B);
rgpulse(pw, zero, 1.0e-5, 1.0e-6);
delay(2.0e-6);
zgradpulse(0.8*gzlvl0,gt0);
delay(taua - gt0 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0,2.0*pwN,zero,zero,zero, 1.0e-6, 1.0e-6);
delay(taua - gt0 - 500.0e-6);
zgradpulse(0.8*gzlvl0,gt0);
txphase(one);
delay(500.0e-6);
rgpulse(pw, one, 1.0e-6, 1.0e-6);
delay(2.0e-6);
zgradpulse(1.3*gzlvl3, gt3);
decpwrf(dfCO180);
txphase(zero);
delay(200.0e-6);
dec2rgpulse(pwN, zero, 0.0, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl0, gt0);
delay(taub - gt0 - 2.0*pw - 2.0e-6);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(bigT - taub - WFG3_START_DELAY);
sim3shaped_pulse("","offC8","",(double)0.0,pwCO180,2.0*pwN,zero,zero,zero,0.0,0.0);
delay(bigT - gt0 - WFG3_STOP_DELAY - 1.0e-3);
zgradpulse(gzlvl0, gt0);
delay(1.0e-3);
dec2rgpulse(pwN, zero, 0.0, 0.0);
delay(2.0e-6);
zgradpulse(gzlvl9, gt9);
decpwrf(dpwrfC);
decphase(t3);
delay(200.0e-6);
if(ref_flg[A] != 'y')
{
decrgpulse(pwC, t3, 0.0, 0.0);
delay(2.0e-6);
if(gt6 > 0.2e-6)
zgradpulse(gzlvl6, gt6);
decpwrf(dfCO180);
txphase(t1);
delay(bigTCO - gt6 - 2.0e-6);
rgpulse(pw, t1, 0.0, 0.0);
if(tau1 >(pwCab180/2.0 + WFG_START_DELAY +WFG_STOP_DELAY+ POWER_DELAY + pwCO180/2.0))
{
decpwrf(dfCab180);
delay(tau1 - pwCab180/2.0 - WFG_START_DELAY - POWER_DELAY);
decshaped_pulse("offC27", pwCab180, zero, 0.0, 0.0);
decpwrf(dfCO180);
delay(tau1-pwCO180/2.0-pwCab180/2.0-WFG_STOP_DELAY-WFG_START_DELAY-POWER_DELAY);
decshaped_pulse("offC8", pwCO180, zero, 0.0, 0.0);
decpwrf(dfCab180);
delay(tau1-pwCO180/2.0-pwCab180/2.0-WFG_STOP_DELAY-WFG_START_DELAY-POWER_DELAY);
decshaped_pulse("offC27", pwCab180, zero, 0.0, 0.0);
txphase(zero);
delay(tau1 - pwCab180/2.0 - WFG_STOP_DELAY);
}
else
{
delay(2.0*tau1);
decshaped_pulse("offC8", pwCO180, zero, 0.0, 0.0);
txphase(zero);
delay(2.0*tau1);
}
rgpulse(pw, zero, 0.0, 0.0);
delay(bigTCO - gt6 - POWER_DELAY - 1.0e-3);
if (gt6 > 0.2e-6)
zgradpulse(gzlvl6, gt6);
decpwrf(dpwrfC);
delay(1.0e-3);
decrgpulse(pwC, zero, 0.0, 0.0);
}
else
{
decrgpulse(pwC, t3, 0.0, 0.0);
decpwrf(dfCa180);
sim3shaped_pulse("","offC17","",0.0e-6,pwCa180,0.0e-6,zero,zero,zero,2.0e-6,0.0);
delay(2.0e-6);
if(gt6 > 0.2e-6)
zgradpulse(gzlvl6, gt6);
decpwrf(dfCO180);
delay(bigTCO - 2.0*tau1 - maxcan - gt6 - 2.0*POWER_DELAY - 4.0e-6);
decshaped_pulse("offC8", pwCO180, zero, 0.0, 0.0);
delay(bigTCO - gt6 - maxcan - 2.0*POWER_DELAY - 1.0e-3);
if (gt6 > 0.2e-6)
zgradpulse(gzlvl6, gt6);
decpwrf(dfCa180);
delay(1.0e-3);
sim3shaped_pulse("","offC17","",2.0*pw,pwCa180,2.0*pwN,zero,zero,zero,0.0,0.0);
decpwrf(dpwrfC);
delay(2.0*tau1);
decrgpulse(pwC, t1, 2.0e-6, 0.0);
}
delay(2.0e-6);
zgradpulse(gzlvl7, gt7);
decpwrf(dfCO180);
dec2phase(t2);
delay(200.0e-6);
dec2rgpulse(pwN, t2, 0.0, 0.0);
delay(bigTN - tau2);
dec2phase(t4);
sim3shaped_pulse("","offC8","",(double)0.0,pwCO180,2.0*pwN,zero,zero,t4,0.0,0.0);
decpwrf(dfCa180);
delay(bigTN - taub - WFG_STOP_DELAY - POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(taub - 2.0*pw - gt1 - 1.0e-3 - 6.0*GRADIENT_DELAY);
if (mag_flg[A] == 'y')
{
magradpulse(gzcal*gzlvl1, gt1);
}
else
{
zgradpulse(gzlvl1, gt1);
delay(4.0*GRADIENT_DELAY);
}
dec2phase(t5);
delay(1.0e-3);
decshaped_pulse("offC17", pwCa180, zero, 0.0, 0.0);
delay(tau2);
sim3pulse(pw,(double)0.0, pwN, zero,zero, t5, 0.0, 0.0);
dec2phase(zero);
delay(2.0e-6);
zgradpulse(0.8*gzlvl5, gt5);
delay(taua - gt5 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, zero, 0.0, 0.0);
delay(taua - gt5 - 500.0e-6);
zgradpulse(0.8*gzlvl5, gt5);
txphase(one);
decphase(one);
delay(500.0e-6);
sim3pulse(pw,(double)0.0, pwN, one,zero, one, 0.0, 0.0);
delay(2.0e-6);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
delay(taua - gt5 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0, 2.0*pwN, zero,zero, zero, 0.0, 0.0);
delay(taua - gt5 - 2.0*POWER_DELAY - 500.0e-6);
zgradpulse(gzlvl5, gt5);
decpower(dpwr);
dec2power(dpwr2);
delay(500.0e-6);
rgpulse(pw, zero, 0.0, 0.0);
delay(1.0e-4 +gstab + gt1/10.0 - 0.5*pw + 6.0*GRADIENT_DELAY);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(2.0e-6);
if(mag_flg[A] == 'y')
{
magradpulse(icosel*gzcal*gzlvl2, gt1/10.0);
}
else
{
zgradpulse(icosel*gzlvl2, gt1/10.0);
delay(4.0*GRADIENT_DELAY);
}
delay(1.0e-4 - 2.0e-6);
statusdelay(C,1.0e-4);
setreceiver(t10);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char autocal[MAXSTR], /* auto-calibration flag */
fsat[MAXSTR],
fscuba[MAXSTR],
f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
f2180[MAXSTR], /* Flag to start t2 @ halfdwell */
c180_flg[MAXSTR],
codecseq[MAXSTR],
mess_flg[MAXSTR],
ch_shp1[MAXSTR], /* shape for the 1st purge CHIRP */
ch_shp2[MAXSTR], /* shape for the 2nd purge CHIRP */
chshpi[MAXSTR]; /* shape for the INEPT CHIRPs */
int phase, phase2,
t1_counter, /* used for states tppi in t1 */
t2_counter; /* used for states tppi in t2 */
double tau1, /* t1 delay */
tau2, /* t2 delay */
ni2,
mix, /* mixing time in seconds */
pwC, /* PW90 for c nucleus @ pwClvl */
pwcodec, /* PW for C' nucleus @ dpwrco seduce dec */
tsatpwr, /* low level 1H trans.power for presat */
pwClvl, /* power level for 13C pulses on dec1 */
dpwrco, /* power level for C' seduce decoupling */
sw1, /* sweep width in f1 */
sw2, /* sweep width in f2 */
tofps, /* tof for presat */
dressed, /* decoupler resolution for seduce decoupling */
tpwrmess, /* power level for Messerlie purge */
dly_pg1, /* duration of first part of purge */
dly_wt,
taua1, /* Delay for the first purge CHIRP */
taua2, /* Delay for the second purge CHIRP */
pwchirp1, /* duration of the 1st purge CHIRP */
pwchirp2, /* duration of the 2nd purge CHIRP */
d_me1, /* time difference between
start of the sweep and the
excitation of the methyl region
automatically calculated by the program
necessary parameter diff (see below) */
d_me2, /* time difference between
start of the sweep and the
excitation of the methyl region
automatically calculated by the program
necessary parameter diff (see below) */
dchrp1, /* power for the 1st purge CHIRP pulse, only lower
limit is important (see above!) */
dchrp2, /* power for the 2nd purge CHIRP pulse, only lower
limit is important (see above!) */
dmfchp1, /* dmf (1/90) for the 1st purge CHIRP pulse
dmfchp1 = 1/time_step of chirp-pulse
[time_step = pwchirp1/no. of points in
the .DEC-shape] */
dmfchp2, /* dmf (1/90) for the 1st purge CHIRP pulse
dmfchp2 = 1/time_step of chirp-pulse
[time_step = pwchirp2/no. of points in
the .DEC-shape] */
dres_chp, /* dres for the chirp pulse
(must be set to 90, otherwise
timing errors! ) */
diff1, /* shift differences between
methyl region and start of sweep */
diff2, /* shift differences between
methyl region and start of sweep */
rate1, /* sweep rate of the 1st purge CHIRP pulse
frequency sweep/pwchirp1 */
rate2, /* sweep rate of the 2nd purge CHIRP pulse
frequency sweep/pwchirp2 */
dchrpi,
dmfchpi,
pwchirpi, /* INEPT CHIRP duration */
ratei,
diffi,
tauf,
d_mei,
compC, /* C-13 RF calibration parameters */
pwrcor=0.0,
gt0,
gt1,
gt2,
gt3,
gt4,
gt5,
gt8,
gt9,
gt10,
gt11,
gstab,
gzlvl0,
gzlvl1,
gzlvl2,
gzlvl3,
gzlvl4,
gzlvl5,
gzlvl8,
gzlvl9,
gzlvl10,
gzlvl11;
/* variables commented out are already defined by the system */
/* LOAD VARIABLES */
getstr("autocal",autocal);
getstr("fsat",fsat);
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("fscuba",fscuba);
getstr("c180_flg",c180_flg);
getstr("mess_flg",mess_flg);
tofps = getval("tofps");
mix = getval("mix");
pwC = getval("pwC");
tpwr = getval("tpwr");
tsatpwr = getval("tsatpwr");
pwClvl = getval("pwClvl");
dpwr = getval("dpwr");
dpwr2 = getval("dpwr2");
phase = (int) ( getval("phase") + 0.5);
phase2 = (int) ( getval("phase2") + 0.5);
sw1 = getval("sw1");
sw2 = getval("sw2");
ni2 = getval("ni2");
tpwrmess = getval("tpwrmess");
dly_pg1 = getval("dly_pg1");
dly_wt = getval("dly_wt");
taua1 = getval("taua1");
taua2 = getval("taua2");
rate1 = getval("rate1");
rate2 = getval("rate2");
diff1 = getval("diff1");
diff2 = getval("diff2");
diffi = getval("diffi");
ratei = getval("ratei");
tauf = getval("tauf");
gt0 = getval("gt0");
gt1 = getval("gt1");
gt2 = getval("gt2");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt8 = getval("gt8");
gt9 = getval("gt9");
gt10 = getval("gt10");
gt11 = getval("gt11");
gstab = getval("gstab");
gzlvl0 = getval("gzlvl0");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl8 = getval("gzlvl8");
gzlvl9 = getval("gzlvl9");
gzlvl10 = getval("gzlvl10");
gzlvl11 = getval("gzlvl11");
if(autocal[0]=='n')
{
getstr("codecseq",codecseq);
dressed = getval("dressed");
pwcodec = getval("pwcodec");
dpwrco = getval("dpwrco");
getstr("ch_shp1",ch_shp1);
getstr("ch_shp2",ch_shp2);
pwchirp1 = getval("pwchirp1");
pwchirp2 = getval("pwchirp2");
dchrp1 = getval("dchrp1");
dchrp2 = getval("dchrp2");
dmfchp1 = getval("dmfchp1");
dmfchp2 = getval("dmfchp2");
dres_chp = getval("dres_chp");
getstr("chshpi",chshpi);
dchrpi = getval("dchrpi");
dmfchpi = getval("dmfchpi");
pwchirpi = getval("pwchirpi");
}
else
{
strcpy(codecseq,"Psed_108p");
strcpy(ch_shp1,"Pwurst180_1");
strcpy(ch_shp2,"Pwurst180_2");
strcpy(chshpi,"Pwurst180i");
if (FIRST_FID)
{
compC = getval("compC");
codec = pbox(codecseq, CODEC, CODECps, dfrq, compC*pwC, pwClvl);
chirp1 = pbox(ch_shp1, CHIRP1, CHIRPps, dfrq, compC*pwC, pwClvl);
chirp2 = pbox(ch_shp2, CHIRP2, CHIRPps, dfrq, compC*pwC, pwClvl);
chirpi = pbox(chshpi, CHIRPi, CHIRPps, dfrq, compC*pwC, pwClvl);
}
dpwrco = codec.pwr; pwcodec = 1.0/codec.dmf; dressed = codec.dres;
dchrp1 = chirp1.pwr; dmfchp1 = chirp1.dmf;
pwchirp1 = chirp1.pw; dres_chp = chirp1.dres;
dchrp2 = chirp1.pwr; dmfchp2 = chirp2.dmf;
pwchirp2 = chirp2.pw;
dchrpi = chirpi.pwr; dmfchpi = chirpi.dmf;
pwchirpi = chirpi.pw;
pwrcor = pwClvl - dchrp1 - 6.0; /* use more power for adiabatic pulses, if available */
if(pwrcor > 3.0) pwrcor = 3.0;
else if (pwrcor < 0.0) pwrcor = 0.0;
dchrp1 = dchrp1 + pwrcor;
dchrp2 = dchrp2 + pwrcor;
pwrcor = pwClvl - dchrpi - 4.0;
if(pwrcor > 2.0) pwrcor = 2.0;
else if (pwrcor < 0.0) pwrcor = 0.0;
dchrpi = dchrpi + pwrcor;
}
/* LOAD PHASE TABLE */
settable(t1,8,phi1);
settable(t2,16,phi2);
settable(t4,16,rec);
settable(t5,4,phi5);
settable(t6,2,phi6);
settable(t7,4,phi7);
/* CHECK VALIDITY OF PARAMETER RANGES */
if((dm[A] == 'y' || dm[B] == 'y' ))
{
printf("incorrect dec1 decoupler flags! ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y'))
{
printf("incorrect dec2 decoupler flags! Should be 'nnn' ");
psg_abort(1);
}
if( tsatpwr > 6 )
{
printf("TSATPWR too large !!! ");
psg_abort(1);
}
if( dpwr > 50 )
{
printf("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( dpwrco > 50 )
{
printf("don't fry the probe, dpwrco too large! ");
psg_abort(1);
}
if( dpwr2 > 46 )
{
printf("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( pw > 200.0e-6 )
{
printf("dont fry the probe, pw too high ! ");
psg_abort(1);
}
if( pwC > 200.0e-6 )
{
printf("dont fry the probe, pwC too high ! ");
psg_abort(1);
}
if( pwcodec < 300.0e-6 )
{
printf("dont fry the probe, pwcodec too high ! ");
psg_abort(1);
}
if ( tpwrmess > 56 )
{
printf("dont fry the probe, tpwrmess too high ! ");
psg_abort(1);
}
if ( dly_pg1 > 0.010)
{
printf("dont fry the probe, dly_pg1 too long ! ");
psg_abort(1);
}
if( gt0 > 15e-3 || gt1 > 15e-3 || gt2 > 15e-3
|| gt3 > 15e-3 || gt4 > 15e-3
|| gt5 > 15e-3
|| gt8 > 15e-3
|| gt9 > 15e-3 || gt10 > 15e-3 || gt11 > 15e-3 )
{
printf("gti values < 15e-3\n");
psg_abort(1);
}
if( gzlvl3*gzlvl4 > 0.0 )
{
printf("gt3 and gt4 must be of opposite sign \n");
printf("for optimal water suppression\n");
psg_abort(1);
}
if( dchrp1 > 60 )
{
printf("don't fry the probe, dchrp1 too large! ");
psg_abort(1);
}
if( dchrp2 > 60 )
{
printf("don't fry the probe, dchrp2 too large! ");
psg_abort(1);
}
if( pwchirp1 > 10.e-03 )
{
printf("don't fry the probe, pwchirp1 too large! ");
psg_abort(1);
}
if( pwchirp2 > 10.e-03 )
{
printf("don't fry the probe, pwchirp2 too large! ");
psg_abort(1);
}
d_me1 = diff1/rate1 ;
d_me2 = diff2/rate2 ;
if( d_me1 > 10.e-03 )
{
printf("don't fry the probe, d_me1 too large \n");
printf(" (must be less than 10 msec)! ");
psg_abort(1);
}
if( d_me2 > 10.e-03 )
{
printf("don't fry the probe, d_me2 too large \n");
printf(" (must be less than 10 msec)! ");
psg_abort(1);
}
if( d_me1 > pwchirp1 )
{
printf("impossible; d_me1 > pwchirp1 ! ");
psg_abort(1);
}
if( d_me2 > pwchirp2 )
{
printf("impossible; d_me2 > pwchirp2 ! ");
psg_abort(1);
}
if( dchrpi > 60 )
{
printf("dont fry the probe, dchrpi too large\n");
psg_abort(1);
}
if(pwchirpi > 10.0e-3)
{
printf("don't fry the probe, pwchirpi too large! ");
psg_abort(1);
}
d_mei = diffi/ratei;
/* Phase incrementation for hypercomplex 2D data */
if (phase == 2)
tsadd(t1,1,4);
if (phase2 == 2)
tsadd(t2,1,4);
/* Set up f1180 tau1 = t1 */
tau1 = d2;
if(f1180[A] == 'y') {
tau1 += ( 1.0 / (2.0*sw1) - 4.0/PI*pw - 2.0e-6 );
}
else
tau1 = tau1 - 4.0/PI*pw - 2.0e-6;
if(tau1 < 0.2e-6) tau1 = 2.0e-7;
/* Set up f2180 tau2 = t2 */
tau2 = d3;
if(f2180[A] == 'y') {
tau2 += ( 1.0 / (2.0*sw2) - (4.0/PI)*pwC
- 2.0*pw - PRG_START_DELAY - PRG_STOP_DELAY
- 2.0*POWER_DELAY - 4.0e-6);
}
else tau2 = tau2 - ((4.0/PI)*pwC + 2.0*pw
+ PRG_START_DELAY + PRG_STOP_DELAY
+ 2.0*POWER_DELAY + 4.0e-6);
if(tau2 < 0.2e-6) tau2 = 4.0e-7;
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2 ;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2) {
tsadd(t1,2,4);
tsadd(t4,2,4);
}
if( ix == 1) d3_init = d3 ;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2) {
tsadd(t2,2,4);
tsadd(t4,2,4);
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
delay(5.0e-6);
obspower(tsatpwr); /* Set transmitter power for 1H presaturation */
decpower(pwClvl); /* Set Dec1 power for hard 13C pulses */
delay(5.0e-6);
/* Presaturation Period */
if (mess_flg[A] == 'y') {
obsoffset(tofps);
obspower(tpwrmess);
txphase(zero);
rgpulse(dly_pg1,zero,2.0e-6,2.0e-6);
txphase(one);
rgpulse(dly_pg1/1.62,one,2.0e-6,2.0e-6);
obspower(tsatpwr);
}
if (fsat[0] == 'y')
{
obsoffset(tofps);
delay(2.0e-5);
rgpulse(d1,zero,2.0e-6,2.0e-6); /* presat */
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
delay(2.0e-5);
if(fscuba[0] == 'y')
{
delay(2.2e-2);
rgpulse(pw,zero,2.0e-6,0.0);
rgpulse(2*pw,one,2.0e-6,0.0);
rgpulse(pw,zero,2.0e-6,0.0);
delay(2.2e-2);
}
}
else
{
delay(d1);
}
obspower(tpwr); /* Set transmitter power for hard 1H pulses */
obsoffset(tof);
decphase(zero);
/* Begin Pulses */
status(B);
rcvroff();
delay(10.0e-6);
rgpulse(pw,t6,4.0e-6,0.0); /* 90 deg 1H pulse */
txphase(zero); decphase(zero);
delay(2.0e-6);
zgradpulse(gzlvl8,gt8);
delay(gstab);
delay(taua1 - gt8 - gstab -2.0e-6 - POWER_DELAY - 4.0e-6
- PRG_START_DELAY - d_me1);
/* 1st purge CHIRP inversion on */
decpower(dchrp1); /* Set power for 1st purge CHIRP inversion */
delay(4.0e-6);
decprgon(ch_shp1,1.0/dmfchp1,dres_chp);
decon();
delay(d_me1);
rgpulse(2*pw,zero,0.0,0.0); /* 1H inversion pulse */
delay(pwchirp1 - d_me1 - 2*pw);
decoff();
decprgoff();
/* chirp inversion off */
delay(2.0e-6);
zgradpulse(gzlvl8,gt8);
delay(gstab);
delay(taua1 + 2*pw - (pwchirp1 - d_me1)
- PRG_STOP_DELAY - gt8 - gstab -2.0e-6);
rgpulse(pw,zero,0.0,0.0);
txphase(t7);
delay(2.0e-6);
zgradpulse(gzlvl9,gt9);
delay(2.0*gstab);
rgpulse(pw,t7,0.0,0.0); /* PHASE t7 = 2(x),2(-x)*/
delay(2.0e-6);
zgradpulse(gzlvl11,gt11);
delay(gstab);
decphase(zero); txphase(zero);
delay(taua2 - gt11 - gstab -2.0e-6 - POWER_DELAY
- 4.0e-6 - PRG_START_DELAY - d_me2);
/* Second chirp inversion on */
decpower(dchrp2); /* Set power for chirp inversion */
delay(4.0e-6);
decprgon(ch_shp2,1.0/dmfchp2,dres_chp);
decon();
delay(d_me2);
rgpulse(2*pw,zero,0.0,0.0); /* 1H inversion pulse */
delay(pwchirp2 - d_me2 - 2*pw);
decoff();
decprgoff();
/* Second purge CHIRP off */
delay(2.0e-6);
zgradpulse(gzlvl11,gt11);
delay(gstab);
txphase(zero);
delay(taua2 + 2*pw - (pwchirp2 - d_me2)
- PRG_STOP_DELAY - gt11 - gstab -2.0e-6 );
rgpulse(pw,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl10,gt10);
delay(2.0*gstab);
rgpulse(pw,t1,4.0e-6,0.0);
delay(tau1);
rgpulse(pw,zero,2.0e-6,0.0);
delay(mix - 10.0e-3);
delay(2.0e-6);
zgradpulse(gzlvl0,gt0);
decpower(pwClvl); /* Set power for hard pulses */
delay(4.0e-6);
decrgpulse(pwC,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl1,gt1);
delay(2.0e-6);
decphase(zero);
delay(10.0e-3 - gt1 - gt0 - 8.0e-6);
rgpulse(pw,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(gstab);
decphase(zero);
delay(tauf - gt2 - gstab -2.0e-6 - POWER_DELAY - 4.0e-6
- PRG_START_DELAY - d_mei);
/* INEPT CHIRP inversion on */
decpower(dchrpi); /* Set power for chirp inversion */
delay(4.0e-6);
decprgon(chshpi,1.0/dmfchpi,dres_chp);
decon();
delay(d_mei);
rgpulse(2*pw,zero,0.0,0.0); /* 1H inversion pulse */
delay(pwchirpi - d_mei - 2*pw);
decoff();
decprgoff();
/* chirp inversion off */
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(gstab);
txphase(one);
delay(tauf + 2*pw - (pwchirpi - d_mei)
- PRG_STOP_DELAY - gt2 - gstab -2.0e-6 );
rgpulse(pw,one,0.0,0.0);
txphase(zero); decphase(t2);
decpower(pwClvl); /* Set power for C13 hard pulse */
delay(2.0e-6);
zgradpulse(gzlvl3,gt3);
delay(200.0e-6);
decrgpulse(pwC,t2,0.0,0.0);
decphase(zero);
if( c180_flg[A] == 'n' ) {
delay(2.0e-6);
/* CO decoupling on */
decpower(dpwrco);
decprgon(codecseq,pwcodec,dressed);
decon();
/* CO decoupling on */
delay(tau2);
rgpulse(2*pw,zero,0.0,0.0);
delay(tau2);
/* CO decoupling off */
decoff();
decprgoff();
decpower(pwClvl);
/* CO decoupling off */
delay(2.0e-6);
}
else
simpulse(2*pw,2*pwC,zero,zero,2.0e-6,2.0e-6);
decrgpulse(pwC,zero,0.0,0.0);
delay(2.0e-6);
zgradpulse(gzlvl4,gt4);
delay(200.0e-6);
rgpulse(pw,t5,2.0e-6,0.0);
txphase(zero);
delay(2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(gstab);
decphase(zero);
delay(tauf - gt5 - gstab -2.0e-6 - POWER_DELAY
- 4.0e-6 - PRG_START_DELAY - d_mei);
/* 2nd INEPT CHIRP inversion on */
decpower(dchrpi); /* Set power for chirp inversion */
delay(4.0e-6);
decprgon(chshpi,1.0/dmfchpi,dres_chp);
decon();
delay(d_mei);
rgpulse(2*pw,zero,0.0,0.0); /* 1H inversion pulse */
delay(pwchirpi - d_mei - 2*pw);
decoff();
decprgoff();
/* chirp inversion off */
delay(2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(gstab);
decpower(dpwr); /* Set power for decoupling */
txphase(t5);
delay(tauf + 2*pw - (pwchirpi - d_mei) - PRG_STOP_DELAY
- gt5 - gstab -2.0e-6 - 2*POWER_DELAY);
rgpulse(pw,t5,0.0,rof2);
/* BEGIN ACQUISITION */
status(C);
setreceiver(t4);
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES; parameters used in the last half of the */
/* sequence are declared and initialized as 0.0 in bionmr.h, and */
/* reinitialized below */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
f2180[MAXSTR], /* Flag to start t2 @ halfdwell */
COrefoc[MAXSTR],
TROSY[MAXSTR]; /* do TROSY on N15 and H1 */
int t1_counter, /* used for states tppi in t1 */
t2_counter, /* used for states tppi in t2 */
ni2 = getval("ni2");
double d2_init=0.0, /* used for states tppi in t1 */
d3_init=0.0, /* used for states tppi in t2 */
tau1, /* t1 delay */
timeTN = getval("timeTN"), /* constant time for 15N evolution */
timeNCA = getval("timeNCA"),
timeC = getval("timeC"),
lambda = 1.0/(4.0*getval("JNH")),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
pwS1, /* length of square 90 on Ca */
phshift, /* phase shift induced on Ca by 180 on CO in middle of t1 */
pwS2, /* length of 180 on CO */
pwS = getval("pwS"), /* used to change 180 on CO in t1 for 1D calibrations */
pwZ, /* the largest of pwS2 and 2.0*pwN */
pwZ1, /* the largest of pwS2 and 2.0*pwN for 1D experiments */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
sw2 = getval("sw2"),
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3");
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("COrefoc",COrefoc);
getstr("TROSY",TROSY);
/* LOAD PHASE TABLE */
settable(t3,2,phi3);
settable(t4,1,phx);
settable(t5,4,phi5);
if (TROSY[A]=='y')
{settable(t8,1,phy);
settable(t9,1,phx);
settable(t10,1,phy);
settable(t11,1,phx);
settable(t12,4,recT);}
else
{settable(t8,1,phx);
settable(t9,8,phi9);
settable(t10,1,phx);
settable(t11,1,phy);
settable(t12,4,rec);}
/* INITIALIZE VARIABLES */
kappa = 5.4e-3;
pwHs = 1.7e-3*500.0/sfrq; /* length of H2O flipback, 1.7ms at 500 MHz*/
widthHd = 34.0; /* bandwidth of H1 WALTZ16 decoupling, 7.3 kHz at 600 MHz */
pwHd = h1dec90pw("WALTZ16", widthHd, 0.0); /* H1 90 length for WALTZ16 */
/* get calculated pulse lengths of shaped C13 pulses */
pwS1 = c13pulsepw("co", "ca", "sinc", 90.0);
pwS2 = c13pulsepw("ca", "co", "square", 180.0);
/* get calculated pulse lengths of shaped C13 pulses
pwS1 = c13pulsepw("ca", "co", "square", 90.0);
pwS2 = c13pulsepw("co", "ca", "sinc", 180.0); */
/* the 180 pulse on CO at the middle of t1 */
if ((ni2 > 0.0) && (ni == 1.0)) ni = 0.0;
if (pwS2 > 2.0*pwN) pwZ = pwS2; else pwZ = 2.0*pwN;
if ((pwS==0.0) && (pwS2>2.0*pwN)) pwZ1=pwS2-2.0*pwN; else pwZ1=0.0;
if ( ni > 1 ) pwS = 180.0;
if ( pwS > 0 ) phshift = 130.0;
else phshift = 130.0;
/* CHECK VALIDITY OF PARAMETER RANGES */
if ( 0.5*ni2*1/(sw2) > timeTN - WFG3_START_DELAY)
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN - WFG3_START_DELAY)*2.0*sw2))); psg_abort(1);}
if ( dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' )
{ printf("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1);}
if ( dm2[A] == 'y' || dm2[B] == 'y' )
{ printf("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1);}
if ( dm3[A] == 'y' || dm3[C] == 'y' )
{ printf("incorrect dec3 decoupler flags! Should be 'nyn' or 'nnn' ");
psg_abort(1);}
if ( dpwr2 > 46 )
{ printf("dpwr2 too large! recheck value "); psg_abort(1);}
if ( pw > 20.0e-6 )
{ printf(" pw too long ! recheck value "); psg_abort(1);}
if ( pwN > 100.0e-6 )
{ printf(" pwN too long! recheck value "); psg_abort(1);}
if ( TROSY[A]=='y' && dm2[C] == 'y')
{ text_error("Choose either TROSY='n' or dm2='n' ! "); psg_abort(1);}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 2) tsadd(t3,1,4);
if (TROSY[A]=='y')
{ if (phase2 == 2) icosel = +1;
else {tsadd(t4,2,4); tsadd(t10,2,4); icosel = -1;}
}
else { if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Set up f2180 */
tau2 = d3;
if((f2180[A] == 'y') && (ni2 > 1.0))
{ tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.0; }
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); }
if( ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{ tsadd(t8,2,4); tsadd(t12,2,4); }
/* BEGIN PULSE SEQUENCE */
status(A);
delay(d1);
if (dm3[B]=='y') lk_hold();
rcvroff();
set_c13offset("co");
obsoffset(tof);
obspower(tpwr);
obspwrf(4095.0);
decpower(pwClvl);
decpwrf(4095.0);
dec2power(pwNlvl);
txphase(zero);
delay(1.0e-5);
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 and C13 magnetization*/
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
dec2rgpulse(pwN, one, 0.0, 0.0);
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
delay(5.0e-4);
rgpulse(pw,zero,0.0,0.0); /* 1H pulse excitation */
dec2phase(zero);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
txphase(one);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
rgpulse(pw, one, 0.0, 0.0);
if (TROSY[A]=='y')
{txphase(two);
shiftedpulse("sinc", pwHs, 90.0, 0.0, two, 2.0e-6, 0.0);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
dec2rgpulse(pwN, zero, 0.0, 0.0);
delay(0.5*kappa - 2.0*pw);
rgpulse(2.0*pw, two, 0.0, 0.0);
decphase(zero);
dec2phase(zero);
delay(timeTN - 0.5*kappa - WFG3_START_DELAY);
}
else
{txphase(zero);
shiftedpulse("sinc", pwHs, 90.0, 0.0, zero, 2.0e-6, 0.0);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
dec2rgpulse(pwN, zero, 0.0, 0.0);
delay(kappa - POWER_DELAY - PWRF_DELAY - pwHd - 4.0e-6 - PRG_START_DELAY);
/* delays for h1waltzon subtracted */
h1waltzon("WALTZ16", widthHd, 0.0);
decphase(zero);
dec2phase(zero);
delay(timeTN - kappa - WFG3_START_DELAY);
}
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0); /* pwS2 */
delay(timeNCA - timeTN - timeC);
dec2rgpulse(2.0*pwN,zero,0.0,0.0);
c13pulse("ca", "co", "sinc", 180.0, zero, 0.0, 0.0);
decphase(zero);
delay(timeNCA - timeC + 1.3*pwN);
c13pulse("co", "ca", "sinc", 90.0, zero, 0.0, 0.0); /* pwS1 */
delay(timeC);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); /* pwS2 */
delay(timeC);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
c13pulse("co", "ca", "sinc", 90.0, one, 0.0, 0.0); /* pwS1 */
dec2rgpulse(pwN, zero, 0.0, 0.0);
if (TROSY[A]=='n') h1waltzoff("WALTZ16", widthHd, 0.0);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
if(dm3[B] == 'y') /*optional 2H decoupling on */
{dec3unblank(); dec3rgpulse(1/dmf3, one, 0.0, 0.0);
dec3unblank(); setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);}
h1waltzon("WALTZ16", widthHd, 0.0);
/* xxxxxxxxxxxxxxxxxxxxxx 13Ca EVOLUTION xxxxxxxxxxxxxxxxxx */
set_c13offset("ca");
c13pulse("ca", "co", "square", 90.0, t3, 2.0e-6, 0.0); /* pwS1 */
decphase(zero);
if ((ni>1.0) && (tau1>0.0)) /* total 13C evolution equals d2 exactly */
{
/* 2.0*pwS1/PI compensates for evolution at 64% rate during 90 */
if (tau1 - 2.0*pwS1/PI - WFG3_START_DELAY - 0.5*pwZ - 2.0e-6
- 2.0*PWRF_DELAY - 2.0*POWER_DELAY > 0.0)
{
delay(tau1 - 2.0*pwS1/PI - WFG3_START_DELAY - 0.5*pwZ - 2.0e-6 - 2.0*PWRF_DELAY - 2.0*POWER_DELAY);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,zero, zero, zero, 2.0e-6, 0.0);
initval(phshift, v3);
decstepsize(1.0);
dcplrphase(v3);
delay(tau1 - 2.0*pwS1/PI - SAPS_DELAY - 0.5*pwZ - WFG_START_DELAY - 2.0e-6 - 2.0*PWRF_DELAY - 2.0*POWER_DELAY);
}
else
{
initval(180.0, v3);
decstepsize(1.0);
dcplrphase(v3);
delay(2.0*tau1 - 4.0*pwS1/PI - SAPS_DELAY - WFG_START_DELAY - 2.0e-6 - PWRF_DELAY - POWER_DELAY);
}
/* delay(tau1);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,zero, zero, zero, 2.0e-6, 0.0);
delay(tau1);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 0.0);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,zero, zero, zero, 2.0e-6, 0.0);*/
}
else if (ni==1.0)
{
delay(10.0e-6 + SAPS_DELAY + 0.5*pwZ1 + WFG_START_DELAY);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, pwS, 2.0*pwN, zero, zero, zero, 2.0e-6, 0.0);
initval(phshift, v3);
decstepsize(1.0);
dcplrphase(v3);
delay(10.0e-6 + WFG3_START_DELAY + 0.5*pwZ1);
}
else
{
delay(10.0e-6);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 0.0);
delay(10.0e-6);
/* delay(tau1);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,zero, zero, zero, 2.0e-6, 0.0);
delay(tau1);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 0.0);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,zero, zero, zero, 2.0e-6, 0.0); */
}
decphase(t5);
c13pulse("ca", "co", "square", 90.0, t5, 2.0e-6, 0.0); /* pwS1 */
h1waltzoff("WALTZ16", widthHd, 0.0);
if(dm3[B] == 'y') /*optional 2H decoupling off */
{dec3rgpulse(1/dmf3, three, 0.0, 0.0); dec3blank();
setstatus(DEC3ch, FALSE, 'w', FALSE, dmf3); dec3blank();}
set_c13offset("co");
/* xxxxxxxxxxxxxxxxxxxx N15 EVOLUTION & SE TRAIN xxxxxxxxxxxxxxxxxxxxxxx */
ihn_evol_se_train("co", "ca"); /* common part of sequence in bionmr.h */
if (dm3[B] == 'y') lk_sample();
}
void pulsesequence()
{
double p1lvl,
trim,
mix,
window,
cycles;
char sspul[MAXSTR];
/* LOAD AND INITIALIZE VARIABLES */
mix = getval("mix");
trim = getval("trim");
p1lvl = getval("p1lvl");
window=getval("window");
getstr("sspul", sspul);
/* CHECK CONDITIONS */
if ((phase1 != 3) && (arrayelements > 2))
{
fprintf(stdout, "PHASE=3 is required if MIX is arrayed!\n");
psg_abort(1);
}
if (satdly > 9.999)
{
fprintf(stdout, "Presaturation period is too long.\n");
psg_abort(1);
}
if (!newtransamp)
{
fprintf(stdout, "TOCSY requires linear amplifiers on transmitter.\n");
fprintf(stdout, "Use DECTOCSY with the appropriate re-cabling,\n");
psg_abort(1);
}
if ((p1 == 0.0) && (ix == 1))
fprintf(stdout, "Warning: P1 has a zero value.\n");
if ((rof1 < 9.9e-6) && (ix == 1))
fprintf(stdout,"Warning: ROF1 is less than 10 us\n");
if (satpwr > 40)
{
printf("satpwr too large - acquisition aborted./n");
psg_abort(1);
}
/* STEADY-STATE PHASECYCLING */
/* This section determines if the phase calculations trigger off of (SS - SSCTR)
or off of CT */
ifzero(ssctr);
hlv(ct, v13);
mod2(ct, v1);
hlv(ct, v2);
elsenz(ssctr);
sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */
hlv(v12, v13);
mod2(v12, v1);
hlv(v12, v2);
endif(ssctr);
/* CALCULATE PHASES */
/* A 2-step cycle is performed on the first pulse (90 degrees) to suppress
axial peaks in the first instance. Second, the 2-step F2 quadrature image
suppression subcycle is added to all pulse phases and receiver phase.
Finally, a 2-step cycle is performed on the spin-lock pulses. */
mod2(v13, v13);
dbl(v1, v1);
incr(v1);
hlv(v2, v2);
mod2(v2, v2);
dbl(v2, v2);
incr(v2);
add(v13, v2, v2);
sub(v2, one, v3);
add(two, v2, v4);
add(two, v3, v5);
add(v1, v13, v1);
assign(v1, oph);
if (phase1 == 2)
incr(v1);
if (phase1 == 3)
add(v1, id2, v1);
/*HYPERCOMPLEX MODE USES REDFIELD TRICK TO MOVE AXIAL PEAKS TO EDGE*/
if ((phase1==1)||(phase1==2))
{
initval(2.0*(double)(d2_index%2),v6);
add(v1,v6,v1); add(oph,v6,oph);
}
/* CALCULATE AND INITIALIZE LOOP COUNTER */
if (pw > 0.0)
{
cycles = (mix - trim) / (64.66*pw+32*window);
cycles = 2.0*(double) (int) (cycles/2.0);
}
else
{
cycles = 0.0;
}
initval(cycles, v9); /* V9 is the MIX loop count */
/* BEGIN ACTUAL PULSE SEQUENCE CODE */
status(A);
obspower(p1lvl);
if (sspul[0] == 'y')
{
rgpulse(1000*1e-6, zero, rof1, 0.0e-6);
rgpulse(1000*1e-6, one, 0.0e-6, rof1);
}
hsdelay(d1);
if (satmode[A] == 'y')
{ obspower(satpwr);
rgpulse(satdly,zero,rof1,rof2);
obspower(p1lvl);}
status(B);
rgpulse(p1, v1, rof1, 1.0e-6);
if (satmode[B] =='y')
{
if (d2 > 0.0)
{
obspower(satpwr);
rgpulse(d2 - (2*POWER_DELAY) - 1.0e-6 - (2*p1/3.1416),zero,0.0,0.0);
}
}
else
{
if (d2 > 0.0)
delay(d2 - POWER_DELAY - 1.0e-6 - (2*p1/3.1416));
}
rcvroff();
obsunblank();
obspower(tpwr);
txphase(v3);
xmtron();
delay(trim);
if (cycles > 1.0)
{
starthardloop(v9);
mleva(window); mleva(window); mlevb(window); mlevb(window);
mlevb(window); mleva(window); mleva(window); mlevb(window);
mlevb(window); mlevb(window); mleva(window); mleva(window);
mleva(window); mlevb(window); mlevb(window); mleva(window);
rgpulse(.66*pw,v3,rof1,rof2);
endhardloop();
}
txphase(v13);
xmtroff();
/* detection */
delay(rof2);
rcvron();
obsblank();
status(C);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char fscuba[MAXSTR],f1180[MAXSTR],fsat[MAXSTR],mess_flg[MAXSTR],
shp_flg[MAXSTR],shp_sl[MAXSTR];
int phase,
t1_counter;
double hscuba, /* length of 1/2 scuba delay */
tauxh, /* 1 / 4J(XH) */
pwN, /* PW90 for X-nuc on channel 3 */
tsatpwr, /* low power level for presat */
pwNlvl, /* power level for X hard pulses */
jxh, /* coupling for XH */
tau1, /* t1/2 */
sw1,
tpwrmess, /* power level for Messerlie purge */
dly_pg1, /* duration of first part of purge */
tpwrsl,
pw_sl,
d1_wait,
gzlvl1,
gt1,
gzlvl2,
gt2;
/* LOAD VARIABLES */
jxh = getval("jxh");
pwN = getval("pwN");
tsatpwr = getval("tsatpwr");
pwNlvl = getval("pwNlvl");
hscuba = getval("hscuba");
phase = (int) (getval("phase") + 0.5);
sw1 = getval("sw1");
tpwrmess = getval("tpwrmess");
dly_pg1 = getval("dly_pg1");
d1_wait = getval("d1_wait");
tpwrsl = getval("tpwrsl");
pw_sl = getval("pw_sl");
gzlvl1 = getval("gzlvl1");
gt1 = getval("gt1");
gzlvl2 = getval("gzlvl2");
gt2 = getval("gt2");
getstr("fscuba",fscuba);
getstr("fsat",fsat);
getstr("f1180",f1180);
getstr("shp_flg",shp_flg);
getstr("mess_flg",mess_flg);
getstr("shp_sl",shp_sl);
/* check validity of parameter range */
if((dm2[A] == 'y' || dm2[B] == 'y'))
{
printf("incorrect Dec2 decoupler flags! ");
psg_abort(1);
}
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{
printf("incorrect Dec decoupler flags! ");
psg_abort(1);
}
if( tsatpwr > 8 )
{
printf("tsatpwr too large !!! ");
psg_abort(1);
}
if( dpwr > 10 )
{
printf("don't fry the probe, dpwr too large! ");
psg_abort(1);
}
if( dpwr2 > 50 )
{
printf("don't fry the probe, dpwr2 too large! ");
psg_abort(1);
}
if( pwNlvl > 63 )
{
printf("don't fry the probe, pwNlvl too large! ");
psg_abort(1);
}
if(tpwrmess > 55)
{
printf("dont fry the probe, tpwrmess too large < 55");
psg_abort(1);
}
if(dly_pg1 > 0.010)
{
printf("dont fry the probe, dly_pg1 is too long < 10 ms");
psg_abort(1);
}
if(gt1 > 15.0e-3 || gt2 > 15.0e-3)
{
printf("gti is too long\n");
psg_abort(1);
}
if(tpwrsl > 25)
{
printf("tpwrsl is too high\n");
psg_abort(1);
}
/* LOAD VARIABLES */
settable(t1, 1, phi1);
settable(t2, 2, phi2);
settable(t3, 8, phi3);
settable(t4, 16, phi4);
settable(t5, 16, rec);
/* INITIALIZE VARIABLES */
tauxh = ((jxh != 0.0) ? 1/(2*(jxh)) : 3.57e-3);
/* Phase incrementation for hypercomplex data */
if ( phase == 2 ) /* Hypercomplex in t1 */
{
tsadd(t2, 1, 4);
}
/* calculate modifications to phases based on current t1 values
to achieve States-TPPI acquisition */
if(ix==1)
d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5);
if(t1_counter %2) {
tsadd(t2,2,4);
tsadd(t5,2,4);
}
/* set up so that get (-90,180) phase corrects in F1 if f1180 flag is y */
tau1 = d2;
if(f1180[A] == 'y') tau1 += ( 1.0/(2.0*sw1) - 2.0*pw - 4.0/PI*pwN );
else tau1 = tau1 - 2.0*pw - 4.0/PI*pwN;
if(tau1 < 0.2e-6) tau1 = 0.4e-6;
tau1 = tau1/2.0;
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(tsatpwr); /* Set power for presaturation */
decpower(dpwr); /* Set decoupler1 power to dpwr */
dec2power(pwNlvl); /* Set decoupler2 power to pwNlvl */
/* Presaturation Period */
if (mess_flg[A] == 'y') {
obspower(tpwrmess);
rgpulse(dly_pg1,zero,2.0e-6,2.0e-6);
rgpulse(dly_pg1/1.62,one,2.0e-6,2.0e-6);
obspower(tsatpwr);
}
if(fsat[0] == 'y')
{
txphase(zero);
if(d1_wait == 0.0)
rgpulse(d1,zero,2.0e-6,2.0e-6); /* presaturation */
else
{
delay(d1_wait);
rgpulse(d1,zero,2.0e-6,2.0e-6);
}
obspower(tpwr); /* Set power for hard pulses */
if (fscuba[0] == 'y') /* Scuba pulse sequence */
{
hsdelay(hscuba);
rgpulse(pw,zero,1.0e-6,0.0); /* 90x180y90x */
rgpulse(2*pw,one,1.0e-6,0.0);
rgpulse(pw,zero,1.0e-6,0.0);
txphase(zero);
delay(hscuba);
}
}
else {
obspower(tpwr); /* Set power for hard pulses */
delay(d1);
}
status(B);
obspower(tpwr);
rcvroff();
delay(20.0e-6);
if (shp_flg[A] == 'y') {
/* shaped pulse */
obspower(tpwrsl);
shaped_pulse(shp_sl,pw_sl,two,2.0e-6,0.0);
delay(2.0e-6);
obspower(tpwr);
/* shaped pulse */
delay(2.0e-6);
zgradpulse(gzlvl1,gt1);
delay(1000.0e-6);
}
rgpulse(pw,t1,1.0e-6,0.0); /* proton excit. pulse, */
/* shaped pulse */
obspower(tpwrsl);
shaped_pulse(shp_sl,pw_sl,two,2.0e-6,0.0);
delay(2.0e-6);
obspower(tpwr);
/* shaped pulse */
txphase(t3);
dec2phase(t2);
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(2.0e-6);
delay(tauxh - gt2 - 4.0e-6 - pw_sl); /* delay=1/2J(XH) */
dec2rgpulse(pwN,t2,0.0,0.0);
dec2phase(t4);
delay(tau1); /* delay=t2/2 */
rgpulse(2*pw,t3,0.0,0.0);
delay(tau1); /* delay=t2/2 */
dec2rgpulse(pwN,t4,0.0,0.0);
/* shaped pulse */
obspower(tpwrsl);
shaped_pulse(shp_sl,pw_sl,one,2.0e-6,0.0);
delay(2.0e-6);
obspower(tpwr);
/* shaped pulse */
dec2power(dpwr2); /* lower decoupler power for decoupling on decouper channel 2 */
delay(2.0e-6);
zgradpulse(gzlvl2,gt2);
delay(tauxh - POWER_DELAY - gt2 - 4.0e-6 - 2.0e-6 - pw_sl);
rgpulse(pw,one,2.0e-6,0.0);
/* acquire data */
status(C);
setreceiver(t5);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char
f1180[MAXSTR],satmode[MAXSTR],abfilter[MAXSTR];
int phase,t1_counter,icosel,ni,first_FID;
double /* DELAYS */
tauhn,
taunco,
tau1, /* t1/2 */
/* COUPLINGS */
jhn = getval("jhn"),
jnco = getval("jnco"),
/* PULSES */
pw180offca = getval("pw180offca"), /* PW180 for off-res ca nucleus @ rf180offca */
pw90onco, /* PW90 for on-res co nucleus @ rf90onco */
pw180onco, /* PW180 for on-res co nucleus @ rf90onco */
pwN = getval("pwN"), /* PW90 for N-nuc */
pwC = getval("pwC"), /* PW90 for C-nuc */
pwHs = getval("pwHs"), /* pw for water selective pulse */
/* POWER LEVELS */
satpwr = getval("satpwr"), /* low power level for presat */
pwClvl = getval("pwClvl"), /* power level for C hard pulses */
pwNlvl = getval("pwNlvl"), /* power level for N hard pulses */
rf90onco, /* power level for CO 90 pulses */
rf180onco, /* power level for CO 180 pulses */
rf180offca, /* power level for off-res Ca 180 pulses */
compH = getval("compH"), /* adjustment for C13 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
/* CONSTANTS */
sw1 = getval("sw1"),
dof = getval("dof"),
kappa,
dofca,
tpwrsf_d = getval("tpwrsf_d"), /* fine power adustment for first soft pulse*/
tpwrsf_u = getval("tpwrsf_u"), /* fine power adustment for first soft pulse*/
tpwrs, /* power for the pwHs ("H2Osinc") pulse */
/* GRADIENT DELAYS AND LEVES */
gstab = getval("gstab"),
gt0 = getval("gt0"), /* gradient time */
gt1 = getval("gt1"), /* gradient time */
gt3 = getval("gt3"),
gt5 = getval("gt5"),
gzlvl0 = getval("gzlvl0"), /* level of gradient */
gzlvl1 = getval("gzlvl1"), /* level of gradient */
gzlvl2 = getval("gzlvl2"),
gzlvl3 = getval("gzlvl3"),
gzlvl5 = getval("gzlvl5");
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /*needs 1.69 times more*/
tpwrs = (int) (tpwrs); /*power than a square pulse */
/* 180 degree pulse on Ca, null at CO 118ppm away */
rf180offca = (compC*4095.0*pwC*2.0)/pw180offca;
rf180offca = (int) (rf180offca + 0.5);
/* LOAD VARIABLES */
ni = getval("ni");
phase = (int) (getval("phase") + 0.5);
getstr("satmode",satmode);
getstr("f1180",f1180);
getstr("abfilter",abfilter);
/* check validity of parameter range */
if (dm[A] == 'y')
{
printf("incorrect Dec1 decoupler flags! ");
psg_abort(1);
}
if (dm2[A] == 'y')
{
printf("incorrect Dec2 decoupler flags! ");
psg_abort(1);
}
if ( satpwr > 8 )
{
printf("satpwr too large !!! ");
psg_abort(1);
}
if ( dpwr > 50 )
{
printf("don't fry the probe, dpwr too large! ");
psg_abort(1);
}
if ( dpwr2 > 50 )
{
printf("don't fry the probe, dpwr2 too large! ");
psg_abort(1);
}
/* LOAD VARIABLES */
settable(t1, 2, phi1);
settable(t2, 1, phi2);
settable(t3, 1, phi3);
settable(t4, 1, phi4);
settable(t5, 4, phi5);
settable(t7, 4, phi7);
/* INITIALIZE VARIABLES AND POWER LEVELS FOR PULSES */
tauhn = 1/(4.0*95.0); /* initialize */
taunco = 1/(4.0*15.0); /* initialize */
tauhn = ((jhn != 0.0) ? 1/(4*(jhn)) : 2.25e-3);
taunco = ((jnco !=0.0) ? 1/(4*(jnco)) : 16.6e-3);
kappa=(gt1 +gstab + (4.0/PI)*pwN + WFG_START_DELAY + pw180offca)/(0.5*ni/sw1)-0.001;
if (kappa > 1.0)
{
kappa=1.0-0.01;
}
if (ix == 1)
printf("semi-constant-time factor %4.6f\n",kappa);
dofca = dof - 118.0*dfrq;
if((getval("arraydim") < 1.5) || (ix==1))
first_FID = 1;
else
first_FID = 0;
/* 90 degree pulse on CO, null at Ca 118ppm away */
pw90onco = sqrt(15.0)/(4.0*118.0*dfrq);
rf90onco = (compC*4095.0*pwC)/pw90onco;
rf90onco = (int) (rf90onco + 0.5);
if(rf90onco > 4095.0)
{
if(first_FID)
printf("insufficient power for pw90onco -> rf90onco (%.0f)\n", rf90onco);
rf90onco = 4095.0;
pw90onco = pwC;
}
/* 180 degree pulse on CO, null at Ca 118ppm away */
pw180onco = sqrt(3.0)/(2.0*118.0*dfrq);
rf180onco = (compC*4095.0*pwC*2.0)/pw180onco;
rf180onco = (int) (rf180onco + 0.5);
if(rf180onco > 4095.0)
{
if(first_FID)
printf("insufficient power for pw180onco -> rf180onco (%.0f)\n", rf180onco);
rf180onco = 4095.0;
pw180onco = pwC*2.0;
}
pw180offca = pw180onco; rf180offca = rf180onco;
/* Phase incrementation for hypercomplex data */
if (phase == 1) /* Hypercomplex in t2 */
{
icosel = 1;
tsadd(t2, 2, 4);
tsadd(t3, 2, 4);
}
else icosel = -1;
/* calculate modification to phases based on current t1 values
to achieve States-TPPI acquisition */
if(ix == 1)
d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5);
if(t1_counter %2)
{
tsadd(t1, 2, 4);
tsadd(t7, 2, 4);
}
/* set up so that get (-90,180) phase corrects in F1 if f1180 flag is y */
tau1 = d2;
if (f1180[A] == 'y') tau1 += ( 1.0/(2.0*sw1));
tau1 = tau1/2.0;
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obspower(satpwr); /* Set power for presaturation */
decpower(pwClvl); /* Set decoupler1 power to pwClvl */
decpwrf(rf180onco);
dec2power(pwNlvl); /* Set decoupler2 power to pwNlvl */
obsoffset(tof);
decoffset(dof);
dec2offset(dof2);
/* Presaturation Period */
if (satmode[0] == 'y')
{
rgpulse(d1,zero,rof1,rof1);
obspower(tpwr); /* Set power for hard pulses */
}
else
{
obspower(tpwr); /* Set power for hard pulses */
delay(d1);
}
if (tpwrsf_d<4095.0) tpwrs=tpwrs+6.0; /* allow for fine power control via tpwrsf_d */
rcvroff();
dec2phase(zero);
obspwrf(tpwrsf_d); obspower(tpwrs);
shaped_pulse("H2Osinc_d", pwHs, one, rof1, rof1);
obspower(tpwr); obspwrf(4095.0);
rgpulse(pw,zero,rof1,0.0);
zgradpulse(gzlvl0,gt0);
delay(gstab);
delay(tauhn - gt0 - gstab); /* delay for 1/4JHN coupling */
sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1);
delay(tauhn - gt0 - gstab); /* delay for 1/4JHN coupling */
zgradpulse(gzlvl0,gt0);
delay(gstab -rof1);
dec2phase(zero);
rgpulse(pw,three,rof1,0.0);
zgradpulse(gzlvl3,gt3);
delay(gstab);
dec2rgpulse(pwN,zero,0.0,0.0);
if (abfilter[0] == 'b')
{
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
delay(0.5*taunco - gt5 - gstab); /* 1/8J(NCO) */
sim3pulse(0.0*pw,0.0*pw180onco,0.0,zero,zero,zero,rof1,rof1);
delay(0.5*taunco - gt5 - gstab); /* 1/8J(NCO) */
zgradpulse(gzlvl5*1.2,gt5);
dec2phase(t4);
delay(gstab);
sim3pulse(0.0,pw180onco,2.0*pwN,zero,zero,t4,rof1,rof1);
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
delay(0.5*taunco - gt5 - gstab); /* 1/8J(NCO) */
sim3pulse(0.0*pw,0.0*pw180onco,0.0,zero,zero,zero,rof1,rof1);
delay(0.5*taunco - gt5 - gstab - POWER_DELAY); /* 1/8J(NCO) */
decpwrf(rf180offca);
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
dec2phase(one);
dec2rgpulse(pwN,one,0.0,0.0); /* purge for 15N */
}
if (abfilter[0] == 'a')
{
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
delay(0.5*taunco - gt5 - gstab - 0.5*pw180onco); /* 1/8J(NCO) */
sim3pulse(0.0*pw,pw180onco,0.0,zero,zero,zero,rof1,rof1); /* 180 CO */
delay(0.5*taunco - gt5 - gstab - 0.5*pw180onco); /* 1/8J(NCO) */
zgradpulse(gzlvl5*1.2,gt5);
dec2phase(t4);
delay(gstab);
sim3pulse(0.0,0.0,2.0*pwN,zero,zero,t4,rof1,rof1); /* 180 15N */
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
delay(0.5*taunco - gt5 - gstab - 0.5*pw180onco); /* 1/8J(NCO) */
sim3pulse(0.0*pw,pw180onco,0.0,zero,zero,zero,rof1,rof1); /* 180 CO */
delay(0.5*taunco - gt5 - gstab - 0.5*pw180onco - POWER_DELAY); /* 1/8J(NCO) */
decpwrf(rf180offca);
zgradpulse(gzlvl5*1.2,gt5);
delay(gstab);
decphase(t5);
dec2phase(zero);
dec2rgpulse(pwN,zero,0.0,0.0); /* purge for 15N */
}
zgradpulse(gzlvl3*1.3,gt3);
delay(gstab);
dec2rgpulse(pwN,t1,0.0,0.0); /* read for 15N */
delay(tau1);
decshaped_pulse("offC3",pw180offca,t5,0.0,0.0);
delay((1-kappa)*tau1);
zgradpulse(gzlvl1,gt1);
delay(gstab);
dec2phase(zero);
dec2rgpulse(2.0*pwN,zero,0.0,0.0);
delay(gt1 + gstab + (4.0/PI)*pwN + WFG_START_DELAY + pw180offca - kappa*tau1);
sim3pulse(pw,0.0,0.0,t2,zero,zero,rof1,rof1); /* Pulse for 1H */
zgradpulse(gzlvl5,gt5);
delay(gstab);
delay(tauhn - gt5 - gstab); /* delay=1/4J (NH) */
sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1);
txphase(zero);
dec2phase(zero);
delay(tauhn - gt5 - gstab); /* 1/4J (NH) */
zgradpulse(gzlvl5,gt5);
delay(gstab);
txphase(one);
sim3pulse(pw,0.0,pwN,one,zero,zero,rof1,rof1); /* 90 for 1H and 15N */
obspower(tpwrs); obspwrf(tpwrsf_u);
shaped_pulse("H2Osinc_u", pwHs, t2, rof1, 0.0);
obspower(tpwr); obspwrf(4095.0);
dec2phase(zero);
zgradpulse(gzlvl5*0.8,gt5);
delay(gstab);
delay(tauhn -gt5 -gstab -2.0*POWER_DELAY -pwHs -WFG_START_DELAY); /* delay=1/4J (NH) */
sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1);
txphase(zero);
dec2phase(t3);
delay(tauhn - gt5 - gstab - 2.0*POWER_DELAY); /* 1/4J (NH) */
zgradpulse(gzlvl5*0.8,gt5);
delay(gstab);
dec2rgpulse(pwN,t3,0.0,0.0);
decpower(dpwr);
dec2power(dpwr2);
delay((gt1/10.0) + gstab - 2.0*POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, 0.0);
zgradpulse(gzlvl2*icosel,gt1*0.1);
delay(gstab);
/* acquire data */
setreceiver(t7);
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES; parameters used in the last half of the */
/* sequence are declared and initialized as 0.0 in bionmr.h, and */
/* reinitialized below */
char f2180[MAXSTR],
cbdec[MAXSTR],
cbdecseq[MAXSTR]; /* shape for selective CB inversion */
int t1_counter, t2_counter,
ni = getval("ni"), ni2 = getval("ni2");
double
d2_init=0.0, d3_init=0.0,
tau1, tau2, tau3, /* t1,t2,t3 delay */
t1a, t1b, t1c, sheila_1,
t2a, t2b, t2c, sheila_2,
tauCH = getval("tauCH"), /* 1/4J delay for CH */
tauCH_1,
timeTN = getval("timeTN"), /* ~ 12 ms for N evolution and 1JNCa transfer */
epsilon = 1.05e-3, /* 0.7*1/4J delay for CHn */
epsilon_1,
tauCaCO = getval("tauCaCO"), /* 1/4J delay for CaCO, 4.5ms */
tauNCO = getval("tauNCO"), /* 1/4J delay for NCO, 17.0ms */
Hali_offset = getval("Hali_offset"),
cbpwr, /* power level for selective CB inversion */
cbdmf, /* pulse width for selective CB inversion */
cbres,
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
dpwr2 = getval("dpwr2"), /* power for N15 decoupling */
swH = getval("swH"), swC = getval("swC"), swTilt,
angle_H = getval("angle_H"), angle_C, cos_H, cos_C,
pwCa90,
pwCa180, /* length of square 180 on Ca */
pwCO90,
pwCO180, /* length of sinc 180 on CO */
pwZ,
phi7cal = getval("phi7cal"), /* small phase correction for 90 CO pulse */
ncyc = getval("ncyc"), /* no. of cycles of DIPSI-3 decoupling on Cab */
waltzB1 = getval("waltzB1"), /* H1 decoupling strength in Hz for DIPSI-2 */
sw1 = getval("sw1"), sw2 = getval("sw2"),
gstab= getval("gstab"),
gt0 = getval("gt0"), gzlvl0 = getval("gzlvl0"),
gt1 = getval("gt1"), gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt3 = getval("gt3"), gzlvl3 = getval("gzlvl3"),
gt4 = getval("gt4"), gzlvl4 = getval("gzlvl4"),
gt5 = getval("gt5"), gzlvl5 = getval("gzlvl5"),
gt6 = getval("gt6"), gzlvl6 = getval("gzlvl6"),
gt7 = getval("gt7"), gzlvl7 = getval("gzlvl7"),
gt8 = getval("gt8"), gzlvl8 = getval("gzlvl8"),
gt9 = getval("gt9"), gzlvl9 = getval("gzlvl9");
getstr("f2180",f2180);
widthHd = 2.069*(waltzB1/sfrq); /* produces same B1 as gc_co_nh.c */
cbpwr = getval("cbpwr"); cbdmf = getval("cbdmf"); cbres = getval("cbres");
getstr("cbdecseq", cbdecseq); getstr("cbdec", cbdec);
/* LOAD PHASE TABLE */
settable(t2,1,phx); settable(t3,2,phi3); settable(t4,1,phx);
settable(t8,1,phx); settable(t9,8,phi9); settable(t10,1,phx);
settable(t11,1,phy); settable(t12,4,rec);
/* INITIALIZE VARIABLES */
kappa = 5.4e-3; lambda = 2.4e-3;
/* get calculated pulse lengths of shaped C13 pulses */
pwCa90 = c13pulsepw("ca", "co", "square", 90.0);
pwCa180 = c13pulsepw("ca", "co", "square", 180.0);
pwCO90 = c13pulsepw("co", "ca", "sinc", 90.0);
pwCO180 = c13pulsepw("co", "ca", "sinc", 180.0);
/* pwZ: the bigger of pwN*2.0 and pwCa180 */
if (pwN*2.0 > pwCa180) pwZ=pwN*2.0; else pwZ=pwCa180;
/* CHECK VALIDITY OF PARAMETER RANGES */
if ( 0.5*ni2*1/(sw2) > timeTN - WFG3_START_DELAY)
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN - WFG3_START_DELAY)*2.0*sw2))); psg_abort(1);}
if ( dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' )
{ printf("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1);}
if ( dm2[A] == 'y' || dm2[B] == 'y' )
{ printf("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1);}
if ( dm3[A] == 'y' || dm3[B] == 'y' || dm3[C] == 'y' )
{ printf("incorrect dec3 decoupler flags! Should be 'nnn' ");
psg_abort(1);}
if ( dpwr2 > 46 )
{ printf("dpwr2 too large! recheck value "); psg_abort(1);}
if ( pw > 20.0e-6 )
{ printf(" pw too long ! recheck value "); psg_abort(1);}
if ( pwN > 100.0e-6 )
{ printf(" pwN too long! recheck value "); psg_abort(1);}
if ( pwC > 20.0*600.0/sfrq )
{ printf("increase pwClvl so that pwC < 20*600/sfrq"); psg_abort(1);}
/**********************************************************************/
/* Calculate t1_counter from sw1 as a generic control of the sequence */
/* Make sure sw1 is not zero */
/**********************************************************************/
angle_C = 90.0 - angle_H;
if ( (angle_H < 0) || (angle_H > 90) )
{ printf ("angle_H must be between 0 and 90 degree.\n"); psg_abort(1); }
if ( sw1 < 1.0 )
{ printf ("Please set sw1 to a non-zero value.\n"); psg_abort(1); }
cos_H = cos (PI*angle_H/180);
cos_C = cos (PI*angle_C/180);
swTilt = swH * cos_H + swC * cos_C;
if (ix ==1)
{
printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
printf ("PR(4,3)D intra_cbd_hccnh\n");
printf ("Set ni2=1, phase=1,2,3,4 and phase2=1,2 \n");
printf ("Maximum Sweep Width: \t\t %f Hz\n", swTilt);
printf ("Angle_H:\t%6.2f degree \t\tAngle_C:\t%f degree\n", angle_H, angle_C);
}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 1) {;} /* CC */
else if (phase1 == 2) { tsadd(t2, 1, 4); } /* SC */
else if (phase1 == 3) { tsadd(t3, 1, 4); } /* CS */
else if (phase1 == 4) { tsadd(t2, 1, 4); tsadd(t3,1,4); } /* SS */
if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if (t1_counter % 2) { tsadd(t2,2,4); tsadd(t12,2,4); }
tau1 = 1.0 * t1_counter * cos_H / swTilt;
tau2 = 1.0 * t1_counter * cos_C / swTilt;
tau1 = tau1/2.0; tau2 = tau2/2.0;
if (ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if (t2_counter % 2) { tsadd(t8,2,4); tsadd(t12,2,4); }
/* Set up f2180 */
tau3 = d3;
if ((f2180[A] == 'y') && (ni2 > 1.0))
{ tau3 += ( 1.0 / (2.0*sw2) ); if(tau3 < 0.2e-6) tau3 = 0.0; }
tau3 = tau3/2.0;
/* Hyperbolic sheila_1 seems superior */
tauCH_1 = tauCH - gt3 - 2.0*GRADIENT_DELAY - 5.0e-5;
if ((ni-1)/(2.0*swTilt/cos_H) > 2.0*tauCH_1)
{
if (tau1 > 2.0*tauCH_1) sheila_1 = tauCH_1;
else if (tau1 > 0) sheila_1 = 1.0/(1.0/tau1+1.0/tauCH_1 - 1.0/(2.0*tauCH_1));
else sheila_1 = 0.0;
}
else
{
if (tau1 > 0) sheila_1 = 1.0/(1.0/tau1 + 1.0/tauCH_1 - 2.0*swTilt/cos_H/((double)(ni-1)));
else sheila_1 = 0.0;
}
/* The following check fixes the phase distortion of certain tilts */
if (sheila_1 > tau1) sheila_1 = tau1;
if (sheila_1 > tauCH_1) sheila_1 =tauCH_1;
t1a = tau1 + tauCH_1;
t1b = tau1 - sheila_1;
t1c = tauCH_1 - sheila_1;
/* subtract unavoidable delays from epsilon */
epsilon_1 = epsilon - pwCO180 - WFG_START_DELAY - 4.0e-6 - POWER_DELAY
- PWRF_DELAY - gt5 - 2.0*GRADIENT_DELAY - 5.0e-5;
if ((ni-1)/(2.0*swTilt/cos_C) > 2.0*epsilon_1)
{
if (tau2 > 2.0*epsilon_1) sheila_2 = epsilon_1;
else if (tau2 > 0) sheila_2 = 1.0/(1.0/tau2+1.0/epsilon_1 - 1.0/(2.0*epsilon_1));
else sheila_2 = 0.0;
}
else
{
if (tau2 > 0) sheila_2 = 1.0/(1.0/tau2 + 1.0/epsilon_1 - 2.0*swTilt/cos_C/((double)(ni-1)));
else sheila_2 = 0.0;
}
/* The following check fixes the phase distortion of certain tilts */
if (sheila_2 > tau2) sheila_2 = tau2;
if (sheila_2 > epsilon_1) sheila_2 = epsilon_1;
t2a = tau2;
t2b = tau2 - sheila_2;
t2c = epsilon_1 - sheila_2;
/* BEGIN PULSE SEQUENCE */
status(A);
delay(d1);
rcvroff();
obsoffset(tof - Hali_offset); obspower(tpwr); obspwrf(4095.0);
set_c13offset("gly"); decpower(pwClvl); decpwrf(4095.0);
dec2offset(dof2); dec2power(pwNlvl); dec2pwrf(4095.0);
txphase(t2); delay(1.0e-5);
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 and C13 magnetization*/
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl0, gt0);
delay(gstab);
rgpulse(pw, t2, 0.0, 0.0); /* 1H pulse excitation */
/* point a */
txphase(zero);
decphase(zero);
zgradpulse(gzlvl3, gt3); /* 2.0*GRADIENT_DELAY */
delay(gstab);
delay(t1a - 2.0*pwC);
decrgpulse(2.0*pwC, zero, 0.0, 0.0);
delay(t1b);
rgpulse(2.0*pw, zero, 0.0, 0.0);
zgradpulse(gzlvl3, gt3); /* 2.0*GRADIENT_DELAY */
txphase(one);
delay(gstab);
delay(t1c);
/* point b */
rgpulse(pw, one, 0.0, 0.0);
obsoffset(tof);
zgradpulse(gzlvl4, gt4);
decphase(t3);
delay(gstab);
decrgpulse(pwC, t3, 0.0, 0.0);
decphase(zero);
delay(t2a);
/* WFG_START_DELAY+POWER_DELAY+PWRF_DELAY */
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0); /* pwCO180 */
zgradpulse(gzlvl5, gt5); /* 2.0*GRADIENT_DELAY */
delay(gstab);
delay(epsilon_1 - 2.0*pw);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(t2b);
c13pulse("gly", "co", "square", 180.0, zero, 2.0e-6, 0.0);
zgradpulse(gzlvl5, gt5); /* 2.0*GRADIENT_DELAY */
delay(gstab);
delay(t2c);
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0);
delay(2.0*pwC/PI); /* Compensation for pwC */
delay(WFG_START_DELAY+PWRF_DELAY + POWER_DELAY);
decrgpulse(0.5e-3, zero, 2.0e-6, 0.0); /* 0.5 ms trim(X) pulse */
c13decouple("gly", "DIPSI3", 120.0, ncyc); /* PRG_STOP_DELAY */
/* ========= Begin Ca(i)x --> Ca(i)zN(i)z ================*/
if (cbdec[A] == 'y')
{ decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(tauCaCO*2.0 - pwCO90*0.6366 - 2.0e-6 - PRG_START_DELAY
- 2*PRG_STOP_DELAY - WFG_START_DELAY - POWER_DELAY - PWRF_DELAY );
decoff();
decprgoff();
}
else
{ delay(tauCaCO*2.0 - pwCO90*0.6366 - 2.0e-6
- PRG_STOP_DELAY - WFG_START_DELAY - POWER_DELAY - PWRF_DELAY );
}
c13pulse("co", "ca", "sinc", 90.0, zero, 2.0e-6, 2.0e-6);
if (cbdec[A] == 'y')
{ decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(tauNCO - pwCO90*0.6366 - pwCO180 - pwZ/2.0 - 8.0e-6
- PRG_START_DELAY - PRG_STOP_DELAY
- WFG_START_DELAY - WFG3_START_DELAY - 4.0*POWER_DELAY - 4.0*PWRF_DELAY);
decoff();
decprgoff();
}
else
{
zgradpulse(gzlvl6, gt6);
delay(gstab);
delay(tauNCO - pwCO90*0.6366 - pwCO180 - pwZ/2.0 - 8.0e-6
- gt6 - gstab - 2.0*GRADIENT_DELAY - WFG_START_DELAY
- WFG3_START_DELAY - 4.0*POWER_DELAY - 4.0*PWRF_DELAY);
}
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 2.0e-6);
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
if (cbdec[A] == 'y')
{ decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(tauNCO - pwZ/2.0 - pwCO180 - pwCO90*0.6366 - 8.0e-6
- PRG_START_DELAY - PRG_STOP_DELAY
- 2*WFG_START_DELAY - 4.0*POWER_DELAY - 4.0*PWRF_DELAY - SAPS_DELAY);
decoff();
decprgoff();
}
else
{
zgradpulse(gzlvl6, gt6);
delay(gstab);
delay(tauNCO - pwZ/2.0 - pwCO180 - pwCO90*0.6366 - 8.0e-6
- gt6 - gstab - 2.0*GRADIENT_DELAY - 2*WFG_START_DELAY
- 4.0*POWER_DELAY - 4.0*PWRF_DELAY - SAPS_DELAY);
}
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 2.0e-6); /* BSP */
initval(phi7cal, v7); decstepsize(1.0);
decphase(one); dcplrphase(v7); /* SAPS_DELAY */
c13pulse("co", "ca", "sinc", 90.0, one, 2.0e-6, 2.0e-6);
dcplrphase(zero);
if (cbdec[A] == 'y')
{ decpower(cbpwr);
decphase(zero);
decprgon(cbdecseq,1/cbdmf,cbres);
decon();
delay(tauCaCO*2.0 -pwCO90*0.6366 - pwCa90*0.6366 - 4.0e-6
- PRG_START_DELAY - PRG_STOP_DELAY
- WFG_START_DELAY - 2.0*POWER_DELAY - 2.0*PWRF_DELAY);
decoff();
decprgoff();
}
else
{ delay(tauCaCO*2.0 -pwCO90*0.6366 - pwCa90*0.6366 - 4.0e-6
- WFG_START_DELAY - 2.0*POWER_DELAY - 2.0*PWRF_DELAY);
}
decphase(one);
c13pulse("ca", "co", "square", 90.0, one, 2.0e-6, 2.0e-6);
/* ========= End Ca(i)x --> Ca(i)zN(i)z ================*/
zgradpulse(gzlvl7, gt7);
delay(gstab);
h1decon("DIPSI2", widthHd, 0.0);
/*POWER_DELAY+PWRF_DELAY+PRG_START_DELAY */
/* xxxxxxxxxxxx TRIPLE RESONANCE NH EVOLUTION & SE TRAIN xxxxxxxxxxxx */
dec2rgpulse(pwN, t8, 2.0e-6, 2.0e-6);
decphase(zero); dec2phase(t9);
delay(timeTN - WFG3_START_DELAY - tau3);
/* WFG3_START_DELAY */
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, t9, 2.0e-6, 2.0e-6);
dec2phase(t10);
if (tau3 > kappa + PRG_STOP_DELAY)
{
delay(timeTN - pwCO180 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0*PWRF_DELAY - 2.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0); /* pwCO180 */
delay(tau3 - kappa - PRG_STOP_DELAY - POWER_DELAY - PWRF_DELAY);
h1decoff(); /* POWER_DELAY+PWRF_DELAY+PRG_STOP_DELAY */
txphase(zero);
delay(kappa - gt1 - 2.0*GRADIENT_DELAY - gstab);
zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
delay(gstab);
}
else if (tau3 > (kappa - pwCO180 - WFG_START_DELAY - 2.0*POWER_DELAY - 2.0e-6))
{
delay(timeTN + tau3 - kappa -PRG_STOP_DELAY -POWER_DELAY -PWRF_DELAY);
h1decoff(); /* POWER_DELAY+PWRF_DELAY+PRG_STOP_DELAY */
txphase(zero); /* WFG_START_DELAY + 2.0*POWER_DELAY */
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0); /* pwCO180 */
delay(kappa - pwCO180 - WFG_START_DELAY - 2.0*POWER_DELAY - 1.0e-6 - gt1
- 2.0*GRADIENT_DELAY - gstab);
zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
delay(gstab);
}
else if (tau3 > gt1 + 2.0*GRADIENT_DELAY + 1.0e-4)
{
delay(timeTN + tau3 - kappa -PRG_STOP_DELAY -POWER_DELAY -PWRF_DELAY);
h1decoff(); /* POWER_DELAY+PWRF_DELAY+PRG_STOP_DELAY */
txphase(zero);
delay(kappa - tau3 - pwCO180 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0); /* pwCO180 */
delay(tau3 - gt1 - 2.0*GRADIENT_DELAY - gstab);
zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
delay(gstab);
}
else
{
delay(timeTN + tau3 - kappa -PRG_STOP_DELAY -POWER_DELAY -PWRF_DELAY);
h1decoff(); /* POWER_DELAY+PWRF_DELAY+PRG_STOP_DELAY */
txphase(zero);
delay(kappa - tau3 - pwCO180 - WFG_START_DELAY - 2.0*POWER_DELAY
- 2.0e-6 - gt1 - 2.0*GRADIENT_DELAY - gstab);
zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
delay(gstab);
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 0.0); /* pwCO180 */
delay(tau3);
}
sim3pulse(pw, 0.0, pwN, zero, zero, t10, 0.0, 0.0);
txphase(zero); dec2phase(zero);
zgradpulse(gzlvl8, gt8);
delay(lambda - 1.3*pwN - gt8);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl8, gt8);
txphase(one); dec2phase(t11);
delay(lambda - 1.3*pwN - gt8);
sim3pulse(pw, 0.0, pwN, one, zero, t11, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl9, gt9);
delay(lambda - 1.3*pwN - gt9);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
zgradpulse(gzlvl9, gt9);
delay(lambda - 0.65*(pw + pwN) - gt9);
rgpulse(pw, zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 - 0.3*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
delay(1.0e-4);
rgpulse(2.0*pw, zero, 0.0, 0.0);
dec2power(dpwr2); /* POWER_DELAY */
zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
statusdelay(C, gstab);
setreceiver(t12);
}
pulsesequence()
{
char
shname1[MAXSTR],
f1180[MAXSTR],
f2180[MAXSTR],
SE_flg[MAXSTR];
int icosel = 0,
t1_counter,
t2_counter,
ni2 = getval("ni2"),
phase;
double d2_init=0.0,
d3_init=0.0,
pwS1,pwS2,pwS3,pwS4,pwS5,pwS6,pwS7,
lambda = getval("lambda"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gzlvl6 = getval("gzlvl6"),
gzlvl5 = getval("gzlvl5"),
gt1 = getval("gt1"),
gt6 = getval("gt6"),
gt5 = getval("gt5"),
gstab = getval("gstab"),
shlvl1 = getval("shlvl1"),
shpw1 = getval("shpw1"),
pwClvl = getval("pwClvl"),
pwNlvl = getval("pwNlvl"),
pwN = getval("pwN"),
d2 = getval("d2"),
timeTN = getval("timeTN"),
timeTN1,
Delta,
tauNCO = getval("tauNCO"),
tauC = getval("tauC"),
tau1 = getval("tau1"),
tau2 = getval("tau2"),
taunh = getval("taunh");
getstr("shname1", shname1);
getstr("SE_flg",SE_flg);
getstr("f1180",f1180);
getstr("f2180",f2180);
phase = (int) (getval("phase") + 0.5);
settable(t1,2,phi1);
settable(t3,4,phi3);
settable(t10,1,phi10);
settable(t12,4,phi12);
settable(t13,4,phi13);
/* INITIALIZE VARIABLES */
timeTN1= timeTN-tauC;
Delta = timeTN-tauC-tauNCO;
pwS1 = c13pulsepw("ca", "co", "square", 90.0);
pwS2 = c13pulsepw("ca", "co", "square", 180.0);
pwS3 = c13pulsepw("co", "ca", "sinc", 180.0);
pwS7 = c13pulsepw("co", "ca", "sinc", 90.0);
pwS4 = h_shapedpw("eburp2",4.0,3.5,zero, 0.0, 0.0);
pwS5 = h_shapedpw("reburp",4.0,3.5,zero, 0.0, 0.0);
pwS6 = h_shapedpw("pc9f",4.0,3.5,zero, 2.0e-6, 0.0);
if (SE_flg[0] == 'y')
{
if ( ni2*1/(sw2)/2.0 > (timeTN1-Delta-pwS3-pwS4))
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN1-Delta-pwS3-pwS4)*2.0*sw2))); psg_abort(1);}
}
else
{
if ( ni2*1/(sw2)/2.0 > (timeTN1-Delta-pwS3))
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN1-Delta-pwS3)*2.0*sw2))); psg_abort(1);}
}
if (phase == 1) ;
if (phase == 2) tsadd(t1,1,4);
if (SE_flg[0] =='y')
{
if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
else
{
if (phase2 == 2) {tsadd(t3,1,4); icosel = 1;}
}
tau1 = d2;
if((f1180[A] == 'y') )
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1;
tau2 = d3;
if((f2180[A] == 'y') )
{ tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.0; }
tau2 = tau2;
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t1,2,4); tsadd(t12,2,4); tsadd(t13,2,4); }
if( ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); tsadd(t13,2,4); }
status(A);
decpower(pwClvl);
dec2power(pwNlvl);
set_c13offset("co");
zgradpulse(gzlvl6, gt6);
delay(d1-gt6 +1.0e-4);
lk_hold();
rcvroff();
h_shapedpulse("pc9f",4.0,3.5,zero, 2.0e-6, 0.0);
delay(lambda-pwS5*0.5-pwS6*0.4);
h_sim3shapedpulse("reburp",4.0,3.5,0.0,2.0*pwN, one, zero, zero, 0.0, 0.0);
delay(lambda-pwS5*0.5-pwS6*0.4);
h_shapedpulse("pc9f_",4.0,3.5,one, 2.0e-6, 0.0);
obspower(shlvl1);
/**************************************************************************/
/* xxxxxxxxxxxxxxxxxxxxxx N-> CA transfer xxxxxxxxxxxxxxxxxx */
/**************************************************************************/
dec2rgpulse(pwN,zero,0.0,0.0);
delay(timeTN1);
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(Delta);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(timeTN1-Delta-pwS3+pwN*4.0/3.0);
c13pulse("co", "ca", "sinc", 90.0, zero, 0.0, 0.0);
delay(tauC);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(tauC-taunh*0.5-shpw1+pwS2+pwS7);
shaped_pulse(shname1,shpw1,zero,0.0,0.0);
delay(taunh*0.5-pwS2-pwS7);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
c13pulse("co", "ca", "sinc", 90.0, one, 0.0, 0.0);
dec2rgpulse(pwN,zero,0.0,0.0);
/**************************************************************************/
/* xxxxxxxxxxxxxxxxxxxxxx 13CA EVOLUTION xxxxxxxxxxxxxxxxxx */
/**************************************************************************/
set_c13offset("ca");
c13pulse("ca", "co", "square", 90.0, t1, 2.0e-6, 0.0);
delay(tau1*0.5);
sim3_c13pulse(shname1, "co", "ca", "sinc", "", shpw1, 180.0, 2.0*pwN,
zero, zero, zero, 0.0, 0.0);
delay(tau1*0.5);
c13pulse("ca", "co", "square", 180.0, zero, 0.0, 0.0);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 0.0,
zero, zero, zero, 0.0, 0.0);
if (pwN*2.0 > pwS3) delay(pwN*2.0-pwS3);
c13pulse("ca", "co", "square", 90.0, zero, 0.0, 0.0);
set_c13offset("co");
/**************************************************************************/
/**************************************************************************/
/**************************************************************************/
obspower(shlvl1);
dec2rgpulse(pwN,t3,0.0,0.0);
c13pulse("co", "ca", "sinc", 90.0, one, 0.0, 0.0);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
delay(tauC);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
delay(tauC-taunh*0.5-shpw1);
shaped_pulse(shname1,shpw1,zero,0.0,0.0);
delay(taunh*0.5);
c13pulse("co", "ca", "sinc", 90.0, zero, 0.0, 0.0);
/**************************************************************************/
if (SE_flg[0] == 'y')
{
delay(tau2*0.5);
shaped_pulse(shname1,shpw1,two,0.0,0.0);
delay(timeTN1+pwN*4.0/3.0-shpw1-gt1-1.0e-4);
zgradpulse(-gzlvl1, gt1);
delay(1.0e-4);
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(Delta);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(timeTN1-tau2*0.5-pwS4-Delta-pwS3);
h_shapedpulse("eburp2",4.0,3.5,zero, 2.0e-6, 0.0);
dec2rgpulse(pwN, t10, 0.0, 0.0);
}
else
{
delay(tau2*0.5);
shaped_pulse(shname1,shpw1,two,0.0,0.0);
delay(timeTN1+pwN*4.0/3.0-shpw1);
sim3_c13pulse("", "ca", "co", "square", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(Delta);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
delay(timeTN1-tau2*0.5-Delta-pwS3);
dec2rgpulse(pwN, zero, 0.0, 0.0);
}
/**************************************************************************/
if (SE_flg[0] == 'y')
{
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
h_sim3shapedpulse("reburp",4.0,3.5,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
dec2rgpulse(pwN, one, 0.0, 0.0);
h_shapedpulse("eburp2_",4.0,3.5,one, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
delay(lambda-pwS4*0.5-pwS6*0.4);
h_sim3shapedpulse("reburp",4.0,3.5,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
delay(lambda-pwS4*0.5-pwS6*0.4);
h_shapedpulse("eburp2",4.0,3.5,zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab + 2.0*GRADIENT_DELAY + POWER_DELAY);
h_shapedpulse("reburp",4.0,3.5,zero, 0.0, 0.0);
zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
}
else
{
h_shapedpulse("eburp2",4.0,3.5,zero, 2.0e-6, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
h_sim3shapedpulse("reburp",4.0,3.5,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5-POWER_DELAY-1.0e-4);
}
dec2power(dpwr2); /* POWER_DELAY */
lk_sample();
if (SE_flg[0] == 'y')
setreceiver(t13);
else
setreceiver(t12);
rcvron();
statusdelay(C,1.0e-4 );
}
void pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
f2180[MAXSTR], /* Flag to start t2 @ halfdwell */
mag_flg[MAXSTR], /* magic-angle coherence transfer gradients */
TROSY[MAXSTR]; /* do TROSY on N15 and H1 */
int icosel, /* used to get n and p type */
t1_counter, /* used for states tppi in t1 */
t2_counter, /* used for states tppi in t2 */
PRexp, /* projection-reconstruction flag */
ni = getval("ni"),
ni2 = getval("ni2");
double tau1, /* t1 delay */
tau2, /* t2 delay */
tauCH = getval("tauCH"), /* 1/4J delay for CH */
zeta = getval("zeta"), /* zeta delay, 0.006 for 1D, 0.011 for 2D*/
timeTN = getval("timeTN"), /* constant time for 15N evolution */
timeCH = 1.1e-3, /* other delays */
timeAB = 3.3e-3,
kappa = 5.4e-3,
lambda = 2.4e-3,
csa, sna,
pra = M_PI*getval("pra")/180.0,
bw, ofs, ppm, /* temporary Pbox parameters */
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rf0, /* maximum fine power when using pwC pulses */
/* 90 degree pulse at Cab(46ppm), first off-resonance null at CO (174ppm) */
pwC1, /* 90 degree pulse length on C13 at rf1 */
rf1, /* fine power for 5.1 kHz rf for 600MHz magnet */
/* 180 degree pulse at Cab(46ppm), first off-resonance null at CO(174ppm) */
pwC2, /* 180 degree pulse length at rf2 */
rf2, /* fine power for 11.4 kHz rf for 600MHz magnet */
/* the following pulse lengths for SLP pulses are automatically calculated */
/* by the macro "biocal". SLP pulse shapes, "offC7" etc are called */
/* directly from your shapelib. */
pwC7, /* 180 degree selective sinc pulse on CO(174ppm) */
rf7, /* fine power for the pwC7 ("offC7") pulse */
compH = getval("compH"), /* adjustment for C13 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
pwH, /* H1 90 degree pulse length at tpwr1 */
tpwr1, /* 9.2 kHz rf magnet for DIPSI-2 */
DIPSI2time, /* total length of DIPSI-2 decoupling */
ncyc_dec,
waltzB1=getval("waltzB1"),
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
sw2 = getval("sw2"),
gt1 = getval("gt1"), /* coherence pathway gradients */
gzcal = getval("gzcal"), /* g/cm to DAC conversion factor */
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gstab = getval("gstab"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl6 = getval("gzlvl6");
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("mag_flg",mag_flg);
getstr("TROSY",TROSY);
csa = cos(pra);
sna = sin(pra);
/* LOAD PHASE TABLE */
settable(t3,1,phx);
settable(t4,1,phx);
if (TROSY[A]=='y')
{settable(t8,2,phi8T);
settable(t9,1,phx);
settable(t10,1,phy);
settable(t11,1,phx);
settable(t12,2,recT);}
else
{settable(t8,2,phi8);
settable(t9,8,phi9);
settable(t10,1,phx);
settable(t11,1,phy);
settable(t12,4,rec);}
/* INITIALIZE VARIABLES */
if( dpwrf < 4095 )
{ printf("reset dpwrf=4095 and recalibrate C13 90 degree pulse");
psg_abort(1); }
/* set zeta to 6ms for 1D spectral check, otherwise it will be the */
/* value in the dg2 parameter set (about 11ms) for 2D/13C and 3D work */
if (ni>1) zeta = zeta;
else zeta = 0.006;
/* maximum fine power for pwC pulses */
rf0 = 4095.0;
setautocal(); /* activate auto-calibration flags */
if (autocal[0] == 'n')
{
/* 90 degree pulse on Cab, null at CO 128ppm away */
pwC1 = sqrt(15.0)/(4.0*128.0*dfrq);
rf1 = 4095.0*(compC*pwC/pwC1);
rf1 = (int) (rf1 + 0.5);
/* 180 degree pulse on Cab, null at CO 128ppm away */
pwC2 = sqrt(3.0)/(2.0*128.0*dfrq);
rf2 = (4095.0*compC*pwC*2.0)/pwC2;
rf2 = (int) (rf2 + 0.5);
if( rf2 > 4295 )
{ printf("increase pwClvl"); psg_abort(1);}
if(( rf2 < 4296 ) && (rf2>4095)) rf2=4095;
/* 180 degree one-lobe sinc pulse on CO, null at Ca 118m away */
pwC7 = getval("pwC7");
rf7 = (compC*4095.0*pwC*2.0*1.65)/pwC7; /* needs 1.65 times more */
rf7 = (int) (rf7 + 0.5); /* power than a square pulse */
}
else /* if autocal = 'y'(yes), 'q'(quiet), r(read), or 's'(semi) */
{
if(FIRST_FID) /* call Pbox */
{
ppm = getval("dfrq");
bw = 128.0*ppm; ofs = bw;
offC1 = pbox_Rcal("square90n", bw, compC*pwC, pwClvl);
offC2 = pbox_Rcal("square180n", bw, compC*pwC, pwClvl);
bw = 118.0*ppm;
offC7 = pbox_make("offC7", "sinc180n", bw, ofs, compC*pwC, pwClvl);
if (dm3[B] == 'y') H2ofs = 3.2;
ofs_check(H1ofs, C13ofs, N15ofs, H2ofs);
}
pwC1 = offC1.pw; rf1 = offC1.pwrf;
pwC2 = offC2.pw; rf2 = offC2.pwrf;
pwC7 = offC7.pw; rf7 = offC7.pwrf;
/* Example of semi-automatic calibration - use parameters, if they exist :
if ((autocal[0] == 's') || (autocal[1] == 's'))
{
if (find("pwC1") > 0) pwC1 = getval("pwC1");
if (find("rf1") > 0) rf1 = getval("rf1");
}
*/
}
/* power level and pulse times for DIPSI 1H decoupling */
DIPSI2time = 2.0*zeta + 2.0*timeTN - 5.4e-3 + pwC1 + 5.0*pwN + gt3 + 5.0e-5 + 2.0*GRADIENT_DELAY + 3.0*POWER_DELAY;
pwH=1.0/(4.0*waltzB1);
ncyc_dec = (DIPSI2time*90.0)/(pwH*2590.0*4.0);
ncyc_dec = (int) (ncyc_dec +0.5);
pwH = (DIPSI2time*90.0)/(ncyc_dec*2590.0*4.0); /* adjust pwH */
tpwr1 = 4095.0*(compH*pw/pwH);
tpwr1 = (int) (2.0*tpwr1 + 0.5); /* x2 because obs atten will be reduced by 6dB */
/* CHECK VALIDITY OF PARAMETER RANGES */
if ( 0.5*ni*1/(sw1) > timeAB - gt4 - WFG_START_DELAY - pwC7 )
{ printf(" ni is too big. Make ni equal to %d or less.\n",
((int)((timeAB - gt4 - WFG_START_DELAY - pwC7)*2.0*sw1))); psg_abort(1);}
PRexp = 0;
if((pra > 0.0) && (pra < 90.0)) PRexp = 1;
if (PRexp)
{
if( 0.5*ni*sna/sw1 > timeTN - WFG3_START_DELAY)
{ printf(" ni is too big. Make ni equal to %d or less.\n",
((int)((timeTN - WFG3_START_DELAY)*2.0*sw1/sna))); psg_abort(1);}
}
else
{
if ( 0.5*ni2*1/(sw2) > timeTN - WFG3_START_DELAY)
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN - WFG3_START_DELAY)*2.0*sw2))); psg_abort(1);}
}
if ( dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' )
{ printf("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1);}
if ( dm2[A] == 'y' || dm2[B] == 'y' )
{ printf("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1);}
if ( dm3[A] == 'y' || dm3[C] == 'y' )
{ printf("incorrect dec3 decoupler flags! Should be 'nyn' or 'nnn' ");
psg_abort(1);}
if ( dpwr2 > 50 )
{ printf("dpwr2 too large! recheck value "); psg_abort(1);}
if ( pw > 20.0e-6 )
{ printf(" pw too long ! recheck value "); psg_abort(1);}
if ( pwN > 100.0e-6 )
{ printf(" pwN too long! recheck value "); psg_abort(1);}
if ( TROSY[A]=='y' && dm2[C] == 'y')
{ text_error("Choose either TROSY='n' or dm2='n' ! "); psg_abort(1);}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 2) tsadd(t3,1,4);
if (TROSY[A]=='y')
{ if (phase2 == 2) icosel = +1;
else {tsadd(t4,2,4); tsadd(t10,2,4); icosel = -1;}
}
else { if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
/* Set up f1180 */
if(PRexp) /* set up Projection-Reconstruction experiment */
tau1 = d2*csa;
else
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Set up f2180 */
if(PRexp)
tau2 = d2*sna;
else
{
tau2 = d3;
if((f2180[A] == 'y') && (ni2 > 1.0))
{ tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.0; }
}
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); }
if( ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{ tsadd(t8,2,4); tsadd(t12,2,4); }
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
delay(d1);
if ( dm3[B] == 'y' )
{ lk_hold(); lk_sampling_off();} /*freezes z0 correction, stops lock pulsing*/
rcvroff();
obspower(tpwr);
decpower(pwClvl);
dec2power(pwNlvl);
decpwrf(rf0);
obsoffset(tof);
txphase(zero);
delay(1.0e-5);
if (TROSY[A] == 'n')
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 and C13 magnetization*/
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
if (TROSY[A] == 'n')
dec2rgpulse(pwN, one, 0.0, 0.0);
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
delay(5.0e-4);
rgpulse(pw,zero,0.0,0.0); /* 1H pulse excitation */
decphase(zero);
zgradpulse(gzlvl0, gt0);
delay(tauCH - gt0);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
txphase(one);
decphase(t3);
zgradpulse(gzlvl0, gt0);
delay(tauCH - gt0);
rgpulse(pw, one, 0.0, 0.0);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
if ( dm3[B] == 'y' ) /* begins optional 2H decoupling */
{
gt4=0.0; /* no gradients during 2H decoupling */
dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6);
dec3unblank();
dec3phase(zero);
delay(2.0e-6);
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
}
decrgpulse(pwC, t3, 0.0, 0.0);
/* point a */
txphase(zero);
decphase(zero);
decpwrf(rf7);
delay(tau1);
/* WFG3_START_DELAY */
sim3shaped_pulse("", "offC7", "", 0.0, pwC7, 2.0*pwN, zero, zero, zero,
0.0, 0.0);
zgradpulse(gzlvl4, gt4);
decpwrf(rf2);
if ( pwC7 > 2.0*pwN)
{delay(timeCH - pwC7 - gt4 - WFG3_START_DELAY - 2.0*pw);}
else
{delay(timeCH - 2.0*pwN - gt4 - WFG3_START_DELAY - 2.0*pw);}
rgpulse(2.0*pw,zero,0.0,0.0);
delay(timeAB - timeCH);
decrgpulse(pwC2, zero, 0.0, 0.0);
zgradpulse(gzlvl4, gt4);
decpwrf(rf7);
delay(timeAB - tau1 - gt4 - WFG_START_DELAY - pwC7 - 2.0e-6);
/* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
decpwrf(rf1); /* point b */
decrgpulse(pwC1, zero, 2.0e-6, 0.0);
obspwrf(tpwr1); obspower(tpwr-6); /* POWER_DELAY */
obsprgon("dipsi2", pwH, 5.0); /* PRG_START_DELAY */
xmtron();
/* point c */
dec2phase(zero);
decpwrf(rf2);
delay(zeta - POWER_DELAY - PRG_START_DELAY);
sim3pulse(0.0, pwC2, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
decpwrf(rf1);
dec2phase(t8);
delay(zeta);
/* point d */
decrgpulse(pwC1, zero, 0.0, 0.0);
if ( dm3[B] == 'y' ) /* turns off 2H decoupling */
{
setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);
dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);
dec3blank();
lk_autotrig(); /* resumes lock pulsing */
}
/* xxxxxxxxxxxxxxxxxx OPTIONS FOR N15 EVOLUTION xxxxxxxxxxxxxxxxxxxxx */
zgradpulse(gzlvl3, gt3);
if (TROSY[A]=='y') { xmtroff(); obsprgoff(); }
delay(2.0e-4);
dec2rgpulse(pwN, t8, 0.0, 0.0);
/* point e */
decpwrf(rf2);
decphase(zero);
dec2phase(t9);
delay(timeTN - WFG3_START_DELAY - tau2);
/* WFG3_START_DELAY */
sim3pulse(0.0, pwC2, 2.0*pwN, zero, zero, t9, 0.0, 0.0);
dec2phase(t10);
decpwrf(rf7);
if (TROSY[A]=='y')
{
if (tau2 > gt1 + 2.0*GRADIENT_DELAY + 1.0e-4)
{
txphase(t4);
delay(timeTN - pwC7 - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(tau2 - gt1 - 2.0*GRADIENT_DELAY - 1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY);
}
else
{
txphase(t4);
delay(timeTN -pwC7 -WFG_START_DELAY -gt1 -2.0*GRADIENT_DELAY -1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(tau2);
}
}
else
{
if (tau2 > kappa)
{
delay(timeTN - pwC7 - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(tau2 - kappa - PRG_STOP_DELAY);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
txphase(t4);
delay(kappa - gt1 - 2.0*GRADIENT_DELAY - 1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY);
}
else if (tau2 > (kappa - pwC7 - WFG_START_DELAY))
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
txphase(t4); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(kappa -pwC7 -WFG_START_DELAY -gt1 -2.0*GRADIENT_DELAY -1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY);
}
else if (tau2 > gt1 + 2.0*GRADIENT_DELAY + 1.0e-4)
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
txphase(t4);
delay(kappa - tau2 - pwC7 - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(tau2 - gt1 - 2.0*GRADIENT_DELAY - 1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY);
}
else
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
txphase(t4);
delay(kappa-tau2-pwC7-WFG_START_DELAY-gt1-2.0*GRADIENT_DELAY-1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspwrf(4095.0); obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - 2.0*POWER_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC7", pwC7, zero, 0.0, 0.0);
delay(tau2);
}
} /* point f */
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
if (TROSY[A]=='y') rgpulse(pw, t4, 0.0, 0.0);
else sim3pulse(pw, 0.0, pwN, t4, zero, t10, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
if (TROSY[A]=='y') delay(lambda - 0.65*(pw + pwN) - gt5);
else delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
txphase(one);
dec2phase(t11);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(pw, 0.0, pwN, one, zero, t11, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl6, gt5);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
zgradpulse(gzlvl6, gt5);
if (TROSY[A]=='y') delay(lambda - 1.6*pwN - gt5);
else delay(lambda - 0.65*pwN - gt5);
if (TROSY[A]=='y') dec2rgpulse(pwN, t10, 0.0, 0.0);
else rgpulse(pw, zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab - 0.5*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, rof1);
dec2power(dpwr2); /* POWER_DELAY */
if (mag_flg[A] == 'y') magradpulse(icosel*gzcal*gzlvl2, gt1/10.0);
else zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
rcvron();
statusdelay(C,1.0e-4 - rof1);
if (dm3[B]=='y') lk_sample();
setreceiver(t12);
}
pulsesequence()
{
char CT_flg[MAXSTR], /* Constant time flag */
shname1[MAXSTR],
shname2[MAXSTR],
shname3[MAXSTR],
f1180[MAXSTR],
Cdecflg[MAXSTR],
Cdecseq[MAXSTR],
grad_flg[MAXSTR]; /*gradient flag */
int t1_counter,
phase;
double d2_init=0.0,
adjust = getval("adjust"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
shlvl1 = getval("shlvl1"),
shlvl2 = getval("shlvl2"),
shlvl3 = getval("shlvl3"),
shdmf2 = getval("shdmf2"),
shpw1 = getval("shpw1"),
shpw2 = getval("shpw2"),
shpw3 = getval("shpw3"),
pwClvl = getval("pwClvl"),
pwC = getval("pwC"),
dpwr = getval("dpwr"),
CT_delay = getval("CT_delay"),
d2 = getval("d2"),
tau1 = getval("tau1"),
tauch = getval("tauch");
getstr("shname1", shname1);
getstr("shname2", shname2);
getstr("shname3", shname3);
getstr("CT_flg", CT_flg);
getstr("grad_flg",grad_flg);
getstr("f1180",f1180);
getstr("Cdecflg",Cdecflg);
getstr("Cdecseq",Cdecseq);
phase = (int) (getval("phase") + 0.5);
settable(t1,2,phi1);
settable(t2,2,phi2);
if (phase == 1) ;
if (phase == 2) tsadd(t1,1,4);
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1;
if (f1180[0] == 'y') tau1 = tau1-pwC*4.0/3.0;
if(CT_flg[0] == 'y')
{
if ( (ni/sw1) > (CT_delay-pwC*8.0/3.0))
{ text_error( " ni is too big. Make ni equal to %d or less.\n",
((int)((CT_delay-pwC*8.0/3.0)*sw1)) ); psg_abort(1); }
}
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t1,2,4); tsadd(t2,2,4); }
status(A);
decpower(pwClvl);
decoffset(dof);
obsoffset(tof);
zgradpulse(gzlvl2, gt2);
lk_sample();
delay(1.0e-4);
delay(d1-gt2);
if (ix < (int)(2.0*ni)) lk_hold(); /*force lock sampling at end of experiment*/
obspower(shlvl1);
shaped_pulse(shname1,shpw1,zero,2.0e-4,2.0e-6);
zgradpulse(gzlvl1, gt1);
delay(1.0e-4);
if (ni == 0)
{
delay(tauch-gt1-1.0e-4-WFG_START_DELAY+pwC*4.0-adjust);
obspower(shlvl2);
shaped_pulse(shname2,shpw2,zero,2.0e-6,2.0e-6);
obspower(shlvl1);
decrgpulse(pwC,t1,0.0,0.0);
decrgpulse(pwC*2.0,zero,0.0,0.0);
decrgpulse(pwC,zero,0.0,0.0);
}
else
{
delay(tauch-gt1-1.0e-4-adjust);
obspower(shlvl2);
status(B);
if(CT_flg[0] == 'y')
{
/*************************************************/
/**** CT EVOLUTION **********/
/*************************************************/
decrgpulse(pwC,t1,0.0,0.0);
delay((CT_delay-tau1)*0.25-pwC*2.0/3.0);
decpower(shlvl3);
decshaped_pulse(shname3,shpw3,zero,0.0,0.0);
delay((CT_delay+tau1)*0.25-shpw2*0.5);
shapedpulse(shname2,shpw2,zero,0.0,0.0);
delay((CT_delay+tau1)*0.25-shpw2*0.5);
decshaped_pulse(shname3,shpw3,zero,0.0,0.0);
decpower(pwClvl);
delay((CT_delay-tau1)*0.25-pwC*2.0/3.0);
decrgpulse(pwC,zero,0.0,0.0);
}
else
{
/*************************************************/
/**** REAL-TIME EVOLUTION **********/
/*************************************************/
if ((tau1) > shpw2)
{
decrgpulse(pwC,t1,0.0,0.0);
if(Cdecflg[0] == 'y')
{
decpower(getval("Cdecpwr"));
decprgon(Cdecseq, 1.0/getval("Cdecdmf"), getval("Cdecres"));
decon();
}
delay((tau1-shpw2)*0.5);
xmtrphase(zero);
xmtron();
obsunblank();
obsprgon(shname2,1/shdmf2,9.0);
delay(shpw2);
obsprgoff();
obsblank();
xmtroff();
delay((tau1-shpw2)*0.5);
if(Cdecflg[0] == 'y')
{
decoff(); decprgoff();
decpower(pwClvl);
}
decrgpulse(pwC,zero,0.0,0.0);
}
else
{
xmtrphase(zero);
xmtron();
obsunblank();
obsprgon(shname2,1/shdmf2,9.0);
delay((shpw2-tau1-pwC*2.0)*0.5);
decrgpulse(pwC,t1,0.0,0.0);
if(Cdecflg[0] == 'y')
{
decpower(getval("Cdecpwr"));
decprgon(Cdecseq, 1.0/getval("Cdecdmf"), getval("Cdecres"));
decon();
delay(tau1);
decoff(); decprgoff();
decpower(pwClvl);
}
else
delay(tau1);
decrgpulse(pwC,zero,0.0,0.0);
delay((shpw2-tau1-pwC*2.0)*0.5);
obsprgoff();
obsblank();
xmtroff();
}
}
obspower(shlvl1);
status(A);
zgradpulse(gzlvl1, gt1);
delay(1.0e-4);
delay(tauch-gt1-1.0e-4-POWER_DELAY);
decpower(dpwr);
status(C);
setreceiver(t2);
}
}
pulsesequence()
{
int t1_counter;
char N15refoc[MAXSTR], /* N15 pulse in middle of t1*/
TROSY[MAXSTR];
double
tau1, tauxh,
gzlvl3=getval("gzlvl3"),
gt3=getval("gt3"),
cor=getval("cor")*1.0e-6,
JCH = getval("JCH"),
pwN = getval("pwN"),
pwNlvl = getval("pwNlvl"),
sw1 = getval("sw1"),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rf0, /* maximum fine power when using pwC pulses */
rfst, /* fine power for the stCall pulse */
compC = getval("compC"); /* adjustment for C13 amplifier compression */
getstr("N15refoc",N15refoc);
getstr("TROSY",TROSY);
/* maximum fine power for pwC pulses (and initialize rfst) */
rf0 = 4095.0; rfst=0.0;
/* 180 degree adiabatic C13 pulse from 0 to 200 ppm */
{rfst = (compC*4095.0*pwC*4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35));
rfst = (int) (rfst + 0.5);
if (( 1.0/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35)) < pwC ) && (ni > 1))
{ text_error( " Not enough C13 RF. pwC must be %f usec or less.\n",
(1.0e6/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35))) ); psg_abort(1); }}
initval(0.0,v1);
initval(3.0,v2);
initval(1.0,v3);
initval(2.0,v4);
/* check validity of parameter range */
if((dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y') )
{
printf("incorrect Dec2 decoupler flags! ");
psg_abort(1);
}
if( dpwr2 > 50)
{
printf("don't fry the probe, dpwr too large! ");
psg_abort(1);
}
/* LOAD VARIABLES */
if (TROSY[A] == 'y')
{settable(t1, 8, phT1);
settable(t2, 8, phT2);
settable(t3, 8, phT3);
settable(t4,16, phi4);
settable(t5, 8, recT);}
else
{settable(t1, 4, phi1);
settable(t2, 2, phi2);
settable(t3, 8, phi3);
settable(t4, 16, phi4);
settable(t5, 8, rec);}
/* INITIALIZE VARIABLES */
tauxh = ((JCH != 0.0) ? 1/(4*(JCH)) : 2.25e-3);
/* Phase incrementation for hypercomplex data */
if ( phase1 == 2 ) /* Hypercomplex in t1 */
{
tsadd(t2, 1, 4);
}
/* calculate modification to phases based on current t1 values
to achieve States-TPPI acquisition */
if(ix == 1)
d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5);
if(t1_counter %2) {
tsadd(t2,2,4);
tsadd(t5,2,4);
}
tau1 = d2;
tau1 = tau1/2.0;
/*sequence starts!!*/
status(A);
obspower(tpwr);
dec2power(pwNlvl);
decpower(pwClvl);
decpwrf(rfst);
delay(d1);
rcvroff();
status(B);
rgpulse(pw, v1, 0.0, 0.0);
zgradpulse(0.3*gzlvl3,gt3);
txphase(zero);
dec2phase(zero);
delay(tauxh-gt3- WFG2_START_DELAY - 0.5e-3 + 70.0e-6); /* delay=1/4J(XH) */
sim3shaped_pulse("","stC200","",2*pw,1.0e-3,0.0,zero,zero,zero,0.0,0.0);
zgradpulse(0.3*gzlvl3,gt3);
decphase(t2);
delay(tauxh-gt3- WFG2_START_DELAY - 0.5e-3 + 70.0e-6 ); /* delay=1/4J(XH) */
if (TROSY[A] == 'y')
{
rgpulse(pw, v3, 0.0,0.0);
zgradpulse(-0.5*gzlvl3,gt3);
decpwrf(rf0); delay(200.0e-6);
decrgpulse(pwC, t2, 0.0, 0.0);
txphase(t1); decphase(zero);
if (tau1>0.0)
{
if ( (N15refoc[A]=='y') && (tau1 > (pwN/2.0 +2.0*pwC/PI) ) )
{delay(tau1 - pwN -2.0*pwC/PI);
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(tau1 - pwN -2.0*pwC/PI);}
else
{ if (tau1>2.0*pwC/PI)
delay(2.0*tau1-4.0*pwC/PI);
else
delay(2.0*tau1);
}
}
rgpulse(pw, t1, 0.0,0.0);
decpwrf(rfst);
zgradpulse(0.3*gzlvl3,gt3);
delay(tauxh-gt3-WFG2_START_DELAY - 0.5e-3 + 70.0e-6);
sim3shaped_pulse("","stC200","",2*pw,1.0e-3,0.0,zero,zero,zero,0.0,0.0); zgradpulse(0.3*gzlvl3,gt3);
delay(tauxh-gt3-WFG2_START_DELAY - 0.5e-3 + 70.0e-6);
sim3pulse(pw,pwC,0.0,two,zero,one,0.0,0.0);
zgradpulse(gzlvl3,gt3);
txphase(v4);
delay(tauxh-gt3-WFG2_START_DELAY - 0.5e-3 + 70.0e-6);
rgpulse(pw*0.231,v4,0.0,0.0);
delay(d3);
rgpulse(pw*0.692,v4,0.0,0.0);
delay(d3);
rgpulse(pw*1.462,v4,0.0,0.0);
delay(d3/2);
sim3shaped_pulse("","stC200","",0.0,1.0e-3,0.0,zero,zero,zero,0.0,0.0);
txphase(v1);
delay(d3/2);
rgpulse(pw*1.462,v1,0.0,0.0);
delay(d3);
rgpulse(pw*0.692,v1,0.0,0.0);
delay(d3);
rgpulse(pw*0.231,v1,0.0,0.0);
dec2phase(t3);
zgradpulse(gzlvl3,gt3); decpwrf(rf0);
delay(tauxh-gt3-WFG2_START_DELAY - 0.5e-3 + 70.0e-6);
decrgpulse(pwC, t3, 0.0,0.0);}
else
{
rgpulse(pw, t1, 0.0,0.0);
zgradpulse(0.5*gzlvl3,gt3); decpwrf(rf0);
delay(200.0e-6);
decrgpulse(pwC, t2, 0.0, 0.0);
txphase(t4); decphase(zero);
if (tau1>0.0)
{
if ( (N15refoc[A]=='y') && (tau1 > (pwN+2.0*pwC/PI)) )
{delay(tau1 - pwN -2.0*pwC/PI);
sim3pulse(2*pw,0.0,2.0*pwN, zero, zero, zero,0.0, 0.0);
delay(tau1 - pwN -2.0*pwC/PI);}
else
{
if (tau1 > (pw +2.0*pwC/PI))
{delay(tau1-pw -2.0*pwC/PI); rgpulse(2.0*pw, t4, 0.0, 0.0); decphase(t3); delay(tau1-pw -2.0*pwC/PI);}
else
{delay(tau1); decphase(t3); delay(tau1);}
}
}
decrgpulse(pwC, t3, 0.0, 0.0);
zgradpulse(0.5*gzlvl3,gt3);
delay(200.0e-6);
rgpulse(pw, v4, 0.0,0.0);
decphase(zero);
zgradpulse(gzlvl3,gt3);
decpwrf(rfst);
txphase(zero);
dec2phase(zero);
delay(tauxh-gt3- WFG2_START_DELAY - 0.5e-3 + 70.0e-6); /* delay=1/4J(XH) */
rgpulse(pw*0.231,v2,0.0,0.0);
delay(d3);
rgpulse(pw*0.692,v2,0.0,0.0);
delay(d3);
rgpulse(pw*1.462,v2,0.0,0.0);
delay(d3/2.0);
sim3shaped_pulse("","stC200","",0.0,1.0e-3,0.0,zero,zero,zero,0.0,0.0);
delay(d3/2.0);
rgpulse(pw*1.462,v3,0.0,0.0);
delay(d3);
rgpulse(pw*0.692,v3,0.0,0.0);
delay(d3);
rgpulse(pw*0.231,v3,0.0,0.0);
zgradpulse(gzlvl3,gt3);
decpwrf(rf0);
delay(tauxh-gt3- WFG2_START_DELAY - 0.5e-3 + 70.0e-6 +cor );} /* delay=1/4J(XH) */
decpower(dpwr);
setreceiver(t5);
status(C);
rcvron();
}
void pulsesequence()
{
char satflg[MAXSTR], stCshape[MAXSTR]; /* sech/tanh pulses from shapelib */
int icosel, t1_counter;
double
tau1, tau2, tau3, swTilt,
cos_hm1, cos_cm1, cos_cm2,
sw1 = getval("sw1"),
sw_hm1 = getval("sw_hm1"),
sw_cm1 = getval("sw_cm1"),
sw_cm2 = getval("sw_cm2"),
angle_hm1 = getval("angle_hm1"),
angle_cm1 = getval("angle_cm1"),
angle_cm2,
pwHs = getval("pwHs"),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
rf0, /* maximum fine power when using pwC pulses */
rfst = 0.0, /* fine power for the stCshape pulse, initialised */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
lambda = getval("lambda"), /* J delay optimized for CH3 */
tauCH = 1/(4.0*getval("jch")), /* 1/4J J delay */
gstab = getval("gstab"),
gt0 = getval("gt0"), gzlvl0 = getval("gzlvl0"),
gt1 = getval("gt1"), gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt3 = getval("gt3"), gzlvl3 = getval("gzlvl3"),
gt4 = getval("gt4"), gzlvl4 = getval("gzlvl4"),
gt5 = getval("gt5"), gzlvl5 = getval("gzlvl5"),
gt6 = getval("gt6"), gzlvl6 = getval("gzlvl6");
getstr("satflg",satflg);
pwN=pwN*1.0; cos_cm2=0.0; angle_cm2=0.0;
/* LOAD PHASE TABLE */
settable(t1,1,phi1); settable(t3,2,phi3); settable(t9,8,phi9);
settable(t10,1,phi10); settable(t11,4,rec);
/* INITIALIZE VARIABLES */
/* 30 ppm sech pulse */
rf0 = 4095.0;
rfst = (compC*4095.0*pwC*4000.0*sqrt((4.5*sfrq/600.0+3.85)/0.41));
rfst = (int) (rfst + 0.5);
strcpy(stCshape, "stC30");
/* CHECK VALIDITY OF PARAMETER RANGES */
if((dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y' ))
{ text_error("incorrect dec2 decoupler flags! Should be 'nnn' "); psg_abort(1); }
if((dm[A] == 'y' || dm[B] == 'y'))
{ text_error("incorrect dec decoupler flags! Should be 'nny' "); psg_abort(1); }
if( (dpwr > 52) && (dm[C]=='y'))
{ text_error("don't fry the probe, DPWR too large! "); psg_abort(1); }
/* Phases and delays related to PR-NMR */
/* sw1 is used as symbolic index */
if ( sw1 < 1000 ) { printf ("Please set sw1 to some value larger than 1000.\n"); psg_abort(1); }
if (angle_hm1 < 0 || angle_cm1 < 0 || angle_hm1 > 90 || angle_cm1 > 90 )
{ printf("angles must be set between 0 and 90 degree.\n"); psg_abort(1); }
cos_hm1 = cos (PI*angle_hm1/180); cos_cm1 = cos (PI*angle_cm1/180);
if ( (cos_hm1*cos_hm1 + cos_cm1*cos_cm1) > 1.0) { printf ("Impossible angle combinations.\n"); psg_abort(1); }
else { cos_cm2 = sqrt(1 - (cos_hm1*cos_hm1 + cos_cm1*cos_cm1) ); angle_cm2 = acos(cos_cm2)*180/PI; }
if (ix == 1) d2_init = d2;
t1_counter = (int)((d2-d2_init)*sw1 + 0.5);
swTilt = sw_hm1*cos_hm1 + sw_cm1*cos_cm1 + sw_cm2*cos_cm2;
if (phase1 == 1) {; } /* C+/- */
else if (phase1 == 2) { tsadd (t1, 1, 4); } /* S+/- */
icosel=1;
if ( (phase2 == 1) || (phase2 == 3) ) { tsadd(t10,2,4); icosel = 1; }
else { icosel = -1; }
if (t1_counter % 2) { tsadd(t1,2,4); tsadd(t11,2,4); } /* PZ TPPI */
tau1 = 1.0*t1_counter*cos_hm1/swTilt;
tau2 = 1.0*t1_counter*cos_cm1/swTilt;
tau3 = 1.0*t1_counter*cos_cm2/swTilt;
tau1 = tau1/2.0; tau2 = tau2/2.0; tau3 = tau3/2.0;
if (ix ==1 )
{
printf ("Current Spectral Width:\t\t%5.2f\n", swTilt);
printf ("Angle_hm1: %5.2f \n", angle_hm1);
printf ("Angle_cm1: %5.2f \n", angle_cm1);
printf ("Angle_cm2: %5.2f \n", angle_cm2);
printf ("\n\n\n\n\n");
}
/* BEGIN PULSE SEQUENCE */
status(A);
delay(d1);
rcvroff();
txphase(zero); obspower(tpwr);
decphase(zero); decpower(pwClvl); decpwrf(rf0);
dec2phase(zero); dec2power(pwNlvl);
decoffset(dof);
obsoffset(satfrq);
if (satflg[A] == 'y')
{
obspower(satpwr);
rgpulse(satdly, zero, 0.0, 0.0);
obspower(tpwr);
}
if (satflg[A] == 'y')
{
shiftedpulse("sinc", pwHs, 90.0, 0.0, zero, 2.0e-6, 2.0e-6);
}
decrgpulse(pwC, zero, 2.0e-6, 2.0e-6); /*destroy C13 magnetization*/
zgradpulse(gzlvl0, gt0);
delay(gstab);
if (satflg[A] == 'y')
{
shiftedpulse("sinc", pwHs, 90.0, 0.0, one, 2.0e-6, 2.0e-6);
}
decrgpulse(pwC, one, 2.0e-6, 2.0e-6);
zgradpulse(0.7*gzlvl0, gt0);
txphase(t1);
obsoffset(tof);
delay(gstab);
status(B);
rgpulse(pw, t1, 2.0e-6,2.0e-6); /* 1H pulse excitation */
if (tau1 > pwC)
{
delay(tau1 - pwC);
decrgpulse(2.0*pwC, zero, 0.0, 0.0);
delay(tau1 - pwC);
}
else
{
delay(2.0*tau1);
}
zgradpulse(gzlvl3, gt3);
delay(tauCH - gt3 - 4.0e-6);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 2.0e-6, 2.0e-6);
delay(tauCH - gt3 - gstab -4.0e-6);
zgradpulse(gzlvl3, gt3);
txphase(one);
delay(gstab);
rgpulse(pw, one, 2.0e-6, 2.0e-6);
zgradpulse(gzlvl4, gt4);
obsoffset(satfrq);
decphase(t3);
delay(gstab);
decrgpulse(pwC, t3, 4.0e-6, 2.0e-6);
/*================== Carbon evolution ===============*/
txphase(zero); decphase(zero);
if ((phase2 ==1) || (phase2 ==2)) { delay(tau2 + tau3); }
else { delay(tau3); }
rgpulse(2.0*pw, zero, 2.0e-6, 2.0e-6);
if ((phase2 == 1) || (phase2 ==2)) { delay(tau2 + tau3); }
else { delay(tau3); }
zgradpulse(-1.0*gzlvl1, gt1/2);
decphase(t9);
delay(gstab - 2.0*GRADIENT_DELAY);
decrgpulse(2.0*pwC, t9, 2.0e-6, 2.0e-6);
if ((phase2 == 3) || (phase2 ==4)) { delay(tau2); }
rgpulse(2.0*pw, zero, 2.0e-6, 2.0e-6);
if ((phase2 == 3) || (phase2 ==4)) { delay(tau2); }
zgradpulse(gzlvl1, gt1/2);
decphase(t10);
delay(gstab -2.0*GRADIENT_DELAY );
/*================== End of Carbon evolution ===============*/
simpulse(pw, pwC, zero, t10, 2.0e-6, 2.0e-6);
decphase(zero);
zgradpulse(gzlvl5, gt5);
delay(lambda - 1.5*pwC - gt5 - 4.0e-6);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 2.0e-6, 2.0e-6);
delay(lambda - 1.5*pwC - gt5 - gstab -4.0e-6);
zgradpulse(gzlvl5, gt5);
txphase(one); decphase(one);
delay(gstab);
simpulse(pw, pwC, one, one, 2.0e-6, 2.0e-6);
txphase(zero);
decphase(zero);
zgradpulse(gzlvl6, gt6);
delay(tauCH - 1.5*pwC - gt6 -4.0e-6);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 2.0e-6, 2.0e-6);
delay(tauCH - pwC - 0.5*pw - gt6 -gstab -4.0e-6);
zgradpulse(gzlvl6, gt6);
delay(gstab);
rgpulse(pw, zero, 2.0e-6, 2.0e-6);
delay((gt1/4.0) + gstab -2.0e-6 - 0.5*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 2.0e-6, 2.0e-6);
decpower(dpwr); /* POWER_DELAY */
zgradpulse(icosel*gzlvl2, gt1/4.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
status(C);
setreceiver(t11);
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
f2180[MAXSTR], /* Flag to start t2 @ halfdwell */
RELAY[MAXSTR], /* Insert HCCH-relay delay */
ribose[MAXSTR], /* ribose CHn groups only */
aromatic[MAXSTR], /* aromatic CHn groups only */
rna_stCshape[MAXSTR], /* calls sech/tanh pulses from shapelib */
rna_stCdec[MAXSTR], /* calls STUD+ waveforms from shapelib */
mag_flg[MAXSTR], /* Flag to use magic-angle gradients */
H2O_flg[MAXSTR],
sspul[MAXSTR],
SHAPE[MAXSTR],
STUD[MAXSTR]; /* apply automatically calculated STUD decoupling */
int t1_counter, /* used for states tppi in t1 */
t2_counter, /* used for states tppi in t2 */
ni2 = getval("ni2");
double tau1, /* t1 delay */
tau2, /* t2 delay */
delta1,delta2,
ni = getval("ni"),
lambda = 0.94/(4*getval("JCH")), /* 1/4J H1 evolution delay */
tCH = 1/(6.0*getval("JCH")), /* 1/4J C13 evolution delay */
tCC = 1/(8*getval("JCC")),
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rfC, /* maximum fine power when using pwC pulses */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
/* temporary Pbox parameters */
bw, pws, ofs, ppm, nst, /* bandwidth, pulsewidth, offset, ppm, # steps */
/* Sech/tanh inversion pulses automatically calculated by macro "rna_cal" */
/* and string parameter rna_stCshape calls them from your shapelib. */
rfst = 0.0, /* fine power for the rna_stCshape pulse, initialised */
dofa, /* dof shifted to 80 or 120ppm for ribose or aromatic spectra */
/* string parameter stCdec calls stud decoupling waveform from your shapelib.*/
studlvl, /* coarse power for STUD+ decoupling */
stdmf = getval("dmf80"), /* dmf for 80 ppm of STUD decoupling */
rf80 = getval("rf80"), /* rf in Hz for 80ppm STUD+ */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
sw2 = getval("sw2"),
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gt7 = getval("gt7"),
gt8 = getval("gt8"),
gt9 = getval("gt9"),
gzcal = getval("gzcal"),
grecov = getval("grecov"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl7 = getval("gzlvl7"), /* triax option */
gzlvl8 = getval("gzlvl8"),
gzlvl9 = getval("gzlvl9");
getstr("f1180",f1180);
getstr("mag_flg",mag_flg);
getstr("f2180",f2180);
getstr("RELAY",RELAY);
getstr("ribose",ribose);
getstr("aromatic",aromatic);
getstr("H2O_flg",H2O_flg);
getstr("sspul",sspul);
getstr("SHAPE",SHAPE);
getstr("STUD",STUD);
/* INITIALIZE VARIABLES */
/* maximum fine power for pwC pulses */
rfC = 4095.0;
setautocal(); /* activate auto-calibration flags */
if (autocal[0] == 'n')
{
/* 50ppm sech/tanh inversion */
rfst = (compC*4095.0*pwC*4000.0*sqrt((7.5*sfrq/600+3.85)/0.41));
rfst = (int) (rfst + 0.5);
}
else /* if autocal = 'y'(yes), 'q'(quiet), r(read), or 's'(semi) */
{
if(FIRST_FID) /* call Pbox */
{
ppm = getval("dfrq");
bw = 50.0*ppm; pws = 0.001; ofs = 0.0; nst = 500.0;
stC50 = pbox_makeA("rna_stC50", "sech", bw, pws, ofs, compC*pwC, pwClvl, nst);
if (dm3[B] == 'y') H2ofs = 3.2;
ofs_check(H1ofs, C13ofs, N15ofs, H2ofs);
}
rfst = stC50.pwrf;
}
strcpy(rna_stCshape, "rna_stC50");
strcpy(rna_stCdec, "wurst80");
studlvl = pwClvl + 20.0*log10(compC*pwC*4.0*rf80);
studlvl = (int) (studlvl + 0.5);
/* RIBOSE spectrum only, centered on 80ppm. */
if (ribose[A]=='y')
dofa = dof - 30.0*dfrq;
/* AROMATIC spectrum only, centered on 120ppm */
else
dofa = dof + 10*dfrq;
/* CHECK VALIDITY OF PARAMETER RANGES */
if( dpwrf < 4095 )
{ printf("reset dpwrf=4095 and recalibrate C13 90 degree pulse");
psg_abort(1); }
if( pwC > (24.0e-6*600.0/sfrq) )
{ printf("Increase pwClvl so that pwC < 24*600/sfrq");
psg_abort(1); }
if((dm[A] == 'y' || dm[B] == 'y' ))
{ printf("incorrect Dec1 decoupler flags! "); psg_abort(1);}
if((dm2[A] == 'y' || dm2[B] == 'y'))
{ printf("incorrect Dec2 decoupler flags! "); psg_abort(1);}
if((dm3[A] == 'y' || dm3[C] == 'y' ))
{printf("incorrect dec1 decoupler flags! Should be 'nyn' or 'nnn' ");
psg_abort(1); }
if ((dm3[B] == 'y' && dpwr3 > 44 ))
{ printf("Deuterium decoupling power too high ! "); psg_abort(1);}
if( dpwr > 50 )
{ printf("don't fry the probe, dpwr too large! "); psg_abort(1);}
if( dpwr2 > 50 )
{ printf("don't fry the probe, dpwr2 too large! "); psg_abort(1); }
/* CHOICE OF PULSE SEQUENCE */
if ( ((ribose[A]=='y') && (aromatic[A]=='y')) )
{ text_error("Choose ONE of ribose='y' OR aromatic='y' ! ");
psg_abort(1); }
if ( ((aromatic[A]=='y') && (RELAY[A]=='y')) )
{ text_error("No RELAY with aromatic='y' ! ");
psg_abort(1); }
/* LOAD VARIABLES */
settable(t1, 2, phi1);
settable(t2, 4, phi2);
settable(t3, 16, phi3);
settable(t4, 2, phi4);
settable(t11,8, rec);
/* INITIALIZE VARIABLES */
/* Phase incrementation for hypercomplex data */
if ( phase1 == 2 ) /* Hypercomplex in t1 */
tsadd(t1,1,4);
if ( phase2 == 2 )
tsadd(t2,1,4);
/* calculate modification to phases based on current t1 values
to achieve States-TPPI acquisition */
if(ix == 1) d2_init = d2;
t1_counter = (int)((d2-d2_init)*sw1 + 0.5);
if(t1_counter % 2)
{
tsadd(t1,2,4);
tsadd(t11,2,4);
}
/* calculate modification to phases based on current t2 values
to achieve States-TPPI acquisition */
if(ix == 1) d3_init = d3;
t2_counter = (int)((d3-d3_init)*sw2 + 0.5);
if(t2_counter % 2)
{
tsadd(t2,2,4);
tsadd(t11,2,4);
}
/* set up so that get (90, -180) phase corrects in F1 if f1180 flag is y */
tau1 = d2;
if(f1180[A] == 'y')
{
tau1 += (1.0/(2.0*sw1));
}
if (tau1 < 1.0e-6) tau1 = 0.0;
tau1 = tau1/2.0;
/* set up so that get (90, -180) phase corrects in F2 if f2180 flag is y */
tau2 = d3;
if(f2180[A] == 'y')
{
tau2 += (1.0/(2.0*sw2));
}
if (tau2 < 1.0e-6) tau2 = 0.0;
tau2 = tau2/2.0;
if (ni > 1)
delta1 = (double)(t1_counter*(lambda - gt5 - 0.2e-3))/((double)(ni-1));
else delta1 = 0.0;
if (ni2 > 1)
delta2 = (double)(t2_counter*(tCC - 0.6e-3))/((double)(ni2-1));
else delta2 = 0.0;
initval(7.0, v1);
obsstepsize (45.0);
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
obsoffset(tof);
decoffset(dofa);
dec2offset(dof2);
obspower(tpwr-12);
decpower(pwClvl);
decpwrf(rfC);
dec2power(pwNlvl);
decphase(zero);
dec2phase(zero);
if (sspul[0] == 'y')
{
rgpulse(200*pw, one, 10.0e-6, 0.0e-6);
rgpulse(200*pw, zero, 0.0e-6, 1.0e-6);
}
obspower(tpwr);
xmtrphase(v1);
txphase(t1);
if (dm3[B] == 'y') lk_sample();
delay(d1);
if (dm3[B] == 'y') lk_hold();
rcvroff();
decrgpulse(pwC, zero, rof1, rof1);
delay(rof1);
zgradpulse(gzlvl0,0.5e-3);
delay(grecov);
if(dm3[B] == 'y') /*optional 2H decoupling on */
{
dec3unblank();
dec3rgpulse(1/dmf3, one, 0.0, 0.0);
dec3unblank();
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
}
status(B);
rgpulse(pw, t1, 1.0e-4, rof1);
xmtrphase(zero);
txphase(zero);
zgradpulse(gzlvl5,gt5);
/*
decpwrf(rfst);
delay(lambda - gt5 - rof1 - SAPS_DELAY - GRADIENT_DELAY - POWER_DELAY -
WFG2_START_DELAY - 0.5e-3 + 70.0e-6 + tau1);
decshaped_pulse(rna_stCshape, 1.0e-3, zero, 0.0, 0.0);
delay(tau1 - delta1);
rgpulse(2.0*pw, zero, 0.0, rof1);
txphase(one);
decpwrf(rfC);
zgradpulse(gzlvl5,gt5);
delay(lambda - delta1 - gt5 - rof1 - GRADIENT_DELAY - POWER_DELAY - 0.5e-3 + 70.0e-6);
*/
delay(lambda - gt5 - rof1 - SAPS_DELAY - GRADIENT_DELAY + tau1);
decrgpulse(2*pwC, zero, 0.0, 0.0);
delay(tau1 - delta1);
rgpulse(2.0*pw, zero, 0.0, rof1);
txphase(one);
zgradpulse(gzlvl5,gt5);
delay(lambda - delta1 - gt5 - rof1 - GRADIENT_DELAY);
rgpulse(pw, one, 0.0, rof1);
decphase(t2);
txphase(zero);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl3,gt3);
else
zgradpulse(gzlvl3,gt3);
delay(grecov);
decrgpulse(pwC, t2, rof1, 0.0);
decphase(zero);
delay(tau2);
dec2rgpulse(2.0*pwN,zero,0.0,0.0);
delay(tCH - 2*pwN);
rgpulse(2.0*pw, zero, 0.0, 0.0);
decphase(t3);
delay(tCC - tCH + tau2 - delta2 - 2.0*pw);
decrgpulse(2.0*pwC, t3, 0.0, 0.0);
decphase(t4);
delay(tCC - delta2);
decrgpulse(pwC, t4, 0.0, rof1);
txphase(zero);
decphase(zero);
if(RELAY[A] == 'y')
{
zgradpulse(gzlvl4, gt4);
delay(tCC - gt4 - GRADIENT_DELAY - pwC);
decrgpulse(2.0*pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl4, gt4);
delay(tCC - gt4 - GRADIENT_DELAY - pwC);
decrgpulse(pwC, zero, 0.0, 0.0);
}
zgradpulse(gzlvl4,gt4);
delay(tCC - gt4);
decrgpulse(2.0*pwC, zero, 0.0, rof1);
if (H2O_flg[A] == 'y')
{
delay(tCC - gt4 - grecov - POWER_DELAY);
zgradpulse(gzlvl4,gt4);
txphase(one);
decphase(one);
delay(grecov);
decrgpulse(pwC, one, 0.0, rof1);
rgpulse(900*pw, one, 0.0, rof1);
txphase(zero);
rgpulse(500*pw, zero, rof1, rof1);
decphase(one);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl7,gt7);
else
zgradpulse(gzlvl7,gt7);
delay(200.0e-6);
simpulse(pw, pwC, zero, one, 0.0, rof1);
decphase(zero);
zgradpulse(gzlvl4,gt4);
delay(tCH - gt4);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, rof1);
zgradpulse(gzlvl4,gt4);
delay(tCH - gt4);
}
else
{
delay(tCC - tCH - 2.0*pw - POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, rof1);
zgradpulse(gzlvl4,gt4);
delay(tCH - gt4 - rof1);
}
decrgpulse(pwC, zero, 0.0, rof1);
txphase(zero);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl8,gt8);
else
zgradpulse(gzlvl8,gt8);
delay(grecov);
if(dm3[B] == 'y') /*optional 2H decoupling off */
{
dec3rgpulse(1/dmf3, three, 0.0, 0.0);
dec3blank();
setstatus(DEC3ch, FALSE, 'w', FALSE, dmf3);
dec3blank();
}
rgpulse(pw, zero, 0.0, rof1);
if (SHAPE[A] =='y')
{
decpwrf(rfst);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl9,gt9);
else
zgradpulse(gzlvl9,gt9);
delay(lambda - gt9 - GRADIENT_DELAY - POWER_DELAY - WFG2_START_DELAY - 0.5e-3 + 70.0e-6);
simshaped_pulse("",rna_stCshape,2*pw, 1.0e-3, zero, zero, 0.0, rof1);
decphase(zero);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl9,gt9);
else
zgradpulse(gzlvl9,gt9);
decpwrf(rfC);
if (STUD[A]=='y') decpower(studlvl); else decpower(dpwr);
delay(lambda - gt9 -rof1 -0.5*pw - 2*POWER_DELAY - GRADIENT_DELAY - 0.5e-3 + 70.0e-6);
}
else
{
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl9,gt9);
else
zgradpulse(gzlvl9,gt9);
delay(lambda - gt9 - GRADIENT_DELAY);
simpulse(2*pw, 2*pwC, zero, zero, 0.0, rof1);
if(mag_flg[A] == 'y')
magradpulse(gzcal*gzlvl9,gt9);
else
zgradpulse(gzlvl9,gt9);
if (STUD[A]=='y') decpower(studlvl); else decpower(dpwr);
delay(lambda - gt9 -rof1 -0.5*pw - POWER_DELAY - GRADIENT_DELAY);
}
rgpulse(pw, zero, rof1, rof2);
rcvron();
if (dm3[B] == 'y') lk_sample();
setreceiver(t11);
if ((STUD[A]=='y') && (dm[C] == 'y'))
{
decunblank();
decon();
decprgon(rna_stCdec,1/stdmf, 1.0);
startacq(alfa);
acquire(np, 1.0/sw);
decprgoff();
decoff();
decblank();
}
else
status(C);
setreceiver(t11);
}
pulsesequence()
{
/* DECLARE VARIABLES */
char pw11[MAXSTR], /* off resonance 1-1 type proton excitation pulse */
URA[MAXSTR], /* Setup for U-imino - U-H6 */
CYT[MAXSTR], /* Setup for C-imino - C-H6 */
CP[MAXSTR], /* CP H->N transfer */
INEPT[MAXSTR], /* INEPT H->N transfer */
C13refoc[MAXSTR], /* C13 pulse in middle of t1*/
f1180[MAXSTR]; /* Flag to start t1 @ halfdwell */
int t1_counter;
double tau1, /* t1 delay */
lambda = 0.94/(4.0*getval("JCH")), /* 1/4J C-H INEPT delay */
lambdaN = 0.94/(4.0*getval("JNH")), /* 1/4J N-H INEPT delay */
tCC = 1.0/(4.0*getval("JCC")), /* 1/4J C-C INEPT delay */
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rfC, /* maximum fine power when using pwC pulses */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
rfN, /* maximum fine power when using pwN pulses */
compN = getval("compN"), /* adjustment for N15 amplifier compression */
tpwr = getval("tpwr"), /* power for H1 pulses */
pw = getval("pw"), /* H1 90 degree pulse length at tpwr */
rfH, /* maximum fine power when using pw pulses */
compH = getval("compH"), /* adjustment for H1 amplifier compression */
tof_75, /* tof shifted to 7.5 ppm for H4-N4 transfer */
tof_12, /* tof shifted to 12 ppm for H3-N3 transfer */
dof_169, /* dof shifted to 169 ppm for N3-C4 transfer */
dof_140, /* dof shifted to 140 ppm for C4-C5-C6 transfer and DEC1 */
dof2_97, /* dof2 shifted to 97 ppm for H4-N4 and N4-C4 transfer */
dof2_160, /* dof2 shifted to 160 ppm for H3-N3 and N3-C4 transfer */
/* p_d is used to calculate the isotropic mixing */
p_d, /* 50 degree pulse for DIPSI-3 at rfdC-rfdN-rfdH */
rfdC, /* fine C13 power for 1.9 kHz rf for 500MHz magnet */
rfdN, /* fine N15 power for 1.9 kHz rf for 500MHz magnet */
rfdH, /* fine H1 power for 1.9 kHz rf for 500MHz magnet */
ncyc_hn = getval("ncyc_hn"), /* number of pulsed cycles in HN half-DIPSI-3 */
ncyc_nc = getval("ncyc_nc"), /* number of pulsed cycles in NC DIPSI-3 */
sw1 = getval("sw1"),
grecov = getval("grecov"),
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrs, /* power for the pwHs ("rna_H2Osinc") pulse */
pwHs2 = getval("pwHs2"), /* H1 90 degree pulse length at tpwrs2 */
tpwrs2, /* power for the pwHs2 square pulse */
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gt3 = getval("gt3"),
gzlvl4 = getval("gzlvl4"),
gt4 = getval("gt4"),
gzlvl5 = getval("gzlvl5"),
gt5 = getval("gt5"),
gzlvlr = getval("gzlvlr");
getstr("pw11",pw11);
getstr("URA",URA);
getstr("CYT",CYT);
getstr("CP",CP);
getstr("INEPT",INEPT);
getstr("C13refoc",C13refoc);
getstr("f1180",f1180);
/* LOAD PHASE TABLE */
settable(t1,2,phi1);
settable(t3,8,phi3);
settable(t4,4,phi4);
settable(t5,16,phi5);
if ( CP[A] == 'y' )
settable(t10,8,rec1);
if ( INEPT[A] == 'y' )
settable(t10,16,rec2);
/* INITIALIZE VARIABLES */
/* maximum fine power for pwC pulses */
rfC = 4095.0;
/* maximum fine power for pwN pulses */
rfN = 4095.0;
/* maximum fine power for pw pulses */
rfH = 4095.0;
/* different offset values tof=H2O, dof=110ppm, dof2=200ppm */
tof_75 = tof + 2.5*sfrq; /* tof shifted to nH2 */
tof_12 = tof + 7.0*sfrq; /* tof shifted to nH */
dof_169 = dof + 59*dfrq; /* dof shifted to C4 */
dof_140 = dof + 30*dfrq; /* dof shifted to C6 */
dof2_160 = dof2 - 40*dfrq2; /* dof2 shifted to Nh */
dof2_97 = dof2 - 103*dfrq2; /* dof2 shifted to Nh2 */
/* 1.9 kHz DIPSI-3 at 500MHz*/
p_d = (5.0)/(9.0*4.0*1900.0*(sfrq/500.0)); /* 1.9 kHz DIPSI-3 at 500MHz*/
/* fine C13 power for dipsi-3 isotropic mixing on C4 region */
rfdC = (compC*4095.0*pwC*5.0)/(p_d*9.0);
rfdC = (int) (rfdC + 0.5);
/* fine N15 power for dipsi-3 isotropic mixing on Nh region */
rfdN = (compN*4095.0*pwN*5.0)/(p_d*9.0);
rfdN = (int) (rfdN + 0.5);
/* fine H1 power for half dipsi-3 isotropic mixing on nH2 region */
rfdH = (compH*4095.0*pw*5.0)/(p_d*9.0);
rfdH = (int) (rfdH + 0.5);
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /* needs 1.69 times more */
tpwrs = (int) (tpwrs); /* power than a square pulse */
/* selective H20 square pulse */
tpwrs2 = tpwr - 20.0*log10(pwHs2/(compH*pw));
tpwrs2 = (int) (tpwrs2);
/* number of cycles and mixing time */
ncyc_nc = (int) (ncyc_nc + 0.5);
ncyc_hn = (int) (ncyc_hn + 0.5);
if (ncyc_nc > 0 )
{
printf("NC-mixing time is %f ms.\n",(ncyc_nc*51.8*4*p_d));
}
if (CP[A] == 'y')
{
if (ncyc_hn > 0 )
printf("HN-mixing time is %f ms.\n",(ncyc_hn*51.8*2*p_d));
}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 2)
tsadd(t1,1,4);
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t1,2,4); tsadd(t10,2,4); }
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* CHECK VALIDITY OF PARAMETER RANGE */
if( sfrq > 610 )
{ printf("Power Levels at 750/800 MHz may be too high for probe");
psg_abort(1); }
if( dpwrf < 4095 )
{ printf("reset dpwrf=4095 and recalibrate C13 90 degree pulse");
psg_abort(1); }
if( dpwrf2 < 4095 )
{ printf("reset dpwrf2=4095 and recalibrate N15 90 degree pulse");
psg_abort(1); }
if((dm[A] == 'y' || dm[B] == 'y'))
{
printf("incorrect dec1 decoupler flag! Should be 'nny' or 'nnn' ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y'))
{
printf("incorrect dec2 decoupler flags! Should be 'nnn' or 'nny' ");
psg_abort(1);
}
if( ((dm[C] == 'y') && (dm2[C] == 'y') && (at > 0.18)) )
{
text_error("check at time! Don't fry probe !! ");
psg_abort(1);
}
if( dpwr > 50 )
{
printf("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( dpwr2 > 50 )
{
printf("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( pw > 20.0e-6 )
{
printf("dont fry the probe, pw too high ! ");
psg_abort(1);
}
if( pwC > 40.0e-6 )
{
printf("dont fry the probe, pwC too high ! ");
psg_abort(1);
}
if( pwN > 100.0e-6 )
{
printf("dont fry the probe, pwN too high ! ");
psg_abort(1);
}
if (gzlvlr > 500 || gzlvlr < -500)
{
text_error(" RDt1-gzlvlr must be -500 to 500 (0.5G/cm) \n");
psg_abort(1);
}
if( (CP[A] == 'y') && (INEPT[A] == 'y') )
{
text_error("Choose either CP or INEPT for H->N transfer !! ");
psg_abort(1);
}
if( ncyc_hn > 2 )
{
text_error("check H->N half-dipsi-3 time !! ");
psg_abort(1);
}
if( ncyc_nc > 7 )
{
text_error("check N->C dipsi-3 time !! ");
psg_abort(1);
}
if( (URA[A] == 'y') && (CYT[A] == 'y') )
{
text_error("Choose either URA or CYT !! ");
psg_abort(1);
}
if( (URA[A] == 'n') && (CYT[A] == 'n') )
{
text_error("Do you really want to run this experiment ?? ");
psg_abort(1);
}
if( (URA[A] == 'y') && (CP[A] == 'y') )
{
printf("Remember that CP covers just 3.8 ppm !!! ");
}
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
rcvroff();
obspower(tpwr);
obspwrf(rfH);
obsstepsize(0.5);
decpower(pwClvl);
decpwrf(rfC);
decstepsize(0.5);
dec2power(pwNlvl);
dec2pwrf(rfN);
dec2stepsize(0.5);
if (URA[A] == 'y')
{
obsoffset(tof_12); /* Set the proton frequency to U-nH */
dec2offset(dof2_160); /* Set the nitrogen frequency to U-Nh */
}
else if (CYT[A] == 'y')
{
obsoffset(tof_75); /* Set the proton frequency to C-nH2 */
dec2offset(dof2_97); /* Set the nitrogen frequency to C-Nh2 */
}
else
{
}
decoffset(dof_169); /* Preset the carbon frequency for the NC-tocsy */
txphase(zero);
decphase(zero);
dec2phase(zero);
delay(d1);
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 and C13 magnetization*/
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
dec2rgpulse(pwN, one, 0.0, 0.0);
decrgpulse(pwC, one, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
delay(5.0e-4);
if (CP[A] == 'y')
initval(ncyc_hn,v12);
initval(ncyc_nc,v11);
txphase(t1);
decphase(zero);
dec2phase(zero);
delay(5.0e-4);
rcvroff();
if(pw11[A] == 'y')
{
rgpulse(pw/2, t1, 50.0e-6, 0.0);
if (URA[A] == 'y')
delay(1/(2*(tof_12-tof)));
else if (CYT[A] == 'y')
delay(1/(2*(tof_75-tof)));
else
delay(1/(2*(tof_75-tof)));
rgpulse(pw/2, t1, 0.0, 0.0);
}
else
{
rgpulse(pw, t1, 50.0e-6, 0.0);
}
txphase(zero);
if (C13refoc[A]=='y')
{
if (tau1 > (0.001-(2.0*GRADIENT_DELAY + pwN + 0.64*pw )))
{
zgradpulse(gzlvlr, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw) );
sim3pulse(0.0, 2.0*pwC, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(-1.0*gzlvlr, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
}
else
{
if (tau1 > (0.001-(pwN + 0.64*pw )))
{
delay(tau1 - pwN - 0.64*pw );
sim3pulse(0.0, 2.0*pwC, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
delay(tau1 - pwN - 0.64*pw);
}
else
{
if (tau1 > (0.64*pw ))
delay(2.0*tau1 - 2.0*0.64*pw );
}
}
}
else
{
if (tau1 > (0.001-(2.0*GRADIENT_DELAY + pwN + 0.64*pw )))
{
zgradpulse(gzlvlr, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw) );
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
zgradpulse(-1.0*gzlvlr, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw));
}
else
{
if (tau1 > (0.001-(pwN + 0.64*pw )))
{
delay(tau1 - pwN - 0.64*pw );
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(tau1 - pwN - 0.64*pw);
}
else
{
if (tau1 > (0.64*pw ))
delay(2.0*tau1 - 2.0*0.64*pw );
}
}
}
if (INEPT[A] == 'y')
{
delay(lambdaN);
sim3pulse(2*pw, 0.0, 2*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t5);
delay(lambdaN - SAPS_DELAY);
sim3pulse(pw, 0.0, pwN, zero, zero, t5, 0.0, 0.0);
dec2phase(zero);
zgradpulse(gzlvl5,gt5);
delay(lambdaN - SAPS_DELAY - gt5);
sim3pulse(2*pw, 0.0, 2*pwN, one, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5,gt5);
delay(lambdaN - 2*SAPS_DELAY - gt5 - 2*POWER_DELAY);
decpwrf(rfdC); /* Set fine power for carbon */
dec2pwrf(rfdN); /* Set fine power for nitrogen */
}
else if (CP[A] == 'y')
{
obspwrf(rfdH); /* Set fine power for proton */
decpwrf(rfdC); /* Preset fine power for carbon */
dec2pwrf(rfdN); /* Set fine power for nitrogen */
delay(2.0e-6);
starthardloop(v12);
sim3pulse(6.4*p_d,0.0,6.4*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(8.2*p_d,0.0,8.2*p_d,two,two,two,0.0,0.0);
sim3pulse(5.8*p_d,0.0,5.8*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(5.7*p_d,0.0,5.7*p_d,two,two,two,0.0,0.0);
sim3pulse(0.6*p_d,0.0,0.6*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(4.9*p_d,0.0,4.9*p_d,two,two,two,0.0,0.0);
sim3pulse(7.5*p_d,0.0,7.5*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(5.3*p_d,0.0,5.3*p_d,two,two,two,0.0,0.0);
sim3pulse(7.4*p_d,0.0,7.4*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(6.4*p_d,0.0,6.4*p_d,two,two,two,0.0,0.0);
sim3pulse(8.2*p_d,0.0,8.2*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(5.8*p_d,0.0,5.8*p_d,two,two,two,0.0,0.0);
sim3pulse(5.7*p_d,0.0,5.7*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.6*p_d,0.0,0.6*p_d,two,two,two,0.0,0.0);
sim3pulse(4.9*p_d,0.0,4.9*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(7.5*p_d,0.0,7.5*p_d,two,two,two,0.0,0.0);
sim3pulse(5.3*p_d,0.0,5.3*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(7.4*p_d,0.0,7.4*p_d,two,two,two,0.0,0.0);
endhardloop();
}
else
{
}
dec2phase(zero);
decphase(zero);
starthardloop(v11);
sim3pulse(0.0,6.4*p_d,6.4*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,8.2*p_d,8.2*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.8*p_d,5.8*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.7*p_d,5.7*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,0.6*p_d,0.6*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,4.9*p_d,4.9*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,7.5*p_d,7.5*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.3*p_d,5.3*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,7.4*p_d,7.4*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,6.4*p_d,6.4*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,8.2*p_d,8.2*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.8*p_d,5.8*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.7*p_d,5.7*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,0.6*p_d,0.6*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,4.9*p_d,4.9*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,7.5*p_d,7.5*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.3*p_d,5.3*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,7.4*p_d,7.4*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,6.4*p_d,6.4*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,8.2*p_d,8.2*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.8*p_d,5.8*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.7*p_d,5.7*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,0.6*p_d,0.6*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,4.9*p_d,4.9*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,7.5*p_d,7.5*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.3*p_d,5.3*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,7.4*p_d,7.4*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,6.4*p_d,6.4*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,8.2*p_d,8.2*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,5.8*p_d,5.8*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.7*p_d,5.7*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,0.6*p_d,0.6*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,4.9*p_d,4.9*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,7.5*p_d,7.5*p_d,zero,zero,zero,0.0,0.0);
sim3pulse(0.0,5.3*p_d,5.3*p_d,two,two,two,0.0,0.0);
sim3pulse(0.0,7.4*p_d,7.4*p_d,zero,zero,zero,0.0,0.0);
endhardloop();
obspwrf(rfH);
decpwrf(rfC);
dec2pwrf(rfN);
obsoffset(tof);
decoffset(dof_140);
txphase(zero);
decphase(one);
decrgpulse(pwC,one,0.0,0.0); /* flip transferred 13C-magn. to z */
decphase(t3);
decrgpulse(pwC,t3,0.0,0.0); /* flip transferred 13C-magnetization to x */
decphase(zero);
zgradpulse(gzlvl5,gt5);
delay(tCC - SAPS_DELAY - gt5);
decrgpulse(2*pwC,zero,0.0,0.0);
zgradpulse(gzlvl5,gt5);
delay(tCC - gt5);
decrgpulse(pwC,zero,0.0,0.0); /* flip transferred 13C-magnetization to x */
decphase(zero);
zgradpulse(gzlvl5,gt5);
delay(tCC - SAPS_DELAY - gt5);
decrgpulse(2*pwC,zero,0.0,0.0);
zgradpulse(gzlvl5,gt5);
delay(tCC - gt5);
decrgpulse(pwC,zero,0.0,0.0); /* flip transferred 13C-magnetization to x */
decphase(zero);
delay(tCC - SAPS_DELAY);
decrgpulse(2*pwC,zero,0.0,0.0);
delay(tCC - lambda - pw);
rgpulse(2*pw,zero,0.0,0.0); /* Invert water signal */
delay(lambda - pw);
decrgpulse(pwC,zero,0.0,0.0);
zgradpulse(gzlvl3,gt3);
delay(grecov);
txphase(zero);
obspower(tpwrs);
shaped_pulse("rna_H2Osinc", pwHs, zero, 5.0e-4, 0.0);
obspower(tpwr);
rgpulse(pw, zero, 2*rof1, 0.0);
txphase(two);
obspower(tpwrs2);
zgradpulse(gzlvl4,gt4);
delay(grecov - 2*SAPS_DELAY - 2*POWER_DELAY - GRADIENT_DELAY);
rgpulse((lambda-grecov-gt4-pwC), two, 0.0, 0.0);
simpulse(pwC,pwC,two,three,0.0,0.0);
simpulse(2*pwC,2*pwC,two,zero,0.0,0.0);
simpulse(pwC,pwC,two,three,0.0,0.0);
rgpulse((pwHs2-2*pwC-(lambda-grecov-gt4-pwC)), two, 0.0, 0.0);
txphase(zero);
obspower(tpwr);
rgpulse(2*pw, zero, 0.0, 0.0);
txphase(two);
obspower(tpwrs2);
rgpulse(pwHs2, two, 0.0, 0.0);
decphase(t4);
zgradpulse(gzlvl4,gt4);
delay(grecov-2*pwC-2*SAPS_DELAY - POWER_DELAY - GRADIENT_DELAY);
decrgpulse(pwC,t4,0.0,0.0);
decrgpulse(pwC,zero,0.0,0.0);
dec2power(dpwr2); /* 2*POWER_DELAY */
decpower(dpwr);
status(C);
rcvron();
setreceiver(t10);
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
f2180[MAXSTR], /* Flag to start t2 @ halfdwell */
mag_flg[MAXSTR], /* magic-angle coherence transfer gradients */
TROSY[MAXSTR], /* do TROSY on N15 and H1 */
h1dec[MAXSTR], /* Flag to waltz-decouple of H1 for t1*/
CT_c[MAXSTR]; /* Flag to constant time evolution for C13*/
int icosel, /* used to get n and p type */
t1_counter, /* used for states tppi in t1 */
t2_counter, /* used for states tppi in t2 */
ni2 = getval("ni2");
double tau1, /* t1 delay */
tau2, /* t2 delay */
timeTC = getval("timeTC"), /* constant time for 13C evolution */
timeTN = getval("timeTN"), /* constant time for 15N evolution */
kappa = 5.4e-3,
lambda = 2.4e-3,
taud = 1.7e-3,
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rf0, /* maximum fine power when using pwC pulses */
/* 90 degree pulse at Ca (56ppm), first off-resonance null at CO (174ppm) */
pwC1, /* 90 degree pulse length on C13 at rf1 */
rf1, /* fine power for 4.7 kHz rf for 600MHz magnet */
/* 180 degree pulse at Ca (56ppm), first off-resonance null at CO(174ppm) */
pwC2, /* 180 degree pulse length at rf2 */
rf2, /* fine power for 10.5 kHz rf for 600MHz magnet */
/* the following pulse lengths for SLP pulses are automatically calculated */
/* by the macro "BPcal". SLP pulse shapes, "offC9" etc are called */
/* directly from your shapelib. */
pwC9 = getval("pwC9"), /*180 degree pulse at CO(174ppm) null at Ca(56ppm) */
pwC9a = getval("pwC9a"), /* pwC9a=pwC9, but not set to zero when pwC9=0 */
phshift9, /* phase shift induced on Ca by pwC9 ("offC9") pulse */
pwZ, /* the largest of pwC9 and 2.0*pwN */
pwZ1, /* the larger of pwC9a and 2.0*pwN for 1D experiments */
rf9, /* fine power for the pwC9 ("offC9") pulse */
compH = getval("compH"), /* adjustment for C13 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrs, /* power for the pwHs ("H2Osinc") pulse */
pwHd, /* H1 90 degree pulse length at tpwrd */
tpwrd, /* rf for WALTZ decoupling */
waltzB1 = getval("waltzB1"), /* waltz16 field strength (in Hz) */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
sw2 = getval("sw2"),
gt1 = getval("gt1"), /* coherence pathway gradients */
gzcal = getval("gzcal"), /* g/cm to DAC conversion factor */
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gt7 = getval("gt7"),
gstab = getval("gstab"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl6 = getval("gzlvl6"),
gzlvl7 = getval("gzlvl7");
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("mag_flg",mag_flg);
getstr("TROSY",TROSY);
getstr("h1dec",h1dec);
getstr("CT_c",CT_c);
/* LOAD PHASE TABLE */
settable(t3,2,phi3);
settable(t4,1,phx);
settable(t5,4,phi5);
if (TROSY[A]=='y')
{settable(t8,1,phy);
settable(t9,1,phx);
settable(t10,1,phy);
settable(t11,1,phx);
settable(t12,4,recT);}
else
{settable(t8,1,phx);
settable(t9,8,phi9);
settable(t10,1,phx);
settable(t11,1,phy);
settable(t12,4,rec);}
/* INITIALIZE VARIABLES */
if( dpwrf < 4095 )
{ printf("reset dpwrf=4095 and recalibrate C13 90 degree pulse");
psg_abort(1); }
/* maximum fine power for pwC pulses */
rf0 = 4095.0;
/* 90 degree pulse on Ca, null at CO 118ppm away */
pwC1 = sqrt(15.0)/(4.0*118.0*dfrq);
rf1 = (compC*4095.0*pwC)/pwC1;
rf1 = (int) (rf1 + 0.5);
/* 180 degree pulse on Ca, null at CO 118ppm away */
pwC2 = sqrt(3.0)/(2.0*118.0*dfrq);
rf2 = (4095.0*compC*pwC*2.0)/pwC2;
rf2 = (int) (rf2 + 0.5);
if( rf2 > 4095.0 )
{printf("increase pwClvl so that C13 90 < 24us*(600/sfrq)"); psg_abort(1);}
/* 180 degree one-lobe sinc pulse on CO, null at Ca 118ppm away */
rf9 = (compC*4095.0*pwC*2.0*1.65)/pwC9a; /* needs 1.65 times more */
rf9 = (int) (rf9 + 0.5); /* power than a square pulse */
/* the pwC9 pulse at the middle of t1 */
if ((ni2 > 0.0) && (ni == 1.0)) ni = 0.0;
if (pwC9a > 2.0*pwN) pwZ = pwC9a; else pwZ = 2.0*pwN;
if ((pwC9==0.0) && (pwC9a>2.0*pwN)) pwZ1=pwC9a-2.0*pwN; else pwZ1=0.0;
if (ni > 1) pwC9 = pwC9a;
if ( pwC9 > 0 ) phshift9 = 320.0;
else phshift9 = 0.0;
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /* needs 1.69 times more */
tpwrs = (int) (tpwrs); /* power than a square pulse */
/* power level and pulse time for WALTZ 1H decoupling */
pwHd = 1/(4.0 * waltzB1) ;
tpwrd = tpwr - 20.0*log10(pwHd/(compH*pw));
tpwrd = (int) (tpwrd + 0.5);
/* CHECK VALIDITY OF PARAMETER RANGES */
if ( 0.5*ni*1/(sw1) > timeTC)
{ printf(" ni is too big. Make ni less than %d . Check by using dps and make sure no ? appears for d2=t1max (ni/sw1).\n",
((int)((timeTC)*2.0*sw1-7))); psg_abort(1); }
if ( 0.5*ni2*1/(sw2) > timeTN - WFG3_START_DELAY)
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN - WFG3_START_DELAY)*2.0*sw2))); psg_abort(1);}
if ( dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' )
{ printf("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1);}
if ( dm2[A] == 'y' || dm2[B] == 'y' )
{ printf("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1);}
if ( dm3[A] == 'y' || dm3[C] == 'y' )
{ printf("incorrect dec3 decoupler flags! Should be 'nyn' or 'nnn' ");
psg_abort(1);}
if ( dpwr2 > 46 )
{ printf("dpwr2 too large! recheck value "); psg_abort(1);}
if ( pw > 20.0e-6 )
{ printf(" pw too long ! recheck value "); psg_abort(1);}
if ( pwN > 100.0e-6 )
{ printf(" pwN too long! recheck value "); psg_abort(1);}
if ( TROSY[A]=='y' && dm2[C] == 'y')
{ text_error("Choose either TROSY='n' or dm2='n' ! "); psg_abort(1);}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 2) tsadd(t3,1,4);
if (TROSY[A]=='y')
{ if (phase2 == 2) icosel = +1;
else {tsadd(t4,2,4); tsadd(t10,2,4); icosel = -1;}
}
else { if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Set up f2180 */
tau2 = d3;
if((f2180[A] == 'y') && (ni2 > 1.0))
{ tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.0; }
tau2 = tau2/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); }
if( ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{ tsadd(t8,2,4); tsadd(t12,2,4); }
/* BEGIN PULSE SEQUENCE */
status(A);
delay(d1);
if ( dm3[B] == 'y' )
{ lk_hold(); lk_sampling_off();} /*freezes z0 correction, stops lock pulsing*/
rcvroff();
obspower(tpwr);
decpower(pwClvl);
dec2power(pwNlvl);
decpwrf(rf0);
obsoffset(tof);
txphase(zero);
delay(1.0e-5);
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 and C13 magnetization*/
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
dec2rgpulse(pwN, one, 0.0, 0.0);
decrgpulse(pwC, zero, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
delay(5.0e-4);
rgpulse(pw,zero,0.0,0.0); /* 1H pulse excitation */
dec2phase(zero);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
txphase(one);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
rgpulse(pw, one, 0.0, 0.0);
if (TROSY[A]=='y')
{
txphase(two);
obspower(tpwrs);
shaped_pulse("H2Osinc",pwHs,two,5.0e-4,0.0);
obspower(tpwr);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
dec2rgpulse(pwN, zero, 0.0, 0.0);
delay(0.5*kappa - 2.0*pw);
rgpulse(2.0*pw, two, 0.0, 0.0);
dec2phase(zero);
decpwrf(rf2);
delay(timeTN - 0.5*kappa);
}
else
{
txphase(zero);
obspower(tpwrs);
shaped_pulse("H2Osinc",pwHs,zero,5.0e-4,0.0);
obspower(tpwrd);
zgradpulse(gzlvl3, gt3);
delay(2.0e-4);
dec2rgpulse(pwN, zero, 0.0, 0.0);
txphase(one);
delay(kappa - pwHd - 2.0e-6 - PRG_START_DELAY);
rgpulse(pwHd,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
obsprgon("waltz16", pwHd, 90.0); /* PRG_START_DELAY */
xmtron();
decphase(zero);
dec2phase(zero);
decpwrf(rf2);
delay(timeTN - kappa);
}
sim3pulse(0.0, pwC2, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
decphase(t3);
decpwrf(rf1);
delay(timeTN);
dec2rgpulse(pwN, zero, 0.0, 0.0);
if (TROSY[A]=='n')
{
xmtroff();
obsprgoff();
if (h1dec[0]=='y')
rgpulse(pwHd,three,2.0e-6,0.0);
else
rgpulse(pwHd,one,2.0e-6,0.0);
}
zgradpulse(gzlvl3, gt3);
txphase(one);
delay(2.0e-4);
if(h1dec[0]=='y')
{
obspower(tpwrd);
rgpulse(pwHd,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
obsprgon("waltz16", pwHd, 90.0);
xmtron();
}
if ( dm3[B] == 'y' ) /* begins optional 2H decoupling */
{
dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6);
dec3unblank();
dec3phase(zero);
delay(2.0e-6);
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
}
decrgpulse(pwC1,t3,0.0,0.0);
decphase(zero);
/* xxxxxxxxxxxxxxxxxxxxxx 13Ca EVOLUTION xxxxxxxxxxxxxxxxxx */
if (CT_c[0]=='n') {
if ((ni>1.0) && (tau1>0.0)) /* total 13C evolution equals d2 exactly */
{ /* 2.0*pwC1/PI compensates for evolution at 64% rate duting pwC1 */
decpwrf(rf9);
if(tau1 - 2.0*pwC1/PI - WFG3_START_DELAY - 0.5*pwZ > 0.0)
{
delay(tau1 - 2.0*pwC1/PI - WFG3_START_DELAY - 0.5*pwZ);
/* WFG3_START_DELAY */
sim3shaped_pulse("", "offC9", "", 0.0, pwC9a, 2.0*pwN, zero, zero, zero,
0.0, 0.0);
initval(phshift9, v9);
decstepsize(1.0);
dcplrphase(v9); /* SAPS_DELAY */
delay(tau1 - 2.0*pwC1/PI - SAPS_DELAY - 0.5*pwZ - 2.0e-6);
}
else
{
initval(180.0, v9);
decstepsize(1.0);
dcplrphase(v9); /* SAPS_DELAY */
delay(2.0*tau1 - 4.0*pwC1/PI - SAPS_DELAY - 2.0e-6);
}
}
else if (ni==1.0) /* special 1D check of pwC9 phase enabled when ni=1 */
{
decpwrf(rf9);
delay(10.0e-6 + SAPS_DELAY + 0.5*pwZ1);
/* WFG3_START_DELAY */
sim3shaped_pulse("", "offC9", "", 0.0, pwC9, 2.0*pwN, zero, zero, zero,
2.0e-6, 0.0);
initval(phshift9, v9);
decstepsize(1.0);
dcplrphase(v9); /* SAPS_DELAY */
delay(10.0e-6 + WFG3_START_DELAY + 0.5*pwZ1);
}
else /* 13Ca evolution refocused for 1st increment */
{
decpwrf(rf2);
decrgpulse(pwC2, zero, 2.0e-6, 0.0);
}
}
else { /* %%%%%%%%%%STARTING 13Ca Constant Time EVOLUTION %%%%%%%%%%%%%%%%%%*/
decpwrf(rf9);
if(tau1 - 2.0*pwC1/PI - WFG_START_DELAY -POWER_DELAY> 0.0) {
delay(tau1 -2.0*pwC1/PI -POWER_DELAY -WFG_START_DELAY);
sim3shaped_pulse("","offC9","",0.0,pwC9a, 2.0*pwN, zero, zero, zero,
0.0, 0.0);
}
else {
sim3shaped_pulse("","offC9","",0.0,pwC9a, 2.0*pwN, zero, zero, zero,
0.0, 0.0);
}
if (h1dec[0]=='n'){
delay(taud-POWER_DELAY);
obspower(tpwr);
rgpulse(2.0*pw,zero,0.0,0.0);
if ( dm3[B] == 'y' ) /* turns off 2H decoupling */
{
delay(timeTC -pwZ -2.0*WFG_STOP_DELAY -taud -2.0*pw -1/dmf3 -2.0e-6 -202.0e-6 -gt7);
setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);
dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);
dec3blank();
}
else{ /* Should be forbidden?? */
delay(timeTC -pwZ -WFG_STOP_DELAY -taud -2.0*pw -202.0e-6 -gt7);
}
}
else { /* hdec=y */
if ( dm3[B] == 'y' ) /* turns off 2H decoupling */
{
delay(timeTC -pwZ -2.0*WFG_STOP_DELAY -PRG_STOP_DELAY -pwHd -1/dmf3
-4.0e-6-202.0e-6-gt7);
xmtroff();
obsprgoff();
rgpulse(pwHd,three,2.0e-6,2.0e-6);
setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);
dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);
dec3blank();
}
else{
delay(timeTC -pwZ -WFG_STOP_DELAY -PRG_STOP_DELAY -4.0e-6 -202.0e-6
-gt7);
xmtroff();
obsprgoff();
rgpulse(pwHd,three,2.0e-6,2.0e-6);
}
}
delay(2.0e-6);
zgradpulse(gzlvl7,gt7);
delay(200.0e-6-POWER_DELAY);
decpwrf(rf2);
decrgpulse(pwC2, zero, 0.0, 0.0); /* 13Ca 180 degree pulse */
delay(2.0e-6);
zgradpulse(gzlvl7,gt7);
delay(200.0e-6);
if (h1dec[0]=='n') {
if ( dm3[B] == 'y' ) /* begins optional 2H decoupling */
{
dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6);
dec3unblank();
dec3phase(zero);
delay(2.0e-6);
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
delay(timeTC-tau1-202.0e-6-gt7-2.0*WFG_START_DELAY-1/dmf3-
2.0*POWER_DELAY-pwC9a-2.0e-6-WFG_STOP_DELAY-SAPS_DELAY);
}
else{ /* Should be forbidden??? */
delay(timeTC -tau1 - 202.0e-6 - gt7-2.0*POWER_DELAY-pwC9a-
WFG_START_DELAY-WFG_STOP_DELAY-2.0e-6-SAPS_DELAY);
}
}
else {
if (dm3[B]=='y') {
rgpulse(pwHd,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
obsprgon("waltz16", pwHd, 90.0);
xmtron();
dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6);
dec3unblank();
dec3phase(zero);
delay(2.0e-6);
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
delay(timeTC-tau1-202.0e-6-gt7-2.0*WFG_START_DELAY-4.0e-6-1/dmf3-pwHd-
PRG_START_DELAY-2.0*POWER_DELAY-pwC9a-2.0e-6-SAPS_DELAY);
}
else {
delay(2.0e-6);
rgpulse(pwHd,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
obsprgon("waltz16", pwHd, 90.0);
xmtron();
delay(timeTC-tau1-202.0e-6-gt7-4.0e-6-pwHd-PRG_START_DELAY-
2.0*POWER_DELAY-pwC9a-WFG_START_DELAY-WFG_STOP_DELAY-SAPS_DELAY);
}
}
decpwrf(rf9);
decshaped_pulse("offC9",pwC9a,zero,0.0,0.0);
initval(phshift9, v9);
decstepsize(1.0);
dcplrphase(v9); /* SAPS_DELAY */
} /* %%%%%%%%%%%%%%%%%%ENDING 13Ca Constant Time EVOLUTION %%%%%%%%%%%%%%%%%%*/
decphase(t5);
decpwrf(rf1);
decrgpulse(pwC1, t5, 2.0e-6, 0.0);
dec2phase(t8);
dcplrphase(zero);
if ( dm3[B] == 'y' ) /* turns off 2H decoupling */
{
setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);
dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);
dec3blank();
lk_autotrig(); /* resumes lock pulsing */
}
if (h1dec[0]=='y')
{
xmtroff();
obsprgoff();
rgpulse(pwHd,three,2.0e-6,0.0);
txphase(one);
}
delay(2.0e-6);
zgradpulse(gzlvl4, gt4);
delay(2.0e-4);
if (TROSY[A]=='n') {
rgpulse(pwHd,one,0.0,0.0);
txphase(zero);
delay(2.0e-6);
obsprgon("waltz16", pwHd, 90.0);
xmtron();
}
/* %%%%%%%%%%%%%%%%%%STARTING N15 Constant Time Evolution %%%%%%%%%%%%%%%%%%*/
dec2rgpulse(pwN, t8, 0.0, 0.0);
decphase(zero);
dec2phase(t9);
decpwrf(rf2);
delay(timeTN - tau2);
sim3pulse(0.0, pwC2, 2.0*pwN, zero, zero, t9, 0.0, 0.0);
dec2phase(t10);
decpwrf(rf9);
if (TROSY[A]=='y')
{ if (tau2 > gt1 + 2.0*GRADIENT_DELAY + 1.5e-4 + pwHs)
{
txphase(three);
delay(timeTN - pwC9a - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2 - gt1 - 2.0*GRADIENT_DELAY - 1.5e-4 - pwHs);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwrs); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY);
shaped_pulse("H2Osinc", pwHs, three, 0.0, 0.0);
txphase(t4);
obspower(tpwr); /* POWER_DELAY */
delay(0.5e-4 - POWER_DELAY);
}
else if (tau2 > pwHs + 0.5e-4)
{
txphase(three);
delay(timeTN-pwC9a-WFG_START_DELAY-gt1-2.0*GRADIENT_DELAY-1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwrs); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2 - pwHs - 0.5e-4);
shaped_pulse("H2Osinc", pwHs, three, 0.0, 0.0);
txphase(t4);
obspower(tpwr); /* POWER_DELAY */
delay(0.5e-4 - POWER_DELAY);
}
else
{
txphase(three);
delay(timeTN - pwC9a - WFG_START_DELAY - gt1 - 2.0*GRADIENT_DELAY
- 1.5e-4 - pwHs);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwrs); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY); /* WFG_START_DELAY */
shaped_pulse("H2Osinc", pwHs, three, 0.0, 0.0);
txphase(t4);
obspower(tpwr); /* POWER_DELAY */
delay(0.5e-4 - POWER_DELAY);
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2);
}
}
else
{
if (tau2 > kappa)
{
delay(timeTN - pwC9a - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
rgpulse(pwHd,three,2.0e-6,0.0);
txphase(t4);
delay(kappa - gt1 - 2.0*GRADIENT_DELAY - 1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY);
}
else if (tau2 > (kappa - pwC9a - WFG_START_DELAY))
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
rgpulse(pwHd,three,2.0e-6,0.0);
txphase(t4); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(kappa -pwC9a -WFG_START_DELAY -gt1 -2.0*GRADIENT_DELAY -1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY);
}
else if (tau2 > gt1 + 2.0*GRADIENT_DELAY + 1.0e-4)
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
rgpulse(pwHd,three,2.0e-6,0.0);
txphase(t4);
delay(kappa - tau2 - pwC9a - WFG_START_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2 - gt1 - 2.0*GRADIENT_DELAY - 1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY);
}
else
{
delay(timeTN + tau2 - kappa - PRG_STOP_DELAY - pwHd - 2.0e-6);
xmtroff();
obsprgoff(); /* PRG_STOP_DELAY */
rgpulse(pwHd,three,2.0e-6,0.0);
txphase(t4);
delay(kappa-tau2-pwC9a-WFG_START_DELAY-gt1-2.0*GRADIENT_DELAY-1.0e-4);
if (mag_flg[A]=='y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
obspower(tpwr); /* POWER_DELAY */
delay(1.0e-4 - POWER_DELAY); /* WFG_START_DELAY */
decshaped_pulse("offC9", pwC9a, zero, 0.0, 0.0);
delay(tau2);
}
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
if (TROSY[A]=='y') rgpulse(pw, t4, 0.0, 0.0);
else sim3pulse(pw, 0.0, pwN, t4, zero, t10, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
if (TROSY[A]=='y') delay(lambda - 0.65*(pw + pwN) - gt5);
else delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
txphase(one);
dec2phase(t11);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(pw, 0.0, pwN, one, zero, t11, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl6, gt5);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
zgradpulse(gzlvl6, gt5);
if (TROSY[A]=='y') delay(lambda - 1.6*pwN - gt5);
else delay(lambda - 0.65*pwN - gt5);
if (TROSY[A]=='y') dec2rgpulse(pwN, t10, 0.0, 0.0);
else rgpulse(pw, zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab - 0.5*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, rof1);
dec2power(dpwr2); /* POWER_DELAY */
if (mag_flg[A] == 'y') magradpulse(icosel*gzcal*gzlvl2, gt1/10.0);
else zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
rcvron();
statusdelay(C,1.0e-4 - rof1);
if (dm3[B]=='y') lk_sample();
setreceiver(t12);
}
pulsesequence()
{
char f1180[MAXSTR],
f2180[MAXSTR],
f3180[MAXSTR],
mag_flg[MAXSTR];
int phase, icosel,
t1_counter,
t2_counter,
t3_counter;
double pwClvl,
pwC,
rf0 = 4095,
rfst,
compC = getval("compC"),
tpwrs,
pwHs = getval("pwHs"),
compH = getval("compH"),
pwNlvl,
pwN,
tau1,
tau2,
tau3,
tauch, /* 3.4 ms */
taunh, /* 2.4 ms */
mix,
tofh,
dofcaco, /* ~120 ppm */
gt0, gzlvl0,
gt1,gzlvl1,
gzlvl2,
gzcal = getval("gzcal"),
gstab = getval("gstab"),
gt3,gzlvl3,
gt4,gzlvl4,
gt5,gzlvl5,
gt6,gzlvl6,
gt7,gzlvl7,
gt8, gzlvl8,
gt9, gzlvl9;
/* LOAD VARIABLES */
getstr("f1180",f1180);
getstr("f2180",f2180);
getstr("f3180",f3180);
getstr("mag_flg", mag_flg);
pwClvl = getval("pwClvl");
pwC = getval("pwC");
pwNlvl = getval("pwNlvl");
pwN = getval("pwN");
mix = getval("mix");
tauch = getval("tauch");
taunh = getval("taunh");
sw1 = getval("sw1");
sw2 = getval("sw2");
sw3 = getval("sw3");
phase = (int) (getval("phase") + 0.5);
phase2 = (int) (getval("phase2") + 0.5);
phase3 = (int) (getval("phase3") + 0.5);
gt0 = getval("gt0");
gt1 = getval("gt1");
gt3 = getval("gt3");
gt4 = getval("gt4");
gt5 = getval("gt5");
gt6 = getval("gt6");
gt7 = getval("gt7");
gt8 = getval("gt8");
gt9 = getval("gt9");
gzlvl0 = getval("gzlvl0");
gzlvl1 = getval("gzlvl1");
gzlvl2 = getval("gzlvl2");
gzlvl3 = getval("gzlvl3");
gzlvl4 = getval("gzlvl4");
gzlvl5 = getval("gzlvl5");
gzlvl6 = getval("gzlvl6");
gzlvl7 = getval("gzlvl7");
gzlvl8 = getval("gzlvl8");
gzlvl9 = getval("gzlvl9");
setautocal(); /* activate auto-calibration flags */
if (autocal[0] == 'n')
{
tofh = getval("tofh");
dofcaco = getval("dofcaco"); /* ~120 ppm */
/* 180 degree adiabatic C13 pulse from 0 to 200 ppm */
rfst = (compC*4095.0*pwC*4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35));
rfst = (int) (rfst + 0.5);
if (1.0/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35)) < pwC )
{
text_error( " Not enough C13 RF. pwC must be %f usec or less.\n",
(1.0e6/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35))) );
psg_abort(1);
}
}
else /* if autocal = 'y'(yes), 'q'(quiet), r(read), or 's'(semi) */
{
if(FIRST_FID) /* call Pbox */
{
ppm = getval("dfrq"); ofs = 0.0; pws = 0.001; /* 1 ms long pulse */
bw = 200.0*ppm; nst = 1000; /* nst - number of steps */
stC200 = pbox_makeA("stC200", "sech", bw, pws, ofs, compC*pwC, pwClvl, nst);
ofs_check(H1ofs, C13ofs, N15ofs, H2ofs);
ofs = getval("tof") - 1.75*getval("sfrq");
pws = getval("dof") + 85.0*ppm;
}
rfst = stC200.pwrf;
tofh = ofs;
dofcaco = pws;
}
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69));
tpwrs = (int)(tpwrs+0.5);
/* check validity of parameter range */
if((dm[A] == 'y' || dm[C] == 'y'))
{
printf("incorrect Dec1 decoupler flags! ");
psg_abort(1);
}
if((dm2[A] == 'y' || dm2[B] == 'y'))
{
printf("incorrect Dec2 decoupler flags! ");
psg_abort(1);
}
if ((dpwr > 50) || (dpwr2 > 50))
{
printf("don't fry the probe, dpwr too high! ");
psg_abort(1);
}
/* Load phase cycling variables */
settable(t1, 4, phi1);
settable(t2, 2, phi2);
settable(t3, 1, phi3);
settable(t4, 8, phi4);
settable(t5, 1, phi5);
settable(t11, 8, rec_1);
/* Phase incrementation for hypercomplex data */
if ( phase == 2 )
{
tsadd(t1,1,4);
}
if ( phase2 == 2 )
{
tsadd(t2,1,4);
}
if ( phase3 == 1 )
{
tsadd(t5,2,4);
icosel = 1;
}
else icosel = -1;
/* calculate modification to phases based on current t2 values
to achieve STATES-TPPI acquisition */
if(ix == 1) d2_init = d2;
t1_counter = (int)((d2-d2_init)*sw1 + 0.5);
if(t1_counter % 2)
{
tsadd(t1,2,4);
tsadd(t11,2,4);
}
if(ix == 1) d3_init = d3;
t2_counter = (int)((d3-d3_init)*sw2 + 0.5);
if(t2_counter % 2)
{
tsadd(t2,2,4);
tsadd(t11,2,4);
}
if(ix == 1) d4_init = d4;
t3_counter = (int)((d4-d4_init)*sw3 + 0.5);
if(t3_counter % 2)
{
tsadd(t3,2,4);
tsadd(t11,2,4);
}
/* set up so that get (90, -180) phase corrects in F1 if f1180 flag is 'y' */
tau1 = d2;
if(f1180[A] == 'y')
{
tau1 += (1.0/(2.0*sw1));
}
if (tau1 < 0.2e-6) tau1 = 0.0;
tau1 = tau1/2.0;
/* set up so that get (90, -180) phase corrects in F2 if f2180 flag is 'y' */
tau2 = d3 - (4.0*pwC/PI + 2.0*pw + 2.0e-6);
if (dm[B] == 'y')
{
tau2 = tau2 - (2.0*POWER_DELAY + PRG_START_DELAY + PRG_STOP_DELAY);
}
if(f2180[A] == 'y')
{
tau2 += (1.0/(2.0*sw2));
}
if (tau2 < 0.2e-6) tau2 = 0.0;
tau2 = tau2/2.0;
/* set up so that get (90, -180) phase corrects in F3 if f3180 flag is 'y' */
tau3 = d4;
if(f3180[A] == 'y')
{
tau3 += (1.0/(2.0*sw3));
}
if (tau3 < 0.2e-6) tau3 = 0.0;
tau3 = tau3/2.0;
initval(315.0, v7);
obsstepsize(1.0);
/* BEGIN ACTUAL PULSE SEQUENCE */
status(A);
delay(10.0e-6);
obspower(tpwr);
decpower(pwClvl);
decpwrf(rf0);
dec2power(pwNlvl);
obsoffset(tofh);
decoffset(dof);
dec2offset(dof2);
txphase(t1);
xmtrphase(v7);
delay(d1);
if (gt0 > 0.2e-6)
{
decrgpulse(pwC,zero,2.0e-6,0.0);
dec2rgpulse(pwN,zero,2.0e-6,0.0);
zgradpulse(gzlvl0,gt0);
delay(1.0e-3);
}
decphase(t2);
rgpulse(pw,t1,2.0e-6,0.0);
xmtrphase(zero);
zgradpulse(gzlvl3,gt3);
delay(tauch - gt3);
decrgpulse(pwC,t2,2.0e-6,0.0);
status(B);
decpower(dpwr);
delay(tau2);
rgpulse(2.0*pw,t1,0.0,0.0);
decphase(zero);
if (tau2 > 2.0*pwN)
{
dec2rgpulse(2.0*pwN,zero,0.0,0.0);
delay(tau2 - 2.0*pwN);
}
else
delay(tau2);
status(A);
decpower(pwClvl);
decrgpulse(pwC,zero, 2.0e-6,2.0e-6);
txphase(zero);
delay(tauch + tau1 + SAPS_DELAY - gt3 - 4.0*pwC - 500.0e-6);
zgradpulse(gzlvl3,gt3);
delay(500.0e-6);
decrgpulse(pwC,zero,0.0, 0.0);
decphase(one);
decrgpulse(2.0*pwC, one, 0.2e-6, 0.0);
decphase(zero);
decrgpulse(pwC, zero, 0.2e-6, 0.0);
delay(tau1);
rgpulse(pw,zero,0.0,0.0);
delay(mix - gt4 - gt5 - pwN - 2.0e-3);
obsoffset(tof);
zgradpulse(gzlvl4,gt4);
delay(1.0e-3);
sim3pulse((double)0.0,pwC,pwN,zero,zero,zero,0.0,2.0e-6);
zgradpulse(gzlvl5,gt5);
delay(1.0e-3);
rgpulse(pw,zero,0.0,2.0e-6);
zgradpulse(gzlvl6,gt6);
delay(taunh - gt6 - 2.0e-6);
sim3pulse(2.0*pw,(double)0.0,2*pwN,zero,zero,zero,0.0,0.0);
delay(taunh - gt6 - 500.0e-6);
zgradpulse(gzlvl6,gt6);
txphase(one);
delay(500.0e-6);
rgpulse(pw,one,0.0,0.0);
txphase(two);
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, two, 2.0e-6, 2.0e-6);
obspower(tpwr);
zgradpulse(gzlvl7,gt7);
dec2phase(t3);
decoffset(dofcaco);
decpwrf(rfst);
delay(200.0e-6);
dec2rgpulse(pwN,t3,0.0,0.0);
dec2phase(t4);
delay(tau3);
rgpulse(2.0*pw, zero, 0.0, 0.0);
decshaped_pulse("stC200", 1.0e-3, zero, 0.0, 0.0);
delay(tau3);
delay(gt1 + 202.0e-6 - 1.0e-3 - 2.0*pw);
dec2rgpulse(2.0*pwN, t4, 0.0, 2.0e-6);
dec2phase(t5);
if(mag_flg[A] == 'y')
{
magradpulse(gzcal*gzlvl1, gt1);
}
else
{
zgradpulse(gzlvl1, gt1);
delay(4.0*GRADIENT_DELAY);
}
delay(200.0e-6 + WFG_START_DELAY + WFG_STOP_DELAY - 6.0*GRADIENT_DELAY);
sim3pulse(pw, 0.0, pwN, zero, zero, t5, 0.0, 2.0e-6);
dec2phase(zero);
zgradpulse(gzlvl8, gt8);
delay(taunh - gt8);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
delay(taunh - gt8 - 400.0e-6);
zgradpulse(gzlvl8, gt8);
txphase(one);
dec2phase(one);
delay(400.0e-6);
sim3pulse(pw, 0.0, pwN, one, zero, one, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl9, gt9);
delay(taunh - gt9);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl9, gt9);
delay(taunh - gt9);
rgpulse(pw, zero, 0.0, 0.0);
delay((gt1/10.0) + gstab - 0.5*pw + 6.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, 0.0);
if(mag_flg[A] == 'y')
{
magradpulse(icosel*gzcal*gzlvl2, gt1/10.0);
}
else
{
zgradpulse(icosel*gzlvl2, gt1/10.0);
delay(4.0*GRADIENT_DELAY);
}
dec2power(dpwr2);
delay(gstab);
status(C);
setreceiver(t11);
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
CT[MAXSTR],
refocN15[MAXSTR],
refocCO[MAXSTR], COshape[MAXSTR],
C180shape[MAXSTR];
int t1_counter,icosel; /* used for states tppi in t1 */
double tau1, /* t1 delay */
tauch = getval("tauch"), /* 1/4J evolution delay */
tauch1 = getval("tauch1"), /* 1/4J or 1/8JC13H evolution delay */
timeCC = getval("timeCC"), /* 13C constant-time if needed*/
corrD, corrB, /* small correction delays */
dof_dec = getval("dof_dec"), /*decoupler offset for decoupling during acq - folding */
pwClvl = getval("pwClvl"), /* power for hard C13 pulses */
pwC180lvl = getval("pwC180lvl"), /*power levels for 180 shaped pulse */
pwC180lvlF = getval("pwC180lvlF"),
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
pwC180 = getval("pwC180"), /* shaped 180 pulse on C13channl */
sw1 = getval("sw1"),
pwNlvl = getval("pwNlvl"),
pwN = getval("pwN"),
pwCOlvl = getval("pwCOlvl"),
pwCO = getval("pwCO"),
gstab = getval("gstab"),
gstab1 = getval("gstab1"), /* recovery for club sandwitch, short*/
gt0 = getval("gt0"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gt3 = getval("gt3"), /* other gradients */
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gt9 = getval("gt9"),
gzlvl0 = getval("gzlvl0"),
gzlvl2 = getval("gzlvl2"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl9 = getval("gzlvl9");
getstr("f1180",f1180);
getstr("C180shape",C180shape);
getstr("COshape",COshape);
getstr("refocCO",refocCO);
getstr("refocN15",refocN15);
getstr("CT",CT);
/* LOAD PHASE TABLE */
settable(t2,2,phi2);
settable(t3,1,phi3);
settable(t4,1,phi4);
settable(t10,1,phix);
settable(t11,4,rec);
/* INITIALIZE VARIABLES */
/* CHECK VALIDITY OF PARAMETER RANGES */
/* like in olde good times */
if((dm[A] == 'y' || dm[B] == 'y'))
{
text_error("incorrect dec1 decoupler flags! Should be 'nnn' or 'nny' ");
psg_abort(1);
}
if((dm2[A] != 'n' || dm2[B] != 'n' || dm2[C] != 'n'))
{
text_error("incorrect dec2 decoupler flags! Should be 'nnn' ");
psg_abort(1);
}
if( dpwr2 > 45 )
{
text_error("don't fry the probe, DPWR2 too large! ");
psg_abort(1);
}
if( dpwr > 50 )
{
text_error("don't fry the probe, DPWR too large! ");
psg_abort(1);
}
if( (pw > 30.0e-6) )
{
text_error("don't fry the probe, pw too high ! ");
psg_abort(1);
}
if( (pwC > 200.0e-6) )
{
text_error("don't fry the probe, pwC too high ! ");
psg_abort(1);
}
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-TPPI-Haberkorn element */
if (phase1 == 1) {
tsadd(t10,2,4);
icosel = +1;
}
else {
icosel = -1;
}
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{
tsadd(t2,2,4);
tsadd(t11,2,4);
}
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 0.0))
{
tau1 += ( 1.0 / (2.0*sw1) );
if(tau1 < 0.2e-6) tau1 = 0.0;
}
tau1 = tau1/2.0;
if(CT[A]=='y') {
refocN15[A]='y';
refocCO[A]='y';
if ( (timeCC-ni/sw1*0.5)*0.5 -pw -pwCO*0.5 -pwN-rof1 <0.2e-6 )
{
text_error("too many increments in t1 for a constant time");
psg_abort(1);
}
}
/*temporary*/
/* correction delays */
corrB=0.0;
corrD=2.0/M_PI*pwC-pw-rof1;
if (corrD < 0.0) {
corrB=-corrD;
corrD=0.0;
}
/* BEGIN PULSE SEQUENCE */
status(A);
obsoffset(tof);
obspower(tpwr);
decpower(pwClvl);
decpwrf(4095.0);
decoffset(dof);
obspwrf(4095.0);
delay(d1);
txphase(zero);
decphase(zero);
decrgpulse(pwC, zero, rof1, rof1);
zgradpulse(gzlvl0, gt0);
delay(2.0*gstab);
delay(5.0e-3);
/************ H->C13 */
txphase(zero);
decphase(zero);
rgpulse(pw,zero,rof1,rof1);
decpower(pwC180lvl);
decpwrf(pwC180lvlF);
delay(gstab);
zgradpulse(gzlvl5, gt5);
delay(tauch - gt5 -gstab);
simshaped_pulse("hard",C180shape,2.0*pw,pwC180,zero,zero, 0.0, 0.0);
decpower(pwClvl);
decpwrf(4095.0);
txphase(one);
delay(tauch - gt5-gstab);
zgradpulse(gzlvl5, gt5);
delay(gstab);
rgpulse(pw, one, rof1,rof1);
/*** purge */
dec2power(pwNlvl);
dec2pwrf(4095.0);
txphase(zero);
decphase(t2);
delay(gstab);
zgradpulse(gzlvl2, gt2);
delay(3.0*gstab);
/* evolution on t1 */
/* real time here */
if(CT[A]=='n')
{
decrgpulse(pwC, t2, 0.0, 0.0);
decphase(zero);
decpower(pwC180lvl);
decpwrf(pwC180lvlF);
delay(tau1);
obsunblank();
rgpulse(pw,one,rof1,0.0);
rgpulse(2.0*pw,zero,0.0,0.0);
rgpulse(pw,one,0.0,rof1);
obsblank();
if(refocN15[A]=='y') dec2rgpulse(2.0*pwN,zero,0.0,0.0); /*n15 refocusing */
if(refocCO[A]=='y')
{
decpower(pwCOlvl);
decshaped_pulse(COshape,pwCO,zero, 3.0e-6, 3.0e-6);
decpower(pwC180lvl);
}
delay(tau1);
/*************** CODING with CLUB sandwitches and BIPS */
zgradpulse(gzlvl3*icosel, gt3);
delay(gstab1);
decshaped_pulse(C180shape,pwC180,zero, 0.0, 0.0);
zgradpulse(-gzlvl3*icosel, gt3);
delay(gstab1 +rof1*2.0+pw*4.0 +pwC*4.0/M_PI +2.0*POWER_DELAY+2.0*PWRF_DELAY);
if(refocN15[A]=='y') delay(2.0*pwN); /*n15 refocusing */
if(refocCO[A]=='y') /* ghost CO pulse */
{
decpower(pwCOlvl);
decshaped_pulse(COshape,pwCO,zero, 3.0e-6, 3.0e-6);
decpower(pwC180lvl);
}
zgradpulse(-gzlvl3*icosel, gt3);
delay(gstab1);
decshaped_pulse(C180shape,pwC180,zero, 0.0, 0.0);
zgradpulse( gzlvl3*icosel, gt3);
decpower(pwClvl);
decpwrf(4095.0);
delay(gstab1);
} /* end of if bracket for real-time */
/*^^^^^^^ end of real time */
/* CONSTANT TIME VESION: */
if(CT[A]=='y')
{
decrgpulse(pwC, t2, 0.0, 0.0);
/* timeCC-t1 evolution */
decpower(pwC180lvl);
decpwrf(pwC180lvlF);
delay((timeCC-tau1)*0.5 -2.0*pw -pwCO*0.5 -pwN-rof1);
obsunblank();
rgpulse(pw,one,rof1,0.0);
rgpulse(2.0*pw,zero,0.0,0.0);
rgpulse(pw,one,0.0,rof1);
obsblank();
if(refocN15[A]=='y') dec2rgpulse(2.0*pwN,zero,0.0,0.0); /*n15 refocusing */
if(refocCO[A]=='y' )
{
decpower(pwCOlvl);
decshaped_pulse(COshape,pwCO,zero, 3.0e-6, 3.0e-6);
decpower(pwC180lvl);
}
delay((timeCC-tau1)*0.5 -2.0*pw -pwCO*0.5 -pwN-rof1);
/* end of timeCC-t1 evolution */
/* 180 on carbons in T1 */
decshaped_pulse(C180shape,pwC180,zero, 0.0, 0.0);
/* timeCC+t1 evolution + encoding */
delay((timeCC+tau1)*0.5 -2.0*pw -pwCO*0.5 -pwN -rof1);
obsunblank();
rgpulse(pw,one,rof1,0.0);
rgpulse(2.0*pw,zero,0.0,0.0);
rgpulse(pw,one,0.0,rof1);
obsblank();
if(refocN15[A]=='y') dec2rgpulse(2.0*pwN,zero,0.0,0.0); /*n15 refocusing */
if(refocCO[A]=='y' )
{
decpower(pwCOlvl);
decshaped_pulse(COshape,pwCO,zero, 3.0e-6, 3.0e-6);
decpower(pwC180lvl);
}
delay((timeCC+tau1)*0.5 -2.0*pw -pwCO*0.5 -pwN -rof1);
zgradpulse(-gzlvl3*icosel, gt3*2.0); /* coding */
delay(gstab +pwC*4.0/M_PI);
decshaped_pulse(C180shape,pwC180,zero, 2e-6, 2e-6); /* ghost BIP pulse */
zgradpulse(gzlvl3*icosel, gt3*2.0); /* coding */
delay(gstab);
} /*^^^^^^^ end of CONSTANT time bracket*/
/*reverse INPET */
simpulse(pw, pwC, zero, t10, 0.0, 0.0);
delay(gstab);
zgradpulse(gzlvl4,gt4);
decpower(pwC180lvl);
decpwrf(pwC180lvlF);
delay(tauch - gt4 - gstab -corrD-pwC180 -POWER_DELAY-PWRF_DELAY);
decshaped_pulse(C180shape,pwC180,zero, 0.0, 0.0);
delay(corrD);
rgpulse(2.0*pw,zero,rof1,rof1);
zgradpulse(gzlvl4,gt4);
delay(tauch - gt4 - gstab -corrB-pwC180 -POWER_DELAY-PWRF_DELAY);
delay(gstab);
decphase(one);
txphase(one);
decshaped_pulse(C180shape,pwC180,zero, 0.0, 0.0);
decpower(pwClvl);
decpwrf(4095.0);
delay(corrB);
simpulse(pw, pwC, one, one, 0.0, 0.0);
decpower(pwC180lvl);
decpwrf(pwC180lvlF);
delay(gstab-POWER_DELAY-PWRF_DELAY -WFG_START_DELAY);
zgradpulse(gzlvl5,gt5);
delay(tauch1 - gt5 - gstab);
simshaped_pulse("hard",C180shape,2.0*pw,pwC180,zero,zero, 0.0, 0.0);
delay(tauch1- gt5 - gstab - WFG_STOP_DELAY);
zgradpulse(gzlvl5,gt5);
delay(gstab-rof1);
rgpulse(pw, zero,rof1,rof1);
/* echo and decoding */
delay(gstab+gt9-rof1+10.0e-6 + 2.0*POWER_DELAY+PWRF_DELAY +2.0*GRADIENT_DELAY);
decoffset(dof_dec);
rgpulse(2.0*pw, zero,rof1,rof1);
delay(10.0e-6);
zgradpulse(gzlvl9,gt9);
decpower(dpwr);
decpwrf(4095.0);
decoffset(dof_dec);
dec2power(dpwr2); /* POWER_DELAY EACH */
delay(gstab);
status(C);
setreceiver(t11);
}
pulsesequence()
{
char
shname1[MAXSTR],
f1180[MAXSTR],
f2180[MAXSTR],
SE_flg[MAXSTR],
dec_flg[MAXSTR],
CT_flg[MAXSTR];
int icosel=1,
t1_counter,
t2_counter,
ni2 = getval("ni2"),
phase;
double d2_init=0.0,
d3_init=0.0,
pwS1,pwS2,pwS3,pwS4,pwS5,pwS6,
lambda = getval("lambda"),
CTdelay = getval("CTdelay"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5"),
gzlvl6 = getval("gzlvl6"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gt6 = getval("gt6"),
gstab = getval("gstab"),
tpwrsf = getval("tpwrsf"),
shlvl1,
shpw1,
pwClvl = getval("pwClvl"),
pwC = getval("pwC"),
pwNlvl = getval("pwNlvl"),
pwN = getval("pwN"),
dpwr2 = getval("dpwr2"),
d2 = getval("d2"),
shbw = getval("shbw"),
shofs = getval("shofs")-4.77,
timeTN = getval("timeTN"),
tauC = getval("tauC"),
tau1 = getval("tau1"),
tau2 = getval("tau2"),
taunh = getval("taunh");
getstr("shname1", shname1);
getstr("SE_flg",SE_flg);
getstr("dec_flg",dec_flg);
getstr("CT_flg",CT_flg);
getstr("f1180",f1180);
getstr("f2180",f2180);
phase = (int) (getval("phase") + 0.5);
settable(t1,2,phi1);
settable(t3,4,phi3);
settable(t10,1,phi10);
settable(t12,4,phi12);
settable(t13,4,phi13);
/* INITIALIZE VARIABLES */
shpw1 = pw*8.0;
shlvl1 = tpwr;
pwS1 = c13pulsepw("co", "ca", "sinc", 90.0);
pwS2 = c13pulsepw("co", "ca", "sinc", 180.0);
pwS3 = c13pulsepw("ca", "co", "square", 180.0);
pwS4 = h_shapedpw("eburp2",shbw,shofs,zero, 0.0, 0.0);
pwS6 = h_shapedpw("reburp",shbw,shofs,zero, 0.0, 0.0);
pwS5 = h_shapedpw("pc9f",shbw,shofs,zero, 2.0e-6, 0.0);
if (SE_flg[0] == 'y')
{
if ( ni2*1/(sw2)/2.0 > (timeTN-pwS2*0.5-pwS4))
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN-pwS2*0.5-pwS4)*2.0*sw2))); psg_abort(1);}
}
else
{
if ( ni2*1/(sw2)/2.0 > (timeTN-pwS2*0.5))
{ printf(" ni2 is too big. Make ni2 equal to %d or less.\n",
((int)((timeTN-pwS2*0.5)*2.0*sw2))); psg_abort(1);}
}
if (CT_flg[0] == 'y')
{
if ( ni*1/(sw1) > (CTdelay))
{ printf(" ni is too big. Make ni equal to %d or less.\n",
((int)(CTdelay*sw1))); psg_abort(1);}
}
if (phase == 1) ;
if (phase == 2) tsadd(t1,1,4);
if (SE_flg[0] =='y')
{
if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
else
{
if (phase2 == 2) tsadd(t3,1,4);
}
tau1 = d2;
if((f1180[A] == 'y') )
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1;
tau2 = d3;
if((f2180[A] == 'y') )
{ tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.0; }
tau2 = tau2;
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t1,2,4); tsadd(t12,2,4); tsadd(t13,2,4); }
if( ix == 1) d3_init = d3;
t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 );
if(t2_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); tsadd(t13,2,4); }
status(A);
rcvroff();
decpower(pwClvl);
decoffset(dof);
dec2power(pwNlvl);
dec2offset(dof2);
obspwrf(tpwrsf);
decpwrf(4095.0);
obsoffset(tof);
set_c13offset("co");
zgradpulse(gzlvl2, gt2);
delay(1.0e-4);
delay(d1-gt2);
lk_hold();
h_shapedpulse("pc9f",shbw,shofs,zero, 2.0e-6, 0.0);
delay(lambda-pwS5*0.5-pwS6*0.4);
h_sim3shapedpulse("reburp",shbw,shofs,0.0,2.0*pwN, one, zero, zero, 0.0, 0.0);
delay(lambda-pwS5*0.5-pwS6*0.4);
h_shapedpulse("pc9f_",shbw,shofs,one, 0.0, 0.0);
obspower(shlvl1);
/**************************************************************************/
dec2rgpulse(pwN,zero,0.0,0.0);
zgradpulse(gzlvl6,gt6);
delay(timeTN-pwS2*0.5-gt6);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(timeTN-pwS2*0.5-taunh*0.5-shpw1);
shaped_pulse(shname1,shpw1,two,0.0,0.0);
zgradpulse(gzlvl6, gt6);
delay(taunh*0.5-gt6);
dec2rgpulse(pwN,zero,0.0,0.0);
shaped_pulse(shname1,shpw1,zero,0.0,0.0);
/**************************************************************************/
/*** CO -> CA transfer *********************************/
/**************************************************************************/
c13pulse("co", "ca", "sinc", 90.0, zero, 2.0e-6, 0.0);
zgradpulse(-gzlvl4, gt4);
decphase(zero);
delay(tauC - gt4 - 0.5*10.933*pwC);
decrgpulse(pwC*158.0/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*171.2/90.0, two, 0.0, 0.0);
decrgpulse(pwC*342.8/90.0, zero, 0.0, 0.0); /* Shaka 6 composite */
decrgpulse(pwC*145.5/90.0, two, 0.0, 0.0);
decrgpulse(pwC*81.2/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*85.3/90.0, two, 0.0, 0.0);
zgradpulse(-gzlvl4, gt4);
decphase(one);
delay(tauC - gt4 - 0.5*10.933*pwC - WFG_START_DELAY - 2.0e-6);
c13pulse("co", "ca", "sinc", 90.0, one, 2.0e-6, 0.0);
/**************************************************************************/
/* xxxxxxxxxxxxxxxxxxxx 13Ca EVOLUTION xxxxxxxxxxxxxxxxxx */
/**************************************************************************/
set_c13offset("ca");
if (CT_flg[0] == 'y')
{
c13pulse("ca", "co", "square", 90.0, t1, 2.0e-6, 0.0);
delay(tau1*0.5);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 0.0, 0.0);
delay(CTdelay*0.5);
c13pulse("cab", "co", "square", 180.0, zero, 0.0, 0.0);
delay((CTdelay-tau1)*0.5);
c13pulse("co", "ca", "sinc", 180.0, zero, 0.0, 0.0);
c13pulse("ca", "co", "square", 90.0, zero, 0.0, 0.0);
}
else
{
if (dec_flg[0] == 'y')
{
c13pulse("ca", "co", "square", 90.0, t1, 2.0e-6, 2.0e-6);
delay(tau1*0.5);
c_shapedpulse2("isnob5",30.0,-31.0,"isnob5",30.0,120.0 , zero, 0.0, 0.0);
dec2rgpulse(pwN*2.0,zero,0.0,0.0);
delay(tau1*0.5);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
dec2rgpulse(pwN*2.0,two,0.0,0.0);
c_shapedpulse2("isnob5",30.0,-31.0,"isnob5",30.0,120.0 , two, 0.0, 0.0);
c13pulse("ca", "co", "square", 90.0, zero, 2.0e-6, 2.0e-6);
}
else
{
c13pulse("ca", "co", "square", 90.0, t1, 2.0e-6, 2.0e-6);
delay(tau1*0.5);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(tau1*0.5);
c13pulse("ca", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6);
c13pulse("co", "ca", "sinc", 180.0, zero, 2.0e-6, 2.0e-6);
if (pwN*2.0 > pwS2) delay(pwN*2.0 - pwS2);
c13pulse("ca", "co", "square", 90.0, zero, 2.0e-6, 2.0e-6);
}
}
set_c13offset("co");
zgradpulse(gzlvl3, gt3);
delay(1.0e-4);
/**************************************************************************/
/*** CO -> CA transfer *********************************/
/**************************************************************************/
c13pulse("co", "ca", "sinc", 90.0, one, 2.0e-6, 0.0);
zgradpulse(gzlvl4, gt4*0.7);
delay(tauC - gt4*0.7 - 0.5*10.933*pwC);
decrgpulse(pwC*158.0/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*171.2/90.0, two, 0.0, 0.0);
decrgpulse(pwC*342.8/90.0, zero, 0.0, 0.0); /* Shaka 6 composite */
decrgpulse(pwC*145.5/90.0, two, 0.0, 0.0);
decrgpulse(pwC*81.2/90.0, zero, 0.0, 0.0);
decrgpulse(pwC*85.3/90.0, two, 0.0, 0.0);
zgradpulse(gzlvl4, gt4*0.7);
delay(tauC - gt4*0.7 - 0.5*10.933*pwC - WFG_START_DELAY - 2.0e-6);
/* WFG_START_DELAY */
c13pulse("co", "ca", "sinc", 90.0, zero, 2.0e-6, 0.0);
/**************************************************************************/
obspower(shlvl1);
shaped_pulse(shname1,shpw1,zero,0.0,0.0);
dec2rgpulse(pwN,t3,0.0,0.0);
if (SE_flg[0] == 'y')
{
delay(tau2*0.5);
c13pulse("ca", "co", "square", 180.0, zero, 0.0, 0.0);
delay(taunh*0.5-pwS3);
shaped_pulse(shname1,shpw1,two,0.0,0.0);
delay(timeTN-pwS2*0.5-shpw1-taunh*0.5-gt1-1.0e-4);
zgradpulse(-gzlvl1, gt1);
delay(1.0e-4);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(timeTN-pwS2*0.5-tau2*0.5-pwS4);
h_shapedpulse("eburp2",shbw,shofs,zero, 2.0e-6, 0.0);
dec2rgpulse(pwN, t10, 0.0, 0.0);
}
else
{
delay(tau2*0.5);
c13pulse("ca", "co", "square", 180.0, zero, 0.0, 0.0);
delay(taunh*0.5-pwS3);
shaped_pulse(shname1,shpw1,two,0.0,0.0);
delay(timeTN-pwS2*0.5-taunh*0.5-shpw1);
sim3_c13pulse("", "co", "ca", "sinc", "", 0.0, 180.0, 2.0*pwN,
zero, zero, zero, 2.0e-6, 2.0e-6);
delay(timeTN-pwS2*0.5-tau2*0.5);
dec2rgpulse(pwN, zero, 0.0, 0.0);
}
/**************************************************************************/
if (SE_flg[0] == 'y')
{
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
h_sim3shapedpulse("reburp",shbw,shofs,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
dec2rgpulse(pwN, one, 0.0, 0.0);
h_shapedpulse("eburp2_",shbw,shofs,one, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
delay(lambda-pwS4*0.5-pwS6*0.4);
h_sim3shapedpulse("reburp",shbw,shofs,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
delay(lambda-pwS4*0.5-pwS6*0.4);
h_shapedpulse("eburp2",shbw,shofs,zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab + 2.0*GRADIENT_DELAY + POWER_DELAY);
h_shapedpulse("reburp",shbw,shofs,zero, 0.0, rof2);
zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */
delay(gstab);
}
else
{
h_shapedpulse("eburp2",shbw,shofs,zero, 2.0e-6, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5);
h_sim3shapedpulse("reburp",shbw,shofs,0.0,2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
delay(lambda-pwS6*0.4 - gt5-POWER_DELAY-1.0e-4);
}
dec2power(dpwr2); /* POWER_DELAY */
lk_sample();
if (SE_flg[0] == 'y')
setreceiver(t13);
else
setreceiver(t12);
rcvron();
statusdelay(C,1.0e-4 );
}
void pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
mag_flg[MAXSTR], /* magic-angle coherence transfer gradients */
bottom[MAXSTR],
right[MAXSTR],
C13refoc[MAXSTR]; /* C13 sech/tanh pulse in middle of t1*/
int t1_counter; /* used for states tppi in t1 */
double tau1, /* t1 delay */
lambda = 0.91/(4.0*getval("JNH")), /* 1/4J H1 evolution delay */
timeT = getval("timeT"), /* HN->N transfer time: T=15-20ms */
/* the sech/tanh pulse is automatically calculated by the macro "rna_cal", */
/* and is called directly from your shapelib. */
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rfC, /* maximum fine power when using pwC pulses */
rfst, /* fine power for the stCall pulse */
compH = getval("compH"), /* adjustment for H1 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
tpwrs, /* power for the pwHs ("H2Osinc") pulse */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
sw1 = getval("sw1"),
grecov = getval("grecov"), /* Gradient recovery delay, typically 150-200us */
gt1 = getval("gt1"), /* coherence pathway gradients */
gzcal = getval("gzcal"), /* dac to G/cm conversion */
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gt5 = getval("gt5"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl5 = getval("gzlvl5");
getstr("mag_flg",mag_flg);
getstr("f1180",f1180);
getstr("C13refoc",C13refoc);
getstr("bottom",bottom);
getstr("right",right);
/* LOAD PHASE TABLE */
settable(t3,4,phi3);
/*settable(t4,1,ph_y);*/
settable(t1,1,phx);
settable(t5,8,phi5);
settable(t6,16,phi6);
if (bottom[A]=='y')
{
settable(t4,1,ph_y);
settable(t7,1,phy);
}
else
{
settable(t4,1,phy);
settable(t7,1,ph_y);
}
if (right[A]=='y')
settable(t10,1,ph_x);
else
settable(t10,1,phx);
settable(t9,1,phx);
settable(t11,1,phy);
settable(t12,4,recT);
/* INITIALIZE VARIABLES */
/* maximum fine power for pwC pulses (and initialize rfst) */
rfC = 4095.0; rfst=0.0;
/* 180 degree adiabatic C13 pulse covers 140ppm */
if (C13refoc[A]=='y')
{rfst = (compC*4095.0*pwC*4000.0*sqrt((21.0*sfrq/600.0+7.0)/0.35));
rfst = (int) (rfst + 0.5);
if ( 1.0/(4000.0*sqrt((21.0*sfrq/600.0+7.0)/0.35)) < pwC )
{ text_error( " Not enough C13 RF. pwC must be %f usec or less.\n",
(1.0e6/(4000.0*sqrt((21.0*sfrq/600.0+7.0)/0.35))) ); psg_abort(1); }}
/* selective H20 one-lobe sinc pulse */
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /*needs 1.69 times more*/
tpwrs = (int) (tpwrs); /*power than a square pulse */
/* CHECK VALIDITY OF PARAMETER RANGES */
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{ text_error("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1); }
if((dm2[A] == 'y' || dm2[B] == 'y' || dm2[C] == 'y' ))
{ text_error("incorrect dec2 decoupler flags! Should be 'nnn' "); psg_abort(1); }
if( pw > 50.0e-6 )
{ text_error("dont fry the probe, pw too high ! "); psg_abort(1); }
if( pwN > 100.0e-6 )
{ text_error("dont fry the probe, pwN too high ! "); psg_abort(1); }
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (phase1 == 2)
{tsadd(t3,1,4); tsadd(t5,1,4);}
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t3,2,4); tsadd(t5,2,4); tsadd(t12,2,4); }
/* BEGIN PULSE SEQUENCE */
status(A);
obspower(tpwr);
decpower(pwClvl);
decpwrf(rfC);
dec2power(pwNlvl);
txphase(zero);
decphase(zero);
dec2phase(zero);
dec2offset(dof2-(10*dfrq2));
delay(d1);
status(B);
rcvroff();
decrgpulse(pwC, zero, 0.0, 0.0); /*destroy C13 magnetization*/
zgradpulse(gzlvl0, 0.5e-3);
delay(grecov/2);
decrgpulse(pwC, one, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
decpwrf(rfst);
txphase(t1);
delay(5.0e-4);
rgpulse(pw,t1,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
txphase(one);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0);
rgpulse(pw, one, 0.0, 0.0);
txphase(two);
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, two, 5.0e-5, 0.0);
obspower(tpwr);
zgradpulse(gzlvl3, gt3);
dec2phase(t3);
delay(grecov);
dec2rgpulse(pwN, t3, 0.0, 0.0);
txphase(zero);
decphase(zero);
delay(timeT - 2.0*SAPS_DELAY);
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
dec2phase(t5);
delay(timeT - SAPS_DELAY);
dec2rgpulse(pwN, t5, 0.0, 0.0);
dec2phase(t6);
if ( (C13refoc[A]=='y') && (tau1 > 0.5e-3 + WFG2_START_DELAY) )
{delay(tau1 - 0.5e-3 - WFG2_START_DELAY); /* WFG2_START_DELAY */
decshaped_pulse("rna_stC140", 1.0e-3, zero, 0.0, 0.0);
delay(tau1 - 0.5e-3);}
else delay(2.0*tau1);
dec2rgpulse(pwN, t6, 0.0, 0.0);
dec2phase(t9);
delay(timeT - lambda - SAPS_DELAY);
dec2rgpulse(2.0*pwN, t9, 0.0, 0.0);
delay(timeT - lambda - gt1 - 2.0*GRADIENT_DELAY - pwHs - 1.5e-4 - 2.0*POWER_DELAY - SAPS_DELAY);
if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1);
txphase(t7);
obspower(tpwrs);
shaped_pulse("H2Osinc", pwHs, t7, 1.0e-4, 0.0);
txphase(t4);
obspower(tpwr);
delay(5.0e-5);
rgpulse(pw, t4, 0.0, 0.0);
txphase(one);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
delay(lambda - 0.65*(pw + pwN) - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, one, zero, zero, 0.0, 0.0);
txphase(two);
dec2phase(t11);
zgradpulse(gzlvl5, gt5);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(pw, 0.0, pwN, two, zero, t11, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(1.5*gzlvl5, gt5);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
zgradpulse(1.5*gzlvl5, gt5);
delay(lambda - 1.6*pwN - gt5);
dec2rgpulse(pwN, t10, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 - 0.65*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
rgpulse(2.0*pw, zero, 0.0, rof2);
dec2power(dpwr2); /* POWER_DELAY */
if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl2, 0.1*gt1);
else zgradpulse(gzlvl2, 0.1*gt1); /* 2.0*GRADIENT_DELAY */
statusdelay(C,1.0e-4-rof2);
setreceiver(t12);
}
