ModeCPhonon¶

class sisl.physics.phonon.ModeCPhonon(state, c, parent=None, **info)[source]¶

A mode describing a physical quantity related to phonons, with associated coefficients of the mode

Attributes

`c`
`dkind`	The data-type of the state (in str)
`dtype`	Data-type for the state
`info`
`mode`
`parent`
`shape`	Returns the shape of the state
`state`

Methods

`__init__`(state, c[, parent])	Define a state container with a given set of states and coefficients for the states
`asCoefficient`()
`asState`()
`change_gauge`(gauge)	In-place change of the gauge of the mode coefficients
`copy`()	Return a copy (only the coefficients and states are copied), `parent` and `info` are passed by reference
`degenerate`(eps)	Find degenerate coefficients with a specified precision
`iter`([asarray])	An iterator looping over the states in this system
`norm`()	Return a vector with the norm of each state \(\sqrt{\langle\psi\|\psi\rangle}\)
`norm2`([sum])	Return a vector with the norm of each state \(\langle\psi\|\psi\rangle\)
`normalize`()	Return a normalized state where each state has \(\|\psi\|^2=1\)
`outer`([idx])	Return the outer product for the indices idx (or all if `None`) by \(\sum_i\|\psi_i\rangle c_i\langle\psi_i\|\)
`sort`([ascending])	Sort and return a new `StateC` by sorting the coefficients (default to ascending)
`sub`(idx)	Return a new state with only the specified states
`velocity`([eps])	Calculate velocity for the modes

asCoefficient()¶

asState()¶

c¶

change_gauge(gauge)¶

In-place change of the gauge of the mode coefficients

The two gauges are related through:

\[\tilde C_j = e^{i\mathbf k\mathbf r_j} C_j\]

where \(C_j\) belongs to the gauge R and \(\tilde C_j\) is in the gauge r.

Parameters:	gauge : {‘R’, ‘r’} specify the new gauge for the mode coefficients

copy()¶: Return a copy (only the coefficients and states are copied), parent and info are passed by reference

degenerate(eps)¶

Find degenerate coefficients with a specified precision

Parameters:	eps : float the precision above which coefficients are not considered degenerate
Returns:	list of numpy.ndarray: a list of indices

dkind¶: The data-type of the state (in str)

dtype¶: Data-type for the state

info¶

iter(asarray=False)¶

An iterator looping over the states in this system

Parameters:	asarray: bool, optional if true the yielded values are the state vectors, i.e. a numpy array. Otherwise an equivalent object is yielded.
Yields:	state : State a state only containing individual elements, if asarray is false state : numpy.ndarray a state only containing individual elements, if asarray is true

mode¶

norm()¶

Return a vector with the norm of each state \(\sqrt{\langle\psi|\psi\rangle}\)

Returns:	numpy.ndarray the normalization for each state

norm2(sum=True)¶

Return a vector with the norm of each state \(\langle\psi|\psi\rangle\)

Parameters:	sum : bool, 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

normalize()¶

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:	state : a new state with all states normalized, otherwise equal to this

outer(idx=None)¶

Return the outer product for the indices idx (or all if None) by \(\sum_i|\psi_i\rangle c_i\langle\psi_i|\)

Parameters:	idx : int or array_like, optional only perform an outer product of the specified indices, otherwise all states are used
Returns:	numpy.ndarray : a matrix with the sum of outer state products

parent¶

shape¶: Returns the shape of the state

sort(ascending=True)¶

Sort and return a new StateC by sorting the coefficients (default to ascending)

Parameters:	ascending : bool, optional sort the contained elements ascending, else they will be sorted descending

state¶

sub(idx)¶

Return a new state with only the specified states

Parameters:	idx : int or array_like indices that are retained in the returned object
Returns:	StateC : a new object with a subset of the states

velocity(eps=1e-07)[source]¶

Calculate velocity for the modes

This routine calls velocity with appropriate arguments and returns the velocity for the modes.

Note that the coefficients associated with the ModeCPhonon must correspond to the energies of the modes.

See velocity for details.

Parameters:	eps : float, optional precision used to find degenerate modes.

Notes

The eigenvectors for the modes may have changed after calling this routine. This is because of the velocity un-folding for degenerate modes. I.e. calling displacement and/or PDOS after this method may change the result.