### Navigation

- index
- modules
- toc
- next
- previous
- PSI4 [beta5] »

# psi4: Linking C++ and Python

    Python Library Documentation: built-in module psi4

    NAME
        psi4

    FILE
        (built-in)

    CLASSES
        Boost.Python.enum(__builtin__.int)
            DiagonalizeOrder
            PsiReturnType
        Boost.Python.instance(__builtin__.object)
            AOShellCombinationsIterator
            Arguments
            BasisSet
            BasisSetParser
                Gaussian94BasisSetParser
            CdSalcList
            Checkpoint
            CorrelationFactor
                FittedSlaterCorrelationFactor
            DFChargeFitter
            Dimension
            Dispersion
            DoublePyBuffer
            Environment
            ExternalPotential
            FittingMetric
            Functional
            GaussianShell
            GridProp
            IO
            IOManager
            IntVector
            IntegralFactory
            Localizer
                BoysLocalizer
                PMLocalizer
            Matrix
            MatrixFactory
            MintsHelper
            MoldenWriter
            Molecule
            MultipoleSymmetry
            NBOWriter
            OEProp
            OneBodyAOInt
                AngularMomentumInt
                DipoleInt
                ElectricFieldInt
                ElectrostaticInt
                KineticInt
                MultipoleInt
                NablaInt
                OverlapInt
                PotentialInt
                PseudospectralInt
                QuadrupoleInt
                TracelessQuadrupoleInt
            OrbitalSpace
            PetiteList
            PointGroup
            Process
            PseudoTrial
            SOBasisSet
            SuperFunctional
            SymmetryOperation
            TwoBodyAOInt
                TwoElectronInt
                    ERI
                    ErfComplementERI
                    ErfERI
                    F12
                    F12DoubleCommutator
                    F12G12
                    F12Squared
            Vector
            Vector3
            View
            Wavefunction
                HF
                    RHF(HF, Wavefunction)
            matrix_vector
            vector_of_doubles

        class AOShellCombinationsIterator(Boost.Python.instance)
         |  Method resolution order:
         |      AOShellCombinationsIterator
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  first(...)
         |      first( (AOShellCombinationsIterator)arg1) -> None :
         |          docstring
         |
         |  is_done(...)
         |      is_done( (AOShellCombinationsIterator)arg1) -> bool :
         |          docstring
         |
         |  next(...)
         |      next( (AOShellCombinationsIterator)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  p
         |      docstring
         |
         |  q
         |      docstring
         |
         |  r
         |      docstring
         |
         |  s
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class AngularMomentumInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      AngularMomentumInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Arguments(Boost.Python.instance)
         |  Method resolution order:
         |      Arguments
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __getitem__(...)
         |      __getitem__( (Arguments)arg1, (int)arg2) -> str :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 28
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class BasisSet(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      BasisSet
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __add__(...)
         |      __add__( (BasisSet)arg1, (BasisSet)arg2) -> object
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  add(...)
         |      add( (BasisSet)arg1, (BasisSet)arg2) -> BasisSet :
         |          Combine two basis sets to make a new one.
         |
         |  ao_to_shell(...)
         |      ao_to_shell( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  concatenate(...)
         |      concatenate( (BasisSet)arg1, (BasisSet)arg2) -> BasisSet :
         |          Concatenates two basis sets together into a new basis without reordering anything. Unless you know what you're doing, you should use the '+' operator instead of this method.
         |
         |  function_to_center(...)
         |      function_to_center( (BasisSet)arg1, (int)arg2) -> int :
         |          Given a function number, return the number of the center it is on.
         |
         |  function_to_shell(...)
         |      function_to_shell( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  has_puream(...)
         |      has_puream( (BasisSet)arg1) -> bool :
         |          docstring
         |
         |  max_am(...)
         |      max_am( (BasisSet)arg1) -> int :
         |          docstring
         |
         |  nao(...)
         |      nao( (BasisSet)arg1) -> int :
         |          docstring
         |
         |  nbf(...)
         |      nbf( (BasisSet)arg1) -> int :
         |          docstring
         |
         |  nprimitive(...)
         |      nprimitive( (BasisSet)arg1) -> int :
         |          docstring
         |
         |  nshell(...)
         |      nshell( (BasisSet)arg1) -> int :
         |          docstring
         |
         |  nshell_on_center(...)
         |      nshell_on_center( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  print_detail_out(...)
         |      print_detail_out( (BasisSet)arg1) -> None :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (BasisSet)arg1) -> None :
         |          docstring
         |
         |  shell(...)
         |      shell( (BasisSet)arg1, (int)arg2) -> GaussianShell :
         |          docstring
         |
         |      shell( (BasisSet)arg1, (int)arg2, (int)arg3) -> GaussianShell :
         |          docstring
         |
         |  shell_to_ao_function(...)
         |      shell_to_ao_function( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  shell_to_basis_function(...)
         |      shell_to_basis_function( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  shell_to_center(...)
         |      shell_to_center( (BasisSet)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  construct(...)
         |      construct( (BasisSetParser)arg1, (Molecule)arg2, (str)arg3) -> BasisSet :
         |          docstring
         |
         |  make_filename(...)
         |      make_filename( (str)arg1) -> str :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class BasisSetParser(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      BasisSetParser
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class BoysLocalizer(Localizer)
         |  docstring
         |
         |  Method resolution order:
         |      BoysLocalizer
         |      Localizer
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Localizer:
         |
         |  localize(...)
         |      localize( (Localizer)arg1) -> None :
         |          Perform the localization procedure
         |
         |  ----------------------------------------------------------------------
         |  Static methods inherited from Localizer:
         |
         |  build(...)
         |      build( (str)arg1, (BasisSet)arg2, (Matrix)arg3) -> Localizer :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Localizer:
         |
         |  L
         |      Localized orbital coefficients
         |
         |  U
         |      Orbital rotation matrix
         |
         |  converged
         |      Did the localization procedure converge?
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class CdSalcList(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      CdSalcList
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  matrix(...)
         |      matrix( (CdSalcList)arg1) -> Matrix :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (CdSalcList)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Checkpoint(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Checkpoint
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (IO)arg2, (int)arg3) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  shared_object(...)
         |      shared_object() -> Checkpoint :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  disp
         |      docstring
         |
         |  e_t
         |      docstring
         |
         |  eccsd
         |      docstring
         |
         |  ecorr
         |      docstring
         |
         |  efzc
         |      docstring
         |
         |  emp2
         |      docstring
         |
         |  enuc
         |      docstring
         |
         |  eref
         |      docstring
         |
         |  escf
         |      docstring
         |
         |  etot
         |      docstring
         |
         |  label
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class CorrelationFactor(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      CorrelationFactor
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (int)arg2) -> None
         |
         |      __init__( (object)arg1, (Vector)arg2, (Vector)arg3) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  set_params(...)
         |      set_params( (CorrelationFactor)arg1, (Vector)arg2, (Vector)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class DFChargeFitter(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      DFChargeFitter
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  d(...)
         |      d( (DFChargeFitter)arg1) -> Vector :
         |          docstring
         |
         |  fit(...)
         |      fit( (DFChargeFitter)arg1) -> Vector :
         |          docstring
         |
         |  setAuxiliary(...)
         |      setAuxiliary( (DFChargeFitter)arg1, (BasisSet)arg2) -> None :
         |          docstring
         |
         |  setD(...)
         |      setD( (DFChargeFitter)arg1, (Matrix)arg2) -> None :
         |          docstring
         |
         |  setPrimary(...)
         |      setPrimary( (DFChargeFitter)arg1, (BasisSet)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class DiagonalizeOrder(Boost.Python.enum)
         |  docstring
         |
         |  Method resolution order:
         |      DiagonalizeOrder
         |      Boost.Python.enum
         |      __builtin__.int
         |      __builtin__.object
         |
         |  Data and other attributes defined here:
         |
         |  Ascending = psi4.DiagonalizeOrder.Ascending
         |
         |  Descending = psi4.DiagonalizeOrder.Descending
         |
         |  names = {'Ascending': psi4.DiagonalizeOrder.Ascending, 'Descending': p...
         |
         |  values = {1: psi4.DiagonalizeOrder.Ascending, 3: psi4.DiagonalizeOrder...
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Boost.Python.enum:
         |
         |  __repr__(...)
         |      x.__repr__() <==> repr(x)
         |
         |  __str__(...)
         |      x.__str__() <==> str(x)
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.enum:
         |
         |  name
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from __builtin__.int:
         |
         |  __abs__(...)
         |      x.__abs__() <==> abs(x)
         |
         |  __add__(...)
         |      x.__add__(y) <==> x+y
         |
         |  __and__(...)
         |      x.__and__(y) <==> x&y
         |
         |  __cmp__(...)
         |      x.__cmp__(y) <==> cmp(x,y)
         |
         |  __coerce__(...)
         |      x.__coerce__(y) <==> coerce(x, y)
         |
         |  __div__(...)
         |      x.__div__(y) <==> x/y
         |
         |  __divmod__(...)
         |      x.__divmod__(y) <==> divmod(x, y)
         |
         |  __float__(...)
         |      x.__float__() <==> float(x)
         |
         |  __floordiv__(...)
         |      x.__floordiv__(y) <==> x//y
         |
         |  __format__(...)
         |
         |  __getattribute__(...)
         |      x.__getattribute__('name') <==> x.name
         |
         |  __getnewargs__(...)
         |
         |  __hash__(...)
         |      x.__hash__() <==> hash(x)
         |
         |  __hex__(...)
         |      x.__hex__() <==> hex(x)
         |
         |  __index__(...)
         |      x[y:z] <==> x[y.__index__():z.__index__()]
         |
         |  __int__(...)
         |      x.__int__() <==> int(x)
         |
         |  __invert__(...)
         |      x.__invert__() <==> ~x
         |
         |  __long__(...)
         |      x.__long__() <==> long(x)
         |
         |  __lshift__(...)
         |      x.__lshift__(y) <==> x<<y
         |
         |  __mod__(...)
         |      x.__mod__(y) <==> x%y
         |
         |  __mul__(...)
         |      x.__mul__(y) <==> x*y
         |
         |  __neg__(...)
         |      x.__neg__() <==> -x
         |
         |  __nonzero__(...)
         |      x.__nonzero__() <==> x != 0
         |
         |  __oct__(...)
         |      x.__oct__() <==> oct(x)
         |
         |  __or__(...)
         |      x.__or__(y) <==> x|y
         |
         |  __pos__(...)
         |      x.__pos__() <==> +x
         |
         |  __pow__(...)
         |      x.__pow__(y[, z]) <==> pow(x, y[, z])
         |
         |  __radd__(...)
         |      x.__radd__(y) <==> y+x
         |
         |  __rand__(...)
         |      x.__rand__(y) <==> y&x
         |
         |  __rdiv__(...)
         |      x.__rdiv__(y) <==> y/x
         |
         |  __rdivmod__(...)
         |      x.__rdivmod__(y) <==> divmod(y, x)
         |
         |  __rfloordiv__(...)
         |      x.__rfloordiv__(y) <==> y//x
         |
         |  __rlshift__(...)
         |      x.__rlshift__(y) <==> y<<x
         |
         |  __rmod__(...)
         |      x.__rmod__(y) <==> y%x
         |
         |  __rmul__(...)
         |      x.__rmul__(y) <==> y*x
         |
         |  __ror__(...)
         |      x.__ror__(y) <==> y|x
         |
         |  __rpow__(...)
         |      y.__rpow__(x[, z]) <==> pow(x, y[, z])
         |
         |  __rrshift__(...)
         |      x.__rrshift__(y) <==> y>>x
         |
         |  __rshift__(...)
         |      x.__rshift__(y) <==> x>>y
         |
         |  __rsub__(...)
         |      x.__rsub__(y) <==> y-x
         |
         |  __rtruediv__(...)
         |      x.__rtruediv__(y) <==> y/x
         |
         |  __rxor__(...)
         |      x.__rxor__(y) <==> y^x
         |
         |  __sub__(...)
         |      x.__sub__(y) <==> x-y
         |
         |  __truediv__(...)
         |      x.__truediv__(y) <==> x/y
         |
         |  __trunc__(...)
         |      Truncating an Integral returns itself.
         |
         |  __xor__(...)
         |      x.__xor__(y) <==> x^y
         |
         |  bit_length(...)
         |      int.bit_length() -> int
         |
         |      Number of bits necessary to represent self in binary.
         |      >>> bin(37)
         |      '0b100101'
         |      >>> (37).bit_length()
         |      6
         |
         |  conjugate(...)
         |      Returns self, the complex conjugate of any int.
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from __builtin__.int:
         |
         |  denominator
         |      the denominator of a rational number in lowest terms
         |
         |  imag
         |      the imaginary part of a complex number
         |
         |  numerator
         |      the numerator of a rational number in lowest terms
         |
         |  real
         |      the real part of a complex number
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from __builtin__.int:
         |
         |  __new__ = <built-in method __new__ of type object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Dimension(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Dimension
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __getitem__(...)
         |      __getitem__( (Dimension)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (int)arg2) -> None
         |
         |      __init__( (object)arg1, (int)arg2, (str)arg3) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setitem__(...)
         |      __setitem__( (Dimension)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  init(...)
         |      init( (Dimension)arg1, (str)arg2, (int)arg3) -> None :
         |          Re-initializes the dimension object
         |
         |  n(...)
         |      n( (Dimension)arg1) -> int :
         |          The order of the dimension
         |
         |  print_out(...)
         |      print_out( (Dimension)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  name
         |      The name of the dimension. Used in printing.
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 20
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class DipoleInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      DipoleInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Dispersion(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Dispersion
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  a1(...)
         |      a1( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  a2(...)
         |      a2( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  bibtex(...)
         |      bibtex( (Dispersion)arg1) -> str :
         |          Get the BibTeX key for the literature reference.
         |
         |  citation(...)
         |      citation( (Dispersion)arg1) -> str :
         |          docstring
         |
         |  compute_energy(...)
         |      compute_energy( (Dispersion)arg1, (Molecule)arg2) -> float :
         |          docstring
         |
         |  compute_gradient(...)
         |      compute_gradient( (Dispersion)arg1, (Molecule)arg2) -> Matrix :
         |          docstring
         |
         |  compute_hessian(...)
         |      compute_hessian( (Dispersion)arg1, (Molecule)arg2) -> Matrix :
         |          docstring
         |
         |  d(...)
         |      d( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  description(...)
         |      description( (Dispersion)arg1) -> str :
         |          docstring
         |
         |  name(...)
         |      name( (Dispersion)arg1) -> str :
         |          docstring
         |
         |  print_energy(...)
         |      print_energy( (Dispersion)arg1, (Molecule)arg2) -> str :
         |          docstring
         |
         |  print_gradient(...)
         |      print_gradient( (Dispersion)arg1, (Molecule)arg2) -> str :
         |          docstring
         |
         |  print_hessian(...)
         |      print_hessian( (Dispersion)arg1, (Molecule)arg2) -> str :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (Dispersion)arg1) -> None :
         |          docstring
         |
         |  s6(...)
         |      s6( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  s8(...)
         |      s8( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  set_bibtex(...)
         |      set_bibtex( (Dispersion)arg1, (str)arg2) -> None :
         |          Set the BibTeX key for the literature reference.
         |
         |  set_citation(...)
         |      set_citation( (Dispersion)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_description(...)
         |      set_description( (Dispersion)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_name(...)
         |      set_name( (Dispersion)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  sr6(...)
         |      sr6( (Dispersion)arg1) -> float :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  build(...)
         |      build( (str)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> Dispersion :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class DoublePyBuffer(Boost.Python.instance)
         |  Buffer interface to NumPy arrays
         |
         |  Method resolution order:
         |      DoublePyBuffer
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __array_interface__(...)
         |      __array_interface__( (DoublePyBuffer)arg1) -> dict :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ERI(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      ERI
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ElectricFieldInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      ElectricFieldInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ElectrostaticInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      ElectrostaticInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Environment(Boost.Python.instance)
         |  Method resolution order:
         |      Environment
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __getitem__(...)
         |      __getitem__( (Environment)arg1, (str)arg2) -> str :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 192
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ErfComplementERI(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      ErfComplementERI
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ErfERI(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      ErfERI
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class ExternalPotential(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      ExternalPotential
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  addBasis(...)
         |      addBasis( (ExternalPotential)arg1, (BasisSet)arg2, (Vector)arg3) -> None :
         |          docstring
         |
         |  addCharge(...)
         |      addCharge( (ExternalPotential)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None :
         |          docstring
         |
         |  clear(...)
         |      clear( (ExternalPotential)arg1) -> None :
         |          docstring
         |
         |  computePotentialMatrix(...)
         |      computePotentialMatrix( (ExternalPotential)arg1, (BasisSet)arg2) -> Matrix :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (ExternalPotential)arg1) -> None :
         |          docstring
         |
         |  setName(...)
         |      setName( (ExternalPotential)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class F12(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      F12
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class F12DoubleCommutator(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      F12DoubleCommutator
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class F12G12(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      F12G12
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class F12Squared(TwoElectronInt)
         |  docstring
         |
         |  Method resolution order:
         |      F12Squared
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class FittedSlaterCorrelationFactor(CorrelationFactor)
         |  docstring
         |
         |  Method resolution order:
         |      FittedSlaterCorrelationFactor
         |      CorrelationFactor
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (float)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  exponent(...)
         |      exponent( (FittedSlaterCorrelationFactor)arg1) -> float
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from CorrelationFactor:
         |
         |  set_params(...)
         |      set_params( (CorrelationFactor)arg1, (Vector)arg2, (Vector)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class FittingMetric(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      FittingMetric
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  form_QR_inverse(...)
         |      form_QR_inverse( (FittingMetric)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  form_cholesky_inverse(...)
         |      form_cholesky_inverse( (FittingMetric)arg1) -> None :
         |          docstring
         |
         |  form_eig_inverse(...)
         |      form_eig_inverse( (FittingMetric)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  form_fitting_metric(...)
         |      form_fitting_metric( (FittingMetric)arg1) -> None :
         |          docstring
         |
         |  form_full_inverse(...)
         |      form_full_inverse( (FittingMetric)arg1) -> None :
         |          docstring
         |
         |  get_algorithm(...)
         |      get_algorithm( (FittingMetric)arg1) -> str :
         |          docstring
         |
         |  get_metric(...)
         |      get_metric( (FittingMetric)arg1) -> Matrix :
         |          docstring
         |
         |  get_pivots(...)
         |      get_pivots( (FittingMetric)arg1) -> IntVector :
         |          docstring
         |
         |  get_reverse_pivots(...)
         |      get_reverse_pivots( (FittingMetric)arg1) -> IntVector :
         |          docstring
         |
         |  is_inverted(...)
         |      is_inverted( (FittingMetric)arg1) -> bool :
         |          docstring
         |
         |  is_poisson(...)
         |      is_poisson( (FittingMetric)arg1) -> bool :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Functional(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Functional
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  alpha(...)
         |      alpha( (Functional)arg1) -> float :
         |          docstring
         |
         |  citation(...)
         |      citation( (Functional)arg1) -> str :
         |          docstring
         |
         |  description(...)
         |      description( (Functional)arg1) -> str :
         |          docstring
         |
         |  is_gga(...)
         |      is_gga( (Functional)arg1) -> bool :
         |          docstring
         |
         |  is_lrc(...)
         |      is_lrc( (Functional)arg1) -> bool :
         |          docstring
         |
         |  is_meta(...)
         |      is_meta( (Functional)arg1) -> bool :
         |          docstring
         |
         |  lsda_cutoff(...)
         |      lsda_cutoff( (Functional)arg1) -> float :
         |          docstring
         |
         |  meta_cutoff(...)
         |      meta_cutoff( (Functional)arg1) -> float :
         |          docstring
         |
         |  name(...)
         |      name( (Functional)arg1) -> str :
         |          docstring
         |
         |  omega(...)
         |      omega( (Functional)arg1) -> float :
         |          docstring
         |
         |  print_detail(...)
         |      print_detail( (SuperFunctional)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (Functional)arg1) -> None :
         |          docstring
         |
         |  set_alpha(...)
         |      set_alpha( (Functional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_citation(...)
         |      set_citation( (Functional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_description(...)
         |      set_description( (Functional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_gga(...)
         |      set_gga( (Functional)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  set_lsda_cutoff(...)
         |      set_lsda_cutoff( (Functional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_meta(...)
         |      set_meta( (Functional)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  set_meta_cutoff(...)
         |      set_meta_cutoff( (Functional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_name(...)
         |      set_name( (Functional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_omega(...)
         |      set_omega( (Functional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_parameter(...)
         |      set_parameter( (Functional)arg1, (str)arg2, (float)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  build_base(...)
         |      build_base( (str)arg1) -> Functional :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Gaussian94BasisSetParser(BasisSetParser)
         |  docstring
         |
         |  Method resolution order:
         |      Gaussian94BasisSetParser
         |      BasisSetParser
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class GaussianShell(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      GaussianShell
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  coef(...)
         |      coef( (GaussianShell)arg1, (int)arg2) -> float :
         |          docstring
         |
         |  exp(...)
         |      exp( (GaussianShell)arg1, (int)arg2) -> float :
         |          Returns the exponent of the given primitive
         |
         |  is_cartesian(...)
         |      is_cartesian( (GaussianShell)arg1) -> bool :
         |          docstring
         |
         |  is_pure(...)
         |      is_pure( (GaussianShell)arg1) -> bool :
         |          docstring
         |
         |  normalize_shell(...)
         |      normalize_shell( (GaussianShell)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  AMCHAR
         |      docstring
         |
         |  am
         |      docstring
         |
         |  amchar
         |      docstring
         |
         |  center
         |      A Vector3 representing the center of the GaussianShell.
         |
         |  coefs
         |      The coefficients of all the primitives
         |
         |  exps
         |      The exponents of all the primitives
         |
         |  function_index
         |      Basis function index where this shell starts.
         |
         |  ncartesian
         |      docstring
         |
         |  ncenter
         |      docstring
         |
         |  nfunction
         |      docstring
         |
         |  nprimitive
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class GridProp(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      GridProp
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  add(...)
         |      add( (GridProp)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  add_alpha_mo(...)
         |      add_alpha_mo( (GridProp)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  add_basis_fun(...)
         |      add_basis_fun( (GridProp)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  add_beta_mo(...)
         |      add_beta_mo( (GridProp)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  build_grid_overages(...)
         |      build_grid_overages( (GridProp)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  compute(...)
         |      compute( (GridProp)arg1) -> None :
         |          docstring
         |
         |  get_l(...)
         |      get_l( (GridProp)arg1, (int)arg2) -> float :
         |          docstring
         |
         |  get_n(...)
         |      get_n( (GridProp)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  get_o(...)
         |      get_o( (GridProp)arg1, (int)arg2) -> float :
         |          docstring
         |
         |  set_caxis(...)
         |      set_caxis( (GridProp)arg1, (float)arg2, (float)arg3) -> None :
         |          docstring
         |
         |  set_filename(...)
         |      set_filename( (GridProp)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_format(...)
         |      set_format( (GridProp)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_l(...)
         |      set_l( (GridProp)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
         |          docstring
         |
         |  set_n(...)
         |      set_n( (GridProp)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :
         |          docstring
         |
         |  set_o(...)
         |      set_o( (GridProp)arg1, (float)arg2, (float)arg3, (float)arg4) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class HF(Wavefunction)
         |  docstring
         |
         |  Method resolution order:
         |      HF
         |      Wavefunction
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Wavefunction:
         |
         |  Ca(...)
         |      Ca( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Cb(...)
         |      Cb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Da(...)
         |      Da( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Db(...)
         |      Db( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fa(...)
         |      Fa( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fb(...)
         |      Fb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  add_postiteration_callback(...)
         |      add_postiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  add_preiteration_callback(...)
         |      add_preiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  alpha_orbital_space(...)
         |      alpha_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  basisset(...)
         |      basisset( (Wavefunction)arg1) -> BasisSet :
         |          docstring
         |
         |  beta_orbital_space(...)
         |      beta_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  doccpi(...)
         |      doccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  energy(...)
         |      energy( (Wavefunction)arg1) -> float :
         |          docstring
         |
         |  epsilon_a(...)
         |      epsilon_a( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  epsilon_b(...)
         |      epsilon_b( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frequencies(...)
         |      frequencies( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frzcpi(...)
         |      frzcpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  frzvpi(...)
         |      frzvpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  gradient(...)
         |      gradient( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  molecule(...)
         |      molecule( (Wavefunction)arg1) -> Molecule :
         |          docstring
         |
         |  nalpha(...)
         |      nalpha( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nalphapi(...)
         |      nalphapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nbeta(...)
         |      nbeta( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nbetapi(...)
         |      nbetapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmo(...)
         |      nmo( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmopi(...)
         |      nmopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nso(...)
         |      nso( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nsopi(...)
         |      nsopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  sobasisset(...)
         |      sobasisset( (Wavefunction)arg1) -> SOBasisSet :
         |          docstring
         |
         |  soccpi(...)
         |      soccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class IO(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      IO
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  close(...)
         |      close( (IO)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  open(...)
         |      open( (IO)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  open_check(...)
         |      open_check( (IO)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  rehash(...)
         |      rehash( (IO)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  set_pid(...)
         |      set_pid( (IO)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  state(...)
         |      state( (IO)arg1) -> int :
         |          docstring
         |
         |  tocclean(...)
         |      tocclean( (IO)arg1, (int)arg2, (str)arg3) -> None :
         |          docstring
         |
         |  tocprint(...)
         |      tocprint( (IO)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  tocwrite(...)
         |      tocwrite( (IO)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  change_file_namespace(...)
         |      change_file_namespace( (int)arg1, (str)arg2, (str)arg3) -> None :
         |          docstring
         |
         |  get_default_namespace(...)
         |      get_default_namespace() -> str :
         |          docstring
         |
         |  set_default_namespace(...)
         |      set_default_namespace( (str)arg1) -> None :
         |          docstring
         |
         |  shared_object(...)
         |      shared_object() -> IO
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class IOManager(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      IOManager
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  crashclean(...)
         |      crashclean( (IOManager)arg1) -> None :
         |          docstring
         |
         |  get_default_path(...)
         |      get_default_path( (IOManager)arg1) -> str :
         |          docstring
         |
         |  get_file_path(...)
         |      get_file_path( (IOManager)arg1, (int)arg2) -> str :
         |          docstring
         |
         |  mark_file_for_retention(...)
         |      mark_file_for_retention( (IOManager)arg1, (str)arg2, (bool)arg3) -> None :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (IOManager)arg1) -> None :
         |          docstring
         |
         |  psiclean(...)
         |      psiclean( (IOManager)arg1) -> None :
         |          docstring
         |
         |  set_default_path(...)
         |      set_default_path( (IOManager)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_specific_path(...)
         |      set_specific_path( (IOManager)arg1, (int)arg2, (str)arg3) -> None :
         |          docstring
         |
         |  set_specific_retention(...)
         |      set_specific_retention( (IOManager)arg1, (int)arg2, (bool)arg3) -> None :
         |          docstring
         |
         |  write_scratch_file(...)
         |      write_scratch_file( (IOManager)arg1, (str)arg2, (str)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  shared_object(...)
         |      shared_object() -> IOManager :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class IntVector(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      IntVector
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (int)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  dim(...)
         |      dim( (IntVector)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  get(...)
         |      get( (IntVector)arg1, (int)arg2, (int)arg3) -> int :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (IntVector)arg1) -> int :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (IntVector)arg1) -> None :
         |          docstring
         |
         |  set(...)
         |      set( (IntVector)arg1, (int)arg2, (int)arg3, (int)arg4) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class IntegralFactory(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      IntegralFactory
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (BasisSet)arg2, (BasisSet)arg3, (BasisSet)arg4, (BasisSet)arg5) -> None
         |
         |      __init__( (object)arg1, (BasisSet)arg2 [, (BasisSet)arg3]) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ao_angular_momentum(...)
         |      ao_angular_momentum( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_dipole(...)
         |      ao_dipole( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_kinetic(...)
         |      ao_kinetic( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_multipoles(...)
         |      ao_multipoles( (IntegralFactory)arg1, (int)arg2) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_nabla(...)
         |      ao_nabla( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_overlap(...)
         |      ao_overlap( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_potential(...)
         |      ao_potential( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_pseudospectral(...)
         |      ao_pseudospectral( (IntegralFactory)arg1 [, (int)arg2]) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_quadrupole(...)
         |      ao_quadrupole( (IntegralFactory)arg1) -> OneBodyAOInt :
         |          docstring
         |
         |  ao_traceless_quadrupole(...)
         |      ao_traceless_quadrupole( (IntegralFactory)arg1) -> OneBodyAOInt :
         |          docstring
         |
         |  electric_field(...)
         |      electric_field( (IntegralFactory)arg1) -> OneBodyAOInt :
         |          docstring
         |
         |  electrostatic(...)
         |      electrostatic( (IntegralFactory)arg1) -> OneBodyAOInt :
         |          docstring
         |
         |  erf_complement_eri(...)
         |      erf_complement_eri( (IntegralFactory)arg1, (float)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  erf_eri(...)
         |      erf_eri( (IntegralFactory)arg1, (float)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  eri(...)
         |      eri( (IntegralFactory)arg1 [, (int)arg2 [, (bool)arg3]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  f12(...)
         |      f12( (IntegralFactory)arg1, (CorrelationFactor)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  f12_double_commutator(...)
         |      f12_double_commutator( (IntegralFactory)arg1, (CorrelationFactor)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  f12_squared(...)
         |      f12_squared( (IntegralFactory)arg1, (CorrelationFactor)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  f12g12(...)
         |      f12g12( (IntegralFactory)arg1, (CorrelationFactor)arg2 [, (int)arg3 [, (bool)arg4]]) -> TwoBodyAOInt :
         |          docstring
         |
         |  shells_iterator(...)
         |      shells_iterator( (IntegralFactory)arg1) -> AOShellCombinationsIterator :
         |          docstring
         |
         |  so_multipoles(...)
         |      so_multipoles( (IntegralFactory)arg1, (int)arg2) -> object :
         |          docstring
         |
         |  so_overlap(...)
         |      so_overlap( (IntegralFactory)arg1 [, (int)arg2]) -> object :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class KineticInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      KineticInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Localizer(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Localizer
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  localize(...)
         |      localize( (Localizer)arg1) -> None :
         |          Perform the localization procedure
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  build(...)
         |      build( (str)arg1, (BasisSet)arg2, (Matrix)arg3) -> Localizer :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  L
         |      Localized orbital coefficients
         |
         |  U
         |      Orbital rotation matrix
         |
         |  converged
         |      Did the localization procedure converge?
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Matrix(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Matrix
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __array_interface__(...)
         |      __array_interface__( (Matrix)arg1) -> dict :
         |          docstring
         |
         |  __getitem__(...)
         |      __getitem__( (Matrix)arg1, (tuple)arg2) -> float :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (int)arg2, (int)arg3) -> None
         |
         |      __init__( (object)arg1, (str)arg2, (Dimension)arg3, (Dimension)arg4) -> None
         |
         |      __init__( (object)arg1, (str)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setitem__(...)
         |      __setitem__( (Matrix)arg1, (tuple)arg2, (float)arg3) -> None :
         |          docstring
         |
         |  accumulate_product(...)
         |      accumulate_product( (Matrix)arg1, (Matrix)arg2, (Matrix)arg3) -> None :
         |          docstring
         |
         |  add(...)
         |      add( (Matrix)arg1, (Matrix)arg2) -> None :
         |          docstring
         |
         |  add_and_orthogonalize_row(...)
         |      add_and_orthogonalize_row( (Matrix)arg1, (Vector)arg2) -> bool :
         |          docstring
         |
         |  back_transform(...)
         |      back_transform( (Matrix)arg1, (Matrix)arg2, (Matrix)arg3) -> None :
         |          docstring
         |
         |  canonical_orthogonalization(...)
         |      canonical_orthogonalization( (Matrix)arg1, (float)arg2 [, (Matrix)arg3]) -> Matrix
         |
         |  cholesky_factorize(...)
         |      cholesky_factorize( (Matrix)arg1) -> None :
         |          docstring
         |
         |  clone(...)
         |      clone( (Matrix)arg1) -> Matrix :
         |          docstring
         |
         |  coldim(...)
         |      coldim( (Matrix)arg1) -> Dimension :
         |          docstring
         |
         |  cols(...)
         |      cols( (Matrix)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  copy_lower_to_upper(...)
         |      copy_lower_to_upper( (Matrix)arg1) -> None :
         |          docstring
         |
         |  copy_upper_to_lower(...)
         |      copy_upper_to_lower( (Matrix)arg1) -> None :
         |          docstring
         |
         |  diagonalize(...)
         |      diagonalize( (Matrix)arg1, (Matrix)arg2, (Vector)arg3, (DiagonalizeOrder)arg4) -> None :
         |          docstring
         |
         |  gemm(...)
         |      gemm( (Matrix)arg1, (bool)arg2, (bool)arg3, (float)arg4, (Matrix)arg5, (Matrix)arg6, (float)arg7) -> None :
         |          docstring
         |
         |  get(...)
         |      get( (Matrix)arg1, (int)arg2, (int)arg3 [, (int)arg4]) -> float :
         |          docstring
         |
         |  identity(...)
         |      identity( (Matrix)arg1) -> None :
         |          docstring
         |
         |  invert(...)
         |      invert( (Matrix)arg1) -> None :
         |          docstring
         |
         |  load(...)
         |      load( (Matrix)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  load_mpqc(...)
         |      load_mpqc( (Matrix)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  name(...)
         |      name( (Matrix)arg1) -> str :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (Matrix)arg1) -> int :
         |          docstring
         |
         |  partial_cholesky_factorize(...)
         |      partial_cholesky_factorize( (Matrix)arg1, (float)arg2, (bool)arg3) -> Matrix :
         |          docstring
         |
         |  power(...)
         |      power( (Matrix)arg1, (float)arg2, (float)arg3) -> Dimension :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (Matrix)arg1) -> None :
         |          docstring
         |
         |  project_out(...)
         |      project_out( (Matrix)arg1, (Matrix)arg2) -> None :
         |          docstring
         |
         |  remove_symmetry(...)
         |      remove_symmetry( (Matrix)arg1, (Matrix)arg2, (Matrix)arg3) -> None :
         |          docstring
         |
         |  rms(...)
         |      rms( (Matrix)arg1) -> float :
         |          docstring
         |
         |  rowdim(...)
         |      rowdim( (Matrix)arg1) -> Dimension :
         |          docstring
         |
         |  rows(...)
         |      rows( (Matrix)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  save(...)
         |      save( (Matrix)arg1, (str)arg2, (bool)arg3, (bool)arg4, (bool)arg5) -> None :
         |          docstring
         |
         |  scale(...)
         |      scale( (Matrix)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  scale_column(...)
         |      scale_column( (Matrix)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :
         |          docstring
         |
         |  scale_row(...)
         |      scale_row( (Matrix)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :
         |          docstring
         |
         |  set(...)
         |      set( (Matrix)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :
         |          docstring
         |
         |      set( (Matrix)arg1, (int)arg2, (int)arg3, (int)arg4, (float)arg5) -> None :
         |          docstring
         |
         |      set( (Matrix)arg1, (list)arg2) -> None :
         |          docstring
         |
         |  set_name(...)
         |      set_name( (Matrix)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  subtract(...)
         |      subtract( (Matrix)arg1, (Matrix)arg2) -> None :
         |          docstring
         |
         |  sum_of_squares(...)
         |      sum_of_squares( (Matrix)arg1) -> float :
         |          docstring
         |
         |  symmetry(...)
         |      symmetry( (Matrix)arg1) -> int :
         |          docstring
         |
         |  trace(...)
         |      trace( (Matrix)arg1) -> float :
         |          docstring
         |
         |  transform(...)
         |      transform( (Matrix)arg1, (Matrix)arg2) -> None :
         |          docstring
         |
         |      transform( (Matrix)arg1, (Matrix)arg2 [, (Matrix)arg3]) -> None :
         |          docstring
         |
         |  vector_dot(...)
         |      vector_dot( (Matrix)arg1, (Matrix)arg2) -> float :
         |          docstring
         |
         |  zero(...)
         |      zero( (Matrix)arg1) -> None :
         |          docstring
         |
         |  zero_diagonal(...)
         |      zero_diagonal( (Matrix)arg1) -> None :
         |          docstring
         |
         |  zero_lower(...)
         |      zero_lower( (Matrix)arg1) -> None :
         |          docstring
         |
         |  zero_upper(...)
         |      zero_upper( (Matrix)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class MatrixFactory(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      MatrixFactory
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  create_matrix(...)
         |      create_matrix( (MatrixFactory)arg1) -> Matrix :
         |          docstring
         |
         |      create_matrix( (MatrixFactory)arg1, (str)arg2) -> Matrix :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  shared_object(...)
         |      shared_object() -> MatrixFactory :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class MintsHelper(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      MintsHelper
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (BasisSet)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ao_angular_momentum(...)
         |      ao_angular_momentum( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  ao_erf_eri(...)
         |      ao_erf_eri( (MintsHelper)arg1, (float)arg2) -> Matrix :
         |          docstring
         |
         |  ao_eri(...)
         |      ao_eri( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  ao_eri_shell(...)
         |      ao_eri_shell( (MintsHelper)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> Matrix :
         |          docstring
         |
         |  ao_f12(...)
         |      ao_f12( (MintsHelper)arg1, (CorrelationFactor)arg2) -> Matrix :
         |          docstring
         |
         |  ao_f12_double_commutator(...)
         |      ao_f12_double_commutator( (MintsHelper)arg1, (CorrelationFactor)arg2) -> Matrix :
         |          docstring
         |
         |  ao_f12_squared(...)
         |      ao_f12_squared( (MintsHelper)arg1, (CorrelationFactor)arg2) -> Matrix :
         |          docstring
         |
         |  ao_f12g12(...)
         |      ao_f12g12( (MintsHelper)arg1, (CorrelationFactor)arg2) -> Matrix :
         |          docstring
         |
         |  ao_kinetic(...)
         |      ao_kinetic( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  ao_nabla(...)
         |      ao_nabla( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  ao_overlap(...)
         |      ao_overlap( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  ao_potential(...)
         |      ao_potential( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  basisset(...)
         |      basisset( (MintsHelper)arg1) -> BasisSet :
         |          docstring
         |
         |  cdsalcs(...)
         |      cdsalcs( (MintsHelper)arg1, (int)arg2, (bool)arg3, (bool)arg4) -> CdSalcList :
         |          docstring
         |
         |  factory(...)
         |      factory( (MintsHelper)arg1) -> MatrixFactory :
         |          docstring
         |
         |  integral(...)
         |      integral( (MintsHelper)arg1) -> IntegralFactory :
         |          docstring
         |
         |  integrals(...)
         |      integrals( (MintsHelper)arg1) -> None :
         |          docstring
         |
         |  integrals_erf(...)
         |      integrals_erf( (MintsHelper)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  integrals_erfc(...)
         |      integrals_erfc( (MintsHelper)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  mo_erf_eri(...)
         |      mo_erf_eri( (MintsHelper)arg1, (float)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5, (Matrix)arg6) -> Matrix :
         |          docstring
         |
         |  mo_eri(...)
         |      mo_eri( (MintsHelper)arg1, (Matrix)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5) -> Matrix :
         |          docstring
         |
         |  mo_f12(...)
         |      mo_f12( (MintsHelper)arg1, (CorrelationFactor)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5, (Matrix)arg6) -> Matrix :
         |          docstring
         |
         |  mo_f12_double_commutator(...)
         |      mo_f12_double_commutator( (MintsHelper)arg1, (CorrelationFactor)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5, (Matrix)arg6) -> Matrix :
         |          docstring
         |
         |  mo_f12_squared(...)
         |      mo_f12_squared( (MintsHelper)arg1, (CorrelationFactor)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5, (Matrix)arg6) -> Matrix :
         |          docstring
         |
         |  mo_f12g12(...)
         |      mo_f12g12( (MintsHelper)arg1, (CorrelationFactor)arg2, (Matrix)arg3, (Matrix)arg4, (Matrix)arg5, (Matrix)arg6) -> Matrix :
         |          docstring
         |
         |  one_electron_integrals(...)
         |      one_electron_integrals( (MintsHelper)arg1) -> None :
         |          docstring
         |
         |      one_electron_integrals( (MintsHelper)arg1) -> None :
         |          docstring
         |
         |  petite_list(...)
         |      petite_list( (MintsHelper)arg1) -> PetiteList :
         |          docstring
         |
         |  petite_list1(...)
         |      petite_list1( (MintsHelper)arg1, (bool)arg2) -> PetiteList :
         |          docstring
         |
         |  play(...)
         |      play( (MintsHelper)arg1) -> None :
         |          docstring
         |
         |  so_angular_momentum(...)
         |      so_angular_momentum( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  so_dipole(...)
         |      so_dipole( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  so_kinetic(...)
         |      so_kinetic( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  so_nabla(...)
         |      so_nabla( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  so_overlap(...)
         |      so_overlap( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  so_potential(...)
         |      so_potential( (MintsHelper)arg1) -> Matrix :
         |          docstring
         |
         |  so_quadrupole(...)
         |      so_quadrupole( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  so_traceless_quadrupole(...)
         |      so_traceless_quadrupole( (MintsHelper)arg1) -> matrix_vector :
         |          docstring
         |
         |  sobasisset(...)
         |      sobasisset( (MintsHelper)arg1) -> SOBasisSet :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class MoldenWriter(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      MoldenWriter
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (Wavefunction)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  write(...)
         |      write( (MoldenWriter)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Molecule(Boost.Python.instance)
         |  Class to store the elements, coordinates, fragmentation pattern, basis sets, charge, multiplicity, etc. of a molecule.
         |
         |  Method resolution order:
         |      Molecule
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  BFS(self)
         |      Perform a breadth-first search (BFS) on the real atoms
         |      in molecule, returning an array of atom indices of fragments.
         |      Relies upon van der Waals radii and so faulty for close
         |      (esp. hydrogen-bonded) fragments. Original code from
         |      Michael S. Marshall.
         |
         |  Z(...)
         |      Z( (Molecule)arg1, (int)arg2) -> float :
         |          Nuclear charge of atom
         |
         |  __getattr__ = new_get_attr(self, name)
         |      Function to redefine __getattr__ method of molecule class.
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setattr__ = new_set_attr(self, name, value)
         |      Function to redefine __setattr__ method of molecule class.
         |
         |  activate_all_fragments(...)
         |      activate_all_fragments( (Molecule)arg1) -> None :
         |          Sets all fragments in the molecule to be active
         |
         |  add_atom(...)
         |      add_atom( (Molecule)arg1, (int)arg2, (float)arg3, (float)arg4, (float)arg5, (str)arg6, (float)arg7, (float)arg8, (int)arg9) -> None :
         |          Adds to Molecule arg1 an atom with atomic number arg2, Cartesian coordinates in Bohr (arg3, arg4, arg5), atomic symbol arg6, mass arg7, charge arg8 (optional), and lineno arg9 (optional)
         |
         |  atom_at_position(...)
         |      atom_at_position( (Molecule)arg1, (float)arg2, (float)arg3) -> int :
         |          Tests to see if an atom is at the position arg2 with a given tolerance arg3
         |
         |  center_of_mass(...)
         |      center_of_mass( (Molecule)arg1) -> Vector3 :
         |          Computes center of mass of molecule (does not translate molecule)
         |
         |  charge(...)
         |      charge( (Molecule)arg1, (int)arg2) -> float :
         |          Gets charge of atom
         |
         |  clone(...)
         |      clone( (Molecule)arg1) -> Molecule :
         |          Returns a new Molecule identical to arg1
         |
         |  create_psi4_string_from_molecule(...)
         |      create_psi4_string_from_molecule( (Molecule)arg1) -> str :
         |          Gets a string reexpressing in input format the current states of the molecule
         |
         |  deactivate_all_fragments(...)
         |      deactivate_all_fragments( (Molecule)arg1) -> None :
         |          Sets all fragments in the molecule to be inactive
         |
         |  extract_subsets(...)
         |      extract_subsets( (Molecule)arg1, (list)arg2, (list)arg3) -> Molecule :
         |          Returns copy of arg1 with arg2 fragments Real and arg3 fragments Ghost
         |
         |      extract_subsets( (Molecule)arg1, (list)arg2, (int)arg3) -> Molecule :
         |          Returns copy of arg1 with arg2 fragments Real and arg3 fragment Ghost
         |
         |      extract_subsets( (Molecule)arg1, (int)arg2, (list)arg3) -> Molecule :
         |          Returns copy of arg1 with arg2 fragment Real and arg3 fragments Ghost
         |
         |      extract_subsets( (Molecule)arg1, (int)arg2, (int)arg3) -> Molecule :
         |          Returns copy of arg1 with arg2 fragment Real and arg3 fragment Ghost
         |
         |      extract_subsets( (Molecule)arg1, (list)arg2) -> Molecule :
         |          Returns copy of arg1 with arg2 fragments Real
         |
         |      extract_subsets( (Molecule)arg1, (int)arg2) -> Molecule :
         |          Returns copy of arg1 with arg2 fragment Real
         |
         |  find_point_group(...)
         |      find_point_group( (Molecule)arg1, (float)arg2) -> PointGroup :
         |          Finds computational molecular point group, user can override this with the symmetry keyword
         |
         |  fix_com(...)
         |      fix_com( (Molecule)arg1, (bool)arg2) -> None :
         |          Whether to fix the Cartesian position, or to translate to the C.O.M.
         |
         |  fix_orientation(...)
         |      fix_orientation( (Molecule)arg1, (bool)arg2) -> None :
         |          Fix the orientation at its current frame
         |
         |  form_symmetry_information(...)
         |      form_symmetry_information( (Molecule)arg1, (float)arg2) -> None :
         |          Uses the point group object obtain by calling point_group()
         |
         |  geometry(...)
         |      geometry( (Molecule)arg1) -> Matrix :
         |          Gets the geometry as a (Natom X 3) matrix of coordinates (in Bohr)
         |
         |  get_full_point_group(...)
         |      get_full_point_group( (Molecule)arg1) -> str :
         |          Gets point group name such as C3v or S8
         |
         |  get_variable(...)
         |      get_variable( (Molecule)arg1, (str)arg2) -> float :
         |          Checks if variable arg2 is in the list, sets it to val and returns true if it is, and returns false if not
         |
         |  init_with_checkpoint(...)
         |      init_with_checkpoint( (Molecule)arg1, (Checkpoint)arg2) -> None :
         |          Populate arg1 member data with information from checkpoint file arg2
         |
         |  init_with_io(...)
         |      init_with_io( (Molecule)arg1, (IO)arg2) -> None :
         |          Creates a new checkpoint file with information from arg2
         |
         |  is_variable(...)
         |      is_variable( (Molecule)arg1, (str)arg2) -> bool :
         |          Checks if variable arg2 is in the list, returns true if it is, and returns false if not
         |
         |  label(...)
         |      label( (Molecule)arg1, (int)arg2) -> str :
         |          Gets the original label of the atom as given in the input file (C2, H4)
         |
         |  mass(...)
         |      mass( (Molecule)arg1, (int)arg2) -> float :
         |          Gets mass of atom arg2
         |
         |  molecular_charge(...)
         |      molecular_charge( (Molecule)arg1) -> int :
         |          Gets the molecular charge
         |
         |  move_to_com(...)
         |      move_to_com( (Molecule)arg1) -> None :
         |          Moves molecule to center of mass
         |
         |  multiplicity(...)
         |      multiplicity( (Molecule)arg1) -> int :
         |          Gets the multiplicity (defined as 2Ms + 1)
         |
         |  name(...)
         |      name( (Molecule)arg1) -> str :
         |          Gets molecule name
         |
         |  natom(...)
         |      natom( (Molecule)arg1) -> int :
         |          Number of real atoms
         |
         |  nfragments(...)
         |      nfragments( (Molecule)arg1) -> int :
         |          Gets the number of fragments in the molecule
         |
         |  nuclear_repulsion_energy(...)
         |      nuclear_repulsion_energy( (Molecule)arg1) -> float :
         |          Computes nuclear repulsion energy
         |
         |  point_group(...)
         |      point_group( (Molecule)arg1) -> PointGroup :
         |          Returns the current point group object
         |
         |  print_in_input_format(...)
         |      print_in_input_format( (Molecule)arg1) -> None :
         |          Prints the molecule as Cartesian or ZMatrix entries, just as inputted.
         |
         |  print_out(...)
         |      print_out( (Molecule)arg1) -> None :
         |          Prints the molecule in Cartesians in input units
         |
         |  print_out_in_angstrom(...)
         |      print_out_in_angstrom( (Molecule)arg1) -> None :
         |          Prints the molecule in Cartesians in Angstroms
         |
         |  print_out_in_bohr(...)
         |      print_out_in_bohr( (Molecule)arg1) -> None :
         |          Prints the molecule in Cartesians in Bohr
         |
         |  reinterpret_coordentry(...)
         |      reinterpret_coordentry( (Molecule)arg1, (bool)arg2) -> None :
         |          Do reinterpret coordinate entries during update_geometry().
         |
         |  reset_point_group(...)
         |      reset_point_group( (Molecule)arg1, (str)arg2) -> None :
         |          Overrides symmetry from outside the molecule string
         |
         |  run_dftd3(self, func=None, dashlvl=None, dashparam=None, dertype=None)
         |      Function to call Grimme's dftd3 program (http://toc.uni-muenster.de/DFTD3/)
         |      to compute the -D correction of level *dashlvl* using parameters for
         |      the functional *func*. The dictionary *dashparam* can be used to supply
         |      a full set of dispersion parameters in the absense of *func* or to supply
         |      individual overrides in the presence of *func*. Returns energy if *dertype* is 0,
         |      gradient if *dertype* is 1, else tuple of energy and gradient if *dertype*
         |      unspecified. The dftd3 executable must be independently compiled and found in
         |      :envvar:`PATH`.
         |
         |  save_string_xyz(...)
         |      save_string_xyz( (Molecule)arg1) -> str :
         |          Saves the string of an XYZ file to arg2
         |
         |  save_to_checkpoint(...)
         |      save_to_checkpoint( (Molecule)arg1, (Checkpoint)arg2, (str)arg3) -> None :
         |          Saves molecule information to checkpoint file arg2 with prefix arg3
         |
         |  save_xyz(...)
         |      save_xyz( (Molecule)arg1, (str)arg2, (bool)arg3) -> None :
         |          Saves an XYZ file to arg2
         |
         |  schoenflies_symbol(...)
         |      schoenflies_symbol( (Molecule)arg1) -> str :
         |          Returns the Schoenflies symbol
         |
         |  set_active_fragment(...)
         |      set_active_fragment( (Molecule)arg1, (int)arg2) -> None :
         |          Sets the specified fragment arg2 to be Real
         |
         |  set_active_fragments(...)
         |      set_active_fragments( (Molecule)arg1, (list)arg2) -> None :
         |          Sets the specified list arg2 of fragments to be Real
         |
         |  set_basis_all_atoms(...)
         |      set_basis_all_atoms( (Molecule)arg1, (str)arg2, (str)arg3) -> None :
         |          Sets basis set arg2 to all atoms
         |
         |  set_basis_by_label(...)
         |      set_basis_by_label( (Molecule)arg1, (str)arg2, (str)arg3, (str)arg4) -> None :
         |          Sets basis set arg3 to all atoms with label (e.g., H4) arg2
         |
         |  set_basis_by_number(...)
         |      set_basis_by_number( (Molecule)arg1, (int)arg2, (str)arg3, (str)arg4) -> None :
         |          Sets basis set arg3 to atom number (1-indexed, incl. dummies) arg2
         |
         |  set_basis_by_symbol(...)
         |      set_basis_by_symbol( (Molecule)arg1, (str)arg2, (str)arg3, (str)arg4) -> None :
         |          Sets basis set arg3 to all atoms with symbol (e.g., H) arg2
         |
         |  set_geometry(...)
         |      set_geometry( (Molecule)arg1, (Matrix)arg2) -> None :
         |          Sets the geometry, given a (Natom X 3) matrix arg2 of coordinates (in Bohr)
         |
         |  set_ghost_fragment(...)
         |      set_ghost_fragment( (Molecule)arg1, (int)arg2) -> None :
         |          Sets the specified fragment arg2 to be Ghost
         |
         |  set_ghost_fragments(...)
         |      set_ghost_fragments( (Molecule)arg1, (list)arg2) -> None :
         |          Sets the specified list arg2 of fragments to be Ghost
         |
         |  set_molecular_charge(...)
         |      set_molecular_charge( (Molecule)arg1, (int)arg2) -> None :
         |          Sets the molecular charge
         |
         |  set_multiplicity(...)
         |      set_multiplicity( (Molecule)arg1, (int)arg2) -> None :
         |          Sets the multiplicity (defined as 2Ms + 1)
         |
         |  set_name(...)
         |      set_name( (Molecule)arg1, (str)arg2) -> None :
         |          Sets molecule name
         |
         |  set_point_group(...)
         |      set_point_group( (Molecule)arg1, (PointGroup)arg2) -> None :
         |          Sets the molecular point group to the point group object arg2
         |
         |  set_variable(...)
         |      set_variable( (Molecule)arg1, (str)arg2, (float)arg3) -> None :
         |          Assigns the value arg3 to the variable arg2 in the list of geometry variables, then calls update_geometry()
         |
         |  symbol(...)
         |      symbol( (Molecule)arg1, (int)arg2) -> str :
         |          Gets the cleaned up label of atom arg2 (C2 => C, H4 = H)
         |
         |  symmetrize(...)
         |      symmetrize( (Molecule)arg1, (float)arg2) -> None :
         |          Finds the highest point Abelian point group within the specified tolerance, and forces the geometry to have that symmetry.
         |
         |  translate(...)
         |      translate( (Molecule)arg1, (Vector3)arg2) -> None :
         |          Translates molecule by arg2
         |
         |  update_geometry(...)
         |      update_geometry( (Molecule)arg1) -> None :
         |          Reevaluates the geometry with current variable values, orientation directives, etc. Must be called after initial Molecule definition by string.
         |
         |  x(...)
         |      x( (Molecule)arg1, (int)arg2) -> float :
         |          x position of atom
         |
         |  y(...)
         |      y( (Molecule)arg1, (int)arg2) -> float :
         |          y position of atom
         |
         |  z(...)
         |      z( (Molecule)arg1, (int)arg2) -> float :
         |          z position of atom
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  create_molecule_from_string(...)
         |      create_molecule_from_string( (str)arg1) -> Molecule :
         |          Returns a new Molecule with member data from the geometry string arg1 in psi4 format
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class MultipoleInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      MultipoleInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class MultipoleSymmetry(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      MultipoleSymmetry
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (int)arg2, (Molecule)arg3, (IntegralFactory)arg4, (MatrixFactory)arg5) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  create_matrices(...)
         |      create_matrices( (MultipoleSymmetry)arg1, (str)arg2) -> matrix_vector :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class NBOWriter(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      NBOWriter
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1, (Wavefunction)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  write(...)
         |      write( (NBOWriter)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class NablaInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      NablaInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class OEProp(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      OEProp
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  add(...)
         |      add( (OEProp)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  compute(...)
         |      compute( (OEProp)arg1) -> None :
         |          docstring
         |
         |  set_title(...)
         |      set_title( (OEProp)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class OneBodyAOInt(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class OrbitalSpace(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      OrbitalSpace
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  C(...)
         |      C( (OrbitalSpace)arg1) -> Matrix :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1, (str)arg2, (str)arg3, (Matrix)arg4, (Vector)arg5, (BasisSet)arg6, (IntegralFactory)arg7) -> None
         |
         |      __init__( (object)arg1, (str)arg2, (str)arg3, (Matrix)arg4, (BasisSet)arg5, (IntegralFactory)arg6) -> None
         |
         |      __init__( (object)arg1, (str)arg2, (str)arg3, (Wavefunction)arg4) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  basisset(...)
         |      basisset( (OrbitalSpace)arg1) -> BasisSet :
         |          docstring
         |
         |  dim(...)
         |      dim( (OrbitalSpace)arg1) -> Dimension :
         |          docstring
         |
         |  evals(...)
         |      evals( (OrbitalSpace)arg1) -> Vector :
         |          docstring
         |
         |  id(...)
         |      id( (OrbitalSpace)arg1) -> str :
         |          docstring
         |
         |  integral(...)
         |      integral( (OrbitalSpace)arg1) -> IntegralFactory :
         |          docstring
         |
         |  name(...)
         |      name( (OrbitalSpace)arg1) -> str :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (OrbitalSpace)arg1) -> int :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (OrbitalSpace)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  build_cabs_space(...)
         |      build_cabs_space( (OrbitalSpace)arg1, (OrbitalSpace)arg2, (float)arg3) -> OrbitalSpace :
         |          docstring
         |
         |  build_ri_space(...)
         |      build_ri_space( (BasisSet)arg1, (BasisSet)arg2, (float)arg3) -> OrbitalSpace :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class OverlapInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      OverlapInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PMLocalizer(Localizer)
         |  docstring
         |
         |  Method resolution order:
         |      PMLocalizer
         |      Localizer
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Localizer:
         |
         |  localize(...)
         |      localize( (Localizer)arg1) -> None :
         |          Perform the localization procedure
         |
         |  ----------------------------------------------------------------------
         |  Static methods inherited from Localizer:
         |
         |  build(...)
         |      build( (str)arg1, (BasisSet)arg2, (Matrix)arg3) -> Localizer :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Localizer:
         |
         |  L
         |      Localized orbital coefficients
         |
         |  U
         |      Orbital rotation matrix
         |
         |  converged
         |      Did the localization procedure converge?
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PetiteList(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      PetiteList
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  aotoso(...)
         |      aotoso( (PetiteList)arg1) -> Matrix :
         |          docstring
         |
         |  print(...)
         |      print( (PetiteList)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  sotoao(...)
         |      sotoao( (PetiteList)arg1) -> Matrix :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PointGroup(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      PointGroup
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (str)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  symbol(...)
         |      symbol( (PointGroup)arg1) -> str :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PotentialInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      PotentialInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Process(Boost.Python.instance)
         |  Method resolution order:
         |      Process
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  environment
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 12
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PseudoTrial(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      PseudoTrial
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  getA(...)
         |      getA( (PseudoTrial)arg1) -> Matrix :
         |          docstring
         |
         |  getI(...)
         |      getI( (PseudoTrial)arg1) -> Matrix :
         |          docstring
         |
         |  getIPS(...)
         |      getIPS( (PseudoTrial)arg1) -> Matrix :
         |          docstring
         |
         |  getQ(...)
         |      getQ( (PseudoTrial)arg1) -> Matrix :
         |          docstring
         |
         |  getR(...)
         |      getR( (PseudoTrial)arg1) -> Matrix :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PseudospectralInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      PseudospectralInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class PsiReturnType(Boost.Python.enum)
         |  docstring
         |
         |  Method resolution order:
         |      PsiReturnType
         |      Boost.Python.enum
         |      __builtin__.int
         |      __builtin__.object
         |
         |  Data and other attributes defined here:
         |
         |  Balk = psi4.PsiReturnType.Balk
         |
         |  EndLoop = psi4.PsiReturnType.EndLoop
         |
         |  Failure = psi4.PsiReturnType.Failure
         |
         |  Success = psi4.PsiReturnType.Success
         |
         |  names = {'Balk': psi4.PsiReturnType.Balk, 'EndLoop': psi4.PsiReturnTyp...
         |
         |  values = {0: psi4.PsiReturnType.Success, 1: psi4.PsiReturnType.Failure...
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Boost.Python.enum:
         |
         |  __repr__(...)
         |      x.__repr__() <==> repr(x)
         |
         |  __str__(...)
         |      x.__str__() <==> str(x)
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.enum:
         |
         |  name
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from __builtin__.int:
         |
         |  __abs__(...)
         |      x.__abs__() <==> abs(x)
         |
         |  __add__(...)
         |      x.__add__(y) <==> x+y
         |
         |  __and__(...)
         |      x.__and__(y) <==> x&y
         |
         |  __cmp__(...)
         |      x.__cmp__(y) <==> cmp(x,y)
         |
         |  __coerce__(...)
         |      x.__coerce__(y) <==> coerce(x, y)
         |
         |  __div__(...)
         |      x.__div__(y) <==> x/y
         |
         |  __divmod__(...)
         |      x.__divmod__(y) <==> divmod(x, y)
         |
         |  __float__(...)
         |      x.__float__() <==> float(x)
         |
         |  __floordiv__(...)
         |      x.__floordiv__(y) <==> x//y
         |
         |  __format__(...)
         |
         |  __getattribute__(...)
         |      x.__getattribute__('name') <==> x.name
         |
         |  __getnewargs__(...)
         |
         |  __hash__(...)
         |      x.__hash__() <==> hash(x)
         |
         |  __hex__(...)
         |      x.__hex__() <==> hex(x)
         |
         |  __index__(...)
         |      x[y:z] <==> x[y.__index__():z.__index__()]
         |
         |  __int__(...)
         |      x.__int__() <==> int(x)
         |
         |  __invert__(...)
         |      x.__invert__() <==> ~x
         |
         |  __long__(...)
         |      x.__long__() <==> long(x)
         |
         |  __lshift__(...)
         |      x.__lshift__(y) <==> x<<y
         |
         |  __mod__(...)
         |      x.__mod__(y) <==> x%y
         |
         |  __mul__(...)
         |      x.__mul__(y) <==> x*y
         |
         |  __neg__(...)
         |      x.__neg__() <==> -x
         |
         |  __nonzero__(...)
         |      x.__nonzero__() <==> x != 0
         |
         |  __oct__(...)
         |      x.__oct__() <==> oct(x)
         |
         |  __or__(...)
         |      x.__or__(y) <==> x|y
         |
         |  __pos__(...)
         |      x.__pos__() <==> +x
         |
         |  __pow__(...)
         |      x.__pow__(y[, z]) <==> pow(x, y[, z])
         |
         |  __radd__(...)
         |      x.__radd__(y) <==> y+x
         |
         |  __rand__(...)
         |      x.__rand__(y) <==> y&x
         |
         |  __rdiv__(...)
         |      x.__rdiv__(y) <==> y/x
         |
         |  __rdivmod__(...)
         |      x.__rdivmod__(y) <==> divmod(y, x)
         |
         |  __rfloordiv__(...)
         |      x.__rfloordiv__(y) <==> y//x
         |
         |  __rlshift__(...)
         |      x.__rlshift__(y) <==> y<<x
         |
         |  __rmod__(...)
         |      x.__rmod__(y) <==> y%x
         |
         |  __rmul__(...)
         |      x.__rmul__(y) <==> y*x
         |
         |  __ror__(...)
         |      x.__ror__(y) <==> y|x
         |
         |  __rpow__(...)
         |      y.__rpow__(x[, z]) <==> pow(x, y[, z])
         |
         |  __rrshift__(...)
         |      x.__rrshift__(y) <==> y>>x
         |
         |  __rshift__(...)
         |      x.__rshift__(y) <==> x>>y
         |
         |  __rsub__(...)
         |      x.__rsub__(y) <==> y-x
         |
         |  __rtruediv__(...)
         |      x.__rtruediv__(y) <==> y/x
         |
         |  __rxor__(...)
         |      x.__rxor__(y) <==> y^x
         |
         |  __sub__(...)
         |      x.__sub__(y) <==> x-y
         |
         |  __truediv__(...)
         |      x.__truediv__(y) <==> x/y
         |
         |  __trunc__(...)
         |      Truncating an Integral returns itself.
         |
         |  __xor__(...)
         |      x.__xor__(y) <==> x^y
         |
         |  bit_length(...)
         |      int.bit_length() -> int
         |
         |      Number of bits necessary to represent self in binary.
         |      >>> bin(37)
         |      '0b100101'
         |      >>> (37).bit_length()
         |      6
         |
         |  conjugate(...)
         |      Returns self, the complex conjugate of any int.
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from __builtin__.int:
         |
         |  denominator
         |      the denominator of a rational number in lowest terms
         |
         |  imag
         |      the imaginary part of a complex number
         |
         |  numerator
         |      the numerator of a rational number in lowest terms
         |
         |  real
         |      the real part of a complex number
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from __builtin__.int:
         |
         |  __new__ = <built-in method __new__ of type object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class QuadrupoleInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      QuadrupoleInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class RHF(HF, Wavefunction)
         |  docstring
         |
         |  Method resolution order:
         |      RHF
         |      HF
         |      Wavefunction
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from Wavefunction:
         |
         |  Ca(...)
         |      Ca( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Cb(...)
         |      Cb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Da(...)
         |      Da( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Db(...)
         |      Db( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fa(...)
         |      Fa( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fb(...)
         |      Fb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  add_postiteration_callback(...)
         |      add_postiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  add_preiteration_callback(...)
         |      add_preiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  alpha_orbital_space(...)
         |      alpha_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  basisset(...)
         |      basisset( (Wavefunction)arg1) -> BasisSet :
         |          docstring
         |
         |  beta_orbital_space(...)
         |      beta_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  doccpi(...)
         |      doccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  energy(...)
         |      energy( (Wavefunction)arg1) -> float :
         |          docstring
         |
         |  epsilon_a(...)
         |      epsilon_a( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  epsilon_b(...)
         |      epsilon_b( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frequencies(...)
         |      frequencies( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frzcpi(...)
         |      frzcpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  frzvpi(...)
         |      frzvpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  gradient(...)
         |      gradient( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  molecule(...)
         |      molecule( (Wavefunction)arg1) -> Molecule :
         |          docstring
         |
         |  nalpha(...)
         |      nalpha( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nalphapi(...)
         |      nalphapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nbeta(...)
         |      nbeta( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nbetapi(...)
         |      nbetapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmo(...)
         |      nmo( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmopi(...)
         |      nmopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nso(...)
         |      nso( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nsopi(...)
         |      nsopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  sobasisset(...)
         |      sobasisset( (Wavefunction)arg1) -> SOBasisSet :
         |          docstring
         |
         |  soccpi(...)
         |      soccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class SOBasisSet(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      SOBasisSet
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  petite_list(...)
         |      petite_list( (SOBasisSet)arg1) -> PetiteList :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class SuperFunctional(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      SuperFunctional
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  add_c_functional(...)
         |      add_c_functional( (SuperFunctional)arg1, (Functional)arg2) -> None :
         |          docstring
         |
         |  add_x_functional(...)
         |      add_x_functional( (SuperFunctional)arg1, (Functional)arg2) -> None :
         |          docstring
         |
         |  allocate(...)
         |      allocate( (SuperFunctional)arg1) -> None :
         |          docstring
         |
         |  ansatz(...)
         |      ansatz( (SuperFunctional)arg1) -> int :
         |          docstring
         |
         |  c_alpha(...)
         |      c_alpha( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  c_functional(...)
         |      c_functional( (SuperFunctional)arg1, (str)arg2) -> Functional :
         |          docstring
         |
         |  c_omega(...)
         |      c_omega( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  c_os_alpha(...)
         |      c_os_alpha( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  c_ss_alpha(...)
         |      c_ss_alpha( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  citation(...)
         |      citation( (SuperFunctional)arg1) -> str :
         |          docstring
         |
         |  deriv(...)
         |      deriv( (SuperFunctional)arg1) -> int :
         |          docstring
         |
         |  description(...)
         |      description( (SuperFunctional)arg1) -> str :
         |          docstring
         |
         |  dispersion(...)
         |      dispersion( (SuperFunctional)arg1) -> Dispersion :
         |          docstring
         |
         |  is_c_hybrid(...)
         |      is_c_hybrid( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_c_lrc(...)
         |      is_c_lrc( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_c_scs_hybrid(...)
         |      is_c_scs_hybrid( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_gga(...)
         |      is_gga( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_meta(...)
         |      is_meta( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_x_hybrid(...)
         |      is_x_hybrid( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  is_x_lrc(...)
         |      is_x_lrc( (SuperFunctional)arg1) -> bool :
         |          docstring
         |
         |  max_points(...)
         |      max_points( (SuperFunctional)arg1) -> int :
         |          docstring
         |
         |  name(...)
         |      name( (SuperFunctional)arg1) -> str :
         |          docstring
         |
         |  print_detail(...)
         |      print_detail( (SuperFunctional)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (SuperFunctional)arg1) -> None :
         |          docstring
         |
         |  set_c_alpha(...)
         |      set_c_alpha( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_c_omega(...)
         |      set_c_omega( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_c_os_alpha(...)
         |      set_c_os_alpha( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_c_ss_alpha(...)
         |      set_c_ss_alpha( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_citation(...)
         |      set_citation( (SuperFunctional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_deriv(...)
         |      set_deriv( (SuperFunctional)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  set_description(...)
         |      set_description( (SuperFunctional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_dispersion(...)
         |      set_dispersion( (SuperFunctional)arg1, (Dispersion)arg2) -> None :
         |          docstring
         |
         |  set_max_points(...)
         |      set_max_points( (SuperFunctional)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  set_name(...)
         |      set_name( (SuperFunctional)arg1, (str)arg2) -> None :
         |          docstring
         |
         |  set_x_alpha(...)
         |      set_x_alpha( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set_x_omega(...)
         |      set_x_omega( (SuperFunctional)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  test_functional(...)
         |      test_functional( (SuperFunctional)arg1, (Vector)arg2, (Vector)arg3, (Vector)arg4, (Vector)arg5, (Vector)arg6, (Vector)arg7, (Vector)arg8) -> None :
         |          docstring
         |
         |  value(...)
         |      value( (SuperFunctional)arg1, (str)arg2) -> Vector :
         |          docstring
         |
         |  x_alpha(...)
         |      x_alpha( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  x_functional(...)
         |      x_functional( (SuperFunctional)arg1, (str)arg2) -> Functional :
         |          docstring
         |
         |  x_omega(...)
         |      x_omega( (SuperFunctional)arg1) -> float :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Static methods defined here:
         |
         |  blank(...)
         |      blank() -> SuperFunctional :
         |          docstring
         |
         |  build(...)
         |      build( (str)arg1, (int)arg2, (int)arg3) -> SuperFunctional :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class SymmetryOperation(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      SymmetryOperation
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  E(...)
         |      E( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (SymmetryOperation)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  c2_x(...)
         |      c2_x( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  c2_y(...)
         |      c2_y( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  i(...)
         |      i( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  operate(...)
         |      operate( (SymmetryOperation)arg1, (SymmetryOperation)arg2) -> SymmetryOperation :
         |          docstring
         |
         |  rotate_n(...)
         |      rotate_n( (SymmetryOperation)arg1, (int)arg2) -> None :
         |          docstring
         |
         |  rotate_theta(...)
         |      rotate_theta( (SymmetryOperation)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  sigma_xy(...)
         |      sigma_xy( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  sigma_xz(...)
         |      sigma_xz( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  sigma_yz(...)
         |      sigma_yz( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  trace(...)
         |      trace( (SymmetryOperation)arg1) -> float :
         |          docstring
         |
         |  transform(...)
         |      transform( (SymmetryOperation)arg1, (SymmetryOperation)arg2) -> SymmetryOperation :
         |          docstring
         |
         |  transpose(...)
         |      transpose( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  unit(...)
         |      unit( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  zero(...)
         |      zero( (SymmetryOperation)arg1) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 84
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class TracelessQuadrupoleInt(OneBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      TracelessQuadrupoleInt
         |      OneBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from OneBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (OneBodyAOInt)arg1, (int)arg2, (int)arg3) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from OneBodyAOInt:
         |
         |  basis
         |      The basis set on center one
         |
         |  basis1
         |      The basis set on center one
         |
         |  basis2
         |      The basis set on center two
         |
         |  origin
         |      The origin about which the one body ints are being computed.
         |
         |  py_buffer
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class TwoBodyAOInt(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors defined here:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class TwoElectronInt(TwoBodyAOInt)
         |  docstring
         |
         |  Method resolution order:
         |      TwoElectronInt
         |      TwoBodyAOInt
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Methods inherited from TwoBodyAOInt:
         |
         |  compute_shell(...)
         |      compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
         |          docstring
         |
         |  set_enable_pybuffer(...)
         |      set_enable_pybuffer( (TwoBodyAOInt)arg1, (bool)arg2) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from TwoBodyAOInt:
         |
         |  py_buffer
         |      docstring
         |
         |  py_buffer_object
         |      docstring
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Vector(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Vector
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __getitem__(...)
         |      __getitem__( (Vector)arg1, (int)arg2) -> float :
         |          docstring
         |
         |      __getitem__( (Vector)arg1, (tuple)arg2) -> float :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (int)arg2) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setitem__(...)
         |      __setitem__( (Vector)arg1, (int)arg2, (float)arg3) -> None :
         |          docstring
         |
         |      __setitem__( (Vector)arg1, (tuple)arg2, (float)arg3) -> None :
         |          docstring
         |
         |  dim(...)
         |      dim( (Vector)arg1, (int)arg2) -> int :
         |          docstring
         |
         |  get(...)
         |      get( (Vector)arg1, (int)arg2) -> float :
         |          docstring
         |
         |      get( (Vector)arg1, (int)arg2, (int)arg3) -> float :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (Vector)arg1) -> int :
         |          docstring
         |
         |  print_out(...)
         |      print_out( (Vector)arg1) -> None :
         |          docstring
         |
         |  scale(...)
         |      scale( (Vector)arg1, (float)arg2) -> None :
         |          docstring
         |
         |  set(...)
         |      set( (Vector)arg1, (int)arg2, (float)arg3) -> None :
         |          docstring
         |
         |      set( (Vector)arg1, (int)arg2, (int)arg3, (float)arg4) -> None :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 16
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Vector3(Boost.Python.instance)
         |  Class for vectors of length three, often Cartesian coordinate vectors, and their common operations
         |
         |  Method resolution order:
         |      Vector3
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __add__(...)
         |      __add__( (Vector3)arg1, (Vector3)arg2) -> object
         |
         |  __getitem__(...)
         |      __getitem__( (Vector3)arg1, (int)arg2) -> float :
         |          Returns the arg2-th element of arg1.
         |
         |  __iadd__(...)
         |      __iadd__( (object)arg1, (Vector3)arg2) -> object
         |
         |  __imul__(...)
         |      __imul__( (object)arg1, (float)arg2) -> object
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |      __init__( (object)arg1, (float)arg2) -> None
         |
         |      __init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
         |
         |      __init__( (object)arg1, (Vector3)arg2) -> None
         |
         |  __isub__(...)
         |      __isub__( (object)arg1, (Vector3)arg2) -> object
         |
         |  __neg__(...)
         |      __neg__( (Vector3)arg1) -> object
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __str__(...)
         |      __str__( (Vector3)arg1) -> str :
         |          Returns a string representation of arg1, suitable for printing.
         |
         |  __sub__(...)
         |      __sub__( (Vector3)arg1, (Vector3)arg2) -> object
         |
         |  cross(...)
         |      cross( (Vector3)arg1, (Vector3)arg2) -> Vector3 :
         |          Returns cross product of arg1 and arg2
         |
         |  distance(...)
         |      distance( (Vector3)arg1, (Vector3)arg2) -> float :
         |          Returns distance between two points represented by arg1 and arg2
         |
         |  dot(...)
         |      dot( (Vector3)arg1, (Vector3)arg2) -> float :
         |          Returns dot product of arg1 and arg2
         |
         |  norm(...)
         |      norm( (Vector3)arg1) -> float :
         |          Returns Euclidean norm of arg1
         |
         |  normalize(...)
         |      normalize( (Vector3)arg1) -> None :
         |          Returns vector of unit length and arg1 direction
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 32
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class View(Boost.Python.instance)
         |  Method resolution order:
         |      View
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __call__(...)
         |      __call__( (View)arg1) -> Matrix :
         |          docstring
         |
         |  __init__(...)
         |      __init__( (object)arg1, (Matrix)arg2, (Dimension)arg3, (Dimension)arg4) -> None
         |
         |      __init__( (object)arg1, (Matrix)arg2, (Dimension)arg3, (Dimension)arg4, (Dimension)arg5, (Dimension)arg6) -> None
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class Wavefunction(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      Wavefunction
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  Ca(...)
         |      Ca( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Cb(...)
         |      Cb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Da(...)
         |      Da( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Db(...)
         |      Db( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fa(...)
         |      Fa( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  Fb(...)
         |      Fb( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  add_postiteration_callback(...)
         |      add_postiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  add_preiteration_callback(...)
         |      add_preiteration_callback( (Wavefunction)arg1, (object)arg2) -> None :
         |          docstring
         |
         |  alpha_orbital_space(...)
         |      alpha_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  basisset(...)
         |      basisset( (Wavefunction)arg1) -> BasisSet :
         |          docstring
         |
         |  beta_orbital_space(...)
         |      beta_orbital_space( (Wavefunction)arg1, (str)arg2, (str)arg3, (str)arg4) -> OrbitalSpace :
         |          docstring
         |
         |  doccpi(...)
         |      doccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  energy(...)
         |      energy( (Wavefunction)arg1) -> float :
         |          docstring
         |
         |  epsilon_a(...)
         |      epsilon_a( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  epsilon_b(...)
         |      epsilon_b( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frequencies(...)
         |      frequencies( (Wavefunction)arg1) -> Vector :
         |          docstring
         |
         |  frzcpi(...)
         |      frzcpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  frzvpi(...)
         |      frzvpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  gradient(...)
         |      gradient( (Wavefunction)arg1) -> Matrix :
         |          docstring
         |
         |  molecule(...)
         |      molecule( (Wavefunction)arg1) -> Molecule :
         |          docstring
         |
         |  nalpha(...)
         |      nalpha( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nalphapi(...)
         |      nalphapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nbeta(...)
         |      nbeta( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nbetapi(...)
         |      nbetapi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nirrep(...)
         |      nirrep( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmo(...)
         |      nmo( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nmopi(...)
         |      nmopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  nso(...)
         |      nso( (Wavefunction)arg1) -> int :
         |          docstring
         |
         |  nsopi(...)
         |      nsopi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  sobasisset(...)
         |      sobasisset( (Wavefunction)arg1) -> SOBasisSet :
         |          docstring
         |
         |  soccpi(...)
         |      soccpi( (Wavefunction)arg1) -> Dimension :
         |          docstring
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __init__ = <built-in function __init__>
         |      Raises an exception
         |      This class cannot be instantiated from Python
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class matrix_vector(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      matrix_vector
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __contains__(...)
         |      __contains__( (matrix_vector)arg1, (object)arg2) -> bool
         |
         |  __delitem__(...)
         |      __delitem__( (matrix_vector)arg1, (object)arg2) -> None
         |
         |  __getitem__(...)
         |      __getitem__( (object)arg1, (object)arg2) -> object
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __iter__(...)
         |      __iter__( (object)arg1) -> object
         |
         |  __len__(...)
         |      __len__( (matrix_vector)arg1) -> int
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setitem__(...)
         |      __setitem__( (matrix_vector)arg1, (object)arg2, (object)arg3) -> None
         |
         |  append(...)
         |      append( (matrix_vector)arg1, (object)arg2) -> None
         |
         |  extend(...)
         |      extend( (matrix_vector)arg1, (object)arg2) -> None
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 20
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

        class vector_of_doubles(Boost.Python.instance)
         |  docstring
         |
         |  Method resolution order:
         |      vector_of_doubles
         |      Boost.Python.instance
         |      __builtin__.object
         |
         |  Methods defined here:
         |
         |  __contains__(...)
         |      __contains__( (vector_of_doubles)arg1, (object)arg2) -> bool
         |
         |  __delitem__(...)
         |      __delitem__( (vector_of_doubles)arg1, (object)arg2) -> None
         |
         |  __getitem__(...)
         |      __getitem__( (object)arg1, (object)arg2) -> object
         |
         |  __init__(...)
         |      __init__( (object)arg1) -> None
         |
         |  __iter__(...)
         |      __iter__( (object)arg1) -> object
         |
         |  __len__(...)
         |      __len__( (vector_of_doubles)arg1) -> int
         |
         |  __reduce__ = <unnamed Boost.Python function>(...)
         |
         |  __setitem__(...)
         |      __setitem__( (vector_of_doubles)arg1, (object)arg2, (object)arg3) -> None
         |
         |  append(...)
         |      append( (vector_of_doubles)arg1, (object)arg2) -> None
         |
         |  extend(...)
         |      extend( (vector_of_doubles)arg1, (object)arg2) -> None
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes defined here:
         |
         |  __instance_size__ = 20
         |
         |  ----------------------------------------------------------------------
         |  Data descriptors inherited from Boost.Python.instance:
         |
         |  __dict__
         |
         |  __weakref__
         |
         |  ----------------------------------------------------------------------
         |  Data and other attributes inherited from Boost.Python.instance:
         |
         |  __new__ = <built-in method __new__ of Boost.Python.class object>
         |      T.__new__(S, ...) -> a new object with type S, a subtype of T

    FUNCTIONS
        DASUM(...)
            DASUM( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4) -> float :
                docstring

        DAXPY(...)
            DAXPY( (int)arg1, (int)arg2, (float)arg3, (Vector)arg4, (int)arg5, (Vector)arg6, (int)arg7) -> None :
                docstring

        DCOPY(...)
            DCOPY( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4, (Vector)arg5, (int)arg6) -> None :
                docstring

        DDOT(...)
            DDOT( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4, (Vector)arg5, (int)arg6) -> float :
                docstring

        DGBMV(...)
            DGBMV( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (int)arg5, (int)arg6, (float)arg7, (Matrix)arg8, (int)arg9, (Vector)arg10, (int)arg11, (float)arg12, (Vector)arg13, (int)arg14) -> None :
                docstring

        DGEEV(...)
            DGEEV( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (Matrix)arg5, (int)arg6, (Vector)arg7, (Vector)arg8, (Matrix)arg9, (int)arg10, (Matrix)arg11, (int)arg12, (Vector)arg13, (int)arg14) -> int :
                docstring

        DGEMM(...)
            DGEMM( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (int)arg5, (int)arg6, (float)arg7, (Matrix)arg8, (int)arg9, (Matrix)arg10, (int)arg11, (float)arg12, (Matrix)arg13, (int)arg14) -> None :
                docstring

        DGEMV(...)
            DGEMV( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (float)arg5, (Matrix)arg6, (int)arg7, (Vector)arg8, (int)arg9, (float)arg10, (Vector)arg11, (int)arg12) -> None :
                docstring

        DGER(...)
            DGER( (int)arg1, (int)arg2, (int)arg3, (float)arg4, (Vector)arg5, (int)arg6, (Vector)arg7, (int)arg8, (Matrix)arg9, (int)arg10) -> None :
                docstring

        DGETRF(...)
            DGETRF( (int)arg1, (int)arg2, (int)arg3, (Matrix)arg4, (int)arg5, (IntVector)arg6) -> int :
                docstring

        DGETRI(...)
            DGETRI( (int)arg1, (int)arg2, (Matrix)arg3, (int)arg4, (IntVector)arg5, (Vector)arg6, (int)arg7) -> int :
                docstring

        DGETRS(...)
            DGETRS( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (Matrix)arg5, (int)arg6, (IntVector)arg7, (Matrix)arg8, (int)arg9) -> int :
                docstring

        DNRM2(...)
            DNRM2( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4) -> float :
                docstring

        DPOTRF(...)
            DPOTRF( (int)arg1, (str)arg2, (int)arg3, (Matrix)arg4, (int)arg5) -> int :
                docstring

        DPOTRI(...)
            DPOTRI( (int)arg1, (str)arg2, (int)arg3, (Matrix)arg4, (int)arg5) -> int :
                docstring

        DPOTRS(...)
            DPOTRS( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (Matrix)arg5, (int)arg6, (Matrix)arg7, (int)arg8) -> int :
                docstring

        DROT(...)
            DROT( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4, (Vector)arg5, (int)arg6, (float)arg7, (float)arg8) -> None :
                docstring

        DSBMV(...)
            DSBMV( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (float)arg5, (Matrix)arg6, (int)arg7, (Vector)arg8, (int)arg9, (float)arg10, (Vector)arg11, (int)arg12) -> None :
                docstring

        DSCAL(...)
            DSCAL( (int)arg1, (int)arg2, (float)arg3, (Vector)arg4, (int)arg5) -> None :
                docstring

        DSWAP(...)
            DSWAP( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4, (Vector)arg5, (int)arg6) -> None :
                docstring

        DSYEV(...)
            DSYEV( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (Matrix)arg5, (int)arg6, (Vector)arg7, (Vector)arg8, (int)arg9) -> int :
                docstring

        DSYMM(...)
            DSYMM( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (int)arg5, (float)arg6, (Matrix)arg7, (int)arg8, (Matrix)arg9, (int)arg10, (float)arg11, (Matrix)arg12, (int)arg13) -> None :
                docstring

        DSYMV(...)
            DSYMV( (int)arg1, (str)arg2, (int)arg3, (float)arg4, (Matrix)arg5, (int)arg6, (Vector)arg7, (int)arg8, (float)arg9, (Vector)arg10, (int)arg11) -> None :
                docstring

        DSYR(...)
            DSYR( (int)arg1, (str)arg2, (int)arg3, (float)arg4, (Vector)arg5, (int)arg6, (Matrix)arg7, (int)arg8) -> None :
                docstring

        DSYR2(...)
            DSYR2( (int)arg1, (str)arg2, (int)arg3, (float)arg4, (Vector)arg5, (int)arg6, (Vector)arg7, (int)arg8, (Matrix)arg9, (int)arg10) -> None :
                docstring

        DSYR2K(...)
            DSYR2K( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (int)arg5, (float)arg6, (Matrix)arg7, (int)arg8, (Matrix)arg9, (int)arg10, (float)arg11, (Matrix)arg12, (int)arg13) -> None :
                docstring

        DSYRK(...)
            DSYRK( (int)arg1, (str)arg2, (str)arg3, (int)arg4, (int)arg5, (float)arg6, (Matrix)arg7, (int)arg8, (float)arg9, (Matrix)arg10, (int)arg11) -> None :
                docstring

        DSYSV(...)
            DSYSV( (int)arg1, (str)arg2, (int)arg3, (int)arg4, (Matrix)arg5, (int)arg6, (IntVector)arg7, (Matrix)arg8, (int)arg9, (Vector)arg10, (int)arg11) -> int :
                docstring

        DTBMV(...)
            DTBMV( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5, (int)arg6, (Matrix)arg7, (int)arg8, (Vector)arg9, (int)arg10) -> None :
                docstring

        DTBSV(...)
            DTBSV( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5, (int)arg6, (Matrix)arg7, (int)arg8, (Vector)arg9, (int)arg10) -> None :
                docstring

        DTRMM(...)
            DTRMM( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (str)arg5, (int)arg6, (int)arg7, (float)arg8, (Matrix)arg9, (int)arg10, (Matrix)arg11, (int)arg12) -> None :
                docstring

        DTRMV(...)
            DTRMV( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5, (Matrix)arg6, (int)arg7, (Vector)arg8, (int)arg9) -> None :
                docstring

        DTRSM(...)
            DTRSM( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (str)arg5, (int)arg6, (int)arg7, (float)arg8, (Matrix)arg9, (int)arg10, (Matrix)arg11, (int)arg12) -> None :
                docstring

        DTRSV(...)
            DTRSV( (int)arg1, (str)arg2, (str)arg3, (str)arg4, (int)arg5, (Matrix)arg6, (int)arg7, (Vector)arg8, (int)arg9) -> None :
                docstring

        IDAMAX(...)
            IDAMAX( (int)arg1, (int)arg2, (Vector)arg3, (int)arg4) -> int :
                docstring

        adc(...)
            adc() -> float :
                Runs the ADC propagator code, for excited states.

        add_user_basis_file(...)
            add_user_basis_file( (str)arg1) -> None :
                Adds a custom basis set file, provided by the user.

        benchmark_blas1(...)
            benchmark_blas1( (int)arg1, (float)arg2) -> None :
                docstring

        benchmark_blas2(...)
            benchmark_blas2( (int)arg1, (float)arg2) -> None :
                docstring

        benchmark_blas3(...)
            benchmark_blas3( (int)arg1, (float)arg2, (int)arg3) -> None :
                docstring

        benchmark_disk(...)
            benchmark_disk( (int)arg1, (float)arg2) -> None :
                docstring

        benchmark_integrals(...)
            benchmark_integrals( (int)arg1, (float)arg2) -> None :
                docstring

        benchmark_math(...)
            benchmark_math( (float)arg1) -> None :
                docstring

        ccdensity(...)
            ccdensity() -> float :
                Runs the code to compute coupled cluster density matrices.

        ccenergy(...)
            ccenergy() -> float :
                Runs the coupled cluster energy code.

        cceom(...)
            cceom() -> float :
                Runs the equation of motion coupled cluster code, for excited states.

        cchbar(...)
            cchbar() -> float :
                Runs the code to generate the similariry transformed Hamiltonian.

        cclambda(...)
            cclambda() -> float :
                Runs the coupled cluster lambda equations code.

        ccresponse(...)
            ccresponse() -> float :
                Runs the coupled cluster response theory code.

        ccsort(...)
            ccsort() -> float :
                Runs CCSORT, which reorders integrals for use in the coupled cluster codes.

        cctriples(...)
            cctriples() -> float :
                Runs the coupled cluster (T) energy code.

        clean(...)
            clean() -> None :
                Function to remove scratch files. Call between independent jobs.

        close_outfile(...)
            close_outfile() -> None :
                Closes the output file.

        compute_shell(...)
            compute_shell( (TwoBodyAOInt)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None :
                docstring

        dcft(...)
            dcft() -> float :
                Runs the density cumulant functional theory code.

        deriv(...)
            deriv() -> int :
                Runs deriv, which contracts density matrices with derivative integrals, to compute gradients.

        detci(...)
            detci() -> float :
                Runs the determinant-based configuration interaction code.

        dfmp2(...)
            dfmp2() -> float :
                Runs the DF-MP2 code.

        dfmp2grad(...)
            dfmp2grad() -> float :
                Runs the DF-MP2 gradient.

        fd_1_0(...)
            fd_1_0( (list)arg1) -> PsiReturnType :
                Performs a finite difference gradient computation, from energy points.

        fd_freq_0(...)
            fd_freq_0( (list)arg1, (int)arg2) -> PsiReturnType :
                Performs a finite difference frequency computation, from energy points, for a given irrep.

        fd_freq_1(...)
            fd_freq_1( (list)arg1, (int)arg2) -> PsiReturnType :
                Performs a finite difference frequency computation, from gradients, for a given irrep.

        fd_geoms_1_0(...)
            fd_geoms_1_0() -> matrix_vector :
                Gets the list of displacements needed for a finite difference gradient computation, from energy points.

        fd_geoms_freq_0(...)
            fd_geoms_freq_0( (int)arg1) -> matrix_vector :
                Gets the list of displacements needed for a finite difference frequency computation, from energy points, for a given irrep.

        fd_geoms_freq_1(...)
            fd_geoms_freq_1( (int)arg1) -> matrix_vector :
                Gets the list of displacements needed fof a finite difference frequency computation, from gradients, for a given irrep

        fd_geoms_hessian_0(...)
            fd_geoms_hessian_0() -> matrix_vector :
                Gets the list of displacements needed fof a finite difference frequency computation, from energy points.

        fd_hessian_0(...)
            fd_hessian_0( (list)arg1) -> PsiReturnType :
                Performs a finite difference frequency computation, from energy points.

        flush_outfile(...)
            flush_outfile() -> None :
                Flushes the output file.

        fnocc(...)
            fnocc() -> float :
                Runs the fno-ccsd(t)/qcisd(t)/mp4/cepa energy code

        get_active_molecule(...)
            get_active_molecule() -> Molecule :
                Returns the currently active molecule object.

        get_frequencies(...)
            get_frequencies() -> Vector :
                Returns the most recently computed frequencies, as a 3N-6 Vector object.

        get_global_option(...)
            get_global_option( (str)arg1) -> object :
                Given a string of a keyword name, returns the value associated with the keyword from the global options. Returns error if keyword is not recognized.

        get_global_option_list(...)
            get_global_option_list() -> list :
                Returns a list of all global options.

        get_gradient(...)
            get_gradient() -> Matrix :
                Returns the most recently computed gradient, as a N by 3 Matrix object.

        get_input_directory(...)
            get_input_directory() -> str :
                Returns the location of the input file.

        get_local_option(...)
            get_local_option( (str)arg1, (str)arg2) -> object :
                Given a string of a keyword name and a particular module, returns the value associated with the keyword in the module options scope. Returns error if keyword is not recognized for the module.

        get_memory(...)
            get_memory() -> int :
                Returns the amount of memory available to Psi (in bytes).

        get_option(...)
            get_option( (str)arg1, (str)arg2) -> object :
                Given a string of a keyword name and a particular module, returns the local value associated with the keyword if it's been set, else the global value if it's been set, else the local default value. Returns error if keyword is not recognized globally or if keyword is not recognized for the module.

        get_variable(...)
            get_variable( (str)arg1) -> float :
                Returns one of the PSI variables set internally by the modules or python driver (see manual for full listing of variables available).

        has_global_option_changed(...)
            has_global_option_changed( (str)arg1) -> bool :
                Returns boolean for whether the option has been touched in the global scope, by either user or code. Notwithstanding, code is written such that in practice, this returns whether the option has been touched in the global scope by the user.

        has_local_option_changed(...)
            has_local_option_changed( (str)arg1, (str)arg2) -> bool :
                Returns boolean for whether the option has been touched in the scope of the specified module, by either user or code. Notwithstanding, code is written such that in practice, this returns whether the option has been touched in the module scope by the user.

        has_option_changed(...)
            has_option_changed( (str)arg1, (str)arg2) -> bool :
                Returns boolean for whether the option has been touched either locally to the specified module or globally, by either user or code. Notwithstanding, code is written such that in practice, this returns whether the option has been touched by the user.

        libfock(...)
            libfock() -> int :
                Runs a CPHF calculation, using libfock.

        mcscf(...)
            mcscf() -> float :
                Runs the MCSCF code, (N.B. restricted to certain active spaces).

        me(...)
            me() -> int :
                Returns the current process ID in a MADNESS parallel run.

        mints(...)
            mints() -> int :
                Runs mints, which generate molecular integrals on disk.

        mrcc_generate_input(...)
            mrcc_generate_input( (dict)arg1) -> PsiReturnType :
                Generates an input for Kallay's MRCC code.

        mrcc_load_densities(...)
            mrcc_load_densities( (dict)arg1) -> PsiReturnType :
                Reads in the density matrices from Kallay's MRCC code.

        nproc(...)
            nproc() -> int :
                Returns the number of processors being used in a MADNESS parallel run.

        nthread(...)
            nthread() -> int :
                Returns the number of threads to use in SMP parallel computations.

        nuclear_dipole(...)
            nuclear_dipole( (Molecule)arg1) -> Vector :
                docstring

        occ(...)
            occ() -> float :
                Runs the orbital optimized CC codes.

        opt_clean(...)
            opt_clean() -> None :
                Cleans up the optimizer's scratch files.

        optking(...)
            optking() -> int :
                Runs the geometry optimization / frequency analysis code.

        outfile_name(...)
            outfile_name() -> str :
                Returns the name of the output file.

        plugin(...)
            plugin( (str)arg1) -> int :
                docstring

        plugin_close(...)
            plugin_close( (str)arg1) -> None :
                docstring

        plugin_close_all(...)
            plugin_close_all() -> None :
                docstring

        plugin_load(...)
            plugin_load( (str)arg1) -> int :
                docstring

        prepare_options_for_module(...)
            prepare_options_for_module( (str)arg1) -> None :
                Sets the options module up to return options pertaining to the named argument (e.g. SCF).

        print_global_options(...)
            print_global_options() -> None :
                Prints the currently set global (all modules) options to the output file.

        print_options(...)
            print_options() -> None :
                Prints the currently set options (to the output file) for the current module.

        print_out(...)
            print_out( (str)arg1) -> None :
                Prints a string (using sprintf-like notation) to the output file.

        print_variables(...)
            print_variables() -> None :
                Prints all PSI variables that have been set internally.

        psi_top_srcdir(...)
            psi_top_srcdir() -> str :
                Returns the location of the source code.

        psimrcc(...)
            psimrcc() -> float :
                Runs the multireference coupled cluster code.

        reopen_outfile(...)
            reopen_outfile() -> None :
                Reopens the output file.

        revoke_global_option_changed(...)
            revoke_global_option_changed( (str)arg1) -> None :
                Given a string of a keyword name, sets the has_changed attribute in the global options scope to false. Used in python driver when a function sets the value of an option. Before the function exits, this command is called on the option so that has_changed reflects whether the user (not the program) has touched the option.

        revoke_local_option_changed(...)
            revoke_local_option_changed( (str)arg1, (str)arg2) -> None :
                Given a string of a keyword name and a particular module, sets the has_changed attribute in the module options scope to false. Used in python driver when a function sets the value of an option. Before the function exits, this command is called on the option so that has_changed reflects whether the user (not the program) has touched the option.

        sapt(...)
            sapt() -> float :
                Runs the symmetry adapted perturbation theory code.

        scf(...)
            scf( (object)arg1, (object)arg2) -> float :
                Runs the SCF code.

            scf() -> float :
                Runs the SCF code.

        scfgrad(...)
            scfgrad() -> int :
                Run scfgrad, which is a specialized DF-SCF gradient program.

        scfhess(...)
            scfhess() -> int :
                Run scfhess, which is a specialized DF-SCF hessian program.

        set_active_molecule(...)
            set_active_molecule( (Molecule)arg1) -> None :
                Activates a previously defined (in the input) molecule, by name.

        set_frequencies(...)
            set_frequencies( (Vector)arg1) -> None :
                Assigns the global frequencies to the values stored in the 3N-6 Vector argument.

        set_global_option(...)
            set_global_option( (str)arg1, (str)arg2) -> bool :
                Sets a string option for all modules.

            set_global_option( (str)arg1, (float)arg2) -> bool :
                Sets a double option for all modules.

            set_global_option( (str)arg1, (int)arg2) -> bool :
                Sets an integer option for all modules.

            set_global_option( (str)arg1, (list)arg2 [, (object)arg3]) -> bool

        set_global_option_python(...)
            set_global_option_python( (str)arg1, (object)arg2) -> bool :
                Sets a global option to a Python object type.

        set_gradient(...)
            set_gradient( (Matrix)arg1) -> None :
                Assigns the global gradient to the values stored in the N by 3 Matrix argument.

        set_local_option(...)
            set_local_option( (str)arg1, (str)arg2, (str)arg3) -> bool :
                Sets a string option scoped only to a specific module.

            set_local_option( (str)arg1, (str)arg2, (float)arg3) -> bool :
                Sets a double option scoped only to a specific module.

            set_local_option( (str)arg1, (str)arg2, (int)arg3) -> bool :
                Sets an integer option scoped only to a specific module.

            set_local_option( (str)arg1, (str)arg2, (list)arg3 [, (object)arg4]) -> bool

        set_local_option_python(...)
            set_local_option_python( (str)arg1, (object)arg2) -> None :
                Sets an option to a Python object, but scoped only to a single module.

        set_memory(...)
            set_memory( (int)arg1) -> None :
                Sets the memory available to Psi (in bytes).

        set_nthread(...)
            set_nthread( (int)arg1) -> None :
                Sets the number of threads to use in SMP parallel computations.

        set_parent_symmetry(...)
            set_parent_symmetry( (str)arg1) -> None :
                Sets the symmetry of the 'parent' (undisplaced) geometry, by Schoenflies symbol, at the beginning of a finite difference computation.

        set_variable(...)
            set_variable( (str)arg1, (float)arg2) -> None :
                Sets a PSI variable, by name.

        stability(...)
            stability() -> int :
                Runs the (experimental version) of HF stability analysis.

        thermo(...)
            thermo() -> float :
                Computes thermodynamic data.

        transqt(...)
            transqt() -> float :
                Runs the (deprecated) transformation code.

        transqt2(...)
            transqt2() -> float :
                Runs the (deprecated) transformation code.

        version(...)
            version() -> str :
                Returns the version ID of this copy of Psi.

        wavefunction(...)
            wavefunction() -> Wavefunction :
                Returns the current wavefunction object from the most recent computation.

    DATA
        Ascending = psi4.DiagonalizeOrder.Ascending
        Balk = psi4.PsiReturnType.Balk
        Descending = psi4.DiagonalizeOrder.Descending
        EndLoop = psi4.PsiReturnType.EndLoop
        Failure = psi4.PsiReturnType.Failure
        Success = psi4.PsiReturnType.Success

### Navigation

- index
- modules
- toc
- next
- previous
- PSI4 [beta5] »