irrep 3.3.0__tar.gz → 3.4.0__tar.gz

irrep-3.4.0/.github/workflows/tests.yml

@@ -0,0 +1,46 @@
+name: tests
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  build:
+    strategy:
+      max-parallel: 20
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: ["3.13"]
+        gpaw-version: ["25.7", "26"]
+
+    runs-on: ${{ matrix.os }}
+
+    defaults:
+      run:
+        shell: bash -el {0}   # needed so the conda env is activated in every step
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up conda
+      uses: conda-incubator/setup-miniconda@v3
+      with:
+        python-version: ${{ matrix.python-version }}
+        channels: conda-forge
+        channel-priority: strict
+        activate-environment: test
+    - name: Install GPAW ${{ matrix.gpaw-version }} from conda-forge
+      run: |
+        conda install -y "gpaw=${{ matrix.gpaw-version }}" pytest
+        python -c "import gpaw; print('GPAW', gpaw.__version__)"
+    - name: Install tables from local repo, not from pypi
+      working-directory: ./irreptables
+      run: pip install -e .
+    - name: Install irrep and dependencies
+      run: pip install -e .
+    - name: pytest
+      run: pytest

{irrep-3.3.0 → irrep-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.3.0
+Version: 3.4.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.3.0 → irrep-3.4.0}/irrep/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.3.0'
-__version_tuple__ = version_tuple = (3, 3, 0)
+__version__ = version = '3.4.0'
+__version_tuple__ = version_tuple = (3, 4, 0)
 
-__commit_id__ = commit_id = 'g4f43f138d'
+__commit_id__ = commit_id = 'gfe03a819e'

{irrep-3.3.0 → irrep-3.4.0}/irrep/bandstructure.py

@@ -22,7 +22,7 @@ import functools
 import numpy as np
 from functools import cached_property
 
-
+from .parsers.gpaw import check_legacy_gpaw
 from .parsers import ParserAbinit, ParserVasp, ParserEspresso, ParserW90, ParserGPAW
 from .kpoint import Kpoint
 from .spacegroup import SpaceGroup
@@ -531,8 +531,10 @@ class BandStructure:
         read_paw=False,
         store_paw=True,
         storage="tmp_irrep_storage",
+        legacy_gpaw=None,
         **kwargs
     ):
+        legacy_gpaw = check_legacy_gpaw(legacy_gpaw, calculator_gpaw)
 
         if spacegroup is None:
             cls_spacegroup, kwargs_spacegroup = cls.get_spacegroup_cls(spin_channel=spin_channel, irreps=irreps, **kwargs)

{irrep-3.3.0 → irrep-3.4.0}/irrep/kpoint.py

@@ -1010,8 +1010,6 @@ class Kpoint(KpointAbstract):
         igmax = igall.max(axis=0)
         igmin = igall.min(axis=0)
         igsize = igmax - igmin + 1
-        #        print (self.ig.T)
-        #        print (igsize)
         res = np.zeros((self.num_bands, other.num_bands), dtype=complex)
 
         # short again coefficients of expansions

{irrep-3.3.0 → irrep-3.4.0}/irrep/kpoint_gpaw.py

@@ -34,24 +34,18 @@ class KpointGPAW(KpointAbstract):
     @classmethod
     def from_gpaw(self, calc, ibz_index, ispin, RecLattice,
                   IBstart, IBend,
-                  storage
+                  storage, legacy_gpaw=None
                   ):
+        from .parsers.gpaw import read_gpaw_wf
         ispin = ParserGPAW.spin_channels[ispin]
-        kpt = calc.wfs.kpt_qs[ibz_index][ispin]
-        k = calc.get_ibz_k_points()[ibz_index]
-        nbands = IBend - IBstart
-        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
-        atom_positions = calc.atoms.get_scaled_positions()
-
-        wavefunction = np.array([calc.wfs.get_wave_function_array(n, ibz_index, ispin, periodic=True)
-                                 for n in range(IBstart, IBend)])
+
+        k, proj, wavefunction, RecLattice, atom_positions = read_gpaw_wf(
+            calc=calc, ibz_index=ibz_index, ispin=ispin, IBstart=IBstart, IBend=IBend, RecLattice=RecLattice,
+            legacy_gpaw=legacy_gpaw)
+
         wavefunction = storage.store_array(wavefunction)
 
-        return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=nbands,
+        return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=IBend - IBstart,
                           RecLattice=RecLattice,
                           atom_positions=atom_positions)
 
@@ -83,12 +77,12 @@ class KpointGPAW(KpointAbstract):
 class OverlapPAW:
 
     def __init__(self, calc, get_soc=True):
-
         self.dO_aii = {}
         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)
+        from ase.units import Bohr
+        self.dv = np.copy(calc.wfs.gd.dv) * Bohr ** 3
         if get_soc:
             from gpaw.spinorbit import soc
             self.dVL_avii = [
@@ -108,6 +102,9 @@ class OverlapPAW:
                 include_pseudo=True,
                 bk=None,
                 ):
+        if bk is None:
+            bk = np.zeros(3)
+        assert np.allclose(KP2.k - KP1.k, bk), f"K-points must differ by bk for overlap calculation, but KP1={KP1.k}, KP2={KP2.k}, KP2.k - KP1.k = {KP2.k - KP1.k}, bk={bk}"
         wf1 = KP1.get_wavefunction()
         proj1 = KP1.proj
         wf2 = KP2.get_wavefunction()
@@ -119,12 +116,7 @@ class OverlapPAW:
         if include_pseudo:
             prod += cached_einsum('aijk,bijk->ab', wf1.conj(), wf2) * self.dv
         if include_paw:
-            positions = KP1.atom_positions
-            na = len(positions)
-            if bk is None:
-                phases = np.ones(na, dtype=complex)
-            else:
-                phases = np.exp(-2j * np.pi * (positions @ bk))
+            phases = np.exp(-2j * np.pi * (KP1.atom_positions @ bk))
             for a, dO_ii in self.dO_aii.items():
                 I1, I2 = self.get_orb_indices_on_atom(a)
                 prod += (proj1[:, I1:I2].conj() @ dO_ii @ (proj2[:, I1:I2].T)) * phases[a]
@@ -133,6 +125,7 @@ class OverlapPAW:
 
     def soc(self, KP1, KP2):
         from ase.units import Hartree
+        assert np.allclose(KP1.k, KP2.k), "K-points must be at the same coordinate for SOC calculation"
         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)

{irrep-3.3.0 → irrep-3.4.0}/irrep/parsers/espresso.py

@@ -135,7 +135,6 @@ class ParserEspresso(ParserCommon):
             checked_files = []
             for extension in ["hdf5", "dat"]:
                 for strcase in [str.lower, str.upper]:
-                    print(f"{ik=}, {wfcname=}, {extension=}, {strcase=}")
                     filename = f"{self.prefix}.save/{strcase(wfcname)}.{extension}"
                     if os.path.exists(filename):
                         if extension == "hdf5":

{irrep-3.3.0 → irrep-3.4.0}/irrep/parsers/gpaw.py

@@ -103,11 +103,12 @@ class ParserGPAW(ParserCommon):
         return energies, WFout, kg, kpt, eKG
 
 
-def get_soc_gpaw(calc, ik, flatten=True, theta=0, phi=0):
+def get_soc_gpaw(calc, ik, flatten=True, theta=0, phi=0, legacy_gpaw=None):
     """Calculate SOC Hamiltonian in KS basis for a given k-point."""
     from ase.units import Hartree
     from gpaw.spinorbit import soc
 
+    legacy_gpaw = check_legacy_gpaw(calc, legacy_gpaw)
     nspin = calc.get_number_of_spins()
 
     C_ss = np.array(
@@ -150,12 +151,21 @@ def get_soc_gpaw(calc, ik, flatten=True, theta=0, phi=0):
         for s1 in range(2):
             for s2 in range(2):
                 h_ii = h_ssii[s1, s2]
-                if nspin == 2:
-                    P1_mi = calc.wfs.kpt_qs[q][s1].P_ani[a]
-                    P2_mi = calc.wfs.kpt_qs[q][s2].P_ani[a]
-                if nspin == 1:
-                    P1_mi = calc.wfs.kpt_qs[q][0].P_ani[a]
-                    P2_mi = calc.wfs.kpt_qs[q][0].P_ani[a]
+                if legacy_gpaw:
+                    if nspin == 2:
+                        P1_mi = calc.wfs.kpt_qs[q][s1].P_ani[a]
+                        P2_mi = calc.wfs.kpt_qs[q][s2].P_ani[a]
+                    else:
+                        P1_mi = calc.wfs.kpt_qs[q][0].P_ani[a]
+                        P2_mi = P1_mi
+                else:
+                    if nspin == 2:
+                        # maybe need to use get_wfs_on_master for parallel runs, but needs testing
+                        P1_mi = calc.dft.ibzwfs._get_wfs(kpt=q, spin=s1).P_ani[a]
+                        P2_mi = calc.dft.ibzwfs._get_wfs(kpt=q, spin=s2).P_ani[a]
+                    else:
+                        P1_mi = calc.dft.ibzwfs._get_wfs(kpt=q, spin=0).P_ani[a]
+                        P2_mi = P1_mi
 
                 h_soc[s1, s2] += np.dot(np.dot(P1_mi.conj(), h_ii), P2_mi.T)
     if flatten:
@@ -165,3 +175,69 @@ def get_soc_gpaw(calc, ik, flatten=True, theta=0, phi=0):
             for s2 in range(2):
                 h_soc[s1::2, s2::2] = h_soc_old[s1, s2]
     return h_soc * Hartree
+
+
+def check_legacy_gpaw(calc, legacy_gpaw=None):
+    if legacy_gpaw is not None:
+        return legacy_gpaw
+    else:
+        return not is_new_gpaw(calc)
+
+
+def is_new_gpaw(calc):
+    # "New GPAW" (default in 26): ASECalculator exposing .dft
+    # Legacy calculator (25.x, or 26 with legacy_gpaw=True): real calc.wfs
+    if hasattr(calc, '_wfs_dft'):
+        return True
+    if hasattr(calc, 'get_realspace_wfs'):
+        return False
+    raise ValueError("Cannot determine if GPAW is new or legacy. Please check the GPAW version and calculator type.")
+
+
+
+def is_collinear(calc):
+    if hasattr(calc, 'dft'):                 # new GPAW (26 default)
+        return calc.dft.ibzwfs.collinear
+    return calc.wfs.collinear
+
+
+def get_magnetic_moments(calc, project_collinear_axis=(0, 0, 1), legacy_gpaw=None):
+    legacy_gpaw = check_legacy_gpaw(calc, legacy_gpaw)
+    if legacy_gpaw:
+        magmoms = calc.get_magnetic_moments()
+    else:
+        magmoms = calc.dft.magmoms()[1]
+        if is_collinear(calc) and project_collinear_axis:
+            magmoms = np.dot(magmoms, project_collinear_axis)
+    return magmoms
+
+
+@staticmethod
+def read_gpaw_wf(calc, ibz_index, ispin, IBstart, IBend, RecLattice, legacy_gpaw=None):
+    legacy_gpaw = check_legacy_gpaw(calc, legacy_gpaw)
+    k = calc.get_ibz_k_points()[ibz_index]
+
+    if legacy_gpaw:
+        P_ani = calc.wfs.kpt_qs[ibz_index][ispin].P_ani
+        if RecLattice is None:
+            RecLattice = calc.wfs.gd.reciprocal_lattice
+        wavefunction = np.array([
+            calc.wfs.get_wave_function_array(n, ibz_index, ispin, periodic=True)
+            for n in range(IBstart, IBend)])
+        from ase.units import Bohr
+        wavefunction /= Bohr ** 1.5
+    else:
+        wfs = calc.dft.ibzwfs._get_wfs(kpt=ibz_index, spin=ispin)
+        P_ani = wfs.P_ani.to_cpu()              # AtomArrays; P_ani[a] -> (nbands, nproj_a)
+        wavefunction = calc.dft.wave_functions(n1=IBstart, n2=IBend, kpt=ibz_index, spin=ispin, periodic=True).data
+        # from ase.units import Bohr
+        # wavefunction *= Bohr ** 1.5
+
+        if RecLattice is None:
+            RecLattice = 2 * np.pi * np.linalg.inv(calc.atoms.cell.array).T  # check units vs 25.7
+
+    proj = np.hstack([P_ani[a][IBstart:IBend] for a in range(len(calc.atoms))])
+
+    atom_positions = calc.atoms.get_scaled_positions()
+
+    return k, proj, wavefunction, RecLattice, atom_positions

{irrep-3.3.0 → irrep-3.4.0}/irrep/spacegroup.py

@@ -21,7 +21,8 @@ import warnings
 import numpy as np
 import spglib
 
-from irrep.parsers import ParserAbinit, ParserEspresso, ParserVasp, ParserW90
+from .parsers import ParserAbinit, ParserEspresso, ParserVasp, ParserW90
+from .parsers.gpaw import get_magnetic_moments
 
 from .symmetry_operation import SymmetryOperation
 from .utility import BOHR, clean_np_load, group_numbers, log_message, select_irreducible
@@ -254,7 +255,7 @@ class SpaceGroup:
         """
         return len(self.symmetries)
 
-    def show(self, symmetries=None):
+    def show(self, symmetries=None, short=False, to_stdout=True):
         """
         Print description of space-group and symmetry operations.
 
@@ -265,27 +266,26 @@ class SpaceGroup:
             Run `IrRep` with flag `onlysym` to check the index corresponding 
             to each symmetry operation.
         """
-
-        print('')
-        print("\n ---------- CRYSTAL STRUCTURE ---------- \n")
-        print('')
-
-        # Print cell vectors in DFT cell only
-        print('Cell vectors in angstroms:\n')
-        print(f"{'Vectors of DFT cell':^32}")
+        out_str = ""
+        if not short:
+            out_str += "\n ---------- CRYSTAL STRUCTURE ---------- \n\n"
+            out_str += 'Cell vectors in angstroms:\n\n'
+        out_str += f'{"Vectors of DFT cell":^32}\n'
         for i in range(3):
             vec1 = self.real_lattice[i]
-            print(f'a{i:d} = {vec1[0]:7.4f}  {vec1[1]:7.4f}  {vec1[2]:7.4f}  ')
-        print()
-
-        print()
-        print('\n ---------- SPACE GROUP ----------- \n')
-        print()
-        print(f'Space group: {self.name} (# {self.number_str})')
-        print(f'Number of symmetries: {self.size} (mod. lattice translations)')
+            out_str += f'a{i:d} = {vec1[0]:7.4f}  {vec1[1]:7.4f}  {vec1[2]:7.4f}  \n'
+        out_str += '\n'
+
+        if not short:
+            out_str += '\n ---------- SPACE GROUP ----------- \n\n'
+        out_str += f'Space group: {self.name} (# {self.number_str})\n'
+        out_str += f'Number of symmetries: {self.size} (mod. lattice translations)\n'
         for symop in self.symmetries:
             if symmetries is None or symop.ind in symmetries:
-                symop.show(refUC=None, shiftUC=None)
+                out_str += symop.show(refUC=None, shiftUC=None, to_stdout=False, short=short) + '\n'
+        if to_stdout:
+            print(out_str)
+        return out_str
 
     @property
     def lattice(self):
@@ -903,6 +903,7 @@ class SpaceGroup:
                   magnetic=True,
                   spinor=None,
                   verbosity=0,
+                  legacy_gpaw=None,
                   **kwargs_cell):
         """Get the spacegroup of a GPAW calculator (non-spinor only).
         Parameters
@@ -934,7 +935,7 @@ class SpaceGroup:
             typat = calculator.atoms.get_atomic_numbers()
             if magnetic:
                 if magmom is None:
-                    magmom = calculator.get_magnetic_moments()
+                    magmom = get_magnetic_moments(calculator, legacy_gpaw=legacy_gpaw)
                     assert magmom.shape == (len(calculator.atoms),)
             else:
                 magmom = np.zeros(len(calculator.atoms), dtype=float)
@@ -954,50 +955,6 @@ class SpaceGroup:
                              **kwargs_cell
                                 )
 
-    # @classmethod
-    # def from_gpaw_magnetic(cls, calculator, theta=0, phi=0, include_TR=True,
-    #                        magmom=None, magmoms=None,
-    #                        mag_symprec=0.05, symprec=1e-5,
-    #                        ):
-    #     """
-    #     Get the spacegroup of a GPAW calculator (spinor magnetic version).
-
-    #     Parameters:
-    #     calculator : GPAW
-    #         The GPAW calculator.
-    #     theta, phi : float
-    #         The angles defining the global spin quantization axis. (in radians)
-    #         magnetic moments will be aligned along that direction (in positive or negative direction, as defined from dft calculation)
-    #     include_TR : bool
-    #         Whether to include time-reversal symmetry.
-    #     magmom : array( Nat, 3), optional
-    #         if provided, overrides the magnetic moments of the calculator
-    #     magmoms : array(Nat,), optional
-    #         The older argument for magmom, kept for backward compatibility. Used only if magmom is None.
-    #     mag_symprec : float
-    #         The precision for distinguishing different magnetic moments. Only used if magmom is None.
-    #     symprec : float
-    #         The symmetry precision for spacegroup detection.
-    #     """
-    #     lattice = calculator.atoms.cell
-    #     typat = calculator.atoms.get_atomic_numbers()
-    #     positions = calculator.atoms.get_scaled_positions()
-    #     if magmom is None:
-    #         magmom = magmoms
-    #     if magmom is None:
-    #         magmom_axis = calculator.get_magnetic_moments()
-    #         magmom_axis = group_numbers(magmom_axis, precision=mag_symprec)
-    #         axis = np.array([np.sin(theta) * np.cos(phi), np.sin(theta) * np.sin(phi), np.cos(theta)])
-    #         magmom = magmom_axis[:, None] * axis[None, :]
-    #     print(f"using magmom \n {magmom}")
-    #     return SpaceGroup.from_cell(real_lattice=lattice,
-    #                             positions=positions,
-    #                             typat=typat,
-    #                             spinor=True,
-    #                             include_TR=include_TR,
-    #                             symprec=symprec,
-    #                             mag_symprec=mag_symprec,
-    #                             magmom=magmom)
 
     @classmethod
     def get_trivial(cls, lattice, spinor=False, time_reversal=False):

{irrep-3.3.0 → irrep-3.4.0}/irrep/symmetry_operation.py

@@ -15,6 +15,7 @@
 ##################################################################
 
 
+from gpaw.rotation import rotation   # rotation(l, U_vv) -> (2l+1, 2l+1)
 from functools import cached_property
 import warnings
 import numpy as np
@@ -397,8 +398,15 @@ class SymmetryOperation():
         S *= self.sign
         return S
 
+    def show_short(self, to_stdout=False):
+        out_str = f"axis: {self.axis.round(6)} ; angle = {self.angle_str}, inversion: {self.inversion}, time reversal: {self.time_reversal}"
+        if to_stdout:
+            print(out_str)
+        return out_str
 
-    def show(self, refUC=np.eye(3), shiftUC=np.zeros(3), U=np.eye(2)):
+
+
+    def show(self, refUC=np.eye(3), shiftUC=np.zeros(3), U=np.eye(2), to_stdout=True, short=False):
         """
         Print description of symmetry operation.
 
@@ -413,7 +421,13 @@ class SymmetryOperation():
         U : array, default=np.zeros(2)
             Unitary transformation of spin quantization axis from spglib's 
             choice to reference cell's choice
+        print : bool, default=True
+            If True, print the description. If False, return it as a string.
+        short : bool, default=False
+            If True, print a short description. If False, print a full description.
         """
+        if short:
+            return self.show_short(to_stdout=to_stdout)
 
         def parse_row_transform(mrow):
             s = ""
@@ -447,7 +461,7 @@ class SymmetryOperation():
             write_ref = False
 
         # Print header
-        print(f"\n ### {self.ind} \n")
+        out_str = f"\n ### {self.ind} \n\n"
 
         # Print rotation part
         rotstr = [
@@ -486,8 +500,7 @@ class SymmetryOperation():
                 [parse_row_transform(r) for r in matrix]
             ) + "]"
 
-        print("\n".join(rotstr))
-        print("\n\n", kstring)
+        out_str += "\n".join(rotstr) + "\n\n" + kstring + "\n"
 
         # Print spinor transformation matrix
         if self.spinor:
@@ -497,28 +510,32 @@ class SymmetryOperation():
                            self.spinor_rotation,
                            [" |", " |"])
             ]
-            print("\n".join(spinstr))
+            out_str += "\n".join(spinstr) + "\n"
             if write_ref:
                 spinstr = [s + " ".join(f"{x.real:6.3f}{x.imag:+6.3f}j" for x in row) + t
                            for s, row, t in zip(["spinor rot. (refUC) : |", " " * 22 + "|",],
                                                 self.spinrotation_refUC(U),
                                                 [" |", " |"])
                             ]
-                print("\n".join(spinstr))
+                out_str += "\n".join(spinstr) + "\n"
 
         # Print translation part
         trastr = ("\ntranslation         :  [ " +
                   " ".join(f"{x:8.4f}" for x in self.get_transl_mod1(self.translation.round(6))) +
                   " ] ")
-        print(trastr)
+        out_str += trastr
 
         if write_ref:
             _t = self.translation_refUC(refUC, shiftUC)
             trastr = f"translation (refUC) :  [ {' '.join(f'{x:8.4f}' for x in self.get_transl_mod1(_t.round(6)))} ] "
-            print(trastr)
+            out_str += trastr
+        out_str += "\n\n"
+        out_str += self.show_short(to_stdout=False) + "\n"
+
+        if to_stdout:
+            print(out_str)
+        return out_str
 
-        print(f"\naxis: {self.axis.round(6)} ; angle = {self.angle_str}, "
-              f"inversion: {self.inversion}, time reversal: {self.time_reversal}")
 
     def copy(self):
         """
@@ -860,24 +877,20 @@ class SymmetryOperation():
     def set_R_aii_gpaw(self, calc, reset=False):
         """rotation matrices for the PAW projections."""
         if not hasattr(self, 'R_aii') or reset:
-            from gpaw.atomrotations import AtomRotations
-            setups = calc.setups
-
-            class SymmetryGpaw1():
-                def __init__(self, symop):
-                    # self.op_scc = symop.rotation[None, :, :]
-                    # self.cell_cv = symop.real_lattice
-                    self.op_scc = symop.rotation_cart[None, :, :]
-                    self.cell_cv = np.eye(3)
-            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
+            """One block-diagonal projector-space rotation matrix per atom."""
+            self.R_aii = []
+            for id_ in calc.setups.id_a:                 # one entry per atom
+                setup = calc.setups.setups[id_]          # dict: id -> Setup
+                n = sum(2 * l + 1 for l in setup.l_j)
+                R = np.zeros((n, n))
+                i = 0
+                for l in setup.l_j:
+                    m = 2 * l + 1
+                    R[i:i + m, i:i + m] = rotation(l, self.rotation_cart)
+                    i += m
+                self.R_aii.append(R)
             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."""
-    #     return [ R_ii.T * np.exp( 2j * np.pi * np.dot(kpoiMax errnt, self.atom_map_T[a])) for a, R_ii in enumerate(self.R_aii)]
-    #     # return [ R_ii.T  for a, R_ii in enumerate(self.R_aii)]  # no phase factor, try this
 
     def set_gpaw(self, calculator):
         """Set all gpaw-related attributes."""

{irrep-3.3.0 → irrep-3.4.0}/irrep/tests/conftest.py

@@ -1,3 +1,5 @@
+from packaging.version import parse, Version
+import gpaw
 from pathlib import Path
 import os
 
@@ -6,3 +8,14 @@ REF_DATA_PATH = Path(__file__).parents[0] / "ref_data"
 TMP_DATA_PATH = Path(__file__).parents[0] / "tmp_data"
 if not os.path.exists(TMP_DATA_PATH):
     os.makedirs(TMP_DATA_PATH)
+
+
+if parse(gpaw.__version__) >= Version("26.0.0"):
+    GPAW_VERSION = 26
+else:
+    GPAW_VERSION = 25
+
+
+CALC_TYPE_LIST = ["OLD"]
+if GPAW_VERSION == 26:
+    CALC_TYPE_LIST += ["NEW", "LEGACY"]