pulsesequence() { /* DECLARE VARIABLES */ char fsat[MAXSTR], fscuba[MAXSTR], f1180[MAXSTR], /* Flag to start t1 @ halfdwell */ f2180[MAXSTR], /* Flag to start t2 @ halfdwell */ ch_plane[MAXSTR]; /* Flag to start t2 @ halfdwell */ int phase, phase2, ni, ni2, ncyc, t1_counter, /* used for states tppi in t1 */ t2_counter; /* used for states tppi in t2 */ double tau1, /* t1 delay */ tau2, /* t2 delay */ taua, /* ~ 1/4JCH = 1.7 ms */ taub, /* = 1/4JCH or 1/8JCH for editing */ TC, /* ~ 1/2JCaCo = 9 ms */ pw_ml, /* PW90 for mlev 1H decoupling */ pwN, /* PW90 for 15N pulse */ pwC, /* PW90 hard 13C pulse */ pwc90, /* PW90 for Ca or Co nucleus */ pw_dip, /* PW90 for Ca or Co nucleus */ pwreb180, /* PW180 for reburp */ pwcon180, /* PW for Ca or Co on-res 180 */ pwcoff180, /* PW for Ca or Co off-res 180 */ satpwr, /* low level 1H trans.power for presat */ tpwrml, /* power for 1H decoupling */ pwClvl, /* power level for 13C pulses on dec1 - 64 us 90 for part a of the sequence */ compH, /* compression factor */ compC, /* compression factor */ waltzB1, /* power level for proton decoupling */ d_c90, /* power level for Ca or Co 90 pulse */ d_c180, /* power level for Ca or Co 180 pulse */ d_coff180, /* power level for shifted 180 */ d_reb, /* power level for reburp 180 pulse */ dpwr_dip, /* power level for reburp 180 pulse */ pwNlvl, /* high dec2 pwr for 15N hard pulses */ sw1, /* sweep width in f1 */ sw2, /* sweep width in f2 */ dof_coca, /* offset between Co and Ca for comp180 */ bw,ofs,ppm, /* temporary Pbox parameters */ zeta, zeta1, gt0, gt1, gt2, gt3, gt4, gt5, gt6, gt7, gt8, gstab, gzlvl0, gzlvl1, gzlvl2, gzlvl3, gzlvl4, gzlvl5, gzlvl6, gzlvl7, gzlvl8; /* LOAD VARIABLES */ getstr("fsat",fsat); getstr("fscuba",fscuba); getstr("f1180",f1180); getstr("f2180",f2180); getstr("ch_plane",ch_plane); taua = getval("taua"); taub = getval("taub"); TC = getval("TC"); pwc90 = getval("pwc90"); pwN = getval("pwN"); pwC = getval("pwC"); pwClvl = getval("pwClvl"); compC = getval("compC"); compH = getval("compH"); waltzB1 = getval("waltzB1"); tpwr = getval("tpwr"); satpwr = getval("satpwr"); d_c180 = getval("d_c180"); d_reb = getval("d_reb"); dpwr = getval("dpwr"); pwNlvl = getval("pwNlvl"); phase = (int) ( getval("phase") + 0.5); phase2 = (int) ( getval("phase2") + 0.5); sw1 = getval("sw1"); sw2 = getval("sw2"); ni = getval("ni"); ni2 = getval("ni2"); ncyc = getval("ncyc"); gt0 = getval("gt0"); gt1 = getval("gt1"); gt2 = getval("gt2"); gt3 = getval("gt3"); gt4 = getval("gt4"); gt5 = getval("gt5"); gt6 = getval("gt6"); gt7 = getval("gt7"); gt8 = getval("gt8"); gstab = getval("gstab"); 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"); /* LOAD PHASE TABLE */ settable(t1,1,phi1); settable(t2,4,phi2); settable(t3,2,phi3); settable(t4,16,phi4); settable(t5,1,phi5); settable(t6,8,rec); /* CHECK VALIDITY OF PARAMETER RANGES */ if( satpwr > 6 ) { printf("TSATPWR too large !!! "); psg_abort(1); } if( dpwr > 46 ) { printf("don't fry the probe, DPWR too large! "); psg_abort(1); } if( dpwr2 > 46 ) { printf("don't fry the probe, DPWR2 too large! "); psg_abort(1); } if( pwNlvl > 63 ) { printf("don't fry the probe, DHPWR2 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( pwC > 200.0e-6 ) { printf("dont fry the probe, pwC too high ! "); psg_abort(1); } if( ncyc > 9 ) { printf("dont fry the probe, ncyc must be <= 9\n"); psg_abort(1); } if( gt0 > 10.0e-3 || gt1 > 10.0e-3 || gt2 > 10.0e-3 || gt3 >10.0e-3 || gt4 > 10.0e-3 || gt5 > 10.0e-3 || gt6 > 10.0e-3 || gt7 > 10.0e-3 ) { printf("gt values are too long. Must be < 10.0e-3\n"); psg_abort(1); } /* Phase incrementation for hypercomplex 2D & 3D data */ if (phase == 2) tsadd(t3,1,4); if (phase2 == 2) tsadd(t5,1,4); /* Set up f1180 tau1 = t1 */ tau1 = d2; if(f1180[A] == 'y') { tau1 += 1.0 / (2.0*sw1) - 4.0*pwC - 4.0*2.0e-6 - 2.0*(2.0/PI)*pwN ; if(tau1 < 0.4e-6) { tau1 = 0.4e-6; printf("tau1 is negative; decrease sw1 for proper phasing \n"); } } tau1 = tau1/2.0; /* Set up f2180 tau2 = t2 */ tau2 = d3; if(f2180[A] == 'y') { tau2 += ( 1.0 / (2.0*sw2)); } tau2 = tau2 / 2.0; /* Calculate modifications to phases for States-TPPI acquisition in t1 & t2 */ if( ix == 1) d2_init = d2 ; t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 ); if(t1_counter % 2) { tsadd(t3,2,4); tsadd(t6,2,4); } if( ix == 1) d3_init = d3 ; t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 ); if(t2_counter % 2) { tsadd(t5,2,4); tsadd(t6,2,4); } pwc90 = 1/(4.0 * (4700*(dfrq/150))) ; /* 4.7kHz at 150 MHz 13C */ d_c90 = pwClvl - 20.0*log10(pwc90/(compC*pwC)); d_c90 = (int) (d_c90 + 0.5); pwcon180 = 1/(4.0 * (10900*(dfrq/150))) ; /* 10.9kHz at 150 MHz 13C */ d_c180 = pwClvl - 20.0*log10(pwcon180/(compC*pwC)); d_c180 = (int) (d_c180 + 0.5); /* Now include the Bax/Logan trick (shared time evolution in 13C) */ if(ni2 != 1) zeta = (taub/2.0 + 2*pw) / ( (double)(ni2-1) ); else zeta = 0.0; zeta1 = zeta*( (double)t2_counter ); if (FIRST_FID) /* call Pbox */ { ppm = getval("dfrq"); bw = 132.0*ppm; ofs = bw; /* carrier at 42ppm, inversion at 174ppm */ spco180 = pbox_make("spco180","square180n", bw, ofs, compC*pwC, pwClvl); spreb180 = pbox_make("spreb180","reburp", 20*dfrq, -4*dfrq, compC*pwC, pwClvl); } pwcoff180=spco180.pw; d_coff180=spco180.pwrf; pwreb180=spreb180.pw; d_reb=spreb180.pwrf; if (0.5*TC - 0.5*(ni2-1)/sw2 - pwcon180/2.0 - 2.0e-6 - pwcoff180 -2.0*2.0e-6 \ - WFG_START_DELAY - WFG_STOP_DELAY - POWER_DELAY < 0.4e-6) { printf("ni2 too large !\n"); psg_abort(1); } /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); obsoffset(tof); decoffset(dof); dec2offset(dof2); obspower(satpwr); /* Set transmitter power for 1H presaturation */ decpower(pwClvl); /* Set Dec1 power for hard 13C pulses */ dec2power(pwNlvl); /* Set Dec2 power for 15N hard pulses */ /* Presaturation Period */ status(B); if (fsat[0] == 'y') { delay(2.0e-5); rgpulse(d1,zero,2.0e-6,2.0e-6); /* presaturation */ 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); delay(1.0e-5); /* Begin Pulses */ status(B); rcvroff(); delay(20.0e-6); decrgpulse(pwC,zero,0.0,0.0); delay(0.2e-6); zgradpulse(gzlvl0,gt0); delay(gstab); rgpulse(pw,zero,0.0,0.0); /* 90 deg 1H pulse */ zgradpulse(gzlvl1,gt1); delay(taua - gt1); /* taua <= 1/4JCH */ simpulse(2*pw,2*pwC,zero,zero,0.0,0.0); zgradpulse(gzlvl1,gt1); delay(taua - gt1 ); /* taua <= 1/4JCH */ rgpulse(pw,t1,0.0,0.0); zgradpulse(gzlvl2,gt2); delay(gstab); decrgpulse(pwC,t5,2.0e-6,0.0); txphase(zero); decphase(zero); delay(tau2); dec2rgpulse(2*pwN,zero,0.0,0.0); delay(taub/2.0 - 2*pwN); rgpulse(2*pw,zero,0.0,0.0); zgradpulse(gzlvl3,gt3); delay(tau2 - zeta1); decrgpulse(2.0*pwC,zero,0.0,0.0); zgradpulse(gzlvl3,gt3); delay(taub/2.0 - zeta1 + 2*pw); decrgpulse(pwC,one,0.0,2.0e-6); zgradpulse(gzlvl6,gt6/1.7); delay(gstab); pw_dip = 1/(4.0 * (6700*(dfrq/150))) ; /* 6.7kHz at 150 MHz 13C */ dpwr_dip = pwClvl - 20.0*log10(pw_dip/(compC*pwC)); dpwr_dip = (int) (dpwr_dip + 0.5); decpower(dpwr_dip); if( (float) ncyc > 0.1) { decspinlock("FLOPSY8",pw_dip,1.0,zero,ncyc); } decphase(one); decpower(d_c90); zgradpulse(gzlvl6,gt6); delay(gstab); pw_ml = 1/(4.0 * waltzB1) ; tpwrml = tpwr - 20.0*log10(pw_ml/(compH*pw)); tpwrml = (int) (tpwrml + 0.5); obspower(tpwrml); /* H decoupling on */ rgpulse(pw_ml,one,2.0e-6,0.0); txphase(zero); delay(2.0e-6); obsprgon("waltz16",pw_ml,90.0); xmtron(); /* Cz */ decrgpulse(pwc90,one,0.0,2.0e-6); decpower(d_c180); delay(0.5*TC - 2.0e-6 - POWER_DELAY - 2.0*pwN - 2.0e-6); dec2rgpulse(2.0*pwN,zero,0.0,2.0e-6); decrgpulse(pwcon180,zero,0.0,0.0); delay(0.5*TC - POWER_DELAY ); decphase(t2); decpower(d_c90); decrgpulse(pwc90,t2,0.0,0.0); /* CzNz */ /* H decoupling off */ xmtroff(); obsprgoff(); rgpulse(pw_ml,three,2.0e-6,2.0e-6); zgradpulse(gzlvl4,gt4); dec2phase(t3); delay(gstab); decpower(pwClvl); dof_coca=dof+(110-42)*dfrq; decoffset(dof_coca); /* move C carrier for comp180 */ decphase(one); /* H decoupling on */ obspower(tpwrml); rgpulse(pw_ml,one,2.0e-6,0.0); txphase(zero); delay(2.0e-6); obsprgon("waltz16",pw_ml,90.0); xmtron(); /* N evolution */ dec2rgpulse(pwN,t3, 0.0, 2.0e-6); if(ch_plane[0] == 'y') { dec2phase(zero); delay(0.2e-6); } else { delay(tau1); decrgpulse(pwC, one, 0.0, 0.0); decrgpulse(2.0*pwC, zero, 2.0e-6, 2.0e-6); decrgpulse(pwC, one, 0.0, 0.0); delay(tau1); } dec2rgpulse(pwN, zero, 2.0e-6, 0.0); /* H decoupling off */ xmtroff(); obsprgoff(); rgpulse(pw_ml,three,2.0e-6,2.0e-6); obspower(tpwr); decpower(d_c90); decoffset(dof); /* move back C carrier */ decphase(t5); /* clean-up before proceeding */ zgradpulse(gzlvl5,gt5); delay(gstab); decrgpulse(pwc90,zero,0.0,0.0); /* refocus Ca-N and Ca-H couplings */ delay(0.5*TC - pwcon180/2.0 - pwcoff180 \ - WFG_START_DELAY - WFG_STOP_DELAY - POWER_DELAY ); decphase(zero); decpower(pwClvl); decpwrf(d_coff180); simshaped_pulse("","spco180",2.0*pw,pwcoff180,zero,zero,0.0e-6,0.0e-6); /* Bloch siegert correction */ decphase(zero); decpower(d_c180); decpwrf(4095.0); decrgpulse(pwcon180,t4,0.0e-6,0.0e-6); decpwrf(d_coff180); decpower(pwClvl); dec2rgpulse(2.0*pwN,zero,0.0,0.0); decshaped_pulse("spco180", pwcoff180, zero, 0.0e-6, 0.0e-6); delay(taub/2.0); rgpulse(2.0*pw,zero,0.0,0.0); decpower(d_c90); decpwrf(4095.0); decphase(zero); delay(0.5*TC - taub/2.0 - 2.0*pw -pwcon180/2 - 2.0*pwN - pwcoff180 \ - WFG_START_DELAY - WFG_STOP_DELAY \ - 2.0*POWER_DELAY); decrgpulse(pwc90,zero,0.0,0.0); zgradpulse(gzlvl7,gt7); delay(gstab); rgpulse(pw,zero,0.0,0.0); zgradpulse(gzlvl8,gt8); txphase(zero); dec2phase(zero); decpwrf(d_reb); decpower(pwClvl); delay(taua - 2.0*POWER_DELAY - gt8 - 0.5*pwreb180 ); simshaped_pulse("","spreb180",2.0*pw,pwreb180,zero,zero,0.0e-6,0.0e-6); /* Purge all C outside 26-46 ppm */ zgradpulse(gzlvl8,gt8); decphase(zero); dec2power(dpwr2); /* set power for 15N decoupling */ decpower(dpwr); /* set power for 13C decoupling */ decpwrf(4095.0); delay(taua - 0.5*pwreb180 - gt8 - 3.0*POWER_DELAY); rgpulse(pw,zero,0.0,0.0); /* BEGIN ACQUISITION */ status(C); setreceiver(t6); }
pulsesequence() { double mult = getval("mult"), pp = getval("pp"), pplvl = getval("pplvl"), qphase = getval("qphase"), qtip = getval("qtip"), qrelax = getval("qrelax"), gzlvl5 = getval("gzlvl5"), gt5 = getval("gt5"), tpwr180 = getval("tpwr180"), pw180 = getval("pw180"), qpw, tau; char pw180ad[MAXSTR], sbbiflg[MAXSTR], bipflg[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gt5 = syncGradTime("gt5","gzlvl5",1.0); gzlvl5 = syncGradLvl("gt5","gzlvl5",1.0); getstr("pw180ad", pw180ad); getstr("bipflg", bipflg); getstr("sbbiflg",sbbiflg); if (bipflg[0] == 'y') { tpwr180=getval("tnbippwr"); pw180=getval("tnbippw"); getstr("tnbipshp",pw180ad); } tau = 1.0 / (2.0 * (getval("j1xh"))); if (getflag("PFGflg")) tau = tau - gt5; qpw = qtip*pw/90.0; /* CHECK CONDITIONS */ if ((dm[0] == 'y') || (dm[1] == 'y')) { fprintf(stdout, "Decoupler must be set as dm='nny'.\n"); psg_abort(1); } if ((dmm[0] != 'c') || (dmm[1] != 'c')) { fprintf(stdout, "Decoupler must be set as dmm='ccf' or dmm='ccw'.\n"); psg_abort(1); } /* PHASECYCLE CALCULATIONS */ settable(t3,2, phi3); settable(t4,8, phi4); settable(t9,16, rec_1); settable(t2,16,phi2); assign(zero,v1); /* proton 90 */ getelem(t2,ct,v2); /* proton 180 */ getelem(t3,ct,v3); /* proton theta pulse */ getelem(t4,ct,v4); /* carbon 90 */ getelem(t9,ct,oph); /* Receiver */ add(v4,one,v7); /* 1st pair of carbon 180 */ assign(v4,v5); /* 2nd pair of carbon 180 */ add(oph,one,v6); /* carbon alpha pulse qphase=1 */ if (qphase < -0.5) add(v6,two,v6); /* carbon alpha phase qphase=-1 */ add(one,v5,v10); add(one,v7,v11); add(oph,two,oph); if (getflag("sbbiflg")) sub(oph,two,oph); /* ACTUAL PULSESEQUENCE BEGINS */ status(A); decpower(pplvl); obspower(tpwr); if ((qphase != 0.0) && (qrelax > d1)) { decpower(dpwr); status(C); delay(qrelax - d1); status(A); decpower(pplvl); } delay(d1); status(B); if (getflag("sbbiflg")) { if (qphase != 0.0) { rgpulse(qpw,v6,rof1,rof1); obspower(tpwr180); shaped_pulse(pw180ad,pw180,v7,rof1,rof1); obspower(tpwr); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); delay(tau + pp + 2*rof1 + (2*qpw/PI)); obspower(tpwr180); shaped_pulse(pw180ad,pw180,v7,rof1,rof1); obspower(tpwr); } decrgpulse(pp, v1,rof1,rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); delay(tau - pp - 2*rof1); simpulse(pw, 2.0 * pp, v4, v2, rof1, rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); delay(tau - pp - 2*rof1 - mult*pp); decrgpulse(mult*pp,v3,rof1,rof1); obspower(tpwr180); shaped_pulse(pw180ad,pw180,v5,rof1,rof1); obspower(tpwr); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); decpower(dpwr); delay(tau - POWER_DELAY); obspower(tpwr180); shaped_pulse(pw180ad,pw180,v5,rof1,rof2); obspower(tpwr); } else { if (qphase != 0.0) { rgpulse(qpw,v6,rof1,rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); delay(tau - rof1 - (2*qpw/PI)); rgpulse(pw,v7,rof1,rof1); simpulse(2*pw,pp,v11,v1,rof1,rof1); rgpulse(pw,v7,rof1,rof1); } else decrgpulse(pp,v1,rof1,rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); if (qphase !=0.0) delay(tau - pp - rof1); else delay(tau - pp - (2*pp/PI) - 2*rof1); simpulse(pw, 2.0 * pp, v4, v2, rof1, rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); delay(tau - pp - rof1 - (2*pw/PI)); rgpulse(pw,v5,rof1,rof1); simpulse(2*pw,mult*pp,v10,v3,rof1,rof1); rgpulse(pw,v5,rof1,rof1); if (getflag("PFGflg")) zgradpulse(gzlvl5,gt5); decpower(dpwr); delay(tau - POWER_DELAY + rof2); } status(C); }
pulsesequence() { /* DECLARE VARIABLES */ char satmode[MAXSTR],f1180[MAXSTR],sspul[MAXSTR],comm[MAXSTR], pwx180ad[MAXSTR],pwx180adR[MAXSTR],pwx180ref[MAXSTR]; int phase,satmove,maxni,t1_counter,icosel=1, prgcycle = (int)(getval("prgcycle")+0.5); double tau1,tauxh, tauxh1, taucc,av180, hsgt = getval("hsgt"), gt1 = getval("gt1"), gt2 = getval("gt2"), gt3 = getval("gt3"), hsglvl = getval("hsglvl"), gzlvl1 = getval("gzlvl1"), gzlvl2 = getval("gzlvl2"), gzlvl3 = getval("gzlvl3"), pwx = getval("pwx"), pwxlvl = getval("pwxlvl"), j1xh = getval("j1xh"), jcc = getval("jcc"), satdly = getval("satdly"), satpwr = getval("satpwr"), satfrq = getval("satfrq"), sw1 = getval("sw1"), gstab = getval("gstab"), kappa = getval("kappa"), dofdec = getval("dofdec"), pwx180 = getval("pwx180"), pwxlvl180 = getval("pwxlvl180"); getstr("f1180",f1180); getstr("satmode",satmode); getstr("sspul",sspul); getstr("pwx180ad", pwx180ad); ni = getval("ni"); av180 = (double)((int)(1e6*(9.45*4*pwx/1.54+0.5e-6))/1e6); /* round it to 1usec */ phase = (int) (getval("phase") + 0.5); satmove = ( fabs(tof - satfrq) >= 0.1 ); /* construct a command line for Pbox */ if((getval("arraydim") < 1.5) || (ix==1)) /* execute only once */ { sprintf(comm, "Pbox ad180 -u %s -w \"cawurst-10 %.1f/%.6f\" -s 1.0 -0\n", userdir, 1.0/pwx, 30*pwx); system(comm); /* create adiabatic 180 pulse */ sprintf(comm, "Pbox av180 -u %s -w \"av180b %.6f\" -s 1.0 -0\n", userdir, av180); system(comm); /* create refocusing 180 pulse */ } /* LOAD VARIABLES */ settable(t1, 1, phi1); settable(t2, 1, phi2); settable(t4, 2, phi4); settable(t5, 4, phi5); settable(t6, 4, phi6); settable(t8, 1, phi8); settable(t9, 8, phi9); settable(t10, 16, phi10); settable(t11, 1, phi11); settable(t31, 16, phi31); /* INITIALIZE VARIABLES */ if (j1xh != 0.0) { tauxh = 1/(4*j1xh); tauxh1 = 1/(6*j1xh); } else { tauxh = 1.80e-3; tauxh1 = 1.80e-3; } if ( jcc != 0.0 ) taucc = 1/(4*jcc); else taucc = 1/(4*40); /* Phase incrementation for hypercomplex echo-antiecho 2D data */ if (phase == 2) { tsadd(t6,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(t9,2,4); tsadd(t31,2,4); } /* Check constant-time conditions */ if (kappa == 1.0) { maxni = (int) (taucc*sw1*2.0); if (maxni < ni) { abort_message("too many increments! maxni = %d ",maxni); } } /* SET UP FOR (-90,180) PHASE CORRECTIONS IF f1180='y' */ tau1 = d2; if(f1180[A] == 'y') tau1 += ( 1.0/(2.0*sw1) ); /* Wait half a dwell time */ tau1 = tau1/2.0; /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); decpower(pwxlvl); decoffset(dof); /* Set decoupler power to pwxlvl */ delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,v4); if (getflag("prgflg")) shaped_purge(v1,v4,v18,v19); } else { satpulse(satdly,v4,rof1,rof1); if (getflag("prgflg")) purge(v1,v4,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rcvroff(); rgpulse(pw,t1,1.0e-6,0.0); txphase(t1); decphase(t1); delay(tauxh-15.0*pwx); /* delay=1/4J(XH) */ simshaped_pulse("","ad180",2*pw,30*pwx,t1,t1,0.0,0.0); txphase(t2); decphase(t4); delay(tauxh-15.0*pwx); simpulse(pw,pwx,t2,t4,0.0,0.0); decphase(t8); delay(taucc); decshaped_pulse("av180",av180,t8,0.0,0.0); decphase(t9); delay(taucc); decrgpulse(pwx,t9,0.0,0.0); delay(tau1); rgpulse(2*pw,t1,1.0e-6,0.0); delay(tau1); delay(gt1 + gstab + 2*GRADIENT_DELAY - 2*pw -1.0e-6); decshaped_pulse("av180",av180,t11,1.0e-6,0.0); zgradpulse(gzlvl1, gt1); delay(gstab); decrgpulse(pwx*1.3333,t10,1.0e-6,0.0); /* 120 Grad pulse */ decphase(t11); delay(taucc - kappa*tau1); decshaped_pulse("av180",av180,t11,0.0,0.0); delay(10.0e-6); zgradpulse(gzlvl2,gt2); delay(gstab); delay(taucc - 10.0e-6 - gstab - gt2 - 2*GRADIENT_DELAY - 1.0e-6); rgpulse(kappa*2*pw,t1,1.0e-6,0.0); delay(kappa*tau1); simpulse(pw,pwx,t1,t5,1.0e-6,0.0); txphase(t1); decphase(t1); delay(tauxh1); /* delay=1/4J (XH);1/6J XH,XH2, XH3) */ simshaped_pulse("","av180",2*pw,av180,t1,t1,0.0,0.0); txphase(t2); decphase(t6); delay(tauxh1); simpulse(pw,pwx,t2,t6,0.0,0.0); txphase(t1); decphase(t1); delay(tauxh-15.0*pwx); simshaped_pulse("","ad180",2*pw,30*pwx,t1,t1,0.0,0.0); txphase(t1); delay(tauxh-15.0*pwx-0.5e-6); rgpulse(pw,t1,0.0,0.0); decpower(dpwr); decoffset(dofdec); /* lower decoupler power for decoupling */ delay(gt3 + gstab + 2*GRADIENT_DELAY-POWER_DELAY-1.0e-6); rgpulse(2*pw,t1,1.0e-6,0.0); zgradpulse(icosel*gzlvl3, gt3); delay(gstab); rcvron(); status(C); setreceiver(t31); }
pulsesequence() { /* DECLARE AND LOAD VARIABLES */ char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */ mag_flg[MAXSTR], /* magic-angle coherence transfer gradients */ f2180[MAXSTR], /* Flag to start t2 @ halfdwell */ wudec[MAXSTR], /* automatic low power C-13 WURST decoupling */ C13refoc[MAXSTR], /* adiabatic C13 pulse in middle of t1*/ NH2only[MAXSTR]; /* spectrum of only NH2 groups */ 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 */ ni2 = getval("ni2"); double csa, sna, tau1, tau2, /* t1 and t2 delays */ bw, ofs, ppm, nst, /* bandwidth, offset, ppm, # of steps */ mix = getval("mix"), /* NOESY mix time */ tNH = 1.0/(4.0*getval("JNH")), /* 1/4J N15 evolution delay */ pra = M_PI*getval("pra")/180.0, /* projection angle */ pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */ pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */ compC = getval("compC"), /* adjust for C13 amplifier compression */ pwC180 = 0.001, /* duration of C13 180 degree adiabatic pulse */ compH = getval("compH"), /* adjust for H1 amplifier compression */ tpwrsf = getval("tpwrsf"), /* fine power adjustment for flipback pulse */ pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */ tpwrs = 0.0, /* power for the pwHs ("H2Osinc") pulse */ xdel = 2.0*GRADIENT_DELAY + POWER_DELAY, /* xtra delay */ pwNlvl = getval("pwNlvl"), /* power for N15 pulses */ pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */ sw1 = getval("sw1"), sw2 = getval("sw2"), gzcal=getval("gzcal"), gt1 = getval("gt1"), /* coherence pathway gradients */ 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"), gzlvl6 = getval("gzlvl6"), gzlvl4 = getval("gzlvl4"), gzlvl5 = getval("gzlvl5"); getstr("f1180",f1180); getstr("mag_flg",mag_flg); getstr("f2180",f2180); getstr("C13refoc",C13refoc); getstr("NH2only",NH2only); getstr("wudec",wudec); /* LOAD PHASE TABLE */ settable(t1,2,phi1); settable(t3,4,phi3); settable(t9,16,phi9); settable(t10,1,phi10); settable(t11,8,rec); /* MAKE PBOX SHAPES */ if((FIRST_FID) && ((C13refoc[A]=='y') || (wudec[A]=='y'))) /* call Pbox */ { ppm = getval("dfrq"); ofs = 0.0; nst = 1000; /* nst - number of steps */ bw = pwC*compC; if(bw > 0.0) { bw = 0.1/bw; /* maximum bandwidth */ bw = pwC180*bw*bw; } else bw = 200.0*ppm; if(C13refoc[A]=='y') adC180 = pbox_makeA("adC180", "wurst2i", bw, pwC180, ofs, compC*pwC, pwClvl, nst); if(wudec[A]=='y') wuCdec_lr = pbox_Adec("wurstC_lr", "CAWURST", bw, 0.01, ofs, compC*pwC, pwClvl); } if(pwHs > 1.0e-5) /* selective H20 one-lobe sinc pulse */ { if(FIRST_FID) H2Osinc = pbox_Rsh("H2Osinc", "sinc90", pwHs, 0.0, compH*pw, tpwr); tpwrs = H2Osinc.pwr; pwHs = H2Osinc.pw; } /* CHECK VALIDITY OF PARAMETER RANGES */ if ((mix - gt4 - gt5) < 0.0 ) { text_error("mix is too small. Make mix equal to %f or more.\n",(gt4 + gt5)); psg_abort(1); } 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 > 20.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(t1,1,4); if (phase2 == 1) { tsadd(t10,2,4); icosel = 1; } else icosel = -1; /* set up Projection-Reconstruction experiment */ PRexp = 0; if((pra > 0.0) && (pra < 90.0)) PRexp = 1; csa = cos(pra); sna = sin(pra); if(PRexp) { tau1 = d2*csa; tau2 = d2*sna; } else { tau1 = d2; tau2 = d3; } if((f1180[A] == 'y') && (ni > 1.0)) /* Set up f1180, tau1 = t1 */ tau1 += 1.0/(2.0*sw1); tau1 = tau1/2.0; if((PRexp == 0) && (f2180[A] == 'y') && (ni2 > 1.0)) /* Set up f2180 tau2 = t2 */ tau2 += 1.0/(2.0*sw2); tau2 = tau2/2.0; if(tau1 < 0.2e-6) tau1 = 0.0; if(tau2 < 0.2e-6) tau2 = 0.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(t11,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(t11,2,4); } /* Correct inverted signals for NH2 only spectra */ if(NH2only[A]=='y') { tsadd(t3,2,4); } if(wudec[A]=='y') xdel = xdel + POWER_DELAY + PWRF_DELAY + PRG_START_DELAY; /* BEGIN PULSE SEQUENCE */ status(A); obspower(tpwr); decpower(pwClvl); dec2power(pwNlvl); decpwrf(4095.0); txphase(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); txphase(t1); decphase(zero); dec2phase(zero); delay(5.0e-4); rcvroff(); rgpulse(pw, t1, 50.0e-6, 0.0); /* 1H pulse excitation */ txphase(zero); if (tau1 > (2.0*GRADIENT_DELAY + pwN + 0.64*pw + 5.0*SAPS_DELAY)) { if (tau1>0.002) { zgradpulse(gzlvl6, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw)); delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw) - SAPS_DELAY); } else { delay(tau1-pwN-0.64*pw); } if (C13refoc[A]=='y') sim3pulse(0.0, 2.0*pwC, 2.0*pwN, zero, zero, zero, 0.0, 0.0); else dec2rgpulse(2.0*pwN, zero, 0.0, 0.0); if (tau1>0.002) { zgradpulse(-1.0*gzlvl6, 0.8*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw)); delay(0.2*(tau1 - 2.0*GRADIENT_DELAY - pwN - 0.64*pw) - SAPS_DELAY); } else { delay(tau1-pwN-0.64*pw); } } else if (tau1 > (0.64*pw + 0.5*SAPS_DELAY)) delay(2.0*tau1 - 2.0*0.64*pw - SAPS_DELAY ); rgpulse(pw, zero, 0.0, 0.0); delay(mix - gt4 - gt5 -gstab -200.0e-6); dec2rgpulse(pwN, zero, 0.0, 0.0); zgradpulse(gzlvl4, gt4); delay(gstab); rgpulse(pw, zero, 200.0e-6,0.0); /* HSQC begins */ dec2phase(zero); zgradpulse(gzlvl0, gt0); delay(tNH - gt0); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); txphase(one); zgradpulse(gzlvl0, gt0); delay(tNH - gt0); rgpulse(pw, one, 0.0, 0.0); txphase(two); if (tpwrsf<4095.0) { obspower(tpwrs+6.0); obspwrf(tpwrsf); shaped_pulse("H2Osinc", pwHs, two, 5.0e-4, 0.0); obspower(tpwr); obspwrf(4095.0); } else { obspower(tpwrs); shaped_pulse("H2Osinc", pwHs, two, 5.0e-4, 0.0); obspower(tpwr); } zgradpulse(gzlvl3, gt3); dec2phase(t3); decpwrf(adC180.pwrf); delay(2.0e-4); dec2rgpulse(pwN, t3, 0.0, 0.0); decphase(zero); /* xxxxxxxxxxxxxxxxxx OPTIONS FOR N15 EVOLUTION xxxxxxxxxxxxxxxxxxxxx */ txphase(zero); dec2phase(t9); if (NH2only[A]=='y') { delay(tau2); /* optional sech/tanh pulse in middle of t2 */ if (C13refoc[A]=='y') /* WFG_START_DELAY */ { decshaped_pulse("adC180", pwC180, zero, 0.0, 0.0); delay(tNH - 1.0e-3 - WFG_START_DELAY - 2.0*pw); } else { delay(tNH - 2.0*pw);} rgpulse(2.0*pw, zero, 0.0, 0.0); if (tNH < gt1 + 1.99e-4) delay(gt1 + 1.99e-4 - tNH); delay(tau2); dec2rgpulse(2.0*pwN, t9, 0.0, 0.0); if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1); else zgradpulse(gzlvl1, gt1); dec2phase(t10); if (tNH > gt1 + 1.99e-4) delay(tNH - gt1 - 2.0*GRADIENT_DELAY); else delay(1.99e-4 - 2.0*GRADIENT_DELAY); } else { if ( (C13refoc[A]=='y') && (tau2 > 0.5e-3 + WFG2_START_DELAY) ) { delay(tau2 - 0.5e-3 - WFG2_START_DELAY); /* WFG2_START_DELAY */ simshaped_pulse("", "adC180", 2.0*pw, pwC180, zero, zero, 0.0, 0.0); delay(tau2 - 0.5e-3); delay(gt1 + 2.0e-4);} else { delay(tau2); rgpulse(2.0*pw, zero, 0.0, 0.0); delay(gt1 + 2.0e-4 - 2.0*pw); delay(tau2); } dec2rgpulse(2.0*pwN, t9, 0.0, 0.0); if(mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1); else zgradpulse(gzlvl1, gt1); dec2phase(t10); delay(2.0e-4 - 2.0*GRADIENT_DELAY); } /* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */ sim3pulse(pw, 0.0, pwN, zero, zero, t10, 0.0, 0.0); dec2phase(zero); zgradpulse(gzlvl5, gt5); delay(tNH - 1.5*pwN - gt5); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); zgradpulse(gzlvl5, gt5); txphase(one); dec2phase(one); delay(tNH - 1.5*pwN - gt5); sim3pulse(pw, 0.0, pwN, one, zero, one, 0.0, 0.0); txphase(zero); dec2phase(zero); zgradpulse(1.5*gzlvl5, gt5); delay(tNH - 1.5*pwN - gt5); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); zgradpulse(1.5*gzlvl5, gt5); delay(tNH - pwN - 0.5*pw - gt5); rgpulse(pw, zero, 0.0, 0.0); delay((gt1/10.0) + 1.0e-4+ gstab - 0.5*pw + xdel); 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); delay(gstab + rof2); setreceiver(t11); rcvron(); statusdelay(C,1.0e-4-rof1); if(wudec[A]=='y') { decpwrf(4095.0); decpower(wuCdec_lr.pwr+3.0); decprgon("wurstC_lr", 1.0/wuCdec_lr.dmf, wuCdec_lr.dres); decon(); } }
R_API int r_run_config_env(RRunProfile *p) { int ret; if (!p->_program && !p->_system) { printf ("No program or system rule defined\n"); return 1; } // when IO is redirected to a process, handle them together if (handle_redirection (p->_stdio, true, true, false) != 0) { return 1; } if (handle_redirection (p->_stdin, true, false, false) != 0) { return 1; } if (handle_redirection (p->_stdout, false, true, false) != 0) { return 1; } if (handle_redirection (p->_stderr, false, false, true) != 0) { return 1; } if (p->_aslr != -1) setASLR (p->_aslr); #if __UNIX__ set_limit (p->_docore, RLIMIT_CORE, RLIM_INFINITY); if (p->_maxfd) set_limit (p->_maxfd, RLIMIT_NOFILE, p->_maxfd); #ifdef RLIMIT_NPROC if (p->_maxproc) set_limit (p->_maxproc, RLIMIT_NPROC, p->_maxproc); #endif if (p->_maxstack) set_limit (p->_maxstack, RLIMIT_STACK, p->_maxstack); #else if (p->_docore || p->_maxfd || p->_maxproc || p->_maxstack) eprintf ("Warning: setrlimits not supported for this platform\n"); #endif if (p->_connect) { char *q = strchr (p->_connect, ':'); if (q) { RSocket *fd = r_socket_new (0); *q = 0; if (!r_socket_connect_tcp (fd, p->_connect, q+1, 30)) { eprintf ("Cannot connect\n"); return 1; } eprintf ("connected\n"); close (0); close (1); close (2); dup2 (fd->fd, 0); dup2 (fd->fd, 1); dup2 (fd->fd, 2); } else { eprintf ("Invalid format for connect. missing ':'\n"); return 1; } } if (p->_listen) { RSocket *child, *fd = r_socket_new (0); bool is_child = false; if (!r_socket_listen (fd, p->_listen, NULL)) { eprintf ("rarun2: cannot listen\n"); r_socket_free (fd); return 1; } while (true) { child = r_socket_accept (fd); if (child) { is_child = true; if (p->_dofork && !p->_dodebug) { pid_t child_pid = r_sys_fork (); if (child_pid == -1) { eprintf("rarun2: cannot fork\n"); r_socket_free (child); r_socket_free (fd); return 1; } else if (child_pid != 0){ // parent code is_child = false; } } if (is_child) { r_socket_close_fd (fd); eprintf ("connected\n"); close (0); close (1); close (2); dup2 (child->fd, 0); dup2 (child->fd, 1); dup2 (child->fd, 2); break; } else { r_socket_close_fd (child); } } } if(!is_child) r_socket_free (child); r_socket_free (fd); } if (p->_r2sleep != 0) { r_sys_sleep (p->_r2sleep); } #if __UNIX__ if (p->_chroot) { if (chdir (p->_chroot) == -1) { eprintf ("Cannot chdir to chroot in %s\n", p->_chroot); return 1; } else { if (chroot (".") == -1) { eprintf ("Cannot chroot to %s\n", p->_chroot); return 1; } else { if (p->_chgdir) { if (chdir (p->_chgdir) == -1) { eprintf ("Cannot chdir after chroot to %s\n", p->_chgdir); return 1; } } } } } else if (p->_chgdir) { if (chdir (p->_chgdir) == -1) { eprintf ("Cannot chdir after chroot to %s\n", p->_chgdir); return 1; } } #endif if (p->_chgdir) { ret = chdir (p->_chgdir); if (ret < 0) { return 1; } } if (p->_chroot) { ret = chdir (p->_chroot); if (ret < 0) { return 1; } } #if __UNIX__ if (p->_chroot) { if (chroot (p->_chroot) == 0) { chdir ("/"); } else { eprintf ("rarun2: cannot chroot\n"); r_sys_perror ("chroot"); return 1; } } if (p->_setuid) { ret = setgroups (0, NULL); if (ret < 0) return 1; ret = setuid (atoi (p->_setuid)); if (ret < 0) return 1; } if (p->_seteuid) { ret = seteuid (atoi (p->_seteuid)); if (ret < 0) return 1; } if (p->_setgid) { ret = setgid (atoi (p->_setgid)); if (ret < 0) return 1; } if (p->_input) { char *inp; int f2[2]; pipe (f2); close (0); dup2 (f2[0], 0); inp = getstr (p->_input); if (inp) { write (f2[1], inp, strlen (inp)); close (f2[1]); free (inp); } else { eprintf ("Invalid input\n"); } } #endif if (p->_r2preload) { if (p->_preload) { eprintf ("WARNING: Only one library can be opened at a time\n"); } p->_preload = R2_LIBDIR"/libr2."R_LIB_EXT; } if (p->_libpath) { #if __WINDOWS__ eprintf ("rarun2: libpath unsupported for this platform\n"); #elif __HAIKU__ r_sys_setenv ("LIBRARY_PATH", p->_libpath); #elif __APPLE__ r_sys_setenv ("DYLD_LIBRARY_PATH", p->_libpath); #else r_sys_setenv ("LD_LIBRARY_PATH", p->_libpath); #endif } if (p->_preload) { #if __APPLE__ // 10.6 r_sys_setenv ("DYLD_PRELOAD", p->_preload); r_sys_setenv ("DYLD_INSERT_LIBRARIES", p->_preload); // 10.8 r_sys_setenv ("DYLD_FORCE_FLAT_NAMESPACE", "1"); #else r_sys_setenv ("LD_PRELOAD", p->_preload); #endif } if (p->_timeout) { #if __UNIX__ int mypid = getpid (); if (!r_sys_fork ()) { int use_signal = p->_timeout_sig; if (use_signal < 1) { use_signal = SIGKILL; } sleep (p->_timeout); if (!kill (mypid, 0)) { eprintf ("\nrarun2: Interrupted by timeout\n"); } kill (mypid, use_signal); exit (0); } #else eprintf ("timeout not supported for this platform\n"); #endif } return 0; }
pulsesequence() { /* DECLARE VARIABLES */ char autocal[MAXSTR], fsat[MAXSTR], fscuba[MAXSTR], f1180[MAXSTR], /* Flag to start t1 @ halfdwell */ f2180[MAXSTR], /* Flag to start t2 @ halfdwell */ spca180[MAXSTR], /* string for the waveform 180 */ fc180[MAXSTR], shp_sl[MAXSTR], /* string for shape of water pulse */ sel_flg[MAXSTR]; int phase, phase2, ni2, icosel, /* icosel changes sign with gds */ t1_counter, /* used for states tppi in t1 */ t2_counter; /* used for states tppi in t2 */ double pwC, pwClvl, compC, compN, tau1, /* t1 delay */ tau2, /* t2 delay */ taua, /* ~ 1/4JNH = 2.25 ms */ taub, /* ~ 1/4JNH = 2.25 ms */ zeta, /* time for C'-N to refocuss set to 0.5*24.0 ms */ timeTN, /* nitrogen T period */ BigT1, /* delay to compensate for gradient */ pwN, /* PW90 for 15N pulse */ pwco90, /* PW90 for co nucleus @ dhpwr */ pwca180h, /* PW180 for ca at dvhpwr */ pwco180, /* PW180 for co at dhpwr180 */ tsatpwr, /* low level 1H trans.power for presat */ dhpwr, /* power level for 13C pulses on dec1 - 64 us 90 for part a of the sequence */ dhpwr180, /* power level for 13C pulses on dec1 - 64 us 180 for part a of the sequence */ dvhpwr, /* power level for 180 13C pulses at 54 ppm using a 55.6 us 180 so that get null in co at 178 ppm */ pwNlvl, /* high dec2 pwr for 15N hard pulses */ sw1, /* sweep width in f1 */ sw2, /* sweep width in f2 */ pw_sl, /* pw90 for H selective pulse on water ~ 2ms */ phase_sl, /* pw90 for H selective pulse on water ~ 2ms */ tpwrsl, /* power level for square pw_sl */ Jf, /* scale factor for JNCo, set to 4-5 */ gt0, gt1, gt2, gt3, gt4, gt5, gt6, gt7, gt8, gstab, gzlvl0, gzlvl1, gzlvl2, gzlvl3, gzlvl4, gzlvl5, gzlvl6, gzlvl7, gzlvl8; /* LOAD VARIABLES */ getstr("autocal",autocal); getstr("fsat",fsat); getstr("f1180",f1180); getstr("f2180",f2180); getstr("fscuba",fscuba); getstr("spca180",spca180); getstr("fc180",fc180); getstr("shp_sl",shp_sl); getstr("sel_flg",sel_flg); taua = getval("taua"); taub = getval("taub"); zeta = getval("zeta"); timeTN = getval("timeTN"); BigT1 = getval("BigT1"); pwca180h = getval("pwca180h"); pwco180 = getval("pwco180"); pwco90 = getval("pwco90"); pwN = getval("pwN"); tpwr = getval("tpwr"); tsatpwr = getval("tsatpwr"); dhpwr = getval("dhpwr"); dhpwr180 = getval("dhpwr180"); dpwr = getval("dpwr"); pwNlvl = getval("pwNlvl"); phase = (int) ( getval("phase") + 0.5); phase2 = (int) ( getval("phase2") + 0.5); sw1 = getval("sw1"); sw2 = getval("sw2"); dvhpwr = getval("dvhpwr"); ni = getval("ni"); ni2 = getval("ni2"); pw_sl = getval("pw_sl"); phase_sl = getval("phase_sl"); tpwrsl = getval("tpwrsl"); Jf = getval("Jf"); gt0 = getval("gt0"); gt1 = getval("gt1"); gt2 = getval("gt2"); gt3 = getval("gt3"); gt4 = getval("gt4"); gt5 = getval("gt5"); gt6 = getval("gt6"); gt7 = getval("gt7"); gt8 = getval("gt8"); gstab = getval("gstab"); 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"); if (autocal[0] == 'y') { strcpy(spca180,"Phard_-118p"); if (FIRST_FID) { compC = getval("compC"); pwC = getval("pwC"); pwClvl = getval("pwClvl"); ca180 = pbox(spca180, CA180, CA180ps, dfrq, compC*pwC, pwClvl); co90 = pbox("Phard90", CO90, CA180ps, dfrq, compC*pwC, pwClvl); co180 = pbox("Phard180",CO180,CA180ps, dfrq, compC*pwC, pwClvl); pwN = getval("pwN"); compN = getval("compN"); pwNlvl = getval("pwNlvl"); } pwca180h = ca180.pw; dvhpwr = ca180.pwr; pwco90 = co90.pw; dhpwr = co90.pwr; pwco180 = co180.pw; dhpwr180 = co180.pwr; } /* LOAD PHASE TABLE */ settable(t1,4,phi1); settable(t2,2,phi2); settable(t3,4,phi3); settable(t4,1,phi4); settable(t6,4,rec); /* 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] == 'y' )) { printf("incorrect dec2 decoupler flags! Should be 'nnn' "); psg_abort(1); } if( tsatpwr > 6 ) { printf("TSATPWR too large !!! "); psg_abort(1); } if( dpwr > 46 ) { printf("don't fry the probe, DPWR too large! "); psg_abort(1); } if( dpwr2 > 46 ) { printf("don't fry the probe, DPWR2 too large! "); psg_abort(1); } if( dhpwr > 62 ) { 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( pwN > 200.0e-6 ) { printf("dont fry the probe, pwN too high ! "); psg_abort(1); } if( pwco90 > 200.0e-6 ) { printf("dont fry the probe, pwco90 too high ! "); psg_abort(1); } if( pwca180h > 200.0e-6 ) { printf("dont fry the probe, pwca180h too high ! "); psg_abort(1); } if( gt3 > 2.5e-3 ) { printf("gt3 is too long\n"); psg_abort(1); } if( gt0 > 10.0e-3 || gt1 > 10.0e-3 || gt2 > 10.0e-3 || gt4 > 10.0e-3 || gt5 > 10.0e-3 || gt6 > 10.0e-3 || gt7 > 10.0e-3 || gt8 > 10.0e-3) { printf("gti values are too long. Must be < 10.0e-3\n"); psg_abort(1); } /* Phase incrementation for hypercomplex 2D data */ if (phase == 2) tsadd(t1,1,4); if (phase2 == 2) { tsadd(t4, 2, 4); icosel = 1; } /* change sign of gradient */ else icosel = -1; /* Set up f1180 tau1 = t1 */ tau1 = d2; if(f1180[A] == 'y') { tau1 += ( 1.0 / (2.0*sw1) - 2*pwN - pwca180h - 4.0/PI*pwco90 - 2*POWER_DELAY - WFG_START_DELAY - 8.0e-6 - WFG_STOP_DELAY ); if(tau1 < 0.2e-6) tau1 = 0.4e-6; } tau1 = tau1/2.0; /* Set up f2180 tau2 = t2 */ tau2 = d3; if(f2180[A] == 'y') { tau2 += ( 1.0 / (2.0*sw2) ); if(tau2 < 0.2e-6) tau2 = 0.4e-6; } 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(t6,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(t6,2,4); } /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); obspower(tsatpwr); /* Set transmitter power for 1H presaturation */ decpower(dvhpwr); /* Set Dec1 power for hard 13C pulses */ dec2power(pwNlvl); /* Set Dec2 power for 15N hard pulses */ /* Presaturation Period */ if (fsat[0] == 'y') { rgpulse(d1,zero,2.0e-6,2.0e-6); /* presaturation */ 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); delay(1.0e-5); /* Begin Pulses */ status(B); rcvroff(); delay(20.0e-6); initval(1.0,v2); obsstepsize(phase_sl); xmtrphase(v2); /* shaped pulse */ obspower(tpwrsl); shaped_pulse(shp_sl,pw_sl,one,2.0e-6,0.0); xmtrphase(zero); delay(2.0e-6); obspower(tpwr); txphase(zero); /* shaped pulse */ rgpulse(pw,zero,0.0,0.0); /* 90 deg 1H pulse */ delay(0.2e-6); zgradpulse(gzlvl5*1.3,gt5); delay(taua - gt5 - 0.2e-6); /* taua <= 1/4JNH */ sim3pulse(2*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0); dec2phase(zero); decphase(zero); delay(taua -gt5 -gstab -4.0e-6); zgradpulse(gzlvl5*1.3,gt5); delay(gstab); if(sel_flg[A] == 'y') { /* active suppression of one of the two components */ rgpulse(pw,one,4.0e-6,0.0); /* shaped pulse */ initval(1.0,v3); obsstepsize(45.0); dcplr2phase(v3); delay(0.2e-6); zgradpulse(gzlvl3,gt3); delay(gstab); dec2rgpulse(pwN,zero,0.0,0.0); dcplr2phase(zero); delay( 1.34e-3 - SAPS_DELAY - 2.0*pw); rgpulse(pw,one,0.0,0.0); rgpulse(2*pw,zero,0.0,0.0); rgpulse(pw,one,0.0,0.0); delay( zeta - 1.34e-3 - 2.0*pw + pwco180 ); } else { rgpulse(pw,three,4.0e-6,0.0); delay(0.2e-6); zgradpulse(gzlvl4,gt4); delay(gstab); dec2rgpulse(pwN,zero,0.0,0.0); delay( zeta + pwco180 ); } dec2rgpulse(2*pwN,zero,0.0,0.0); decpower(dhpwr180); decrgpulse(pwco180,zero,0.0,0.0); delay(zeta - 2.0e-6); dec2rgpulse(pwN,one,2.0e-6,0.0); dec2phase(zero); decphase(t1); decpower(dhpwr); delay(0.2e-6); zgradpulse(gzlvl7,gt7); delay(gstab); decpower(dhpwr); decrgpulse(pwco90,t1,2.0e-6,0.0); if( fc180[A] == 'n' ) { decphase(zero); delay(tau1); dec2rgpulse(2*pwN,zero,0.0,0.0); decpower(dvhpwr); decshaped_pulse(spca180,pwca180h,zero,4.0e-6,0.0); decpower(dhpwr); delay(tau1); } else decrgpulse(2*pwco90,zero,2.0e-7,2.0e-7); decrgpulse(pwco90,zero,4.0e-6,0.0); decpower(dvhpwr); delay(0.2e-6); zgradpulse(gzlvl3,gt3); delay(gstab); dec2rgpulse(pwN,t2,2.0e-6,0.0); delay(tau2); decshaped_pulse(spca180,pwca180h,zero,0.0,0.0); delay(tau2); decpower(dhpwr180); delay(tau2*Jf); decrgpulse(pwco180,zero,0.0,0.0); delay(0.2e-6); zgradpulse(-icosel*gzlvl1,gt1/2.0); delay(50.0e-6); delay(timeTN - 50.0e-6 -0.2e-6 - 2.0*GRADIENT_DELAY - gt1/2.0); dec2rgpulse(2*pwN,t3,0.0,0.0); delay(0.2e-6); zgradpulse(icosel*gzlvl1,gt1/2.0); delay(50.0e-6); delay(tau2*Jf + timeTN - 50.0e-6 -0.2e-6 - 2.0*GRADIENT_DELAY - gt1/2.0 + WFG_START_DELAY + pwca180h + WFG_STOP_DELAY + pwco180 ); sim3pulse(pw,0.0e-6,pwN,zero,zero,t4,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.0e-6,2*pwN,zero,zero,zero,0.0,0.0); delay(0.2e-6); zgradpulse(gzlvl6,gt6); delay(gstab); txphase(one); dec2phase(one); delay(taub - gt6 - gstab -0.2e-6); sim3pulse(pw,0.0e-6,pwN,one,zero,one,0.0,0.0); delay(0.2e-6); zgradpulse(gzlvl5,gt5); delay(2.0e-6); txphase(zero); dec2phase(zero); delay(taub - gt5 - 2.2e-6); sim3pulse(2*pw,0.0e-6,2*pwN,zero,zero,zero,0.0,0.0); delay(0.2e-6); zgradpulse(gzlvl5,gt5); delay(gstab); delay(taub - gt5 - gstab -0.2e-6); sim3pulse(pw,0.0e-6,pwN,zero,zero,zero,0.0,0.0); delay(gt2 +gstab +2.0*GRADIENT_DELAY +2.0*POWER_DELAY -0.5*(pwN - pw) -2.0*pw/PI); rgpulse(2.0*pw,zero,0.0,0.0); dec2power(dpwr2); decpower(dpwr); zgradpulse(gzlvl2,gt2); delay(gstab); status(C); setreceiver(t6); }
void pulsesequence() { double hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), satpwr = getval("satpwr"), satdly = getval("satdly"); int prgcycle = (int)(getval("prgcycle")+0.5); char sspul[MAXSTR],satmode[MAXSTR],wet[MAXSTR]; getstr("satmode",satmode); getstr("sspul", sspul); getstr("wet",wet); assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1,4,ph1); getelem(t1,v17,v1); settable(t2,8,ph2); getelem(t2,v17,v2); assign(v1,oph); add(oph,v18,oph); add(oph,v19,oph); /* BEGIN ACTUAL SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,v4); if (getflag("prgflg")) shaped_purge(v1,v4,v18,v19); } else { satpulse(satdly,v4,rof1,rof1); if (getflag("prgflg")) purge(v1,v4,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); if (getflag("cpmgflg")) { rgpulse(pw, v1, rof1, 0.0); cpmg(v1, v15); } else rgpulse(pw, v1, rof1, rof1); delay(d2/2); rgpulse(2.0*pw, v2, rof1, 2*rof1); delay(d2/2 + 2*pw/PI); status(C); }
pulsesequence() { /* DECLARE VARIABLES */ char f1180[MAXSTR],f2180[MAXSTR]; int t1_counter,t2_counter,icosel,first_FID; double /* DELAYS */ tau1, /* t1/2 */ tau2, /* t2/2 */ /* COUPLINGS */ jhn = getval("jhn"), tauhn, jnco = getval("jnco"), taunco, jcoca = getval("jcoca"), taucoca, jnca = getval("jnca"), taunca, jhaca = getval("jhaca"), tauhaca, jcaha = getval("jcaha"), taucaha, jcacb = getval("jcacb"), taucacb, /* PULSES */ pwN = getval("pwN"), /* PW90 for N-nuc */ pwC = getval("pwC"), /* PW90 for C-nuc */ pwHs = getval("pwHs"), /* pw for H2O selective pulse */ /* constants */ kappa,ni2 = getval("ni2"), /* POWER LEVELS */ satpwr = getval("satpwr"), /* low power level for presat */ tpwrs, /* power level for selective pulse for water */ tpwrsf_u = getval("tpwrsf_u"), /* fine power level for H2O pulse */ pwClvl = getval("pwClvl"), /* power level for C hard pulses */ pwNlvl = getval("pwNlvl"), /* power level for N hard pulses */ compH = getval("compH"), /* amplifier compression */ compC = getval("compC"), /* amplifier compression */ rf90onca, pw90onca, /* power level/widthfor Ca 90 hard pulses */ rf180onca,pw180onca, /* power level/widthfor Ca 180 hard pulses */ /* GRADIENT DELAYS AND LEVELS */ gt0 = getval("gt0"), /* grad time */ gt1 = getval("gt1"), /* grad time */ gt3 = getval("gt3"), /* grad time */ gt5 = getval("gt5"), /* grad time */ gstab = getval("gstab"), /* grad time */ gzlvl0 = getval("gzlvl0"), /* level of grad. */ gzlvl1 = getval("gzlvl1"), gzlvl2 = getval("gzlvl2"), gzlvl3 = getval("gzlvl3"), gzlvl5 = getval("gzlvl5"); /* LOAD VARIABLES */ getstr("f1180",f1180); getstr("f2180",f2180); /* 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 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, 1, phi1); settable(t3, 1, phi3); settable(t4, 2, phi4); settable(t5, 4, phi5); settable(t6, 8, phi6); settable(t7, 4, phi7); /* INITIALIZE VARIABLES */ tauhn = ((jhn != 0.0) ? 1/(4*(jhn)) : 2.25e-3); taunco = ((jnco !=0.0) ? 1/(4*(jnco)) : 15e-3); taucoca = ((jcoca !=0.0) ? 1/(4*(jcoca)) : 4.5e-3); taunca = ((jnca !=0.0) ? 1/(4*(jnca)) : 12e-3); tauhaca = ((jhaca !=0.0) ? 1/(4*(jhaca)) : 12e-3); taucaha = ((jcaha !=0.0) ? 1/(4*(jcaha)) : 12e-3); taucacb = ((jcacb !=0.0) ? 1/(4*(jcacb)) : 12e-3); /* Phase incrementation for hypercomplex data */ if (phase2 == 1) /* Hypercomplex in t2 */ { icosel = 1; tsadd(t3, 2, 4); } else icosel = -1; if (phase1 == 2) /* Hypercomplex in t1 */ { tsadd(t4, 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) /* STATES-TPPI */ { tsadd(t4,2,4); tsadd(t7,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) /* STATES-TPPI */ { tsadd(t1,2,4); tsadd(t7,2,4); } /* Calculate correct 13C pulse widths */ if((getval("arraydim") < 1.5) || (ix==1)) first_FID = 1; else first_FID = 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 */ if (tpwrsf_u<4095.0) tpwrs=tpwrs+6; /* nominal tpwrsf_u ~ 2048 */ /* tpwrsf_u can be used to correct for radiation damping */ /* 90 degree pulse on Ca, null at CO 118ppm away */ pw90onca = sqrt(15.0)/(4.0*118.0*dfrq); rf90onca = (4095.0*pwC*compC)/pw90onca; rf90onca = (int) (rf90onca + 0.5); if(rf90onca > 4095.0) { if(first_FID) printf("insufficient power for pw90onca -> rf90onca (%.0f)\n", rf90onca); rf90onca = 4095.0; pw90onca = pwC; } /* 180 degree pulse on CA, null at Co 118ppm away */ pw180onca = sqrt(3.0)/(2.0*118.0*dfrq); rf180onca = (4095.0*pwC*compC*2.0)/pw180onca; rf180onca = (int) (rf180onca + 0.5); if(rf180onca > 4095.0) { if(first_FID) printf("insufficient power for pw180onca -> rf180onca (%.0f)\n", rf180onca); rf180onca = 4095.0; pw180onca = pwC*2.0; } /* 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) - (4.0/PI)*pw90onca - 2.0*pwN - PRG_START_DELAY - PRG_STOP_DELAY - 4.0*POWER_DELAY); 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) ); tau2 = tau2/2.0; if(ni2 > 1) kappa = (double)(t2_counter*(2.0*taunca + pw180onca + PRG_START_DELAY + 2*POWER_DELAY)) / ( (double) (ni2-1) ); else kappa = 0.0; if (ix == 1) printf("semi-constant time factor %4.6f\n",kappa); /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); obspower(satpwr); /* Set power for presaturation */ decpower(pwClvl); /* Set decoupler1 power to pwClvl */ dec2power(pwNlvl); /* Set decoupler2 power to pwNlvl */ /* Presaturation Period */ if (satmode[0] == 'y') { rgpulse(d1,zero,rof1,0.0); obspower(tpwr); /* Set power for hard pulses */ } else { obspower(tpwr); /* Set power for hard pulses */ delay(d1); } if (dm3[B] == 'y') lk_hold(); rcvroff(); /* eliminate all magnetization originating on 13Ca */ decpwrf(rf90onca); decrgpulse(pw90onca,zero,0.0,0.0); zgradpulse(gzlvl0,gt0); delay(gstab); /* transfer from HN to N by INEPT */ rgpulse(pw,zero,rof1,0.0); delay(2.0e-6); zgradpulse(gzlvl0*0.9,gt0); delay(gstab); delay(tauhn - gt0 - gstab); /* 1/4JHN */ sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1); delay(tauhn - gt0 - gstab); /* 1/4JHN */ zgradpulse(gzlvl0*0.9,gt0); delay(gstab-rof1); rgpulse(pw,three,rof1,0.0); /* shaped pulse for water flip-back */ obspower(tpwrs); obspwrf(tpwrsf_u); shaped_pulse("H2Osinc_u",pwHs,zero,rof1,0.0); obspower(tpwr); obspwrf(4095.0); /* shaped pulse */ zgradpulse(gzlvl3,gt3); delay(gstab); /* start transfer from N to CO */ dec2rgpulse(pwN,t1,0.0,0.0); /* decoupling on for carbonyl carbon */ decpwrf(4095.0); decpower(dpwr); decprgon(dseq,1.0/dmf,dres); decon(); /* decoupling on for carbonyl carbon */ delay(tau2); /* co-decoupling off */ decoff(); decprgoff(); /* co-decoupling off */ decpower(pwClvl); decpwrf(rf180onca); decrgpulse(pw180onca,zero,0.0,0.0); /* decoupling on for carbonyl carbon */ decpwrf(4095.0); decpower(dpwr); decprgon(dseq,1.0/dmf,dres); decon(); /* decoupling on for carbonyl carbon */ delay((1-kappa)*tau2); dec2rgpulse(2.0*pwN,t5,0.0,0.0); delay(2.0*taunca + pw180onca + 2.0*POWER_DELAY + 2.0*PRG_START_DELAY - kappa*tau2); /* 1/(4JNCA) */ /* co-decoupling off */ decoff(); decprgoff(); /* co-decoupling off */ decpower(pwClvl); decpwrf(rf90onca); /* t1 evolution period for 13Ca */ if(dm3[B] == 'y') /*optional 2H decoupling on */ { dec3unblank(); dec3rgpulse(1/dmf3, one, 0.0, 0.0); dec3unblank(); setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);} decrgpulse(pw90onca,t4,0.0,0.0); /* decoupling on for carbonyl carbon */ decpwrf(4095.0); decpower(dpwr); decprgon(dseq,1.0/dmf,dres); decon(); /* decoupling on for carbonyl carbon */ delay(tau1); dec2rgpulse(2.0*pwN,zero,0.0,0.0); delay(tau1); /* co-decoupling off */ decoff(); decprgoff(); /* co-decoupling off */ decpower(pwClvl); decpwrf(rf90onca); /* Set decoupler1 power to rf90onca */ decrgpulse(pw90onca,zero,0.0,0.0); /* 90 for Ca */ /* decoupling on for carbonyl carbon */ decpwrf(4095.0); decpower(dpwr); decprgon(dseq,1.0/dmf,dres); decon(); /* decoupling on for carbonyl carbon */ if(dm3[B] == 'y') /*optional 2H decoupling off */ {dec3rgpulse(1/dmf3, three, 0.0, 0.0); dec3blank(); setstatus(DEC3ch, FALSE, 'w', FALSE, dmf3); dec3blank();} if (dm3[B] == 'y') lk_sample(); delay(2.0*taunca - POWER_DELAY - PRG_STOP_DELAY - gt1 - gstab); /* co-decoupling off */ decoff(); decprgoff(); /* co-decoupling off */ decpower(pwClvl); zgradpulse(gzlvl1,gt1); delay(gstab); /* start TROSY transfer from N to HN using PEP-TROSY */ sim3pulse(pw,0.0,pwN,zero,zero,t3,rof1,0.0); zgradpulse(gzlvl5,gt5); delay(gstab); delay(tauhn - gt5 - gstab); /* 1/4J (HN) */ sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1); delay(tauhn - gt5 - gstab); /* 1/4J (HN) */ zgradpulse(gzlvl5,gt5); delay(gstab); decpwrf(rf90onca); /* Set decoupler1 power to rf90onca */ sim3pulse(pw,pw90onca,pwN,one,t6,one,rof1,rof1); /* 90 for 1H, 13Ca and 15N */ zgradpulse(gzlvl5*0.8,gt5); delay(gstab); delay(tauhn - gt5 - gstab); /* 1/4J (HN) */ sim3pulse(2.0*pw,0.0,2.0*pwN,zero,zero,zero,rof1,rof1); /* 180 for 1H and 15N */ delay(tauhn - gt5 - gstab - POWER_DELAY); /* 1/4J (HN) */ zgradpulse(gzlvl5*0.8,gt5); delay(gstab -rof1); sim3pulse(pw,0.0,pwN,zero,zero,zero,rof1,0.0); /* 90 for 15N */ dec2power(dpwr2); decpower(dpwr); delay((gt1/10.0) + gstab - pwN - rof1 - 2.0*POWER_DELAY); rgpulse(2.0*pw, zero, rof1, rof1); zgradpulse(gzlvl2*icosel,gt1/10.0); delay(gstab); /* acquire data */ status(C); setreceiver(t7); }
int getdelim (char **lineptr, size_t * n, int delimiter, FILE * stream) { return getstr (lineptr, n, stream, delimiter, 0, 0); }
pulsesequence() { char N15edit[MAXSTR], C13edit[MAXSTR]; /* C13 editing*/ double tpwrs,pwC,d2,tau,d3,d4,d5,d6, gt2,gt3,gt0,gzlvl0,gzlvl2,gzlvl3,phincr1,tpwrsf_u,tpwrsf_d,pwHs,compH, pwN,pwNlvl,ref_pwr,ref_pw90,pwZa,pwClvl,JXH; pwC=getval("pwC"); pwClvl=getval("pwClvl"); ref_pw90=getval("ref_pw90"); ref_pwr=getval("ref_pwr"); pwHs=getval("pwHs"); gt2=getval("gt2"); gt3=getval("gt3"); gt0=getval("gt0"); /* tau=getval("tau"); */ d2=getval("d2"); d3=getval("d3"); d4=getval("d4"); d5=getval("d5"); gzlvl2=getval("gzlvl2"); gzlvl3=getval("gzlvl3"); gzlvl0=getval("gzlvl0"); phincr1 = getval("phincr1"); d6=getval("d6"); JXH = getval("JXH"); tpwrsf_u = getval("tpwrsf_u"); /* fine power adjustment */ tpwrsf_d = getval("tpwrsf_d"); /* fine power adjustment */ pwHs = getval("pwHs"); /* H1 90 degree pulse length at tpwrs2 */ compH = getval("compH"); pwNlvl = getval("pwNlvl"); /* power for N15 pulses */ pwN = getval("pwN"); /* N15 90 degree pulse length at pwNlvl */ getstr("N15edit",N15edit); getstr("C13edit",C13edit); pwZa=pw; /* initialize variable */ /* optional editing for C13 enriched samples */ if ((N15edit[A]=='y') && (C13edit[A]=='n')) { pwC = 0.0; if (2.0*pw > 2.0*pwN) pwZa = pw; else pwZa = pwN; } if ((C13edit[A]=='y')&& (N15edit[A]=='n')) { pwN = 0.0; if (2.0*pw > 2.0*pwC) pwZa = pw; else pwZa = pwC; } if ((C13edit[A]=='y') && (N15edit[A]=='y')) { if (2.0*pw > 2.0*pwN) pwZa = pw; /*pwN always longer than pwC*/ else pwZa = pwN; } tau = 1/(2*(JXH)); printf("tau is %f\n",tau); printf("pwZa is %f\n",pwZa); /* set pwZa to either pw or pwX depending on which is the largest (for calculating delays) */ /*calculate phase cycle for WATERGATE*/ hlv(ct,v1); hlv(v1,v2); mod2(v2,v3); dbl(v3,v4); assign(two,v5); add(v4,v5,v6); obsstepsize(1.0); if (phincr1 < 0.0) phincr1=360+phincr1; initval(phincr1,v7); settable(t1,16,ph1); settable(t2,16,ph2); settable(t3,16,ph3); settable(t4,16,ph4); settable(t5,16,ph5); settable(t6,16,ph6); settable(t7,16,ph7); settable(t8,16,ph8); settable(t9,16,ph9); settable(t10,2,ph10); tpwrs=tpwr-20.0*log10(pwHs/(compH*pw*1.69)); /* sinc pulse */ tpwrs = (int) (tpwrs) +6.0; /* to permit finepower ~2048 */ /* START THE PULSE SEQUENCE */ status(A); decpower(pwClvl); delay(d1); obsoffset(tof); /*zgradpulse(gzlvl2,gt2); delay(d3+d5-pwHs);*/ obspower(tpwrs); obspwrf(tpwrsf_d); shaped_pulse("H2Osinc_d",pwHs,t2,rof1,rof1); status(B); obspower(tpwr); obspwrf(4095.0); rgpulse(pw,t1,3.0e-6,0.0); delay(d2); zgradpulse(gzlvl2,gt2); delay(d5); rgpulse(pw,t3,3.0e-6,3.0e-6); obspower(tpwrs); obspwrf(tpwrsf_u); shaped_pulse("H2Osinc_u",pwHs,t4,rof1,rof1); zgradpulse(gzlvl3,gt3); delay(d3); obspwrf(tpwrsf_d); shaped_pulse("H2Osinc_d",pwHs,t6,rof1,rof1); obspower(tpwr); obspwrf(4095.0); rgpulse(pw,t5,3.0e-6,3.0e-6); delay(d2); zgradpulse(gzlvl2,gt2); delay(d5); delay(d6); zgradpulse(gzlvl0,gt0); obspower(tpwrs); obspwrf(tpwrsf_d); xmtrphase(v7); delay(tau-pwHs-pwZa-gt0-d6-pwN); shaped_pulse("H2Osinc_d",pwHs,v6,rof1,rof1); obspower(tpwr); obspwrf(4095.0); xmtrphase(zero); dec2power(pwNlvl); dec2rgpulse(pwN,zero,1.0e-6,1.0e-6); decrgpulse(pwC,zero,1.0e-6,1.0e-6); rgpulse(2*pw,t7,1.0e-6, 1.0e-6); decrgpulse(pwC,t10,1.0e-6,1.0e-6); dec2rgpulse(pwN,t10,1.0e-6,1.0e-6); obspower(tpwrs); obspwrf(tpwrsf_u); shaped_pulse("H2Osinc_u",pwHs,t9,rof1,rof1); delay(tau-pwHs-pwZa-gt0-d6-pwN); zgradpulse(gzlvl0,gt0); dec2power(dpwr2); decpower(dpwr); delay(d6); setreceiver(t8); status(C); }
int readfargs( /* read function arguments from stream */ FUNARGS *fa, FILE *fp ) { #define getstr(s) (fgetword(s,sizeof(s),fp)!=NULL) #define getint(s) (getstr(s) && isint(s)) #define getflt(s) (getstr(s) && isflt(s)) char sbuf[MAXSTR]; int n, i; if (!getint(sbuf) || (n = atoi(sbuf)) < 0) return(0); if ( (fa->nsargs = n) ) { fa->sarg = (char **)malloc(n*sizeof(char *)); if (fa->sarg == NULL) return(-1); for (i = 0; i < fa->nsargs; i++) { if (!getstr(sbuf)) return(0); fa->sarg[i] = savestr(sbuf); } } else fa->sarg = NULL; if (!getint(sbuf) || (n = atoi(sbuf)) < 0) return(0); #ifdef IARGS if (fa->niargs = n) { fa->iarg = (long *)malloc(n*sizeof(long)); if (fa->iarg == NULL) return(-1); for (i = 0; i < n; i++) { if (!getint(sbuf)) return(0); fa->iarg[i] = atol(sbuf); } } else fa->iarg = NULL; #else if (n != 0) return(0); #endif if (!getint(sbuf) || (n = atoi(sbuf)) < 0) return(0); if ( (fa->nfargs = n) ) { fa->farg = (RREAL *)malloc(n*sizeof(RREAL)); if (fa->farg == NULL) return(-1); for (i = 0; i < n; i++) { if (!getflt(sbuf)) return(0); fa->farg[i] = atof(sbuf); } } else fa->farg = NULL; return(1); #undef getflt #undef getint #undef getstr }
static void PrintCode(const Proto* f) { const Instruction* code=f->code; int pc,n=f->sizecode; for (pc=0; pc<n; pc++) { Instruction i=code[pc]; OpCode o=GET_OPCODE(i); int a=GETARG_A(i); int b=GETARG_B(i); int c=GETARG_C(i); int bx=GETARG_Bx(i); int sbx=GETARG_sBx(i); int line=getline(f,pc); printf("\t%d\t",pc+1); if (line>0) printf("[%d]\t",line); else printf("[-]\t"); printf("%-9s\t",luaP_opnames[o]); switch (getOpMode(o)) { case iABC: printf("%d",a); if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (-1-INDEXK(b)) : b); if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (-1-INDEXK(c)) : c); break; case iABx: if (getBMode(o)==OpArgK) printf("%d %d",a,-1-bx); else printf("%d %d",a,bx); break; case iAsBx: if (o==OP_JMP) printf("%d",sbx); else printf("%d %d",a,sbx); break; } switch (o) { case OP_LOADK: printf("\t; "); PrintConstant(f,bx); break; case OP_GETUPVAL: case OP_SETUPVAL: printf("\t; %s", (f->sizeupvalues>0) ? getstr(f->upvalues[b]) : "-"); break; case OP_GETGLOBAL: case OP_SETGLOBAL: printf("\t; %s",svalue(&f->k[bx])); break; case OP_GETTABLE: case OP_SELF: if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); } break; case OP_SETTABLE: case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_POW: case OP_EQ: case OP_LT: case OP_LE: if (ISK(b) || ISK(c)) { printf("\t; "); if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-"); printf(" "); if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-"); } break; case OP_JMP: case OP_FORLOOP: case OP_FORPREP: printf("\t; to %d",sbx+pc+2); break; case OP_CLOSURE: printf("\t; %p",VOID(f->p[bx])); break; case OP_SETLIST: if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c); break; default: break; } printf("\n"); } }
pulsesequence() { double satdly = getval("satdly"); int prgcycle=(int)(getval("prgcycle")+0.5); char satmode[MAXSTR], sspul[MAXSTR]; getstr("satmode",satmode); getstr("sspul",sspul); assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1,4,phs1); settable(t2,8,phs2); settable(t3,4,phs3); getelem(t1,v17,v1); getelem(t2,v17,v2); getelem(t3,v17,v3); assign(v1,oph); add(oph,v18,oph); add(oph,v19,oph); if (getflag("prgflg") && (satmode[0] == 'y')) assign(v3,v2); /* equilibrium period */ status(A); delay(5.0e-5); if (sspul[0] == 'y') steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,v2); if (getflag("prgflg")) shaped_purge(v1,v2,v18,v19); } else { satpulse(satdly,v2,rof1,rof1); if (getflag("prgflg")) purge(v1,v2,v18,v19); } } else delay(d1); status(B); pulse(p1,zero); hsdelay(d2); rgpulse(pw,v1,rof1,rof2); status(C); }
static char * printf_doformat(char *start, int *rval) { static const char skip1[] = "#'-+ 0"; static const char skip2[] = "0123456789"; char *fmt; int fieldwidth, haveprec, havewidth, mod_ldbl, precision; char convch, nextch; fmt = start + 1; /* skip to field width */ fmt += strspn(fmt, skip1); if (*fmt == '*') { if (getint(&fieldwidth)) return (NULL); havewidth = 1; ++fmt; } else { havewidth = 0; /* skip to possible '.', get following precision */ fmt += strspn(fmt, skip2); } if (*fmt == '.') { /* precision present? */ ++fmt; if (*fmt == '*') { if (getint(&precision)) return (NULL); haveprec = 1; ++fmt; } else { haveprec = 0; /* skip to conversion char */ fmt += strspn(fmt, skip2); } } else haveprec = 0; if (!*fmt) { warnx("missing format character"); return (NULL); } /* * Look for a length modifier. POSIX doesn't have these, so * we only support them for floating-point conversions, which * are extensions. This is useful because the L modifier can * be used to gain extra range and precision, while omitting * it is more likely to produce consistent results on different * architectures. This is not so important for integers * because overflow is the only bad thing that can happen to * them, but consider the command printf %a 1.1 */ if (*fmt == 'L') { mod_ldbl = 1; fmt++; if (!strchr("aAeEfFgG", *fmt)) { warnx("bad modifier L for %%%c", *fmt); return (NULL); } } else { mod_ldbl = 0; } convch = *fmt; nextch = *++fmt; *fmt = '\0'; switch (convch) { case 'b': { size_t len; char *p; int getout; p = strdup(getstr()); if (p == NULL) { warnx("%s", strerror(ENOMEM)); return (NULL); } getout = escape(p, 0, &len); *(fmt - 1) = 's'; PF(start, p); *(fmt - 1) = 'b'; free(p); if (getout) return (fmt); break; } case 'c': { char p; p = getchr(); PF(start, p); break; } case 's': { const char *p; p = getstr(); PF(start, p); break; } case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': { char *f; intmax_t val; uintmax_t uval; int signedconv; signedconv = (convch == 'd' || convch == 'i'); if ((f = mknum(start, convch)) == NULL) return (NULL); if (getnum(&val, &uval, signedconv)) *rval = 1; if (signedconv) PF(f, val); else PF(f, uval); break; } case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': case 'a': case 'A': { long double p; if (getfloating(&p, mod_ldbl)) *rval = 1; if (mod_ldbl) PF(start, p); else PF(start, (double)p); break; } default: warnx("illegal format character %c", convch); return (NULL); } *fmt = nextch; return (fmt); }
static const char *upvalname (Proto *p, int uv) { TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); if (s == NULL) return "?"; else return getstr(s); }
afs_int32 UDP_GetTicket(int ksoc, struct packet *pkt, afs_int32 kvno, char *authDomain, char *ticket, int ticketLen, char *auth, int authLen) { afs_int32 code; struct ktc_encryptionKey tgskey; char name[MAXKTCNAMELEN]; char inst[MAXKTCNAMELEN]; char cell[MAXKTCREALMLEN]; struct ktc_encryptionKey authSessionKey; afs_int32 host; Date start; Date authEnd; Date now = time(0); int celllen; int import; char *packet; int slen; int byteOrder = pkt->byteOrder; char sname[MAXKTCNAMELEN]; char sinst[MAXKTCNAMELEN]; afs_int32 time_ws; unsigned char life; struct ubik_trans *tt; afs_int32 to; struct kaentry caller; struct kaentry server; Date reqEnd; struct ktc_encryptionKey sessionKey; int newTicketLen; char newTicket[MAXKTCTICKETLEN]; char cipher[2 * MAXKTCTICKETLEN]; /* put encrypted part of answer here */ int cipherLen; struct packet ans; COUNT_REQ(UGetTicket); if ((code = InitAuthServ(&tt, LOCKREAD, this_op))) goto fail; code = ka_LookupKvno(tt, KA_TGS_NAME, ((strlen(authDomain) > 0) ? authDomain : lrealm), kvno, &tgskey); if (code) goto abort; code = tkt_DecodeTicket(ticket, ticketLen, &tgskey, name, inst, cell, &authSessionKey, &host, &start, &authEnd); pkt->name = name; pkt->inst = inst; pkt->realm = cell; if (code) { code = KERB_ERR_AUTH_EXP; /* was KANOAUTH */ goto abort; } save_principal(udptgsPrincipal, name, inst, cell); code = tkt_CheckTimes(start, authEnd, now); if (code <= 0) { if (code == -1) { code = KERB_ERR_SERVICE_EXP; /* was RXKADEXPIRED */ goto abort; } code = KERB_ERR_AUTH_EXP; /* was KANOAUTH */ goto abort; } celllen = strlen(cell); import = 0; if ((strlen(authDomain) > 0) && (strcmp(authDomain, lrealm) != 0)) import = 1; if (import && (celllen == 0)) { code = KERB_ERR_PKT_VER; /* was KABADTICKET */ goto abort; } if (celllen == 0) { strncpy(cell, lrealm, MAXKTCREALMLEN - 1); cell[MAXKTCREALMLEN - 1] = 0; }; if (!krb4_cross && strcmp(lrealm, cell) != 0) { code = KERB_ERR_PRINCIPAL_UNKNOWN; goto abort; } if (krb_udp_debug) { printf("UGetTicket: got ticket from '%s'.'%s'@'%s'\n", name, inst, cell); } code = check_auth(pkt, auth, authLen, &authSessionKey, name, inst, cell); if (code) goto abort; /* authenticator and all is OK so read actual request */ packet = pkt->rest; getint(time_ws); life = *(unsigned char *)packet++; getstr(sname); getstr(sinst); start = now; reqEnd = life_to_time(start, life); if (krb_udp_debug) { printf("UGetTicket: request for server '%s'.'%s'\n", sname, sinst); } save_principal(udptgsServerPrincipal, sname, sinst, 0); if (import) { strcpy(caller.userID.name, name); strcpy(caller.userID.instance, inst); caller.max_ticket_lifetime = htonl(MAXKTCTICKETLIFETIME); } else { code = FindBlock(tt, name, inst, &to, &caller); if (code) goto abort; if (to == 0) { ka_PrintUserID("GetTicket: User ", name, inst, " unknown.\n"); code = KERB_ERR_PRINCIPAL_UNKNOWN; /* KANOENT */ goto abort; } if (ntohl(caller.flags) & KAFNOTGS) { code = KERB_ERR_AUTH_EXP; /* was KABADUSER */ goto abort; } } code = FindBlock(tt, sname, sinst, &to, &server); /* get server's entry */ if (code) goto abort; if (to == 0) { /* entry not found */ ka_PrintUserID("GetTicket: Server ", sname, sinst, " unknown.\n"); code = KERB_ERR_PRINCIPAL_UNKNOWN; /* KANOENT */ goto abort; } code = ubik_EndTrans(tt); if (code) goto fail; if (ntohl(server.flags) & KAFNOSEAL) return KABADSERVER; code = des_random_key(ktc_to_cblock(&sessionKey)); if (code) { code = KERB_ERR_NULL_KEY; /* was KANOKEYS */ goto fail; } reqEnd = umin(umin(reqEnd, authEnd), umin(start + ntohl(caller.max_ticket_lifetime), start + ntohl(server.max_ticket_lifetime))); code = tkt_MakeTicket(newTicket, &newTicketLen, &server.key, caller.userID.name, caller.userID.instance, cell, start, reqEnd, &sessionKey, htonl(pkt->from.sin_addr.s_addr), server.userID.name, server.userID.instance); if (code) goto fail; cipherLen = sizeof(cipher); code = create_cipher(cipher, &cipherLen, &sessionKey, sname, sinst, start, reqEnd, ntohl(server.key_version), newTicket, newTicketLen, &authSessionKey); if (code) goto fail; code = create_reply(&ans, name, inst, start, reqEnd, 0, cipher, cipherLen); if (code) goto fail; code = sendto(ksoc, ans.data, ans.len, 0, (struct sockaddr *)&pkt->from, sizeof(pkt->from)); if (code != ans.len) { perror("calling sendto"); code = -1; goto fail; } if (cipherLen != 0) { KALOG(name, inst, sname, sinst, NULL, host, LOG_GETTICKET); } osi_audit(UDPGetTicketEvent, 0, AUD_STR, name, AUD_STR, inst, AUD_STR, cell, AUD_STR, sname, AUD_STR, sinst, AUD_END); return 0; abort: ubik_AbortTrans(tt); fail: osi_audit(UDPGetTicketEvent, code, AUD_STR, name, AUD_STR, inst, AUD_STR, NULL, AUD_STR, NULL, AUD_STR, NULL, AUD_END); return code; }
pulsesequence() { double j1min = getval("j1min"), j1max = getval("j1max"), pwx180 = getval("pwx180"), pwxlvl180 = getval("pwxlvl180"), pwx180r = getval("pwx180r"), pwxlvl180r = getval("pwxlvl180r"), mult = getval("mult"), gzlvl0 = getval("gzlvl0"), gt0 = getval("gt0"), gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), tauA, tauB, tau, taumb, taug, grad1, grad2, grad3, grad4; char pwx180ad[MAXSTR], pwx180ref[MAXSTR]; int icosel, prgcycle = (int)(getval("prgcycle")+0.5), phase1 = (int)(getval("phase")+0.5); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",1.0); gzlvlE = syncGradLvl("gtE","gzlvlE",1.0); getstr("pwx180ad", pwx180ad); getstr("pwx180ref", pwx180ref); tauA = 1/(2*(j1min + 0.146*(j1max - j1min))); tauB = 1/(2*(j1max - 0.146*(j1max - j1min))); tau = 1/(j1max + j1min); taumb = 1 / (2 * (getval("jnxh"))); taug = tau + getval("tauC"); icosel = 1; assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1, 4, ph1); settable(t2, 8, ph2); settable(t3, 16, ph3); settable(t4, 2, ph4); getelem(t1, v17, v1); getelem(t2, v17, v2); getelem(t3, v17, v3); getelem(t4, v17, oph); add(oph,v18,oph); add(oph,v19,oph); assign(zero,v6); /* mod2(id2, v14); dbl(v14,v14); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); add(v2, v14, v2); add(oph, v14, oph); if ((phase1 == 2) || (phase1 == 5)) { icosel = -1; } grad2 = gzlvlE; grad3 = -1.5*gzlvlE; grad1 = -1.0*grad2*(EDratio + icosel)/EDratio; grad4 = -1.0*grad3*(EDratio - icosel)/EDratio; if (mult > 0.5) { grad4 = -1.0*grad3*(EDratio + icosel)/EDratio; } status(A); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,zero); if (getflag("prgflg")) shaped_purge(v6,zero,v18,v19); } else { satpulse(satdly,zero,rof1,rof1); if (getflag("prgflg")) purge(v6,zero,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); obspower(tpwr); decpower(pwxlvl); status(B); rgpulse(pw, v6, rof1, rof2); /* Start of J filter */ if (getflag("jfilter")) { zgradpulse(gzlvl0,gt0); delay(tauA - gt0); decrgpulse(pwx, zero, rof1, rof1); zgradpulse(-gzlvl0*2/3,gt0); delay(tauB - gt0); decrgpulse(pwx, zero, rof1, rof1); zgradpulse(-gzlvl0/3,gt0); } /* End of J filter */ delay(taumb); zgradpulse(grad1,gtE); delay(gstab); decrgpulse(pwx, v2, rof1, rof1); if (mult > 0.5) { decpower(pwxlvl180r); zgradpulse(grad2,gtE); delay(taug-gtE-2*GRADIENT_DELAY); decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1); delay(d2/2); rgpulse(2*pw,v3,rof1,rof1); delay(d2/2); delay(taug-(gtE+gstab+2*GRADIENT_DELAY)+(4*pwx/PI+2*rof1+2*POWER_DELAY-2*pw-2*rof1)); zgradpulse(grad3,gtE); delay(gstab); decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1); } else { decpower(pwxlvl180); zgradpulse(grad2,gtE); delay(taug/2+(pwx180r-pwx180)/2- gtE - 2*GRADIENT_DELAY); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); delay(taug/2+(pwx180r-pwx180)/2.0); delay(d2/2); rgpulse(2*pw,v3,rof1,rof1); delay(d2/2); delay(taug/2+(pwx180r-pwx180)/2.0+(4*pwx/PI+2*rof1+2*POWER_DELAY-2*pw-2*rof1)); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); delay(taug/2+(pwx180r-pwx180)/2-gtE-gstab-2*GRADIENT_DELAY); zgradpulse(grad3,gtE); delay(gstab); } decpower(pwxlvl); decrgpulse(pwx, v1, rof1, rof2); decpower(dpwr); zgradpulse(grad4,gtE); delay(gstab); status(C); }
int process_udp_auth(int ksoc, struct packet *pkt) { char *packet = pkt->rest; char name[MAXKTCNAMELEN]; char inst[MAXKTCNAMELEN]; char realm[MAXKTCREALMLEN]; char sname[MAXKTCNAMELEN]; char sinst[MAXKTCNAMELEN]; int slen; Date now = time(0); Date startTime, endTime; unsigned char lifetime; afs_int32 code; pkt->name = packet; getstr(name); pkt->inst = packet; getstr(inst); pkt->realm = packet; getstr(realm); if (krb_udp_debug) { printf("Processing KDC Request from '%s'.'%s'@'%s'\n", name, inst, realm); } if ((strlen(realm) > 0) && (strcmp(realm, lrealm) != 0)) { err_packet(ksoc, pkt, KERB_ERR_NONNULL_REALM, "null realm name not allowed"); return -1; } memcpy(&startTime, packet, sizeof(startTime)); packet += sizeof(startTime); startTime = ktohl(pkt->byteOrder, startTime); pkt->time = startTime; lifetime = *packet++; endTime = life_to_time(startTime, lifetime); code = tkt_CheckTimes(startTime, endTime, now); if (code < 0) { err_packet(ksoc, pkt, KERB_ERR_BAD_LIFETIME, "requested ticket lifetime invalid"); return -1; } getstr(sname); getstr(sinst); if ((packet - pkt->data) != pkt->len) { err_packet(ksoc, pkt, KERB_ERR_PKT_LENGTH, "packet length inconsistent"); return -1; } pkt->rest = packet; code = UDP_Authenticate(ksoc, &pkt->from, name, inst, startTime, endTime, sname, sinst); if (code) { if (code == KANOENT) { code = KERB_ERR_PRINCIPAL_UNKNOWN; err_packet(ksoc, pkt, code, (char *)afs_error_message(code)); } else if (code == KAPWEXPIRED) { code = KERB_ERR_NAME_EXP; err_packet(ksoc, pkt, code, "password has expired"); } else err_packet(ksoc, pkt, code, (char *)afs_error_message(code)); } return 0; }
pulsesequence() { double pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */ gt0= getval("gt0"), gzlvl0= getval("gzlvl0"), phincr=getval("phincr"), compH = getval("compH"), tpwrs, /* power for the pwHs ("H2Osinc") pulse */ tpwrsf = getval("tpwrsf"); /* fine power for pwHs pulse */ /* use to adjust for radiation-damping */ char shape[MAXSTR]; getstr("shape",shape); /* selective H20 one-lobe sinc pulse */ tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /* needs 1.69 times more */ tpwrs=tpwrs+6; tpwrs = (int) (tpwrs); /* power than a square pulse */ obsstepsize(1.0); if (phincr < 0.0) phincr=360+phincr; initval(phincr,v3); delay(0.01); zgradpulse(1.5*gzlvl0,0.001); delay(d1); obspower(tpwr); rcvroff(); if (satmode[A] == 'u') /* calibrate flipback pulse following hard 90 */ { obspwrf(4095.0); obspower(tpwr); rgpulse(pw, two, rof1, 0.0); obspwrf(tpwrsf); obspower(tpwrs); xmtrphase(v3); shaped_pulse(shape, pwHs, zero, rof1, rof2); } if (satmode[A] == 'd') /* calibrate flipdown pulse prior to hard 90 */ { obspwrf(tpwrsf); obspower(tpwrs); xmtrphase(v3); shaped_pulse(shape, pwHs, zero, rof1, 0.0); obspwrf(4095.0); obspower(tpwr); xmtrphase(zero); delay(SAPS_DELAY); rgpulse(pw, two, rof1, rof2); } if (satmode[A] == 'i') /* calibrate flipback pulse following INEPT ghn... non-TROSY mode */ { rgpulse(pw,zero,rof1,0.0); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(2.0*pw, zero, 0.0, 0.0); txphase(one); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(pw, one, 0.0, 0.0); obspwrf(tpwrsf); obspower(tpwrs); xmtrphase(v3); shaped_pulse(shape, pwHs, zero, rof1, rof2); } if (satmode[A] == 't') /* calibrate flipback pulse following INEPT (gNhsqc non-Trosy, ghn..TROSY mode) */ { rgpulse(pw,zero,rof1,0.0); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(2.0*pw, zero, 0.0, 0.0); txphase(one); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(pw, one, 0.0, 0.0); obspwrf(tpwrsf); obspower(tpwrs); xmtrphase(v3); shaped_pulse(shape, pwHs, two, rof1, 0.0); obspower(tpwr); xmtrphase(zero); obspwrf(4095.0); rgpulse(2.0*pw,zero,rof1,rof2); } if (satmode[A] == 'n') /*calibrate flipback pulse following INEPT (gNhsqc TROSY mode) */ { rgpulse(pw,two,rof1,0.0); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(2.0*pw, zero, 0.0, 0.0); txphase(one); zgradpulse(gzlvl0,gt0); delay(2.4e-3-gt0); rgpulse(pw, one, 0.0, 0.0); obspwrf(tpwrsf); obspower(tpwrs); xmtrphase(v3); shaped_pulse(shape, pwHs, two, rof1, 0.0); obspower(tpwr); xmtrphase(zero); obspwrf(4095.0); } }
/* * Process library mappings of the form: * <library_name> <machdep_variable> <value,...:library_name,...> ... */ static void _rtld_process_mapping(Library_Xform **lib_p, const char *bp, const char *ep) { Library_Xform *hwptr = NULL; const char *ptr, *key, *ekey, *lib, *elib, *l; int i, j; dbg((" processing mapping \"%.*s\"", (int)(ep - bp), bp)); if ((ptr = getword(&bp, ep, WS)) == NULL || ptr == bp) return; dbg((" library \"%.*s\"", (int)(bp - ptr), ptr)); hwptr = xmalloc(sizeof(*hwptr)); memset(hwptr, 0, sizeof(*hwptr)); hwptr->name = exstrdup(ptr, bp); bp++; if ((ptr = getword(&bp, ep, WS)) == NULL || ptr == bp) { xwarnx("missing sysctl variable name"); goto cleanup; } dbg((" sysctl \"%.*s\"", (int)(bp - ptr), ptr)); hwptr->ctlname = exstrdup(ptr, bp); for (i = 0; bp++, (ptr = getword(&bp, ep, WS)) != NULL;) { dbg((" ptr = %.*s", (int)(bp - ptr), ptr)); if (ptr == bp) continue; if (i == RTLD_MAX_ENTRY) { no_more: xwarnx("maximum library entries exceeded `%s'", hwptr->name); goto cleanup; } if ((key = getstr(&ptr, bp, ":")) == NULL) { xwarnx("missing sysctl variable value for `%s'", hwptr->name); goto cleanup; } ekey = ptr++; if ((lib = getstr(&ptr, bp, ":")) == NULL) { xwarnx("missing sysctl library list for `%s'", hwptr->name); goto cleanup; } elib = ptr; /* No need to advance */ for (j = 0; (l = getstr(&lib, elib, ",")) != NULL; j++, lib++) { if (j == RTLD_MAX_LIBRARY) { xwarnx("maximum library entries exceeded `%s'", hwptr->name); goto cleanup; } dbg((" library \"%.*s\"", (int)(lib - l), l)); hwptr->entry[i].library[j] = exstrdup(l, lib); } if (j == 0) { xwarnx("No library map entries for `%s/%.*s'", hwptr->name, (int)(bp - ptr), ptr); goto cleanup; } j = i; for (; (l = getstr(&key, ekey, ",")) != NULL; i++, key++) { /* * Allow empty key (it is valid as string * value). Thus, we loop at least once and * `i' is incremented. */ dbg((" key \"%.*s\"", (int)(key - l), l)); if (i == RTLD_MAX_ENTRY) goto no_more; if (i != j) (void)memcpy(hwptr->entry[i].library, hwptr->entry[j].library, sizeof(hwptr->entry[j].library)); hwptr->entry[i].value = exstrdup(l, key); } } if (i == 0) { xwarnx("No library entries for `%s'", hwptr->name); goto cleanup; } hwptr->next = *lib_p; *lib_p = hwptr; return; cleanup: if (hwptr->name) xfree(hwptr->name); xfree(hwptr); }
void pulsesequence() { /* Internal variable declarations *************************/ double freqEx[MAXNSLICE]; double pespoil_amp,maxgradtime,spoilMoment,perTime,pe2_offsetamp,tau1,te_delay,tr_delay; double te2=0.0,te3=0.0,te2min,te3min,tau2,tau3,te2_delay,te3_delay=0; char minte2[MAXSTR],minte3[MAXSTR],spoilflag[MAXSTR],perName[MAXSTR]; int sepSliceRephase,sepReadRephase=0,readrev,table,shapeEx; int i; /* Real-time variables used in this sequence **************/ int vpe_steps = v1; // Number of PE steps int vpe_ctr = v2; // PE loop counter int vms_slices = v3; // Number of slices int vms_ctr = v4; // Slice loop counter int vpe_offset = v5; // PE/2 for non-table offset int vpe_mult = v6; // PE multiplier, ranges from -PE/2 to PE/2 int vper_mult = v7; // PE rewinder multiplier; turn off rewinder when 0 int vpe2_steps = v8; // Number of PE2 steps int vpe2_ctr = v9; // PE2 loop counter int vpe2_mult = v10; // PE2 multiplier int vpe2_offset = v11; // PE2/2 for non-table offset int vpe2r_mult = v12; // PE2 rewinder multiplier int vssc = v13; // Compressed steady-states int vacquire = v14; // Argument for setacqvar, to skip steady state acquires int vrfspoil_ctr = v15; // RF spoil counter int vrfspoil = v16; // RF spoil multiplier int vtrimage = v17; // Counts down from nt, trimage delay when 0 int vne = v18; // Number of echoes int vne_ctr = v19; // Echo loop counter int vneindex = v20; // Echo index, odd or even int vnelast = v21; // Check for last echo int vtrigblock = v22; // Number of slices per trigger block /* Initialize paramaters **********************************/ init_mri(); getstr("spoilflag",spoilflag); te2=getval("te2"); te3=getval("te3"); getstr("minte2",minte2); getstr("minte3",minte3); readrev=(int)getval("readrev"); /* Check for external PE table ***************************/ table = 0; if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); table = 1; } /* Set Rcvr/Xmtr phase increments for RF Spoiling ********/ /* Ref: Zur, Y., Magn. Res. Med., 21, 251, (1991) *******/ if (rfspoil[0] == 'y') { rcvrstepsize(rfphase); obsstepsize(rfphase); } /* Initialize gradient structures *************************/ shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2 ); // excitation pulse init_slice(&ss_grad,"ss",thk); // slice select gradient init_slice_refocus(&ssr_grad,"ssr"); // slice refocus gradient init_readout(&ro_grad,"ro",lro,np,sw); // readout gradient init_readout_refocus(&ror_grad,"ror"); // dephase gradient init_phase(&pe_grad,"pe",lpe,nv); // phase encode gradient init_phase(&pe2_grad,"pe2",lpe2,nv2); // 2nd phase encode gradient init_dephase(&spoil_grad,"spoil"); // optimized spoiler init_dephase(&ref_grad,"ref"); // readout rephase /* RF Calculations ****************************************/ calc_rf(&p1_rf,"tpwr1","tpwr1f"); /* Gradient calculations **********************************/ calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice_refocus(&ssr_grad, &ss_grad, WRITE,"gssr"); calc_readout(&ro_grad, WRITE,"gro","sw","at"); calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror"); calc_phase(&pe_grad, NOWRITE,"gpe","tpe"); calc_phase(&pe2_grad,NOWRITE,"gpe2",""); calc_dephase(&ref_grad,WRITE,ro_grad.m0,"",""); if (spoilflag[0] == 'y') { spoilMoment = ro_grad.acqTime*ro_grad.roamp; // Optimal spoiling is at*gro for 2pi per pixel spoilMoment -= ro_grad.m0def; // Subtract partial spoiling from back half of readout if (perewind[0] == 'y') calc_dephase(&spoil_grad,NOWRITE,spoilMoment,"gspoil","tspoil"); else calc_dephase(&spoil_grad,WRITE,spoilMoment,"gspoil","tspoil"); } /* Is TE long enough for separate slab refocus? *******/ maxgradtime = MAX(ror_grad.duration,pe_grad.duration); if (spoilflag[0] == 'y') maxgradtime = MAX(maxgradtime,spoil_grad.duration); tau1 = ss_grad.rfCenterBack + ssr_grad.duration + maxgradtime + alfa + ro_grad.timeToEcho + 4e-6; if ((te >= tau1) && (minte[0] != 'y')) sepSliceRephase = 1; // Set flag for separate slice rephase else { sepSliceRephase = 0; pe2_grad.areaOffset = ss_grad.m0ref; // Add slab refocus on pe2 axis calc_phase(&pe2_grad,NOWRITE,"gpe2",""); // Recalculate pe2 to include slab refocus } /* Equalize refocus and PE gradient durations *************/ pespoil_amp = 0.0; perTime = 0.0; if ((perewind[0] == 'y') && (spoilflag[0] == 'y')) { // All four must be single shape if (ror_grad.duration > spoil_grad.duration) { // calc_sim first with ror calc_sim_gradient(&pe_grad,&pe2_grad,&ror_grad,tpemin,WRITE); calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,NOWRITE); } else { // calc_sim first with spoil calc_sim_gradient(&pe_grad,&pe2_grad,&spoil_grad,tpemin,WRITE); calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,WRITE); } strcpy(perName,pe_grad.name); perTime = pe_grad.duration; } else { // post-acquire shape will be either pe or spoil, but not both calc_sim_gradient(&ror_grad,&pe_grad,&pe2_grad,tpemin,WRITE); if ((perewind[0] == 'y') && (spoilflag[0] == 'n')) { // Rewinder, no spoiler strcpy(perName,pe_grad.name); perTime = pe_grad.duration; spoil_grad.amp = 0.0; } else if ((perewind[0] == 'n') && (spoilflag[0] == 'y')) { // Spoiler, no rewinder strcpy(perName,spoil_grad.name); perTime = spoil_grad.duration; pespoil_amp = spoil_grad.amp; // Apply spoiler on PE & PE2 axis if no rewinder } } pe2_offsetamp = sepSliceRephase ? 0.0 : pe2_grad.offsetamp; // pe2 slab refocus /* Create optional prepulse events ************************/ if (sat[0] == 'y') create_satbands(); if (fsat[0] == 'y') create_fatsat(); if (mt[0] == 'y') create_mtc(); if (ir[0] == 'y') create_inversion_recovery(); /* Set up frequency offset pulse shape list ********/ offsetlist(pss,ss_grad.ssamp,0,freqEx,ns,seqcon[1]); shapeEx = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freqEx,ns,ss_grad.rfFraction,seqcon[1]); /* Check that all Gradient calculations are ok ************/ sgl_error_check(sglerror); /* Min TE ******************************************/ tau1 = ss_grad.rfCenterBack + pe_grad.duration + alfa + ro_grad.timeToEcho; tau1 += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event temin = tau1 + 4e-6; /* ensure that te_delay is at least 4us */ if (minte[0] == 'y') { te = temin; putvalue("te",te); } if (te < temin) { abort_message("TE too short. Minimum TE= %.2fms\n",temin*1000+0.005); } te_delay = te - tau1; /* Min TE2 *****************************************/ tau2 = (readrev) ? 2*ro_grad.timeFromEcho+alfa : ro_grad.duration+ref_grad.duration; te2min = tau2 + 4e-6; if (minte2[0] == 'y') { te2 = te2min; putvalue("te2",te2); } if (te2 < te2min) { abort_message("TE2 too short. Minimum TE2= %.2fms\n",te2min*1000+0.005); } if (readrev) te2_delay = te2 - tau2; else { tau2 = ro_grad.duration + 2*ror_grad.duration; if (te2 >= tau2) { sepReadRephase = 1; // Set flag for separate read rephase te2_delay = te2 - ro_grad.duration - 2*ror_grad.duration; } else { sepReadRephase = 0; if (te2 > te2min+4e-6) { ref_grad.duration = granularity(te2-ro_grad.duration-8e-6,GRADIENT_RES); ref_grad.calcFlag = AMPLITUDE_FROM_MOMENT_DURATION; calc_dephase(&ref_grad,WRITE,ro_grad.m0,"",""); } te2_delay = te2 - ro_grad.duration - ref_grad.duration; } } /* Min TE3 *****************************************/ if (readrev) { tau3 = 2*ro_grad.timeToEcho + alfa; te3min = tau3 + 4e-6; if (minte3[0] == 'y') { te3 = te3min; putvalue("te3",te3); } if (te3 < te3min) { abort_message("TE3 too short. Minimum TE3= %.2fms\n",te3min*1000+0.005); } te3_delay = te3 - tau3; } /* Now set the TE array accordingly */ putCmd("TE = 0"); /* Re-initialize TE */ putCmd("TE[1] = %f",te*1000); if (readrev) { for (i=1;i<ne;i++) { if (i%2 == 0) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te3*1000); else putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000); } } else { for (i=1;i<ne;i++) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000); } /* Check nsblock, the number of slices blocked together (used for triggering and/or inversion recovery) */ check_nsblock(); /* Min TR ******************************************/ trmin = ss_grad.duration + te_delay + pe_grad.duration + ne*ro_grad.duration + perTime + 8e-6; trmin += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event if (readrev) trmin += (ne/2)*te2_delay + ((ne-1)/2)*te3_delay; else trmin += (sepReadRephase) ? (ne-1)*(te2_delay+2*ror_grad.duration) : (ne-1)*(te2_delay+ref_grad.duration); /* Increase TR if any options are selected *********/ if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (mt[0] == 'y') trmin += mtTime; if (ticks > 0) trmin += 4e-6; /* Adjust for all slices ***************************/ trmin *= ns; /* Inversion recovery *********************************/ if (ir[0] == 'y') { /* tiaddTime is the additional time beyond IR component to be included in ti */ /* satTime, fsatTime and mtTime all included as those modules will be after IR */ tiaddTime = satTime + fsatTime + mtTime + 4e-6 + ss_grad.rfCenterFront; /* calc_irTime checks ti and returns the time of all IR components */ trmin += calc_irTime(tiaddTime,trmin,mintr[0],tr,&trtype); } if (mintr[0] == 'y') { tr = trmin; putvalue("tr",tr); } if (FP_LT(tr,trmin)) { abort_message("TR too short. Minimum TR = %.2fms\n",trmin*1000+0.005); } /* Calculate tr delay */ tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES); /* Set pe_steps for profile or full image **********/ pe_steps = prep_profile(profile[0],nv,&pe_grad,&per_grad); F_initval(pe_steps/2.0,vpe_offset); pe2_steps = prep_profile(profile[1],nv2,&pe2_grad,&null_grad); F_initval(pe2_steps/2.0,vpe2_offset); /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Adjust experiment time for VnmrJ *******************/ if (ssc<0) { if (seqcon[2]=='s') g_setExpTime(trmean*ntmean*pe_steps*pe2_steps*arraydim); else if (seqcon[3]=='s') g_setExpTime(trmean*pe2_steps*(ntmean*pe_steps*arraydim - ssc*arraydim)); else g_setExpTime(trmean*(ntmean*pe_steps*pe2_steps*arraydim - ssc*arraydim)); } else { if (seqcon[2]=='s') g_setExpTime(trmean*ntmean*pe_steps*pe2_steps*arraydim); else g_setExpTime(trmean*ntmean*pe_steps*pe2_steps*arraydim + tr*ssc); } /* Return parameters to VnmrJ */ putvalue("tror",ror_grad.duration); // ROR duration putvalue("gpe",pe_grad.peamp); // PE max grad amp putvalue("gss",ss_grad.ssamp); // Excitation slice grad putvalue("gro",ro_grad.roamp); // RO grad /* PULSE SEQUENCE ***************************************/ status(A); rotate(); triggerSelect(trigger); // Select trigger input 1/2/3 obsoffset(resto); delay(4e-6); initval(fabs(ssc),vssc); // Compressed steady-state counter if (seqcon[2]=='s') assign(zero,vssc); // Zero for standard peloop assign(zero,vrfspoil_ctr); // RF spoil phase counter assign(zero,vrfspoil); // RF spoil multiplier assign(one,vacquire); // real-time acquire flag setacqvar(vacquire); // Turn on acquire when vacquire is zero /* trigger */ if (ticks > 0) F_initval((double)nsblock,vtrigblock); /* Begin phase-encode loop ****************************/ peloop2(seqcon[3],pe2_steps,vpe2_steps,vpe2_ctr); /* Begin phase-encode loop ****************************/ peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr); if (trtype) delay(ns*tr_delay); // relaxation delay /* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */ if ((ix > 1) && (ssc > 0)) assign(zero,vssc); sub(vpe_ctr,vssc,vpe_ctr); // vpe_ctr counts up from -ssc assign(zero,vssc); if (seqcon[2] == 's') assign(zero,vacquire); // Always acquire for non-compressed loop else { ifzero(vpe_ctr); assign(zero,vacquire); // Start acquiring when vpe_ctr reaches zero endif(vpe_ctr); } /* Use standard encoding order for 2nd PE dimension */ ifzero(vacquire); sub(vpe2_ctr,vpe2_offset,vpe2_mult); elsenz(vacquire); sub(zero,vpe2_offset,vpe2_mult); endif(vacquire); /* Set rcvr/xmtr phase for RF spoiling *******************/ if (rfspoil[0] == 'y') { incr(vrfspoil_ctr); // vrfspoil_ctr = 1 2 3 4 5 6 add(vrfspoil,vrfspoil_ctr,vrfspoil); // vrfspoil = 1 3 6 10 15 21 xmtrphase(vrfspoil); rcvrphase(vrfspoil); } /* Read external kspace table if set ******************/ if (table) getelem(t1,vpe_ctr,vpe_mult); else { ifzero(vacquire); sub(vpe_ctr,vpe_offset,vpe_mult); elsenz(vacquire); sub(zero,vpe_offset,vpe_mult); // Hold PE mult at initial value for steady states endif(vacquire); } /* PE rewinder follows PE table; zero if turned off ***/ if (perewind[0] == 'y') { assign(vpe_mult,vper_mult); assign(vpe2_mult,vpe2r_mult); } else { assign(zero,vper_mult); assign(zero,vpe2r_mult); } /* Begin multislice loop ******************************/ msloop(seqcon[1],ns,vms_slices,vms_ctr); if (!trtype) delay(tr_delay); // Relaxation delay if (ticks > 0) { modn(vms_ctr,vtrigblock,vtest); ifzero(vtest); // if the beginning of an trigger block xgate(ticks); grad_advance(gpropdelay); delay(4e-6); elsenz(vtest); delay(4e-6); endif(vtest); } /* TTL scope trigger **********************************/ sp1on(); delay(4e-6); sp1off(); /* Prepulse options ***********************************/ if (ir[0] == 'y') inversion_recovery(); if (sat[0] == 'y') satbands(); if (fsat[0] == 'y') fatsat(); if (mt[0] == 'y') mtc(); /* Slice select RF pulse ******************************/ obspower(p1_rf.powerCoarse); obspwrf(p1_rf.powerFine); delay(4e-6); obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT); delay(ss_grad.rfDelayFront); shapedpulselist(shapeEx,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr); delay(ss_grad.rfDelayBack); /* Phase encode, refocus, and dephase gradient ********/ if (sepSliceRephase) { // separate slice refocus gradient obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT); delay(te_delay); // delay between slab refocus and pe pe2_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,-pe2_offsetamp, -pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT); } else { pe2_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,-pe2_offsetamp, -pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT); delay(te_delay); // delay after refocus/pe } F_initval(ne,vne); loop(vne,vne_ctr); if (readrev) { mod2(vne_ctr,vneindex); ifzero(vneindex); /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); delay(te2_delay); endif(vnelast); elsenz(vneindex); /* Shift DDR for pro *******************************/ roff = -poffset(pro,-ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,-ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); delay(te3_delay); endif(vnelast); endif(vneindex); } else { /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); if (sepReadRephase) { obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT); delay(te2_delay); obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT); } else { obl_shapedgradient(ref_grad.name,ref_grad.duration,-ref_grad.amp,0,0,WAIT); delay(te2_delay); } endif(vnelast); } endloop(vne_ctr); /* Rewind / spoiler gradient **************************/ if ((perewind[0] == 'y') || (spoilflag[0] == 'y')) { pe2_shapedgradient(perName,perTime,spoil_grad.amp,pespoil_amp,pespoil_amp, pe_grad.increment,pe2_grad.increment,vper_mult,vpe2r_mult,WAIT); } endmsloop(seqcon[1],vms_ctr); endpeloop(seqcon[2],vpe_ctr); endpeloop(seqcon[3],vpe2_ctr); /* Inter-image delay **********************************/ sub(ntrt,ct,vtrimage); decr(vtrimage); ifzero(vtrimage); delay(trimage); endif(vtrimage); }
void _rtld_process_hints(const char *execname, Search_Path **path_p, Library_Xform **lib_p, const char *fname) { int fd; char *buf, small[128]; const char *b, *ep, *ptr; struct stat st; ssize_t sz; Search_Path **head_p = path_p; if ((fd = open(fname, O_RDONLY)) == -1) { /* Don't complain */ return; } /* Try to avoid mmap/stat on the file. */ buf = small; buf[0] = '\0'; sz = read(fd, buf, sizeof(small)); if (sz == -1) { xwarn("read: %s", fname); (void)close(fd); return; } if (sz >= sizeof(small)) { if (fstat(fd, &st) == -1) { /* Complain */ xwarn("fstat: %s", fname); (void)close(fd); return; } sz = (ssize_t) st.st_size; buf = mmap(0, sz, PROT_READ, MAP_SHARED|MAP_FILE, fd, 0); if (buf == MAP_FAILED) { xwarn("mmap: %s", fname); (void)close(fd); return; } } (void)close(fd); while ((*path_p) != NULL) path_p = &(*path_p)->sp_next; for (b = buf, ep = buf + sz; b < ep; b++) { (void)getcstr(&b, ep, WS); if (b == ep) break; ptr = getstr(&b, ep, "\n#"); if (*ptr == '/') { /* * Since '/' != '\n' and != '#', we know ptr < * b. And we will stop when b[-1] == '/'. */ while (b[-1] == ' ' || b[-1] == '\t') b--; path_p = _rtld_append_path(head_p, path_p, execname, ptr, b); } else _rtld_process_mapping(lib_p, ptr, b); /* * b points one of ' ', \t, \n, # or equal to ep. So, * make sure we are at newline or end of string. */ (void)getstr(&b, ep, "\n"); } if (buf != small) (void)munmap(buf, sz); }
R_API int r_run_parseline (RRunProfile *p, char *b) { int must_free = false; char *e = strchr (b, '='); if (!e) return 0; if (*b=='#') return 0; *e++ = 0; if (*e=='$') { must_free = true; e = r_sys_getenv (e); } if (e == NULL) return 0; if (!strcmp (b, "program")) p->_args[0] = p->_program = strdup (e); else if (!strcmp (b, "system")) p->_system = strdup (e); else if (!strcmp (b, "aslr")) p->_aslr = parseBool (e); else if (!strcmp (b, "pid")) p->_pid = atoi (e); else if (!strcmp (b, "pidfile")) p->_pidfile = strdup (e); else if (!strcmp (b, "connect")) p->_connect = strdup (e); else if (!strcmp (b, "listen")) p->_listen = strdup (e); else if (!strcmp (b, "stdio")) { if (e[0] == '!') { p->_stdio = strdup (e); } else { p->_stdout = strdup (e); p->_stderr = strdup (e); p->_stdin = strdup (e); } } else if (!strcmp (b, "stdout")) p->_stdout = strdup (e); else if (!strcmp (b, "stdin")) p->_stdin = strdup (e); else if (!strcmp (b, "stderr")) p->_stderr = strdup (e); else if (!strcmp (b, "input")) p->_input = strdup (e); else if (!strcmp (b, "chdir")) p->_chgdir = strdup (e); else if (!strcmp (b, "core")) p->_docore = parseBool (e); else if (!strcmp (b, "fork")) p->_dofork = parseBool (e); else if (!strcmp (b, "sleep")) p->_r2sleep = atoi (e); else if (!strcmp (b, "maxstack")) p->_maxstack = atoi (e); else if (!strcmp (b, "maxproc")) p->_maxproc = atoi (e); else if (!strcmp (b, "maxfd")) p->_maxfd = atoi (e); else if (!strcmp (b, "bits")) p->_bits = atoi (e); else if (!strcmp (b, "chroot")) p->_chroot = strdup (e); else if (!strcmp (b, "libpath")) p->_libpath = strdup (e); else if (!strcmp (b, "preload")) p->_preload = strdup (e); else if (!strcmp (b, "r2preload")) p->_r2preload = parseBool (e); else if (!strcmp (b, "r2preweb")) r_sys_setenv ("RARUN2_WEB", "yes"); else if (!strcmp (b, "setuid")) p->_setuid = strdup (e); else if (!strcmp (b, "seteuid")) p->_seteuid = strdup (e); else if (!strcmp (b, "setgid")) p->_setgid = strdup (e); else if (!strcmp (b, "setegid")) p->_setegid = strdup (e); else if (!strcmp (b, "nice")) p->_nice = atoi (e); else if (!memcmp (b, "arg", 3)) { int n = atoi (b + 3); if (n >= 0 && n < R_RUN_PROFILE_NARGS) { p->_args[n] = getstr (e); } else eprintf ("Out of bounds args index: %d\n", n); } else if (!strcmp (b, "timeout")) { p->_timeout = atoi (e); } else if (!strcmp (b, "timeoutsig")) { // TODO: support non-numeric signal numbers here p->_timeout_sig = atoi (e); } else if (!strcmp (b, "envfile")) { char *p, buf[1024]; FILE *fd = fopen (e, "r"); if (!fd) { eprintf ("Cannot open '%s'\n", e); if (must_free == true) free (e); return 0; } for (;;) { fgets (buf, sizeof (buf)-1, fd); if (feof (fd)) break; p = strchr (buf, '='); if (p) { *p = 0; r_sys_setenv (buf, p+1); } } fclose (fd); } else if (!strcmp (b, "unsetenv")) { r_sys_setenv (e, NULL); } else if (!strcmp (b, "setenv")) { char *v = strchr (e, '='); if (v) { *v++ = 0; r_sys_setenv (e, v); } } else if (!strcmp(b, "clearenv")) { r_sys_clearenv (); } if (must_free == true) free (e); return 1; }
/* Basic name -> sysctl MIB translation */ int _rtld_sysctl(const char *name, void *oldp, size_t *oldlen) { const char *node, *ep; struct sysctlnode query, *result, *newresult; int mib[CTL_MAXNAME], i, r; size_t res_size, n; u_int miblen = 0; /* Start with 16 entries, will grow it up as needed. */ res_size = 16 * sizeof(struct sysctlnode); result = xmalloc(res_size); if (result == NULL) return (-1); ep = name + strlen(name); do { i = -1; while (*name == '/' || *name == '.') name++; if (name >= ep) break; mib[miblen] = CTL_QUERY; memset(&query, 0, sizeof(query)); query.sysctl_flags = SYSCTL_VERSION; n = res_size; if (sysctl(mib, miblen + 1, result, &n, &query, sizeof(query)) == -1) { if (errno != ENOMEM) goto bad; /* Grow up result */ res_size = n; newresult = xrealloc(result, res_size); if (newresult == NULL) goto bad; result = newresult; if (sysctl(mib, miblen + 1, result, &n, &query, sizeof(query)) == -1) goto bad; } n /= sizeof(struct sysctlnode); node = getstr(&name, ep, "./"); for (i = 0; i < n; i++) if (matchstr(result[i].sysctl_name, node, name)) { mib[miblen] = result[i].sysctl_num; miblen++; break; } } while (name < ep && miblen <= CTL_MAXNAME); if (name < ep || i == -1) goto bad; r = SYSCTL_TYPE(result[i].sysctl_flags); xfree(result); if (sysctl(mib, miblen, oldp, oldlen, NULL, 0) == -1) return (-1); return r; bad: xfree(result); return (-1); }
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() { double selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), gstab = getval("gstab"), slpwrR = getval("slpwrR"), slpwR = getval("slpwR"), mixR = getval("mixR"), gzlvlz = getval("gzlvlz"), gtz = getval("gtz"), alfa1, t1dly, zfphinc = getval("zfphinc"); char slpatR[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR]; int phase1 = (int)(getval("phase")+0.5), prgcycle = (int)(getval("prgcycle")+0.5); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); /* LOAD AND INITIALIZE PARAMETERS */ getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("slpatR",slpatR); alfa1 = POWER_DELAY + (2*pw/PI) + rof1; if (getflag("homodec")) alfa1 = alfa1 + 2.0e-6 + 2*pw; t1dly = d2-alfa1; if (t1dly > 0.0) t1dly = t1dly; else t1dly = 0.0; if (strcmp(slpatR,"cw") && strcmp(slpatR,"troesy") && strcmp(slpatR,"dante")) abort_message("SpinLock pattern %s not supported!.\n", slpatR); assign(ct,v17); assign(zero,v18); assign(zero,v19); if (getflag("prgflg") && (satmode[0] == 'y') && (prgcycle > 1.5)) { hlv(ct,v17); mod2(ct,v18); dbl(v18,v18); if (prgcycle > 2.5) { hlv(v17,v17); hlv(ct,v19); mod2(v19,v19); dbl(v19,v19); } } settable(t1,4,ph1); getelem(t1,v17,v1); settable(t2,8,ph2); getelem(t2,v17,v20); settable(t3,8,ph3); settable(t8,4,ph8); getelem(t8,v17,v8); settable(t6,8,ph6); getelem(t6,v17,v6); assign(v1,oph); if (getflag("zfilt")) getelem(t3,v17,oph); assign(v20,v9); if (!strcmp(slpatR,"troesy")) assign(v20,v21); else add(v20,one,v21); add(oph,v18,oph); add(oph,v19,oph); if (getflag("prgflg") && (satmode[0] == 'y')) assign(v1,v6); if (phase1 == 2) {incr(v1); incr(v6);} /* hypercomplex method */ assign(v1,v11); add(v11,two,v12); assign(oph,v14); /* mod2(id2,v13); dbl(v13,v13); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v13); if (getflag("fadflg")) { add(v1,v13,v1); add(v6,v13,v6); add(oph,v13,oph); } if (getflag("homodec")) add(oph,two,oph); /* The following is for flipback pulse */ zfphinc=zfphinc+180; if (zfphinc < 0) zfphinc=zfphinc+360; initval(zfphinc,v10); /* BEGIN ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); if (getflag("slpsat")) { shaped_satpulse("relaxD",satdly,v6); if (getflag("prgflg")) shaped_purge(v1,v6,v18,v19); } else { satpulse(satdly,v6,rof1,rof1); if (getflag("prgflg")) purge(v1,v6,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(dpwr); status(B); rgpulse(pw, v1, rof1, rof1); if (getflag("homodec")) { delay(t1dly/2); rgpulse(2*pw,v14,1.0e-6,1.0e-6); } else delay(t1dly); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v11,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (getflag("homodec")) delay(t1dly/2); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v12,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(slpwrR); if (mixR > 0.0) { if (dps_flag) rgpulse(mixR,v21,0.0,0.0); else SpinLock(slpatR,mixR,slpwR,v21); } if ((getflag("zfilt")) && (getflag("PFGflg"))) { obspower(tpwr); rgpulse(pw,v9,1.0e-6,rof1); zgradpulse(gzlvlz,gtz); delay(gtz/3); if (getflag("flipback")) FBpulse(v8,v10); rgpulse(pw,v8,rof1,rof2); } else delay(rof2); status(C); }
pulsesequence() { /* 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 */ 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 */ timeTN = getval("timeTN"), /* constant time for 15N evolution */ kappa = 5.4e-3, lambda = 2.4e-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 */ /* the following pulse lengths for SLP pulses are automatically calculated */ /* by the macro "biocal". SLP pulse shapes, "offC3" etc are called */ /* directly from your shapelib. */ pwC3 = getval("pwC3"), /*180 degree pulse at Ca(56ppm) null at CO(174ppm) */ pwC3a, /* pwC3a=pwC3, but not set to zero when pwC3=0 */ phshift3, /* phase shift induced on CO by pwC3 ("offC3") pulse */ pwZ, /* the largest of pwC3 and 2.0*pwN */ pwC6, /* 90 degree selective sinc pulse on CO(174ppm) */ pwC8, /* 180 degree selective sinc pulse on CO(174ppm) */ rf3, /* fine power for the pwC3 ("offC3") pulse */ rf6, /* fine power for the pwC6 ("offC6") pulse */ rf8, /* fine power for the pwC8 ("offC8") pulse */ bw, ofs, ppm, /* bandwidth, offset, ppm - temporary Pbox parameters */ 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 */ tpwrsf = getval("tpwrsf"), /* fine power for pwHs pulse */ 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"), 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); /* LOAD PHASE TABLE */ settable(t3,2,phi3); settable(t4,1,phx); settable(t5,4,phi5); {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; setautocal(); /* activate auto-calibration */ if (autocal[0] == 'n') { /* offC3 - 180 degree pulse on Ca, null at CO 118ppm away */ pwC3a = getval("pwC3a"); rf3 = (compC*4095.0*pwC*2.0)/pwC3a; rf3 = (int) (rf3 + 0.5); /* 90 degree one-lobe sinc pulse on CO, null at Ca 118ppm away */ pwC6 = getval("pwC6"); rf6 = (compC*4095.0*pwC*1.69)/pwC6; /* needs 1.69 times more */ rf6 = (int) (rf6 + 0.5); /* power than a square pulse */ /* 180 degree one-lobe sinc pulse on CO, null at Ca 118ppm away */ pwC8 = getval("pwC8"); 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 */ /* power level and pulse time for WALTZ 1H decoupling */ pwHd = 1/(4.0 * waltzB1) ; /* 7.5 kHz rf */ tpwrd = tpwr - 20.0*log10(pwHd/(compH*pw)); tpwrd = (int) (tpwrd + 0.5); } else /* if autocal = 'y'(yes), 'q'(quiet), 'r'(read) or 's'(semi) */ { if(FIRST_FID) /* make shapes */ { ppm = getval("dfrq"); bw = 118.0*ppm; ofs = -bw; offC3 = pbox_make("offC3", "square180n", bw, ofs, compC*pwC, pwClvl); offC6 = pbox_make("offC6", "sinc90n", bw, 0.0, compC*pwC, pwClvl); offC8 = pbox_make("offC8", "sinc180n", bw, 0.0, compC*pwC, pwClvl); H2Osinc = pbox_Rsh("H2Osinc", "sinc90", pwHs, 0.0, compH*pw, tpwr); bw = 2.8*7500.0; wz16 = pbox_Dcal("WALTZ16", 2.8*waltzB1, 0.0, compH*pw, tpwr); ofs_check(H1ofs, C13ofs, N15ofs, H2ofs); } pwC3a = offC3.pw; rf3 = offC3.pwrf; /* set up parameters */ pwC6 = offC6.pw; rf6 = offC6.pwrf; pwC8 = offC8.pw; rf8 = offC8.pwrf; pwHs = H2Osinc.pw; tpwrs = H2Osinc.pwr-1.0; /* 1dB correction applied */ tpwrd = wz16.pwr; pwHd = 1.0/wz16.dmf; } if (tpwrsf < 4095.0) tpwrs = tpwrs + 6.0; /* the pwC3 pulse at the middle of t1 */ if (pwC3a > 2.0*pwN) pwZ = pwC3a; else pwZ = 2.0*pwN; phshift3=0.0; if(pwC3 > 0) phshift3 = 48.0; /* CHECK VALIDITY OF PARAMETER RANGES */ if ( 0.5*ni2*1/(sw2) > timeTN - pwC3a - 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 ( dpwr2 > 50 ) { printf("dpwr2 too large! recheck value "); psg_abort(1);} if ( pw > 50.0e-6 ) { printf(" pw too long ! recheck value "); psg_abort(1);} if ( (pwN > 100.0e-6) && (ni>1 || ni2>1)) { printf(" pwN too long! recheck value "); psg_abort(1);} /* PHASES AND INCREMENTED TIMES */ /* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */ if (phase1 == 2) tsadd(t3,1,4); { if (phase2 == 2) {tsadd(t10,2,4); icosel = +1;} else icosel = -1; } /* Set up f1180 */ 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 f2180 */ 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(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); 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 (tpwrsf < 4095.0) obspwrf(tpwrsf); obspower(tpwrs); txphase(two); shaped_pulse("H2Osinc", pwHs, two, 2.0e-6, 0.0); obspower(tpwrd); if (tpwrsf < 4095.0) obspwrf(4095.0); 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(rf8); delay(timeTN - kappa - WFG3_START_DELAY); /* WFG3_START_DELAY */ sim3shaped_pulse("", "offC8", "", 0.0, pwC8, 2.0*pwN, zero, zero, zero, 0.0, 0.0); decphase(t3); decpwrf(rf6); delay(timeTN); dec2rgpulse(pwN, zero, 0.0, 0.0); xmtroff(); obsprgoff(); rgpulse(pwHd,three,2.0e-6,0.0); zgradpulse(gzlvl3, gt3); delay(2.0e-4); rgpulse(pwHd,one,0.0,0.0); txphase(zero); delay(2.0e-6); obsprgon("waltz16", pwHd, 90.0); /* PRG_START_DELAY */ xmtron(); /* xxxxxxxxxxxxxxxxxxxxxx 13CO EVOLUTION xxxxxxxxxxxxxxxxxx */ decshaped_pulse("offC6", pwC6, t3, 1.0e-6, 0.0); decphase(zero); if((tau1 - 2.0*pwC6/3.14 - WFG3_START_DELAY - 0.5*pwZ - POWER_DELAY) > SAPS_DELAY) { decpwrf(rf3); delay(tau1 - 2.0*pwC6/3.14 - WFG3_START_DELAY - 0.5*pwZ - POWER_DELAY); sim3shaped_pulse("", "offC3", "", 0.0, pwC3a, 2.0*pwN, zero, zero, zero,0.0,0.0); initval(phshift3, v3); decstepsize(1.0); dcplrphase(v3); /* SAPS_DELAY */ decpwrf(rf6); decphase(t5); delay(tau1 - 2.0*pwC6/3.14 - SAPS_DELAY - 0.5*pwZ- WFG3_START_DELAY - POWER_DELAY); } else { decpwrf(rf8); decshaped_pulse("offC8", pwC8, zero, 2.0e-6, 0.0); decpwrf(rf6); decphase(t5); delay(2.0e-6); } decshaped_pulse("offC6", pwC6, t5, 0.5e-6, 1.0e-6); xmtroff(); obsprgoff(); rgpulse(pwHd,three,2.0e-6,0.0); /* xxxxxxxxxxxxxxxxxx N15 EVOLUTION xxxxxxxxxxxxxxxxxxxxx */ dec2phase(t8); zgradpulse(gzlvl4, gt4); dcplrphase(zero); obspower(tpwr); delay(2.0e-4); dec2rgpulse(pwN, t8, 0.0, 0.0); decpwrf(rf3); decphase(zero); delay((timeTN - tau2 - pwC3a)/2.0); decshaped_pulse("offC3", pwC3a, zero, 0.0, 0.0); dec2phase(t9); decpwrf(rf8); delay((timeTN - tau2 - pwC3a)/2.0); /* WFG3_START_DELAY */ /* sim3shaped_pulse("", "offC8", "", 2.0*pw, pwC8, 2.0*pwN, zero, zero, t9, 0.0, 0.0); */ sim3shaped_pulse("", "offC8", "",0.0,pwC8,2.0*pwN,zero,zero,t9,0.0,0.0); dec2phase(t10); decpwrf(rf3); delay((timeTN + tau2 - pwC3a)/2.0); decshaped_pulse("offC3", pwC3a, zero, 0.0, 0.0); delay((timeTN + tau2 - pwC3a)/2.0 - 2.75e-3 - 2.0*pw); rgpulse(2.0*pw,zero, 0.0, 0.0); if (mag_flg[A]=='y') { magradpulse(gzcal*gzlvl1, gt1); } else { zgradpulse(gzlvl1, gt1); delay(4.0*GRADIENT_DELAY); } txphase(t4); delay(2.75e-3 - gt1 - 6.0*GRADIENT_DELAY); /* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */ sim3pulse(pw, 0.0, pwN, t4, zero, t10, 0.0, 0.0); txphase(zero); dec2phase(zero); zgradpulse(gzlvl5, gt5); 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); zgradpulse(gzlvl6, gt5); delay(lambda - 0.65*pwN - gt5); rgpulse(pw, zero, 0.0, 0.0); delay((gt1/10.0) + 1.0e-4 - 0.5*pw + 2.0*GRADIENT_DELAY + POWER_DELAY); rgpulse(2.0*pw, zero, 0.0,0.0); 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 */ rcvron(); statusdelay(C,1.0e-4); setreceiver(t12); }
void pulsesequence() { /* DECLARE AND LOAD VARIABLES */ char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */ f2180[MAXSTR], /* Flag to start t2 @ halfdwell */ N15refoc[MAXSTR], /* Flag for N15 labeled samples */ satmode[MAXSTR]; int t1_counter, /* used for states tppi in t1 */ t2_counter, /* used for states tppi in t2 */ ni2=getval("ni2"); double tau1,tau2, /* t1 and t2 delay */ mix = getval("mix"), /* NOESY mix time */ lambda = 1.0 / (2.0*getval("JCH")), /* HMQC delay */ satpwr = getval("satpwr"), satdly = getval("satdly"), satfrq = getval("satfrq"), 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 */ pwNlvl = getval("pwNlvl"), /* power for N15 pulses */ pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */ compN = getval("compN"), /* adjustment for N15 amplifier compression */ pwClw=getval("pwClw"), pwNlw=getval("pwNlw"), pwZlw=0.0, sw1 = getval("sw1"), sw2 = getval("sw2"), gt1 = getval("gt1"), gt5 = getval("gt5"), gzlvl1 = getval("gzlvl1"), gzlvl5 = getval("gzlvl5"), gstab = getval("gstab"); getstr("f1180",f1180); getstr("f2180",f2180); getstr("satmode",satmode); getstr("N15refoc",N15refoc); /* LOAD PHASE TABLE */ settable(t1,4,phi1); settable(t2,1,phi2); settable(t3,2,phi3); settable(t4,8,phi4); settable(t9,8,rec); /* INITIALIZE VARIABLES */ /* CHECK VALIDITY OF PARAMETER RANGES */ if ( (mix - gt1 -gstab -2.0*GRADIENT_DELAY) < 0.0 ) { text_error("mix is too small. Make mix equal to %f or more.\n",(gt1 +gstab +2.0*GRADIENT_DELAY)); psg_abort(1); } if( dpwr2 > 46 ) { text_error("don't fry the probe, DPWR2 too large! "); psg_abort(1); } if( pw > 20.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(t1,1,4); if (phase2 == 2) tsadd(t3,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; /* 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(t1,2,4); tsadd(t9,2,4); } /* Calculate modifications to phases for States-TPPI acquisition */ if( ix == 1) d3_init = d3; t2_counter = (int) ( (d3-d3_init)*sw2 + 0.5 ); if(t2_counter % 2) { tsadd(t3,2,4); tsadd(t9,2,4); } /* calculate 3db lower power hard pulses for simultaneous CN decoupling during indirect H1 evoluion pwNlw and pwClw should be calculated by the macro that calls the experiment. */ if (N15refoc[A] == 'y') { if (pwNlw==0.0) pwNlw = compN*pwN*exp(3.0*2.303/20.0); if (pwClw==0.0) pwClw = compC*pwC*exp(3.0*2.303/20.0); if (pwNlw > 2.0*pwClw) pwZlw=pwNlw; else pwZlw=2.0*pwClw; /* Uncomment to check pwClw and pwNlw */ if (d2==0.0 && d3==0.0) printf(" pwClw = %.2f ; pwNlw = %.2f\n", pwClw*1e6,pwNlw*1e6); } /* BEGIN PULSE SEQUENCE */ status(A); decpower(pwClvl); dec2power(pwNlvl); txphase(zero); decphase(zero); dec2phase(zero); if ((satmode[A]=='y') && (satfrq!=tof)) obsoffset(satfrq); else obsoffset(tof); delay(d1); rcvroff(); /* presat */ if (satmode[A]=='y') { obspower(satpwr); rgpulse(satdly,zero,rof1,rof1); if (satfrq!=tof) obsoffset(tof); } obspower(tpwr); rgpulse(pw, t1, rof1, rof1); /* T1 EVOLUTION TIME STARTS */ txphase(zero); if ((N15refoc[A]=='y') && (tau1 > pwZlw +2.0*pw/PI +2.0*SAPS_DELAY +2.0*POWER_DELAY +2.0*rof1)) { decpower(pwClvl-3.0); dec2power(pwNlvl-3.0); delay(tau1 -pwZlw -2.0*pw/PI -2.0*POWER_DELAY -2.0*SAPS_DELAY -2.0*rof1); if (pwNlw > 2.0*pwClw) { dec2rgpulse(pwNlw -2.0*pwClw,zero,rof1,0.0); sim3pulse(0.0,pwClw,pwClw,zero,zero,zero,0.0,0.0); decphase(one); sim3pulse(0.0,2*pwClw,2*pwClw,zero,one,zero,0.0,0.0); decphase(zero); sim3pulse(0.0,pwClw,pwClw,zero,zero,zero,0.0,0.0); dec2rgpulse(pwNlw -2.0*pwClw,zero,0.0,rof1); } else { decrgpulse(2.0*pwClw-pwNlw,zero,rof1,0.0); sim3pulse(0.0,pwNlw-pwClw,pwNlw-pwClw,zero,zero,zero,0.0,0.0); decphase(one); sim3pulse(0.0,2.0*pwClw,2.0*pwClw,zero,one,zero,0.0,0.0); decphase(zero); sim3pulse(0.0,pwNlw-pwClw,pwNlw-pwClw,zero,zero,zero,0.0,0.0); decrgpulse(2.0*pwClw-pwNlw,zero,0.0,rof1); } decpower(pwClvl); dec2power(pwNlvl); delay(tau1 -pwZlw -2.0*pw/PI -2.0*POWER_DELAY -SAPS_DELAY -2.0*rof1); } else if ((tau1 -(2.0*pwC +2.0*pw/PI +2.0*SAPS_DELAY +2.0*rof1)) > 2.0e-6) { delay(tau1 -2.0*pwC -2.0*pw/PI -2.0*SAPS_DELAY -2.0*rof1); decrgpulse(pwC, zero, rof1, 0.0); decphase(one); decrgpulse(2.0*pwC, one, 0.0, 0.0); decphase(zero); decrgpulse(pwC, zero, 0.0, rof1); delay(tau1 -2.0*pwC -2.0*pw/PI -SAPS_DELAY -2.0*rof1); } else if ((2.0*tau1 -(4.0*pw/PI +SAPS_DELAY +2.0*rof1)) > 2.0e-6) delay(2.0*tau1 -4.0*pw/PI -SAPS_DELAY -2.0*rof1); /* T1 EVOLUTION TIME ENDS */ rgpulse(pw, zero, rof1, rof1); /* MIXING TIME STARTS */ delay(mix -gt1 -2.0*GRADIENT_DELAY -gstab); zgradpulse(gzlvl1, gt1); delay(gstab); /* MIXING TIME ENDS */ rgpulse(pw, zero, rof1, rof1); zgradpulse(gzlvl5, gt5); txphase(t2); decphase(t3); delay(lambda -gt5 -2.0*GRADIENT_DELAY -2.0*SAPS_DELAY); /* 1/2*JCH */ decrgpulse(pwC, t3, rof1, rof1); /* T2 EVOLUTION TIME STARTS */ decphase(t4); if (N15refoc[A]=='y' && tau2 > (pwN +2*pwC/PI +SAPS_DELAY +2.0*rof1)) { delay(tau2 -pwN -2*pwC/PI -SAPS_DELAY -2.0*rof1); sim3pulse(2.0*pw, 0.0, 2.0*pwN, t2, zero, zero, rof1, rof1); delay(tau2 -pwN -2*pwC/PI -2.0*rof1); } else if (tau2 > (pw +2*pwC/PI +SAPS_DELAY +2.0*rof1)) { delay(tau2 -pw -2*pwC/PI -SAPS_DELAY -2.0*rof1); rgpulse(2.0*pw, t2, rof1, rof1); delay(tau2 -pw -2*pwC/PI -2.0*rof1); } else rgpulse(2.0*pw, zero, rof1, rof1); /* T2 EVOLUTION TIME ENDS */ decrgpulse(pwC, t4, rof1, rof1); zgradpulse(gzlvl5, gt5); decpower(dpwr); dec2power(dpwr2); delay(lambda -gt5 -2.0*GRADIENT_DELAY -2.0*POWER_DELAY); status(C); setreceiver(t9); }
pulsesequence() { char sel_flg[MAXSTR], autocal[MAXSTR], glyshp[MAXSTR]; int icosel, t1_counter, ni = getval("ni"); double d2_init=0.0, tau1, tau2, tau3, glypwr,glypwrf, /* Power levels for Cgly selective 90 */ pwgly, /* Pulse width for Cgly selective 90 */ waltzB1 = getval("waltzB1"), /* 1H decoupling strength (in Hz) */ timeTN = getval("timeTN"), /* constant time for 15N evolution */ tauCaCb = getval("tauCaCb"), tauNCa = getval("tauNCa"), tauNCo = getval("tauNCo"), tauCaCo = getval("tauCaCo"), compH = getval("compH"), /* adjustment for H1 amplifier compression */ tpwrs, /* power for the pwHs ("H2Osinc") pulse */ bw,ppm, pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */ compC = getval("compC"), /* amplifier compression 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 */ dpwr2 = getval("dpwr2"), /* power for N15 decoupling */ pwCa90, /* length of square 90 on Ca */ pwCa180, pwCab90, pwCab180, phshift, /* phase shift induced on Ca by 180 on CO in middle of t1 */ pwCO180, /* length of 180 on CO */ pwS = getval("pwS"), /* used to change 180 on CO in t1 for 1D calibrations */ pwZ, /* the largest of pwCO180 and 2.0*pwN */ pwZ1, /* the largest of pwCO180 and 2.0*pwN for 1D experiments */ sw1 = getval("sw1"), swCb = getval("swCb"), swCa = getval("swCa"), swN = getval("swN"), swTilt, /* This is the sweep width of the tilt vector */ cos_N, cos_Ca, cos_Cb, angle_N, angle_Ca, angle_Cb, /* angle_N is calculated automatically */ 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"), gt10= getval("gt10"), gzlvl10= getval("gzlvl10"), gt11= getval("gt11"), gzlvl11= getval("gzlvl11"), gt12= getval("gt12"), gzlvl12= getval("gzlvl12"); angle_N = 0; glypwr = getval("glypwr"); pwgly = getval("pwgly"); tau1 = 0; tau2 = 0; tau3 = 0; cos_N = 0; cos_Cb = 0; cos_Ca = 0; getstr("autocal", autocal); getstr("glyshp", glyshp); getstr("sel_flg",sel_flg); pwHs = getval("pwHs"); /* H1 90 degree pulse length at tpwrs */ /* LOAD PHASE TABLE */ settable(t2,1,phy); settable(t3,2,phi3); settable(t4,1,phx); settable(t5,4,phi5); settable(t8,1,phy); 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; /* 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 */ pwHs = 1.7e-3*500.0/sfrq; widthHd = 2.861*(waltzB1/sfrq); /* bandwidth of H1 WALTZ16 decoupling in ppm */ pwHd = h1dec90pw("WALTZ16", widthHd, 0.0); /* H1 90 length for WALTZ16 */ /* get calculated pulse lengths of shaped C13 pulses */ pwCa90 = c13pulsepw("ca", "co", "square", 90.0); pwCa180 = c13pulsepw("ca", "co", "square", 180.0); pwCO180 = c13pulsepw("co", "cab", "sinc", 180.0); pwCab90 = c13pulsepw("cab","co", "square", 90.0); pwCab180= c13pulsepw("cab","co", "square", 180.0); /* the 180 pulse on CO at the middle of t1 */ if (pwCO180 > 2.0*pwN) pwZ = pwCO180; else pwZ = 2.0*pwN; if ((pwS==0.0) && (pwCO180>2.0*pwN)) pwZ1=pwCO180-2.0*pwN; else pwZ1=0.0; if ( ni > 1 ) pwS = 180.0; if ( pwS > 0 ) phshift = 320.0; else phshift = 0.0; /* CHECK VALIDITY OF PARAMETER RANGES */ 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);} /* PHASES AND INCREMENTED TIMES */ /* Set up angles and phases */ angle_Cb=getval("angle_Cb"); cos_Cb=cos(PI*angle_Cb/180.0); angle_Ca=getval("angle_Ca"); cos_Ca=cos(PI*angle_Ca/180.0); if ( (angle_Cb < 0) || (angle_Cb > 90) ) { printf ("angle_Cb 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_Cb*cos_Cb + cos_Ca*cos_Ca) ) { printf ("Impossible angles.\n"); psg_abort(1); } else { cos_N=sqrt(1.0- (cos_Cb*cos_Cb + cos_Ca*cos_Ca)); angle_N = 180.0*acos(cos_N)/PI; } swTilt=swCb*cos_Cb + 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_Cb:\t%6.2f\n", angle_Cb); 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(t8,2,4); tsadd(t12,2,4); } if (phase1 == 1) { ;} /* CC */ else if (phase1 == 2) { tsadd(t3,3,4); tsadd(t2,3,4);} /* SC */ else if (phase1 == 3) { tsadd(t5,1,4); } /* CS */ else if (phase1 == 4) { tsadd(t3,3,4); tsadd(t2,3,4); tsadd(t5,1,4);} /* SS */ else { printf ("phase1 can only be 1,2,3,4. \n"); psg_abort(1); } if (phase2 == 2) { tsadd(t10,2,4); icosel = +1; } /* N */ else icosel = -1; tau1 = 1.0*t1_counter*cos_Cb/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 (0.5*ni*(cos_N/swTilt) > timeTN - WFG3_START_DELAY) { printf(" ni is too big. Make ni equal to %d or less.\n", ((int)((timeTN - WFG3_START_DELAY)*2.0*swTilt/cos_N))); psg_abort(1);} /* BEGIN PULSE SEQUENCE */ status(A); delay(d1); if ( dm3[B] == 'y' ) lk_hold(); rcvroff(); obsoffset(tof); obspower(tpwr); obspwrf(4095.0); set_c13offset("cab"); decpower(pwClvl); decpwrf(4095.0); dec2power(pwNlvl); txphase(zero); delay(1.0e-5); decrgpulse(pwC, zero, 0.0, 0.0); zgradpulse(gzlvl0, gt0); delay(gstab); decrgpulse(pwC, one, 0.0, 0.0); zgradpulse(0.7*gzlvl0, gt0); delay(gstab); txphase(one); delay(1.0e-5); shiftedpulse("sinc", pwHs, 90.0, 0.0, one, 2.0e-6, 0.0); txphase(zero); decphase(zero); dec2phase(zero); delay(2.0e-6); /* pulse sequence starts */ rgpulse(pw,zero,0.0,0.0); /* 1H pulse excitation */ dec2phase(zero); zgradpulse(gzlvl3, gt3); delay(lambda - gt3); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); if (sel_flg[A] == 'n') txphase(three); else txphase(one); zgradpulse(gzlvl3, gt3); delay(lambda - gt3); if (sel_flg[A] == 'n') { rgpulse(pw, three, 0.0, 0.0); txphase(zero); zgradpulse(gzlvl4, gt4); /* Crush gradient G4 */ delay(gstab); /* Begin of N to Ca transfer */ dec2rgpulse(pwN, one, 0.0, 0.0); decphase(zero); dec2phase(zero); delay(tauNCo - pwCO180/2 - 2.0e-6 - WFG3_START_DELAY); } else /* active suppresion */ { rgpulse(pw,one,2.0e-6,0.0); initval(1.0,v6); dec2stepsize(45.0); dcplr2phase(v6); zgradpulse(gzlvl4, gt4); /* Crush gradient G4 */ delay(gstab); /* Begin of N to Ca transfer */ dec2rgpulse(pwN,one,0.0,0.0); dcplr2phase(zero); /* SAPS_DELAY */ delay(1.34e-3 - SAPS_DELAY - 2.0*pw); rgpulse(pw,one,0.0,0.0); rgpulse(2.0*pw,zero,0.0,0.0); rgpulse(pw,one,0.0,0.0); delay(tauNCo - pwCO180/2 - 1.34e-3 - 2.0*pw - WFG3_START_DELAY); } /* Begin transfer from HzNz to N(i)zC'(i-1)zCa(i)zCa(i-1)z */ c13pulse("co", "cab", "sinc", 180.0, zero, 2.0e-6, 0.0); delay(tauNCa - tauNCo - pwCO180/2 - WFG3_START_DELAY - WFG3_STOP_DELAY - 2.0e-6); /* WFG3_START_DELAY */ sim3_c13pulse("", "cab", "co", "square", "", 0.0, 180.0, 2.0*pwN, zero, zero, zero, 2.0e-6, 2.0e-6); delay(tauNCa - 2.0e-6 - WFG3_STOP_DELAY); dec2rgpulse(pwN, zero, 0.0, 0.0); /* End transfer from HzNz to N(i)zC'(i-1)zCa(i)zCa(i-1)z */ zgradpulse(gzlvl5, gt5); delay(gstab); /* Begin removal of Ca(i-1) */ c13pulse("co", "cab", "sinc", 90.0, zero, 2.0e-6, 2.0e-6); zgradpulse(gzlvl6, gt6); delay(tauCaCo - gt6 - pwCab180 - pwCO180/2 - 6.0e-6); c13pulse("cab","co", "square", 180.0, zero, 2.0e-6, 2.0e-6); c13pulse("co","cab", "sinc", 180.0, zero, 2.0e-6, 2.0e-6); zgradpulse(gzlvl6, gt6); delay(tauCaCo - gt6 - pwCab180 - pwCO180/2 - 6.0e-6); c13pulse("cab","co", "square", 180.0, zero, 2.0e-6, 2.0e-6); c13pulse("co", "cab", "sinc", 90.0, one, 2.0e-6, 2.0e-6); /* End removal of Ca(i-1) */ /* xx Selective glycine pulse xx */ set_c13offset("gly"); setautocal(); if (autocal[A] == 'y') { if(FIRST_FID) { ppm = getval("dfrq"); bw=9*ppm; gly90 = pbox_make("gly90","eburp1",bw,0.0,compC*pwC,pwClvl); /* Gly selective 90 with null at 50ppm */ } pwgly=gly90.pw; glypwr=gly90.pwr; glypwrf=gly90.pwrf; decpwrf(glypwrf); decpower(glypwr); decshaped_pulse("gly90",pwgly,zero,2.0e-6,0.0); } else { decpwrf(4095.0); decpower(glypwr); decshaped_pulse(glyshp,pwgly,zero,2.0e-6,0.0); } /* xx End of glycine selecton xx */ zgradpulse(gzlvl7, gt7); set_c13offset("cab"); delay(gstab); decphase(t3); if ( dm3[B] == 'y' ) /* begins optional 2H decoupling */ { dec3unblank(); dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6); dec3unblank(); dec3phase(zero); delay(2.0e-6); setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3); } /* ========== Ca to Cb transfer =========== */ c13pulse("cab", "co", "square", 90.0, t3, 2.0e-6, 2.0e-6); decphase(zero); delay(tauCaCb - 4.0e-6); c13pulse("cab", "co", "square", 180.0, zero, 2.0e-6, 2.0e-6); decphase(t2); delay(tauCaCb - 4.0e-6 ); /* xxxxxxxxxxxxxxxxxxxxxx 13Cb EVOLUTION xxxxxxxxxxxxxxxxxx */ c13pulse("cab", "co", "square", 90.0, t2, 2.0e-6, 0.0); /* pwCa90 */ decphase(zero); if ((ni>1.0) && (tau1>0.0)) { if (tau1 - 2.0*pwCab90/PI - WFG_START_DELAY - pwN - 2.0e-6 - PWRF_DELAY - POWER_DELAY > 0.0) { delay(tau1 - 2.0*pwCab90/PI - pwN - 2.0e-6 ); dec2rgpulse(2.0*pwN, zero, 2.0e-6, 0.0); delay(tau1 - 2.0*pwCab90/PI - pwN - WFG_START_DELAY - 2.0e-6 - PWRF_DELAY - POWER_DELAY); } else { tsadd(t12,2,4); delay(2.0*tau1); delay(10.0e-6); /* WFG_START_DELAY */ sim3_c13pulse("", "cab", "co", "square", "", 0.0, 180.0, 2.0*pwN, zero, zero, zero, 2.0e-6, 0.0); delay(10.0e-6); } } else { tsadd(t12,2,4); delay(10.0e-6); /* WFG_START_DELAY */ sim3_c13pulse("", "cab", "co", "square", "", 0.0, 180.0, 2.0*pwN, zero, zero, zero, 2.0e-6, 0.0); delay(10.0e-6); } decphase(one); c13pulse("cab", "co", "square", 90.0, one, 2.0e-6, 0.0); /* pwCa90 */ /* xxxxxxxxxxx End of 13Cb EVOLUTION - Start 13Ca EVOLUTION xxxxxxxxxxxx */ decphase(zero); delay(tau2); sim3_c13pulse("", "co", "cab", "sinc", "", 0.0, 180.0, 2.0*pwN, zero, zero, zero, 2.0e-6, 0.0); decphase(zero); delay(tauCaCb - 2*pwN - pwCab180/2 - WFG2_START_DELAY - 2.0*PWRF_DELAY - 2.0*POWER_DELAY - WFG2_STOP_DELAY - 4.0e-6 ); c13pulse("cab", "co", "square", 180.0, zero, 2.0e-6, 0.0); delay(tauCaCb- tau2 - pwCO180 - pwCab180/2 - WFG2_START_DELAY - 2.0*PWRF_DELAY -2.0*POWER_DELAY - WFG2_STOP_DELAY - 4.0e-6); c13pulse("co", "cab", "sinc", 180.0, zero, 2.0e-6, 0.0); decphase(t5); c13pulse("cab", "co", "square", 90.0, t5, 2.0e-6, 0.0); /* xxxxxxxxxxxxxxxxxxx End of 13Ca EVOLUTION xxxxxxxxxxxxxxxxxx */ if ( dm3[B] == 'y' ) /* turns off 2H decoupling */ { dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6); dec3blank(); setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3); dec3blank(); } /* xxxxxxxxxxxxxxxxxxxx N15 EVOLUTION & SE TRAIN xxxxxxxxxxxxxxxxxxxxxxx */ dcplrphase(zero); dec2phase(t8); zgradpulse(gzlvl10, gt10); delay(gstab); dec2rgpulse(pwN, t8, 2.0e-6, 0.0); c13pulse("co", "cab", "sinc", 180.0, zero, 2.0e-6, 0.0); /*pwCO180*/ decphase(zero); dec2phase(t9); delay(timeTN - pwCO180 - WFG3_START_DELAY - tau3 - 4.0e-6); /* WFG3_START_DELAY */ sim3_c13pulse("", "cab", "co", "square", "", 0.0, 180.0, 2.0*pwN, zero, zero, t9, 2.0e-6, 2.0e-6); c13pulse("co", "cab", "sinc", 180.0, zero, 2.0e-6, 0.0); /*pwCO180*/ dec2phase(t10); txphase(t4); delay(timeTN - pwCO180 + tau3 - 500.0e-6 - gt1 - 2.0*GRADIENT_DELAY- WFG_START_DELAY - WFG_STOP_DELAY ); delay(0.2e-6); zgradpulse(gzlvl1, gt1); delay(gstab); sim3pulse(pw, 0.0, pwN, t4, zero, t10, 0.0, 0.0); txphase(zero); dec2phase(zero); zgradpulse(gzlvl11, gt11); delay(lambda - 1.3*pwN - gt11); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); zgradpulse(gzlvl11, gt11); txphase(one); dec2phase(t11); delay(lambda - 1.3*pwN - gt11); sim3pulse(pw, 0.0, pwN, one, zero, t11, 0.0, 0.0); txphase(zero); dec2phase(zero); zgradpulse(gzlvl12, gt12); delay(lambda - 1.3*pwN - gt12); sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0); dec2phase(zero); zgradpulse(gzlvl12, gt12); delay(lambda - 1.3*pwN - gt12); sim3pulse(pw, 0.0, pwN, zero, zero, zero, 0.0, 0.0); delay((gt1/10.0) + 1.0e-4 + 2.0*GRADIENT_DELAY + POWER_DELAY); rgpulse(2.0*pw, zero, 0.0, 0.0); dec2power(dpwr2); /* POWER_DELAY */ zgradpulse(icosel*gzlvl2, gt1/10.0); /* 2.0*GRADIENT_DELAY */ statusdelay(C, 1.0e-4 ); setreceiver(t12); if (dm3[B]=='y') lk_sample(); }
static void anchor_token (LexState *ls) { if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) { TString *ts = ls->t.seminfo.ts; luaX_newstring(ls, getstr(ts), ts->tsv.len); } }