MixedXKLattice
full name: tenpy.models.mixed_xk.MixedXKLattice
parent module:
tenpy.models.mixed_xk
type: class
Inheritance Diagram
Methods
|
|
Shallow copy of self. |
|
|
Count e.g. the number of nearest neighbors for a site in the bulk. |
Calculate correct shape of the strengths for a coupling. |
|
|
Get the distance for a given coupling between two sites in the lattice. |
|
Repeat the unit cell for infinite MPS boundary conditions; in place. |
|
Extract a finite segment from an infinite/large system. |
|
Automatically find coupling pairs grouped by distances. |
Initialize from charges, defining default Sites. |
|
|
Load instance from a HDF5 file. |
Return \(\exp(\frac{2 pi i }{L_y} ky)\). |
|
Return momentum index k for given unit cell index u. |
|
Return orbital index l for given unit cell index u. |
|
|
Return unit cell index u as a function of momentum index k and orbital l. |
|
Translate lattice indices |
Translate MPS index i to lattice indices |
|
|
Reshape/reorder A to replace an MPS index by lattice indices. |
|
Like |
|
Reshape/reorder an array A to replace an MPS index by lattice indices. |
|
Like |
return an index array of MPS indices for which the site within the unit cell is u. |
|
Similar as |
|
Return a list of sites for all MPS indices. |
|
Calculate correct shape of the strengths for a multi_coupling. |
|
|
Provide possible orderings of the N lattice sites. |
|
Plot arrows indicating the basis vectors of the lattice. |
|
Mark two sites identified by periodic boundary conditions. |
|
Plot the Brillouin Zone of the lattice. |
|
Plot lines connecting nearest neighbors of the lattice. |
|
Plot a line connecting sites in the specified "order" and text labels enumerating them. |
|
Plot arrows indicating the basis vectors of the reciprocal lattice. |
|
Plot the sites of the lattice with markers. |
|
return 'space' position of one or multiple sites. |
|
Find possible MPS indices for two-site couplings. |
Generalization of |
|
|
Export self into a HDF5 file. |
return |
|
Sanity check. |
Class Attributes and Properties
The Brillouin Zone as |
|
the (expected) number of sites in the unit cell, |
|
|
|
Human-readable list of boundary conditions from |
|
Direction of the cylinder axis. |
|
The dimension of the lattice. |
|
Defines an ordering of the lattice sites, thus mapping the lattice to a 1D chain. |
|
Reciprocal basis vectors of the lattice. |
- class tenpy.models.mixed_xk.MixedXKLattice(N_rings, Ly, N_orb, sites, ring_order=None, orbital_names=None, orbital_values=None, **kwargs)[source]
Bases:
Lattice
Lattice for fermions with mixed real and momentum space on a cylinder.
This class represents a square lattice cylinder with a unit cell of N_orb fermionic orbitals, where we identify the y-direction (around the cylinder) as momentum space. The full lattice unit cell consists of a ‘ring’, which is repeated in cylinder direction: indices \((x, u= k * N_{orb} + l)\) in the lattice correspond to the ring \(x\), momentum \(k_y = 2\pi k/L_y\) around the cylinder, and orbital l. Indices are related by
u = k * N_orb + l
,k = u // N_orb
, andl = u % N_orb
, seeget_u()
,get_k()
,get_l()
. Note that the DMRG snake might wind in a different order, as specified byring_order
.Warning
Using the Jordan-Wigner string (
JW
) is crucial to get correct results! See Fermions and the Jordan-Wigner transformation for details.See
tenpy.models.mixed_xk
for the mappings between x,k and x,y.- Parameters:
N_rings (int) – Number of rings in the MPS unit cell.
Ly (int) – The circumference of the cylinder: the number of possible k values.
N_orb (int) – Number of orbitals. A single ‘ring’ of the cylinder contains
N_orb*Ly
sites.sites (list of
Site
) – The sites making up the unit cell, in the order specified by ring_order.ring_order (1D array, len Ly*N_orb) – Gives the order of the sites within a ring for the DMRG snake; sites are labeled by the index
u = k*N_orb + l
of theunit_cell
. Defaults tonp.arange(Ly*N_orb)
.orbital_names (None | list of str) – Names for the orbitals, e.g.
['spin', 'valley', 'ky']
orbital_values (array, shape (len(sites), len(orbital_names))) – Values for the orbitals, one row for each site in sites.
**kwargs – Further keyword arguments given to
Lattice
.
- ring_order
Gives the order of the sites within a ring for the DMRG snake; sites are labeled by the index
u = k*N_orb + l
of theunit_cell
. Defaults tonp.arange(Ly*N_orb)
.- Type:
1D array, len
Ly*N_orb
- delta_q
delta_q[q][k1, k2]
is the Kronecker \(\delta_{k1+q \mod Ly, k2}\).- Type:
ndarray, shape (L_y, Ly, Ly)
- orbital_values
Values for the orbitals, one row for each site in the unit cell.
- Type:
None | array, shape (len(sites), len(orbital_names))
- property order
Defines an ordering of the lattice sites, thus mapping the lattice to a 1D chain.
Each row of the array contains the lattice indices for one site, the order of the rows thus specifies a path through the lattice, along which an MPS will wind through the lattice.
You can visualize the order with
plot_order()
.
- classmethod from_charges_of_orbitals(N_rings, Ly, N_orb, chinfo, charges, conserve_k=True, ring_order=None, **kwargs)[source]
Initialize from charges, defining default Sites.
- Parameters:
N_rings (int) – Number of rings in the MPS unit cell.
Ly (int) – The circumference of the cylinder: the number of possible k values.
N_orb (int) – Number of orbitals. A single ‘ring’ of the cylinder contains
N_orb*Ly
sites.chinfo (
ChargeInfo
) – The nature of the charges. If conserve_k is True, the charge"ky"
for the momentum around the cylinder is added.charges (array_like of shape (N_orb, chinfo.qnumber)) – For each of the orbitals the value of each charges (except
"ky"
), when the orbital is occupied.ring_order (1D array, len Ly*N_orb) – Gives the order of the sites within a ring for the DMRG snake; sites are labeled by the index
u = k*N_orb + l
of theunit_cell
. Defaults tonp.arange(Ly*N_orb)
.conserve_k (bool) – Whether to add “ky” as separate charge to chinfo.
**kwargs – Further keyword arguments given to
Lattice
.
- Returns:
lat – Instance of this class, with the sites initialized according to the charges of the orbitals defined above.
- Return type:
cls
- save_hdf5(hdf5_saver, h5gr, subpath)[source]
Export self into a HDF5 file.
This method saves all the data it needs to reconstruct self with
from_hdf5()
.In addition to
save_hdf5()
, it savesring_order
,orbital_names
andorbital_values
as HDF5 dataset, andLy
andN_orb
as HDF5 attributes.
- classmethod from_hdf5(hdf5_loader, h5gr, subpath)[source]
Load instance from a HDF5 file.
This method reconstructs a class instance from the data saved with
save_hdf5()
.- Parameters:
hdf5_loader (
Hdf5Loader
) – Instance of the loading engine.h5gr (
Group
) – HDF5 group which is represent the object to be constructed.subpath (str) – The name of h5gr with a
'/'
in the end.
- Returns:
obj – Newly generated class instance containing the required data.
- Return type:
cls
- get_exp_ik(ky)[source]
Return \(\exp(\frac{2 pi i }{L_y} ky)\).
If you need the factor for given k and y, just give
k*y
as argument.
- mps2lat_values_k(A, axes=0)[source]
Like
Lattice.mps2lat_values()
, but introduce k as separate lattice index.
- mps2lat_values_masked_k(A, axes=-1, mps_inds=None, include_u=None)[source]
Like
Lattice.mps2lat_values_masked()
, but introduce k as separate lattice index.
- property BZ
The Brillouin Zone as
SimpleBZ
- Lu = None
the (expected) number of sites in the unit cell,
len(unit_cell)
.
- property boundary_conditions
Human-readable list of boundary conditions from
bc
andbc_shift
.
- count_neighbors(u=0, key='nearest_neighbors')[source]
Count e.g. the number of nearest neighbors for a site in the bulk.
- Parameters:
- Returns:
number – Number of nearest neighbors (or whatever key specified) for the u-th site in the unit cell, somewhere in the bulk of the lattice. Note that it might not be the correct value at the edges of a lattice with open boundary conditions.
- Return type:
- coupling_shape(dx)[source]
Calculate correct shape of the strengths for a coupling.
- Parameters:
dx (tuple of int) – Translation vector in the lattice for a coupling of two operators. Corresponds to dx argument of
tenpy.models.model.CouplingModel.add_multi_coupling()
.- Returns:
coupling_shape (tuple of int) – Len
dim
. The correct shape for an array specifying the coupling strength. lat_indices has only rows within this shape.shift_lat_indices (array) – Translation vector from origin to the lower left corner of box spanned by dx.
- property cylinder_axis
Direction of the cylinder axis.
For an infinite cylinder (bc_MPS=’infinite’ and ``boundary_conditions[1] == ‘open’`), this property gives the direction of the cylinder axis, in the same coordinates as the
basis
, as a normalized vector. For a 1D lattice or for open boundary conditions along y, it’s just alongbasis[0]
.
- property dim
The dimension of the lattice.
- distance(u1, u2, dx)[source]
Get the distance for a given coupling between two sites in the lattice.
The u1, u2, dx parameters are defined in analogy with
add_coupling()
, i.e., this function calculates the distance between a pair of operators added with add_coupling (using thebasis
andunit_cell_positions
of the lattice).Warning
This function ignores “wrapping” around the cylinder in the case of periodic boundary conditions.
- Parameters:
u1 (int) – Indices within the unit cell; the u1 and u2 of
add_coupling()
u2 (int) – Indices within the unit cell; the u1 and u2 of
add_coupling()
dx (array) – Length
dim
. The translation in terms of basis vectors for the coupling.
- Returns:
distance – The distance between site at lattice indices
[x, y, u1]
and[x + dx[0], y + dx[1], u2]
, ignoring any boundary effects. In case of non-trivialposition_disorder
, an array is returned. This array is compatible with the shape/indexing required foradd_coupling()
. For example to add a Z-Z interaction of strength J/r with r the distance, you can do something like this ininit_terms()
:- for u1, u2, dx in self.lat.pairs[‘nearest_neighbors’]:
dist = self.lat.distance(u1, u2, dx) self.add_coupling(J/dist, u1, ‘Sz’, u2, ‘Sz’, dx)
- Return type:
float | ndarray
- enlarge_mps_unit_cell(factor=2)[source]
Repeat the unit cell for infinite MPS boundary conditions; in place.
- Parameters:
factor (int) – The new number of sites in the MPS unit cell will be increased from N_sites to
factor*N_sites_per_ring
. Since MPS unit cells are repeated in the x-direction in our convention, the lattice shape goes from(Lx, Ly, ..., Lu)
to(Lx*factor, Ly, ..., Lu)
.
- extract_segment(first=0, last=None, enlarge=None)[source]
Extract a finite segment from an infinite/large system.
- Parameters:
first (int) – The first and last site to include into the segment. last defaults to
L
- 1, i.e., the MPS unit cell for infinite MPS.last (int) – The first and last site to include into the segment. last defaults to
L
- 1, i.e., the MPS unit cell for infinite MPS.enlarge (int) – Instead of specifying the first and last site, you can specify this factor by how much the MPS unit cell should be enlarged.
- Returns:
copy – A copy of self with “segment”
bc_MPS
andsegment_first_last
set.- Return type:
Lattice
- find_coupling_pairs(max_dx=3, cutoff=None, eps=1e-10)[source]
Automatically find coupling pairs grouped by distances.
Given the
unit_cell_positions
andbasis
, the couplingpairs
of nearest_neighbors, next_nearest_neighbors etc at a given distance are basically fixed (although not uniquely, since we take out half of them to avoid double-counting couplings in both directionsA_i B_j + B_i A_i
). This function iterates through all possible couplings up to a given cutoff distance and then determines the possiblepairs
at fixed distances (up to round-off errors).- Parameters:
max_dx (int) – Maximal index for each index of dx to iterate over. You need large enough values to include every possible coupling up to the desired distance, but choosing it too large might make this function run for a long time.
cutoff (float) – Maximal distance (in the units in which
basis
andunit_cell_positions
is given).eps (float) – Tolerance up to which to distances are considered the same.
- Returns:
coupling_pairs – Keys are distances of nearest-neighbors, next-nearest-neighbors etc. Values are
[(u1, u2, dx), ...]
as inpairs
.- Return type:
- lat2mps_idx(lat_idx)[source]
Translate lattice indices
(x_0, ..., x_{D-1}, u)
to MPS index i.- Parameters:
lat_idx (array_like [..., dim+1]) – The last dimension corresponds to lattice indices
(x_0, ..., x_{D-1}, u)
. All lattice indices should be positive and smaller than the corresponding entry inself.shape
. Exception: for “infinite” or “segment” bc_MPS, an x_0 outside indicates shifts across the boundary.- Returns:
i – MPS index/indices corresponding to lat_idx. Has the same shape as lat_idx without the last dimension.
- Return type:
array_like
- mps2lat_idx(i)[source]
Translate MPS index i to lattice indices
(x_0, ..., x_{dim-1}, u)
.- Parameters:
- Returns:
lat_idx – First dimensions like i, last dimension has len dim`+1 and contains the lattice indices ``(x_0, …, x_{dim-1}, u)` corresponding to i. For i across the MPS unit cell and “infinite” or “segment” bc_MPS, we shift x_0 accordingly.
- Return type:
array
- mps2lat_values(A, axes=0, u=None)[source]
Reshape/reorder A to replace an MPS index by lattice indices.
- Parameters:
A (ndarray) – Some values. Must have
A.shape[axes] = self.N_sites
if u isNone
, orA.shape[axes] = self.N_cells
if u is an int.axes ((iterable of) int) – chooses the axis which should be replaced.
u (
None
| int) – Optionally choose a subset of MPS indices present in the axes of A, namely the indices corresponding toself.unit_cell[u]
, as returned bymps_idx_fix_u()
. The resulting array will not have the additional dimension(s) of u.
- Returns:
res_A – Reshaped and reordered version of A. Such that MPS indices along the specified axes are replaced by lattice indices, i.e., if MPS index j maps to lattice site (x0, x1, x2), then
res_A[..., x0, x1, x2, ...] = A[..., j, ...]
.- Return type:
ndarray
Examples
Say you measure expectation values of an onsite term for an MPS, which gives you an 1D array A, where A[i] is the expectation value of the site given by
self.mps2lat_idx(i)
. Then this function gives you the expectation values ordered by the lattice:>>> print(lat.shape, A.shape) (10, 3, 2) (60,) >>> A_res = lat.mps2lat_values(A) >>> A_res.shape (10, 3, 2) >>> bool(A_res[tuple(lat.mps2lat_idx(5))] == A[5]) True
If you have a correlation function
C[i, j]
, it gets just slightly more complicated:>>> print(lat.shape, C.shape) (10, 3, 2) (60, 60) >>> lat.mps2lat_values(C, axes=[0, 1]).shape (10, 3, 2, 10, 3, 2)
If the unit cell consists of different physical sites, an onsite operator might be defined only on one of the sites in the unit cell. Then you can use
mps_idx_fix_u()
to get the indices of sites it is defined on, measure the operator on these sites, and use the argument u of this function.>>> u = 0 >>> idx_subset = lat.mps_idx_fix_u(u) >>> A_u = A[idx_subset] >>> A_u_res = lat.mps2lat_values(A_u, u=u) >>> A_u_res.shape (10, 3) >>> bool(np.all(A_res[:, :, u] == A_u_res[:, :])) True
- mps2lat_values_masked(A, axes=-1, mps_inds=None, include_u=None)[source]
Reshape/reorder an array A to replace an MPS index by lattice indices.
This is a generalization of
mps2lat_values()
allowing for the case of an arbitrary set of MPS indices present in each axis of A.- Parameters:
A (ndarray) – Some values.
axes ((iterable of) int) – Chooses the axis of A which should be replaced. If multiple axes are given, you also need to give multiple index arrays as mps_inds.
mps_inds ((list of) 1D ndarray) – Specifies for each axis in axes, for which MPS indices we have values in the corresponding axis of A. Defaults to
[np.arange(A.shape[ax]) for ax in axes]
. For indices across the MPS unit cell and “infinite” bc_MPS, we shift x_0 accordingly.include_u ((list of) bool) – Specifies for each axis in axes, whether the u index of the lattice should be included into the output array res_A. Defaults to
len(self.unit_cell) > 1
.
- Returns:
res_A – Reshaped and reordered copy of A. Such that MPS indices along the specified axes are replaced by lattice indices, i.e., if MPS index j maps to lattice site (x0, x1, x2), then
res_A[..., x0, x1, x2, ...] = A[..., mps_inds[j], ...]
.- Return type:
np.ma.MaskedArray
- mps_idx_fix_u(u=None)[source]
return an index array of MPS indices for which the site within the unit cell is u.
If you have multiple sites in your unit-cell, an onsite operator is in general not defined for all sites. This functions returns an index array of the mps indices which belong to sites given by
self.unit_cell[u]
.- Parameters:
u (None | int) – Selects a site of the unit cell.
None
(default) means all sites.- Returns:
mps_idx – MPS indices for which
self.site(i) is self.unit_cell[u]
. Ordered ascending.- Return type:
array
- mps_lat_idx_fix_u(u=None)[source]
Similar as
mps_idx_fix_u()
, but return also the corresponding lattice indices.- Parameters:
u (None | int) – Selects a site of the unit cell.
None
(default) means all sites.- Returns:
mps_idx (array) – MPS indices i for which
self.site(i) is self.unit_cell[u]
.lat_idx (2D array) – The row j contains the lattice index (without u) corresponding to
mps_idx[j]
.
- mps_sites()[source]
Return a list of sites for all MPS indices.
Equivalent to
[self.site(i) for i in range(self.N_sites)]
.This should be used for sites of 1D tensor networks (MPS, MPO,…).
- multi_coupling_shape(dx)[source]
Calculate correct shape of the strengths for a multi_coupling.
- Parameters:
dx (2D array, shape (N_ops,
dim
)) –dx[i, :]
is the translation vector in the lattice for the i-th operator. Corresponds to the dx of each operator given in the argument ops oftenpy.models.model.CouplingModel.add_multi_coupling()
.- Returns:
coupling_shape (tuple of int) – Len
dim
. The correct shape for an array specifying the coupling strength. lat_indices has only rows within this shape.shift_lat_indices (array) – Translation vector from origin to the lower left corner of box spanned by dx. (Unlike for
coupling_shape()
it can also contain entries > 0)
- ordering(order)[source]
Provide possible orderings of the N lattice sites.
Subclasses often override this function to define additional orderings.
Possible strings for the order defined here are:
'Cstyle', 'default'
:Recommended in most cases. First within the unit cell, then along y, then x.
priority=(0, 1, ..., dim-1, dim)
.'snake', 'snakeCstyle'
:Back and forth along the various directions, in Cstyle priority. Equivalent to
snake_winding=(True, ..., True, True)
andpriority=(0, 1, ..., dim-1, dim)
.'Fstyle'
:Might be good for almost completely decoupled chains in a finite, long ladder/cylinder; in other cases not a good idea. Equivalent to
snake_winding=(False, ..., False, False)
andpriority=(dim-1, ..., 1., 0, dim)
.'snakeFstyle'
:Snake-winding for Fstyle. Equivalent to
snake_winding=(True, ..., True, True)
andpriority=(dim-1, ..., 1., 0, dim)
.
(
Source code
,png
,hires.png
,pdf
)Note
For lattices with a non-trivial unit cell (e.g. Honeycomb, Kagome), the grouped order might be more appropriate, see
get_order_grouped()
.- Parameters:
order (str |
('standard', snake_winding, priority)
|('grouped', groups, ...)
) – Specifies the desired ordering using one of the strings of the above tables. Alternatively, an ordering is specified by a tuple with first entry specifying a function,'standard'
forget_order()
and'grouped'
forget_order_grouped()
, and other arguments in the tuple as specified in the documentation of these functions.- Returns:
order – the order to be used for
order
.- Return type:
array, shape (N, D+1), dtype np.intp
See also
get_order
generates the order from equivalent priority and snake_winding.
get_order_grouped
variant of get_order.
plot_order
visualizes the resulting order.
- plot_basis(ax, origin=(0.0, 0.0), shade=None, **kwargs)[source]
Plot arrows indicating the basis vectors of the lattice.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.**kwargs – Keyword arguments for
ax.arrow
.
- plot_bc_identified(ax, direction=-1, origin=None, cylinder_axis=False, **kwargs)[source]
Mark two sites identified by periodic boundary conditions.
Works only for lattice with a 2-dimensional basis.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.direction (int) – The direction of the lattice along which we should mark the identified sites. If
None
, mark it along all directions with periodic boundary conditions.cylinder_axis (bool) – Whether to plot the cylinder axis as well.
origin (None | np.ndarray) – The origin starting from where we mark the identified sites. Defaults to the first entry of
unit_cell_positions
.**kwargs – Keyword arguments for the used
ax.plot
.
- plot_brillouin_zone(ax, *args, **kwargs)[source]
Plot the Brillouin Zone of the lattice.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.*args – arguments for
plot_brillouin_zone()
of :class:self.BZ.__class__
.**kwargs – Keyword arguments for
plot_brillouin_zone()
of :class:self.BZ.__class__
.
- plot_coupling(ax, coupling=None, wrap=False, **kwargs)[source]
Plot lines connecting nearest neighbors of the lattice.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.coupling (list of (u1, u2, dx)) – By default (
None
), useself.pairs['nearest_neighbors']
. Specifies the connections to be plotted; iterating over lattice indices (i0, i1, …), we plot a connection from the site(i0, i1, ..., u1)
to the site(i0+dx[0], i1+dx[1], ..., u2)
, taking into account the boundary conditions.wrap (bool) – If
True
, plot couplings going around the boundary by directly connecting the sites it connects. This might be hard to see, as this puts lines from one end of the lattice to the other. IfFalse
, plot the couplings as dangling lines.**kwargs – Further keyword arguments given to
ax.plot()
.
- plot_order(ax, order=None, textkwargs={'color': 'r'}, **kwargs)[source]
Plot a line connecting sites in the specified “order” and text labels enumerating them.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.order (None | 2D array (self.N_sites, self.dim+1)) – The order as returned by
ordering()
; by default (None
) useorder
.textkwargs (
None
| dict) – If notNone
, we add text labels enumerating the sites in the plot. The dictionary can contain keyword arguments forax.text()
.**kwargs – Further keyword arguments given to
ax.plot()
.
- plot_reciprocal_basis(ax, origin=(0.0, 0.0), plot_symmetric=True, **kwargs)[source]
Plot arrows indicating the basis vectors of the reciprocal lattice.
(Same as
plot_basis()
, but without shading, since Brillouin zone is drawn separately)- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.plot_symmetric (bool, default=True) – if True, centers the plot around the origin
origin (iterable) – coordinates of the origin
**kwargs – Keyword arguments for
ax.arrow
.
- plot_sites(ax, markers=['o', '^', 's', 'p', 'h', 'D'], labels=None, **kwargs)[source]
Plot the sites of the lattice with markers.
- Parameters:
ax (
matplotlib.axes.Axes
) – The axes on which we should plot.markers (list) – List of values for the keyword marker of
ax.plot()
to distinguish the different sites in the unit cell, a site u in the unit cell is plotted with a markermarkers[u % len(markers)]
.labels (list of str) – Labels for the different sites in the unit cell.
**kwargs – Further keyword arguments given to
ax.plot()
.
- position(lat_idx)[source]
return ‘space’ position of one or multiple sites.
- Parameters:
lat_idx (ndarray,
(... , dim+1)
) – Lattice indices.- Returns:
pos – The position of the lattice sites specified by lat_idx in real-space. If
position_disorder
is non-trivial, it can shift the positions!- Return type:
ndarray,
(..., Dim)
- possible_couplings(u1, u2, dx, strength=None)[source]
Find possible MPS indices for two-site couplings.
For periodic boundary conditions (
bc[a] == False
) the indexx_a
is taken moduloLs[a]
and runs throughrange(Ls[a])
. For open boundary conditions,x_a
is limited to0 <= x_a < Ls[a]
and0 <= x_a+dx[a] < lat.Ls[a]
.- Parameters:
u1 (int) – Indices within the unit cell; the u1 and u2 of
add_coupling()
u2 (int) – Indices within the unit cell; the u1 and u2 of
add_coupling()
dx (array) – Length
dim
. The translation in terms of basis vectors for the coupling.strength (array_like | None) – If given, instead of returning lat_indices and coupling_shape directly return the correct strength_12.
- Returns:
mps1, mps2 (1D array) – For each possible two-site coupling the MPS indices for the u1 and u2.
strength_vals (1D array) – (Only returned if strength is not None.) Such that
for (i, j, s) in zip(mps1, mps2, strength_vals):
iterates over all possible couplings with s being the strength of that coupling. Couplings wherestrength_vals == 0.
are filtered out.lat_indices (2D int array) – (Only returned if strength is None.) Rows of lat_indices correspond to entries of mps1 and mps2 and contain the lattice indices of the “lower left corner” of the box containing the coupling.
coupling_shape (tuple of int) – (Only returned if strength is None.) Len
dim
. The correct shape for an array specifying the coupling strength. lat_indices has only rows within this shape.
- possible_multi_couplings(ops, strength=None)[source]
Generalization of
possible_couplings()
to couplings with more than 2 sites.- Parameters:
ops (list of
(opname, dx, u)
) – Same as the argument ops ofadd_multi_coupling()
.- Returns:
mps_ijkl (2D int array) – Each row contains MPS indices i,j,k,l,…` for each of the operators positions. The positions are defined by dx (j,k,l,… relative to i) and boundary conditions of self (how much the box for given dx can be shifted around without hitting a boundary - these are the different rows).
strength_vals (1D array) – (Only returned if strength is not None.) Such that
for (ijkl, s) in zip(mps_ijkl, strength_vals):
iterates over all possible couplings with s being the strength of that coupling. Couplings wherestrength_vals == 0.
are filtered out.lat_indices (2D int array) – (Only returned if strength is None.) Rows of lat_indices correspond to rows of mps_ijkl and contain the lattice indices of the “lower left corner” of the box containing the coupling.
coupling_shape (tuple of int) – (Only returned if strength is None.) Len
dim
. The correct shape for an array specifying the coupling strength. lat_indices has only rows within this shape.
- property reciprocal_basis
Reciprocal basis vectors of the lattice.
The reciprocal basis vectors obey \(a_i b_j = 2 \pi \delta_{i, j}\), such that
b_j = reciprocal_basis[j]