quadlib 0.1.0__py3-none-any.whl

quadlib/__init__.py

@@ -0,0 +1,39 @@
+# 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 os.path
+
+# -------------------------------------------------------------
+# Make classes available in quadlib's namespace
+from quadlib.wavefunction.wfn_exact import WfnExact
+from quadlib.wavefunction.wfn_cpd import WfnCPD
+
+from quadlib.basis.boson import Boson
+from quadlib.basis.discrete import Discrete
+from quadlib.basis.expdvr import Expdvr
+from quadlib.basis.hodvr import HOdvr
+from quadlib.basis.sindvr import Sindvr
+from quadlib.basis.spin import Spin
+from quadlib.basis.jbasis import Jbasis
+
+from quadlib.operator.sop import SumOfProducts
+from quadlib.operator.sop import SumOfProducts as SOP
+from quadlib.operator.sop import OpType
+
+from quadlib.hdmctdh.rundirectory import Rundirectory
+#from quadlib.hdmctdh.mctdh_runner import MctdhRunner
+
+# -------------------------------------------------------------
+# Make submodules available
+import quadlib.tools.constants as cons
+import quadlib.tools.linalg as linalg
+import quadlib.tools.spectra as spectra
+import quadlib.tools.bath as bath
+import quadlib.tools.tensor as tensor
+import quadlib.wavefunction.wfn_exact as exactwfn
+
+import quadlib.propagation as propagation
+
+QDLPATH = os.path.dirname(__file__)

quadlib/basis/__init__.py

@@ -0,0 +1,60 @@
+# 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)
+
+"""
+Primitive basis classes.
+
+Every basis class in this subpackage exposes at minimum the attribute `n`
+(the dimension of the single-DOF Hilbert space it represents).
+
+DVR (position-space) bases additionally expose `x`, `w`, `xmat`, `dq1`,
+`dq2`, `u`; see the :class:`DVRBasis` Protocol below.
+
+Algebraic bases (Boson, Spin, Jbasis, Discrete) expose the operators
+relevant to their physics with conventional capitalised names
+(``PauliX``, ``Jz``, ``Nop``, ``C``, ``A``, …). The dimension is always
+the lowercase `n`.
+"""
+
+from typing import Protocol, runtime_checkable
+
+import numpy as np
+
+
+@runtime_checkable
+class Basis(Protocol):
+    """Minimum interface every basis class provides."""
+
+    n: int  # dimension of the single-DOF Hilbert space
+
+
+@runtime_checkable
+class DVRBasis(Basis, Protocol):
+    """Position-space (DVR) basis.
+
+    All array attributes are real unless otherwise noted.
+
+    Attributes
+    ----------
+    x : ndarray of shape (n,)
+        DVR grid points.
+    w : ndarray of shape (n,)
+        DVR quadrature weights.
+    xmat : ndarray of shape (n, n)
+        Position operator in the DVR basis, equal to ``np.diag(x)``.
+    dq1 : ndarray of shape (n, n)
+        First-derivative matrix in the DVR basis.
+    dq2 : ndarray of shape (n, n)
+        Second-derivative matrix in the DVR basis.
+    u : ndarray of shape (n, n)
+        FBR → DVR transformation matrix.
+    """
+
+    x: np.ndarray
+    w: np.ndarray
+    xmat: np.ndarray
+    dq1: np.ndarray
+    dq2: np.ndarray
+    u: np.ndarray

quadlib/basis/boson.py

@@ -0,0 +1,61 @@
+import numpy as np
+
+
+class Boson:
+    """
+    Boson (harmonic oscillator in SQ) basis.
+
+    N -- integer: number of states, counting |0>.
+
+    Notes: the maximum number of particles for a given N is N-1
+
+    """
+
+    def __init__(self, N):
+        """
+        Initialize a boson (harmonic oscillator SQ) basis object
+
+        """
+        if not isinstance(N, (int, np.integer)):
+            raise ValueError('N needs to be an integer\n')
+        self.n = N
+        self.ONE = _ONE(N)      # unit operator as a matrix
+        self.ONE_d = _ONE(N, diag=True) # unit operator as a diagonal oper.
+        self.Nop = _Bnum(N)    # number operator
+        self.Nop_d = _Bnum(N, diag=True) # number operator as a diagonal oper.
+        self.C = _Bc(N)        # creation operator
+        self.A = _Ba(N)        # annihilation operator
+        self.H = np.diag(np.ones(N)*0.5) + self.Nop # Hamiltonian in au.
+
+
+def _ONE(n, diag=False):
+    if diag:
+        return np.ones(n, float)
+    else:
+        return np.diag(np.ones(n, float))
+
+
+def _Bnum(n, diag=False):
+    ln = np.asarray(list(range(0, n)), float)
+    if diag:
+        return ln
+    else:
+        return np.diag(ln)
+
+
+def _Bc(n):
+    bc = np.zeros((n, n), float)
+    for i in list(range(1, n)):
+        bc[i, i-1] = np.sqrt(i)
+    return bc
+
+
+def _Ba(n):
+    ba = np.zeros((n, n), float)
+    for i in list(range(1, n)):
+        ba[i-1, i] = np.sqrt(i)
+    return ba
+
+
+
+

quadlib/basis/discrete.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+
+class Discrete:
+    """
+    Discrete basis (e.g. to represent electronic-state degrees of freedom).
+
+    N -- integer: number of states, counting |0>.
+
+    Notes: the maximum number of particles for a given N is N-1
+
+    """
+    def __init__(self, N):
+        """
+        Initialize a discrete basis object
+
+        """
+        if not isinstance(N, (int, np.integer)):
+            raise ValueError('N needs to be an integer\n')
+        self.n = N
+        self.ONE = _ONE(N)      # unit operator as a matrix
+        self.ONE_d = _ONE(N, diag=True) # unit operator as a diagonal oper.
+
+
+    def P(self, n, diag=False):
+        """
+        Projector |n><n|
+
+        n -- state number, n <= self.n
+
+        """
+        p = np.zeros((self.n), float)
+        p[n] = 1.0
+        if diag:
+            return p
+        else:
+            return np.diag(p)
+
+
+    def S(self, n, m):
+        """
+        Symmetric operator |n><m| + |m><n|
+
+        n, m -- state number, n, m <= self.n
+
+        """
+        p = np.zeros((self.n, self.n), float)
+        p[n, m] = 1.0
+        p[m, n] = 1.0
+        return p
+
+
+    def Z(self, n, m):
+        """
+        Off-diagonal operator |n><m|
+
+        n, m -- state number, n, m <= self.n
+
+        """
+        p = np.zeros((self.n, self.n), float)
+        p[n, m] = 1.0
+        return p
+
+
+def _ONE(n, diag=False):
+    if diag:
+        return np.ones(n, float)
+    else:
+        return np.diag(np.ones(n, float))
+
+

quadlib/basis/expdvr.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+
+class Expdvr:
+    """
+    Exp DVR (plane wave) basis.
+
+    """
+
+    def __init__(self, N, x0=0, L=2*np.pi):
+        """
+        Initialize a exp DVR basis object
+        """
+        if not isinstance(N, (int, np.integer)):
+            raise ValueError('N needs to be an odd integer\n')
+        if N%2 == 0:
+            raise ValueError('N needs to be an odd integer\n')
+        x0 = float(x0)
+        L = float(L)
+        self.n = N
+        self.x0 = x0
+        self.dX = L/N
+        self.xf = x0 + L - L/N # Last grid point
+        self.L = L
+        self.x, self.w, self.dq1, self.dq2, self.u = expdvr(N, x0, L)
+        self.xmat = np.diag(self.x)
+
+
+def expdvr(N, x0, L):
+    weights = np.ones(N, float)*L/N
+    x, umat = _calcumat(N, x0, L)
+    d1dvr = _calcd1dvr(N, x0, L)
+    d2dvr = _calcd2dvr(N, x0, L)
+    return x, weights, d1dvr, d2dvr, umat
+
+
+def _dx(N, L):
+    return L/N
+
+
+def _calcumat(N, x0, L):
+    U = np.zeros((N, N), float)
+    X = np.zeros(N, float)
+    dx = L/N
+    N1 = N + 1
+    fac = np.sqrt(2.0/(N + 1))
+    for j in range(N):
+        X[j] = x0 + j*dx
+        for a in range(N):
+            U[j, a] = fac*np.sin(j*a*np.pi/N1)
+    return X, U
+
+
+def _calcd1dvr(N, x0, L):
+    D1 = np.zeros((N, N), float)
+    fac = np.pi/L
+    for a in range(N):
+        for b in range(N):
+            if a==b:
+                continue
+            pref = fac*(-1)**(a - b)
+            D1[a, b] = pref/np.sin(np.pi*(a - b)/N)
+    return D1
+
+
+def _calcd2dvr(N, x0, L):
+    D2 = np.zeros((N, N), float)
+    fac1 = -np.pi**2/(3*L**2)*(N**2 - 1)
+    fac2 = -2*np.pi**2/(L**2)
+    for a in range(N):
+        for b in range(N):
+            if a==b:
+                D2[a, b] = fac1
+            else:
+                pref = fac2*(-1)**(a - b)
+                c = np.cos(np.pi*(a - b)/N)
+                s2 = np.sin(np.pi*(a - b)/N)**2
+                D2[a, b] = pref*c/s2
+    return D2
+

quadlib/basis/hodvr.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+import quadlib.basis.boson as boson
+
+
+class HOdvr:
+    """
+    Harmonic oscillator DVR basis.
+
+    """
+
+    def __init__(self, N, m=1.0, w=1.0, x0=0.0):
+        """
+        Initialize a HO DVR basis object
+        """
+        if not isinstance(N, (int, np.integer)):
+            raise ValueError('N needs to be an integer\n')
+        m = float(m)
+        w = float(w)
+        mw = m*w
+        mw4 = (mw/np.pi)**-0.25
+        B = boson.Boson(N)
+        H = (B.Nop + np.diag(np.ones(N))*0.5)*w
+        x_fbr = (B.C + B.A)/np.sqrt(2*mw) + np.diag(np.ones(N))*x0
+        p_fbr = 1.0j*(B.C - B.A)*np.sqrt(mw/2)
+        x2_fbr = x_fbr @ x_fbr
+        v_fbr = 0.5*m*w**2 * x2_fbr
+        dq2_fbr = -2.0*m*(H - v_fbr)
+        # Line above is the correct way to obtain the second derivative matrix.
+        # It prevents the fbr basis truncation error
+
+        X, U = np.linalg.eigh(x_fbr)
+        for j, u0j in enumerate(U[0,:]):
+            if u0j < 0.0: U[:,j] = -1.0*U[:,j]
+
+        P_dvr = U.T @ p_fbr @ U
+        self.dq1 = -1.0j*P_dvr
+        self.P = P_dvr
+
+        self.dq2 =  U.T @ dq2_fbr @ U
+        self.T = -0.5*self.dq2/m
+
+        self.n = N
+        self.u = U
+        self.x = X
+        self.xmat = np.diag(X)
+        self.x0 = self.x[0]
+        self.xf = self.x[-1]
+        w12 = mw4*np.exp(0.5*mw*X**2)*np.abs(U[0])
+        self.w = w12**2
+

quadlib/basis/jbasis.py

@@ -0,0 +1,87 @@
+import numpy as np
+
+
+class Jbasis:
+    """
+    General angular momentum basis.
+
+    """
+
+    def __init__(self, M):
+        """
+        Initialize a general angular momentum basis
+
+        M -- spin multiplicity, M = 2S + 1 (S is the total spin)
+
+        Notes:
+            - See e.g. Griffiths, Introduction to Quantum Mechanics
+            - |0> has the highest angular momentum projection along z.
+        """
+        self.n = M
+        self.ONE = np.diag(np.ones(M, float))
+        self.Jz = _Jz(M)
+        self.Jx = _Jx(M)
+        self.Jy = _Jy(M)
+        self.Jp = _Jp(M)
+        self.Jm = _Jm(M)
+        self.J2 = _J2(M)
+
+
+def _bj(j, s):
+    t = (s + j)*(s + 1 - j)
+    return np.sqrt(t)
+
+
+def _Jx(M):
+    jx = np.zeros((M, M), float)
+    s = (M - 1.0)/2.0
+    for i in list(range(0, M - 1)):
+        j = s - i
+        bj = _bj(j, s)
+        jx[i + 1, i] = bj
+        jx[i, i + 1] = bj
+    jx = 0.5*jx
+    return jx
+
+
+def _Jy(M):
+    jy = np.zeros((M, M), complex)
+    s = (M - 1.0)/2.0
+    for i in list(range(0, M - 1)):
+        j = s - i
+        bj = _bj(j, s)
+        jy[i + 1, i] = 1.0j*bj
+        jy[i, i + 1] = -1.0j*bj
+    jy = 0.5*jy
+    return jy
+
+
+def _Jz(M):
+    jz = np.zeros((M, M), float)
+    s = (M - 1.0)/2.0
+    for i in list(range(0, M)):
+        j = s - i
+        jz[i, i] = j
+    return jz
+
+
+def _Jp(M):
+    jx = _Jx(M)
+    jy = _Jy(M)
+    return np.real(jx + 1.0j*jy)
+
+
+def _Jm(M):
+    jx = _Jx(M)
+    jy = _Jy(M)
+    return np.real(jx - 1.0j*jy)
+
+
+def _J2(M):
+    jx = _Jx(M)
+    jy = _Jy(M)
+    jz = _Jz(M)
+    j2 = np.dot(jx, jx) + np.dot(jy, jy) + np.dot(jz, jz)
+    return np.real(j2)
+
+

quadlib/basis/sindvr.py

@@ -0,0 +1,97 @@
+import math
+
+import numpy as np
+
+
+class Sindvr:
+    """
+    Sin DVR (particle in a box) basis.
+
+    """
+
+    def __init__(self, N, x0=-0.5, xf=0.5):
+        """
+        Initialize a sin DVR basis object
+        """
+        if not isinstance(N, (int, np.integer)):
+            raise ValueError('N needs to be an integer\n')
+        x0 = float(x0)
+        xf = float(xf)
+        self.n = N
+        self.x0 = x0
+        self.xf = xf
+        self.x, self.w, self.dq1, self.dq2, self.u = sindvr(N, x0, xf)
+        self.xmat = np.diag(self.x)
+        self.dX = _dx(N, x0, xf)
+        self.L = _L(N, x0, xf)
+
+
+def sindvr(N, x0, xf):
+    weights = np.ones(N, float)*_dx(N, x0, xf)
+    x, umat = _calcumat(N, x0, xf)
+    d1dvr = _calcd1dvr(N, x0, xf, umat)
+    d2dvr = _calcd2dvr(N, x0, xf, umat)
+    return x, weights, d1dvr, d2dvr, umat
+
+
+def _dx(N, x0, xf):
+    return (xf-x0) / (N-1)
+
+
+def _L(N, x0, xf):
+    return (xf-x0) * (N+1.0) / (N-1.0) # physical length of box
+
+
+def _calcumat(N, x0, xf):
+    dx = _dx(N, x0, xf)
+    L = _L(N, x0, xf)
+    dkron = np.identity(N+1,int)
+    # Generate the matrix Q(z), where z=cos(pi(x-xo)/L)
+    Qz = np.zeros((N, N), float)
+    for i in range(N):
+        for j in range(N):
+            Qz[i, j] = 0.5 * float( dkron[i, j+1] + dkron[i, j-1] )
+    evals, evecs = np.linalg.eigh(Qz)
+    # Reverse order of eigevalues and eigenvectors for ascending grid points
+    idx = list(range(0, N))
+    idx.reverse()
+    evals = evals[idx]
+    evecs = evecs[:,idx]
+    evals[:] = (L/math.pi) * np.arccos(evals)
+    umat = evecs
+    # change sign of eigenvectors to ensure positive weights
+    for i in range(N):
+        if umat[0, i] < 0.0:
+            umat[:, i] = -1.0*umat[:, i]
+    x = evals + x0 - dx
+    return x, umat
+
+
+def _calcd1dvr(N, x0, xf, umat):
+    d1vbr = np.zeros((N, N), float)
+    umatT = np.transpose(umat)
+    L = _L(N, x0, xf)
+    for j in range(N):
+        j1=j+1
+        for k in range(N):
+            k1=k+1
+            if j != k:
+                d1vbr[j,k] = float((j1-k1)%2) * \
+                               (4.0/L) * j1*k1/(j1**2 - k1**2)
+    d1dvr = np.dot(umatT, np.dot(d1vbr, umat))
+    return d1dvr
+
+
+def _calcd2dvr(N, x0, xf, umat):
+    d2vbr = np.zeros((N, N), float)
+    umatT = np.transpose(umat)
+    dkron = np.identity(N+1,int)
+    L = _L(N, x0, xf)
+    for j in range(N):
+        j1=j+1
+        for k in range(N):
+            k1=k+1
+            d2vbr[j,k] = -dkron[j1,k1] * (j1*math.pi/L)**2
+    d2dvr = np.dot(umatT, np.dot(d2vbr, umat))
+    return d2dvr
+

quadlib/basis/spin.py

@@ -0,0 +1,64 @@
+import numpy as np
+
+
+class Spin:
+    """
+    Spin (two-level system) basis.
+
+    """
+
+    def __init__(self):
+        """
+        Initialize a spin basis object
+
+        Notes: we are using the convention
+            (1, 0)T --> |0>, spin-up
+            (0, 1)T --> |1>, spin-down.
+        This convention agrees with the definition of the general jbasis.
+        """
+        self.n = 2
+        self.ONE = np.diag(np.ones(2, float))
+        self.PauliZ = _PauliZ()
+        self.PauliX = _PauliX()
+        self.PauliY = _PauliY()
+        self.Sz = 0.5*self.PauliZ
+        self.Sx = 0.5*self.PauliX
+        self.Sy = 0.5*self.PauliY
+        self.Sp = _Sp()
+        self.Sm = _Sm()
+        self.S2 = 0.75*self.ONE
+
+
+def _PauliX():
+    sx = np.zeros((2,2), float)
+    sx[0, 1] = 1.0
+    sx[1, 0] = 1.0
+    return sx
+
+
+def _PauliY():
+    sy = np.zeros((2, 2), complex)
+    sy[0, 1] = -1.0j
+    sy[1, 0] = 1.0j
+    return sy
+
+
+def _PauliZ():
+    sz = np.diag(np.ones(2, float))
+    sz[1, 1] = -1.0
+    return sz
+
+
+def _Sp():
+    sp = np.zeros((2,2), float)
+    sp[0, 1] = 1.0
+    return sp
+
+
+def _Sm():
+    sm = np.zeros((2,2), float)
+    sm[1, 0] = 1.0
+    return sm
+
+
+

quadlib/cli/qlb_offset_oper_dof.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# 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)
+
+"""
+Add an offset to the mode numbers (|n) of an MCTDH operator.
+
+Reads the operator from stdin, writes it to stdout:
+    qlb-offset-oper-dof -o 3 < in.op > out.op
+"""
+
+import argparse
+import re
+import sys
+
+
+def offset_line(line, offset):
+    """Return line with every '|<n>' replaced by '|<n + offset>'."""
+    return re.sub(r'\|[0-9]+', lambda m: '|' + str(int(m[0][1:]) + offset), line)
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.strip().splitlines()[0])
+    parser.add_argument('-o', '--offset', type=int, default=0,
+                        help='Offset added to the modenumbers of an MCTDH operator')
+    opts = parser.parse_args(argv)
+    for line in sys.stdin:
+        print(offset_line(line.rstrip('\n'), opts.offset), file=sys.stdout)
+
+
+if __name__ == '__main__':
+    main()

quadlib/experimental/__init__.py

@@ -0,0 +1,17 @@
+# 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)
+
+"""
+Unfinished or known-incorrect code kept for ongoing method development.
+
+Nothing here is imported by ``quadlib/__init__.py``; import the
+submodules explicitly, e.g. ``import quadlib.experimental.cpd_eom``.
+Nothing here is covered by the stability or correctness expectations of
+the rest of the library.
+
+node, tree, pdof - tree-tensor-network scaffolding (Node, Tree, Pdof)
+mctdh            - placeholders for the (ML-)MCTDH equations of motion
+cpd_eom          - coupled CPD equations (known incorrect)
+"""