Merge branch 'housekeeping_2026-02-20' into 'development'

housekeeping 2026-02-20

Closes #602 and #603

See merge request damask/DAMASK!1175

Author: dmentock

.gitlab-ci.yml

@@ -14,7 +14,7 @@ variables:
   MARC_VERSION: '2025.1'
   PETSC_GCC_LATEST: '2025.11.13'
   PETSC_ONEAPI_LATEST: '2025.11.13'
-  PYTHON_LATEST: '2025.06.05'
+  PYTHON_LATEST: '2026.02.24'
 
 ####################################################################################################
 # https://docs.gitlab.com/ci/yaml/workflow
@@ -115,6 +115,7 @@ workflow:
   parallel:
     matrix:
       - IMAGE:
+          - python:2025.06.05
           - python:2025.01.05
           - python:310_2412
 

PRIVATE

@@ -28,9 +28,9 @@ cd $DAMASK_ROOT >/dev/null; BRANCH=$(git branch 2>/dev/null| grep -E '^\* '); cd
 
 PATH=${DAMASK_ROOT}/bin:$PATH
 
-SOLVER_GRID=$(type -p DAMASK_grid || true 2>/dev/null)
+SOLVER_GRID=$(type -p damask_grid || true 2>/dev/null)
 [ "x$SOLVER_GRID" == "x" ] && SOLVER_GRID=$(blink 'Not found!')
-SOLVER_MESH=$(type -p DAMASK_mesh || true 2>/dev/null)
+SOLVER_MESH=$(type -p damask_mesh || true 2>/dev/null)
 [ "x$SOLVER_MESH" == "x" ] && SOLVER_MESH=$(blink 'Not found!')
 
 

env/DAMASK.sh

@@ -18,9 +18,9 @@ cd $DAMASK_ROOT >/dev/null; BRANCH=$(git branch 2>/dev/null| grep -E '^\* '); cd
 
 PATH=${DAMASK_ROOT}/bin:$PATH
 
-SOLVER_GRID=$(which DAMASK_grid || true 2>/dev/null)
+SOLVER_GRID=$(which damask_grid || true 2>/dev/null)
 [[ "x$SOLVER_GRID" == "x" ]] && SOLVER_GRID=$(blink 'Not found!')
-SOLVER_MESH=$(which DAMASK_mesh || true 2>/dev/null)
+SOLVER_MESH=$(which damask_mesh || true 2>/dev/null)
 [[ "x$SOLVER_MESH" == "x" ]] && SOLVER_MESH=$(blink 'Not found!')
 
 

env/DAMASK.zsh

@@ -648,7 +648,7 @@ def from_Voronoi_tessellation(cells: IntSequence,
         """
         coords = grid_filters.coordinates0_point(cells,size).reshape(-1,3)
         tree = spatial.KDTree(seeds,boxsize=np.asarray(size) if periodic else None)
-        material_ = tree.query(coords, workers = int(os.environ.get('OMP_NUM_THREADS',4)))[1]
+        material_ = np.asarray(tree.query(coords, workers = int(os.environ.get('OMP_NUM_THREADS',4)))[1])
 
         return GeomGrid(material = (material_ if material is None else np.array(material)[material_]).reshape(cells),
                         size     = size,
@@ -1003,14 +1003,11 @@ def flip(self,
         if not set(directions).issubset(valid):
             raise ValueError(f'invalid direction "{set(directions).difference(valid)}" specified')
 
-        mat = np.flip(self.material, [valid.index(d) for d in directions if d in valid])
-        ic = {}
-        for label in self.initial_conditions:
-            ic[label] = np.flip(self.initial_conditions[label],[valid.index(d) for d in directions if d in valid])
-        return GeomGrid(material = mat,
+        directions_ = tuple([valid.index(d) for d in directions if d in valid])
+        return GeomGrid(material = np.flip(self.material, directions_),
                         size     = self.size,
                         origin   = self.origin,
-                        initial_conditions = ic,
+                        initial_conditions = {label:np.flip(ic, directions_) for label,ic in self.initial_conditions.items()},
                         comments = self.comments+[util.execution_stamp('GeomGrid','flip')],
                        )
 
@@ -1056,10 +1053,12 @@ def rotate(self,
         material = self.material
         # These rotations are always applied in the reference coordinate system, i.e. (z,x,z) not (z,x',z'')
         # see https://www.cs.utexas.edu/~theshark/courses/cs354/lectures/cs354-14.pdf
-        for angle,axes in zip(R.as_Euler_angles(degrees=True)[::-1], [(0,1),(1,2),(0,1)]):
-            material_temp = ndimage.rotate(material,angle,axes,order=0,prefilter=False,
+        for angle,axes in zip(np.flip(R.as_Euler_angles(degrees=True)), [(0,1),(1,2),(0,1)]):
+            material_temp = ndimage.rotate(material,angle,axes,
                                            output=self.material.dtype,
-                                           cval=np.nanmax(self.material) + 1 if fill is None else fill)
+                                           order=0,
+                                           cval=np.nanmax(self.material) + 1 if fill is None else fill,
+                                           prefilter=False)                                         # type: ignore[call-overload]
             # avoid scipy interpolation errors for rotations close to multiples of 90°
             material = material_temp if np.prod(material_temp.shape) != np.prod(material.shape) else \
                        np.rot90(material,k=np.rint(angle/90.).astype(np.int64),axes=axes)

python/damask/_geomgrid.py

@@ -2020,7 +2020,7 @@ def export_VTK(self,
 
                         for grp_label,dataset in outs.items():
                             v = v.set(' / '.join(['/'.join([grp_type,grp_field,grp_label]),
-                                                 dataset.dtype.metadata.get('unit')]),dataset)
+                                                 dataset.dtype.metadata['unit']]),dataset)          # type: ignore[index]
 
                 v.save(out_dir/f'{self.fname.stem}_inc{grp_inc.split(prefix_inc)[-1].zfill(N_digits)}',
                        parallel=parallel)
@@ -2083,14 +2083,14 @@ def create_and_open(obj,name):
                     for grp_label in self._visible['phases']:
                         try:
                             data = _read(f['/'.join([grp_inc,'phase',grp_label,'mechanical',q])])
-                            lattice = data.dtype.metadata['lattice']
                             # Map to DREAM.3D IDs
-                            if lattice == 'hP':
-                                crystal_structure.append(0)
-                            elif lattice in ['cI','cF']:
-                                crystal_structure.append(1)
-                            elif lattice == 'tI':
-                                crystal_structure.append(8)
+                            match data.dtype.metadata['lattice']:                                   # type: ignore[index]
+                                case 'hP':
+                                    crystal_structure.append(0)
+                                case 'cI' | 'cF':
+                                    crystal_structure.append(1)
+                                case 'tI':
+                                    crystal_structure.append(8)
 
                             cell_orientation[at_cell_ph[c][grp_label],:] = \
                                 Rotation(data[in_data_ph[c][grp_label],:]).as_Euler_angles().astype(np.float32)

python/damask/_result.py

@@ -275,8 +275,8 @@ def __array__(self: MyType,
                   *,
                   copy: Optional[bool] = None) -> np.ndarray:
         """Initializer for numpy."""
-        return self.quaternion.__array__(dtype) if util.version(np.__version__) < '2.0.0' else \
-               self.quaternion.__array__(dtype,copy=copy)                                           # type: ignore[arg-type]
+        return np.asarray(self.quaternion,dtype) if util.version(np.__version__) < '2.0.0' else \
+               np.asarray(self.quaternion,dtype,copy=copy)
 
 
     def __len__(self: MyType) -> int:
@@ -693,7 +693,7 @@ def misorientation_angle(self: MyType,
     ################################################################################################
     # convert to different orientation representations (numpy arrays)
 
-    def as_quaternion(self) -> np.ndarray:
+    def as_quaternion(self) -> npt.NDArray[np.floating]:
         """
         Represent as unit quaternion.
 
@@ -705,7 +705,7 @@ def as_quaternion(self) -> np.ndarray:
         return self.quaternion.copy()
 
     def as_Euler_angles(self,
-                        degrees: bool = False) -> np.ndarray:
+                        degrees: bool = False) -> npt.NDArray[np.floating]:
         """
         Represent as Bunge Euler angles.
 
@@ -769,7 +769,7 @@ def as_axis_angle(self,
         else:
             return ax
 
-    def as_matrix(self) -> np.ndarray:
+    def as_matrix(self) -> npt.NDArray[np.floating]:
         """
         Represent as rotation matrix.
 
@@ -791,7 +791,7 @@ def as_matrix(self) -> np.ndarray:
         return Rotation._qu2om(self.quaternion)
 
     def as_Rodrigues_vector(self,
-                            compact: bool = False) -> np.ndarray:
+                            compact: bool = False) -> npt.NDArray[np.floating]:
         """
         Represent as Rodrigues–Frank vector with separate axis and angle argument.
 
@@ -823,7 +823,7 @@ def as_Rodrigues_vector(self,
         else:
             return ro
 
-    def as_homochoric(self) -> np.ndarray:
+    def as_homochoric(self) -> npt.NDArray[np.floating]:
         """
         Represent as homochoric vector.
 
@@ -842,7 +842,7 @@ def as_homochoric(self) -> np.ndarray:
         """
         return Rotation._qu2ho(self.quaternion)
 
-    def as_cubochoric(self) -> np.ndarray:
+    def as_cubochoric(self) -> npt.NDArray[np.floating]:
         """
         Represent as cubochoric vector.
 

python/damask/_rotation.py

@@ -126,7 +126,7 @@ def __getitem__(self,
                 (item[0], item[1]) if isinstance(item[0],(slice,np.ndarray)) else \
                 (slice(None,None,None),item)
         sliced = self.data.loc[item_]
-        cols = np.array(sliced.columns if isinstance(sliced,pd.core.frame.DataFrame) else [item_[1]])
+        cols = np.array(sliced.columns if isinstance(sliced,pd.DataFrame) else [item_[1]])
         _,idx = np.unique(cols,return_index=True)
         return self.__class__(shapes={k:self.shapes[k] for k in cols[np.sort(idx)]},
                               data=sliced,

python/damask/_table.py

@@ -717,6 +717,9 @@ def show(self,
         (this includes tensor datasets as they are flattened).
         """
         # See http://compilatrix.com/article/vtk-1 for possible improvements.
+        if os.name == 'posix' and 'DISPLAY' not in os.environ:
+            logger.warning('Found no rendering device')
+            return
         try:
             import wx
             _ = wx.App(False)                                                                       # noqa
@@ -769,8 +772,5 @@ def show(self,
 
         iren = vtkRenderWindowInteractor()
         iren.SetRenderWindow(window)
-        if os.name == 'posix' and 'DISPLAY' not in os.environ:
-            logger.warning('Found no rendering device')
-        else:
-            window.Render()
-            iren.Start()
+        window.Render()
+        iren.Start()

python/damask/_vtk.py

@@ -21,7 +21,7 @@
 import numpy as _np
 import h5py as _h5py
 try:
-    import numba as _nb                                                                             # type: ignore[import-not-found]
+    import numba as _nb                                                                             # type: ignore
 except ImportError:
     _nb = False