irrep 3.1.1__tar.gz → 3.2.0__tar.gz

{irrep-3.1.1 → irrep-3.2.0}/.github/workflows/tests.yml

@@ -37,12 +37,6 @@ jobs:
     - name: Install irrep and dependencies
       run: |
         pip install -e .
-    - name: Set PYTHONPATH
-      run: echo "PYTHONPATH=$(pwd):$(pwd)/irreptables" >> $GITHUB_ENV
-    - name: Run tests
-      run: pytest
-      env:
-        PYTHONPATH: ${{ env.PYTHONPATH }}
     - name: pytest
       run: |
-        pytest --color=yes
+        pytest

{irrep-3.1.1 → irrep-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.1.1
+Version: 3.2.0
 Summary: A tool to get symmetry proberties of ab-initio wavefunctions, irreduible representations and more.
 Author-email: "Stepan S. Tsirkin" <stepan.tsirkin@ehu.eus>
 License: GNU General Public License v3 (GPLv3)

{irrep-3.1.1 → irrep-3.2.0}/irrep/__init__.py

@@ -2,4 +2,4 @@ try:
     from ._version import version as __version__
 except ImportError:
     __version__ = "unknown"
-from .parsers.parse_files_bandstructure import parse_files as parse_bandstructure
+from .parsers.parse_files_bandstructure import parse_files as parse_bandstructure  # noqa: F401

{irrep-3.1.1 → irrep-3.2.0}/irrep/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.1.1'
-__version_tuple__ = version_tuple = (3, 1, 1)
+__version__ = version = '3.2.0'
+__version_tuple__ = version_tuple = (3, 2, 0)
 
-__commit_id__ = commit_id = 'g55e0c10c3'
+__commit_id__ = commit_id = 'g5a82e29d3'

irrep-3.2.0/irrep/altermagnetic_transformer.py

@@ -0,0 +1,90 @@
+import numpy as np
+
+from .spacegroup import SpaceGroup
+from .utility import all_close_mod1
+from .symmetry_operation import SymmetryOperation, get_atom_map
+
+
+class AltermagneticTransformer:
+
+    def __init__(self, calculator,
+                 symmetrizer_up,
+                 alter_symop=None,
+                 rotation_latt=None,
+                 translation_latt=None,
+                ):
+        spacegroup_up = symmetrizer_up.spacegroup
+        if alter_symop is None:
+            alter_symop = SymmetryOperation(rot=rotation_latt,
+                                      trans=translation_latt,
+                                      Lattice=spacegroup_up.Lattice,
+                                      spinor=False
+                                      )
+        self.alter_symop = alter_symop
+        self.alter_symop.set_gpaw(calculator)
+        # self.symops = [symop * alter_symop for symop in spacegroup_up.symmetries]
+        self.alter_map = []  # alter_map[i] = j means ki = alter_map_symops[i] * kj
+        self.alter_map_isym = []
+        self.symmetry_operations = []
+        self.k_intermediate = []
+        for kirr in symmetrizer_up.kptirr:
+            kpt_red = symmetrizer_up.kpoints_all[kirr]
+            kpt_red_before_transform = alter_symop.transform_k(kpt_red, inverse=True)
+            for ik, kpt in enumerate(symmetrizer_up.kpoints_all):
+                if all_close_mod1(kpt, kpt_red_before_transform):
+                    self.alter_map.append(symmetrizer_up.kpt2kptirr[ik])
+                    isym = symmetrizer_up.kpt2kptirr_sym[ik]
+                    self.alter_map_isym.append(isym)
+                    self.symmetry_operations.append(symmetrizer_up.spacegroup.symmetries[isym])
+                    self.k_intermediate.append(kpt)
+                    break
+            else:
+                raise RuntimeError(f"No corresponding k-point found for R({kpt_red})={kpt_red_before_transform} out of \n{symmetrizer_up.kpoints_all} under the altermagnetic symmetry operation.")
+
+    @classmethod
+    def from_gpaw(cls, calculator, symmetrizer_up, nskip_symmetries=0):
+        symop = find_altermagnetic_symmetry(lattice=calculator.atoms.cell,
+                                            positions=calculator.atoms.get_scaled_positions(),
+                                            typat=calculator.atoms.get_atomic_numbers(),
+                                            magmom=calculator.get_magnetic_moments(),
+                                            nskip=nskip_symmetries)
+        return cls(calculator, symmetrizer_up, rotation_latt=symop.rotation, translation_latt=symop.translation)
+
+    def get_kpoint_down(self, ikirr, kpoints_up):
+        ik_origin = self.alter_map[ikirr]
+        KPtransformed = kpoints_up[ik_origin].get_transformed_copy(
+            symmetry_operation=self.symmetry_operations[ikirr],
+            k_new=self.k_intermediate[ikirr])
+        KPtransformed = KPtransformed.get_transformed_copy(
+            symmetry_operation=self.alter_symop,
+            k_new=kpoints_up[ikirr].k)
+        # TODO : unify the transformations, using just their product
+        return KPtransformed
+
+
+def find_altermagnetic_symmetry(lattice, positions, typat, magmom, nskip=0):
+    magmom = np.array(magmom)
+    assert magmom.ndim == 1, "Magnetic moments must be a 1D array."
+    positions = np.array(positions)
+    assert positions.ndim == 2 and positions.shape[1] == 3, "Positions must be a 2D array with shape (N, 3)."
+    typat = np.array(typat)
+    assert typat.ndim == 1, "Atom types must be a 1D array."
+    assert len(positions) == len(typat)
+    assert len(positions) == len(magmom), "Number of positions, atom types, and magnetic moments must match."
+
+    spacegroup_nomag = SpaceGroup.from_cell(real_lattice=lattice, positions=positions, typat=typat, include_TR=False)
+    if nskip >= len(spacegroup_nomag.symmetries) // 2:
+        raise ValueError(f"nskip={nskip} is too large for the number of symmetries={len(spacegroup_nomag.symmetries)}.")
+    cnt = 0
+    for symop in spacegroup_nomag.symmetries:
+        atommap, T = get_atom_map(symop, positions)
+        # print (f"Checking symmetry operation: {symop}, {atommap=}, {T=}")
+        assert np.all(typat[atommap] == typat), "Atom types must match under symmetry operation."
+        magmom_transformed = magmom[atommap]
+        print(f"{magmom_transformed=}, {atommap=},")
+        if np.allclose(magmom_transformed, -magmom):
+            cnt += 1
+            if cnt > nskip:
+                return symop
+    else:
+        raise ValueError("No altermagnetic symmetry operation found for the given magnetic moments.")

{irrep-3.1.1 → irrep-3.2.0}/irrep/bandstructure.py

@@ -544,7 +544,7 @@ class BandStructure:
         if read_paw:
             spacegroup.set_gpaw(calculator=parser.calculator)
             from irrep.kpoint_gpaw import OverlapPAW
-            overlap_paw = OverlapPAW(wfs=parser.calculator.wfs)
+            overlap_paw = OverlapPAW(calc=parser.calculator)
 
         NBin, kpred, Lattice, _spinor, typat, positions, EF_in = parser.parse_header()
         if Ecut is None:
@@ -683,11 +683,9 @@ class BandStructure:
             return False
 
         kpt_coords = [parser.get_kpt_coord(ik) for ik in kplist]
-        log_message(f'Input files contain {NK} k-points:\n {kpt_coords}', verbosity, 1)
         kplist_noskip = [ik for ik in kplist if not check_skip(parser.get_kpt_coord(ik))]
 
 
-
         # Set Fermi energy
         if isinstance(EF, str) and EF.lower() == "auto" or EF is None:
             if EF_in is None:
@@ -724,8 +722,10 @@ class BandStructure:
 
 
         # To do: create writer of description for this class
-        log_message((f"Input files contain {NK} k-points and {NBin} bands.\n"
-                     f"Saving {NBout} bands starting from {IBstart + 1} in the output"), verbosity, 1)
+        log_message(f"Wave function file contains total {NK} k-points and {NBin} bands.", verbosity, 1)
+        log_message(f"Saving {len(kpt_coords)} k-points and {NBout} bands in the output.", verbosity, 1)
+        log_message(f'Saving k-points with coordinates: \n {kpt_coords}', verbosity, 2)
+        log_message(f'Saving bands with band indices: {IBstart + 1} to {IBend + 1}', verbosity, 2)
         log_message(f"Energy cutoff in WAVECAR : {Ecut0}", verbosity, 1)
         log_message(f"Energy cutoff reduced to : {Ecut}", verbosity, 1)
 

{irrep-3.1.1 → irrep-3.2.0}/irrep/kpoint_gpaw.py

@@ -1,4 +1,3 @@
-from gpaw.utilities.partition import AtomPartition
 import numpy as np
 from .kpoint import KpointAbstract
 from .utility import cached_einsum
@@ -24,11 +23,10 @@ class KpointGPAW(KpointAbstract):
     def __init__(self, kpt, wavefunction=None, proj=None, nbands=None,
                  RecLattice=None,
                  atom_positions=None):
-        super().__init__(kpt=kpt, num_bands=nbands)
+        super().__init__(kpt=kpt, num_bands=nbands, RecLattice=RecLattice)
         self.wavefunction = wavefunction
         self.proj = proj
         self.nbands = nbands
-        self.RecLattice = RecLattice
         self.atom_positions = atom_positions
 
     @classmethod
@@ -39,8 +37,8 @@ class KpointGPAW(KpointAbstract):
         kpt = calc.wfs.kpt_qs[ibz_index][ispin]
         k = calc.get_ibz_k_points()[ibz_index]
         nbands = IBend - IBstart
-        proj = new_paw_projection(kpt.projections, nbands=nbands)
-        proj.array[:] = kpt.projections.array[IBstart:IBend]
+        proj = np.hstack([kpt.P_ani[a][IBstart:IBend] for a in range(len(calc.wfs.setups))])
+
         # Get projections in ibz
         if RecLattice is None:
             RecLattice = calc.wfs.gd.reciprocal_lattice
@@ -48,7 +46,10 @@ class KpointGPAW(KpointAbstract):
 
         wavefunction = np.array([calc.wfs.get_wave_function_array(n, ibz_index, ispin, periodic=True)
                                  for n in range(IBstart, IBend)])
-        return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=nbands, RecLattice=RecLattice, atom_positions=atom_positions)
+        return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=nbands,
+                          RecLattice=RecLattice,
+                          atom_positions=atom_positions)
+
 
 
     def get_transformed_copy(self, symmetry_operation, k_new):
@@ -69,15 +70,27 @@ class KpointGPAW(KpointAbstract):
 
 class OverlapPAW:
 
-    def __init__(self, wfs):
+    def __init__(self, calc, get_soc=True):
+
         self.dO_aii = {}
-        for a in wfs.kpt_u[0].projections.map:
-            self.dO_aii[a] = np.copy(wfs.setups[a].dO_ii)
-        self.dv = np.copy(wfs.gd.dv)
+        for a, setup in enumerate(calc.wfs.setups):
+            self.dO_aii[a] = np.copy(setup.dO_ii)
+        self.orb_atom_indices = np.cumsum([0] + [dO.shape[0] for dO in self.dO_aii.values()])
+        self.dv = np.copy(calc.wfs.gd.dv)
+        if get_soc:
+            from gpaw.spinorbit import soc
+            self.dVL_avii = [
+                soc(calc.wfs.setups[a], calc.hamiltonian.xc, calc.density.D_asp[a])
+                for a in range(len(calc.wfs.setups))]
+
         # print ("Initialized PAW overlap with dO_ii for atoms", list(self.dO_aii.keys()))
         # print ("dO_ii shapes", {a: dO.shape for a, dO in self.dO_aii.items()})
         # print ("dv", self.dv)
 
+    def get_orb_indices_on_atom(self, atom_index):
+        """Get the orbital indices corresponding to a specific atom index."""
+        return self.orb_atom_indices[[atom_index, atom_index + 1]]
+
     def product(self, KP1, KP2,
                 include_paw=True,
                 include_pseudo=True,
@@ -101,23 +114,18 @@ class OverlapPAW:
             else:
                 phases = np.exp(-2j * np.pi * (positions @ bk))
             for a, dO_ii in self.dO_aii.items():
-                prod += (proj1[a].conj() @ dO_ii @ (proj2[a].T)) * phases[a]
+                I1, I2 = self.get_orb_indices_on_atom(a)
+                prod += (proj1[:, I1:I2].conj() @ dO_ii @ (proj2[:, I1:I2].T)) * phases[a]
         return prod
 
 
-
-class AtomPartitionSerial(AtomPartition):
-    def __init__(self, at_part):
-        self.comm = None
-        self.rank_a = None
-        self.my_indices = at_part.my_indices
-        self.natoms = at_part.natoms
-        self.name = "serial"
-
-
-def new_paw_projection(proj,
-                       **kwargs):
-    ap = AtomPartitionSerial(proj.atom_partition)
-    new_projection = proj.new(bcomm=None, atom_partition=ap, **kwargs)
-    new_projection.atom_partition = ap
-    return new_projection
+    def soc(self, KP1, KP2):
+        from ase.units import Hartree
+        dVsoc = np.zeros((3, KP1.nbands, KP2.nbands), dtype=complex)
+        for a, dVL_vii in enumerate(self.dVL_avii):
+            I1, I2 = self.get_orb_indices_on_atom(a)
+            P1_mi = KP1.proj[:, I1:I2].conj()
+            P2_mi = KP2.proj[:, I1:I2].T
+            for t in range(3):
+                dVsoc[t] += P1_mi @ dVL_vii[t] @ P2_mi
+        return dVsoc * Hartree

{irrep-3.1.1 → irrep-3.2.0}/irrep/parsers/espresso.py

@@ -28,8 +28,7 @@ class ParserEspresso(ParserCommon):
         self.recip_lattice_alat_inv = np.linalg.inv(recip_lattice_alat)
 
     def parse_header(self, spin_channel=None):
-        Ecut0 = float(self.input.find("basis").find("ecutwfc").text)
-        Ecut0 *= Hartree_eV
+        Ecut0 = float(self.input.find("basis").find("ecutwfc").text) * Hartree_eV
         NK = len(self.bandstr.findall("ks_energies"))
 
         self.spin_channel = spin_channel
@@ -123,8 +122,7 @@ class ParserEspresso(ParserCommon):
             NBin = self.NBin_list[0]
 
         if getE:
-            Energy = np.array(kptxml.find("eigenvalues").text.split(), dtype=float)[NB_skip: NB_skip + NBin]
-            Energy *= Hartree_eV
+            Energy = np.array(kptxml.find("eigenvalues").text.split(), dtype=float)[NB_skip: NB_skip + NBin] * Hartree_eV
         else:
             Energy = None
         npw = int(kptxml.find("npw").text)

{irrep-3.1.1 → irrep-3.2.0}/irrep/parsers/gpaw.py

@@ -158,11 +158,10 @@ def get_soc_gpaw(calc, ik, flatten=True, theta=0, phi=0):
                     P2_mi = calc.wfs.kpt_qs[q][0].P_ani[a]
 
                 h_soc[s1, s2] += np.dot(np.dot(P1_mi.conj(), h_ii), P2_mi.T)
-    h_soc[:] *= Hartree
     if flatten:
         h_soc_old = h_soc.copy()
         h_soc = np.zeros((2 * m, 2 * m), complex)
         for s1 in range(2):
             for s2 in range(2):
                 h_soc[s1::2, s2::2] = h_soc_old[s1, s2]
-    return h_soc
+    return h_soc * Hartree

{irrep-3.1.1 → irrep-3.2.0}/irrep/spacegroup.py

@@ -30,6 +30,8 @@ import os
 
 from pyxtal import Group
 from sympy import Matrix, sympify
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
+
 
 
 class SpaceGroup:
@@ -877,6 +879,7 @@ class SpaceGroup:
                   mag_symprec=0.05,
                   typat=None,
                   magmom=None,
+                  magnetic=True,
                   spinor=None,
                   verbosity=0,
                   **kwargs_cell):
@@ -908,9 +911,12 @@ class SpaceGroup:
         lattice = calculator.atoms.cell
         if typat is None:
             typat = calculator.atoms.get_atomic_numbers()
-            if magmom is None:
-                magmom = calculator.get_magnetic_moments()
-                assert magmom.shape == (len(calculator.atoms),)
+            if magnetic:
+                if magmom is None:
+                    magmom = calculator.get_magnetic_moments()
+                    assert magmom.shape == (len(calculator.atoms),)
+            else:
+                magmom = np.zeros(len(calculator.atoms), dtype=float)
             magmom = group_numbers(magmom, precision=mag_symprec)
             magmom_set = set(magmom)
             if len(magmom_set) > 1:
@@ -1055,7 +1061,8 @@ class SpaceGroup:
         for sim_vector in conventional_wyckoffs:
 
             # sim_vector is a string on array shape change to numeric or simbolic
-            vector = Matrix([sympify(v) for v in sim_vector.split(',')])
+            _TRANSFORMS = standard_transformations + (implicit_multiplication_application,)
+            vector = Matrix([parse_expr(v, transformations=_TRANSFORMS) for v in sim_vector.split(',')])
             wyckoff_new_base = inv_transformation_matrix * (vector - origin_shift)
 
             # Change to string again
@@ -1067,6 +1074,32 @@ class SpaceGroup:
         return wyckoffs_in_cell_base
 
 
+    def get_transformed_group_index(self, symmetry_operation):
+        """
+        calculates the operations S^-1*g*S for a given symmetry operation S and each symmetry operation g in the group. Returns the index of the transformed operation in the group.
+        Also returns the translation difference between the transformed operation and the corresponding operation in the group.
+        """
+        transformed_group_index = []
+        translation_difference = []
+        symmetry_operation_inv = symmetry_operation.inverse(mod1=False)
+        for sym in self.symmetries:
+            transformed_sym = symmetry_operation_inv.multiply_keeptransl(sym).multiply_keeptransl(symmetry_operation)
+            sym.show()
+            transformed_sym.show()
+            for i, sym2 in enumerate(self.symmetries):
+                if transformed_sym.equals(sym2, mod1=True) and transformed_sym.time_reversal == sym2.time_reversal:
+                    transl_diff = transformed_sym.translation - sym2.translation
+                    transl_diff_int = np.round(transl_diff).astype(int)
+                    if np.allclose(transl_diff, transl_diff_int):
+                        transformed_group_index.append(i)
+                        translation_difference.append(transl_diff_int)
+                        break
+            else:
+                raise ValueError(f"Transformed symmetry operation {transformed_sym.str()} not found in the group")
+        return np.array(transformed_group_index), np.array(translation_difference).astype(int)
+
+
+
 def read_sym_file(fname):
     """
     Read symmetry operations from a file.

{irrep-3.1.1 → irrep-3.2.0}/irrep/symmetry_operation.py

@@ -91,7 +91,10 @@ class SymmetryOperation():
                  positions=None,
                  translation_mod1=True, spinor_rotation=None):
         self.ind = ind
-        self.rotation = rot
+        rot_int = np.array(rot.round(), dtype=int)
+        if not np.allclose(rot, rot_int, atol=1e-6):
+            raise ValueError(f"Rotation matrix is not integer: {rot}")
+        self.rotation = rot_int
         self.positions = positions
         self.time_reversal = bool(time_reversal)
         self.real_lattice = Lattice
@@ -111,7 +114,7 @@ class SymmetryOperation():
             self.spinor_rotation = spinor_rotation
         self.sign = 1  # May be changed later externally
 
-    def inverse(self):
+    def inverse(self, mod1=None):
         """
         Create the inverse symmetry operation.
 
@@ -120,7 +123,7 @@ class SymmetryOperation():
         SymmetryOperation
             A new instance of the symmetry operation representing the inverse.
         """
-        rot_inv = np.linalg.inv(self.rotation)
+        rot_inv = self.rotation_inv
         trans_inv = -rot_inv @ self.translation
         spinor_rot_inv = self.spinor_rotation.conj().T
         if self.time_reversal:
@@ -132,7 +135,7 @@ class SymmetryOperation():
                                  time_reversal=self.time_reversal,
                                  ind=self.ind,
                                  spinor=self.spinor,
-                                 translation_mod1=self.translation_mod1,
+                                 translation_mod1=self.translation_mod1 if mod1 is None else mod1,
                                  spinor_rotation=spinor_rot_inv)
 
     def __mul__(self, other):
@@ -216,6 +219,12 @@ class SymmetryOperation():
             return False
         return True
 
+    @cached_property
+    def rotation_inv(self):
+        rotinv = np.linalg.inv(self.rotation)
+        rotinv_int = np.array(rotinv.round(), dtype=int)
+        assert np.allclose(rotinv, rotinv_int, atol=1e-6), f"Inverse Rotation matrix is not integer: {rotinv}"
+        return rotinv_int
 
     @property
     def lattice(self):
@@ -458,18 +467,18 @@ class SymmetryOperation():
             ]
             rotstr = [r + r1 for r, r1 in zip(rotstr, rotstr1)]
 
-        matrix = np.transpose(np.linalg.inv(self.rotation))
+        matrix = self.rotation_inv.T
         if self.time_reversal:
-            matrix *= -1
+            matrix = -matrix
         kstring = "gk = [" + ", ".join(
             [parse_row_transform(r) for r in matrix]
         ) + "]"
 
 
         if write_ref:
-            matrix = np.transpose(np.linalg.inv(R))
+            matrix = np.linalg.inv(R).T
             if self.time_reversal:
-                matrix *= -1
+                matrix = -matrix
             kstring += "  |   refUC:  gk = [" + ", ".join(
                 [parse_row_transform(r) for r in matrix]
             ) + "]"
@@ -655,7 +664,7 @@ class SymmetryOperation():
 
         return d
 
-    def transform_r(self, vector, inverse=False):
+    def transform_r(self, vector, inverse=False, translation=True):
         """
         Transform a real-space vector (in lattice coordinates) under the symmetry operation.
 
@@ -670,9 +679,15 @@ class SymmetryOperation():
             Transformed vector.
         """
         if inverse:
-            return (np.array(vector) - self.translation[..., :]).dot(self.rotation_inv.T)
+            result = np.array(vector)
+            if translation:
+                result -= self.translation[..., :]
+            return result.dot(self.rotation_inv.T)
         else:
-            return np.array(vector).dot(self.rotation.T) + self.translation[..., :]
+            result = np.array(vector).dot(self.rotation.T).astype(float)
+            if translation:
+                result += self.translation[..., :]
+            return result
 
 
     @cached_property
@@ -702,14 +717,6 @@ class SymmetryOperation():
     def det(self):
         return np.linalg.det(self.rotation)
 
-
-    @cached_property
-    def rotation_inv(self):
-        rotinv = np.linalg.inv(self.rotation)
-        rotinv_int = np.array(rotinv.round(), dtype=int)
-        assert np.allclose(rotinv, rotinv_int, atol=1e-6), f"Inverse Rotation matrix is not integer: {rotinv}"
-        return rotinv_int
-
     @cached_property
     def spinor_rotation_TR(self):
         """
@@ -862,6 +869,7 @@ class SymmetryOperation():
             symmetry = SymmetryGpaw1(self)
             R_aii = AtomRotations(setups.setups, setups.id_a, symmetry).get_R_asii()
             self.R_aii = [R_ii[0] for R_ii in R_aii]  # remove unnecessary nesting
+            self.orb_atom_indices = np.cumsum([0] + [R.shape[0] for R in self.R_aii])
 
     # def get_U_aii_gpaw(self, kpoint):
     #     """Phase corrected rotation matrices for the PAW projections."""
@@ -896,16 +904,17 @@ class SymmetryOperation():
         proj_rot : Projections
             the rotated projection coefficients
         """
-        from .kpoint_gpaw import new_paw_projection
-        mapped_projections = new_paw_projection(projections)
-
+        # from .kpoint_gpaw import new_paw_projection
+        mapped_projections = np.zeros_like(projections)
         for a, R_ii in enumerate(self.R_aii):
-            Pout_ni = (projections[a] @ R_ii.T)  # * np.exp(2j * np.pi * k_target @ self.atom_map_T[a])
+            b = self.atom_map[a]
+            I1, I2 = self.orb_atom_indices[ [a, a + 1]]
+            J1, J2 = self.orb_atom_indices[ [b, b + 1]]
+            Pout_ni = (projections[:, I1:I2] @ R_ii.T)  # * np.exp(2j * np.pi * k_target @ self.atom_map_T[a])
             if self.time_reversal:
                 Pout_ni = np.conj(Pout_ni)
             Pout_ni = Pout_ni * np.exp(2j * np.pi * k_target @ self.atom_map_T[a])
-            I1, I2 = mapped_projections.map[self.atom_map[a]]
-            mapped_projections.array[..., I1:I2] = Pout_ni
+            mapped_projections[:, J1:J2] = Pout_ni
         return mapped_projections
 
     def rotate_pseudo_wavefunction(self, psi_n_grid, k_origin, k_target):

irrep-3.2.0/irrep/tests/test_altermagnetic.py

@@ -0,0 +1,26 @@
+import numpy as np
+from pytest import approx
+
+from irrep.altermagnetic_transformer import find_altermagnetic_symmetry
+
+
+def test_find_altermagnetic_symmetry():
+
+    a = 4.134
+    c = 6.652
+    lattice = a * np.array([[1, 0, 0], [-1 / 2, np.sqrt(3) / 2, 0], [0, 0, c / a]])
+    positions = np.array(
+        [
+            [0, 0, 0],
+            [0, 0, 1 / 2],
+            [1 / 3, 2 / 3, 1 / 4],
+            [2 / 3, 1 / 3, 3 / 4],
+        ]
+    )
+    magmom = np.array([1, -1, 0, 0])
+    symop = find_altermagnetic_symmetry(lattice=lattice, positions=positions, typat=[1, 1, 2, 2], magmom=magmom)
+    assert symop.angle == approx(np.pi / 3), f"Expected angle=np.pi/3, got {symop.angle}"
+    assert symop.axis == approx([0, 0, 1]), f"Expected axis=[0, 0, 1], got {symop.axis}"
+    assert symop.translation == approx([0, 0, 0.5]), f"Expected translation=[0, 0, 0.5], got {symop.translation}"
+    assert symop.inversion is False, f"Expected inversion=False, got {symop.inversion}"
+    assert symop.time_reversal is False, f"Expected timereversal=False, got {symop.timereversal}"

{irrep-3.1.1 → irrep-3.2.0}/irrep/tests/test_spacegroup.py

@@ -5,7 +5,8 @@ from irrep.tests.test_dmn import REF_FILES_PATH, TMP_FILES_PATH
 
 from .conftest import REF_DATA_PATH, TMP_DATA_PATH
 from irrep.utility import group_numbers
-
+import sympy
+from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application
 
 a = 4.456
 c = 5.926
@@ -128,5 +129,50 @@ def test_wyckoff_positions():
     return
 
 
-test_conventional_wyckoff_positions()
-test_wyckoff_positions()
+def test_wyckoff_positions_2():
+    """ Test for MnTe, which has a spacegroup containing WP of the form (2x,...,...), which can break the sympify parser """
+    a = 4.17349018
+
+    cell = (
+        np.array([
+            [a, 0, 0],
+            [-a / 2, np.sqrt(3) * a / 2, 0],
+            [0, 0, 6.75345133],
+        ]),
+
+        np.array([
+            [0, 0, 0],
+            [0, 0, 0.5],
+            [1 / 3, 2 / 3, 1 / 4],
+            [2 / 3, 1 / 3, 3 / 4],
+        ]),
+
+        np.array([25, 25, 52, 52]),
+    )
+
+    MnTe_wyckoffs = SpaceGroup.wyckoff_positions(cell)
+
+    first_MnTe_wyckoffs = [
+        [1 / 3, 2 / 3, 0.75],
+        [1 / 3, 2 / 3, 0.25],
+        [0, 0, 0.25],
+        [0, 0, 0],
+    ]
+    print(MnTe_wyckoffs)
+    # Testing the first 4 wp because they are numerical arrays not symbols
+    for i, wp in enumerate(MnTe_wyckoffs[-4:]):
+        numerical_wp = wp.split(',')
+        numerical_wp = [ float(x) for x in numerical_wp]
+        assert np.allclose(numerical_wp, first_MnTe_wyckoffs[i])
+    # checking correct parsing of the symbolic strings
+    assert MnTe_wyckoffs[4].split(',')[1] == '2.0*x'
+    return
+    
+
+def test_implicit_multiplication_parsing():
+    """test lines 1060-1061 of spacegroup.py, which use parse_expr with implicit multiplication"""
+    x, y = sympy.symbols('x y')
+    _TRANSFORMS = standard_transformations + (implicit_multiplication_application,)
+    assert parse_expr('2x', transformations=_TRANSFORMS) == 2 * x
+    assert parse_expr('-2x+1', transformations=_TRANSFORMS) == -2 * x + 1
+    assert parse_expr('2x-y', transformations=_TRANSFORMS) == 2 * x - y

{irrep-3.1.1 → irrep-3.2.0}/irrep.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.1.1
+Version: 3.2.0
 Summary: A tool to get symmetry proberties of ab-initio wavefunctions, irreduible representations and more.
 Author-email: "Stepan S. Tsirkin" <stepan.tsirkin@ehu.eus>
 License: GNU General Public License v3 (GPLv3)

{irrep-3.1.1 → irrep-3.2.0}/irrep.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ uploadpypi.sh
 .github/workflows/tests.yml
 irrep/__init__.py
 irrep/_version.py
+irrep/altermagnetic_transformer.py
 irrep/bandstructure.py
 irrep/cli.py
 irrep/ebrs.py
@@ -42,6 +43,7 @@ irrep/tests/__init__.py
 irrep/tests/conftest.py
 irrep/tests/test_abinit_scalar.py
 irrep/tests/test_abinit_spinor.py
+irrep/tests/test_altermagnetic.py
 irrep/tests/test_dmn.py
 irrep/tests/test_ebr_decomposition.py
 irrep/tests/test_espresso_hdf5.py