pulseqzero 0.1.0__py3-none-any.whl

pulseqzero/__init__.py

@@ -0,0 +1,92 @@
+from contextlib import contextmanager
+
+
+class Impl:
+    def __init__(self):
+        self.use_pypulseq()
+
+    def use_pypulseq(self):
+        import pypulseq as pp
+        self.calc_SAR = pp.calc_SAR
+        self.Sequence = pp.Sequence
+        self.add_gradients = pp.add_gradients
+        self.align = pp.align
+        self.calc_duration = pp.calc_duration
+        self.calc_ramp = pp.calc_ramp
+        self.calc_rf_bandwidth = pp.calc_rf_bandwidth
+        self.calc_rf_center = pp.calc_rf_center
+        self.make_adc = pp.make_adc
+        self.make_adiabatic_pulse = pp.make_adiabatic_pulse
+        self.make_arbitrary_grad = pp.make_arbitrary_grad
+        self.make_arbitrary_rf = pp.make_arbitrary_rf
+        self.make_block_pulse = pp.make_block_pulse
+        self.sigpy_n_seq = pp.sigpy_n_seq
+        self.make_slr = pp.make_slr
+        self.make_sms = pp.make_sms
+        self.make_delay = pp.make_delay
+        self.make_digital_output_pulse = pp.make_digital_output_pulse
+        self.make_extended_trapezoid = pp.make_extended_trapezoid
+        self.make_extended_trapezoid_area = pp.make_extended_trapezoid_area
+        self.make_gauss_pulse = pp.make_gauss_pulse
+        self.make_label = pp.make_label
+        self.make_sinc_pulse = pp.make_sinc_pulse
+        self.make_trapezoid = pp.make_trapezoid
+        self.SigpyPulseOpts = pp.SigpyPulseOpts
+        self.make_trigger = pp.make_trigger
+        self.Opts = pp.Opts
+        self.points_to_waveform = pp.points_to_waveform
+        self.rotate = pp.rotate
+        self.scale_grad = pp.scale_grad
+        self.split_gradient = pp.split_gradient
+        self.split_gradient_at = pp.split_gradient_at
+        self.get_supported_labels = pp.get_supported_labels
+        self.traj_to_grad = pp.traj_to_grad
+
+    def use_pulseqzero(self):
+        from . import adapter as ad
+        self.calc_SAR = ad.calc_SAR
+        self.Sequence = ad.Sequence
+        # self.add_gradients = ad.add_gradients
+        # self.align = ad.align
+        self.calc_duration = ad.calc_duration
+        # self.calc_ramp = ad.calc_ramp
+        self.calc_rf_bandwidth = ad.calc_rf_bandwidth
+        self.calc_rf_center = ad.calc_rf_center
+        self.make_adc = ad.make_adc
+        # self.make_adiabatic_pulse = ad.make_adiabatic_pulse
+        self.make_arbitrary_grad = ad.make_arbitrary_grad
+        self.make_arbitrary_rf = ad.make_arbitrary_rf
+        self.make_block_pulse = ad.make_block_pulse
+        # self.sigpy_n_seq = ad.sigpy_n_seq
+        # self.make_slr = ad.make_slr
+        # self.make_sms = ad.make_sms
+        self.make_delay = ad.make_delay
+        self.make_digital_output_pulse = ad.make_digital_output_pulse
+        self.make_extended_trapezoid = ad.make_extended_trapezoid
+        # self.make_extended_trapezoid_area = ad.make_extended_trapezoid_area
+        self.make_gauss_pulse = ad.make_gauss_pulse
+        self.make_label = ad.make_label
+        self.make_sinc_pulse = ad.make_sinc_pulse
+        self.make_trapezoid = ad.make_trapezoid
+        # self.SigpyPulseOpts = ad.SigpyPulseOpts
+        self.make_trigger = ad.make_trigger
+        self.Opts = ad.Opts
+        # self.points_to_waveform = ad.points_to_waveform
+        # self.rotate = ad.rotate
+        # self.scale_grad = ad.scale_grad
+        # self.split_gradient = ad.split_gradient
+        # self.split_gradient_at = ad.split_gradient_at
+        self.get_supported_labels = ad.get_supported_labels
+        # self.traj_to_grad = ad.traj_to_grad
+
+
+pp_impl = Impl()
+
+
+@contextmanager
+def mr0_mode():
+    pp_impl.use_pulseqzero()
+    try:
+        yield
+    finally:
+        pp_impl.use_pypulseq()

pulseqzero/adapter/__init__.py

@@ -0,0 +1,47 @@
+def calc_SAR(file):
+    pass
+
+
+def make_label(label, type, value):
+    pass
+
+
+def calc_duration(*args):
+    # We assume that all events have a duration property
+    return max(
+        (event.duration for event in args if event is not None),
+        default=0.0
+    )
+
+
+def calc_rf_bandwidth(rf, cutoff=0.5, return_axis=False, return_spectrum=False):
+    import numpy as np
+    bw = 0
+    spectrum = np.zeros(1)
+    w = np.zeros(1)
+
+    if return_spectrum and not return_axis:
+        return bw, spectrum
+    if return_axis:
+        return bw, spectrum, w
+    return bw
+
+
+def calc_rf_center(rf):
+    return 0, 0
+
+
+def get_supported_labels():
+    return (
+        "SLC", "SEG", "REP", "AVG", "SET", "ECO", "PHS", "LIN", "PAR", "NAV",
+        "REV", "SMS", "REF", "IMA", "NOISE", "PMC", "NOROT", "NOPOS", "NOSCL",
+        "ONCE", "TRID",
+    )
+
+
+from .opts import Opts
+from .delay import make_delay, make_trigger, make_digital_output_pulse
+from .adc import make_adc
+from .grads import make_trapezoid, make_arbitrary_grad, make_extended_trapezoid
+from .pulses import make_arbitrary_rf, make_block_pulse, make_gauss_pulse, make_sinc_pulse
+from .sequence import Sequence

pulseqzero/adapter/adc.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from ..adapter import Opts
+
+
+def make_adc(
+    num_samples,
+    delay=0,
+    duration=None,
+    dwell=None,
+    freq_offset=0,
+    phase_offset=0,
+    system=None
+):
+    if (dwell is None) == (duration is None):
+        raise ValueError("Either dwell or duration must be defined")
+
+    if dwell is None:
+        dwell = duration / num_samples
+    if system is None:
+        system = Opts.default
+    if delay < system.adc_dead_time:
+        delay = system.adc_dead_time
+
+    return Adc(num_samples, dwell, delay, freq_offset, phase_offset)
+
+
+@dataclass
+class Adc:
+    num_samples: ...
+    dwell: ...
+    delay: ...
+    freq_offset: ...  # ignored by sim
+    phase_offset: ...
+
+    @property
+    def duration(self):
+        return self.delay + self.num_samples * self.dwell

pulseqzero/adapter/delay.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+
+def make_delay(d):
+    return Delay(d)
+
+
+def make_trigger(channel, delay=0, duration=0, system=None):
+    return Delay(delay)
+
+
+def make_digital_output_pulse(channel, delay=0, duration=None, system=None):
+    return Delay(delay)
+
+
+@dataclass
+class Delay:
+    delay: ...
+
+    @property
+    def duration(self):
+        return self.delay

pulseqzero/adapter/grads.py

@@ -0,0 +1,222 @@
+from dataclasses import dataclass
+from copy import copy
+import numpy as np
+from ..adapter import Opts, calc_duration
+
+
+def scale_grad(grad, scale):
+    grad = copy(grad)
+    if isinstance(grad, TrapGrad):
+        grad.amplitude *= scale
+    if isinstance(grad, FreeGrad):
+        grad.waveform *= scale
+    return grad
+
+
+def split_gradient(grad, system):
+    assert isinstance(grad, TrapGrad)
+    if system is None:
+        system = Opts.default
+    total_duration = calc_duration(grad)
+
+    ramp_up = make_extended_trapezoid(
+        channel=grad.channel,
+        amplitudes=np.array([0, grad.amplitude]),
+        times=np.ndarray([0, grad.rise_time])
+    )
+    flat_top = make_extended_trapezoid(
+        channel=grad.channel,
+        amplitudes=np.array([grad.amplitude, grad.amplitude]),
+        times=np.ndarray([grad.rise_time, grad.rise_time + grad.flat_time])
+    )
+    ramp_down = make_extended_trapezoid(
+        channel=grad.channel,
+        amplitudes=np.array([grad.amplitude, 0]),
+        times=np.ndarray([grad.rise_time + grad.flat_time, total_duration])
+    )
+
+    return ramp_up, flat_top, ramp_down
+
+
+def make_trapezoid(
+    channel,
+    amplitude=None,
+    area=None,
+    delay=0,
+    duration=None,
+    fall_time=None,
+    flat_area=None,
+    flat_time=None,
+    max_grad=None,
+    max_slew=None,
+    rise_time=None,
+    system=None,
+):
+    if system is None:
+        system = Opts.default
+    if max_grad is None:
+        max_grad = system.max_grad
+    if max_slew is None:
+        max_slew = system.max_slew
+
+    # new_amp is only calculated to set rise_time below, the actual
+    # amplitude is then calculated from tmp_amp and the timing
+
+    # TODO: This function should really be split into multiple with the different argument combination options
+
+    if flat_time is not None:
+        if amplitude is not None:
+            new_amp = amplitude
+        elif area is not None:
+            assert rise_time is not None
+            if fall_time is None:
+                fall_time = rise_time
+            new_amp = area / (rise_time / 2 + flat_time + fall_time / 2)
+        else:
+            assert flat_area is not None
+            new_amp = flat_area / flat_time
+
+        if rise_time is None:
+            rise_time = abs(new_amp) / max_slew
+        if fall_time is None:
+            fall_time = rise_time
+
+    elif duration is not None:
+        if amplitude is None:
+            assert area is not None
+
+            if rise_time is None:
+                _, rise_time, flat_time, fall_time = calc_params_for_area(area, max_slew, max_grad)
+                assert duration >= rise_time + flat_time + fall_time
+
+                dC = 1 / abs(2 * max_slew)
+                new_amp = (
+                    duration - (duration**2 - 4 * abs(area) * dC)
+                ) / (2 * dC)
+            else:
+                if fall_time is None:
+                    fall_time = rise_time
+                new_amp = area / (duration - rise_time / 2 - fall_time / 2)
+        else:
+            new_amp = amplitude
+
+        if rise_time is None:
+            rise_time = abs(new_amp) / max_slew
+        if fall_time is None:
+            fall_time = rise_time
+        flat_time = duration - rise_time - fall_time
+
+        if amplitude is None:
+            new_amp = area / (rise_time / 2 + flat_time + fall_time / 2)
+
+    else:
+        assert area is not None
+        new_amp, rise_time, flat_time, fall_time = calc_params_for_area(area, max_slew, max_grad)
+
+    return TrapGrad(
+        channel,
+        new_amp,
+        rise_time,
+        flat_time,
+        fall_time,
+        delay
+    )
+
+
+def calc_params_for_area(area, max_slew, max_grad):
+    rise_time = (abs(area) / max_slew)**0.5
+    amplitude = area / rise_time
+    t_eff = rise_time
+
+    if abs(amplitude) > max_grad:
+        t_eff = abs(area) / max_grad
+        amplitude = area / t_eff
+        rise_time = abs(amplitude) / max_slew
+
+    flat_time = t_eff - rise_time
+    fall_time = rise_time
+
+    return amplitude, rise_time, flat_time, fall_time
+
+
+@dataclass
+class TrapGrad:
+    channel: ...
+    amplitude: ...
+    rise_time: ...
+    flat_time: ...
+    fall_time: ...
+    delay: ...
+
+    @property
+    def area(self):
+        return self.amplitude * (self.rise_time / 2 + self.flat_time + self.fall_time / 2)
+
+    @property
+    def flat_area(self):
+        return self.amplitude * self.flat_time
+
+    @property
+    def duration(self):
+        return self.delay + self.rise_time + self.flat_time + self.fall_time
+
+
+def make_arbitrary_grad(
+    channel,
+    waveform,
+    delay=0,
+    max_grad=None,
+    max_slew=None,
+    system=None,
+):
+    if system is None:
+        system = Opts.default
+
+    tt = (np.arange(len(waveform)) + 0.5) * system.grad_raster_time
+
+    return FreeGrad(
+        channel,
+        waveform,
+        delay,
+        tt,
+        len(waveform) * system.grad_raster_time
+    )
+
+
+@dataclass
+class FreeGrad:
+    channel: ...
+    waveform: ...
+    delay: ...
+    tt: ...
+    shape_dur: ...
+
+    @property
+    def duration(self):
+        return self.delay + self.shape_dur
+
+    @property
+    def area(self):
+        return 0.5 * (
+            (self.tt[1:] - self.tt[:-1]) *
+            (self.waveform[1:] + self.waveform[:-1])
+        ).sum()
+
+
+def make_extended_trapezoid(
+    channel,
+    amplitudes=np.zeros(1),
+    convert_to_arbitrary=False,
+    max_grad=None,
+    max_slew=None,
+    skip_check=False,
+    system=None,
+    times=np.zeros(1),
+):
+    return FreeGrad(
+        channel,
+        amplitudes,
+        times[0],
+        times - times[0],
+        times[-1]
+    )

pulseqzero/adapter/opts.py

@@ -0,0 +1,98 @@
+def convert(from_value, from_unit, gamma, to_unit=""):
+    from math import pi
+
+    value_SI = from_value * {
+        "Hz/m": 1,
+        "mT/m": 1e-3 * gamma,
+        "rad/ms/mm": 1e6 / (2 * pi),
+        "Hz/m/s": 1,
+        "mT/m/ms": gamma,
+        "T/m/s": gamma,
+        "rad/ms/mm/ms": 1e9 / (2 * pi),
+    }[from_unit]
+
+    return value_SI * {
+        "Hz/m": 1,
+        "mT/m": 1e3 / gamma,
+        "rad/ms/mm": 1e-6 * 2 * pi,
+        "Hz/m/s": 1,
+        "mT/m/ms": 1 / gamma,
+        "T/m/s": 1 / gamma,
+        "rad/ms/mm/ms": 1e-9 * 2 * pi
+    }[to_unit]
+
+
+class Opts:
+    def __init__(
+        self,
+        adc_dead_time=None,
+        adc_raster_time=None,
+        block_duration_raster=None,
+        gamma=None,
+        grad_raster_time=None,
+        grad_unit="Hz/m",
+        max_grad=None,
+        max_slew=None,
+        rf_dead_time=None,
+        rf_raster_time=None,
+        rf_ringdown_time=None,
+        rise_time=None,
+        slew_unit="Hz/m/s",
+        B0=None,
+    ):
+        def select(a, b):
+            if a is not None:
+                return a
+            else:
+                return getattr(self.default, b)
+            return a if a is not None else b
+
+        self.gamma = select(gamma, "gamma")
+        self.max_grad = select(convert(max_grad, grad_unit, self.gamma, "Hz/m"), "max_grad")
+        self.max_slew = select(convert(max_slew, slew_unit, self.gamma, "Hz/m/s"), "max_slew")
+        # Rise time seems to overwrite
+        if rise_time is not None:
+            self.max_slew = self.max_grad / rise_time
+        self.adc_dead_time = select(adc_dead_time, "adc_dead_time")
+        self.adc_raster_time = select(adc_raster_time, "adc_raster_time")
+        self.block_duration_raster = select(block_duration_raster, "block_duration_raster")
+        self.rf_dead_time = select(rf_dead_time, "rf_dead_time")
+        self.rf_raster_time = select(rf_raster_time, "rf_raster_time")
+        self.grad_raster_time = select(grad_raster_time, "grad_raster_time")
+        self.rf_ringdown_time = select(rf_ringdown_time, "rf_ringdown_time")
+        self.B0 = select(B0, "B0")
+
+    def set_as_default(self):
+        from copy import copy
+        Opts.default = copy(self)
+
+    @classmethod
+    def reset_default(cls):
+        cls.default = Opts(
+            gamma=42.576e6,
+            max_grad=40,
+            grad_unit="mT/m",
+            max_slew=170,
+            slew_unit="T/m/s",
+            rf_dead_time=0,
+            rf_ringdown_time=0,
+            adc_dead_time=0,
+            adc_raster_time=100e-9,
+            rf_raster_time=1e-6,
+            grad_raster_time=10e-6,
+            block_duration_raster=10e-6,
+            B0=1.5
+        )
+
+    def __str__(self) -> str:
+        """
+        Print a string representation of the system limits objects.
+        """
+        variables = vars(self)
+        s = [f"{key}: {value}" for key, value in variables.items()]
+        s = "\n".join(s)
+        s = "System limits:\n" + s
+        return s
+
+
+Opts.reset_default()