Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Nboost
►Nnumeric
►Nbindings
►Ndetail
Cadaptor< Eigen::Map< Matrix >, Id, Enable >	Specialize numeric bindings traits for Eigen::Map
Cadaptor< Eigen::Matrix< T, Rows, 1, Options >, Id, Enable >
Cadaptor< mpqc::matrix< T, Options >, Id, Enable >	Specialize numeric bindings traits for mpqc::matrix
►Nproperty_tree
Ctranslator_between< std::basic_string< Ch, Traits, Alloc >, sc::XMLDataStream< T, val > >
►Ndetail
Cbasis_iterable
►Nmpqc	Contains new MPQC code since version 3
►Nci
►CCI	CI class template
CIO
CSort	Compare-by-rank functor
CConfig	CI configuration
CExcitation	One-particle excitation from string I to string J, {sign, ij, I, J}
CExcitations	Vector of single particle excitations from I to J subspace
CFull
CRestricted	Restricted CI Functor
CSpace	A CI space, marked by Spin S and rank
CSpin	Electron spin
►CString
CIndex	Implements a dense String->index map, appropriate for a full CI string sets
CList	String::List represents a set of String objects
Corbitals
CSubspace	A range of a space where all objects in the subspace range are assumed to have the same space rank
CSubspace< Any >	A subspace specialization that "discard" the spin parameter
►CSubspaceBlock
CSort
CSubspaceGrid	Grid of subspaces, represented as blocks of determinants defined by alpha/beta pair, along with sparsity information
►CVector	Block CI Vector, with 1-d (vector) and 2-d (matrix) access
CBlock1d	1-d vector sub-block
CBlock2d	2-d vector sub-block
►Ndetail
►NArrayServer
►Carray_proxy
CDescriptor
CSegment
CMessage
CThread
►NFile	Implementation details
CAttribute
CObject	A reference-counted HDF5 handle object, superclass for eg File, Dataset, Attribute, etc
CProperties
Cstatic_container
Cthreadsafe	HDF5 may not be threadsafe, in that case mpqc::mutex::global is used
►NTensor
Cassign
Cdivide_assign
Cintegral_tie	Index tie wrapper
Cis_integral
Cis_integral_tuple	"returns" true if every element of tuple T is an integral type
Cminus_assign
Cmultiply_assign
Cplus_assign
Crange_tie	Range tie wrapper
Carray_core_driver
Carray_file_driver
Carray_impl
Carray_impl< T, array_core_driver >
Carray_impl< T, array_file_driver >
Carray_parallel_impl
Carray_thread_comm
Carray_tile
CArrayBase
CArraySocket
CArrayTile
►Nlcao
CIntegrals	Wraps an MPQC integral engine (e.g
CShell
►NMPI
►CComm	MPI_Comm object wrapper/stub
COStream
CTask	Distributed task
►Nomp
Cmutex
Ctask
►Npurification
Cperformance
►NTA
►Ncluster
CClusterAtom
CClDFGEngine
CCLHF
CCLSCF	The taclscf class is the base class for implementing self-consistent proceedure for closed-shell molecules in MPQC3
CGEngineBase
CIntegralEnginePool	IntegralEnginePool is a class that will take a Ref<Engine> as a prototype and then clone it multiple times such that each thread has its own integral engine
CKCluster	Class holds the information about the differnt clusters in k-means tiling
CSCF
CShellOrder	Determines the clustering of shells based on k-means clustering
CTiledBasisSet	TiledBasisSet is a GaussianBasisSet in which basis functions/shells are grouped into tiles ("blocks")
CWavefunction	Wavefunction represents an electronic wave function expressed in terms of a basis set of atomic orbitals
CArray	Array implementation
Ccstring	Cstring-like object to cast a value to `const char*< > string`
CException	MPQC exception class
►CFile	Top-level file object that holds groups
CDataset	Array-like collection of data
CDataspace	A subset of File::Dataset
CDriver	Base file driver
CGroup	Directory-like container that holds datasets and other groups
CPOSIXDriver	POSIX I/O file driver, the default
CMADNESSRuntime
►Cmatrix	Matrix class derived from Eigen::Matrix with additional MPQC integration
CAssignable	An interface to enable matrix assignment from other containers
►Cmutex	Static mutex instances
Cglobal_mutex_tag
►Crange
Cblock_list
Ctie	Boost::tuple tie wrapper
CRange
Cstatic_mutex	Static mutex factory
CTensor	Tensor reference class
CTensorBase	Tensor base class
►CTensorColumnMajor	Tensor column major (i.e. first dimension is contiguous) storage order
Cmake_index
CTensorDimensionsException
CTensorIndexException
CTensorRangeException
CTensorRef	Tensor reference class
►CTensorRowMajor	Tensor row major (i.e. last dimension is contiguous) storage order
Cmake_index
Ctimer
Cvector	Vector class derived from Eigen::Matrix with additional MPQC integration
CWorld	World is a wrapper around madness::World
►Nsc	Contains all MPQC code up to version 3
►Ncadf
►Nassignments
CAssignments
CAtomCluster
►Ndetail
Cbegin_index_less
Cderef_compare
Cderef_compare< boost::shared_ptr< T >, compare >
Cderef_compare< T *, compare >
Cindex_less
Cmore_work
CAssignableAtom
CAssignableItem
CAssignableShell
CAssignableShellPair
CAssignmentBin
CAssignmentBinRow
CAssignmentGrid
CHistogram2d
CNode
CProductBlock
CTreeBlock
CTreeMatrix
►Ndetail
C__to_extern_C_eval
C_CABS_singles_h0t1	This functor helps to implement conjugate gradient CABS singles solver
C_Merger
C_OrbResponse	This functor helps to implement orbital response
CContainerAdaptor
CContainerAdaptor< RefDiagSCMatrix >
CDDPhiEvalCreator
CDeltaFunctionEvalCreator
CDeltaFunctionEvalCreator< 2 >
CDeltaFunctionEvalCreator< 3 >
CDeltaFunctionEvalCreator< 4 >
Cdiag_precond2	Makes a diagonal 2-index preconditioner: pc_x^y = -1/ ( <x\|O1\|x> - <y\|O2\|y> )
Cdiag_precond4	Makes a diagonal 4-index preconditioner: pc_xy^zw = -1/ ( <x\|O1\|x> + <y\|O2\|y> - <z\|O3\|z> - <w\|O4\|w> )
CDPhiEvalCreator
Ce_ij
CEqualTypes
CEqualTypes< A, A >
CERIEvalCreator
CERIEvalCreator< 2 >
CERIEvalCreator< 3 >
CERIEvalCreator< 4 >
CFockMatrixType
►CFockMatrixType< false >
CFactory
►CFockMatrixType< true >
CFactory
CG12DKHEvalCreator
CG12DKHEvalCreator< 2 >
CG12DKHEvalCreator< 3 >
CG12DKHEvalCreator< 4 >
CG12EvalCreator
CG12EvalCreator< 2 >
CG12EvalCreator< 3 >
CG12EvalCreator< 4 >
CG12NCEvalCreator
CG12NCEvalCreator< 2 >
CG12NCEvalCreator< 3 >
CG12NCEvalCreator< 4 >
CG12T1G12EvalCreator
CG12T1G12EvalCreator< 2 >
CG12T1G12EvalCreator< 3 >
CG12T1G12EvalCreator< 4 >
CGetValue	GetValue(keyval, key, i) grabs the value corresponding to key
CGetValue< bool >
CGetValue< char >
CGetValue< double >
CGetValue< float >
CGetValue< int >
CGetValue< long >
CGetValue< std::size_t >
CGetValue< std::string >
Chash_
Chash_< ShellIndexWithValue >
CHCoreEvalCreator
Cindex_equal_
CMakeTwoBodyTransform
CMakeTwoBodyTransform< false >
CMakeTwoBodyTransform< true >
CMuEvalCreator
CNeedDF
CNeedDF< TwoBodyMOIntsTransform_ixjy_df >
CNonsingletonCreationPolicy	NonsingletonCreationPolicy is used to create non-Singletons on heap
COneBodyEvalCreator
COrbital_relaxation_Abjai
CP4EvalCreator
CParsedTwoBodyIntKey
CParsedTwoBodyIntKey< 2 >
CParsedTwoBodyIntKey< 3 >
CParsedTwoBodyIntKey< 4 >
CPhiEvalCreator
Cpoint
CQEvalCreator
CR120G12EvalCreator
CR120G12EvalCreator< 2 >
CR120G12EvalCreator< 3 >
CR120G12EvalCreator< 4 >
CR12EvalCreator
CR12EvalCreator< 2 >
CR12EvalCreator< 3 >
CR12EvalCreator< 4 >
CR12m1G12EvalCreator
CR12m1G12EvalCreator< 2 >
CR12m1G12EvalCreator< 3 >
CR12m1G12EvalCreator< 4 >
Cselfenergy_denom	Makes a pseudo-3-index (4-index, but first index is dummy) self-energy denominator: (se_den)_{xyz} = 1/ ( E + <x\|Y\|x> - <y\|X1\|y> - <z\|X2\|z>);
CSEvalCreator
CSEvalCreator< 2u >
CSingletonCreationPolicy	SingletonCreationPolicy is used to create Singletons
CSumMerger
CTEvalCreator
CToDensityFittingType
CToDensityFittingType< TwoBodyMOIntsTransform_ikjy >
CToDensityFittingType< TwoBodyMOIntsTransform_iRjS >
CToDensityFittingType< TwoBodyMOIntsTransform_ixjy >
CTriangleWriter
CTriangleWriter< Derived, Eigen::Lower >
Ctuple
CTwoBodyEvalCreator
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::DeltaFunction >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::ERI >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::G12 >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::G12_T1_G12 >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::G12DKH >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::G12NC >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::R12 >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::R12_0_G12 >
CTwoBodyEvalCreator< NumCenters, TwoBodyOperSet::R12_m1_G12 >
CTwoBodyIntEval
CTwoBodyIntEval< 2 >
CTwoBodyIntEval< 3 >
CTwoBodyIntEval< 4 >
CTwoBodyMOIntsRuntimeParams
CTwoBodyMOIntsRuntimeParams< 2 >
CTwoBodyMOIntsRuntimeParams< 3 >
CTwoBodyMOIntsRuntimeParams< 4 >	4-center 2-body integrals can use density fitting
Cvertex
Cvertices
CVEvalCreator
►Nexpressions
Cdiag_tensor2_op
CTGeminalGenerator	Makes a geminal T tensor
Ctrace_tensor2_op
►Nfastpairiter
CMOPairIter	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
►Nlibint2
CInt2eCreator
►NManyBodyTensors	Contains classes used to compute many-body tensors
CApply_H0minusE0	Applies (H0 - E0)
CApply_Identity	Tensor elements are <pq\|\|rs>
CApply_Inverse_H0minusE0	Applies (H0 - E0)^{-1}, e.g. MP2 T2 tensor elements are <ij\|\|ab> /(e_i + e_j - e_a - e_b)
CApply_Inverse_Sqrt_H0minusE0	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()
►Nmath
CGaussian1D	Gaussian1D(k,x) = c x^k exp(-a*x^2)
CPowerExponential1D	PowerExponential1D(k,l,x) = c x^k exp(-a*x^l)
CSlater1D	Slater1D(k,x) = $c x^k \exp(-a*x)$
►Nmbptr12
CABS_OBS_Contraction	ABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the ABS approach
CCABS_OBS_Contraction	CABS_OBS_Contraction contracts 2 square nobs-by-nobs blocks for the CABS approach
CDirect_Contraction	Direct_Contraction is a straight scalar (dot) product of 2 rectangular blocks, scaled by scale
CTwoParticleContraction	TwoParticleContraction contracts nrow-by-ncol bra- or ket-blocks of two 2-particle tensors i.e
►Nmeta
Csplat_types
Csplat_values
►Nsma2
CArray	Implements a block sparse tensor
CArray24SCExtrapData	This permits an Array<2> and an Array<4> to be used with SelfConsistentExtrapolation derivatives
CArray24SCExtrapError	This permits an Array<2> and an Array<4> to be used with SelfConsistentExtrapolation derivatives
CArray2SCExtrapData	This permits Array<2>'s to be used with SelfConsistentExtrapolation derivatives
CArray2SCExtrapError	This permits Array<2>'s to be used with SelfConsistentExtrapolation derivatives
CArray4SCExtrapData	This permits Array<4>'s to be used with SelfConsistentExtrapolation derivatives
CArray4SCExtrapError	This permits Array<4>'s to be used with SelfConsistentExtrapolation derivatives
CArray6SCExtrapData	This permits Array<6>'s to be used with SelfConsistentExtrapolation derivatives
CArray6SCExtrapError	This permits Array<6>'s to be used with SelfConsistentExtrapolation derivatives
CBlockDistrib	Provides information about how blocks are distributed onto processes
CBlockInfo	BlockInfo stores info about a block of data
CBlockInfo< 0 >
CBlockInfo< 3 >
CBlockInfo< 4 >
CBlockIter	BlockIter loops through the all the indices within a block
CBlockIter< 0 >	Blocksize == 0 specialization of BlockIter
CCompleteBlockDistrib	Distribute blocks round-robin among processes using one or more index values
CContractPart	Represents an array and symbolic indices in a contraction
CContractProd	Represents a pairs of contracted array and their symbolic indices
CContractUnion
CData	Data holds the values for each block
CDivOperation
CIndex	An Index is used in the symbolic notation for contractions
CIndexList	An IndexList is a vector of indices
CIndexListLess	Functor for determining if one IndexList is less than another
CIndicesLess	Functor for comparing a block's indices
CIndicesLess< 0 >	Functor for comparing a block's indices
CPairBlockDistrib	An implementation of BlockDistrib using PairMapping
CPairMapping	Distributes pairs of indices among the processes
CRange	An Range represent a set of integers, [0, N)
CRepackScheme	Determine the cost of repacking arrays for a contraction
CSumOperation
Ctriplet	Stores a triplet of data
►Ntr1
►Narray
Carray	Array idential to C++0X arrays
Carray< T, 0 >
Cabs_greater
Cabs_less	Useful comparison functions
CAccResult	This associates a result datum with an accuracy
CAccResultInfo	This is like ResultInfo but the accuracy with which a result was computed as well as the desired accuracy are stored
CAccumEffectiveH
CAccumH	AccumH computes additions to the one body Hamiltonian
CAccumHNull	This specialization of AccumH does nothing
CActiveMessage	Derivatives of ActiveMessage can be constructed in one process and executed in another by using ActiveMessageGrp
CActiveMessageEcho	This is an ActiveMessage derivative used for testing
CActiveMessageGrp	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
CActiveMessageThread	This is a help class that is used by ActiveMessageGrp
CActiveMsgMemoryGrp	The ActiveMsgMemoryGrp abstract class specializes the MsgMemoryGrp class
CAggregateKeyVal
CALevelShift
CAlgorithmException	This exception is thrown whenever a problem with an algorithm is encountered
CAM05Functional	Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional
CAngularIntegrator	An abstract base class for angular integrators
CAnimatedObject
CAppearance
CApproximatePairWriter
CARMCIMemoryGrp	The ARMCIMemoryGrp concrete class provides an implementation of MsgMemoryGrp
CAssertionFailed	This is thrown when an assertion fails
CAssignedKeyVal
CAtom	Atom represents an atom in a Molecule
CAtomicOrbitalSpace	This is an OrbitalSpace describing a set of atomic orbitals
CAtomInfo	Information about atoms
CAtomProximityColorizer
Cauto_time_accumulator
Cauto_vec	The auto_vec class functions much like auto_ptr, except it contains references to arrays
►CAVLMap
Citerator
CAVLMapNode
►CAVLMMap
Cconst_iterator
Citerator
CAVLMMapNode
►CAVLSet
Citerator
CBacktrack	Implements backtrack line search algorithm
Cbasis_element_iterator
Cbasis_element_with_value_iterator
CBasisElementData
CBasisElementIteratorDereference
CBasisFileSet
CBasisFunctionData
CBatchElectronDensity	This a more highly optimized than ElectronDensity since everything is precomputed
CBcastState	This creates and forwards/retrieves data from either a BcastStateRecv or a BcastStateSend depending on the value of the argument to constructor
CBcastStateInBin	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
CBcastStateRecv	BcastStateRecv does the receive part of a broadcast of an object to all nodes
CBcastStateSend	BcastStateSend does the send part of a broadcast of an object to all nodes
CBecke88XFunctional	Implements Becke's 1988 exchange functional
CBeckeIntegrationWeight	Implements Becke's integration weight scheme
CBEMSolvent
CBEMSolventH	This specialization of AccumH computes the contribution to the energy and one body Hamiltonian from a solvent using a polarizable continuum model
CBendSimpleCo	Describes an bend internal coordinate of a molecule
CBFGSUpdate	The DFPUpdate class is used to specify a Broyden, Fletcher, Goldfarb, and Shanno hessian update scheme
CBiggestContribs
CBitArrayLTri
CBLevelShift
CBlockedDiagSCMatrix	Blocked DiagSCMatrix
CBlockedSCElementOp
CBlockedSCElementOp2
CBlockedSCElementOp3
CBlockedSCMatrix	Blocked SCMatrix
CBlockedSCMatrixKit	BlockedSCMatrixKit is a SCMatrixKit that produces blocked matrices
CBlockedSCVector
CBlockedSymmSCMatrix	Blocked SymmSCMatrix
CBoundsLibint2	Computes log2 bounds for a particular Int2e evaluator
CBuildIntV3
►CCADFCLHF	A specialization of CLHF that uses concentric atomic density fitting to build fock matrices
►CScreeningStatistics
CIteration
CCannotConstructMap
Ccanonical_aa	Can be used as a template argument to GenericPetiteList2
Ccanonical_aaaa	If the shell loop structure has 8 fold symmetry, then this should be used as the template argument to GenericPetiteList4
Ccanonical_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
Ccanonical_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
Ccanonical_ab	Can be used as a template argument to GenericPetiteList2
Ccanonical_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
Ccanonical_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
Ccanonical_abcd	If the shell loop structure has no symmetry, then this should be used as the template argument to GenericPetiteList4
CCartesianBasisSet	CartesianBasisSet is obtained from the parent basis by converting spherical harmonic shells to cartesian counterparts
CCartesianIter	CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization
CCartesianIterCCA
CCartesianIterGAMESS
CCartesianIterV3
CCartMolecularCoor	Implements Cartesian coordinates in a way suitable for use in geometry optimizations
CCCR12	CCR12 is the base class for CC and CC-R12 methods
CCCR12_Info	CCR12_Info is the compilation of members that are used in CC and CC-R12 methods
CCCR12_Triples
CCCSD
CCCSD_2Q_LEFT
CCCSD_2Q_RIGHT
CCCSD_2T_LEFT
CCCSD_2T_PR12_RIGHT
CCCSD_2T_R12_LEFT
CCCSD_2T_RIGHT
CCCSD_E
CCCSD_PT
CCCSD_PT_LEFT
CCCSD_PT_RIGHT
CCCSD_R12
CCCSD_R12_E
CCCSD_R12_PT_RIGHT
CCCSD_R12_T1
CCCSD_R12_T2
CCCSD_Sub_Bar_R12
CCCSD_Sub_Full_R12
CCCSD_Sub_R12	CCSD_Sub_R12 is the base class for some (2)R12 methods
CCCSD_SUB_R12_LEFT
CCCSD_SUB_R12_RIGHT
CCCSD_T1
CCCSD_T2
CCCSDPR12
CCCSDPR12_C
CCCSDPR12_T1
CCCSDPR12_T2
CCCSDT
CCCSDT_T1
CCCSDT_T2
CCCSDT_T3
CCCSDTQ
CCCSDTQ_T2
CCCSDTQ_T3
CCCSDTQ_T4
CCharacterTable	Workable character table for all of the non-cubic point groups
Cchunk_allocator
CCI	CI is a configuration interaction ManyBodyWavefunction
CClassDesc	This class is used to contain information about classes
CCLHF	CLHF is a Hartree-Fock specialization of CLSCF
CCLHFContribution	Computes components of the Fock matrix necessary for closed-shell calculations (i.e
CCLKS	This provides a Kohn-Sham implementation for closed-shell systems
CCLSCF	Base for classes implementing a self-consistent procedure for closed-shell molecules
CColor
CCompute	Means of keeping results up to date
CConcurrentCacheBase
CConcurrentCacheWithSymmetry	A cache of objects that can be safely accessed concurrently by threads that share memory
CConcurrentCacheWithSymmetry< val_type, KeySymmetry< IdentityKeyPermutation< sizeof...(key_types)> >, key_types... >	Specialization for the identity
CConcurrentCacheWithSymmetry< val_type, KeySymmetry< IdentityKeyPermutation< sizeof...(key_types)>, KeyTransposition< n_keys, idx1, idx2 > >, key_types... >	Specialization with only one transposition other than the identity
CConjugateGradientSolver	Solves linear system a(x) = b using conjugate gradient solver where a is a linear function of x
CConnollyShape	DiscreteConnollyShape and ConnollyShape should produce the same result
CConsumableResources	ConsumableResources keeps track of consumable resources (memory, disk)
CContiguousShellBlockList
Ccontribution
CConvergence	Used by the optimizer to determine when an optimization is converged
►CCoreIntsEngine	CoreIntsEngine manages Boys, and other core integral, engines
CEngine
CCorrelatedMOOrder	Order by occupation first, then by symmetry, then by energy
CCorrelatedSpinMOOrder	Order by occupation first, then by spin, then by symmetry, then by energy
CCorrelationTable	Correlation table between two point groups
CCreateTransformHints	Provides hints to the constructors of a Transform class that help configure its implementation
CCS2Sphere
CCSGrad34Qbtr
CCSGradErep12Qtr
CCSGradS2PDM
CCuspConsistentGeminalCoefficient	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
CDA4_Tile	Tile of a 4-index tensor that's "evaluated" when needed by reading from DistArray4
CDA4_Tile34	Tile of a <34> slice of <1234> that's "evaluated" when needed by reading from DistArray4 holding pqrs
►CDebugger	Describes what should be done when a catastrophic error causes unexpected program termination
CBacktrace	Creates a backtrace of a running program/thread
CDecoratedOrbital	Orbital = index + attributes
CDefaultPrintThresholds	Default print thresholds
CDenFunctional	An abstract base class for density functionals
CDenIntegrator	An abstract base class for integrating the electron density
CDensityColorizer
CDensityFitting	Decomposition by density fitting with respect to some kernel
CDensityFittingInfo	This class encapsulates objects needed to perform density fitting of a 4-center integral
CDensityFittingParams	DensityFittingParams defines parameters used by DensityFittingRuntime and other runtime components to compute density fitting objects
CDensityFittingRuntime	Smart runtime support for managing DensityFitting objects
Cder_centersv3_t
CDerivCenters	DerivCenters keeps track the centers that derivatives are taken with respect to
CDescribedClass	Classes which need runtime information about themselves and their relationship to other classes can virtually inherit from DescribedClass
CDescribedClassProxy	Classes deriving from this are used to generate objects of DescribedClass type
CDescribedXMLWritable
CDFCLHF	DFCLHF is a specialization of CLHF that uses a density-fitting FockBuild class for computing fock matrices
CDFPUpdate	Used to specify a Davidson, Fletcher, and Powell hessian update scheme
CDiagMolecularHessian	DiagMolecularHessian is an implementation of MolecularHessian that returns a hessian that is a diagonal matrix
CDiagSCMatrix	The SymmSCMatrix class is the abstract base class for diagonal double valued matrices
CDiagSCMatrixdouble
CDIIS	DIIS extrapolation
CDipoleIntV3
CDiscreteConnollyShape	DiscreteConnollyShape and ConnollyShape should produce the same result
CDisplacements	Maps displacements in terms of symmetrized coordinates to property values
CDistArray4	DistArray4 contains a set of one or more distributed dense 4-index arrays
CDistArray4_MemoryGrp	DistArray4_MemoryGrp handles transformed integrals held in memory by MemoryGrp
►CDistArray4_MPIIOFile	DistArray4_MPIIOFile handles transformed integrals stored in a binary file accessed through MPI-IO
CPairBlkInfo
CDistArray4_MPIIOFile_Ind	DistArray4_MPIIOFile_Ind handles transformed integrals stored in a binary file accessed through MPI-IO individual I/O routines
CDistArray4_Node0File	DistArray4_Node0File handles transformed integrals stored in file on node 0 (file is a usual POSIX binary file)
CDistArray4Creator	Creates new DistArray4 using TwoBodyFourCenterMOIntsRuntime and a vector of transform keys
CDistArray4Dimensions
CDistDiagSCMatrix	Distributed DiagSCMatrix
CDistFockBuildMatrix
CDistSCMatrix	Distributed SCMatrix
CDistSCMatrixKit	The DistSCMatrixKit produces matrices that work in a many processor environment
CDistSCMatrixListSubblockIter
CDistSCVector
►CDistShell	Distributes sets of shells either statically or dynamically
CSharedData	This is used to store data that must be shared between all cooperating shell sets
►CDistShellPair	Distributes shell pairs either statically or dynamically
CSharedData	This is used to store data that must be shared between all cooperating shell pairs
CDistSymmSCMatrix	Distributed SymmSCMatrix
CDummySavableState	Useful as a dummy template argument
►CEAVLMMap
Citerator
CEAVLMMapNode
CEdge
CEFCOpt	Implements eigenvector following as described by Baker in J
CEfieldDotVectorData
CEfieldDotVectorIntV3
CEfieldIntV3
CEGH	Energy + gradient + hessian
CElectronDensity	This is a Volume that computes the electron density
CEmptyOrbitalSpace	This is an empty OrbitalSpace
CEnergyMOOrder	Order by energy first, then by symmetry. EnergyCompare specifies the weak strict ordering of orbitals wrt energy
CETraIn	Class ETraIn evaluates transfer and overlap matrix in the basis of monomer SCF wave functions
CEulerMaclaurinRadialIntegrator	An implementation of a radial integrator using the Euler-Maclaurin weights and grid points
CException	This is a std::exception specialization that records information about where an exception took place
CExEnv	Used to find out about how the program is being run
CExtendedHuckelWfn	This computes the extended Huckel energy and wavefunction
CExtentData
CExtern_RefWavefunction	RefWavefunction specialization that is not an adaptor to a Wavefunction object
CExternMOInfo	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
CExternPT2R12	ExternPT2R12 is a PT2R12 wave function computed from external MO info and 2-RDM
CExternSpinFreeRDMOne	Reads 1-RDM from a text file
CExternSpinFreeRDMTwo	Reads 2-RDM from a text file
CFeatureNotImplemented	This is thrown when an attempt is made to use a feature that is not yet implemented
CFEMO	Describes a simple the free-electron molecular orbital model that can be used to guess the lowest-energy orbital configuration
CFermionBasicNCOper	Basic Nb-body number-conserving (nc) operator in sp representation
CFermionBasicNCOper< 1, FString >
►CFermionOccupationBlockString	Block-"sparse" string represents occupancies of an arbitrarily-large set of states as a set of alternating unoccupied/occupied blocks
CBlock	Continuous block of states of same occupancy
CFermionOccupationDBitString	"dense" string represents occupancies of a set of Ns states by a bitstring
CFermionOccupationNBitString	"dense" string represents occupancies of a set of Ns states by a fixed-width bitstring
CFermionStringDenseSet
CFermionStringSparseSet
CFileGrp	The FileGrp abstract class provides a way of accessing distributed file in a parallel machine
CFileOperationFailed	This is thrown when an operation on a file fails
CFileRender
CFinDispMolecularGradient	Computes the molecular gradient by finite differences of energies
CFinDispMolecularHessian	Computes the molecular hessian by finite displacements of gradients (or, if not available, energies)
CFJT	"Old" intv3 code from Curt Computes F_j(T) using 6-th order Taylor interpolation
CFjt	Evaluates the Boys function F_j(T)
CFockBlocks
CFockBuild	Works with the FockBuildThread class to generate Fock matrices for both closed shell and open shell methods
CFockBuildAM
CFockBuildAMG
CFockBuildCLHF	FockBuildCLHF is a specialization of CLHF that uses FockBuild class for computing fock matrices
CFockBuildMatrix
CFockBuildOp
CFockBuildRuntime	Build Fock matrices using some combination of FockBuilder objects
CFockBuildThread	Used to actually build the Fock matrix
CFockBuildThread_F11_P11	The FockBuildThread class is used to actually build the Fock matrix
CFockBuildThread_F12_P33	This is used to build the Fock matrix when none of the basis sets are equivalent
CFockContribution
CFockDist
CFockDistDynamic
CFockDistDynamic2
CFockDistDynamic4
CFockDistribution	FockDistribution is a factory for constructing the desired FockDist specialization
CFockDistStatic
CFockDistStatic2
CFockDistStatic4
CForceLink	This, together with ForceLinkBase, is used to force code for particular classes to be linked into executables
CForceLinkBase	This, together with ForceLink, is used to force code for particular classes to be linked into executables
CFreeData
CFullFermionStringSetBuild	Build all possible strings by distributing n particles in m states
CFunction	Abstract base class that, given a set of coordinates, will compute a value and possibly a gradient and hessian at that point
CG12NCLibint2	G12NCLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to explicitly correlated methods which use Gaussian geminals (formulation without commutators)
CG96XFunctional	Implements the Gill 1996 (G96) exchange functional
►CGaussianBasisSet	Used describe a basis set composed of atomic gaussian orbitals
CShell	Shell is a GaussianShell that is part of GaussianBasisSet, i.e. has a center on which it's centered
CValueData	This holds scratch data needed to compute basis function values
CGaussianBasisSetMap	A heavy-duty map from one GaussianBasisSet to another GaussianBasisSet
CGaussianFit	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
CGaussianShell	A shell of Gaussian functions
CGaussLegendreAngularIntegrator	An implementation of an angular integrator using the Gauss-Legendre weights and grid points
CGaussTriangleIntegrator
CGBuild
CGDIISOpt
►CGenericFockContribution	Much of the infrastructure needed by FockContribution specializations
CJKBlock
CJLocator
CKLocator
CPBlock
CGenericPetiteList2	This class provides a generalized 2-index petite list
CGenericPetiteList4	This class provides a generalized four index petite list
CGetLongOpt	Parse command line options
CGlobalCounter	Allows processes on the same SMP node to share a counter using SysV IPC semaphores
CGlobalMsgIter
CGPetiteList2	This class is an abstract base to a generalized 2-index petite list
CGPetiteList4	This class is an abstract base to a generalized four index petite list
CGPetiteListFactory	Produces generalized 2 and 4-index petite list objects
CGradDensityColorizer
CGrid	Defines a finite regular Carthesian grid
CGrpArithmeticAndReduce
CGrpArithmeticOrReduce
CGrpArithmeticXOrReduce
CGrpCompareReduce
CGrpFunctionReduce
CGrpMaxReduce
CGrpMinReduce
CGrpProductReduce
CGrpReduce
CGrpSumReduce
CGRTLibint2	GRTLibint2 is a specialization of Int2eLibint2 that computes two-electron integrals specific to linear R12 methods
CGSGeneralEffH
CGSHighSpinEffH
CGTOInfo	Provides precomputed information about Gaussian basis functions
CGuessMolecularHessian	GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates
Chash
CHCoreWfn	This is useful as an initial guess for other one body wavefunctions. Produces high-spin electron configurations
CHessianUpdate	The HessianUpdate abstract class is used to specify a hessian update scheme
CHSOSHF	HSOSHF is a Hartree-Fock specialization of HSOSSCF
CHSOSHFContribution	Computes components of the Fock matrix necessary for high-spin open-shell calculations (e.g
CHSOSKS	This provides a Kohn-Sham implementation for restricted-orbital high-spin open-shell systems
CHSOSSCF	Base for classes implementing a self-consistent procedure for high-spin open-shell molecules
CHSOSV1Erep1Qtr
CHundsFEMOSeeker	Finds the FEMO configuration that corresponds to the maximum multiplicity
CHypercubeGMI
CHypercubeTopology
CIdentityKeyPermutation
CIdentityTransform	The IdentityTransform is a special case of NonlinearTransform were no transformation takes place
Cignored_argument
CImplicitSurfacePolygonizer
CIndexRangeIterator	This is an abstract range of indices
CInputError	This is thrown when invalid input is provided
CInt1eLibint2	Int1eLibint2 is used by OneBodyIntLibint2 and OneBodyDerivIntLibint2 to implement IntegralLibint2
CInt1eV3	Int1eV3 is a class wrapper for the one body part of the C language IntV3 library
CInt2eLibint2	Int2eLibint2 is an interface to various specializations of two-electron integral evaluators implemented in Libint2
►CInt2eV3	Int2eV3 is a class wrapper for the two body part of the C language IntV3 library
Cstore_list
CIntCoor	The IntCoor abstract class describes an internal coordinate of a molecule
CIntCoorGen	IntCoorGen generates a set of simple internal coordinates for a molecule
CIntDescrFactory
CIntegral	The Integral abstract class acts as a factory to provide objects that compute one and two electron integrals
CIntegralLibint2	IntegralLibint2 computes integrals between Gaussian basis functions
CIntegralSetDescr	IntegralSetDescr contains all information necessary to construct an IntEval object that computes a particular set of integrals using an Integral factory
CIntegralV3	IntegralV3 computes integrals between Gaussian basis functions
CIntegrationWeight	An abstract base class for computing grid weights
CIntEvalToOperSetType
CIntEvalToOperSetType< TwoBodyInt >
CIntEvalToOperSetType< TwoBodyThreeCenterInt >
CIntEvalToOperSetType< TwoBodyTwoCenterInt >
Cintlist_struct
CIntMolecularCoor	The IntMolecularCoor abstract class describes a molecule's coordinates in terms of internal coordinates
CIntParams	This class passes optional operator parameters
CIntParamsG12	Used to pass params to Integral::g12()
CIntParamsOrigin	Passes params to Integral::dipole() and other factory methods which need r information
CIntParamsVoid	Passes params to Integral::electron_repulsion() and other factory methods which do not need parameters
CIntV3Arraydouble2
CIntV3Arraydouble3
CIntV3Arraydoublep2
CIntV3Arraydoublep3
CIntV3Arraydoublep4
CIntV3Arrayint3
CIntV3Arrayint4
Cip_cwk_stack_struct
Cip_keyword_tree_list_struct
Cip_keyword_tree_struct
Cip_string_list_struct
CIPV2
CIrreducibleRepresentation	Information associated with a particular irreducible representation of a point group
CIsosurfaceGen
CISphericalTransform	This describes a solid harmonic to Cartesian transform
CISphericalTransformLibint2
CISphericalTransformV3
CIterableBasisElementData
CKeyPermutation
CKeySymmetry
CKeyTransposition
CKeyVal
CKeyValValue	Represents the value of a keyword
CKeyValValueboolean	Represents a boolean value
CKeyValValuechar	Represents a char value
CKeyValValuedouble	Represents a double value
CKeyValValuefloat	Represents a float value
CKeyValValueint	Represents an int value
CKeyValValuelong	Represents a long value
CKeyValValuepchar	Represents a pointer to char value (deprecated, use KeyValValuestring)
CKeyValValueRefDescribedClass	Represents a Ref<DescribedClass> value
CKeyValValuesize	Represents a size_t value
CKeyValValuestring	Represents a std::string value
CKeyword
CLAMBDA_CCSD_T1
CLAMBDA_CCSD_T2
CLAMBDA_CCSDPR12_T1
CLAMBDA_CCSDPR12_T2
CLazyTensor	Tile of a DIM-order tensor that's "evaluated" when needed by calling ElementGenerator({i0, i1, i2, .... i_DIM-1})
CLCorr	A base class for local correlation methods
CLebedevLaikovIntegrator	An implementation of a Lebedev angular integrator
CLevelShift
CLibint2StaticInterface
CLibr12StaticInterface
CLimitExceeded	This is thrown when a limit is exceeded
CLineOpt	The LineOpt abstract class is used to perform one dimensional optimizations
CLinIPSimpleCo	Describes an in-plane component of a linear bend internal coordinate of a molecule
CLinKListGroup
CLinOPSimpleCo	Describes an out-of-plane component of a linear bend internal coordinate of a molecule
CLMP2	Computes the local second order perturbation theory energy
CLocalCLHFContribution
CLocalCLHFEnergyContribution
CLocalCLHFGradContribution
CLocalCLKSContribution
CLocalCLKSEnergyContribution
CLocalDiagSCMatrix	Local DiagSCMatrix
CLocalGBuild
CLocalHSOSContribution
CLocalHSOSEnergyContribution
CLocalHSOSGradContribution
CLocalHSOSKSContribution
CLocalHSOSKSEnergyContribution
CLocalLBGBuild
CLocalOSSContribution
CLocalOSSEnergyContribution
CLocalOSSGradContribution
CLocalSCMatrix
CLocalSCMatrixKit	The LocalSCMatrixKit produces matrices that work in a single processor environment
CLocalSCVector
CLocalSymmSCMatrix	Local SymmSCMatrix
CLocalTBGrad
CLocalTCContribution
CLocalTCEnergyContribution
CLocalTCGradContribution
CLocalUHFContribution
CLocalUHFEnergyContribution
CLocalUHFGradContribution
CLocalUKSContribution
CLocalUKSEnergyContribution
CLog2Bounds	Computes log2 bounds
CLSDACFunctional	An abstract base class for local correlation functionals
CLSelectBasisSet	Used to select shells by angular momentum from a mother basis
CLYPCFunctional	Implements the Lee, Yang, and Parr functional
CMachineTopology
CManyBodyWavefunction	ManyBodyWavefunction is a Wavefunction obtained from a reference OneBodyWavefunction (its orbitals or more)
CMaskedOrbitalSpace	This is an OrbitalSpace produced from an existing one by masking out some Orbitals
Cmat3
Cmat4
CMaterial
CMaxIterExceeded	This is thrown when an iterative algorithm attempts to use more iterations than allowed
CMBPT2	Implements several second-order perturbation theory methods
CMBPT2_R12	Implements several R12 second-order Moeller-Plesset perturbation theory methods
CMCSearch	This performs line searches with cubic steps
CMemAllocFailed	This is thrown when a memory allocation fails
CMemoryDataRequest	This is a help class used by ActiveMsgMemoryGrp
CMemoryDataRequestQueue	This is a help class used by ActiveMsgMemoryGrp
CMemoryGrp	The MemoryGrp abstract class provides a way of accessing distributed memory in a parallel machine
CMemoryGrpBuf	The MemoryGrpBuf class provides access to pieces of the global shared memory that have been obtained with MemoryGrp
CMemoryGrpRegion	The MemoryGrpRegion is a MemoryGrp proxy to a region of a MemoryGrp
CMemoryIter	This iterates through data in a global array
Cmessage_struct
►CMessageGrp	The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine
CMessageHandle
CMessageInfo
CMOIntsRuntime	MOIntsRuntime provides runtime support for computing 1-body and 2-body (2-, 3-, and 4-center) MO-basis integrals (with or without density fitting)
►CMOIntsTransform
CStoreMethod	Describes the method of storing transformed MO integrals
CMOIntsTransformFactory	MOIntsTransformFactory is a factory that produces MOIntsTransform objects
CMOLagrangian
CMolcasPT2R12	Interface between Molcas and MPQC to perform CASPT2F12 calculations
CMOLDEN_ExternReadMOInfo	Reads MO information from a text MOLDEN file
CMolecularCoor	The MolecularCoor abstract class describes the coordinate system used to describe a molecule
CMolecularEnergy	The MolecularEnergy abstract class inherits from the Function class
CMolecularFormula	Used to calculate the molecular formula of a Molecule
CMolecularFragment	MolecularFragment is a Molecule that is a fragment of another Molecule object
CMolecularFrequencies	Used to compute the molecular frequencies and thermodynamic information
CMolecularGradient	MolecularGradient is an abstract class that computes a molecule's first derivatives of the energy with respect to changes in the nuclear coordinates
CMolecularHessian	MolecularHessian is an abstract class that computes a molecule's second derivatives of the energy with respect to changes in the nuclear coordinates
CMolecularOrbitalAttributes	MO is irrep, energy, occupation number
CMolecularOrbitalMask	Mask out first n MOs in the order defined by Compare. By default mask the n lowest-energy MOs
CMolecularSpinOrbitalAttributes	Same as MolecularOrbitalAttributes, plus spin
CMolecule	Information about molecules
CMoleculeColorizer
CMolEnergyConvergence
CMolFreqAnimate
CMOPairIter	MOPairIter gives the ordering of orbital pairs
CMOPairIterFactory	This class produces MOPairIter objects
CMP2BasisExtrap
CMP2R12Energy	Class MP2R12Energy is the object that computes and maintains MP2-R12 energies
CMP2R12Energy_Diag	The class MP2R12Energy_Diag is an implementation of MP2R12Energy that supports Ten-no's diagonal orbital-invariant ansatz for closed and open-shells
CMP2R12Energy_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
CMP2R12EnergyUtil_base	Class MP2R12EnergyUtil_base is the abstract interface to utility functions used by MP2R12Energy derivatives
CMP2R12EnergyUtil_Diag
CMP2R12EnergyUtil_Diag_DifferentSpin	Class MP2R12EnergyUtil provides some misc functions to operate on (blocked) ijxy and xyxy matrices
CMP2R12EnergyUtil_Diag_SameSpin
CMP2R12EnergyUtil_Nondiag
►CMPIMessageGrp	Concrete implementation of MessageGrp that uses the MPI 1 library
CMessageHandleData
►CMPQCIn	Converts MPQC simple input to object-oriented input
CBasis
CMPQCInDatum
CMPQCInit	This helper class simplifies initialization of MPQC
CmPW91XFunctional	Implements a modified 1991 Perdew-Wang exchange functional
CMsgMemoryGrp	A MsgMemoryGrp that initializes its data using a messagegrp
CMsgStateBufRecv	The MsgStateBufRecv is an abstract base class that buffers objects sent through a MessageGrp
CMsgStateRecv	The MsgStateRecv is an abstract base class that receives objects from nodes in a MessageGrp
CMsgStateSend	The MsgStateSend is an abstract base class that sends objects to nodes in a MessageGrp
CMTensor	Tensor metadata is implicit; MTensor is Tensor + metadata
CMTMPIMemoryGrp	This MemoryGrp class requires a MT-safe MPI implementation
CMultiThreadTimer
CNBodyIntEval	This is an abstract base type for classes that compute integrals of general N-body operators described by OperDescr
CNBodyIntIter
CNCAccResult	This associates a result non-class datum with an accuracy
CNCentersToIntDescr
CNCentersToIntDescr< 1, 1 >
CNCentersToIntDescr< 2, 1 >
CNCentersToIntDescr< 2, 2 >
CNCentersToIntDescr< 3, 2 >
CNCentersToIntDescr< 4, 2 >
CNCResult	This is similar to Result, but can be used with non-class types
CNElFunctional	The NElFunctional computes the number of electrons
CNewP86CFunctional
CNewtonOpt	Implements Newton method
CNonblockedOrbitalSpace	This is an OrbitalSpace produced from an existing one by getting rid of the blocking
CNonlinearTransform	Transforms between two nonlinear coordinate systems
CNonreentrantUncappedTorusHoleShape
COBWfnRDMCumulantTwo	OBWfnRDMCumulantTwo is the cumulant of OBWfnRDMTwo
COBWfnRDMOne	OBWfnRDMOne is a 1-RDM from a OneBodyWavefunction
COBWfnRDMTwo	OBWfnRDMTwo is a 2-RDM from a OneBodyWavefunction
COneBody3IntOp
COneBodyDerivInt	OneBodyDerivInt is an abstract base class for objects that compute one body derivative integrals
COneBodyDerivIntV3	This implements one body derivative integrals in the IntV3 library
COneBodyFockMatrixBuilder	Builds the one-body part of the Fock matrix in AO basis
COneBodyInt	OneBodyInt is an abstract base class for objects that compute integrals between two basis functions
COneBodyIntEvalType	Returns the type of the evaluator for evaluating this set of two-body integrals
COneBodyIntEvalType< 1 >
COneBodyIntEvalType< 2 >
COneBodyIntIter
COneBodyIntLibint2	This implements most one body integrals in the Libint2 library
COneBodyIntOp
COneBodyIntParamsType	Which parameter set needed to specify the operator set?
COneBodyIntParamsType< OneBodyOperSet::ddphi >
COneBodyIntParamsType< OneBodyOperSet::dphi >
COneBodyIntParamsType< OneBodyOperSet::h >
COneBodyIntParamsType< OneBodyOperSet::mu >
COneBodyIntParamsType< OneBodyOperSet::p4 >
COneBodyIntParamsType< OneBodyOperSet::phi >
COneBodyIntParamsType< OneBodyOperSet::pVp >
COneBodyIntParamsType< OneBodyOperSet::q >
COneBodyIntParamsType< OneBodyOperSet::T >
COneBodyIntParamsType< OneBodyOperSet::V >
COneBodyIntTraits	Traits of a set of one-body integrals
COneBodyIntType
COneBodyIntType< 1 >
COneBodyIntType< 2 >
COneBodyIntV3	This implements most one body integrals in the IntV3 library
COneBodyNCenterIntDescr	Implements descriptors for various two-body evaluators
COneBodyOneCenterDerivInt	OneBodyOneCenterDerivInt is an abstract base class for objects that compute one body derivative integrals on a single center
COneBodyOneCenterInt	OneBodyOneCenterInt is an abstract base class for objects that compute integrals between two basis functions
COneBodyOneCenterWrapper
COneBodyOper	Describes one-body operators
COneBodyOperDescr	Describes permutational properties (hermiticity) of one-body operators
COneBodyOperSet	Describes sets of one-body operator
COneBodyOperSetDescr	Runtime version of OneBodyOperSetProperties
COneBodyOperSetProperties	Describes sets of two-body operators (
COneBodyOperSetProperties< OneBodyOperSet::ddphi >
COneBodyOperSetProperties< OneBodyOperSet::dphi >
COneBodyOperSetProperties< OneBodyOperSet::h >
COneBodyOperSetProperties< OneBodyOperSet::mu >
COneBodyOperSetProperties< OneBodyOperSet::p4 >
COneBodyOperSetProperties< OneBodyOperSet::phi >
COneBodyOperSetProperties< OneBodyOperSet::pVp >
COneBodyOperSetProperties< OneBodyOperSet::q >
COneBodyOperSetProperties< OneBodyOperSet::S >
COneBodyOperSetProperties< OneBodyOperSet::T >
COneBodyOperSetProperties< OneBodyOperSet::V >
COneBodySODerivInt	OneBodySODerivInt computes two-center one-electron integrals in a symmetry-adapted basis
COneBodySOInt	OneBodySOInt computes two-center one-electron integrals in a symmetry-adapted basis
COneBodyWavefunction	A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem
COOGLRender
COperatorDescr	For an operator (e.g
COptimize	Abstract base class for classes that find the extreme points of Function's
COptionalRefParameter
COrbital
COrbitalSpace	Class OrbitalSpace describes a range of orbitals that are linear combinations of Gaussian basis functions (e.g
COrbitalSpaceUnion	This is a union of two OrbitalSpaces s1 and s2
COrderedOrbitalSpace	This is an OrbitalSpace ordered according to the Order type
COrderedShellList
COrderedSpinOrbitalSpace	Same as OrderedOrbitalSpace, except for spin-orbitals
COSSHF	Hartree-Fock-like wave function for open-shell singlet electronic configurations
COSSSCF	SCF implementation for open-shell singlet electronic configurations
COutSimpleCo
COverlapOrthog	This class computes the orthogonalizing transform for a basis set
CP86CFunctional	Implements the Perdew 1986 (P86) correlation functional
CParallelRegionTimer	This is a parallel-away derivative of RegionTimer
CParameter
CParamsRegistry	This is a singleton registry that holds IntParams objects
CParentClass	Gives one parent class of a class
CParentClasses	Gives a list of parent classes of a class
CParenthesis2q
CParenthesis2t
CParenthesis2tNum	PTNum is the base class for the numerator in various (2)T/(2)Q models
CParsedDensityFittingKey	Parsed representation of a string key that represents fitting of a product of space1 and space2 into fspace
CParsedKeyVal
CParsedOneBodyIntKey	Parsed representation of a string key that represents a set of one-body integrals
CParsedOneBodyOperSetKey	Parsed representation of a string key that represents a one-body operator set (OneBodyOperSet + associated parameters)
►CParsedOrbitalSpaceKey	Parses keys of OrbitalSpace
Cexception
►CParsedTransformedOrbitalSpaceKey	Parses keys of a "transformed" OrbitalSpace
Cexception
CParsedTwoBodyFourCenterIntKey	Parsed representation of a string key that represents a set of 4-center 2-body integrals
CParsedTwoBodyMOIntsKeyInvolvesSpace
CParsedTwoBodyMOIntsKeyInvolvesSpace< 2 >
CParsedTwoBodyMOIntsKeyInvolvesSpace< 3 >
CParsedTwoBodyMOIntsKeyInvolvesSpace< 4 >
CParsedTwoBodyOperSetKey	Parsed representation of a string key that represents a two-body operator set (TwoBodyOperSet + associated parameters)
CParsedTwoBodyThreeCenterIntKey	Parsed representation of a string key that represents a set of 3-center 2-body integrals
CParsedTwoBodyTwoCenterIntKey	Parsed representation of a string key that represents a set of 2-center 2-body integrals
CParticleHoleOrbitalAttributes	Describes particle-hole attributes of orbitals
CPBECFunctional	Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional
CPBEXFunctional	Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional
CPermutedDensityFitting	Computes density fitting for \|ij) density from fitting of \|ji) DensityFitting
CPetiteList	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
CPipekMezeyLocalization	Performs a Pipek-Mezey orbital localization
CPointChargeData
CPointChargeIntV3
CPointGroup	Really a place holder for a CharacterTable
►CPointInputData	Contains data needed at each point by a DenFunctional
CSpinData
CPointOutputData	Contains data generated at each point by a DenFunctional
CPool
CPoolData
CPopulatedOrbitalSpace	PopulatedOrbitalSpace is an OrbitalSpace populated with a density
CPowellUpdate	Used to specify a Powell hessian update
CPrefixKeyVal
Cprim_pair_t
CPrimPairsLibint2	PrimPairsLibint2 contains primitive pair data
CProcFileGrp	The ProcFileGrp concrete class provides an implementation of FileGrp for a single processor
CProcMemoryGrp	The ProcMemoryGrp concrete class provides an implementation of MemoryGrp for a single processor
CProcMessageGrp	ProcMessageGrp provides a concrete specialization of MessageGrp that supports only one node
CProcThreadGrp	Privides a concrete thread group appropriate for an environment where there is only one thread
Cproduct_iterator
CProgrammingError	This is thrown when a situations arises that should be impossible
Cproperty	Helper class to connect a 'property' in a c++ class to getter/setter methods
CPsiCC	PsiCC is a Psi coupled cluster wave function
CPsiCC2	PsiCC2 is a concrete implementation of Psi ground-state CC2 wave function
CPsiCC3	PsiCC3 is a concrete implementation of Psi ground-state CC3 wave function
CPsiCC3_PT2R12	PsiCC3_PT2R12 is a concrete implementation of the ground-state $\mathrm{CC3}-(2)_{\overline{R12}}$ method
CPsiCC_PT2R12	PsiCC_PT2R12 is used to implement $\mathrm{CC}-(2)_{\overline{R12}}$ methods
CPsiCCSD	PsiCCSD is a concrete implementation of Psi CCSD wave function
CPsiCCSD_PT2R12	PsiCCSD_PT2R12 is a concrete implementation of the $\mathrm{CCSD}-(2)_{\overline{R12}}$ method
CPsiCCSD_PT2R12T	PsiCCSD_PT2R12T is a concrete implementation of the $\mathrm{CCSD}(T)_{\overline{R12}}$ method
CPsiCCSD_T	PsiCCSD_T is a concrete implementation of Psi CCSD(T) wave function
CPsiChkpt	PsiChkpt know to read data from Psi checkpoint file and convert it to conform to the representations expected in MPQC
CPsiCLHF	PsiCLHF is a concrete implementation of Psi RHF wave function
CPsiCorrWavefunction	PsiCorrWavefunction is a Psi correlated wave function
CPsiEffH
CPsiExEnv	PsiExEnv specifies a Psi execution environment
CPsiFile11	PsiFile11 is a Psi gradient file
CPsiHSOSHF	PsiHSOSHF is a concrete implementation of Psi ROHF wave function
CPsiInput	PsiInput is a Psi input file
CPsiRASCI	PsiRASCI is a general (RAS) CI PsiWavefunction
CPsiRASCI_RefWavefunction	RefWavefunction specialization for a general restricted-active-space multiconfiguration wave function
CPsiRASSCF	PsiRASSCF is a type of a PsiRASCI wavefunction that implements orbital optimization
CPsiRDMOne	PsiRDMOne is a 1-RDM from a PsiWavefunction
CPsiRDMTwo	PsiRDMTwo is a 2-RDM from a PsiWavefunction
CPsiSCF	PsiSCF is an abstract base for all Psi SCF wave functions
CPsiSCF_RefWavefunction	RefWavefunction specialization initialized with a PsiSCF wave function
CPsiSpinFreeRDMOne	PsiSpinFreeRDMOne is a spin-free 1-RDM from a PsiWavefunction
CPsiSpinFreeRDMTwo	PsiRDMTwo is a spin-free 2-RDM from a PsiWavefunction
CPsiUHF	PsiUHF is a concrete implementation of Psi UHF wave function
CPsiWavefunction	PsiWavefunction is an abstract base for all Psi wave functions
CPT2R12	PT2R12: a universal spin-free second-order R12 correction
CPthreadThreadGrp	Privides a concrete thread group appropriate for an environment where pthreads is available
CPTNum	PTNum is the base class for the numerator in various (T) models
CPumaThreadGrp	Privides a concrete thread group appropriate for the intel teraflops machine
CPW86XFunctional	Implements the Perdew-Wang 1986 (PW86) Exchange functional
CPW91CFunctional	The Perdew-Wang 1991 correlation functional computes energies and densities using the designated local correlation functional
CPW91XFunctional	The Perdew-Wang 1991 exchange functional computes energies and densities using the designated local correlation functional
CPW92LCFunctional	Implements the PW92 local (LSDA) correlation term
CPZ81LCFunctional	Implements the PZ81 local (LSDA) correlation functional
CQNewtonOpt	The QNewtonOpt implements a quasi-Newton optimization scheme
CR12Amplitudes	R12Amplitudes gives the amplitudes of some R12-ansatz-related terms in wave function
CR12EnergyIntermediates	The class R12EnergyIntermediates is the front-end to R12 intermediates
CR12IntEval	R12IntEval is the top-level class which computes intermediates occuring in R12 theories
►CR12Technology	R12Technology describes technical features of the R12 approach
CCorrelationFactor	CorrelationFactor is a set of one or more two-particle functions of the interparticle distance
CCorrParamCompare	Compares CorrelationParamaters corresponding to IntParam
CG12CorrelationFactor	G12CorrelationFactor stands for Gaussian geminals correlation factor, usable with methods that require commutator integrals
CG12NCCorrelationFactor	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
CGeminalDescriptor
CGeminalDescriptorFactory
CNullCorrelationFactor	NullCorrelationFactor stands for no correlation factor; only for test
CR12Ansatz	R12Ansatz specifies the manner in which the R12 geminals are constructed
CR12CorrelationFactor	R12CorrelationFactor stands for no correlation factor
CR12TwoBodyIntKeyCreator	Creates R12TwoBodyIntKey for the given CorrelationFactor
CR12WavefunctionWorld	Class R12WavefunctionWorld describes the environment of a Wavefunction implementing an R12 method
CRadialAngularIntegrator	An implementation of an integrator using any combination of a RadialIntegrator and an AngularIntegrator
CRadialIntegrator	An abstract base class for radial integrators
CRangeCreator	RangeCreator<T> is Functor which can be used up to n times to create objects of type T
CRangeLock
CRangeLockItem
CRDM	RDM<R> is a reduced density matrix of rank R
CRDM< Zero >	This specialization is needed to make RDM<R>::rdm_m_1() work
CRDMAMemoryGrp	The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp class
CRDMCumulant	RDMCumulant<R> is a reduced density matrix cumulant of rank R
CReadMolecularHessian	ReadMolecularHessian is an implementation of MolecularHessian that reads the hessian from a file
CRedundantCartesianIter	RedundantCartesianIter objects loop through all possible combinations of a given number of axes
CRedundantCartesianIterCCA
CRedundantCartesianIterGAMESS
CRedundantCartesianIterV3
CRedundantCartesianSubIter	Like RedundantCartesianIter, except a, b, and c are fixed to a given value
CRedundantCartesianSubIterCCA
CRedundantCartesianSubIterGAMESS
CRedundantCartesianSubIterV3
CRedundMolecularCoor	Redundant set of simple internal coordinates
Creentrant_auto_time_accumulator
Creentrant_time_accumulator_factory
CReentrantUncappedTorusHoleShape
CRef	A template class that maintains references counts
CRefBase	Provides a few utility routines common to all Ref template instantiations
CRefCount	The base class for all reference counted objects
CRefDiagSCMatrix	Smart pointer to an DiagSCMatrix specialization
CRefObjectEqual	This functor can be used as a binary predicate for standard algorithms
CRefSCDimension	Smart pointer to an SCDimension specialization
CRefSCMatrix	Smart pointer to an SCMatrix specialization
CRefSCVector	Smart pointer to an SCVector specialization
CRefSymmSCMatrix	Smart pointer to an SCSymmSCMatrix specialization
CRefSymmSCMatrixEqual	This functor compares RefSymmSCMatrix objects
CRefWavefunction	RefWavefunction represents the reference wave function (or, more generally, a state) used as a starting point for the introduction of electron correlation
CRefWavefunctionFactory	This factory produces the RefWavefunction that corresponds to the type of ref object
CRegionTimer	Used to record the time spent in a section of code
►CRegistry	Registry wraps std::map and can be policy-configured to act as a Singleton or a regular object
Cnot_found
CRender
CRenderedBallMolecule
CRenderedMolecularSurface
CRenderedMolecule
CRenderedObject
CRenderedObjectSet
CRenderedPolygons
CRenderedPolylines
CRenderedSphere
CRenderedStickMolecule
CReplDiagSCMatrix	Replicated DiagSCMatrix
CReplFockBuildMatrix
CReplSCMatrix
CReplSCMatrixKit	The ReplSCMatrixKit produces matrices that work in a many processor environment
CReplSCMatrixListSubblockIter
CReplSCVector
CReplSymmSCMatrix	Replicated SymmSCMatrix
CResult	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
CResultInfo	This is a base class for all of Compute's result types
CRunnable	DescribedClass with a pure virtual run member
CSavableState	Base class for objects that can save/restore state
CSavableStateProxy
CScaledTorsSimpleCo	Describes an scaled torsion internal coordinate of a molecule
CSCBlockInfo	SCBlockInfo contains blocking information for the SCDimension class
CSCDimension	Used to determine the size and blocking of matrices
CSCElement
CSCElementAccumulateDiagSCMatrix
CSCElementAccumulateSCMatrix
CSCElementAccumulateSCVector
CSCElementAccumulateSymmSCMatrix
CSCElementAssign
CSCElementBinaryPredicateAdapter	Adapts a binary predicate that acts on SCElement::value_type
CSCElementDAXPY	Does $Y(i,j) += a*X(i,j), \forall i,j$
CSCElementDestructiveProduct	Does $A(i,j) *= B(i,j), \forall i,j$
CSCElementDot
CSCElementFindExtremum	Searches each range in IterationRanges for element i so that there is no element j in that Range for which Op(i,j) == true
CSCElementInvert
CSCElementKNorm	Computes k-norm of matrix
CSCElementMaxAbs
CSCElementMinAbs
CSCElementOp	Objects of class SCElementOp are used to perform operations on the elements of matrices
CSCElementOp2	Very similar to the SCElementOp class except that pairs of blocks are treated simultaneously
CSCElementOp3	Very similar to the SCElementOp class except that a triplet of blocks is treated simultaneously
CSCElementRandomize
CSCElementScalarProduct	Evaluates $\sum_{i,j} A(i,j) * B(i,j)$
CSCElementScale
CSCElementScaleDiagonal
CSCElementShiftDiagonal
CSCElementSquareRoot
CSCElementSum
CSCException	This is a sc::Exception specialization that keeps track of the ClassDesc for the MPQC object from which it is thrown, and optional sc::Debugger::Backtrace object
CSCExtrapData	SCExtrapData hold the data to be extrapolated needed by SelfConsistentExtrapolation
CSCExtrapError	SCExtrapError holds the error data needed by SelfConsistentExtrapolation
CSCF	Base for all classes that use a self-consistent field procedure to solve an effective one body problem
CSCFEnergy
CSCFIterationData
CSCFIterationLogger
CSCFormIO	This utility class is used to print only on node 0 and to provide attractive indentation of output
CSCMatrix	Abstract base class for general double valued n by m matrices
CSCMatrix3
CSCMatrixBlock	SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors
CSCMatrixBlockIter	Used to described iterates that loop through the elements in a block
CSCMatrixBlockList
CSCMatrixBlockListIter
CSCMatrixBlockListLink
CSCMatrixCompositeSubblockIter
CSCMatrixDiagBlock	The SCMatrixDiagBlock describes a diagonal piece of a matrix
CSCMatrixDiagBlockIter
CSCMatrixDiagSubBlock	The SCMatrixDiagSubBlock describes a diagonal subblock of a matrix
CSCMatrixDiagSubBlockIter
CSCMatrixdouble
CSCMatrixIterationRanges
CSCMatrixJointSubblockIter
CSCMatrixKit	The SCMatrixKit abstract class acts as a factory for producing matrices
CSCMatrixListSubblockIter
CSCMatrixLTriBlock	The SCMatrixLTriBlock describes a triangular piece of a matrix
CSCMatrixLTriBlockIter
CSCMatrixLTriSubBlock	The SCMatrixLTriSubBlock describes a triangular subblock of a matrix
CSCMatrixLTriSubBlockIter
CSCMatrixNullSubblockIter
CSCMatrixRectBlock	The SCMatrixRectBlock describes a rectangular piece of a matrix
CSCMatrixRectBlockIter
CSCMatrixRectSubBlock	The SCMatrixRectSubBlock describes a rectangular piece of a matrix
CSCMatrixRectSubBlockIter
CSCMatrixSimpleSubblockIter
CSCMatrixSubblockIter	Objects of class SCMatrixSubblockIter are used to iterate through the blocks of a matrix
Cscprintf	This class allows `printf`-like output to be sent to an `ostream`
CSCVector	Abstract base class for double valued vectors
CSCVector3	3-element version of SCVector
CSCVectordouble
CSCVectorSimpleBlock	The SCVectorSimpleBlock describes a piece of a vector
CSCVectorSimpleBlockIter
CSCVectorSimpleSubBlock	The SCVectorSimpleSubBlock describes a subblock of a vector
CSCVectorSimpleSubBlockIter
CSD_RefWavefunction	RefWavefunction specialization for a single-determinant wave function
CSelfConsistentExtrapolation	The SelfConsistentExtrapolation abstract class is used to iteratively solve equations requiring a self consistent solution, such as,
CSetIntCoor	Describes a set of internal coordinates
CShape	A Shape is a Volume represents an 3D solid
Cshell_block_iterator
CShellBlockData
CShellBlockIterator
CShellBlockSkeleton
CShellData
CShellDataWithValue
CShellExtent
CShellIndexWithValue	Binds an integer index + real annotation, e.g. Shell index + associated operator norm
CShellPairIter
CShellPairLibint2	ShellPairLibint2 is an interface to PrimPairsLibint2
CShellPairsLibint2	ShellPairsLibint2 contains primitive pair data for all shell pairs formed from a pair of basis sets
CShellQuartetIter
CShellRotation	Compute the transformation matrices that maps a set of Cartesian functions to another set of Cartesian functions in a rotated coordinate system
CShmMemoryGrp	The ShmMemoryGrp concrete class provides an implementation of MsgMemoryGrp
CSimpleCo	The SimpleCo abstract class describes a simple internal coordinate of a molecule
CSingleReference_R12Intermediates	SingleReference_R12Intermediates computes R12/F12 intermediates using MPQC3 runtime
CSlaterXFunctional	Implements the Slater exchange functional
CSO
CSO_block
CSOBasis	A SOBasis object describes the transformation from an atomic orbital basis to a symmetry orbital basis
CSOTransform	SOTransform maintains a list of AO shells that are be used to compute the SO
CSOTransformFunction	SOTransformShell describes how an AO function contributes to an SO function in a particular SO shell
CSOTransformShell	SOTransformShell maintains a list of AO functions contribute to an SO function in a particular SO shell
CSpatialMOPairIter	SpatialMOPairIter gives the ordering of pairs of spatial orbitals
CSpatialMOPairIter_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
CSpatialMOPairIter_neq	SpatialMOPairIter_neq gives the ordering of pairs of spatial orbitals from different spaces
CSphereShape
CSphericalTransform	This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation
CSphericalTransformComponent	This is a base class for a container for a component of a sparse Cartesian to solid harmonic basis function transformation
CSphericalTransformComponentLibint2
CSphericalTransformComponentV3
CSphericalTransformIter	This iterates through the components of a SphericalTransform
CSphericalTransformLibint2
CSphericalTransformV3
CSpinFreeRDM	SpinFreeRDM<R> is a spin-free reduced density matrix of rank R
CSpinFreeRDM< Zero >	This specialization is needed to make SpinFreeRDM<R>::rdm_m_1() work
CSpinMOPairIter	SpinMOPairIter iterates over pairs of spinorbitals
CSpinOrbitalPT2R12	SpinOrbitalPT2R12: a universal second-order R12 correction
CSplitBasisSet	Used to split a basis set's contractions into multiple shells
CSSAccResult	This associates a result datum with an accuracy
CStack
CStateClassData
CStateIn
CStateInBin
CStateInData
CStateInFile
CStateInText
CStateOut
CStateOutBin
CStateOutData
CStateOutFile
CStateOutText
CStateRecv	StateRecv is a concrete specialization of MsgStateRecv that does the receive part of point to point communication in a MessageGrp
CStateSend	StateSend is a concrete specialization of MsgStateSend that does the send part of point to point communication in a MessageGrp
CStdDenFunctional	Used to construct the standard density functionals
CSteepestDescentOpt
CStreSimpleCo	Describes an stretch internal coordinate of a molecule
CStringKeyVal
CStringReplacementListIterator	Iterates over strings obtained by rank R replecement from a given string
CSumAccumH	This specialization of AccumHNull does nothing
CSumDenFunctional	The SumDenFunctional computes energies and densities using the a sum of energy density functions method
CSumIntCoor	SumIntCoor is used to construct linear combinations of internal coordinates
CSumMolecularEnergy	Linear combination of MolecularEnergy objects
CSuperpositionOfAtomicDensities	SuperpositionOfAtomicDensities is a OneBodyWavefunction useful as a guess for other OneBodyWavefunction objects
CSymmetryMOOrder	Order by symmetry first, then by energy, then by occ num
CSymmetryOperation	3 by 3 matrix representation of a symmetry operation, such as a rotation or reflection
CSymmMolecularCoor	Derives from IntMolecularCoor
CSymmOneBodyIntIter	Iterator over symmetry unique shell pairs
CSymmSCMatrix	Abstract base class for symmetric double valued matrices
CSymmSCMatrix2SCExtrapData
CSymmSCMatrix4SCExtrapData
CSymmSCMatrixdouble
CSymmSCMatrixNSCExtrapData
CSymmSCMatrixSCExtrapData
CSymmSCMatrixSCExtrapError
CSymmTwoBodyIntIter	Iterator over symmetry unique shell quartets
CSymmTwoBodyTwoCenterIntIter	Iterator over symmetry unique shell pairs
CSymRep	N dimensional matrix representation of a symmetry operation, such as a rotation or reflection
CSyscallFailed	This is thrown when an system call fails with an errno
CSystemException	This is thrown when a system problem occurs
CTaylor_Fjt	Uses Taylor interpolation of up to 8-th order to compute the Boys function
CTaylorMolecularEnergy
CTBGrad
CTCHF	Two-determinant wave function for open-shell singlet electronic configurations
CTCSCF	SCF implementation for open-shell singlet electronic configurations
CTensor
CTensorExtrapData
CTensorExtrapError
CTensorIndexRangeIterator	TensorIndexRangeIterator is a direct product of shell ranges for each center
CTestEffH
CTestRunnable
CThread	The Thread abstract class defines an interface which must be implemented by classes wishing to be run as threads
Cthreaded_iterator
CThreadGrp	The ThreadGrp abstract class provides a means to manage separate threads of control
CThreadLock	The ThreadLock abstract class provides mutex locks to be used in conjunction with ThreadGrp's
CThreadLockHolder	Acquire a lock on creation and release it on destruction
CThreadReplicated
CThreadTimer
Ctime_accumulator_factory
CTimedRegion	TimedRegion is a helper class for RegionTimer
CTimer	Uses RegionTimer to time intervals in an exception safe manner
CTimerHolder
CToleranceExceeded	This is thrown when when some tolerance is exceeded
CTorsSimpleCo	Describes an torsion internal coordinate of a molecule
CTransform
CTransformedDensityFitting	Computes density fitting for \|ij) density from fitting of \|iq) DensityFitting where q is the AO space supporting j
CTranslateData	Generic data translation
CTranslateDataByteSwap	Data translation to an external representation with bytes swapped
CTranslateDataIn	Convert data from other formats
CTranslateDataOut	Convert data to other formats
CTriangle
CTriangleIntegrator
CTriangulatedImplicitSurface
CTriangulatedSurface
CTriangulatedSurfaceIntegrator
CTriInterpCoef
CTriInterpCoefKey
Ctristate_less
CTwoBodyDerivInt	This is an abstract base type for classes that compute geometric derivatives of the integrals involving two electrons and four basis functions
CTwoBodyDerivIntLibint2	This implements electron repulsion derivative integrals in the IntV3 library
CTwoBodyDerivIntV3	This implements electron repulsion derivative integrals in the IntV3 library
CTwoBodyFockMatrixBuilder	Builds the two-body part of the Fock matrix in AO basis using integral-direct algorithm
CTwoBodyFockMatrixDFBuilder	Builds the two-body part of the Fock matrix in AO basis using DF-based algorithm
CTwoBodyFockMatrixTransformBuilder	Builds the two-body part of the Fock matrix in MO basis using AO->MO transforms
CTwoBodyGrid	Class TwoBodyGrid describes a set of coordinates of 2 particles
CTwoBodyInt	This is an abstract base type for classes that compute integrals involving two electrons and 2 functions per electron
CTwoBodyIntBatch	This is an abstract base type for classes that compute integrals involving two electrons and 2 functions per electron
CTwoBodyIntBatchGeneric	This is a generic implementation of TwoBodyIntBatch in terms of a TwoBodyInt
CTwoBodyIntDescrCreator	Creates TwoBodyIntDescr for correlation factor C
CTwoBodyIntEval	This is an abstract base type for classes that compute integrals involving two electrons and 2 functions per electron
CTwoBodyIntEvalType	Returns the type of the evaluator for evaluating this set of two-body integrals
CTwoBodyIntEvalType< 2 >
CTwoBodyIntEvalType< 3 >
CTwoBodyIntEvalType< 4 >
CTwoBodyIntIter
CTwoBodyIntLayout	Describes the physical layout of the integrals in TwoBodyIntsAcc
CTwoBodyIntLibint2	This implements 4-center two-electron integrals in the IntLibint2 library
CTwoBodyIntParamsType	Which parameter set needed to specify the operator set?
CTwoBodyIntParamsType< TwoBodyOperSet::DeltaFunction >
CTwoBodyIntParamsType< TwoBodyOperSet::ERI >
CTwoBodyIntParamsType< TwoBodyOperSet::G12 >
CTwoBodyIntParamsType< TwoBodyOperSet::G12_T1_G12 >
CTwoBodyIntParamsType< TwoBodyOperSet::G12DKH >
CTwoBodyIntParamsType< TwoBodyOperSet::G12NC >
CTwoBodyIntParamsType< TwoBodyOperSet::R12 >
CTwoBodyIntParamsType< TwoBodyOperSet::R12_0_G12 >
CTwoBodyIntParamsType< TwoBodyOperSet::R12_m1_G12 >
CTwoBodyIntShape	Describes types of integrals of 2-body operators
CTwoBodyIntTraits	Traits of a set of two-body integrals
CTwoBodyIntType
CTwoBodyIntType< 2 >
CTwoBodyIntType< 3 >
CTwoBodyIntType< 4 >
CTwoBodyIntV3	This implements electron repulsion integrals in the IntV3 library
CTwoBodyMOIntsRuntime	Smart runtime support for computing MO-basis integrals
CTwoBodyMOIntsRuntimeUnion23	TwoBodyMOIntsRuntimeUnion23 packages 2-center and 3-center runtimes; it also keeps track of 2-center matrix inverses
►CTwoBodyMOIntsTransform	TwoBodyMOIntsTransform computes two-body integrals in MO basis using parallel integrals-direct AO->MO transformation
CMOSpaces	Predefined enumerated type for the MO spaces
CTwoBodyMOIntsTransform_123Inds
CTwoBodyMOIntsTransform_12Inds
CTwoBodyMOIntsTransform_13Inds
CTwoBodyMOIntsTransform_ijxy	TwoBodyMOIntsTransform_ijxy computes (ij\|xy) integrals using parallel integrals-direct AO->MO transformation
CTwoBodyMOIntsTransform_ikjy	TwoBodyMOIntsTransform_ikjy computes (ik\|jy) integrals using parallel integrals-direct AO->MO transformation
CTwoBodyMOIntsTransform_iRjS	TwoBodyMOIntsTransform_iRjS computes (iR\|jS), or <ij\|RS> integrals, where R and S are atomic orbitals, using parallel integral-direct AO->MO transformation
CTwoBodyMOIntsTransform_ixjy	TwoBodyMOIntsTransform_ixjy computes (ix\|jy) integrals using parallel integrals-direct AO->MO transformation
CTwoBodyMOIntsTransform_ixjy_df	TwoBodyMOIntsTransform_ixjy_df computes (ix\|jy) integrals using parallel integral-direct density-fitting
CTwoBodyNCenterIntDescr	Implements descriptors for various two-body evaluators
CTwoBodyOper	Describes two-body operators
CTwoBodyOperDescr	Describes permutational properties (hermiticity, Bose/Fermi) of a two-body operator
CTwoBodyOperSet	Known two-body operator sets
CTwoBodyOperSetDescr	Describes sets of two-body operator
CTwoBodyOperSetProperties	Describes sets of two-body operators (
CTwoBodyOperSetProperties< TwoBodyOperSet::DeltaFunction >
CTwoBodyOperSetProperties< TwoBodyOperSet::ERI >
CTwoBodyOperSetProperties< TwoBodyOperSet::G12 >
CTwoBodyOperSetProperties< TwoBodyOperSet::G12_T1_G12 >
CTwoBodyOperSetProperties< TwoBodyOperSet::G12DKH >
CTwoBodyOperSetProperties< TwoBodyOperSet::G12NC >
CTwoBodyOperSetProperties< TwoBodyOperSet::R12 >
CTwoBodyOperSetProperties< TwoBodyOperSet::R12_0_G12 >
CTwoBodyOperSetProperties< TwoBodyOperSet::R12_m1_G12 >
CTwoBodySODerivInt	TwoBodySODerivInt computes four-center two-electron derivative integrals in a symmetry-adapted basis
CTwoBodySOInt	TwoBodySOInt computes four-center two-electron integrals in a symmetry-adapted basis
CTwoBodyTensorInfo	Provides information about the type of a two body tensor
CTwoBodyThreeCenterDerivInt	This is an abstract base type for classes that compute three centers integrals involving two electrons
CTwoBodyThreeCenterInt	This is an abstract base type for classes that compute integrals involving two electrons in three Gaussian functions
CTwoBodyThreeCenterIntLibint2	This implements 3-center 2-body integrals in the IntLibint2 library
CTwoBodyThreeCenterIntV3	This implements electron repulsion integrals involving three centers in the IntV3 library
CTwoBodyThreeCenterMOIntsTransform	TwoBodyThreeCenterMOIntsTransform computes (xy\|z) integrals, using parallel integral-direct AO->MO transformation
CTwoBodyThreeCenterMOIntsTransform_ijR	TwoBodyThreeCenterMOIntsTransform_ijR computes (ij\|R) integrals, where R are atomic orbitals, using parallel integral-direct AO->MO transformation
CTwoBodyThreeCenterMOIntsTransform_ijR_using_iqR	TwoBodyThreeCenterMOIntsTransform_ijR computes (ij\|R) integrals, where R are atomic orbitals, using (iq\|R) integrals
CTwoBodyTwoCenterDerivInt	This is an abstract base type for classes that compute two centers integrals involving two electrons
CTwoBodyTwoCenterInt	This is an abstract base type for classes that compute integrals involving two electrons in two Gaussian functions
CTwoBodyTwoCenterIntIter
CTwoBodyTwoCenterIntLibint2	This implements 2-center 2-body integrals in the IntLibint2 library
CTwoBodyTwoCenterIntOp	The 2-body analog of OneBodyIntOp
CTwoBodyTwoCenterIntV3	This implements electron repulsion integrals involving two centers in the IntV3 library
Ctype_info_key
CUHF	This provides an unrestricted Hartree-Fock implementation
CUKS	This provides a Kohn-Sham implementation for unrestricted-orbital open-shell systems
CUncapped5SphereExclusionShape
CUncappedTorusHoleShape
CUncontractedBasisSet	Used to form uncontracted Gaussian basis sets
CUnionBasisSet	UnionBasisSet constructs a union of two GaussianBasisSet objects
CUnionShape	A UnionShape is volume enclosed by a set of Shape's
CUnits	Used to perform unit conversions
CUnrestrictedSCF	A base class for unrestricted self-consistent-field methods
CUsedData
CVDWShape	Describes the surface of a molecule as the union of atom centered spheres, each the van der Waals radius of the atom
Cvec2
Cvec3
Cvec4
CVertex
CVolume	A Volume is a Function of three variables
CVWN1LCFunctional	The VWN1LCFunctional computes energies and densities using the VWN1 local correlation term (from Vosko, Wilk, and Nusair)
CVWN2LCFunctional	The VWN2LCFunctional computes energies and densities using the VWN2 local correlation term (from Vosko, Wilk, and Nusair)
CVWN3LCFunctional	The VWN3LCFunctional computes energies and densities using the VWN3 local correlation term (from Vosko, Wilk, and Nusair)
CVWN4LCFunctional	The VWN4LCFunctional computes energies and densities using the VWN4 local correlation term (from Vosko, Wilk, and Nusair)
CVWN5LCFunctional	The VWN5LCFunctional computes energies and densities using the VWN5 local correlation term (from Vosko, Wilk, and Nusair)
CVWNLCFunctional	An abstract base class from which the various VWN (Vosko, Wilk and Nusair) local correlation functional (1, 2, 3, 4, 5) classes are derived
CWavefunction	A Wavefunction is a MolecularEnergy that utilizies a GaussianBasisSet
CWavefunctionWorld	Class WavefunctionWorld describes the environment of a Wavefunction
CWriteBasisGrid
CWriteElectronDensity	Writes the electron density at user defined grid points to the standard output or to a separate file
CWriteElectrostaticPotential	Writes the electrostatic potential at user defined grid points to the standard output or to a separate file
CWriteGrid	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
CWriteMolden
CWriteOrbital	Writes an orbital at user defined grid points to the standard output or to a separate file
CWriteOrbitals	Writes orbitals at user defined grid points to the standard output or to a separate file
►CWriteVectorGrid	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)
CDimensionMap
CX
CXalphaFunctional	Implements the Xalpha exchange functional
CXMLDataStream
CXMLDataStreamTranslator
CXMLReadable
CXMLReader
CXMLWritable
CXMLWriter
CY
►Nstd	STL namespace
Chash< sc::FermionOccupationBlockString >	Specialization of std::hash for sc::FermionOccupationBlockString
Chash< sc::FermionOccupationDBitString >	Specialization of std::hash for sc::FermionOccupationDBitString
Chash< sc::FermionOccupationNBitString< Ns > >	Specialization of std::hash for sc::FermionOccupationNBitString
►NTiledArray
►Nexpressions
CTensorExpression
Cfunction_iterable
CGlobalFixture
CIterableBasisElementData
CIterableBasisElementData< Iterator, ShellBlockIterator< Iterable > >
Cshell_block_iterable
Cshell_iterable
►CShellBlockIterator
CSkeleton
CShellData