void InvertibleRSAFunction::Initialize(const Integer &n, const Integer &e, const Integer &d) { m_n = n; m_e = e; m_d = d; Integer r = --(d*e); while (r.IsEven()) r >>= 1; ModularArithmetic modn(n); for (Integer i = 2; ; ++i) { Integer a = modn.Exponentiate(i, r); if (a == 1) continue; Integer b; while (a != -1) { b = modn.Square(a); if (b == 1) { m_p = GCD(a-1, n); m_q = n/m_p; m_dp = m_d % (m_p-1); m_dq = m_d % (m_q-1); m_u = m_q.InverseMod(m_p); return; } a = b; } } }
// For a set of n equations in the form: x=r[i] (mod m[i]) // find the smallest nonnegative solution or return -1, // if no solution exists ll non_chinese(int n, int *m, int *r) { ll res = r[0]; ll mres = m[0]; for (int i = 1; i < n; i++) { // set of 2 equations: x=res (mod mres), x=r[i] (mod m[i]) ll g = euclid(mres, m[i]); if (res % g != r[i] % g) return -1; ll rnew = modn(r[i] - res, m[i]); // solve k*mres = rnew (mod m[i]) ll ld = mres / g, rd = rnew / g, md = m[i] / g; ll u, v; euclid_extended(md, ld, u, v); ll k = modn(v*rd, md); res = k*mres + res; mres = md * mres; res %= mres; } return res; }
void caesar_cipher_dec(char *intext, int intext_size, char *outtext, int *shift, int shift_size) { int i; char ch; for (i = 0; i < intext_size; i++) { ch = *(intext + i); *(outtext + i) = ALPHA_CH(ch) ? NUMCHAR( modn( CHARNUM(ch) - *(shift + modp(i, shift_size)), 26) ) : ch; } }
Integer InvertibleRSAFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const { DoQuickSanityCheck(); ModularArithmetic modn(m_n); Integer r(rng, Integer::One(), m_n - Integer::One()); Integer re = modn.Exponentiate(r, m_e); re = modn.Multiply(re, x); // blind // here we follow the notation of PKCS #1 and let u=q inverse mod p // but in ModRoot, u=p inverse mod q, so we reverse the order of p and q Integer y = ModularRoot(re, m_dq, m_dp, m_q, m_p, m_u); y = modn.Divide(y, r); // unblind ASSERT( modn.Exponentiate(y, m_e) == x ); // check return y; }
// Solve a set of n equations of the form: x=r[i] (mod m[i]) // Moduli must be pairwise coprime ll chinese(int n, int *m, int *r) { ll M = 1, x = 0; for (int i = 0; i < n; i++) M *= m[i]; for (int i = 0; i < n; i++) { ll u, v; ll s = M / m[i]; euclid_extended(m[i], s, u, v); // v*s=1(mod m[i]), v*s=0(mod m[j]) for j!=i if (v < 0) v += m[i]; x += r[i] * v * s; x = modn(x, M); } return x; }
Integer InvertibleRSAFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const { DoQuickSanityCheck(); ModularArithmetic modn(m_n); Integer r(rng, Integer::One(), m_n - Integer::One()); Integer re = modn.Exponentiate(r, m_e); re = modn.Multiply(re, x); // blind // here we follow the notation of PKCS #1 and let u=q inverse mod p // but in ModRoot, u=p inverse mod q, so we reverse the order of p and q Integer y = ModularRoot(re, m_dq, m_dp, m_q, m_p, m_u); y = modn.Divide(y, r); // unblind if (modn.Exponentiate(y, m_e) != x) // check throw Exception(Exception::OTHER_ERROR, "InvertibleRSAFunction: computational error during private key operation"); return y; }
Integer RSA_PrivateKey::CalculateInverse(RandomNumberGenerator& rng, const Integer& x) const { ModularArithmetic modn(n_); Integer r(rng, Integer::One(), n_ - Integer::One()); Integer re = modn.Exponentiate(r, e_); re = modn.Multiply(re, x); // blind // here we follow the notation of PKCS #1 and let u=q inverse mod p // but in ModRoot, u=p inverse mod q, so we reverse the order of p and q Integer y = ModularRoot(re, dq_, dp_, q_, p_, u_); y = modn.Divide(y, r); // unblind return y; }
Integer InvertibleRWFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const { DoQuickSanityCheck(); ModularArithmetic modn(m_n); Integer r, rInv; do { // do this in a loop for people using small numbers for testing r.Randomize(rng, Integer::One(), m_n - Integer::One()); rInv = modn.MultiplicativeInverse(r); } while (rInv.IsZero()); Integer re = modn.Square(r); re = modn.Multiply(re, x); // blind Integer cp=re%m_p, cq=re%m_q; if (Jacobi(cp, m_p) * Jacobi(cq, m_q) != 1) { cp = cp.IsOdd() ? (cp+m_p) >> 1 : cp >> 1; cq = cq.IsOdd() ? (cq+m_q) >> 1 : cq >> 1; }
void InvertibleRSAFunction::Initialize(const Integer &n, const Integer &e, const Integer &d) { if (n.IsEven() || e.IsEven() | d.IsEven()) throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key"); m_n = n; m_e = e; m_d = d; Integer r = --(d*e); unsigned int s = 0; while (r.IsEven()) { r >>= 1; s++; } ModularArithmetic modn(n); for (Integer i = 2; ; ++i) { Integer a = modn.Exponentiate(i, r); if (a == 1) continue; Integer b; unsigned int j = 0; while (a != n-1) { b = modn.Square(a); if (b == 1) { m_p = GCD(a-1, n); m_q = n/m_p; m_dp = m_d % (m_p-1); m_dq = m_d % (m_q-1); m_u = m_q.InverseMod(m_p); return; } if (++j == s) throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key"); a = b; } } }
Integer InvertibleRabinFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &in) const { DoQuickSanityCheck(); ModularArithmetic modn(m_n); Integer r(rng, Integer::One(), m_n - Integer::One()); r = modn.Square(r); Integer r2 = modn.Square(r); Integer c = modn.Multiply(in, r2); // blind Integer cp=c%m_p, cq=c%m_q; int jp = Jacobi(cp, m_p); int jq = Jacobi(cq, m_q); if (jq==-1) { cp = cp*EuclideanMultiplicativeInverse(m_r, m_p)%m_p; cq = cq*EuclideanMultiplicativeInverse(m_r, m_q)%m_q; } if (jp==-1) { cp = cp*EuclideanMultiplicativeInverse(m_s, m_p)%m_p; cq = cq*EuclideanMultiplicativeInverse(m_s, m_q)%m_q; } cp = ModularSquareRoot(cp, m_p); cq = ModularSquareRoot(cq, m_q); if (jp==-1) cp = m_p-cp; Integer out = CRT(cq, m_q, cp, m_p, m_u); out = modn.Divide(out, r); // unblind if ((jq==-1 && out.IsEven()) || (jq==1 && out.IsOdd())) out = m_n-out; return out; }
pulsesequence() { /* Internal variable declarations *************************/ /*timing*/ double tr_delay; double te_d1,te_d2,te_d3; /* delays */ double tau1,tau2,tau3; /*voxel crusher multipliers */ double fx,fy,fz; /*localization parameters*/ double freq1,freq2,freq3; double vox1_cr,vox2_cr, vox3_cr; int nDim; double rprof,pprof,sprof; char profile_vox[MAXSTR],profile_ovs[MAXSTR]; double restol, resto_local, csd_ppm; /*phase cycle****/ int counter,noph; char autoph[MAXSTR], pcflag[MAXSTR]; int rf1_phase[64] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3}; int rf2_phase[64] = {0,0,0,0,2,2,2,2,1,1,1,1,3,3,3,3,0,0,0,0,2,2,2,2,1,1,1,1,3,3,3,3, 0,0,0,0,2,2,2,2,1,1,1,1,3,3,3,3,0,0,0,0,2,2,2,2,1,1,1,1,3,3,3,3}; int rf3_phase[64] = {0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3, 0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3,0,2,1,3}; /* Initialize paramaters **********************************/ init_mri(); //this gets all the parameters that are defined in acqparms.h, etc get_wsparameters(); get_ovsparameters(); rprof = getval("rprof"); pprof = getval("pprof"); sprof = getval("sprof"); //read the crusher factors that are designed to create grad on the same axis without refoc fx=getval("fx"); fy=getval("fy"); fz=getval("fz"); getstr("profile_vox",profile_vox); getstr("profile_ovs",profile_ovs); /*set voxel sizes for butterfly crushers to 10^6 to set the slice portion to zero ***/ vox1_cr=1000000; vox2_cr=1000000; vox3_cr=1000000; /***** RF power initialize *****/ init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2); /***** Initialize gradient structs *****/ trampfixed=trise; //rise time =trise tcrush=granularity(tcrush,GRADIENT_RES); //this is to avoid the granularity errors //if trampfixed is used, rise time needs to be checked if (trise*2>tcrush){ abort_message("tcrush too short. Minimum tcrush = %fms \n",1000*trise*2); } if (gcrush>gmax){ abort_message("gcrush too large. Max gcrush = %f \n",gmax*0.95); } init_slice_butterfly(&vox1_grad,"vox1",vox1,gcrush,tcrush); init_slice_butterfly(&vox2_grad,"vox2",vox2,gcrush,tcrush); init_slice_butterfly(&vox3_grad,"vox3",vox3,gcrush,tcrush); init_slice_butterfly(&vox1_crush,"vox1_crush",vox1_cr,gcrush,tcrush); init_slice_butterfly(&vox2_crush,"vox2_crush",vox2_cr,gcrush,tcrush); init_slice_butterfly(&vox3_crush,"vox3_crush",vox3_cr,gcrush,tcrush); if (profile_vox[0] == 'y') { init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); init_readout_refocus(&ror_grad,"ror"); } /***** RF and Gradient calculations *****/ calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); calc_slice(&vox1_grad,&p2_rf,WRITE,"gvox1"); calc_slice(&vox2_grad,&p2_rf,WRITE,"gvox2"); calc_slice(&vox3_grad,&p2_rf,WRITE,"gvox3"); calc_slice(&vox1_crush,&p2_rf,WRITE,"vox1_crush"); calc_slice(&vox2_crush,&p2_rf,WRITE,"vox2_crush"); calc_slice(&vox3_crush,&p2_rf,WRITE,"vox3_crush"); if (profile_vox[0] == 'y') { calc_readout(&ro_grad,WRITE,"gro","sw","at"); putvalue("gro",ro_grad.roamp); // RO grad calc_readout_refocus(&ror_grad,&ro_grad,WRITE,"gror"); putvalue("tror",ror_grad.duration); // ROR duration } //set all gradients along a particular direction to zero if profile is needed if (profile_ovs[0]=='y'){ if (rprof==1) { vox1_grad.amp=0; //set slice selection in read direction to none vox3_crush.amp=0; // set corresponding crusher gradients to none } else if(pprof==1) { vox2_grad.amp=0; vox1_crush.amp=0; } else if(sprof==1) { vox3_grad.amp=0; vox2_crush.amp=0; } } /* Optional OVS and Water Suppression */ if (ovs[0] == 'y') create_ovsbands(); if (sat[0] == 'y') create_satbands(); if (ws[0] == 'y') create_watersuppress(); //Read in parameters not defined in acqparms.h and sglHelper nDim=getval("nDim"); restol=getval("restol"); //local frequency offset roff=getval("roff"); //receiver offset csd_ppm=getval("csd_ppm"); //chemical shift displacement factor noph=getval("noph"); getstr("autoph",autoph); getstr("pcflag",pcflag); settable(t3,noph,rf1_phase); settable(t2,noph,rf2_phase); settable(t1,noph,rf3_phase); /* tau1, tau2 and tau3 are sums of all events in TE*/ tau1 = vox1_grad.rfCenterFront+GDELAY+rof2; tau2 = vox1_grad.rfCenterBack + vox1_grad.rfCenterFront+2*(GDELAY+rof2); tau3 = vox3_grad.rfCenterBack+GDELAY+rof2; temin = tau1+5.0*tau2+tau3; if (minte[0] == 'y') { te = temin; putvalue("te",te); } if (te < temin) { abort_message("te too short. Minimum te = %.2f ms\n",temin*1000); } /***** Calculate TE delays *****/ te_d1 = te/12.0 - tau1+GDELAY; te_d2 = te/6.0 - tau2+2*(GDELAY+rof2); te_d3 = te/12.0 - tau3+GDELAY+rof2; //Calculate delta from resto to include local frequency line+ chemical shift offset resto_local=resto-restol; /***** Min TR *****/ trmin = GDELAY + p1 + te + at+rof1+rof2; if (ws[0] == 'y') trmin += wsTime; if (ovs[0] == 'y') trmin += ovsTime; if (sat[0] == 'y') trmin += satTime; if (profile_vox[0] == 'y') trmin += ror_grad.duration + ro_grad.duration - at; if (mintr[0] == 'y') { tr = trmin; // ensure at least 4us between gradient events putvalue("tr",tr); } if ((trmin-tr) > 12.5e-9) { abort_message("TR too short. Minimum TR= %.2fms\n",trmin*1000); } /***** Calculate TR delay *****/ tr_delay = tr - trmin; /* Frequency offsets */ freq1 = poffset(pos1,vox1_grad.ssamp); // First RF pulse freq2 = poffset(pos2,vox2_grad.ssamp); // Second RF pulse freq3 = poffset(pos3,vox3_grad.ssamp); // Third RF pulse freq1=freq1-csd_ppm*sfrq; freq2=freq2-csd_ppm*sfrq; freq3=freq3-csd_ppm*sfrq; /* Frequency offsets */ if (profile_vox[0] == 'y') { /* Shift DDR for pro ************************************/ roff = -poffset(pro,ro_grad.roamp); } /* Put gradient information back into VnmrJ parameters */ putvalue("gvox1",vox1_grad.ssamp); putvalue("gvox2",vox2_grad.ssamp); putvalue("gvox3",vox3_grad.ssamp); putvalue("rgvox1",vox1_grad.tramp); putvalue("rgvox2",vox2_grad.tramp); putvalue("rgvox3",vox3_grad.tramp); sgl_error_check(sglerror); if (ss<0) g_setExpTime(tr*(nt-ss)*arraydim); else g_setExpTime(tr*(nt*arraydim+ss)); /**[2.7] PHASE CYCLING ******************************************************/ assign(zero, oph); counter=(double)nt*(ix-1); if (autoph[0] == 'n') counter=0.0; //only goes through nt, if 'y' goes through nt*array initval(counter,v1); initval(noph,v3); add(v1,ct,v2); modn(v2,v3,v2); /* Full phase cycling requires 64 steps*/ if (pcflag[0] == 'n') { assign(zero,v2); getelem(t1,v2,v10); getelem(t2,v2,v11); getelem(t3,v2,v12); } else { getelem(t1,v2,v10); getelem(t2,v2,v11); getelem(t3,v2,v12); } /*Start of the sequence*/ obsoffset(resto_local); // need it here for water suppression to work delay(GDELAY); rot_angle(vpsi,vphi,vtheta); if (ticks) { xgate(ticks); grad_advance(gpropdelay); delay(4e-6); } /* TTL scope trigger **********************************/ //sp1on(); delay(4e-6); sp1off(); /* Saturation bands ***********************************/ if (ovs[0] == 'y') ovsbands(); if (sat[0] == 'y') satbands(); /* Water suppression **********************************/ if (ws[0] == 'y') watersuppress(); /* Slice selective 90 degree RF pulse *****/ obspower(p1_rf.powerCoarse); obspwrf(p1_rf.powerFine); delay(GDELAY); shaped_pulse(p1pat,p1,zero,rof1,rof2); /* start localization */ obspower(p2_rf.powerCoarse); obspwrf(p2_rf.powerFine); if (nDim > 2.5) { delay(te_d1); //this is at least GDELAY == 4 us obl_shaped3gradient(vox1_grad.name,vox1_crush.name,"",vox1_grad.duration,vox1_grad.amp,fy*vox1_crush.amp,0,NOWAIT); delay(vox1_grad.rfDelayFront); if (profile_ovs[0]=='y'&& rprof==1) freq1=0.0; shapedpulseoffset(p2_rf.pulseName,vox1_grad.rfDuration,v12,rof1,rof2,freq1); delay(vox1_grad.rfDelayBack); delay(te_d2); obl_shaped3gradient (vox1_grad.name,vox1_crush.name,"",vox1_grad.duration,vox1_grad.amp,fy*0.777*vox1_crush.amp,0,NOWAIT); delay(vox1_grad.rfDelayFront); if (profile_ovs[0]=='y'&& rprof==1) freq1=0.0; shapedpulseoffset(p2_rf.pulseName,vox1_grad.rfDuration,v12,rof1,rof2,freq1); delay(vox1_grad.rfDelayBack); delay(te_d2); } if (nDim > 1.5) { //this is 2nd slice selection obl_shaped3gradient("",vox2_grad.name,vox2_crush.name,vox2_grad.duration,0,vox2_grad.amp,fz*vox2_crush.amp,NOWAIT); delay(vox2_grad.rfDelayFront); if (profile_ovs[0]=='y'&& pprof==1) freq2=0.0; shapedpulseoffset(p2_rf.pulseName,vox2_grad.rfDuration,v11,rof1,rof2,freq2); delay(vox2_grad.rfDelayBack); delay(te_d2); obl_shaped3gradient("",vox2_grad.name,vox2_crush.name,vox2_grad.duration,0,vox2_grad.amp,fz*0.777*vox2_crush.amp,NOWAIT); delay(vox2_grad.rfDelayFront); if (profile_ovs[0]=='y'&& pprof==1) freq2=0.0; shapedpulseoffset(p2_rf.pulseName,vox2_grad.rfDuration,v11,rof1,rof2,freq2); delay(vox2_grad.rfDelayBack); delay(te_d2); } if (nDim > 0.5){ //this is 3rd slice selection obl_shaped3gradient(vox3_crush.name,"",vox3_grad.name,vox3_grad.duration,fx*vox3_crush.amp,0,vox3_grad.amp,NOWAIT); delay(vox3_grad.rfDelayFront); if (profile_ovs[0]=='y'&& sprof==1) freq3=0.0; shapedpulseoffset(p2_rf.pulseName,vox3_grad.rfDuration,v10,rof1,rof2,freq3); delay(vox3_grad.rfDelayBack); delay(te_d2); obl_shaped3gradient(vox3_crush.name,"",vox3_grad.name,vox3_grad.duration,fx*vox3_crush.amp,0,vox3_grad.amp,NOWAIT); delay(vox3_grad.rfDelayFront); if (profile_ovs[0]=='y'&& sprof==1) freq3=0.0; shapedpulseoffset(p2_rf.pulseName,vox3_grad.rfDuration,v10,rof1,rof2,freq3); delay(vox3_grad.rfDelayBack); delay(te_d3); } if (profile_vox[0] == 'y') { obl_shapedgradient(ror_grad.name,ror_grad.duration, -rprof*ror_grad.amp,-pprof*ror_grad.amp,-sprof*ror_grad.amp,WAIT); delay(GDELAY); obl_shapedgradient(ro_grad.name,ro_grad.duration, rprof*ro_grad.amp,pprof*ro_grad.amp,sprof*ro_grad.amp,NOWAIT); delay(ro_grad.atDelayFront); startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); } else { startacq(alfa); acquire(np,1.0/sw); endacq(); } delay(tr_delay);
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); }
/*------------------------------------------------------------------- | | test4acquire() | check too see if data has been acquired yet. | if it has not then do an implicit acuire. | else do not. | Author Greg Brissey 7/10/86 +------------------------------------------------------------------*/ void test4acquire() { int i; int chan; int MINch; double acqdelay; /* delay time between receiver On an data acquired*/ codeint *tmpptr; /* temp pointer into codes */ extern void prg_dec_off(); double truefrq=0.0, dqdfrq=0.0; char osskip[4]; if (bgflag) fprintf(stderr,"test4acquire(): acqtriggers = %d \n",acqtriggers); if (acqtriggers == 0) /* No data acquisition Yet? */ { if (nf > 1.0) { text_error("Number of FIDs (nf) Not Equal to One\n"); psg_abort(0); } if (ap_interface < 4) HSgate(rcvr_hs_bit,FALSE); /* turn receiver On */ else SetRFChanAttr(RF_Channel[OBSch], SET_RCVRGATE, ON, 0); if (newacq) { /* execute osskip delay if osskip parameter set */ if ((P_getstring(GLOBAL,"qcomp",osskip,1,2)) == 0) { if (osskip[0] == 'y') { /* fprintf(stderr,"hwlooping:test4acquire(): executing dsposskipdelay= %g\n", dsposskipdelay); */ if (dsposskipdelay >= 0.0) G_Delay(DELAY_TIME, dsposskipdelay, 0); } } HSgate(INOVA_RCVRGATE,FALSE); /* turn receiver On */ } /* txphase(zero); */ /* set xmitter phase to zero */ /* decphase(zero); */ /* set decoupler phase to zero */ /* acqdelay = alfa + (1.0 / (beta * fb) ); */ for (i = 1; i <= NUMch; i++) /* zero HS phaseshifts */ SetRFChanAttr(RF_Channel[i], SET_RTPHASE90, zero, 0); if ((!noiseacquire) && (dsp_params.il_oversamp > 1)) find_dqdfrq(&truefrq, &dqdfrq); if (fabs(dqdfrq) > 0.1) set_spare_freq(OBSch); /* obsoffset(truefrq+dqdfrq); */ acqdelay = alfa + (1.0 / (beta * fb) ); if (acqdelay > ACQUIRE_START_DELAY) acqdelay = acqdelay - ACQUIRE_START_DELAY; if ((fabs(dqdfrq) > 0.1) && (acqdelay > 1.7e-6)) /* more like 40us?? */ acqdelay = acqdelay - 1.7e-6; if ((acqdelay < 0.0) && (ix == 1)) text_error("Acquisition filter delay (fb, alfa) is negative (%f).\n", acqdelay); else G_Delay(DELAY_TIME,acqdelay,0); /* alfa delay */ acquire(np,1.0/sw); /* acquire data */ MINch = (ap_interface < 4) ? DODEV : TODEV; for (chan = MINch; chan <= NUMch; chan++) { if ( is_y(rfwg[chan-1]) ) { if ( (ModInfo[chan].MI_dm[0] == 'n') || ((ModInfo[chan].MI_dm[0] == 'y') && (ModInfo[chan].MI_dmm[0] != 'p')) ) { prg_dec_off(2, chan); } } } tmpptr = Aacode + multhwlp_ptr; /* get address into codes */ *tmpptr = 1; /* impliicit acquisition */ } if (newacq) { if (explicitacq) { codeint *ptr; /* update last acquire with disable overload */; ptr = Aacode + disovld_ptr; *ptr++ = DISABLEOVRFLOW; *ptr = adccntrl; } /* Always set to FALSE for the next array element */ explicitacq = FALSE; } if (grad_flag == TRUE) { zero_all_gradients(); } if (newacq) { gatedecoupler(A,15.0e-6); /* init to status A conditions */ statusindx = A; } putcode(STFIFO); /* start fifo if it already hasn't */ putcode(HKEEP); /* do house keeping */ if (newacq) { if ( getIlFlag() ) { ifzero(ilflagrt); putcode(IFZFUNC); /* brach to start of scan (NSC) if ct<nt */ putcode((codeint)ct); putcode((codeint)ntrt); putcode(nsc_ptr); /* pointer to nsc */ elsenz(ilflagrt); add(strt,one,tmprt); putcode(IFZFUNC); /* brach to start of scan (NSC) if ct<strt+1 */ putcode((codeint)ct); putcode((codeint)tmprt); putcode(nsc_ptr); /* pointer to nsc */ modn(ct, bsval, tmprt); putcode(IFZFUNC); /* brach to start of scan (NSC) if ct%bs */ putcode((codeint)zero); putcode((codeint)tmprt); putcode(nsc_ptr); /* pointer to nsc */ endif(ilflagrt); } else { putcode(IFZFUNC); /* brach to start of scan (NSC) if ct<nt */ putcode((codeint)ct); putcode((codeint)ntrt); putcode(nsc_ptr); /* pointer to nsc */ } } else { putcode(BRANCH); /* brach back to start of scan (NSC) */ putcode(nsc_ptr); /* pointer to nsc */ } }
pulsesequence() { /* Internal variable declarations *************************/ double freqEx[MAXNSLICE]; double maxgradtime,spoilMoment,perTime,tau1,te_delay,tr_delay; double te2=0.0,te3=0.0,te2min,te3min,tau2,tau3,te2_delay,te3_delay=0; char minte2[MAXSTR],minte3[MAXSTR],spoilflag[MAXSTR]; int sepSliceRephase,sepReadRephase=0,readrev,table,shapeEx; int i; /* Real-time variables used in this sequence **************/ int vpe_steps = v1; // Number of PE steps int vpe_ctr = v2; // PE loop counter int vms_slices = v3; // Number of slices int vms_ctr = v4; // Slice loop counter int vpe_offset = v5; // PE/2 for non-table offset int vpe_mult = v6; // PE multiplier, ranges from -PE/2 to PE/2 int vper_mult = v7; // PE rewinder multiplier; turn off rewinder when 0 int vssc = v8; // Compressed steady-states int vacquire = v9; // Argument for setacqvar, to skip steady state acquires int vrfspoil_ctr = v10; // RF spoil counter int vrfspoil = v11; // RF spoil multiplier int vtrimage = v12; // Counts down from nt, trimage delay when 0 int vne = v13; // Number of echoes int vne_ctr = v14; // Echo loop counter int vneindex = v15; // Echo index, odd or even int vnelast = v16; // Check for last echo int vtrigblock = v17; // Number of slices per trigger block /* Initialize paramaters **********************************/ init_mri(); getstr("spoilflag",spoilflag); te2=getval("te2"); te3=getval("te3"); getstr("minte2",minte2); getstr("minte3",minte3); readrev=(int)getval("readrev"); /* Check for external PE table ***************************/ table = 0; if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); table = 1; } /* Set Rcvr/Xmtr phase increments for RF Spoiling ********/ /* Ref: Zur, Y., Magn. Res. Med., 21, 251, (1991) *******/ if (rfspoil[0] == 'y') { rcvrstepsize(rfphase); obsstepsize(rfphase); } /* Initialize gradient structures *************************/ shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2 ); // excitation pulse init_slice(&ss_grad,"ss",thk); // slice select gradient init_slice_refocus(&ssr_grad,"ssr"); // slice refocus gradient init_readout(&ro_grad,"ro",lro,np,sw); // readout gradient ro_grad.pad1=alfa; ro_grad.pad2=alfa; init_readout_refocus(&ror_grad,"ror"); // dephase gradient init_phase(&pe_grad,"pe",lpe,nv); // phase encode gradient init_dephase(&spoil_grad,"spoil"); // optimized spoiler init_dephase(&ref_grad,"ref"); // readout rephase /* RF Calculations ****************************************/ calc_rf(&p1_rf,"tpwr1","tpwr1f"); /* Gradient calculations **********************************/ calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice_refocus(&ssr_grad, &ss_grad,WRITE,"gssr"); calc_readout(&ro_grad, WRITE,"gro","sw","at"); calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror"); calc_phase(&pe_grad, NOWRITE,"gpe","tpe"); calc_dephase(&ref_grad,WRITE,ro_grad.m0,"",""); spoilMoment = ro_grad.acqTime*ro_grad.roamp; // Optimal spoiling is at*gro for 2pi per pixel spoilMoment -= ro_grad.m0def; // Subtract partial spoiling from back half of readout calc_dephase(&spoil_grad,WRITE,spoilMoment,"gspoil","tspoil"); /* Is TE long enough for separate slice refocus? ******/ maxgradtime = MAX(ror_grad.duration,pe_grad.duration); if (spoilflag[0] == 'y') maxgradtime = MAX(maxgradtime,spoil_grad.duration); tau1 = ss_grad.rfCenterBack + ssr_grad.duration + maxgradtime + ro_grad.timeToEcho + GRADIENT_RES; /* Equalize refocus and PE gradient durations *********/ if ((te >= tau1) && (minte[0] != 'y')) { sepSliceRephase = 1; // Set flag for separate slice rephase calc_sim_gradient(&ror_grad,&pe_grad,&spoil_grad,tpemin,WRITE); } else { sepSliceRephase = 0; calc_sim_gradient(&ror_grad,&pe_grad,&ssr_grad,tpemin,WRITE); calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,NOWRITE); } perTime = 0.0; if ((perewind[0] == 'y') || (spoilflag[0] == 'y')) perTime = spoil_grad.duration; if (spoilflag[0] == 'n') spoil_grad.amp = 0.0; /* Create optional prepulse events ************************/ if (sat[0] == 'y') create_satbands(); if (fsat[0] == 'y') create_fatsat(); if (mt[0] == 'y') create_mtc(); if (ir[0] == 'y') create_inversion_recovery(); /* Set up frequency offset pulse shape list ********/ offsetlist(pss,ss_grad.ssamp,0,freqEx,ns,seqcon[1]); shapeEx = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freqEx,ns,ss_grad.rfFraction,seqcon[1]); /* Check that all Gradient calculations are ok ************/ sgl_error_check(sglerror); /* Min TE ******************************************/ tau1 = ss_grad.rfCenterBack + pe_grad.duration + ro_grad.timeToEcho; tau1 += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event temin = tau1 + GRADIENT_RES; /* ensure that te_delay is at least GRADIENT_RES */ te = granularity(te,GRADIENT_RES); if (minte[0] == 'y') { te = temin; putvalue("te",te); } if (FP_LT(te,temin)) { abort_message("TE too short. Minimum TE= %.3fms\n",temin*1000); } te_delay = te - tau1; /* Min TE2 *****************************************/ tau2 = (readrev) ? 2*ro_grad.timeFromEcho : ro_grad.duration+ref_grad.duration; te2min = tau2 + GRADIENT_RES; te2 = granularity(te2,GRADIENT_RES); if (minte2[0] == 'y') { te2 = te2min; putvalue("te2",te2); } if (FP_LT(te2,te2min)) { abort_message("TE2 too short. Minimum TE2= %.3fms\n",te2min*1000); } if (readrev) te2_delay = te2 - tau2; else { tau2 = ro_grad.duration + 3*ror_grad.duration; if (te2 >= tau2) { sepReadRephase = 1; // Set flag for separate read rephase te2_delay = te2 - ro_grad.duration - 2*ror_grad.duration; } else { sepReadRephase = 0; if (te2 > te2min+GRADIENT_RES) { ref_grad.duration = granularity(te2-ro_grad.duration-2*GRADIENT_RES,GRADIENT_RES); ref_grad.calcFlag = AMPLITUDE_FROM_MOMENT_DURATION; calc_dephase(&ref_grad,WRITE,ro_grad.m0,"",""); } te2_delay = te2 - ro_grad.duration - ref_grad.duration; } } /* Min TE3 *****************************************/ if (readrev) { tau3 = 2*ro_grad.timeToEcho; te3min = tau3 + GRADIENT_RES; te3 = granularity(te3,GRADIENT_RES); if (minte3[0] == 'y') { te3 = te3min; putvalue("te3",te3); } if (FP_LT(te3,te3min)) { abort_message("TE3 too short. Minimum TE3= %.3fms\n",te3min*1000); } te3_delay = te3 - tau3; } /* Now set the TE array accordingly */ putCmd("TE = 0"); /* Re-initialize TE */ putCmd("TE[1] = %f",te*1000); if (readrev) { for (i=1;i<ne;i++) { if (i%2 == 0) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te3*1000); else putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000); } } else { for (i=1;i<ne;i++) putCmd("TE[%d] = TE[%d]+%f",i+1,i,te2*1000); } /* Check nsblock, the number of slices blocked together (used for triggering and/or inversion recovery) */ check_nsblock(); /* Min TR ******************************************/ trmin = ss_grad.duration + te_delay + pe_grad.duration + ne*ro_grad.duration + perTime + 2*GRADIENT_RES; trmin += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event if (readrev) trmin += (ne/2)*te2_delay + ((ne-1)/2)*te3_delay; else trmin += (sepReadRephase) ? (ne-1)*(te2_delay+2*ror_grad.duration) : (ne-1)*(te2_delay+ref_grad.duration); /* Increase TR if any options are selected *********/ if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (mt[0] == 'y') trmin += mtTime; if (ticks > 0) trmin += 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 = %.3fms\n",trmin*1000); } /* Calculate tr delay */ tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES); /* Set pe_steps for profile or full image **********/ pe_steps = prep_profile(profile[0],nv,&pe_grad,&per_grad); F_initval(pe_steps/2.0,vpe_offset); /* 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); /* PULSE SEQUENCE ***************************************/ status(A); rotate(); triggerSelect(trigger); // Select trigger input 1/2/3 obsoffset(resto); delay(GRADIENT_RES); initval(fabs(ssc),vssc); // Compressed steady-state counter if (seqcon[2]=='s') assign(zero,vssc); // Zero for standard peloop assign(zero,vrfspoil_ctr); // RF spoil phase counter assign(zero,vrfspoil); // RF spoil multiplier assign(one,vacquire); // real-time acquire flag setacqvar(vacquire); // Turn on acquire when vacquire is zero /* trigger */ if (ticks > 0) F_initval((double)nsblock,vtrigblock); /* Begin phase-encode loop ****************************/ 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); } /* Set rcvr/xmtr phase for RF spoiling *******************/ if (rfspoil[0] == 'y') { incr(vrfspoil_ctr); // vrfspoil_ctr = 1 2 3 4 5 6 add(vrfspoil,vrfspoil_ctr,vrfspoil); // vrfspoil = 1 3 6 10 15 21 xmtrphase(vrfspoil); rcvrphase(vrfspoil); } /* Read external kspace table if set ******************/ if (table) getelem(t1,vpe_ctr,vpe_mult); else { ifzero(vacquire); sub(vpe_ctr,vpe_offset,vpe_mult); elsenz(vacquire); sub(zero,vpe_offset,vpe_mult); // Hold PE mult at initial value for steady states endif(vacquire); } /* PE rewinder follows PE table; zero if turned off ***/ if (perewind[0] == 'y') assign(vpe_mult,vper_mult); else assign(zero,vper_mult); /* Begin multislice loop ******************************/ msloop(seqcon[1],ns,vms_slices,vms_ctr); if (!trtype) delay(tr_delay); // Relaxation delay if (ticks > 0) { modn(vms_ctr,vtrigblock,vtest); ifzero(vtest); // if the beginning of an trigger block xgate(ticks); grad_advance(gpropdelay); delay(GRADIENT_RES); elsenz(vtest); delay(GRADIENT_RES); endif(vtest); } /* TTL scope trigger **********************************/ sp1on(); delay(GRADIENT_RES); sp1off(); /* Prepulse options ***********************************/ if (ir[0] == 'y') inversion_recovery(); if (sat[0] == 'y') satbands(); if (fsat[0] == 'y') fatsat(); if (mt[0] == 'y') mtc(); /* Slice select RF pulse ******************************/ obspower(p1_rf.powerCoarse); obspwrf(p1_rf.powerFine); delay(GRADIENT_RES); obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT); delay(ss_grad.rfDelayFront); shapedpulselist(shapeEx,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr); delay(ss_grad.rfDelayBack); /* Phase encode, refocus, and dephase gradient ********/ if (sepSliceRephase) { // separate slice refocus gradient obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT); delay(te_delay); // delay between slab refocus and pe pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,0, -pe_grad.increment,vpe_mult,WAIT); } else { pe_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp,0,-ssr_grad.amp, -pe_grad.increment,vpe_mult,WAIT); delay(te_delay); // delay after refocus/pe } F_initval(ne,vne); loop(vne,vne_ctr); if (readrev) { mod2(vne_ctr,vneindex); ifzero(vneindex); /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront-alfa); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); delay(te2_delay); endif(vnelast); elsenz(vneindex); /* Shift DDR for pro *******************************/ roff = -poffset(pro,-ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,-ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront-alfa); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); delay(te3_delay); endif(vnelast); endif(vneindex); } else { /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Readout gradient ********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp,0,0,NOWAIT); delay(ro_grad.atDelayFront-alfa); /* Acquisition ***************************************/ startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); sub(vne,vne_ctr,vnelast); sub(vnelast,one,vnelast); ifzero(vnelast); elsenz(vnelast); if (sepReadRephase) { obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT); delay(te2_delay); obl_shapedgradient(ror_grad.name,ror_grad.duration,-ror_grad.amp,0,0,WAIT); } else { obl_shapedgradient(ref_grad.name,ref_grad.duration,-ref_grad.amp,0,0,WAIT); delay(te2_delay); } endif(vnelast); } endloop(vne_ctr); /* Rewind / spoiler gradient **************************/ if ((perewind[0] == 'y') || (spoilflag[0] == 'y')) { pe_shapedgradient(pe_grad.name,pe_grad.duration,spoil_grad.amp,0,0,pe_grad.increment,vper_mult,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); }
void pulsesequence() { /* Internal variable declarations *********************/ int shapelist90,shapelist180,shapelistte=0; double kzero,thk2fact,thk3fact; double te1=0.0,te1_delay,te2_delay,te3_delay,tr_delay,te_delay1=0.0,te_delay2=0.0; double crushm0,pem0,gcrushr,gcrushp,gcrushs; double freq90[MAXNSLICE],freq180[MAXNSLICE],freqte[MAXNSLICE]; char autocrush[MAXSTR]; /* Phase encode variables */ FILE *fp; int tab[4096],petab[4096],odd,seg0,tabscheme; char tabname[MAXSTR],tabfile[MAXSTR]; int i,j,k; /* Diffusion variables */ double Gro,Gss; // "gdiff" for readout/readout refocus and slice/slice refocus double dgro,Dgro; // delta and DELTA for readout dephase & readout double dgss,Dgss; // delta and DELTA for excitation ss double dgss3,Dgss3; // delta and DELTA for spin echo prep ss double dcrush3,Dcrush3; // delta and DELTA for spin echo prep crusher double dgss2,Dgss2; // delta and DELTA for refocus ss double dcrush2,Dcrush2; // delta and DELTA for refocus crusher /* 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 vpe2_steps = v10; // Number of PE2 steps int vpe2_ctr = v11; // PE2 loop counter int vpe2_mult = v12; // PE2 multiplier int vpe2_offset = v13; // PE2/2 for non-table offset int vssc = v14; // Compressed steady-states int vtrimage = v15; // Counts down from nt, trimage delay when 0 int vacquire = v16; // Argument for setacqvar, to skip steady state acquires int vphase180 = v17; // phase of 180 degree refocusing pulse int vtrigblock = v18; // Number of slices per trigger block /* Initialize paramaters ******************************/ init_mri(); kzero = getval("kzero"); getstr("autocrush",autocrush); tabscheme = getval("tabscheme"); getstr("spoilflag",spoilflag); /* Allow ROxPE2 projection ****************************/ if (profile[0] == 'y' && profile[1] == 'n') { etl=1; kzero=1; nv=nv2; } else { /* Check kzero is valid *****************************/ if (kzero<1) kzero=1; if (kzero>etl) kzero=etl; putCmd("kzero = %d",(int)kzero); } /* Set petable name and full path *********************/ sprintf(tabname,"fse%d_%d_%d",(int)nv,(int)etl,(int)kzero); putCmd("petable = '%s'",tabname); strcpy(tabfile,userdir); strcat(tabfile,"/tablib/"); strcat(tabfile,tabname); /* Generate phase encode table ************************/ if (tabscheme) { /* New scheme */ /* Calculate PE table for kzero=1 */ seg0=nseg/2; for (j=0;j<seg0;j++) { for (i=0;i<etl/2;i++) tab[j*(int)etl+i] = i*nseg+seg0-j; for (i=1;i<=etl/2;i++) tab[(j+1)*(int)etl-i] = tab[j*(int)etl]-i*nseg; } for (j=seg0;j<nseg;j++) { for (i=0;i<=etl/2;i++) tab[j*(int)etl+i] = i*nseg+seg0-j; for (i=1;i<etl/2;i++) tab[(j+1)*(int)etl-i] = tab[j*(int)etl]-i*nseg; } /* Adjust for kzero */ for (i=0;i<nseg;i++) { k=i*etl; for (j=0;j<kzero-1;j++) petab[k+j]=tab[k+(int)etl-(int)kzero+j+1]; for (j=kzero-1;j<etl;j++) petab[k+j]=tab[k+j-(int)kzero+1]; } } else { /* Original scheme */ /* Calculate PE table for kzero=1 */ odd=(int)nseg%2; seg0=nseg/2+odd; k=0; for (i=0;i<etl;i++) for (j=seg0-odd*i%2-1;j>=0;j--) tab[j*(int)etl+i] = k--; k=1; for (i=0;i<etl;i++) for (j=seg0-odd*i%2;j<nseg;j++) tab[j*(int)etl+i] = k++; /* Adjust for kzero */ for (i=0;i<nseg;i++) { k=i*etl; for (j=0;j<kzero-1;j++) petab[k+j]=tab[k+(int)etl-j-1]; for (j=kzero-1;j<etl;j++) petab[k+j]=tab[k+j-(int)kzero+1]; } } /* Set petable name and full path *********************/ sprintf(tabname,"fse%d_%d_%d",(int)nv,(int)etl,(int)kzero); putCmd("petable = '%s'",tabname); strcpy(tabfile,userdir); strcat(tabfile,"/tablib/"); strcat(tabfile,tabname); /* Write to tabfile ***********************************/ fp=fopen(tabfile,"w"); fprintf(fp,"t1 ="); for (i=0;i<nseg;i++) { fprintf(fp,"\n"); for (j=0;j<etl;j++) fprintf(fp,"%3d\t",petab[i*(int)etl+j]); } fclose(fp); /* Set pelist to contain table order ******************/ putCmd("pelist = 0"); /* Re-initialize pelist */ for (i=0;i<nseg*etl;i++) putCmd("pelist[%d] = %d",i+1,petab[i]); /* Avoid gradient slew rate errors */ for (i=0;i<nseg*etl;i++) if (abs(petab[i]) > nv/2) petab[i]=0; /* Set phase encode table *****************************/ settable(t1,(int)etl*nseg,petab); /* 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"); /* Calculate thk2fact to ensure gss=gss2 for the choice of p1 and p2 so that the sequence remains robust in the absence of correct balancing of slice select and slice refocus gradients */ thk2fact=p2_rf.bandwidth/p1_rf.bandwidth; putvalue("thk2fact",thk2fact); /* Initialize gradient structures *********************/ init_readout(&ro_grad,"ro",lro,np,sw); ro_grad.pad1=alfa; ro_grad.pad2=alfa; init_readout_refocus(&ror_grad,"ror"); init_phase(&pe_grad,"pe",lpe,nv); init_phase(&pe2_grad,"pe2",lpe2,nv2); init_slice(&ss_grad,"ss",thk); init_slice(&ss2_grad,"ss2",thk*thk2fact); init_slice_refocus(&ssr_grad,"ssr"); init_dephase(&crush_grad,"crush"); /* Gradient calculations ******************************/ calc_readout(&ro_grad,WRITE,"gro","sw","at"); calc_readout_refocus(&ror_grad,&ro_grad,WRITE,"gror"); calc_phase(&pe_grad,NOWRITE,"",""); calc_phase(&pe2_grad,NOWRITE,"",""); calc_slice(&ss_grad,&p1_rf,WRITE,"gss"); calc_slice(&ss2_grad,&p2_rf,WRITE,""); calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr"); /* Equalize refocus gradient durations ****************/ calc_sim_gradient(&ror_grad,&null_grad,&ssr_grad,0.0,WRITE); /* Equalize PE gradient durations *********************/ calc_sim_gradient(&pe_grad,&pe2_grad,&null_grad,0.0,WRITE); /* Set crushing gradient moment ***********************/ crushm0=fabs(gcrush*tcrush); if (spoilflag[0] == 'y') { init_generic(&spoil_grad,"spoil",gspoil,tspoil); calc_generic(&spoil_grad,WRITE,"gspoil","tspoil"); } /* Create optional prepulse events ********************/ if (sat[0] == 'y') create_satbands(); if (fsat[0] == 'y') create_fatsat(); if (mt[0] == 'y') create_mtc(); if (ir[0] == 'y') create_inversion_recovery(); if (diff[0] == 'y') init_diffusion(&diffusion,&diff_grad,"diff",gdiff,tdelta); if (diff[0] == 'y') { /* Diffusion encoding is during spin echo preparation */ spinecho[0]='y'; putCmd("spinecho='y'"); } if (spinecho[0] == 'y') { /* spin echo preparation */ shape_rf(&p3_rf,"p3",p3pat,p3,flip3,rof1,rof2); calc_rf(&p3_rf,"tpwr3","tpwr3f"); /* Calculate thk3fact to ensure gss=gss2=gss3 for the choice of p1, p2 and p3 so that the sequence remains robust in the absence of correct balancing of slice select and slice refocus gradients */ thk3fact=p3_rf.bandwidth/p1_rf.bandwidth; putvalue("thk3fact",thk3fact); init_slice(&ss3_grad,"ss3",thk*thk3fact); calc_slice(&ss3_grad,&p3_rf,WRITE,""); putvalue("gss3",ss3_grad.ssamp); offsetlist(pss,ss3_grad.ssamp,0,freqte,ns,seqcon[1]); shapelistte = shapelist(p3_rf.pulseName,ss3_grad.rfDuration,freqte,ns,ss3_grad.rfFraction,seqcon[1]); /* Automatically set crushers to avoid unwanted echoes */ if (autocrush[0] == 'y') { if (crushm0 < 0.6*ro_grad.m0) crushm0=0.6*ro_grad.m0; } } /* Make sure crushing in PE dimensions does not refocus signal from 180 */ pem0 = (pe_grad.m0 > pe2_grad.m0) ? pe_grad.m0 : pe2_grad.m0; calc_dephase(&crush_grad,WRITE,crushm0+pem0,"",""); gcrushr = crush_grad.amp*crushm0/crush_grad.m0; gcrushp = crush_grad.amp*(crushm0+pe_grad.m0)/crush_grad.m0; gcrushs = crush_grad.amp*(crushm0+pe2_grad.m0)/crush_grad.m0; sgl_error_check(sglerror); /* Set up frequency offset pulse shape list ***********/ offsetlist(pss,ss_grad.amp,0,freq90,ns,seqcon[1]); offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]); shapelist90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freq90,ns,ss_grad.rfFraction,seqcon[1]); shapelist180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,ss2_grad.rfFraction,seqcon[1]); /* To ensure proper overlap spin and stimulated echoes ensure that the middle of the refocusing RF pulse is the centre of the pulse and that echoes are formed in the centre of the acquisition window */ if (ss2_grad.rfFraction != 0.5) abort_message( "ERROR %s: Refocusing RF pulse must be symmetric (RF fraction = %.2f)", seqfil,ss2_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 ****/ esp = granularity(esp,2*GRADIENT_RES); tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + GRADIENT_RES; tau2 = ss2_grad.rfCenterBack + crush_grad.duration + pe_grad.duration + ro_grad.timeToEcho + GRADIENT_RES; tau3 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + GRADIENT_RES; espmin = 2*MAX(MAX(tau1,tau2),tau3); // Minimum echo spacing if (minesp[0] == 'y') { esp = espmin; putvalue("esp",esp); } if (FP_LT(esp,espmin)) { abort_message("ERROR %s: Echo spacing too small, minimum is %.3fms\n",seqfil,espmin*1000); } te1_delay = esp/2.0 - tau1 + GRADIENT_RES; // Intra-esp delays te2_delay = esp/2.0 - tau2 + GRADIENT_RES; te3_delay = esp/2.0 - tau3 + GRADIENT_RES; /* Spin echo preparation ******************************/ if (spinecho[0] == 'y') { te = granularity(te,2*GRADIENT_RES); te1 = te-kzero*esp; tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss3_grad.duration/2.0 + GRADIENT_RES; tau2 = ss3_grad.duration/2.0 + crush_grad.duration + GRADIENT_RES; 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 = ss3_grad.duration + 2*crush_grad.duration; /* set minimum diffusion structure requirements for gradient echo: taudiff, tDELTA, te and minte[0] */ set_diffusion(&diffusion,taudiff,tDELTA,te1,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') { te1 = temin; te = te1+kzero*esp; putvalue("te",te); } te_delay1 = te1/2 - tau1 + GRADIENT_RES; te_delay2 = te1/2 - tau2 + GRADIENT_RES; if (FP_LT(te,temin+kzero*esp)) { abort_message("ERROR %s: TE too short, minimum TE = %.3f ms\n",seqfil,temin*1000); } } else putvalue("te",kzero*esp); // Return effective TE /* Check nsblock, the number of slices blocked together (used for triggering and/or inversion recovery) */ check_nsblock(); /* 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); // readout dephase & readout delta Gro = ro_grad.m0ref/dgro; // readout dephase & readout gradient strength Dgro = dgro+2*crush_grad.duration+ss2_grad.duration+te2_delay+pe_grad.duration; // readout dephase & readout DELTA dgss = 0.5*(ss_grad.rfCenterBack+ssr_grad.duration); // slice & slice refocus delta Gss = ss_grad.m0ref/dgss; // slice & slice refocus gradient strength Dgss = dgss; // slice & slice refocus DELTA dgss2 = (ss2_grad.duration-ss2_grad.tramp)/2.0; // refocus slice select delta Dgss2 = dgss2; // refocus slice select DELTA dcrush2 = crush_grad.duration-crush_grad.tramp; // refocus crusher delta Dcrush2 = crush_grad.duration+ss2_grad.duration; // refocus crusher DELTA dcrush3 = crush_grad.duration-crush_grad.tramp; // spin echo prep crusher delta Dcrush3 = crush_grad.duration+ss3_grad.duration; // spin echo prep crusher DELTA dgss3 = (ss3_grad.duration-ss3_grad.tramp)/2.0; // spin echo prep slice select delta Dgss3 = dgss3; // spin echo prep slice select DELTA 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(gcrushr,dcrush2,Dcrush2); diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,gcrushr,dcrush2,Dcrush2); /* Phase */ diffusion.bpe[i] += bval(gcrushp,dcrush2,Dcrush2); /* Slice */ diffusion.bsl[i] += bval(Gss,dgss,Dgss); diffusion.bsl[i] += bval(gcrushs,dcrush2,Dcrush2); diffusion.bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2); diffusion.bsl[i] += bval_nested(gcrushs,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2); /* Readout/Phase Cross-terms */ diffusion.brp[i] += bval2(gcrushr,gcrushp,dcrush2,Dcrush2); /* Readout/Slice Cross-terms */ diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gcrushs,dcrush2,Dcrush2); diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,ss2_grad.ssamp,dgss2,Dgss2); diffusion.brs[i] += bval2(gcrushr,gcrushs,dcrush2,Dcrush2); diffusion.brs[i] += bval_cross(gcrushr,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2); /* Slice/Phase Cross-terms */ diffusion.bsp[i] += bval2(gcrushs,gcrushp,dcrush2,Dcrush2); diffusion.bsp[i] += bval_cross(gcrushp,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2); if (spinecho[0] == 'y') { /* Readout */ diffusion.bro[i] += bval(crush_grad.amp,dcrush3,Dcrush3); diffusion.bro[i] += bval_nested(gdiff*droval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3); /* Slice */ diffusion.bsl[i] += bval(ss3_grad.amp,dgss3,Dgss3); diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,ss3_grad.ssamp,dgss3,Dgss3); /* Readout/Slice Cross-terms */ diffusion.brs[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3); diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,ss3_grad.amp,dgss3,Dgss3); diffusion.brs[i] += bval_cross(crush_grad.amp,dcrush3,Dcrush3,ss3_grad.amp,dgss3,Dgss3); /* Readout/Phase Cross-terms */ diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3); /* Slice/Phase Cross-terms */ diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,ss3_grad.amp,dgss3,Dgss3); } } /* End for-all-directions */ /* Write the values */ write_bvalues(&diffusion,"bval","bvalue","max_bval"); } /* Minimum TR *****************************************/ trmin = ss_grad.rfCenterFront + etl*esp + ro_grad.timeFromEcho + pe_grad.duration + te3_delay + 2*GRADIENT_RES; if (spoilflag[0] == 'y') trmin += spoil_grad.duration; /* Increase TR if any options are selected ************/ if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (mt[0] == 'y') trmin += mtTime; if (spinecho[0] == 'y') trmin += te1; 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("ERROR %s: TR too short, minimum TR = %.3fms\n",seqfil,trmin*1000); } /* Calculate tr delay *********************************/ tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES); /* Set number of segments for profile or full image ***/ nseg = prep_profile(profile[0],nseg,&pe_grad,&null_grad); pe2_steps = prep_profile(profile[1],nv2,&pe2_grad,&null_grad); F_initval(pe2_steps/2.0,vpe2_offset); /* Shift DDR for pro **********************************/ roff = -poffset(pro,ro_grad.roamp); /* Adjust experiment time for VnmrJ *******************/ if (ssc<0) { if (seqcon[2] == 's' && seqcon[3]=='s') g_setExpTime(trmean*ntmean*arraydim - ssc*arraydim); else if (seqcon[2]=='s') g_setExpTime(trmean*nseg*(ntmean*pe2_steps*arraydim - ssc*arraydim)); else if (seqcon[3]=='s') g_setExpTime(trmean*pe2_steps*(ntmean*nseg*arraydim - ssc*arraydim)); else g_setExpTime(trmean*(ntmean*pe_steps*pe2_steps*arraydim - ssc*arraydim)); } else g_setExpTime(trmean*ntmean*nseg*pe2_steps*arraydim + tr*ssc); /* 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' && seqcon[3]=='s') assign(zero,vssc); // Zero for standard peloop and pe2loop 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); /* trigger */ if (ticks > 0) F_initval((double)nsblock,vtrigblock); /* Begin phase-encode loop ****************************/ peloop2(seqcon[3],pe2_steps,vpe2_steps,vpe2_ctr); /* Begin phase-encode loop ****************************/ peloop(seqcon[2],nseg,vseg,vseg_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); if (seqcon[2] == 'c') sub(vseg_ctr,vssc,vseg_ctr); // vseg_ctr counts up from -ssc else if (seqcon[3] == 'c') sub(vpe2_ctr,vssc,vpe2_ctr); // vpe2_ctr counts up from -ssc assign(zero,vssc); if (seqcon[2] == 's' && seqcon[3]=='s') assign(zero,vacquire); // Always acquire for non-compressed loop else { if (seqcon[2] == 'c') { ifzero(vseg_ctr); assign(zero,vacquire); // Start acquiring when vseg_ctr reaches zero endif(vseg_ctr); } else if (seqcon[3] == 'c') { ifzero(vpe2_ctr); assign(zero,vacquire); // Start acquiring when vpe2_ctr reaches zero endif(vpe2_ctr); } } setacqvar(vacquire); // Turn on acquire when vacquire is zero /* Use standard encoding order for 2nd PE dimension */ ifzero(vacquire); sub(vpe2_ctr,vpe2_offset,vpe2_mult); elsenz(vacquire); sub(zero,vpe2_offset,vpe2_mult); endif(vacquire); 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(); /* 90 degree 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(shapelist90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr); delay(ss_grad.rfDelayBack); /* Spin echo preparation ******************************/ if (spinecho[0] == 'y') { obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0.0,0.0,-ssr_grad.amp,WAIT); if (diff[0] == 'y') { delay(diffusion.d1); diffusion_dephase(&diffusion,dro,dpe,dsl); delay(diffusion.d2); } else delay(te_delay1); obspower(p3_rf.powerCoarse); obspwrf(p3_rf.powerFine); obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0.0,0.0,WAIT); obl_shapedgradient(ss3_grad.name,ss3_grad.duration,0,0,ss3_grad.amp,NOWAIT); delay(ss3_grad.rfDelayFront); shapedpulselist(shapelistte,ss3_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr); delay(ss3_grad.rfDelayBack); obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0.0,0.0,WAIT); if (diff[0] == 'y') { delay(diffusion.d3); diffusion_rephase(&diffusion,dro,dpe,dsl); delay(diffusion.d4); } else delay(te_delay2); delay(ss_grad.duration/2.0); delay(te1_delay); obspower(p2_rf.powerCoarse); obspwrf(p2_rf.powerFine); obl_shapedgradient(ror_grad.name,ror_grad.duration,ror_grad.amp,0.0,0.0,WAIT); } else { /* 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); } F_initval(etl,vetl); loop(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 *********************************/ obl_shapedgradient(crush_grad.name,crush_grad.duration,gcrushr,gcrushp,gcrushs,WAIT); 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); obl_shapedgradient(crush_grad.name,crush_grad.duration,gcrushr,gcrushp,gcrushs,WAIT); /* Second half-TE period ****************************/ delay(te2_delay); /* Phase-encode gradient ****************************/ pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,-pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT); /* Readout gradient *********************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.roamp,0,0,NOWAIT); delay(ro_grad.atDelayFront-alfa); /* Acquire data *************************************/ startacq(alfa); acquire(np,1.0/sw); endacq(); delay(ro_grad.atDelayBack); /* Rewinding phase-encode gradient ******************/ pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,pe_grad.increment,pe2_grad.increment,vpe_mult,vpe2_mult,WAIT); /* Second half-TE delay *****************************/ delay(te3_delay); endloop(vetl_ctr); if (spoilflag[0] == 'y') obl_shapedgradient(spoil_grad.name,spoil_grad.duration,spoil_grad.amp,spoil_grad.amp,spoil_grad.amp,WAIT); endmsloop(seqcon[1],vms_ctr); endpeloop(seqcon[2],vseg_ctr); endpeloop(seqcon[3],vpe2_ctr); /* Inter-image delay **********************************/ sub(ntrt,ct,vtrimage); decr(vtrimage); ifzero(vtrimage); delay(trimage); endif(vtrimage); }
pulsesequence() { /* Internal variable declarations *************************/ double freqEx[MAXNSLICE]; double pespoil_amp,spoilMoment,maxgradtime,pe2_offsetamp=0.0,nvblock; double tetime,te_delay,tr_delay,perTime; int table=0,shapeEx=0,sepSliceRephase=0,image,blocknvs; char spoilflag[MAXSTR],perName[MAXSTR],slab[MAXSTR]; /* Real-time variables used in this sequence **************/ int vpe_steps = v1; // Number of PE steps int vpe_ctr = v2; // PE loop counter int vpe_offset = v3; // PE/2 for non-table offset int vpe_mult = v4; // PE multiplier, ranges from -PE/2 to PE/2 int vper_mult = v5; // PE rewinder multiplier; turn off rewinder when 0 int vpe2_steps = v6; // Number of PE2 steps int vpe2_ctr = v7; // PE2 loop counter int vpe2_mult = v8; // PE2 multiplier int vpe2_offset = v9; // PE2/2 for non-table offset int vpe2r_mult = v10; // PE2 rewinder multiplier int vtrigblock = v11; // Number of PE steps per trigger block int vpe = v12; // Current PE step out of total PE*PE2 steps /* Initialize paramaters *********************************/ init_mri(); getstr("spoilflag",spoilflag); getstr("slab",slab); image = getval("image"); blocknvs = (int)getval("blocknvs"); nvblock = getval("nvblock"); if (!blocknvs) nvblock=1; // If blocked PEs for trigger not selected nvblock=1 trmin = 0.0; temin = 0.0; /* Check for external PE table ***************************/ if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); table = 1; } if (ns > 1) abort_message("No of slices must be set to one"); /* RF Calculations ****************************************/ init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2); /* hard pulse */ init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof2); /* soft pulse */ calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); /* Gradient calculations **********************************/ if (slab[0] == 'y') { init_slice(&ss_grad,"ss",thk); init_slice_refocus(&ssr_grad,"ssr"); calc_slice(&ss_grad,&p2_rf,WRITE,"gss"); calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr"); } if (FP_GT(tcrushro,0.0)) init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); else init_readout(&ro_grad,"ro",lro,np,sw); init_readout_refocus(&ror_grad,"ror"); calc_readout(&ro_grad,WRITE,"gro","sw","at"); ro_grad.m0ref *= grof; calc_readout_refocus(&ror_grad,&ro_grad,NOWRITE,"gror"); init_phase(&pe_grad,"pe",lpe,nv); init_phase(&pe2_grad,"pe2",lpe2,nv2); calc_phase(&pe_grad,NOWRITE,"gpe","tpe"); if (!blocknvs) nvblock=1; calc_phase(&pe2_grad,NOWRITE,"gpe2",""); if (spoilflag[0] == 'y') { // Calculate spoil grad if spoiling is turned on init_dephase(&spoil_grad,"spoil"); // Optimized spoiler spoilMoment = ro_grad.acqTime*ro_grad.roamp; // Optimal spoiling is at*gro for 2pi per pixel spoilMoment -= ro_grad.m0def; // Subtract partial spoiling from back half of readout calc_dephase(&spoil_grad,WRITE,spoilMoment,"gspoil","tspoil"); } /* Is TE long enough for separate slab refocus? ***********/ maxgradtime = MAX(ror_grad.duration,MAX(pe_grad.duration,pe2_grad.duration)); if (spoilflag[0] == 'y') maxgradtime = MAX(maxgradtime,spoil_grad.duration); tetime = maxgradtime + alfa + ro_grad.timeToEcho + 4e-6; if (slab[0] == 'y') { tetime += ss_grad.rfCenterBack + ssr_grad.duration; if ((te >= tetime) && (minte[0] != 'y')) { sepSliceRephase = 1; // Set flag for separate slice rephase } else { pe2_grad.areaOffset = ss_grad.m0ref; // Add slab refocus on pe2 axis calc_phase(&pe2_grad,NOWRITE,"gpe2",""); // Recalculate pe2 to include slab refocus } } /* Equalize refocus and PE gradient durations *************/ pespoil_amp = 0.0; perTime = 0.0; if ((perewind[0] == 'y') && (spoilflag[0] == 'y')) { // All four must be single shape if (ror_grad.duration > spoil_grad.duration) { // calc_sim first with ror calc_sim_gradient(&pe_grad,&pe2_grad,&ror_grad,tpemin,WRITE); calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,NOWRITE); } else { // calc_sim first with spoil calc_sim_gradient(&pe_grad,&pe2_grad,&spoil_grad,tpemin,WRITE); calc_sim_gradient(&ror_grad,&spoil_grad,&null_grad,tpemin,NOWRITE); } strcpy(perName,pe_grad.name); perTime = pe_grad.duration; putvalue("tspoil",perTime); putvalue("gspoil",spoil_grad.amp); } else { // post-acquire shape will be either pe or spoil, but not both calc_sim_gradient(&ror_grad,&pe_grad,&pe2_grad,tpemin,WRITE); if ((perewind[0] == 'y') && (spoilflag[0] == 'n')) { // Rewinder, no spoiler strcpy(perName,pe_grad.name); perTime = pe_grad.duration; spoil_grad.amp = 0.0; putvalue("tpe",perTime); } else if ((perewind[0] == 'n') && (spoilflag[0] == 'y')) { // Spoiler, no rewinder strcpy(perName,spoil_grad.name); perTime = spoil_grad.duration; pespoil_amp = spoil_grad.amp; // Apply spoiler on PE & PE2 axis if no rewinder } } if (slab[0] == 'y') pe2_offsetamp = sepSliceRephase ? 0.0 : pe2_grad.offsetamp; // pe2 slab refocus /* Create optional prepulse events ************************/ if (sat[0] == 'y') create_satbands(); if (fsat[0] == 'y') create_fatsat(); sgl_error_check(sglerror); // Check for any SGL errors /* Min TE ******************************************/ tetime = pe_grad.duration + alfa + ro_grad.timeToEcho; if (slab[0] == 'y') { tetime += ss_grad.rfCenterBack; tetime += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event } else if (ws[0] == 'y') tetime += p2/2.0 + rof2; /* soft pulse */ else tetime += p1/2.0 + rof2; /* hard pulse */ temin = tetime + 4e-6; // Ensure that te_delay is at least 4us if (minte[0] == 'y') { te = temin; putvalue("te",te); } if (te < temin) { abort_message("TE too short. Minimum TE= %.2fms\n",temin*1000+0.005); } te_delay = te - tetime; /* Min TR ******************************************/ trmin = te_delay + pe_grad.duration + ro_grad.duration + perTime; if (slab[0] == 'y') { trmin += ss_grad.duration; trmin += (sepSliceRephase) ? ssr_grad.duration : 0.0; // Add slice refocusing if separate event } else if (ws[0] == 'y') trmin += p2 +rof1 + rof2; /* soft pulse */ else trmin += p1 +rof1 + rof2; /* hard pulse */ trmin += 8e-6; /* Increase TR if any options are selected *********/ if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (ticks > 0) trmin += 4e-6; if (mintr[0] == 'y') { tr = trmin; putvalue("tr",tr); } if (FP_LT(tr,trmin)) { abort_message("TR too short. Minimum TR = %.2fms\n",trmin*1000+0.005); } /* Calculate tr delay */ tr_delay = granularity(tr-trmin,GRADIENT_RES); if(slab[0] == 'y') { /* Generate phase-ramped pulses: 90 */ offsetlist(pss,ss_grad.ssamp,0,freqEx,ns,seqcon[1]); shapeEx = shapelist(p1pat,ss_grad.rfDuration,freqEx,ns,ss_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); pe2_steps = prep_profile(profile[1],nv2,&pe2_grad,&null_grad); F_initval(pe2_steps/2.0,vpe2_offset); assign(zero,oph); /* Shift DDR for pro *******************************/ roff = -poffset(pro,ro_grad.roamp); /* Adjust experiment time for VnmrJ *******************/ g_setExpTime(tr*(nt*pe_steps*pe2_steps)); /* PULSE SEQUENCE *************************************/ status(A); rotate(); triggerSelect(trigger); // Select trigger input 1/2/3 obsoffset(resto); delay(4e-6); /* trigger */ if (ticks > 0) F_initval((double)nvblock,vtrigblock); /* Begin phase-encode loop ****************************/ peloop2(seqcon[3],pe2_steps,vpe2_steps,vpe2_ctr); peloop(seqcon[2],pe_steps,vpe_steps,vpe_ctr); delay(tr_delay); // relaxation delay sub(vpe_ctr,vpe_offset,vpe_mult); sub(vpe2_ctr,vpe2_offset,vpe2_mult); mult(vpe2_ctr,vpe_steps,vpe); add(vpe_ctr,vpe,vpe); /* PE rewinder follows PE table; zero if turned off ***/ if (perewind[0] == 'y') { assign(vpe_mult,vper_mult); assign(vpe2_mult,vpe2r_mult); } else { assign(zero,vper_mult); assign(zero,vpe2r_mult); } if (ticks > 0) { modn(vpe,vtrigblock,vtest); ifzero(vtest); // if the beginning of an trigger block xgate(ticks); grad_advance(gpropdelay); delay(4e-6); elsenz(vtest); delay(4e-6); endif(vtest); } sp1on(); delay(4e-6); sp1off(); // Scope trigger /* Prepulse options ***********************************/ if (sat[0] == 'y') satbands(); if (fsat[0] == 'y') fatsat(); if (slab[0] == 'y') { obspower(p2_rf.powerCoarse); obspwrf(p2_rf.powerFine); delay(4e-6); obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT); delay(ss_grad.rfDelayFront); shapedpulselist(shapeEx,ss_grad.rfDuration,zero,rof1,rof2,seqcon[1],zero); delay(ss_grad.rfDelayBack); if (sepSliceRephase) { obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT); delay(te_delay + tau); /* tau is current B0 encoding delay */ } } else { obspower(p1_rf.powerCoarse); obspwrf(p1_rf.powerFine); delay(4e-6); if (ws[0] == 'y') shapedpulse(p2pat,p2,zero,rof1,rof2); /* soft CS pulse */ else shapedpulse(p1pat,p1,zero,rof1,rof2); /* hard pulse */ delay(te_delay + tau); /* tau is current B0 encoding delay */ } pe2_shapedgradient(pe_grad.name,pe_grad.duration,-ror_grad.amp*image,0,-pe2_offsetamp, -pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT); if ((slab[0] == 'y') && !sepSliceRephase) delay(te_delay + tau); /* tau is current B0 encoding delay */ /* Readout gradient and acquisition ********************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.amp*image,0,0,NOWAIT); delay(ro_grad.atDelayFront); startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); /* Rewind / spoiler gradient *********************************/ if (perewind[0] == 'y' || (spoilflag[0] == 'y')) { pe2_shapedgradient(perName,perTime,spoil_grad.amp,pespoil_amp,pespoil_amp, pe_grad.increment,pe2_grad.increment,vper_mult,vpe2r_mult,WAIT); } endpeloop(seqcon[2],vpe_ctr); endpeloop(seqcon[3],vpe2_ctr); }
void pulsesequence() { double base, qlvl; char sspul[MAXSTR]; /* LOAD VARIABLES AND CHECK CONDITIONS */ 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) add(id2, v1, v1); /* TPPI increment */ /* BEGIN ACTUAL PULSE SEQUENCE CODE */ if (newtrans) obsstepsize(base); status(A); if (sspul[A] == 'y') { rgpulse(200*pw, zero, rof1,0.0e-6); rgpulse(200*pw, one, 0.0e-6, rof1); } if (satmode[A] == 'y') { obspower(satpwr); rgpulse(satdly,zero,rof1,rof1); obspower(tpwr); } status(B); if (newtrans) xmtrphase(v10); /* hardware digital phaseshift */ rgpulse(pw, v1, rof1, 1.0e-6); if (satmode[B] == 'y') { obspower(satpwr); if (d2>0.0) rgpulse(d2 -9.4e-6 -rof1 -(4*pw)/3.1416,zero,0.0,0.0); obspower(tpwr); } else { if (d2>0.0) delay(d2 -1.0e-6 -rof1 -(4*pw)/3.1416); } rcvroff(); 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() { /* Internal variable declarations *************************/ int shapelist90,shapelist180; int table = 0; double tau1,tau2,tau3,te1_delay,te2_delay,te3_delay,tr_delay; double freq90[MAXNSLICE],freq180[MAXNSLICE]; double thk2fact,crush_step,neby2,crush_ind; int suppressSTE,*crushtab; char crushmod[MAXSTR]; 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 vpe_mult = v3; // PE multiplier, ranges from -PE/2 to PE/2 int vpe_offset = v4; // PE/2 for non-table offset int vms_slices = v5; // Number of slices int vms_ctr = v6; // Slice loop counter int vne = v7; // Number of echoes int vne_ctr = v8; // Echo loop counter 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 vphase90 = v12; // Phase of 90 degree excitation pulse int vphase180 = v13; // Phase of 180 degree refocusing pulse int vphindex = v14; // Phase cycle index int vneindex = v15; // Echo index, odd or even int vcrush = v16; // Crusher modulation int vtrigblock = v17; // Number of slices per trigger block /* Initialize paramaters **********************************/ init_mri(); getstr("crushmod",crushmod); suppressSTE=getval("suppressSTE"); /* Load external PE table ********************************/ if (strcmp(petable,"n") && strcmp(petable,"N") && strcmp(petable,"")) { loadtable(petable); 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"); /* Calculate thk2fact to ensure gss=gss2 for the choice of p1 and p2 so that the sequence remains robust in the absence of correct balancing of slice select and slice refocus gradients */ thk2fact=p2_rf.bandwidth/p1_rf.bandwidth; putvalue("thk2fact",thk2fact); /* Initialize gradient structures *************************/ init_readout(&ro_grad,"ro",lro,np,sw); ro_grad.pad1=alfa; ro_grad.pad2=alfa; init_readout_refocus(&ror_grad,"ror"); init_phase(&pe_grad,"pe",lpe,nv); init_slice(&ss_grad,"ss",thk); init_slice(&ss2_grad,"ss2",thk*thk2fact); init_slice_refocus(&ssr_grad,"ssr"); init_generic(&crush_grad,"crush",gcrush,tcrush); /* 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,&p2_rf,WRITE,""); calc_slice_refocus(&ssr_grad,&ss_grad,NOWRITE,"gssr"); calc_generic(&crush_grad,WRITE,"",""); /* Equalize slice 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') create_inversion_recovery(); sgl_error_check(sglerror); /* Set up frequency offset pulse shape list ********/ offsetlist(pss,ss_grad.amp,0,freq90,ns,seqcon[1]); offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]); shapelist90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freq90,ns,ss_grad.rfFraction,seqcon[1]); shapelist180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,ss2_grad.rfFraction,seqcon[1]); /* To ensure proper overlap spin and stimulated echoes ensure that the middle of the refocusing RF pulse is the centre of the pulse and that echoes are formed in the centre of the acquisition window */ if (ss2_grad.rfFraction != 0.5) abort_message("ERROR %s: Refocusing RF pulse must be symmetric (RF fraction = %.2f)", seqfil,ss2_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 + crush_grad.duration + ss2_grad.rfCenterFront; tau2 = ss2_grad.rfCenterBack + pe_grad.duration + crush_grad.duration + ro_grad.timeToEcho; tau3 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront; espmin = 2*MAX(MAX(tau1,tau2),tau3); // Minimum echo spacing espmin += 2*GRADIENT_RES; // Ensure that each delay is at least GRADIENT_RES te = granularity(te,2*GRADIENT_RES); if (minesp[0] == 'y') { te = espmin; putvalue("te",te); } if (FP_LT(te,espmin)) { abort_message("ERROR %s: Echo time too small, minimum is %.3fms\n",seqfil,espmin*1000); } te1_delay = te/2.0 - tau1; // Intra-esp delays te2_delay = te/2.0 - tau2; te3_delay = te/2.0 - tau3; /* Now set the TE processing array accordingly */ putCmd("TE = 0"); /* Re-initialize TE */ for (i=0;i<ne;i++) putCmd("TE[%d] = %f",i+1,te*1000*(i+1)); /* Check nsblock, the number of slices blocked together (used for triggering and/or inversion recovery) */ check_nsblock(); /* Minimum TR **************************************/ trmin = ss_grad.rfCenterFront + ne*te + ro_grad.timeFromEcho + pe_grad.duration + te3_delay + 2*GRADIENT_RES; /* Increase TR if any options are selected *********/ if (sat[0] == 'y') trmin += satTime; if (fsat[0] == 'y') trmin += fsatTime; if (mt[0] == 'y') trmin += mtTime; if (ticks > 0) trmin += 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("ERROR %s: TR too short, minimum TR is %.3fms\n",seqfil,trmin*1000); } /* Calculate tr delay */ tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES); /* Set pe_steps for profile or full image **********/ pe_steps = prep_profile(profile[0],nv,&pe_grad,&per_grad); F_initval(pe_steps/2.0,vpe_offset); /* 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); /* Set phase cycle tables */ if (suppressSTE) { if ((int)nt%2 == 1) abort_message("STE suppression requires a 2 step phase cycle. Set nt as a multiple of 2\n"); settable(t2,4,phref1s); settable(t3,4,phref2s); settable(t4,4,phrec1s); settable(t5,4,phrec2s); } else { settable(t2,4,phref1); settable(t3,4,phref2); settable(t4,4,phrec1); settable(t5,4,phrec2); } /* Set crusher table */ crushtab=malloc((int)ne*sizeof(int)); neby2=ceil(ne/2.0 - US); // US to handle precision errors crush_step=gcrush/neby2; for (i=0; i<ne; i++) { crush_ind = (1.0-2.0*(i%2))*(neby2-floor(i/2)); crushtab[i] = (int)(crush_ind); } settable(t6,(int)ne,crushtab); /* PULSE SEQUENCE ***************************************/ status(A); rotate(); triggerSelect(trigger); // Select trigger input 1/2/3 obsoffset(resto); delay(GRADIENT_RES); 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 /* Phase for excitation pulse */ assign(zero,vphase90); /* 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); } 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(); /* 90 degree 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(shapelist90,ss_grad.rfDuration,vphase90,rof1,rof2,seqcon[1],vms_ctr); delay(ss_grad.rfDelayBack); /* 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); F_initval(ne,vne); loop(vne,vne_ctr); /* Phase cycle for refocusing pulse and receiver */ mod4(ct,vphindex); mod2(vne_ctr,vneindex); ifzero(vneindex); getelem(t2,vphindex,vphase180); getelem(t4,vphindex,oph); elsenz(vneindex); getelem(t3,vphindex,vphase180); getelem(t5,vphindex,oph); endif(vneindex); /* Crusher gradient modulation */ assign(one,vcrush); if (crushmod[0] == 'y') { assign(zero,vcrush); ifzero(vneindex); add(vcrush,one,vcrush); elsenz(vneindex); sub(vcrush,one,vcrush); endif(vneindex); } if (crushmod[0] == 'p') { getelem(t6,vne_ctr,vcrush); crush_grad.amp=crush_step; } /* 180 degree pulse *******************************/ if (crushmod[0] == 'y' || crushmod[0] == 'p') var3_shapedgradient(crush_grad.name,crush_grad.duration,0.0,0.0,0.0,0.0,0.0,crush_grad.amp,zero,zero,vcrush,WAIT); else obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0,crush_grad.amp,WAIT); 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); if (crushmod[0] == 'y' || crushmod[0] == 'p') var3_shapedgradient(crush_grad.name,crush_grad.duration,0.0,0.0,0.0,0.0,0.0,crush_grad.amp,zero,zero,vcrush,WAIT); else obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0,crush_grad.amp,WAIT); /* Second half-TE period ******************************/ delay(te2_delay); /* Phase-encode gradient ******************************/ pe_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,-pe_grad.increment,vpe_mult,WAIT); /* Readout gradient ************************************/ obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.roamp,0,0,NOWAIT); delay(ro_grad.atDelayFront-alfa); /* Acquire data ****************************************/ startacq(alfa); acquire(np,1.0/sw); endacq(); delay(ro_grad.atDelayBack); /* Rewinding phase-encode 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); endloop(vne_ctr); 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); }
// DJB's "RSA signatures and Rabin-Williams signatures..." (http://cr.yp.to/sigs/rwsota-20080131.pdf). Integer InvertibleRWFunction::CalculateInverse(RandomNumberGenerator &rng, const Integer &x) const { DoQuickSanityCheck(); if(!m_precompute) Precompute(); ModularArithmetic modn(m_n), modp(m_p), modq(m_q); Integer r, rInv; do { // Do this in a loop for people using small numbers for testing r.Randomize(rng, Integer::One(), m_n - Integer::One()); // Fix for CVE-2015-2141. Thanks to Evgeny Sidorov for reporting. // Squaring to satisfy Jacobi requirements suggested by Jean-Pierre Muench. r = modn.Square(r); rInv = modn.MultiplicativeInverse(r); } while (rInv.IsZero()); Integer re = modn.Square(r); re = modn.Multiply(re, x); // blind const Integer &h = re, &p = m_p, &q = m_q; Integer e, f; const Integer U = modq.Exponentiate(h, (q+1)/8); if(((modq.Exponentiate(U, 4) - h) % q).IsZero()) e = Integer::One(); else e = -1; const Integer eh = e*h, V = modp.Exponentiate(eh, (p-3)/8); if(((modp.Multiply(modp.Exponentiate(V, 4), modp.Exponentiate(eh, 2)) - eh) % p).IsZero()) f = Integer::One(); else f = 2; Integer W, X; #pragma omp parallel sections if(CRYPTOPP_RW_USE_OMP) { #pragma omp section { W = (f.IsUnit() ? U : modq.Multiply(m_pre_2_3q, U)); } #pragma omp section { const Integer t = modp.Multiply(modp.Exponentiate(V, 3), eh); X = (f.IsUnit() ? t : modp.Multiply(m_pre_2_9p, t)); } } const Integer Y = W + q * modp.Multiply(m_pre_q_p, (X - W)); // Signature Integer s = modn.Multiply(modn.Square(Y), rInv); CRYPTOPP_ASSERT((e * f * s.Squared()) % m_n == x); // IEEE P1363, Section 8.2.8 IFSP-RW, p.44 s = STDMIN(s, m_n - s); if (ApplyFunction(s) != x) // check throw Exception(Exception::OTHER_ERROR, "InvertibleRWFunction: computational error during private key operation"); return s; }
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); }
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() { /***** Internal variable declarations *****/ int shapelist1,shapelist2,shapelist3; /* pulse shapes (lists) */ double freq1,freq2,freq3,ws_delta; double rprof,pprof,sprof; double restol, resto_local,csd_ppm; char profile_ovs[MAXSTR]; char profile_vox[MAXSTR]; int wsfirst; //wsfirst makes ws unit to be exececuted first int isis; int counter,noph; char autoph[MAXSTR],pcflag[MAXSTR]; /* sequence timing variables */ double te_delay1, te_delay2, newdelay,tr_delay, tm_delay; double tau1=0, tau2=0; /* Extra crushers */ double gcrushtm,tcrushtm; double ky; double vox3_cr, vox3r_cr; double gcrush_end, tcrush_end; /*extra ws pulse flag*/ char ws_tm[MAXSTR]; double wsflipftm; double tmwstpwr,tmwstpwrf; init_mri(); noph=(int)getval("noph"); isis=(int)getval("isis"); int inv1[32]= {0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, 3, 3, 3, 3};//excitation pulse int inv2[32]= {0, 0, 1, 1, 2, 2, 3, 3, 0, 0, 1, 1, 2, 2, 3, 3, 1, 1, 2, 2, 3, 3, 0, 0, 1, 1, 2, 2, 3, 3, 0, 0}; //refocusing pulse int inv3[32]= {0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3};//inversion pulse int phrec[32]= {0, 2, 2, 0, 2, 0, 0, 2, 0, 2, 2, 0, 2, 0, 0, 2, 1, 3, 3, 1, 3, 1, 1, 3, 1, 3, 3, 1, 3, 1, 1, 3};// rec phase int phrec0[32]= {0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 1, 1, 3, 3, 3, 3, 1, 1, 1, 1, 3, 3, 3, 3, 1, 1};// rec phase for non-isis /***** Real-time variables used in this sequence *****/ int vinv1 = v1; // on/off flag first inversion pulse int vms = v5; // dummy shapedpulselist slice counter (= one) get_ovsparameters(); get_wsparameters(); rprof = getval("rprof"); pprof = getval("pprof"); sprof = getval("sprof"); ky=getval("ky"); getstr("autoph",autoph); getstr("pcflag",pcflag); getstr("profile_ovs",profile_ovs); getstr("profile_vox",profile_vox); wsfirst=(int)getval("wsfirst"); restol=getval("restol"); //local frequency offset roff=getval("roff"); //receiver offset csd_ppm=getval("csd_ppm"); //chemical shift displacement factor gcrushtm = getval("gcrushtm"); tcrushtm = getval("tcrushtm"); wsflipftm = getval("wsflipftm"); getstr("ws_tm",ws_tm); ws_delta=getval("ws_delta"); vox3_cr=1000000; /***** RF power calculations *****/ shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2); shape_rf(&p2_rf,"p2",p2pat,p2,flip2,rof1,rof2); shape_rf(&p3_rf,"p3",p3pat,p3,flip3,rof1,rof2); shape_rf(&p4_rf,"p4",p4pat,p4,flip4,rof1,rof2); p4_rf.flipmult=wsflipftm; calc_rf(&p1_rf,"tpwr1","tpwr1f"); calc_rf(&p2_rf,"tpwr2","tpwr2f"); calc_rf(&p3_rf,"tpwr3","tpwr3f"); calc_rf(&p4_rf,"tpwr4","tpwr4f"); // wsfpwrtm=p4_rf.powerFine*wsflipftm; /* ws fine RF power */ trampfixed=trise; //rise time =trise tcrush=granularity(tcrush,GRADIENT_RES); //this is to avoid the granularity errors //if trampfixed is used, rise time needs to be checked if (trise*2>tcrush){ abort_message("tcrush too short. Minimum tcrush = %fms \n",1000*trise*2); } if (gcrush>gmax){ abort_message("gcrush too large. Max gcrush = %f \n",gmax*0.95); } init_slice(&vox1_grad,"vox1",vox1); init_slice(&vox2_grad,"vox2",vox2); init_slice_butterfly(&vox3_crush,"vox3_crush",vox3_cr,gcrush,tcrush); init_slice_butterfly(&vox3r_crush,"vox3r_crush",vox3_cr,gcrush,tcrush); init_slice_butterfly(&vox3_grad,"vox3",vox3,gcrush,tcrush); init_generic(&tmcrush_grad,"tmcrush",gcrushtm,tcrushtm); //crusher grad during tm if (profile_vox[0] == 'y') { init_readout_butterfly(&ro_grad,"ro",lro,np,sw,gcrushro,tcrushro); init_readout_refocus(&ror_grad,"ror"); } /***** Gradient calculations *****/ calc_slice(&vox1_grad,&p1_rf,WRITE,"vox1_grad"); calc_slice(&vox2_grad,&p2_rf,WRITE,"vox2_grad"); calc_slice(&vox3_grad,&p3_rf,NOWRITE,""); calc_slice(&vox3_crush,&p3_rf,WRITE,"vox3_crush"); calc_slice(&vox3r_crush,&p3_rf,NOWRITE,""); vox3r_crush.crusher1Moment0 -= vox2_grad.m0ref; //only now can re-calculate the moment vox3r_crush.crusher1CalcFlag=AMPLITUDE_FROM_MOMENT_DURATION_RAMP; calc_slice(&vox3r_crush,&p3_rf,WRITE,"vox3r_crush"); vox3_grad.crusher2Moment0 *= vox3_grad.m0def/vox3_grad.m0ref*ky; //only now can re-calculate the moment vox3_grad.crusher2CalcFlag=AMPLITUDE_FROM_MOMENT_DURATION_RAMP; calc_slice(&vox3_grad,&p3_rf,WRITE,"vox3_grad"); calc_generic(&tmcrush_grad,WRITE,"",""); if (profile_vox[0] == 'y') { calc_readout(&ro_grad,WRITE,"gro","sw","at"); putvalue("gro",ro_grad.roamp); // RO grad calc_readout_refocus(&ror_grad,&ro_grad,WRITE,"gror"); putvalue("tror",ror_grad.duration); // ROR duration } if (profile_ovs[0]=='y'){ if (rprof==1) { vox1_grad.amp=0; } else if(pprof==1) { vox2_grad.amp=0; } else if(sprof==1) { vox3_grad.amp=0; } } /***** Check nt is a multiple of 2 *****/ if (ix == 1) { if ((int)nt%2 != 0) text_message("WARNING: SPECIAL requires 2 steps. Set nt as a multiple of 2\n"); } /* Optional Outer Volume Suppression */ if (ovs[0] == 'y') create_ovsbands(); if (sat[0] == 'y') create_satbands(); /* Optional Water Suppression */ if (ws[0] == 'y') create_watersuppress(); /***** Set up frequency offset pulse shape list *****/ offsetlist(&pos1,vox1_grad.ssamp,0,&freq1,1,'s'); offsetlist(&pos2,vox2_grad.ssamp,0,&freq2,1,'s'); offsetlist(&pos3,vox3_grad.ssamp,0,&freq3,1,'s'); if (profile_ovs[0]=='y'&& sprof==1) freq3=0.0; if (profile_ovs[0]=='y'&& pprof==1) freq2=0.0; if (profile_ovs[0]=='y'&& rprof==1) freq1=0.0; freq1=freq1-csd_ppm*sfrq; freq2=freq2-csd_ppm*sfrq; freq3=freq3-csd_ppm*sfrq; shapelist1 = shapelist(p1_rf.pulseName,vox1_grad.rfDuration,&freq1,1,vox1_grad.rfFraction,'s'); shapelist2 = shapelist(p2_rf.pulseName,vox2_grad.rfDuration,&freq2,1,vox2_grad.rfFraction,'s'); shapelist3 = shapelist(p3_rf.pulseName,vox3_grad.rfDuration,&freq3,1,vox3_grad.rfFraction,'s'); /* Calculate delta from resto to include local frequency line + chemical shift offset */ resto_local=resto-restol; /* Frequency offsets */ if (profile_vox[0] == 'y') { /* Shift DDR for pro ************************************/ roff = -poffset(pro,ro_grad.roamp); } /* Set tables */ /* Real time variables for inversion pulses */ settable(t1,noph,inv1); settable(t2,noph,inv2); settable(t3,noph,inv3); /* Phase cycle for excitation pulse and receiver */ if (isis!=1) settable(t4,noph,phrec0); else settable(t4,noph,phrec); /* shapedpulselist variable */ assign(one,vms); /* Put gradient information back into VnmrJ parameters */ putvalue("gvox1",vox1_grad.ssamp); putvalue("gvox2",vox2_grad.ssamp); putvalue("gvox3",vox3_grad.ssamp); putvalue("rgvox1",vox1_grad.tramp); putvalue("rgvox2",vox2_grad.tramp); putvalue("rgvox3",vox3_grad.tramp); sgl_error_check(sglerror); if (ss<0) g_setExpTime(trmean*(nt-ss)*arraydim); else g_setExpTime(tr*(ntmean*arraydim+ss)); /* PULSE SEQUENCE *************************************/ /* Real time variables for inversion pulses */ counter=(double)nt*(ix-1); if (autoph[0] == 'n') counter=0.0; initval(counter,v11); initval(noph,v13); //v13=number of phase cycling steps add(v11,ctss,v12); //v12=counter modn(v12,v13,v12); //v12 runs from 1:v13 getelem(t1,v12,v8); /* 90 DEG. SPIN ECHO PULSE */ getelem(t2,v12,v9); /* 180 DEG. SPIN ECHO P. */ getelem(t3,v12,v10); /* ISIS 180 DEG. ADIAB. PULSE */ getelem(t4,v12,oph); /*RCVR PHASE*/ mod2(v12,vinv1); // this controls 1D isis on, off, on, of... up to noph(=32) /****************************************************/ /* Sequence Timing **********************************/ /****************************************************/ /* Min TE ******************************************/ tau1 = vox2_grad.rfCenterBack + vox3_grad.rfCenterFront; tau2 = vox3_grad.rfCenterBack+alfa; temin = 2*(MAX(tau1,tau2) + 4e-6); /* have at least 4us between gradient events */ if (minte[0] == 'y') { te = temin; putvalue("te",te); } else if (te < temin) { abort_message("TE too short. Minimum TE = %.2fms\n",temin*1000); } te_delay1 = te/2 - tau1; te_delay2 = te/2 - tau2; printf("te delay1 is %f", te_delay1); printf("te delay2 is %f", te_delay2); /***************************************************/ /* Min TM ******************************************/ if (ws_tm[0] == 'y') { tau1 = vox1_grad.rfCenterBack + rof1+rof2+p4_rf.rfDuration+tmcrush_grad.duration + 4e-6 + vox2_grad.rfCenterFront; } else tau1 = vox1_grad.rfCenterBack + rof2+tmcrush_grad.duration + 4e-6 + vox2_grad.rfCenterFront; tmmin = tau1 + 4e-6; /* have at least 4us between gradient events */ if (mintm[0] == 'y') { tm = tmmin; putvalue("tm",tm); } else if (tm < tmmin) { abort_message("TM too short. Minimum TM = %.2fms\n",tmmin*1000); } tm_delay = (tm - tau1); /* Relaxation delay ***********************************/ /***** Min TR *****/ trmin = vox1_grad.rfCenterFront + tm + te+alfa + at + 20e-6; if (profile_vox[0] == 'y') trmin += ror_grad.duration + ro_grad.duration - at; if (ws[0] == 'y') trmin += wsTime; if (ovs[0] == 'y') trmin += ovsTime; if (sat[0] == 'y') trmin += satTime; if (mintr[0] == 'y') { tr = trmin; putCmd("setvalue('tr',%f,'current')\n",tr); } if ((trmin-tr) > 12.5e-9) { abort_message("tr too short. Minimum tr = %.2f ms\n",(trmin)*1000); } /***** Calculate TR delay *****/ tr_delay = tr - trmin; /**Sequence Begin**/ status(A); obsoffset(resto_local); delay(4e-6); set_rotation_matrix(vpsi,vphi,vtheta); if (ticks > 0) { xgate(ticks); grad_advance(gpropdelay); delay(4e-6); } /* TTL scope trigger **********************************/ sp1on(); delay(4e-6); sp1off(); /* Saturation bands ***********************************/ if (ovs[0] == 'y') ovsbands(); if (sat[0] == 'y') satbands(); /* Post OVS water suppression *************************/ if (ws[0] == 'y') watersuppress(); /* First inversion pulse *****/ if (isis >= 1){ /*for the ISIS pulse on,off,on,off... or on,on,on,on... */ obspower(p1_rf.powerCoarse); obspwrf(p1_rf.powerFine); delay(4e-6); if (isis == 1) /* for ISIS on,off,on,off,... */{ ifzero(vinv1); obl_shapedgradient(vox1_grad.name,vox1_grad.duration,vox1_grad.amp,0,0,NOWAIT); delay(vox1_grad.rfDelayFront); shapedpulselist(shapelist1,vox1_grad.rfDuration,v10,rof1,rof2,'s',vms); delay(vox1_grad.rfDelayBack); elsenz(vinv1); obl_shapedgradient(vox1_grad.name,vox1_grad.duration,vox1_grad.amp,0,0,WAIT); endif(vinv1); } else { /* for ISIS on,on,on,on...*/ obl_shapedgradient(vox1_grad.name,vox1_grad.duration,vox1_grad.amp,0,0,NOWAIT); delay(vox1_grad.rfDelayFront); shapedpulselist(shapelist1,vox1_grad.rfDuration,v10,rof1,rof2,'s',vms); delay(vox1_grad.rfDelayBack); } } else delay(vox1_grad.duration); //this is for isis off,off,off,off /* tm delay before excitation pulse *****/ /* Optional TM water suppression ***********************/ if (ws_tm[0] == 'y') { if (wsrf[0]=='y') { obspower(p4_rf.powerCoarse); obspwrf(p4_rf.powerFine); delay(4e-6); shapedpulseoffset(p4_rf.pulseName,p4_rf.rfDuration,zero,rof1,rof2,ws_delta); } else delay(p4_rf.rfDuration+rof1+rof2); } //end of ws_tm='y' condition delay(tm_delay); /* TM Gradient crusher ********************************/ obl_shapedgradient(tmcrush_grad.name,tmcrush_grad.duration,0,0,tmcrush_grad.amp,WAIT); /* 90 degree excitation pulse *****/ obspower(p2_rf.powerCoarse); obspwrf(p2_rf.powerFine); delay(4e-6); obl_shapedgradient(vox2_grad.name,vox2_grad.duration,0,vox2_grad.amp,0,NOWAIT); delay(vox2_grad.rfDelayFront); shapedpulselist(shapelist2,vox2_grad.rfDuration,v8,rof1,rof2,'s',vms); delay(vox2_grad.rfDelayBack); delay(te_delay1); /* 180 degree pulse ********************************/ obspower(p3_rf.powerCoarse); obspwrf(p3_rf.powerFine); delay(4e-6); obl_shaped3gradient (vox3_crush.name,vox3r_crush.name,vox3_grad.name,vox3_grad.duration,vox3_crush.amp,vox3r_crush.amp,vox3_grad.amp,NOWAIT); delay(vox3_grad.rfDelayFront); shapedpulselist(shapelist3,vox3_grad.rfDuration,v9,rof1,rof2,'s',vms); delay(vox3_grad.rfDelayBack); delay(te_delay2); //acquisition starts if (profile_vox[0] == 'y') { obl_shapedgradient(ror_grad.name,ror_grad.duration, -rprof*ror_grad.amp,-pprof*ror_grad.amp,-sprof*ror_grad.amp,WAIT); delay(4e-6); obl_shapedgradient(ro_grad.name,ro_grad.duration, rprof*ro_grad.amp,pprof*ro_grad.amp,sprof*ro_grad.amp,NOWAIT); delay(ro_grad.atDelayFront); startacq(alfa); acquire(np,1.0/sw); delay(ro_grad.atDelayBack); endacq(); } else { startacq(alfa); acquire(np,1.0/sw); endacq(); } delay(tr_delay); }