NormalModeAnalyzer¶

class pylimer_tools_cpp.NormalModeAnalyzer(self: pylimer_tools_cpp.NormalModeAnalyzer, spring_from: collections.abc.Sequence[SupportsInt], spring_to: collections.abc.Sequence[SupportsInt])¶

Bases: pybind11_object

Compute the normal modes and predict the loss/storage moduli.

Please cite Gusev and Bernhard [GB24] if you use this method in your work.

Initialize the NormalModeAnalyzer with the bonds (edges).

Constructs the connectivity matrix from the given edges.

Parameters:

spring_from – Vector of starting node indices for springs/bonds
spring_to – Vector of ending node indices for springs/bonds

Methods Summary

`compute_chebyshev_moments_kpm`(self[, ...])	Compute Chebyshev moments using the Kernel Polynomial Method (KPM).
`compute_density_of_states_kpm`(self, lambda_grid)	Compute continuous density of states (DOS) using KPM.
`evaluate_loss_modulus`(self, omega)	Evaluate the loss modulus \(G''(\omega)\).
`evaluate_loss_modulus_kpm`(self, omega[, ...])	Evaluate loss modulus G'' directly using KPM without computing eigenvalues.
`evaluate_storage_modulus`(self, omega)	Evaluate the storage modulus \(G'(\omega)\).
`evaluate_storage_modulus_kpm`(self, omega[, ...])	Evaluate storage modulus G' directly using KPM without computing eigenvalues.
`evaluate_stress_autocorrelation`(self, t)	Evaluate stress autocorrelation \(C(t)\).
`evaluate_stress_autocorrelation_kpm`(self, t)	Evaluate stress autocorrelation directly using KPM without computing eigenvalues.
`find_all_eigenvalues`(self[, solver, ...])	Find all eigenvalues using the specified solver.
`find_sparse_eigenvalues`(self, nr_of_eigenvalues)	Find the k smallest eigenvalues using a sparse solver.
`get_eigenvalues`(self)	Get the eigenvalues.
`get_eigenvectors`(self)	Get eigenvectors.
`get_matrix`(self)	Get the assembled connectivity matrix.
`get_matrix_size`(self)	Get the size of the matrix (the maximum number of eigenvalues that could be queried).
`get_nr_of_soluble_clusters`(self)	Get the number of soluble clusters (eigenvalues = 0).
`set_eigenvalues`(self, eigenvalues)	Set the eigenvalues, e.g. if you use an external solver.
`set_eigenvectors`(self, eigenvectors)	Set eigenvectors, e.g. if you use an external solver.

Methods Documentation

compute_chebyshev_moments_kpm(self: pylimer_tools_cpp.NormalModeAnalyzer, num_moments: SupportsInt = 1024, num_random_vectors: SupportsInt = 20) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Compute Chebyshev moments using the Kernel Polynomial Method (KPM).

Parameters:

num_moments – Number of moments to compute (default: 1024)
num_random_vectors – Number of random Rademacher vectors for trace estimation (default: 20)

Returns:

Vector of damped Chebyshev moments

compute_density_of_states_kpm(self: pylimer_tools_cpp.NormalModeAnalyzer, lambda_grid: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]'], num_moments: SupportsInt = 1024, num_random_vectors: SupportsInt = 20) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Compute continuous density of states (DOS) using KPM.

Parameters:

lambda_grid – Eigenvalue points at which to evaluate DOS
num_moments – Number of Chebyshev moments (default: 1024)
num_random_vectors – Number of random vectors (default: 20)

Returns:

Density of states values on the grid

evaluate_loss_modulus(self: pylimer_tools_cpp.NormalModeAnalyzer, omega: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate the loss modulus \(G''(\omega)\). Yet misses the conversion factor.

Parameters:: omega – Angular frequencies
Returns:: Loss modulus values

evaluate_loss_modulus_kpm(self: pylimer_tools_cpp.NormalModeAnalyzer, omega: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]'], num_moments: SupportsInt = 1024, num_random_vectors: SupportsInt = 20, num_quadrature_points: SupportsInt = 2048) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate loss modulus G’’ directly using KPM without computing eigenvalues.

Parameters:

omega – Angular frequencies to evaluate
num_moments – Number of Chebyshev moments (default: 1024)
num_random_vectors – Number of random vectors (default: 20)
num_quadrature_points – Number of Gauss-Chebyshev quadrature points (default: 2048)

Returns:

Loss modulus values

evaluate_storage_modulus(self: pylimer_tools_cpp.NormalModeAnalyzer, omega: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate the storage modulus \(G'(\omega)\). Yet misses the conversion factor.

Parameters:: omega – Angular frequencies
Returns:: Storage modulus values

evaluate_storage_modulus_kpm(self: pylimer_tools_cpp.NormalModeAnalyzer, omega: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]'], num_moments: SupportsInt = 1024, num_random_vectors: SupportsInt = 20, num_quadrature_points: SupportsInt = 2048) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate storage modulus G’ directly using KPM without computing eigenvalues.

Parameters:

omega – Angular frequencies to evaluate
num_moments – Number of Chebyshev moments (default: 1024)
num_random_vectors – Number of random vectors (default: 20)
num_quadrature_points – Number of Gauss-Chebyshev quadrature points (default: 2048)

Returns:

Storage modulus values

evaluate_stress_autocorrelation(self: pylimer_tools_cpp.NormalModeAnalyzer, t: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate stress autocorrelation \(C(t)\).

Parameters:: t – The time at which to evaluate the stress autocorrelation
Returns:: Stress autocorrelation values

evaluate_stress_autocorrelation_kpm(self: pylimer_tools_cpp.NormalModeAnalyzer, t: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]'], num_moments: SupportsInt = 1024, num_random_vectors: SupportsInt = 20, num_quadrature_points: SupportsInt = 2048) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Evaluate stress autocorrelation directly using KPM without computing eigenvalues.

Parameters:

t – Time points to evaluate
num_moments – Number of Chebyshev moments (default: 1024)
num_random_vectors – Number of random vectors (default: 20)
num_quadrature_points – Number of Gauss-Chebyshev quadrature points (default: 2048)

Returns:

Stress autocorrelation values

find_all_eigenvalues(self: pylimer_tools_cpp.NormalModeAnalyzer, solver: object = 'auto', compute_eigenvectors: bool = False, decompose_components: bool = True) → None¶

Find all eigenvalues using the specified solver.

Parameters:

solver – Solver method to use (NormalModeSolver enum or string: ‘auto’, ‘dense_lapack’, ‘dense_eigen’, ‘sparse_slicing’; default: NormalModeSolver.AUTO)
compute_eigenvectors – Whether to also compute eigenvectors (default: False)
decompose_components – Whether to decompose the graph into connected components (default: True)

find_sparse_eigenvalues(self: pylimer_tools_cpp.NormalModeAnalyzer, nr_of_eigenvalues: SupportsInt, compute_eigenvectors: bool = False) → None¶

Find the k smallest eigenvalues using a sparse solver.

Parameters:

nr_of_eigenvalues – Number of smallest eigenvalues to find
compute_eigenvectors – Whether to also compute eigenvectors (default: False)

Returns:

True if computation was successful

get_eigenvalues(self: pylimer_tools_cpp.NormalModeAnalyzer) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Get the eigenvalues.

Returns:: Vector of eigenvalues

get_eigenvectors(self: pylimer_tools_cpp.NormalModeAnalyzer) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶

Get eigenvectors.

Returns:: Matrix of eigenvectors

get_matrix(self: pylimer_tools_cpp.NormalModeAnalyzer) → scipy.sparse.csc_matrix[numpy.float64]¶

Get the assembled connectivity matrix.

Returns:: The connectivity matrix

get_matrix_size(self: pylimer_tools_cpp.NormalModeAnalyzer) → int¶

Get the size of the matrix (the maximum number of eigenvalues that could be queried).

Returns:: Size of the connectivity matrix

get_nr_of_soluble_clusters(self: pylimer_tools_cpp.NormalModeAnalyzer) → int¶

Get the number of soluble clusters (eigenvalues = 0).

Returns:: Number of soluble clusters

set_eigenvalues(self: pylimer_tools_cpp.NormalModeAnalyzer, eigenvalues: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, 1]']) → None¶

Set the eigenvalues, e.g. if you use an external solver.

Parameters:: eigenvalues – Vector of eigenvalues to set

set_eigenvectors(self: pylimer_tools_cpp.NormalModeAnalyzer, eigenvectors: Annotated[numpy.typing.ArrayLike, numpy.float64, '[m, n]']) → None¶

Set eigenvectors, e.g. if you use an external solver.

Parameters:: eigenvectors – Matrix of eigenvectors to set