| sc::LinearR12::ABS_OBS_Contraction | ABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the ABS approach |
| sc::AbstractCCAFramework | Defines an interface to abstract CCA frameworks |
| sc::AccResult< T > | This associates a result datum with an accuracy |
| sc::AccResultInfo | This is like ResultInfo but the accuracy with which a result was computed as well as the desired accuracy are stored |
| sc::AccumH | AccumH computes additions to the one body Hamiltonian |
| sc::AccumHNull | This specialization of AccumH does nothing |
| sc::ActiveMessage | Derivatives of ActiveMessage can be constructed in one process and executed in another by using ActiveMessageGrp |
| sc::ActiveMessageEcho | This is an ActiveMessage derivative used for testing |
| sc::ActiveMessageGrp | ActiveMessageGrp provides an implemention of active messages that sends objects derived from ActiveMessage to remote processes and causes their run member to be executed there |
| sc::ActiveMessageThread | This is a help class that is used by ActiveMessageGrp |
| sc::ActiveMsgMemoryGrp | The ActiveMsgMemoryGrp abstract class specializes the MsgMemoryGrp class |
| sc::AggregateKeyVal | This takes several KeyVal objects and makes them look like one KeyVal object |
| sc::AlgorithmException | This exception is thrown whenever a problem with an algorithm is encountered |
| sc::AM05Functional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional |
| sc::AngularIntegrator | An abstract base class for angular integrators |
| sc::ManyBodyTensors::Apply_H0minusE0< sign > | Applies (H0 - E0) |
| sc::ManyBodyTensors::Apply_Identity< sign > | Tensor elements are <pq||rs> |
| sc::ManyBodyTensors::Apply_Inverse_H0minusE0< sign > | Applies (H0 - E0)^{-1}, e.g. MP2 T2 tensor elements are <ij||ab> /(e_i + e_j - e_a - e_b) |
| sc::ManyBodyTensors::Apply_Inverse_Sqrt_H0minusE0< sign > | Applies 1.0/sqrt(H0-E0) MP2 pseudo-T2 (S2) tensor elements are <ij||ab> /sqrt(|e_i + e_j - e_a - e_b|) such that MP2 pair energies are the diagonal elements of S2 * S2.t() |
| sc::ARMCIMemoryGrp | The ARMCIMemoryGrp concrete class provides an implementation of MsgMemoryGrp |
| sc::AssignedKeyVal | This class allows keyval associations to be set up by the program, rather than determined by an external file |
| sc::AtomInfo | Information about atoms |
| sc::auto_vec< T > | The auto_vec class functions much like auto_ptr, except it contains references to arrays |
| sc::test::BasisProductDecomposition | Represents decomposition of a product of basis sets |
| sc::BatchElectronDensity | This a more highly optimized than ElectronDensity since everything is precomputed |
| sc::BcastState | This creates and forwards/retrieves data from either a BcastStateRecv or a BcastStateSend depending on the value of the argument to constructor |
| sc::BcastStateInBin | BcastStateBin reads a file in written by StateInBin on node 0 and broadcasts it to all nodes so state can be simultaneously restored on all nodes |
| sc::BcastStateRecv | BcastStateRecv does the receive part of a broadcast of an object to all nodes |
| sc::BcastStateSend | BcastStateSend does the send part of a broadcast of an object to all nodes |
| sc::Becke88XFunctional | Implements Becke's 1988 exchange functional |
| sc::BeckeIntegrationWeight | Implements Becke's integration weight scheme |
| sc::BEMSolventH | WARNING: The BEMSolventH class is not thoroughly tested |
| sc::BendSimpleCo | Describes an bend internal coordinate of a molecule |
| sc::BFGSUpdate | The DFPUpdate class is used to specify a Broyden, Fletcher, Goldfarb, and Shanno hessian update scheme |
| sc::BoundsLibint2< Int2e > | Computes log2 bounds for a particular Int2e evaluator |
| sc::LinearR12::CABS_OBS_Contraction | CABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the CABS approach |
| sc::canonical_aa | Can be used as a template argument to GenericPetiteList2 |
| sc::canonical_aaaa | If the shell loop structure has 8 fold symmetry, then this should be used as the template argument to GenericPetiteList4 |
| sc::canonical_aabb | If the shell loop structure has 2 fold symmetry between the first two indices and a 2 fold symmetry between the last two indices, then this should be used as the template argument to GenericPetiteList4 |
| sc::canonical_aabc | If the shell loop structure has 2 fold symmetry between the first two indices, then this should be used as the template argument to GenericPetiteList4 |
| sc::canonical_ab | Can be used as a template argument to GenericPetiteList2 |
| sc::canonical_abab | If the shell loop structure has 2 fold symmetry between the bra and the ket then this should be used as the template argument to GenericPetiteList4 |
| sc::canonical_abcc | If the shell loop structure has 2 fold symmetry between the last two indices, then this should be used as the template argument to GenericPetiteList4 |
| sc::canonical_abcd | If the shell loop structure has no symmetry, then this should be used as the template argument to GenericPetiteList4 |
| sc::CartesianIter | CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization |
| sc::CartMolecularCoor | Implements Cartesian coordinates in a way suitable for use in geometry optimizations |
| sc::CCAEnv | CCA environment |
| sc::CCAFramework | Defines an interface to CCA frameworks |
| sc::CharacterTable | Workable character table for all of the non-cubic point groups |
| sc::ClassDesc | This class is used to contain information about classes |
| sc::CLHF | CLHF is a Hartree-Fock specialization of CLSCF |
| sc::CLHFContribution | Computes components of the Fock matrix necessary for closed-shell calculations (i.e |
| sc::CLKS | This provides a Kohn-Sham implementation for closed-shell systems |
| sc::CLSCF | Base for classes implementing a self-consistent procedure for closed-shell molecules |
| sc::Compute | Means of keeping results up to date |
| sc::ConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result |
| sc::Convergence | Used by the optimizer to determine when an optimization is converged |
| sc::CorrelatedMOOrder | Order by occupation first, then by symmetry, then by energy |
| sc::CorrelatedSpinMOOrder | Order by occupation first, then by spin, then by symmetry, then by energy |
| sc::LinearR12::CorrelationFactor | CorrelationFactor is a set of one or more two-particle functions of the interparticle distance |
| sc::CorrelationTable | Correlation table between two point groups |
| sc::LinearR12::CorrParamCompare< IntParam > | Compares CorrelationParamaters corresponding to IntParam |
| sc::CreateTransformHints | Provides hints to the constructors of a Transform class that help configure its implementation |
| sc::Debugger | Describes what should be done when a catastrophic error causes unexpected program termination |
| sc::DecoratedOrbital< Attributes > | Orbital = index + attributes |
| sc::DefaultPrintThresholds | Default print thresholds |
| sc::DenFunctional | An abstract base class for density functionals |
| sc::DenIntegrator | An abstract base class for integrating the electron density |
| sc::test::DensityFitting | Decomposition by density fitting with respect to some kernel |
| sc::DerivCenters | DerivCenters keeps track the centers that derivatives are taken with respect to |
| sc::DescribedClass | Classes which need runtime information about themselves and their relationship to other classes can virtually inherit from DescribedClass |
| sc::DescribedClassProxy | Classes deriving from this are used to generate objects of DescribedClass type |
| sc::DFPUpdate | Used to specify a Davidson, Fletcher, and Powell hessian update scheme |
| sc::DiagMolecularHessian | DiagMolecularHessian is an implementation of MolecularHessian that returns a hessian that is a diagonal matrix |
| sc::DiagSCMatrix | The SymmSCMatrix class is the abstract base class for diagonal double valued matrices |
| sc::DIIS | DIIS extrapolation |
| sc::LinearR12::Direct_Contraction | Direct_Contraction is a straight scalar (dot) product of 2 rectangular blocks, scaled by scale |
| sc::DiscreteConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result |
| sc::DistSCMatrixKit | The DistSCMatrixKit produces matrices that work in a many processor environment |
| sc::DistShellPair | Distributes shell pairs either statically or dynamically |
| sc::DistShellPair::SharedData | This is used to store data that must be shared between all cooperating shell pairs |
| sc::EFCOpt | Implements eigenvector following as described by Baker in J |
| sc::ElectronDensity | This is a Volume that computes the electron density |
| sc::EnergyMOOrder | Order by energy first, then by symmetry |
| sc::EriCints | EriCints is a specialization of Int2eCints that computes electron repulsion integrals |
| sc::EriLibint2 | EriLibint2 is a specialization of Int2eLibint2 that computes electron repulsion integrals |
| sc::EulerMaclaurinRadialIntegrator | An implementation of a radial integrator using the Euler-Maclaurin weights and grid points |
| sc::ExEnv | Used to find out about how the program is being run |
| sc::ExternalCCAFramework | Handles externally initialized CCA frameworks |
| sc::F12Amplitudes | F12Amplitudes gives the amplitudes of some linear-F12-ansatz-related terms in wave function |
| sc::FeatureNotImplemented | This is thrown when an attempt is made to use a feature that is not yet implemented |
| sc::FEMO | Describes a simple the free-electron molecular orbital model that can be used to guess the lowest-energy orbital configuration |
| sc::FileGrp | The FileGrp abstract class provides a way of accessing distributed file in a parallel machine |
| sc::FileOperationFailed | This is thrown when an operation on a file fails |
| sc::FinDispMolecularHessian | Computes the molecular hessian by finite displacements of gradients |
| sc::Fjt | Evaluates the Boys function F_j(T) |
| sc::FJT | "Old" intv3 code from Curt Computes F_j(T) using 6-th order Taylor interpolation |
| sc::FockBuild | Works with the FockBuildThread class to generate Fock matrices for both closed shell and open shell methods |
| sc::FockBuildCLHF | CLHF is a Hartree-Fock specialization of CLSCF |
| sc::FockBuildThread | Used to actually build the Fock matrix |
| sc::FockBuildThread_F11_P11 | The FockBuildThread class is used to actually build the Fock matrix |
| sc::FockBuildThread_F12_P33 | This is used to build the Fock matrix when none of the basis sets are equivalent |
| sc::FockDistribution | FockDistribution is a factory for constructing the desired FockDist specialization |
| sc::ForceLink< T, A > | This, together with ForceLinkBase, is used to force code for particular classes to be linked into executables |
| sc::ForceLinkBase< A > | This, together with ForceLink, is used to force code for particular classes to be linked into executables |
| sc::detail::FromStateIn< T > | Helper template to read from StateIn |
| sc::detail::FromStateIn< sc::Ref< T > > | Specialization for Ref<SavableState> |
| sc::detail::FromStateIn< sc::RefDiagSCMatrix > | Specialization for RefDiagSCMatrix |
| sc::detail::FromStateIn< sc::RefSCMatrix > | Specialization for RefSCMatrix |
| sc::detail::FromStateIn< sc::RefSymmSCMatrix > | Specialization for RefSymmSCMatrix |
| sc::Function | Abstract base class that, given a set of coordinates, will compute a value and possibly a gradient and hessian at that point |
| sc::LinearR12::G12CorrelationFactor | G12CorrelationFactor stands for Gaussian geminals correlation factor, usable with methods that require commutator integrals |
| sc::G12DKHLibint2 | G12DKHLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to relativistic explicitly correlated methods which use Gaussian geminals |
| sc::G12Libint2 | G12Libint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to explicitly correlated methods which use Gaussian geminals |
| sc::LinearR12::G12NCCorrelationFactor | G12NCCorrelationFactor stands for Gaussian geminals correlation factor, usable with methods that do not require commutator integrals |
| sc::G12NCLibint2 | G12NCLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to explicitly correlated methods which use Gaussian geminals (formulation without commutators) |
| sc::G96XFunctional | Implements the Gill 1996 (G96) exchange functional |
| sc::mbptr12::Gaussian1D | Gaussian1D(k,x) = x^k exp(-a*x^2) |
| sc::GaussianBasisSet | Used describe a basis set composed of atomic gaussian orbitals |
| sc::GaussianBasisSet::ValueData | This holds scratch data needed to compute basis function values |
| sc::GaussianBasisSetSum | GaussianBasisSetSum constructs a sum of 2 basis sets formed by GaussianBasisSet::operator+() as well as various maps from the constituent basis sets to the sum |
| sc::GaussianFit< Function, Weight > | GaussianFit<Function> is a fit of Function(x)*Weight(x) to N Gaussians on range [left,right] Valid Function and Weight are Unary Functions which take and return a double |
| sc::GaussianShell | A Gaussian orbital shell |
| sc::GaussLegendreAngularIntegrator | An implementation of an angular integrator using the Gauss-Legendre weights and grid points |
| sc::GenericFockContribution | Much of the infrastructure needed by FockContribution specializations |
| sc::GenericPetiteList2< C2 > | This class provides a generalized 2-index petite list |
| sc::GenericPetiteList4< C4 > | This class provides a generalized four index petite list |
| sc::LinearR12::GenG12CorrelationFactor | GenG12CorrelationFactor stands for no correlation factor |
| sc::GenG12Libint2 | GenG12Libint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to explicitly correlated methods which use general Gaussian geminals (i.e |
| sc::GetLongOpt | Parse command line options |
| sc::GlobalCounter | Allows processes on the same SMP node to share a counter using SysV IPC semaphores |
| sc::GPetiteList2 | This class is an abstract base to a generalized 2-index petite list |
| sc::GPetiteList4 | This class is an abstract base to a generalized four index petite list |
| sc::GPetiteListFactory | Produces generalized 2 and 4-index petite list objects |
| sc::Grid | Defines a finite regular Carthesian grid |
| sc::GRTCints | GRTCints is a specialization of Int2eCints that computes two-electron integrals specific to linear R12 methods |
| sc::GRTLibint2 | GRTLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to linear R12 methods |
| sc::GuessMolecularHessian | GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates |
| sc::HessianUpdate | The HessianUpdate abstract class is used to specify a hessian update scheme |
| sc::HSOSHF | HSOSHF is a Hartree-Fock specialization of HSOSSCF |
| sc::HSOSHFContribution | Computes components of the Fock matrix necessary for high-spin open-shell calculations (e.g |
| sc::HSOSKS | This provides a Kohn-Sham implementation for restricted-orbital high-spin open-shell systems |
| sc::HSOSSCF | Base for classes implementing a self-consistent procedure for high-spin open-shell molecules |
| sc::HundsFEMOSeeker | Finds the FEMO configuration that corresponds to the maximum multiplicity |
| sc::Identifier | Identifier's are used to distinguish and order objects |
| sc::Identity | Identity gives objects a unique identity and ordering relationship relative to all other objects |
| sc::IdentityTransform | The IdentityTransform is a special case of NonlinearTransform were no transformation takes place |
| sc::InputError | This is thrown when invalid input is provided |
| sc::Int1eCints | Int1eCints is used by OneBodyIntCints and OneBodyDerivIntCints to implement IntegralCints |
| sc::Int1eLibint2 | Int1eLibint2 is used by OneBodyIntLibint2 and OneBodyDerivIntLibint2 to implement IntegralLibint2 |
| sc::Int1eV3 | Int1eV3 is a class wrapper for the one body part of the C language IntV3 library |
| sc::Int2eCints | Int2eCints is an interface to various specializations of two-electron integral evaluators implemented in Cints |
| sc::Int2eLibint2 | Int2eLibint2 is an interface to various specializations of two-electron integral evaluators implemented in Libint2 |
| sc::Int2eV3 | Int2eV3 is a class wrapper for the two body part of the C language IntV3 library |
| sc::IntCoor | The IntCoor abstract class describes an internal coordinate of a molecule |
| sc::IntCoorGen | IntCoorGen generates a set of simple internal coordinates for a molecule |
| sc::Integral | The Integral abstract class acts as a factory to provide objects that compute one and two electron integrals |
| sc::IntegralCCA | IntegralCCA provides an SC client for CCA IntegralEvaluator components |
| sc::IntegralCints | IntegralCints computes integrals between Gaussian basis functions |
| sc::IntegralLibint2 | IntegralLibint2 computes integrals between Gaussian basis functions |
| sc::IntegralSetDescr< IntEval > | For a set of integrals (e.g |
| sc::IntegralTypeDescr | For a kind of integrals (e.g |
| sc::IntegralV3 | IntegralV3 computes integrals between Gaussian basis functions |
| sc::IntegrationWeight | An abstract base class for computing grid weights |
| sc::IntMolecularCoor | The IntMolecularCoor abstract class describes a molecule's coordinates in terms of internal coordinates |
| sc::IntParams | This class passes optional operator parameters |
| sc::IntParamsG12 | Passes params to Integral::g12() |
| sc::IntParamsGenG12 | Passes params to Integral::geng12() |
| sc::IntParamsVoid | Passes params to Integral::electron_repulsion() and other factory methods which do not need parameters |
| sc::IrreducibleRepresentation | Information associated with a particular irreducible representation of a point group |
| sc::ISphericalTransform | This describes a solid harmonic to Cartesian transform |
| sc::KeyVal | Designed to simplify the process of allowing a user to specify keyword/value associations to a C++ program |
| sc::KeyValValue | Represents the value of a keyword |
| sc::KeyValValueboolean | Represents a boolean value |
| sc::KeyValValuechar | Represents a char value |
| sc::KeyValValuedouble | Represents a double value |
| sc::KeyValValuefloat | Represents a float value |
| sc::KeyValValueint | Represents an int value |
| sc::KeyValValuelong | Represents a long value |
| sc::KeyValValuepchar | Represents a pointer to char value (deprecated, use KeyValValuestring) |
| sc::KeyValValueRefDescribedClass | Represents a Ref<DescribedClass> value |
| sc::KeyValValuesize | Represents a size_t value |
| sc::KeyValValueString | Represents a pointer to char value (deprecated, use KeyValValuestring) |
| sc::KeyValValuestring | Represents a std::string value |
| sc::LebedevLaikovIntegrator | An implementation of a Lebedev angular integrator |
| sc::LimitExceeded< T > | This is thrown when a limit is exceeded |
| sc::LineOpt | The LineOpt abstract class is used to perform one dimensional optimizations |
| sc::LinIPSimpleCo | Describes an in-plane component of a linear bend internal coordinate of a molecule |
| sc::LinOPSimpleCo | Describes an out-of-plane component of a linear bend internal coordinate of a molecule |
| sc::LocalSCMatrixKit | The LocalSCMatrixKit produces matrices that work in a single processor environment |
| sc::Log2Bounds | Computes log2 bounds |
| sc::LSDACFunctional | An abstract base class for local correlation functionals |
| sc::LSelectBasisSet | Used to select shells by angular momentum from a mother basis |
| sc::LYPCFunctional | Implements the Lee, Yang, and Parr functional |
| sc::MaskedOrbitalSpace | This is an OrbitalSpace produced from an existing one by masking out some Orbitals |
| sc::MaxIterExceeded | This is thrown when an iterative algorithm attempts to use more iterations than allowed |
| sc::MBPT2 | Implements several second-order perturbation theory methods |
| sc::MBPT2_R12 | Implements several linear R12 second-order perturbation theory methods |
| sc::MCSearch | This performs line searches with cubic steps |
| sc::MemAllocFailed | This is thrown when a memory allocation fails |
| sc::MemoryDataRequest | This is a help class used by ActiveMsgMemoryGrp |
| sc::MemoryDataRequestQueue | This is a help class used by ActiveMsgMemoryGrp |
| sc::MemoryGrp | The MemoryGrp abstract class provides a way of accessing distributed memory in a parallel machine |
| sc::MemoryGrpBuf< data_t > | The MemoryGrpBuf class provides access to pieces of the global shared memory that have been obtained with MemoryGrp |
| sc::MemoryGrpRegion | The MemoryGrpRegion is a MemoryGrp proxy to a region of a MemoryGrp |
| sc::MemoryIter | This iterates through data in a global array |
| sc::MessageGrp | The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine |
| sc::MOIntsRuntime | Smart runtime support for computing MO-basis integrals |
| sc::MOIntsRuntime::Layout | Describes the physical layout of the integrals in TwoBodyIntsAcc |
| sc::MOIntsTransformFactory | MOIntsTransformFactory is a factory that produces MOIntsTransform objects |
| sc::MOIntsTransformFactory::StoreMethod | Describes the method of storing transformed MO integrals |
| sc::MolecularCoor | The MolecularCoor abstract class describes the coordinate system used to describe a molecule |
| sc::MolecularEnergy | The MolecularEnergy abstract class inherits from the Function class |
| sc::MolecularEnergyCCA | The MolecularEnergyCCA concrete class inherits from the MolecularEnergy class |
| sc::MolecularFormula | Used to calculate the molecular formula of a Molecule |
| sc::MolecularFrequencies | Used to compute the molecular frequencies and thermodynamic information |
| sc::MolecularHessian | MolecularHessian is an abstract class that computes a molecule's second derivatives of the energy with respect to changes in the nuclear coordinates |
| sc::detail::MolecularOrbitalAttributes | MO is irrep, energy, occupation number |
| sc::MolecularOrbitalMask< Attribute, AttributeContainer, Compare > | Mask out first n MOs in the order defined by Compare. By default mask the n lowest-energy MOs |
| sc::detail::MolecularSpinOrbitalAttributes | Same as MolecularOrbitalAttributes, plus spin |
| sc::Molecule | Information about molecules |
| sc::MOPairIter | MOPairIter gives the ordering of orbital pairs |
| sc::fastpairiter::MOPairIter< PSymm > | SpinMOPairIter iterates over pairs of spinorbitals of spin case Spin12 This class differs from other MOPairIter classes: 1) cannot start from arbitrary IJ, only IJ=0; 2) error checking maximally reduced |
| sc::MOPairIterFactory | This class produces MOPairIter objects |
| sc::MP2R12Energy | Class MP2R12Energy is the object that computes and maintains MP2-R12 energies |
| sc::MP2R12Energy_SpinOrbital | The class MP2R12Energy_SpinOrbital is the original implementation of MP2R12Energy It supports only the standard orbital-invariant ansatz and the full set of features of R12Technology |
| sc::MP2R12Energy_SpinOrbital_new | The class MP2R12Energy_SpinOrbital_new is a new version of MP2R12Energy_SpinOrbital and computes diagonal and non diagonal MP2 F12 energies preserving the Spin symmetry of the wavefunction |
| sc::MP2R12EnergyUtil_base | Class MP2R12EnergyUtil_base is the abstract interface to utility functions used by MP2R12Energy derivatives |
| sc::MP2R12EnergyUtil_Diag_DifferentSpin | Class MP2R12EnergyUtil provides some misc functions to operate on (blocked) ijxy and xyxy matrices |
| sc::MPIMessageGrp | Concrete implementation of MessageGrp that uses the MPI 1 library |
| sc::MPQC_CCAFramework | Handles embedded CCA frameworks |
| sc::MPQCInit | This helper class simplifies initialization of MPQC |
| sc::mPW91XFunctional | Implements a modified 1991 Perdew-Wang exchange functional |
| sc::MsgMemoryGrp | A MsgMemoryGrp that initializes its data using a messagegrp |
| sc::MsgStateBufRecv | The MsgStateBufRecv is an abstract base class that buffers objects sent through a MessageGrp |
| sc::MsgStateRecv | The MsgStateRecv is an abstract base class that receives objects from nodes in a MessageGrp |
| sc::MsgStateSend | The MsgStateSend is an abstract base class that sends objects to nodes in a MessageGrp |
| sc::MTMPIMemoryGrp | This MemoryGrp class requires a MT-safe MPI implementation |
| sc::NCAccResult< T > | This associates a result non-class datum with an accuracy |
| sc::NCResult< T > | This is similar to Result, but can be used with non-class types |
| sc::NElFunctional | The NElFunctional computes the number of electrons |
| sc::NonblockedOrbitalSpace | This is an OrbitalSpace produced from an existing one by getting rid of the blocking |
| sc::NonlinearTransform | Transforms between two nonlinear coordinate systems |
| sc::detail::NonsingletonCreationPolicy< T > | NonsingletonCreationPolicy is used to create non-Singletons on heap |
| sc::LinearR12::NullCorrelationFactor | NullCorrelationFactor stands for no correlation factor |
| sc::OneBodyDerivInt | OneBodyDerivInt is an abstract base class for objects that compute one body derivative integrals |
| sc::OneBodyDerivIntCCA | This implements one body derivative integrals through the CCA interface |
| sc::OneBodyDerivIntV3 | This implements one body derivative integrals in the IntV3 library |
| sc::OneBodyFockMatrixBuilder< bra_eq_ket > | Builds the one-body part of the Fock matrix in AO basis |
| sc::OneBodyInt | OneBodyInt is an abstract base class for objects that compute integrals between two basis functions |
| sc::OneBodyIntCCA | This implements one body integrals through the CCA interface |
| sc::OneBodyIntCints | This implements most one body integrals in the Cints library |
| sc::OneBodyIntLibint2 | This implements most one body integrals in the Libint2 library |
| sc::OneBodyIntV3 | This implements most one body integrals in the IntV3 library |
| sc::OneBodyOneCenterDerivInt | OneBodyOneCenterDerivInt is an abstract base class for objects that compute one body derivative integrals on a single center |
| sc::OneBodyOneCenterInt | OneBodyOneCenterInt is an abstract base class for objects that compute integrals between two basis functions |
| sc::OneBodyWavefunction | A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem |
| sc::Optimize | Abstract base class for classes that find the extreme points of Function's |
| sc::OrbitalSpace | Class OrbitalSpace describes a range of orbitals that are linear combinations of Gaussian basis functions (e.g |
| sc::OrbitalSpaceRuntime | Smart runtime that knows how to build OrbitalSpace objects and knows relationships between OrbitalSpace objects |
| sc::OrderedOrbitalSpace< Order > | This is an OrbitalSpace ordered according to the Order type |
| sc::OrderedSpinOrbitalSpace< Order > | Same as OrderedOrbitalSpace, except for spin-orbitals |
| sc::OverlapOrthog | This class computes the orthogonalizing transform for a basis set |
| sc::P86CFunctional | Implements the Perdew 1986 (P86) correlation functional |
| sc::ParallelRegionTimer | This is a parallel-away derivative of RegionTimer |
| sc::ParentClass | Gives one parent class of a class |
| sc::ParentClasses | Gives a list of parent classes of a class |
| sc::ParsedKeyVal | Converts textual information into keyword/value assocations |
| sc::ParsedOneBodyIntKey | Parsed representation of a string key that represents a set of one-body integrals |
| sc::ParsedOrbitalSpaceKey | Parses keys of OrbitalSpace |
| sc::ParsedTransformedOrbitalSpaceKey | Parses keys of a "transformed" OrbitalSpace |
| sc::ParsedTwoBodyIntKey | Parsed representation of a string key that represents a set of 2-body integrals |
| sc::PBECFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional |
| sc::PBEXFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional |
| sc::PointGroup | Really a place holder for a CharacterTable |
| sc::PointInputData | Contains data needed at each point by a DenFunctional |
| sc::PointOutputData | Contains data generated at each point by a DenFunctional |
| sc::PowellUpdate | Used to specify a Powell hessian update |
| sc::mbptr12::PowerGaussian1D | PowerGaussian1D(k,l,x) = x^k exp(-a*x^l) |
| sc::PrefixKeyVal | PrefixKeyVal is a KeyVal that searches a different KeyVal using modified keys |
| sc::PrimPairsCints | PrimPairsCints contains primitive pair data |
| sc::PrimPairsLibint2 | PrimPairsLibint2 contains primitive pair data |
| sc::ProcFileGrp | The ProcFileGrp concrete class provides an implementation of FileGrp for a single processor |
| sc::ProcMemoryGrp | The ProcMemoryGrp concrete class provides an implementation of MemoryGrp for a single processor |
| sc::ProcMessageGrp | ProcMessageGrp provides a concrete specialization of MessageGrp that supports only one node |
| sc::ProcThreadGrp | Privides a concrete thread group appropriate for an environment where there is only one thread |
| sc::ProgrammingError | This is thrown when a situations arises that should be impossible |
| sc::PsiCC | PsiCC is a Psi coupled cluster wave function |
| sc::PsiCCSD | PsiCCSD is a concrete implementation of Psi CCSD wave function |
| sc::PsiCCSD_PT2R12 | PsiCCSD_PT2R12 is a concrete implementation of the  method |
| sc::PsiCCSD_PT2R12T | PsiCCSD_PT2R12T is a concrete implementation of the  method |
| sc::PsiCCSD_T | PsiCCSD_T is a concrete implementation of Psi CCSD(T) wave function |
| sc::PsiCLHF | PsiCLHF is a concrete implementation of Psi RHF wave function |
| sc::PsiCorrWavefunction | PsiCorrWavefunction is a Psi correlated wave function |
| sc::PsiExEnv | PsiExEnv specifies a Psi calculation |
| sc::PsiFile11 | PsiFile11 is a Psi gradient file |
| sc::PsiHSOSHF | PsiHSOSHF is a concrete implementation of Psi ROHF wave function |
| sc::PsiInput | PsiInput is a Psi input file |
| sc::PsiSCF | PsiSCF is an abstract base for all Psi SCF wave functions |
| sc::PsiUHF | PsiUHF is a concrete implementation of Psi UHF wave function |
| sc::PsiWavefunction | PsiWavefunction is an abstract base for all Psi wave functions |
| sc::PthreadThreadGrp | Privides a concrete thread group appropriate for an environment where pthreads is available |
| sc::PumaThreadGrp | Privides a concrete thread group appropriate for the intel teraflops machine |
| sc::PureSpinPairIter | PureSpinPairIter iterates over spin-adapted (singlet or triplet) orbital pairs |
| sc::PW86XFunctional | Implements the Perdew-Wang 1986 (PW86) Exchange functional |
| sc::PW91CFunctional | The Perdew-Wang 1991 correlation functional computes energies and densities using the designated local correlation functional |
| sc::PW91XFunctional | The Perdew-Wang 1991 exchange functional computes energies and densities using the designated local correlation functional |
| sc::PW92LCFunctional | Implements the PW92 local (LSDA) correlation term |
| sc::PZ81LCFunctional | Implements the PZ81 local (LSDA) correlation functional |
| sc::QNewtonOpt | The QNewtonOpt implements a quasi-Newton optimization scheme |
| sc::LinearR12::R12CorrelationFactor | R12CorrelationFactor stands for no correlation factor |
| sc::R12EnergyIntermediates | The class R12EnergyIntermediates stores all intermediates for F12 calculations and administrates their computation and / or provision |
| sc::R12IntEval | R12IntEval is the top-level class which computes intermediates occuring in linear R12 theories |
| sc::R12IntEvalInfo | Class R12IntEvalInfo contains information necessary for R12 intermediate evaluators |
| sc::R12IntEvalInfo::SpinSpaces | Maintains virtual orbitals and RI space info if VBS != OBS |
| sc::R12IntsAcc | R12IntsAcc contains a set of one or more distributed dense 4-index arrays |
| sc::R12IntsAcc_MemoryGrp | R12IntsAcc_MemoryGrp handles transformed integrals held in memory by MemoryGrp |
| sc::R12IntsAcc_MPIIOFile | R12IntsAcc_MPIIOFile handles transformed integrals stored in a binary file accessed through MPI-IO |
| sc::R12IntsAcc_MPIIOFile_Ind | R12IntsAcc_MPIIOFile_Ind handles transformed integrals stored in a binary file accessed through MPI-IO individual I/O routines |
| sc::R12IntsAcc_Node0File | R12IntsAcc_Node0File handles transformed integrals stored in file on node 0 (file is a usual POSIX binary file) |
| sc::R12IntsAccCreator | Creates new R12IntsAcc using MOIntsRuntime and a vector of transform keys |
| sc::R12Technology | R12Technology describes technical features of the R12 approach |
| sc::R12TwoBodyIntKeyCreator | Creates R12TwoBodyIntKey for the given CorrelationFactor |
| sc::RadialAngularIntegrator | An implementation of an integrator using any combination of a RadialIntegrator and an AngularIntegrator |
| sc::RadialIntegrator | An abstract base class for radial integrators |
| sc::RangeCreator< T > | RangeCreator<T> is Functor which can be used up to n times to create objects of type T |
| sc::RDMAMemoryGrp | The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp class |
| sc::ReadMolecularHessian | ReadMolecularHessian is an implementation of MolecularHessian that reads the hessian from a file |
| sc::RedundantCartesianIter | RedundantCartesianIter objects loop through all possible combinations of a given number of axes |
| sc::RedundantCartesianSubIter | Like RedundantCartesianIter, except a, b, and c are fixed to a given value |
| sc::RedundMolecularCoor | Redundant set of simple internal coordinates |
| sc::Ref< T > | A template class that maintains references counts |
| sc::RefBase | Provides a few utility routines common to all Ref template instantiations |
| sc::RefCount | The base class for all reference counted objects |
| sc::RefDiagSCMatrix | Smart pointer to an DiagSCMatrix specialization |
| sc::RefObjectEqual< T, EqualTo > | This functor can be used as a binary predicate for standard algorithms |
| sc::RefSCDimension | Smart pointer to an SCDimension specialization |
| sc::RefSCMatrix | Smart pointer to an SCMatrix specialization |
| sc::RefSCVector | Smart pointer to an SCVector specialization |
| sc::RefSymmSCMatrix | Smart pointer to an SCSymmSCMatrix specialization |
| sc::RegionTimer | Used to record the time spent in a section of code |
| sc::Registry< Key, Value, CreationPolicy, KeyEqual, ValueEqual > | Registry contains is an extension of std::map with configurable Creation policy |
| sc::ReplSCMatrixKit | The ReplSCMatrixKit produces matrices that work in a many processor environment |
| sc::Result< T > | Result are members of Compute specializations that keep track of whether or not a particular result should be computed or if it has already been computed |
| sc::ResultInfo | This is a base class for all of Compute's result types |
| sc::Runnable | DescribedClass with a pure virtual run member |
| sc::SavableState | Base class for objects that can save/restore state |
| sc::SavableStateProxy | Create a proxy for a SavableState object |
| sc::ScaledTorsSimpleCo | Describes an scaled torsion internal coordinate of a molecule |
| sc::SCBlockInfo | SCBlockInfo contains blocking information for the SCDimension class |
| sc::SCDimension | Used to determine the size and blocking of matrices |
| sc::SCElementKNorm | Computed k-norm of matrix |
| sc::SCElementOp | Objects of class SCElementOp are used to perform operations on the elements of matrices |
| sc::SCElementOp2 | Very similar to the SCElementOp class except that pairs of blocks are treated simultaneously |
| sc::SCElementOp3 | Very similar to the SCElementOp class except that a triplet of blocks is treated simultaneously |
| sc::SCException | This is a std::exception specialization that records information about where an exception took place |
| sc::SCExtrapData | SCExtrapData hold the data to be extrapolated needed by SelfConsistentExtrapolation |
| sc::SCExtrapError | SCExtrapError holds the error data needed by SelfConsistentExtrapolation |
| sc::SCF | Base for all classes that use a self-consistent field procedure to solve an effective one body problem |
| sc::SCFormIO | This utility class is used to print only on node 0 and to provide attractive indentation of output |
| sc::SCMatrix | Abstract base class for general double valued n by m matrices |
| sc::SCMatrixBlock | SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors |
| sc::SCMatrixBlockIter | Used to described iterates that loop through the elements in a block |
| sc::SCMatrixDiagBlock | The SCMatrixDiagBlock describes a diagonal piece of a matrix |
| sc::SCMatrixDiagSubBlock | The SCMatrixDiagSubBlock describes a diagonal subblock of a matrix |
| sc::SCMatrixKit | The SCMatrixKit abstract class acts as a factory for producing matrices |
| sc::SCMatrixLTriBlock | The SCMatrixLTriBlock describes a triangular piece of a matrix |
| sc::SCMatrixLTriSubBlock | The SCMatrixLTriSubBlock describes a triangular subblock of a matrix |
| sc::SCMatrixRectBlock | The SCMatrixRectBlock describes a rectangular piece of a matrix |
| sc::SCMatrixRectSubBlock | The SCMatrixRectSubBlock describes a rectangular piece of a matrix |
| sc::SCMatrixSubblockIter | Objects of class SCMatrixSubblockIter are used to iterate through the blocks of a matrix |
| sc::scprintf | This class allows printf-like output to be sent to an ostream |
| sc::SCVector | Abstract base class for double valued vectors |
| sc::SCVectorSimpleBlock | The SCVectorSimpleBlock describes a piece of a vector |
| sc::SCVectorSimpleSubBlock | The SCVectorSimpleSubBlock describes a subblock of a vector |
| sc::SelfConsistentExtrapolation | The SelfConsistentExtrapolation abstract class is used to iteratively solve equations requiring a self consistent solution, such as, |
| sc::SetIntCoor | Describes a set of internal coordinates |
| sc::Shape | A Shape is a Volume represents an 3D solid |
| sc::ShellPairCints | ShellPairCints provides all primitive pair data for a given shell pair |
| sc::ShellPairLibint2 | ShellPairLibint2 is an interface to PrimPairsLibint2 |
| sc::ShellPairsCints | ShellPairsCints contains primitive pair data for all shell pairs |
| sc::ShellPairsLibint2 | ShellPairsLibint2 contains primitive pair data for all shell pairs |
| sc::ShellRotation | Compute the transformation matrices that maps a set of Cartesian functions to another set of Cartesian functions in a rotated coordinate system |
| sc::ShmMemoryGrp | The ShmMemoryGrp concrete class provides an implementation of MsgMemoryGrp |
| sc::SimpleCo | The SimpleCo abstract class describes a simple internal coordinate of a molecule |
| sc::SingleRefInfo | SingleRefInfo maintains orbital information for the single-reference case |
| sc::detail::SingletonCreationPolicy< T > | SingletonCreationPolicy is used to create Singletons |
| sc::mbptr12::Slater1D | Slater1D(k,x) = x^k exp(-a*x) |
| sc::SlaterXFunctional | Implements the Slater exchange functional |
| sc::SOBasis | A SOBasis object describes the transformation from an atomic orbital basis to a symmetry orbital basis |
| sc::SOTransform | SOTransform maintains a list of AO shells that are be used to compute the SO |
| sc::SOTransformFunction | SOTransformShell describes how an AO function contributes to an SO function in a particular SO shell |
| sc::SOTransformShell | SOTransformShell maintains a list of AO functions contribute to an SO function in a particular SO shell |
| sc::SpatialMOPairIter | SpatialMOPairIter gives the ordering of pairs of spatial orbitals |
| sc::SpatialMOPairIter_eq | SpatialMOPairIter_eq gives the ordering of same-spin and different-spin orbital pairs if both orbitals of the pairs are from the same space |
| sc::SpatialMOPairIter_neq | SpatialMOPairIter_neq gives the ordering of pairs of spatial orbitals from different spaces |
| sc::SphericalTransform | This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation |
| sc::SphericalTransformComponent | This is a base class for a container for a component of a sparse Cartesian to solid harmonic basis function transformation |
| sc::SphericalTransformIter | This iterates through the components of a SphericalTransform |
| sc::SpinMOPairIter | SpinMOPairIter iterates over pairs of spinorbitals |
| sc::SplitBasisSet | Used to split a basis set's contractions into multiple shells |
| sc::SSAccResult< T > | This associates a result datum with an accuracy |
| sc::StateIn | Restores objects that derive from SavableState |
| sc::StateInBin | Read objects written with StateOutBin |
| sc::StateInFile | Reads state information from a file |
| sc::StateInText | Reads state information written with StateOutText |
| sc::StateOut | Serializes objects that derive from SavableState |
| sc::StateOutBin | Save state to a binary file |
| sc::StateOutFile | Writes state information to files |
| sc::StateOutText | Writes out state information in an almost human readable format |
| sc::StateRecv | StateRecv is a concrete specialization of MsgStateRecv that does the receive part of point to point communication in a MessageGrp |
| sc::StateSend | StateSend is a concrete specialization of MsgStateSend that does the send part of point to point communication in a MessageGrp |
| sc::StdDenFunctional | Used to construct the standard density functionals |
| sc::StreSimpleCo | Describes an stretch internal coordinate of a molecule |
| sc::StringKeyVal | StringKeyVal is a base class for KeyVal implementations that store all values in a string format |
| sc::SumAccumH | This specialization of AccumHNull does nothing |
| sc::SumDenFunctional | The SumDenFunctional computes energies and densities using the a sum of energy density functions method |
| sc::SumIntCoor | SumIntCoor is used to construct linear combinations of internal coordinates |
| sc::SymmetryMOOrder | Order by symmetry first, then by energy |
| sc::SymmetryOperation | 3 by 3 matrix representation of a symmetry operation, such as a rotation or reflection |
| sc::SymmMolecularCoor | Derives from IntMolecularCoor |
| sc::SymmSCMatrix | Abstract base class for symmetric double valued matrices |
| sc::SymRep | N dimensional matrix representation of a symmetry operation, such as a rotation or reflection |
| sc::SyscallFailed | This is thrown when an system call fails with an errno |
| sc::SystemException | This is thrown when a system problem occurs |
| sc::Taylor_Fjt | Uses Taylor interpolation of up to 8-th order to compute the Boys function |
| sc::Thread | The Thread abstract class defines an interface which must be implemented by classes wishing to be run as threads |
| sc::ThreadGrp | The ThreadGrp abstract class provides a means to manage separate threads of control |
| sc::ThreadLock | The ThreadLock abstract class provides mutex locks to be used in conjunction with ThreadGrp's |
| sc::ThreadLockHolder | Acquire a lock on creation and release it on destruction |
| sc::TimedRegion | TimedRegion is a helper class for RegionTimer |
| sc::Timer | Uses RegionTimer to time intervals in an exception safe manner |
| sc::ToleranceExceeded | This is thrown when when some tolerance is exceeded |
| sc::TorsSimpleCo | Describes an torsion internal coordinate of a molecule |
| sc::detail::ToStateOut< T > | Helper template to save to StateOut |
| sc::detail::ToStateOut< sc::Ref< T > > | Specialization for Ref<SavableState> |
| sc::detail::ToStateOut< sc::RefDiagSCMatrix > | Specialization for RefDiagSCMatrix |
| sc::detail::ToStateOut< sc::RefSCMatrix > | Specialization for RefSCMatrix |
| sc::detail::ToStateOut< sc::RefSymmSCMatrix > | Specialization for RefSymmSCMatrix |
| sc::TranslateData | Generic data translation |
| sc::TranslateDataByteSwap | Data translation to an external representation with bytes swapped |
| sc::TranslateDataIn | Convert data from other formats |
| sc::TranslateDataOut | Convert data to other formats |
| sc::TwoBodyDerivInt | This is an abstract base type for classes that compute integrals involving two electrons |
| sc::TwoBodyDerivIntCCA | This implements two body derivative integrals through the CCA interface |
| sc::TwoBodyDerivIntCints | This implements electron repulsion derivative integrals in the IntV3 library |
| sc::TwoBodyDerivIntLibint2 | This implements electron repulsion derivative integrals in the IntV3 library |
| sc::TwoBodyDerivIntV3 | This implements electron repulsion derivative integrals in the IntV3 library |
| sc::TwoBodyFockMatrixBuilder< bra_eq_ket > | Builds the two-body part of the Fock matrix in AO basis using integral-direct algorithm |
| sc::TwoBodyFockTransformBuilder | Builds the two-body part of the Fock matrix in MO basis using AO->MO transforms |
| sc::TwoBodyGrid | Class TwoBodyGrid describes a set of coordinates of 2 particles |
| sc::TwoBodyInt | This is an abstract base type for classes that compute integrals involving two electrons and 2 functions per electron |
| sc::TwoBodyIntCCA | This implements two body integrals through the CCA interface |
| sc::TwoBodyIntCints | This implements electron repulsion integrals in the IntCints library |
| sc::TwoBodyIntDescrCreator | Creates TwoBodyIntDescr for correlation factor C |
| sc::TwoBodyIntDescrERI | TwoBodyIntDescrERI describes single set of electron repulsion integrals |
| sc::TwoBodyIntDescrG12 | TwoBodyIntDescrG12 describes a complete set of integrals used in MP2-F12 theories using Gaussian geminal correlation factors |
| sc::TwoBodyIntDescrG12DKH | TwoBodyIntDescrG12DKH describes a particular set of integrals used in Gaussian geminal-based R12 methods based on Douglas-Kroll-Hess references |
| sc::TwoBodyIntDescrG12NC | TwoBodyIntDescrG12NC describes a complete set of integrals used in MP2-F12 theories using Gaussian geminal correlation factors (without kinetic energy commutators) |
| sc::TwoBodyIntDescrGenG12 | TwoBodyIntDescrGenG12 describes a complete set of integrals used in MP2-F12 theories using general Gaussian geminal correlation factors |
| sc::TwoBodyIntDescrR12 | TwoBodyIntDescrR12 describes a complete set of integrals used in MP2-F12 theories using linear r12 correlation factor |
| sc::TwoBodyIntLibint2 | This implements electron repulsion integrals in the IntLibint2 library |
| sc::TwoBodyIntTypeDescr | Two-body integrals with n functions per particle and given symmetry properties |
| sc::TwoBodyIntV3 | This implements electron repulsion integrals in the IntV3 library |
| sc::TwoBodyMOIntsTransform | TwoBodyMOIntsTransform computes two-body integrals in MO basis using parallel integrals-direct AO->MO transformation |
| sc::TwoBodyMOIntsTransform::MOSpaces | Predefined enumerated type for the MO spaces |
| sc::TwoBodyMOIntsTransform_ijxy | TwoBodyMOIntsTransform_ijxy computes (ij|xy) integrals using parallel integrals-direct AO->MO transformation |
| sc::TwoBodyMOIntsTransform_ikjy | TwoBodyMOIntsTransform_ikjy computes (ik|jy) integrals using parallel integrals-direct AO->MO transformation |
| sc::TwoBodyMOIntsTransform_iRjS | TwoBodyMOIntsTransform_iRjS computes (iR|jS), or <ij|RS> integrals, where R and S are atomic orbitals, using parallel integral-direct AO->MO transformation |
| sc::TwoBodyMOIntsTransform_ixjy | TwoBodyMOIntsTransform_ixjy computes (ix|jy) integrals using parallel integrals-direct AO->MO transformation |
| sc::TwoBodyThreeCenterDerivInt | This is an abstract base type for classes that compute three centers integrals involving two electrons |
| sc::TwoBodyThreeCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in three Gaussian functions |
| sc::TwoBodyThreeCenterIntDescrERI | TwoBodyThreeCenterIntDescrERI describes single set of 3-center electron repulsion integrals |
| sc::TwoBodyThreeCenterIntV3 | This implements electron repulsion integrals involving three centers in the IntV3 library |
| sc::TwoBodyTwoCenterDerivInt | This is an abstract base type for classes that compute two centers integrals involving two electrons |
| sc::TwoBodyTwoCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in two Gaussian functions |
| sc::TwoBodyTwoCenterIntDescrERI | TwoBodyTwoCenterIntDescrERI describes single set of 2-center electron repulsion integrals |
| sc::TwoBodyTwoCenterIntV3 | This implements electron repulsion integrals involving two centers in the IntV3 library |
| sc::LinearR12::TwoParticleContraction | TwoParticleContraction contracts nrow-by-ncol bra- or ket-blocks of two 2-particle tensors |
| sc::UHF | This provides an unrestricted Hartree-Fock implementation |
| sc::UKS | This provides a Kohn-Sham implementation for unrestricted-orbital open-shell systems |
| sc::UncontractedBasisSet | Used to form uncontracted Gaussian basis sets |
| sc::UnionShape | A UnionShape is volume enclosed by a set of Shape's |
| sc::Units | Used to perform unit converions |
| sc::UnrestrictedSCF | A base class for unrestricted self-consistent-field methods |
| sc::VDWShape | Describes the surface of a molecule as the union of atom centered spheres, each the van der Waals radius of the atom |
| sc::Volume | A Volume is a Function of three variables |
| sc::VWN1LCFunctional | The VWN1LCFunctional computes energies and densities using the VWN1 local correlation term (from Vosko, Wilk, and Nusair) |
| sc::VWN2LCFunctional | The VWN2LCFunctional computes energies and densities using the VWN2 local correlation term (from Vosko, Wilk, and Nusair) |
| sc::VWN3LCFunctional | The VWN3LCFunctional computes energies and densities using the VWN3 local correlation term (from Vosko, Wilk, and Nusair) |
| sc::VWN4LCFunctional | The VWN4LCFunctional computes energies and densities using the VWN4 local correlation term (from Vosko, Wilk, and Nusair) |
| sc::VWN5LCFunctional | The VWN5LCFunctional computes energies and densities using the VWN5 local correlation term (from Vosko, Wilk, and Nusair) |
| sc::VWNLCFunctional | An abstract base class from which the various VWN (Vosko, Wilk and Nusair) local correlation functional (1, 2, 3, 4, 5) classes are derived |
| sc::Wavefunction | A Wavefunction is a MolecularEnergy that utilizies a GaussianBasisSet |
| sc::WriteElectronDensity | Writes the electron density at user defined grid points to the standard output or to a separate file |
| sc::WriteElectrostaticPotential | Writes the electrostatic potential at user defined grid points to the standard output or to a separate file |
| sc::WriteGrid | The abstract WriteGrid class provides an interface for writing the value of a scalar function evaluated at a given set of grid points to a file |
| sc::XalphaFunctional | Implements the Xalpha exchange functional |