Here are the classes, structs, unions and interfaces with brief descriptions:
| sc::mbptr12::__to_extern_C_eval< Function, Weight > | |
| sc::mbptr12::ABS_OBS_Contraction | ABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the ABS approach |
| libint2::abssqrt< T > | |
| 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::AccumEffectiveH | |
| 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::ALevelShift | |
| 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::AnimatedObject | |
| sc::Appearance | |
| 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::sma2::Array< N > | Implements a block sparse tensor |
| sc::tr1::array::array< T, N > | Array idential to C++0X arrays |
| sc::sma2::Array24SCExtrapData | This permits an Array<2> and an Array<4> to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array24SCExtrapError | This permits an Array<2> and an Array<4> to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array2SCExtrapData | This permits Array<2>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array2SCExtrapError | This permits Array<2>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array4SCExtrapData | This permits Array<4>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array4SCExtrapError | This permits Array<4>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array6SCExtrapData | This permits Array<6>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::sma2::Array6SCExtrapError | This permits Array<6>'s to be used with SelfConsistentExtrapolation derivatives |
| sc::tr1::array::array< T, 0 > | |
| sc::AssignedKeyVal | This class allows keyval associations to be set up by the program, rather than determined by an external file |
| sc::AtomicOrbitalSpace | This is an OrbitalSpace describing a set of atomic orbitals |
| sc::AtomInfo | Information about atoms |
| sc::AtomProximityColorizer | |
| sc::auto_vec< T > | The auto_vec class functions much like auto_ptr, except it contains references to arrays |
| sc::AVLMap< K, T > | |
| sc::AVLMapNode< K, T > | |
| sc::AVLMMap< K, T, C, A > | |
| sc::AVLMMapNode< K, T > | |
| sc::AVLSet< K > | |
| sc::Backtrack | Implements backtrack line search algorithm |
| sc::MPQCIn::Basis | |
| sc::BasisFileSet | |
| 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::BEMSolvent | |
| sc::BEMSolventH | This specialization of AccumH computes the contribution to the energy and one body Hamiltonian from a solvent using a polarizable continuum model |
| 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::BiggestContribs | |
| sc::BitArrayLTri | |
| sc::BLevelShift | |
| sc::sma2::BlockDistrib< N > | Provides information about how blocks are distributed onto processes |
| sc::BlockedDiagSCMatrix | Blocked DiagSCMatrix |
| sc::BlockedSCElementOp | |
| sc::BlockedSCElementOp2 | |
| sc::BlockedSCElementOp3 | |
| sc::BlockedSCMatrix | Blocked SCMatrix |
| sc::BlockedSCMatrixKit | |
| sc::BlockedSCVector | |
| sc::BlockedSymmSCMatrix | Blocked SymmSCMatrix |
| sc::sma2::BlockInfo< N > | BlockInfo stores info about a block of data |
| sc::sma2::BlockInfo< 0 > | |
| sc::sma2::BlockInfo< 2 > | |
| sc::sma2::BlockInfo< 3 > | |
| sc::sma2::BlockInfo< 4 > | |
| sc::sma2::BlockInfoEqual< N > | |
| sc::sma2::BlockInfoHash< N > | |
| sc::sma2::BlockIter< N > | BlockIter loops through the all the indices within a block |
| sc::sma2::BlockIter< 0 > | Blocksize == 0 specialization of BlockIter |
| sc::BoundsLibint2< Int2e > | Computes log2 bounds for a particular Int2e evaluator |
| MpqcCca::BufferSize | |
| sc::BuildIntV3 | |
| sc::mbptr12::CABS_OBS_Contraction | CABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the CABS approach |
| sc::CannotConstructMap | |
| 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::CartesianBasisSet | CartesianBasisSet is obtained from the parent basis by converting spherical harmonic shells to cartesian counterparts |
| sc::CartesianIter | CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization |
| sc::CartesianIterCCA | |
| MPQC::CartesianIterCCA | |
| sc::CartesianIterCints | |
| sc::CartesianIterGAMESS | |
| sc::CartesianIterV3 | |
| 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::CCR12 | CCR12 is the base class for CC and CC-R12 methods |
| sc::CCR12_Info | CCR12_Info is the compilation of members that are used in CC and CC-R12 methods |
| sc::CCR12_Triples | |
| sc::CCSD | |
| sc::CCSD_2Q_LEFT | |
| sc::CCSD_2Q_RIGHT | |
| sc::CCSD_2T_LEFT | |
| sc::CCSD_2T_PR12_RIGHT | |
| sc::CCSD_2T_R12_LEFT | |
| sc::CCSD_2T_RIGHT | |
| sc::CCSD_E | |
| sc::CCSD_PT | |
| sc::CCSD_PT_LEFT | |
| sc::CCSD_PT_RIGHT | |
| sc::CCSD_R12 | |
| sc::CCSD_R12_E | |
| sc::CCSD_R12_PT_RIGHT | |
| sc::CCSD_R12_T1 | |
| sc::CCSD_R12_T2 | |
| sc::CCSD_Sub_Bar_R12 | |
| sc::CCSD_Sub_Full_R12 | |
| sc::CCSD_Sub_R12 | CCSD_Sub_R12 is the base class for some (2)R12 methods |
| sc::CCSD_SUB_R12_LEFT | |
| sc::CCSD_SUB_R12_RIGHT | |
| sc::CCSD_T1 | |
| sc::CCSD_T2 | |
| sc::CCSDPR12 | |
| sc::CCSDPR12_C | |
| sc::CCSDPR12_T1 | |
| sc::CCSDPR12_T2 | |
| sc::CCSDT | |
| sc::CCSDT_T1 | |
| sc::CCSDT_T2 | |
| sc::CCSDT_T3 | |
| sc::CCSDTQ | |
| sc::CCSDTQ_T2 | |
| sc::CCSDTQ_T3 | |
| sc::CCSDTQ_T4 | |
| sc::CharacterTable | Workable character table for all of the non-cubic point groups |
| sc::chunk_allocator< T > | |
| 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::Color | |
| sc::sma2::CompleteBlockDistrib< N > | Distribute blocks round-robin among processes using one or more index values |
| MpqcCca::CompositeIntegralEvaluator< eval_type, computer_type > | |
| sc::Compute | Means of keeping results up to date |
| sc::ConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result |
| sc::AVLMMap< K, T, C, A >::const_iterator | |
| sc::ConsumableResources | ConsumableResources keeps track of consumable resources (memory, disk) |
| sc::detail::ContainerAdaptor< Container > | |
| sc::detail::ContainerAdaptor< RefDiagSCMatrix > | |
| sc::sma2::ContractPart< N > | Represents an array and symbolic indices in a contraction |
| sc::sma2::ContractProd< Nl, Nr > | Represents a pairs of contracted array and their symbolic indices |
| sc::sma2::ContractUnion< Nl, Nr > | |
| sc::contribution | |
| 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::R12Technology::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::R12Technology::CorrParamCompare< IntParam > | Compares CorrelationParamaters corresponding to IntParam |
| sc::CreateTransformHints | Provides hints to the constructors of a Transform class that help configure its implementation |
| sc::CS2Sphere | |
| sc::CSGrad34Qbtr | |
| sc::CSGradErep12Qtr | |
| sc::CSGradS2PDM | |
| sc::CuspConsistentGeminalCoefficient | Computes fixed coefficients determined according to the cusp conditions for geminal (r12-dependent) functions that have been normalized so that coefficient of r12 in Taylor expansion around r12=0 is 1 |
| sc::sma2::Data | Data holds the values for each block |
| 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::DensityColorizer | |
| sc::DensityFitting | Decomposition by density fitting with respect to some kernel |
| sc::test::DensityFitting | Decomposition by density fitting with respect to some kernel |
| sc::DensityFittingInfo | This class encapsulates objects needed to perform density fitting of a 4-center integral |
| sc::DensityFittingParams | DensityFittingParams defines parameters needed to compute density fitting objects |
| sc::DensityFittingRuntime | Smart runtime support for managing DensityFitting objects |
| sc::der_centersv3_t | |
| 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::DFCLHF | DFCLHF is a specialization of CLHF that uses a density-fitting FockBuild class for computing fock matrices |
| 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::DiagSCMatrixdouble | |
| sc::DIIS | DIIS extrapolation |
| sc::WriteVectorGrid::DimensionMap | |
| sc::DipoleData | |
| sc::DipoleIntV3 | |
| sc::mbptr12::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::Displacements< Value > | Maps displacements in terms of symmetrized coordinates to property values |
| sc::DistArray4 | DistArray4 contains a set of one or more distributed dense 4-index arrays |
| sc::DistArray4_MemoryGrp | DistArray4_MemoryGrp handles transformed integrals held in memory by MemoryGrp |
| sc::DistArray4_MPIIOFile | DistArray4_MPIIOFile handles transformed integrals stored in a binary file accessed through MPI-IO |
| sc::DistArray4_MPIIOFile_Ind | DistArray4_MPIIOFile_Ind handles transformed integrals stored in a binary file accessed through MPI-IO individual I/O routines |
| sc::DistArray4_Node0File | DistArray4_Node0File handles transformed integrals stored in file on node 0 (file is a usual POSIX binary file) |
| sc::DistArray4Creator | Creates new DistArray4 using TwoBodyFourCenterMOIntsRuntime and a vector of transform keys |
| sc::DistArray4Dimensions | |
| sc::DistDiagSCMatrix | Distributed DiagSCMatrix |
| sc::DistFockBuildMatrix | |
| sc::DistSCMatrix | Distributed SCMatrix |
| sc::DistSCMatrixKit | The DistSCMatrixKit produces matrices that work in a many processor environment |
| sc::DistSCMatrixListSubblockIter | |
| sc::DistSCVector | |
| sc::DistShell | Distributes sets of shells either statically or dynamically |
| sc::DistShellPair | Distributes shell pairs either statically or dynamically |
| sc::distsize_t | |
| sc::DistSymmSCMatrix | Distributed SymmSCMatrix |
| sc::sma2::DivOperation | |
| sc::DummySavableState | Useful as a dummy template argument |
| sc::EAVLMMap< K, T > | |
| sc::EAVLMMapNode< K, T > | |
| sc::Edge | |
| sc::EFCOpt | Implements eigenvector following as described by Baker in J |
| sc::EfieldDotVectorData | |
| sc::EfieldDotVectorIntV3 | |
| sc::EGH | Energy + gradient + hessian |
| sc::ElectronDensity | This is a Volume that computes the electron density |
| sc::EmptyOrbitalSpace | This is an empty OrbitalSpace |
| sc::EnergyMOOrder< EnergyCompare > | Order by energy first, then by symmetry. EnergyCompare specifies the weak strict ordering of orbitals wrt energy |
| sc::detail::EqualTypes< A, B > | |
| sc::detail::EqualTypes< A, A > | |
| sc::EriCints | EriCints is a specialization of Int2eCints that computes electron repulsion integrals |
| sc::detail::ERIEvalCreator< 2 > | |
| sc::detail::ERIEvalCreator< 3 > | |
| sc::detail::ERIEvalCreator< 4 > | |
| sc::EriLibint2 | EriLibint2 is a specialization of Int2eLibint2 that computes electron repulsion integrals |
| errno_exception | |
| sc::ETraIn | Class ETraIn evaluates transfer and overlap matrix in the basis of monomer SCF wave functions |
| sc::EulerMaclaurinRadialIntegrator | An implementation of a radial integrator using the Euler-Maclaurin weights and grid points |
| sc::detail::EvalCreator< NumCenters, TwoBodyOperSet::ERI > | |
| sc::detail::EvalCreator< NumCenters, TwoBodyOperSet::G12 > | |
| sc::detail::EvalCreator< NumCenters, TwoBodyOperSet::G12DKH > | |
| sc::detail::EvalCreator< NumCenters, TwoBodyOperSet::G12NC > | |
| sc::detail::EvalCreator< NumCenters, TwoBodyOperSet::R12 > | |
| sc::ExEnv | Used to find out about how the program is being run |
| sc::ExtendedHuckelWfn | |
| sc::ExtentData | |
| sc::Extern_RefWavefunction | RefWavefunction specialization for a general wave function specified by its orbitals and rank-1 reduced density matrices |
| sc::ExternalCCAFramework | Handles externally initialized CCA frameworks |
| sc::ExternMOInfo | Reads MO information from a text file Note that the MO ordering in the external file may not be the same as in MPQC For example, irreducible representations may be ordered differently in different programs Thus MOs will be reordered to be consistent with MPQC rules, and a map from the native to MPQC representation will be provided so that other files produced by the external program can be interpreted |
| sc::ExternPT2R12 | ExternPT2R12 is a PT2R12 wave function computed from external MO info and 2-RDM |
| sc::ExternSpinFreeRDMOne | Reads 1-RDM from a text file |
| sc::ExternSpinFreeRDMTwo | Reads 2-RDM from a text file |
| sc::SCElement::fabs_less | |
| sc::fabs_less< T > | Fabs_less(a,b) return true if fabs(a) < fabs(b) |
| sc::detail::FockMatrixType< true >::Factory | |
| sc::detail::FockMatrixType< false >::Factory | |
| 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::FermionBasicNCOper< 1, FermionOccupationBitString< Ns > > | |
| sc::FermionOccupationBitString< Ns > | "dense" string represents represent occupancies of a set of Ns states by a bitstring |
| sc::FermionOccupationBlockString | Block-"sparse" string represents occupancies of an arbitrarily-large set of states as a set of alternating unoccupied/occupied blocks |
| 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::FinDispDerivative< TargetOrder, Function > | FinDispDerivative computes derivatives of functions using finite-difference formulas |
| sc::FinDispMolecularGradient | Computes the molecular gradient by finite differences of energies |
| sc::FinDispMolecularHessian | Computes the molecular hessian by finite displacements of gradients (or, if not available, energies) |
| 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::FockBlocks | |
| sc::FockBuild | Works with the FockBuildThread class to generate Fock matrices for both closed shell and open shell methods |
| sc::FockBuildAM | |
| sc::FockBuildAMG | |
| sc::FockBuildCLHF | FockBuildCLHF is a specialization of CLHF that uses FockBuild class for computing fock matrices |
| sc::FockBuildMatrix | |
| sc::FockBuildOp | |
| sc::FockBuildRuntime | Build Fock matrices using some combination of FockBuilder objects |
| 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::FockContribution | |
| sc::FockDist | |
| sc::FockDistDynamic | |
| sc::FockDistDynamic2 | |
| sc::FockDistDynamic4 | |
| sc::FockDistribution | FockDistribution is a factory for constructing the desired FockDist specialization |
| sc::FockDistStatic | |
| sc::FockDistStatic2 | |
| sc::FockDistStatic4 | |
| sc::detail::FockMatrixType< false > | |
| sc::detail::FockMatrixType< true > | |
| 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::FreeData | |
| sc::detail::FromStateIn< T > | Helper template to read from StateIn |
| sc::detail::FromStateIn< EGH > | |
| 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::RefSCVector > | Specialization for RefSCVector |
| 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::R12Technology::G12CorrelationFactor | G12CorrelationFactor stands for Gaussian geminals correlation factor, usable with methods that require commutator integrals |
| sc::detail::G12DKHEvalCreator< 2 > | |
| sc::detail::G12DKHEvalCreator< 3 > | |
| sc::detail::G12DKHEvalCreator< 4 > | |
| sc::G12DKHLibint2 | G12DKHLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to relativistic explicitly correlated methods which use Gaussian geminals |
| sc::detail::G12EvalCreator< 2 > | |
| sc::detail::G12EvalCreator< 3 > | |
| sc::detail::G12EvalCreator< 4 > | |
| sc::G12Libint2 | G12Libint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to explicitly correlated methods which use Gaussian geminals |
| sc::R12Technology::G12NCCorrelationFactor | G12NCCorrelationFactor stands for Gaussian geminals correlation factor, usable with methods that do not require commutator integrals; this is more for temporary tests or quick implementation |
| sc::detail::G12NCEvalCreator< 2 > | |
| sc::detail::G12NCEvalCreator< 3 > | |
| sc::detail::G12NCEvalCreator< 4 > | |
| 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) = c x^k exp(-a*x^2) |
| sc::GaussianBasisSet | Used describe a basis set composed of atomic gaussian orbitals |
| sc::GaussianBasisSetMap | A heavy-duty map from one GaussianBasisSet to another GaussianBasisSet |
| 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::GaussTriangleIntegrator | |
| sc::GBuild< T > | |
| sc::GDIISOpt | |
| sc::R12Technology::GeminalDescriptor | |
| sc::R12Technology::GeminalDescriptorFactory | |
| 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::GetLongOpt | Parse command line options |
| sc::detail::GetValue< bool > | |
| sc::detail::GetValue< char > | |
| sc::detail::GetValue< double > | |
| sc::detail::GetValue< float > | |
| sc::detail::GetValue< int > | |
| sc::detail::GetValue< long > | |
| sc::detail::GetValue< std::size_t > | |
| sc::detail::GetValue< std::string > | |
| sc::GlobalCounter | Allows processes on the same SMP node to share a counter using SysV IPC semaphores |
| sc::GlobalMsgIter | |
| 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::GradDensityColorizer | |
| sc::Grid | Defines a finite regular Carthesian grid |
| sc::GrpArithmeticAndReduce< T > | |
| sc::GrpArithmeticOrReduce< T > | |
| sc::GrpArithmeticXOrReduce< T > | |
| sc::GrpCompareReduce< T, BinaryPredicate > | |
| sc::GrpFunctionReduce< T > | |
| sc::GrpMaxReduce< T > | |
| sc::GrpMinReduce< T > | |
| sc::GrpProductReduce< T > | |
| sc::GrpReduce< T > | |
| sc::GrpSumReduce< T > | |
| 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::GSGeneralEffH | |
| sc::GSHighSpinEffH | |
| sc::GTOInfo | Provides precomputed information about Gaussian basis functions |
| sc::GuessMolecularHessian | GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates |
| sc::HCoreWfn | |
| 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::HSOSV1Erep1Qtr | |
| sc::HundsFEMOSeeker | Finds the FEMO configuration that corresponds to the maximum multiplicity |
| sc::HypercubeGMI | |
| sc::HypercubeTopology | |
| 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::sma2::Index | An Index is used in the symbolic notation for contractions |
| sc::sma2::IndexList | An IndexList is a vector of indices |
| sc::sma2::IndexListLess< N > | Functor for determining if one IndexList is less than another |
| sc::IndexRangeIterator< NDIM > | This is an abstract range of indices |
| sc::sma2::IndicesLess< N > | Functor for comparing a block's indices |
| sc::sma2::IndicesLess< 0 > | Functor for comparing a block's indices |
| 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::IntDescrFactory | |
| 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 |
| MpqcCca::IntegralEvaluator< eval_type, computer_type > | |
| sc::IntegralKey | |
| sc::IntegralLibint2 | IntegralLibint2 computes integrals between Gaussian basis functions |
| sc::IntegralLink | |
| sc::IntegralSetDescr< IntEval > | For a set of integrals (e.g |
| sc::IntegralStorer | |
| sc::IntegralV3 | IntegralV3 computes integrals between Gaussian basis functions |
| sc::IntegrationWeight | An abstract base class for computing grid weights |
| sc::IntEvalToOperSetType< TwoBodyInt > | |
| sc::IntEvalToOperSetType< TwoBodyThreeCenterInt > | |
| sc::IntEvalToOperSetType< TwoBodyTwoCenterInt > | |
| sc::intlist_struct | |
| 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::IntParamsType< TwoBodyOperSet::ERI > | |
| sc::IntParamsType< TwoBodyOperSet::G12 > | |
| sc::IntParamsType< TwoBodyOperSet::G12DKH > | |
| sc::IntParamsType< TwoBodyOperSet::G12NC > | |
| sc::IntParamsType< TwoBodyOperSet::R12 > | |
| sc::IntParamsVoid | Passes params to Integral::electron_repulsion() and other factory methods which do not need parameters |
| sc::IntV3Arraydouble2 | |
| sc::IntV3Arraydouble3 | |
| sc::IntV3Arraydoublep2 | |
| sc::IntV3Arraydoublep3 | |
| sc::IntV3Arraydoublep4 | |
| sc::IntV3Arrayint3 | |
| sc::IntV3Arrayint4 | |
| sc::ip_cwk_stack_struct | |
| sc::ip_keyword_tree_list_struct | |
| sc::ip_keyword_tree_struct | |
| sc::ip_string_list_struct | |
| sc::IPV2 | |
| sc::IrreducibleRepresentation | Information associated with a particular irreducible representation of a point group |
| sc::IsosurfaceGen | |
| sc::ISphericalTransform | This describes a solid harmonic to Cartesian transform |
| sc::ISphericalTransformCCA | |
| sc::ISphericalTransformCints | |
| sc::ISphericalTransformLibint2 | |
| sc::ISphericalTransformV3 | |
| sc::AVLMMap< K, T, C, A >::iterator | |
| sc::AVLMap< K, T >::iterator | |
| sc::AVLSet< K >::iterator | |
| sc::EAVLMMap< K, T >::iterator | |
| sc::GenericFockContribution::JKBlock< Locator > | |
| sc::GenericFockContribution::JLocator | |
| 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 std::string value |
| sc::Keyword | Provides convenient way to fill standard containers from KeyVal |
| sc::GenericFockContribution::KLocator | |
| sc::LAMBDA_CCSD_T1 | |
| sc::LAMBDA_CCSD_T2 | |
| sc::LAMBDA_CCSDPR12_T1 | |
| sc::LAMBDA_CCSDPR12_T2 | |
| sc::LCorr | A base class for local correlation methods |
| sc::LebedevLaikovIntegrator | An implementation of a Lebedev angular integrator |
| sc::LevelShift | |
| sc::Libint2StaticInterface | |
| sc::LibintStaticInterface | |
| sc::Libr12StaticInterface | |
| 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::LMP2 | Computes the local second order perturbation theory energy |
| sc::LocalCLHFContribution | |
| sc::LocalCLHFEnergyContribution | |
| sc::LocalCLHFGradContribution | |
| sc::LocalCLKSContribution | |
| sc::LocalCLKSEnergyContribution | |
| sc::LocalDiagSCMatrix | Local DiagSCMatrix |
| sc::LocalGBuild< T > | |
| LocalHSOSContribution | |
| LocalHSOSEnergyContribution | |
| LocalHSOSGradContribution | |
| sc::LocalHSOSKSContribution | |
| sc::LocalHSOSKSEnergyContribution | |
| sc::LocalLBGBuild< T > | |
| sc::LocalOSSContribution | |
| sc::LocalOSSEnergyContribution | |
| sc::LocalOSSGradContribution | |
| sc::LocalSCMatrix | |
| sc::LocalSCMatrixKit | The LocalSCMatrixKit produces matrices that work in a single processor environment |
| sc::LocalSCVector | |
| sc::LocalSymmSCMatrix | Local SymmSCMatrix |
| sc::LocalTBGrad< T > | |
| sc::LocalTCContribution | |
| sc::LocalTCEnergyContribution | |
| sc::LocalTCGradContribution | |
| sc::LocalUHFContribution | |
| sc::LocalUHFEnergyContribution | |
| sc::LocalUHFGradContribution | |
| sc::LocalUKSContribution | |
| sc::LocalUKSEnergyContribution | |
| 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::MachineTopology | |
| sc::detail::MakeTwoBodyTransform< false > | |
| sc::detail::MakeTwoBodyTransform< true > | |
| sc::MaskedOrbitalSpace | This is an OrbitalSpace produced from an existing one by masking out some Orbitals |
| sc::mat3 | |
| sc::mat4 | |
| sc::Material | |
| 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 R12 second-order Moeller-Plesset 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::message_struct | |
| sc::MessageGrp | The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine |
| sc::MessageGrp::MessageHandle | |
| sc::MPIMessageGrp::MessageHandleData | |
| sc::MessageGrp::MessageInfo | |
| sc::MOIntsRuntime | MOIntsRuntime provides runtime support for computing 2-, 3-, and 4-center MO-basis integrals (with or without density fitting) |
| sc::MOIntsTransform | |
| sc::MOIntsTransformFactory | MOIntsTransformFactory is a factory that produces MOIntsTransform objects |
| sc::MOLagrangian | |
| sc::MOLDEN_ExternReadMOInfo | Reads MO information from a text MOLDEN file |
| 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::MolecularFragment | MolecularFragment is a Molecule that is a fragment of another Molecule object |
| sc::MolecularFrequencies | Used to compute the molecular frequencies and thermodynamic information |
| sc::MolecularGradient | MolecularGradient is an abstract class that computes a molecule's first derivatives of the energy with respect to changes in the nuclear coordinates |
| 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::MolecularPropertyDerivative | Computes numerical derivatives of a molecular property by finite differences of values (or, if available, lower-order analytic derivatives) |
| sc::detail::MolecularSpinOrbitalAttributes | Same as MolecularOrbitalAttributes, plus spin |
| sc::Molecule | Information about molecules |
| sc::MoleculeColorizer | |
| sc::MolEnergyConvergence | |
| sc::MolFreqAnimate | |
| 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::TwoBodyMOIntsTransform::MOSpaces | Predefined enumerated type for the MO spaces |
| sc::MP2BasisExtrap | |
| sc::MP2R12Energy | Class MP2R12Energy is the object that computes and maintains MP2-R12 energies |
| sc::MP2R12Energy_Diag | The class MP2R12Energy_Diag is an implementation of MP2R12Energy that supports Ten-no's diagonal orbital-invariant ansatz for closed and open-shells |
| 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 | |
| sc::MP2R12EnergyUtil_Diag_DifferentSpin | Class MP2R12EnergyUtil provides some misc functions to operate on (blocked) ijxy and xyxy matrices |
| sc::MP2R12EnergyUtil_Diag_SameSpin | |
| sc::MP2R12EnergyUtil_Nondiag | |
| sc::MPIMessageGrp | Concrete implementation of MessageGrp that uses the MPI 1 library |
| sc::MPQC_CCAFramework | Handles embedded CCA frameworks |
| sc::MPQCIn | |
| sc::MPQCInDatum< T > | |
| 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::MTensor< NDIM > | Tensor metadata is implicit; MTensor is Tensor + metadata |
| sc::MTMPIMemoryGrp | This MemoryGrp class requires a MT-safe MPI implementation |
| sc::NBodyIntTraits< NumCenters, Type > | Traits of a set of two-body integrals |
| sc::NCAccResult< T > | This associates a result non-class datum with an accuracy |
| sc::NCentersToDescr< 2, 2 > | |
| sc::NCentersToDescr< 3, 2 > | |
| sc::NCentersToDescr< 4, 2 > | |
| sc::NCResult< T > | This is similar to Result, but can be used with non-class types |
| sc::detail::NeedDF< TransformType > | |
| sc::detail::NeedDF< TwoBodyMOIntsTransform_ixjy_df > | |
| sc::NElFunctional | The NElFunctional computes the number of electrons |
| sc::NewP86CFunctional | |
| sc::NewtonOpt | Implements Newton method |
| 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::NonreentrantUncappedTorusHoleShape | |
| sc::detail::NonsingletonCreationPolicy< T > | NonsingletonCreationPolicy is used to create non-Singletons on heap |
| sc::Registry< Key, Value, CreationPolicy, KeyEqual, ValueEqual >::not_found | |
| sc::R12Technology::NullCorrelationFactor | NullCorrelationFactor stands for no correlation factor; only for test |
| sc::OBWfnRDMCumulantTwo | OBWfnRDMCumulantTwo is the cumulant of OBWfnRDMTwo |
| sc::OBWfnRDMOne | OBWfnRDMOne is a 1-RDM from a OneBodyWavefunction |
| sc::OBWfnRDMTwo | OBWfnRDMTwo is a 2-RDM from a OneBodyWavefunction |
| sc::OneBody3IntOp | |
| MpqcCca::onebody_computer | |
| MpqcCca::onebody_deriv_computer | |
| MpqcCca::onebody_onecenter_computer | |
| MpqcCca::onebody_onecenter_deriv_computer | |
| 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::OneBodyIntIter | |
| sc::OneBodyIntLibint2 | This implements most one body integrals in the Libint2 library |
| 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::OneBodySODerivInt | OneBodySODerivInt computes two-center one-electron integrals in a symmetry-adapted basis |
| sc::OneBodySOInt | OneBodySOInt computes two-center one-electron integrals in a symmetry-adapted basis |
| sc::OneBodyWavefunction | A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem |
| sc::OOGLRender | |
| sc::OperatorDescr | For an operator (e.g |
| sc::OperSetTypeMap< TwoBodyOperSet::ERI > | |
| sc::OperSetTypeMap< TwoBodyOperSet::G12 > | |
| sc::OperSetTypeMap< TwoBodyOperSet::G12DKH > | |
| sc::OperSetTypeMap< TwoBodyOperSet::G12NC > | |
| sc::OperSetTypeMap< TwoBodyOperSet::R12 > | |
| sc::Optimize | Abstract base class for classes that find the extreme points of Function's |
| sc::Orbital | |
| sc::OrbitalSpace | Class OrbitalSpace describes a range of orbitals that are linear combinations of Gaussian basis functions (e.g |
| sc::OrbitalSpaceUnion | This is a union of two OrbitalSpaces s1 and s2 |
| sc::OrderedOrbitalSpace< Order > | This is an OrbitalSpace ordered according to the Order type |
| sc::OrderedSpinOrbitalSpace< Order > | Same as OrderedOrbitalSpace, except for spin-orbitals |
| sc::OSSHF | |
| sc::OSSSCF | |
| sc::OutSimpleCo | |
| sc::OverlapOrthog | This class computes the orthogonalizing transform for a basis set |
| sc::P86CFunctional | Implements the Perdew 1986 (P86) correlation functional |
| sc::DistArray4_MPIIOFile::PairBlkInfo | |
| sc::sma2::PairBlockDistrib< N > | An implementation of BlockDistrib using PairMapping |
| sc::sma2::PairMapping | Distributes pairs of indices among the processes |
| sc::ParallelRegionTimer | This is a parallel-away derivative of RegionTimer |
| sc::Parameter< T > | |
| sc::ParamsRegistry | This is a singleton registry that holds IntParams objects |
| sc::ParentClass | Gives one parent class of a class |
| sc::ParentClasses | Gives a list of parent classes of a class |
| sc::Parenthesis2q | |
| sc::Parenthesis2t | |
| sc::Parenthesis2tNum | PTNum is the base class for the numerator in various (2)T/(2)Q models |
| sc::ParsedDensityFittingKey | Parsed representation of a string key that represents fitting of a product of space1 and space2 into fspace Coulomb fitting kernel is the default |
| 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::ParsedTwoBodyFourCenterIntKey | Parsed representation of a string key that represents a set of 4-center 2-body integrals |
| sc::detail::ParsedTwoBodyIntKey< 2 > | |
| sc::detail::ParsedTwoBodyIntKey< 3 > | |
| sc::detail::ParsedTwoBodyIntKey< 4 > | |
| sc::ParsedTwoBodyThreeCenterIntKey | Parsed representation of a string key that represents a set of 3-center 2-body integrals |
| sc::ParsedTwoBodyTwoCenterIntKey | Parsed representation of a string key that represents a set of 2-center 2-body integrals |
| sc::PBECFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional |
| sc::PBEXFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional |
| sc::GenericFockContribution::PBlock | |
| sc::PermutedDensityFitting | Computes density fitting for |ij) density from fitting of |ji) DensityFitting |
| sc::PetiteList | PetiteList is a petite list (see Dupuis & King, IJQC 11,613,(1977) ) that can be used for constructing symmetry-adapted basis functions (``symmetry orbitals'', SO for short) as well as transforming operators and functions from AO to SO basis, and vice versa |
| sc::PipekMezeyLocalization | Performs a Pipek-Mezey orbital localization |
| point | |
| sc::PointChargeData | |
| sc::PointChargeIntV3 | |
| 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::Pool | |
| sc::PoolData | |
| sc::PopulatedOrbitalSpace | PopulatedOrbitalSpace is an OrbitalSpace populated with a density |
| sc::PowellUpdate | Used to specify a Powell hessian update |
| sc::mbptr12::PowerGaussian1D | PowerGaussian1D(k,l,x) = c x^k exp(-a*x^l) |
| sc::PrefixKeyVal | PrefixKeyVal is a KeyVal that searches a different KeyVal using modified keys |
| sc::prim_pair_t | |
| 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::PsiCC2 | PsiCC2 is a concrete implementation of Psi ground-state CC2 wave function |
| sc::PsiCC3 | PsiCC3 is a concrete implementation of Psi ground-state CC3 wave function |
| sc::PsiCC3_PT2R12 | PsiCC3_PT2R12 is a concrete implementation of the ground-state  method |
| sc::PsiCC_PT2R12 | PsiCC_PT2R12 is used to implement  methods |
| 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::PsiChkpt | PsiChkpt know to read data from Psi checkpoint file and convert it to conform to the representations expected in MPQC |
| sc::PsiCLHF | PsiCLHF is a concrete implementation of Psi RHF wave function |
| sc::PsiCorrWavefunction | PsiCorrWavefunction is a Psi correlated wave function |
| sc::PsiCorrWavefunction_PT2R12 | PsiCorrWavefunction_PT2R12: a corrlated wave function with a perturbational explicitly correlated correction |
| sc::PsiEffH | |
| sc::PsiExEnv | PsiExEnv specifies a Psi execution environment |
| 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::PsiRASCI | PsiRASCI is a general (RAS) CI PsiWavefunction |
| sc::PsiRASCI_RefWavefunction | RefWavefunction specialization for a general restricted-active-space multiconfiguration wave function |
| sc::PsiRASSCF | PsiRASSCF is a type of a PsiRASCI wavefunction that implements orbital optimization |
| sc::PsiRDMCumulantTwo | PsiRDMCumulantTwo is the cumulant of PsiRDMTwo |
| sc::PsiRDMOne | PsiRDMOne is a 1-RDM from a PsiWavefunction |
| sc::PsiRDMTwo | PsiRDMTwo is a 2-RDM from a PsiWavefunction |
| sc::PsiSCF | PsiSCF is an abstract base for all Psi SCF wave functions |
| sc::PsiSCF_RefWavefunction | RefWavefunction specialization initialized with a PsiSCF wave function |
| 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::PT2R12 | PT2R12: a universal spin-free second-order R12 correction |
| sc::PthreadThreadGrp | Privides a concrete thread group appropriate for an environment where pthreads is available |
| sc::PTNum | PTNum is the base class for the numerator in various (T) models |
| 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::R12Amplitudes | R12Amplitudes gives the amplitudes of some R12-ansatz-related terms in wave function |
| sc::R12Technology::R12Ansatz | R12Ansatz specifies the manner in which the R12 geminals are constructed |
| sc::R12Technology::R12CorrelationFactor | R12CorrelationFactor stands for no correlation factor |
| sc::R12EnergyIntermediates | The class R12EnergyIntermediates is the front-end to R12 intermediates |
| sc::detail::R12EvalCreator< 2 > | |
| sc::detail::R12EvalCreator< 3 > | |
| sc::detail::R12EvalCreator< 4 > | |
| sc::R12IntEval | R12IntEval is the top-level class which computes intermediates occuring in R12 theories |
| sc::R12Technology | R12Technology describes technical features of the R12 approach |
| sc::R12TwoBodyIntKeyCreator | Creates R12TwoBodyIntKey for the given CorrelationFactor |
| sc::R12WavefunctionWorld | Class R12WavefunctionWorld describes the environment of a Wavefunction implementing an R12 method |
| 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::sma2::Range | An Range represent a set of integers, [0, N) |
| sc::RangeCreator< T > | RangeCreator<T> is Functor which can be used up to n times to create objects of type T |
| sc::RangeLock | |
| sc::RangeLockItem | |
| sc::RDM< R > | RDM<R> is a reduced density matrix of rank R |
| sc::RDM< Zero > | This specialization is needed to make RDM<R>::rdm_m_1() work |
| sc::RDMAMemoryGrp | The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp class |
| sc::RDMCumulant< R > | RDMCumulant<R> is a reduced density matrix cumulant of rank R |
| 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::RedundantCartesianIterCCA | |
| sc::RedundantCartesianIterCints | |
| sc::RedundantCartesianIterGAMESS | |
| sc::RedundantCartesianIterV3 | |
| sc::RedundantCartesianSubIter | Like RedundantCartesianIter, except a, b, and c are fixed to a given value |
| sc::RedundantCartesianSubIterCCA | |
| sc::RedundantCartesianSubIterCints | |
| sc::RedundantCartesianSubIterGAMESS | |
| sc::RedundantCartesianSubIterV3 | |
| sc::RedundMolecularCoor | Redundant set of simple internal coordinates |
| sc::ReentrantUncappedTorusHoleShape | |
| 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::FockBuildRuntime::RefSymmSCMatrixEqual | This functor compares RefSymmSCMatrix objects |
| sc::RefWavefunction | RefWavefunction represents the reference wave function used in correlated calculations |
| sc::RefWavefunctionFactory | This factory produces the RefWavefunction that corresponds to the type of ref object |
| sc::RegionTimer | Used to record the time spent in a section of code |
| sc::Registry< Key, Value, CreationPolicy, KeyEqual, ValueEqual > | Registry wraps std::map and can be policy-configured to act as a Singleton or a regular object |
| sc::Render | |
| sc::RenderedBallMolecule | |
| sc::RenderedMolecularSurface | |
| sc::RenderedMolecule | |
| sc::RenderedObject | |
| sc::RenderedObjectSet | |
| sc::RenderedPolygons | |
| sc::RenderedPolylines | |
| sc::RenderedSphere | |
| sc::RenderedStickMolecule | |
| MpqcCca::ReorderEngine | |
| sc::sma2::RepackScheme< NC, NA, NB > | Determine the cost of repacking arrays for a contraction |
| sc::ReplDiagSCMatrix | Replicated DiagSCMatrix |
| sc::ReplFockBuildMatrix | |
| sc::ReplSCMatrix | |
| sc::ReplSCMatrixKit | The ReplSCMatrixKit produces matrices that work in a many processor environment |
| sc::ReplSCMatrixListSubblockIter | |
| sc::ReplSCVector | |
| sc::ReplSymmSCMatrix | Replicated SymmSCMatrix |
| 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::SCDestructiveElementProduct | |
| sc::SCDimension | Used to determine the size and blocking of matrices |
| sc::SCElement | |
| sc::SCElementAccumulateDiagSCMatrix | |
| sc::SCElementAccumulateSCMatrix | |
| sc::SCElementAccumulateSCVector | |
| sc::SCElementAccumulateSymmSCMatrix | |
| sc::SCElementAssign | |
| sc::SCElementDot | |
| sc::SCElementInvert | |
| sc::SCElementKNorm | Computes k-norm of matrix |
| sc::SCElementMaxAbs | |
| sc::SCElementMaxElement< IterationRanges, BinaryPredicate > | Searches each range in IterationRanges for element i so that there is no element j in that Range for which Op(i<j) == true |
| sc::SCElementMinAbs | |
| 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::SCElementRandomize | |
| sc::SCElementScalarProduct | |
| sc::SCElementScale | |
| sc::SCElementScaleDiagonal | |
| sc::SCElementShiftDiagonal | |
| sc::SCElementSquareRoot | |
| sc::SCElementSum | |
| 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::SCFEnergy | |
| 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::SCMatrix3 | |
| 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::SCMatrixBlockList | |
| sc::SCMatrixBlockListIter | |
| sc::SCMatrixBlockListLink | |
| sc::SCMatrixCompositeSubblockIter | |
| sc::SCMatrixDiagBlock | The SCMatrixDiagBlock describes a diagonal piece of a matrix |
| sc::SCMatrixDiagBlockIter | |
| sc::SCMatrixDiagSubBlock | The SCMatrixDiagSubBlock describes a diagonal subblock of a matrix |
| sc::SCMatrixDiagSubBlockIter | |
| sc::SCMatrixdouble | |
| sc::SCMatrixIterationRanges | |
| sc::SCMatrixJointSubblockIter | |
| sc::SCMatrixKit | The SCMatrixKit abstract class acts as a factory for producing matrices |
| sc::SCMatrixListSubblockIter | |
| sc::SCMatrixLTriBlock | The SCMatrixLTriBlock describes a triangular piece of a matrix |
| sc::SCMatrixLTriBlockIter | |
| sc::SCMatrixLTriSubBlock | The SCMatrixLTriSubBlock describes a triangular subblock of a matrix |
| sc::SCMatrixLTriSubBlockIter | |
| sc::SCMatrixNullSubblockIter | |
| sc::SCMatrixRectBlock | The SCMatrixRectBlock describes a rectangular piece of a matrix |
| sc::SCMatrixRectBlockIter | |
| sc::SCMatrixRectSubBlock | The SCMatrixRectSubBlock describes a rectangular piece of a matrix |
| sc::SCMatrixRectSubBlockIter | |
| sc::SCMatrixSimpleSubblockIter | |
| 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::SCVector3 | |
| sc::SCVectordouble | |
| sc::SCVectorSimpleBlock | The SCVectorSimpleBlock describes a piece of a vector |
| sc::SCVectorSimpleBlockIter | |
| sc::SCVectorSimpleSubBlock | The SCVectorSimpleSubBlock describes a subblock of a vector |
| sc::SCVectorSimpleSubBlockIter | |
| sc::SD_RefWavefunction | RefWavefunction specialization for a single-determinant wave function |
| 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::DistShell::SharedData | This is used to store data that must be shared between all cooperating shell sets |
| sc::DistShellPair::SharedData | This is used to store data that must be shared between all cooperating shell pairs |
| sc::ShellExtent | |
| sc::ShellPairCints | ShellPairCints provides all primitive pair data for a given shell pair |
| sc::ShellPairIter | |
| 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::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::SimpleCo | The SimpleCo abstract class describes a simple internal coordinate of a molecule |
| sc::detail::SingletonCreationPolicy< T > | SingletonCreationPolicy is used to create Singletons |
| sc::mbptr12::Slater1D | Slater1D(k,x) = c x^k exp(-a*x) |
| sc::SlaterXFunctional | Implements the Slater exchange functional |
| sc::SO | |
| sc::SO_block | |
| 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::SphereShape | |
| sc::SphericalTransform | This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation |
| sc::SphericalTransformCCA | |
| 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::SphericalTransformComponentCints | |
| sc::SphericalTransformComponentLibint2 | |
| sc::SphericalTransformComponentV3 | |
| sc::SphericalTransformIter | This iterates through the components of a SphericalTransform |
| sc::SphericalTransformLibint2 | |
| sc::SphericalTransformV3 | |
| sc::PointInputData::SpinData | |
| sc::SpinFreeRDM< R > | SpinFreeRDM<R> is a spin-free reduced density matrix of rank R |
| sc::SpinFreeRDM< Zero > | This specialization is needed to make SpinFreeRDM<R>::rdm_m_1() work |
| sc::SpinMOPairIter | SpinMOPairIter iterates over pairs of spinorbitals |
| sc::SpinOrbitalPT2R12 | SpinOrbitalPT2R12: a universal second-order R12 correction |
| 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::Stack< T > | |
| sc::StateClassData | |
| sc::StateIn | Restores objects that derive from SavableState |
| sc::StateInBin | Read objects written with StateOutBin |
| 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::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::SteepestDescentOpt | |
| sc::Int2eV3::store_list | |
| sc::MOIntsTransform::StoreMethod | Describes the method of storing transformed MO integrals |
| 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::SumMolecularEnergy | Linear combination of MolecularEnergy objects |
| sc::sma2::SumOperation | |
| sc::SymmetryMOOrder | Order by symmetry first, then by energy, then by occ num |
| sc::SymmetryOperation | 3 by 3 matrix representation of a symmetry operation, such as a rotation or reflection |
| sc::SymmMolecularCoor | Derives from IntMolecularCoor |
| sc::SymmOneBodyIntIter | Iterator over symmetry unique shell pairs |
| sc::SymmSCMatrix | Abstract base class for symmetric double valued matrices |
| sc::SymmSCMatrix2SCExtrapData | |
| sc::SymmSCMatrix4SCExtrapData | |
| sc::SymmSCMatrixdouble | |
| sc::SymmSCMatrixNSCExtrapData | |
| sc::SymmSCMatrixSCExtrapData | |
| sc::SymmSCMatrixSCExtrapError | |
| sc::SymmTwoBodyIntIter | Iterator over symmetry unique shell quartets |
| sc::SymmTwoBodyTwoCenterIntIter | Iterator over symmetry unique shell pairs |
| 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::TaylorMolecularEnergy | |
| sc::TBGrad< T > | |
| sc::TCHF | |
| TCPClientConnection | |
| TCPIOSocket | |
| TCPServerConnection | |
| TCPServerSocket | |
| TCPSocket | |
| sc::TCSCF | |
| sc::Tensor | |
| sc::TensorExtrapData | |
| sc::TensorExtrapError | |
| sc::TensorIndexRangeIterator< NDIM > | TensorIndexRangeIterator is a direct product of shell ranges for each center |
| sc::TestEffH | |
| sc::TestRunnable | |
| 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::detail::ToDensityFittingType< TransformType > | |
| sc::detail::ToDensityFittingType< TwoBodyMOIntsTransform_ikjy > | |
| sc::detail::ToDensityFittingType< TwoBodyMOIntsTransform_iRjS > | |
| sc::detail::ToDensityFittingType< TwoBodyMOIntsTransform_ixjy > | |
| 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< EGH > | |
| 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::RefSCVector > | Specialization for RefSCVector |
| sc::detail::ToStateOut< sc::RefSymmSCMatrix > | Specialization for RefSymmSCMatrix |
| sc::Transform | |
| sc::TransformedDensityFitting | Computes density fitting for |ij) density from fitting of |iq) DensityFitting where q is the AO space supporting j |
| 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::Triangle | |
| sc::TriangleIntegrator | |
| sc::TriangulatedImplicitSurface | |
| sc::TriangulatedSurface | |
| sc::TriangulatedSurfaceIntegrator | |
| sc::TriInterpCoef | |
| sc::TriInterpCoefKey | |
| sc::sma2::triplet< T1, T2, T3 > | Stores a triplet of data |
| sc::tristate_less< T > | |
| sc::detail::tuple< NumCenters, T > | |
| MpqcCca::twobody_computer | |
| MpqcCca::twobody_deriv_computer | |
| MpqcCca::twobody_threecenter_computer | |
| MpqcCca::twobody_threecenter_deriv_computer | |
| 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::TwoBodyFockMatrixDFBuilder | Builds the two-body part of the Fock matrix in AO basis using DF-based algorithm |
| sc::TwoBodyFockMatrixTransformBuilder | 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::TwoBodyIntBatch< NumCenters > | This is an abstract base type for classes that compute integrals involving two electrons and 2 functions per electron |
| sc::TwoBodyIntBatchGeneric< NumCenters > | This is a generic implementation of TwoBodyIntBatch in terms of a TwoBodyInt |
| 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::detail::TwoBodyIntEval< 2 > | |
| sc::detail::TwoBodyIntEval< 3 > | |
| sc::detail::TwoBodyIntEval< 4 > | |
| sc::TwoBodyIntEvalType< 2 > | |
| sc::TwoBodyIntEvalType< 3 > | |
| sc::TwoBodyIntEvalType< 4 > | |
| sc::TwoBodyIntIter | |
| sc::TwoBodyIntLayout | Describes the physical layout of the integrals in TwoBodyIntsAcc |
| sc::TwoBodyIntLibint2 | This implements 4-center two-electron integrals in the IntLibint2 library |
| sc::TwoBodyIntType< 2 > | |
| sc::TwoBodyIntType< 3 > | |
| sc::TwoBodyIntType< 4 > | |
| sc::TwoBodyIntV3 | This implements electron repulsion integrals in the IntV3 library |
| sc::TwoBodyMOIntsRuntime< NumCenters > | Smart runtime support for computing MO-basis integrals |
| sc::detail::TwoBodyMOIntsRuntimeParams< 2 > | |
| sc::detail::TwoBodyMOIntsRuntimeParams< 3 > | |
| sc::detail::TwoBodyMOIntsRuntimeParams< 4 > | 4-center 2-body integrals can use density fitting |
| sc::TwoBodyMOIntsRuntimeUnion23 | TwoBodyMOIntsRuntimeUnion23 packages 2-center and 3-center runtimes |
| sc::TwoBodyMOIntsTransform | TwoBodyMOIntsTransform computes two-body integrals in MO basis using parallel integrals-direct AO->MO transformation |
| sc::TwoBodyMOIntsTransform_123Inds | |
| sc::TwoBodyMOIntsTransform_12Inds | |
| sc::TwoBodyMOIntsTransform_13Inds | |
| 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::TwoBodyMOIntsTransform_ixjy_df | TwoBodyMOIntsTransform_ixjy_df computes (ix|jy) integrals using parallel integral-direct density-fitting |
| sc::TwoBodyNCenterIntDescr< NumCenters, TwoBodyIntSet > | Implements descriptors for various two-body evaluators |
| sc::TwoBodyOper | Types of two-body integrals that TwoBodyInt understands: eri -- integral of  , r12 -- integral of  , r12ti -- integral of ![$[r_{12},\hat{T}_i]$](form_57.png) , r12_0_g12 -- integral of  , r12_m1_g12 -- integral of  , tig12 -- integral of ![$[\hat{T}_i,g_{12}]$](form_60.png) , g12t1g12 -- integral of ![$[g_{12},[\hat{T}_1,g_{12}]]$](form_61.png) , g12p4g12_m_g12t1g12t1 -- integral of ![$[g_{12}, [\hat{p}^4_1 + \hat{p}^4_2, g_{12}]] - 2 [g_{12}, [\hat{T}_1 + \hat{T}_2, g_{12}]](\hat{T}_1 + \hat{T}_2)$](form_62.png) , anti_g12g12 -- integral of |
| sc::TwoBodyOperDescr | Two-body operators with n functions per particle and given symmetry properties |
| sc::TwoBodyOperSet | Known operator sets |
| sc::TwoBodyOperSetDescr | Runtime version of OperSetTypeMap |
| sc::TwoBodySODerivInt | TwoBodySODerivInt computes four-center two-electron derivative integrals in a symmetry-adapted basis |
| sc::TwoBodySOInt | TwoBodySOInt computes four-center two-electron integrals in a symmetry-adapted basis |
| sc::TwoBodyTensorInfo | Provides information about the type of a two body tensor |
| 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::TwoBodyThreeCenterIntLibint2 | This implements 3-center 2-body integrals in the IntLibint2 library |
| sc::TwoBodyThreeCenterIntV3 | This implements electron repulsion integrals involving three centers in the IntV3 library |
| sc::TwoBodyThreeCenterMOIntsTransform | TwoBodyThreeCenterMOIntsTransform computes (xy|z) integrals, using parallel integral-direct AO->MO transformation |
| sc::TwoBodyThreeCenterMOIntsTransform_ijR | TwoBodyThreeCenterMOIntsTransform_ijR computes (ij|R) integrals, where R are atomic orbitals, using parallel integral-direct AO->MO transformation |
| sc::TwoBodyThreeCenterMOIntsTransform_ijR_using_iqR | TwoBodyThreeCenterMOIntsTransform_ijR computes (ij|R) integrals, where R are atomic orbitals, using (iq|R) integrals |
| 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::TwoBodyTwoCenterIntIter | |
| sc::TwoBodyTwoCenterIntLibint2 | This implements 2-center 2-body integrals in the IntLibint2 library |
| sc::TwoBodyTwoCenterIntOp | The 2-body analog of OneBodyIntOp |
| sc::TwoBodyTwoCenterIntV3 | This implements electron repulsion integrals involving two centers in the IntV3 library |
| sc::mbptr12::TwoParticleContraction | TwoParticleContraction contracts nrow-by-ncol bra- or ket-blocks of two 2-particle tensors i.e |
| sc::type_info_key | |
| 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::UncappedTorusHoleShape | |
| sc::UncontractedBasisSet | Used to form uncontracted Gaussian basis sets |
| sc::UnionBasisSet | UnionBasisSet constructs a union of two GaussianBasisSet objects |
| 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::UsedData | |
| sc::GaussianBasisSet::ValueData | This holds scratch data needed to compute basis function values |
| 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::vec2 | |
| sc::vec3 | |
| sc::vec4 | |
| vertex | |
| sc::Vertex | |
| vertices | |
| 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::WavefunctionWorld | Class WavefunctionWorld describes the environment of a Wavefunction |
| sc::WfnRDMCumulantOne | WfnRDMCumulantOne is the cumulant of WfnRDMOne |
| sc::WfnRDMOne | WfnRDMOne is a 1-RDM from a Wavefunction This implementation assumes that the AO-basis density matrix is available for this Wavefunction |
| 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::WriteOrbital | Writes an orbital at user defined grid points to the standard output or to a separate file |
| sc::WriteOrbitals | Writes orbitals at user defined grid points to the standard output or to a separate file |
| sc::WriteVectorGrid | WriteVectorGrid provides an interface for writing the value of a vector function evaluated at a given set of grid points to a file (compare to WriteGrid) |
| sc::X | |
| sc::XalphaFunctional | Implements the Xalpha exchange functional |
| sc::Y | |
| yy | |
| YYSTYPE |