irrep 3.2.0__tar.gz → 3.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.2.0
+Version: 3.3.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.3.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.3.0'
+__version_tuple__ = version_tuple = (3, 3, 0)
 
-__commit_id__ = commit_id = 'g5a82e29d3'
+__commit_id__ = commit_id = 'g4f43f138d'

{irrep-3.2.0 → irrep-3.3.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.3.0}/irrep/bandstructure.py

@@ -29,7 +29,7 @@ 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,6 +529,8 @@ class BandStructure:
         spacegroup=None,
         read_kpoints=True,
         read_paw=False,
+        store_paw=True,
+        storage="tmp_irrep_storage",
         **kwargs
     ):
 
@@ -542,6 +548,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 +587,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 +596,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.3.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.
 

{irrep-3.2.0 → irrep-3.3.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,14 +26,15 @@ 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
                   ):
         ispin = ParserGPAW.spin_channels[ispin]
         kpt = calc.wfs.kpt_qs[ibz_index][ispin]
@@ -46,13 +49,16 @@ class KpointGPAW(KpointAbstract):
 
         wavefunction = np.array([calc.wfs.get_wave_function_array(n, ibz_index, ispin, periodic=True)
                                  for n in range(IBstart, IBend)])
+        wavefunction = storage.store_array(wavefunction)
+
         return KpointGPAW(kpt=k, wavefunction=wavefunction, proj=proj, nbands=nbands,
                           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,10 +68,16 @@ 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:
@@ -96,9 +108,9 @@ class OverlapPAW:
                 include_pseudo=True,
                 bk=None,
                 ):
-        wf1 = KP1.wavefunction
+        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

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

@@ -24,7 +24,7 @@ import spglib
 from irrep.parsers import ParserAbinit, ParserEspresso, ParserVasp, ParserW90
 
 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 +226,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):
         """

irrep-3.3.0/irrep/storage.py

@@ -0,0 +1,69 @@
+import os
+import numpy as np
+from warnings import warn
+
+
+class Storage:
+
+    def __init__(self, path):
+        self.path = path
+        os.makedirs(path, exist_ok=True)
+        self.files = os.listdir(path)
+
+    def generate_name(self, name=None):
+        """generates a unique name for storing an array"""
+        if name is None:
+            name = "array"
+        existing_files = set(self.files)
+        i = 0
+        while True:
+            name_loc = f"{name}{f"_{i}" if i > 0 else ''}.npy"
+            if name_loc not in existing_files:
+                return name_loc
+            i += 1
+
+    def store_array(self, array, name=None, ignore_existing=False):
+        name = self.generate_name(name)
+        if os.name in self.files and not ignore_existing:
+            warn(f"File {name} already exists in storage {self.path}. Overwriting.")
+        path = os.path.join(self.path, name)
+        np.save(path, array)
+        self.files.append(name)
+        return StoredArray(name=name, storage=self)
+
+
+    def get_array(self, name):
+        if name not in self.files:
+            raise FileNotFoundError(f"File {name} not found in storage {self.path}.")
+        return np.load(os.path.join(self.path, name))
+
+
+class DummyStorage(Storage):
+
+    def __init__(self, path=None):
+        self.arrays = {}
+        self.files = []
+
+    def store_array(self, array, name=None, ignore_existing=False):
+        if name is None:
+            name = f"array_{len(self.arrays)}"
+        if name in self.arrays and not ignore_existing:
+            warn(f"Array {name} already exists in storage. Overwriting.")
+        self.arrays[name] = array
+        self.files.append(name)
+        return StoredArray(name=name, storage=self)
+
+    def get_array(self, name):
+        if name not in self.arrays:
+            raise KeyError(f"Array {name} not found in storage.")
+        return self.arrays[name]
+
+
+class StoredArray:
+
+    def __init__(self, name, storage):
+        self.name = name
+        self.storage = storage
+
+    def get(self):
+        return self.storage.get_array(self.name)

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

@@ -280,8 +280,11 @@ class SymmetryOperation():
 
     @cached_property
     def is_identity(self):
-        return np.allclose(self.rotation, np.eye(3)) and np.allclose(self.translation, 0) and not self.time_reversal and not self.inversion
+        return self.is_identity_space and not self.time_reversal
 
+    @cached_property
+    def is_identity_space(self):
+        return np.allclose(self.rotation, np.eye(3)) and np.allclose(self.translation, 0)
 
     def _get_operation_type(self):
         """

{irrep-3.2.0 → irrep-3.3.0}/irrep/tests/test_gpaw.py

@@ -1,3 +1,5 @@
+import pickle
+
 from gpaw import GPAW
 import numpy as np
 import pytest
@@ -66,3 +68,31 @@ def test_gpaw_spinorbit(spinor):
         for k in irr:
             if abs(irr[k]) > 1e-3:
                 assert k in irref, f"at energy {E}, extra irrep {k}({irr[k]}) found in calculated irreps {irr}, not in reference {irref}"
+
+
+
+def test_gpaw_storage():
+    calc = GPAW(f"{TEST_FILES_PATH}/gpaw/Bi-gamma.gpw")
+
+    print("Fermi level", calc.get_fermi_level())
+    bandstructure = BandStructure.from_gpaw(calculator_gpaw=calc,
+                                  IBstart=10,
+                                  IBend=15,
+                                  Ecut=50,
+                                  degen_thresh=2e-4,
+                                  calculate_traces=True,
+                                  irreps=True,
+                                  read_paw=True,
+                                  search_cell=True,
+                                  store_paw=True,
+                                  kplist=[0])
+    output_file = f"{TEST_FILES_PATH}/gpaw/Bi-gamma_bandstructure_tmp.pickle"
+    bandstructure.pickle(output_file)
+    bandstructure2 = pickle.load(open(output_file, "rb"))
+    assert len(bandstructure.kpoints_paw) == len(bandstructure2.kpoints_paw), "Number of k-points in bandstructure and loaded bandstructure do not match."
+    assert len(bandstructure.kpoints) > 0, "No k-points found in bandstructure."
+    for kp1, kp2 in zip(bandstructure.kpoints_paw, bandstructure2.kpoints_paw):
+        assert np.allclose(kp1.get_wavefunction(), kp2.get_wavefunction()), f"Wavefunctions differ for k-point {kp1.k} and {kp2.k}"
+        assert np.allclose(kp1.proj, kp2.proj), f"Projections differ for k-point {kp1.k} and {kp2.k}"
+    bandstructure.spacegroup.show()
+    bandstructure.identify_irreps(kpnames=["GM"], verbosity=0)

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

@@ -1,5 +1,6 @@
 from irrep.spacegroup import SpaceGroup
 import numpy as np
+import pytest
 
 from irrep.tests.test_dmn import REF_FILES_PATH, TMP_FILES_PATH
 
@@ -167,7 +168,7 @@ def test_wyckoff_positions_2():
     # 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"""
@@ -176,3 +177,22 @@ def test_implicit_multiplication_parsing():
     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
+
+
+@pytest.mark.parametrize("include_TR", [True, False])
+def test_spacegroup_save_load(include_TR):
+    spacegroup_Te = SpaceGroup.from_cell(**struct_param_Te,
+                                         include_TR=include_TR)
+    tmp_file_path = TMP_DATA_PATH / "spacegroup_Te_TR={}.npz".format(include_TR)
+    print(f"spinor : {spacegroup_Te.spinor}, include_TR: {include_TR}")
+    np.savez(tmp_file_path, **spacegroup_Te.as_dict())
+    spacegroup_Te_loaded = SpaceGroup.from_npz(tmp_file_path)
+    for key in spacegroup_Te.__dict__:
+        type_key = type(spacegroup_Te.__dict__[key])
+        assert type_key == type(spacegroup_Te_loaded.__dict__[key]), f"Type mismatch in attribute {key}, saved {type(getattr(spacegroup_Te, key))}, loaded {type(getattr(spacegroup_Te_loaded, key))}"
+        if key in ['real_lattice', 'positions', 'typat', 'magmom', 'number', 'number_str']:
+            if type_key == np.ndarray:
+                assert np.allclose(getattr(spacegroup_Te, key), getattr(spacegroup_Te_loaded, key)), f"Value mismatch in attribute {key}, saved {getattr(spacegroup_Te, key)}, loaded {getattr(spacegroup_Te_loaded, key)}"
+            else:
+                assert getattr(spacegroup_Te, key) == getattr(spacegroup_Te_loaded, key), f"Value mismatch in attribute {key}, saved {getattr(spacegroup_Te, key)}, loaded {getattr(spacegroup_Te_loaded, key)}"
+    assert spacegroup_Te.equals(spacegroup_Te_loaded), "Loaded spacegroup is not equal to the original"

{irrep-3.2.0 → irrep-3.3.0}/irrep/utility.py

@@ -798,3 +798,14 @@ class DummyMethodTables(DummyMethod):
         message = f"{method_name} requires irreptables package to be installed. " \
             f"Please install irreptables>=3.0.0 via pip: pip install irreptables"
         super().__init__(message)
+
+
+def clean_np_load(dict):
+    """converts zero-dimensional np.ndarray to python scalars"""
+    dict_new = {}
+    for key, val in dict.items():
+        if isinstance(val, np.ndarray) and val.ndim == 0:
+            dict_new[key] = val.item()
+        else:
+            dict_new[key] = val
+    return dict_new

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: irrep
-Version: 3.2.0
+Version: 3.3.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.3.0}/irrep.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ irrep/kpoint_gpaw.py
 irrep/or_solutions_obtainer.py
 irrep/spacegroup.py
 irrep/spacegroup_irreps.py
+irrep/storage.py
 irrep/symmetry_operation.py
 irrep/utility.py
 irrep.egg-info/PKG-INFO

{irrep-3.2.0 → irrep-3.3.0}/irrep.egg-info/scm_file_list.json

@@ -222,6 +222,7 @@
     "irrep/parsers/wannier90.py",
     "irrep/spacegroup.py",
     "irrep/spacegroup_irreps.py",
+    "irrep/storage.py",
     "irrep/symmetry_operation.py",
     "irrep/tests/__init__.py",
     "irrep/tests/conftest.py",

irrep-3.3.0/irrep.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "3.3.0",
+  "distance": 0,
+  "node": "g4f43f138d30ef37a499a297ac9b1ec8ef14717cc",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-02"
+}

irrep-3.2.0/irrep.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "3.2.0",
-  "distance": 0,
-  "node": "g5a82e29d3f389776627e6a5438b745c2ee5cd48a",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-13"
-}