def createSequence(): # Set shimming mri.iniSequence(expt, 20, shimming) # Initialize time tEx = 20e3 # Excitation pulse t0 = tEx - hw.blkTime - rfExTime[indexExTime] / 2 if pulseShape == 'Rec': mri.rfRecPulse(expt, t0, rfExTime[indexExTime], rfExAmp, rfExPhase * np.pi / 180) elif pulseShape == 'Sinc': mri.rfSincPulse(expt, t0, rfExTime[indexExTime], 7, rfExAmp, rfExPhase * np.pi / 180) # First acquisition t0 = tEx + rfExTime[indexExTime] / 2 + deadTime mri.rxGate(expt, t0, tAcq) # Refocusing pulse t0 = tEx + tEcho / 2 - rfReTime[indexExTime] / 2 - hw.blkTime if pulseShape == 'Rec': mri.rfRecPulse(expt, t0, rfReTime[indexExTime], rfReAmp, np.pi / 2) elif pulseShape == 'Sinc': mri.rfSincPulse(expt, t0, rfReTime[indexExTime], 7, rfReAmp, np.pi / 2) # Second acquisition t0 = tEx + tEcho - tAcq / 2 mri.rxGate(expt, t0, tAcq) # End sequence mri.endSequence(expt, tRepetition)
def createSequence(): # Set shimming mri.iniSequence(expt, 20, shimming) for repeIndex in range(nRepetitions): # Initialize time tEx = 20e3+repetitionTime*repeIndex # Excitation pulse t0 = tEx-hw.blkTime-rfExTime/2 mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, 0) # # Rx gating # t0 = tEx+rfExTime/2+hw.deadTime # mri.rxGate(expt, t0, acqTime) # Crusher gradient t0 = tEx+echoTime/2-crusherTime/2-gradRiseTime-hw.gradDelay-43 mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[0], shimming) mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[2], shimming) # Refocusing pulse t0 = tEx+echoTime/2-rfReTime/2-hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, np.pi/2) # Rx gating t0 = tEx+echoTime-acqTime/2 mri.rxGate(expt, t0, acqTime) # End sequence mri.endSequence(expt, scanTime)
def createSequence(shimming): # Set shimming mri.iniSequence(expt, 20, shimming) # Initialize time tEx = 20e3 # Excitation pulse t0 = tEx-hw.blkTime-rfExTime/2 if pulseShape=='Rec': mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, 0) elif pulseShape=='Sinc': mri.rfSincPulse(expt, t0, rfExTime, 7, rfExAmp, 0) # Refocusing pulse t0 = tEx+echoTime/2-rfReTime/2-hw.blkTime if pulseShape=='Rec': mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, np.pi/2) elif pulseShape=='Sinc': mri.rfSincPulse(expt, t0, rfReTime, 7, rfReAmp, np.pi/2) # Acquisition window t0 = tEx+echoTime-acqTime/2 mri.rxGate(expt, t0, acqTime) # End sequence mri.endSequence(expt, repetitionTime)
def createSequence(): # Set shimming mri.iniSequence(expt, 20, shimming) for repeIndex in range(nRepetitions): # Initialize time tEx = 20e3 + np.max(tSat) + repetitionTime * repeIndex # Inversion time for current iteration inversionTime = tSat[repeIndex] # Crusher gradient for inversion rf pulse # t0 = tEx-inversionTime-crusherTime/2-gradRiseTime-hw.gradDelay-50 # mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[0], shimming) # mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[1], shimming) # mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[2], shimming) # Saturation pulse t0 = tEx - inversionTime - hw.blkTime - rfReTime / 2 mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, 0) # Spoiler gradients to destroy residual transversal signal detected for ultrashort inversion times # mri.gradTrap(expt, t0+hw.blkTime+rfReTime, gradRiseTime, inversionTime*0.5, 0.005, gSteps, axes[0], shimming) # mri.gradTrap(expt, t0+hw.blkTime+rfReTime, gradRiseTime, inversionTime*0.5, 0.005, gSteps, axes[1], shimming) # mri.gradTrap(expt, t0+hw.blkTime+rfReTime, gradRiseTime, inversionTime*0.5, 0.005, gSteps, axes[2], shimming) # Excitation pulse t0 = tEx - hw.blkTime - rfExTime / 2 mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, 0) # # Rx gating # t0 = tEx+rfExTime/2+hw.deadTime # mri.rxGate(expt, t0, acqTime) # Crusher gradient t0 = tEx + echoTime / 2 - crusherTime / 2 - gradRiseTime - hw.gradDelay - 50 mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[0], shimming) mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, crusherTime, 0.005, gSteps, axes[2], shimming) # Refocusing pulse t0 = tEx + echoTime / 2 - rfReTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, np.pi / 2) # Rx gating t0 = tEx + echoTime - acqTime / 2 mri.rxGate(expt, t0, acqTime) # End sequence mri.endSequence(expt, scanTime)
def createSequence(): phIndex = 0 nRepetitions = int(nPH / etl + dummyPulses) scanTime = 20e3 + nRepetitions * repetitionTime rawData['batchTime'] = scanTime * 1e-6 if rdGradTime == 0: # Check if readout gradient is dc or pulsed dc = True else: dc = False # Set shimming mri.iniSequence(expt, 20, shimming) for repeIndex in range(nRepetitions): # Initialize time tEx = 20e3 + repetitionTime * repeIndex + inversionTime + preExTime # First I do a noise measurement. if repeIndex == 0: t0 = tEx - preExTime - inversionTime - 4 * acqTime mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) # Pre-excitation pulse if repeIndex >= dummyPulses and preExTime != 0: t0 = tEx - preExTime - inversionTime - rfExTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfExTime, rfExAmp / 90 * 90, 0) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, preExTime * 0.5, -0.005, gSteps, axes[0], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, preExTime * 0.5, -0.005, gSteps, axes[1], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, preExTime * 0.5, -0.005, gSteps, axes[2], shimming) # Inversion pulse if repeIndex >= dummyPulses and inversionTime != 0: t0 = tEx - inversionTime - rfReTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp / 180 * 180, 0) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[0], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[1], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[2], shimming) # DC gradient if desired if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == True: t0 = tEx - 10e3 mri.gradTrap(expt, t0, gradRiseTime, 10e3 + echoSpacing * (etl + 1), rdGradAmplitude, gSteps, axes[0], shimming) # Excitation pulse t0 = tEx - hw.blkTime - rfExTime / 2 mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, drfPhase) # Dephasing readout t0 = tEx + rfExTime / 2 - hw.gradDelay if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == False: mri.gradTrap(expt, t0, gradRiseTime, rdDephTime, rdDephAmplitude * rdPreemphasis, gSteps, axes[0], shimming) # Echo train for echoIndex in range(etl): tEcho = tEx + echoSpacing * (echoIndex + 1) # Refocusing pulse t0 = tEcho - echoSpacing / 2 - rfReTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, drfPhase + np.pi / 2) # Dephasing phase and slice gradients if repeIndex >= dummyPulses: # This is to account for dummy pulses t0 = tEcho - echoSpacing / 2 + rfReTime / 2 - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, phGradTime, phGradients[phIndex], gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, phGradTime, slGradients[slIndex], gSteps, axes[2], shimming) # Readout gradient if (repeIndex == 0 or repeIndex >= dummyPulses ) and dc == False: # This is to account for dummy pulses t0 = tEcho - rdGradTime / 2 - gradRiseTime - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, rdGradTime, rdGradAmplitude, gSteps, axes[0], shimming) # Rx gate if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEcho - acqTime / 2 - addRdPoints / BW mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) # Rephasing phase and slice gradients t0 = tEcho + acqTime / 2 + addRdPoints / BW - hw.gradDelay if (echoIndex < etl - 1 and repeIndex >= dummyPulses): mri.gradTrap(expt, t0, gradRiseTime, phGradTime, -phGradients[phIndex], gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, phGradTime, -slGradients[slIndex], gSteps, axes[2], shimming) elif (echoIndex == etl - 1 and repeIndex >= dummyPulses): mri.gradTrap(expt, t0, gradRiseTime, phGradTime, +phGradients[phIndex], gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, phGradTime, +slGradients[slIndex], gSteps, axes[2], shimming) # Update the phase and slice gradient if repeIndex >= dummyPulses: phIndex += 1 if repeIndex == nRepetitions - 1: mri.endSequence(expt, scanTime)
def createSequence(): nRepetitions = int(1 + dummyPulses) scanTime = 20e3 + nRepetitions * repetitionTime rawData['scanTime'] = scanTime * 1e-6 print('Scan Time = ', (scanTime * 1e-6), 's') if rdGradTime == 0: # Check if readout gradient is dc or pulsed dc = True else: dc = False # Set shimming mri.iniSequence(expt, 20, shimming) for repeIndex in range(nRepetitions): # Initialize time tEx = 20e3 + repetitionTime * repeIndex + inversionTime # Inversion pulse if repeIndex >= dummyPulses and inversionTime != 0: t0 = tEx - inversionTime - rfReTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp / 180 * 180, 0) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[0], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[1], shimming) mri.gradTrap(expt, t0 + hw.blkTime + rfReTime, gradRiseTime, inversionTime * 0.5, 0.005, gSteps, axes[2], shimming) # DC radout gradient if desired if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == True: t0 = tEx - rfExTime / 2 - gradRiseTime - hw.gradDelay mri.gradTrap(expt, t0, echoSpacing * (nPH + 1), rdGradAmplitude, axes[0]) # Slice selection gradient dephasing if (slThickness != 0 and repeIndex >= dummyPulses): t0 = tEx - rfExTime / 2 - gradRiseTime - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, rfExTime, ssGradAmplitude, gSteps, axes[2], shimming) # Excitation pulse t0 = tEx - hw.blkTime - rfExTime / 2 if rfEnvelope == 'Rec': mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, drfPhase * np.pi / 180) elif rfEnvelope == 'Sinc': mri.rfSincPulse(expt, t0, rfExTime, rfSincLobes, rfExAmp, drfPhase * np.pi / 180) # Slice selection gradient rephasing if (slThickness != 0 and repeIndex >= dummyPulses): t0 = tEx + rfExTime / 2 + gradRiseTime - hw.gradDelay if rfEnvelope == 'Rec': mri.gradTrap(expt, t0, gradRiseTime, 0., -ssGradAmplitude * ssPreemphasis, gSteps, axes[2], shimming) elif rfEnvelope == 'Sinc': mri.gradTrap(expt, t0, gradRiseTime, ssDephGradTime, -ssGradAmplitude * ssPreemphasis, gSteps, axes[2], shimming) # Dephasing readout t0 = tEx + rfExTime / 2 - hw.gradDelay if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == False: mri.gradTrap(expt, t0, gradRiseTime, rdDephTime, rdDephAmplitude * rdPreemphasis, gSteps, axes[0], shimming) # Echo train for echoIndex in range(nPH): tEcho = tEx + echoSpacing * (echoIndex + 1) # Crusher gradient if repeIndex >= dummyPulses: t0 = tEcho - echoSpacing / 2 - rfReTime / 2 - gradRiseTime - hw.gradDelay - crusherDelay mri.gradTrap(expt, t0, gradRiseTime, rfReTime + 2 * crusherDelay, ssGradAmplitude, gSteps, axes[2], shimming) # Refocusing pulse t0 = tEcho - echoSpacing / 2 - rfReTime / 2 - hw.blkTime if rfEnvelope == 'Rec': mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, np.pi / 2 + drfPhase * np.pi / 180) if rfEnvelope == 'Sinc': mri.rfSincPulse(expt, t0, rfReTime, rfSincLobes, rfReAmp, np.pi / 2 + drfPhase * np.pi / 180) # Dephasing phase gradient t0 = tEcho - echoSpacing / 2 + rfReTime / 2 - hw.gradDelay if repeIndex >= dummyPulses: # This is to account for dummy pulses mri.gradTrap(expt, t0, gradRiseTime, phGradTime, phGradients[echoIndex], gSteps, axes[1], shimming) # Readout gradient t0 = tEcho - rdGradTime / 2 - gradRiseTime - hw.gradDelay if (repeIndex == 0 or repeIndex >= dummyPulses ) and dc == False: # This is to account for dummy pulses mri.gradTrap(expt, t0, gradRiseTime, rdGradTime, rdGradAmplitude, gSteps, axes[0], shimming) # Rx gate if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEcho - acqTime / 2 - addRdPoints / BW mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) # Rephasing phase and slice gradients t0 = tEcho + acqTime / 2 + addRdPoints / BW - hw.gradDelay if (echoIndex < nPH - 1 and repeIndex >= dummyPulses): mri.gradTrap(expt, t0, gradRiseTime, phGradTime, -phGradients[echoIndex], gSteps, axes[1], shimming) elif (echoIndex == nPH - 1 and repeIndex >= dummyPulses): mri.gradTrap(expt, t0, gradRiseTime, phGradTime, +phGradients[echoIndex], gSteps, axes[1], shimming) if repeIndex == nRepetitions - 1: mri.endSequence(expt, scanTime)
def createSequence(phIndex=0, slIndex=0, repeIndexGlobal=0, rewrite=True): repeIndex = 0 if rdGradTime == 0: # Check if readout gradient is dc or pulsed dc = True else: dc = False acqPoints = 0 orders = 0 # Check in case of dummy pulse fill the cache if (dummyPulses > 0 and etl * nRD * 2 > hw.maxRdPoints) or ( dummyPulses == 0 and etl * nRD > hw.maxRdPoints): print('ERROR: Too many acquired points.') return () # Set shimming mri.iniSequence(expt, 20, shimming, rewrite=rewrite) while acqPoints + etl * nRD <= hw.maxRdPoints and orders <= hw.maxOrders and repeIndexGlobal < nRepetitions: # Initialize time tEx = 20e3 + repetitionTime * repeIndex + inversionTime + preExTime # First I do a noise measurement. if repeIndex == 0: t0 = tEx - preExTime - inversionTime - 4 * acqTime mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) # Pre-excitation pulse if repeIndex >= dummyPulses and preExTime != 0: t0 = tEx - preExTime - inversionTime - rfExTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfExTime, rfExAmp / 90 * 90, 0) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, -0.005, preExTime * 0.5, axes[0], shimming, orders) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, -0.005, preExTime * 0.5, axes[1], shimming, orders) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, -0.005, preExTime * 0.5, axes[2], shimming, orders) # Inversion pulse if repeIndex >= dummyPulses and inversionTime != 0: t0 = tEx - inversionTime - rfReTime / 2 - hw.blkTime mri.rfPulse(expt, t0, rfReTime, rfReAmp / 180 * 180, 0) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, 0.005, inversionTime * 0.5, axes[0], shimming, orders) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, 0.005, inversionTime * 0.5, axes[1], shimming, orders) mri.gradTrapAmplitude(expt, t0 + hw.blkTime + rfReTime, 0.005, inversionTime * 0.5, axes[2], shimming, orders) # DC gradient if desired if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == True: t0 = tEx - 10e3 mri.gradTrapAmplitude(expt, t0, rdGradAmplitude, 10e3 + echoSpacing * (etl + 1), axes[0], shimming, orders) # Excitation pulse t0 = tEx - hw.blkTime - rfExTime / 2 mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, drfPhase) # Dephasing readout if (repeIndex == 0 or repeIndex >= dummyPulses) and dc == False: t0 = tEx + rfExTime / 2 - hw.gradDelay mri.gradTrapAmplitude(expt, t0, rdDephAmplitude * rdPreemphasis, rdDephTime, axes[0], shimming, orders) # Echo train for echoIndex in range(etl): tEcho = tEx + echoSpacing * (echoIndex + 1) # Refocusing pulse t0 = tEcho - echoSpacing / 2 - rfReTime / 2 - hw.blkTime mri.rfRecPulse(expt, t0, rfReTime, rfReAmp, drfPhase + np.pi / 2) # Dephasing phase and slice gradients if repeIndex >= dummyPulses: # This is to account for dummy pulses t0 = tEcho - echoSpacing / 2 + rfReTime / 2 - hw.gradDelay mri.gradTrapAmplitude(expt, t0, phGradients[phIndex], phGradTime, axes[1], shimming, orders) mri.gradTrapAmplitude(expt, t0, slGradients[slIndex], phGradTime, axes[2], shimming, orders) # Readout gradient if (repeIndex == 0 or repeIndex >= dummyPulses ) and dc == False: # This is to account for dummy pulses t0 = tEcho - rdGradTime / 2 - gRiseTimeRd - hw.gradDelay mri.gradTrapAmplitude(expt, t0, rdGradAmplitude, rdGradTime + 2 * gRiseTimeRd, axes[0], shimming, orders) # Rx gate if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEcho - acqTime / 2 - addRdPoints / BW mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) acqPoints += nRD # Rephasing phase and slice gradients t0 = tEcho + acqTime / 2 + addRdPoints / BW - hw.gradDelay if (echoIndex < etl - 1 and repeIndex >= dummyPulses): mri.gradTrapAmplitude(expt, t0, -phGradients[phIndex], phGradTime, axes[1], shimming, orders) mri.gradTrapAmplitude(expt, t0, -slGradients[slIndex], phGradTime, axes[2], shimming, orders) elif (echoIndex == etl - 1 and repeIndex >= dummyPulses): mri.gradTrapAmplitude(expt, t0, phGradients[phIndex], phGradTime, axes[1], shimming, orders) mri.gradTrapAmplitude(expt, t0, slGradients[slIndex], phGradTime, axes[2], shimming, orders) # Update the phase and slice gradient if repeIndex >= dummyPulses: if phIndex == nPH - 1: phIndex = 0 slIndex += 1 else: phIndex += 1 if repeIndex >= dummyPulses: repeIndexGlobal += 1 # Update the global repeIndex repeIndex += 1 # Update the repeIndex after the ETL # Turn off the gradients after the end of the batch mri.endSequence(expt, repeIndex * repetitionTime) # Return the output variables return (phIndex, slIndex, repeIndexGlobal)
def createSequence(phIndex=0, slIndex=0, repeIndexGlobal=0, rewrite=True): repeIndex = 0 acqPoints = 0 orders = 0 # check in case of dummy pulse filling the cache if (dummyPulses > 0 and nRD * 3 > hw.maxRdPoints) or ( dummyPulses == 0 and nRD * 2 > hw.maxRdPoints): print( 'ERROR: Too many acquired points or orders to the red pitaya.') return () # Set shimming mri.iniSequence(expt, 20, shimming, rewrite=rewrite) # Run sequence batch while acqPoints + nRD <= hw.maxRdPoints and orders <= hw.maxOrders and repeIndexGlobal < nRepetitions: # Initialize time tEx = 20e3 + repetitionTime * repeIndex # First I do a noise measurement if repeIndex == 0: t0 = tEx - 4 * acqTime mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) acqPoints += nRD # Excitation pulse t0 = tEx - hw.blkTime - rfExTime / 2 mri.rfRecPulse(expt, t0, rfExTime, rfExAmp, 0.) # Dephasing readout, phase and slice if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEx + rfExTime / 2 - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, dephGradTime, rdDephAmplitude, gSteps, axes[0], shimming) orders = orders + gSteps * 2 if repeIndex >= dummyPulses: t0 = tEx + rfExTime / 2 - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, dephGradTime, phGradients[phIndex], gSteps, axes[1], shimming) mri.gradTrap(expt, t0, gradRiseTime, dephGradTime, slGradients[slIndex], gSteps, axes[2], shimming) orders = orders + gSteps * 4 # Rephasing readout gradient if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEx + echoTime - rdGradTime / 2 - gradRiseTime - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, rdGradTime, rdGradAmplitude, gSteps, axes[0], shimming) orders = orders + gSteps * 2 # Rx gate if (repeIndex == 0 or repeIndex >= dummyPulses): t0 = tEx + echoTime - acqTime / 2 - addRdPoints / BW mri.rxGate(expt, t0, acqTime + 2 * addRdPoints / BW) acqPoints += nRD # Spoiler if spoiler: t0 = tEx + echoTime + rdGradTime / 2 + gradRiseTime - hw.gradDelay mri.gradTrap(expt, t0, gradRiseTime, dephGradTime, -rdDephAmplitude, gSteps, axes[0], shimming) orders = orders + gSteps * 2 # Update the phase and slice gradient if repeIndex >= dummyPulses: if phIndex == nPH - 1: phIndex = 0 slIndex += 1 else: phIndex += 1 if repeIndex >= dummyPulses: repeIndexGlobal += 1 # Update the global repeIndex repeIndex += 1 # Update the repeIndex after the ETL # Turn off the gradients after the end of the batch mri.endSequence(expt, repeIndex * repetitionTime) # Return the output variables return (phIndex, slIndex, repeIndexGlobal, acqPoints)