pulseqzero 0.1.2__tar.gz → 0.1.4__tar.gz

{pulseqzero-0.1.2/src/pulseqzero.egg-info → pulseqzero-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulseqzero
-Version: 0.1.2
+Version: 0.1.4
 Summary: Use PyPulseq for MRI sequence definitions in MR-zero
 Author-email: Jonathan Endres <jonathan.endres@uk-erlangen.de>
 Project-URL: Repository, https://github.com/pulseq-frame/pulseq-zero
@@ -54,7 +54,7 @@ It relies on the following amazing projects:
 
 ## 2. Usage
 
-Example scripts are provided in [pulseqzero/seq_examples](pulseqzero/seq_examples).
+Example scripts are provided in the [tests](tests) folder.
 They are modified versions of the PyPulseq 1.4.2 examples found [here](https://github.com/imr-framework/pypulseq/tree/v1.4.2/pypulseq/seq_examples/scripts).
 The changes that are typically necessary to convert from a pypulseq sequence script to Pulseq-zero are as follows:
 
@@ -166,6 +166,49 @@ If you want to contribute to Pulseq-zero or make local changes to it, the easies
 
 ## 4. API
 
+### Additional API
+
+Pulseq requires many events to align with the block-, gradient- or ADC raster.
+For this, rounding is necessary, which is not differentiable.
+As a workaround, Pulseq-zero includes differentiable rounding functions, which are wrappers around the corresponding PyTorch functions, but which behave like the identity function for backpropagation.
+This means they are invisible to the calculation of gradients, which is okay as long as the rounding is small compared to the changes to the optimized parameters, which is typically the case with small raster times.
+
+```python
+my_param = torch.tensor(1.5, requires_grad=True)
+some_calc = pp.round(torch.sin(my_param))
+some_calc.backward()
+
+assert some_calc == 1
+assert my_param.grad == torch.cos(my_param)
+```
+Use pulseq-zeros rounding functions instead of e.g. those of numpy or torch if it is applied to timings (or other sequence properties) that are part of an optimization.
+
+In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+```
+
+If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
+```python
+if pulseqzero.is_mr0_mode():
+  pass
+else:
+  seq.calculate_pns()
+```
+
+Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+  # This function here
+  mr0_seq = seq.to_mr0()
+  # Now do some simulations with mr0_seq!
+```
+
+
+### PyPulseq API
+
 The following is a list of all functions and methods exposed in PyPulseq 1.4.2 when importing it directly.
 Pulseq-zero tries to provide all of those - it is currently not planned to cover other functions that are available internally in PyPulseq but not exposed this way.
 If you need one of them, file an issue or submit a pull request.
@@ -270,7 +313,7 @@ The reason for disabling is either that a differentiable re-implementation if ou
 | `make_label` | `None` |
 | `make_extended_trapezoid_area` | **error** |
 | `calc_rf_bandwidth` | returns zeroes as mr0 mode doesn't store pulse shapes |
-| `calc_rf_center` | returns zeroes as mr0 mode doesn't store pulse shapes |
+| `calc_rf_center` | returns (shape_dur / 2, 0) - mr0 mode ignores (assymetric) pulse shapes |
 | `points_to_waveform` | **error** |
 
 ### Altered behaviour
@@ -296,33 +339,6 @@ Pulses have no shape, `center_pos` will influence the returned `gzr` but nothing
 | `make_extended_trapezoid` | skipping some checks and ignoring `convert_to_arbitrary`; `area` is a computed property, no `first` or `last` |
 | `Sequence` | way less internal bookkeeping, most variables are missing, reports etc. are not calculated |
 
-### Additional API
-
-This API is where Pulseq-zero comes into play:
-
-In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-```
-
-If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
-```python
-if pulseqzero.is_mr0_mode():
-  pass
-else:
-  seq.calculate_pns()
-```
-
-Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-  # This function here
-  mr0_seq = seq.to_mr0()
-  # Now do some simulations with mr0_seq!
-```
-
 
 ## 5. References
 

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/README.md

@@ -42,7 +42,7 @@ It relies on the following amazing projects:
 
 ## 2. Usage
 
-Example scripts are provided in [pulseqzero/seq_examples](pulseqzero/seq_examples).
+Example scripts are provided in the [tests](tests) folder.
 They are modified versions of the PyPulseq 1.4.2 examples found [here](https://github.com/imr-framework/pypulseq/tree/v1.4.2/pypulseq/seq_examples/scripts).
 The changes that are typically necessary to convert from a pypulseq sequence script to Pulseq-zero are as follows:
 
@@ -154,6 +154,49 @@ If you want to contribute to Pulseq-zero or make local changes to it, the easies
 
 ## 4. API
 
+### Additional API
+
+Pulseq requires many events to align with the block-, gradient- or ADC raster.
+For this, rounding is necessary, which is not differentiable.
+As a workaround, Pulseq-zero includes differentiable rounding functions, which are wrappers around the corresponding PyTorch functions, but which behave like the identity function for backpropagation.
+This means they are invisible to the calculation of gradients, which is okay as long as the rounding is small compared to the changes to the optimized parameters, which is typically the case with small raster times.
+
+```python
+my_param = torch.tensor(1.5, requires_grad=True)
+some_calc = pp.round(torch.sin(my_param))
+some_calc.backward()
+
+assert some_calc == 1
+assert my_param.grad == torch.cos(my_param)
+```
+Use pulseq-zeros rounding functions instead of e.g. those of numpy or torch if it is applied to timings (or other sequence properties) that are part of an optimization.
+
+In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+```
+
+If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
+```python
+if pulseqzero.is_mr0_mode():
+  pass
+else:
+  seq.calculate_pns()
+```
+
+Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+  # This function here
+  mr0_seq = seq.to_mr0()
+  # Now do some simulations with mr0_seq!
+```
+
+
+### PyPulseq API
+
 The following is a list of all functions and methods exposed in PyPulseq 1.4.2 when importing it directly.
 Pulseq-zero tries to provide all of those - it is currently not planned to cover other functions that are available internally in PyPulseq but not exposed this way.
 If you need one of them, file an issue or submit a pull request.
@@ -258,7 +301,7 @@ The reason for disabling is either that a differentiable re-implementation if ou
 | `make_label` | `None` |
 | `make_extended_trapezoid_area` | **error** |
 | `calc_rf_bandwidth` | returns zeroes as mr0 mode doesn't store pulse shapes |
-| `calc_rf_center` | returns zeroes as mr0 mode doesn't store pulse shapes |
+| `calc_rf_center` | returns (shape_dur / 2, 0) - mr0 mode ignores (assymetric) pulse shapes |
 | `points_to_waveform` | **error** |
 
 ### Altered behaviour
@@ -284,33 +327,6 @@ Pulses have no shape, `center_pos` will influence the returned `gzr` but nothing
 | `make_extended_trapezoid` | skipping some checks and ignoring `convert_to_arbitrary`; `area` is a computed property, no `first` or `last` |
 | `Sequence` | way less internal bookkeeping, most variables are missing, reports etc. are not calculated |
 
-### Additional API
-
-This API is where Pulseq-zero comes into play:
-
-In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-```
-
-If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
-```python
-if pulseqzero.is_mr0_mode():
-  pass
-else:
-  seq.calculate_pns()
-```
-
-Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-  # This function here
-  mr0_seq = seq.to_mr0()
-  # Now do some simulations with mr0_seq!
-```
-
 
 ## 5. References
 

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pulseqzero"
-version = "0.1.2"
+version = "0.1.4"
 description = "Use PyPulseq for MRI sequence definitions in MR-zero"
 readme = "README.md"
 authors = [

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/__init__.py

@@ -1,5 +1,7 @@
 from contextlib import contextmanager
 
+from .math import ceil, floor, round
+
 
 class Impl:
     def __init__(self):
@@ -26,7 +28,11 @@ class Impl:
         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
+        try:  # Fix for pypulseq 1.4.2 which doesn't re-export this
+            self.make_arbitrary_grad = pp.make_arbitrary_grad
+        except ImportError:
+            from pypulseq.make_arbitrary_grad import make_arbitrary_grad
+            self.make_arbitrary_grad = 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

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/adapter/__init__.py

@@ -28,7 +28,7 @@ def calc_rf_bandwidth(rf, cutoff=0.5, return_axis=False, return_spectrum=False):
 
 
 def calc_rf_center(rf):
-    return 0, 0
+    return rf.shape_dur / 2, 0
 
 
 def get_supported_labels():

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/adapter/grads.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from copy import copy
 import numpy as np
 from ..adapter import Opts, calc_duration
+from ..math import ceil
 
 
 def scale_grad(grad, scale):
@@ -22,17 +23,17 @@ def split_gradient(grad, system):
     ramp_up = make_extended_trapezoid(
         channel=grad.channel,
         amplitudes=np.array([0, grad.amplitude]),
-        times=np.ndarray([0, grad.rise_time])
+        times=np.array([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])
+        times=np.array([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])
+        times=np.array([grad.rise_time + grad.flat_time, total_duration])
     )
 
     return ramp_up, flat_top, ramp_down
@@ -77,7 +78,9 @@ def make_trapezoid(
             new_amp = flat_area / flat_time
 
         if rise_time is None:
-            rise_time = abs(new_amp) / max_slew
+            rise_time = ceil(abs(new_amp) / max_slew / system.grad_raster_time) * system.grad_raster_time
+            if rise_time == 0:
+                rise_time = system.grad_raster_time
         if fall_time is None:
             fall_time = rise_time
 
@@ -86,7 +89,9 @@ def make_trapezoid(
             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)
+                _, rise_time, flat_time, fall_time = calc_params_for_area(
+                    area, max_slew, max_grad, system.grad_raster_time
+                )
                 assert duration >= rise_time + flat_time + fall_time
 
                 dC = 1 / abs(2 * max_slew)
@@ -101,7 +106,9 @@ def make_trapezoid(
             new_amp = amplitude
 
         if rise_time is None:
-            rise_time = abs(new_amp) / max_slew
+            rise_time = ceil(abs(new_amp) / max_slew / system.grad_raster_time) * system.grad_raster_time
+            if rise_time == 0:
+                rise_time = system.grad_raster_time
         if fall_time is None:
             fall_time = rise_time
         flat_time = duration - rise_time - fall_time
@@ -111,7 +118,9 @@ def make_trapezoid(
 
     else:
         assert area is not None
-        new_amp, rise_time, flat_time, fall_time = calc_params_for_area(area, max_slew, max_grad)
+        new_amp, rise_time, flat_time, fall_time = calc_params_for_area(
+            area, max_slew, max_grad, system.grad_raster_time
+        )
 
     return TrapGrad(
         channel,
@@ -123,15 +132,18 @@ def make_trapezoid(
     )
 
 
-def calc_params_for_area(area, max_slew, max_grad):
-    rise_time = (abs(area) / max_slew)**0.5
+def calc_params_for_area(area, max_slew, max_grad, grad_raster_time):
+    rise_time = ceil((abs(area) / max_slew)**0.5 / grad_raster_time) * grad_raster_time
     amplitude = area / rise_time
     t_eff = rise_time
 
     if abs(amplitude) > max_grad:
-        t_eff = abs(area) / max_grad
+        t_eff = ceil(abs(area) / max_grad / grad_raster_time) * grad_raster_time
         amplitude = area / t_eff
-        rise_time = abs(amplitude) / max_slew
+        rise_time = ceil(abs(amplitude) / max_slew / grad_raster_time) * grad_raster_time
+
+        if rise_time == 0:
+            rise_time = grad_raster_time
 
     flat_time = t_eff - rise_time
     fall_time = rise_time

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/adapter/pulses.py

@@ -225,11 +225,11 @@ def make_sinc_pulse(
         area = BW / slice_thickness * duration
 
         gz = make_trapezoid(
-            "z", max_grad=max_grad, max_slew=max_slew,
-            flat_time=duration, flat_area=area
+            "z", system=system,
+            flat_area=area, flat_time=duration
         )
         gzr = make_trapezoid(
-            "z", max_grad=max_grad, max_slew=max_slew,
+            "z", system=system,
             area=-area * (1 - center_pos) - 0.5 * (gz.area - area)
         )
 

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/adapter/seq_convert.py

@@ -40,11 +40,10 @@ def convert(pp0) -> mr0.Sequence:
                     grad_z = ev
 
         if rf:
-            assert delay is None and adc is None
-            seq += parse_pulse(rf, grad_x, grad_y, grad_z)
+            assert adc is None
+            seq += parse_pulse(delay, rf, grad_x, grad_y, grad_z)
         elif adc:
-            assert delay is None
-            seq += parse_adc(adc, grad_x, grad_y, grad_z)
+            seq += parse_adc(delay, adc, grad_x, grad_y, grad_z)
         else:
             seq += parse_spoiler(delay, grad_x, grad_y, grad_z)
 
@@ -129,9 +128,9 @@ class TmpAdc:
         return f"Adc(phase={self.phase * 180 / pi}°, total_gradm={self.gradm.sum(0)}, total_time={self.event_time.sum(0)})"
 
 
-def parse_pulse(rf, grad_x, grad_y, grad_z) -> tuple[TmpSpoiler, TmpPulse, TmpSpoiler]:
+def parse_pulse(delay, rf, grad_x, grad_y, grad_z) -> tuple[TmpSpoiler, TmpPulse, TmpSpoiler]:
     t = rf.delay + rf.shape_dur / 2
-    duration = calc_duration(rf, grad_x, grad_y, grad_z)
+    duration = calc_duration(delay, rf, grad_x, grad_y, grad_z)
 
     gx1 = gx2 = gy1 = gy2 = gz1 = gz2 = 0.0
     if grad_x:
@@ -156,11 +155,12 @@ def parse_spoiler(delay, grad_x, grad_y, grad_z) -> tuple[TmpSpoiler]:
     return (TmpSpoiler(duration, gx, gy, gz), )
 
 
-def parse_adc(adc: Adc, grad_x, grad_y, grad_z) -> tuple[TmpAdc, TmpSpoiler]:
-    duration = calc_duration(adc, grad_x, grad_y, grad_z)
+# TODO: why does only adc have typing?
+def parse_adc(delay, adc: Adc, grad_x, grad_y, grad_z) -> tuple[TmpAdc, TmpSpoiler]:
+    duration = calc_duration(delay, adc, grad_x, grad_y, grad_z)
     time = torch.cat([
         torch.as_tensor(0.0).view((1, )),
-        adc.delay + torch.arange(adc.num_samples) * adc.dwell,
+        adc.delay + (torch.arange(adc.num_samples) + 0.5) * adc.dwell,
         torch.as_tensor(duration).view((1, ))
     ])
 
@@ -190,7 +190,10 @@ def integrate(grad, t):
     if isinstance(grad, TrapGrad):
         # heaviside could be replaced with error function for differentiability
         def h(x):
-            return torch.heaviside(torch.as_tensor(x), torch.tensor(0.5))
+            try:
+                return torch.heaviside(torch.as_tensor(x), torch.tensor(0.5, dtype=x.dtype))
+            except AttributeError:
+                return 0 if x < 0 else 1 if x > 0 else 0.5
 
         # https://www.desmos.com/calculator/0q5co02ecm
 
@@ -221,10 +224,10 @@ def integrate(grad, t):
         # https://www.desmos.com/calculator/j2vopzhb2z
 
         # Start and end time point and amplitude of all line segments
-        t1 = torch.as_tensor(grad.times[:-1])
-        t2 = torch.as_tensor(grad.times[1:])
-        c1 = torch.as_tensor(grad.amplitudes[:-1])
-        c2 = torch.as_tensor(grad.amplitudes[1:])
+        t1 = torch.as_tensor(grad.tt[:-1])
+        t2 = torch.as_tensor(grad.tt[1:])
+        c1 = torch.as_tensor(grad.waveform[:-1])
+        c2 = torch.as_tensor(grad.waveform[1:])
 
         # This is how much of every segment contributes, clamped to [0, width]
         t_rel = torch.clamp(t - t1, 0 * t1, t2 - t1)

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero/adapter/sequence.py

@@ -21,7 +21,7 @@ class Sequence:
     def duration(self):
         duration = sum(calc_duration(*block) for block in self.blocks)
         num_blocks = len(self.blocks)
-        event_count = len(filter(lambda b: len(b) > 0, self.blocks))
+        event_count = sum(len(b) for b in self.blocks)
         return duration, num_blocks, event_count
 
     def get_definition(self, key):

pulseqzero-0.1.4/src/pulseqzero/math.py

@@ -0,0 +1,71 @@
+import torch
+import numpy as np
+
+
+class Ceil(torch.autograd.Function):
+    @staticmethod
+    def forward(x):
+        return torch.ceil(x)
+    
+    @staticmethod
+    def setup_context(ctx, inputs, output):
+        pass
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output
+
+
+class Floor(torch.autograd.Function):
+    @staticmethod
+    def forward(x):
+        return torch.floor(x)
+    
+    @staticmethod
+    def setup_context(ctx, inputs, output):
+        pass
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output
+
+
+class Round(torch.autograd.Function):
+    @staticmethod
+    def forward(x):
+        return torch.round(x)
+    
+    @staticmethod
+    def setup_context(ctx, inputs, output):
+        pass
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output
+
+
+def ceil(x: torch.Tensor | float) -> torch.Tensor:
+    """Differentiable version of torch.ceil.
+    For gradient calculation, this mimicks the identity function."""
+    try:
+        return Ceil.apply(x)
+    except TypeError:
+        return torch.as_tensor(np.ceil(x))
+
+
+def floor(x: torch.Tensor) -> torch.Tensor:
+    """Differentiable version of torch.floor.
+    For gradient calculation, this mimicks the identity function."""
+    try:
+        return Floor.apply(x)
+    except TypeError:
+        return torch.as_tensor(np.floor(x))
+
+
+def round(x: torch.Tensor) -> torch.Tensor:
+    """Differentiable version of torch.round.
+    For gradient calculation, this mimicks the identity function."""
+    try:
+        return Round.apply(x)
+    except TypeError:
+        return torch.as_tensor(np.round(x))

{pulseqzero-0.1.2 → pulseqzero-0.1.4/src/pulseqzero.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulseqzero
-Version: 0.1.2
+Version: 0.1.4
 Summary: Use PyPulseq for MRI sequence definitions in MR-zero
 Author-email: Jonathan Endres <jonathan.endres@uk-erlangen.de>
 Project-URL: Repository, https://github.com/pulseq-frame/pulseq-zero
@@ -54,7 +54,7 @@ It relies on the following amazing projects:
 
 ## 2. Usage
 
-Example scripts are provided in [pulseqzero/seq_examples](pulseqzero/seq_examples).
+Example scripts are provided in the [tests](tests) folder.
 They are modified versions of the PyPulseq 1.4.2 examples found [here](https://github.com/imr-framework/pypulseq/tree/v1.4.2/pypulseq/seq_examples/scripts).
 The changes that are typically necessary to convert from a pypulseq sequence script to Pulseq-zero are as follows:
 
@@ -166,6 +166,49 @@ If you want to contribute to Pulseq-zero or make local changes to it, the easies
 
 ## 4. API
 
+### Additional API
+
+Pulseq requires many events to align with the block-, gradient- or ADC raster.
+For this, rounding is necessary, which is not differentiable.
+As a workaround, Pulseq-zero includes differentiable rounding functions, which are wrappers around the corresponding PyTorch functions, but which behave like the identity function for backpropagation.
+This means they are invisible to the calculation of gradients, which is okay as long as the rounding is small compared to the changes to the optimized parameters, which is typically the case with small raster times.
+
+```python
+my_param = torch.tensor(1.5, requires_grad=True)
+some_calc = pp.round(torch.sin(my_param))
+some_calc.backward()
+
+assert some_calc == 1
+assert my_param.grad == torch.cos(my_param)
+```
+Use pulseq-zeros rounding functions instead of e.g. those of numpy or torch if it is applied to timings (or other sequence properties) that are part of an optimization.
+
+In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+```
+
+If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
+```python
+if pulseqzero.is_mr0_mode():
+  pass
+else:
+  seq.calculate_pns()
+```
+
+Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
+```python
+with pulseqzero.mr0_mode():
+  seq = build_my_seq()
+  # This function here
+  mr0_seq = seq.to_mr0()
+  # Now do some simulations with mr0_seq!
+```
+
+
+### PyPulseq API
+
 The following is a list of all functions and methods exposed in PyPulseq 1.4.2 when importing it directly.
 Pulseq-zero tries to provide all of those - it is currently not planned to cover other functions that are available internally in PyPulseq but not exposed this way.
 If you need one of them, file an issue or submit a pull request.
@@ -270,7 +313,7 @@ The reason for disabling is either that a differentiable re-implementation if ou
 | `make_label` | `None` |
 | `make_extended_trapezoid_area` | **error** |
 | `calc_rf_bandwidth` | returns zeroes as mr0 mode doesn't store pulse shapes |
-| `calc_rf_center` | returns zeroes as mr0 mode doesn't store pulse shapes |
+| `calc_rf_center` | returns (shape_dur / 2, 0) - mr0 mode ignores (assymetric) pulse shapes |
 | `points_to_waveform` | **error** |
 
 ### Altered behaviour
@@ -296,33 +339,6 @@ Pulses have no shape, `center_pos` will influence the returned `gzr` but nothing
 | `make_extended_trapezoid` | skipping some checks and ignoring `convert_to_arbitrary`; `area` is a computed property, no `first` or `last` |
 | `Sequence` | way less internal bookkeeping, most variables are missing, reports etc. are not calculated |
 
-### Additional API
-
-This API is where Pulseq-zero comes into play:
-
-In the `mr0_mode` context, all PyPulseq functions are swapped for Pulseq-zero implementations that track all calls so that the sequence can be converted to MR-zero later:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-```
-
-If you use some functions that are only available in PyPulseq but not Pulseq-zero (PNS computations or similar), you can check if `mr0_mode` is activated:
-```python
-if pulseqzero.is_mr0_mode():
-  pass
-else:
-  seq.calculate_pns()
-```
-
-Finally, the sequence object returned in `mr0_mode` has one method that is not available otherwise and forms the central point of Pulseq-zero:
-```python
-with pulseqzero.mr0_mode():
-  seq = build_my_seq()
-  # This function here
-  mr0_seq = seq.to_mr0()
-  # Now do some simulations with mr0_seq!
-```
-
 
 ## 5. References
 

{pulseqzero-0.1.2 → pulseqzero-0.1.4}/src/pulseqzero.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/pulseqzero/__init__.py
+src/pulseqzero/math.py
 src/pulseqzero.egg-info/PKG-INFO
 src/pulseqzero.egg-info/SOURCES.txt
 src/pulseqzero.egg-info/dependency_links.txt