BosonSite¶

full name: tenpy.networks.site.BosonSite
parent module: tenpy.networks.site
type: class

Inheritance Diagram

Methods

`BosonSite.__init__`([Nmax, conserve, filling])
`BosonSite.add_op`(name, op[, need_JW, hc, ...])	Add one on-site operators.
`BosonSite.change_charge`([new_leg_charge, ...])	Change the charges of the site (in place).
`BosonSite.from_hdf5`(hdf5_loader, h5gr, subpath)	Load instance from a HDF5 file.
`BosonSite.get_hc_op_name`(name)	Return the hermitian conjugate of a given operator.
`BosonSite.get_op`(name)	Return operator of given name.
`BosonSite.multiply_op_names`(names)	Multiply operator names together.
`BosonSite.multiply_operators`(operators)	Multiply local operators (possibly given by their names) together.
`BosonSite.op_needs_JW`(name)	Whether an (composite) onsite operator is fermionic and needs a Jordan-Wigner string.
`BosonSite.remove_op`(name)	Remove an added operator.
`BosonSite.rename_op`(old_name, new_name)	Rename an added operator.
`BosonSite.save_hdf5`(hdf5_saver, h5gr, subpath)	Export self into a HDF5 file.
`BosonSite.sort_charge`([bunch])	Sort the `leg` charges (in place).
`BosonSite.state_index`(label)	Return index of a basis state from its label.
`BosonSite.state_indices`(labels)	Same as `state_index()`, but for multiple labels.
`BosonSite.test_sanity`()	Sanity check, raises ValueErrors, if something is wrong.
`BosonSite.valid_opname`(name)	Check whether 'name' labels a valid onsite-operator.

Class Attributes and Properties

`BosonSite.dim`	Dimension of the local Hilbert space.
`BosonSite.onsite_ops`	Dictionary of on-site operators for iteration.

class tenpy.networks.site.BosonSite(Nmax=1, conserve='N', filling=0.0)[source]¶

Bases: Site

Create a Site for up to Nmax bosons.

Local states are vac, 1, 2, ... , Nc. (Exception: for parity conservation, we sort as vac, 2, 4, ..., 1, 3, 5, ....)

operator	description
`Id, JW`	Identity \(\mathbb{1}\)
`B`	Annihilation operator \(b\)
`Bd`	Creation operator \(b^\dagger\)
`N`	Number operator \(n= b^\dagger b\)
`NN`	\(n^2\)
`dN`	\(\delta n := n - filling\)
`dNdN`	\((\delta n)^2\)
`P`	Parity \(Id - 2 (n \mod 2)\).

conserve	qmod	excluded onsite operators
`'N'`	[1]	–
`'parity'`	[2]	–
`'None'`	[]	–

Parameters

Nmax (int) – Cutoff defining the maximum number of bosons per site. The default Nmax=1 describes hard-core bosons.
conserve (str) – Defines what is conserved, see table above.
filling (float) – Average filling. Used to define dN.

conserve¶

Defines what is conserved, see table above.

Type: str

filling¶

Average filling. Used to define dN.

Type: float

add_op(name, op, need_JW=False, hc=None, permute_dense=None)[source]¶

Add one on-site operators.

Parameters

name (str) – A valid python variable name, used to label the operator. The name under which op is added as attribute to self.
op (np.ndarray | Array) – A matrix acting on the local hilbert space representing the local operator. Dense numpy arrays are automatically converted to Array. LegCharges have to be [leg, leg.conj()]. We set labels 'p', 'p*'.
need_JW (bool) – Whether the operator needs a Jordan-Wigner string. If True, add name to need_JW_string.
hc (None | False | str) – The name for the hermitian conjugate operator, to be used for hc_ops. By default (None), try to auto-determine it. If False, disable adding antries to hc_ops.
permute_dense (bool | None) – Flag to enable/disable permuations when converting op from numpy to np_conserved arrays. If True, the operator is permuted with perm to account for permutations induced by sorting charges; False disables the permutations. By default (None), the value of used_sort_charge is used.

change_charge(new_leg_charge=None, permute=None)[source]¶

Change the charges of the site (in place).

Parameters

new_leg_charge (LegCharge | None) – The new charges to be used. If None, use trivial charges.
permute (ndarray | None) – The permuation applied to the physical leg, which also gets used to adjust state_labels and perm. If you sorted the previous leg with perm_qind, new_leg_charge = leg.sort(), use old_leg.perm_flat_from_perm_qind(perm_qind). Ignored if None.

property dim¶: Dimension of the local Hilbert space.

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_hc_op_name(name)[source]¶

Return the hermitian conjugate of a given operator.

Parameters: name (str) – The name of the operator to be returned. Multiple operators separated by whitespace are interpreted as an operator product, exactly as get_op() does.
Returns: hc_op_name – Operator name for the hermi such that get_op() of
Return type: str

get_op(name)[source]¶

Return operator of given name.

Parameters: name (str) – The name of the operator to be returned. In case of multiple operator names separated by whitespace, we multiply them together to a single on-site operator (with the one on the right acting first).
Returns: op – The operator given by name, with labels 'p', 'p*'. If name already was an npc Array, it’s directly returned.
Return type: np_conserved

multiply_op_names(names)[source]¶

Multiply operator names together.

Join the operator names in names such that get_op returns the product of the corresponding operators.

Parameters: names (list of str) – List of valid operator labels.
Returns: combined_opname – A valid operator name Operatorname representing the product of operators in names.
Return type: str

multiply_operators(operators)[source]¶

Multiply local operators (possibly given by their names) together.

Parameters: operators (list of {str | Array}) – List of valid operator names (to be translated with get_op()) or directly on-site operators in the form of npc arrays with 'p', 'p*' label. The operators are multiplied left-to-right.
Returns: combined_operator – The product of the given operators in a left-to-right multiplication following the usual mathematical convention. For example, if operators=['Sz', 'Sp', 'Sx'], the final operator is equivalent to site.get_op('Sz Sp Sx'), with the 'Sx' operator acting first on any physical state.
Return type: Array

property onsite_ops¶

Dictionary of on-site operators for iteration.

Single operators are accessible as attributes.

op_needs_JW(name)[source]¶

Whether an (composite) onsite operator is fermionic and needs a Jordan-Wigner string.

Parameters: name (str) – The name of the operator, as in get_op().
Returns: needs_JW – Whether the operator needs a Jordan-Wigner string, judging from need_JW_string.
Return type: bool

remove_op(name)[source]¶

Remove an added operator.

Parameters: name (str) – The name of the operator to be removed.

rename_op(old_name, new_name)[source]¶

Rename an added operator.

Parameters

old_name (str) – The old name of the operator.
new_name (str) – The new name of the operator.

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().

This implementation saves the content of __dict__ with save_dict_content(), storing the format under the attribute 'format'.

Parameters

hdf5_saver (Hdf5Saver) – Instance of the saving engine.
h5gr (:class`Group`) – HDF5 group which is supposed to represent self.
subpath (str) – The name of h5gr with a '/' in the end.

sort_charge(bunch=True)[source]¶

Sort the leg charges (in place).

Parameters: bunch (bool) – Whether to also group equal charges into larger blocks (usually a good idea).
Returns: perm – The permutation
Return type: 1D ndarray

state_index(label)[source]¶

Return index of a basis state from its label.

Parameters: label (int | string) – eather the index directly or a label (string) set before.
Returns: state_index – the index of the basis state associated with the label.
Return type: int

state_indices(labels)[source]¶: Same as state_index(), but for multiple labels.

test_sanity()[source]¶: Sanity check, raises ValueErrors, if something is wrong.

valid_opname(name)[source]¶

Check whether ‘name’ labels a valid onsite-operator.

Parameters: name (str) – Label for the operator. Can be multiple operator(labels) separated by whitespace, indicating that they should be multiplied together.
Returns: valid – True if name is a valid argument to get_op().
Return type: bool