dsv2pulseq 0.0.0__py3-none-any.whl

dsv2pulseq/__init__.py

@@ -0,0 +1 @@
+from .read_dsv import read_dsv, check_dsv

dsv2pulseq/dsv_to_pulseq.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import sys
+from dsv2pulseq.read_dsv import read_dsv
+
+defaults = {
+    'out_file': 'external.seq',
+    'ref_volt': 223.529007,
+    'lead_time': 100,
+    'hold_time': 30,
+    'adc_dead_time': 10,
+    'fov': [None, None, None],
+}
+
+def parse_arguments(argv=None):
+    parser = argparse.ArgumentParser(
+        description='Create Pulseq sequence file from dsv file.',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('in_file_prefix', type=str, help="Input dsv file prefix. E.g. 'gre'")
+    parser.add_argument('-o', '--out_file', type=str, help='Output Pulseq file.')
+    parser.add_argument('-r', '--ref_volt', type=float, help='Reference voltage of simulation [V].')
+    parser.add_argument('--lead_time', type=int, help='RF lead time [us].')
+    parser.add_argument('--hold_time', type=int, help='RF hold time [us].')
+    parser.add_argument('--adc_dead_time', type=int, help='ADC dead time [us].')
+    parser.add_argument('--fov', type=float, nargs=3, help='Field of view [mm] for x, y, z.')
+    parser.add_argument('--highgain', action='store_true', help='Set receiver gain to high.')
+
+    parser.set_defaults(**defaults)
+    return parser.parse_args(argv)
+
+def main(argv=None):
+    args = parse_arguments(argv)
+
+    # check input
+    sfx = ['_INF', '_GRX', '_GRY', '_GRZ', '_RFD', '_RFP']
+    for suffix in sfx:
+        fname = args.in_file_prefix + suffix + '.dsv'
+        if not os.path.isfile(fname):
+            raise OSError(f"DSV file {fname} does not exist.")
+
+    seq = read_dsv(args.in_file_prefix, args.ref_volt, plot=False)
+    seq.set_lead_hold_time(args.lead_time, args.hold_time)
+    seq.set_adc_dead_time(args.adc_dead_time)
+    seq.make_pulseq_sequence(args.out_file, fov=args.fov, highgain=args.highgain)
+
+if __name__ == "__main__":
+    sys.exit(main())

dsv2pulseq/helper.py

@@ -0,0 +1,56 @@
+"""
+Helper functions
+"""
+
+import numpy as np
+import math
+
+def trapezoid(amplitude, rise_time, flat_time, fall_time, dt=1e-5):
+    # Time segments
+    t_rise = np.arange(dt/2, rise_time, dt)
+    t_flat = np.arange(dt/2, flat_time, dt)
+    t_fall = np.arange(dt/2, fall_time, dt)
+
+    # Signal segments
+    rise = (amplitude / rise_time) * t_rise
+    plateau = np.ones_like(t_flat) * amplitude
+    fall = amplitude - (amplitude / fall_time) * t_fall
+
+    # Concatenate full waveform
+    waveform = np.concatenate((rise, plateau, fall))
+
+    return waveform
+
+def waveform_from_seqblock(grad, system=None):
+    """
+    extracts gradient waveform from Pypulseq sequence block
+    """
+
+    if grad.type == 'trap':
+        waveform = trapezoid(grad.amplitude, grad.rise_time, grad.flat_time, grad.fall_time, dt=system.grad_raster_time)
+    else:
+        waveform = grad.waveform
+
+    waveform = np.concatenate((np.zeros(int(grad.delay / system.grad_raster_time)), waveform))
+
+    return waveform
+
+def round_up_to_raster(number, decimals=5, tol=1e-10):
+    """
+    Round number up to a specific number of decimal places.
+    Rounds up only if the digit beyond the desired precision exceeds a tolerance.
+    This avoids rounding up for tiny floating point errors.
+    
+    Parameters:
+    - number: float, the value to round
+    - decimals: int, number of decimal places
+    - tol: float, minimum excess to consider as real (not floating point noise)
+    """
+    multiplier = 10 ** decimals
+    scaled = number * multiplier
+    rounded = math.floor(scaled)
+
+    if scaled - rounded > tol:
+        rounded += 1
+
+    return rounded / multiplier

dsv2pulseq/insert_twix_data.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+import argparse
+import twixtools
+import ismrmrd
+import sys
+
+defaults = {'out_file': 'merged_rawdata.dat'}
+
+def parse_arguments(argv=None):
+    parser = argparse.ArgumentParser(
+        description='Merge Pulseq data into Siemens raw data file.',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('in_file_1', type=str, help="Siemens raw data file acquired with original sequence.")
+    parser.add_argument('in_file_2', type=str, help="Pulseq raw data file.")
+    parser.add_argument('-o', '--out_file', type=str, help='Output Siemens raw data file name.')
+
+    parser.set_defaults(**defaults)
+    return parser.parse_args(argv)
+
+def main(argv=None):
+    args = parse_arguments(argv)
+
+    if not args.in_file_1.endswith('.dat'):
+        raise ValueError("Input file 1 must be a Siemens raw data file '.dat'.")
+    if not (args.in_file_2.endswith('.dat') or args.in_file_2.endswith('.mrd')):
+        raise ValueError("Input file 2 (Pulseq data file) must be either a Siemens raw data file '.dat' or ISMRMRD file '.mrd'.")
+    use_mrd = args.in_file_2.endswith('.mrd')
+
+    file1 = twixtools.read_twix(args.in_file_1, keep_syncdata=True, keep_acqend=True)
+    n_acq1 = len(file1[-1]['mdb'])
+    if use_mrd:
+        file2 = ismrmrd.Dataset(args.in_file_2)
+        n_acq2 = file2.number_of_acquisitions()
+        if n_acq1 - n_acq2 == 1:
+            n_acq2 += 1  # ACQEND is usually not converted to MRD
+    else:
+        file2 = twixtools.read_twix(args.in_file_2, keep_syncdata=True, keep_acqend=True)
+        n_acq2 = len(file2[-1]['mdb'])
+
+    if n_acq1 != n_acq2:
+        raise ValueError(f"Files have different number of measurement data blocks. File 1: {n_acq1}, File 2: {n_acq2}.")
+
+    print(f"Read and copy {n_acq1} measurement data blocks.")
+    for k, mdb in enumerate(file1[-1]['mdb']):
+        if not mdb.is_flag_set('ACQEND') and not mdb.is_flag_set('SYNCDATA'):
+            mdb = mdb.convert_to_local()
+            if use_mrd:
+                mdb.data = file2.read_acquisition(k).data.copy()
+            else:
+                mdb.data = file2[-1]['mdb'][k].data.copy()
+            file1[-1]['mdb'][k] = mdb
+
+    if use_mrd:
+        file2.close()
+
+    print(f"Writing merged data to {args.out_file}.")
+    twixtools.write_twix(file1, args.out_file, version_is_ve=True)
+
+if __name__ == "__main__":
+    sys.exit(main())

dsv2pulseq/read_dsv.py

@@ -0,0 +1,214 @@
+import time
+import numpy as np
+import logging
+import os
+from dsv2pulseq.sequence import Sequence
+from dsv2pulseq.read_dsv_samples import DSVFile
+from dsv2pulseq.read_dsv_inf import read_dsv_inf
+
+logging.basicConfig(level=logging.INFO)
+
+def plot_seq(dsv):
+    """
+    Plots the complete sequence
+    """
+    import matplotlib.pyplot as plt
+
+    plt.figure(figsize=(20,20))
+    plt.subplot(511)
+    dsv[0].plot()
+    plt.subplot(512)
+    dsv[1].plot()
+    plt.subplot(513)
+    dsv[2].plot()
+    plt.subplot(514)
+    dsv[3].plot()
+    plt.subplot(515)
+    dsv[4].plot()
+
+def read_dsv(file_prefix, ref_volt=223.529007, plot=False):
+    """ 
+    Reads dsv files and returns complete sequence
+
+    Parameters:
+        file_prefix: dsv file prefix, e.g. 'gre'
+        ref_volt: reference voltage of the simulation in V
+        plot: if True, plots the sequence shapes
+    Returns:
+        seq: Sequence object containing the shapes and blocks
+    """
+    seq = Sequence(ref_volt)
+
+    # read event shapes
+    logging.info(f"Read RF and gradient shapes of {file_prefix} sequence.")
+    start_dsv = time.time()
+    rfd = DSVFile(file_prefix+"_RFD.dsv")
+    rfp = DSVFile(file_prefix+"_RFP.dsv")
+    grx = DSVFile(file_prefix+"_GRX.dsv")
+    gry = DSVFile(file_prefix+"_GRY.dsv")
+    grz = DSVFile(file_prefix+"_GRZ.dsv")
+    end_dsv = time.time()
+    logging.info(f"Finished reading dsv files in {(end_dsv-start_dsv):.2f}s.")
+
+    shapes = [rfd, rfp, grx, gry, grz]
+    seq.set_shapes(shapes)
+
+    # Read block structure
+    logging.info("Read block structure.")
+    start_inf = time.time()
+    read_dsv_inf(file_prefix+"_INF.dsv", seq)
+    end_inf = time.time()
+    logging.info(f"Finished reading block structure in {(end_inf-start_inf):.2f}s.")
+
+    if plot:
+        plot_seq([rfd,rfp,grx,gry,grz])
+
+    return seq
+
+def check_dsv(file_prefix1, file_prefix2, time_shift=20):
+    """ 
+    Checks, if dsv files from converted sequence are the same as in the original sequence
+
+    Pulseq sequence shape usually have two 20us long additional global
+    freq/phase event in the beginning and end of the sequence. This can be
+    compensated by the time_shift parameter.
+
+    If provided, also the ADC shapes are compared.
+
+    Parameters:
+        file_prefix1: dsv file prefix of the original sequence
+        file_prefix2: dsv file prefix of the Pulseq sequence
+        time_shift: time shift in us for the Pulseq sequence
+
+    Returns:
+        seq1: Sequence object of the original sequence
+        seq2: Sequence object of the Pulseq sequence
+    """
+    import matplotlib.pyplot as plt
+
+    seq1 = read_dsv(file_prefix1)
+    seq2 = read_dsv(file_prefix2)
+
+    if os.path.exists(file_prefix1 + "_ADC.dsv") and os.path.exists(file_prefix2 + "_ADC.dsv"):
+        adc1_dsv = DSVFile(file_prefix1 + "_ADC.dsv")
+        adc2_dsv = DSVFile(file_prefix2 + "_ADC.dsv")
+        adc_delta = adc1_dsv.definitions.horidelta
+        seq1.adc = adc1_dsv.values
+        seq2.adc = adc2_dsv.values
+    else:
+        seq1.adc = None
+        seq2.adc = None
+
+    rfd1 = abs(seq1.rf)
+    rfp1 = np.angle(seq1.rf)
+    grx1 = seq1.gx
+    gry1 = seq1.gy
+    grz1 = seq1.gz
+    adc1 = seq1.adc
+
+    rfd2 = abs(seq2.rf)
+    rfp2 = np.angle(seq2.rf)
+    grx2 = seq2.gx
+    gry2 = seq2.gy
+    grz2 = seq2.gz
+    adc2 = seq2.adc
+
+    shift_rf = int(time_shift / seq1.delta_rf)
+    shift_grad = int(time_shift / seq1.delta_grad)
+
+    rfd2 = rfd2[shift_rf:-shift_rf]
+    rfp2 = rfp2[shift_rf:-shift_rf]
+    grx2 = grx2[shift_grad:-shift_grad]
+    gry2 = gry2[shift_grad:-shift_grad]
+    grz2 = grz2[shift_grad:-shift_grad]
+    if adc1 is not None and adc2 is not None:
+        shift_adc = int(time_shift / adc_delta)
+        adc2 = adc2[shift_adc:-shift_adc]
+        subplots = 6
+    else:
+        subplots = 5
+
+    len_rf = min(len(rfd1), len(rfd2))
+    len_gx = min(len(grx1), len(grx2))
+    len_gy = min(len(gry1), len(gry2))
+    len_gz = min(len(grz1), len(grz2))
+    if adc1 is not None and adc2 is not None:
+        len_adc = min(len(adc1), len(adc2))
+
+    # Plot sequence 1
+    n_subplots = subplots  # 5 or 6
+    plt.figure(figsize=(10, 2 * n_subplots))
+    plt.suptitle(f"Sequence 1: {file_prefix1}", fontsize=16)
+    plt.subplot(n_subplots, 1, 1)
+    plt.plot(rfd1)
+    plt.title("RFD")
+    plt.subplot(n_subplots, 1, 2)
+    plt.plot(rfp1)
+    plt.title("RFP")
+    plt.subplot(n_subplots, 1, 3)
+    plt.plot(grx1)
+    plt.title("GX")
+    plt.subplot(n_subplots, 1, 4)
+    plt.plot(gry1)
+    plt.title("GY")
+    plt.subplot(n_subplots, 1, 5)
+    plt.plot(grz1)
+    plt.title("GZ")
+    if n_subplots == 6:
+        plt.subplot(n_subplots, 1, 6)
+        plt.plot(adc1)
+        plt.title("ADC")
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+
+    # Plot sequence 2
+    plt.figure(figsize=(10, 2 * n_subplots))
+    plt.suptitle(f"Sequence 2: {file_prefix2}", fontsize=16)
+    plt.subplot(n_subplots, 1, 1)
+    plt.plot(rfd2)
+    plt.title("RFD")
+    plt.subplot(n_subplots, 1, 2)
+    plt.plot(rfp2)
+    plt.title("RFP")
+    plt.subplot(n_subplots, 1, 3)
+    plt.plot(grx2)
+    plt.title("GX")
+    plt.subplot(n_subplots, 1, 4)
+    plt.plot(gry2)
+    plt.title("GY")
+    plt.subplot(n_subplots, 1, 5)
+    plt.plot(grz2)
+    plt.title("GZ")
+    if n_subplots == 6:
+        plt.subplot(n_subplots, 1, 6)
+        plt.plot(adc2)
+        plt.title("ADC")
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+
+    # Plot difference
+    plt.figure(figsize=(10, 2 * n_subplots))
+    plt.suptitle(f"Difference: {file_prefix1} - {file_prefix2}", fontsize=16)
+    plt.subplot(n_subplots, 1, 1)
+    plt.plot(rfd1[:len_rf] - rfd2[:len_rf])
+    plt.title("RFD")
+    plt.subplot(n_subplots, 1, 2)
+    plt.plot(rfp1[:len_rf] - rfp2[:len_rf])
+    plt.title("RFP")
+    plt.subplot(n_subplots, 1, 3)
+    plt.plot(grx1[:len_gx] - grx2[:len_gx])
+    plt.title("GX")
+    plt.subplot(n_subplots, 1, 4)
+    plt.plot(gry1[:len_gy] - gry2[:len_gy])
+    plt.title("GY")
+    plt.subplot(n_subplots, 1, 5)
+    plt.plot(grz1[:len_gz] - grz2[:len_gz])
+    plt.title("GZ")
+    if n_subplots == 6:
+        plt.subplot(n_subplots, 1, 6)
+        plt.plot(adc1[:len_adc] - adc2[:len_adc])
+        plt.title("ADC")
+    plt.tight_layout(rect=[0, 0, 1, 0.96])
+
+    plt.show()
+
+    return seq1, seq2
+    

dsv2pulseq/read_dsv_inf.py

@@ -0,0 +1,94 @@
+"""
+Read a dsv INF file and append blocks to sequence
+"""
+
+def find_char(s, ch):
+    return [i for i, ltr in enumerate(s) if ltr == ch]
+
+def read_dsv_inf(file, seq):
+    """ Read INF dsv file (tested only for VE)
+
+    Important: The INF file contains the gradients in logical coordinate system (GP,GR,GS)
+    """
+
+    delta_rf = seq.delta_rf
+    delta_grad = seq.delta_grad
+
+    with open(file, 'r') as f:
+        line_ix = float('inf')
+        block_idx = -1
+        for k,line in enumerate(f):
+            if 'EventBlock' in line:
+                block_idx = seq.n_blocks
+                char_ix = find_char(line, ' ')
+                start_time = int(line[char_ix[-2]:char_ix[-1]])
+                duration = int(line[char_ix[-1]:])
+                seq.add_block(block_idx, duration, start_time)
+            if 'Rel.Time' in line:
+                ix = find_char(line, '|') # position of events in line
+                line_ix = k+2
+                ts_old = 0
+                freq_phase = None
+            if '|' not in line:
+                # end of event block
+                line_ix = float('inf')
+                ts = -1
+            if k>=line_ix:
+                block = seq.get_block(block_idx)
+                ts = int(line[ix[0]+1:ix[1]].strip())
+                block.add_timestamp(ts)
+
+                if ts != ts_old and freq_phase is not None:
+                    block.set_freqphase(freq_phase, ts_old)
+                    freq_phase = None
+
+                if line[ix[1]+1:ix[2]].strip():
+                    rf_str = line[ix[1]+1:ix[2]].strip()
+                    rf_dur = int(rf_str[rf_str.rfind('/')+1:].strip())
+                    rf_shape_ix = slice((block.start_time+ts)//delta_rf, (block.start_time+ts+rf_dur)//delta_rf)
+                    block.add_rf(rf_dur, rf_shape_ix, ts)
+                if line[ix[2]+1:ix[3]].strip():
+                    freqphase_str = line[ix[2]+1:ix[3]].strip()
+                    freq = float(freqphase_str[freqphase_str.rfind(':')+1:freqphase_str.rfind('/')].strip())
+                    phase = float(freqphase_str[freqphase_str.rfind('/')+1:].strip())
+                    freq_phase = [freq, phase]
+                if line[ix[4]+1:ix[5]].strip():
+                    adc_str = line[ix[4]+1:ix[5]].strip()
+                    adc_samples = float(adc_str[adc_str.rfind(':')+1:adc_str.rfind('/')].strip())
+                    adc_dur = float(adc_str[adc_str.rfind('/')+1:].strip())
+                    if "VOP_READOUT" not in adc_str: # pTx RX events during RFs are not ADCs
+                        block.add_adc(adc_dur, adc_samples, ts)
+                if line[ix[5]+1:ix[6]].strip():
+                    gp_str = line[ix[5]+1:ix[6]].strip()
+                    gp_ix = find_char(gp_str, '/')
+                    gp_amp = float(gp_str[gp_str.rfind(':')+1:gp_ix[0]].strip()) # amplitude in logical! coordinate system
+                    gp_rut = int(gp_str[gp_ix[0]+1:gp_ix[1]].strip())
+                    gp_dur = int(gp_str[gp_ix[1]+1:gp_ix[2]].strip())
+                    gp_rdt = int(gp_str[gp_ix[2]+1:].strip())
+                    gp_shape_ix = slice((block.start_time+ts)//delta_grad, (block.start_time+ts+gp_dur+gp_rdt)//delta_grad)
+                    block.add_grad('p', gp_amp, gp_dur, gp_rut, gp_rdt, gp_shape_ix, ts)
+                if line[ix[6]+1:ix[7]].strip():
+                    gr_str = line[ix[6]+1:ix[7]].strip()
+                    gr_ix = find_char(gr_str, '/')
+                    gr_amp = float(gr_str[gr_str.rfind(':')+1:gr_ix[0]].strip())
+                    gr_rut = int(gr_str[gr_ix[0]+1:gr_ix[1]].strip())
+                    gr_dur = int(gr_str[gr_ix[1]+1:gr_ix[2]].strip())
+                    gr_rdt = int(gr_str[gr_ix[2]+1:].strip())
+                    gr_shape_ix = slice((block.start_time+ts)//delta_grad, (block.start_time+ts+gr_dur+gr_rdt)//delta_grad)
+                    block.add_grad('r', gr_amp, gr_dur, gr_rut, gr_rdt, gr_shape_ix, ts)
+                if line[ix[7]+1:ix[8]].strip():
+                    gs_str = line[ix[7]+1:ix[8]].strip()
+                    gs_ix = find_char(gs_str, '/')
+                    gs_amp = float(gs_str[gs_str.rfind(':')+1:gs_ix[0]].strip())
+                    gs_rut = int(gs_str[gs_ix[0]+1:gs_ix[1]].strip())
+                    gs_dur = int(gs_str[gs_ix[1]+1:gs_ix[2]].strip())
+                    gs_rdt = int(gs_str[gs_ix[2]+1:].strip())
+                    gs_shape_ix = slice((block.start_time+ts)//delta_grad, (block.start_time+ts+gs_dur+gs_rdt)//delta_grad)
+                    block.add_grad('s', gs_amp, gs_dur, gs_rut, gs_rdt, gs_shape_ix, ts)
+                if line[ix[8]+1:ix[9]].strip():
+                    trig_str = line[ix[8]+1:ix[9]].strip()
+                    trig_type = trig_str[trig_str.rfind(':')+1:trig_str.rfind('/')].strip()
+                    trig_dur = int(trig_str[trig_str.rfind('/')+1:].strip())
+                    block.add_trig(trig_dur, trig_type, ts)
+
+                ts_old = ts

dsv2pulseq/read_dsv_samples.py

@@ -0,0 +1,148 @@
+"""
+This code is copied from the dsvreader from Markus Boland.
+"""
+
+# coding=utf-8
+import numpy as np
+import codecs
+from collections import namedtuple
+from warnings import warn
+
+class DSVFile:
+    """
+    This class loads and uncompresses a dsv file.
+    """
+
+    def __decode_dsv_values(self):
+        """
+        Decodes a compressed dsv array
+        :return: Decompressed dsv array
+
+        The values are signed 32-bit integers. The real value
+        will be obtained after division by VERTFACTOR.
+        If the same sample value is repeated several times,
+        the value is only listed twice, and the third value
+        specifies the number of repetitions.
+        Only the first sample is stored as an absolute value.
+        All other values are deltas to the preceeding value.
+        (This way it is possible to compress linear slopes.)
+        """
+        ndsv = np.zeros((int(self.definitions.samples)), dtype=int)
+        dsv = np.array(self.values, dtype=int)
+        count = 0
+        ncount = 1
+        ndsv[ncount] = dsv[count]
+        prev = dsv[0]
+        while count < dsv.shape[0]-1:
+            count += 1
+            if not (dsv[count] == prev):  # no repetition
+                ndsv[ncount] = ndsv[ncount-1] + dsv[count]
+                prev = dsv[count]
+                ncount += 1
+            else:  # number repeated
+                # get repetitions
+                nrep = dsv[count+1]
+                ndsv[ncount] = ndsv[ncount-1] + dsv[count]
+                ncount += 1
+                for i in range(nrep):
+                    ndsv[ncount] = ndsv[ncount-1] + dsv[count]
+                    ncount += 1
+                # store last value
+                prev = dsv[count]
+
+                # inc counters
+                count += 1
+
+        # apply vertical factor
+        ndsv = ndsv / self.definitions.vertfactor
+        return ndsv
+
+    @staticmethod
+    def __isfloat(value):
+        """
+        Returns if string contains a valid float
+        :param value: String
+        :return: Float?
+        """
+        try:
+            float(value)
+            return True
+        except ValueError:
+            return False
+
+    def __init__(self, filename, encoding='cp1252'):
+        """
+        Loads the data from filename
+        :param filename: Path to dsv file
+        :param encoding: Encoding of dsv file
+        :return:
+        The values are automatically uncompressed and stored in values field. Other parameters
+        are stored in field given by the structure of the dsv file. The values are converted
+        to float if possible and remain unicode if not (should be right for all params).
+        """
+
+        # load file
+        dsv_file = codecs.open(filename, 'r', encoding)
+        try:
+            filecnt = dsv_file.readlines()
+        finally:
+            dsv_file.close()
+
+        # trim lines
+        filecnt = list(map(str.strip, filecnt))
+        filecnt = [x for x in filecnt if len(x) > 0]
+        filecnt = [x for x in filecnt if not x.startswith(';')]
+        filecnt = list(map(str.lower, filecnt))
+
+        file_data = dict()
+        dictkeys = {'definitions', 'filetype', 'frame'}
+        listkeys = {'values'}
+        curkey = ''
+        for line in filecnt:
+            # Section line
+            if line.startswith('[') and line.endswith(']'):
+                line = line[1:-1]
+                if line in dictkeys:
+                    file_data[line] = dict()
+                    curkey = line
+                elif line in listkeys:
+                    setattr(self, line, list())
+                    curkey = line
+                else:
+                    warn(f'Unknown key {line} in DSV file {filename}... skipping.')
+            # Key value pair
+            elif line.find('=') > 0:
+                key, val = line.split('=')
+                if self.__isfloat(val):
+                    val = float(val)
+                file_data[curkey][key] = val
+            elif curkey in listkeys:
+                getattr(self, curkey).append(int(line))
+
+        # set params
+        for _d in dictkeys:
+            setattr(self, _d, namedtuple(_d, list(file_data[_d].keys()))(**file_data[_d]))
+
+        # uncompress values
+        self.values = self.__decode_dsv_values()
+        self.time = np.arange(self.values.shape[0]) * self.definitions.horidelta
+        pass
+
+    def plot(self, smin=0, skip=1000, smax=1000000):
+        """
+        Plots the stored dsv data
+        :param smin: Start index to plot
+        :param skip: Index delta
+        :param smax: Stop index
+        :return:
+        """
+        import matplotlib.pyplot as plt
+
+        smin *= int(10./self.definitions.horidelta)
+        smax *= int(10./self.definitions.horidelta)
+        skip *= int(10./self.definitions.horidelta)
+
+        plt.plot(self.time[smin:smax:skip], self.values[smin:smax:skip])
+        plt.xlabel(self.definitions.horiunitname)
+        plt.ylabel(self.definitions.vertunitname)
+        pass

dsv2pulseq/sequence.py

@@ -0,0 +1,517 @@
+import numpy as np
+import os
+import time
+import copy
+from warnings import warn
+import logging
+import pypulseq as pp
+from dsv2pulseq.helper import round_up_to_raster, waveform_from_seqblock
+
+
+class Block():
+    """
+    Event block in "Siemens style", allows more than one object per channel
+    All units are in Siemens units:
+    times: [us]
+    gradients: [mT/m]
+    RF pulses: [V]
+    """
+
+    def __init__(self, idx, duration, start_time):
+        self.block_idx = idx
+        self.block_duration = duration
+        self.start_time = start_time
+        self.timestamps = {}
+
+    def __repr__(self):
+        return f"Block {self.block_idx} with duration {self.block_duration} us at start time {self.start_time} us with timestamps {self.timestamps}."
+    
+    def add_timestamp(self, ts):
+        if not ts in self.timestamps:
+            self.timestamps[ts] = []
+
+    def add_rf(self, duration, shape_ix, ts):
+        self.add_timestamp(ts)
+        rf = Rf(duration, shape_ix)
+        self.timestamps[ts].append(rf)
+    
+    def add_grad(self, channel, amp, duration, ramp_up, ramp_dn, shape_ix, ts):
+        self.add_timestamp(ts)
+        grad = Grad(channel, amp, duration, ramp_up, ramp_dn, shape_ix)
+        self.timestamps[ts].append(grad)
+
+    def add_adc(self, duration, samples, ts):
+        self.add_timestamp(ts)
+        adc = Adc(duration, samples)
+        self.timestamps[ts].append(adc)
+
+    def add_trig(self, duration, trig_type, ts):
+        self.add_timestamp(ts)
+        trig = Trig(duration, trig_type)
+        self.timestamps[ts].append(trig)
+
+    def set_freqphase(self, freq_phase, ts):
+        for event in self.timestamps[ts]:
+            if event.type == 'rf' or event.type == 'adc':
+                event.set_freqphase(freq_phase)
+
+class Rf():
+
+    def __init__(self, duration, shape_ix):
+        self.type = 'rf'
+        self.duration = duration
+        self.freq = 0
+        self.phase = 0
+        self.shape_ix = shape_ix
+
+    def set_freqphase(self, freq_phase):
+        self.freq = freq_phase[0]
+        self.phase = freq_phase[1]
+    
+class Grad():
+
+    def __init__(self, channel, amp, duration, ramp_up, ramp_dn, shape_ix):
+        self.type = 'g' + channel 
+        self.channel = channel
+        self.amp = amp # amplitude in logical! coordinate system
+        self.duration = duration # flat_top + ramp_up
+        self.ramp_up = ramp_up
+        self.ramp_dn = ramp_dn
+        self.shape_ix = shape_ix
+
+class Adc():
+
+    def __init__(self, duration, samples):
+        self.type = 'adc'
+        self.duration = duration
+        self.samples = samples
+        self.freq = 0
+        self.phase = 0
+
+    def set_freqphase(self, freq_phase):
+        self.freq = freq_phase[0]
+        self.phase = freq_phase[1]
+
+class Trig():
+
+    def __init__(self, duration, trig_type):
+        self.type = 'trig'
+        self.duration = duration
+        self.trig_type = trig_type
+
+class Sequence():
+
+    def __init__(self, ref_volt):
+        self.n_blocks = 0
+        self.duration = 0
+        self.block_list = []
+
+        self.rf = np.array([])
+        self.gx = np.array([])
+        self.gy = np.array([])
+        self.gz = np.array([])
+
+        # raster times
+        self.delta_rf = 5 # RF raster times in dsv file [us]
+        self.delta_grad = 10 # Gradient raster times in dsv file [us]
+
+        # Conversion factors from dsv to (Py)Pulseq (SI) units
+        self.gamma = 42.576e6
+        self.cf_time = 1e-6 # [us] -> [s]
+        self.cf_grad = 1e-3*self.gamma # [mT/m] -> [Hz/m]
+
+        # ref_volt is voltage for 1ms 180 deg rectangular pulse
+        # -> pulse [Hz] = pulse[V]/ref_volt[V] * 500[Hz]
+        self.cf_rf = 5e2 / ref_volt # [V] -> [Hz]
+
+        # trigger types
+        self.trig_types = {'EXTRIG0': 'ext1', 'OSC0': 'osc0', 'OSC1': 'osc1'}
+
+        # coil lead & hold times
+        self.rf_lead_time = 100 # [us]
+        self.rf_hold_time = 30 # [us]
+
+        # ADC dead time
+        self.adc_dead_time = 10 # [us]
+
+    def add_block(self, idx, duration, start_time):
+        self.n_blocks += 1
+        self.duration = start_time + duration
+        self.block_list.append(Block(idx, duration, start_time))
+
+    def get_block(self, idx):
+        return self.block_list[idx]
+
+    def set_shapes(self, shapes):
+
+        rfd = shapes[0].values * shapes[0].definitions.maxlimit / np.max(shapes[0].values)
+        rf = rfd * np.exp(1j*np.deg2rad(shapes[1].values))
+        self.rf = rf
+        self.gx = shapes[2].values
+        self.gy = shapes[3].values
+        self.gz = shapes[4].values
+        self.delta_rf = int(shapes[0].definitions.horidelta)
+        self.delta_grad= int(shapes[2].definitions.horidelta)
+
+    def get_shape(self, event):
+        """
+        Gets shape for RF or gradient event
+
+        Logical coordinates 'gr', 'gp', 'gs' only map to the physical coordinates
+        when the sequence was simulated with transversal orientation and PE direction A->P
+        """
+        if event.type == 'rf':
+            return self.rf[event.shape_ix]
+        elif event.type == 'gx' or event.type == 'gr':
+            return self.gx[event.shape_ix]
+        elif event.type == 'gy' or event.type == 'gp':
+            return self.gy[event.shape_ix]
+        elif event.type == 'gz' or event.type == 'gs':
+            return self.gz[event.shape_ix]
+        else:
+            return None
+        
+    def set_lead_hold_time(self, rf_lead_time, rf_hold_time):
+        """
+        Set RF lead and hold times
+        """
+        self.rf_lead_time = rf_lead_time
+        self.rf_hold_time = rf_hold_time
+
+    def set_adc_dead_time(self, adc_dead_time):
+        """
+        Set ADC dead time
+        """
+        self.adc_dead_time = adc_dead_time
+
+    def make_pulseq_sequence(self, filename=None, fov=[None, None, None], highgain=False):
+        """
+        Create a Pulseq file from the sequence object.
+        Time tracking is always done in [us] (integers), 
+        time is only converted to [s], when creating a pulseq event
+        
+        Inputs:
+        --------
+        filename: If provided, Pulseq sequence will be saved to this file.
+        fov: Field of view in [mm] for x, y, z direction, which is set in the Pulseq file
+        """
+
+        logging.info("Create Pulseq sequence file.")
+        start_time = time.time()
+
+        filename = os.path.splitext(filename)[0] + '.seq'
+
+        system = pp.Opts(
+            max_grad=1e4,
+            max_slew=1e4,
+            rf_raster_time=self.delta_rf * self.cf_time,
+            grad_raster_time=self.delta_grad * self.cf_time,
+            grad_unit='mT/m',
+            slew_unit='mT/m/ms',
+            rf_ringdown_time=self.rf_hold_time * self.cf_time,
+            rf_dead_time=self.rf_lead_time * self.cf_time,
+            adc_dead_time=self.adc_dead_time * self.cf_time
+        )
+
+        pp_seq = pp.Sequence(system=system)
+        pp_seq.set_definition('Name', os.path.basename(filename))
+        if all(fov):
+            pp_seq.set_definition("FOV", [fov[0]*1e-3, fov[1]*1e-3, fov[2]*1e-3])
+        if highgain:
+            pp_seq.set_definition("ReceiverGainHigh", 1)
+
+        pulseq_events = self.__init_event_dict()
+        ts_offset = 0
+
+        if not self.block_list:
+            warn("No blocks in sequence. Please check the input DSV files. Exiting.")
+            return
+
+        # Shift RF and ADC timestamps to account for lead and dead times
+        block_list = self.make_pulseq_block_list()
+
+        for ix, block in enumerate(block_list):
+            if ix == 1:
+                pass
+            block_offset = block_list[ix - 1].block_duration if ix > 0 else 0
+            ts_offset -= block_offset # offset time if Siemens block is splitted
+            for ts in block.timestamps:
+                events = block.timestamps[ts]
+                concat_g = {'gx': False, 'gy': False, 'gz': False}
+                pulseq_time = ts - ts_offset # timestamp in the current Pulseq block [us]
+
+                # check if any event exceeds the current timestamp
+                event_exceeds = {}
+                for key, event in pulseq_events.items():
+                    if event is not None:
+                        duration = round(pp.calc_duration(event) / self.cf_time)
+                        event_exceeds[key] = duration > pulseq_time
+                    else:
+                        event_exceeds[key] = False
+                exceeded = any(event_exceeds.values())
+
+                if exceeded and any(pulseq_events[event.type] is not None for event in events):
+                    # Check if the block has to be split (Pulseq only allows one event per channel per block)
+                    # Gradients are either splitted or concatenated, depending on the presence of ADC, RF or Trigger events
+                    split = not (event_exceeds['rf'] or event_exceeds['adc'] or event_exceeds['trig'])
+                    if split: # split block
+                        split_pt = round(pulseq_time / self.delta_grad)
+                        pulseq_events_tmp = self.__init_event_dict()
+                        for key, pp_event in pulseq_events.items():
+                            if pp_event is None:
+                                continue
+                            pp_dur = round(pp.calc_duration(pp_event) / self.cf_time)
+                            if pp_dur > pulseq_time:
+                                if hasattr(pp_event, 'waveform') or hasattr(pp_event, 'amplitude'):
+                                    g_pre, g_post = self.__split_gradients(pp_event, split_pt, system)
+                                    pulseq_events_tmp[key] = g_post
+                                    pulseq_events[key] = g_pre
+                                else:
+                                    raise ValueError(f"Event with type {pp_event.type} in block with index {block.block_idx} "
+                                                        "cannot be split. Only gradients can be split.")
+                        if any(pulseq_events.values()):
+                            pp_seq.add_block(*self.__extract_events(pulseq_events))
+                        pulseq_events = pulseq_events_tmp.copy()
+                        ts_offset = round(ts / self.delta_grad) * self.delta_grad
+                    else: # concatenate gradients
+                        for event in events:
+                            if pulseq_events[event.type] is not None:
+                                pp_event = pulseq_events[event.type]
+                                if event.type[0] == 'g':
+                                    g_conc = self.__make_pp_grad(event, pulseq_time, system)
+                                    if g_conc is not None:
+                                        g_wf = [waveform_from_seqblock(pp_event, system=system), waveform_from_seqblock(g_conc, system=system)]
+                                        len_wf = max([len(wf) for wf in g_wf])
+                                        g_wf = [np.concatenate([wf, np.zeros(len_wf - len(wf))]) for wf in g_wf]
+                                        g_wf = g_wf[0] + g_wf[1]
+                                        pulseq_events[event.type] = self.__make_arbitrary_grad(g_wf, event.channel, 0, system=system)
+                                    concat_g[event.type] = True
+                                else:
+                                    raise ValueError(f"Event with type {pp_event.type} in block with index {block.block_idx} "
+                                                        "cannot be concatenated. Only gradients can be concatenated.")
+                elif not exceeded: 
+                    # no split or concatenation needed, start new block
+                    block_dur = pp.calc_duration(*self.__extract_events(pulseq_events))
+                    block_dur_rounded = round_up_to_raster(pp.calc_duration(*self.__extract_events(pulseq_events)), 5)
+                    if abs(block_dur - block_dur_rounded) > 1e-7:
+                        pulseq_events['delay'] = pp.make_delay(block_dur_rounded)
+                    if any(pulseq_events.values()):
+                        pp_seq.add_block(*self.__extract_events(pulseq_events))
+
+                    # Add remaining delay to the new block
+                    delay = round((ts - ts_offset) * self.cf_time, 5)
+                    delay_remain = delay - block_dur_rounded
+                    pulseq_events = self.__init_event_dict()
+                    if delay_remain > 0:
+                        pulseq_events['delay'] = pp.make_delay(delay_remain)
+                    ts_offset += round(block_dur_rounded  / self.cf_time)
+
+                # add events to the block
+                for event in events:
+                    event_del = ts - ts_offset
+                    if event_del < 0:
+                        raise ValueError("Negative event delay encountered.")
+                    if event.type == 'rf':
+                        event_del += self.rf_lead_time
+                        rf = self.__make_pp_rf(event, event_del, system)
+                        pulseq_events['rf'] = rf
+                    elif event.type in ['gx', 'gy', 'gz']:
+                        if not concat_g[event.type]:
+                            g = self.__make_pp_grad(event, event_del, system)
+                            if g is not None:
+                                pulseq_events[event.type] = g
+                    elif event.type == 'adc':
+                        event_del += self.adc_dead_time
+                        adc_dur = round(event.duration * self.cf_time, 7) # ADCs can be on nanosecond raster
+                        adc_del = round(event_del * self.cf_time, 6)
+                        adc = pp.make_adc(num_samples=event.samples, duration=adc_dur, delay=adc_del, freq_offset=event.freq, phase_offset=np.deg2rad(event.phase), system=system)
+                        pulseq_events['adc'] = adc
+                    elif event.type == 'trig':
+                        trig_dur = round(event.duration * self.cf_time, 6)
+                        trig_del = round(event_del * self.cf_time, 6)
+                        if event.trig_type in self.trig_types:
+                            trig = pp.make_digital_output_pulse(channel=self.trig_types[event.trig_type], duration=trig_dur, delay=trig_del, system=system)
+                            pulseq_events['trig'] = trig
+                        else:
+                            delay = trig_dur + trig_del
+                            if self.__check_delay(pulseq_events, delay):
+                                pulseq_events['trig'] = pp.make_delay(d=delay)
+                            logging.info(f'Unknown trigger type {event.trig_type} in block {block.block_idx} at time stamp {ts}. Replaced with delay.')
+
+        # add last block
+        delay = round((ts - ts_offset) * self.cf_time, 5)
+        if self.__check_delay(pulseq_events, delay):
+            pulseq_events['delay'] = pp.make_delay(delay)  # account for possible delay in last block
+        if any(pulseq_events.values()):
+            pp_seq.add_block(*self.__extract_events(pulseq_events))
+
+        # check timing of the sequence
+        # set raster time to 1us for timing check, as otherwise ADC delays will throw errors
+        pp_seq.system.rf_raster_time = 1e-6
+        ok, error_report = pp_seq.check_timing()
+        pp_seq.system.rf_raster_time = self.delta_rf * self.cf_time
+        if not ok:
+            warn(f"PyPulseq timing check failed with {len(error_report)} errors.")
+        
+        # write sequence
+        pp_seq.write(filename, check_timing=False)
+        end_time = time.time()
+        logging.info(f"Finished creating Pulseq file in {(end_time - start_time):.2f}s.")
+
+        return pp_seq
+
+    def __init_event_dict(self):
+        return {'rf': None, 'gx': None, 'gy': None, 'gz': None, 'adc': None, 'trig': None, 'delay': None}
+
+    def __extract_events(self, event_dict):
+        return [event for event in event_dict.values() if event is not None]
+
+    def __make_pp_rf(self, rf_event, event_del, system):
+            """
+            Make a Pulseq RF event
+            """
+
+            rf_sig = self.get_shape(rf_event)
+            rf_del = round(event_del*self.cf_time, 6)
+            rf = pp.make_arbitrary_rf(signal=rf_sig, flip_angle=1, delay=rf_del, freq_offset=rf_event.freq, phase_offset=np.deg2rad(rf_event.phase), return_gz=False, system=system)
+            rf.signal = rf_sig * self.cf_rf # reset the signal as it gets scaled in make_arbitrary_rf
+            return rf
+
+    def __make_pp_grad(self, grad_event, event_del, system):
+        """
+        Make a Pulseq gradient event
+        """
+
+        if grad_event.duration == 0 and grad_event.ramp_up == 0:
+            # zero duration gradient
+            return None
+        else:
+            g_wf = self.get_shape(grad_event) * self.cf_grad
+            g_del = round(event_del*self.cf_time, 5)
+            return self.__make_arbitrary_grad(g_wf, grad_event.channel, delay=g_del, system=system)
+
+    def __make_arbitrary_grad(self, wf, channel, delay, system):
+        
+        if len(wf) > 1:
+            grad = pp.make_arbitrary_grad(channel=channel, waveform=wf, delay=delay, system=system)
+        else:
+            # Pypulseq throws an error if the waveform has only one point.
+            grad = pp.make_arbitrary_grad(
+                channel=channel,
+                waveform=np.concatenate([wf, np.zeros(1, dtype=float)]),
+                delay=0,
+                system=system
+            )
+            grad.waveform = wf
+            grad.tt = (np.arange(len(wf)) + 0.5) * system.grad_raster_time
+            grad.shape_dur = len(wf) * system.grad_raster_time
+            grad.first = wf[0]
+            grad.last = wf[0]
+            grad.area = np.sum(wf * system.grad_raster_time)
+        return grad
+
+    def __split_gradients(self, grad_event, split_pt, system):
+        """
+        Split gradients at the split point.
+        """
+
+        g_wf = waveform_from_seqblock(grad_event, system=system) # already contains delay
+        g_pre_wf = g_wf[:split_pt]
+        g_post_wf = g_wf[split_pt:]
+
+        g_pre = self.__make_arbitrary_grad(g_pre_wf, grad_event.channel, 0, system)
+        g_post = self.__make_arbitrary_grad(g_post_wf, grad_event.channel, 0, system)
+        return g_pre, g_post
+
+    def __check_delay(self, pulseq_events, delay):
+        """
+        Check if delay is the longest delay in the current event block
+        """
+        pulseq_events = self.__extract_events(pulseq_events)
+        delays = [item.delay for item in pulseq_events if (item.type == "delay" and item is not None)] + [0]
+        if delay > max(delays):
+            return True
+        else:
+            return False
+    
+    def make_pulseq_block_list(self):
+        """
+        Restructures the block list to simplify writing the Pulseq file. This includes:
+        - RF events are shifted by the RF lead time to not violate it
+        - ADC events are shifted by the ADC dead time to not violate it
+
+        Additionally, gradient events are created on all axes for all time periods where a gradient is present on any axis.
+        Gradient timing from the INF file is in logical coordinates, while gradient waveforms (GRX/GRY/GRZ) are in physical coordinates. 
+        Since the rotation matrix is unavailable, we conservatively assume all axes are active wherever any axis has gradient activity.
+
+        Returns:
+        --------
+        A copy of self.block_list with 'rf' events shifted earlier by self.rf_lead_time.
+        The original self.block_list remains unchanged.
+        """
+
+        # Deep copy to avoid modifying original blocks or event lists
+        block_list_shifted = copy.deepcopy(self.block_list)
+
+        grad_offset = {'x': 0, 'y': 0, 'z': 0}
+        for block in block_list_shifted:
+            shifted_timestamps = {}
+            grad_ts = {'x': 0, 'y': 0, 'z': 0}
+            grad_end_last = {'x': 0, 'y': 0, 'z': 0}
+            grads = {'x': None, 'y': None, 'z': None}
+
+            for ts_str in block.timestamps:
+                ts = int(ts_str)
+                events = block.timestamps[ts_str]
+
+                if not events:
+                    shifted_timestamps.setdefault(ts, [])
+
+                for event in events:
+                    if event.type == 'rf':
+                        new_ts = ts - self.rf_lead_time
+                        shifted_timestamps.setdefault(new_ts, []).append(event)
+
+                    elif event.type == 'adc':
+                        new_ts = ts - self.adc_dead_time
+                        shifted_timestamps.setdefault(new_ts, []).append(event)
+
+                    elif event.type[0] == 'g':
+                        for axis, g in grads.items():
+                            grad_start = max(ts, grad_offset[axis])
+                            grad_dur = event.duration + event.ramp_dn
+                            grad_end = ts + grad_dur
+                            grad_dur = grad_end - grad_start # correct if offset > start
+                            shape_ix = slice((block.start_time + grad_start) // self.delta_grad,
+                                            (block.start_time + grad_start + grad_dur) // self.delta_grad)
+
+                            if grad_start >= grad_end_last[axis] and grad_end > grad_offset[axis]:
+                                if g is not None:
+                                    shifted_timestamps.setdefault(grad_ts[axis], []).append(g)
+
+                                g = Grad(axis, 0, grad_dur, grad_dur, 0, shape_ix)
+                                if any(self.get_shape(g)):
+                                    grads[axis] = g
+                                    grad_ts[axis] = grad_start
+                                    grad_end_last[axis] = grad_end
+
+                            elif grad_end > grad_end_last[axis]:
+                                grad_dur_new = g.duration + grad_end - grad_end_last[axis]
+                                shape_end_new = g.shape_ix.stop + (grad_end - grad_end_last[axis]) // self.delta_grad
+                                g.duration = g.ramp_up = grad_dur_new
+                                g.shape_ix = slice(g.shape_ix.start, shape_end_new)
+                                grad_end_last[axis] = grad_end
+
+                    else:
+                        shifted_timestamps.setdefault(ts, []).append(event)
+
+            for axis, g in grads.items():
+                grad_offset[axis] = grad_end_last[axis] - block.block_duration # gradients can extend beyond the block duration
+                if g is not None:
+                    shifted_timestamps.setdefault(grad_ts[axis], []).append(g)
+
+            block.timestamps = dict(
+                sorted(((ts, evts) for ts, evts in shifted_timestamps.items()), key=lambda x: int(x[0]))
+            )
+
+        return block_list_shifted

dsv2pulseq-0.0.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: dsv2pulseq
+Version: 0.0.0
+Summary: Create Pulseq sequences from dsv.
+Author-email: Marten Veldmann <marten.veldmann@dzne.de>
+License: MIT License
+Project-URL: Homepage, https://github.com/mavel101/dsv2pulseq
+Keywords: pulseq,dsv,siemens,mri
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pypulseq==1.4.2.post1
+Requires-Dist: ismrmrd==1.14.1
+Requires-Dist: twixtools==0.23
+Dynamic: license-file
+
+# dsv2pulseq
+
+Create Pulseq sequence files from Siemens dsv simulation files. The converter was only tested with VE/VX dsv file layouts.
+VB/VD files are not supported, as the simulator can not output RF phase data.  
+RF values might be differing slightly compared to the original sequence, as the dsv files contain RF values only on a 5us raster.
+
+## Dependencies & Installation
+
+A Python environment with the package installed can be created with the provided yml file: `conda env create -f dsv2pulseq.yml`.
+Unittests can be run with `python -m unittest discover test/`. This includes testing, whether the conversion is successful for each dsv dataset in the folder "test/test_data".
+
+This package only depends on numpy and PyPulseq [1].
+
+Merging data to the original Siemens raw data file for retrospective reconstruction (see "Reconstruction of Pulseq data") requires the twixtools package (https://github.com/pehses/twixtools).
+
+## Sequence simulation
+
+Simulate the sequence with the following settings:  
+- Transversal orientation with phase-encode direction A->P and no FOV shift (which is the default)
+- Simulate with RF phase output (sim /RFP+). 
+- Mandatory dsv files are "_INF", "_RFD", "_RFP", "_GRX", "_GRY" and "_GRZ".
+
+Example data "MiniFLASH.dsv" can be found in the test/test_data folder. These simulation files are from the Siemens MiniFLASH demo sequence.
+
+## Create Pulseq output
+
+The conversion can be started by running:  
+```
+dsv_to_pulseq -o OUT_FILE -r REF_VOLT IN_FILE_PREFIX
+```
+from the shell.
+
+The IN_FILE_PREFIX is the prefix of the dsv files, e.g. "gre" for "gre_XXX.dsv". The OUT_FILE is the Pulseq output sequence file (default: "external.seq"). The reference voltage is the voltage the sequence was simulated with (Siemens default: 223.529007 V).
+
+The conversion can also be done in Python by running:
+```
+from dsv2pulseq import read_dsv
+seq = read_dsv('/path/to/dsv/dsv_prefix')
+seq_pulseq = seq.make_pulseq_sequence('external.seq')
+```
+
+There is an experimental function to check the shapes of RF waveforms and gradients that plots the difference between the original and converted waveforms:
+```
+from dsv2pulseq import check_dsv
+check_dsv('/path_to_dsv/dsv_prefix_original', 'path_to_dsv/dsv_prefix_pulseq')
+```
+
+Note that:  
+- Only single transmit channel RF pulses are currently supported.
+- The Pulseq sequence has the same orientation as the original sequence in the physical/scanner coordinate system, when running the Pulseq interpreter in "XYZ in TRA" mode.
+- The Pulseq interpreter version 1.5.0 should be used, as the versions before contain a bug in setting the RF raster time correctly. 
+- RF and gradient waveforms might be slightly different compared to the original sequence due to limited numerical accuracy of the DSV files.
+- RF pulse values are on a 5us raster in the dsv files, which might be insufficient for pulses with rapidly varying phase
+
+## Reconstruction of Pulseq data
+
+Data acquired with the converted Pulseq sequence cannot be easily reconstructed, as the scan headers containing the meta information are missing.
+The data from the Pulseq sequence (IN_FILE_2) can be inserted into a raw data file acquired with the original sequence (IN_FILE_1) using twixtools (see dependencies). If twixtools is installed, the following command will insert the data:
+```
+insert_twix_data IN_FILE_1 IN_FILE_2 -o OUT_FILE
+```
+The merged output file (OUT_FILE) can be used for rectrospective reconstruction at the scanner. Alternatively the Pulseq data file can also be in the MRD format (requires ISMRMRD python package)
+
+## References
+
+[1] Ravi, Keerthi, Sairam Geethanath, and John Vaughan. "PyPulseq: A Python Package for MRI Pulse Sequence Design." Journal of Open Source Software 4.42 (2019): 1725., https://github.com/imr-framework/pypulseq

dsv2pulseq-0.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+dsv2pulseq/__init__.py,sha256=owW-fIyzHOvugm4hJwBXLvSLfjjCKJ76obKteZsXZCU,41
+dsv2pulseq/dsv_to_pulseq.py,sha256=N_CKKwWOBKst8aQ9cFdMIHu4gLIXv4TQJko17BGmR9Y,1867
+dsv2pulseq/helper.py,sha256=irbn8beTvuSnSVBXP0r3Bs1trOg4BhPYQ8L4KXkLoaw,1633
+dsv2pulseq/insert_twix_data.py,sha256=ap6NwrdO9g1_ZyyJ-eIUyesFIEkd_TkTsWCQYGUnIMo,2394
+dsv2pulseq/read_dsv.py,sha256=6YgAk7Ex887uyLMCHaIcDcx3n6aeOQcQqg4FATLcWsc,6216
+dsv2pulseq/read_dsv_inf.py,sha256=9InZBXvRsBwZLKO6gmCZ9FAAaXLlGESdYuLckMpt2p8,4959
+dsv2pulseq/read_dsv_samples.py,sha256=OSVwsFNv37JBAAwJhg3Z2SXVRCB7xaBUo3vQlVqTTF8,4950
+dsv2pulseq/sequence.py,sha256=ogVnsfMgeC07rghViObZgY3Tz979VOnxC-o97Tn3SgI,22793
+dsv2pulseq-0.0.0.dist-info/licenses/LICENSE,sha256=BLTe_Dlta_WTwEeHsZVasjaklHAx6IFpWguMWroxs4U,1072
+dsv2pulseq-0.0.0.dist-info/METADATA,sha256=qZf-DziA4OSRfHxTo3SUdMlGm48o-vKB2MKz98H7lQw,4320
+dsv2pulseq-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsv2pulseq-0.0.0.dist-info/entry_points.txt,sha256=9r2VipfrgHXLDTwsGeyCK7XyJ0lcdycCDMJO4lVc4Bo,116
+dsv2pulseq-0.0.0.dist-info/top_level.txt,sha256=HE9Nz1e1uYO0SPUX-Ub868nHguGulocRXGUgAEi3S4g,11
+dsv2pulseq-0.0.0.dist-info/RECORD,,

dsv2pulseq-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dsv2pulseq-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dsv_to_pulseq = dsv2pulseq.dsv_to_pulseq:main
+insert_twix_data = dsv2pulseq.insert_twix_data:main

dsv2pulseq-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Marten Veldmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dsv2pulseq-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dsv2pulseq