midas-plotting 0.3.2__tar.gz → 0.4.1__tar.gz

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midas-plotting
-Version: 0.3.2
+Version: 0.4.1
 Summary: Standard plots for MIDAS reconstructions - near-field, far-field and Laue: IPF maps and legends, grain maps, pole figures, strain and size distributions, and Laue texture diagnostics against their chance levels.
 Author-email: Hemant Sharma <hsharma@anl.gov>
 License: BSD-3-Clause
@@ -88,7 +88,7 @@ Things the module will not let you get wrong:
 * **Symmetry comes from the file.** `Grains.csv` states its space group in the
   preamble; the plots use it. Defaulting to cubic would colour a hexagonal
   sample with the wrong IPF triangle and produce a plausible, wrong figure.
-* **Columns are read by name.** `Grains.csv` has 47 columns and
+* **Columns are read by name.** `Grains.csv` has 53 columns (47 before 2026-08-21) and
   `midas-fit-grain` 0.5.6 shipped a cyclic rotation of three of them; a
   positional reader inherits that silently.
 * **Euler angles are cross-checked against `O11..O33`.** They describe the same

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/README.md

@@ -67,7 +67,7 @@ Things the module will not let you get wrong:
 * **Symmetry comes from the file.** `Grains.csv` states its space group in the
   preamble; the plots use it. Defaulting to cubic would colour a hexagonal
   sample with the wrong IPF triangle and produce a plausible, wrong figure.
-* **Columns are read by name.** `Grains.csv` has 47 columns and
+* **Columns are read by name.** `Grains.csv` has 53 columns (47 before 2026-08-21) and
   `midas-fit-grain` 0.5.6 shipped a cyclic rotation of three of them; a
   positional reader inherits that silently.
 * **Euler angles are cross-checked against `O11..O33`.** They describe the same

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/midas_plotting/__init__.py

@@ -48,7 +48,7 @@ from .solutions import (
 )
 from .mic import MicMap, read_mic
 
-__version__ = "0.3.2"
+__version__ = "0.4.1"
 __all__ = [
     "MicMap", "read_mic", "GrainList", "read_grains", "ff", "laue",
     "LaueSolutions", "LaueSpots", "read_solutions", "read_spots",

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/midas_plotting/ff.py

@@ -318,9 +318,17 @@ def completeness_hist(grains, ax=None, *, bins: int = 30,
 
 # ─── strain ─────────────────────────────────────────────────────────────────
 def strain_scalar(grains, kind: str = "hydrostatic", *,
-                  convention: str = "fab") -> np.ndarray:
+                  convention: str = "ken") -> np.ndarray:
     """Reduce the per-grain strain tensor to one number per grain.
 
+    ``convention`` defaults to **eKen**, matching
+    ``midas_stress.io.read_grains_csv``'s ``strain`` key and its documented
+    recommendation, so a strain map from this module and a stress computed by
+    ``midas_stress`` from the same Grains.csv are the same tensor. It used to
+    default to ``"fab"``; both sites labelled their choice, so nothing was
+    mis-read, but the two answers silently differed. Pass ``convention="fab"``
+    for the lattice-parameter form.
+
     ``kind``:
       ``hydrostatic``  trace/3
       ``vonmises``     von Mises equivalent of the deviatoric part
@@ -352,7 +360,7 @@ def strain_scalar(grains, kind: str = "hydrostatic", *,
 
 
 def strain_map(grains, ax=None, *, kind: str = "hydrostatic",
-               convention: str = "fab", plane: str = "xy", cmin: float = 0.0,
+               convention: str = "ken", plane: str = "xy", cmin: float = 0.0,
                cmap: str = "coolwarm", vmin=None, vmax=None,
                symmetric: bool = True, title: Optional[str] = None):
     """Grain map coloured by a strain scalar (µε).
@@ -392,7 +400,7 @@ def strain_map(grains, ax=None, *, kind: str = "hydrostatic",
     return ax
 
 
-def strain_distribution(grains, ax=None, *, convention: str = "fab",
+def strain_distribution(grains, ax=None, *, convention: str = "ken",
                         bins: int = 30, title: Optional[str] = None):
     """Histograms of the three normal strain components (µε)."""
     import matplotlib.pyplot as plt

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/midas_plotting/grains.py

@@ -4,11 +4,16 @@ The FF analogue of :mod:`midas_plotting.mic`: one place that knows the column
 layout so analysis scripts stop re-deriving it.
 
 Columns are looked up **by name** from the ``%ID ...`` header line, never by
-position. That matters more here than it looks: ``Grains.csv`` has grown to 47
-columns, and `midas-fit-grain` 0.5.6 shipped a cyclic rotation of the
-``DiffPos`` / ``DiffOme`` / ``DiffAngle`` columns (fixed in 0.5.7) that a
-positional reader would silently inherit -- one grain's ω residual read 223.87°
-where the true value was 0.054°.
+position. That matters more here than it looks: ``Grains.csv`` has been widened
+repeatedly (19 -> 21 -> 23 -> 47 -> 53 columns), and `midas-fit-grain` 0.5.6
+shipped a cyclic rotation of the ``DiffPos`` / ``DiffOme`` / ``DiffAngle``
+columns (fixed in 0.5.7) that a positional reader would silently inherit --
+one grain's ω residual read 223.87° where the true value was 0.054°.
+
+Rows are split on **whitespace**, not on tabs: the C ``ProcessGrains`` writer
+ends every data row with a tab, so a bare ``split("\t")`` produces a trailing
+empty field and ``float("")`` raises on files that are otherwise perfectly
+valid.
 
 As a further guard, :func:`read_grains` recomputes the orientation matrix from
 the Euler angles and compares it against the ``O11..O33`` columns. Both describe
@@ -125,8 +130,20 @@ class GrainList:
     def n_grains(self) -> int:
         return len(self)
 
-    def strain(self, convention: str = "fab") -> np.ndarray:
-        """``(N, 3, 3)`` strain tensor in the requested convention."""
+    def strain(self, convention: str = "ken") -> np.ndarray:
+        """``(N, 3, 3)`` strain tensor in the requested convention.
+
+        Defaults to **eKen** to agree with ``midas_stress.io.read_grains_csv``,
+        whose plain ``strain`` key is eKen and which documents it as the
+        recommended form (it is fit directly from the per-reflection
+        ``eps_ij g_i g_j = (d_obs - d_0)/d_0`` gauge equation, so it is tied to
+        the raw observables and has better noise properties than the
+        lattice-parameter form). These two packages are routinely pointed at
+        the same Grains.csv -- a strain map here and a stress calculation
+        there -- and while both label their choice, disagreeing on the default
+        meant the map and the stress were not the same tensor. Pass
+        ``convention="fab"`` for the lattice-parameter (Fable-Beaudoin) form.
+        """
         c = convention.lower()
         if c in ("fab", "fable", "efab"):
             s = self.strain_fab
@@ -163,11 +180,22 @@ def _parse(path: Path):
         if not line.strip():
             continue
         if not line.startswith("%"):
-            rows.append(line.split("\t"))
+            # Whitespace-split, NOT `split("\t")`. The C `ProcessGrains`
+            # terminates every data row with a tab, so a bare tab-split yields
+            # a spurious empty final field and `float("")` raises -- which is
+            # exactly what every file under midas_stress/dev/paper3/runs/ and
+            # the bundled GrainsSim.csv did. Splitting on whitespace also
+            # accepts the space-separated flavours (NF mic2grains seed files).
+            # No value in this format ever contains an internal space, and a
+            # collapsed empty field would be caught by the column-count check
+            # in read_grains() below.
+            rows.append(line.split())
             continue
 
         body = line[1:]
-        fields = [f.strip() for f in body.split("\t")]
+        # Same rule for the header, so a space-separated file's column names
+        # are found too. Column names never contain spaces.
+        fields = body.split()
         # Column header: names O11 (and therefore the whole grain record).
         if "O11" in fields or (fields and fields[0] in ("ID", "GrainID")
                                and len(fields) > 5):
@@ -204,7 +232,7 @@ def read_grains(path, *, check_orientation: bool = True) -> GrainList:
     if columns is None:
         raise ValueError(
             f"{path}: no column header found. Expected a line beginning "
-            "'%ID' or '%GrainID' listing tab-separated column names.")
+            "'%ID' or '%GrainID' listing the column names.")
     if not rows:
         raise ValueError(f"{path}: header present but no grain rows.")
 
@@ -213,8 +241,8 @@ def read_grains(path, *, check_orientation: bool = True) -> GrainList:
     if arr.shape[1] != len(columns):
         raise ValueError(
             f"{path}: {arr.shape[1]} data columns but {len(columns)} header "
-            "names -- the file is malformed or tab/space separated "
-            "inconsistently.")
+            "names -- the file is malformed (an empty field mid-row, or a "
+            "header that does not match the rows).")
 
     def col(name, required=True):
         if name not in idx:

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/midas_plotting/ipf.py

@@ -15,10 +15,11 @@ from typing import Sequence
 
 import numpy as np
 
-__all__ = ["ipf_rgb", "sym_matrices", "CUBIC", "HEXAGONAL"]
+__all__ = ["ipf_rgb", "sym_matrices", "CUBIC", "HEXAGONAL", "TRIGONAL"]
 
 CUBIC = "cubic"
 HEXAGONAL = "hexagonal"
+TRIGONAL = "trigonal"
 
 # Laue class per space-group range, for the ones MIDAS actually reconstructs.
 # Deliberately explicit rather than clever: a wrong guess here silently
@@ -26,6 +27,7 @@ HEXAGONAL = "hexagonal"
 _SG_LAUE = [
     (195, 230, CUBIC),
     (168, 194, HEXAGONAL),
+    (143, 167, TRIGONAL),
 ]
 
 
@@ -41,7 +43,7 @@ def laue_class(space_group: int) -> str:
             return name
     raise NotImplementedError(
         f"IPF colouring for space group {space_group} is not implemented "
-        f"(have: cubic 195-230, hexagonal 168-194). Refusing to guess."
+        f"(have: cubic 195-230, hexagonal 168-194, trigonal 143-167). Refusing to guess."
     )
 
 
@@ -81,6 +83,58 @@ def _rgb_hexagonal(d: np.ndarray) -> np.ndarray:
     return np.stack([dz, planar * (1.0 - t), planar * t], axis=1)
 
 
+def _trigonal_sector_deg(sym: np.ndarray) -> float:
+    """Azimuthal fundamental-sector width, measured from the operators.
+
+    Counts the distinct upper-hemisphere azimuths a generic direction is sent
+    to by the group plus the Laue centre. For -3m that is 6 images, so 60 deg
+    -- twice the hexagonal 30. Measured rather than hard-coded so a change in
+    the operator set cannot silently mis-scale the colour ramp.
+    """
+    g = np.array([0.3411, 0.1297, 0.4271])       # generic, no special azimuth
+    g = g / np.linalg.norm(g)
+    both = np.concatenate([sym @ g, -(sym @ g)], axis=0)
+    up = both[both[:, 2] >= -1e-12]
+    phi = np.sort(np.degrees(np.arctan2(up[:, 1], up[:, 0])) % 360.0)
+    keep = [phi[0]]
+    for a in phi[1:]:
+        if a - keep[-1] > 1e-6:
+            keep.append(a)
+    return 360.0 / len(keep)
+
+
+def _rgb_trigonal(d_all: np.ndarray, sym: np.ndarray) -> np.ndarray:
+    """Standard [0001]-[10-10]-[01-10] triangle for Laue class -3m.
+
+    D3 has 6 proper rotations (3-fold about c, three 2-fold in the basal
+    plane) against 6/mmm's 12, so the sector spans 60 deg, not 30. Colouring
+    R-3m with the hexagonal triangle folds by a 6-fold axis the crystal does
+    not have and silently gives distinct orientations the same colour.
+
+    The azimuth is NOT hand-folded. Where MIDAS puts the 2-fold axes is a
+    convention, and assuming one sits at azimuth 0 gives a colouring that is
+    not symmetry invariant (measured: colour moved by up to 0.99 under
+    ``g -> S.g``). Instead take the whole orbit, add ``-d`` for the Laue
+    centre, keep the upper hemisphere and pick the smallest azimuth --
+    canonical whatever the operator convention.
+
+    ``d_all`` is ``(n, n_sym, 3)``, every symmetry image of each direction.
+    """
+    both = np.concatenate([d_all, -d_all], axis=1)              # (n, 2s, 3)
+    phi = np.degrees(np.arctan2(both[:, :, 1], both[:, :, 0])) % 360.0
+    phi = np.where(both[:, :, 2] >= -1e-12, phi, np.inf)        # upper only
+    k = np.argmin(phi, axis=1)
+    idx = np.arange(both.shape[0])
+    rep, phi_c = both[idx, k], phi[idx, k]
+    phi_c = np.where(np.isfinite(phi_c), phi_c, 0.0)
+    rep = rep / np.linalg.norm(rep, axis=1, keepdims=True)
+
+    dz = np.abs(rep[:, 2])
+    planar = np.hypot(rep[:, 0], rep[:, 1])
+    t = np.clip(phi_c / _trigonal_sector_deg(sym), 0.0, 1.0)
+    return np.stack([dz, planar * (1.0 - t), planar * t], axis=1)
+
+
 def ipf_rgb(
     euler: np.ndarray,
     space_group: int = 225,
@@ -139,7 +193,14 @@ def ipf_rgb_from_matrix(
         raise ValueError("axis must be non-zero")
     a = a / n
 
-    d = np.einsum("nij,j->ni", g, a)                 # crystal dir of the axis
+    # TRANSPOSE. MIDAS orientation matrices map CRYSTAL -> LAB (v_lab = g v_crystal),
+    # so the crystal direction parallel to the sample axis `a` is g^T a, not g a.
+    # This is not cosmetic: with g a, the colour is NOT symmetry-invariant for this
+    # convention -- the 24 equally valid representations of one grain spread over
+    # 0.96 in RGB, so a map's colour depended on which variant the indexer happened
+    # to store. Two grains agreeing to 0.5 deg came out 0.42 apart in RGB.
+    # Fixed 2026-09-03; see tests::test_ipf_colour_is_symmetry_invariant.
+    d = np.einsum("nji,j->ni", g, a)                 # crystal dir of the axis = g^T a
     return direction_rgb(d, space_group, gamma=gamma)
 
 
@@ -170,6 +231,8 @@ def direction_rgb(
         red = red[np.arange(red.shape[0]), pick]
         red /= np.linalg.norm(red, axis=1, keepdims=True)
         rgb = _rgb_cubic(red)
+    elif fam == TRIGONAL:
+        rgb = _rgb_trigonal(d, sym)
     else:
         dd = d.copy()
         dd[:, :, 2] = np.abs(dd[:, :, 2])

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/midas_plotting.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: midas-plotting
-Version: 0.3.2
+Version: 0.4.1
 Summary: Standard plots for MIDAS reconstructions - near-field, far-field and Laue: IPF maps and legends, grain maps, pole figures, strain and size distributions, and Laue texture diagnostics against their chance levels.
 Author-email: Hemant Sharma <hsharma@anl.gov>
 License: BSD-3-Clause
@@ -88,7 +88,7 @@ Things the module will not let you get wrong:
 * **Symmetry comes from the file.** `Grains.csv` states its space group in the
   preamble; the plots use it. Defaulting to cubic would colour a hexagonal
   sample with the wrong IPF triangle and produce a plausible, wrong figure.
-* **Columns are read by name.** `Grains.csv` has 47 columns and
+* **Columns are read by name.** `Grains.csv` has 53 columns (47 before 2026-08-21) and
   `midas-fit-grain` 0.5.6 shipped a cyclic rotation of three of them; a
   positional reader inherits that silently.
 * **Euler angles are cross-checked against `O11..O33`.** They describe the same

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "midas-plotting"
-version = "0.3.2"
+version = "0.4.1"
 description = "Standard plots for MIDAS reconstructions - near-field, far-field and Laue: IPF maps and legends, grain maps, pole figures, strain and size distributions, and Laue texture diagnostics against their chance levels."
 readme = "README.md"
 license = { text = "BSD-3-Clause" }

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/tests/test_ff.py

@@ -13,16 +13,38 @@ from midas_plotting.ipf import (                                # noqa: E402
     direction_rgb, ipf_rgb, ipf_rgb_from_matrix,
 )
 
-_COLS = (["ID"] + [f"O{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
-         + ["X", "Y", "Z", "a", "b", "c", "alpha", "beta", "gamma",
-            "DiffPos", "DiffOme", "DiffAngle", "GrainRadius", "Confidence"]
-         + [f"eFab{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
-         + [f"eKen{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
-         + ["RMSErrorStrain", "PhaseNr", "Eul0", "Eul1", "Eul2"])
-
-
-def _write_grains(tmp_path, n=4, sg=225, break_orientation=False):
-    """A Grains.csv with the real preamble shape, incl. tab-indented phase info."""
+# The CURRENT width is 53: the six DiffPos/Ome/Angle Pre/Post diagnostics were
+# appended on 2026-08-21. The fixture used to stop at 47, which is why nothing
+# here noticed the widening.
+_DATA_COLS = ([f"O{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
+              + ["X", "Y", "Z", "a", "b", "c", "alpha", "beta", "gamma",
+                 "DiffPos", "DiffOme", "DiffAngle",
+                 "GrainRadius", "Confidence"]
+              + [f"eFab{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
+              + [f"eKen{i}{j}" for i in (1, 2, 3) for j in (1, 2, 3)]
+              + ["RMSErrorStrain", "PhaseNr", "Eul0", "Eul1", "Eul2",
+                 "DiffPosPre", "DiffOmePre", "DiffAnglePre",
+                 "DiffPosPost", "DiffOmePost", "DiffAnglePost"])
+_COLS = ["ID"] + _DATA_COLS
+
+
+def _write_grains(tmp_path, n=4, sg=225, break_orientation=False,
+                  *, trailing_tab=False, id_token="ID", sep="\t"):
+    """A Grains.csv with the real preamble shape, incl. tab-indented phase info.
+
+    Parameters
+    ----------
+    trailing_tab : bool
+        Terminate every data row with a tab, which is what the C
+        ``ProcessGrains`` actually writes. A reader that does ``split("\t")``
+        then sees a spurious empty final field and ``float("")`` raises. Every
+        real file under ``midas_stress/dev/paper3/runs/*/data/*MPa/`` and the
+        bundled ``GrainsSim.csv`` is in this form, and this fixture's omission
+        of it is why the crash shipped.
+    id_token : "ID" or "GrainID"
+        Both spellings are written by live MIDAS writers.
+    sep : column separator for the header and data rows.
+    """
     from midas_stress.orientation import euler_to_orient_mat_batch
 
     rng = np.random.default_rng(0)
@@ -38,7 +60,7 @@ def _write_grains(tmp_path, n=4, sg=225, break_orientation=False):
         f"%\tSpaceGroup:{sg}",
         "%\tLattice Parameter:4.078200\t4.078200\t4.078200\t"
         "90.000000\t90.000000\t90.000000",
-        "%" + "\t".join(_COLS),
+        "%" + sep.join([id_token] + _DATA_COLS),
     ]
     for k in range(n):
         row = [str(k + 1)] + [f"{v:.6f}" for v in om[k].reshape(-1)]
@@ -50,7 +72,9 @@ def _write_grains(tmp_path, n=4, sg=225, break_orientation=False):
         row += [f"{v:.4f}" for v in rng.normal(200, 50, 9)]             # eKen
         row += ["400.0", "1"]
         row += [f"{v:.9f}" for v in eul[k]]
-        lines.append("\t".join(row))
+        row += ["151.0", "0.06", "0.09", "150.0", "0.05", "0.08"]       # pre/post
+        assert len(row) == len(_COLS)
+        lines.append(sep.join(row) + ("\t" if trailing_tab else ""))
     p = tmp_path / "Grains.csv"
     p.write_text("\n".join(lines) + "\n")
     return p, eul, om
@@ -111,6 +135,51 @@ def test_orientation_check_can_be_disabled(tmp_path):
         read_grains(p, check_orientation=False)
 
 
+@pytest.mark.parametrize("trailing_tab", [False, True])
+@pytest.mark.parametrize("id_token", ["ID", "GrainID"])
+def test_trailing_tab_and_both_id_spellings(tmp_path, trailing_tab, id_token):
+    """The shipped crash: `line.split("\t")` on a tab-terminated row.
+
+    The C ``ProcessGrains`` ends every data row with a tab, so a tab-split
+    yields one extra empty field and ``float("")`` raised
+    ``could not convert string to float: ''`` on every real file under
+    ``midas_stress/dev/paper3/runs/*/data/*MPa/Grains.csv``.
+    """
+    p, eul, om = _write_grains(tmp_path, n=4, trailing_tab=trailing_tab,
+                               id_token=id_token)
+    g = read_grains(p)
+    assert len(g) == 4
+    assert len(g.columns) == 53
+    np.testing.assert_array_equal(g.ids, [1, 2, 3, 4])
+    assert np.allclose(g.euler, eul, atol=1e-6)
+    assert np.allclose(g.orient_mat, om, atol=1e-5)
+    assert np.allclose(g.radius, [40.0, 50.0, 60.0, 70.0])
+
+
+def test_space_separated_file_is_readable(tmp_path):
+    """NF ``mic2grains`` seed files are space-separated, not tab-separated."""
+    p, eul, _ = _write_grains(tmp_path, n=3, sep=" ")
+    g = read_grains(p)
+    assert len(g) == 3 and len(g.columns) == 53
+    assert np.allclose(g.euler, eul, atol=1e-6)
+
+
+def test_current_width_exposes_pre_post_residual_columns(tmp_path):
+    """The 2026-08-21 widening: 47 -> 53. The extra columns must be readable
+    by name, and must not displace anything that was already there."""
+    p, _, _ = _write_grains(tmp_path, n=2)
+    g = read_grains(p)
+    idx = {c: i for i, c in enumerate(g.columns)}
+    for c in ("DiffPosPre", "DiffOmePre", "DiffAnglePre",
+              "DiffPosPost", "DiffOmePost", "DiffAnglePost"):
+        assert c in idx
+    np.testing.assert_allclose(g.raw[:, idx["DiffPosPre"]], 151.0)
+    np.testing.assert_allclose(g.raw[:, idx["DiffPosPost"]], 150.0)
+    # ...and the pre-existing block is untouched.
+    np.testing.assert_allclose(g.diff_pos, 150.0)
+    np.testing.assert_allclose(g.diff_ome, 0.05)
+
+
 def test_missing_header_is_an_error(tmp_path):
     p = tmp_path / "bad.csv"
     p.write_text("1\t2\t3\n")
@@ -127,7 +196,7 @@ def test_strain_is_not_rescaled(tmp_path):
     p, _, _ = _write_grains(tmp_path, n=4)
     g = read_grains(p)
     raw11 = g.strain_fab[:, 0, 0]
-    assert np.allclose(ff.strain_scalar(g, "11"), raw11)
+    assert np.allclose(ff.strain_scalar(g, "11", convention="fab"), raw11)
     assert np.abs(ff.strain_scalar(g, "hydrostatic")).max() < 1e4
 
 
@@ -135,6 +204,9 @@ def test_strain_scalars(tmp_path):
     p, _, _ = _write_grains(tmp_path, n=4)
     g = read_grains(p)
     e = g.strain("fab")
+    assert np.allclose(ff.strain_scalar(g, "hydrostatic", convention="fab"),
+                       np.trace(e, axis1=1, axis2=2) / 3.0)
+    e = g.strain()          # default convention, checked below
     assert np.allclose(ff.strain_scalar(g, "hydrostatic"),
                        np.trace(e, axis1=1, axis2=2) / 3.0)
     assert (ff.strain_scalar(g, "vonmises") >= 0).all()
@@ -246,3 +318,37 @@ def test_ff_detected_by_content_not_filename(tmp_path):
     other.write_text("1 2 3 4 5\n")
     assert not _looks_like_ff(other)
     assert not _looks_like_ff(tmp_path / "missing.csv")
+
+
+# ── strain convention default (regression) ──────────────────────────────────
+def test_strain_default_convention_is_eken(tmp_path):
+    """The default must be eKen, matching ``midas_stress.io``'s ``strain`` key.
+
+    midas_plotting defaulted to eFab while midas_stress.io mapped its plain
+    ``strain`` key to eKen and documented eKen as the recommendation. Both
+    sites labelled their choice, so nothing raised and nothing was mislabelled
+    -- but a strain map from here and a stress from there, on the SAME
+    Grains.csv, were different tensors.
+    """
+    p, _, _ = _write_grains(tmp_path, n=6)
+    g = read_grains(p)
+    # The fixture draws eFab and eKen independently, so a wrong default shows.
+    assert not np.allclose(g.strain_fab, g.strain_ken)
+    np.testing.assert_allclose(g.strain(), g.strain_ken)
+    for kind in ("hydrostatic", "vonmises", "11", "23"):
+        np.testing.assert_allclose(ff.strain_scalar(g, kind),
+                                   ff.strain_scalar(g, kind, convention="ken"))
+
+
+def test_strain_default_agrees_with_midas_stress(tmp_path):
+    """Same file, same tensor, across the two packages.
+
+    midas_stress returns dimensionless strain (it divides the stored
+    microstrain by 1e6); midas_plotting keeps microstrain. That factor is the
+    ONLY difference the two defaults may have.
+    """
+    ms_io = pytest.importorskip("midas_stress.io")
+    p, _, _ = _write_grains(tmp_path, n=6)
+    g = read_grains(p)
+    ms = ms_io.read_grains_csv(str(p))
+    np.testing.assert_allclose(g.strain(), ms["strain"] * 1e6, rtol=1e-9)

{midas_plotting-0.3.2 → midas_plotting-0.4.1}/tests/test_ipf.py

@@ -72,7 +72,11 @@ def test_symmetry_equivalent_orientations_get_the_same_colour():
 
     base = ipf_rgb(e0, 225)
     for op in S[1:6]:
-        g1 = np.einsum("ij,njk->nik", op, g0)
+        # symmetry acts on the RIGHT for crystal->lab matrices (MIDAS convention):
+        # midas_stress.misorientation_om_batch calls g.S equivalent and S.g a
+        # DIFFERENT orientation (61 deg). Asserting the wrong side is what let the
+        # g-vs-g^T bug survive until 2026-09-03.
+        g1 = np.einsum("nij,jk->nik", g0, op)
         e1 = np.array([np.asarray(orient_mat_to_euler(m.ravel().tolist())).ravel()
                        for m in g1])
         np.testing.assert_allclose(ipf_rgb(e1, 225), base, atol=1e-6)
@@ -98,3 +102,61 @@ def test_hexagonal_c_axis_along_z_is_red():
     """[0001] || Z is the first corner of the hexagonal triangle."""
     rgb = ipf_rgb(np.zeros((1, 3)), 194)[0]
     assert rgb[0] > 0.9
+
+
+# --- trigonal (Laue -3m), added for NMC811 R-3m / SG 166 -------------------
+
+def _random_oms(n, seed=0):
+    rng = np.random.default_rng(seed)
+    q = rng.normal(size=(n, 4))
+    q /= np.linalg.norm(q, axis=1, keepdims=True)
+    w, x, y, z = q.T
+    return np.stack([
+        1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w),
+        2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w),
+        2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y),
+    ], axis=1).reshape(-1, 3, 3)
+
+
+@pytest.mark.parametrize("sg", [166, 194, 225])
+def test_ipf_colour_is_symmetry_invariant(sg):
+    """colour(S.g) == colour(g) for every proper rotation S.
+
+    This is the property that makes an IPF map mean anything: one grain, one
+    colour, whichever symmetrically equivalent orientation the indexer
+    happened to report. It is also what caught the first -3m triangle, which
+    hand-folded the azimuth assuming a 2-fold axis at 0 deg and moved the
+    colour by up to 0.99 under this test.
+    """
+    from midas_plotting.ipf import ipf_rgb_from_matrix, sym_matrices
+    g = _random_oms(2000, seed=sg)
+    base = ipf_rgb_from_matrix(g, sg)
+    for s in sym_matrices(sg):
+        got = ipf_rgb_from_matrix(np.einsum("nij,jk->nik", g, s), sg)
+        np.testing.assert_allclose(got, base, atol=1e-9)
+
+
+def test_trigonal_sector_is_twice_the_hexagonal_one():
+    """-3m has 6 proper rotations to 6/mmm's 12, so a 60 deg sector, not 30.
+
+    Measured from the operator set, so a change there cannot silently
+    mis-scale the ramp.
+    """
+    from midas_plotting.ipf import _trigonal_sector_deg, sym_matrices
+    assert _trigonal_sector_deg(sym_matrices(166)) == pytest.approx(60.0)
+    assert _trigonal_sector_deg(sym_matrices(194)) == pytest.approx(30.0)
+
+
+def test_trigonal_is_not_the_hexagonal_colouring():
+    """R-3m must not be quietly coloured as 6/mmm -- that merges orientations."""
+    from midas_plotting.ipf import ipf_rgb_from_matrix
+    g = _random_oms(3000, seed=7)
+    assert np.abs(ipf_rgb_from_matrix(g, 166)
+                  - ipf_rgb_from_matrix(g, 194)).mean() > 0.05
+
+
+def test_laue_class_still_refuses_what_it_cannot_draw():
+    from midas_plotting.ipf import laue_class
+    assert laue_class(166) == "trigonal"
+    with pytest.raises(NotImplementedError):
+        laue_class(2)          # triclinic: no triangle implemented