quadlib 0.1.0__py3-none-any.whl

quadlib/experimental/cpd_eom.py

@@ -0,0 +1,95 @@
+# 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)
+
+"""
+Coupled equations of motion for the CPD wavefunction (A-vector and SPFs).
+
+KNOWN INCORRECT, kept as found for later work. The Dirac-Frenkel
+equations for Psi = sum_j A_j prod_d phi_{d,j}, with unconstrained,
+non-orthogonal SPFs, read
+
+    S dA/dt = -i H A - T A,   T_ij = <Phi_i|dPhi_j/dt>
+    rho^(d) dphi_d/dt = -i sum_k MF_k^(d) h_k^(d) phi_d - tau^(d) phi_d
+
+where T and tau^(d) are sums of terms with one derivative overlap
+each. Compared with them:
+
+- T_matrix and tau_matrix take the product of all derivative overlaps
+  instead of a sum of terms with one derivative factor each;
+- rhs_A_coupled and rhs_spfs are consistent with those equations only
+  if T and tau carry a factor i, which they do not;
+- no gauge condition is imposed and the equations are implicit
+  (T and tau need the derivatives being solved for).
+
+The mean-field term (mfield_hole and its use in rhs_spfs) does agree
+with the derivation.
+
+All functions take the wavefunction ``wfn`` (a ``quadlib.WfnCPD`` with
+its ``hamiltonian`` set) and, where needed, ``dtpsi``: a list with the
+same layout as ``wfn.psi`` holding the time derivatives (SPF matrices
+first, one SPF per row, A-vector last). ``empty_dtpsi`` builds one.
+"""
+
+import numpy as np
+
+import quadlib.tools.linalg as linalg
+from quadlib.wavefunction.wfn_cpd import cpd_overlap_prod, cpd_overlap_tensor, empty_cpd
+
+
+def empty_dtpsi(wfn):
+    return empty_cpd(wfn.pdim, wfn.rank, datatype=complex)
+
+
+def T_matrix(wfn, dtpsi):
+    """T -> configuration overlap matrix, rhs time derivative (see module notes)"""
+    ovl_dt = cpd_overlap_tensor(wfn.psi, dtpsi)
+    return cpd_overlap_prod(ovl_dt, hole=-1)
+
+
+def tau_matrix(wfn, dof, dtpsi):
+    """tau -> density matrix, rhs time derivative (see module notes)"""
+    ovl_dt = cpd_overlap_tensor(wfn.psi, dtpsi)
+    return cpd_overlap_prod(ovl_dt, hole=dof)
+
+
+def mfield_hole(wfn, dof):
+    """
+    Compute the meanfield-only (the meanfield hole) of the mean field operator
+
+    dof -- degree of freedom, counting from 0
+
+    The coefficient of each operator term is included, so that the
+    mean field is complete whichever DOF is left out.
+    """
+    wfn._update_hterms()
+    t = np.ones(wfn._hterms.shape, bool)
+    t[:, dof, :] = False
+    mf = np.prod(wfn._hterms, axis=1, where=t)
+    mf = np.einsum('k,kij->kij', wfn._coeff(), mf)
+    mf = np.einsum('ij,kij->kij', wfn.A_density(), mf)
+    return mf
+
+
+def rhs_A_coupled(wfn, dtpsi):
+    """A-vector RHS including the T term (see module notes)"""
+    S1 = linalg.invert_reg(wfn.S_matrix())[0]
+    T = T_matrix(wfn, dtpsi)
+    H = wfn.H_matrix()
+    dtA = H.sum(axis=0) @ wfn.psi[-1]
+    dtA = dtA - T @ wfn.psi[-1]
+    return -1.0j * S1 @ dtA
+
+
+def rhs_spfs(wfn, dof, dtpsi):
+    """SPF RHS for degree of freedom dof (see module notes)"""
+    rho1 = linalg.invert_reg(wfn.rho_matrix(dof))[0]
+    tau = tau_matrix(wfn, dof, dtpsi)
+    mfhole = mfield_hole(wfn, dof)
+    dtspf = np.zeros_like(wfn.psi[dof])
+    for k in range(wfn.hamiltonian.rank):  # operator terms loop
+        tmp = wfn.hamiltonian.multiply_term(k, dof, wfn.psi[dof])
+        dtspf = dtspf + mfhole[k] @ tmp
+    dtspf = dtspf - tau @ wfn.psi[dof]
+    return -1.0j * (rho1 @ dtspf)

quadlib/experimental/mctdh.py

@@ -0,0 +1,32 @@
+# 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)
+
+"""
+Placeholders for the (ML-)MCTDH equations of motion on a Tree.
+
+Not implemented. They mark where the tree EOMs will go; once they work
+they move out of experimental into an actual WfnMCTDH.
+"""
+
+
+def rhsEOM(wfn, oper, **opts):
+    """Right-hand side of the MCTDH equations of motion."""
+    raise NotImplementedError('MCTDH equations of motion are not implemented yet')
+
+
+def stepEOM(wfn, oper, **opts):
+    raise NotImplementedError('MCTDH equations of motion are not implemented yet')
+
+
+def htermsEOM(wfn, oper, **opts):
+    raise NotImplementedError('MCTDH equations of motion are not implemented yet')
+
+
+def mfieldsEOM(wfn, oper, **opts):
+    raise NotImplementedError('MCTDH equations of motion are not implemented yet')
+
+
+def dmatEOM(wfn, oper, **opts):
+    raise NotImplementedError('MCTDH equations of motion are not implemented yet')

quadlib/experimental/node.py

@@ -0,0 +1,259 @@
+import uuid
+
+import numpy as np
+
+import quadlib.tools.linalg as linalg
+
+
+class Node:
+    def __init__(self, **opts):
+        self.uid = uuid.uuid4().hex             # unique ID string for the node
+        self.tag = opts.get('tag', self.uid)    # human readable tagname for the node
+        self.links = []
+        self.index_at_link = []                 # index of this bond in the corresponding linked node
+        #self.shape = np.array([], int)
+        self.shape = []
+        self.parent_index = -1
+        self.tensor = None
+        self.is_pdof = False
+        self.is_visited = False # needed for some traversing algorithms
+
+
+    @property
+    def dim(self):
+        """
+        Return node dimensionality (number of bonds)
+        """
+        return len(self.shape)
+
+
+    @property
+    def len(self, **opts):
+        """
+        Return node length, i.e. product over dimensions = number of coefficients
+        """
+        return np.prod(self.shape)
+
+
+    def allocate(self, **opts):
+        dtype = opts.get('dtype', complex)
+        order = opts.get('order', 'C')
+        self.tensor = np.zeros(self.shape, dtype, order=order)
+
+
+    def init_tensor_orthonormal_rand(self, ortho_index = 'last', **opts):
+        """
+        Initialize the tensor as a random orthogonal matrix w.r.t. index ortho_index
+        """
+        if ortho_index == 'last':
+            dim1 = self.len//self.shape[-1]
+            dim2 = self.shape[-1]
+            if dim2 > dim1: raise ValueError('init_tensor_orthonormal_rand: error dim2 > dim1')
+            Q = linalg.random_orthogonal_matrix(dim1, dim2)
+            self.tensor[:] = Q.reshape(self.tensor.shape)
+        elif ortho_index == 'first':
+            dim1 = self.len//self.shape[0]
+            dim2 = self.shape[0]
+            if dim2 > dim1: raise ValueError('init_tensor_orthonormal_rand: error dim2 > dim1')
+            Q = linalg.random_orthogonal_matrix(dim1, dim2)
+            Q = Q.T
+            self.tensor[:] = Q.reshape(self.tensor.shape)
+
+    def init_tensor_normal_rand(self):
+        """
+        Initialize the tensor with random numbers and normalize
+
+        (useful e.g. for top A-vector) 
+        """
+        t = np.random.random_sample(self.shape)
+        tf = t.flatten()
+        N = np.sqrt(np.conj(tf) @ tf)
+        self.tensor = t / N
+
+
+    def reset_initial(self, **opts):
+        """
+        (Re)set the tensor used for getting the autocorrelation
+        """
+        self.tensor0 = self.tensor.copy()
+
+
+    def link_node(self, nodeB, dim=0):
+        """
+        Link two nodes.
+        """
+        nodeA = self
+        if nodeA.uid == nodeB.uid: # avoid 1-node loops
+            raise ValueError('Not possible to link node with itself\n')
+        if nodeA.is_linked_to(nodeB): # avoid double linking
+            raise ValueError('Not possible to link two nodes twice\n')
+        nodeA.links.append(nodeB)
+        if not nodeB.is_pdof:
+            nodeB.links.append(nodeA)
+            nodeA.shape.append(dim)
+            nodeB.shape.append(dim)
+            nodeA.index_at_link.append(nodeB.links.index(nodeA))
+            nodeB.index_at_link.append(nodeA.links.index(nodeB))
+        else:
+            nodeA.shape.append(nodeB.dim)
+            nodeA.index_at_link.append(0)
+
+
+    def transpose_index(self, iold: int, inew: int):
+        """
+        Transpose index at position iold to position inew
+
+        If the node tensor is present the tensor indices are transposed accordingly
+        """
+        # Transpose pointers to nodes in the self.links list
+        trans_node = self.links.pop(iold)
+        self.links.insert(inew, trans_node)
+        # Transpose entries with bond dimensions in the self.shape list
+        trans_shape = self.shape.pop(iold)
+        self.shape.insert(inew, trans_shape)
+        # Transpose tensor indices
+        if self.tensor is not None:
+            # Create list with index positions [0, 1, 2,... ,self.dim()]
+            indices = list(range(self.dim))
+            trans_indx = indices.pop(iold)
+            indices.insert(inew, trans_indx)
+            self.tensor = self.tensor.transpose(indices)
+        # Update index of this node at linked nodes
+        for lb, nodeB in enumerate(self.links):
+            if not nodeB.is_pdof:
+                la = nodeB.links.index(self)
+                nodeB.index_at_link[la] = lb
+
+
+
+    def has_loops(self):
+        """
+        Return True if the graph under this node structure contains loops
+        """
+        pass
+
+
+    def is_linked_to(self, nodeB):
+        for lnode in self.links:
+            if lnode.uid == nodeB.uid:
+                return True
+        return False
+
+
+    def list_links(self, tags = False, exclude_pdof = False):
+        """
+        Lists all connections linked to nodeA, both nodes and primitives
+
+        Returns
+            list: The list is empty if the node has no links
+        """
+        lconnections = self.links[:]
+        if exclude_pdof:
+            lnodes = []
+            for l in lconnections:
+                if not l.is_pdof:
+                    lnodes.append(l)
+            lconnections = lnodes
+        if tags:
+            return _list_tags(lconnections)
+        else:
+            return lconnections
+
+
+    def return_link_index(self, other):
+        """
+        Return the index of node other @ node self
+        """
+        return self.links.index(other)
+
+
+    def is_primitive(self):
+       """
+       Return True if a node is primitive
+
+       Primitive nodes have ONE link to a non-primitive node
+       """
+       p = self.count_pdof()
+       n = len(self.shape) - p
+       if p >= 1 and n == 1:
+           return True
+       else:
+           return False
+
+
+    def is_mixed(self):
+        """
+        Return True if a node is of mixed type
+
+        A mixed node has primitive DOFs and more than one link to non-primitive nodes
+        """
+        p = self.count_pdof()
+        n = len(self.shape) - p
+        if p >= 1 and n > 1:
+            return True
+        else:
+            return False
+
+
+    def is_pure(self):
+        """
+        Return True if a node is of pure type
+
+        A pure node no primitive DOFs
+        """
+        p = self.count_pdof()
+        n = len(self.shape) - p
+        if p == 0 and n >= 1:
+            return True
+        else:
+            return False
+
+
+    def count_pdof(self):
+        count = 0
+        for child in self.list_links():
+            if child.is_pdof:
+                count += 1
+        return count
+
+
+    def sanity_check(self):
+        print('------------- Check Node ' + self.tag + ' ------------')
+        i = 0
+        for nodeB in self.links:
+            if nodeB.is_pdof:
+                continue
+            if nodeB.shape[nodeB.links.index(self)] == self.shape[self.links.index(nodeB)]:
+                tagA = self.tag
+                tagB = nodeB.tag
+                iB_at_A = str(self.links.index(nodeB))
+                iA_at_B = str(nodeB.links.index(self))
+                iA_at_B_2 = str(self.index_at_link[i])
+                m = str(nodeB.shape[nodeB.links.index(self)])
+                print(' ... ' + tagA + ' ' + iB_at_A + ' <-> ' + tagB + ' ' + iA_at_B + ' ' + iA_at_B_2 + ' => ' + m)
+            else:
+                raise ValueError(nodeB.tag + ' <-> ' + self.tag + ' broken')
+
+
+    def apply_matrix_to_index(self, matrix, indx):
+        pass
+
+    def apply_unitary_to_link(self, U, indx):
+        """
+        [NodeA ------ U] ------ [U^-1 --------- NodeB]
+
+        The convention is to apply U to node A (self) and U^-1 to node B
+        """
+        self.apply_matrix_to_index(U, indx)
+        UT = np.conj(U.T)
+        nodeB = self.links[indx]
+        iA_at_B = nodeB.links.index(self)
+        nodeB.apply_matrix_to_index(UT, iA_at_B)
+
+def _list_tags(nodeList):
+    lid = []
+    for node in nodeList:
+        lid.append(node.tag)
+    return lid
+
+

quadlib/experimental/pdof.py

@@ -0,0 +1,9 @@
+import uuid
+
+
+class Pdof:
+    def __init__(self, **opts):
+        self.uid = uuid.uuid4().hex
+        self.tag = opts.get('tag', self.uid)
+        self.dim = opts.get('dim', 0)
+        self.is_pdof = True

quadlib/experimental/tree.py

@@ -0,0 +1,138 @@
+import uuid
+
+
+class Tree:
+    def __init__(self, root = None, **opts):
+        self.uid = uuid.uuid4().hex
+        self.root = root
+        self.set_root(root)
+
+
+    @property
+    def len(self, **opts):
+        nCoeff = 0
+        lnodes = self.traverse_preorder(self.root)
+        for n in lnodes:
+            nNodeCoeff = n.len
+            nCoeff += nNodeCoeff
+        return nCoeff
+
+
+    def set_root(self, nroot, **opts):
+        self.root = nroot
+        self.root.is_visited = True
+        self.root.parent_index = -1
+        L = self.traverse_preorder() # pre-order traversal starting from the new root
+        for node in L[1:]:
+            node.is_visited = True
+            for j, lnode in enumerate(node.links):
+                if lnode.is_pdof is True:
+                    continue
+                if lnode.is_visited is True:
+                    node.parent_index = j
+                    break
+        # clean-up
+        for node in L:
+            node.is_visited = False
+        # Bring node links to canonical order (within each node parent is last self.links entry)
+        self.transpose_parent_index(**opts)
+
+
+    def transpose_parent_index(self, **opts):
+        """
+        Transpose parent index to last (first) position
+
+        For each node, the link to the parent is moved to either the first or the last (default) position.
+        The local tensor with the node's data is transposed accordingly.
+        """
+        index_order = opts.get('index_order', 'plast')
+        nodelist = self.traverse_preorder()
+        for n in nodelist[1:]:
+            iparent = n.parent_index
+            ndim = n.dim
+            if index_order == 'plast':
+                n.transpose_index(iparent, ndim - 1)
+            elif index_order == 'pfirst':
+                n.transpose_index(iparent, 0) 
+
+
+    def traverse_preorder(self,
+                          next_node = None,
+                          tags = False,
+                          lnodes = None,
+                          discovered = None,
+                          isFirstCall = True):
+        """
+        Traverse the tree in depth-first-search, preorder
+
+        - rootNode: node where the tree traversal is started
+        """
+        if isFirstCall:
+            lnodes = []
+            discovered = []
+            next_node = self.root
+        lnodes.append(next_node)
+        discovered.append(next_node)
+        for node in next_node.list_links(exclude_pdof = True):
+            if discovered.count(node) == 0:
+                self.traverse_preorder(node,
+                                       tags = False,
+                                       lnodes = lnodes,
+                                       discovered = discovered,
+                                       isFirstCall = False)
+        if tags:
+            return _list_tags(lnodes)
+        else:
+            return lnodes
+
+
+    def traverse_postorder(self,
+                           next_node = None,
+                           tags = False,
+                           lnodes = None,
+                           discovered = None,
+                           isFirstCall = True):
+        """
+        Traverse the tree in depth-first-search, postorder
+        """
+        if isFirstCall:
+            lnodes = []
+            discovered = []
+            next_node = self.root
+        discovered.append(next_node)
+        for node in next_node.list_links(exclude_pdof = True):
+            if discovered.count(node) == 0:
+                self.traverse_postorder(node,
+                                        tags = False,
+                                        lnodes = lnodes,
+                                        discovered = discovered,
+                                        isFirstCall = False)
+        lnodes.append(next_node)
+        if tags:
+            return _list_tags(lnodes)
+        else:
+            return lnodes
+
+
+    def print_tree_list(self):
+        for n in self.traverse_preorder():
+            t = n.tag
+            l = n.list_links(tags = True)
+            if n.parent_index > -1:
+                l.pop(n.parent_index)
+            s = t + ' -> ' + str(l)
+            print(s)
+
+
+    def sanity_check(self):
+        lnodes = self.traverse_preorder()
+        for node in lnodes:
+            node.sanity_check()
+
+
+def _list_tags(nodeList):
+    lid = []
+    for node in nodeList:
+        lid.append(node.tag)
+    return lid
+

quadlib/hdmctdh/rundirectory.py

@@ -0,0 +1,74 @@
+
+# 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)
+
+
+# This module defines classes and functions to open and interact with
+# an MCTDH run directory
+
+from pathlib import Path
+
+STANDARDFILES = ['input', 'output', 'check', 'log', 'oper', 'dvr']
+
+class Rundirectory:
+    """
+    Open an MCTDH Run directory for analysis etc.
+
+    path: str, path (absolute or relative) to run directory
+    """
+
+    def __init__(self, path):
+        rundir = Path(path)
+        self._messages = []
+        if not rundir.is_dir():
+            raise ValueError(path + ' is not a directory')
+        # We look for standard files to determine that this is an MCTDH run
+        for f in STANDARDFILES:
+            rf = rundir / f
+            if not rf.is_file():
+                msg = ' * Warning: ' + str(rf) + ' file not found'
+                self._messages.append(msg)
+        self.rundir = rundir
+        try:
+            self.auto = self.load_auto()
+        except Exception:
+            msg = ' * Error: auto file could not be loaded'
+            self._messages.append(msg)
+
+    @property
+    def messages(self):
+        return self._messages
+
+    def load_auto(self):
+        """
+        Load auto file as numpy array and return
+
+        Returns numpy array:
+          auto[0]: time steps
+          auto[1]: real part
+          auto[2]: imag part
+          auto[3]: absolute
+        """
+        import numpy as np
+        path_auto = self.rundir / 'auto'
+        if not path_auto.is_file():
+            msg = 'auto file not found in ' + str(self.rundir) 
+            raise ValueError(msg)
+            self._messages.append(msg)
+        auto = np.loadtxt(path_auto).T
+        return auto
+
+    def plauto(self, mode = 'survival'):
+        import matplotlib.pyplot as plt
+        a = self.auto
+        if mode == 'abs':
+            plt.plot(a[0], a[3])
+        elif mode == 'real':
+            plt.plot(a[0], a[1])
+        elif mode == 'imag':
+            plt.plot(a[0], a[2])
+        elif mode == 'survival':
+            plt.plot(a[0], a[3]**2)
+        plt.show()

quadlib/legacy/__init__.py

@@ -0,0 +1,14 @@
+# 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)
+
+"""
+Older utilities kept for reference and for existing scripts.
+
+Not imported by ``quadlib/__init__.py``, not used by the library, and
+not tested; import explicitly, e.g. ``import quadlib.legacy.math``.
+``quadlib.legacy.math`` is the former ``quadlib.tools.math`` minus the
+functions the library uses, which now live in ``quadlib.tools.linalg``
+and ``quadlib.tools.spectra``.
+"""