quadlib 0.1.0__py3-none-any.whl

quadlib/tools/linalg.py

@@ -0,0 +1,215 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+"""
+Linear-algebra helpers used by the library.
+"""
+
+from functools import reduce
+
+import numpy as np
+
+
+def sort_eig(evals, evecs, absval=False, order='ascending'):
+    """Sort an (eigvals, eigvecs) pair in place.
+
+    Parameters
+    ----------
+    evals : 1D ndarray, modified in place
+    evecs : 2D ndarray, eigenvectors stored in columns (axis=1), modified in place
+    absval : bool, optional
+        If True, sort by ``|evals|`` rather than the signed value.
+    order : {'ascending', 'descending'}, optional
+        Sort direction. Ignored when ``absval`` is True.
+    """
+    if absval:
+        s = abs(evals).argsort()
+    else:
+        if order == 'ascending':
+            s = evals.argsort()
+        elif order == 'descending':
+            s = (-evals).argsort()
+        else:
+            raise ValueError("order must be 'ascending' or 'descending'")
+    evecs[:] = evecs.take(s, axis=1)
+    evals[:] = evals.take(s)
+
+
+def simul_diag(matrices, **kwargs):
+    """Simultaneous diagonalisation of a collection of real symmetric matrices.
+
+    Finds an orthogonal Us that makes every Us^T A Us as diagonal as
+    possible (exactly diagonal if the matrices commute), by Jacobi
+    rotations. Based on: "Jacobi angles for simultaneous
+    diagonalization", J.-F. Cardoso and A. Souloumiac,
+    SIAM J. Matrix Anal. Appl. 17, 161 (1996).
+
+    Note: kept largely for legacy reasons (not used by the library), but
+    it may be useful later, e.g. for DVRs of several coordinates. Only
+    real symmetric input is supported (ValueError otherwise): the real
+    Jacobi rotations used here do not apply to non-symmetric or complex
+    Hermitian matrices; the latter would need complex rotations.
+
+    Parameters
+    ----------
+    matrices : sequence of real symmetric (n, n) arrays
+    maxiter : int, maximum number of sweeps (default 100)
+    tol : float, stop when the change of sum_k |diag(A_k)|^2 between
+          sweeps falls below tol (default 1e-4)
+    prediag : bool, first diagonalize matrices[matdiag] exactly (default True)
+    matdiag : int, index of that matrix (default 0)
+
+    Returns
+    -------
+    Us : (n, n) orthogonal matrix; Us^T A Us is (nearly) diagonal
+    k : index of the last sweep
+    l_eps : array of the convergence measure per sweep
+    """
+    for A in matrices:
+        A = np.asarray(A)
+        if np.iscomplexobj(A):
+            raise ValueError('simul_diag: only real symmetric matrices are supported')
+        if not np.allclose(A, A.T, rtol=0, atol=1e-12 * max(1.0, np.abs(A).max())):
+            raise ValueError('simul_diag: input matrices must be symmetric')
+    maxiter = kwargs.get('maxiter', 100)
+    tol = kwargs.get('tol', 1.e-4)
+    prediag = kwargs.get('prediag', True)
+    matdiag = kwargs.get('matdiag', 0)  # matrix to fully diagonalise 1st step
+    l_eps = np.zeros(maxiter, float)
+    rank = len(matrices[0])
+    mat0 = []
+    sdiag0 = 0.0
+    if prediag:
+        ev, U = np.linalg.eigh(matrices[matdiag])
+        for M in matrices:
+            mat0.append(reduce(np.dot, (U.T, M, U)))
+        U = U.T
+    else:
+        U = np.identity(rank, float)
+        mat0 = matrices
+    for k in range(maxiter):
+        mat1, U1, sdiag1 = _sweep(mat0)
+        U = np.dot(U1, U)
+        mat0 = mat1
+        epsilon = abs(sdiag1 - sdiag0)
+        sdiag0 = sdiag1
+        l_eps[k] = epsilon
+        if epsilon < tol:
+            break
+    return U.T, k, l_eps
+
+
+def _sweep(matrices):
+    """Single sweep of the simultaneous-diagonalisation algorithm."""
+    rank = len(matrices[0])
+    dmatr = []
+    R = np.identity(rank, float)
+    for i in range(rank):
+        for j in range(i + 1, rank):
+            c, s = _rotation_angles(matrices, i, j)
+            Rij = np.identity(rank, float)
+            Rij[i, i] = c
+            Rij[j, j] = c
+            Rij[i, j] = s
+            Rij[j, i] = -s
+            R = np.dot(Rij, R)
+    for A in matrices:
+        dA = reduce(np.dot, (R, A, R.T))
+        dmatr.append(dA)
+    return dmatr, R, _sum_diag2(dmatr)
+
+
+def _sum_diag2(matrices):
+    """Return the sum of ``dot(diag(A), diag(A))`` over a list of matrices."""
+    d2 = 0.0
+    for A in matrices:
+        da = np.diag(A)
+        d2 = d2 + np.dot(da, da)
+    return d2
+
+
+def _rotation_angles(matrices, i, j):
+    if i == j:
+        raise ValueError('indices must be different')
+    G = np.zeros((2, 2), float)
+    for A in matrices:
+        h = np.array([A[i, i] - A[j, j], A[i, j] + A[j, i]])
+        G += np.outer(h, h)
+    E, U = np.linalg.eigh(G)   # ascending: column 1 is the top eigenvector
+    x = U[0, 1]
+    y = U[1, 1]
+    if x < 0:  # either sign is a valid rotation; x >= 0 avoids x + r ~ 0
+        x, y = -x, -y
+    r = np.dot(U[:, 1], U[:, 1])**0.5
+    c = ((x + r) / (2 * r))**0.5
+    s = y / (2 * r * (x + r))**0.5
+    return c, s
+
+
+def _rank2_diagonalization(M):
+    """Closed-form diagonalisation of a 2x2 matrix.
+
+    Not used; ``_rotation_angles`` uses :func:`numpy.linalg.eigh`
+    for the same job.
+    """
+    trace = M[0, 0] + M[1, 1]
+    detrm = M[0, 0] * M[1, 1] - M[0, 1] * M[1, 0]
+    ev0 = trace / 2 + (trace**2 / 4 - detrm)**0.5
+    ev1 = trace / 2 - (trace**2 / 4 - detrm)**0.5
+    E = np.array([ev0, ev1], float)
+    U = np.zeros((2, 2), float)
+    U[0, 0] = ev0 - M[1, 1]
+    U[0, 1] = ev1 - M[1, 1]
+    U[1, 0] = M[1, 0]
+    U[1, 1] = M[1, 0]
+    U[:, 0] = U[:, 0] / np.dot(U[:, 0], U[:, 0])**0.5
+    U[:, 1] = U[:, 1] / np.dot(U[:, 1], U[:, 1])**0.5
+    return E, U
+
+
+def kron_list(matrices):
+    """Kronecker product of a list of matrices, first factor slowest."""
+    return reduce(np.kron, matrices)
+
+
+def invert_reg(mat, tol=1.0e-8):
+    """
+    Invert a Hermitian matrix, flooring its eigenvalues at tol
+
+    Eigenvalues below tol (including negative ones) are replaced by tol
+    before inverting.
+
+    Returns (inverse, eigenvalues, floored eigenvalues, eigenvectors).
+    """
+    evals, evecs = np.linalg.eigh(mat)
+    evalsreg = np.fmax(evals, tol)
+    inv = evecs @ np.diag(evalsreg**-1) @ evecs.conj().T
+    return inv, evals, evalsreg, evecs
+
+
+def random_orthogonal_matrix(dim, nvec, istype=float):
+    """(dim, nvec) matrix with orthonormal columns (QR of a random matrix)."""
+    T = np.random.random((dim, nvec))
+    if istype is complex:
+        T = T + 1.0j * np.random.random((dim, nvec))
+    elif istype is not float:
+        raise ValueError('istype = [float|complex] only')
+    Q, R = np.linalg.qr(T)
+    return Q
+
+
+def random_normal_columns_matrix(ndim, nvec, istype=float):
+    """(ndim, nvec) matrix of random columns, each normalized to 1.
+
+    The columns are not orthogonal; entries are uniform in [0, 1) before
+    normalization ("normal" means normalized, not Gaussian).
+    """
+    T = np.random.random((nvec, ndim))
+    if istype is complex:
+        T = T + 1.0j * np.random.random((nvec, ndim))
+    elif istype is not float:
+        raise ValueError('istype = [float|complex] only')
+    T = T / np.linalg.norm(T, axis=1)[:, None]
+    return T.T

quadlib/tools/pulses.py

@@ -0,0 +1,187 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+import math
+
+import numpy as np
+
+import quadlib.tools.constants as cv
+
+
+class EField:
+    """
+    Represents an oscillating field characterized by
+
+    E(t) = P A(t)
+
+    P: unit 3-vector, polarizarion axis of the field
+    A(t): function, field amplitude as a function of time
+
+    P and A must have been defined at execution time.
+
+    Units for A(t) must be au both for time and E-field.
+    """
+    def __init__(self,**opts):
+        self.P = np.array([0.0,0.0,1.0],float)
+
+
+    def A(self,t):
+        return 0.0
+
+
+    def E(self,t):
+        return self.A(t) * np.asarray(self.P)
+
+
+    def set_gaussian_pulse(self, omega, fwhm, amp, t0=0, phase=0):
+        """
+        Gaussian shaped pulse with single photon energy
+
+        A(t) = amp * G(fwhm,t0) * cos( omega t + phase)
+
+        All input in au
+
+        omega -- photon energy
+        fwhm -- full width at half maximum
+        amp -- maximum field amplitude
+        t0 -- center of the pulse
+        phase -- phase of the cosine carrier, units of Pi
+
+        No output, modifies self.A
+        """
+        g = gaussian_envelope(fwhm,t0)
+        p = phase * math.pi
+        def a(t):
+            return g(t) * amp * np.cos( omega*t + p )
+        self.A = a
+
+
+    def init_from_input_options(self, iopts):
+        opt_env    = iopts.get('envelope',None)
+        opt_amp    = iopts.get('amplitude',None)
+        opt_omega  = iopts.get('omega',None)
+        opt_center = iopts.get('center',None)
+        opt_fwhm   = iopts.get('fwhm',None)
+        opt_phase  = iopts.get('phase',None)
+        opt_pol    = iopts.get('polarization',None)
+
+        if opt_env:
+            env = opt_env[0]
+        else:
+            env = 'gaussian' # Default envelope
+
+        if opt_amp:
+            amp = cv.numval(opt_amp, 'efield')
+        else:
+            amp = 0.001     # Default peak field amplitude
+
+        if opt_omega:
+            omega = cv.numval(opt_omega, 'energy')
+        else:
+            omega = 0.0      # Default photon energy
+
+        if opt_center:
+            center = cv.numval(opt_center, 'time')
+        else:
+            center = 0.0     # Default center
+
+        if opt_fwhm:
+            fwhm = cv.numval(opt_fwhm, 'time')
+        else:
+            fwhm = 200.0     # Default fwhm in au
+
+        if opt_phase:
+            phase = float( opt_phase[0] )
+        else:
+            phase = 0.0
+
+        if opt_pol:
+            pol = np.array( list( map(float,opt_pol) ) )
+            pol = pol/np.dot(pol,pol)**0.5
+        else:
+            pol = np.array([0,0,1],float)
+
+        self.P = pol
+        if env == 'gaussian':
+            self.set_gaussian_pulse(omega,fwhm,amp,center,phase)
+
+
+
+    def plot(self, ti=0.0, tf=10.0, **opts):
+        """
+        Use matplotlib to plot the time-profile of the pulse
+
+        ti -- float, intial time
+        tf -- float, final time
+        """
+        import matplotlib.pyplot as plt
+        tunit = opts.get('tunit','au')    # time units (field is plotted in au)
+        npoints = opts.get('npoints',500) # number of points used for plotting
+        color = opts.get('color','r')
+        t = np.linspace(ti,tf,npoints)
+        if tunit == 'fs':
+            au_t  = t*cv.fs2au
+        else:
+            au_t = t
+        amp = list( map(self.A,au_t) )
+        plt.plot(t,amp,color)
+#       plt.show()
+
+
+
+
+__k = 4.0*math.log(2.0)
+__N = __k/math.pi
+def gaussian_envelope(fwhm, t0=0.0, norm=False):
+    """
+    Return Gaussian function f(t)
+
+    fwhm -- float; full width at half maximum
+    t0   -- float; center of envelope; Def t0 = 0.0
+    norm -- bool; True: integral = 1, False: maximum = 1. Def. norm=False
+    """
+    N = __N/fwhm
+    if norm:
+        def g(t):
+            return N*np.exp(-__k*((t-t0)/fwhm)**2)
+    else:
+        def g(t):
+            return np.exp(-__k*((t-t0)/fwhm)**2)
+    return g
+
+
+def gaussian_pulse(w, F, E0, t0=0.0, phi=0.0):
+    """
+    Return a Gaussian pulse f(t)
+
+    The pulsed is derived from the vector potential
+    A[t] = G[t]cos(wt + phi)
+    as E[t] = -dA[t]/dt
+    thus ensuring that the pulse is fully propagating
+
+    w - photon energy
+    F - full with at half maximum (duration) of the INTENSITY profile
+    E0 - maximum field amplitude in atomic units
+    t0 - center of the pulse
+    phi - additional phase
+    """
+    ln5 = np.log(0.5)
+    def g(Time):
+        ENVg = np.exp(2*ln5*(Time-t0)**2/F**2)
+        dtENVg = ENVg*4*ln5*(Time-t0)/F**2
+        CARCOS = np.cos(w*Time - phi)
+        CARSIN = np.sin(w*Time - phi)
+        return -E0*CARSIN*ENVg + E0/w*CARCOS*dtENVg
+    return g
+
+
+if __name__ == '__main__':
+    ef = EField()
+    ef.P = np.array([0,0,1],float)
+    ef.set_gaussian_pulse(100*cv.ic2au, 200.0*cv.fs2au, 1.0, 250.0*cv.fs2au, 0.5)
+    ef.plot(ti=0,tf=1000,tunit='fs')
+
+
+

quadlib/tools/spectra.py

@@ -0,0 +1,179 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+"""
+Spectra from time signals: correlation-function spectra and Fourier
+transforms.
+"""
+
+import numpy as np
+from scipy.integrate import simpson
+
+
+def corrspec(corr,dt,**opts):
+    """
+    Compute spectrum of a correlation function
+
+    Parameters
+    ----------
+    corr : array_like
+        1D complex array with correlation function.
+    dt : float
+        time interval between correlation values; [au]
+
+    Options
+    -------
+    eref : float; 0.0
+        energy shift, e.g. zero point energy; [au]
+    emin : float; 0.0
+        start of spectrum counting from eref; [au]
+    emax : float; 0.0 (calculated from dt if not given)
+        end of spectrum counting from eref; [au]
+    npoints : int; 500
+        number of discrete points where spectrum is evaluated
+        between emin and emax
+    EP : bool; False
+        if True, multiplication of spectrum with energy factor
+    ncos : int; 1
+        exponent of the cosine damping function
+    """
+    eref = opts.get('eref',0.0)
+    emin = opts.get('emin',0.0)
+    emax = opts.get('emax',0.0)
+    npoints = opts.get('npoints',500)
+    EP = opts.get('EP',False)
+    ncos = opts.get('ncos',1)
+
+    a = np.asarray(corr)
+    maxwidth = 2.0*np.pi/dt
+    eminspec = eref + emin
+    emaxspec = eref + emax
+    if emax <= emin:
+        emaxspec = eminspec + maxwidth
+    T = (len(a) - 1)*dt
+    tlist = np.linspace(0.0,T,len(a))
+    elist = np.linspace(eminspec,emaxspec,npoints)
+    spect = np.zeros(len(elist), complex)
+
+    cos_damp = np.cos(0.5*np.pi*tlist/T)**ncos
+    adamp = a*cos_damp
+
+    for i,energy in enumerate(elist):
+        tmp = energy*tlist*1.0j
+        tmp = np.exp(tmp)
+        tmp = tmp*adamp
+        spect[i] = tmp.sum()*dt
+        #spect[i] = spect[i].real
+
+    if EP:
+        spect = spect*(elist-eref)
+
+    return elist-eref,spect
+
+
+def fourierTransform(y, dt, **option):
+    """
+    Compute Fourier transform
+
+    Parameters:
+    -----------
+    y : 1D array_like
+        function to be Fourier transformed.
+    dt : float
+        interval of the domain function.
+    method : string, default: 'simp', optional
+        integration method to be used.
+        'trapz' for trapezoidal rule,
+        'simp' for Simpson rule
+    t_init : float, default: 0.0, optional
+        initial point of the domain function.
+    odamp : int, default: 1, optional
+        cosine damping function order (to damp the signal function at its end) [as the cosine power]
+    usage : {'phys', 'math'}, default: 'phys', optional
+        usage of the Fourier transform:
+        'phys': mostly for physics application, it means using angular frequency, (2pi*f),
+                thus the inverse is asymmetric.
+        'math': mostly for mathematics application, it means using normal frequency,
+                thus the inverse is symmetric.
+    f_range : tuple of float, default: if usage='phys' (-pi/dt, pi/dt), if usage='math' (-0.5/dt, 0.5/dt), optional
+        minimum frequency and maximum frequency.
+    npoints : int, default: len(y), optional
+        number of points of transformed domain function.
+    symmetry : {'gen', 'even', 'odd'}, default: 'gen', optional
+        symmetry of the function y to be transformed.
+        'gen': general, the exponential function will be used.
+        'even': even function, cosine transform will be used.
+        'odd': odd function, sine transform will be used.
+        if symmetry is 'even' or 'odd', the t_init will be set to 0.0
+
+    Returns
+    -------
+    fline, FT_func : (list)
+    fline : 1D numpy.ndarray
+        Domain of transformed function (frequency domain)
+    FT_func : 1D numpy.ndarray
+        Fourier transform of y function.
+    """
+    func = np.asarray(y, dtype=complex)
+    # evaluating options
+    method = option.get('method', 'simp')
+    t_init = option.get('t_init', 0.0)
+    odamp = option.get('odamp', 1)
+    usage = option.get('usage', 'phys')
+    npoints = option.get('npoints', len(func))
+    symmetry = option.get('symmetry', 'gen')
+    if usage == 'math':
+        f_range = option.get('f_range', (-0.5/dt, 0.5/dt))
+    else:
+        f_range = option.get('f_range', (-np.pi/dt, np.pi/dt))
+    fmin = f_range[0]
+    fmax = f_range[1]
+
+    Nsegments = len(func) - 1
+    spanT = dt * (len(func) - 1)
+    if symmetry == 'even' or symmetry == 'odd':
+        t_init = 0.0
+    t_end = t_init + spanT
+    tline = np.linspace(t_init, t_end, Nsegments + 1)
+
+    if usage == 'phys':
+        #fline = np.linspace(0.0, 2.0 * np.pi / dt, npoints)
+        factor = 1.0
+    else:
+        #fline = np.linspace(0.0, 1.0 / dt, npoints)
+        factor = 2.0 * np.pi
+    fline = np.linspace(fmin, fmax, npoints)
+
+    # integration method
+    int_method = {'simp': simpson, 'trapz': np.trapezoid}
+    if method != 'simp' and method != 'trapz':
+        method = 'simp'
+
+    FT_func = np.zeros(npoints, dtype=complex)
+
+    # damped input function
+    if odamp == 0:
+        damp_func = func
+    else:
+        fn_damp = np.cos(0.5 * np.pi * (tline - t_init) / spanT)**odamp
+        damp_func = func * fn_damp
+
+    if symmetry == 'even':
+        for i, alpha in enumerate(fline):
+            integrand = alpha * tline * factor
+            integrand = damp_func * np.cos(integrand)
+            FT_func[i] = 2.0 * int_method[method](integrand, dx = dt)
+    elif symmetry == 'odd':
+        for i, alpha in enumerate(fline):
+            integrand = alpha * tline * factor
+            integrand = damp_func * np.sin(integrand)
+            FT_func[i] = 2.0 * 1.0j * int_method[method](integrand, dx = dt)
+    else:
+        for i, alpha in enumerate(fline):
+            integrand = -alpha * tline * factor
+            integrand = damp_func * np.exp(1.0j * integrand)
+            FT_func[i] = int_method[method](integrand, dx = dt)
+
+    return fline, FT_func