irrep 3.2.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.2.0 → irrep-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.2.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.2.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.2.0'
-__version_tuple__ = version_tuple = (3, 2, 0)
+__version__ = version = '3.4.0'
+__version_tuple__ = version_tuple = (3, 4, 0)
 
-__commit_id__ = commit_id = 'g5a82e29d3'
+__commit_id__ = commit_id = 'gfe03a819e'

{irrep-3.2.0 → irrep-3.4.0}/irrep/altermagnetic_transformer.py

@@ -42,27 +42,29 @@ class AltermagneticTransformer:
                 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):
+    def from_gpaw(cls, calculator, symmetrizer_up, nskip_symmetries=0, tol_magmom=1e-4):
         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)
+                                            nskip=nskip_symmetries,
+                                            tol=tol_magmom)
         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])
+            k_new=self.k_intermediate[ikirr], store=False)
         KPtransformed = KPtransformed.get_transformed_copy(
             symmetry_operation=self.alter_symop,
-            k_new=kpoints_up[ikirr].k)
+            k_new=kpoints_up[ikirr].k, store=False)
         # TODO : unify the transformations, using just their product
         return KPtransformed
 
 
-def find_altermagnetic_symmetry(lattice, positions, typat, magmom, nskip=0):
+def find_altermagnetic_symmetry(lattice, positions, typat, magmom, nskip=0,
+                                all=False, tol=1e-4):
     magmom = np.array(magmom)
     assert magmom.ndim == 1, "Magnetic moments must be a 1D array."
     positions = np.array(positions)
@@ -76,15 +78,22 @@ def find_altermagnetic_symmetry(lattice, positions, typat, magmom, nskip=0):
     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
+    if all:
+        symop_list = []
     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):
+        print(f"{magmom_transformed=}, {atommap=}, m-transformed={magmom_transformed + magmom}")
+        if np.allclose(magmom_transformed, -magmom, atol=tol):
             cnt += 1
             if cnt > nskip:
-                return symop
+                if all:
+                    symop_list.append(symop)
+                else:
+                    return symop
+    if all:
+        return symop_list
     else:
         raise ValueError("No altermagnetic symmetry operation found for the given magnetic moments.")

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

@@ -22,14 +22,14 @@ 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
 from .spacegroup_irreps import SpaceGroupIrreps
 from .gvectors import sortIG, calc_gvectors
 from .utility import get_block_indices, get_mapping_irr, grid_from_kpoints, log_message, UniqueListMod1, restore_full_grid, select_irreducible
-
+from .storage import DummyStorage
 try:
     from irreptables.ebrs import load_ebr_data
 except ImportError:
@@ -181,9 +181,10 @@ class BandStructure:
                  efermi=0.0,
                  Ecut=None,
                  kwargs_kpoint=None,
+                 storage=None,
                  **kwargs_parser):
         if len(kwargs_parser) > 0:
-            raise ValueError(f"the following kwargs are not recognized by BandStructure-__init__(): {list(kwargs_parser.keys())}, please use BandStructure.from_???() class methods to parse files instead of calling BandStructure.__init__() directly.")
+            raise ValueError(f"the following kwargs are not recognized by BandStructure-__init__(): {list(kwargs_parser.keys())}, \n If you meant the old API, please use BandStructure.from_???() class methods to parse files instead of calling BandStructure.__init__() directly.")
         self.kpoints = kpoints
         if kpoints_paw is not None:
             self.kpoints_paw = kpoints_paw
@@ -193,6 +194,9 @@ class BandStructure:
         self.efermi = efermi
         self.Ecut = Ecut
         self.kwargs_kpoint = kwargs_kpoint
+        if storage is None:
+            storage = DummyStorage()
+        self.storage = storage
         self.kpoint_getter = kpoint_getter
         self.kpoint_getter_paw = kpoint_getter_paw
         self.kplist = kplist
@@ -525,8 +529,12 @@ class BandStructure:
         spacegroup=None,
         read_kpoints=True,
         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)
@@ -542,6 +550,13 @@ class BandStructure:
                             verbosity=verbosity
                             )
         if read_paw:
+            if isinstance(storage, str):
+                if store_paw:
+                    from .storage import Storage
+                    storage = Storage(storage)
+                else:
+                    from .storage import DummyStorage
+                    storage = DummyStorage()
             spacegroup.set_gpaw(calculator=parser.calculator)
             from irrep.kpoint_gpaw import OverlapPAW
             overlap_paw = OverlapPAW(calc=parser.calculator)
@@ -574,7 +589,8 @@ class BandStructure:
                 from irrep.kpoint_gpaw import KpointGPAW
                 kp_gpaw = KpointGPAW.from_gpaw(calc=calculator_gpaw, ibz_index=ik, ispin=spin_channel,
                                                RecLattice=spacegroup.reciprocal_lattice,
-                                               IBstart=IBstart, IBend=IBend)
+                                               IBstart=IBstart, IBend=IBend,
+                                               storage=storage)
                 return kp_gpaw
         else:
             get_kpoint_paw = None
@@ -582,7 +598,8 @@ class BandStructure:
         bandstr = cls(kplist=kplist_noskip, spacegroup=spacegroup, Ecut=Ecut, mp_grid=mp_grid, efermi=efermi,
                    overlap_paw=overlap_paw if read_paw else None,
                    kpoint_getter_paw=get_kpoint_paw,
-                   kpoint_getter=get_kpoint)
+                   kpoint_getter=get_kpoint,
+                   storage=storage)
         if read_kpoints:
             bandstr.read_all_kpoints()
             if read_paw:

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

@@ -751,7 +751,7 @@ class Kpoint(KpointAbstract):
 
 
 
-    def get_transformed_copy(self, symmetry_operation, k_new=None):
+    def get_transformed_copy(self, symmetry_operation, k_new=None, store=False):
         """
         Get a copy of the k-point transformed by a symmetry operation.
 
@@ -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.2.0 → irrep-3.4.0}/irrep/kpoint_gpaw.py

@@ -1,4 +1,6 @@
 import numpy as np
+
+from irrep.storage import DummyStorage
 from .kpoint import KpointAbstract
 from .utility import cached_einsum
 from .parsers import ParserGPAW
@@ -24,35 +26,33 @@ class KpointGPAW(KpointAbstract):
                  RecLattice=None,
                  atom_positions=None):
         super().__init__(kpt=kpt, num_bands=nbands, RecLattice=RecLattice)
-        self.wavefunction = wavefunction
+        self._wavefunction = wavefunction
         self.proj = proj
         self.nbands = nbands
         self.atom_positions = atom_positions
 
     @classmethod
     def from_gpaw(self, calc, ibz_index, ispin, RecLattice,
-                  IBstart, IBend
+                  IBstart, IBend,
+                  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)])
-        return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=nbands,
+
+        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=IBend - IBstart,
                           RecLattice=RecLattice,
                           atom_positions=atom_positions)
 
+    def get_wavefunction(self):
+        return self._wavefunction.get()
 
-
-    def get_transformed_copy(self, symmetry_operation, k_new):
+    def get_transformed_copy(self, symmetry_operation, k_new, store=False):
         """Get a transformed copy of the KpointGPAW object according to the given symmetry operation.
 
         Args:
@@ -62,21 +62,27 @@ class KpointGPAW(KpointAbstract):
         Returns:
             KpointGPAW: Transformed copy of the KpointGPAW object.
         """
-        new_wavefunction = symmetry_operation.rotate_pseudo_wavefunction(psi_n_grid=self.wavefunction, k_origin=self.k, k_target=k_new)
+        new_wavefunction = symmetry_operation.rotate_pseudo_wavefunction(psi_n_grid=self.get_wavefunction(), k_origin=self.k, k_target=k_new)
         new_proj = symmetry_operation.rotate_projection(self.proj, self.k, k_new)
+        if store:
+            storage = self._wavefunction.storage
+        else:
+            storage = DummyStorage()
+        new_wavefunction = storage.store_array(new_wavefunction)
         return KpointGPAW(kpt=k_new, wavefunction=new_wavefunction, proj=new_proj, nbands=self.nbands,
-                          RecLattice=self.RecLattice, atom_positions=self.atom_positions)
+                          RecLattice=self.RecLattice, atom_positions=self.atom_positions,
+                          )
 
 
 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 = [
@@ -96,9 +102,12 @@ class OverlapPAW:
                 include_pseudo=True,
                 bk=None,
                 ):
-        wf1 = KP1.wavefunction
+        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.wavefunction
+        wf2 = KP2.get_wavefunction()
         proj2 = KP2.proj
         assert wf1.ndim == 4
         assert wf2.ndim == 4
@@ -107,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]
@@ -121,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.2.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.2.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.2.0 → irrep-3.4.0}/irrep/spacegroup.py

@@ -21,10 +21,11 @@ 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, group_numbers, log_message, select_irreducible
+from .utility import BOHR, clean_np_load, group_numbers, log_message, select_irreducible
 from packaging import version
 import os
 
@@ -226,6 +227,27 @@ class SpaceGroup:
                     dic[key] = val
         return dic
 
+    @classmethod
+    def from_dict(cls, dic):
+        """
+        Create a SpaceGroup object from a dictionary.
+        """
+        dic_clean = clean_np_load(dic)
+        return cls(**dic_clean)
+
+    @classmethod
+    def from_npz(cls, file_path):
+        """
+        Create a SpaceGroup object from a .npz file.
+        """
+        return cls.from_dict(np.load(file_path, allow_pickle=True))
+
+    def to_npz(self, file_path):
+        """
+        Save the SpaceGroup object to a .npz file.
+        """
+        np.savez(file_path, **self.as_dict())
+
     @property
     def size(self):
         """
@@ -233,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.
 
@@ -244,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):
@@ -882,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
@@ -913,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)
@@ -933,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):