pyscf 2.6.2__py3-none-macosx_11_0_arm64.whl → 2.8.0__py3-none-macosx_11_0_arm64.whl

{pyscf-2.6.2.dist-info → pyscf-2.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-macosx_11_0_arm64
 

pyscf/dft/gen_libxc_param.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2014-2019 The PySCF Developers. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import sys
-ldpath = os.path.abspath(os.path.join(__file__, '..', '..', 'lib', 'deps', 'lib'))
-if ldpath not in os.environ['LD_LIBRARY_PATH']:
-    sys.stderr.write(f'Set\n\tLD_LIBRARY_PATH={ldpath}:$LD_LIBRARY_PATH\n'
-                     'and rerun the script\n')
-    exit()
-
-pypath = os.path.join(__file__, '..', '..', 'lib', 'build', 'deps', 'src', 'libxc')
-sys.path.insert(0, os.path.abspath(pypath))
-import pylibxc
-
-for xcname in pylibxc.util.xc_available_functional_names():
-    f = pylibxc.LibXCFunctional(xcname, 1)
-    f_id = f.get_number()
-    ref = f.get_references()
-    key = f"'{xcname.upper()}'"
-    print(f"{key:<31s}: {f_id:<3d}, # {ref[0]}")
-    for r in ref[1:]:
-        print(f"                                     # {r}")

pyscf/dft/gen_xcfun_param.py

@@ -1,209 +0,0 @@
-#!/usr/bin/env python
-# Copyright 2014-2020 The PySCF Developers. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from pyscf import dft
-import ctypes
-
-libdft = dft.xcfun._itrf
-libdft.xc_enumerate_parameters.restype = ctypes.c_char_p
-libdft.XCFUN_xc_type.restype = ctypes.c_int
-libdft.xc_describe_short.restype = ctypes.c_char_p
-libdft.xc_describe_short.argtype = [ctypes.c_char_p]
-libdft.xc_describe_long.restype = ctypes.c_char_p
-libdft.xc_describe_long.argtype = [ctypes.c_char_p]
-lda_ids = []
-gga_ids = []
-mgga_ids = []
-mlgga_ids = []
-xc_codes = {}
-for i in range(68):
-    name = libdft.xc_enumerate_parameters(ctypes.c_int(i))
-    sdescr = libdft.xc_describe_short(name)
-    #ldescr = libdft.xc_describe_long(ctypes.c_int(i))
-    if sdescr is not None:
-        #print("'%s' : %d,  # %s" % (name, i, sdescr.replace('\n', '. ')))
-        print('%-16s: %2d,  # %s' % ("'%s'"%name, i, sdescr.replace('\n', '. ')))
-        xc_codes[name] = i
-
-    fntype = libdft.XCFUN_xc_type(ctypes.c_int(i))
-    if fntype == 0:
-        lda_ids.append(i)
-    elif fntype == 1:
-        gga_ids.append(i)
-    elif fntype == 2:
-        mgga_ids.append(i)
-
-alias = {
-    'SLATER': 'SLATERX',
-    'LDA'   : 'SLATERX',
-    'VWN'   : 'VWN5C',
-    'VWN5'  : 'VWN5C',
-    'B88'   : 'BECKEX',
-    'LYP'   : 'LYPC',
-}
-for k, v in alias.items():
-    print('%-16s: %2d,  # %s' % ("'%s'"%k, xc_codes[v], v))
-print('LDA_IDS = %s' % lda_ids)
-print('GGA_IDS = %s' % gga_ids)
-print('MGGA_IDS = %s' % mgga_ids)
-
-#define XC_D0 0
-#define XC_D1 1
-#define XC_D2 2
-#define XC_D3 3
-#define XC_D4 4
-
-#define XC_D00 0
-#define XC_D10 1
-#define XC_D01 2
-#define XC_D20 3
-#define XC_D11 4
-#define XC_D02 5
-#define XC_D30 6
-#define XC_D21 7
-#define XC_D12 8
-#define XC_D03 9
-#define XC_D40 10
-#define XC_D31 11
-#define XC_D22 12
-#define XC_D13 13
-#define XC_D04 14
-
-#define XC_D00000 0
-#define XC_D10000 1
-#define XC_D01000 2
-#define XC_D00100 3
-#define XC_D00010 4
-#define XC_D00001 5
-#define XC_D20000 6
-#define XC_D11000 7
-#define XC_D10100 8
-#define XC_D10010 9
-#define XC_D10001 10
-#define XC_D02000 11
-#define XC_D01100 12
-#define XC_D01010 13
-#define XC_D01001 14
-#define XC_D00200 15
-#define XC_D00110 16
-#define XC_D00101 17
-#define XC_D00020 18
-#define XC_D00011 19
-#define XC_D00002 20
-#define XC_D30000 21
-#define XC_D21000 22
-#define XC_D20100 23
-#define XC_D20010 24
-#define XC_D20001 25
-#define XC_D12000 26
-#define XC_D11100 27
-#define XC_D11010 28
-#define XC_D11001 29
-#define XC_D10200 30
-#define XC_D10110 31
-#define XC_D10101 32
-#define XC_D10020 33
-#define XC_D10011 34
-#define XC_D10002 35
-#define XC_D03000 36
-#define XC_D02100 37
-#define XC_D02010 38
-#define XC_D02001 39
-#define XC_D01200 40
-#define XC_D01110 41
-#define XC_D01101 42
-#define XC_D01020 43
-#define XC_D01011 44
-#define XC_D01002 45
-#define XC_D00300 46
-#define XC_D00210 47
-#define XC_D00201 48
-#define XC_D00120 49
-#define XC_D00111 50
-#define XC_D00102 51
-#define XC_D00030 52
-#define XC_D00021 53
-#define XC_D00012 54
-#define XC_D00003 55
-#define XC_D40000 56
-#define XC_D31000 57
-#define XC_D30100 58
-#define XC_D30010 59
-#define XC_D30001 60
-#define XC_D22000 61
-#define XC_D21100 62
-#define XC_D21010 63
-#define XC_D21001 64
-#define XC_D20200 65
-#define XC_D20110 66
-#define XC_D20101 67
-#define XC_D20020 68
-#define XC_D20011 69
-#define XC_D20002 70
-#define XC_D13000 71
-#define XC_D12100 72
-#define XC_D12010 73
-#define XC_D12001 74
-#define XC_D11200 75
-#define XC_D11110 76
-#define XC_D11101 77
-#define XC_D11020 78
-#define XC_D11011 79
-#define XC_D11002 80
-#define XC_D10300 81
-#define XC_D10210 82
-#define XC_D10201 83
-#define XC_D10120 84
-#define XC_D10111 85
-#define XC_D10102 86
-#define XC_D10030 87
-#define XC_D10021 88
-#define XC_D10012 89
-#define XC_D10003 90
-#define XC_D04000 91
-#define XC_D03100 92
-#define XC_D03010 93
-#define XC_D03001 94
-#define XC_D02200 95
-#define XC_D02110 96
-#define XC_D02101 97
-#define XC_D02020 98
-#define XC_D02011 99
-#define XC_D02002 100
-#define XC_D01300 101
-#define XC_D01210 102
-#define XC_D01201 103
-#define XC_D01120 104
-#define XC_D01111 105
-#define XC_D01102 106
-#define XC_D01030 107
-#define XC_D01021 108
-#define XC_D01012 109
-#define XC_D01003 110
-#define XC_D00400 111
-#define XC_D00310 112
-#define XC_D00301 113
-#define XC_D00220 114
-#define XC_D00211 115
-#define XC_D00202 116
-#define XC_D00130 117
-#define XC_D00121 118
-#define XC_D00112 119
-#define XC_D00103 120
-#define XC_D00040 121
-#define XC_D00031 122
-#define XC_D00022 123
-#define XC_D00013 124
-#define XC_D00004 125

pyscf/pbc/tdscf/kproxy.py

@@ -1,189 +0,0 @@
-#  Author: Artem Pulkin
-# flake8: noqa
-"""
-This and other `proxy` modules implement the time-dependent mean-field procedure using the existing pyscf
-implementations as a black box. The main purpose of these modules is to overcome the existing limitations in pyscf
-(i.e. real-only orbitals, davidson diagonalizer, incomplete Bloch space, etc). The primary performance drawback is that,
-unlike the original pyscf routines with an implicit construction of the eigenvalue problem, these modules construct TD
-matrices explicitly by proxying to pyscf density response routines with a O(N^4) complexity scaling. As a result,
-regular `numpy.linalg.eig` can be used to retrieve TD roots. Several variants of proxy-TD are available:
-
- * `pyscf.tdscf.proxy`: the molecular implementation;
- * `pyscf.pbc.tdscf.proxy`: PBC (periodic boundary condition) Gamma-point-only implementation;
- * `pyscf.pbc.tdscf.kproxy_supercell`: PBC implementation constructing supercells. Works with an arbitrary number of
-   k-points but has an overhead due to ignoring the momentum conservation law. In addition, works only with
-   time reversal invariant (TRI) models: i.e. the k-point grid has to be aligned and contain at least one TRI momentum.
- * (this module) `pyscf.pbc.tdscf.kproxy`: same as the above but respect the momentum conservation and, thus, diagonlizes smaller
-   matrices (the performance gain is the total number of k-points in the model).
-"""
-
-# Convention for these modules:
-# * PhysERI is the proxying class constructing time-dependent matrices
-# * vector_to_amplitudes reshapes and normalizes the solution
-# * TDProxy provides a container
-
-from functools import reduce
-from pyscf.pbc.tdscf import kproxy_supercell, krhf_slow
-
-import numpy
-
-
-def kov2ov(nocc, nmo, k):
-    """
-    Converts k point pairs into ov mask.
-    Args:
-        nocc (Iterable): occupation numbers per k-point;
-        nmo (Iterable): numbers of orbitals per k-point;
-        k (ndarray): k-point pairs;
-
-    Returns:
-        An ov-mask. Basis order: [k_o, o, k_v, v].
-    """
-    nocc = numpy.asanyarray(nocc)
-    nmo = numpy.asanyarray(nmo)
-
-    nvirt = nmo - nocc
-
-    mask = numpy.zeros((sum(nocc), sum(nvirt)), dtype=bool)
-
-    o_e = numpy.cumsum(nocc)
-    o_s = o_e - o_e[0]
-
-    v_e = numpy.cumsum(nvirt)
-    v_s = v_e - v_e[0]
-
-    for k1, k2 in enumerate(k):
-        mask[o_s[k1]:o_e[k1], v_s[k2]:v_e[k2]] = True
-
-    return mask.reshape(-1)
-
-
-class PhysERI(kproxy_supercell.PhysERI):
-    def __init__(self, model, proxy, x, mf_constructor, frozen=None, **kwargs):
-        """
-        A proxy class for calculating the TD matrix blocks (k-point version).
-
-        Args:
-            model: the base model with a time reversal-invariant k-point grid;
-            proxy: a pyscf proxy with TD response function, one of 'hf', 'dft';
-            x (Iterable): the original k-grid dimensions (numbers of k-points per each axis);
-            mf_constructor (Callable): a function constructing the mean-field object;
-            frozen (int, Iterable): the number of frozen valence orbitals or the list of frozen orbitals;
-            **kwargs: arguments to `k2s` function constructing supercells;
-        """
-        super(PhysERI, self).__init__(model, proxy, x, mf_constructor, frozen=frozen, **kwargs)
-
-    def get_ov_space_mask(self):
-        """
-        Prepares the space mask in the ov form.
-        Returns:
-            The mask in the ov form.
-        """
-        return kproxy_supercell.orb2ov(numpy.concatenate(self.space), self.nocc_full, self.nmo_full)
-
-    def kov2ov(self, k):
-        """
-        Converts k-ov mask into ov mask.
-        Args:
-            k (ndarray): k-point pairs;
-
-        Returns:
-            An ov-mask. Basis order: [k_o, o, k_v, v].
-        """
-        mask = self.get_ov_space_mask()
-        return numpy.logical_and(mask, kov2ov(self.nocc_full, self.nmo_full, k))
-
-    def proxy_response_ov_batch(self, k_row, k_col):
-        """
-        A raw response submatrix corresponding to specific k-points.
-        Args:
-            k_row (ndarray): sets of k-point pairs (row index);
-            k_col (ndarray): sets of k-point pairs (column index);
-
-        Returns:
-            A raw response matrix.
-        """
-        masks_row = tuple(self.kov2ov(i) for i in k_row)
-        masks_col = tuple(self.kov2ov(i) for i in k_col)
-
-        full_mask_row = reduce(numpy.logical_or, masks_row)
-        full_mask_col = reduce(numpy.logical_or, masks_col)
-
-        big = kproxy_supercell.supercell_response_ov(
-            self.proxy_vind,
-            (full_mask_row, full_mask_col),
-            self.nocc_full,
-            self.nmo_full,
-            self.proxy_is_double(),
-            self.model_super.supercell_inv_rotation,
-            self.model,
-        )
-
-        result = []
-
-        for m_row, m_col in zip(masks_row, masks_col):
-            m_row_red = m_row[full_mask_row]
-            m_col_red = m_col[full_mask_col]
-            result.append(tuple(i[m_row_red][:, m_col_red] for i in big))
-
-        return tuple(result)
-
-    # This is needed for krhf_slow.get_block_k_ix
-    get_k_ix = krhf_slow.PhysERI.get_k_ix.im_func
-
-    def tdhf_primary_form(self, k):
-        """
-        A primary form of TD matrices (full).
-        Args:
-            k (tuple, int): momentum transfer: either a pair of k-point indexes specifying the momentum transfer
-            vector or a single integer with the second index assuming the first index being zero;
-
-        Returns:
-            Output type: "full", and the corresponding matrix.
-        """
-        r1, r2, c1, c2 = krhf_slow.get_block_k_ix(self, k)
-        (a, _), (_, b), (_, b_star), (a_star, _) = self.proxy_response_ov_batch((r1, r1, r2, r2), (c1, c2, c1, c2))
-        return "full", numpy.block([[a, b], [-b_star.conj(), -a_star.conj()]])
-
-
-vector_to_amplitudes = krhf_slow.vector_to_amplitudes
-
-
-class TDProxy(kproxy_supercell.TDProxy):
-    v2a = staticmethod(vector_to_amplitudes)
-    proxy_eri = PhysERI
-
-    def __init__(self, mf, proxy, x, mf_constructor, frozen=None, **kwargs):
-        """
-        Performs TD calculation. Roots and eigenvectors are stored in `self.e`, `self.xy`.
-        Args:
-            mf: the base model with a time-reversal invariant k-point grid;
-            proxy: a pyscf proxy with TD response function, one of 'hf', 'dft';
-            x (Iterable): the original k-grid dimensions (numbers of k-points per each axis);
-            mf_constructor (Callable): a function constructing the mean-field object;
-            frozen (int, Iterable): the number of frozen valence orbitals or the list of frozen orbitals;
-            **kwargs: arguments to `k2s` function constructing supercells;
-        """
-        super(TDProxy, self).__init__(mf, proxy, x, mf_constructor, frozen=frozen, **kwargs)
-        self.e = {}
-        self.xy = {}
-
-    def kernel(self, k=None):
-        """
-        Calculates eigenstates and eigenvalues of the TDHF problem.
-        Args:
-            k (tuple, int): momentum transfer: either an index specifying the momentum transfer or a list of such
-            indexes;
-
-        Returns:
-            Positive eigenvalues and eigenvectors.
-        """
-        if k is None:
-            k = numpy.arange(len(self._scf.kpts))
-
-        if isinstance(k, int):
-            k = [k]
-
-        for kk in k:
-            self.e[kk], self.xy[kk] = self.__kernel__(k=kk)
-        return self.e, self.xy