def calcModes(self, n_modes=20, turbo=True):
"""Calculate principal (or essential) modes. This method uses
:func:`scipy.linalg.eigh`, or :func:`numpy.linalg.eigh`, function
to diagonalize the covariance matrix.
:arg n_modes: number of non-zero eigenvalues/vectors to calculate,
default is 20,
if **None** or ``'all'`` is given, all modes will be calculated
:type n_modes: int
:arg turbo: when available, use a memory intensive but faster way to
calculate modes, default is **True**
:type turbo: bool"""
if self._cov is None:
raise ValueError('covariance matrix is not built or set')
start = time.time()
self._clear()
if str(n_modes).lower() == 'all':
n_modes = None
values, vectors, _ = solveEig(self._cov,
n_modes=n_modes,
zeros=True,
turbo=turbo,
reverse=True)
which = values > ZERO
self._eigvals = values[which]
self._array = vectors[:, which]
self._vars = values
self._n_modes = len(self._eigvals)
LOGGER.debug('{0} modes were calculated in {1:.2f}s.'.format(
self._n_modes,
time.time() - start))
def calcModes(self, n_modes=20, zeros=False, turbo=True):
"""Calculate normal modes. This method uses :func:`scipy.linalg.eigh`
function to diagonalize the Kirchhoff matrix. When Scipy is not found,
:func:`numpy.linalg.eigh` is used.
:arg n_modes: number of non-zero eigenvalues/vectors to calculate.
If **None** or ``'all'`` is given, all modes will be calculated.
:type n_modes: int or None, default is 20
:arg zeros: If **True**, modes with zero eigenvalues will be kept.
:type zeros: bool, default is **True**
:arg turbo: Use a memory intensive, but faster way to calculate modes.
:type turbo: bool, default is **True**
"""
if self._kirchhoff is None:
raise ValueError('Kirchhoff matrix is not built or set')
if str(n_modes).lower() == 'all':
n_modes = None
assert n_modes is None or isinstance(n_modes, int) and n_modes > 0, \
'n_modes must be a positive integer'
assert isinstance(zeros, bool), 'zeros must be a boolean'
assert isinstance(turbo, bool), 'turbo must be a boolean'
self._clear()
LOGGER.timeit('_gnm_calc_modes')
values, vectors, vars = solveEig(self._kirchhoff,
n_modes=n_modes,
zeros=zeros,
turbo=turbo,
expct_n_zeros=1)
self._eigvals = values
self._array = vectors
self._vars = vars
self._trace = self._vars.sum()
self._n_modes = len(self._eigvals)
if self._n_modes > 1:
LOGGER.report('{0} modes were calculated in %.2fs.'.format(
self._n_modes),
label='_anm_calc_modes')
else:
LOGGER.report('{0} mode was calculated in %.2fs.'.format(
self._n_modes),
label='_anm_calc_modes')
def calcPrincAxes(coords, turbo=True):
"""Calculate principal axes from coords"""
M = calcInertiaTensor(coords)
_, vectors, _ = solveEig(M, 3, zeros=True, turbo=turbo, reverse=True)
return vectors