Package mpqc-devel
Development headers and libraries for mpqc
This package contains the header files and static libraries needed to
build programs linked with mpqc, the scientific computing toolkit,
based on mpqc computational chemistry package from Sandia Labs.
Version: 2.3.1
See also: mpqc.
General Commands | |
| sc-config | The sc-config program is used to obtain information about MPQC's compile time environment. |
| sc-libtool | The sc-libtool program is used to link and build MPQC executables and libraries. |
| sc-mkf77sym | The sc-mkf77sym program is used to generate symbols for linking FORTRAN subroutines into MPQC. |
Library Functions | |
| sc_ALevelShift | sc::ALevelShift |
| sc_ARMCIMemoryGrp | The ARMCIMemoryGrp concrete class provides an implementation of MsgMemoryGrp. |
| sc_AVLMap | sc::AVLMap< K, T > |
| sc_AVLMapNode | sc::AVLMapNode< K, T > |
| sc_AVLMap_iterator | sc::AVLMap< K, T >::iterator |
| sc_AVLSet | sc::AVLSet< K > |
| sc_AVLSet_iterator | sc::AVLSet< K >::iterator |
| sc_AccResult | 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_AccumEffectiveH | sc::AccumEffectiveH |
| sc_AccumH | sc::AccumH |
| sc_AccumHNull | sc::AccumHNull |
| 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_AngularIntegrator | An abstract base class for angular integrators. |
| sc_AnimatedObject | sc::AnimatedObject |
| sc_Appearance | sc::Appearance |
| sc_AssignedKeyVal | This class allows keyval associations to be set up by the program, rather than determined by an external file. |
| sc_AtomInfo | The AtomInfo class provides information about atoms. |
| sc_AtomProximityColorizer | sc::AtomProximityColorizer |
| sc_BEMSolvent | sc::BEMSolvent |
| sc_BEMSolventH | sc::BEMSolventH |
| sc_BFGSUpdate | The DFPUpdate class is used to specify a Broyden, Fletcher, Goldfarb, and Shanno hessian update scheme. |
| sc_BLevelShift | sc::BLevelShift |
| sc_Backtrack | sc::Backtrack |
| sc_BasisFileSet | sc::BasisFileSet |
| 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_BendSimpleCo | The BendSimpleCo class describes an bend internal coordinate of a molecule. |
| sc_BiggestContribs | sc::BiggestContribs |
| sc_BitArrayLTri | sc::BitArrayLTri |
| sc_BlockedDiagSCMatrix | sc::BlockedDiagSCMatrix |
| sc_BlockedSCElementOp | sc::BlockedSCElementOp |
| sc_BlockedSCElementOp2 | sc::BlockedSCElementOp2 |
| sc_BlockedSCElementOp3 | sc::BlockedSCElementOp3 |
| sc_BlockedSCMatrix | sc::BlockedSCMatrix |
| sc_BlockedSCMatrixKit | sc::BlockedSCMatrixKit |
| sc_BlockedSCVector | sc::BlockedSCVector |
| sc_BlockedSymmSCMatrix | sc::BlockedSymmSCMatrix |
| sc_BuildIntV3 | sc::BuildIntV3 |
| sc_CCAEnv | The CCAEnv class handles embedded CCA frameworks. |
| sc_CLHF | CLHF is a Hartree-Fock specialization of CLSCF. |
| sc_CLKS | This provides a Kohn-Sham implementation for closed-shell systems. |
| sc_CLSCF | The CLSCF class is a base for classes implementing a self-consistent procedure for closed-shell molecules. |
| sc_CS2Sphere | sc::CS2Sphere |
| sc_CSGrad34Qbtr | sc::CSGrad34Qbtr |
| sc_CSGradErep12Qtr | sc::CSGradErep12Qtr |
| sc_CSGradS2PDM | sc::CSGradS2PDM |
| sc_CartMolecularCoor | The CartMolecularCoor class implements Cartesian coordinates in a way suitable for use in geometry optimizations. |
| sc_CartesianIter | CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization. |
| sc_CartesianIterCCA | sc::CartesianIterCCA |
| sc_CartesianIterCints | sc::CartesianIterCints |
| sc_CartesianIterV3 | sc::CartesianIterV3 |
| sc_CharacterTable | The CharacterTable class provides a workable character table for all of the non-cubic point groups. |
| sc_ClassDesc | This class is used to contain information about classes. |
| sc_Color | sc::Color |
| sc_Compute | The Compute class provides a means of keeping results up to date. |
| sc_ConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result. |
| sc_Convergence | The Convergence class is used by the optimizer to determine when an optimization is converged. |
| sc_CorrelationTable | The CorrelationTable class provides a correlation table between two point groups. |
| sc_DFPUpdate | The DFPUpdate class is used to specify a Davidson, Fletcher, and Powell hessian update scheme. |
| sc_DIIS | The DIIS class provides DIIS extrapolation. |
| sc_Debugger | The Debugger class describes what should be done when a catastrophic error causes unexpected program termination. |
| sc_DenFunctional | An abstract base class for density functionals. |
| sc_DenIntegrator | An abstract base class for integrating the electron density. |
| sc_DensityColorizer | sc::DensityColorizer |
| 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 | sc::DescribedClassProxy |
| sc_DescribedMemberDatum | sc::DescribedMemberDatum< T, C > |
| 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_DiagSCMatrixdouble | sc::DiagSCMatrixdouble |
| sc_DipoleData | sc::DipoleData |
| sc_DipoleIntV3 | sc::DipoleIntV3 |
| sc_DiscreteConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result. |
| sc_DistDiagSCMatrix | sc::DistDiagSCMatrix |
| sc_DistSCMatrix | sc::DistSCMatrix |
| sc_DistSCMatrixKit | The DistSCMatrixKit produces matrices that work in a many processor environment. |
| sc_DistSCMatrixListSubblockIter | sc::DistSCMatrixListSubblockIter |
| sc_DistSCVector | sc::DistSCVector |
| 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_DistSymmSCMatrix | sc::DistSymmSCMatrix |
| sc_EAVLMMap | sc::EAVLMMap< K, T > |
| sc_EAVLMMapNode | sc::EAVLMMapNode< K, T > |
| sc_EAVLMMap_iterator | sc::EAVLMMap< K, T >::iterator |
| sc_EFCOpt | The EFCOpt class implements eigenvector following as described by Baker in J. |
| sc_Edge | sc::Edge |
| sc_EfieldDotVectorData | sc::EfieldDotVectorData |
| sc_EfieldDotVectorIntV3 | sc::EfieldDotVectorIntV3 |
| sc_ElectronDensity | This is a Volume that computer the electron density. |
| sc_EriCints | EriCints is a specialization of Int2eCints that computes electron repulsion integrals. |
| sc_EulerMaclaurinRadialIntegrator | An implementation of a radial integrator using the Euler-Maclaurin weights and grid points. |
| sc_ExEnv | The ExEnv class is used to find out about how the program is being run. |
| sc_ExtendedHuckelWfn | sc::ExtendedHuckelWfn |
| sc_ExtentData | sc::ExtentData |
| sc_FJT | sc::FJT |
| sc_FeatureNotImplemented | This is thrown when an attempt is made to use a feature that is not yet implemented. |
| 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_FileRender | sc::FileRender |
| sc_FinDispMolecularHessian | Computes the molecular hessian by finite displacements of gradients. |
| sc_ForceLink | This, together with ForceLinkBase, is used to force code for particular classes to be linked into executables. |
| sc_ForceLinkBase | This, together with ForceLink, is used to force code for particular classes to be linked into executables. |
| sc_FreeData | sc::FreeData |
| sc_Function | The Function class is an abstract base class that, given a set of coordinates, will compute a value and possibly a gradient and hessian at that point. |
| sc_G96XFunctional | Implements the Gill 1996 (G96) exchange functional. |
| sc_GBuild | sc::GBuild< T > |
| sc_GDIISOpt | sc::GDIISOpt |
| sc_GPetite4 | This class provides a generalized four index petite list. |
| sc_GRTCints | GRTCints is a specialization of Int2eCints that computes two-electron integrals specific to linear R12 methods. |
| sc_GSGeneralEffH | sc::GSGeneralEffH |
| sc_GSHighSpinEffH | sc::GSHighSpinEffH |
| sc_GaussLegendreAngularIntegrator | An implementation of an angular integrator using the Gauss-Legendre weights and grid points. |
| sc_GaussTriangleIntegrator | sc::GaussTriangleIntegrator |
| sc_GaussianBasisSet | The GaussianBasisSet class is used describe a basis set composed of atomic gaussian orbitals. |
| sc_GaussianBasisSet_ValueData | This holds scratch data needed to compute basis function values. |
| sc_GaussianShell | A Gaussian orbital shell. |
| sc_GenPetite4 | This class is an abstract base to a generalized four index petite list. |
| sc_GetLongOpt | sc::GetLongOpt |
| sc_GlobalCounter | sc::GlobalCounter |
| sc_GlobalMsgIter | sc::GlobalMsgIter |
| sc_GradDensityColorizer | sc::GradDensityColorizer |
| sc_GrpArithmeticAndReduce | sc::GrpArithmeticAndReduce< T > |
| sc_GrpArithmeticOrReduce | sc::GrpArithmeticOrReduce< T > |
| sc_GrpArithmeticXOrReduce | sc::GrpArithmeticXOrReduce< T > |
| sc_GrpFunctionReduce | sc::GrpFunctionReduce< T > |
| sc_GrpMaxReduce | sc::GrpMaxReduce< T > |
| sc_GrpMinReduce | sc::GrpMinReduce< T > |
| sc_GrpProductReduce | sc::GrpProductReduce< T > |
| sc_GrpReduce | sc::GrpReduce< T > |
| sc_GrpSumReduce | sc::GrpSumReduce< T > |
| sc_GuessMolecularHessian | GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates. |
| sc_HCoreWfn | sc::HCoreWfn |
| sc_HSOSHF | HSOSHF is a Hartree-Fock specialization of HSOSSCF. |
| sc_HSOSKS | This provides a Kohn-Sham implementation for restricted-orbital high-spin open-shell systems. |
| sc_HSOSSCF | The HSOSSCF class is a base for classes implementing a self-consistent procedure for high-spin open-shell molecules. |
| sc_HSOSV1Erep1Qtr | sc::HSOSV1Erep1Qtr |
| sc_HessianUpdate | The HessianUpdate abstract class is used to specify a hessian update scheme. |
| sc_HypercubeGMI | sc::HypercubeGMI |
| sc_HypercubeTopology | sc::HypercubeTopology |
| sc_IPV2 | sc::IPV2 |
| sc_ISphericalTransform | This describes a solid harmonic to Cartesian transform. |
| sc_ISphericalTransformCCA | sc::ISphericalTransformCCA |
| sc_ISphericalTransformCints | sc::ISphericalTransformCints |
| sc_ISphericalTransformV3 | sc::ISphericalTransformV3 |
| 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_ImplicitSurfacePolygonizer | sc::ImplicitSurfacePolygonizer |
| sc_InputError | This is thrown when invalid input is provided. |
| sc_Int1eCCA | Int1eCCA adapts CCA integrals components for use within SC. |
| sc_Int1eCints | Int1eCints is used by OneBodyIntCints and OneBodyDerivIntCints to implement IntegralCints. |
| sc_Int1eV3 | Int1eV3 is a class wrapper for the one body part of the C language IntV3 library. |
| sc_Int2eCCA | Int2eCCA adapts CCA integrals components for use within SC. |
| sc_Int2eCints | Int2eCints is an interface to various specializations of two-electron integral evaluators implemented in Cints. |
| sc_Int2eV3 | Int2eV3 is a class wrapper for the two body part of the C language IntV3 library. |
| sc_Int2eV3_store_list | sc::Int2eV3::store_list |
| 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_IntMolecularCoor | The IntMolecularCoor abstract class describes a molecule's coordinates in terms of internal coordinates. |
| sc_IntV3Arraydouble2 | sc::IntV3Arraydouble2 |
| sc_IntV3Arraydouble3 | sc::IntV3Arraydouble3 |
| sc_IntV3Arraydoublep2 | sc::IntV3Arraydoublep2 |
| sc_IntV3Arraydoublep3 | sc::IntV3Arraydoublep3 |
| sc_IntV3Arraydoublep4 | sc::IntV3Arraydoublep4 |
| sc_IntV3Arrayint3 | sc::IntV3Arrayint3 |
| sc_IntV3Arrayint4 | sc::IntV3Arrayint4 |
| 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_IntegralKey | sc::IntegralKey |
| sc_IntegralLink | sc::IntegralLink |
| sc_IntegralStorer | sc::IntegralStorer |
| sc_IntegralV3 | IntegralV3 computes integrals between Gaussian basis functions. |
| sc_IntegrationWeight | An abstract base class for computing grid weights. |
| sc_IrreducibleRepresentation | The IrreducibleRepresentation class provides information associated with a particular irreducible representation of a point group. |
| sc_IsosurfaceGen | sc::IsosurfaceGen |
| sc_KeyVal | The KeyVal class is designed to simplify the process of allowing a user to specify keyword/value associations to a C++ program. |
| sc_KeyValValue | sc::KeyValValue |
| sc_KeyValValueRefDescribedClass | sc::KeyValValueRefDescribedClass |
| sc_KeyValValueString | sc::KeyValValueString |
| sc_KeyValValueboolean | sc::KeyValValueboolean |
| sc_KeyValValuechar | sc::KeyValValuechar |
| sc_KeyValValuedouble | sc::KeyValValuedouble |
| sc_KeyValValuefloat | sc::KeyValValuefloat |
| sc_KeyValValueint | sc::KeyValValueint |
| sc_KeyValValuepchar | sc::KeyValValuepchar |
| sc_KeyValValuesize | sc::KeyValValuesize |
| sc_KeyValValuestring | sc::KeyValValuestring |
| sc_LSDACFunctional | An abstract base class for local correlation functionals. |
| sc_LYPCFunctional | Implements the Lee, Yang, and Parr functional. |
| sc_LebedevLaikovIntegrator | An implementation of a Lebedev angular integrator. |
| sc_LevelShift | sc::LevelShift |
| sc_LibintStaticInterface | sc::LibintStaticInterface |
| sc_Libr12StaticInterface | sc::Libr12StaticInterface |
| sc_LimitExceeded | This is thrown when a limit is exceeded. |
| sc_LinIPSimpleCo | The LinIPSimpleCo class describes an in-plane component of a linear bend internal coordinate of a molecule. |
| sc_LinOPSimpleCo | The LinOPSimpleCo class describes an out-of-plane component of a linear bend internal coordinate of a molecule. |
| sc_LineOpt | The LineOpt abstract class is used to perform one dimensional optimizations. |
| sc_LocalCLHFContribution | sc::LocalCLHFContribution |
| sc_LocalCLHFEnergyContribution | sc::LocalCLHFEnergyContribution |
| sc_LocalCLHFGradContribution | sc::LocalCLHFGradContribution |
| sc_LocalCLKSContribution | sc::LocalCLKSContribution |
| sc_LocalCLKSEnergyContribution | sc::LocalCLKSEnergyContribution |
| sc_LocalDiagSCMatrix | sc::LocalDiagSCMatrix |
| sc_LocalGBuild | sc::LocalGBuild< T > |
| sc_LocalHSOSContribution | LocalHSOSContribution |
| sc_LocalHSOSEnergyContribution | LocalHSOSEnergyContribution |
| sc_LocalHSOSGradContribution | LocalHSOSGradContribution |
| sc_LocalHSOSKSContribution | sc::LocalHSOSKSContribution |
| sc_LocalHSOSKSEnergyContribution | sc::LocalHSOSKSEnergyContribution |
| sc_LocalLBGBuild | sc::LocalLBGBuild< T > |
| sc_LocalOSSContribution | sc::LocalOSSContribution |
| sc_LocalOSSEnergyContribution | sc::LocalOSSEnergyContribution |
| sc_LocalOSSGradContribution | sc::LocalOSSGradContribution |
| sc_LocalSCMatrix | sc::LocalSCMatrix |
| sc_LocalSCMatrixKit | The LocalSCMatrixKit produces matrices that work in a single processor environment. |
| sc_LocalSCVector | sc::LocalSCVector |
| sc_LocalSymmSCMatrix | sc::LocalSymmSCMatrix |
| sc_LocalTBGrad | sc::LocalTBGrad< T > |
| sc_LocalTCContribution | sc::LocalTCContribution |
| sc_LocalTCEnergyContribution | sc::LocalTCEnergyContribution |
| sc_LocalTCGradContribution | sc::LocalTCGradContribution |
| sc_LocalUHFContribution | sc::LocalUHFContribution |
| sc_LocalUHFEnergyContribution | sc::LocalUHFEnergyContribution |
| sc_LocalUHFGradContribution | sc::LocalUHFGradContribution |
| sc_LocalUKSContribution | sc::LocalUKSContribution |
| sc_LocalUKSEnergyContribution | sc::LocalUKSEnergyContribution |
| sc_MBPT2 | The MBPT2 class implements several second-order perturbation theory methods. |
| sc_MBPT2_R12 | The MBPT2_R12 class implements several linear R12 second-order perturbation theory methods. |
| sc_MCSearch | This performs line searches with cubic steps. |
| sc_MOIndexSpace | Class MOIndexSpace describes a range of molecular orbitals or similar objects that are linear combinations of basis functions (e.g. |
| sc_MOIntsTransformFactory | MOIntsTransformFactory is a factory that produces MOIntsTransform objects. |
| sc_MOLagrangian | sc::MOLagrangian |
| sc_MOPairIter | MOPairIter gives the ordering of orbital pairs. |
| sc_MOPairIterFactory | This class produces MOPairIter objects. |
| sc_MP2BasisExtrap | sc::MP2BasisExtrap |
| sc_MP2R12Energy | Class MP2R12Energy is the object that computes and maintains MP2-R12 energies. |
| sc_MPIMessageGrp | The MPIMessageGrp class is an concrete implementation of MessageGrp that uses the MPI 1 library. |
| sc_MPQC_CartesianIterCCA | MPQC::CartesianIterCCA |
| sc_MTMPIMemoryGrp | This MemoryGrp class requires a MT-safe MPI implementation. |
| sc_MachineTopology | sc::MachineTopology |
| sc_Material | sc::Material |
| sc_MaxIterExceeded | This is thrown when an iterative algorithm attempts to use more iterations than allowed. |
| sc_MemAllocFailed | This is thrown when a memory allocation fails. |
| sc_MemoryDataRequest | sc::MemoryDataRequest |
| sc_MemoryDataRequestQueue | sc::MemoryDataRequestQueue |
| sc_MemoryGrp | The MemoryGrp abstract class provides a way of accessing distributed memory in a parallel machine. |
| sc_MemoryGrpBuf | The MemoryGrpBuf class provides access to pieces of the global shared memory that have been obtained with MemoryGrp. |
| sc_MemoryIter | sc::MemoryIter |
| sc_MessageGrp | The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine. |
| sc_MolEnergyConvergence | sc::MolEnergyConvergence |
| sc_MolFreqAnimate | sc::MolFreqAnimate |
| 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_MolecularFormula | The MolecularFormula class is used to calculate the molecular formula of a Molecule. |
| sc_MolecularFrequencies | The MolecularFrequencies class is 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_Molecule | The Molecule class contains information about molecules. |
| sc_MoleculeColorizer | sc::MoleculeColorizer |
| 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_NCAccResult | This associates a result non-class datum with an accuracy. |
| sc_NCResult | This is similar to Result, but can be used with non-class types. |
| sc_NElFunctional | The NElFunctional computes the number of electrons. |
| sc_NewP86CFunctional | sc::NewP86CFunctional |
| sc_NewtonOpt | sc::NewtonOpt |
| sc_NonlinearTransform | The NonlinearTransform class transforms between two nonlinear coordinate systems. |
| sc_NonreentrantUncappedTorusHoleShape | sc::NonreentrantUncappedTorusHoleShape |
| sc_OOGLRender | sc::OOGLRender |
| sc_OSSHF | sc::OSSHF |
| sc_OSSSCF | sc::OSSSCF |
| sc_OneBody3IntOp | sc::OneBody3IntOp |
| sc_OneBodyDerivInt | OneBodyDerivInt is an abstract base class for objects that compute one body derivative integrals. |
| sc_OneBodyDerivIntCCA | This implements one body derivative integrals. |
| sc_OneBodyDerivIntV3 | This implements one body derivative integrals in the IntV3 library. |
| 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_OneBodyIntIter | sc::OneBodyIntIter |
| sc_OneBodyIntOp | sc::OneBodyIntOp |
| 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_OneBodyOneCenterWrapper | sc::OneBodyOneCenterWrapper |
| sc_OneBodySOInt | sc::OneBodySOInt |
| sc_OneBodyWavefunction | A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem. |
| sc_Optimize | The Optimize class is an abstract base class for classes that find the extreme points of Function's. |
| sc_Orbital | sc::Orbital |
| sc_OutSimpleCo | sc::OutSimpleCo |
| sc_OverlapOrthog | This class computes the orthogonalizing transform for a basis set. |
| sc_P86CFunctional | Implements the Perdew 1986 (P86) correlation functional. |
| sc_PBECFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional. |
| sc_PBEXFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional. |
| 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_ParallelRegionTimer | sc::ParallelRegionTimer |
| sc_Parameter | sc::Parameter< T > |
| 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_PetiteList | sc::PetiteList |
| sc_PointChargeData | sc::PointChargeData |
| sc_PointChargeIntV3 | sc::PointChargeIntV3 |
| sc_PointGroup | The PointGroup class is really a place holder for a CharacterTable. |
| sc_PointInputData | Contains data needed at each point by a DenFunctional. |
| sc_PointInputData_SpinData | sc::PointInputData::SpinData |
| sc_PointOutputData | Contains data generated at each point by a DenFunctional. |
| sc_Pool | sc::Pool |
| sc_PoolData | sc::PoolData |
| sc_PowellUpdate | The PowellUpdate class is used to specify a Powell hessian update. |
| sc_PrefixKeyVal | PrefixKeyVal is a KeyVal that searches a different KeyVal using modified keys. |
| sc_PrimPairsCints | PrimPairsCints 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 | The ProcThreadGrp class 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_PsiCCSD | PsiCCSD is a concrete implementation of Psi CCSD wave function. |
| 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_PsiEffH | sc::PsiEffH |
| 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 | The PthreadThreadGrp class privides a concrete thread group appropriate for an environment where pthreads is available. |
| sc_PumaThreadGrp | The PumaThreadGrp class privides a concrete thread group appropriate for the intel teraflops machine. |
| sc_QNewtonOpt | The QNewtonOpt implements a quasi-Newton optimization scheme. |
| sc_R12Amplitudes | R12Amplitudes gives the amplitudes of some linear-R12-ansatz-related terms in wave function. |
| 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_R12IntsAcc | R12IntsAcc accumulates transformed (MO) integrals stored as (ijxy) where i, j, x, and, y lie in spaces I, J, X, and Y, respectively. |
| sc_R12IntsAcc_MPIIOFile | sc::R12IntsAcc_MPIIOFile |
| sc_R12IntsAcc_MPIIOFile_Ind | sc::R12IntsAcc_MPIIOFile_Ind |
| sc_R12IntsAcc_MPIIOFile_PairBlkInfo | sc::R12IntsAcc_MPIIOFile::PairBlkInfo |
| sc_R12IntsAcc_MemoryGrp | sc::R12IntsAcc_MemoryGrp |
| sc_R12IntsAcc_Node0File | sc::R12IntsAcc_Node0File |
| sc_RDMAMemoryGrp | The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp class. |
| 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_RangeLock | sc::RangeLock |
| sc_RangeLockItem | sc::RangeLockItem |
| sc_ReadMolecularHessian | ReadMolecularHessian is an implementation of MolecularHessian that reads the hessian from a file. |
| sc_RedundMolecularCoor | The RedundMolecularCoor class provides a redundant set of simple internal coordinates. |
| sc_RedundantCartesianIter | RedundantCartesianIter objects loop through all possible combinations of a given number of axes. |
| sc_RedundantCartesianIterCCA | sc::RedundantCartesianIterCCA |
| sc_RedundantCartesianIterCints | sc::RedundantCartesianIterCints |
| sc_RedundantCartesianIterV3 | sc::RedundantCartesianIterV3 |
| sc_RedundantCartesianSubIter | Like RedundantCartesianIter, except a, b, and c are fixed to a given value. |
| sc_RedundantCartesianSubIterCCA | sc::RedundantCartesianSubIterCCA |
| sc_RedundantCartesianSubIterCints | sc::RedundantCartesianSubIterCints |
| sc_RedundantCartesianSubIterV3 | sc::RedundantCartesianSubIterV3 |
| sc_ReentrantUncappedTorusHoleShape | sc::ReentrantUncappedTorusHoleShape |
| sc_Ref | 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 | The RefDiagSCMatrix class is a smart pointer to an DiagSCMatrix specialization. |
| sc_RefSCDimension | The RefSCDimension class is a smart pointer to an SCDimension specialization. |
| sc_RefSCMatrix | The RefSCMatrix class is a smart pointer to an SCMatrix specialization. |
| sc_RefSCVector | The RefSCVector class is a smart pointer to an SCVector specialization. |
| sc_RefSymmSCMatrix | The RefSymmSCMatrix class is a smart pointer to an SCSymmSCMatrix specialization. |
| sc_RegionTimer | The RegionTimer class is used to record the time spent in a section of code. |
| sc_Render | sc::Render |
| sc_RenderedBallMolecule | sc::RenderedBallMolecule |
| sc_RenderedMolecularSurface | sc::RenderedMolecularSurface |
| sc_RenderedMolecule | sc::RenderedMolecule |
| sc_RenderedObject | sc::RenderedObject |
| sc_RenderedObjectSet | sc::RenderedObjectSet |
| sc_RenderedPolygons | sc::RenderedPolygons |
| sc_RenderedPolylines | sc::RenderedPolylines |
| sc_RenderedSphere | sc::RenderedSphere |
| sc_RenderedStickMolecule | sc::RenderedStickMolecule |
| sc_ReplDiagSCMatrix | sc::ReplDiagSCMatrix |
| sc_ReplSCMatrix | sc::ReplSCMatrix |
| sc_ReplSCMatrixKit | The ReplSCMatrixKit produces matrices that work in a many processor environment. |
| sc_ReplSCMatrixListSubblockIter | sc::ReplSCMatrixListSubblockIter |
| sc_ReplSCVector | sc::ReplSCVector |
| sc_ReplSymmSCMatrix | sc::ReplSymmSCMatrix |
| sc_Result | 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_SCBlockInfo | SCBlockInfo contains blocking information for the SCDimension class. |
| sc_SCDestructiveElementProduct | sc::SCDestructiveElementProduct |
| sc_SCDimension | The SCDimension class is used to determine the size and blocking of matrices. |
| sc_SCElementAccumulateDiagSCMatrix | sc::SCElementAccumulateDiagSCMatrix |
| sc_SCElementAccumulateSCMatrix | sc::SCElementAccumulateSCMatrix |
| sc_SCElementAccumulateSCVector | sc::SCElementAccumulateSCVector |
| sc_SCElementAccumulateSymmSCMatrix | sc::SCElementAccumulateSymmSCMatrix |
| sc_SCElementAssign | sc::SCElementAssign |
| sc_SCElementDot | sc::SCElementDot |
| sc_SCElementInvert | sc::SCElementInvert |
| sc_SCElementKNorm | Computed k-norm of matrix. |
| sc_SCElementMaxAbs | sc::SCElementMaxAbs |
| sc_SCElementMinAbs | sc::SCElementMinAbs |
| sc_SCElementOp | Objects of class SCElementOp are used to perform operations on the elements of matrices. |
| sc_SCElementOp2 | The SCElementOp2 class is very similar to the SCElementOp class except that pairs of blocks are treated simultaneously. |
| sc_SCElementOp3 | The SCElementOp3 class is very similar to the SCElementOp class except that a triplet of blocks is treated simultaneously. |
| sc_SCElementRandomize | sc::SCElementRandomize |
| sc_SCElementScalarProduct | sc::SCElementScalarProduct |
| sc_SCElementScale | sc::SCElementScale |
| sc_SCElementScaleDiagonal | sc::SCElementScaleDiagonal |
| sc_SCElementShiftDiagonal | sc::SCElementShiftDiagonal |
| sc_SCElementSquareRoot | sc::SCElementSquareRoot |
| sc_SCElementSumAbs | sc::SCElementSumAbs |
| 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 | The SCF class is the base for all classes that use a self-consistent field procedure to solve an effective one body problem. |
| sc_SCFEnergy | sc::SCFEnergy |
| sc_SCFormIO | This utility class is used to print only on node 0 and to provide attractive indentation of output. |
| sc_SCMatrix | The SCMatrix class is the abstract base class for general double valued n by m matrices. |
| sc_SCMatrix3 | sc::SCMatrix3 |
| sc_SCMatrixBlock | SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors. |
| sc_SCMatrixBlockIter | The SCMatrixBlockIter class is used to described iterates that loop through the elements in a block. |
| sc_SCMatrixBlockList | sc::SCMatrixBlockList |
| sc_SCMatrixBlockListIter | sc::SCMatrixBlockListIter |
| sc_SCMatrixBlockListLink | sc::SCMatrixBlockListLink |
| sc_SCMatrixCompositeSubblockIter | sc::SCMatrixCompositeSubblockIter |
| sc_SCMatrixDiagBlock | The SCMatrixDiagBlock describes a diagonal piece of a matrix. |
| sc_SCMatrixDiagBlockIter | sc::SCMatrixDiagBlockIter |
| sc_SCMatrixDiagSubBlock | The SCMatrixDiagSubBlock describes a diagonal subblock of a matrix. |
| sc_SCMatrixDiagSubBlockIter | sc::SCMatrixDiagSubBlockIter |
| sc_SCMatrixJointSubblockIter | sc::SCMatrixJointSubblockIter |
| 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_SCMatrixLTriBlockIter | sc::SCMatrixLTriBlockIter |
| sc_SCMatrixLTriSubBlock | The SCMatrixLTriSubBlock describes a triangular subblock of a matrix. |
| sc_SCMatrixLTriSubBlockIter | sc::SCMatrixLTriSubBlockIter |
| sc_SCMatrixListSubblockIter | sc::SCMatrixListSubblockIter |
| sc_SCMatrixNullSubblockIter | sc::SCMatrixNullSubblockIter |
| sc_SCMatrixRectBlock | The SCMatrixRectBlock describes a rectangular piece of a matrix. |
| sc_SCMatrixRectBlockIter | sc::SCMatrixRectBlockIter |
| sc_SCMatrixRectSubBlock | The SCMatrixRectSubBlock describes a rectangular piece of a matrix. |
| sc_SCMatrixRectSubBlockIter | sc::SCMatrixRectSubBlockIter |
| sc_SCMatrixSimpleSubblockIter | sc::SCMatrixSimpleSubblockIter |
| sc_SCMatrixSubblockIter | Objects of class SCMatrixSubblockIter are used to iterate through the blocks of a matrix. |
| sc_SCMatrixdouble | sc::SCMatrixdouble |
| sc_SCVector | The SCVector class is the abstract base class for double valued vectors. |
| sc_SCVector3 | sc::SCVector3 |
| sc_SCVectorSimpleBlock | The SCVectorSimpleBlock describes a piece of a vector. |
| sc_SCVectorSimpleBlockIter | sc::SCVectorSimpleBlockIter |
| sc_SCVectorSimpleSubBlock | The SCVectorSimpleSubBlock describes a subblock of a vector. |
| sc_SCVectorSimpleSubBlockIter | sc::SCVectorSimpleSubBlockIter |
| sc_SCVectordouble | sc::SCVectordouble |
| sc_SO | sc::SO |
| 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_SO_block | sc::SO_block |
| sc_SSAccResult | This associates a result datum with an accuracy. |
| sc_SavableState | Base class for objects that can save/restore state. |
| sc_SavableStateProxy | Create a proxy for a SavableState object. |
| sc_ScaledTorsSimpleCo | The ScaledTorsSimpleCo class describes an scaled torsion internal coordinate of a molecule. |
| sc_SelfConsistentExtrapolation | The SelfConsistentExtrapolation abstract class is used to iteratively solve equations requiring a self consistent solution, such as,. |
| sc_SetIntCoor | The SetIntCoor class describes a set of internal coordinates. |
| sc_Shape | A Shape is a Volume represents an 3D solid. |
| sc_ShellExtent | sc::ShellExtent |
| sc_ShellPairCints | ShellPairCints provides all primitive pair data for a given shell pair. |
| sc_ShellPairIter | sc::ShellPairIter |
| sc_ShellPairsCints | ShellPairsCints contains primitive pair data for all shell pairs. |
| sc_ShellQuartetIter | sc::ShellQuartetIter |
| 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_ShmMessageGrp | The ShmMessageGrp class is an implementation of MessageGrp that allows multiple process to be started that communicate with shared memory. |
| sc_SimpleCo | The SimpleCo abstract class describes a simple internal coordinate of a molecule. |
| sc_SlaterXFunctional | Implements the Slater exchange functional. |
| 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_SphereShape | sc::SphereShape |
| sc_SphericalTransform | This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation. |
| sc_SphericalTransformCCA | sc::SphericalTransformCCA |
| sc_SphericalTransformCints | sc::SphericalTransformCints |
| sc_SphericalTransformComponent | This is a base class for a container for a component of a sparse Cartesian to solid harmonic basis function transformation. |
| sc_SphericalTransformComponentCCA | sc::SphericalTransformComponentCCA |
| sc_SphericalTransformComponentCints | sc::SphericalTransformComponentCints |
| sc_SphericalTransformComponentV3 | sc::SphericalTransformComponentV3 |
| sc_SphericalTransformIter | This iterates through the components of a SphericalTransform. |
| sc_SphericalTransformV3 | sc::SphericalTransformV3 |
| sc_Stack | sc::Stack< T > |
| sc_StateClassData | sc::StateClassData |
| sc_StateIn | Restores objects that derive from SavableState. |
| sc_StateInBin | Read objects written with StateOutBin. |
| sc_StateInData | sc::StateInData |
| 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_StateOutData | sc::StateOutData |
| 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 | The StdDenFunctional class is used to construct the standard density functionals. |
| sc_SteepestDescentOpt | sc::SteepestDescentOpt |
| sc_StreSimpleCo | The StreSimpleCo class 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 | sc::SumAccumH |
| 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_SumMolecularEnergy | sc::SumMolecularEnergy |
| sc_SymRep | The SymRep class provides an n dimensional matrix representation of a symmetry operation, such as a rotation or reflection. |
| sc_SymmMolecularCoor | The SymmMolecularCoor class derives from IntMolecularCoor. |
| sc_SymmOneBodyIntIter | sc::SymmOneBodyIntIter |
| sc_SymmSCMatrix | The SymmSCMatrix class is the abstract base class for symmetric double valued matrices. |
| sc_SymmSCMatrix2SCExtrapData | sc::SymmSCMatrix2SCExtrapData |
| sc_SymmSCMatrix4SCExtrapData | sc::SymmSCMatrix4SCExtrapData |
| sc_SymmSCMatrixNSCExtrapData | sc::SymmSCMatrixNSCExtrapData |
| sc_SymmSCMatrixSCExtrapData | sc::SymmSCMatrixSCExtrapData |
| sc_SymmSCMatrixSCExtrapError | sc::SymmSCMatrixSCExtrapError |
| sc_SymmSCMatrixdouble | sc::SymmSCMatrixdouble |
| sc_SymmTwoBodyIntIter | sc::SymmTwoBodyIntIter |
| sc_SymmetryOperation | The SymmetryOperation class provides a 3 by 3 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_TBGrad | sc::TBGrad< T > |
| sc_TCHF | sc::TCHF |
| sc_TCPClientConnection | TCPClientConnection |
| sc_TCPIOSocket | TCPIOSocket |
| sc_TCPServerConnection | TCPServerConnection |
| sc_TCPServerSocket | TCPServerSocket |
| sc_TCPSocket | TCPSocket |
| sc_TCSCF | sc::TCSCF |
| sc_TaylorMolecularEnergy | sc::TaylorMolecularEnergy |
| sc_Taylor_Fjt_Eval | Taylor_Fjt_Eval |
| sc_TestEffH | sc::TestEffH |
| 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 | sc::TimedRegion |
| sc_Timer | The Timer class uses RegionTimer to time intervals in an exception safe manner. |
| sc_ToleranceExceeded | This is thrown when when some tolerance is exceeded. |
| sc_TorsSimpleCo | The TorsSimpleCo class describes an torsion internal coordinate of a molecule. |
| sc_Transform | sc::Transform |
| 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_TriInterpCoef | sc::TriInterpCoef |
| sc_TriInterpCoefKey | sc::TriInterpCoefKey |
| sc_Triangle | sc::Triangle |
| sc_TriangleIntegrator | sc::TriangleIntegrator |
| sc_TriangulatedImplicitSurface | sc::TriangulatedImplicitSurface |
| sc_TriangulatedSurface | sc::TriangulatedSurface |
| sc_TriangulatedSurfaceIntegrator | sc::TriangulatedSurfaceIntegrator |
| 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_TwoBodyDerivIntV3 | This implements electron repulsion derivative integrals in the IntV3 library. |
| 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. |
| sc_TwoBodyIntCCA | This implements two body integrals through the CCA interface. |
| sc_TwoBodyIntCints | This implements electron repulsion integrals in the IntCints library. |
| sc_TwoBodyIntIter | sc::TwoBodyIntIter |
| 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_123Inds | sc::TwoBodyMOIntsTransform_123Inds |
| sc_TwoBodyMOIntsTransform_12Inds | sc::TwoBodyMOIntsTransform_12Inds |
| sc_TwoBodyMOIntsTransform_13Inds | sc::TwoBodyMOIntsTransform_13Inds |
| 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_ixjy | TwoBodyMOIntsTransform_ixjy computes (ix|jy) integrals using parallel integrals-direct AO->MO transformation. |
| sc_TwoBodySOInt | sc::TwoBodySOInt |
| 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_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_TwoBodyTwoCenterIntV3 | This implements electron repulsion integrals involving two centers in the IntV3 library. |
| sc_UHF | This provides an unrestricted Hartree-Fock implementation. |
| sc_UKS | This provides a Kohn-Sham implementation for unrestricted-orbital open-shell systems. |
| sc_Uncapped5SphereExclusionShape | sc::Uncapped5SphereExclusionShape |
| sc_UncappedTorusHoleShape | sc::UncappedTorusHoleShape |
| sc_UnionShape | A UnionShape is volume enclosed by a set of Shape's. |
| sc_Units | The Units class is used to perform unit converions. |
| sc_UnrestrictedSCF | A base class for unrestricted self-consistent-field methods. |
| sc_UsedData | sc::UsedData |
| sc_VDWShape | The VDWShape class describes the surface of a molecule as the union of atom centered spheres, each the van der Waals radius of the atom. |
| 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_Vertex | sc::Vertex |
| sc_Volume | A Volume is a Function of three variables. |
| sc_Wavefunction | A Wavefunction is a MolecularEnergy that utilizies a GaussianBasisSet. |
| sc_X | sc::X |
| sc_XalphaFunctional | Implements the Xalpha exchange functional. |
| sc_Y | sc::Y |
| sc_YYSTYPE | YYSTYPE |
| sc_auto_vec | The auto_vec class functions much like auto_ptr, except it contains references to arrays. |
| sc_canonical_aaaa | If the shell loop structure has 8 fold symmetry, then this should be used as the template argument to GPetite4. |
| 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… |
| 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 GPetite4. |
| sc_canonical_abcd | If the shell loop structure has no symmetry, then this should be used as the template argument to GPetite4. |
| sc_commbuf_struct | sc::commbuf_struct |
| sc_contribution | sc::contribution |
| sc_der_centersv3_t | sc::der_centersv3_t |
| sc_distsize_t | sc::distsize_t |
| sc_errno_exception | errno_exception |
| sc_intMessageGrp | Uses integer message types to send and receive messages. |
| sc_intlist_struct | sc::intlist_struct |
| sc_ip_cwk_stack_struct | sc::ip_cwk_stack_struct |
| sc_ip_keyword_tree_list_struct | sc::ip_keyword_tree_list_struct |
| sc_ip_keyword_tree_struct | sc::ip_keyword_tree_struct |
| sc_ip_string_list_struct | sc::ip_string_list_struct |
| sc_mPW91XFunctional | Implements a modified 1991 Perdew-Wang exchange functional. |
| sc_mat3 | sc::mat3 |
| sc_mat4 | sc::mat4 |
| sc_message_struct | sc::message_struct |
| sc_msgbuf_struct | sc::msgbuf_struct |
| sc_point | point |
| sc_prim_pair_t | sc::prim_pair_t |
| sc_scprintf | This class allows printf like output to put sent to an ostream. |
| sc_type_info_key | sc::type_info_key |
| sc_vec2 | sc::vec2 |
| sc_vec3 | sc::vec3 |
| sc_vec4 | sc::vec4 |
| sc_vertex | vertex |
| sc_vertices | vertices |