StateC¶
-
class
sisl.physics.
StateC
(state, c, parent=None, **info)[source]¶ An object handling a set of vectors describing a given state with associated coefficients
c
- Parameters
- statearray_like
state vectors
state[i, :]
containing the i’th state vector- carray_like
coefficients for the states
c[i]
containing the i’th coefficient- parentobj, optional
a parent object that defines the origin of the state.
- **infodict, optional
an info dictionary that turns into an attribute on the object. This
info
may contain anything that may be relevant for the state.
Notes
This class should be subclassed!
- Attributes
- cndarray
coefficients assigned to each state
- statendarray
state coefficients
- infodict
information regarding the creation of the states
- parentobj
object from where the states has been calculated, in one way or the other
Attributes
The data-type of the state (in str)
Data-type for the state
Returns the shape of the state
Methods
__init__
(self, state, c[, parent])Define a state container with a given set of states and coefficients for the states
align
(self, other[, copy])Align other.state with the angles for this state, a copy of other is returned with rotated elements
asCoefficient
(self)asState
(self)copy
(self)Return a copy (only the coefficients and states are copied),
parent
andinfo
are passed by referencedegenerate
(self, eps)Find degenerate coefficients with a specified precision
inner
(self[, right, diagonal, align])Return the inner product by \(\mathbf M_{ij} = \langle\psi_i|\psi'_j\rangle\)
iter
(self[, asarray])An iterator looping over the states in this system
norm
(self)Return a vector with the norm of each state \(\sqrt{\langle\psi|\psi\rangle}\)
norm2
(self[, sum])Return a vector with the norm of each state \(\langle\psi|\psi\rangle\)
normalize
(self)Return a normalized state where each state has \(|\psi|^2=1\)
outer
(self[, idx])Return the outer product for the indices idx (or all if
None
) by \(\sum_i|\psi_i\rangle c_i\langle\psi_i|\)phase
(self[, method, return_indices])Calculate the Euler angle (phase) for the elements of the state, in the range \(]-\pi;\pi]\)
rotate
(self[, phi, individual])Rotate all states (in-place) to rotate the largest component to be along the angle phi
sort
(self[, ascending])Sort and return a new
StateC
by sorting the coefficients (default to ascending)sub
(self, idx)Return a new state with only the specified states
-
align
(self, other, copy=False)¶ Align other.state with the angles for this state, a copy of other is returned with rotated elements
States will be rotated by \(\pi\) provided the phase difference between the states are above \(|\Delta\theta| > \pi/2\).
- Parameters
- otherState
the other state to align onto this state
- copybool, optional
sometimes no states require rotation, if this is the case this flag determines whether other will be copied or not
-
c
¶
-
copy
(self)[source]¶ Return a copy (only the coefficients and states are copied),
parent
andinfo
are passed by reference
-
degenerate
(self, eps)[source]¶ Find degenerate coefficients with a specified precision
- Parameters
- epsfloat
the precision above which coefficients are not considered degenerate
- Returns
- list of numpy.ndarraya list of indices
-
property
dkind
¶ The data-type of the state (in str)
-
property
dtype
¶ Data-type for the state
-
info
¶
-
inner
(self, right=None, diagonal=True, align=True)¶ Return the inner product by \(\mathbf M_{ij} = \langle\psi_i|\psi'_j\rangle\)
- Parameters
- rightState, optional
the right object to calculate the inner product with, if not passed it will do the inner product with itself. This object will always be the left \(\langle\psi_i|\)
- diagonalbool, optional
only return the diagonal matrix \(\mathbf M_{ii}\).
- alignbool, optional
first align right with the angles for this state (see
align
)
- Returns
- numpy.ndarray
a matrix with the sum of outer state products
Notes
This does not take into account a possible overlap matrix when non-orthogonal basis sets are used.
-
iter
(self, asarray=False)¶ An iterator looping over the states in this system
- Parameters
- asarraybool, optional
if true the yielded values are the state vectors, i.e. a numpy array. Otherwise an equivalent object is yielded.
- Yields
- stateState
a state only containing individual elements, if asarray is false
- statenumpy.ndarray
a state only containing individual elements, if asarray is true
-
norm
(self)¶ Return a vector with the norm of each state \(\sqrt{\langle\psi|\psi\rangle}\)
- Returns
- numpy.ndarray
the normalization for each state
-
norm2
(self, sum=True)¶ Return a vector with the norm of each state \(\langle\psi|\psi\rangle\)
- Parameters
- sumbool, optional
if true the summed site square is returned (a vector). For false a matrix with normalization squared per site is returned.
- Returns
- numpy.ndarray
the normalization for each state
Notes
This does not take into account a possible overlap matrix when non-orthogonal basis sets are used.
-
normalize
(self)[source]¶ Return a normalized state where each state has \(|\psi|^2=1\)
This is roughly equivalent to:
>>> state = StateC(np.arange(10), 1) >>> n = state.norm() >>> norm_state = StateC(state.state / n.reshape(-1, 1), state.c.copy()) >>> norm_state.c[0] == 1
- Returns
- statea new state with all states normalized, otherwise equal to this
-
outer
(self, idx=None)[source]¶ Return the outer product for the indices idx (or all if
None
) by \(\sum_i|\psi_i\rangle c_i\langle\psi_i|\)- Parameters
- idxint or array_like, optional
only perform an outer product of the specified indices, otherwise all states are used
- Returns
- numpy.ndarraya matrix with the sum of outer state products
-
parent
¶
-
phase
(self, method='max', return_indices=False)¶ Calculate the Euler angle (phase) for the elements of the state, in the range \(]-\pi;\pi]\)
- Parameters
- method{‘max’, ‘all’}
for max, the phase for the element which has the largest absolute magnitude is returned, for all, all phases are calculated
- return_indicesbool, optional
return indices for the elements used when
method=='max'
-
rotate
(self, phi=0.0, individual=False)¶ Rotate all states (in-place) to rotate the largest component to be along the angle phi
The states will be rotated according to:
\[S' = S / S^\dagger_{\phi-\mathrm{max}} \exp (i \phi),\]where \(S^\dagger_{\phi-\mathrm{max}}\) is the phase of the component with the largest amplitude and \(\phi\) is the angle to align on.
- Parameters
- phifloat, optional
angle to align the state at (in radians), 0 is the positive real axis
- individualbool, optional
whether the rotation is per state, or a single maximum component is chosen.
-
property
shape
¶ Returns the shape of the state
-
sort
(self, ascending=True)[source]¶ Sort and return a new
StateC
by sorting the coefficients (default to ascending)- Parameters
- ascendingbool, optional
sort the contained elements ascending, else they will be sorted descending
-
state
¶