Пример #1
0
def test_grad_echo_Elena():
    samples_tmp = 140
    tx_dt = 0.1
    rx_dt = 3.33 #desired sampling dt
    rx_dt_corr = rx_dt *0.5 #correction till the bug is fixed
    
    exp = Experiment(samples=samples_tmp,
                     lo_freq=14.2375,
                     tx_t= tx_dt,
                     rx_t=rx_dt_corr,
                     instruction_file="grad_echo_elena.txt")

     # RF pulse`
    tx_time = 20
    t = np.linspace(0, tx_time, math.ceil(tx_time/tx_dt)+1) # goes to tx_time us, samples every tx_t us; length of pulse must be adjusted in grad_echo_elena.txt
    
    alpha = 0.46 # alpha=0.46 for Hamming window, alpha=0.5 for Hanning window
    Nlobes = 5
    ampl = 0.125

    #sinc pulse with Hamming window
    tx_x = ampl * sinc(math.pi*(t - tx_time/2),tx_time,Nlobes,alpha)
    tx_idx = exp.add_tx(tx_x) # add the data to the ocra TX memory

    # gradient echo; 190 samples total: 50 for first ramp, 140 for second ramp
    grad = np.hstack([
        np.linspace(0, 0.9, 10), np.ones(30), np.linspace(0.9, 0, 10), # first ramp up/down
        np.linspace(0,-0.285, 20), -0.3 * np.ones(100), np.linspace(-0.285, 0, 20)
        ])

    # Correct for DC offset and scaling
    scale = 0.9
    offset = 0.0
    grad_corr = grad*scale + offset

    grad_idx = exp.add_grad(grad_corr, grad_corr, grad_corr)
    if False: # set to true if you want to plot the x gradient waveform
        plt.plot(grad_corr);plt.show()

    data = exp.run()
    data_mV = data*1000
    
    # time vector for representing the received data
    samples_data = len(data)
    t_rx = np.linspace(0, rx_dt*samples_data, samples_data) #us

    plt.plot(t,tx_x)
    plt.title('sampled data = %i' % samples_data)

    # plt.plot(t_rx,np.real(data_mV))
    # plt.plot(t_rx,np.imag(data_mV))
    # plt.plot(t_rx,np.abs(data_mV))
    # plt.legend(['real', 'imag', 'abs'])
    # plt.xlabel('time (us)')
    # plt.ylabel('signal received (mV)')
    # plt.title('sampled data = %i' %samples_data)
    plt.show()
Пример #2
0
def test_grad_echo_Elena():

    exp = Experiment(samples=600,
                     lo_freq=14.2375,
                     tx_t=0.1,
                     rx_t=2,
                     instruction_file="ocra_lib/grad_echo_elena.txt")

    # RF pulse
    t = np.linspace(
        0, 20, 201
    )  # goes to 20us, samples every 10ns; length of pulse must be adjusted in grad_echo_elena.txt

    # sinc pulse
    tx_x = np.sinc((t - 10) / 6)
    tx_idx = exp.add_tx(tx_x)  # add the data to the ocra TX memory

    # gradient echo; 190 samples total: 50 for first ramp, 140 for second ramp
    grad = np.hstack([
        np.linspace(0, 0.9, 10),
        np.ones(30),
        np.linspace(0.9, 0, 10),  # first ramp up/down
        np.linspace(0, -0.285, 20),
        -0.3 * np.ones(100),
        np.linspace(-0.285, 0, 20)
    ])

    # Correct for DC offset and scaling
    scale = 0.9
    offset = 0.0
    grad_corr = grad * scale + offset

    grad_idx = exp.add_grad(grad_corr, grad_corr, grad_corr)
    if False:  # set to true if you want to plot the x gradient waveform
        plt.plot(grad_corr)
        plt.show()

    data = exp.run()

    plt.plot(np.real(data))
    plt.plot(np.imag(data))
    plt.plot(np.abs(data))
    plt.legend(['real', 'imag', 'abs'])
    plt.show()
Пример #3
0
def se_2D_v0_RP():
    # Experiment parameters
    freq_larmor = 2.147  # local oscillator frequency, MHz
    sample_nr_echo = 128  # number of (I,Q) USEFUL samples to acquire during a shot
    pe_step_nr = 128  # number of phase encoding steps

    tx_dt = 0.1  # RF TX sampling dt in microseconds; is rounded to a multiple of clocks (122.88 MHz)
    rx_dt = 50  # RF RX sampling dt

    ##### Times have to match with "<instruction_file>.txt" ####
    T_tx_Rf = 100  # RF pulse length (us)
    T_G_ramp_dur = 250  # Gradient ramp time
    BW = 20000  # Rf Rx Bandwidth

    sample_nr_2_STOP_Seq = 256 + 1000  # Nr. of samples to acquire TO STOP the acquisition

    # Correct for DC offset and scaling
    scale_G_x = 0.32
    scale_G_y = 0.32
    scale_G_z = 0.32
    offset_G_x = 0.0
    offset_G_y = 0.0
    offset_G_z = 0.0

    # Rf amplitude
    Rf_ampl = 0.3  #0.07125  # for Tom

    # Centering the echo
    echo_delay = 4550  # us; correction for receiver delay

    rx_dt_corr = rx_dt * 0.5  # correction factor to have correct Rx sampling time till the bug is fixed
    t_G_ref_Area = (
        (1 / (BW / sample_nr_echo)) /
        2) * 1e6  # The time needed to do half the encoding (square pulse)
    T_G_pe_dur = t_G_ref_Area + T_G_ramp_dur  # Total phase encoding gradient ON time length (us)
    T_G_pre_fe_dur = t_G_ref_Area + (
        3 /
        2) * T_G_ramp_dur  # Total freq. encoding REWINDER ON time length (us)
    T_G_fe_dur = 2 * (
        t_G_ref_Area + T_G_ramp_dur
    )  # Total Frequency encoding gradient ON time length (us)

    ##### RF pulses #####
    ### 90 RF pulse   ###
    # Time vector
    t_Rf_90 = np.linspace(0, T_tx_Rf,
                          math.ceil(T_tx_Rf / tx_dt) +
                          1)  # Actual TX RF pulse length
    # sinc pulse
    alpha = 0.46  # alpha=0.46 for Hamming window, alpha=0.5 for Hanning window
    Nlobes = 1
    # sinc pulse with Hamming window
    # tx90 = Rf_ampl * sinc(math.pi*(t_Rf_90 - T_tx_Rf/2),T_tx_Rf,Nlobes,alpha)
    tx90_clean = Rf_ampl * np.ones(np.size(t_Rf_90))

    ### 180 RF pulse ###
    # sinc pulse
    tx180 = tx90_clean * 2
    tx90 = np.concatenate((tx90_clean, np.zeros(1100 - np.size(tx90_clean))))
    tx180 = np.concatenate(
        (tx180, np.zeros(2200 - np.size(tx180) - np.size(tx90))))

    # For testing ONLY: shot rf to mimic echo for centering the acquisition window
    tx90_echo_cent = np.hstack((tx90_clean, np.zeros(100)))

    ##### Gradients #####
    # Phase encoding gradient shape
    grad_pe_samp_nr = math.ceil(T_G_pe_dur / 10)
    grad_ramp_samp_nr = math.ceil(T_G_ramp_dur / 10)
    grad_pe = np.hstack([
        np.linspace(0, 1, grad_ramp_samp_nr),  # Ramp up
        np.ones(grad_pe_samp_nr - 2 * grad_ramp_samp_nr),  # Top
        np.linspace(1, 0, grad_ramp_samp_nr)
    ])  # Ramp down
    grad_pe = np.hstack([grad_pe, np.zeros(500 - np.size(grad_pe))])

    # Pre-frequency encoding gradient shape
    grad_pre_fe_samp_nr = math.ceil(T_G_pre_fe_dur / 10)
    grad_pre_fe = np.hstack([
        np.linspace(0, 1, grad_ramp_samp_nr),  # Ramp up
        np.ones(grad_pre_fe_samp_nr - 2 * grad_ramp_samp_nr),  # Top
        np.linspace(1, 0, grad_ramp_samp_nr)
    ])  # Ramp down
    grad_pre_fe = np.hstack(
        [grad_pre_fe, np.zeros(500 - np.size(grad_pre_fe))])

    # Frequency encoding gradient shape
    grad_fe_samp_nr = math.ceil(T_G_fe_dur / 10)
    grad_fe = np.hstack([
        np.linspace(0, 1, grad_ramp_samp_nr),  # Ramp up
        np.ones(grad_fe_samp_nr - 2 * grad_ramp_samp_nr),  # Top
        np.linspace(1, 0, grad_ramp_samp_nr)
    ])  # Ramp down
    sample_nr_center_G_fe = (
        ((1 / (BW / 128)) / 2) * 1e6 +
        T_G_ramp_dur) / 10  # Total phase encoding gradient ON time length (us)
    grad_fe = np.hstack([
        np.zeros(
            np.round(sample_nr_center_G_fe -
                     np.size(grad_fe) / 2).astype('int')), grad_fe,
        np.zeros(np.round(1000 - np.size(grad_fe)).astype('int'))
    ])

    # Initialisation of the DAC
    exp = Experiment(
        samples=
        4,  # number of (I,Q) samples to acquire during a shot of the experiment
        lo_freq=freq_larmor,  # local oscillator frequency, MHz
        tx_t=tx_dt,
        instruction_file="ocra_lib/se_default_vn.txt")
    exp.initialize_DAC()

    # Loop repeating TR and updating the gradients waveforms
    data = np.zeros([sample_nr_2_STOP_Seq, pe_step_nr], dtype=complex)

    for idx2 in range(pe_step_nr):
        exp = Experiment(
            samples=
            sample_nr_2_STOP_Seq,  # number of (I,Q) samples to acquire during a shot of the experiment
            lo_freq=freq_larmor,  # local oscillator frequency, MHz
            tx_t=
            tx_dt,  # RF TX sampling time in microseconds; will be rounded to a multiple of system clocks (122.88 MHz)
            rx_t=rx_dt_corr,  # RF RX sampling time in microseconds; as above
            instruction_file="se_2D_LUMC_v0.txt")
        ###### Send waveforms to RP memory ###########
        # Load the RF waveforms
        tx_idx = exp.add_tx(tx90)  # add 90 Rf data to the ocra TX memory
        tx_idx = exp.add_tx(tx180)  # add 180 Rf data to the ocra TX memory
        tx_idx = exp.add_tx(
            tx90_echo_cent
        )  # add Reference pulse only for measuring acquisition delay
        scale_G_pe_sweep = 2 * (idx2 / (pe_step_nr - 1) - 0.5
                                )  # Change phase encoding gradient magnitude

        # Adjust gradient waveforms
        grad_x_1_corr = grad_pre_fe * scale_G_x + offset_G_x
        grad_y_1_corr = grad_pe * scale_G_y * scale_G_pe_sweep + offset_G_y
        grad_z_1_corr = np.zeros(np.size(grad_x_1_corr)) + offset_G_z
        grad_x_2_corr = grad_fe * scale_G_x + offset_G_x
        grad_y_2_corr = np.zeros(np.size(grad_x_2_corr)) + offset_G_y
        grad_z_2_corr = np.zeros(np.size(grad_x_2_corr)) + offset_G_z

        # Load gradient waveforms
        grad_idx = exp.add_grad(grad_x_1_corr, grad_y_1_corr, grad_z_1_corr)
        grad_idx = exp.add_grad(grad_x_2_corr, grad_y_2_corr, grad_z_2_corr)

        # Run command to MaRCoS
        data[:, idx2] = exp.run()

    # time vector for representing the received data
    samples_data = len(data)
    t_rx = np.linspace(0, rx_dt * samples_data, samples_data)  # us

    plt.figure(1)
    plt.subplot(2, 1, 1)
    # plt.plot(t_rx, np.real(data))
    # plt.plot(t_rx, np.abs(data))
    plt.plot(np.real(data))
    plt.plot(np.abs(data))
    plt.legend(['real', 'abs'])
    plt.xlabel('time (us)')
    plt.ylabel('signal received (V)')
    plt.title('Total sampled data = %i' % samples_data)
    plt.grid()

    echo_shift_idx = np.floor(echo_delay / rx_dt).astype('int')
    rx_sample_nr_center_G_fe = (
        ((1 / (BW / 128)) / 2) * 1e6 +
        T_G_ramp_dur) / 50  # Total phase encoding gradient ON time length (us)
    echo_idx = (
        rx_sample_nr_center_G_fe - np.floor(sample_nr_echo / 2)
    ).astype(
        'int'
    )  # np.floor(T_G_fe_dur / (2 * rx_dt)).astype('int') - np.floor(sample_nr_echo / 2).astype('int')
    kspace = data[echo_idx + echo_shift_idx:echo_idx + echo_shift_idx +
                  sample_nr_echo, :]

    plt.subplot(2, 1, 2)
    # plt.plot(t_rx[echo_idx+echo_shift_idx:echo_idx+echo_shift_idx+sample_nr_echo], np.real(kspace))
    # # plt.plot(t_rx, np.imag(data))
    # plt.plot(t_rx[echo_idx+echo_shift_idx:echo_idx+echo_shift_idx+sample_nr_echo], np.abs(kspace))
    plt.plot(np.real(kspace))
    plt.plot(np.abs(kspace))
    plt.legend(['real', 'abs'])
    plt.xlabel('Sample nr.')
    plt.ylabel('signal received (V)')
    plt.title('Echo time in acquisition from = %f' %
              t_rx[echo_idx + echo_shift_idx])
    plt.grid()

    plt.figure(2)
    plt.subplot(1, 2, 1)
    Y = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(kspace)))
    img = np.abs(Y)
    plt.imshow(np.abs(kspace), cmap='gray')
    plt.title('k-Space')
    plt.subplot(1, 2, 2)
    plt.imshow(img, cmap='gray')
    plt.title('image')
    plt.show()
Пример #4
0
    # RF       |_$$_____|______|_$$__|_______|_________|_______|_$$__|_______|_________|_______|_$$_
    #          |        |      |     |       |         |       |     |       |         |       |
    # Gss      |/--\   _|______|/--\_|_______|_________|_______|/--\_|_______|_________|_______|/--\
    #          |    \_/ |      |     |       |         |       |     |       |         |       |
    # Gpe      |________|______|_____|/1111\_|_________|      _|_____|/2222\_|_________|      _|____
    #          |        |      |     |       |         |\1111/ |     |       |         |\2222/ |
    # Gfe      |________|/---\_|_____|_______|/------\_|_______|_____|_______|/------\_|_______|____

    # Shape Gradients block by block
    G_length = np.zeros(1).astype(int)
    # Block 1: Rf90 + ss
    # Block 2: -fe/2 prephase
    grad_fe_2_corr = grad_pre_fe * scale_G_fe + offset_G_fe
    grad_pe_2_corr = np.zeros(np.size(grad_fe_2_corr)) + offset_G_pe
    grad_ss_2_corr = np.zeros(np.size(grad_fe_2_corr)) + offset_G_ss
    grad_idx = exp.add_grad(grad_ss_2_corr, grad_pe_2_corr, grad_fe_2_corr)
    G_length = np.hstack([G_length, G_length[-1] + grad_fe_2_corr.size])

    for idxETL in range(ETL):
        scale_G_pe_sweep = scale_G_pe_range[kIdxTmp2[idxTR, idxETL]]
        # ----echo 1--------------------
        # Block 3: Rf180 + ss
        # Block 4: pe+
        grad_pe_4_corr = grad_pe * scale_G_pe * scale_G_pe_sweep + offset_G_pe
        grad_fe_4_corr = np.zeros(np.size(grad_pe_4_corr)) + offset_G_fe
        grad_ss_4_corr = np.zeros(np.size(grad_pe_4_corr)) + offset_G_ss
        grad_idx = exp.add_grad(grad_ss_4_corr, grad_pe_4_corr, grad_fe_4_corr)
        G_length = np.hstack([G_length, G_length[-1] + grad_fe_4_corr.size])

        # Block 5: fe
        grad_fe_5_corr = grad_fe * scale_G_fe + offset_G_fe
Пример #5
0
def se_2D_v0_RP():
    sample_nr = 1100             # number of (I,Q) samples to acquire during a shot of the experiment
    pe_step_nr = 32             # number of phase encoding steps
    tx_dt = 0.1                 # RF TX sampling time in microseconds; will be rounded to a multiple of system clocks (122.88 MHz)
    rx_dt = 1                 # desired sampling dt
    rx_dt_corr = rx_dt * 0.5    # correction factor till the bug is fixed
    sample_nr_echo = 32
    ##### Times in "<instruction_file>.txt" #####
    TR = 0.02e6  # Repetition time (us)
    TE = 0.001e6  # Echo time (us)
    T_tx_Rf = 10  # RF pulse length (us)
    T_G_pe_trig = 50  # Phase encoding gradient starting time (us)
    T_G_pe_dur = 200  # Phase encoding gradient ON time length (us)
    T_G_ramp_dur = 50  # Gradient ramp time
    T_G_fe_dur = 2 * T_G_pe_dur  # Frequency encoding gradient ON time length (us)
    t = np.linspace(0, TR, math.ceil(TR / tx_dt) + 1)  # 90 TX instruction length
    seq = np.array([[0, T_tx_Rf],  # 90 Rf pulse
                    [T_G_pe_trig, T_G_pe_trig + T_G_pe_dur],  # Phase encoding gradient
                    [TE / 2, TE / 2 + T_tx_Rf],  # 180 Rf pulse
                    [TE + T_tx_Rf / 2 - T_G_fe_dur / 2,
                     TE + T_tx_Rf / 2 + T_G_fe_dur / 2]])  # Frequency encoding gradient
    idx_tmp = np.zeros([np.size(seq, 1), np.size(seq, 0)])
    for idx in range(np.size(seq, 0)):
        idx_tmp[0, idx] = np.argmin(t <= seq[idx, 0])  # Instruction Start times
        idx_tmp[1, idx] = np.argmin(t <= seq[idx, 1])  # Instruction Stop times

    ##### RF pulses #####
    ### 90 RF pulse   ###
    # Time vector
    t_Rf_90 = np.linspace(0, T_tx_Rf, math.ceil(T_tx_Rf / tx_dt) + 1)  # Actual TX RF pulse length
    # sinc pulse
    alpha = 0.46  # alpha=0.46 for Hamming window, alpha=0.5 for Hanning window
    Nlobes = 1
    Rf_ampl = 0.125
    # sinc pulse with Hamming window
    tx90 = Rf_ampl * sinc(math.pi*(t_Rf_90 - T_tx_Rf/2),T_tx_Rf,Nlobes,alpha)
    # tx90 = Rf_ampl * np.ones(np.size(t_Rf_90))
    ### 180 RF pulse ###
    # sinc pulse     
    tx180 = tx90 * 2
    tx180 =np.concatenate((tx180, np.zeros(1000-np.size(tx180)-np.size(tx90))))

    # For testing ONLY: echo centering
    acq_shift = 0
    tx90_echo_cent = np.hstack((
        np.zeros(np.floor(T_G_fe_dur/(2*tx_dt)).astype('int')- np.floor(np.size(tx90)/2).astype('int')-acq_shift),
        tx90 ,
        np.zeros(np.floor(T_G_fe_dur/(2*tx_dt)).astype('int')- np.floor(np.size(tx90)/2).astype('int')+acq_shift)))
    # tx90_echo_cent = tx90_echo_cent * 0
    ##### Gradients #####
    # Phase encoding gradient shape
    grad_pe_samp_nr = math.ceil(T_G_pe_dur / 10)
    grad_ramp_samp_nr = math.ceil(T_G_ramp_dur / 10)
    grad_pe = np.hstack([np.linspace(0, 1, grad_ramp_samp_nr),  # Ramp up
                         np.ones(grad_pe_samp_nr - 2 * grad_ramp_samp_nr),  # Top
                         np.linspace(1, 0, grad_ramp_samp_nr)])  # Ramp down
    grad_pe = np.hstack([grad_pe, np.zeros(100 - np.size(grad_pe))])
    # Frequency encoding gradient shape
    grad_fe_samp_nr = math.ceil(T_G_fe_dur / 10)
    grad_fe = np.hstack([np.linspace(0, 1, grad_ramp_samp_nr),  # Ramp up
                         np.ones(grad_fe_samp_nr - 2 * grad_ramp_samp_nr),  # Top
                         np.linspace(1, 0, grad_ramp_samp_nr)])  # Ramp down
    grad_fe = np.hstack([grad_fe, np.zeros(100 - np.size(grad_fe))])
    # Correct for DC offset and scaling
    scale_G_x = 0.1
    scale_G_y = 0.1
    scale_G_z = 0.1
    offset_G_x = 0.05
    offset_G_y = 0.05
    offset_G_z = 0.0

    # Loop repeating TR and updating the gradients waveforms
    # data = np.zeros([np.size(grad_fe_corr),pe_step_nr])
    data = np.zeros([sample_nr, pe_step_nr], dtype=complex)
    exp = Experiment(samples=sample_nr,  # number of (I,Q) samples to acquire during a shot of the experiment
                     lo_freq=5,  # local oscillator frequency, MHz
                     tx_t=tx_dt,
                     # RF TX sampling time in microseconds; will be rounded to a multiple of system clocks (122.88 MHz)
                     rx_t=rx_dt_corr,  # RF RX sampling time in microseconds; as above
                     instruction_file="ocra_lib/se_default_vn.txt")
    exp.initialize_DAC()

    for idx2 in range(pe_step_nr):
        exp = Experiment(samples=sample_nr,  # number of (I,Q) samples to acquire during a shot of the experiment
                         lo_freq=5,  # local oscillator frequency, MHz
                         tx_t=tx_dt,
                         # RF TX sampling time in microseconds; will be rounded to a multiple of system clocks (122.88 MHz)
                         rx_t=rx_dt_corr,  # RF RX sampling time in microseconds; as above
                         instruction_file="se_2D_v0_RP.txt")
        ###### Send waveforms to RP memory ###########
        # Load the RF waveforms
        tx_idx = exp.add_tx(tx90)  # add the data to the ocra TX memory
        tx_idx = exp.add_tx(tx180)  # add the data to the ocra TX memory
        tx_idx = exp.add_tx(tx90_echo_cent)
        scale_G_pe_sweep = 2 * (idx2 / (pe_step_nr - 1) - 0.5)

        grad_x_pe_corr = grad_pe * scale_G_x + offset_G_x
        grad_y_pe_corr = grad_pe * scale_G_y * scale_G_pe_sweep + offset_G_y
        grad_z_pe_corr = np.zeros(np.size(grad_x_pe_corr))+ offset_G_z
        grad_x_fe_corr = grad_fe * scale_G_x + offset_G_x
        grad_y_fe_corr = np.zeros(np.size(grad_x_fe_corr)) + offset_G_y
        grad_z_fe_corr = np.zeros(np.size(grad_x_fe_corr)) + offset_G_z

        grad_idx = exp.add_grad(grad_x_pe_corr , grad_y_pe_corr , grad_z_pe_corr)
        grad_idx = exp.add_grad(grad_x_fe_corr , grad_y_fe_corr , grad_z_fe_corr)
        # grad_idx = exp.add_grad(np.zeros(np.size(grad_fe_corr)), grad_fe_corr, np.zeros(np.size(grad_fe_corr)))
        data[:, idx2] = exp.run()
        # data = exp.run()
        data_mV = data * 1000    # data = np.zeros([sample_nr, pe_step_nr])

    # time vector for representing the received data
    samples_data = len(data)
    t_rx = np.linspace(0, rx_dt * samples_data, samples_data)  # us

    plt.plot(t_rx, np.real(data_mV))
    # plt.plot(t_rx, np.imag(data_mV))
    plt.plot(t_rx, np.abs(data_mV))
    plt.legend(['real', 'imag', 'abs'])
    plt.xlabel('time (us)')
    plt.ylabel('signal received (mV)')
    plt.title('sampled data = %i' % samples_data)
    plt.grid()

    echo_delay = 96.5 # ms
    echo_shift_idx = np.floor(echo_delay/rx_dt).astype('int')
    echo_idx = np.floor(T_G_fe_dur / (2 * rx_dt)).astype('int') - np.floor(sample_nr_echo/ 2).astype('int')
    kspace = data[echo_idx+echo_shift_idx:echo_idx+echo_shift_idx+sample_nr_echo, : ]
    # Y = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(kspace)))

    plt.figure(2)
    plt.plot(t_rx[echo_idx+echo_shift_idx:echo_idx+echo_shift_idx+sample_nr_echo], np.real(kspace))
    # plt.plot(t_rx, np.imag(data_mV))
    plt.plot(t_rx[echo_idx+echo_shift_idx:echo_idx+echo_shift_idx+sample_nr_echo], np.abs(kspace))
    plt.legend(['real', 'imag', 'abs'])
    plt.xlabel('time (us)')
    plt.ylabel('signal received (mV)')
    plt.title('sampled data = %i' % samples_data)
    plt.grid()

    Y = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(kspace)))
    img = np.abs(Y)
    plt.figure(3)
    plt.imshow(img, cmap='gray')
    plt.title('image')
    plt.show()
Пример #6
0
    tx_idx = exp.add_tx(
        tx90_echo_cent
    )  # add Reference pulse only for measuring acquisition delay
    scale_G_pe_sweep = 2 * (idx2 / (pe_step_nr - 1) - 0.5
                            )  # Change phase encoding gradient magnitude

    # Adjust gradient waveforms
    grad_x_1_corr = grad_pre_fe * scale_G_x + offset_G_x
    grad_y_1_corr = grad_pe * scale_G_y * scale_G_pe_sweep + offset_G_y
    grad_z_1_corr = np.zeros(np.size(grad_x_1_corr)) + offset_G_z
    grad_x_2_corr = grad_fe * scale_G_x + offset_G_x
    grad_y_2_corr = np.zeros(np.size(grad_x_2_corr)) + offset_G_y
    grad_z_2_corr = np.zeros(np.size(grad_x_2_corr)) + offset_G_z

    # Load gradient waveforms
    grad_idx = exp.add_grad(grad_x_1_corr, grad_y_1_corr, grad_z_1_corr)
    grad_idx = exp.add_grad(grad_x_2_corr, grad_y_2_corr, grad_z_2_corr)

    # Run command to MaRCoS
    data[:, idx2] = exp.run()

# time vector for representing the received data
samples_data = len(data)
t_rx = np.linspace(0, rx_dt * samples_data, samples_data)  # us

plt.figure(1)
plt.subplot(2, 1, 1)
# plt.plot(t_rx, np.real(data))
# plt.plot(t_rx, np.abs(data))
# plt.plot(np.real(data))
plt.plot(np.abs(data))