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

pyscf/solvent/cosmors.py

@@ -0,0 +1,366 @@
+# Copyright 2014-2018 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.
+
+'''
+Provides functionality to generate COSMO files and sigma-profiles
+for the further use in COSMO-RS/COSMO-SAC computations and/or ML
+'''
+
+#%% Imports
+
+import re as _re
+from itertools import product as _product
+
+import numpy as _np
+
+from pyscf import __version__
+from pyscf.data.nist import BOHR as _BOHR
+
+
+
+#%% SAS volume
+
+def _get_line_atom_intersection(x, y, atom, r):
+    '''Returns z-coordinates of boundaries of intersection of
+    the (x,y,0) + t(0,0,1) line and vdW sphere
+
+    Arguments:
+        x (float): x parameter of the line
+        y (float): y parameter of the line
+        atom (np.ndarray): xyz-coordinates of the atom
+        r (float): van der Waals radii of the atom
+
+    Returns:
+        _tp.Optional[_tp.List[float, float]]: z-coordinates
+            of the line/sphere intersection, and None
+            if they do not intersect
+
+    '''
+    # check distance between line and atom
+    d = _np.linalg.norm(_np.array([x,y]) - atom[:2])
+    if d >= r:
+        return None
+    # find interval
+    dz = (r**2 - d**2)**0.5
+    interval = [atom[2] - dz, atom[2] + dz]
+
+    return interval
+
+
+def _unite_intervals(intervals):
+    '''Unites float intervals
+
+    Arguments:
+        intervals (_tp.List[_tp.List[float, float]]): list of intervals
+
+    Returns:
+        _tp.List[_tp.List[float, float]]: list of united intervals
+
+    '''
+    united = []
+    for begin, end in sorted(intervals):
+        if united and united[-1][1] >= begin:
+            united[-1][1] = end
+        else:
+            united.append([begin, end])
+
+    return united
+
+
+def _get_line_sas_intersection_length(x, y, coords, radii):
+    '''Finds total length of all (x,y,0) + t(0,0,1) line's intervals
+    enclosed by intersections with solvent-accessible surface
+
+    Arguments:
+        x (float): x parameter of the line
+        y (float): y parameter of the line
+        atoms (_np.ndarray): (n*3) array of atomic coordinates
+        radii (_np.ndarray): array of vdW radii
+
+    Returns:
+        float: total length of all line's intervals enclosed by SAS
+
+    '''
+    intervals = [_get_line_atom_intersection(x, y, atom, r) for atom, r in zip(coords, radii)]
+    intervals = _unite_intervals([_ for _ in intervals if _])
+    length = sum([end - begin for begin, end in intervals])
+
+    return length
+
+
+def get_sas_volume(surface, step=0.2):
+    '''Computes volume [A**3] of space enclosed by solvent-accessible surface
+
+    Arguments:
+        surface (dict): dictionary containing SAS parameters (mc.with_solvent.surface)
+        step (float): grid spacing parameter, [Bohr]
+
+    Returns:
+        float: SAS-defined volume of the molecule [A**3]
+
+    '''
+    # get parameters
+    coords = surface['atom_coords']
+    radii = _np.array([surface['R_vdw'][i] for i, j in surface['gslice_by_atom']])
+    # compute minimaxes of SAS coordinates
+    bounds = _np.array([(coords - radii[:, _np.newaxis]).min(axis = 0),
+                        (coords + radii[:, _np.newaxis]).max(axis = 0)])
+    # swap axes to minimize integration mesh
+    axes = [(val, idx) for idx, val in enumerate(bounds[1] - bounds[0])]
+    axes = [idx for val, idx in sorted(axes)]
+    coords = coords[:,axes]
+    bounds = bounds[:,axes]
+    # mesh parameters
+    xs = _np.linspace(bounds[0,0], bounds[1,0],
+                      int(_np.ceil((bounds[1,0] - bounds[0,0])/step)) + 1)
+    ys = _np.linspace(bounds[0,1], bounds[1,1],
+                      int(_np.ceil((bounds[1,1] - bounds[0,1])/step)) + 1)
+    dxdy = (xs[1] - xs[0])*(ys[1] - ys[0])
+    # integration
+    V = sum([dxdy * _get_line_sas_intersection_length(x, y, coords, radii) for x, y in _product(xs, ys)])
+
+    return V * _BOHR**3
+
+
+
+#%% COSMO-files
+
+def _check_feps(mf, ignore_low_feps):
+    '''Checks f_epsilon value and raises ValueError for f_eps < 1
+
+    Arguments:
+        mf: processed SCF with PCM solvation
+        ignore_low_feps (bool): if True, does not raise ValueError if feps < 1
+
+    Raises:
+        ValueError: if f_epsilon < 1 and ignore_low_feps flag is set to False
+
+    '''
+    if ignore_low_feps:
+        return
+
+    f_eps = mf.with_solvent._intermediates['f_epsilon']
+    if f_eps < 1.0:
+        message  = f'Low f_eps value: {f_eps}. '
+        message += 'COSMO-RS requires f_epsilon=1.0 or eps=float("inf"). '
+        message += 'Rerun computation with correct epsilon or use the ignore_low_feps argument.'
+        raise ValueError(message)
+
+    return
+
+
+def _lot(mf):
+    '''Returns level of theory in method-disp/basis/solvation format (raw solution)
+
+    Arguments:
+        mf: processed SCF
+
+    Returns:
+        str: method-dispersion/basis/solvation
+
+    '''
+    # method
+    method = mf.xc if hasattr(mf, 'xc') else None
+    if method is None:
+        match = _re.search('HF|MP2|CCSD', str(type(mf)))
+        method = match.group(0) if match else '???'
+    # dispersion
+    match = _re.search('D3|D4', str(type(mf)))
+    disp = '-' + match.group(0) if match else ''
+    # other
+    basis = mf.mol.basis
+    solv = '/' + mf.with_solvent.method if hasattr(mf, 'with_solvent') else ''
+    # approx
+    lot = f'{method}{disp}/{basis}{solv}'.lower()
+
+    return lot
+
+
+def write_cosmo_file(fout, mf, step=0.2, ignore_low_feps=False):
+    '''Saves COSMO file
+
+    Arguments:
+        fout: writable file object
+        mf: processed SCF with PCM solvation
+        step (float): grid spacing parameter to compute volume, [Bohr]
+        ignore_low_feps (bool): if True, does not raise ValueError if feps < 1
+
+    Raises:
+        ValueError: if f_epsilon < 1 and ignore_low_feps flag is set to False
+
+    '''
+    _check_feps(mf, ignore_low_feps)
+
+    # qm params
+    fout.write('$info\n')
+    fout.write(f'PySCF v. {__version__}, {_lot(mf)}\n')
+
+    # cosmo data
+    f_epsilon = mf.with_solvent._intermediates['f_epsilon']
+    n_segments = len(mf.with_solvent._intermediates['q'])
+    area = sum(mf.with_solvent.surface['area'])
+    volume = get_sas_volume(mf.with_solvent.surface, step) /  _BOHR**3
+    # print
+    fout.write('$cosmo_data\n')
+    fout.write(f'  fepsi  = {f_epsilon:>.8f}\n')
+    fout.write(f'  nps    = {n_segments:>10d}\n')
+    fout.write(f'  area   = {area:>10.2f}       # [Bohr**2]\n')
+    fout.write(f'  volume = {volume:>10.2f}       # [Bohr**3]\n')
+
+    # atomic coordinates
+    atoms = range(1, 1 + len(mf.mol.elements))
+    xs, ys, zs = zip(*mf.mol.atom_coords().tolist())
+    elems = [elem.lower() for elem in mf.mol.elements]
+    radii = [mf.with_solvent.surface['R_vdw'][i] for i, j in mf.with_solvent.surface['gslice_by_atom']]
+    # print
+    fout.write('$coord_rad\n')
+    fout.write('#atom   x [Bohr]           y [Bohr]           z [Bohr]      element  radius [Bohr]\n')
+    for atom, x, y, z, elem, r in zip(atoms, xs, ys, zs, elems, radii):
+        fout.write(f'{atom:>4d}{x:>19.14f}{y:>19.14f}{z:>19.14f}  {elem:<2}{r:>12.5f}\n')
+
+    # cosmo parameters
+    screening_charge = sum(mf.with_solvent._intermediates['q'])
+    E_tot = sum(mf.scf_summary.values())
+    E_diel = mf.scf_summary['e_solvent']
+    # print
+    fout.write('$screening_charge\n')
+    fout.write(f'  cosmo                          = {screening_charge:>15.6f}\n')
+    fout.write('$cosmo_energy\n')
+    fout.write(f'  Total energy [a.u.]            = {E_tot:>19.10f}\n')
+    fout.write(f'  Dielectric energy [a.u.]       = {E_diel:>19.10f}\n')
+
+    # segments
+    xs, ys, zs = zip(*mf.with_solvent.surface['grid_coords'].tolist())
+    ns = range(1, len(xs) + 1)
+    atoms = []
+    for idx, (start, end) in enumerate(mf.with_solvent.surface['gslice_by_atom']):
+        atoms += [idx + 1] * (end - start)
+    qs = mf.with_solvent._intermediates['q']
+    areas = mf.with_solvent.surface['area'] * _BOHR**2
+    sigmas = qs / areas
+    pots = mf.with_solvent._intermediates['v_grids']
+    # print legend
+    fout.write('$segment_information\n')
+    fout.write('# n             - segment number\n')
+    fout.write('# atom          - atom associated with segment n\n')
+    fout.write('# x, y, z       - segment coordinates, [Bohr]\n')
+    fout.write('# charge        - segment charge\n')
+    fout.write('# area          - segment area [A**2]\n')
+    fout.write('# charge/area   - segment charge density [e/A**2]\n')
+    fout.write('# potential     - solute potential on segment\n')
+    fout.write('#\n')
+    fout.write('#  n   atom              position (X, Y, Z)                   ')
+    fout.write('charge         area        charge/area     potential\n')
+    fout.write('#\n')
+    fout.write('#\n')
+    # print params
+    for n, x, y, z, atom, q, area, sigma, pot in zip(ns, xs, ys, zs, atoms, qs, areas, sigmas, pots):
+        line  = f'{n:>5d}{atom:>5d}{x:>15.9f}{y:>15.9f}{z:>15.9f}'
+        line += f'{q:>15.9f}{area:>15.9f}{sigma:>15.9f}{pot:>15.9f}\n'
+        fout.write(line)
+
+    return
+
+
+
+#%% Sigma-profile
+
+def get_sigma_profile(mf, sigmas_grid, ignore_low_feps=False):
+    '''Computes sigma-profile in [-0.025..0.025] e/A**2 range as in
+    https://github.com/usnistgov/COSMOSAC/blob/master/profiles/to_sigma.py#L181
+    https://doi.org/10.1021/acs.jctc.9b01016
+
+    Arguments:
+        mf: processed SCF with PCM solvation
+        sigmas_grid (_np.ndarray): grid of screening charge values,
+            e.g. np.linspace(-0.025, 0.025, 51)
+        ignore_low_feps (bool): if True, does not raise ValueError if feps < 1
+
+    Returns:
+        _np.ndarray: array of 51 elements corresponding to the p(sigma) values for
+            the screening charge values in [-0.025..0.025] e/A**2 range
+
+    Raises:
+        ValueError: if f_epsilon < 1 and ignore_low_feps flag is set to False
+
+    '''
+    _check_feps(mf, ignore_low_feps)
+
+    # prepare params
+    qs = mf.with_solvent._intermediates['q']
+    areas = mf.with_solvent.surface['area'] * _BOHR**2
+    sigmas = qs / areas
+    step = sigmas_grid[1] - sigmas_grid[0]
+    max_sigma = sigmas_grid[-1] + step
+    n_bins = len(sigmas_grid)
+
+    # compute profile
+    psigma = _np.zeros(n_bins)
+    for sigma, area in zip(sigmas, areas):
+        # get index of left sigma grid value
+        left = int(_np.floor((sigma - sigmas_grid[0]) / step))
+        if left < -1 or left > n_bins - 1:
+            continue
+        # get impact of the segment to the left bin
+        val_right = sigmas_grid[left+1] if left < n_bins - 1 else max_sigma
+        w_left = (val_right - sigma) / step
+        # add areas to p(sigma)
+        if left > -1:
+            psigma[left] += area * w_left
+        if left < n_bins - 1:
+            psigma[left+1] += area * (1 - w_left)
+
+    return psigma
+
+
+def get_cosmors_parameters(mf, sigmas_grid=_np.linspace(-0.025, 0.025, 51),
+                           step=0.2, ignore_low_feps=False):
+    '''Computes main COSMO-RS parameters
+
+    Arguments:
+        mf: processed SCF with PCM solvation
+        step (float): grid spacing parameter to compute volume, [Bohr]
+        ignore_low_feps (bool): if True, does not raise ValueError if feps < 1
+
+    Returns:
+        dict: main COSMO-RS parameters, including sigma-profile, volume, surface area,
+            SCF and dielectric energies
+
+    Raises:
+        ValueError: if f_epsilon < 1 and ignore_low_feps flag is set to False
+
+    '''
+    _check_feps(mf, ignore_low_feps)
+
+    # get params
+    lot = _lot(mf)
+    area = sum(mf.with_solvent.surface['area']) * _BOHR**2
+    volume = get_sas_volume(mf.with_solvent.surface, step)
+    psigma = get_sigma_profile(mf, sigmas_grid, ignore_low_feps=True)
+    E_tot = sum(mf.scf_summary.values())
+    E_diel = mf.scf_summary['e_solvent']
+
+    # output
+    params = {'PySCF version': __version__,
+              'Level of theory': lot,
+              'Surface area, A**2': float(area), # since np.float is not json-seriazable
+              'Volume, A**3': float(volume),
+              'Total energy, a.u.': float(E_tot),
+              'Dielectric energy, a.u.': float(E_diel),
+              'Screening charge density, A**2': psigma.tolist(),
+              'Screening charge, e/A**2': sigmas_grid.tolist()}
+
+    return params
+
+

pyscf/solvent/ddcosmo.py

@@ -680,7 +680,7 @@ class ddCOSMO(lib.StreamObject):
     @dm.setter
     def dm(self, dm):
         '''Set dm to enable/disable the frozen ddCOSMO solvent potential.
-        Setting dm to None will disable the frozen potental, i.e. the
+        Setting dm to None will disable the frozen potential, i.e. the
         potential will respond to the change of the density during SCF
         iterations.
         '''

pyscf/solvent/pcm.py

@@ -328,21 +328,21 @@ class PCM(lib.StreamObject):
 
         epsilon = self.eps
         if self.method.upper() in ['C-PCM', 'CPCM']:
-            f_epsilon = (epsilon-1.)/epsilon
+            f_epsilon = (epsilon-1.)/epsilon if epsilon != float('inf') else 1.0
             K = S
             R = -f_epsilon * numpy.eye(K.shape[0])
         elif self.method.upper() == 'COSMO':
-            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0/2.0)
+            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0/2.0) if epsilon != float('inf') else 1.0
             K = S
             R = -f_epsilon * numpy.eye(K.shape[0])
         elif self.method.upper() in ['IEF-PCM', 'IEFPCM']:
-            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0)
+            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0) if epsilon != float('inf') else 1.0
             DA = D*A
             DAS = numpy.dot(DA, S)
             K = S - f_epsilon/(2.0*PI) * DAS
             R = -f_epsilon * (numpy.eye(K.shape[0]) - 1.0/(2.0*PI)*DA)
         elif self.method.upper() == 'SS(V)PE':
-            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0)
+            f_epsilon = (epsilon - 1.0)/(epsilon + 1.0) if epsilon != float('inf') else 1.0
             DA = D*A
             DAS = numpy.dot(DA, S)
             K = S - f_epsilon/(4.0*PI) * (DAS + DAS.T)

pyscf/solvent/pol_embed.py

@@ -205,7 +205,7 @@ class PolEmbed(lib.StreamObject):
                 element_row = _get_element_row(p.element)
                 ecp_label, _ = _pe_ecps[element_row]
                 ecpatoms.append([ecp_label, p.x, p.y, p.z])
-            self.ecpmol = gto.M(atom=ecpatoms, ecp={l: k for (l, k) in _pe_ecps},
+            self.ecpmol = gto.M(atom=ecpatoms, ecp=dict(_pe_ecps),
                                 basis={}, unit="Bohr")
             # add the normal mol to compute integrals
             self.ecpmol += self.mol

pyscf/solvent/smd.py

@@ -250,17 +250,19 @@ def smd_radii(alpha):
     radii_table[53] = 2.74
     return radii_table/radii.BOHR
 
-import sys
 import ctypes
 from pyscf.lib import load_library
 try:
     libsolvent = load_library('libsolvent')
 except (IOError, NameError):
-    sys.stderr.write('SMD module is not available. '
-                     'You can compile this module with cmake option "-DENABLE_SMD=ON"')
     libsolvent = None
 
 def get_cds_legacy(smdobj):
+    if libsolvent is None:
+        raise RuntimeError(
+            'SMD module is not available. '
+            'You can compile this module with cmake option "-DENABLE_SMD=ON"')
+
     mol = smdobj.mol
     natm = mol.natm
     soln, _, sola, solb, solg, _, solc, solh = smdobj.solvent_descriptors

pyscf/soscf/ciah.py

@@ -16,8 +16,6 @@
 # Author: Qiming Sun <osirpt.sun@gmail.com>
 #
 
-import sys
-
 import numpy
 import scipy.linalg
 from pyscf import lib
@@ -77,10 +75,7 @@ class CIAHOptimizerMixin:
 
 def rotate_orb_cc(iah, u0, conv_tol_grad=None, verbose=logger.NOTE):
     t2m = (logger.process_clock(), logger.perf_counter())
-    if isinstance(verbose, logger.Logger):
-        log = verbose
-    else:
-        log = logger.Logger(sys.stdout, verbose)
+    log = logger.new_logger(verbose=verbose)
 
     if conv_tol_grad is None:
         conv_tol_grad = iah.conv_tol_grad
@@ -163,7 +158,7 @@ def rotate_orb_cc(iah, u0, conv_tol_grad=None, verbose=logger.NOTE):
 
                 elif (ikf > 2 and # avoid frequent keyframe
                       (ikf >= max(iah.kf_interval, iah.kf_interval-numpy.log(norm_dr+1e-9)) or
-                       # Insert keyframe if the keyframe and the esitimated g_orb are too different
+                       # Insert keyframe if the keyframe and the estimated g_orb are too different
                        norm_gorb < norm_gkf/kf_trust_region)):
                     ikf = 0
                     ukf = iah.extract_rotation(dr, ukf)
@@ -211,10 +206,7 @@ def rotate_orb_cc(iah, u0, conv_tol_grad=None, verbose=logger.NOTE):
 def davidson_cc(h_op, g_op, precond, x0, tol=1e-10, xs=[], ax=[],
                 max_cycle=30, lindep=1e-14, dot=numpy.dot, verbose=logger.WARN):
 
-    if isinstance(verbose, logger.Logger):
-        log = verbose
-    else:
-        log = logger.Logger(sys.stdout, verbose)
+    log = logger.new_logger(verbose=verbose)
 
     toloose = numpy.sqrt(tol)
     # the first trial vector is (1,0,0,...), which is not included in xs

pyscf/soscf/newton_ah.py

@@ -413,7 +413,7 @@ def _rotate_orb_cc(mf, h1e, s1e, conv_tol_grad=None, verbose=None):
                 elif (ikf > 2 and # avoid frequent keyframe
                       #TODO: replace it with keyframe_scheduler
                       (ikf >= max(mf.kf_interval, mf.kf_interval-numpy.log(norm_dr+1e-9)) or
-                       # Insert keyframe if the keyframe and the esitimated g_orb are too different
+                       # Insert keyframe if the keyframe and the estimated g_orb are too different
                        norm_gorb < norm_gkf/kf_trust_region)):
                     ikf = 0
                     u = mf.update_rotate_matrix(dr, mo_occ, mo_coeff=mo_coeff)
@@ -508,11 +508,15 @@ def kernel(mf, mo_coeff=None, mo_occ=None, dm=None,
     # Save mo_coeff and mo_occ because they are needed by function rotate_mo
     mf.mo_coeff, mf.mo_occ = mo_coeff, mo_occ
 
+    scf_conv = False
     e_tot = mf._scf.energy_tot(dm, h1e, vhf)
     fock = mf.get_fock(h1e, s1e, vhf, dm, level_shift_factor=0)
     log.info('Initial guess E= %.15g  |g|= %g', e_tot,
              numpy.linalg.norm(mf._scf.get_grad(mo_coeff, mo_occ, fock)))
 
+    if mf.max_cycle <= 0:
+        return scf_conv, e_tot, mo_energy, mo_coeff, mo_occ
+
     if dump_chk and mf.chkfile:
         chkfile.save_mol(mol, mf.chkfile)
 
@@ -525,7 +529,6 @@ def kernel(mf, mo_coeff=None, mo_occ=None, dm=None,
     next(rotaiter)  # start the iterator
     kftot = jktot = 0
     norm_gorb = 0.
-    scf_conv = False
     cput1 = log.timer('initializing second order scf', *cput0)
 
     for imacro in range(max_cycle):

pyscf/symm/__init__.py

@@ -18,7 +18,7 @@
 
 '''
 This module offers the functions to detect point group symmetry, basis
-symmetriziation, Clebsch-Gordon coefficients.  This module works as a plugin of
+symmetrization, Clebsch-Gordon coefficients.  This module works as a plugin of
 PySCF package.  Symmetry is not hard coded in each method.
 '''
 

pyscf/symm/addons.py

@@ -108,7 +108,7 @@ def symmetrize_orb(mol, mo, orbsym=None, s=None,
     :func:`symmetrize_space` symmetrizes the entire space by mixing different
     orbitals.
 
-    Note this function might return non-orthorgonal orbitals.
+    Note this function might return non-orthogonal orbitals.
     Call :func:`symmetrize_space` to find the symmetrized orbitals that are
     close to the given orbitals.
 
@@ -197,7 +197,7 @@ def symmetrize_space(mol, mo, s=None,
     '''Symmetrize the given orbital space.
 
     This function is different to the :func:`symmetrize_orb`:  In this function,
-    the given orbitals are mixed to reveal the symmtery; :func:`symmetrize_orb`
+    the given orbitals are mixed to reveal the symmetry; :func:`symmetrize_orb`
     projects out non-symmetric components for each orbital.
 
     Args:
@@ -281,7 +281,7 @@ def symmetrize_space(mol, mo, s=None,
             orb_irrep = numpy.dot(orb_irrep, orth.lowdin(moso))
             max_non_orth = abs(numpy.dot(orb_irrep.T.conj(), numpy.dot(s, orb_irrep))
                                - numpy.eye(orb_irrep.shape[1])).max()
-            logger.debug(mol, 'Non-orthogonality in irrep %3d after symmetrization and orthogonalizastion: %8.2e',
+            logger.debug(mol, 'Non-orthogonality in irrep %3d after symmetrization and orthogonalization: %8.2e',
                          i, max_non_orth)
         mo1.append(orb_irrep)
     mo1 = numpy.hstack(mo1)
@@ -354,7 +354,7 @@ def symmetrize_multidim(mol, mo, s=None,
             if (max_non_orth_lowdin - max_non_orth) > tol/100:
                 mo = mo_lowdin
                 s_mo = numpy.dot(s, mo)
-                logger.info(mol, 'Use Lowdin-orthogonalizied input orbitals')
+                logger.info(mol, 'Use Lowdin-orthogonalized input orbitals')
             else:
                 logger.info(mol, 'Use original input orbitals')
     irreps_mdim = []
@@ -489,7 +489,7 @@ def irrep_id2name(gpname, irrep_id):
             See IRREP_ID_TABLE in pyscf/symm/param.py
 
     Returns:
-        Irrep sybmol, str
+        Irrep symbol, str
     '''
     gpname = std_symb(gpname)
     if gpname == 'SO3':

pyscf/symm/geom.py

@@ -36,7 +36,6 @@
 # method (point group detection flowchart) to detect the point group.
 #
 
-import sys
 import re
 import numpy
 import scipy.linalg
@@ -166,10 +165,7 @@ def detect_symm(atoms, basis=None, verbose=logger.WARN):
 
     Return group name, charge center, and nex_axis (three rows for x,y,z)
     '''
-    if isinstance(verbose, logger.Logger):
-        log = verbose
-    else:
-        log = logger.Logger(sys.stdout, verbose)
+    log = logger.new_logger(verbose=verbose)
 
     tol = TOLERANCE / numpy.sqrt(1+len(atoms))
     decimals = int(-numpy.log10(tol))