def setUp(self): super(Horton2Test, self).setUp() self.data, self.logfile = getdatafile("Gaussian", "basicGaussian16", ["dvb_un_sp.fchk"]) datadir = os.path.abspath( os.path.join(os.path.dirname(__file__), "..", "..", "data")) inputfile = os.path.join(datadir, "Gaussian", "basicGaussian16", "dvb_un_sp.fchk") self._old_horton = False self._found_horton = find_package("horton") if self._found_horton: try: from horton import __version__ except: self._old_horton = ( True # Old horton versions do not have this __version__ attribute ) else: if __version__[0] == "2": from horton.io.iodata import IOData from horton import log log.set_level( 0 ) # This suppresses horton outputs so that they do not flood the test log. self._hortonver = 2 self.iodat = IOData.from_file(inputfile)
def setUp(self): super(PyscfTest, self).setUp() if not find_package("pyscf"): raise ImportError("Must install pyscf to run this test") self.data, self.logfile = getdatafile( "GAMESS", "basicGAMESS-US2018", ["dvb_sp.out"] ) self.udata, self.ulogfile = getdatafile( "GAMESS", "basicGAMESS-US2018", ["dvb_un_sp.out"] )
def test_makepsi4(self): if not find_package('psi4'): raise ImportError('Must install psi4 to run this test') import psi4 from psi4 import energy psi4.core.set_output_file("psi4_output.dat", False) atomnos = np.array([1, 8, 1], "i") atomcoords = np.array([[-1, 1, 0], [0, 0, 0], [1, 1, 0]], "f") psi4mol = cclib2psi4.makepsi4(atomcoords, atomnos) psi4.set_options({'scf_type': 'pk'}) en = energy("scf/6-31G**", molecule=psi4mol) ref = -75.824754602 assert abs(en - ref) < 1.0e-6
def setUp(self): super(Horton3Test, self).setUp() self.data, self.logfile = getdatafile("Gaussian", "basicGaussian16", ["dvb_un_sp.fchk"]) datadir = os.path.abspath( os.path.join(os.path.dirname(__file__), "..", "..", "data")) inputfile = os.path.join(datadir, "Gaussian", "basicGaussian16", "dvb_un_sp.fchk") self._found_iodata = find_package("iodata") from iodata import IOData from iodata.orbitals import MolecularOrbitals from iodata.api import load_one self._hortonver = 3 self.iodat = load_one(filename=inputfile)
# Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Calculate properties of nuclei based on data parsed by cclib.""" import logging import numpy as np from cclib.method.calculationmethod import Method from cclib.parser.utils import PeriodicTable from cclib.parser.utils import find_package _found_periodictable = find_package("periodictable") if _found_periodictable: import periodictable as pt _found_scipy = find_package("scipy") if _found_scipy: import scipy.constants as spc def _check_periodictable(found_periodictable): if not _found_periodictable: raise ImportError("You must install `periodictable` to use this function") def _check_scipy(found_scipy): if not _found_scipy:
"F": [ (3, 0, 0), (2, 1, 0), (2, 0, 1), (1, 2, 0), (1, 1, 1), (1, 0, 2), (0, 3, 0), (0, 2, 1), (0, 1, 2), (0, 0, 3), ], } _found_pyquante = find_package("PyQuante") if _found_pyquante: from PyQuante.CGBF import CGBF def getbfs(ccdata): from cclib.bridge import cclib2pyquante pymol = cclib2pyquante.makepyquante(ccdata) bfs = [] for i, atom in enumerate(pymol): bs = ccdata.gbasis[i] for sym, prims in bs: for power in sym2powerlist[sym]: bf = CGBF(atom.pos(), power) for expnt, coef in prims:
# -*- coding: utf-8 -*- # # Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Facilities for moving parsed data to other cheminformatic libraries.""" from cclib.parser.utils import find_package if find_package("Bio"): from cclib.bridge.cclib2biopython import makebiopython if find_package("openbabel"): from cclib.bridge.cclib2openbabel import makeopenbabel if find_package("PyQuante"): from cclib.bridge.cclib2pyquante import makepyquante if find_package("psi4"): from cclib.bridge.cclib2psi4 import makepsi4 if find_package("ase"): from cclib.bridge.cclib2ase import makease if find_package("iodata"): from cclib.bridge.cclib2horton import makehorton if find_package("pyscf"): from cclib.bridge.cclib2pyscf import makepyscf, makepyscf_mos del find_package
# # Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in horton (http://theochem.github.io/horton).""" # Support for horton 2 will likely be dropped when Python 2 support is dropped from cclib. import numpy from cclib.parser.data import ccData from cclib.parser.utils import find_package # First check horton version _old_horton = False _found_horton = find_package("horton") _found_iodata = find_package("iodata") # Detect whether horton 2 is present or not if _found_horton: # Older horton packages do not have __version__, causing exceptions. try: from horton import __version__ except: _old_horton = True else: if __version__[0] == "2": from horton.io.iodata import IOData # Detect whether iodata (part of horton 3) is present or not # Horton 3 is divided into smaller (sub)packages that each take different functionalities.
# # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Calculate properties of nuclei based on data parsed by cclib.""" import logging import numpy as np from cclib.method.calculationmethod import Method from cclib.parser.utils import PeriodicTable from cclib.parser.utils import find_package _found_periodictable = find_package("periodictable") if _found_periodictable: import periodictable as pt _found_scipy = find_package("scipy") if _found_scipy: import scipy.constants as spc def _check_periodictable(found_periodictable): if not _found_periodictable: raise ImportError( "You must install `periodictable` to use this function") def _check_scipy(found_scipy):
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge between cclib data and openbabel (http://openbabel.org).""" from cclib.parser.data import ccData from cclib.parser.utils import find_package _found_openbabel = find_package("openbabel") if _found_openbabel: import openbabel as ob def _check_openbabel(found_openbabel): if not found_openbabel: raise ImportError("You must install `openbabel` to use this function") def makecclib(mol): """Create cclib attributes and return a ccData from an OpenBabel molecule. Beyond the numbers, masses and coordinates, we could also set the total charge and multiplicity, but often these are calculated from atomic formal charges so it is better to assume that would not be correct. """ _check_openbabel(_found_openbabel) attributes = {
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in biopython (http://biopython.org).""" from cclib.parser.utils import PeriodicTable from cclib.parser.utils import find_package _found_biopython = find_package("Bio") if _found_biopython: from Bio.PDB.Atom import Atom def makebiopython(atomcoords, atomnos): """Create a list of BioPython Atoms. This creates a list of BioPython Atoms suitable for use by Bio.PDB.Superimposer, for example. """ if not _found_biopython: raise ImportError("You must install `biopython` to use this function") pt = PeriodicTable() bioatoms = [] for coords, atomno in zip(atomcoords, atomnos): symbol = pt.element[atomno] bioatoms.append(Atom(symbol, coords, 0, 0, 0, symbol, 0, symbol.upper())) return bioatoms
# # Copyright (c) 2019, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Script for writing data tables from computational chemistry files.""" import argparse import os.path import sys from cclib.io import ccopen from cclib.io import ccframe from cclib.parser.utils import find_package _has_pandas = find_package("pandas") if _has_pandas: import pandas as pd def process_logfiles(filenames, output, identifier): df = ccframe([ccopen(path) for path in filenames]) if output is not None: outputtype = os.path.splitext(os.path.basename(output))[1][1:] if not outputtype: raise RuntimeWarning( "The output type could not be determined from the given path, " "not writing DataFrame to disk" ) if outputtype in {'csv'}:
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """A writer for chemical markup language (CML) files.""" import xml.etree.cElementTree as ET from cclib.io import filewriter from cclib.parser.utils import find_package _has_openbabel = find_package("openbabel") class CML(filewriter.Writer): """A writer for chemical markup language (CML) files.""" def __init__(self, ccdata, *args, **kwargs): """Initialize the CML writer object. Inputs: ccdata - An instance of ccData, parsed from a logfile. """ # Call the __init__ method of the superclass super(CML, self).__init__(ccdata, *args, **kwargs) def generate_repr(self):
# -*- coding: utf-8 -*- # # Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in ASE (https://wiki.fysik.dtu.dk/ase/).""" import numpy as np from cclib.parser.data import ccData from cclib.parser.utils import find_package _found_ase = find_package("ase") if _found_ase: from ase import Atoms, units from ase.io.trajectory import Trajectory from ase.calculators.calculator import PropertyNotImplementedError def _check_ase(found_ase): if not found_ase: raise ImportError("You must install `ase` to use this function") def makease(atomcoords, atomnos, atomcharges=None, atomspins=None, atommasses=None): """Create an ASE Atoms object from cclib attributes.
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in PyQuante (http://pyquante.sourceforge.net).""" from cclib.parser.utils import find_package _found_pyquante = find_package("PyQuante") if _found_pyquante: from PyQuante.Molecule import Molecule def _check_pyquante(found_pyquante): if not found_pyquante: raise ImportError("You must install `PyQuante` to use this function") def makepyquante(atomcoords, atomnos, charge=0, mult=1): """Create a PyQuante Molecule.""" _check_pyquante(_found_pyquante) return Molecule("notitle", list(zip(atomnos, atomcoords)), units="Angstrom", charge=charge, multiplicity=mult) del find_package
# -*- coding: utf-8 -*- # # Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Facilities for moving parsed data to other cheminformatic libraries.""" from cclib.parser.utils import find_package if find_package("Bio"): from cclib.bridge.cclib2biopython import makebiopython if find_package("openbabel"): from cclib.bridge.cclib2openbabel import makeopenbabel if find_package("PyQuante"): from cclib.bridge.cclib2pyquante import makepyquante if find_package("psi4"): from cclib.bridge.cclib2psi4 import makepsi4 if find_package("horton"): try: from horton import __version__ except Exception: pass else: if (__version__[0] == '2'): from cclib.bridge.cclib2horton import makehorton
[-0.3880329 0.2227029 0.16703 ] (array([-3.7422439 , -3.34907393, 0.80222668]), 5.0856910330516865) [[ 2.9476879 0.39972848 -0.47709812] [ 2.648237 -0.2199436 -0.65167883] [ 1.183168 1.256816 -0.11061444]] ''' import logging import numpy as np from cclib.method.calculationmethod import Method from cclib.parser.utils import PeriodicTable from cclib.parser.utils import find_package _found_periodictable = find_package("periodictable") if _found_periodictable: import periodictable.covalent_radius as pt def _check_periodictable(found_periodictable): if not _found_periodictable: raise ImportError("You must install `periodictable` to use this class") class CM5(Method): def __init__(self, data, fscale=1.20, progress=None, loglevel=logging.INFO,
# -*- coding: utf-8 -*- # # Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in horton (http://theochem.github.io/horton).""" import numpy from cclib.parser.data import ccData from cclib.parser.utils import find_package _found_iodata = find_package("iodata") # Detect whether iodata (part of horton 3) is present or not # Horton 3 is divided into smaller (sub)packages that each take different functionalities. if _found_iodata: from iodata import IOData from iodata.orbitals import MolecularOrbitals def check_horton(): if not _found_iodata: raise ImportError("You must install `horton` to use this function.") def makehorton(data): """ Create horton IOData object from ccData object """ check_horton() attributes = {}
# -*- coding: utf-8 -*- # # Copyright (c) 2019, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in Psi4 (http://www.psicode.org/).""" from cclib.parser.utils import find_package _found_psi4 = find_package("psi4") if _found_psi4: from psi4.core import Molecule def _check_psi4(found_psi4): if not found_psi4: raise ImportError("You must install `psi4` to use this function") def makepsi4(atomcoords, atomnos, charge=0, mult=1): """Create a Psi4 Molecule.""" _check_psi4(_found_psi4) return Molecule.from_arrays( name="notitle", elez=atomnos, geom=atomcoords, units="Angstrom", molecular_charge=charge, molecular_multiplicity=mult, )
# # Copyright (c) 2021, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Tests for the cclib2ase bridge in cclib.""" import unittest import numpy as np from cclib import ccopen from cclib.bridge import cclib2ase from cclib.parser.utils import find_package if not find_package('ase'): raise ImportError('Must install ase to run this test') from ase import Atoms from ase.calculators.emt import EMT class ASETest(unittest.TestCase): """Tests for the cclib2ase bridge in cclib.""" def setUp(self): super(ASETest, self).setUp() def test_makease_allows_optimization(self): """Ensure makease works from direct input.""" h2 = cclib2ase.makease([[0, 0, 0], [0, 0, 0.7]], [1, 1])
def setUp(self): super(pyquante2Test, self).setUp() self._found_pyquante2 = find_package("pyquante2") self.data, self.logfile = getdatafile("Gaussian", "basicGaussian16", ["water_ccsd.log"])
# -*- coding: utf-8 -*- # # Copyright (c) 2019, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in PySCF (https://github.com/pyscf/pyscf).""" from cclib.parser.utils import find_package, PeriodicTable import numpy as np l_sym2num = {"S": 0, "P": 1, "D": 2, "F": 3, "G": 4} _found_pyscf = find_package("pyscf") if _found_pyscf: from pyscf import gto def _check_pyscf(found_pyscf): if not found_pyscf: raise ImportError("You must install `pyscf` to use this function") def makepyscf(data, charge=0, mult=1): """Create a Pyscf Molecule.""" _check_pyscf(_found_pyscf) mol = gto.Mole( atom=[ ["{}".format(data.atomnos[i]), data.atomcoords[-1][i]]
# # Copyright (c) 2019, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Script for writing data tables from computational chemistry files.""" import argparse import os.path import sys from cclib.io import ccopen from cclib.io import ccframe from cclib.parser.utils import find_package _has_pandas = find_package("pandas") if _has_pandas: import pandas as pd def process_logfiles(filenames, output, identifier): df = ccframe([ccopen(path) for path in filenames]) if output is not None: outputtype = os.path.splitext(os.path.basename(output))[1][1:] if not outputtype: raise RuntimeWarning( "The output type could not be determined from the given path, " "not writing DataFrame to disk") if outputtype in {'csv'}: df.to_csv(output, mode='w')
def _read_proatom( self, directory, atom_num, charge # type = str # type = int # type = float ): # type: (...) -> numpy.ndarray, numpy.ndarray """Return a list containing proatom reference densities.""" # TODO: Treat calculations with psuedopotentials # TODO: Modify so that proatom densities are read only once for horton # [https://github.com/cclib/cclib/pull/914#discussion_r464039991] # File name format: # ** Chargemol ** # c2_[atom number]_[nuclear charge]_[electron count]_[cutoff radius]_[# shells] # ** Horton ** # atoms.h5 # File format: # Starting from line 13, each line contains the charge densities for each shell # If `charge` is not an integer, proatom densities have to be linearly interpolated between # the densities of the ion/atom with floor(charge) and ceiling(charge) charge_floor = int(math.floor(charge)) charge_ceil = int(math.ceil(charge)) chargemol_path_floor = os.path.join( directory, "c2_{:03d}_{:03d}_{:03d}_500_100.txt".format( atom_num, atom_num, atom_num - charge_floor), ) chargemol_path_ceil = os.path.join( directory, "c2_{:03d}_{:03d}_{:03d}_500_100.txt".format( atom_num, atom_num, atom_num - charge_ceil), ) horton_path = os.path.join(directory, "atoms.h5") if os.path.isfile(chargemol_path_floor) or os.path.isfile( chargemol_path_ceil): # Use chargemol proatom densities # Each shell is .05 angstroms apart (uniform). # *scalefactor* = 10.58354497764173 bohrs in module_global_parameter.f08 if atom_num <= charge_floor: density_floor = numpy.array([0]) else: density_floor = numpy.loadtxt(chargemol_path_floor, skiprows=12, dtype=float) if atom_num >= charge_ceil: density_ceil = numpy.array([0]) else: density_ceil = numpy.loadtxt(chargemol_path_ceil, skiprows=12, dtype=float) density = (charge_ceil - charge) * density_floor + ( charge - charge_floor) * density_ceil radiusgrid = numpy.arange(1, len(density) + 1) * 0.05 elif os.path.isfile(horton_path): # Use horton proatom densities assert find_package( "h5py" ), "h5py is needed to read in proatom densities from horton." import h5py with h5py.File(horton_path, "r") as proatomdb: if atom_num <= charge_floor: density_floor = numpy.array([0]) radiusgrid = numpy.array([0]) else: keystring_floor = "Z={}_Q={:+d}".format( atom_num, charge_floor) density_floor = numpy.asanyarray( list(proatomdb[keystring_floor]["rho"])) # gridspec is specification of integration grid for proatom densities in horton. # Example -- ['PowerRTransform', '1.1774580743206259e-07', '20.140888089596444', '41'] # is constructed using PowerRTransform grid # with rmin = 1.1774580743206259e-07 # rmax = 20.140888089596444 # and ngrid = 41 # PowerRTransform is default in horton-atomdb.py. gridtype, gridmin, gridmax, gridn = ( proatomdb[keystring_floor].attrs["rtransform"].split()) gridmin = convertor(float(gridmin), "bohr", "Angstrom") gridmax = convertor(float(gridmax), "bohr", "Angstrom") gridn = int(gridn) # Convert byte to string in Python3 if sys.version[0] == "3": gridtype = gridtype.decode("UTF-8") # First verify that it is one of recognized grids assert gridtype in [ "LinearRTransform", "ExpRTransform", "PowerRTransform", ], "Grid type not recognized." if gridtype == "LinearRTransform": # Linear transformation. r(t) = rmin + t*(rmax - rmin)/(npoint - 1) gridcoeff = (gridmax - gridmin) / (gridn - 1) radiusgrid = gridmin + numpy.arange( 1, gridn + 1) * gridcoeff elif gridtype == "ExpRTransform": # Exponential transformation. r(t) = rmin*exp(t*log(rmax/rmin)/(npoint - 1)) gridcoeff = math.log(gridmax / gridmin) / (gridn - 1) radiusgrid = gridmin * numpy.exp( numpy.arange(1, gridn + 1) * gridcoeff) elif gridtype == "PowerRTransform": # Power transformation. r(t) = rmin*t^power # with power = log(rmax/rmin)/log(npoint) gridcoeff = math.log( gridmax / gridmin) / math.log(gridn) radiusgrid = gridmin * numpy.power( numpy.arange(1, gridn + 1), gridcoeff) if atom_num <= charge_ceil: density_ceil = numpy.array([0]) else: keystring_ceil = "Z={}_Q={:+d}".format( atom_num, charge_ceil) density_ceil = numpy.asanyarray( list(proatomdb[keystring_ceil]["rho"])) density = (charge_ceil - charge) * density_floor + ( charge - charge_floor) * density_ceil del h5py else: raise MissingInputError( "Pro-atom densities were not found in the specified path.") if charge == charge_floor: density = density_floor return density, radiusgrid
from cclib.parser.nwchemparser import NWChem from cclib.parser.orcaparser import ORCA from cclib.parser.psi3parser import Psi3 from cclib.parser.psi4parser import Psi4 from cclib.parser.qchemparser import QChem from cclib.parser.turbomoleparser import Turbomole from cclib.io import cjsonreader from cclib.io import cjsonwriter from cclib.io import cmlwriter from cclib.io import moldenwriter from cclib.io import wfxwriter from cclib.io import xyzreader from cclib.io import xyzwriter _has_cclib2openbabel = find_package("openbabel") if _has_cclib2openbabel: from cclib.bridge import cclib2openbabel _has_pandas = find_package("pandas") if _has_pandas: import pandas as pd # Regular expression for validating URLs URL_PATTERN = re.compile( r'^(?:http|ftp)s?://' # http:// or https:// r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain... r'localhost|' # localhost... r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip r'(?::\d+)?' # optional port
def setUp(self): super(BiopythonTest, self).setUp() if not find_package("Bio"): raise ImportError("Must install biopython to run this test")
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Facilities for moving parsed data to other cheminformatic libraries.""" from cclib.parser.utils import find_package if find_package("Bio"): from cclib.bridge.cclib2biopython import makebiopython if find_package("openbabel"): from cclib.bridge.cclib2openbabel import makeopenbabel if find_package("PyQuante"): from cclib.bridge.cclib2pyquante import makepyquante del find_package
# Copyright (c) 2020, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Bridge for using cclib data in PyQuante (http://pyquante.sourceforge.net).""" import numpy from cclib.parser.utils import find_package class MissingAttributeError(Exception): pass _found_pyquante2 = find_package("pyquante2") if _found_pyquante2: from pyquante2 import molecule def _check_pyquante(): if not _found_pyquante2: raise ImportError("You must install `pyquante2` to use this function") def makepyquante(data): """Create a PyQuante Molecule from ccData object.""" _check_pyquante() # Check required attributes. required_attrs = {"atomcoords", "atomnos"}
# -*- coding: utf-8 -*- # # Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Facilities for moving parsed data to other cheminformatic libraries.""" from cclib.parser.utils import find_package if find_package("Bio"): from cclib.bridge.cclib2biopython import makebiopython if find_package("openbabel"): from cclib.bridge.cclib2openbabel import makeopenbabel if find_package("PyQuante"): from cclib.bridge.cclib2pyquante import makepyquante if find_package("psi4"): from cclib.bridge.cclib2psi4 import makepsi4 del find_package
# Copyright (c) 2017, the cclib development team # # This file is part of cclib (http://cclib.github.io) and is distributed under # the terms of the BSD 3-Clause License. """Calculation methods related to volume based on cclib data.""" from __future__ import print_function import copy import numpy from cclib.parser.utils import convertor from cclib.parser.utils import find_package _found_pyquante = find_package("PyQuante") if _found_pyquante: from PyQuante.CGBF import CGBF from cclib.bridge import cclib2pyquante _found_pyvtk = find_package("pyvtk") if _found_pyvtk: from pyvtk import * from pyvtk.DataSetAttr import * def _check_pyvtk(found_pyvtk): if not found_pyvtk: raise ImportError("You must install `pyvtk` to use this function")
import logging import sys from abc import ABCMeta, abstractmethod from six import add_metaclass if sys.version_info <= (3, 3): from collections import Iterable else: from collections.abc import Iterable import numpy from cclib.parser.utils import PeriodicTable from cclib.parser.utils import find_package _has_openbabel = find_package("openbabel") if _has_openbabel: from cclib.bridge import makeopenbabel try: from openbabel import openbabel as ob import openbabel.pybel as pb except: import openbabel as ob import pybel as pb class MissingAttributeError(Exception): pass @add_metaclass(ABCMeta)
def setUp(self): super(PyscfTest, self).setUp() if not find_package('pyscf'): raise ImportError('Must install pyscf to run this test')