自学教程：C++ startacq函数代码示例

void pulsesequence(){  double pwx;  char rcvrsflag[MAXSTR];  pwx = getval("pwx");  getstr("rcvrs",rcvrsflag);  /* check decoupling modes */  if ( (dm[C] == 'y') || (dm[D] == 'y') || (homo[0] == 'y') )  {    printf("dm[C], dm[D] should be set to 'n' and/or homo should set to 'n'");    psg_abort(1);  }  if (strcmp(rcvrsflag,"yy"))    printf("rcvrs parameter should be set to 'yy'/n");    settable(t1,4,ph1);  getelem(t1,ct,v1);  assign(v1,oph);  settable(t2,4,ph2);  status(A);  obspower(tpwr);  decpower(dpwr);  delay(d1);  status(B);  delay(d2);  rgpulse(pw, t2, rof1, rof2);   status(C);  setactivercvrs("yn");  startacq(alfa);  acquire(np,1.0/sw);  endacq();  status(B);  delay(d2);  decrgpulse(pwx, t2, rof1, rof2);  status(D);  setactivercvrs("ny");  startacq(alfa);  acquire(np,1.0/sw);  endacq();}

pulsesequence() {// Define Variables and Objects and Get Parameter Values   MPSEQ dec = getblew("blewH",0,0.0,0.0,0,1);   strncpy(dec.ch,"dec",3);   putCmd("chHblew='dec'/n");   CP hx = getcp("HX",0.0,0.0,0,1);   strncpy(hx.fr,"dec",3);   strncpy(hx.to,"obs",3);   putCmd("frHX='dec'/n");   putCmd("toHX='obs'/n");//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pwH90") + getval("tHX") + getval("rd") + getval("ad") + at;   d.dutyoff = d1 + 4.0e-6;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(phH90,4,table1);   settable(phXhx,4,table2);   settable(phHhx,4,table3);   settable(phRec,4,table4);   setreceiver(phRec);// Begin Sequence   txphase(phXhx); decphase(phH90);   obspwrf(getval("aXhx")); decpwrf(getval("aH90"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H to X Cross Polarization   decrgpulse(getval("pwH90"),phH90,0.0,0.0);   decphase(phHhx);    _cp_(hx,phHhx,phXhx);// Begin Acquisition   _mpseqon(dec, phHhx);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _mpseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

void pulsesequence(){   double tro;   char gread,gphase,gslice;    char grdname[MAXSTR];   gread = 'z';   if (getorientation(&gread,&gphase,&gslice,"orient") < 0)      abort_message("illegal value in orient parameter");   gro = getval("gro");   tro = getval("tro");   getstr("gname",grdname);   /* equilibrium period */   status(A);      hsdelay(d1);   /* --- tau delay --- */   status(B);      pulse(p1, zero);      hsdelay(d2);   /* --- observe period --- */   status(C);   pulse(pw,oph);   delay(0.0001);   shapedgradient(grdname,tro,gro,gread,1,1);    hsdelay(d2);   startacq(alfa);   acquire(np,1.0/sw);   endacq();}

pulsesequence(){   double pd, seqtime;   initparms_sis();  /* initialize standard imaging parameters */   seqtime = at+pw+rof1+rof2;   pd = tr - seqtime;  /* predelay based on tr */    if (pd <= 0.0) {      abort_message("%s: Requested tr too short.  Min tr = %f ms",seqfil,seqtime*1e3);    }   status(A);   delay(pd);   xgate(ticks);   /* --- observe period --- */   obspower(tpwr);      shapedpulse(pwpat,pw,oph,rof1,rof2);      startacq(alfa);   acquire(np,1.0/sw);   endacq();   }

void pulsesequence() {// Define Variables and Objects and Get Parameter Values   DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");   strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pwX90");   d.dutyoff = d1 + 4.0e-6;   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(phX90,4,table1);   settable(phRec,4,table2);   setreceiver(phRec);// Begin Sequence   txphase(phX90); decphase(zero);   obspwrf(getval("aX90"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// X Direct Polarization   rgpulse(getval("pwX90"),phX90,0.0,0.0);// Begin Acquisition   _dseqon(dec);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

void pulsesequence(){   double pd, seqtime;   double n,r,bigtau;   double restol, resto_local;   init_mri();   restol=getval("restol");   //local frequency offset   roff=getval("roff");       //receiver offset   init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);   /* hard pulse */   calc_rf(&p1_rf,"tpwr1","tpwr1f");   init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2);   /* hard pulse */   calc_rf(&p2_rf,"tpwr2","tpwr2f");/* calculate 'big tau' values */   bigtau = getval("bigtau");   n =  bigtau/(2.0*d2);   n = (double)((int)((n/2.0) + 0.5)) * 2.0;   initval(n,v3);   seqtime = at+p1+rof1+rof2;   seqtime += 2*d2+p2+rof1+rof2;  /* cpmg pulse and delay */      pd = tr - seqtime;  /* predelay based on tr */   if (pd <= 0.0) {      abort_message("%s: Requested tr too short.  Min tr = %f ms",seqfil,seqtime*1e3);    }   resto_local=resto-restol;    status(A);   delay(pd);   xgate(ticks);   /* calculate exact delay and phases */   r = d2-p2/2.0-rof2;   /* correct delay for pulse width */   mod2(oph,v2);   /* 0,1,0,1 */   incr(v2);   /* 1,2,1,2 = y,y,-y,-y */   obsoffset(resto_local);    obspower(p1_rf.powerCoarse);   obspwrf(p1_rf.powerFine);   rgpulse(p1,oph,rof1,rof2);  /* 90deg */   obspower(p2_rf.powerCoarse);   obspwrf(p2_rf.powerFine);   starthardloop(v3);      delay(r);      rgpulse(p2,v2,rof1,rof2);   /* 180deg pulse */      delay(r);   endhardloop();   startacq(alfa);   acquire(np,1.0/sw);   endacq();}

pulsesequence(){   double pd, seqtime;   double minte,ted1,ted2;   double restol, resto_local;   int  vph180     = v2;  /* Phase of 180 pulse */   init_mri();              /****needed ****/   restol=getval("restol");   //local frequency offset   roff=getval("roff");       //receiver offset   init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);   /* hard pulse */   calc_rf(&p1_rf,"tpwr1","tpwr1f");   init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2);   /* hard pulse */   calc_rf(&p2_rf,"tpwr2","tpwr2f");   seqtime = at+(p1/2.0)+rof1+d2;   pd = tr - seqtime;  /* predelay based on tr */   if (pd <= 0.0) {      abort_message("%s: Requested tr too short.  Min tr = %f ms",seqfil,seqtime*1e3);    }   minte = p1/2.0 + p2 + 2*rof2 + rof1;   if(d2 > 0) {     if(d2 < minte+4e-6)        abort_message("%s: TE too short. Min te = %f ms",seqfil,minte*1e3);   }   ted1 = d2/2 - p1/2 - p2/2 + rof2 + rof1;   ted2 = d2/2 - p2/2 + rof2;   resto_local=resto-restol;    status(A);   xgate(ticks);   delay(pd);   /* --- observe period --- */   obsoffset(resto_local);   obspower(p1_rf.powerCoarse);   obspwrf(p1_rf.powerFine);   shapedpulse(p1pat,p1,oph,rof1,rof2);   /* if d2=0 no 180 pulse applied */   if (d2 > 0) {     obspower(p2_rf.powerCoarse);     obspwrf(p2_rf.powerFine);        settable(t2,2,ph180);        /* initialize phase tables and variables */     getelem(t2,ct,v6);  /* 180 deg pulse phase alternates +/- 90 off the rcvr */     add(oph,v6,vph180);      /* oph=zero */     delay(ted1);     shapedpulse(p2pat,p2,vph180,rof1,rof2);     delay(ted2);   }   startacq(alfa);   acquire(np,1.0/sw);   endacq();}

pulsesequence(){  double sign,currentlimit,RMScurrentlimit,dutycycle;  int calcpower;  /* Initialize paramaters **********************************/  init_mri();  calcpower=(int)getval("calcpower");  dutycycle=getval("dutycycle");  currentlimit=getval("currentlimit");  RMScurrentlimit=getval("RMScurrentlimit");  if (gspoil>0.0) sign = 1.0;  else sign = -1.0;  init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);  if (calcpower) calc_rf(&p1_rf,"tpwr1","tpwr1f");  if (tspoil>0.0) {    gspoil = sqrt(dutycycle/100.0)*gmax*RMScurrentlimit/currentlimit;    init_generic(&spoil_grad,"spoil",gspoil,tspoil);    spoil_grad.rollOut=FALSE;    calc_generic(&spoil_grad,WRITE,"gspoil","tspoil");  }  xgate(ticks);  rotate();  status(A);  mod4(ct,oph);  delay(d1);  /* TTL scope trigger **********************************/         sp1on(); delay(4e-6); sp1off();  if (calcpower) {    obspower(p1_rf.powerCoarse);    obspwrf(p1_rf.powerFine);  }   else obspower(tpwr1);  delay(4e-6);  if (tspoil>0.0) {    obl_shapedgradient(spoil_grad.name,spoil_grad.duration,0,0,spoil_grad.amp*sign,WAIT);    delay(d2);  }  shapedpulse(p1pat,p1,ct,rof1,rof2);  startacq(alfa);  acquire(np,1.0/sw);  endacq();		}

pulsesequence() {// Define Variables and Objects and Get Parameter Values   initval(getval("periods"),v2); //--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Set Phase Tables   settable(phX90,4,table1);   settable(phRec,4,table2);   setreceiver(phRec);// Begin Sequence   txphase(phX90); decphase(zero);   obspwrf(getval("aX90"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   xgate(1.0);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// Apply a Rotorsync Delay   rgpulse(getval("pwX90"),phX90,0.0,0.0);   rotorsync(v2);   rgpulse(getval("pwX90"),phX90,0.0,0.0);   xgate(getval("xperiods"));    rgpulse(getval("pwX90"),phX90,0.0,0.0);   delay(10.0e-6); // X Direct Polarization   rgpulse(getval("pwX90"),phX90,0.0,0.0);// Begin Acquisition   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   obsunblank(); decunblank(); _unblank34();}

pulsesequence() {// Define Variables and Objects and Get Parameter Values   double pw1Xstmas = getval("pw1Xstmas");   double pw2Xstmas = getval("pw2Xstmas");   double tXzfselinit = getval("tXzfsel");   double tXzfsel = tXzfselinit - 3.0e-6;   if (tXzfsel < 0.0) tXzfsel = 0.0;   double d2init = getval("d2");   double d2 = d2init - pw1Xstmas/2.0 - pw2Xstmas/2.0;   if (d2 < 0.0) d2 = 0.0;   DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");    strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");// Set Constant-time Period for d2.    if (d2_index == 0) d2_init = getval("d2");   double d2_ = (ni - 1)/sw1 + d2_init;   putCmd("d2acqret = %f/n",roundoff(d2_,12.5e-9));   putCmd("d2dwret = %f/n",roundoff(1.0/sw1,12.5e-9));//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pw1Xstmas") + getval("pw2Xstmas") + getval("pwXzfsel");   d.dutyoff = d1 + 4.0e-6;   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = d2_ + tXzfsel + getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = d2_ + tXzfsel + getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(ph1Xstmas,4,table1);   settable(ph2Xstmas,4,table2);   settable(phXzfsel,8,table3);   settable(phRec,8,table4);   if (phase1 == 2) {      tsadd(ph1Xstmas,1,4);   }   setreceiver(phRec);// Begin Sequence   txphase(ph1Xstmas); decphase(zero);   obspower(getval("tpwr"));   obspwrf(getval("aXstmas"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H Decoupler on Before STMAS   _dseqon(dec);// Two-Pulse STMAS   rgpulse(getval("pw1Xstmas"),ph1Xstmas,0.0,0.0);   txphase(ph2Xstmas);   delay(d2);   rgpulse(getval("pw2Xstmas"),ph2Xstmas,0.0,0.0);// Z-filter Pulse   txphase(phXzfsel);   obsblank();    obspower(getval("dbXzfsel"));   obspwrf(getval("aXzfsel"));   delay(3.0e-6);   obsunblank();   delay(tXzfsel);   rgpulse(getval("pwXzfsel"),phXzfsel,0.0,0.0);// Begin Acquisition   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........	sim3shaped_pulse("", "offC10", "", 2.0*pw, pwC10, 2.0*pwN, zero, zero, zero, 0.0, 0.0);        if(pwC10>2.0*pwN) pwZ=0.0; else pwZ=2.0*pwN - pwC10;	delay(tau2);	decpwrf(rf0);                if (mag_flg[A] == 'y')                {                   magradpulse(-icosel2*gzcal*gzlvl2, 1.8*gt1);                }                else                {                   zgradpulse(-icosel2*gzlvl2, 1.8*gt1);                }	delay(2.02e-4);	decrgpulse(2.0*pwC, zero, 0.0, 0.0);	decpwrf(rf10);                if (mag_flg[A] == 'y')                {                   magradpulse(icosel2*gzcal*gzlvl2, 1.8*gt1);                }                else                {                   zgradpulse(icosel2*gzlvl2, 1.8*gt1);                }	delay(2.0e-4 + WFG3_START_DELAY + pwZ);	decshaped_pulse("offC10", pwC10, zero, 0.0, 0.0);	decpwrf(rf0);	decrgpulse(pwC, zero, 2.0e-6, 0.0);	zgradpulse(gzlvl5, gt5);	delay(0.5*del1 - gt5);	simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);	zgradpulse(gzlvl5, gt5);	txphase(one);	decphase(t10);	delay(0.5*del1 - gt5);	simpulse(pw, pwC, one, t10, 0.0, 0.0);	zgradpulse(gzlvl6, gt5);	txphase(zero);	decphase(zero);	delay(0.5*del2 - gt5);	simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);	zgradpulse(gzlvl6, gt5);	delay(0.5*del2 - gt5);	simpulse(pw, pwC, zero, zero, 0.0, 0.0);	delay(0.5*del - 0.5*pwC);	simpulse(2.0*pw,2.0*pwC, zero, zero, 0.0, 0.0);        if (mag_flg[A] == 'y')            magradpulse(gzcal*gzlvl1, gt1);        else            zgradpulse(gzlvl1, gt1);        rcvron();   if ((STUD[A]=='n') && (dm[C] == 'y'))        decpower(dpwr);        if ( dm3[B] == 'y' )   /* turns off 2H decoupling  */        {           delay(0.5*del-40.0e-6 -gt1 -1/dmf3);           setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);           dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);           dec3blank();           lk_autotrig();   /* resumes lock pulsing */           lk_sample();           if (mag_flg[A] == 'y')            statusdelay(C,40.0e-6  - 2.0*VAGRADIENT_DELAY - POWER_DELAY);           else            statusdelay(C,40.0e-6  - 2.0*GRADIENT_DELAY - POWER_DELAY);        }      else        {         delay(0.5*del-40.0e-6 -gt1);        if (mag_flg[A] == 'y')         statusdelay(C,40.0e-6  - 2.0*VAGRADIENT_DELAY - POWER_DELAY);        else         statusdelay(C,40.0e-6  - 2.0*GRADIENT_DELAY - POWER_DELAY);        }  if ((STUD[A]=='y') && (dm[C] == 'y'))        {decpower(studlvl);         decunblank();         decon();         decprgon(stCdec,1/stdmf, 1.0);         startacq(alfa);         acquire(np, 1.0/sw);         decprgoff();         decoff();         decblank();        } setreceiver(t11);}		 

pulsesequence(){   double pd, seqtime;   double mintDELTA,ted1,ted2,gf;   double restol, resto_local;   init_mri();              /****needed ****/   restol=getval("restol");   //local frequency offset   roff=getval("roff");       //receiver offset   init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);   /* hard pulse */   calc_rf(&p1_rf,"tpwr1","tpwr1f");   init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2);   /* hard pulse */   calc_rf(&p2_rf,"tpwr2","tpwr2f");   gf=1.0;   if(diff[0] == 'n') gf=0;   int  vph180     = v2;  /* Phase of 180 pulse */   mintDELTA = tdelta + trise + rof1 + p2 + rof2;   if(tDELTA <= mintDELTA) {       abort_message("%s: tDELTA too short. Min tDELTA = %f ms",seqfil,mintDELTA*1e3);   }   ted1 = tDELTA - tdelta + trise + p2 + rof1 + rof2;   te = p1/2 + rof2 + tdelta + trise + ted1 + rof1 + p2/2;   /* first half-te */   ted2 = te - p2/2 - rof2 - tdelta - trise;   if((ted1 <= 0)||(ted2 <= 0) ) {       abort_message("%s: tDELTA too short. Min tDELTA = %f ms",seqfil,mintDELTA*1e3);   }   te = te*2.0;   putvalue("te",te);   seqtime = at+(p1/2.0)+rof1+te;   pd = tr - seqtime;  /* predelay based on tr */   if (pd <= 0.0) {      abort_message("%s: Requested tr too short.  Min tr = %f ms",seqfil,seqtime*1e3);   }   resto_local=resto-restol;    status(A);   rotate();   delay(pd);   xgate(ticks);   /* --- observe period --- */   obsoffset(resto_local);    obspower(p1_rf.powerCoarse);   obspwrf(p1_rf.powerFine);   shapedpulse(p1pat,p1,oph,rof1,rof2);   obl_gradient(0,0,gdiff*gf);   /* x,y,z gradients selected via orient */   delay(tdelta);   zero_all_gradients();   delay(trise);   delay(ted1);        obspower(p2_rf.powerCoarse);   obspwrf(p2_rf.powerFine);      settable(t2,2,ph180);        /* initialize phase tables and variables */   getelem(t2,ct,v6);  /* 180 deg pulse phase alternates +/- 90 off the rcvr */   add(oph,v6,vph180);      /* oph=zero */   shapedpulse(p2pat,p2,vph180,rof1,rof2);   obl_gradient(0,0,gdiff);   /* x,y,z gradients selected via orient */   delay(tdelta);   zero_all_gradients();   delay(trise);   delay(ted2);   startacq(alfa);   acquire(np,1.0/sw);   endacq();}

pulsesequence() {// Set the Maximum Dynamic Table and v-var Numbers   settablenumber(10);   setvvarnumber(30);// Define Variables and Objects and Get Parameter Values   double aXprep1 = getval("aXprep1");  // Define Tilted Pulses using "prep1X".   double pw1Xprep1 = getval("pw1Xprep1");   double pw2Xprep1 = getval("pw2Xprep1");   double phXprep1 = getval("phXprep1");   WMPA wpmlg = getwpmlg("wpmlgX");   strncpy(wpmlg.ch,"obs",3);    putCmd("chXwpmlg='obs'/n");//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pw1Xprep1") + getval("pw2Xprep1") + 2.0*wpmlg.q*wpmlg.cycles*wpmlg.pw;   d.dutyoff = d1 + 4.0e-6 + 5.0e-6 + wpmlg.r1 + wpmlg.r2 +                at - 2.0*wpmlg.q*wpmlg.cycles*wpmlg.pw;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(ph1Xprep1,4,table1);   settable(ph2Xprep1,4,table2);   settable(phXwpmlg,4,table3);   settable(phRec,4,table4);   setreceiver(phRec);// Set the Small-Angle Step   double obsstep = 360.0/(PSD*8192);   obsstepsize(obsstep);   int phfXprep1 = initphase(phXprep1, obsstep);   int phXzero = initphase(0.0, obsstep);// Begin Sequence   xmtrphase(phfXprep1); txphase(ph1Xprep1);   obspwrf(aXprep1);   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// Tilted Preparation Pulse for FSLG or PMLG "prep1X"   startacq(5.0e-6);   rcvroff();   delay(wpmlg.r1);   rgpulse(pw1Xprep1, ph1Xprep1, 0.0, 0.0);   rgpulse(pw2Xprep1, ph2Xprep1, 0.0, 0.0);   xmtrphase(phXzero);   delay(wpmlg.r2);// Apply WPMLG Cycles   decblank(); _blank34();   _wpmlg(wpmlg, phXwpmlg);   endacq();   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........    pss0 = getval("pss0");    					           getstr("slice_select",slice_select);      /* slice select flag                                               [y] = ON, [n] = OFF */					           /*******************************************************/    /* Slice Select gradient area                          */    /*******************************************************/    t_rampslice = grate * agss;    gssint = (agss*p1/2.0) + (agss*t_rampslice/2.0);    gssrint=gssint;    /*******************************************************     * Calculate slice refocussing gradient                *     *******************************************************/    t_plateau_sr = (gssint / gssr) - trise;    if (t_plateau_sr <= 0.0)            /* traingular gradients */       {       t_plateau_sr = 0.0;       gssr = sqrt(gssint / grate);       }      t_ramp_sr = gssr * grate;           /* ramp time for refocusing gradient*/    gssrint = (gssr * t_plateau_sr) + (t_ramp_sr * gssr);	        /***************************************************************************     * timing calculation                                                      *     ***************************************************************************/       if (slice_select[0] == 'y')       {       t_after = tr - (predelay + p1 + t_plateau_sr + at + acq_delay + 2* (t_rampslice + t_ramp_sr));       min_tr  = predelay + p1 + t_plateau_sr + at + acq_delay + 2* (t_rampslice + t_ramp_sr);       }    else       {       t_after = tr - (predelay + p1 +  at + acq_delay );       min_tr  = predelay + p1 + at + acq_delay ;       }       if (t_after < 0.0)        {        abort_message("Requested repetition time (TR) too short.  Min tr = %.f[ms]/n",min_tr*1000);        }    /******************************************************/    /*                                                    */    /*                  S T A R T                         */    /*        P U L S E    S E Q U E N C E                */    /*                                                    */    /******************************************************/    obspower(tpwr1);                          /* set tranmitter power */    /***************************************************************************     *   Predelay                                                              *     ***************************************************************************/    obsoffset(f_offset);                    /* set transmitter offset */     delay(predelay);                        xgate(ticks);                           /* set gating */    if (slice_select[0] == 'y')         {  	 /***************************************************************************	  * Slice select gradient & RF pulse                                        *	  ***************************************************************************/	 obl_gradient(0.0,0.0,gss);               /* slice select gradient */	 delay(t_rampslice);                      /* delay - time to ramp up gradient */	 shaped_pulse(p1pat,p1,oph,rof1,rof1);	 zero_all_gradients();                    /* force all gradients back to 0 [G/cm] */	 delay(t_rampslice);                      /* time to ramp down gradient */	 /***************************************************************************	  * Slice refocus gradient                                                  *	  ***************************************************************************/	 obl_gradient(0.0,0.0,-gssr);             /* slice refocus gradient */	 delay(t_ramp_sr+t_plateau_sr);          /* ramp up of refocus gradient */	 zero_all_gradients();                   /* force refocus gradient back to 0 [G/cm] */	 delay(t_ramp_sr);                       /* time to ramp down gradient */	 }    else         {         shaped_pulse(p1pat,p1,oph,rof1,rof1);         }    /***************************************************************************     * Pre-acquire delay                                                       *     ***************************************************************************/    delay(acq_delay);    /***************************************************************************     * Acquire echo                                                            *     ***************************************************************************/    startacq(alfa);    acquire(np,1.0/sw);                 /* acquire FID */    endacq();    delay(t_after);                     /* time padding to fill TR */    /******************************************************/    /*                                                    */    /*                    E N D                           */    /*        P U L S E    S E Q U E N C E                */    /*                                                    */    /******************************************************/}

//.........这里部分代码省略.........   MPSEQ spc5ref = getspc5("spc5X",spc5.iSuper,spc5.phAccum,spc5.phInt,1,1);    strncpy(spc5.ch,"obs",3);   putCmd("chXspc5='obs'/n");   DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");    strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");// Set Constant-time Period for d2.    if (d2_index == 0) d2_init = getval("d2");   double d2_ = (ni - 1)/sw1 + d2_init;   putCmd("d2acqret = %f/n",roundoff(d2_,12.5e-9));   putCmd("d2dwret = %f/n",roundoff(1.0/sw1,12.5e-9));//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pwH90") + getval("tHX") + getval("pwX90") +              spc5.t + spc5ref.t;   d.dutyoff = d1 + 4.0e-6 + 2.0*getval("tZF");   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = d2_ +  getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = d2_ +  getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Create Phasetables   settable(phH90,4,table1);   settable(phHhx,4,table2);   settable(phXhx,4,table3);   settable(phXmix1,4,table4);   settable(phXmix2,4,table5);   settable(phRec,4,table6);   setreceiver(phRec);   if (phase1 == 2)      tsadd(phXhx,1,4);// Begin Sequence   txphase(phXhx); decphase(phH90);   obspwrf(getval("aXhx")); decpwrf(getval("aH90"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H to X Cross Polarization   decrgpulse(getval("pwH90"),phH90,0.0,0.0);   decphase(phHhx);    _cp_(hx,phHhx,phXhx);// F2 Indirect Period for X   obspwrf(getval("aX90"));   _dseqon(dec);   delay(d2);   _dseqoff(dec);// Mixing with SPC5 Recoupling   rgpulse(getval("pwX90"),phXmix1,0.0,0.0);   obspwrf(getval("aXspc5"));   xmtrphase(v1); txphase(phXmix1);   delay(getval("tZF"));   decpwrf(getval("aHmix"));   decon();   _mpseq(spc5, phXmix1);   xmtrphase(v2); txphase(phXmix2);   _mpseq(spc5ref, phXmix2);   decoff();   obspwrf(getval("aX90"));   xmtrphase(zero); txphase(phXmix2);   delay(getval("tZF"));   rgpulse(getval("pwX90"),phXmix2,0.0,0.0);// Begin Acquisition   _dseqon(dec);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........             incr(v1);                      /* hypercomplex phase increment */                      initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v10);            add(v1,v10,v1);           add(oph,v10,oph);           mod4(v1,v1);  mod4(v2,v2); mod4(oph,oph);            assign(zero,v3);           if(FIRST_FID) 	   {	     HHmix = pbox_mix("HHmix", "DIPSI2", mixpwr, pw*compH, tpwr);  	     if(c1d[A] == 'n')	     {	       opx("CHdec"); setwave("WURST2 30k/1.2m"); pbox_par("steps","600"); cpx(pwC*compC, pwClvl);	       CHdec = getDsh("CHdec");	     }	   }	   ncyc = (int) (at/HHmix.pw) + 1;	   post_del = ncyc*HHmix.pw - at;	                         /* BEGIN PULSE SEQUENCE */      status(A);	zgradpulse(gzlvl0, gt0);	rgpulse(pw, zero, 0.0, 0.0);  /* destroy H-1 magnetization*/	zgradpulse(gzlvl0, gt0);	delay(1.0e-4);	obspower(tpwr);	txphase(v1);        decphase(zero);        dec2phase(zero);        presat();	obspower(tpwr);        		delay(1.0e-5);      status(B);        if(c1d[A] == 'y')	{   	  rgpulse(pw,v1,0.0,0.0);                 /* 1H pulse excitation */          delay(d2);   	  rgpulse(pw,two,0.0,0.0);                 /* 1H pulse excitation */          assign(oph,v3);	}	else	{          decunblank(); pbox_decon(&CHdec);   	  rgpulse(pw,v1,0.0,0.0);                 /* 1H pulse excitation */   	  txphase(zero);   	          delay(d2);          pbox_decoff(); decblank();            decpower(pwClvl); decpwrf(4095.0);   	  	  delay(tau1 - POWER_DELAY);          simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);          txphase(one); decphase(one); dec2phase(one);	  delay(tau1);          simpulse(pw, pwC, one, one, 0.0, 0.0);          txphase(zero); decphase(zero); dec2phase(zero);	  delay(tau1);          simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);	  delay(tau1);          simpulse(0.0, pwC, zero, zero, 0.0, 0.0);        }	zgradpulse(gzlvl1, gt1);   	delay(grec);        simpulse(0.0, pwC, zero, v3, 0.0, rof2);                txphase(v2);        obsunblank(); pbox_xmtron(&HHmix);        status(C);              setactivercvrs("ny");        startacq(alfa);        acquire(np,1.0/sw);        endacq();        	delay(post_del);        pbox_xmtroff(); obsblank();        zgradpulse(gzlvl2, gt2);        obspower(tpwr);   	delay(grec);   	rgpulse(pw,zero,0.0,rof2);                 /* 1H pulse excitation */   	              status(D);              setactivercvrs("yn");        startacq(alfa);        acquire(np,1.0/sw);        endacq();}		 

//.........这里部分代码省略.........     decrgpulse(4.6*p_d,two,0.0,0.0);     decrgpulse(7.2*p_d,zero,0.0,0.0);     decrgpulse(4.9*p_d,two,0.0,0.0);     decrgpulse(7.4*p_d,zero,0.0,0.0);     decrgpulse(6.8*p_d,two,0.0,0.0);     decrgpulse(7.0*p_d,zero,0.0,0.0);     decrgpulse(5.2*p_d,two,0.0,0.0);     decrgpulse(5.4*p_d,zero,0.0,0.0);     decrgpulse(0.6*p_d,two,0.0,0.0);     decrgpulse(4.5*p_d,zero,0.0,0.0);     decrgpulse(7.3*p_d,two,0.0,0.0);     decrgpulse(5.1*p_d,zero,0.0,0.0);     decrgpulse(7.9*p_d,two,0.0,0.0);	endhardloop();        dec2phase(zero);        decphase(zero);        txphase(zero);	decpwrf(rfC);	delay(tau2);	sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);	delay(tau2);	decpwrf(rfC);	zgradpulse(-icosel2*gzlvl2, 1.8*gt1);	delay(grecov+2.0e-6);	decrgpulse(2.0*pwC, zero, 0.0, 0.0);	decpwrf(rfC);	zgradpulse(icosel2*gzlvl2, 1.8*gt1);	delay(grecov + pwN);	decrgpulse(pwC, zero, 0.0, 0.0);	decpwrf(rfC);	decrgpulse(pwC, zero, 2.0e-6, 0.0);	zgradpulse(gzlvl5, gt5);	delay(0.5*del1 - gt5);	simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);	zgradpulse(gzlvl5, gt5);	txphase(one);	decphase(t10);	delay(0.5*del1 - gt5);	simpulse(pw, pwC, one, t10, 0.0, 0.0);	zgradpulse(gzlvl6, gt5);	txphase(zero);	decphase(zero);	delay(0.5*del2 - gt5);	simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0);	zgradpulse(gzlvl6, gt5);	delay(0.5*del2 - gt5);	simpulse(pw, pwC, zero, zero, 0.0, 0.0);	delay(0.5*del - 0.5*pwC);	simpulse(2.0*pw,2.0*pwC, zero, zero, 0.0, 0.0);   if (STUD[A]=='y') decpower(studlvl);   else    {	decpower(dpwr);	dec2power(dpwr2);    }	zgradpulse(gzlvl1, gt1);         		/* 2.0*GRADIENT_DELAY */   if(dm3[B] == 'y') 	delay(0.5*del - gt1 -1/dmf3 - 2.0*GRADIENT_DELAY - POWER_DELAY);      else	delay(0.5*del - gt1 - 2.0*GRADIENT_DELAY - POWER_DELAY);   if(dm3[B] == 'y')			         /*optional 2H decoupling off */        {          dec3rgpulse(1/dmf3, three, 0.0, 0.0); dec3blank();          setstatus(DEC3ch, FALSE, 'w', FALSE, dmf3);          dec3blank();        }	decpower(dpwr);				               /* POWER_DELAY */  if (dm3[B]=='y') lk_sample();  if ((STUD[A]=='y') && (dm[C] == 'y'))        {decpower(studlvl);         decunblank();         decon();         decprgon(rna_stCdec,1/stdmf, 1.0);         startacq(alfa);         acquire(np, 1.0/sw);         decprgoff();         decoff();         decblank();        }      else	 status(C); setreceiver(t11);}		 

//.........这里部分代码省略.........   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = c7.t + getval("pwXtilt") + d2_ + getval("pwXtilt") + c7ref.t + getval("pwX90") +                   + wdumbo.q*wdumbo.cycles*wdumbo.pw;   d.dutyoff = 4.0e-6 + d1 + tXzfinit + wdumbo.r2 + at - wdumbo.q*wdumbo.cycles*wdumbo.pw;   d = update_dutycycle(d);   abort_dutycycle(d,10.0); // Set Phase Tables   settable(ph1Xc7,4,table1);   settable(phXdumbo,4,table2);   settable(ph2Xc7,4,table3);   settable(phX90,16,table4);   settable(phXwdumbo,4,table5);   settable(phRec,16,table6);   settable(ph1Xtilt,4,table7);   settable(ph2Xtilt,4,table8);// Set the Small-Angle Prep Phase   double obsstep = 360.0/(PSD*8192);   obsstepsize(obsstep);   int phfX90 = initphase(0.0, obsstep);//Add STATES Quadrature Phase   if (phase1 == 2)      initval((45.0/obsstep),v1);   else      initval(0.0,v1);   initval((d2*c7.of[0]*360.0/obsstep),v2);   initval(0.0,v3);   obsstepsize(obsstep);   setreceiver(phRec);// Begin Sequence   xmtrphase(v1); txphase(ph1Xc7);   obspwrf(getval("aXc7"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// C7 Recoupling of 2Q coherence   _mpseq(c7, ph1Xc7);// F1 Evolution With DUMBO   xmtrphase(v3);   if (!getval("scXdcf1")){   	obspwrf(getval("aX90"));   	rgpulse(getval("pwXtilt"),ph1Xtilt,0.0,0.0);   }   obspwrf(getval("aXdumbo"));   obsunblank();   _mpseqon(dumbo,phXdumbo);   delay(d2);   _mpseqoff(dumbo);   if (!getval("scXdcf1")){   	obspwrf(getval("aX90"));   	rgpulse(getval("pwXtilt"),ph2Xtilt,0.0,0.0);   }   obspwrf(getval("aX90"));   obsunblank();// C7 Transfer to 1Q Coherence   xmtrphase(v2);   _mpseq(c7ref, ph2Xc7);// Z-filter Delay   delay(tXzf);// Detection Pulse   txphase(phX90);   obspwrf(getval("aX90"));   startacq(5.0e-6);   rcvroff();   delay(wdumbo.r1);   rgpulse(getval("pwX90"), phX90, 0.0, 0.0);   obsunblank();   xmtrphase(v3);   delay(wdumbo.r2);// Apply WPMLG Cycles During Acqusition   decblank(); _blank34();   _wdumbo(wdumbo,phXwdumbo);   endacq();   obsunblank(); decunblank(); _unblank34();  }

//.........这里部分代码省略.........  if (ticks) {    xgate(ticks);    grad_advance(gpropdelay);    delay(4e-6);  }  /* TTL scope trigger **********************************/  //sp1on(); delay(4e-6); sp1off();  /* Saturation bands ***********************************/      if (ovs[0] == 'y') ovsbands();  if (sat[0] == 'y') satbands();  /* Water suppression **********************************/  if (ws[0]  == 'y') watersuppress();  /* Slice selective 90 degree RF pulse *****/  obspower(p1_rf.powerCoarse);  obspwrf(p1_rf.powerFine);  delay(GDELAY);    shaped_pulse(p1pat,p1,zero,rof1,rof2);   /* start localization */  obspower(p2_rf.powerCoarse);  obspwrf(p2_rf.powerFine);    if (nDim > 2.5) {    delay(te_d1);   //this is at least GDELAY == 4 us    obl_shaped3gradient(vox1_grad.name,vox1_crush.name,"",vox1_grad.duration,vox1_grad.amp,fy*vox1_crush.amp,0,NOWAIT);  delay(vox1_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& rprof==1) freq1=0.0;  shapedpulseoffset(p2_rf.pulseName,vox1_grad.rfDuration,v12,rof1,rof2,freq1);  delay(vox1_grad.rfDelayBack);    delay(te_d2);  obl_shaped3gradient (vox1_grad.name,vox1_crush.name,"",vox1_grad.duration,vox1_grad.amp,fy*0.777*vox1_crush.amp,0,NOWAIT);  delay(vox1_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& rprof==1) freq1=0.0;  shapedpulseoffset(p2_rf.pulseName,vox1_grad.rfDuration,v12,rof1,rof2,freq1);  delay(vox1_grad.rfDelayBack);    delay(te_d2);  }    if (nDim > 1.5) {   //this is 2nd slice selection  obl_shaped3gradient("",vox2_grad.name,vox2_crush.name,vox2_grad.duration,0,vox2_grad.amp,fz*vox2_crush.amp,NOWAIT);  delay(vox2_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& pprof==1) freq2=0.0;  shapedpulseoffset(p2_rf.pulseName,vox2_grad.rfDuration,v11,rof1,rof2,freq2);  delay(vox2_grad.rfDelayBack);    delay(te_d2);    obl_shaped3gradient("",vox2_grad.name,vox2_crush.name,vox2_grad.duration,0,vox2_grad.amp,fz*0.777*vox2_crush.amp,NOWAIT);  delay(vox2_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& pprof==1) freq2=0.0;  shapedpulseoffset(p2_rf.pulseName,vox2_grad.rfDuration,v11,rof1,rof2,freq2);  delay(vox2_grad.rfDelayBack);    delay(te_d2);  }  if (nDim > 0.5){    //this is 3rd slice selection  obl_shaped3gradient(vox3_crush.name,"",vox3_grad.name,vox3_grad.duration,fx*vox3_crush.amp,0,vox3_grad.amp,NOWAIT);  delay(vox3_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& sprof==1) freq3=0.0;  shapedpulseoffset(p2_rf.pulseName,vox3_grad.rfDuration,v10,rof1,rof2,freq3);  delay(vox3_grad.rfDelayBack);    delay(te_d2);   obl_shaped3gradient(vox3_crush.name,"",vox3_grad.name,vox3_grad.duration,fx*vox3_crush.amp,0,vox3_grad.amp,NOWAIT);  delay(vox3_grad.rfDelayFront);  if (profile_ovs[0]=='y'&& sprof==1) freq3=0.0;  shapedpulseoffset(p2_rf.pulseName,vox3_grad.rfDuration,v10,rof1,rof2,freq3);  delay(vox3_grad.rfDelayBack);    delay(te_d3);  }  if (profile_vox[0] == 'y') {    obl_shapedgradient(ror_grad.name,ror_grad.duration,      -rprof*ror_grad.amp,-pprof*ror_grad.amp,-sprof*ror_grad.amp,WAIT);    delay(GDELAY);    obl_shapedgradient(ro_grad.name,ro_grad.duration,      rprof*ro_grad.amp,pprof*ro_grad.amp,sprof*ro_grad.amp,NOWAIT);     delay(ro_grad.atDelayFront);    startacq(alfa);    acquire(np,1.0/sw);    delay(ro_grad.atDelayBack);    endacq();  } else {    startacq(alfa);    acquire(np,1.0/sw);    endacq();  }  delay(tr_delay);

//.........这里部分代码省略.........      /* Slice select RF pulse ******************************/       obspower(p1_rf.powerCoarse);      obspwrf(p1_rf.powerFine);      delay(GRADIENT_RES);      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        pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0,            -pe_grad.increment,vpe_mult,WAIT);      } else {        pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,-ssr_grad.amp,            -pe_grad.increment,vpe_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-alfa);            /* 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-alfa);            /* 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);

//.........这里部分代码省略.........	if( tepad>0.0 )		change_timing( "readDeph", tepad );	if( tepad2>0.0 )	change_timing( "nextSlice", tepad2 );	tr = get_timing( FROM_START_OF, "slice", TO_START_OF, "nextSlice" );	putvalue("tr", tr );	delayRFToAcq = get_timing( FROM_RF_PULSE_OF, "slice", TO_ACQ_OF, "read" );	delayAcqToRF = get_timing( FROM_ACQ_OF, "read", TO_RF_PULSE_OF, "nextSlice" );	set_comp_info( &ss_pre, "ss_pre" );	write_comp_grads_snippet( NULL, NULL, &ss_pre, "START_OF_KERNEL", "markerA" );	set_comp_info( &read, "ro" );	set_comp_info( &phase, "pe" );	set_comp_info( &slice, "ss" );	write_comp_grads_snippet( &read, &phase, &slice, "markerA", "markerB" );	set_comp_info( &ss_post, "ss_post" );	write_comp_grads_snippet( NULL, NULL, &ss_post, "markerB", "END_OF_KERNEL" );	/* Set up frequency offset pulse shape list ********/   		offsetlist(pss,ss_grad.ssamp,0,freqlist,ns,seqcon[1]);	shapelist1 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freqlist,ns,ss_grad.rfFraction, seqcon[1]);	/* Set pe_steps for profile or full image **********/   		pe_steps = prep_profile(profile[0],nv,&pe_grad,&pe_grad);/* profile[0] is n y or r */	F_initval(pe_steps/2.0,vpe_offset);	g_setExpTime(trmean*(ntmean*pe_steps*arraydim + (1+fabs(ssc))*arraydim));	/* Shift DDR for pro *******************************/   		roff = -poffset(pro,ro_grad.roamp);	/* PULSE SEQUENCE */	status( A );	rotate();        triggerSelect(trigger);	obsoffset( resto );	delay( GRADIENT_RES );	initval( 1+fabs( ssc ), vss );		obspower( p1_rf.powerCoarse );	obspwrf( p1_rf.powerFine );	delay( GRADIENT_RES );	assign(one,vacquire);         // real-time acquire flag	setacqvar(vacquire);          // Turn on acquire when vacquire is zero 						obl_shapedgradient(ss_pre.name,ss_pre.dur,0,0,ss_pre.amp,NOWAIT);			sp1on();	delay(GRADIENT_RES);	sp1off();	delay(ss_pre.dur-GRADIENT_RES );	msloop( seqcon[1], ns, vms_slices, vms_ctr );				assign(vss,vssc);		peloop( seqcon[2], pe_steps, vpe_steps, vpe_ctr );			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);			}					if (table)				getelem(t1,vpe_ctr,vpe_index);			else {				ifzero(vacquire);					sub(vpe_ctr,vpe_offset,vpe_index);				elsenz(vacquire);					sub(zero,vpe_offset,vpe_index);				endif(vacquire);			}								pe_shaped3gradient( read.name, phase.name, slice.name,								read.dur, read.amp, 0, slice.amp,								-pe_grad.increment, vpe_index, NOWAIT );			delay(ss_grad.rfDelayFront - granulatedRFDelay);			shapedpulselist( shapelist1, ss_grad.rfDuration, oph, rof1, rof2, seqcon[1], vms_ctr );			delay( delayRFToAcq - alfa );			startacq(alfa);			acquire( np, 1/ro_grad.bandwidth );			endacq();			delay( delayAcqToRF - ss_grad.rfDelayFront + granulatedRFDelay - GRADIENT_RES );			sp1on();			delay(GRADIENT_RES);			sp1off();					endpeloop( seqcon[2], vpe_ctr ); 	endmsloop( seqcon[1], vms_ctr );	obl_shapedgradient(ss_post.name,ss_post.dur,0,0,ss_post.amp,WAIT);}

//.........这里部分代码省略.........   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = getval("rd") + getval("ad") + at;   d.c3 = d.c3 + (!strcmp(mix.seq,"tppm"));   d.c3 = d.c3 + ((!strcmp(mix.seq,"tppm")) && (mix.t.a > 0.0));   d.t3 = 2.0*nYxy8*(1.0/srate - 2.0*pwYxy8) + 1.0/srate - getval("pwX180");   d.c4 = d.c4 + (!strcmp(mix.seq,"spinal"));   d.c4 = d.c4 + ((!strcmp(mix.seq,"spinal")) && (mix.s.a > 0.0));   d.t4 = 2.0*nYxy8*(1.0/srate - 2.0*pwYxy8) + 1.0/srate - getval("pwX180");   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(phX90,4,table1);   settable(ph1Yxy8,8,table2);   settable(ph2Yxy8,4,table3);   settable(phX180,4,table4);   settable(phRec,4,table5);   if (counter < 0) tsadd(phRec,2,4);   setreceiver(phRec);// Begin Sequence   txphase(phX90); decphase(zero);   obspwrf(getval("aX90"));    obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// X Single Pulse  rgpulse(getval("pwX90"),phX90,0.0,0.0);// xy8Y Period One  obspwrf(getval("aX180"));  txphase(phX180);   if (counter >= 0) {      _dseqon(mix);      delay(pwYxy8/2.0);      dec2pwrf(aYxy8);      sub(v1,v1,v1);      if (counter >= 1) {         if (counter > 1) loop(v8,v9);	    getelem(ph1Yxy8,v1,v4);	    incr(v1);	    getelem(ph2Yxy8,ct,v2);	    add(v4,v2,v2);	    dec2phase(v2);	    delay(0.5/srate - pwYxy8);	    if (onYxy8 == 2)               dec2rgpulse(pwYxy8,v2,0.0,0.0);            else               delay(pwYxy8);	 if (counter > 1) endloop(v9);      }// X Refocussing Pulse      delay(0.5/srate - pwYxy8/2.0 - getval("pwX180")/2.0);      rgpulse(getval("pwX180"),phX180,0.0,0.0);      dec2pwrf(aYxy8);      delay(0.5/srate - pwYxy8/2.0 - getval("pwX180")/2.0);// xy8Y Period Two      if (counter >= 1) {         if (counter > 1) loop(v8,v9);	    if (onYxy8 == 2)               dec2rgpulse(pwYxy8,v2,0.0,0.0);            else               delay(pwYxy8);            getelem(ph1Yxy8,v1,v4);	    incr(v1);	    getelem(ph2Yxy8,ct,v2);	    add(v4,v2,v2);	    dec2phase(v2);	    delay(0.5/srate - pwYxy8);	 if (counter > 1) endloop(v9);      }      delay(pwYxy8/2.0);      _dseqoff(mix);   }// Begin Acquisition   _dseqon(dec);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........    endif(vseg_ctr);    setacqvar(vacquire);           // Turn on acquire when vacquire is zero    if (ticks) {      xgate(ticks);      grad_advance(gpropdelay);      delay(4e-6);    }    if(ir[0] == 'y') {  /* IR for all slices prior to data acquisition */      obspower(ir_rf.powerCoarse);      obspwrf(ir_rf.powerFine);      delay(4e-6);      msloop(seqcon[1],ns,vms_slices,vms_ctr);	obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0,0,ssi_grad.amp,NOWAIT);   	delay(ssi_grad.rfDelayFront);	shapedpulselist(shapelistIR,ssi_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);	delay(ssi_grad.rfDelayBack);	delay(iti_delay);      endmsloop(seqcon[1],vms_ctr);      delay(ti_delay);    }    msloop(seqcon[1],ns,vms_slices,vms_ctr);      /* Prepulse options ***********************************/      if (sat[0]  == 'y') satbands();      if (fsat[0] == 'y') fatsat();      if (mt[0]   == 'y') mtc();      /* 90 degree pulse ************************************/               rotate();      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(shapelist90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);      delay(ss_grad.rfDelayBack);      /* Read dephase and Slice refocus *********************/      obl_shapedgradient(ssr_grad.name,ssr_grad.duration,ror_grad.amp,0.0,-ssr_grad.amp,WAIT);      /* First half-TE delay ********************************/      obspower(p2_rf.powerCoarse);      obspwrf(p2_rf.powerFine);      delay(te1_delay);	      peloop(seqcon[2],etl,vetl,vetl_ctr);        mult(vseg_ctr,vetl,vpe_ctr);        add(vpe_ctr,vetl_ctr,vpe_ctr);        getelem(t1,vpe_ctr,vpe_mult);        /* 180 degree pulse *******************************/        /* Note, ss2_grad.amp is max gradient for butterfly shape; flat top = _.ssamp */         obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);       	delay(ss2_grad.rfDelayFront);         shapedpulselist(shapelist180,ss2_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr);        delay(ss2_grad.rfDelayBack);           /* Phase-encode gradient ******************************/        pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,-pe_grad.increment,vpe_mult,WAIT);        /* Second half-TE period ******************************/	delay(te2_delay);	         /* Readout gradient ************************************/        obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);        delay(ro_grad.atDelayFront);        /* Acquire data ****************************************/        startacq(alfa);        acquire(np,1.0/sw);        endacq();        delay(ro_grad.atDelayBack);        /* Rewinding phase-encode gradient ********************/        /* Phase encode, refocus, and dephase gradient ******************/        pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,pe_grad.increment,vpe_mult,WAIT);        /* Second half-TE delay *******************************/        delay(te3_delay);      endpeloop(seqcon[2],vetl_ctr);      /* Relaxation delay ***********************************/      if (!trtype)        delay(tr_delay);    endmsloop(seqcon[1],vms_ctr);    if (trtype)      delay(ns*tr_delay);  endloop(vseg_ctr);  /* Inter-image delay **********************************/  sub(ntrt,ct,vtrimage);  decr(vtrimage);  ifzero(vtrimage);    delay(trimage);  endif(vtrimage);}

pulsesequence() {// Define Variables and Objects and Get Parameter Values   CP hx = getcp("HX",0.0,0.0,0,1);    strncpy(hx.fr,"dec",3);   strncpy(hx.to,"obs",3);   putCmd("frHX='dec'/n");    putCmd("toHX='obs'/n");   DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");    strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pw1Hhytrap") + getval("pw2Hhytrap") + getval("tHX");    d.dutyoff = d1 + 4.0e-6 + getval("t1HYtrap") + getval("t2HYtrap");   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(ph1Hhytrap,4,table1);   settable(phYhytrap,4,table2);   settable(ph2Hhytrap,4,table3);   settable(phXhx,4,table4);   settable(phHhx,4,table5);   settable(phRec,4,table6);   setreceiver(phRec);// Begin Sequence   txphase(phXhx); decphase(ph1Hhytrap); dec2phase(phYhytrap);   obspwrf(getval("aXhx")); decpwrf(getval("aHhytrap")); dec2pwrf(getval("aYhytrap"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// TRAPDOR on H with Y Modulation   decrgpulse(getval("pw1Hhytrap"),ph1Hhytrap,0.0,0.0);   decphase(ph2Hhytrap);   decunblank();   dec2on();   delay(getval("t1HYtrap"));   dec2off();   decrgpulse(getval("pw2Hhytrap"),ph2Hhytrap,0.0,0.0);   decphase(phHhx);   decunblank();   decphase(phHhx);   decpwrf(getval("aHhx"));   delay(getval("t2HYtrap"));// H to X Cross Polarization    _cp_(hx,phHhx,phXhx);// Begin Acquisition   _dseqon(dec);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pw1Xmqmas") + nXfam2*(pw1Xfam2 + pw2Xfam2 + pw3Xfam2 +pw4Xfam2) +               getval("pwXechsel");   d.dutyoff = d1 + 4.0e-6;   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = d2_ + tXechselinit + getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = d2_ + tXechselinit + getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   if (phase1 == 0) {      settable(phf1Xmqmas,12,table1);      settable(ph1Xfam2,6,table2);      settable(ph2Xfam2,6,table3);      settable(phfXechsel,96,table4);      settable(phRec,48,table5);   }   else {      settable(phf1Xmqmas,6,table6);      settable(ph1Xfam2,6,table7);      settable(ph2Xfam2,6,table8);      settable(phfXechsel,48,table9);      settable(phRec,24,table10);      if (phase1 == 2) {         tsadd(phf1Xmqmas,30,360);      }   }    setreceiver(phRec);   obsstepsize(1.0);// Begin Sequence   xmtrphase(phf1Xmqmas); decphase(zero);   obspower(getval("tpwr"));   obspwrf(getval("aXmqmas"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H Decoupler on Before MQMAS   _dseqon(dec);// Two-Pulse MQMAS with DFS Conversion    rgpulse(getval("pw1Xmqmas"),zero,0.0,0.0);   xmtrphase(zero); txphase(ph1Xfam2);   obspwrf(aXfam2);    delay(d20);// X FAM2 Pulse   loop(v4,v5);      xmtron();      delay(pw1Xfam2);      xmtroff();      txphase(ph2Xfam2);      delay(pw2Xfam2);      xmtron();      delay(pw3Xfam2);      xmtroff();      txphase(ph2Xfam2);      delay(pw4Xfam2);   endloop(v5);// Tau Delay and Second Selective Echo Pulse   xmtrphase(phfXechsel);   obsblank();   obspower(getval("dbXechsel"));   obspwrf(getval("aXechsel"));   delay(3.0e-6);   obsunblank();   delay(d21 + tXechsel);   rgpulse(getval("pwXechsel"),zero,0.0,0.0);   delay(d22); // Begin Acquisition    obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........      obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT);      delay(ss_grad.rfDelayFront);      shapedpulselist(shape90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);      delay(ss_grad.rfDelayBack);      /* Slice refocus gradient *****************************/      if (sepRefocus)         obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT);      else        /* Include phase encode and readout dephase gradient if refocus gradients not separated */        pe_shapedgradient(pe_grad.name,pe_grad.duration,ror_grad.amp,0,-ssr_grad.amp*refsign,pe_grad.increment,vpe_mult,WAIT);      if (diff[0] == 'y') {        delay(diffusion.d1);        diffusion_dephase(&diffusion,dro,dpe,dsl);        delay(diffusion.d2);      }       else         delay(te_delay1);      /* Refocusing RF pulse ********************************/       obspower(p2_rf.powerCoarse);      obspwrf(p2_rf.powerFine);      delay(GRADIENT_RES);      obl_shapedgradient(crush_grad.name,crush_grad.duration,crushsign*gcrushr,gcrushp,gcrushs,WAIT);      obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);      delay(ss2_grad.rfDelayFront);      shapedpulselist(shape180,ss2_grad.rfDuration,vph180,rof2,rof2,seqcon[1],vms_ctr);      delay(ss2_grad.rfDelayBack);      obl_shapedgradient(crush_grad.name,crush_grad.duration,crushsign*gcrushr,gcrushp,gcrushs,WAIT);      if (diff[0] == 'y') {        delay(diffusion.d3);        diffusion_rephase(&diffusion,dro,dpe,dsl);        delay(diffusion.d4);      }       else         delay(te_delay2);      /* Readout dephase, phase encode & readout gradients **/      roff = -poffset(pro,ro_grad.roamp);  // incase inverted navigator is acquired      if (slprofile[0] == 'y') {        /* Readout gradient only if refocus gradients not separated */        if (sepRefocus)          obl_shapedgradient(ror_grad.name,ror_grad.duration,0,0,-ror_grad.amp,WAIT);        obl_shapedgradient(ro_grad.name,ro_grad.duration,0,0,ro_grad.amp,NOWAIT);      } else {        /* Readout gradient only if refocus gradients not separated */        if (sepRefocus)           pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0,-pe_grad.increment,vpe_mult,WAIT);        obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT);      }      /* Acquisition ****************************************/      delay(ro_grad.atDelayFront-alfa);      startacq(alfa);      acquire(np,1.0/sw);      delay(ro_grad.atDelayBack);      endacq();      /* Rewind Phase encoding ******************************/      pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,pe_grad.increment,vpe_mult,WAIT);      /* Navigator acquisition ******************************/      if (navigator[0] == 'y') {        delay(te_delay3);        obl_shapedgradient(crush_grad.name,crush_grad.duration,-crushsign*gcrushr,0,-gcrushs,WAIT);        obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);        delay(ss2_grad.rfDelayFront);        shapedpulselist(shape180,ss2_grad.rfDuration,vph180,rof2,rof2,seqcon[1],vms_ctr);        delay(ss2_grad.rfDelayBack);        obl_shapedgradient(crush_grad.name,crush_grad.duration,-crushsign*gcrushr,0,-gcrushs,WAIT);        delay(te_delay4);        obl_shapedgradient(ro_grad.name,ro_grad.duration,navsign*ro_grad.amp,0,0,NOWAIT);        delay(ro_grad.atDelayFront-alfa);        startacq(alfa);        acquire(np,1.0/sw);        delay(ro_grad.atDelayBack);        endacq();      }      if (spoilflag[0] == 'y') {        obl_shapedgradient(spoil_grad.name,spoil_grad.duration,navsign*spoil_grad.amp,0,spoil_grad.amp,WAIT);      }    endmsloop(seqcon[1],vms_ctr);  endpeloop(seqcon[2],vpe_ctr);  /* Inter-image delay **********************************/  sub(ntrt,ct,vtrimage);  decr(vtrimage);  ifzero(vtrimage);    delay(trimage);  endif(vtrimage);  /* Duty cycle *****************************************/  calc_grad_duty(tr);}

pulsesequence(){   double freq,fstart,fend;   double attn,attnd,attnd2,attnd3,attnd4,tattn;/* 5 channels supported */   double tunesw,tuneswd,tuneswd2,tuneswd3,tuneswd4,tsw;   double gain,gaind,gaind2,gaind3,gaind4,tgain;   int chan;   double offset_sec;   int np2;   int nfv,index;   nfv = (int) getval("nf");   np2 = np / 2;   status(A);   /* getRealSetDefault reduces logic - not in Inova */   getRealSetDefault(CURRENT,"tunesw",&tunesw,10000000.0);   getRealSetDefault(CURRENT,"tuneswd",&tuneswd,tunesw);   getRealSetDefault(CURRENT,"tuneswd2",&tuneswd2,tunesw);   getRealSetDefault(CURRENT,"tuneswd3",&tuneswd3,tunesw);   getRealSetDefault(CURRENT,"tuneswd4",&tuneswd4,tunesw);   getRealSetDefault(CURRENT,"tupwr",&attn,10.0);   getRealSetDefault(CURRENT,"tupwrd",&attnd,10.0);   getRealSetDefault(CURRENT,"tupwrd2",&attnd2,10.0);   getRealSetDefault(CURRENT,"tupwrd3",&attnd3,10.0);   getRealSetDefault(CURRENT,"tupwrd4",&attnd4,10.0);   getRealSetDefault(CURRENT,"gain",&gain,10.0);   getRealSetDefault(CURRENT,"gaind",&gaind,gain);   getRealSetDefault(CURRENT,"gaind2",&gaind2,gain);   getRealSetDefault(CURRENT,"gaind3",&gaind3,gain);   getRealSetDefault(CURRENT,"gaind4",&gaind4,gain);   offset_sec = (0.5 / sw);   setacqmode(WACQ|NZ);    for (index = 0; index < nf; index++)   {     switch(index) {      case 0:  chan = OBSch; freq = sfrq; tattn = attn;                     tgain = gain; tsw = tunesw; break;      case 1:  chan = DECch; freq = dfrq; tattn = attnd;                     tgain = gaind; tsw = tuneswd; break;      case 2:  chan = DEC2ch; freq = dfrq2; tattn = attnd2;                     tgain = gaind2; tsw = tuneswd2; break;      case 3:  chan = DEC3ch; freq = dfrq3; tattn = attnd3;                     tgain = gaind3; tsw = tuneswd3; break;      case 4:  chan = DEC4ch; freq = dfrq4; tattn = attnd4;                     tgain = gaind4; tsw = tuneswd4; break;      default:  exit(-1);     }     fstart = freq - (tsw/2) * 1e-6;     fend = freq + (tsw/2) * 1.0e-6;     //printf("channel = %d  frequency = %f/n",chan,freq);     //printf("channel = %d  frequency span = %f/n",chan, tsw);     //printf("start=%f  stop = %f/n",fstart,fend);     //printf("gain = %f power = %f/n",tgain,tattn);     hsdelay(d1);     set4Tune(chan,tgain);      assign(zero,oph);     genPower(tattn,chan);     delay(0.001);     startacq(alfa);     SweepNOffsetAcquire(fstart, fend, np2, chan, offset_sec);      endacq();     delay(0.001);   }}

//.........这里部分代码省略.........   settablenumber(10);   setvvarnumber(30);//Define Variables and Objects and Get Parameter Values   CP hx = getcp("HX",0.0,0.0,0,1);   strncpy(hx.fr,"dec",3);   strncpy(hx.to,"obs",3);   putCmd("frHX='dec'/n");   putCmd("toHX='obs'/n");   WMPA cpmg = getcpmg("cpmgX");   strncpy(cpmg.ch,"obs",3);   putCmd("chXcpmg='obs'/n");   double aXecho = getval("aXecho");  // define the echoX group in the sequence   double t1Xechoinit = getval("t1Xecho");   double pwXecho = getval("pwXecho");   double t2Xechoinit = getval("t2Xecho");   double t1Xecho  = t1Xechoinit - pwXecho/2.0 - getval("pwX90")/2.0;   if (t1Xecho < 0.0) t1Xecho = 0.0;   double t2Xecho  = t2Xechoinit - pwXecho/2.0 - cpmg.r1 - cpmg.t2 - getval("ad");   if (t2Xecho < 0.0) t2Xecho = 0.0;   DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");    strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");//--------------------------------------// Copy Current Parameters to Processed//-------------------------------------   putCmd("groupcopy('current','processed','acquisition')");// Dutycycle Protection   DUTY d = init_dutycycle();   d.dutyon = getval("pwH90") + getval("tHX") + pwXecho + (cpmg.cycles - 1)*cpmg.pw;    d.dutyoff = d1 + 4.0e-6;   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = t1Xecho + t2Xecho + getval("rd") + getval("ad") +           at - (cpmg.cycles - 1)*cpmg.pw;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = t1Xecho + t2Xecho + getval("rd") + getval("ad") +           at - (cpmg.cycles - 1)*cpmg.pw;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(phH90,64,table1);   settable(phXhx,64,table2);   settable(phHhx,64,table3);   settable(phXecho,64,table4);   settable(phXcpmg,64,table5);   settable(phRec,64,table6);   setreceiver(phRec);// Begin Sequence   txphase(phXhx); decphase(phH90);   obspwrf(getval("aXhx")); decpwrf(getval("aH90"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H to X Cross Polarization   decrgpulse(getval("pwH90"),phH90,0.0,0.0);   decphase(phHhx);   _cp_(hx,phHhx,phXhx);// H Decoupling On   decphase(zero);   _dseqon(dec);// X Hahn Echo   txphase(phXecho);   obspwrf(aXecho);   delay(t1Xecho);   rgpulse(pwXecho,phXecho,0.0,0.0);   delay(t2Xecho);// Apply CPMG Cycles   obsblank(); _blank34();   delay(cpmg.r1);   startacq(getval("ad"));   _cpmg(cpmg,phXcpmg);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

pulsesequence() {// Define Variables and Objects and Get Parameter Values   CP hy = getcp("HY",0.0,0.0,0,1);   strncpy(hy.fr,"dec",3);   strncpy(hy.to,"dec2",4);   putCmd("frHY='dec'/n");   putCmd("toHY='dec2'/n");   GP inept = getinept("ineptYX");   strncpy(inept.ch1,"dec2",4);   strncpy(inept.ch2,"obs",3);   putCmd("ch1YXinept='dec2'/n");   putCmd("ch2YXinept='obs'/n");      DSEQ dec = getdseq("H");   strncpy(dec.t.ch,"dec",3);   putCmd("chHtppm='dec'/n");    strncpy(dec.s.ch,"dec",3);   putCmd("chHspinal='dec'/n");   DSEQ mix = getdseq("Hmix");   strncpy(mix.t.ch,"dec",3);   putCmd("chHmixtppm='dec'/n");    strncpy(mix.s.ch,"dec",3);   putCmd("chHmixspinal='dec'/n");// Dutycycle Protection   double simpw1 = inept.pw1;   if (inept.pw2 > inept.pw1) simpw1 = inept.pw2;   double simpw2 = inept.pw3;   if (inept.pw4 > inept.pw3) simpw2 = inept.pw4;   DUTY d = init_dutycycle();   d.dutyon = getval("pwH90") + getval("tHY") + 2.0*simpw1 + 2.0*simpw2;   d.dutyoff = d1 + 4.0e-6;   d.c1 = d.c1 + (!strcmp(dec.seq,"tppm"));   d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0));   d.t1 = inept.t1 + inept.t2 + inept.t3 + inept.t4 +           getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(dec.seq,"spinal"));   d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0));   d.t2 = inept.t1 + inept.t2 + inept.t3 + inept.t4 +           getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);// Set Phase Tables   settable(phH90,16,table1);   settable(phHhy,4,table2);   settable(phYhy,4,table3);   settable(ph1Yyxinept,4,table4);   settable(ph1Xyxinept,4,table5);   settable(ph2Yyxinept,4,table6);   settable(ph2Xyxinept,16,table7);   settable(ph3Yyxinept,8,table8);   settable(ph3Xyxinept,4,table9);   settable(phRec,8,table10);   setreceiver(phRec);// Begin Sequence   txphase(ph1Xyxinept); decphase(phH90); dec2phase(phYhy);   obspwrf(getval("aXyxinept")); decpwrf(getval("aH90")); dec2pwrf(getval("aYhy"));   obsunblank(); decunblank(); _unblank34();   delay(d1);   sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);// H to Y Cross Polarization   decrgpulse(getval("pwH90"),phH90,0.0,0.0);   decphase(phHhy);   _cp_(hy,phHhy,phYhy);   decphase(zero);// INEPT Transfer from Y to X   _dseqon(mix);   _ineptref(inept,ph1Yyxinept,ph1Xyxinept,ph2Yyxinept,ph2Xyxinept,ph3Yyxinept,ph3Xyxinept);   _dseqoff(mix);// Begin Acquisition   _dseqon(dec);   obsblank(); _blank34();   delay(getval("rd"));   startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);   obsunblank(); decunblank(); _unblank34();}

//.........这里部分代码省略.........   d.dutyoff = d1 + 4.0e-6;   if (!strcmp(homo1.dm,"y"))     d.dutyon += t1H_echo + t2H_echo;   else     d.dutyoff += t1H_echo + t2H_echo;   d.c1 = d.c1 + (!strcmp(Xseq,"tppm"));   d.c1 = d.c1 + ((!strcmp(Xseq,"tppm")) && (dec.t.a > 0.0));   d.t1 = getval("rd") + getval("ad") + at;   d.c2 = d.c2 + (!strcmp(Xseq,"spinal"));   d.c2 = d.c2 + ((!strcmp(Xseq,"spinal")) && (dec.s.a > 0.0));   d.t2 = getval("rd") + getval("ad") + at;   d = update_dutycycle(d);   abort_dutycycle(d,10.0);//------------------------// Set Phase Tables//-----------------------   settable(phH90,4,table1);       settable(phHecho,8,table2);   settable(phRec,4,table3);   setreceiver(phRec);//=======================    // Begin Sequence//=======================   txphase(phH90); decphase(zero);   obspwrf(getval("aH90"));    obsunblank(); decunblank(); _unblank34();   delay(d1);     sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6);//------------------------  // H Direct Polarization //------------------------     rgpulse(getval("pwH90"),phH90,0.0,0.0);   obsunblank(); decunblank(); _unblank34();// -----------------------------// H Hahn Echo// -----------------------------   if (!strcmp(homo1.dm,"y")) {      delay (t1H_left);      if (getval("pwHshort1") > 0.0 ) {         obspwrf(getval("aHhdec1"));         rgpulse(getval("pwHshort1"),three,0.0,0.0);           obsunblank();      }      if (!strcmp(homo1.dm,"y")) _mpseqon(homo1.mps,zero);      delay(t1H_echo);      if (!strcmp(homo1.dm,"y")) _mpseqoff(homo1.mps);      if (getval("pwHshort1") > 0.0 ) {         obspwrf(getval("aHhdec1")); txphase(one);         rgpulse(getval("pwHshort1"),one,0.0,0.0);           obsunblank();      }   }   else delay(t1Hecho);   txphase(phHecho);   obspwrf(getval("aHecho"));   rgpulse(getval("pwHecho"),phHecho,0.0,0.0);   obsunblank();   if (!strcmp(homo1.dm,"y")) {      if (getval("pwHshort1") > 0.0 ) {         obspwrf(getval("aHhdec1"));         rgpulse(getval("pwHshort1"),three,0.0,0.0);           obsunblank();      }      if (!strcmp(homo1.dm,"y")) _mpseqon(homo1.mps,zero);      delay(t2H_echo);      if (!strcmp(homo1.dm,"y")) _mpseqoff(homo1.mps);      if(getval("pwHshort1")>0 )  {         obspwrf(getval("aHhdec1"));         rgpulse(getval("pwHshort1"),one,0.0,0.0);           obsunblank();      }      delay(t2H_left);   }   else delay(t2Hecho);//====================// Begin Acquisition //====================   _dseqon(dec);       obsblank(); decblank(); _blank34();   delay(getval("rd"));     startacq(getval("ad"));   acquire(np, 1/sw);   endacq();   _dseqoff(dec);    obsunblank(); decunblank(); _unblank34();}