""" PEPS unit cell """ from __future__ import annotations import collections from dataclasses import dataclass import datetime import pathlib from os import PathLike import subprocess import h5py import numpy as np import jax.numpy as jnp from jax.tree_util import register_pytree_node_class from .tensor import ( PEPS_Tensor, PEPS_Tensor_Split_Transfer, PEPS_Tensor_Triangular, PEPS_Type, ) import varipeps from varipeps.utils.random import PEPS_Random_Number_Generator from varipeps.utils.periodic_indices import calculate_periodic_indices from varipeps import varipeps_config import varipeps.config from typing import ( TypeVar, Type, Union, Optional, Sequence, Tuple, List, Any, Iterator, Set, Dict, ) from varipeps.typing import Tensor, is_int T_PEPS_Unit_Cell = TypeVar("T_PEPS_Unit_Cell", bound="PEPS_Unit_Cell") @dataclass @register_pytree_node_class class PEPS_Unit_Cell: """ Class to model a unit cell of a PEPS structure. The structure of the unit cell is modeled by a two dimensional array with the first index corresponding to the x-axis and the second one to the y-axis. The array consists of integer labeling the different unique peps tensors in one unit cell (either starting with 0 or 1). For example for two rows with a AB/BA structure:: structure = [[0, 1], [1, 0]] Args: data (:obj:`Unit_Cell_Data`): Instance of unit cell data class real_ix (:obj:`int`): Which real x index of data.structure correspond to x = 0 of this unit cell instance. real_iy (:obj:`int`): Which real y index of data.structure correspond to y = 0 of this unit cell instance. """ data: PEPS_Unit_Cell.Unit_Cell_Data real_ix: int = 0 real_iy: int = 0 sanity_checks: bool = True @dataclass @register_pytree_node_class class Unit_Cell_Data: """ Class to encapsulate the data of the unit cell which can be shared by more than one instance. Args: peps_tensors (:term:`sequence` of :obj:`PEPS_Tensor`): Sequence with the unique peps tensors structure (2d :obj:`jax.numpy.ndarray`): Two dimensional array modeling the structure of the unit cell. For details see the description of the parent unit cell class. """ peps_tensors: List[PEPS_Tensor] structure: Tuple[Tuple[int, ...], ...] def copy(self) -> PEPS_Unit_Cell.Unit_Cell_Data: """ Creates a (flat) copy of the unit cell data. Returns: ~varipeps.peps.PEPS_Unit_Cell.Unit_Cell_Data: New instance of the unit cell data class. """ return type(self)( peps_tensors=[i for i in self.peps_tensors], structure=self.structure, ) def replace_peps_tensors( self, new_peps_tensors: List[PEPS_Tensor] ) -> PEPS_Unit_Cell.Unit_Cell_Data: """ Return new instance with the list of peps tensors replaced. Returns: ~varipeps.peps.PEPS_Unit_Cell.Unit_Cell_Data: New instance of the unit cell data class with the list replaced. """ return type(self)( peps_tensors=new_peps_tensors, structure=self.structure, ) def save_to_group(self, grp: h5py.Group) -> None: """ Store the unit cell data into a HDF5 group. Args: grp (:obj:`h5py.Group`): HDF5 group object to save the data into. """ grp.create_dataset("structure", data=jnp.asarray(self.structure)) grp_tensors = grp.create_group("peps_tensors", track_order=True) grp_tensors.attrs["len"] = len(self.peps_tensors) for ti, t in enumerate(self.peps_tensors): grp_ti = grp_tensors.create_group(f"t_{ti:d}") t.save_to_group(grp_ti) @classmethod def load_from_group( cls: Type[PEPS_Unit_Cell.Unit_Cell_Data], grp: h5py.Group ) -> PEPS_Unit_Cell.Unit_Cell_Data: """ Load the unit cell data from a HDF5 group. Args: grp (:obj:`h5py.Group`): HDF5 group object to load the data from. """ structure = tuple(tuple(int(j) for j in i) for i in grp["structure"]) try: if grp["peps_tensors"]["t_0"].attrs["is_triangular_peps"]: peps_tensors = [ PEPS_Tensor_Triangular.load_from_group( grp["peps_tensors"][f"t_{ti:d}"] ) for ti in range(grp["peps_tensors"].attrs["len"]) ] else: raise KeyError except KeyError: try: peps_tensors = [ PEPS_Tensor.load_from_group(grp["peps_tensors"][f"t_{ti:d}"]) for ti in range(grp["peps_tensors"].attrs["len"]) ] except KeyError as e: try: peps_tensors = [ PEPS_Tensor_Split_Transfer.load_from_group( grp["peps_tensors"][f"t_{ti:d}"] ) for ti in range(grp["peps_tensors"].attrs["len"]) ] except KeyError: raise e return cls(structure=structure, peps_tensors=peps_tensors) def tree_flatten(self) -> Tuple[Tuple[Any, ...], Tuple[Any, ...]]: return ((self.peps_tensors,), (self.structure,)) @classmethod def tree_unflatten( cls: Type[PEPS_Unit_Cell.Unit_Cell_Data], aux_data: Tuple[Any, ...], children: Tuple[Any, ...], ) -> PEPS_Unit_Cell.Unit_Cell_Data: (peps_tensors,) = children (structure,) = aux_data return cls(structure=structure, peps_tensors=peps_tensors) def __post_init__(self): if not self.sanity_checks or self.data.structure is None: return self._check_structure(self.data.structure) unit_cell_len_x = len(self.data.structure) unit_cell_len_y = len(self.data.structure[0]) if ( not is_int(self.real_ix) or self.real_ix < 0 or self.real_ix >= unit_cell_len_x ): raise ValueError("Invalid value for real x index.") if ( not is_int(self.real_iy) or self.real_iy < 0 or self.real_iy >= unit_cell_len_y ): raise ValueError("Invalid value for real x index.") if not all( self.data.peps_tensors[0].chi == i.chi for i in self.data.peps_tensors[1:] ): raise ValueError("CTMRG bond dimension has to be the same for all tensors.") @staticmethod def _check_structure( structure: Tuple[Tuple[int, ...], ...], ) -> Tuple[Tuple[Tuple[int, ...], ...], jnp.ndarray]: structure = np.array(structure) if structure.ndim != 2 or not np.issubdtype(structure.dtype, np.integer): raise ValueError("Structure is not a 2-d int array.") tensors_i = np.unique(structure) min_i = np.min(tensors_i) if min_i < 0 or min_i > 2: raise ValueError( "Found negative index or minimal index > 1 in unit cell structure" ) if min_i == 1: tensors_i = tensors_i - 1 structure = structure - 1 # type: ignore max_i = np.max(tensors_i) if max_i != (tensors_i.size - 1): raise ValueError("Indices in structure seem to be non-monotonous.") return tuple(tuple(int(j) for j in i) for i in structure), tensors_i @classmethod def from_tensor_list( cls: Type[T_PEPS_Unit_Cell], tensor_list: Sequence[PEPS_Tensor], structure: Union[Sequence[Sequence[int]], Tensor], ) -> T_PEPS_Unit_Cell: structure, tensors_i = cls._check_structure(structure) if tensors_i.size != len(tensor_list): raise ValueError("Structure and tensor list mismatch.") data = cls.Unit_Cell_Data(peps_tensors=list(tensor_list), structure=structure) return cls(data=data) @classmethod def random( cls: Type[T_PEPS_Unit_Cell], structure: Union[Sequence[Sequence[int]], Tensor], d: Union[int, Sequence[int]], D: Union[int, Sequence[Sequence[int]]], chi: Union[int, Sequence[int]], dtype: Type[jnp.number], max_chi: Optional[int] = None, peps_type: PEPS_Type = PEPS_Type.SQUARE, *, seed: Optional[int] = None, destroy_random_state: bool = True, ) -> T_PEPS_Unit_Cell: """ Randomly initialize the unit cell and its PEPS tensors according to the structure given. Args: structure (:term:`sequence` of :term:`sequence` of :obj:`int` or 2d array): Two dimensional array modeling the structure of the unit cell. For details see the description of the parent unit cell class. d (:obj:`int` or :term:`sequence` of :obj:`int`): Physical dimension. If sequence, physical of each unique PEPS tensor separately. D (:obj:`int` or :term:`sequence` of :term:`sequence` of :obj:`int`): Bond dimension of PEPS tensor. If sequence, dimension of each unique PEPS tensor separately. chi (:obj:`int` or :term:`sequence` of :obj:`int`): Bond dimension of environment tensors. If sequence, dimension of each unique PEPS tensor separately. dtype (:term:`type` of :obj:`jax.numpy.number`): Data type of the PEPS tensors. max_chi (:obj:`int`): Maximal allowed bond dimension for the environment tensors. peps_type (:obj:`~varipeps.peps.PEPS_Type`): Select which type of PEPS state should be generated. For example selects a square with full transfer tensor, a square with split-CTMRG env or the triangular PEPS mode. Keyword args: seed (:obj:`int`, optional): Seed for random number generator destroy_random_state (:obj:`bool`): Destroy state of random number generator and reinitialize it. Defaults to True. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the initialized tensors. """ structure, tensors_i = cls._check_structure(structure) # Check the inputs if isinstance(d, int): d = [d] * tensors_i.size if not all(isinstance(i, int) for i in d) or len(d) != tensors_i.size: raise ValueError( "d has to be a single integer or a sequence of ints for every unique tensor of the unit cell." ) if isinstance(D, int): if peps_type is PEPS_Type.TRIANGULAR: D = [(D, D, D, D, D, D) for _ in range(tensors_i.size)] else: D = [(D, D, D, D) for _ in range(tensors_i.size)] if ( not all(isinstance(j, int) for i in D for j in i) or len(D) != tensors_i.size ): raise ValueError( "D has to be a single integer or a sequence of a int sequence for every unique tensor of the unit cell." ) if isinstance(chi, int): chi = [chi] * tensors_i.size if not all(isinstance(i, int) for i in chi) or len(chi) != tensors_i.size: raise ValueError( "chi has to be a single integer or a sequence of ints for every unique tensor of the unit cell." ) # Generate the PEPS tensors if destroy_random_state: PEPS_Random_Number_Generator.destroy_state() peps_tensors = [] if peps_type is PEPS_Type.TRIANGULAR: peps_tensor_class = PEPS_Tensor_Triangular else: peps_tensor_class = PEPS_Tensor for i in tensors_i: if i > 0: seed = None peps_tensors.append( peps_tensor_class.random( d=d[i], D=D[i], chi=chi[i], dtype=dtype, seed=seed, max_chi=max_chi ) ) data = cls.Unit_Cell_Data(peps_tensors=peps_tensors, structure=structure) result = cls(data=data) if peps_type is PEPS_Type.SQUARE_SPLIT: return result.convert_to_split_transfer() return result def get_size(self) -> Tuple[int, int]: """ Returns the size of the unit cell as tuple (x_size, y_size). Returns: :obj:`tuple`\ (:obj:`int`, :obj:`int`): Size of the unit cell as tuple (x_size, y_size). """ return (len(self.data.structure), len(self.data.structure[0])) def get_len_unique_tensors(self) -> int: """ Return the length of the list of the unique tensors the unit cell consists of. Returns: :obj:`int`: Length of list of unique tensors """ return len(self.data.peps_tensors) def get_indices( self, key: Tuple[Union[int, slice], Union[int, slice]] ) -> Sequence[Sequence[int]]: """ Get indices of PEPS tensors according to unit cell structure. Args: key (:obj:`tuple` of 2 :obj:`int` or :obj:`slice` elements): x and y coordinates to select. Can be either integers or slices. Negative numbers as selectors are supported. Returns: :term:`sequence` of :term:`sequence` of :obj:`~PEPS_Tensor`: 2d sequence with the indices of the selected PEPS tensor objects. """ return calculate_periodic_indices( key, self.data.structure, self.real_ix, self.real_iy ) def __getitem__( self, key: Tuple[Union[int, slice], Union[int, slice]] ) -> List[List[PEPS_Tensor]]: """ Get PEPS tensors according to unit cell structure. Args: key (:obj:`tuple` of 2 :obj:`int` or :obj:`slice` elements): x and y coordinates to select. Can be either integers or slices. Negative numbers as selectors are supported. Returns: :obj:`list` of :obj:`list` of :obj:`PEPS_Tensor`: 2d list with the selected PEPS tensor objects. """ indices = self.get_indices(key) return [[self.data.peps_tensors[ty] for ty in tx] for tx in indices] def __setitem__(self, key: Tuple[int, int], value: PEPS_Tensor) -> None: """ Set PEPS tensors according to unit cell structure. Args: key (:obj:`tuple` of 2 :obj:`int` elements): x and y coordinates to select. Have to be a single integer. value (:obj:`~varipeps.peps.PEPS_Tensor`): New PEPS tensor object to be set. """ if not isinstance(value, (PEPS_Tensor, PEPS_Tensor_Triangular)): raise TypeError("Invalid type for value. Expected PEPS_Tensor.") x, y = key unit_cell_len_x = len(self.data.structure) unit_cell_len_y = len(self.data.structure[0]) x = (self.real_ix + x) % unit_cell_len_x y = (self.real_iy + y) % unit_cell_len_y self.data.peps_tensors[self.data.structure[x][y]] = value def get_unique_tensors(self) -> List[PEPS_Tensor]: """ Get the list of unique tensors the unit cell consists of. Returns: :obj:`list` of :obj:`~varipeps.peps.PEPS_Tensor`: List of unique tensors. """ return self.data.peps_tensors def replace_unique_tensors( self: T_PEPS_Unit_Cell, new_unique_tensors: List[PEPS_Tensor] ) -> T_PEPS_Unit_Cell: """ Replace the list of unique tensors the unit cell consists of. Args: new_unique_tensors (:obj:`list` of :obj:`~varipeps.peps.PEPS_Tensor`): New list of unique tensors the unit cell should consists of. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new unique tensor list. """ if len(self.data.peps_tensors) != len(new_unique_tensors): raise ValueError("Length of old and new list mismatches.") new_data = self.data.replace_peps_tensors(new_unique_tensors) return type(self)( data=new_data, real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def is_split_transfer(self: T_PEPS_Unit_Cell) -> bool: return all(t.is_split_transfer for t in self.data.peps_tensors) def is_triangular_peps(self: T_PEPS_Unit_Cell) -> bool: try: return all(t.is_triangular_peps for t in self.data.peps_tensors) except AttributeError: return False def convert_to_split_transfer( self: T_PEPS_Unit_Cell, interlayer_chi: Optional[int] = None ) -> T_PEPS_Unit_Cell: """ Convert the list of unique tensors to the split transfer ansatz. Args: interlayer_chi (:obj:`int`, optional): Bond dimension for the interlayer index in the split transfer ansatz. If set to None, the same value as for the enviroment bond dimension is used. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new unique tensor list. """ if self.is_split_transfer(): return self new_unique_tensors = type(self.data.peps_tensors)( t.convert_to_split_transfer(interlayer_chi) for t in self.data.peps_tensors ) new_data = self.data.replace_peps_tensors(new_unique_tensors) return type(self)( data=new_data, real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def convert_to_full_transfer(self: T_PEPS_Unit_Cell) -> T_PEPS_Unit_Cell: """ Convert the list of unique tensors to the full transfer ansatz. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new unique tensor list. """ if not self.is_split_transfer(): return self new_unique_tensors = type(self.data.peps_tensors)( t.convert_to_full_transfer() for t in self.data.peps_tensors ) new_data = self.data.replace_peps_tensors(new_unique_tensors) return type(self)( data=new_data, real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def change_chi( self: T_PEPS_Unit_Cell, new_chi: int, reset_max_chi: bool = False, ) -> T_PEPS_Unit_Cell: """ Change environment bond dimension of all tensors in the unit cell. Args: new_chi (:obj:`int`): New value for the environment bond dimension. reset_max_chi (:obj:`bool`): Set maximal bond dimension to the same new value. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new tensor list. """ new_unique_tensors = type(self.data.peps_tensors)( t.change_chi(new_chi, reset_max_chi=reset_max_chi) for t in self.data.peps_tensors ) new_data = self.data.replace_peps_tensors(new_unique_tensors) return type(self)( data=new_data, real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def increase_max_chi(self: T_PEPS_Unit_Cell, new_max_chi: int) -> T_PEPS_Unit_Cell: """ Change environment maximal bond dimension of all tensors in the unit cell. Args: new_max_chi (:obj:`int`): New value for the maximal environment bond dimension. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new tensor list. """ new_unique_tensors = type(self.data.peps_tensors)( t.increase_max_chi(new_max_chi) for t in self.data.peps_tensors ) new_data = self.data.replace_peps_tensors(new_unique_tensors) return type(self)( data=new_data, real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def change_D(self: T_PEPS_Unit_Cell, new_D: int) -> T_PEPS_Unit_Cell: """ Change iPEPS bond dimension of all tensors in the unit cell. Args: new_D (:obj:`int`): New value for the iPEPS bond dimension. Returns: PEPS_Unit_Cell: New instance of PEPS unit cell with the new tensor list. """ old_D = self.get_unique_tensors()[0].D[0] if any(D != old_D for t in self.get_unique_tensors() for D in t.D): raise NotImplementedError( "Only supporting isotropic bond dim at the moment" ) if new_D == old_D: return self.copy() from varipeps.utils.projector_dict import Projector_Dict from varipeps.utils.svd import svd_wrapper from varipeps.contractions import apply_contraction_jitted max_x, max_y = self.get_size() projectors = Projector_Dict(max_x=max_x, max_y=max_y) working_unitcell = self.copy() new_D = int(new_D) for x, iter_rows in working_unitcell.iter_all_rows(only_unique=True): for y, view in iter_rows: working_tensor_obj_top_left = view[0, 0][0][0] working_tensor_obj_top_right = view[0, 1][0][0] working_tensor_obj_bottom_left = view[1, 0][0][0] rho_left = apply_contraction_jitted( "unitcell_bond_dim_change_left", [working_tensor_obj_top_left.tensor], [working_tensor_obj_top_left], [], ) rho_left = rho_left / jnp.linalg.norm(rho_left) rho_right = apply_contraction_jitted( "unitcell_bond_dim_change_right", [working_tensor_obj_top_right.tensor], [working_tensor_obj_top_right], [], ) rho_right = rho_right / jnp.linalg.norm(rho_right) rho_top = apply_contraction_jitted( "unitcell_bond_dim_change_top", [working_tensor_obj_top_left.tensor], [working_tensor_obj_top_left], [], ) rho_top = rho_top / jnp.linalg.norm(rho_top) rho_bottom = apply_contraction_jitted( "unitcell_bond_dim_change_bottom", [working_tensor_obj_bottom_left.tensor], [working_tensor_obj_bottom_left], [], ) rho_bottom = rho_bottom / jnp.linalg.norm(rho_bottom) rho_left_matrix = rho_left.reshape( rho_left.shape[0] * rho_left.shape[1] * rho_left.shape[2], rho_left.shape[3], ) rho_right_matrix = rho_right.reshape( rho_right.shape[0], rho_right.shape[1] * rho_right.shape[2] * rho_right.shape[3], ) rho_top_matrix = rho_top.reshape( rho_top.shape[0] * rho_top.shape[1] * rho_top.shape[2], rho_top.shape[3], ) rho_bottom_matrix = rho_bottom.reshape( rho_bottom.shape[0], rho_bottom.shape[1] * rho_bottom.shape[2] * rho_bottom.shape[3], ) U, S, Vh = svd_wrapper(rho_left_matrix @ rho_right_matrix) # Truncate the singular values S = S[:new_D] U = U[:, :new_D] Vh = Vh[:new_D, :] if new_D > old_D: for i in range(old_D, new_D): S = S.at[i].set(S[i - 1] * 1e-1) relevant_S_values = (S / S[0]) > varipeps_config.ctmrg_truncation_eps S_inv_sqrt = jnp.where( relevant_S_values, 1 / jnp.sqrt(jnp.where(relevant_S_values, S, 1)), 0, ) projector_left = jnp.dot( U.transpose().conj() * S_inv_sqrt[:, jnp.newaxis], rho_left_matrix ) projector_right = jnp.dot( rho_right_matrix, Vh.transpose().conj() * S_inv_sqrt ) U, S, Vh = svd_wrapper(rho_top_matrix @ rho_bottom_matrix) # Truncate the singular values S = S[:new_D] U = U[:, :new_D] Vh = Vh[:new_D, :] if new_D > old_D: for i in range(old_D, new_D): S = S.at[i].set(S[i - 1] * 1e-1) relevant_S_values = (S / S[0]) > varipeps_config.ctmrg_truncation_eps S_inv_sqrt = jnp.where( relevant_S_values, 1 / jnp.sqrt(jnp.where(relevant_S_values, S, 1)), 0, ) projector_top = jnp.dot( U.transpose().conj() * S_inv_sqrt[:, jnp.newaxis], rho_top_matrix ) projector_bottom = jnp.dot( rho_bottom_matrix, Vh.transpose().conj() * S_inv_sqrt ) projectors[(x, y)] = ( projector_left, projector_right, projector_top, projector_bottom, ) for x, iter_rows in working_unitcell.iter_all_rows(only_unique=True): for y, view in iter_rows: working_tensor_obj_top_left = view[0, 0][0][0] working_tensor_obj_top_right = view[0, 1][0][0] working_tensor_obj_bottom_left = view[1, 0][0][0] projector_left, projector_right, projector_top, projector_bottom = ( projectors.get_projector(x, y, 0, 0) ) new_top_left_D = list(working_tensor_obj_top_left.D) new_top_left = jnp.tensordot( working_tensor_obj_top_left.tensor, projector_left, ((3,), (1,)) ) new_top_left = new_top_left.transpose(0, 1, 2, 4, 3) new_top_left_D[2] = new_D new_top_left = jnp.tensordot(new_top_left, projector_top, ((1,), (1,))) new_top_left = new_top_left.transpose(0, 4, 1, 2, 3) new_top_left_D[1] = new_D if working_tensor_obj_top_right is working_tensor_obj_top_left: new_top_left = jnp.tensordot( projector_right, new_top_left, ((0,), (0,)) ) new_top_left_D[0] = new_D else: new_top_right = jnp.tensordot( projector_right, working_tensor_obj_top_right.tensor, ((0,), (0,)), ) new_top_right_D = list(working_tensor_obj_top_right.D) new_top_right_D[0] = new_D new_top_right_D = tuple(new_top_right_D) if working_tensor_obj_bottom_left is working_tensor_obj_top_left: new_top_left = jnp.tensordot( new_top_left, projector_bottom, ((4,), (0,)) ) new_top_left_D[3] = new_D else: new_bottom_left = jnp.tensordot( working_tensor_obj_bottom_left.tensor, projector_bottom, ((4,), (0,)), ) new_bottom_left_D = list(working_tensor_obj_bottom_left.D) new_bottom_left_D[3] = new_D new_bottom_left_D = tuple(new_bottom_left_D) new_top_left_D = tuple(new_top_left_D) working_tensor_obj_top_left = ( working_tensor_obj_top_left.replace_tensor( new_top_left, reinitialize_env_as_identities=True, new_D=new_top_left_D, ) ) view[0, 0] = working_tensor_obj_top_left if view[0, 0][0][0] is not view[0, 1][0][0]: working_tensor_obj_top_right = ( working_tensor_obj_top_right.replace_tensor( new_top_right, reinitialize_env_as_identities=True, new_D=new_top_right_D, ) ) view[0, 1] = working_tensor_obj_top_right if view[0, 0][0][0] is not view[1, 0][0][0]: working_tensor_obj_bottom_left = ( working_tensor_obj_bottom_left.replace_tensor( new_bottom_left, reinitialize_env_as_identities=True, new_D=new_bottom_left_D, ) ) view[1, 0] = working_tensor_obj_bottom_left return working_unitcell def move(self: T_PEPS_Unit_Cell, new_xi: int, new_yi: int) -> T_PEPS_Unit_Cell: """ Move origin of the unit cell coordination system. This function just creates a new view but do not copy the structure object or the PEPS tensors. Args: new_xi (:obj:`int`): New x origin coordinate relative to current origin new_yi (:obj:`int`): New y origin coordinate relative to current origin Returns: PEPS_Unit_Cell: PEPS unit cell with shifted origin. """ if not isinstance(new_xi, int) or not isinstance(new_yi, int): raise ValueError("New indices have to be integers.") unit_cell_len_x = len(self.data.structure) unit_cell_len_y = len(self.data.structure[0]) return type(self)( data=self.data, real_ix=(self.real_ix + new_xi) % unit_cell_len_x, real_iy=(self.real_iy + new_yi) % unit_cell_len_y, sanity_checks=False, ) def _iter_one_column_impl( self, fixed_y: int, *, only_unique: bool = False, unique_memory: Optional[Set[int]] = None, ): unit_cell_len_x = len(self.data.structure) if unique_memory is None: unique_memory = set() for x in range(unit_cell_len_x): view = self.move(x, fixed_y) if only_unique: ind_up_left = int(view.get_indices((0, 0))[0][0]) if ind_up_left in unique_memory: continue else: unique_memory.add(ind_up_left) yield x, view def iter_one_column( self: T_PEPS_Unit_Cell, fixed_y: int, *, only_unique: bool = False ) -> Iterator[Tuple[int, T_PEPS_Unit_Cell]]: """ Get a iterator over a single column with a fixed y value. Args: fixed_y (int): Fixed y value. Keyword args: only_unique (bool): Return only views where each unique PEPS tensor in the unitcell is only once at index (0, 0). Returns: :term:`iterator`\ (:obj:`~varipeps.peps.PEPS_Unit_Cell`): Iterator over one column of the unit cell with the current PEPS tensor at moved position (0, 0). """ return self._iter_one_column_impl(fixed_y, only_unique=only_unique) def iter_all_columns( self: T_PEPS_Unit_Cell, *, reverse: bool = False, only_unique: bool = False ) -> Iterator[Tuple[int, Iterator[Tuple[int, T_PEPS_Unit_Cell]]]]: """ Get a iterator over all columns. This function calls :obj:`~varipeps.peps.PEPS_Unit_Cell.iter_one_column` for all columns and yields the resulting iterator. Keyword args: reverse (bool): Reverse the order of the iteration. only_unique (bool): Return only views where each unique PEPS tensor in the unitcell is only once at index (0, 0). Returns: :term:`iterator`\ (:term:`iterator`\ (:obj:`~varipeps.peps.PEPS_Unit_Cell`)): Iterator for all columns over the iterator for single column with the current PEPS tensor at moved position (0, 0). """ unit_cell_len_y = len(self.data.structure[0]) if reverse: yiter = range(unit_cell_len_y - 1, -1, -1) else: yiter = range(unit_cell_len_y) unique_memory: Set[int] = set() for y in yiter: yield y, self._iter_one_column_impl( y, only_unique=only_unique, unique_memory=unique_memory ) def _iter_main_diagonal_impl(self): unit_cell_len_x, unit_cell_len_y = self.get_size() max_i = jnp.lcm(unit_cell_len_x, unit_cell_len_y) for i in range(max_i): view = self.move(i, i) yield i, view def iter_main_diagonal( self: T_PEPS_Unit_Cell, ) -> Iterator[Tuple[int, T_PEPS_Unit_Cell]]: """ Get a iterator over the main diagonal. Returns: :term:`iterator`\ (:obj:`~varipeps.peps.PEPS_Unit_Cell`): Iterator over main diagonal of the unit cell with the current PEPS tensor at moved position (0, 0). """ return self._iter_main_diagonal_impl() def _iter_one_row_impl( self, fixed_x: int, *, only_unique: bool = False, unique_memory: Optional[Set[int]] = None, ): unit_cell_len_y = len(self.data.structure[0]) if unique_memory is None: unique_memory = set() for y in range(unit_cell_len_y): view = self.move(fixed_x, y) if only_unique: ind_up_left = int(view.get_indices((0, 0))[0][0]) if ind_up_left in unique_memory: continue else: unique_memory.add(ind_up_left) yield y, view def iter_one_row( self: T_PEPS_Unit_Cell, fixed_x: int, *, only_unique: bool = False ) -> Iterator[Tuple[int, T_PEPS_Unit_Cell]]: """ Get a iterator over a single row with a fixed x value. Args: fixed_x (int): Fixed x value. Keyword args: only_unique (bool): Return only views where each unique PEPS tensor in the unitcell is only once at index (0, 0). Returns: :term:`iterator`\ (:obj:`~varipeps.peps.PEPS_Unit_Cell`): Iterator over one row of the unit cell with the current PEPS tensor at moved position (0, 0). """ return self._iter_one_row_impl(fixed_x, only_unique=only_unique) def iter_all_rows( self: T_PEPS_Unit_Cell, *, reverse: bool = False, only_unique: bool = False ) -> Iterator[Tuple[int, Iterator[Tuple[int, T_PEPS_Unit_Cell]]]]: """ Get a iterator over all rows. This function calls :obj:`~varipeps.peps.PEPS_Unit_Cell.iter_one_row` for all rows and yields the resulting iterator. Keyword args: reverse (bool): Reverse the order of the iteration. only_unique (bool): Return only views where each unique PEPS tensor in the unitcell is only once at index (0, 0). Returns: :term:`iterator`\ (:term:`iterator`\ (:obj:`~varipeps.peps.PEPS_Unit_Cell`)): Iterator for all rows over the iterator for single row with the current PEPS tensor at moved position (0, 0). """ unit_cell_len_x = len(self.data.structure) if reverse: xiter = range(unit_cell_len_x - 1, -1, -1) else: xiter = range(unit_cell_len_x) unique_memory: Set[int] = set() for x in xiter: yield x, self._iter_one_row_impl( x, only_unique=only_unique, unique_memory=unique_memory ) def copy(self: T_PEPS_Unit_Cell) -> T_PEPS_Unit_Cell: """ Performs a (flat) copy of the PEPS unit cell. Returns: ~varipeps.peps.PEPS_Unit_Cell: Copied instance of the unit cell. """ return type(self)( data=self.data.copy(), real_ix=self.real_ix, real_iy=self.real_iy, sanity_checks=False, ) def save_to_file( self, path: PathLike, store_config: bool = True, auxiliary_data: Optional[Dict[str, Any]] = None, ) -> None: """ Save unit cell to a HDF5 file. This function creates a single group "unitcell" in the file and pass this group to the method :obj:`~PEPS_Unit_Cell.save_to_group` then. Args: path (:obj:`os.PathLike`): Path of the new file. Caution: The file will overwritten if existing. store_config (:obj:`bool`): Store the current values of the global config object into the HDF5 file as attrs of an extra group. auxiliary_data (:obj:`dict` with :obj:`str` to storable objects, optional): Dictionary with string indexed auxiliary HDF5-storable entries which should be stored along the other data in the file. """ with h5py.File(path, "w", libver=("earliest", "v110")) as f: grp = f.create_group("unitcell") self.save_to_group(grp, store_config) if auxiliary_data is not None: grp_aux = f.create_group("auxiliary_data") self.save_auxiliary_data(grp_aux, auxiliary_data) @classmethod def save_auxiliary_data( cls, grp: h5py.Group, auxiliary_data: Optional[Dict[str, Any]] ): """ Save auxiliary data to HDF5 group. Args: grp (:obj:`h5py.Group`): HDF5 group object to store the data into. auxiliary_data (:obj:`dict` with :obj:`str` to storable objects): Dictionary with string indexed auxiliary HDF5-storable entries which should be stored along the other data in the file. """ grp.attrs["keys"] = list(auxiliary_data.keys()) for key, val in auxiliary_data.items(): if key == "keys": raise ValueError("Name 'keys' forbidden as name for auxiliary data") if isinstance( val, (jnp.ndarray, np.ndarray, collections.abc.Sequence) ) and not isinstance(val, str): try: if val.ndim == 0: val = val.reshape(1) except AttributeError: pass grp.create_dataset( key, data=jnp.asarray(val), compression="gzip", compression_opts=6, ) elif isinstance(val, collections.abc.Mapping): inner_grp = grp.create_group(key) cls.save_auxiliary_data(inner_grp, val) else: grp.attrs[key] = val def save_to_group(self, grp: h5py.Group, store_config: bool = True) -> None: """ Save unit cell to a HDF5 group which is be passed to the method. Args: grp (:obj:`h5py.Group`): HDF5 group object to store the data into. store_config (:obj:`bool`): Store the current values of the global config object into the HDF5 file as attrs of an extra group. """ grp.attrs["real_ix"] = self.real_ix grp.attrs["real_iy"] = self.real_iy grp_data = grp.create_group("data") self.data.save_to_group(grp_data) if store_config: grp_config = grp.create_group("config") for config_attr in varipeps_config.__dataclass_fields__.keys(): grp_config.attrs[config_attr] = getattr(varipeps_config, config_attr) grp_version = grp.create_group("version") grp_version.attrs["version"] = varipeps.__version__ if varipeps.git_commit is not None: grp_version.attrs["git_hash"] = varipeps.git_commit if varipeps.git_tag is not None: grp_version.attrs["git_tag"] = varipeps.git_tag if ( slurm_data := varipeps.utils.slurm.SlurmUtils.get_own_job_data() ) is not None: grp_slurm = grp.create_group("slurm") for k, v in slurm_data.items(): if isinstance(v, datetime.datetime): grp_slurm.attrs[k] = v.isoformat() elif isinstance(v, datetime.timedelta): grp_slurm.attrs[k] = v.total_seconds() elif isinstance(v, dict): for k2, v2 in v.items(): grp_slurm.attrs[f"{k}_{k2}"] = v2 else: grp_slurm.attrs[k] = v @classmethod def load_from_file( cls: Type[T_PEPS_Unit_Cell], path: PathLike, return_unitcell: bool = True, return_config: bool = False, return_auxiliary_data: bool = False, ) -> Union[ T_PEPS_Unit_Cell, Tuple[T_PEPS_Unit_Cell, varipeps.config.VariPEPS_Config] ]: """ Load unit cell from a HDF5 file. This function read the group "unitcell" from the file and pass this group to the method :obj:`~PEPS_Unit_Cell.load_from_group` then. Args: path (:obj:`os.PathLike`): Path of the HDF5 file. return_unitcell (:obj:`bool`): Return the PEPS unit cell. return_config (:obj:`bool`): Return a config object initialized with the values from the HDF5 files. If no config is stored in the file, just the data is returned. Missing config flags in the file uses the default values from the config object. return_auxiliary_data (:obj:`bool`): Return dictionary with string indexed auxiliary data which has been should be stored along the other data in the file. """ with h5py.File(path, "r") as f: out = cls.load_from_group(f["unitcell"], return_unitcell, return_config) if return_auxiliary_data: auxiliary_data = {} if (auxiliary_data_grp := f.get("auxiliary_data")) is not None: auxiliary_data = cls.load_auxiliary_data(auxiliary_data_grp) elif ( max_trunc_error_list := f.get("max_trunc_error_list") ) is not None: auxiliary_data["max_trunc_error_list"] = jnp.asarray( max_trunc_error_list ) if out is None: out = auxiliary_data elif isinstance(out, tuple): out = out + (auxiliary_data,) else: out = (out, auxiliary_data) return out @staticmethod def load_auxiliary_data(grp: h5py.Group): """ Load auxiliary data from a HDF5 group. Args: grp (:obj:`h5py.Group`): HDF5 group object to store the data into. """ auxiliary_data = {} for k in grp.attrs["keys"]: aux_d = grp.get(k) if aux_d is None: aux_d = grp.attrs[k] else: aux_d = jnp.asarray(aux_d) auxiliary_data[k] = aux_d return auxiliary_data @classmethod def load_from_group( cls: Type[T_PEPS_Unit_Cell], grp: h5py.Group, return_unitcell: bool = True, return_config: bool = False, ) -> Union[ T_PEPS_Unit_Cell, Tuple[T_PEPS_Unit_Cell, varipeps.config.VariPEPS_Config] ]: """ Load the unit cell from a HDF5 group which is be passed to the method. Args: grp (:obj:`h5py.Group`): HDF5 group object to load the data from. return_unitcell (:obj:`bool`): Return the PEPS unit cell. return_config (:obj:`bool`): Return a config object initialized with the values from the HDF5 files. If no config is stored in the file, just the data is returned. Missing config flags in the file uses the default values from the config object. """ if return_unitcell: data = cls.Unit_Cell_Data.load_from_group(grp["data"]) real_ix = int(grp.attrs["real_ix"]) real_iy = int(grp.attrs["real_iy"]) elif not return_config: return None if return_config: if grp.get("config") is None: return cls(data=data, real_ix=real_ix, real_iy=real_iy), None config_dict = { config_attr: grp["config"].attrs.get(config_attr) for config_attr in varipeps_config.__dataclass_fields__.keys() if grp["config"].attrs.get(config_attr) is not None } if config_dict.get("ctmrg_full_projector_method"): config_dict["ctmrg_full_projector_method"] = ( varipeps.config.Projector_Method( config_dict["ctmrg_full_projector_method"] ) ) if config_dict.get("optimizer_method"): config_dict["optimizer_method"] = varipeps.config.Optimizing_Methods( config_dict["optimizer_method"] ) if config_dict.get("line_search_method"): config_dict["line_search_method"] = varipeps.config.Line_Search_Methods( config_dict["line_search_method"] ) if config_dict.get("spiral_wavevector_type"): config_dict["spiral_wavevector_type"] = varipeps.config.Wavevector_Type( config_dict["spiral_wavevector_type"] ) if config_dict.get("slurm_restart_mode"): config_dict["slurm_restart_mode"] = varipeps.config.Slurm_Restart_Mode( config_dict["slurm_restart_mode"] ) if return_unitcell: return cls( data=data, real_ix=real_ix, real_iy=real_iy ), varipeps.config.VariPEPS_Config(**config_dict) else: return varipeps.config.VariPEPS_Config(**config_dict) return cls(data=data, real_ix=real_ix, real_iy=real_iy) def tree_flatten(self) -> Tuple[Tuple[Any, ...], Tuple[Any, ...]]: aux_data = (self.real_ix, self.real_iy) return ((self.data,), aux_data) @classmethod def tree_unflatten( cls: Type[T_PEPS_Unit_Cell], aux_data: Tuple[Any, ...], children: Tuple[Any, ...], ) -> T_PEPS_Unit_Cell: real_ix, real_iy = aux_data (data,) = children return cls( data=data, real_ix=real_ix, real_iy=real_iy, sanity_checks=False, )