Esempio n. 1
0
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);

}
Esempio n. 2
0
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);
}
Esempio n. 3
0
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);
}
Esempio n. 4
0
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();
        }	
}		 
Esempio n. 5
0
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;
}
Esempio n. 6
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);

}
Esempio n. 7
0
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);
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
int
getdelim (char **lineptr, size_t * n, int delimiter, FILE * stream)
{
  return getstr (lineptr, n, stream, delimiter, 0, 0);
}
Esempio n. 10
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);
}
Esempio n. 11
0
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
}
Esempio n. 12
0
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");
 }
}
Esempio n. 13
0
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);
}
Esempio n. 14
0
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);
}
Esempio n. 15
0
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);
}
Esempio n. 16
0
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;
}
Esempio n. 17
0
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);
}
Esempio n. 18
0
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;
}
Esempio n. 19
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);
       }
}		 
Esempio n. 20
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);
}
Esempio n. 21
0
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);
}
Esempio n. 22
0
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);
}
Esempio n. 23
0
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;
}
Esempio n. 24
0
/* 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);
}
Esempio n. 25
0
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);
}
Esempio n. 26
0
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);
}
Esempio n. 27
0
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);
}		 
Esempio n. 28
0
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();
}
Esempio n. 30
0
File: lparser.c Progetto: 1nv1/wxlua
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);
  }
}