pulsesequence() { char Cdseq[MAXSTR], refoc[MAXSTR], sspul[MAXSTR]; int mult = (0.5 + getval("mult")); double rg1 = 2.0e-6, j1xh = getval("j1xh"), gt0 = getval("gt0"), gzlvl0 = getval("gzlvl0"), pp = getval("pp"), pplvl = getval("pplvl"), compH = getval("compH"), Cdpwr = getval("Cdpwr"), Cdres = getval("Cdres"), tau1 = 0.002, tau2 = 0.002, Cdmf = getval("Cdmf"); shape hdx; /* Get new variables from parameter table */ getstr("Cdseq", Cdseq); getstr("refoc", refoc); getstr("sspul", sspul); if (j1xh < 1.0) j1xh = 150.0; hdx = pboxHT_F1i("gaus180", pp*compH, pplvl); /* HADAMARD stuff */ if (getval("htcal1") > 0.5) /* Optional fine power calibration */ hdx.pwr = getval("htpwr1"); if(j1xh > 0.0) tau1 = 0.25/j1xh; tau2 = tau1; if (mult > 2) tau2=tau1/2.5; else if ((mult == 0) || (mult == 2)) tau2=tau1/2.0; dbl(ct, v1); /* v1 = 02 */ add(two,v1,oph); mod4(oph,oph); /* oph = 02 */ /* Calculate delays */ if (dm[0] == 'y') { abort_message("decoupler must be set as dm=nny\n"); } if(refoc[A]=='n' && dm[C]=='y') { abort_message("with refoc=n decoupler must be set as dm=nnn\n"); } /* Relaxation delay */ status(A); delay(0.05); zgradpulse(gzlvl0,gt0); if (sspul[0] == 'y') { obspower(tpwr); decpower(pplvl); simpulse(pw, pp, zero, zero, rg1, rg1); /* destroy H and C magnetization */ zgradpulse(gzlvl0,gt0); } delay(d1); status(B); obspower(Cdpwr); obsunblank(); xmtron(); obsprgon(Cdseq, 1.0/Cdmf, Cdres); pbox_decpulse(&hdx, zero, rg1, rg1); obsprgoff(); xmtroff(); obsblank(); obspower(tpwr); decpower(pplvl); delay(2.0e-4); decrgpulse(pp, v1, rg1, rg1); delay(tau1 - POWER_DELAY); simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1); txphase(one); decphase(one); delay(tau1); simpulse(pw, pp, one, one, rg1, rg1); if(refoc[A]=='y') { txphase(zero); decphase(zero); delay(tau2); simpulse(2.0*pw, 2.0*pp, zero, zero, rg1, rg1); delay(tau2 - rof2 - POWER_DELAY); decrgpulse(pp, zero, rg1, rof2); } decpower(dpwr); status(C); }
pulsesequence() { /* Internal variable declarations *************************/ int shapelist90,shapelist180,shapelistIR; double nseg; double seqtime,tau1,tau2,tau3, te1_delay,te2_delay,te3_delay, iti_delay, ti_delay, tr_delay; double kzero; double freq90[MAXNSLICE], freq180[MAXNSLICE], freqIR[MAXNSLICE]; /* Real-time variables used in this sequence **************/ int vpe_ctr = v2; // PE loop counter int vpe_mult = v3; // PE multiplier, ranges from -PE/2 to PE/2 int vms_slices = v4; // Number of slices int vms_ctr = v5; // Slice loop counter int vseg = v6; // Number of ETL segments int vseg_ctr = v7; // Segment counter int vetl = v8; // Echo train length int vetl_ctr = v9; // Echo train loop counter int vssc = v10; // Compressed steady-states int vtrimage = v11; // Counts down from nt, trimage delay when 0 int vacquire = v12; // Argument for setacqvar, to skip steady state acquires int vphase180 = v13; // phase of 180 degree refocusing pulse /* Initialize paramaters **********************************/ init_mri(); /* Load external PE table ********************************/ if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); } else { abort_message("petable undefined"); } seqtime = 0.0; espmin = 0.0; kzero = getval("kzero"); /* RF Power & Bandwidth Calculations **********************/ init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2); calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); /* Initialize gradient structures *************************/ init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); init_readout_refocus(&ror_grad,"ror"); init_phase(&pe_grad,"pe",lpe,nv); init_slice(&ss_grad,"ss",thk); /* NOTE assume same band widths for p1 and p2 */ init_slice_butterfly(&ss2_grad,"ss2",thk,gcrush,tcrush); init_slice_refocus(&ssr_grad,"ssr"); /* Gradient calculations **********************************/ calc_readout(&ro_grad,WRITE,"gro","sw","at"); calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror"); calc_phase(&pe_grad,WRITE,"gpe","tpe"); calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice(&ss2_grad,&p1_rf,WRITE,""); calc_slice_refocus(&ssr_grad,&ss_grad,NOWRITE,"gssr"); /* Equalize refocus and PE gradient durations *************/ calc_sim_gradient(&ror_grad,&null_grad,&ssr_grad,0.0,WRITE); /* 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') { init_rf(&ir_rf,pipat,pi,flipir,rof1,rof2); calc_rf(&ir_rf,"tpwri","tpwrif"); init_slice_butterfly(&ssi_grad,"ssi",thk,gcrushir,tcrushir); calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi"); } /* Set up frequency offset pulse shape list ********/ offsetlist(pss,ss_grad.ssamp, 0,freq90, ns,seqcon[1]); offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]); offsetlist(pss,ssi_grad.ssamp,0,freqIR, ns,seqcon[1]); shapelist90 = shapelist(p1pat,ss_grad.rfDuration, freq90, ns,0,seqcon[1]); shapelist180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]); shapelistIR = shapelist(pipat,ssi_grad.rfDuration,freqIR, ns,0,seqcon[1]); /* same slice selection gradient and RF pattern used */ if (ss_grad.rfFraction != 0.5) abort_message("ERROR %s: RF pulse must be symmetric (RF fraction = %.2f)", seqfil,ss_grad.rfFraction); if (ro_grad.echoFraction != 1) abort_message("ERROR %s: Echo Fraction must be 1",seqfil); /* Find sum of all events in each half-echo period ********/ tau1 = ss_grad.rfCenterBack + ssr_grad.duration + ss2_grad.rfCenterFront; tau2 = ss2_grad.rfCenterBack + pe_grad.duration + ro_grad.timeToEcho; tau3 = ro_grad.timeFromEcho + pe_grad.duration + ss2_grad.rfCenterFront; espmin = 2*MAX(MAX(tau1,tau2),tau3); // Minimum echo spacing if (minesp[0] == 'y') { esp = espmin + 8e-6; // ensure at least 4us delays in both TE periods putvalue("esp",esp); } else if (((espmin+8e-6)-esp) > 12.5e-9) { abort_message("ERROR %s: Echo spacing too small, minimum is %.2fms\n",seqfil,(espmin+8e-6)*1000); } te1_delay = esp/2.0 - tau1; // Intra-esp delays te2_delay = esp/2.0 - tau2; te3_delay = esp/2.0 - tau3; te = kzero*esp; // Return effective TE putvalue("te",te); /* Minimum TR **************************************/ /* seqtime is total time per slice */ seqtime = 2*4e-6 + ss_grad.rfCenterFront + etl*esp + ro_grad.timeFromEcho + pe_grad.duration + te3_delay; /* Increase TR if any options are selected****************/ if (sat[0] == 'y') seqtime += ns*satTime; if (fsat[0] == 'y') seqtime += ns*fsatTime; if (mt[0] == 'y') seqtime += ns*mtTime; if (ir[0] == 'y') { /* Inter-IR delay */ if (ns > 1) iti_delay = seqtime - ssi_grad.duration; /* it is probably safe to assume that seqtime is always > the pulse widths */ else iti_delay = 0; /* Inversion Recovery */ timin = ssi_grad.rfCenterBack + ss_grad.rfCenterFront; timin += 8e-6; // from sp1on/off and after 90 pulse power setting timin += seqtime*(ns-1) + iti_delay; if (ti < timin + 4e-6) // ensure at least a 4us delay abort_message("%s: ti too short, minimum is %.2fms",seqfil,timin*1000); /* Delay after the last IR pulse */ ti_delay = ti - timin; /* force all slices to be acquired back-to-back, with a single TR delay at end */ trtype = 1; } else { iti_delay = ti_delay = 0; } trmin = ns*(seqtime + 4e-6); if (ir[0] == 'y') { trmin += (4e-6 + ssi_grad.rfCenterFront + ti); } if (mintr[0] == 'y'){ tr = trmin; putvalue("tr",tr); } if ((trmin-tr) > 12.5e-9) { abort_message("TR too short. Minimum TR = %.2fms\n",trmin*1000); } tr_delay = (tr - trmin)/ns; /* Set number of segments for profile or full image **********/ nseg = prep_profile(profile[0],nv/etl,&pe_grad,&per_grad); /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Calculate total acquisition time */ g_setExpTime(tr*(nt*nseg*getval("arraydim") + ssc) + trimage*getval("arraydim")); /* Return parameters to VnmrJ */ putvalue("rgss",ss_grad.tramp); //90 slice ramp if (ss2_grad.enableButterfly) { //180 slice ramps putvalue("rcrush",ss2_grad.crusher1RampToCrusherDuration); putvalue("rgss2",ss2_grad.crusher1RampToSsDuration); } else { putvalue("rgss2",ss2_grad.tramp); } if (ro_grad.enableButterfly) { putvalue("rgro",ro_grad.crusher1RampToSsDuration); } else { putvalue("rgro",ro_grad.tramp); //RO ramp } putvalue("tror",ror_grad.duration); //ROR duration putvalue("rgror",ror_grad.tramp); //ROR ramp putvalue("gpe",pe_grad.peamp); //PE max amp putvalue("gss",ss_grad.ssamp); putvalue("gro",ro_grad.roamp); /* PULSE SEQUENCE *************************************/ initval(fabs(ssc),vssc); // Compressed steady-state counter assign(one,vacquire); // real-time acquire flag /* Phase cycle: Alternate 180 phase to cancel residual FID */ mod2(ct,vphase180); // 0101 dbl(vphase180,vphase180); // 0202 add(vphase180,one,vphase180); // 1313 Phase difference from 90 add(vphase180,oph,vphase180); obsoffset(resto); delay(4e-6); initval(nseg,vseg); loop(vseg,vseg_ctr); /* TTL scope trigger **********************************/ sp1on(); delay(4e-6); sp1off(); /* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */ if ((ix > 1) && (ssc > 0)) assign(zero,vssc); sub(vseg_ctr,vssc,vseg_ctr); // vpe_ctr counts up from -ssc assign(zero,vssc); ifzero(vseg_ctr); assign(zero,vacquire); // Start acquiring when vseg_ctr reaches zero 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); }
void pulsesequence() { double slpwrR = getval("slpwrR"), slpwR = getval("slpwR"), mixR = getval("mixR"), 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"), selfrq = getval("selfrq"), gzlvl1 = getval("gzlvl1"), gt1 = getval("gt1"), gzlvl2 = getval("gzlvl2"), gt2 = getval("gt2"), zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), gzlvlzq1 = getval("gzlvlzq1"), phincr1 = getval("phincr1"); char selshapeA[MAXSTR],selshapeB[MAXSTR], slpatR[MAXSTR], zqfpat1[MAXSTR], alt_grd[MAXSTR]; //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); getstr("slpatR",slpatR); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat1",zqfpat1); getstr("alt_grd",alt_grd); if (strcmp(slpatR,"cw") && strcmp(slpatR,"troesy") && strcmp(slpatR,"dante")) abort_message("SpinLock pattern %s not supported!.\n", slpatR); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ assign(ct,v17); ifzero(ssctr); assign(v17,v13); elsenz(ssctr); /* purge option does not adjust v13 during steady state */ sub(ssval, ssctr, v13); endif(ssctr); /* Beginning phase cycling */ dbl(v13,v1); /* v1 = 0 2 */ hlv(v13,v13); dbl(v13,v20); /* v20 = 00 22 */ hlv(v13,v13); dbl(v13,v6); /* v6 = 0000 2222 */ hlv(v13,v13); dbl(v13,v7); /* v7 = 00000000 22222222 */ assign(v1,oph); if (getflag("Gzqfilt")) add(v7,oph,oph); /* CYCLOPS */ assign(v13,v14); /* v14 = 8x0 8x1 8x2 8x3 */ if (getflag("Gzqfilt")) hlv(v13,v14); /* v14 = 16x0 16x1 16x2 16x3 */ add(v1,v14,v1); add(v20,v14,v20); add(v6,v14,v6); add(v7,v14,v7); add(oph,v14,oph); /* add(oph,v18,oph); add(oph,v19,oph); */ assign(zero,v9); mod2(ct,v2); /* 01 01 */ hlv(ct,v11); hlv(v11,v11); mod2(v11,v11); dbl(v11,v11); /* 0000 2222 */ add(v11,v2,v11); mod4(v11,v11); /* 0101 2323 first echo in Excitation Sculpting */ hlv(ct,v4); mod2(v4,v4); /* 0011 */ hlv(ct,v12); hlv(v12,v12); hlv(v12,v12); dbl(v12,v12); add(v12,v4,v12); mod4(v12,v12); /* 0011 0011 2233 2233 second echo in Excitation Sculpting */ dbl(v2,v2); /* 0202 */ dbl(v4,v4); /* 0022 */ add(v2,v4,v4); /* 0220 correct oph for Excitation Sculpting */ add(oph,v4,oph); mod4(oph,oph); if (!strcmp(slpatR,"troesy")) assign(v20,v21); else add(v20,one,v21); if (alt_grd[0] == 'y') mod2(ct,v8); /* alternate gradient sign on even scans */ /* The following is for flipback pulse */ if (phincr1 < 0.0) phincr1=360+phincr1; initval(phincr1,v5); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); if (getflag("lkgate_flg")) lk_sample(); /* turn lock sampling on */ obspower(tpwr); delay(5.0e-5); if (getflag("sspul")) steadystate(); delay(d1); if (getflag("lkgate_flg")) lk_hold(); /* turn lock sampling off */ status(B); if (getflag("cpmgflg")) { rgpulse(pw, v1, rof1, 0.0); cpmg(v1, v15); } else rgpulse(pw, v1, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); ifzero(v8); zgradpulse(gzlvlA,gtA); elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v14,rof1,rof1); obspower(tpwr); ifzero(v8); zgradpulse(gzlvlA,gtA); elsenz(v8); zgradpulse(-gzlvlA,gtA); endif(v8); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); ifzero(v8); zgradpulse(gzlvlB,gtB); elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v6,rof1,rof1); obspower(slpwrR); ifzero(v8); zgradpulse(gzlvlB,gtB); elsenz(v8); zgradpulse(-gzlvlB,gtB); endif(v8); delay(gstab); if (selfrq != tof) obsoffset(tof); if (mixR > 0.0) { if (dps_flag) rgpulse(mixR,v21,0.0,0.0); else SpinLock(slpatR,mixR,slpwR,v21); } if (getflag("Gzqfilt")) { obspower(tpwr); rgpulse(pw,v7,rof1,rof1); ifzero(v8); zgradpulse(gzlvl1,gt1); elsenz(v8); zgradpulse(-gzlvl1,gt1); endif(v8); delay(gstab); obspower(zqfpwr1); ifzero(v8); rgradient('z',gzlvlzq1); elsenz(v8); rgradient('z',-gzlvlzq1); endif(v8); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); ifzero(v8); zgradpulse(-gzlvl2,gt2); elsenz(v8); zgradpulse(gzlvl2,gt2); endif(v8); obspower(tpwr); delay(gstab); if (getflag("flipback")) FlipBack(v14,v5); rgpulse(pw,v14,rof1,2.0e-6); } ExcitationSculpting(v11,v12,v8); delay(rof2); status(C); }
void pulsesequence() { char c1d[MAXSTR]; /* option to record only 1D C13 spectrum */ int ncyc; double tau1 = 0.002, /* t1 delay */ post_del = 0.0, pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */ pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */ compC = getval("compC"), compH = getval("compH"), mixpwr = getval("mixpwr"), jCH = getval("jCH"), gt0 = getval("gt0"), gt1 = getval("gt1"), gt2 = getval("gt2"), gzlvl0 = getval("gzlvl0"), gzlvl1 = getval("gzlvl1"), gzlvl2 = getval("gzlvl2"), grec = getval("grec"), phase = getval("phase"); getstr("c1d",c1d); ncyc=1; if(jCH > 0.0) tau1 = 0.25/jCH; dbl(ct, v1); /* v1 = 0 */ mod4(v1,oph); hlv(ct,v2); add(v2,v1,v2); if (phase > 1.5) incr(v1); /* hypercomplex phase increment */ initval(2.0*(double)((int)(d2*getval("sw1")+0.5)%2),v10); add(v1,v10,v1); add(oph,v10,oph); mod4(v1,v1); mod4(v2,v2); mod4(oph,oph); assign(zero,v3); if(FIRST_FID) { HHmix = pbox_mix("HHmix", "DIPSI2", mixpwr, pw*compH, tpwr); if(c1d[A] == 'n') { opx("CHdec"); setwave("WURST2 30k/1.2m"); pbox_par("steps","600"); cpx(pwC*compC, pwClvl); CHdec = getDsh("CHdec"); } } ncyc = (int) (at/HHmix.pw) + 1; post_del = ncyc*HHmix.pw - at; /* BEGIN PULSE SEQUENCE */ status(A); zgradpulse(gzlvl0, gt0); rgpulse(pw, zero, 0.0, 0.0); /* destroy H-1 magnetization*/ zgradpulse(gzlvl0, gt0); delay(1.0e-4); obspower(tpwr); txphase(v1); decphase(zero); dec2phase(zero); presat(); obspower(tpwr); delay(1.0e-5); status(B); if(c1d[A] == 'y') { rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */ delay(d2); rgpulse(pw,two,0.0,0.0); /* 1H pulse excitation */ assign(oph,v3); } else { decunblank(); pbox_decon(&CHdec); rgpulse(pw,v1,0.0,0.0); /* 1H pulse excitation */ txphase(zero); delay(d2); pbox_decoff(); decblank(); decpower(pwClvl); decpwrf(4095.0); delay(tau1 - POWER_DELAY); simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0); txphase(one); decphase(one); dec2phase(one); delay(tau1); simpulse(pw, pwC, one, one, 0.0, 0.0); txphase(zero); decphase(zero); dec2phase(zero); delay(tau1); simpulse(2.0*pw, 2.0*pwC, zero, zero, 0.0, 0.0); delay(tau1); simpulse(0.0, pwC, zero, zero, 0.0, 0.0); } zgradpulse(gzlvl1, gt1); delay(grec); simpulse(0.0, pwC, zero, v3, 0.0, rof2); txphase(v2); obsunblank(); pbox_xmtron(&HHmix); status(C); setactivercvrs("ny"); startacq(alfa); acquire(np,1.0/sw); endacq(); delay(post_del); pbox_xmtroff(); obsblank(); zgradpulse(gzlvl2, gt2); obspower(tpwr); delay(grec); rgpulse(pw,zero,0.0,rof2); /* 1H pulse excitation */ status(D); setactivercvrs("yn"); startacq(alfa); acquire(np,1.0/sw); endacq(); }
pulsesequence() { double gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), mult = getval("mult"), pwx180 = getval("pwx180"), pwxlvl180 = getval("pwxlvl180"), pwx180r = getval("pwx180r"), pwxlvl180r = getval("pwxlvl180r"), tpwr180 = getval("tpwr180"), pw180 = getval("pw180"), hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), gzlvl5 = getval("gzlvl5"), tau, taug; int icosel, phase1 = (int)(getval("phase")+0.5), prgcycle = (int)(getval("prgcycle")+0.5), ZZgsign; char pwx180ad[MAXSTR], pwx180ref[MAXSTR], bipflg[MAXSTR], pw180ad[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",0.5); gzlvlE = syncGradLvl("gtE","gzlvlE",0.5); getstr("pwx180ad", pwx180ad); getstr("pwx180ref", pwx180ref); getstr("pw180ad", pw180ad); getstr("bipflg",bipflg); if (bipflg[0] == 'y') { tpwr180=getval("tnbippwr"); pw180=getval("tnbippw"); getstr("tnbipshp",pw180ad); } if (bipflg[1] == 'y') { pwxlvl180=getval("dnbippwr"); pwx180=getval("dnbippw"); getstr("dnbipshp",pwx180ad); } tau = 1 / (4*(getval("j1xh"))); if (mult > 0.5) taug = 2*tau + getval("tauC"); else taug = gtE + gstab + 2 * GRADIENT_DELAY; ZZgsign=-1; if (mult == 2) ZZgsign=1; 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, 2, ph2); settable(t3, 8, ph3); settable(t4, 16, ph4); settable(t5, 16, ph5); getelem(t1, v17, v1); getelem(t3, v17, v3); getelem(t4, v17, v4); getelem(t2, v17, v2); getelem(t5, v17, oph); assign(zero,v6); add(oph,v18,oph); add(oph,v19,oph); if ((phase1 == 2) || (phase1 == 5)) icosel = -1; initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); /* mod2(id2, v14); dbl(v14,v14); */ add(v2, v14, v2); add(oph, v14, oph); 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,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(pwxlvl180); status(B); if (getflag("nullflg")) { rgpulse(0.5 * pw, zero, rof1, rof1); obspower(tpwr180); delay(tau); simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1); delay(tau+POWER_DELAY+rof1); delay(tau+POWER_DELAY+rof1); simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1); obspower(tpwr); delay(tau); rgpulse(0.5 * pw, zero, rof1, rof1); zgradpulse(hsglvl, hsgt); delay(1e-3); } rgpulse(pw, v6, rof1, rof1); obspower(tpwr180); shaped_pulse(pw180ad,pw180,zero,rof1,rof1); delay(tau+2.0*POWER_DELAY+2.0*rof1); simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof1); delay(tau); obspower(tpwr); rgpulse(pw, v1, rof1, rof1); zgradpulse(hsglvl, 2 * hsgt); decpower(pwxlvl); obspower(tpwr180); delay(1e-3); decrgpulse(pwx, v2, rof1, 2.0e-6); delay(d2 / 2); shaped_pulse(pw180ad,pw180,zero,rof1,rof1); delay(d2 / 2); delay(taug - POWER_DELAY); decpower(pwxlvl180r); decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1); if(mult < 1.5) { obspower(tpwr); if (mult <0.5) delay(2*rof1); else rgpulse(mult*pw,zero,rof1,rof1); } else shaped_pulse(pw180ad,pw180,zero,rof1,rof1); if(mult < 1.5) delay(4*pwx/PI + 4.0e-6 + taug - gtE - gstab - 2 * GRADIENT_DELAY + WFG_START_DELAY + pw180 + WFG_STOP_DELAY - mult*pw); else delay(4*pwx/PI + 4.0e-6 + POWER_DELAY + taug - gtE - gstab - 2 * GRADIENT_DELAY); zgradpulse(gzlvlE, gtE); delay(gstab); decshaped_pulse(pwx180ref, pwx180r, zero, rof1, rof1); decpower(pwxlvl); decrgpulse(pwx, v4, 2.0e-6, rof1); obspower(tpwr); decpower(pwxlvl180); zgradpulse(ZZgsign*0.6 * hsglvl, 1.2 * hsgt); delay(1e-3); rgpulse(pw, v3, rof1, rof1); obspower(tpwr180); shaped_pulse(pw180ad,pw180,zero,rof1,rof1); zgradpulse(gzlvl5,gtE/2.0); delay(tau-gtE/2.0+2.0*POWER_DELAY); simshaped_pulse(pw180ad,pwx180ad,pw180,pwx180,zero,zero,rof1,rof2); zgradpulse(gzlvl5+icosel * 2.0*gzlvlE/EDratio, gtE/2.0); delay(tau-gtE/2.0); decpower(dpwr); status(C); }
// Return value of constant dbl FreshEval_d(std::shared_ptr<Variable> const& diff_variable) const override { return dbl(double(true_value_real_),double(true_value_imag_)); }
pulsesequence() { double gstab = getval("gstab"), gt1 = getval("gt1"), gzlvl1 = getval("gzlvl1"), gt2 = getval("gt2"), gzlvl2 = getval("gzlvl2"), satpwr = getval("satpwr"), satdly = getval("satdly"), del = getval("del"), del2 = getval("del2"), dosyfrq = getval("sfrq"), gzlvlhs = getval("gzlvlhs"), hsgt = getval("hsgt"), Ddelta,dosytimecubed; char convcomp[MAXSTR],satmode[MAXSTR],alt_grd[MAXSTR],lkgate_flg[MAXSTR], sspul[MAXSTR]; getstr("convcomp",convcomp); getstr("satmode",satmode); getstr("alt_grd",alt_grd); getstr("lkgate_flg",lkgate_flg); getstr("sspul",sspul); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gt1 = syncGradTime("gt1","gzlvl1",1.0); gzlvl1 = syncGradLvl("gt1","gzlvl1",1.0); gt2 = syncGradTime("gt2","gzlvl2",1.0); gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0); /* CHECK CONDITIONS */ if (p1 == 0.0) p1 = 2*pw; /* STEADY-STATE PHASECYCLING This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); dbl(ct, v1); hlv(ct, v3); elsenz(ssctr); sub(ssval, ssctr, v7); /* v7 = 0,...,ss-1 */ dbl(v7, v1); hlv(v7, v3); endif(ssctr); /* PHASECYCLE CALCULATION */ hlv(v3, v2); mod2(v3, v3); add(v3, v1, v1); assign(v1, oph); dbl(v2, v4); add(v4, oph, oph); add(v2, v3, v2); Ddelta=gt1; /*the diffusion-encoding pulse width is gt1*/ if (convcomp[A]=='y') dosytimecubed=Ddelta*Ddelta*(del - (4.0*Ddelta/3.0)); else dosytimecubed=Ddelta*Ddelta*(del - (Ddelta/3.0)); putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq); mod2(ct,v10); /* gradients change sign at odd transients */ /* BEGIN ACTUAL SEQUENCE */ status(A); if (sspul[0]=='y') { zgradpulse(gzlvlhs,hsgt); rgpulse(pw,zero,rof1,rof1); zgradpulse(gzlvlhs,hsgt); } if (satmode[0] == 'y') { if (d1 - satdly > 0) delay(d1 - satdly); obspower(satpwr); rgpulse(satdly,zero,rof1,rof1); obspower(tpwr); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); if (del>0.0) { if (convcomp[A]=='y') { if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-gzlvl2,2.0*gt2); elsenz(v10); zgradpulse(gzlvl2,2.0*gt2); endif(v10); } else zgradpulse(-gzlvl2,2.0*gt2); delay(gstab); rgpulse(pw, v1, rof1, rof1); delay(d2/2.0); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay(((del+del2)/4)-gt1); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1); elsenz(v10); zgradpulse(gzlvl1,gt1); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1); elsenz(v10); zgradpulse(gzlvl1,gt1); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay(((del-del2)/4)-gt1); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl2,gt2); elsenz(v10); zgradpulse(-1.0*gzlvl2,gt2); endif(v10); } else zgradpulse(gzlvl2,gt2); delay(gstab); rgpulse(p1, v2, rof1, rof1); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl2,gt2); elsenz(v10); zgradpulse(-1.0*gzlvl2,gt2); endif(v10); } else zgradpulse(gzlvl2,gt2); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse(((del-del2)/4)-gt1-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay(((del-del2)/4)-gt1); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1); elsenz(v10); zgradpulse(gzlvl1,gt1); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1); elsenz(v10); zgradpulse(gzlvl1,gt1); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse(((del+del2)/4)-gt1-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay(((del+del2)/4)-gt1); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); delay(gstab); delay(d2/2.0); if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */ } else { rgpulse(pw, v1, rof1, rof1); if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */ delay(d2/2.0); delay(gstab); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay((del-p1-2.0*rof1-gt1)/2.0); rgpulse(p1, v2, rof1, rof1); if (satmode[1] == 'y') { obspower(satpwr); rgpulse((del-p1-2.0*rof1-gt1)/2.0-2.0*rof1,zero,rof1,rof1); obspower(tpwr); } else delay((del-p1-2.0*rof1-gt1)/2.0); if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1); endif(v10); } else zgradpulse(gzlvl1,gt1); delay(gstab); delay(d2/2.0); if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */ } } else rgpulse(pw,oph,rof1,rof2); status(C); }
pulsesequence() { /* Internal variable declarations *************************/ double freq90[MAXNSLICE],freq180[MAXNSLICE],freqIR[MAXNSLICE]; int shape90=0, shape180=0, shapeIR=0; double te_delay1, te_delay2, tr_delay, ti_delay = 0; double del1=0, del2=0, del3=0, del4=0; double tau1=0, tau2=0, difftime=0, tetime=0; int table=0; /* Diffusion parameters */ #define MAXDIR 1024 /* Will anybody do more than 1024 directions or b-values? */ double roarr[MAXDIR], pearr[MAXDIR], slarr[MAXDIR]; int nbval, /* Total number of bvalues*directions */ nbro, nbpe, nbsl, i; double bro[MAXDIR], bpe[MAXDIR], bsl[MAXDIR], /* b-values along RO, PE, SL */ brs[MAXDIR], brp[MAXDIR], bsp[MAXDIR], /* and the cross-terms */ btrace[MAXDIR], /* and the trace */ max_bval=0, dcrush, dgss2, /* "delta" for crusher and gss2 gradients */ Dro, Dcrush, Dgss2; /* "DELTA" for readout, crusher and gss2 gradients */ /* Real-time variables ************************************/ int vpe_steps = v1; int vpe_ctr = v2; int vms_slices = v3; int vms_ctr = v4; int vpe_offset = v5; int vpe_index = v6; int vph180 = v7; // Phase of 180 pulse int vph2 = v8; // alternate phase of 180 on odd transients /* Initialize paramaters *********************************/ init_mri(); /* Check for external PE table ***************************/ if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); table = 1; } if ((diff[0] == 'y') && (gcrush < 4)) warn_message("Advisory: set gcrush to higher value to avoid image artifacts"); /* Initialize gradient structures *************************/ init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); init_rf(&p2_rf,p2pat,p2,flip2,rof2,rof2); init_slice(&ss_grad,"ss",thk); init_slice_butterfly(&ss2_grad,"ss2",thk*1.1,gcrush,tcrush); init_slice_refocus(&ssr_grad,"ssr"); init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); init_readout_refocus(&ror_grad,"ror"); init_phase(&pe_grad,"pe",lpe,nv); /* RF Calculations ****************************************/ calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); if (p2_rf.header.rfFraction != 0.5) abort_message("RF pulse for refocusing (%s) must be symmetric",p2pat); /* Gradient calculations **********************************/ calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2"); calc_slice_refocus(&ssr_grad, &ss_grad, NOWRITE,"gssr"); calc_readout(&ro_grad, WRITE, "gro","sw","at"); ro_grad.m0ref *= grof; calc_readout_refocus(&ror_grad, &ro_grad, NOWRITE, "gror"); calc_phase(&pe_grad, NOWRITE, "gpe","tpe"); /* Equalize refocus and PE gradient durations *************/ calc_sim_gradient(&ror_grad, &pe_grad, &ssr_grad,0,WRITE); /* Set up diffusion gradient */ if (diff[0] == 'y') { init_generic(&diff_grad,"diff",gdiff,tdelta); calc_generic(&diff_grad,NOWRITE,"",""); /* adjust duration, so tdelta is from start ramp up to start ramp down */ if (ix == 1) diff_grad.duration += diff_grad.tramp; calc_generic(&diff_grad,WRITE,"",""); } /* Min TE *************************************************/ tau1 = ss_grad.rfCenterBack + pe_grad.duration + 4e-6 + ss2_grad.rfCenterFront; tau2 = ss2_grad.rfCenterBack + ror_grad.duration + ro_grad.timeToEcho + alfa; temin = 2*(MAX(tau1,tau2) + 2*4e-6); /* have at least 4us between gradient events */ /* Calculate te_delays with the current TE, then later see how diffusion fits */ if ((minte[0] == 'y') || (te < temin)) { te_delay1 = temin/2 - tau1; te_delay2 = temin/2 - tau2; } else { te_delay1 = te/2 - tau1; te_delay2 = te/2 - tau2; } if (diff[0] =='y') { /* Is tDELTA long enough for RF refocusing gradient? */ if (tDELTA < diff_grad.duration + ss2_grad.duration) abort_message("DELTA too short, increase to %.2fms", (diff_grad.duration + ss2_grad.duration)*1000+0.005); /* Is tDELTA too long for TE dead time? */ difftime = tDELTA + diff_grad.duration; // tDELTA + front & back half diff_grad tetime = ss2_grad.duration + te_delay1 + te_delay2; if (difftime > tetime) { temin += (difftime - tetime); } } /* We now know the minimum TE incl. diffusion */ if (minte[0] == 'y') { te = temin; putvalue("te",ceil(te*1e6)*1e-6); /* round up to nearest us */ } if (te < temin) { if (diff[0] == 'n') { abort_message("TE too short. Minimum TE = %.2fms\n",temin*1000); } else { abort_message("TE too short, increase to %.2fms or reduce DELTA to %.2fms", temin*1000,(tetime-diff_grad.duration)*1000); } } te_delay1 = te/2 - tau1; te_delay2 = te/2 - tau2; /* Set up delays around diffusion gradients */ /* RF1 - del1 - diff - del2 - RF2 - del3 - diff - del4 - ACQ */ if (diff[0] == 'y') { del1 = (tetime - difftime)/2; del4 = del1; del2 = te_delay1 - diff_grad.duration; del3 = te_delay2 - diff_grad.duration; if (del3 < 0.0) { // shift diff block to right del1 += del3; del2 -= del3; del4 -= del3; del3 = 0; } else if (del2 < 0.0) { // shift diff block to left del1 -= del2; del3 -= del2; del4 += del2; del2 = 0; } } else { /* No diffusion */ del1 = 0; del3 = 0; del2 = te_delay1; del4 = te_delay2; } /* Min TR *************************************************/ trmin = (ss_grad.duration - ss_grad.rfCenterBack) + te + ro_grad.timeFromEcho; if (navigator[0] == 'y') trmin += (pe_grad.duration + ro_grad.duration); /* Optional prepulse calculations *************************/ if (sat[0] == 'y') { create_satbands(); trmin += satTime; } if (fsat[0] == 'y') { create_fatsat(); trmin += fsatTime; } if (mt[0] == 'y') { create_mtc(); trmin += mtTime; } if (ir[0] == 'y') { init_rf(&ir_rf,pipat,pi,flipir,rof2,rof2); calc_rf(&ir_rf,"tpwri","tpwrif"); init_slice_butterfly(&ssi_grad,"ssi",thk,gcrushir,tcrushir); calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi"); tau1 = ss_grad.duration - ss_grad.rfCenterBack; /* duration of ss_grad before RF center */ ti_delay = ti - (ssi_grad.rfCenterBack + tau1); if (ti_delay < 0) { abort_message("TI too short, Minimum TI = %.2fms\n",(ti-ti_delay)*1000); } irTime = ti + ssi_grad.duration - ssi_grad.rfCenterBack; /* time to add to TR */ trmin += irTime; trmin -= tau1; /* but subtract out ss_grad which was already included in TR */ } trmin *= ns; if (mintr[0] == 'y'){ tr = trmin + ns*4e-6; putvalue("tr",tr); } if (tr < trmin) { abort_message("TR too short. Minimum TR= %.2fms\n",trmin*1000); } tr_delay = (tr - trmin)/ns > 4e-6 ? (tr - trmin)/ns : 4e-6; /***************************************************/ /* CALCULATE B VALUES ******************************/ if (diff[0] == 'y') { /* Get multiplication factors and make sure they have same # elements */ /* All this is only necessary because putCmd only work for ix==1 */ nbro = (int) getarray("dro",roarr); nbval = nbro; nbpe = (int) getarray("dpe",pearr); if (nbpe > nbval) nbval = nbpe; nbsl = (int) getarray("dsl",slarr); if (nbsl > nbval) nbval = nbsl; if ((nbro != nbval) && (nbro != 1)) abort_message("%s: Number of directions/b-values must be the same for all axes (readout)",seqfil); if ((nbpe != nbval) && (nbpe != 1)) abort_message("%s: Number of directions/b-values must be the same for all axes (phase)",seqfil); if ((nbsl != nbval) && (nbsl != 1)) abort_message("%s: Number of directions/b-values must be the same for all axes (slice)",seqfil); if (nbro == 1) for (i = 1; i < nbval; i++) roarr[i] = roarr[0]; if (nbpe == 1) for (i = 1; i < nbval; i++) pearr[i] = pearr[0]; if (nbsl == 1) for (i = 1; i < nbval; i++) slarr[i] = slarr[0]; } else { nbval = 1; roarr[0] = 0; pearr[0] = 0; slarr[0] = 0; } for (i = 0; i < nbval; i++) { /* Readout */ Dro = ror_grad.duration; bro[i] = bval(gdiff*roarr[i],tdelta,tDELTA); bro[i] += bval(ro_grad.amp,ro_grad.timeToEcho,Dro); /* Slice */ dgss2 = Dgss2 = ss_grad.rfCenterFront; dcrush = tcrush; //"delta" for crusher part of butterfly Dcrush = dcrush + ss_grad.rfDuration; //"DELTA" for crusher bsl[i] = bval(gdiff*slarr[i],tdelta,tDELTA); bsl[i] += bval(gcrush,dcrush,Dcrush); bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2); bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush); bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); bsl[i] += bval_nested(gcrush,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2); /* Phase */ bpe[i] = bval(gdiff*pearr[i],tdelta,tDELTA); /* Readout/Slice Cross-terms */ brs[i] = bval2(gdiff*roarr[i],gdiff*slarr[i],tdelta,tDELTA); brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush); brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); /* Readout/Phase Cross-terms */ brp[i] = bval2(gdiff*roarr[i],gdiff*pearr[i],tdelta,tDELTA); /* Slice/Phase Cross-terms */ bsp[i] = bval2(gdiff*slarr[i],gdiff*pearr[i],tdelta,tDELTA); bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush); bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); btrace[i] = (bro[i]+bsl[i]+bpe[i]); if (max_bval < btrace[i]) { max_bval = (bro[i]+bsl[i]+bpe[i]); } } /* End for-all-directions */ putarray("bvalrr",bro,nbval); putarray("bvalpp",bpe,nbval); putarray("bvalss",bsl,nbval); putarray("bvalrp",brp,nbval); putarray("bvalrs",brs,nbval); putarray("bvalsp",bsp,nbval); putarray("bvalue",btrace,nbval); putvalue("max_bval",max_bval); /* Generate phase-ramped pulses: 90, 180, and IR */ offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]); shape90 = shapelist(p1pat,ss_grad.rfDuration,freq90,ns,0,seqcon[1]); offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]); shape180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]); if (ir[0] == 'y') { offsetlist(pss,ssi_grad.ssamp,0,freqIR,ns,seqcon[1]); shapeIR = shapelist(pipat,ssi_grad.rfDuration,freqIR,ns,0,seqcon[1]); } /* Set pe_steps for profile or full image **********/ pe_steps = prep_profile(profile[0],nv,&pe_grad,&null_grad); initval(pe_steps/2.0,vpe_offset); sgl_error_check(sglerror); /* Return parameters to VnmrJ */ putvalue("rgss",ss_grad.tramp); //90 slice ramp if (ss2_grad.enableButterfly) { //180 slice ramps putvalue("rcrush",ss2_grad.crusher1RampToCrusherDuration); putvalue("rgss2",ss2_grad.crusher1RampToSsDuration); } else { putvalue("rgss2",ss2_grad.tramp); } if (ro_grad.enableButterfly) { putvalue("rgro",ro_grad.crusher1RampToSsDuration); } else { putvalue("rgro",ro_grad.tramp); //RO ramp } putvalue("tror",ror_grad.duration); //ROR duration putvalue("rgror",ror_grad.tramp); //ROR ramp putvalue("gpe",pe_grad.peamp); //PE max amp putvalue("gss",ss_grad.ssamp); putvalue("gro",ro_grad.roamp); g_setExpTime(tr*(nt*pe_steps*arraydim + ssc)); /* PULSE SEQUENCE *************************************/ rotate(); obsoffset(resto); roff = -poffset(pro,ro_grad.roamp); delay(4e-6); /* Begin phase-encode loop ****************************/ peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr); /* Read external kspace table if set ******************/ if (table) getelem(t1,vpe_ctr,vpe_index); else sub(vpe_ctr,vpe_offset,vpe_index); settable(t2,2,ph180); // initialize phase tables and variables getelem(t2,vpe_ctr,vph180); add(oph,vph180,vph180); // 180 deg pulse phase alternates +/- 90 from receiver mod2(ct,vph2); dbl(vph2,vph2); add(vph180,vph2,vph180); // Alternate phase for 180 on odd transients /* Begin multislice loop ******************************/ msloop(seqcon[1],ns,vms_slices,vms_ctr); if (ticks) { xgate(ticks); grad_advance(gpropdelay); } /* TTL scope trigger **********************************/ sp1on(); delay(5e-6); sp1off(); /* Prepulses ******************************************/ if (sat[0] == 'y') satbands(); if (fsat[0] == 'y') fatsat(); if (mt[0] == 'y') mtc(); /* Optional IR pulse **********************************/ if (ir[0] == 'y') { obspower(ir_rf.powerCoarse); obspwrf(ir_rf.powerFine); delay(4e-6); obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0,0,ssi_grad.amp,NOWAIT); delay(ssi_grad.rfDelayFront); shapedpulselist(shapeIR,ssi_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr); delay(ssi_grad.rfDelayBack); delay(ti_delay); } /* 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(shape90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr); delay(ss_grad.rfDelayBack); /* Phase encode, refocus, and dephase gradient ********/ pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,-ssr_grad.amp, pe_grad.increment,vpe_index,WAIT); delay(del1); // delay to start of first diffusion gradient if (diff[0] == 'y') { obl_shapedgradient(diff_grad.name,diff_grad.duration, diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT); } delay(del2); // delay from end of diffusion to slice refocusing /* Refocusing RF pulse ********************************/ obspower(p2_rf.powerCoarse); obspwrf(p2_rf.powerFine); delay(4e-6); 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); delay(del3); // delay from slice refocusing to second diffusion gradient if (diff[0] == 'y') { obl_shapedgradient(diff_grad.name,diff_grad.duration, diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT); } delay(del4); // delay from end of diffusion gradient to readout event /* Readout gradient and acquisition ********************/ roff = -poffset(pro,ro_grad.roamp); obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT); obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront); 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_index,WAIT); if (navigator[0] == 'y') { roff = -poffset(pro,-ro_grad.roamp); obl_shapedgradient(ro_grad.name,ro_grad.duration,-ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront); startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); } /* Relaxation delay ***********************************/ delay(tr_delay); endmsloop(seqcon[1],vms_ctr); endpeloop(seqcon[2],vpe_ctr); }
static inline void add(EcT& R, const EcT& P, const EcT& Q) { if (P.isZero()) { R = Q; return; } if (Q.isZero()) { R = P; return; } #if MIE_EC_COORD == MIE_EC_USE_JACOBI Fp r, U1, S1, H, H3; Fp::square(r, P.z); Fp::square(S1, Q.z); Fp::mul(U1, P.x, S1); Fp::mul(H, Q.x, r); H -= U1; r *= P.z; S1 *= Q.z; S1 *= P.y; Fp::mul(r, Q.y, r); r -= S1; if (H.isZero()) { if (r.isZero()) { dbl(R, P, false); } else { R.clear(); } return; } Fp::mul(R.z, P.z, Q.z); R.z *= H; Fp::square(H3, H); // H^2 Fp::square(R.y, r); // r^2 U1 *= H3; // U1 H^2 H3 *= H; // H^3 R.y -= U1; R.y -= U1; Fp::sub(R.x, R.y, H3); U1 -= R.x; U1 *= r; H3 *= S1; Fp::sub(R.y, U1, H3); #elif MIE_EC_COORD == MIE_EC_USE_PROJ Fp r, PyQz, v, A, vv; Fp::mul(r, P.x, Q.z); Fp::mul(PyQz, P.y, Q.z); Fp::mul(A, Q.y, P.z); Fp::mul(v, Q.x, P.z); v -= r; if (v.isZero()) { Fp::add(vv, A, PyQz); if (vv.isZero()) { R.clear(); } else { dbl(R, P, false); } return; } Fp::sub(R.y, A, PyQz); Fp::square(A, R.y); Fp::square(vv, v); r *= vv; vv *= v; Fp::mul(R.z, P.z, Q.z); A *= R.z; R.z *= vv; A -= vv; vv *= PyQz; A -= r; A -= r; Fp::mul(R.x, v, A); r -= A; R.y *= r; R.y -= vv; #else Fp t; Fp::neg(t, Q.y); if (P.y == t) { R.clear(); return; } Fp::sub(t, Q.x, P.x); if (t.isZero()) { dbl(R, P, false); return; } Fp s; Fp::sub(s, Q.y, P.y); Fp::div(t, s, t); R.inf_ = false; Fp x3; Fp::square(x3, t); x3 -= P.x; x3 -= Q.x; Fp::sub(s, P.x, x3); s *= t; Fp::sub(R.y, s, P.y); R.x = x3; #endif }
void 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"), gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), pwx180 = getval("pwx180"), pwxlvl180 = getval("pwxlvl180"), hsglvl = getval("hsglvl"), hsgt = getval("hsgt"), tau, evolcorr, jdly, bird; int icosel, ijscale, prgcycle = (int)(getval("prgcycle")+0.5), phase1=(int)(getval("phase")+0.5); char selshapeA[MAXSTR], selshapeB[MAXSTR], pwx180ad[MAXSTR], pwx180adR[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",0.5); gzlvlE = syncGradLvl("gtE","gzlvlE",0.5); gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("pwx180ad", pwx180ad); getstr("pwx180adR", pwx180adR); evolcorr=(4*pwx/PI)+2*pw+8.0e-6; bird = 1 / (4*(getval("j1xh"))); tau = 1/(4*(getval("jnxh"))); ijscale=(int)(getval("jscale") + 0.5); jdly=(d2*ijscale); 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,2,ph2); settable(t4,8,ph4); settable(t5,8,ph5); getelem(t1,v17,v1); getelem(t2,v17,v2); getelem(t4,v17,v4); getelem(t5,v17,oph); add(oph,v18,oph); add(oph,v19,oph); if ((phase1 == 2) || (phase1 == 5)) icosel = -1; initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v14); /* mod2(id2, v14); dbl(v14,v14); */ add(v2, v14, v2); add(oph, v14, oph); 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,zero); if (getflag("prgflg")) shaped_purge(v1,zero,v18,v19); } else { satpulse(satdly,zero,rof1,rof1); if (getflag("prgflg")) purge(v1,zero,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); if (getflag("nullflg")) { rgpulse(0.5 * pw, zero, rof1, rof1); delay(2 * bird); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); rgpulse(2.0 * pw, zero, rof1, rof1); delay(2 * bird + 2 * POWER_DELAY); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); decpower(pwxlvl); rgpulse(1.5 * pw, zero, rof1, rof1); zgradpulse(hsglvl, hsgt); delay(1e-3); } if (getflag("cpmgflg")) { rgpulse(pw, v1, rof1, 0.0); cpmg(v1, v15); } else rgpulse(pw, v1, rof1, rof1); delay(tau/2 - gtA - gstab); delay(jdly/4); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); shaped_pulse(selshapeA,selpwA,zero,rof1,rof1); zgradpulse(gzlvlA,gtA); delay(gstab); delay(tau/2 - gtA - gstab); delay(jdly/2); delay(tau/2 - gtB - gstab); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); shaped_pulse(selshapeB,selpwB,two,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); decpower(pwxlvl); delay(jdly/4); delay(tau/2 - gtB - gstab); rgpulse(pw, one, rof1, rof1); zgradpulse(hsglvl, 2 * hsgt); delay(1e-3); decrgpulse(pwx, v2, rof1, 2.0e-6); delay(d2/2); rgpulse(2 * pw, zero, 2.0e-6, 2.0e-6); delay(d2/2); delay(gtE + gstab + 2*GRADIENT_DELAY - POWER_DELAY); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); zgradpulse(gzlvlE, gtE); delay(gstab + POWER_DELAY + evolcorr); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); decpower(pwxlvl); decrgpulse(pwx, v4, 2.0e-6, rof1); zgradpulse(-0.6 * hsglvl, 1.2 * hsgt); delay(1e-3); rgpulse(pw, zero, rof1, rof1); zgradpulse(icosel * 2.0*gzlvlE/EDratio, gtE/2.0); delay(gstab); delay(tau - gtA - 2*gstab - gtE/2); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); shaped_pulse(selshapeA,selpwA,zero,rof1,rof1); zgradpulse(gzlvlA,gtA); delay(gstab); delay(tau - gtA - gstab); decshaped_pulse(pwx180adR, pwx180, zero, rof1, rof1); decpower(dpwr); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,two,rof1,rof2); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); status(C); }
void pulsesequence() { double p1lvl, trim, mix, window, cycles; char sspul[MAXSTR]; /* LOAD AND INITIALIZE VARIABLES */ mix = getval("mix"); trim = getval("trim"); p1lvl = getval("p1lvl"); window=getval("window"); getstr("sspul", sspul); /* CHECK CONDITIONS */ if ((phase1 != 3) && (arrayelements > 2)) { fprintf(stdout, "PHASE=3 is required if MIX is arrayed!\n"); psg_abort(1); } if (satdly > 9.999) { fprintf(stdout, "Presaturation period is too long.\n"); psg_abort(1); } if (!newtransamp) { fprintf(stdout, "TOCSY requires linear amplifiers on transmitter.\n"); fprintf(stdout, "Use DECTOCSY with the appropriate re-cabling,\n"); psg_abort(1); } if ((p1 == 0.0) && (ix == 1)) fprintf(stdout, "Warning: P1 has a zero value.\n"); if ((rof1 < 9.9e-6) && (ix == 1)) fprintf(stdout,"Warning: ROF1 is less than 10 us\n"); if (satpwr > 40) { printf("satpwr too large - acquisition aborted./n"); psg_abort(1); } /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); hlv(ct, v13); mod2(ct, v1); hlv(ct, v2); elsenz(ssctr); sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */ hlv(v12, v13); mod2(v12, v1); hlv(v12, v2); endif(ssctr); /* CALCULATE PHASES */ /* A 2-step cycle is performed on the first pulse (90 degrees) to suppress axial peaks in the first instance. Second, the 2-step F2 quadrature image suppression subcycle is added to all pulse phases and receiver phase. Finally, a 2-step cycle is performed on the spin-lock pulses. */ mod2(v13, v13); dbl(v1, v1); incr(v1); hlv(v2, v2); mod2(v2, v2); dbl(v2, v2); incr(v2); add(v13, v2, v2); sub(v2, one, v3); add(two, v2, v4); add(two, v3, v5); add(v1, v13, v1); assign(v1, oph); if (phase1 == 2) incr(v1); if (phase1 == 3) add(v1, id2, v1); /*HYPERCOMPLEX MODE USES REDFIELD TRICK TO MOVE AXIAL PEAKS TO EDGE*/ if ((phase1==1)||(phase1==2)) { initval(2.0*(double)(d2_index%2),v6); add(v1,v6,v1); add(oph,v6,oph); } /* CALCULATE AND INITIALIZE LOOP COUNTER */ if (pw > 0.0) { cycles = (mix - trim) / (64.66*pw+32*window); cycles = 2.0*(double) (int) (cycles/2.0); } else { cycles = 0.0; } initval(cycles, v9); /* V9 is the MIX loop count */ /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); obspower(p1lvl); if (sspul[0] == 'y') { rgpulse(1000*1e-6, zero, rof1, 0.0e-6); rgpulse(1000*1e-6, one, 0.0e-6, rof1); } hsdelay(d1); if (satmode[A] == 'y') { obspower(satpwr); rgpulse(satdly,zero,rof1,rof2); obspower(p1lvl);} status(B); rgpulse(p1, v1, rof1, 1.0e-6); if (satmode[B] =='y') { if (d2 > 0.0) { obspower(satpwr); rgpulse(d2 - (2*POWER_DELAY) - 1.0e-6 - (2*p1/3.1416),zero,0.0,0.0); } } else { if (d2 > 0.0) delay(d2 - POWER_DELAY - 1.0e-6 - (2*p1/3.1416)); } rcvroff(); obsunblank(); obspower(tpwr); txphase(v3); xmtron(); delay(trim); if (cycles > 1.0) { starthardloop(v9); mleva(window); mleva(window); mlevb(window); mlevb(window); mlevb(window); mleva(window); mleva(window); mlevb(window); mlevb(window); mlevb(window); mleva(window); mleva(window); mleva(window); mlevb(window); mlevb(window); mleva(window); rgpulse(.66*pw,v3,rof1,rof2); endhardloop(); } txphase(v13); xmtroff(); /* detection */ delay(rof2); rcvron(); obsblank(); status(C); }
void pulsesequence() { double Dtau,Ddelta,dosytimecubed,dosyfrq,delcor, del = getval("del"), gstab = getval("gstab"), gt1 = getval("gt1"), gzlvl1 = getval("gzlvl1"), gzlvlhs = getval("gzlvlhs"), hsgt = getval("hsgt"), satpwr = getval("satpwr"), satdly = getval("satdly"), satfrq = getval("satfrq"); char delflag[MAXSTR],sspul[MAXSTR], alt_grd[MAXSTR],satmode[MAXSTR],lkgate_flg[MAXSTR]; getstr("delflag",delflag); getstr("satmode",satmode); getstr("alt_grd",alt_grd); getstr("lkgate_flg",lkgate_flg); getstr("sspul",sspul); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gt1 = syncGradTime("gt1","gzlvl1",0.5); gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5); /* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */ if (del < (4*pw+3.0*rof1+gt1+2.0*gstab)) { abort_message("Dbppste error: 'del' is less than %g, too short!", (4.0*pw+3*rof1+gt1+2.0*gstab)); } Ddelta=gt1; Dtau=2.0*pw+rof1+gstab+gt1/2.0; dosyfrq = sfrq; dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0)); putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq); /* Check for the validity of the number of transients selected ! if ( (nt != 4) && ((int)nt%16 != 0) ) { abort_message("Dbppste error: nt must be 4, 16, 64 or n*16 (n: integer)!"); } */ /* phase cycling calculation */ mod2(ct,v1); dbl(v1,v1); hlv(ct,v2); mod2(v2,v3); dbl(v3,v3); hlv(v2,v2); mod2(v2,v4); add(v1,v4,v1); /* v1 */ hlv(v2,v2); add(v2,v3,v4); /* v4 */ hlv(v2,v2); mod2(v2,v3); dbl(v3,v5); hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */ hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */ hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */ assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph); add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6); add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/ add(two,oph,oph); mod2(ct,v10); /* gradients change sign at odd transients */ if (ni > 1.0) { abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1"); } /* equilibrium period */ status(A); if (sspul[0]=='y') { zgradpulse(gzlvlhs,hsgt); rgpulse(pw,zero,rof1,rof1); zgradpulse(gzlvlhs,hsgt); } if (satmode[0] == 'y') { if (d1 - satdly > 0) delay(d1 - satdly); obspower(satpwr); if (satfrq != tof) obsoffset(satfrq); rgpulse(satdly,zero,rof1,rof1); if (satfrq != tof) obsoffset(tof); obspower(tpwr); delay(1.0e-5); } else { delay(d1); } if (getflag("wet")) wet4(zero,one); status(B); /* first part of bppdel sequence */ if (delflag[0]=='y') { if (gt1>0 && gzlvl1>0) { rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */ if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */ delcor = del-4.0*pw-3.0*rof1-gt1-2.0*gstab; if (satmode[1] == 'y') { obspower(satpwr); if (satfrq != tof) obsoffset(satfrq); rgpulse(delcor,zero,rof1,rof1); if (satfrq != tof) obsoffset(tof); obspower(tpwr); } else delay(delcor); /*diffusion delay */ rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1/2.0); delay(gstab+2*pw/PI); if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock sampling on */ } } else rgpulse(pw,oph,rof1,rof2); /* --- observe period --- */ status(C); }
void pulsesequence() { double base, corr, presat, qlvl; char sspul[MAXSTR]; /* LOAD VARIABLES AND CHECK CONDITIONS */ presat = getval("presat"); qlvl = getval("qlvl"); getstr("sspul", sspul); base = 180.0 / qlvl; initval(2.0 * qlvl, v5); if ((rof1 < 9.9e-6) && (ix == 1)) fprintf(stdout,"Warning: ROF1 is less than 10 us\n"); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); modn(ct, v5, v10); divn(ct, v5, v12); mod2(ct, v9); elsenz(ssctr); sub(ssval, ssctr, v14); /* v14 = 0,...,ss-1 */ modn(v14, v5, v10); divn(v14, v5, v12); mod2(v14, v9); endif(ssctr); /* CALCULATE PHASECYCLE */ /* The phasecycle first performs a (2*Q)-step cycle on the third pulse in order to select for MQC. The phasecycle is then adjusted so that the receiver goes +- in an alternating fashion. Second, the 2-step QIS cycle is added in. Third, a 2-step cycle for axial peak suppression is performed on the first pulse. */ assign(v12, v1); mod2(v12, v12); /* v12=quad. image suppression */ hlv(v1, v1); mod2(v1, v1); dbl(v1, v1); add(v1, v12, v4); add(v12, v1, v1); assign(v12, v2); assign(v12, v3); dbl(v9, v9); add(v9, v4, v4); assign(v4, oph); if (phase1 == 2) incr(v1); if (phase1 == 3) /* TPPI */ add(id2, v1, v1); /* FAD added for phase=1 or phase=2 */ if ((phase1 == 1) || (phase1 == 2)) { initval(2.0*(double)(d2_index%2),v13); add(v1,v13,v1); add(oph,v13,oph); } /* BEGIN ACTUAL PULSE SEQUENCE CODE */ if (newtrans) obsstepsize(base); status(A); if (sspul[0] == 'y') { hsdelay(hst + 0.001); rgpulse(pw, v1, 1.0e-6, 1.0e-6); hsdelay(hst + 0.001); } if ((d1 - presat) <= hst) { rcvroff(); decon(); hsdelay(presat); decoff(); delay(1.0e-6); rcvron(); } else { hsdelay(d1 - presat); decon(); rcvroff(); delay(presat); decoff(); delay(1.0e-6); rcvron(); } status(B); if (newtrans) xmtrphase(v10); /* hardware digital phaseshift */ rgpulse(pw, v1, rof1, 1.0e-6); corr = 1.0e-6 + rof1 + 4.0*pw/3.1416; if (d2 > corr) delay(d2-corr); rgpulse(pw, v2, rof1, 0.0); if (newtrans) { xmtrphase(zero); /* resets relative phase to absolute phase */ } else { phaseshift(-base, v10, OBSch); /* software small-angle phaseshift */ } rgpulse(pw, v3, 1.0e-6, rof2); status(C); }
pulsesequence() { double j1min = getval("j1min"), j1max = getval("j1max"), pwxlvl180 = getval("pwxlvl180"), pwx180 = getval("pwx180"), gzlvl0 = getval("gzlvl0"), gt0 = getval("gt0"), gzlvlE = getval("gzlvlE"), gtE = getval("gtE"), EDratio = getval("EDratio"), gstab = getval("gstab"), grad1, grad2, tau, tauA, tauB, taumb; char pwx180ad[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); grad1 = gzlvlE; grad2 = -1.0*gzlvlE*(EDratio-1)/(EDratio+1); tauA = 1/(2*(j1min + 0.146*(j1max - j1min))); tauB = 1/(2*(j1max - 0.146*(j1max - j1min))); taumb = 1 / (2 * (getval("jnxh"))); tau = 1 / (j1min+j1max); 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, 1, ph1); settable(t2, 1, ph2); settable(t3, 2, ph3); settable(t4, 1, ph4); settable(t5, 4, ph5); settable(t6, 4, ph6); getelem(t1, v17,v1); getelem(t2, v17,v2); getelem(t3, v17, v3); getelem(t4, v17, v4); getelem(t5, v17, v5); getelem(t6, v17, oph); add(oph,v18,oph); add(oph,v19,oph); /* mod2(id2, v10); dbl(v10,v10); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10); add(v3, v10, v3); add(oph, v10, oph); if ((phase1 == 2) || (phase1 == 5)) { icosel = -1; grad1 = gzlvlE*(EDratio-1)/(EDratio+1); grad2 = -1.0*gzlvlE; } 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(v1,zero,v18,v19); } else { satpulse(satdly,zero,rof1,rof1); if (getflag("prgflg")) purge(v1,zero,v18,v19); } } else delay(d1); if (getflag("wet")) wet4(zero,one); decpower(pwxlvl); status(B); rgpulse(pw, v1, rof1, rof2); /* Start of J filter */ if (getflag("jfilter")) { zgradpulse(gzlvl0/2,gt0); delay(tauA - gt0); decrgpulse(pwx, zero, rof1, rof1); zgradpulse(-gzlvl0/3,gt0); delay(tauB - gt0); decrgpulse(pwx, zero, rof1, rof1); zgradpulse(-gzlvl0/6,gt0); delay(gstab); } /* End of J filter */ delay(taumb); decrgpulse(pwx, v3, rof1, rof1); delay(d2 / 2.0); rgpulse(2 * pw, v4, rof1, rof1); delay(d2 / 2.0); decpower(pwxlvl180); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); delay(2 * pw + 2*POWER_DELAY + 4 * rof1 + (4 * pwx / 3.1416)); zgradpulse(icosel * grad1, gtE); delay(gstab); decshaped_pulse(pwx180ad, pwx180, zero, rof1, rof1); zgradpulse(icosel * grad2, gtE); decpower(pwxlvl); delay(gstab); decrgpulse(pwx, v5, rof1, rof2); decpower(dpwr); status(C); }
// Return value of constant dbl FreshEval_d(std::shared_ptr<Variable> const& diff_variable) const override { return dbl(highest_precision_value_); }
void pulsesequence() { double mixN = getval("mixN"), gzlvlC = getval("gzlvlC"), gtC = getval("gtC"), gstab = getval("gstab"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), selfrq = getval("selfrq"), zqfpw3 = getval("zqfpw3"), zqfpwr3 = getval("zqfpwr3"), gzlvlzq3 = getval("gzlvlzq3"), mixNcorr, sweeppw = getval("sweeppw"), sweeppwr = getval("sweeppwr"); char sweepshp[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat3[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtC = syncGradTime("gtC","gzlvlC",1.0); gzlvlC = syncGradLvl("gtC","gzlvlC",1.0); gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("sweepshp",sweepshp); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat3",zqfpat3); mixNcorr=0.0; if (getflag("Gzqfilt")) mixNcorr=getval("zqfpw3"); hlv(ct,v1); hlv(v1,v1); hlv(v1,v1); hlv(v1,v1); mod4(v1,v1); mod4(ct,v2); add(v1,v2,v2); hlv(ct,v3); hlv(v3,v3); mod4(v3,v3); add(v1,v3,v3); dbl(v3,v4); dbl(v2,oph); add(oph,v4,oph); add(oph,v1,oph); /* BEGIN THE ACTUAL PULSE SEQUENCE */ status(A); obspower(tpwr); delay(5.0e-5); delay(5.0e-5); if (getflag("sspul")) steadystate(); if (satmode[0] == 'y') { if ((d1-satdly) > 0.02) delay(d1-satdly); else delay(0.02); satpulse(satdly,zero,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); if (selfrq != tof) obsoffset(selfrq); rgpulse(pw, v1, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v2,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v3,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); if (selfrq != tof) obsoffset(tof); rgpulse(pw,v1,rof1,rof1); obspower(sweeppwr); delay(0.31*mixN); zgradpulse(gzlvlC,gtC); delay(gstab); shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1); delay(gstab); zgradpulse(-gzlvlC,gtC); delay(0.49*mixN); zgradpulse(-gzlvlC,2*gtC); delay(gstab); if (getflag("Gzqfilt")) { obspower(zqfpwr3); rgradient('z',gzlvlzq3); delay(100.0e-6); shaped_pulse(zqfpat3,zqfpw3,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); } else shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1); delay(gstab); zgradpulse(gzlvlC,2*gtC); delay(0.2*mixN); obspower(tpwr); rgpulse(pw,v1,rof1,rof2); status(C); }
void FreshEval_d(dbl& evaluation_value, std::shared_ptr<Variable> const& diff_variable) const override { evaluation_value = dbl(highest_precision_value_); }
pulsesequence() { int i, relay; double tau; /* GET NEW PARAMETERS */ relay = (int) (getval("relay") + 0.5); tau = getval("tau"); /* CHECK CONDITIONS */ if (p1 == 0.0) p1 = pw; /* CALCULATE PHASES */ sub(ct, ssctr, v11); /* v11 = ct-ss */ initval(256.0, v12); add(v11, v12, v11); /* v11 = ct-ss+256 */ hlv(v11, v1); /* v1 = cyclops = 00112233 */ for (i = 0; i < relay + 1; i++) hlv(v1, v1); /* cyclops = 2**(relay+2) 0's, 1's, 2's, 3's */ mod4(v11, v2); /* v2 = 0123 0123... */ dbl(v2, oph); /* oph = 0202 0202 */ add(v2, v1, v2); /* v2 = 0123 0123 + cyclops */ add(oph, v1, oph); /* oph = 0202 0202 + cyclops */ hlv(v11, v3); /* v3 = 0011 2233 4455 ... */ /* PULSE SEQUENCE */ status(A); if (rof1 == 0.0) { rof1 = 1.0e-6; /* phase switching time */ rcvroff(); } hsdelay(d1); /* preparation period */ status(B); rgpulse(pw, v1, rof1, rof1); delay(d2); /* evolution period */ status(A); if (relay == 0) delay(tau); /* for delayed cosy */ rgpulse(p1, v2, rof1, rof1); /* start of mixing period */ if (relay == 0) delay(tau); /* for delayed cosy */ for (i = 0; i < relay; i++) /* relay coherence */ { hlv(v3, v3); /* v3=2**(relay+1) 0's, 1's, 2's, 3's */ dbl(v3, v4); /* v4=2**(relay+1) 0's, 2's, 0's, 2's */ add(v2, v4, v5); /* v5=v4+v2 (including cyclops) */ delay(tau/2); rgpulse(2.0*pw, v2, rof1, rof1); delay(tau/2); rgpulse(pw, v5, rof1, rof1); } status(C); delay(rof2); rcvron(); }
void FreshEval_d(dbl& evaluation_value, std::shared_ptr<Variable> const& diff_variable) const override { evaluation_value = dbl(double(true_value_real_),double(true_value_imag_)); }
pulsesequence() { double mixN = getval("mixN"), gzlvlC = getval("gzlvlC"), gtC = getval("gtC"), gstab = getval("gstab"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), selfrq = getval("selfrq"), zqfpw3 = getval("zqfpw3"), zqfpwr3 = getval("zqfpwr3"), gzlvlzq3 = getval("gzlvlzq3"), mixNcorr, sweeppw = getval("sweeppw"), sweeppwr = getval("sweeppwr"); char sweepshp[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat3[MAXSTR]; int prgcycle=(int)(getval("prgcycle")+0.5); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtC = syncGradTime("gtC","gzlvlC",1.0); gzlvlC = syncGradLvl("gtC","gzlvlC",1.0); gtA = syncGradTime("gtA","gzlvlA",1.0); gzlvlA = syncGradLvl("gtA","gzlvlA",1.0); gtB = syncGradTime("gtB","gzlvlB",1.0); gzlvlB = syncGradLvl("gtB","gzlvlB",1.0); getstr("sweepshp",sweepshp); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat3",zqfpat3); mixNcorr=0.0; if (getflag("Gzqfilt")) mixNcorr=getval("zqfpw3"); 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); } } assign(zero,v16); if (getflag("STEP")) { mod2(v17,v16); hlv(v17,v17); } hlv(v17,v1); hlv(v1,v1); hlv(v1,v1); hlv(v1,v1); mod4(v1,v1); mod4(v17,v2); add(v1,v2,v2); hlv(v17,v3); hlv(v3,v3); mod4(v3,v3); add(v1,v3,v3); dbl(v3,v4); dbl(v2,oph); add(oph,v4,oph); add(oph,v1,oph); if (!getflag("NOE")) assign(v1,oph); /* if prgflg='n' the next two steps are non-events */ add(oph,v18,oph); add(oph,v19,oph); /* if STEP='n', the next two steps are non-events */ add(oph,v16,oph); add(oph,v16,oph); add(v1,v16,v16); /*v16 is the phase of first echo pulse in steptrain */ /* example: v1=0,0,2,2 v16=0,1,2,3 oph=0,2,2,0 - if STEP='y'*/ /* v1=0,2 v16=0 oph=0,2 - if STEP='n' */ if (getflag("prgflg") && (satmode[0] == 'y')) assign(v1,v6); /* BEGIN THE 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); status(B); rgpulse(pw,v1,rof1,rof2); if (getflag("STEP")) steptrain(v1,v16); if (getflag("NOE")) { if (selfrq != tof) obsoffset(selfrq); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v2,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v3,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); if (selfrq != tof) obsoffset(tof); rgpulse(pw,v1,rof1,rof1); obspower(sweeppwr); delay(0.31*mixN); zgradpulse(gzlvlC,gtC); delay(gstab); shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1); delay(gstab); zgradpulse(-gzlvlC,gtC); delay(0.49*mixN); zgradpulse(-gzlvlC,2*gtC); delay(gstab); if (getflag("Gzqfilt")) { obspower(zqfpwr3); rgradient('z',gzlvlzq3); delay(100.0e-6); shaped_pulse(zqfpat3,zqfpw3,zero,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); } else shaped_pulse(sweepshp,sweeppw,zero,rof1,rof1); delay(gstab); zgradpulse(gzlvlC,2*gtC); delay(0.2*mixN); obspower(tpwr); rgpulse(pw,v1,rof1,rof2); } status(C); }
void pulsesequence() { char sspul[MAXSTR]; /* LOAD VARIABLES AND CHECK CONDITIONS */ getstr("sspul", sspul); if (satpwr > 40) { printf("satpwr too large - acquisition aborted./n"); psg_abort(1); } if ((rof1 < 9.9e-6) && (ix== 1)) fprintf(stdout,"Warning: ROF1 is less than 10 us\n"); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); hlv(ct, v4); mod4(ct, v3); elsenz(ssctr); sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */ hlv(v12, v4); mod4(v12, v3); endif(ssctr); /* CALCULATE PHASECYCLE */ /* The phasecycle first performs a 4-step cycle on the third pulse in order to select for DQC. Second, the 2-step QIS cycle is added in. Third, a 2-step cycle for axial peak suppression is performed on the second pulse. Fourth, a 2-step cycle for axial peak suppression is performed on the first pulse. If P-type peaks only are being selected, the 2-step cycle for P-type peak selection is performed on the first pulse immediately after the 4-step cycle on the third pulse. */ hlv(v4, v4); if (phase1 == 0) { assign(v4, v6); hlv(v4, v4); mod2(v6, v6); /* v6 = P-type peak selection in w1 */ } hlv(v4, v2); mod4(v4, v4); /* v4 = quadrature image suppression */ hlv(v2, v1); mod2(v1, v1); dbl(v1, v1); mod2(v2, v2); dbl(v2, v2); dbl(v3, v5); add(v3, v5, v5); add(v1, v5, v5); add(v2, v5, v5); add(v4, v5, v5); add(v4, v1, v1); add(v4, v2, v2); add(v4, v3, v3); if (phase1 == 0) { add(v6, v1, v1); add(v6, v5, v5); } if (phase1 == 2) incr(v1); if (phase1 == 3) add(id2, v1, v1); /* adds TPPI increment to the phase of the * first pulse */ assign(v5, oph); /* FOR HYPERCOMPLEX, USE REDFIED TRICK TO MOVE AXIALS TO EDGE */ if ((phase1==2)||(phase1==1)) { initval(2.0*(double)(d2_index%2),v9); /* moves axials */ add(v1,v9,v1); add(oph,v9,oph); } /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); if (sspul[0] == 'y') { rgpulse(200*pw, one, 10.0e-6, 0.0e-6); rgpulse(200*pw, zero, 0.0e-6, 1.0e-6); } hsdelay(d1); if (satmode[A] == 'y') { obspower(satpwr); rgpulse(satdly,zero,rof1,rof2); obspower(tpwr); } status(B); rgpulse(pw, v1, rof1, 1.0e-6); if (satmode[B] == 'y') { obspower(satpwr); if (d2>100.0e-6) rgpulse(d2-(2*POWER_DELAY)-1.0e-6-rof1-(4*pw)/3.14159,zero,0.0,0.0); obspower(tpwr); } else if (d2>0.0) { delay(d2 - rof1 - 1.0e-6 -(4*pw)/3.1416); } rgpulse(pw, v2, rof1, 0.0); rgpulse(pw, v3, 1.0e-6, rof2); status(C); }
pulsesequence() { int prgcycle = (int)(getval("prgcycle")+0.5); double cmult = getval("cmult"); 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); } } assign(zero,v4); settable(t1,8,ph1); settable(t2,8,ph2); settable(t3,8,ph3); getelem(t1,v17,v1); getelem(t2,v17,v2); getelem(t3,v17,oph); if (getflag("prgflg") && (satmode[0] == 'y')) assign(v1,v4); add(oph,v18,oph); add(oph,v19,oph); /* mod2(id2,v10); dbl(v10,v10); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v10); add(v1,v10,v1); add(v4,v10,v4); add(oph,v10,oph); 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,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); rgpulse(pw, v1, rof1, rof1); delay(d2); rgpulse(cmult*pw, v2, rof1, rof2); status(C); }
pulsesequence() { double gtE = getval("gtE"), gzlvlE=getval("gzlvlE"), selpwrPS = getval("selpwrPS"), selpwPS = getval("selpwPS"), gzlvlPS = getval("gzlvlPS"), droppts=getval("droppts"), gstab = getval("gstab"); int prgcycle=(int)(getval("prgcycle")+0.5); char selshapePS[MAXSTR]; //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gtE = syncGradTime("gtE","gzlvlE",1.0); gzlvlE = syncGradLvl("gtE","gzlvlE",1.0); getstr("selshapePS",selshapePS); 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,32,ph2); settable(t3,8,ph3); settable(t4,16,ph4); getelem(t1,v17,v1); getelem(t2,v17,v2); getelem(t3,v17,v3); getelem(t4,v17,v4); assign(v4,oph); assign(v1,v6); add(oph,v18,oph); add(oph,v19,oph); /* BEGIN THE 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); status(B); obspower(tpwr); rgpulse(pw, v1, rof1, rof2); delay(d2/2.0); delay((0.25/sw1) - gtE - gstab - 2*pw/PI - rof2 - 2*GRADIENT_DELAY); zgradpulse(gzlvlE,gtE); delay(gstab); rgpulse(2*pw,v2,rof1,rof1); delay(0.25/sw1); delay(gstab); zgradpulse(-1.0*gzlvlE,gtE); delay(gstab); obspower(selpwrPS); rgradient('z',gzlvlPS); shaped_pulse(selshapePS,selpwPS,v3,rof1,rof1); rgradient('z',0.0); obspower(tpwr); delay(gstab); zgradpulse(-2.0*gzlvlE,gtE); delay(gstab - droppts/sw); delay(d2/2.0); status(C); }
pulsesequence() { double del = getval("del"), gstab = getval("gstab"), gt1 = getval("gt1"), gzlvl1 = getval("gzlvl1"), gt2 = getval("gt2"), gzlvl2 = getval("gzlvl2"), satpwr = getval("satpwr"), satdly = getval("satdly"), prgtime = getval("prgtime"), prgpwr = getval("prgpwr"), gzlvlhs = getval("gzlvlhs"), hsgt = getval("hsgt"), d3 = getval("d3"), Dtau,Ddelta,dosytimecubed, dosyfrq; char delflag[MAXSTR],satmode[MAXSTR],prg_flg[MAXSTR],alt_grd[MAXSTR], sspul[MAXSTR],lkgate_flg[MAXSTR]; getstr("delflag",delflag); getstr("satmode",satmode); getstr("prg_flg",prg_flg); getstr("alt_grd",alt_grd); getstr("lkgate_flg",lkgate_flg); getstr("sspul",sspul); //synchronize gradients to srate for probetype='nano' // Preserve gradient "area" gt1 = syncGradTime("gt1","gzlvl1",0.5); gzlvl1 = syncGradLvl("gt1","gzlvl1",0.5); gt2 = syncGradTime("gt2","gzlvl2",1.0); gzlvl2 = syncGradLvl("gt2","gzlvl2",1.0); /* In pulse sequence, minimum del=4.0*pw+3*rof1+gt1+2.0*gstab */ if (del < (4*pw+3.0*rof1+gt1+2.0*gstab)) { abort_message("Dbppste error: 'del' is less than %g, too short!", (4.0*pw+3*rof1+gt1+2.0*gstab)); } Ddelta=gt1; Dtau=2.0*pw+rof1+gstab+gt1/2.0; dosyfrq = sfrq; dosytimecubed=Ddelta*Ddelta*(del-(Ddelta/3.0)-(Dtau/2.0)); putCmd("makedosyparams(%e,%e)\n",dosytimecubed,dosyfrq); /* phase cycling calculation */ mod2(ct,v1); dbl(v1,v1); hlv(ct,v2); mod2(v2,v3); dbl(v3,v3); hlv(v2,v2); mod2(v2,v4); add(v1,v4,v1); /* v1 */ hlv(v2,v2); add(v2,v3,v4); /* v4 */ hlv(v2,v2); mod2(v2,v3); dbl(v3,v5); hlv(v2,v2); mod2(v2,v3); dbl(v3,v3); /* v3 */ hlv(v2,v2); mod2(v2,v6); add(v5,v6,v5); /* v5 */ hlv(v2,v2); mod2(v2,v2); dbl(v2,v2); /* v2 */ assign(v1,oph); dbl(v2,v6); sub(oph,v6,oph); add(v3,oph,oph); sub(oph,v4,oph); dbl(v5,v6); add(v6,oph,oph); mod4(oph,oph); /*receiver phase*/ add(v1,v3,v7); add(v4,v7,v7); add(two,v7,v8); mod2(ct,v10); /* gradients change sign at odd transients */ if (ni > 1.0) { abort_message("Dbppste is a 2D, not a 3D dosy sequence: please set ni to 0 or 1"); } /* equilibrium period */ status(A); if (sspul[0]=='y') { zgradpulse(gzlvlhs,hsgt); rgpulse(pw,zero,rof1,rof1); zgradpulse(gzlvlhs,hsgt); } if (satmode[0] == 'y') { if (d1 - satdly > 0) delay(d1 - satdly); obspower(satpwr); txphase(zero); rgpulse(satdly,zero,rof1,rof1); obspower(tpwr); } else delay(d1); status(B); /* first part of bppdel sequence */ if (delflag[0]=='y') { if (gt1>0 && gzlvl1>0) { rgpulse(pw, v1, rof1, 0.0); /* first 90, v1 */ if (lkgate_flg[0] == 'y') lk_hold(); /* turn lock sampling off */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw*2.0, v2, rof1, 0.0); /* first 180, v2 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw, v3, rof1, 0.0); /* second 90, v3 */ if (satmode[1] == 'y') { obspower(satpwr); rgpulse(del-4.0*pw-3.0*rof1-gt1-2.0*gstab,zero,rof1,rof1); obspower(tpwr); } else { delay(del-4.0*pw-3.0*rof1-gt1-2.0*gstab);/*diffusion delay */ } rgpulse(pw, v4, rof1, 0.0); /* third 90, v4 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(gzlvl1,gt1/2.0); delay(gstab); rgpulse(pw*2.0, v5, rof1, rof1); /* second 180, v5 */ if (alt_grd[0] == 'y') { ifzero(v10); zgradpulse(-1.0*gzlvl1,gt1/2.0); elsenz(v10); zgradpulse(gzlvl1,gt1/2.0); endif(v10); } else zgradpulse(-1.0*gzlvl1,gt1/2.0); delay(gstab); if (prg_flg[0] == 'y') { add(one,v7,v9); obspower(prgpwr); rgpulse(prgtime, v9, rof1, rof1); obspower(tpwr); } } zgradpulse(gzlvl2,gt2); delay(gstab); rgpulse(pw*0.231,v7,rof1,rof1); delay(d3); rgpulse(pw*0.692,v7,rof1,rof1); delay(d3); rgpulse(pw*1.462,v7,rof1,rof1); delay(d3); rgpulse(pw*1.462,v8,rof1,rof1); delay(d3); rgpulse(pw*0.692,v8,rof1,rof1); delay(d3); rgpulse(pw*0.231,v8,rof1,rof1); zgradpulse(gzlvl2,gt2); delay(gstab); if (lkgate_flg[0] == 'y') lk_sample(); /* turn lock on */ } else rgpulse(pw,oph,rof1,rof2); /* --- observe period --- */ status(C); }
pulsesequence() { double slpwrT = getval("slpwrT"), slpwT = getval("slpwT"), mixT = getval("mixT"), gzlvl1 = getval("gzlvl1"), gt1 = getval("gt1"), gzlvl2 = getval("gzlvl2"), gt2 = getval("gt2"), gstab = getval("gstab"), selpwrA = getval("selpwrA"), selpwA = getval("selpwA"), gzlvlA = getval("gzlvlA"), gtA = getval("gtA"), selpwrB = getval("selpwrB"), selpwB = getval("selpwB"), gzlvlB = getval("gzlvlB"), gtB = getval("gtB"), selfrq = getval("selfrq"), zqfpw1 = getval("zqfpw1"), zqfpwr1 = getval("zqfpwr1"), zqfpw2 = getval("zqfpw2"), zqfpwr2 = getval("zqfpwr2"), gzlvlzq1 = getval("gzlvlzq1"), gzlvlzq2 = getval("gzlvlzq2"); char slpatT[MAXSTR], selshapeA[MAXSTR], selshapeB[MAXSTR], zqfpat1[MAXSTR], zqfpat2[MAXSTR]; //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); getstr("slpatT",slpatT); getstr("selshapeA",selshapeA); getstr("selshapeB",selshapeB); getstr("zqfpat1",zqfpat1); getstr("zqfpat2",zqfpat2); if (strcmp(slpatT,"mlev17c") && strcmp(slpatT,"dipsi2") && strcmp(slpatT,"dipsi3") && strcmp(slpatT,"mlev17") && strcmp(slpatT,"mlev16")) abort_message("SpinLock pattern %s not supported!.\n", slpatT); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); assign(ct,v13); elsenz(ssctr); sub(ssval, ssctr, v13); /* v13 = 0,...,ss-1 */ endif(ssctr); mod4(v13,v1); /* v1 = 0 1 2 3 */ hlv(v13,v13); hlv(v13,v13); mod4(v13,v11); /* v11 = 0000 1111 2222 3333 */ dbl(v1,oph); add(v11,oph,oph); add(v11,oph,oph); /* oph = 2v1 + 2v11 */ /* CYCLOPS */ hlv(v13,v13); hlv(v13,v14); add(v1,v14,v1); add(v11,v14,v11); add(oph,v14,oph); assign(v14,v3); add(one,v3,v3); add(two,v3,v12); sub(v3,one,v2); add(v3,one,v4); add(v3,two,v5); /* BEGIN THE 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); satpulse(satdly,v6,rof1,rof1); } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); rgpulse(pw, v14, rof1, rof1); if (selfrq != tof) obsoffset(selfrq); zgradpulse(gzlvlA,gtA); delay(gstab); obspower(selpwrA); shaped_pulse(selshapeA,selpwA,v1,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlA,gtA); delay(gstab); if (selfrq != tof) delay(2*OFFSET_DELAY); zgradpulse(gzlvlB,gtB); delay(gstab); obspower(selpwrB); shaped_pulse(selshapeB,selpwB,v11,rof1,rof1); obspower(tpwr); zgradpulse(gzlvlB,gtB); delay(gstab); if (selfrq != tof) obsoffset(tof); rgpulse(pw, v14, rof1, rof1); if (getflag("Gzqfilt")) { obspower(zqfpwr1); rgradient('z',gzlvlzq1); delay(100.0e-6); shaped_pulse(zqfpat1,zqfpw1,v14,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); } obspower(slpwrT); zgradpulse(gzlvl1,gt1); delay(gstab); if (mixT > 0.0) { if (dps_flag) rgpulse(mixT,v3,0.0,0.0); else SpinLock(slpatT,mixT,slpwT,v2,v3,v4,v5, v9); } if (getflag("Gzqfilt")) { obspower(zqfpwr2); rgradient('z',gzlvlzq2); delay(100.0e-6); shaped_pulse(zqfpat2,zqfpw2,v14,rof1,rof1); delay(100.0e-6); rgradient('z',0.0); delay(gstab); } obspower(tpwr); zgradpulse(gzlvl2,gt2); delay(gstab); rgpulse(pw,v14,rof1,rof2); status(C); }
double ConfigIni::dbl(const string prop) { return dbl(prop, -1.); }
pulsesequence() { char sspul[MAXSTR]; double pwClvl=getval("pwClvl"); /* LOAD VARIABLES AND CHECK CONDITIONS */ getstr("sspul", sspul); /* STEADY-STATE PHASECYCLING */ /* This section determines if the phase calculations trigger off of (SS - SSCTR) or off of CT */ ifzero(ssctr); hlv(ct, v4); mod4(ct, v3); elsenz(ssctr); sub(ssval, ssctr, v12); /* v12 = 0,...,ss-1 */ hlv(v12, v4); mod4(v12, v3); endif(ssctr); /* CALCULATE PHASECYCLE */ /* The phasecycle first performs a 4-step cycle on the third pulse in order to select for DQC. Second, the 2-step QIS cycle is added in. Third, a 2-step cycle for axial peak suppression is performed on the second pulse. Fourth, a 2-step cycle for axial peak suppression is performed on the first pulse. If P-type peaks only are being selected, the 2-step cycle for P-type peak selection is performed on the first pulse immediately after the 4-step cycle on the third pulse. */ hlv(v4, v4); if (phase1 == 0) { assign(v4, v6); hlv(v4, v4); mod2(v6, v6); /* v6 = P-type peak selection in w1 */ } hlv(v4, v2); mod4(v4, v4); /* v4 = quadrature image suppression */ hlv(v2, v1); mod2(v1, v1); dbl(v1, v1); mod2(v2, v2); dbl(v2, v2); dbl(v3, v5); add(v3, v5, v5); add(v1, v5, v5); add(v2, v5, v5); add(v4, v5, v5); add(v4, v1, v1); add(v4, v2, v2); add(v4, v3, v3); if (phase1 == 0) { add(v6, v1, v1); add(v6, v5, v5); } if (phase1 == 2) incr(v1); if (phase1 == 3) add(id2, v1, v1); /* adds TPPI increment to the phase of the * first pulse */ assign(v5, oph); /* FOR HYPERCOMPLEX, USE STATES-TPPI TO MOVE AXIALS TO EDGE */ if ((phase1==2)||(phase1==1)) { initval(2.0*(double)(d2_index%2),v9); /* moves axials */ add(v1,v9,v1); add(oph,v9,oph); } /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); if (sspul[0] == 'y') { obspower(pwClvl-12); rgpulse(200*pw, one, 10.0e-6, 0.0e-6); rgpulse(200*pw, zero, 0.0e-6, 1.0e-6); obspower(pwClvl); } delay(d1); status(B); rgpulse(pw, v1, rof1, 1.0e-6); if (d2>0.0) delay(d2 - rof1 - 1.0e-6 -(4*pw)/3.1416); rgpulse(pw, v2, rof1, 0.0); rgpulse(pw, v3, 1.0e-6, rof2); add(v3,one,v8); delay(d3); rgpulse(2.0*pw,v8,rof1,rof1); delay(d3); status(C); }
pulsesequence() { /* Internal variable declarations *********************/ double freq90[MAXNSLICE],freq180[MAXNSLICE]; double te_delay1,te_delay2,tr_delay,tau1,tau2,thk2fact,te_delay3=0.0,te_delay4=0.0,navTime=0.0; double crushm0,pem0,gcrushr,gcrushp,gcrushs,pecrush; double refsign=1,crushsign=1,navsign=1; int shape90,shape180,table=0,sepRefocus; char slprofile[MAXSTR]; /* sequence dependent diffusion variables */ double Gro,Gss; // "gdiff" for readout/readout refocus and slice/slice refocus double dgro,dgss; // "delta" for readout/readout refocus and slice/slice refocus double Dgro,Dgss; // "DELTA" for readout/readout refocus and slice/slice refocus double dcrush,dgss2; // "delta" for crusher and gss2 gradients double Dcrush,Dgss2; // "DELTA" for crusher and gss2 gradients 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 vph180 = v7; // Phase of 180 pulse int vph2 = v8; // alternate phase of 180 on odd transients int vssc = v9; // Compressed steady-states int vtrimage = v10; // Counts down from nt, trimage delay when 0 int vacquire = v11; // Argument for setacqvar, to skip steady state acquires int vtrigblock = v12; // Number of slices per trigger block /* Initialize paramaters *****************************/ init_mri(); thk2fact=getval("thk2fact"); pecrush=getval("pecrush"); sepRefocus=getvalnwarn("sepRefocus"); getstrnwarn("slprofile",slprofile); /* Check for external PE table ***********************/ init_tablepar("pelist"); // Initialize pelist parameter if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); writetabletopar(t1,"pelist"); // Write t1 table to pelist parameter table = 1; } /* RF Power & Bandwidth Calculations ******************/ shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2); shape_rf(&p2_rf,"p2",p2pat,p2,flip2,rof1,rof2); calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); /* Initialize gradient structures *********************/ init_slice(&ss_grad,"ss",thk); init_slice(&ss2_grad,"ss2",thk*thk2fact); init_dephase(&crush_grad,"crush"); init_slice_refocus(&ssr_grad,"ssr"); if (FP_LT(tcrushro,alfa)) tcrushro=alfa; init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); init_readout_refocus(&ror_grad,"ror"); init_phase(&pe_grad,"pe",lpe,nv); init_generic(&spoil_grad,"spoil",gspoil,tspoil); /* Gradient calculations ******************************/ calc_readout(&ro_grad, WRITE,"gro","sw","at"); ro_grad.m0ref *= grof; calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror"); calc_phase(&pe_grad,NOWRITE,"gpe","tpe"); calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2"); calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr"); calc_generic(&spoil_grad,WRITE,"",""); /* Make sure crushing in PE dimension does not refocus signal from 180 */ crushm0=fabs(gcrush*tcrush); pem0=0.0; gcrushp=0.0; if (pecrush) pem0=pe_grad.m0; calc_dephase(&crush_grad,WRITE,crushm0+pem0,"",""); gcrushr = crush_grad.amp*crushm0/crush_grad.m0; if (pecrush) gcrushp = crush_grad.amp; gcrushs = crush_grad.amp*crushm0/crush_grad.m0; /* Allow phase encode and read dephase to be separated from slice refocus */ if (sepRefocus) { /* Equalize read dephase and PE gradient durations */ calc_sim_gradient(&ror_grad,&pe_grad,&null_grad,0,WRITE); crushsign=-1; } else { if (slprofile[0] == 'y') { /* Combined slice refocusing and read dephasing, reverse gradient sign if ror > ssr integral */ refsign = (ss_grad.m0ref > ro_grad.m0ref) ? 1.0 : -1.0; ss_grad.m0ref -= ro_grad.m0ref; calc_slice_refocus(&ssr_grad,&ss_grad,NOWRITE,"gssr"); } /* Equalize both refocus and PE gradient durations */ calc_sim_gradient(&ror_grad,&pe_grad,&ssr_grad,0,WRITE); } /* Create optional prepulse events ********************/ if (fsat[0] == 'y') create_fatsat(); if (sat[0] == 'y') create_satbands(); if (mt[0] == 'y') create_mtc(); if (ir[0] == 'y') create_inversion_recovery(); if (diff[0] == 'y') init_diffusion(&diffusion,&diff_grad,"diff",gdiff,tdelta); sgl_error_check(sglerror); /* Min TE *********************************************/ te = granularity(te,2*GRADIENT_RES); /* tau1, tau2 are the sum of events in each half echo period */ /* tau1, tau2 include a GRADIENT_RES as this is minimum delay time */ tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + 2*GRADIENT_RES; tau2 = ss2_grad.rfCenterBack + crush_grad.duration + ro_grad.timeToEcho + GRADIENT_RES; if (sepRefocus) tau2 += ror_grad.duration; temin = 2*MAX(tau1,tau2); /* Diffusion ******************************************/ if (diff[0] == 'y') { /* granulate tDELTA */ tDELTA = granularity(tDELTA,GRADIENT_RES); /* taudiff is the duration of events between diffusion gradients */ taudiff = ss2_grad.duration + 2*crush_grad.duration + GRADIENT_RES; /* set minimum diffusion structure requirements for gradient echo: taudiff, tDELTA, te and minte[0] */ set_diffusion(&diffusion,taudiff,tDELTA,te,minte[0]); /* set additional diffusion structure requirements for spin echo: tau1 and tau2 */ set_diffusion_se(&diffusion,tau1,tau2); /* calculate the diffusion structure delays. address &temin is required in order to update temin accordingly */ calc_diffTime(&diffusion,&temin); } /* TE delays ******************************************/ if (minte[0] == 'y') { te = temin; putvalue("te",te); } if (FP_LT(te,temin)) { abort_message("TE too short, minimum TE = %.3f ms\n",temin*1000); } te_delay1 = te/2 - tau1 + GRADIENT_RES; te_delay2 = te/2 - tau2 + GRADIENT_RES; if (navigator[0] == 'y') { /* tau1, tau2 are the sum of events in each half echo period */ tau1 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront; tau2 = ss2_grad.rfCenterBack + crush_grad.duration + ro_grad.timeToEcho; if (FP_GT(tau1,tau2)) { te_delay3 = GRADIENT_RES; te_delay4 = tau1-tau2+GRADIENT_RES; } else { te_delay3 = tau2-tau1+GRADIENT_RES; te_delay4 = GRADIENT_RES; } navTime = te_delay3 + ss2_grad.duration + 2*crush_grad.duration + ro_grad.duration + te_delay4 + 2*GRADIENT_RES; } /* Check nsblock, the number of slices blocked together (used for triggering and/or inversion recovery) */ check_nsblock(); /* Min TR *********************************************/ trmin = ss_grad.rfCenterFront + te + ro_grad.timeFromEcho + pe_grad.duration + 2*GRADIENT_RES; /* Increase TR if any options are selected ************/ if (spoilflag[0] == 'y') trmin += spoil_grad.duration; if (navigator[0] == 'y') trmin += navTime; if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (mt[0] == 'y') trmin += mtTime; if (ticks > 0) trmin += GRADIENT_RES; /* Adjust for all slices ******************************/ trmin *= ns; /* Inversion recovery *********************************/ if (ir[0] == 'y') { /* tauti 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 */ tauti = satTime + fsatTime + mtTime + GRADIENT_RES + ss_grad.rfCenterFront; /* calc_irTime checks ti and returns the time of all IR components */ trmin += calc_irTime(tauti,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 = %.3f ms\n",trmin*1000); } /* TR delay *******************************************/ tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES); /* Calculate B values *********************************/ if (ix == 1) { /* Calculate bvalues according to main diffusion gradients */ calc_bvalues(&diffusion,"dro","dpe","dsl"); /* Add components from additional diffusion encoding imaging gradients peculiar to this sequence */ /* Initialize variables */ dgro = 0.5*(ror_grad.duration+ro_grad.timeToEcho); Gro = ro_grad.m0ref/dgro; Dgro = dgro; if (!sepRefocus) Dgro = te-ss_grad.rfCenterBack-ro_grad.timeToEcho; dgss = 0.5*(ss_grad.rfCenterBack+ssr_grad.duration); Gss = ss_grad.m0ref/dgss; Dgss = dgss; dgss2 = ss2_grad.duration/2; Dgss2 = dgss2; dcrush = crush_grad.duration-crush_grad.tramp; Dcrush = crush_grad.duration+ss2_grad.duration; for (i = 0; i < diffusion.nbval; i++) { /* set droval, dpeval and dslval */ set_dvalues(&diffusion,&droval,&dpeval,&dslval,i); /* Readout */ diffusion.bro[i] += bval(Gro,dgro,Dgro); diffusion.bro[i] += bval(crushsign*gcrushr,dcrush,Dcrush); diffusion.bro[i] += bval_nested(gdiff*droval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush); if (!sepRefocus) { diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,gdiff*droval,tdelta,tDELTA); diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,crushsign*gcrushr,dcrush,Dcrush); } /* Phase */ if (pecrush) { diffusion.bpe[i] += bval(gcrushp,dcrush,Dcrush); diffusion.bpe[i] += bval_nested(gdiff*dpeval,tdelta,tDELTA,gcrushp,dcrush,Dcrush); } /* Slice */ diffusion.bsl[i] += bval(Gss,dgss,Dgss); diffusion.bsl[i] += bval(gcrushs,dcrush,Dcrush); diffusion.bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2); diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,gcrushs,dcrush,Dcrush); diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); diffusion.bsl[i] += bval_nested(gcrushs,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2); /* Readout/Phase Cross-terms */ diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush); diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush); if (pecrush) diffusion.brp[i] += bval_cross(gdiff*droval,tdelta,tDELTA,gcrushp,dcrush,Dcrush); if (!sepRefocus) { diffusion.brp[i] += bval_cross(Gro,dgro,Dgro,gdiff*dpeval,tdelta,tDELTA); if (pecrush) diffusion.brp[i] += bval_cross(Gro,dgro,Dgro,gcrushp,dcrush,Dcrush); } /* Readout/Slice Cross-terms */ diffusion.brs[i] += bval2(crushsign*gcrushr,gcrushs,dcrush,Dcrush); diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,gcrushs,dcrush,Dcrush); diffusion.brs[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,crushsign*gcrushr,dcrush,Dcrush); diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); if (!sepRefocus) { diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gdiff*dslval,tdelta,tDELTA); diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gcrushs,dcrush,Dcrush); diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,ss2_grad.ssamp,dgss2,Dgss2); } /* Slice/Phase Cross-terms */ diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,gcrushs,dcrush,Dcrush); diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2); if (pecrush) { diffusion.bsp[i] += bval2(gcrushs,gcrushp,dcrush,Dcrush); diffusion.bsp[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,gcrushp,dcrush,Dcrush); diffusion.bsp[i] += bval_cross(gcrushp,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2); } } /* End for-all-directions */ /* Write the values */ write_bvalues(&diffusion,"bval","bvalue","max_bval"); } /* Generate phase-ramped pulses ***********************/ offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]); offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]); shape90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freq90,ns,ss_grad.rfFraction,seqcon[1]); shape180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,ss2_grad.rfFraction,seqcon[1]); /* Set pe_steps for profile or full image *************/ pe_steps = prep_profile(profile[0],nv,&pe_grad,&null_grad); F_initval(pe_steps/2.0,vpe_offset); /* Shift DDR for pro **********************************/ roff = -poffset(pro,ro_grad.roamp); /* Adjust experiment time for VnmrJ *******************/ if (ssc<0) { if (seqcon[2] == 'c') g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*arraydim)); else g_setExpTime(trmean*(ntmean*pe_steps*arraydim - ssc*pe_steps*arraydim)); } else g_setExpTime(trmean*ntmean*pe_steps*arraydim + tr*ssc); /* Slice profile **************************************/ if (slprofile[0] == 'y' && !sepRefocus) ror_grad.amp = 0; /* Set phase cycle table ******************************/ if (sepRefocus) settable(t2,1,ph180); // Phase encode is just before readout else settable(t2,2,ph180); /* PULSE SEQUENCE *************************************/ status(A); // Set status A rotate(); // Set gradient rotation according to psi, phi and theta triggerSelect(trigger); // Select trigger input 1/2/3 obsoffset(resto); // Set spectrometer frequency delay(GRADIENT_RES); // Delay for frequency setting initval(fabs(ssc),vssc); // Compressed steady-state counter if (seqcon[2]=='s') assign(zero,vssc); // Zero for standard peloop 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 ****************************/ 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); } /* 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); } /* Phase cycle ****************************************/ getelem(t2,vpe_ctr,vph180); // For phase encoding with slice rephase add(oph,vph180,vph180); // 180 deg pulse phase alternates +/- 90 from receiver mod2(ct,vph2); dbl(vph2,vph2); add(vph180,vph2,vph180); // Alternate phase for 180 on odd transients /* 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(GRADIENT_RES); elsenz(vtest); delay(GRADIENT_RES); endif(vtest); } sp1on(); delay(GRADIENT_RES); sp1off(); // Scope trigger /* 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(GRADIENT_RES); 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() { int phase1 = (int)(getval("phase")+0.5), prgcycle=(int)(getval("prgcycle")+0.5); 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); } } /* CONSTANTS FOR PHASE CALCULATIONS */ initval( 8.0,v13); initval( 32.0,v12); initval( 20.0,v11); initval( 192.0,v10); /* CALCULATE PHASECYCLE */ assign(zero,v14); /* phase of first pulse */ mod2(v17,v1); dbl(v1,v1); /* 0202 */ /* even/odd flag */ hlv(v17,v2); hlv(v2,v3); dbl(v3,v3); /* 0000222244446666 */ /* phase for transients 3 + 4*n */ /* 1+4*n = 0 */ mod2(v2,v2); /* 0011 */ /* switch for pairs */ assign(v13,v4); /* 8 */ ifzero(v2); incr(v4); elsenz(v2); decr(v4); endif(v2); modn(v4,v13,v4); /* 1177 */ /* standard phases for even transients */ /* 1 for 2+4*n, 7 for 4*n */ hlv(v13,v8); /* 4 */ add(v17,v8,v5); /* (ct+4) */ divn(v5,v12,v5); /* (ct+4)/32 */ divn(v17,v12,v6); /* ct/32 */ sub(v5,v6,v5); /* ((ct+4)/32-ct/32 */ /* 00000000 00000000 00000000 00001111 */ add(v17,v11,v6); /* (ct+20) */ divn(v6,v10,v6); /* (ct+20)/192 */ sub(v11,v7,v7); /* 16 */ add(v17,v7,v7); /* (ct+16) */ divn(v7,v10,v7); /* (ct+16)/192 */ add(v5,v6,v5); sub(v5,v7,v5); /* ((ct+4)/32-ct/32)+((ct+20)/192-(ct+16)/192) */ /* flag for exceptions on even transients */ dbl(v2,v6); /* 0022 */ add(v6,three,v6); /* 3355 */ ifzero(v1); /* for odd transients */ ifzero(v2); /* 1+4n: */ assign(zero,v3); /* 0xxx 0xxx 0xxx 0xxx */ endif(v2); /* 3+4n: xx0x xx2x xx4x xx6x */ elsenz(v1); /* for even transients */ ifzero(v5); /* normal case: */ assign(v4,v3); /* x1x7 */ elsenz(v5); /* exceptions: */ assign(v6,v3); /* x3x5 */ endif(v5); /* v3 = phase of first and second pulse */ /* in 45 degrees steps: */ /* 01070127 01470167 01070127 01470365 */ /* 01070127 01470167 01070127 01470365 */ /* 01070127 01470167 01070127 01470365 */ /* 01070127 01470167 01070127 01470365 */ /* 01070127 01470167 01070127 01470365 */ /* 01070127 01470365 01070127 01470365 */ endif(v1); assign(two,v4); /* v4 = phase of last 90 degrees pulse */ assign(v1,oph); /* oph = 0202 */ assign(zero,v20); if (getflag("prgflg") && (satmode[0] == 'y')) assign(v14,v20); add(oph,v18,oph); add(oph,v19,oph); if (phase1 == 2) incr(v14); /* States - Habercorn */ /* mod2(id2,v9); dbl(v9,v9); */ initval(2.0*(double)(((int)(d2*getval("sw1")+0.5)%2)),v9); add(v14,v9,v14); add(oph,v9,oph); /* BEGIN ACTUAL PULSE SEQUENCE CODE */ status(A); obsstepsize(45.0); 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")) { if (getflag("prgflg")) xmtrphase(v3); shaped_satpulse("relaxD",satdly,v20); if (getflag("prgflg")) { shaped_purge(v14,v20,v18,v19); xmtrphase(zero); } } else { if (getflag("prgflg")) xmtrphase(v3); satpulse(satdly,v20,rof1,rof1); if (getflag("prgflg")) { purge(v14,v20,v18,v19); xmtrphase(zero); } } } else delay(d1); if (getflag("wet")) wet4(zero,one); status(B); xmtrphase(v3); rgpulse(pw, v14, rof1, 2.0e-6); if (d2 > 0.0) delay(d2 - (4.0*pw/PI) - 4.0e-6); else delay(d2); rgpulse(pw, zero, 2.0e-6, rof1); xmtrphase(zero); rgpulse(pw, v4, rof1, rof2); status(C); }
pulsesequence() { char normal[MAXSTR], focus[MAXSTR]; double spp, spplvl, pp, mult, j, d3; double gt, gzlvl; /* GATHER AND INTIALIZE */ getstr("focus", focus); getstr("normal", normal); spp = getval("spp"); spplvl = getval("spplvl"); pp = getval("pp"); mult = getval("mult"); j = getval("j"); gt = getval("gt"); gzlvl = getval("gzlvl"); /* calculate phases */ mod2(ct,v1); /* v1 = 01010101 */ dbl(v1,v1); /* v1 = 0 2 */ hlv(ct,v2); mod2(v2,v2); /* v2 = 0 0 1 1 */ add(v1,v2,oph); /* oph = 0 2 1 3 */ /* if mult is zero, then do normal s2pul sequence */ if (mult == 0.0) { status(A); hsdelay(d1); pulse(p1, zero); status(B); delay(d2); status(C); pulse(pw,oph); } else /* this is the INEPT part of the sequence */ { if (j != 0.0) { /* calculation of delays */ d3 = 1.0 / (2.0 * j); if (mult < 2.5) { d2 = 1.0 / (2.0 * j); } else if (mult < 3.5) { d2 = 3.0 / (4.0 * j); } else { d2 = 1.0 / (3.0 * j); } } else d3 = getval("d3"); /* do equilibration delay */ if ((dm[A] == 'y') || (dm[B] == 'y')) { (void) printf("Decoupler must be set as dm=nny or n\n"); psg_abort(1); } if (declvlonoff) declvlon(); /* use pplvl for pulse */ else decpower(pplvl); dec_pw_ovr(FALSE); status(A); delay(d1); /* excitation transfer */ status(B); decrgpulse(pp, v1, rof1, rof1); decpower(spplvl); dec_pw_ovr(TRUE); delay(d3/2 - 2.0*(gt + spp + 1.0e-4)); /*nominal 1/(4j) corrected for H1 & gradient pulses */ zgradpulse(gzlvl,gt); delay(1.0e-4); simpulse(2*pw, 2*spp, zero, zero, rof1, rof1); delay(1.0e-4); zgradpulse(gzlvl,2.0*gt); delay(1.0e-4); simpulse(2.0*pw, 2.0*spp, zero, two, rof1, rof1); zgradpulse(gzlvl,gt); delay(1.0e-4); decpower(pplvl); dec_pw_ovr(FALSE); delay(d3/2 - 2.0*(gt + spp + 1.0e-4)); simpulse(pw, pp, v2, one, 0.0, 0.0); /* make decision on refocussing */ if ((focus[A] == 'y') || (dm[C] == 'y')) { decpower(spplvl); dec_pw_ovr(TRUE); delay(d2/2 - rof1 -spp); /* refocussing delay varied for 2d */ simpulse(2*pw, 2*spp, v2, zero, rof1, rof1); delay(d2/2 - rof1 - spp); } else if (normal[A] == 'y') { decrgpulse(pp, v1, 1.0e-6, 0.0); } if (declvlonoff) declvloff(); else decpower(dpwr); status(C); } }