mrzerocore 0.2.12__cp37-abi3-win_amd64.whl → 0.3.1__cp37-abi3-win_amd64.whl

MRzeroCore/__init__.py

@@ -1,3 +1,11 @@
+import numpy
+if not hasattr(numpy, "int"):
+    numpy.int = int
+if not hasattr(numpy, "float"):
+    numpy.float = float
+if not hasattr(numpy, "complex"):
+    numpy.complex = complex
+
 from .sequence import PulseUsage, Pulse, Repetition, Sequence, chain
 from .phantom.voxel_grid_phantom import VoxelGridPhantom
 from .phantom.custom_voxel_phantom import CustomVoxelPhantom
@@ -9,8 +17,3 @@ from .simulation.main_pass import execute_graph
 from .reconstruction import reco_adjoint
 from .pulseq.exporter import pulseq_write_cartesian
 from . import util
-
-# Currently not exposed directly as it is not required by typical use cases
-# and also not documented. Used internally by Sequence.from_seq_file.
-# Might re-expose later as it contains sequence plotting functionality
-# from .pulseq.pulseq_loader import PulseqFile

MRzeroCore/phantom/brainweb/__init__.py

@@ -85,13 +85,13 @@ def generate_brainweb_phantoms(
     Raw tissue segmentation data is provided by the BrainWeb Database:
     http://www.bic.mni.mcgill.ca/brainweb/
 
-    All tissue data etc. are stored in `brainweb_data.json`. To ensure
-    consistent configurations and reproducible results, available configs are
-    stored in this file as well. They specify which field strength to use,
-    which tissues to include, as well as the downsampling and noise levels.
+    All tissue data etc. are stored in [brainweb_data.json](https://github.com/MRsources/MRzero-Core/blob/main/python/MRzeroCore/phantom/brainweb/brainweb_data.json).
+    To ensure consistent configurations and reproducible results, available
+    configs are stored in this file as well. They specify which field strength
+    to use, which tissues to include, and the downsampling and noise levels.
 
     The emitted files are compressed numpy files, which can be loaded with
-    `np.load(file_name)`. They contain the following arrays:
+    ``np.load(file_name)``. They contain the following arrays:
 
      - `PD_map`: Proton Density [a.u.]
      - `T1_map`: T1 relaxation time [s]

MRzeroCore/phantom/custom_voxel_phantom.py

@@ -52,7 +52,7 @@ class CustomVoxelPhantom:
     Attributes
     ----------
     voxel_pos : torch.Tensor
-        (voxel_count, 3) tensor containing the position of all voxels
+        (voxel_count, 3) tensor of voxel positions in SI units [m]
     PD : torch.Tensor
         1D tensor containing the Proton Density of all voxels
     T1 : torch.Tensor
@@ -128,6 +128,7 @@ class CustomVoxelPhantom:
         """Build a :class:`SimData` instance for simulation."""
         # TODO: until the dephasing func fix is here, this only works on the
         # device self.voxel_size happens to be on
+        size = self.voxel_pos.max(0).values - self.voxel_pos.min(0).values
 
         return SimData(
             self.PD,
@@ -138,7 +139,7 @@ class CustomVoxelPhantom:
             self.B0,
             self.B1[None, :],
             torch.ones(1, self.PD.numel()),
-            torch.tensor([0.2, 0.2, 0.2]),  # FOV for diffusion
+            size,
             self.voxel_pos,
             torch.tensor([float('inf'), float('inf'), float('inf')]),
             build_dephasing_func(self.voxel_shape, self.voxel_size),
@@ -212,7 +213,7 @@ class CustomVoxelPhantom:
         D = torch.fft.fftshift(torch.fft.ifft2(D_kspace))
 
         maps = [PD, T1, T2, T2dash, D]
-        titles = ["$PD$", "$T_1$", "$T_2$", "$T_2#$", "$D$"]
+        titles = ["PD", "T1", "T2", "T2'", "D"]
 
         print("CustomVoxelPhantom")
         print(f"Voxel shape: {self.voxel_shape}")

MRzeroCore/phantom/sim_data.py

@@ -65,6 +65,8 @@ class SimData:
         nyquist: torch.Tensor,
         dephasing_func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
         recover_func: Callable[[SimData], Any] | None = None,
+        phantom_motion=None,
+        voxel_motion=None
     ) -> None:
         """Create a :class:`SimData` instance based on the given tensors.
 
@@ -100,6 +102,9 @@ class SimData:
         self.dephasing_func = dephasing_func
         self.recover_func = recover_func
 
+        self.phantom_motion = phantom_motion
+        self.voxel_motion = voxel_motion
+
     def cuda(self) -> SimData:
         """Move the simulation data to the default CUDA device.
 
@@ -119,7 +124,9 @@ class SimData:
             self.voxel_pos.cuda(),
             self.nyquist.cuda(),
             self.dephasing_func,
-            self.recover_func
+            self.recover_func,
+            self.phantom_motion,
+            self.voxel_motion
         )
 
     def cpu(self) -> SimData:
@@ -141,7 +148,9 @@ class SimData:
             self.voxel_pos.cpu(),
             self.nyquist.cpu(),
             self.dephasing_func,
-            self.recover_func
+            self.recover_func,
+            self.phantom_motion,
+            self.voxel_motion
         )
 
     @property

MRzeroCore/phantom/voxel_grid_phantom.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 from typing import Literal
+from warnings import warn
 from scipy import io
 import numpy as np
 import torch
 import matplotlib.pyplot as plt
 from .sim_data import SimData
+from ..util import imshow
 
 
 def sigmoid(trajectory: torch.Tensor, nyquist: torch.Tensor) -> torch.Tensor:
@@ -36,6 +38,25 @@ def identity(trajectory: torch.Tensor) -> torch.Tensor:
     return torch.ones_like(trajectory[:, 0])
 
 
+def generate_B0_B1(PD):
+    # Generate a somewhat plausible B0 and B1 map.
+    # Visually fitted to look similar to the numerical_brain_cropped
+    x_pos, y_pos, z_pos = torch.meshgrid(
+        torch.linspace(-1, 1, PD.shape[0]),
+        torch.linspace(-1, 1, PD.shape[1]),
+        torch.linspace(-1, 1, PD.shape[2]),
+        indexing="ij"
+    )
+    B1 = torch.exp(-(0.4*x_pos**2 + 0.2*y_pos**2 + 0.3*z_pos**2))
+    dist2 = (0.4*x_pos**2 + 0.2*(y_pos - 0.7)**2 + 0.3*z_pos**2)
+    B0 = 7 / (0.05 + dist2) - 45 / (0.3 + dist2)
+    # Normalize such that the weighted average is 0 or 1
+    weight = PD / PD.sum()
+    B0 -= (B0 * weight).sum()
+    B1 /= (B1 * weight).sum()
+    return B0, B1
+
+
 class VoxelGridPhantom:
     """Class for using typical phantoms like those provided by BrainWeb.
 
@@ -82,15 +103,15 @@ class VoxelGridPhantom:
         This function does no cloning nor contain any other funcionality. You
         probably want to use :meth:`brainweb` to load a phantom instead.
         """
-        self.PD = PD
-        self.T1 = T1
-        self.T2 = T2
-        self.T2dash = T2dash
-        self.D = D
-        self.B0 = B0
-        self.B1 = B1
-        self.coil_sens = coil_sens
-        self.size = size
+        self.PD = torch.as_tensor(PD, dtype=torch.float32)
+        self.T1 = torch.as_tensor(T1, dtype=torch.float32)
+        self.T2 = torch.as_tensor(T2, dtype=torch.float32)
+        self.T2dash = torch.as_tensor(T2dash, dtype=torch.float32)
+        self.D = torch.as_tensor(D, dtype=torch.float32)
+        self.B0 = torch.as_tensor(B0, dtype=torch.float32)
+        self.B1 = torch.as_tensor(B1, dtype=torch.float32)
+        self.coil_sens = torch.as_tensor(coil_sens, dtype=torch.float32)
+        self.size = torch.as_tensor(size, dtype=torch.float32)
 
     def build(self, PD_threshold: float = 1e-6,
               voxel_shape: Literal["sinc", "box", "point"] = "sinc"
@@ -115,6 +136,7 @@ class VoxelGridPhantom:
             self.size[2] *
             torch.fft.fftshift(torch.fft.fftfreq(
                 int(shape[2]), device=self.PD.device)),
+            indexing="ij"
         )
 
         voxel_pos = torch.stack([
@@ -143,13 +165,18 @@ class VoxelGridPhantom:
             self.coil_sens[:, mask],
             self.size,
             voxel_pos,
-            torch.tensor(shape, device=self.PD.device) / 2 / self.size,
+            torch.as_tensor(shape, device=self.PD.device) / 2 / self.size,
             dephasing_func,
             recover_func=lambda data: recover(mask, data)
         )
-
+    
     @classmethod
     def brainweb(cls, file_name: str) -> VoxelGridPhantom:
+        warn("brainweb() will be removed in a future version, use load() instead", DeprecationWarning)
+        return cls.load(file_name)
+
+    @classmethod
+    def load(cls, file_name: str) -> VoxelGridPhantom:
         """Load a phantom from data produced by `generate_maps.py`."""
         with np.load(file_name) as data:
             T1 = torch.tensor(data['T1_map'])
@@ -158,28 +185,21 @@ class VoxelGridPhantom:
             PD = torch.tensor(data['PD_map'])
             D = torch.tensor(data['D_map'])
             try:
-                size = torch.tensor(data['FOV'])
+                B0 = torch.tensor(data['B0_map'])
+                B1 = torch.tensor(data['B1_map'])
+            except KeyError:
+                B0, B1 = generate_B0_B1(PD)
+            try:
+                size = torch.tensor(data['FOV'], dtype=torch.float)
             except KeyError:
                 size = torch.tensor([0.192, 0.192, 0.192])
-
-        # Generate a somewhat plausible B0 and B1 map.
-        # Visually fitted to look similar to the numerical_brain_cropped
-        x_pos, y_pos, z_pos = torch.meshgrid(
-            torch.linspace(-1, 1, PD.shape[0]),
-            torch.linspace(-1, 1, PD.shape[1]),
-            torch.linspace(-1, 1, PD.shape[2]),
-            indexing="ij"
-        )
-        B1 = torch.exp(-(0.4*x_pos**2 + 0.2*y_pos**2 + 0.3*z_pos**2))
-        dist2 = (0.4*x_pos**2 + 0.2*(y_pos - 0.7)**2 + 0.3*z_pos**2)
-        B0 = 7 / (0.05 + dist2) - 45 / (0.3 + dist2)
-        # Normalize such that the weighted average is 0 or 1
-        weight = PD / PD.sum()
-        B0 -= (B0 * weight).sum()
-        B1 /= (B1 * weight).sum()
+        
+        if B1.ndim == 3:
+            # Add coil-dimension
+            B1 = B1[None, ...]
 
         return cls(
-            PD, T1, T2, T2dash, D, B0, B1[None, ...],
+            PD, T1, T2, T2dash, D, B0, B1,
             torch.ones(1, *PD.shape), size,
         )
 
@@ -189,6 +209,7 @@ class VoxelGridPhantom:
         file_name: str,
         T2dash: float | torch.Tensor = 0.03,
         D: float | torch.Tensor = 1.0,
+        size = [0.2, 0.2, 8e-3]
     ) -> VoxelGridPhantom:
         """Load a :class:`VoxelGridPhantom` from a .mat file.
 
@@ -225,15 +246,15 @@ class VoxelGridPhantom:
         """
         data = _load_tensor_from_mat(file_name)
 
-        # TODO: Better handling of data not included in .mat
         if data.ndim < 2 or data.shape[-1] != 5:
             raise Exception(
                 f"Expected a tensor with shape [..., 5], "
                 f"but got {list(data.shape)}"
             )
 
-        # TODO: Assumes 2D data, expands it to 3D
-        data = data.unsqueeze(2)
+        if data.ndim == 3:
+            # Expand to 3D: [x, y, i] -> [x, y, z, i]
+            data = data.unsqueeze(2)
 
         if isinstance(T2dash, float):
             T2dash = torch.full_like(data[..., 0], T2dash)
@@ -249,7 +270,7 @@ class VoxelGridPhantom:
             data[..., 3],  # B0
             data[..., 4][None, ...],  # B1
             coil_sens=torch.ones(1, *data.shape[:-1]),
-            size=torch.tensor([0.2, 0.2, 0.008]),
+            size=torch.as_tensor(size),
         )
 
     def slices(self, slices: list[int]) -> VoxelGridPhantom:
@@ -387,35 +408,36 @@ class VoxelGridPhantom:
         plt.figure(figsize=(12, 10))
         plt.subplot(331)
         plt.title("PD")
-        plt.imshow(self.PD[:, :, s].T.cpu(), vmin=0, origin="lower")
+
+        imshow(self.PD, vmin=0)
         plt.colorbar()
         plt.subplot(332)
         plt.title("T1")
-        plt.imshow(self.T1[:, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.T1, vmin=0)
         plt.colorbar()
         plt.subplot(333)
         plt.title("T2")
-        plt.imshow(self.T2[:, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.T2, vmin=0)
         plt.colorbar()
         plt.subplot(334)
         plt.title("T2'")
-        plt.imshow(self.T2dash[:, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.T2dash, vmin=0)
         plt.colorbar()
         plt.subplot(335)
         plt.title("D")
-        plt.imshow(self.D[:, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.D, vmin=0)
         plt.colorbar()
         plt.subplot(337)
         plt.title("B0")
-        plt.imshow(self.B0[:, :, s].T.cpu(), origin="lower")
+        imshow(self.B0)
         plt.colorbar()
         plt.subplot(338)
         plt.title("B1")
-        plt.imshow(self.B1[0, :, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.B1[0, ...])
         plt.colorbar()
         plt.subplot(339)
         plt.title("coil sens")
-        plt.imshow(self.coil_sens[0, :, :, s].T.cpu(), vmin=0, origin="lower")
+        imshow(self.coil_sens[0, ...], vmin=0)
         plt.colorbar()
         plt.show()
 

MRzeroCore/sequence.py

@@ -390,7 +390,7 @@ class Sequence(list):
         >>> contrast_reco = reco(signal[mask], kspace[mask])
         """
         return torch.cat(
-            [rep.adc_usage[rep.adc_usage != 0] == contrast for rep in self]
+            [rep.adc_usage[rep.adc_usage > 0] == contrast for rep in self]
         )
 
     def get_contrasts(self) -> list[int]:

MRzeroCore/simulation/isochromat_sim.py

@@ -16,6 +16,7 @@ Note that this still uses box shaped voxels, which is generally discouraged.
 """
 
 from __future__ import annotations
+from typing import Literal
 import torch
 from numpy import pi
 
@@ -26,9 +27,14 @@ from ..phantom.sim_data import SimData
 def isochromat_sim(seq: Sequence, data: SimData, spin_count: int,
                    perfect_spoiling=False,
                    print_progress: bool = True,
+                   spin_dist: Literal["r2", "rand"] = "rand",
+                   r2_seed = None
                    ) -> torch.Tensor:
-    """
-    Simulate ``seq`` on ``data`` with ``spin_count`` spins per voxel.
+    """Simulate ``seq`` on ``data`` with ``spin_count`` spins per voxel.
+
+    The intra-voxel spin distribution is randomized, except if
+    `spin_dist = "r2"` and a fixed `r2_seed` are chosen. For a deterministic
+    distribution of spins, call `torch.manual_seed()` before this function.
 
     Parameters
     ----------
@@ -40,7 +46,16 @@ def isochromat_sim(seq: Sequence, data: SimData, spin_count: int,
         Number of spins used for simulation
     perfect_spoiling: bool
         If ``True``, the transversal magnetization is set to zero on excitation
-
+    print_progress: bool
+        If ``True``, the currently simulated repetition is printed
+    spin_dist: "r2" | "rand"
+        Use either a golden-ratio pseudo-random blue-noise like or
+        a white-noise like intra-voxel distribution of spins
+    r2_seed: None | torch.Tensor
+        The seed and position of the first spin for the blue-noise like spin
+        distribution. If ``None``, a random position is chosen. Expects a
+        tensor with 3 floats in the range of ``[0, 1]``
+        
     Returns
     -------
     torch.Tensor
@@ -54,16 +69,25 @@ def isochromat_sim(seq: Sequence, data: SimData, spin_count: int,
         # Fallback voxel size
         voxel_size = torch.tensor([0.1, 0.1, 0.1], device=data.device)
 
-    # 3 dimensional R2 sequence for intravoxel spin distribution
-    g = 1.22074408460575947536  # 3D
-    # g = 1.32471795724474602596  # 2D
-    a = 1.0 / torch.tensor([g**1, g**2, g**3], device=data.device)
-    indices = torch.arange(spin_count, device=data.device)
-    spin_pos = torch.stack([
-        (0.5 + a[0] * indices) % 1,
-        (0.5 + a[1] * indices) % 1,
-        (0.5 + a[2] * indices) % 1
-    ])
+    if spin_dist == "rand":
+        spin_pos = torch.rand(spin_count, 3)
+    elif spin_dist == "r2":
+        if r2_seed is None:
+            r2_seed = torch.rand(3)
+
+        # 3 dimensional R2 sequence for intravoxel spin distribution
+        g = 1.22074408460575947536  # 3D
+        # g = 1.32471795724474602596  # 2D
+        a = 1.0 / torch.tensor([g**1, g**2, g**3], device=data.device)
+        indices = torch.arange(spin_count, device=data.device)
+        spin_pos = torch.stack([
+            (r2_seed[0] + a[0] * indices) % 1,
+            (r2_seed[1] + a[1] * indices) % 1,
+            (r2_seed[2] + a[2] * indices) % 1
+        ])
+    else:
+        raise ValueError("unexpected spin_dist", spin_dist)
+
     # spin_pos = torch.rand_like(spin_pos)  # Use white noise
     spin_pos = 2 * pi * (spin_pos - 0.5) * voxel_size.unsqueeze(1)
 

MRzeroCore/simulation/main_pass.py

@@ -12,12 +12,25 @@ import numpy as np
 # has can extract all information it wants during simulation.
 
 
+def rigid_motion(voxel_pos, motion_func):
+    """Shape of returned tensor: events x voxels x 3"""
+    def voxel_motion(time):
+        # rot: events x 3 x 3, offset: events x 3
+        rot, offset = motion_func(time)
+        rot = rot.to(device=voxel_pos.device)
+        offset = offset.to(device=voxel_pos.device)
+        return torch.einsum("vi, eij -> evj", voxel_pos, rot) + offset[:, None, :]
+    
+    return voxel_motion
+
+
 def execute_graph(graph: Graph,
                   seq: Sequence,
                   data: SimData,
                   min_emitted_signal: float = 1e-2,
                   min_latent_signal: float = 1e-2,
                   print_progress: bool = True,
+                  return_mag_p: int | bool | None = None,
                   return_mag_z: int | bool | None = None,
                   ) -> torch.Tensor | list:
     """Calculate the signal of the sequence by executing the phase graph.
@@ -50,6 +63,14 @@ def execute_graph(graph: Graph,
         The longitudinal magnetisation of the specified or all repetition(s).
 
     """
+    # This is a function that maps time to voxel positions.
+    # If it is defined, motion is simulated, otherwise the static data.voxel_pos is used
+    t0 = 0
+    voxel_pos_func = data.voxel_motion
+    if voxel_pos_func is None and data.phantom_motion is not None:
+        voxel_pos_func = rigid_motion(data.voxel_pos, data.phantom_motion)
+
+
     if seq.normalized_grads:
         grad_scale = 1 / data.size
     else:
@@ -71,6 +92,7 @@ def execute_graph(graph: Graph,
     # Calculate kt_vec ourselves for autograd
     graph[0][0].kt_vec = torch.zeros(4, device=data.device)
 
+    mag_p = []
     mag_z = []
     for i, (dists, rep) in enumerate(zip(graph[1:], seq)):
         if print_progress:
@@ -85,7 +107,7 @@ def execute_graph(graph: Graph,
             B1 = data.B1.sum(0)
         else:
             assert shim_array.shape[0] == data.B1.shape[0]
-            shim = shim_array[:, 0] * torch.exp(1j * shim_array[:, 1])
+            shim = shim_array[:, 0] * torch.exp(-1j * shim_array[:, 1])
             B1 = (data.B1 * shim[:, None]).sum(0)
 
         angle = angle * B1.abs()
@@ -118,7 +140,8 @@ def execute_graph(graph: Graph,
                 raise ValueError(f"Unknown transform {ancestor[0]}")
 
         # shape: events x coils
-        rep_sig = torch.zeros(rep.event_count, coil_count,
+        adc = rep.adc_usage > 0
+        rep_sig = torch.zeros(adc.sum(), coil_count,
                               dtype=torch.cfloat, device=data.device)
 
         # shape: events x 4
@@ -134,6 +157,18 @@ def execute_graph(graph: Graph,
         # Use the same adc phase for all coils
         adc_rot = torch.exp(1j * rep.adc_phase).unsqueeze(1)
 
+        # Calculate the additional phase carried of voxels because of motion
+        motion_phase = 0
+        if voxel_pos_func is not None:
+            time = t0 + torch.cat([torch.zeros(1, device=data.device), trajectory[:, 3]])
+            # Shape: events x voxels x 3
+            voxel_traj = voxel_pos_func((time[:-1] + time[1:]) / 2) - data.voxel_pos[None, :, :]
+            # Shape: events x voxels
+            motion_phase = torch.einsum("evi, ei -> ev", voxel_traj, rep.gradm * grad_scale[None, :]).cumsum(0)
+        t0 += total_time
+
+        mag_p_rep = []
+        mag_p.append(mag_p_rep)
         mag_z_rep = []
         mag_z.append(mag_z_rep)
         for dist in dists:
@@ -148,6 +183,8 @@ def execute_graph(graph: Graph,
                 continue  # skip dists for which no ancestors were simulated
 
             dist.mag = sum([calc_mag(ancestor) for ancestor in ancestors])
+            if dist.dist_type == '+' and return_mag_p in [i, True]:
+                mag_p_rep.append(dist.mag)
             if dist.dist_type in ['z0', 'z'] and return_mag_z in [i, True]:
                 mag_z_rep.append(dist.mag)
 
@@ -169,7 +206,9 @@ def execute_graph(graph: Graph,
             k1[0, :] = dist.kt_vec[:3]
             k1[1:, :] = k2[:-1, :]
             # Integrate over each event to get b factor (lin. interp. grad)
-            b = 1/3 * dt * (k1**2 + k1*k2 + k2**2).sum(1)
+            # Gradients are in rotations / meter, but we need rad / meter,
+            # as integrating over exp(-ikr) assumes that kr is a phase in rad
+            b = 1/3 * (2 * torch.pi)**2 * dt * (k1**2 + k1*k2 + k2**2).sum(1)
             # shape: events x voxels
             diffusion = torch.exp(-1e-9 * data.D * torch.cumsum(b, 0)[:, None])
 
@@ -186,21 +225,27 @@ def execute_graph(graph: Graph,
             # just by switching 2pi * (pos @ grad) to 2pi * pos @ grad
 
             if dist.dist_type == '+' and dist.emitted_signal >= min_emitted_signal:
-                T2 = torch.exp(-trajectory[:, 3:] / torch.abs(data.T2))
-                T2dash = torch.exp(-torch.abs(dist_traj[:, 3:]
-                                              ) / torch.abs(data.T2dash))
+                adc_dist_traj = dist_traj[adc, :]
+                if isinstance(motion_phase, torch.Tensor):
+                    adc_motion_phase = motion_phase[adc, :]
+                else:
+                    adc_motion_phase = motion_phase
+
+                T2 = torch.exp(-trajectory[adc, 3:] / torch.abs(data.T2))
+                T2dash = torch.exp(-torch.abs(adc_dist_traj[:, 3:]) / torch.abs(data.T2dash))
                 rot = torch.exp(2j * np.pi * (
-                    (dist_traj[:, 3:] * data.B0) +
-                    (dist_traj[:, :3] @ data.voxel_pos.T)
+                    (adc_dist_traj[:, 3:] * data.B0) +
+                    (adc_dist_traj[:, :3] @ data.voxel_pos.T) +
+                    adc_motion_phase
                 ))
                 dephasing = data.dephasing_func(
-                    dist_traj[:, :3], data.nyquist)[:, None]
+                    adc_dist_traj[:, :3], data.nyquist)[:, None]
 
                 # shape: events x voxels
                 transverse_mag = (
                     # Add event dimension
                     1.41421356237 * dist.mag.unsqueeze(0)
-                    * rot * T2 * T2dash * diffusion * dephasing
+                    * rot * T2 * T2dash * diffusion[adc, :] * dephasing
                 )
 
                 # (events x voxels) @ (voxels x coils) = (events x coils)
@@ -208,8 +253,10 @@ def execute_graph(graph: Graph,
                 rep_sig += dist_signal
 
             if dist.dist_type == '+':
-                # Diffusion for whole trajectory + T2 relaxation
-                dist.mag = dist.mag * r2 * diffusion[-1, :]
+                # Diffusion for whole trajectory + T2 relaxation + final phase carried by motion
+                dist.mag = dist.mag * r2 * diffusion[-1, :] 
+                if isinstance(motion_phase, torch.Tensor):
+                    dist.mag = dist.mag * torch.exp(2j * np.pi * motion_phase[-1, :])
                 dist.kt_vec = dist_traj[-1]
             else:  # z or z0
                 k = torch.linalg.vector_norm(dist.kt_vec[:3])
@@ -218,7 +265,7 @@ def execute_graph(graph: Graph,
             if dist.dist_type == 'z0':
                 dist.mag = dist.mag + 1 - r1
 
-        rep_sig *= adc_rot
+        rep_sig *= adc_rot[adc]
 
         # Remove ancestors to save memory as we don't need them anymore.
         # When running with autograd this doesn't change memory consumption
@@ -232,11 +279,14 @@ def execute_graph(graph: Graph,
     if print_progress:
         print(" - done")
 
-    # Only return measured samples
-    measured = torch.cat([
-        sig[rep.adc_usage > 0, :] for sig, rep in zip(signal, seq)
-    ])
-    if return_mag_z is not None:
+    measured = torch.cat(signal)
+
+    if return_mag_p is not None:
+        if return_mag_z is not None:
+            return measured, mag_p, mag_z
+        else:
+            return measured, mag_p
+    elif return_mag_z is not None:
         return measured, mag_z
     else:
         return measured

MRzeroCore/simulation/pre_pass.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from warnings import warn
 import torch
 import numpy as np
 import matplotlib.pyplot as plt
@@ -76,6 +77,9 @@ def compute_graph_ext(
             torch.cos(angle),
             torch.sin(angle/2)**2
         ], dim=1).type(torch.float32)
+    
+    if any(rep.pulse.angle > 2*np.pi for rep in seq):
+        warn("Some flip angles are > 360°, inhomogeneities produced by extra rotations are ignored by the pre-pass B1 estimation")
 
     return Graph(_prepass.compute_graph(
         seq,
@@ -107,7 +111,8 @@ class Graph(list):
             y-position of a state in the scatter plot
         color : str
             Use one of ``['abs(mag)', 'phase(mag)', 'latent signal', 'signal',
-            'emitted signal']`` as color of a state in the scatter plot
+            'latent signal unormalized', 'emitted signal']``
+            as the color of a state in the scatter plot
         log_color : bool
             If true, use the logarithm of the chosen property for coloring
         """
@@ -123,8 +128,12 @@ class Graph(list):
                 value = state.latent_signal
             elif color == "signal":
                 value = state.signal
+            elif color == "latent signal unormalized":
+                value = state.latent_signal_unormalized
             elif color == "emitted signal":
                 value = state.emitted_signal
+            else:
+                raise AttributeError(f"Unknown property color={color}")
             if log_color:
                 value = np.log10(np.abs(value) + 1e-7)
             return value

MRzeroCore/util.py

@@ -1,6 +1,6 @@
 import os
 import time
-from typing import Literal
+from typing import Literal, Union
 import torch
 import numpy as np
 
@@ -192,8 +192,7 @@ def pulseq_plot(seq: pp.Sequence,
         if is_valid:
             if getattr(block, 'adc', None) is not None:
                 adc = block.adc
-                t = adc.delay + [(x * adc.dwell)
-                                 for x in range(0, int(adc.num_samples))]
+                t = [(adc.delay + x * adc.dwell) for x in range(0, int(adc.num_samples))]
                 sp11.plot((t0 + t), np.zeros(len(t)), 'rx')
 # >>>> Changed: store adc samples <<<<
                 t_adc = np.append(t_adc, t0 + t)
@@ -314,3 +313,32 @@ def pulseq_plot(seq: pp.Sequence,
 
 # New: return plot axes and adc time points
     return sp11, t_adc
+
+
+def imshow(data: Union[np.ndarray, torch.Tensor], *args, **kwargs):
+    """Alternative to matplotlib's `imshow`.
+    
+    This function applies quadratic coil combine on 4D data and prints 3D
+    data as a grid of slices. Also prints x-axis horizontal and y vertiacl.
+    
+    Assumes data to be indexed [c, x, y, z]"""
+    data = torch.as_tensor(data).detach().cpu()
+    assert 2 <= data.ndim <= 4
+
+    # Coil combine 4D data
+    if data.ndim == 4:
+        data = (data.abs()**2).sum(0)**0.5
+    
+    # Shape 3D data into grid
+    if data.ndim == 3:
+        rows = int(np.floor(data.shape[2]**0.5))
+        cols = int(np.ceil(data.shape[2] / rows))
+        
+        tmp = data
+        data = torch.zeros((tmp.shape[0] * cols, tmp.shape[1] * rows), dtype=tmp.dtype)
+        for i in range(tmp.shape[2]):
+            x = (i % cols)*tmp.shape[0]
+            y = ((rows * cols - i - 1) // cols)*tmp.shape[1]
+            data[x:x+tmp.shape[0], y:y+tmp.shape[1]] = tmp[:, :, i]
+
+    plt.imshow(data.T, *args, origin="lower", **kwargs)

{MRzeroCore-0.2.12.dist-info → MRzeroCore-0.3.1.dist-info}/METADATA

@@ -1,18 +1,18 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: MRzeroCore
-Version: 0.2.12
+Version: 0.3.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3
-Requires-Dist: torch>=1.12
+Requires-Dist: torch >=1.12
 Requires-Dist: pypulseq
-Requires-Dist: matplotlib>=3.5
-Requires-Dist: scipy>=1.7
-Requires-Dist: requests>=2.20
+Requires-Dist: matplotlib >=3.5
+Requires-Dist: scipy >=1.7
+Requires-Dist: requests >=2.20
 Requires-Dist: scikit-image
 Requires-Dist: torchkbnufft
-Requires-Dist: pydisseqt>=0.1.4
+Requires-Dist: pydisseqt >=0.1.4
 License-File: LICENSE
 Summary: Core functionality of MRzero
 Author-email: Jonathan Endres <jonathan.endres@uk-erlangen.de>

{MRzeroCore-0.2.12.dist-info → MRzeroCore-0.3.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
-MRzeroCore-0.2.12.dist-info/METADATA,sha256=Bbz05wbitS0vBO9HNYxnuOVtFPfzqjx4Z_bEvGeLCy0,3801
-MRzeroCore-0.2.12.dist-info/WHEEL,sha256=ZnSmVnashXVUiLCKmp20reANrPJdUjOt4GHgJoJkZ3E,96
-MRzeroCore-0.2.12.dist-info/license_files/LICENSE,sha256=rd_IFJ484uAluv8CigP2CpXg4l2GJLLKENqB6-RXPp4,35112
+MRzeroCore-0.3.1.dist-info/METADATA,sha256=VkmVanzGblXg8alZCu4Cb7EowUR2g2VdeDY2jDc5l0c,3805
+MRzeroCore-0.3.1.dist-info/WHEEL,sha256=p0nSOBx01acCQRB4KO5wmZww0xaSuuHl1nwKWZurtTU,94
+MRzeroCore-0.3.1.dist-info/license_files/LICENSE,sha256=rd_IFJ484uAluv8CigP2CpXg4l2GJLLKENqB6-RXPp4,35112
 MRzeroCore/phantom/brainweb/brainweb_data.json,sha256=El9J5dfEIwGi4_SoRif6ic6IVSMKh01jK0hNRbBYNqA,1794
 MRzeroCore/phantom/brainweb/brainweb_data_sources.txt,sha256=Sh6NFLU1bhdaD0pp12D_Hc70cA_UC1s7KdHcuoGTKuA,1853
 MRzeroCore/phantom/brainweb/output/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-MRzeroCore/phantom/brainweb/__init__.py,sha256=f0mGtGMO0oi4d-HyRlvE042UgLD-jgsVKLF-7h9JD1g,6841
-MRzeroCore/phantom/custom_voxel_phantom.py,sha256=Pt5X1KjOgzNo6ebINyl4oT8drFTWp4NU3Mi3e5a0YVM,10413
-MRzeroCore/phantom/sim_data.py,sha256=rL0eRk_CuvzxIHrjcjHA2nexYEBieu70B2nS6VlhcxQ,7118
-MRzeroCore/phantom/voxel_grid_phantom.py,sha256=h1UAsOzQRQPBuC6m_qpIj2eTYtjBl2Ogz_Kkt4ZQH3E,16627
+MRzeroCore/phantom/brainweb/__init__.py,sha256=jrM_YqK5twOLMDLIYRtCMywmmQdyPyY5qmKb49QS5-Y,6942
+MRzeroCore/phantom/custom_voxel_phantom.py,sha256=oWWt-YXHmhG-wW3DxcrErWRA2szrjWpRaHRFl5Wi9RA,10427
+MRzeroCore/phantom/sim_data.py,sha256=IOq_3vaPfzwAxSLvfu6mIJGxphLiFHTQ8kpGUeKrsRc,7397
+MRzeroCore/phantom/voxel_grid_phantom.py,sha256=-JjxTMqrUDHBI4va_oV36pFUFqjFq9tIH7TvsfsovqY,17269
 MRzeroCore/pulseq/exporter.py,sha256=RlIHkXNVmQy-ywixIPeWeICnb9jq4_1_9O8HujBigLs,17226
 MRzeroCore/pulseq/exporter_v2.py,sha256=GVnhC6bmbxbYq4CFrBbL2nj98B_u3OVglOt50J19pkk,30554
 MRzeroCore/pulseq/helpers.py,sha256=ZEtctXy7qm6BLexcwNRDd8xPSBFNiy5dUeifOo5bYkw,8774
@@ -26,11 +26,11 @@ MRzeroCore/pulseq/pulseq_loader/pulseq_file/__init__.py,sha256=VzN3j7pirpI8zJdfv
 MRzeroCore/pulseq/pulseq_loader/spoiler.py,sha256=R6Hjfno3U-fuICjLUUxmDk_7-Z1HjZYmE55mXTWTIAI,1007
 MRzeroCore/pulseq/pulseq_loader/__init__.py,sha256=6OLwC3k9LSjl8aRin9pV4-Rb-Q3YSbToayyeKbXnUdQ,2812
 MRzeroCore/reconstruction.py,sha256=LGk5EdgQ4AkhWN-7Q81YMkIEEW0T9Q37O2Pat0d-d4o,4277
-MRzeroCore/sequence.py,sha256=wqRwpUIKdX9mgmctmIL2Ttr3eZPJ_H1ACLamkzPp7sY,27647
-MRzeroCore/simulation/isochromat_sim.py,sha256=u6KbN7S8REOHiKqzDGMma7937cKX4bnmj3gXoAiNLi0,9185
-MRzeroCore/simulation/main_pass.py,sha256=DNXEJmN7AEWuqNbMma6AWqJpHH4ihhC3YRJKRhoi4RU,9830
-MRzeroCore/simulation/pre_pass.py,sha256=5wmXKxgFeGwA7yrqTkOjcWoFuGuRYEPzedRGqkx2Evg,5117
-MRzeroCore/util.py,sha256=39TPselHu7f218BRdjHB4_kCSPnFuCC45YmdGotc4uA,11460
-MRzeroCore/__init__.py,sha256=8WViV9GQRwnksnopAAfKWRmtRYk75DC3ke4OQwLx-fU,850
-MRzeroCore/_prepass.pyd,sha256=2Qziu8nvKPnrrYfsWpSwTrGkHhbspMEcSgwiDWTXTow,402944
-MRzeroCore-0.2.12.dist-info/RECORD,,
+MRzeroCore/sequence.py,sha256=uQgNcOICtcdSWXhv9SqBWu-FdJaK6Q6UgkIBHfULsqI,27646
+MRzeroCore/simulation/isochromat_sim.py,sha256=jevQa38CZG_IodgU7LZMz4NKapm6iyENybaBr7dMl8w,10339
+MRzeroCore/simulation/main_pass.py,sha256=-uZCAhyHbGTPEJb6b-XAh75V7hYj6SzHMcYkWwWDGZ4,12140
+MRzeroCore/simulation/pre_pass.py,sha256=r_6XIWBEYW7YF2vM9LOR7Stu9nlcnT-CMM5tyjT7yOU,5589
+MRzeroCore/util.py,sha256=qYrw88OJQ_x0iA0rtqT1RHbDk_929YLRt4tdW3m7YIY,12494
+MRzeroCore/__init__.py,sha256=NYaEvn0xFI4EBX0PQrVnAB55VtocPcTkO0p1_P8foDI,770
+MRzeroCore/_prepass.pyd,sha256=j_RTkM-BO8PCGMKR-YaRRNl89VG_L1iAH5pbq2FegOA,412160
+MRzeroCore-0.3.1.dist-info/RECORD,,

{MRzeroCore-0.2.12.dist-info → MRzeroCore-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (0.14.17)
+Generator: maturin (1.7.0)
 Root-Is-Purelib: false
 Tag: cp37-abi3-win_amd64