static void WET(codeint phaseA, codeint phaseB)
{
double finepwr,gzlvlw,gtw,gswet,dmfwet,dpwrwet,dofwet,wetpwr,pwwet,dz,
ref_pw90 = getval("ref_pw90"),
ref_pwr = getval("ref_pwr"),
slp0bw = getval("slp0bw"),
slpbw = getval("slpbw"),
slp2bw = getval("slp2bw"),
slp3bw = getval("slp3bw"),
slp4bw = getval("slp4bw"),
slp5bw = getval("slp5bw"),
slp6bw = getval("slp6bw"),
slp0,slp,slp2,
slp3,slp4,slp5,slp6;
int slp0w,slpw,slp2w,slp3w,slp4w,slp5w,slp6w,c13wet;
char wetshape[MAXSTR];
c13wet=getflag("c13wet"); /* C13 satellite suppression flag */
getstr("wetshape",wetshape); /* Selective pulse shape (basename) */
wetpwr=getval("wetpwr"); /* User enters power for 90 deg. */
pwwet=getval("pwwet"); /* User enters power for 90 deg. */
dmfwet=getval("dmfwet"); /* dmf for the C13 decoupling */
dpwrwet=getval("dpwrwet"); /* Power fot the C13 decoupling */
dofwet=getval("dofwet"); /* Offset for the C13 decoupling */
dz=getval("dz"); /* Post WET delay */
slp0w=getflag("slp0w"); /* Flags whether user is requesting */
slpw=getflag("slpw"); /* WET suppression on each solvent */
slp2w=getflag("slp2w"); /* signal */
slp3w=getflag("slp3w");
slp4w=getflag("slp4w");
slp5w=getflag("slp5w");
slp6w=getflag("slp6w");
/* On-the fly calculation of the WET shapes.
d.a. March 2001
First check if any of the WET related parameters are arrayed,
in order to avoid extra pulse shaping */
if ((getval("arraydim") < 1.5) || (ix==1) || (isarry("ref_pwr")) || (isarry("ref_pw90")) || (isarry("tof")) || (isarry("slp0bw")) || (isarry("slp")) || (isarry("slpbw")) || (isarry("slp2bw")) || (isarry("slp3bw")) || (isarry("slp4bw")) || (isarry("slp5bw")) || (isarry("slp6bw")) || (isarry("slp0")) || (isarry("slp2")) || (isarry("slp3")) || (isarry("slp4")) || (isarry("slp5")) || (isarry("slp6")) || (isarry("slp0w")) || (isarry("slpw")) || (isarry("slp2w")) || (isarry("slp3w")) || (isarry("slp4w")) || (isarry("slp5w")) || (isarry("slp6w")))
{
/* Set the name of the shape file to wetshape if not arrayed,
for compatibility reasons with the other sequences of the LC
and VAST package.
If something is arrayed then the first elements named with
wetshape and all subsequent with wetshape_n, where n is
the array index */
if (ix==1)
sprintf(wetarr, "%s", wetshape);
else
sprintf(wetarr, "%s_%d", wetshape, ix);
/* Open Pbox and start pulse shape calculation */
opx(wetarr);
/* Explicitly check whether each one of the seven solvent lines
is chosen to be suppressed. If the slpN parameter is set to
'n' or the slpNw flag is set to 'n' then no wave is put into Pbox.
Otherwise the proper line with the SEDUCE shape is addded.
var_active information can be found in /vnmr/psg/active.c */
if ((var_active("slp0",1)) && (slp0w))
{ slp0 = getval("slp0");
putwave("seduce",slp0bw/2,slp0,0.0,0.0,90.0); }
if ((var_active("slp",1)) && (slpw))
{ slp = getval("slp");
putwave("seduce",slpbw/2,slp,0.0,0.0,90.0); }
if ((var_active("slp2",1)) && (slp2w))
{ slp2 = getval("slp2");
putwave("seduce",slp2bw/2,slp2,0.0,0.0,90.0); }
if ((var_active("slp3",1)) && (slp3w))
{ slp3 = getval("slp3");
putwave("seduce",slp3bw/2,slp3,0.0,0.0,90.0); }
if ((var_active("slp4",1)) && (slp4w))
{ slp4 = getval("slp4");
putwave("seduce",slp4bw/2,slp4,0.0,0.0,90.0); }
if ((var_active("slp5",1)) && (slp5w))
{ slp5 = getval("slp5");
putwave("seduce",slp5bw/2,slp5,0.0,0.0,90.0); }
if ((var_active("slp6",1)) && (slp6w))
{ slp6 = getval("slp6");
putwave("seduce",slp6bw/2,slp6,0.0,0.0,90.0); }
/* Add additional control parameters, close Pbox and retrieve
the shape parameters into the proper variables */
pbox_par("attn","i");
pbox_par("reps","2");
cpx(ref_pw90,ref_pwr);
pbox_get();
wetpwr = pbox_pwr;
pwwet = pbox_pw;
}
else
{ /* Read the pbx.RF shape file and retrieve the wetpwr and pwwet values */
dumshape=getRsh(wetshape);
wetpwr = dumshape.pwr;
pwwet = dumshape.pw;
}
finepwr=wetpwr-(int)wetpwr; /* Adjust power to 152 deg. pulse */
wetpwr=(double)((int)wetpwr);
if (finepwr==0.0) {wetpwr=wetpwr+5; finepwr=4095.0; }
else {wetpwr=wetpwr+6; finepwr=4095.0*(1-((1.0-finepwr)*0.12)); }
rcvroff();
if (c13wet)
{
decunblank(); decon();
decoffset(dofwet);
decpower(dpwrwet);
if (rfwg[DECch-1]=='y')
decprgon("garp1",1/dmfwet,1.0);
else
setstatus(DECch,FALSE,'g',FALSE,dmfwet);
}
obspower(wetpwr); /* Set to low power level */
gzlvlw=getval("gzlvlw"); /* Z-Gradient level */
gtw=getval("gtw"); /* Z-Gradient duration */
gswet=getval("gswet"); /* Post-gradient stability delay */
CHESS(finepwr*0.5056,wetarr,pwwet,phaseA,20.0e-6,rof2,gzlvlw,gtw,gswet,c13wet);
CHESS(finepwr*0.6298,wetarr,pwwet,phaseB,20.0e-6,rof2,gzlvlw/2.0,gtw,gswet,c13wet);
CHESS(finepwr*0.4304,wetarr,pwwet,phaseB,20.0e-6,rof2,gzlvlw/4.0,gtw,gswet,c13wet);
CHESS(finepwr*1.00,wetarr,pwwet,phaseB,20.0e-6,rof2,gzlvlw/8.0,gtw,gswet,c13wet);
if (c13wet)
{
if (rfwg[DECch-1]=='y')
decprgoff();
else
setstatus(DECch,FALSE,'c',FALSE,dmf);
decoffset(dof);
decpower(dpwr);
decoff(); decblank();
}
obspower(tpwr); obspwrf(tpwrf); /* Reset to normal power level */
rcvron();
delay(dz);
}
void pulsesequence()
{
char c1d[MAXSTR]; /* option to record only 1D C13 spectrum */
int ncyc;
double tau1 = 0.002, /* t1 delay */
post_del = 0.0,
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
compC = getval("compC"),
compH = getval("compH"),
mixpwr = getval("mixpwr"),
jCH = getval("jCH"),
gt0 = getval("gt0"),
gt1 = getval("gt1"),
gt2 = getval("gt2"),
gzlvl0 = getval("gzlvl0"),
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
grec = getval("grec"),
phase = getval("phase");
getstr("c1d",c1d);
ncyc=1;
if(jCH > 0.0)
tau1 = 0.25/jCH;
dbl(ct, v1); /* v1 = 0 */
mod4(v1,oph);
hlv(ct,v2);
add(v2,v1,v2);
if (phase > 1.5)
incr(v1); /* hypercomplex phase increment */
initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v10);
add(v1,v10,v1);
add(oph,v10,oph);
mod4(v1,v1); mod4(v2,v2); mod4(oph,oph);
assign(zero,v3);
if(FIRST_FID)
{
HHmix = pbox_mix("HHmix", "DIPSI2", mixpwr, pw*compH, tpwr);
if(c1d[A] == 'n')
{
opx("CHdec"); setwave("WURST2 30k/1.2m"); pbox_par("steps","600"); cpx(pwC*compC, pwClvl);
CHdec = getDsh("CHdec");
}
}
ncyc = (int) (at/HHmix.pw) + 1;
post_del = ncyc*HHmix.pw - at;
/* BEGIN PULSE SEQUENCE */
status(A);
zgradpulse(gzlvl0, gt0);
rgpulse(pw, zero, 0.0, 0.0); /* destroy H-1 magnetization*/
zgradpulse(gzlvl0, gt0);
delay(1.0e-4);
obspower(tpwr);
txphase(v1);
decphase(zero);
dec2phase(zero);
presat();
obspower(tpwr);
delay(1.0e-5);
status(B);
if(c1d[A] == 'y')
{
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
delay(d2);
rgpulse(pw,two,0.0,0.0); /* 1H pulse excitation */
assign(oph,v3);
}
else
{
decunblank(); pbox_decon(&CHdec);
rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
delay(d2);
pbox_decoff(); decblank();
decpower(pwClvl); decpwrf(4095.0);
delay(tau1 - POWER_DELAY);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
txphase(one); decphase(one); dec2phase(one);
delay(tau1);
simpulse(pw, pwC, one, one, 0.0, 0.0);
txphase(zero); decphase(zero); dec2phase(zero);
delay(tau1);
simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);
delay(tau1);
simpulse(0.0, pwC, zero, zero, 0.0, 0.0);
}
zgradpulse(gzlvl1, gt1);
delay(grec);
simpulse(0.0, pwC, zero, v3, 0.0, rof2);
txphase(v2);
obsunblank(); pbox_xmtron(&HHmix);
status(C);
setactivercvrs("ny");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
delay(post_del);
pbox_xmtroff(); obsblank();
zgradpulse(gzlvl2, gt2);
obspower(tpwr);
delay(grec);
rgpulse(pw,zero,0.0,rof2); /* 1H pulse excitation */
status(D);
setactivercvrs("yn");
startacq(alfa);
acquire(np,1.0/sw);
endacq();
}
static int
FilterPacket(struct packdesc *pp, struct epacketfilt *pfp)
{
int maxhdr = pp->pd_hdrlen;
int maxword = maxhdr + pp->pd_bodylen;
ushort_t *sp;
ushort_t *fp;
ushort_t *fpe;
unsigned op;
unsigned arg;
unsigned offreg = 0;
ushort_t stack[ENMAXFILTERS+1];
fp = &pfp->pf_Filter[0];
fpe = pfp->pf_FilterEnd;
enprintf(("FilterPacket(%p, %p, %p, %p):\n", pp, pfp, fp, fpe));
/*
* Push TRUE on stack to start. The stack size is chosen such
* that overflow can't occur -- each operation can push at most
* one item on the stack, and the stack size equals the maximum
* program length.
*/
sp = &stack[ENMAXFILTERS];
*sp = 1;
while (fp < fpe) {
op = *fp >> ENF_NBPA;
arg = *fp & ((1 << ENF_NBPA) - 1);
fp++;
switch (arg) {
default:
arg -= ENF_PUSHWORD;
/*
* Since arg is unsigned,
* if it were less than ENF_PUSHWORD before,
* it would now be huge.
*/
if (arg + offreg < maxhdr)
*--sp = pp->pd_hdr[arg + offreg];
else if (arg + offreg < maxword)
*--sp = pp->pd_body[arg - maxhdr + offreg];
else {
enprintf(("=>0(len)\n"));
return (0);
}
break;
case ENF_PUSHLIT:
*--sp = *fp++;
break;
case ENF_PUSHZERO:
*--sp = 0;
break;
case ENF_PUSHONE:
*--sp = 1;
break;
case ENF_PUSHFFFF:
*--sp = 0xffff;
break;
case ENF_PUSHFF00:
*--sp = 0xff00;
break;
case ENF_PUSH00FF:
*--sp = 0x00ff;
break;
case ENF_LOAD_OFFSET:
offreg = *fp++;
break;
case ENF_BRTR:
if (*sp != 0)
fp += *fp;
else
fp++;
if (fp >= fpe) {
enprintf(("BRTR: fp>=fpe\n"));
return (0);
}
break;
case ENF_BRFL:
if (*sp == 0)
fp += *fp;
else
fp++;
if (fp >= fpe) {
enprintf(("BRFL: fp>=fpe\n"));
return (0);
}
break;
case ENF_POP:
++sp;
if (sp > &stack[ENMAXFILTERS]) {
enprintf(("stack underflow\n"));
return (0);
}
break;
case ENF_NOPUSH:
break;
}
if (sp < &stack[2]) { /* check stack overflow: small yellow zone */
enprintf(("=>0(--sp)\n"));
return (0);
}
if (op == ENF_NOP)
continue;
/*
* all non-NOP operators binary, must have at least two operands
* on stack to evaluate.
*/
if (sp > &stack[ENMAXFILTERS-2]) {
enprintf(("=>0(sp++)\n"));
return (0);
}
arg = *sp++;
switch (op) {
default:
enprintf(("=>0(def)\n"));
return (0);
case opx(ENF_AND):
*sp &= arg;
break;
case opx(ENF_OR):
*sp |= arg;
break;
case opx(ENF_XOR):
*sp ^= arg;
break;
case opx(ENF_EQ):
*sp = (*sp == arg);
break;
case opx(ENF_NEQ):
*sp = (*sp != arg);
break;
case opx(ENF_LT):
*sp = (*sp < arg);
break;
case opx(ENF_LE):
*sp = (*sp <= arg);
break;
case opx(ENF_GT):
*sp = (*sp > arg);
break;
case opx(ENF_GE):
*sp = (*sp >= arg);
break;
/* short-circuit operators */
case opx(ENF_COR):
if (*sp++ == arg) {
enprintf(("=>COR %x\n", *sp));
return (1);
}
break;
case opx(ENF_CAND):
if (*sp++ != arg) {
enprintf(("=>CAND %x\n", *sp));
return (0);
}
break;
case opx(ENF_CNOR):
if (*sp++ == arg) {
enprintf(("=>COR %x\n", *sp));
return (0);
}
break;
case opx(ENF_CNAND):
if (*sp++ != arg) {
enprintf(("=>CNAND %x\n", *sp));
return (1);
}
break;
}
}
enprintf(("=>%x\n", *sp));
return (*sp);
}
