Skip to content

beyn#

Includes our NEVP solver based on Beyn's method.

Classes:

  • Beyn –

    Beyn's integral method for solving NEVP.[^1]

Beyn #

Beyn(r_o: float, r_i: float, m_0: int, num_quad_points: int, num_threads_contour: int = 1024, eig_compute_location: str = 'numpy', project_compute_location: str = 'numpy', use_qr: bool = False, contour_batch_size: int | None = None, use_pinned_memory: bool = True)

Bases: NEVP

Beyn's integral method for solving NEVP.1

This is implemented along the lines of what is described in 2.

  1. W.-J. Beyn, An integral method for solving nonlinear eigenvalue problems, Linear Algebra and its Applications, 2012. ↩

  2. S. Brück, Ab-initio Quantum Transport Simulations for Nanoelectronic Devices, ETH Zurich, 2017. ↩

Parameters:

  • r_o (float) –

    The outer radius of the annulus for the contour integration.

  • r_i (float) –

    The inner radius of the annulus for the contour integration.

  • m_0 (int) –

    Guess for the number of eigenvalues that lie in the subspace.

  • num_quad_points (int) –

    The number of quadrature points to use for the contour integration.

  • num_threads_contour (int, default: 1024 ) –

    The number of cuda threads to use for the contour integration kernel. Only relevant for GPU computations.

  • eig_compute_location (str, default: 'numpy' ) –

    The location where to compute the eigenvalues and eigenvectors. Can be either "numpy" or "cupy" or "nvmath".

  • project_compute_location (str, default: 'numpy' ) –

    The location where to compute the singular value or qr decomposition for the projector. Can be either "numpy" or "cupy".

  • use_qr (bool, default: False ) –

    Whether to use QR decomposition for the projector instead of SVD. Default is False.

  • contour_batch_size (int, default: None ) –

    The batch size for the contour integration kernel. If None, the batch size is set to num_quad_points.

  • use_pinned_memory (bool, default: True ) –

    Whether to use pinnend memory if cupy is used. Default is True.

Methods:

  • __call__ –

    Solves the polynomial eigenvalue problem through contour integration.

__call__ #

__call__(a_xx: tuple[NDArray, ...]) -> tuple[NDArray, NDArray]

Solves the polynomial eigenvalue problem through contour integration.

This method solves the non-linear eigenvalue problem defined by the coefficient blocks a_xx from lowest to highest order.

Parameters:

  • a_xx (tuple[NDArray, ...]) –

    The coefficient blocks of the non-linear eigenvalue problem from lowest to highest order.

Returns:

  • ws ( NDArray ) –

    The eigenvalues.

  • vs ( NDArray ) –

    The right eigenvectors.