mrzerocore 0.2.10__tar.gz → 0.2.12__tar.gz

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/CHANGELOG.md

@@ -1,3 +1,9 @@
+- 0.2.12
+  - Fixed Brainweb phantom loading and generation
+  - Switched pre-pass kt precision from f32 to f64
+  - Made pre-pass state merging relative to sequence gradient moment and event time sizes
+- 0.2.11
+  - (re-)introduced return_mag_z parameter in pdg simulation
 - 0.2.10
   - change default FOV in all notebooks to phantom size (200 mm)
   - Use Open in Colab badges in the playground instead of links

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/Cargo.lock

@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "mrzero_core"
-version = "0.2.10"
+version = "0.2.12"
 dependencies = [
  "num-complex",
  "pyo3",

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mrzero_core"
-version = "0.2.10"
+version = "0.2.12"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: MRzeroCore
-Version: 0.2.10
+Version: 0.2.12
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -18,9 +18,9 @@ Summary: Core functionality of MRzero
 Author-email: Jonathan Endres <jonathan.endres@uk-erlangen.de>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: MRzero-Paper, https://arxiv.org/abs/2002.04265
 Project-URL: Documentation, https://mrzero-core.readthedocs.io/
 Project-URL: Repository, https://github.com/MRsources/MRzero-Core
-Project-URL: MRzero-Paper, https://arxiv.org/abs/2002.04265
 
 [![Documentation Status](https://readthedocs.org/projects/mrzero-core/badge/?version=latest)](https://mrzero-core.readthedocs.io/en/latest/?badge=latest)
 

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/documentation/_toc.yml

@@ -42,5 +42,6 @@ chapters:
   - file: playground_mr0/mr00_FLASH_2D_ernstAngle_opt.ipynb
 
   - file: playground_mr0/flash
+  - file: playground_mr0/flash_DWI
   - file: playground_mr0/pulseq_flash
   - file: playground_mr0/pulseq_sim_pTx

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/python/MRzeroCore/phantom/brainweb/__init__.py

@@ -151,7 +151,7 @@ def generate_brainweb_phantoms(
             print("Adding tissue to phantom", end="", flush=True)
             maps["PD_map"] += tissue_data["PD"] * tissue_map * noise()
             maps["T1_map"] += tissue_data["T1"] * tissue_map * noise()
-            maps["T2_map"] += tissue_data["T2"] * noise()
+            maps["T2_map"] += tissue_data["T2"] * tissue_map * noise()
             maps["T2dash_map"] += tissue_data["T2'"] * tissue_map * noise()
             maps["D_map"] += tissue_data["D"] * tissue_map * noise()
             print(" - done")

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/python/MRzeroCore/phantom/brainweb/brainweb_data.json

@@ -33,7 +33,7 @@
       "gm": {
         "PD": 0.8,
         "T1": 1.56,
-        "T2": 0.0083,
+        "T2": 0.083,
         "T2'": 0.32,
         "D": 0.83
       },

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/python/MRzeroCore/phantom/voxel_grid_phantom.py

@@ -157,6 +157,10 @@ class VoxelGridPhantom:
             T2dash = torch.tensor(data['T2dash_map'])
             PD = torch.tensor(data['PD_map'])
             D = torch.tensor(data['D_map'])
+            try:
+                size = torch.tensor(data['FOV'])
+            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
@@ -174,11 +178,6 @@ class VoxelGridPhantom:
         B0 -= (B0 * weight).sum()
         B1 /= (B1 * weight).sum()
 
-        try:
-            size = torch.tensor(data['FOV'])
-        except KeyError:
-            size = torch.tensor([0.192, 0.192, 0.192])
-
         return cls(
             PD, T1, T2, T2dash, D, B0, B1[None, ...],
             torch.ones(1, *PD.shape), size,

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/python/MRzeroCore/simulation/main_pass.py

@@ -18,12 +18,9 @@ def execute_graph(graph: Graph,
                   min_emitted_signal: float = 1e-2,
                   min_latent_signal: float = 1e-2,
                   print_progress: bool = True,
-                  ) -> torch.Tensor:
-    """Calculate the signal of the sequence by computing the graph.
-
-    This function can optionally return the + or z magnetisation and the
-    encoding of all states, if requested. The encoding consists of the signal
-    of a distribution and its k-t space trajectory.
+                  return_mag_z: int | bool | None = None,
+                  ) -> torch.Tensor | list:
+    """Calculate the signal of the sequence by executing the phase graph.
 
     Parameters
     ----------
@@ -40,11 +37,18 @@ def execute_graph(graph: Graph,
         Should be <= than min_emitted_signal.
     print_progress : bool
         If true, the current repetition is printed while simulating.
+    return_mag_z : int or bool, optional
+        If set, returns the longitudinal magnetisation of either the given
+        repetition (int) or all repetitions (``True``).
+
 
     Returns
     -------
     signal : torch.Tensor
         The simulated signal of the sequence.
+    mag_z : torch.Tensor | list[torch.Tensor]
+        The longitudinal magnetisation of the specified or all repetition(s).
+
     """
     if seq.normalized_grads:
         grad_scale = 1 / data.size
@@ -67,6 +71,7 @@ def execute_graph(graph: Graph,
     # Calculate kt_vec ourselves for autograd
     graph[0][0].kt_vec = torch.zeros(4, device=data.device)
 
+    mag_z = []
     for i, (dists, rep) in enumerate(zip(graph[1:], seq)):
         if print_progress:
             print(f"\rCalculating repetition {i+1} / {len(seq)}", end='')
@@ -129,7 +134,8 @@ def execute_graph(graph: Graph,
         # Use the same adc phase for all coils
         adc_rot = torch.exp(1j * rep.adc_phase).unsqueeze(1)
 
-
+        mag_z_rep = []
+        mag_z.append(mag_z_rep)
         for dist in dists:
             # Create a list only containing ancestors that were simulated
             ancestors = list(filter(
@@ -142,6 +148,9 @@ 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 in ['z0', 'z'] and return_mag_z in [i, True]:
+                mag_z_rep.append(dist.mag)
+
             # The pre_pass already calculates kt_vec, but that does not
             # work with autograd -> we need to calculate it with torch
             if dist.dist_type == 'z0':
@@ -224,6 +233,10 @@ def execute_graph(graph: Graph,
         print(" - done")
 
     # Only return measured samples
-    return torch.cat([
+    measured = torch.cat([
         sig[rep.adc_usage > 0, :] for sig, rep in zip(signal, seq)
     ])
+    if return_mag_z is not None:
+        return measured, mag_z
+    else:
+        return measured

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/src/lib.rs

@@ -29,7 +29,7 @@ struct PyDistribution {
     #[pyo3(get)]
     emitted_signal: f32,
     #[pyo3(get)]
-    prepass_kt_vec: [f32; 4],
+    prepass_kt_vec: [f64; 4],
 }
 
 #[pymethods]

{MRzeroCore-0.2.10 → MRzeroCore-0.2.12}/src/pre_pass.rs

@@ -1,7 +1,6 @@
-use num_complex::Complex32;
+use num_complex::{Complex32, ComplexFloat};
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::f32::consts::TAU;
 use std::iter;
 use std::rc::Rc;
 
@@ -42,7 +41,7 @@ pub struct Distribution {
     pub regrown_mag: f32, // Don't propagate to ancestors if its the own mag
     pub signal: f32,
     pub emitted_signal: f32, // relative to the strongest dist in the repetition
-    pub kt_vec: [f32; 4],
+    pub kt_vec: [f64; 4],
     pub dist_type: DistType,
     pub ancestors: Vec<Edge>,
     /// latent_signal metric: if you want to measure states with a minimum signal of x,
@@ -53,17 +52,17 @@ pub struct Distribution {
 impl Distribution {
     fn measure(&mut self, t2dash: f32, nyquist: [f32; 3]) {
         let sigmoid = |x: f32| 1.0 / (1.0 + (-x).exp());
-        let tmp = |nyq: f32, k: f32| sigmoid((nyq - k.abs() + 0.5) * 100.0);
+        let tmp = |nyq: f32, k: f64| sigmoid((nyq - k.abs() as f32 + 0.5) * 100.0);
         let dephasing = tmp(nyquist[0], self.kt_vec[0])
             * tmp(nyquist[1], self.kt_vec[1])
             * tmp(nyquist[2], self.kt_vec[2]);
 
-        let norm = |x: f32, y: f32, z: f32| (x * x + y * y + z * z).sqrt();
+        let norm = |x: f64, y: f64, z: f64| (x * x + y * y + z * z).sqrt() as f32;
         let k_len = norm(self.kt_vec[0], self.kt_vec[1], self.kt_vec[2]);
 
         // Empirical signal drop-off is roughly estimated by x^(-2.2)
         self.signal += self.mag.norm()
-            * (-(self.kt_vec[3] / t2dash).abs()).exp()
+            * (-(self.kt_vec[3] as f32 / t2dash).abs()).exp()
             * (1.0 + k_len).powf(-2.2)
             * dephasing;
     }
@@ -90,6 +89,20 @@ pub fn comp_graph(
     grad_scale: [f32; 3], // scale gradients to SI if they are normalized
     avg_b1_trig: &[[f32; 3]],
 ) -> Vec<Vec<RcDist>> {
+    // Make precision of state merging dependent on the units used in the seq.
+    // For this, we use a fraction of the smallest used step.
+    let min_kt_step = [
+        seq.iter().flat_map(|r| r.gradm_event.iter().map(|g| g[0].abs() as f64)).filter(|x| *x > 1e-3).min_by(f64::total_cmp),
+        seq.iter().flat_map(|r| r.gradm_event.iter().map(|g| g[1].abs() as f64)).filter(|x| *x > 1e-3).min_by(f64::total_cmp),
+        seq.iter().flat_map(|r| r.gradm_event.iter().map(|g| g[2].abs() as f64)).filter(|x| *x > 1e-3).min_by(f64::total_cmp),
+        seq.iter().flat_map(|r| r.event_time.iter().map(|t| *t as f64)).filter(|x| *x > 1e-6).min_by(f64::total_cmp)
+    ];
+    let inv_kt_grid = [
+        1.0 / (0.1 * min_kt_step[0].unwrap_or(1.0)).clamp(1e-6, 1.0),
+        1.0 / (0.1 * min_kt_step[1].unwrap_or(1.0)).clamp(1e-6, 1.0),
+        1.0 / (0.1 * min_kt_step[2].unwrap_or(1.0)).clamp(1e-6, 1.0),
+        1.0 / (0.1 * min_kt_step[3].unwrap_or(1e-3)).clamp(1e-9, 1e-3),
+    ];
     let mut graph: Vec<Vec<RcDist>> = Vec::new();
 
     let mut dists_p = DistVec::new();
@@ -112,6 +125,7 @@ pub fn comp_graph(
                 max_dist_count,
                 min_dist_mag,
                 avg_b1_trig,
+                inv_kt_grid
             );
             dists_p = _dists_p;
             dists_z = _dists_z;
@@ -136,10 +150,10 @@ pub fn comp_graph(
                 .zip(&rep.adc_mask)
             {
                 let k1 = dist.kt_vec;
-                dist.kt_vec[0] += gradm[0] * grad_scale[0];
-                dist.kt_vec[1] += gradm[1] * grad_scale[1];
-                dist.kt_vec[2] += gradm[2] * grad_scale[2];
-                dist.kt_vec[3] += dt;
+                dist.kt_vec[0] += gradm[0] as f64 * grad_scale[0] as f64;
+                dist.kt_vec[1] += gradm[1] as f64 * grad_scale[1] as f64;
+                dist.kt_vec[2] += gradm[2] as f64 * grad_scale[2] as f64;
+                dist.kt_vec[3] += *dt as f64;
                 let k2 = dist.kt_vec;
 
                 // Integrating (dt omitted) over k²(t) = ((1-x)*k1 + x*k2)^2
@@ -148,7 +162,8 @@ pub fn comp_graph(
                     * dt
                     * ((k1[0] * k1[0] + k1[0] * k2[0] + k2[0] * k2[0])
                         + (k1[1] * k1[1] + k1[1] * k2[1] + k2[1] * k2[1])
-                        + (k1[2] * k1[2] + k1[2] * k2[2] + k2[2] * k2[2]));
+                        + (k1[2] * k1[2] + k1[2] * k2[2] + k2[2] * k2[2]))
+                        as f32;
 
                 dist.mag *= r2 * (-b * d).exp();
                 if *adc {
@@ -165,7 +180,7 @@ pub fn comp_graph(
             let sqr = |x| x * x;
             let k2 = sqr(dist.kt_vec[0]) + sqr(dist.kt_vec[1]) + sqr(dist.kt_vec[2]);
 
-            dist.mag *= r1 * (-d * rep_time * k2).exp();
+            dist.mag *= r1 * (-d * rep_time * k2 as f32).exp();
         }
         // Z0 has no diffusion because it's not dephased
         dist_z0.borrow_mut().mag *= r1;
@@ -183,22 +198,23 @@ fn apply_pulse(
     max_dist_count: usize,
     min_dist_mag: f32,
     avg_b1_trig: &[[f32; 3]],
+    inv_kt_grid: [f64; 4],
 ) -> (DistVec, DistVec, RcDist) {
     let rot_mat = RotMat::new(rep.pulse_angle, rep.pulse_phase, avg_b1_trig);
 
     let mut dist_dict_p: DistMap = HashMap::new();
     let mut dist_dict_z: DistMap = HashMap::new();
 
-    let mut add_dist = |kt_vec: [f32; 4],
+    let mut add_dist = |kt_vec: [f64; 4],
                         mag: Complex32,
                         rot_mat_factor: Complex32,
                         relation: DistRelation,
                         ancestor: &RcDist| {
         let key = [
-            (kt_vec[0] * 1e3).round() as i32,
-            (kt_vec[1] * 1e3).round() as i32,
-            (kt_vec[2] * 1e3).round() as i32,
-            (kt_vec[3] * 1e6).round() as i32,
+            (kt_vec[0] * inv_kt_grid[0]).round() as i32,
+            (kt_vec[1] * inv_kt_grid[1]).round() as i32,
+            (kt_vec[2] * inv_kt_grid[2]).round() as i32,
+            (kt_vec[3] * inv_kt_grid[3]).round() as i32,
         ];
         let dist_type = match relation {
             DistRelation::PP | DistRelation::MP | DistRelation::ZP => DistType::P,