conatus.expert.EVPResult

class conatus.expert.EVPResult(values, vectors, residuals, method, label='', n_infinite=0, left=None, drift=None, log=<factory>, context=None, eigenvalue='sigma', growth=None, growth_note='', filter_note=None, tails=None, spurious=None, spurious_note='', unresolved_note='')

Bases: object

Eigenvalues sigma of (L + sigma M) x = 0 for one group, with residuals and a filter log.

Parameters:

• values (ndarray)

• vectors (ndarray | None)

• residuals (ndarray)

• method (str)

• label (str)

• n_infinite (int)

• left (ndarray | None)

• drift (ndarray | None)

• log (list[str])

• context (Any)

• eigenvalue (str)

• growth (Any)

• growth_note (str)

• filter_note (str | None)

• tails (ndarray | None)

• spurious (ndarray | None)

• spurious_note (str)

• unresolved_note (str)

values: ndarray

vectors: ndarray | None

residuals: ndarray

method: str

label: str = ''

n_infinite: int = 0

left: ndarray | None = None

drift: ndarray | None = None

log: list[str]

context: Any = None

eigenvalue: str = 'sigma'

growth: Any = None

growth_note: str = ''

filter_note: str | None = None

tails: ndarray | None = None

spurious: ndarray | None = None

spurious_note: str = ''

unresolved_note: str = ''

property flagged: ndarray

Indices of the modes flagged spurious by the spectral-tail test (empty if none, or if the test did not run: see spurious_note).

property unresolved: ndarray

Indices of the modes that pass the spectral-tail flag but whose tail exceeds the stricter conatus.tolerances.UNRESOLVED_TAIL_TOL (under-resolved physical modes). Empty if the tail test did not run. Kept and ranked as any mode: the result says it (unresolved_note) when the selected mode order()[0] is one of them.

mode(i)

Eigenfunction i on the grid (conatus.solvers.evp_modes.EVPMode): named unknowns (tau variables left out) on the physical grid, .grid("v"), .coordinate("y"), normalised by the declared rule evp_modes.NORMALIZATION.

Parameters:

i (int)

growth_rule()

How order() (key='growth') ranks the modes, in words.

Return type:

str

order(key='growth')

Indices from the least to the most stable mode by the declared growth convention of the eigenvalue (key='growth': Re s for exp(s t), Im c for a phase speed c; an undeclared convention ranks by Re, said by growth_rule()), or by decreasing real part ('real') or imaginary part ('imag').

Modes flagged spurious by the spectral-tail test (flagged) come after every mode that passes it (each part ranked by key): order()[0] is the least stable mode that passes; the result keeps one index per mode.

Parameters:

key (str)

Return type:

ndarray

select(idx, why)

The modes idx, with why appended to the log (nothing is dropped silently).

Parameters:

• idx (Sequence[int] | ndarray)

• why (str)

Return type:

EVPResult

explain(n=6, key='growth', *, full=False)

Counts (finite, infinite, filtered), the filters that removed modes, the growth convention and the n first modes with residuals. full=True: the whole log (pencil regularity, infinite-eigenvalue test, solver tolerances).

Parameters:

• n (int)

• key (str)

• full (bool)

Return type:

str