Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

sc::auto_vec< T > | The auto_vec class functions much like auto_ptr, except it contains references to arrays
sc::auto_vec< double > |
sc::AVLMap< K, T > |
sc::AVLMap< K, int > |
sc::AVLMapNode< K, T > |
sc::AVLMapNode< K, int > |
sc::AVLSet< K > |
sc::BasisFileSet |
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::BiggestContribs |
sc::BitArrayLTri |
sc::BuildIntV3 |
sc::canonical_aaaa | If the shell loop structure has 8 fold symmetry, then this should be used as the template argument to GPetite4
sc::canonical_aabb | If the shell loop structure has 2 fold symmetry between the first two indices and a 2 fold symmetry between the last two indices, then this should be used as the template argument to GPetite4
sc::canonical_aabc | If the shell loop structure has 2 fold symmetry between the first two indices, then this should be used as the template argument to GPetite4
sc::canonical_abcd | If the shell loop structure has no symmetry, then this should be used as the template argument to GPetite4
sc::CartesianIter | CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization
MPQC::CartesianIterCCA |
sc::CartesianIterCCA |
sc::CartesianIterCints |
sc::CartesianIterV3 |
sc::CCAEnv | Handles embedded CCA frameworks
sc::CharacterTable | Workable character table for all of the non-cubic point groups
MPQC::Chemistry_Molecule_impl | Symbol "MPQC.Chemistry_Molecule" (version 0.2)
MPQC::Chemistry_MoleculeViewer_impl | Symbol "MPQC.Chemistry_MoleculeViewer" (version 0.2)
MPQC::Chemistry_QC_Model_impl | Symbol "MPQC.Chemistry_QC_Model" (version 0.2)
MPQC::Chemistry_QC_ModelFactory_impl | Symbol "MPQC.Chemistry_QC_ModelFactory" (version 0.2)
sc::Color |
sc::commbuf_struct |
MPQC::ComponentClassDescription_impl | Symbol "MPQC.ComponentClassDescription" (version 0.2)
MPQC::ComponentFactory_impl | Symbol "MPQC.ComponentFactory" (version 0.2)
sc::Compute | Means of keeping results up to date
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::MolecularEnergy | The MolecularEnergy abstract class inherits from the Function class
sc::SumMolecularEnergy |
sc::MP2BasisExtrap |
sc::TaylorMolecularEnergy |
sc::Wavefunction | A Wavefunction is a MolecularEnergy that utilizies a GaussianBasisSet

sc::MBPT2

    The MBPT2 class implements several second-order perturbation theory

methods

sc::MBPT2_R12

    The MBPT2_R12 class implements several linear R12 second-order perturbation theory

methods

sc::OneBodyWavefunction | A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem
sc::ExtendedHuckelWfn |
sc::HCoreWfn |

sc::SCF

    The SCF class is the base for all classes that use a self-consistent

field procedure to solve an effective one body problem

sc::CLSCF

    The CLSCF class is a base for classes implementing a self-consistent

procedure for closed-shell molecules

sc::CLHF | CLHF is a Hartree-Fock specialization of CLSCF
sc::CLKS | This provides a Kohn-Sham implementation for closed-shell systems

sc::HSOSSCF

    The HSOSSCF class is a base for classes implementing a self-consistent

procedure for high-spin open-shell molecules

sc::HSOSHF | HSOSHF is a Hartree-Fock specialization of HSOSSCF
sc::HSOSKS | This provides a Kohn-Sham implementation for restricted-orbital high-spin open-shell systems
sc::OSSSCF |
sc::OSSHF |
sc::TCSCF |
sc::TCHF |
sc::UnrestrictedSCF | A base class for unrestricted self-consistent-field methods
sc::UHF | This provides an unrestricted Hartree-Fock implementation
sc::UKS | This provides a Kohn-Sham implementation for unrestricted-orbital open-shell systems
sc::PsiWavefunction | PsiWavefunction is an abstract base for all Psi wave functions
sc::PsiCCSD | PsiCCSD is a concrete implementation of Psi CCSD wave function
sc::PsiCCSD_T | PsiCCSD_T is a concrete implementation of Psi CCSD(T) wave function
sc::PsiSCF | PsiSCF is an abstract base for all Psi SCF wave functions
sc::PsiCLHF | PsiCLHF is a concrete implementation of Psi RHF wave function
sc::PsiHSOSHF | PsiHSOSHF is a concrete implementation of Psi ROHF wave function
sc::PsiUHF | PsiUHF is a concrete implementation of Psi UHF wave function
sc::Volume | A Volume is a Function of three variables
sc::BatchElectronDensity | This a more highly optimized than ElectronDensity since everything is precomputed
sc::ElectronDensity | This is a Volume that computer the electron density
sc::Orbital |
sc::Shape | A Shape is a Volume represents an 3D solid
sc::ConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result
sc::SphereShape |
sc::Uncapped5SphereExclusionShape |
sc::UncappedTorusHoleShape |
sc::NonreentrantUncappedTorusHoleShape |
sc::ReentrantUncappedTorusHoleShape |
sc::UnionShape | A UnionShape is volume enclosed by a set of Shape's
sc::DiscreteConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result
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::contribution |
CoordinateModel |
MPQC::ChemistryOpt_CoordinateModel_impl | Symbol "MPQC.ChemistryOpt_CoordinateModel" (version 0.2)
sc::CS2Sphere |
sc::der_centersv3_t |
sc::DerivCenters | DerivCenters keeps track the centers that derivatives are taken with respect to
sc::DescribedMemberDatum< T, C > |
sc::DiagSCMatrixdouble |
sc::DistShellPair | Distributes shell pairs either statically or dynamically
sc::distsize_t |
sc::EAVLMMap< K, T > |
sc::EAVLMMap< int, sc::IntegralLink > |
sc::EAVLMMap< K, sc::AVLMapNode< K, int > > |
sc::EAVLMMap< K, sc::AVLMapNode< K, T > > |
sc::EAVLMMap< sc::IntegralKey, sc::IntegralLink > |
sc::EAVLMMapNode< K, T > |
sc::EAVLMMapNode< int, sc::IntegralLink > |
sc::EAVLMMapNode< K, sc::AVLMapNode< K, int > > |
sc::EAVLMMapNode< K, sc::AVLMapNode< K, T > > |
sc::EAVLMMapNode< sc::IntegralKey, sc::IntegralLink > |
exception |
errno_exception |
sc::SCException | This is a std::exception specialization that records information about where an exception took place
sc::AlgorithmException | This exception is thrown whenever a problem with an algorithm is encountered
sc::MaxIterExceeded | This is thrown when an iterative algorithm attempts to use more iterations than allowed
sc::ToleranceExceeded | This is thrown when when some tolerance is exceeded
sc::InputError | This is thrown when invalid input is provided
sc::LimitExceeded< T > | This is thrown when a limit is exceeded
sc::ProgrammingError | This is thrown when a situations arises that should be impossible
sc::FeatureNotImplemented | This is thrown when an attempt is made to use a feature that is not yet implemented
sc::SystemException | This is thrown when a system problem occurs
sc::FileOperationFailed | This is thrown when an operation on a file fails
sc::MemAllocFailed | This is thrown when a memory allocation fails
sc::SyscallFailed | This is thrown when an system call fails with an errno
sc::ExEnv | Used to find out about how the program is being run
sc::ExtentData |
sc::ForceLinkBase< A > | This, together with ForceLink, is used to force code for particular classes to be linked into executables

sc::ForceLink< T, A >

    This, together with ForceLinkBase, is used to force code for particular

classes to be linked into executables

sc::FreeData |
MPQC::GaussianBasis_Atomic_impl | Symbol "MPQC.GaussianBasis_Atomic" (version 0.2)
MPQC::GaussianBasis_Molecular_impl | Symbol "MPQC.GaussianBasis_Molecular" (version 0.2)
MPQC::GaussianBasis_Shell_impl | Symbol "MPQC.GaussianBasis_Shell" (version 0.2)
sc::GetLongOpt |
sc::GlobalCounter |
sc::GrpReduce< T > |
sc::GrpArithmeticAndReduce< T > |
sc::GrpArithmeticOrReduce< T > |
sc::GrpArithmeticXOrReduce< T > |
sc::GrpFunctionReduce< T > |
sc::GrpMaxReduce< T > |
sc::GrpMinReduce< T > |
sc::GrpProductReduce< T > |
sc::GrpSumReduce< T > |
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::ClassDesc | This class is used to contain information about classes
sc::RefCount | The base class for all reference counted objects
sc::CorrelationTable | Correlation table between two point groups
sc::DescribedClass | Classes which need runtime information about themselves and their relationship to other classes can virtually inherit from DescribedClass
sc::AnimatedObject |
sc::MolFreqAnimate |
sc::Appearance |
sc::BEMSolvent |
sc::DescribedClassProxy |
sc::SavableStateProxy | Create a proxy for a SavableState object
sc::DiagSCMatrix | The SymmSCMatrix class is the abstract base class for diagonal double valued matrices
sc::BlockedDiagSCMatrix |
sc::DistDiagSCMatrix |
sc::LocalDiagSCMatrix |
sc::ReplDiagSCMatrix |

sc::FileGrp

    The FileGrp abstract class provides a way of accessing distributed

file in a parallel machine

sc::ProcFileGrp

    The ProcFileGrp concrete class provides an implementation of

FileGrp for a single processor

sc::GlobalMsgIter |
sc::HypercubeGMI |
sc::IntegralStorer |
sc::MachineTopology |
sc::HypercubeTopology |
sc::Material |

sc::MemoryGrp

    The MemoryGrp abstract class provides a way of accessing distributed

memory in a parallel machine

sc::MsgMemoryGrp | A MsgMemoryGrp that initializes its data using a messagegrp

sc::ActiveMsgMemoryGrp

    The ActiveMsgMemoryGrp abstract class specializes the MsgMemoryGrp

class

sc::MTMPIMemoryGrp | This MemoryGrp class requires a MT-safe MPI implementation

sc::RDMAMemoryGrp

    The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp

class

sc::ARMCIMemoryGrp | The ARMCIMemoryGrp concrete class provides an implementation of MsgMemoryGrp

sc::ShmMemoryGrp

    The ShmMemoryGrp concrete class provides an implementation of

MsgMemoryGrp

sc::ProcMemoryGrp

    The ProcMemoryGrp concrete class provides an implementation of

MemoryGrp for a single processor

sc::MessageGrp | The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine
sc::intMessageGrp | Uses integer message types to send and receive messages

sc::ShmMessageGrp

    The ShmMessageGrp class is an implementation of MessageGrp that

allows multiple process to be started that communicate with shared memory

sc::MPIMessageGrp

    The MPIMessageGrp class is an concrete implementation of MessageGrp

that uses the MPI 1 library

sc::ProcMessageGrp | ProcMessageGrp provides a concrete specialization of MessageGrp that supports only one node
sc::MoleculeColorizer |
sc::AtomProximityColorizer |
sc::DensityColorizer |
sc::GradDensityColorizer |
sc::PsiExEnv | PsiExEnv specifies a Psi calculation

sc::RegionTimer

    The RegionTimer class is used to record the time spent in a section of

code

sc::ParallelRegionTimer |
sc::Render |
sc::FileRender |
sc::OOGLRender |
sc::RenderedObject |
sc::RenderedMolecule |
sc::RenderedBallMolecule |
sc::RenderedMolecularSurface |
sc::RenderedStickMolecule |
sc::RenderedObjectSet |
sc::RenderedPolygons |
sc::RenderedPolylines |
sc::RenderedSphere |
sc::SavableState | Base class for objects that can save/restore state
sc::AccumH |
sc::AccumHNull |
sc::BEMSolventH |
sc::SumAccumH |
sc::AngularIntegrator | An abstract base class for angular integrators
sc::GaussLegendreAngularIntegrator | An implementation of an angular integrator using the Gauss-Legendre weights and grid points
sc::LebedevLaikovIntegrator | An implementation of a Lebedev angular integrator
sc::AtomInfo | Information about atoms

sc::Convergence

    The Convergence class is used by the optimizer to determine when an

optimization is converged

sc::MolEnergyConvergence |

sc::Debugger

    The Debugger class describes what should be done when a catastrophic

error causes unexpected program termination

sc::DenFunctional | An abstract base class for density functionals
sc::Becke88XFunctional | Implements Becke's 1988 exchange functional
sc::G96XFunctional | Implements the Gill 1996 (G96) exchange functional
sc::LSDACFunctional | An abstract base class for local correlation functionals
sc::PW92LCFunctional | Implements the PW92 local (LSDA) correlation term
sc::PZ81LCFunctional | Implements the PZ81 local (LSDA) correlation functional
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::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::LYPCFunctional | Implements the Lee, Yang, and Parr functional
sc::mPW91XFunctional | Implements a modified 1991 Perdew-Wang exchange functional
sc::NElFunctional | The NElFunctional computes the number of electrons
sc::NewP86CFunctional |
sc::P86CFunctional | Implements the Perdew 1986 (P86) correlation functional
sc::PBECFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional
sc::PBEXFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional
sc::PW86XFunctional | Implements the Perdew-Wang 1986 (PW86) Exchange functional
sc::PW91CFunctional | The Perdew-Wang 1991 correlation functional computes energies and densities using the designated local correlation functional
sc::PW91XFunctional | The Perdew-Wang 1991 exchange functional computes energies and densities using the designated local correlation functional
sc::SlaterXFunctional | Implements the Slater exchange functional
sc::SumDenFunctional | The SumDenFunctional computes energies and densities using the a sum of energy density functions method
sc::StdDenFunctional | Used to construct the standard density functionals
sc::XalphaFunctional | Implements the Xalpha exchange functional
sc::DenIntegrator | An abstract base class for integrating the electron density
sc::RadialAngularIntegrator | An implementation of an integrator using any combination of a RadialIntegrator and an AngularIntegrator
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::GaussianBasisSet

    The GaussianBasisSet class is used describe a basis set composed of

atomic gaussian orbitals

sc::GaussianShell | A Gaussian orbital shell

sc::HessianUpdate

    The HessianUpdate abstract class is used to specify a hessian update

scheme

sc::DFPUpdate

    The DFPUpdate class is used to specify a Davidson, Fletcher, and Powell

hessian update scheme

sc::BFGSUpdate

    The DFPUpdate class is used to specify a Broyden, Fletcher, Goldfarb,

and Shanno hessian update scheme

sc::PowellUpdate | Used to specify a Powell hessian update

sc::IntCoor

    The IntCoor abstract class describes an internal coordinate of a

molecule

sc::SimpleCo | The SimpleCo abstract class describes a simple internal coordinate of a molecule

sc::BendSimpleCo

    The BendSimpleCo class describes an bend internal coordinate of a

molecule

sc::LinIPSimpleCo

    The LinIPSimpleCo class describes an in-plane component of a linear

bend internal coordinate of a molecule

sc::LinOPSimpleCo

    The LinOPSimpleCo class describes an out-of-plane component of a linear

bend internal coordinate of a molecule

sc::OutSimpleCo |
sc::ScaledTorsSimpleCo | Describes an scaled torsion internal coordinate of a molecule
sc::StreSimpleCo | Describes an stretch internal coordinate of a molecule
sc::TorsSimpleCo | Describes an torsion internal coordinate of a molecule

sc::SumIntCoor

    SumIntCoor is used to construct linear combinations of internal

coordinates

sc::IntCoorGen | IntCoorGen generates a set of simple internal coordinates for a molecule

sc::Integral

    The Integral abstract class acts as a factory to provide objects that

compute one and two electron integrals

sc::IntegralCCA | IntegralCCA provides an SC client for CCA IntegralEvaluator components
sc::IntegralCints | IntegralCints computes integrals between Gaussian basis functions
sc::IntegralV3 | IntegralV3 computes integrals between Gaussian basis functions
sc::IntegrationWeight | An abstract base class for computing grid weights
sc::BeckeIntegrationWeight | Implements Becke's integration weight scheme
sc::MOIndexSpace | Class MOIndexSpace describes a range of molecular orbitals or similar objects that are linear combinations of basis functions (e.g
sc::MOIntsTransformFactory | MOIntsTransformFactory is a factory that produces MOIntsTransform objects

sc::MolecularCoor

    The MolecularCoor abstract class describes the coordinate system used

to describe a molecule

sc::CartMolecularCoor | Implements Cartesian coordinates in a way suitable for use in geometry optimizations

sc::IntMolecularCoor

    The IntMolecularCoor abstract class describes a molecule's coordinates

in terms of internal coordinates

sc::RedundMolecularCoor

    The RedundMolecularCoor class provides a redundant set of simple

internal coordinates

sc::SymmMolecularCoor | Derives from IntMolecularCoor

sc::MolecularFrequencies

    The MolecularFrequencies class is used to compute the molecular

frequencies and thermodynamic information

sc::MolecularHessian | MolecularHessian is an abstract class that computes a molecule's second derivatives of the energy with respect to changes in the nuclear coordinates
sc::DiagMolecularHessian | DiagMolecularHessian is an implementation of MolecularHessian that returns a hessian that is a diagonal matrix
sc::FinDispMolecularHessian | Computes the molecular hessian by finite displacements of gradients
sc::GuessMolecularHessian | GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates
sc::ReadMolecularHessian | ReadMolecularHessian is an implementation of MolecularHessian that reads the hessian from a file
sc::Molecule | Information about molecules
sc::MP2R12Energy | Class MP2R12Energy is the object that computes and maintains MP2-R12 energies
sc::Optimize | Abstract base class for classes that find the extreme points of Function's
sc::EFCOpt | Implements eigenvector following as described by Baker in J
sc::GDIISOpt |

sc::LineOpt

    The LineOpt abstract class is used to perform one dimensional

optimizations

sc::Backtrack |
sc::MCSearch | This performs line searches with cubic steps
sc::NewtonOpt |
sc::QNewtonOpt | The QNewtonOpt implements a quasi-Newton optimization scheme
sc::SteepestDescentOpt |
sc::OverlapOrthog | This class computes the orthogonalizing transform for a basis set
sc::PointGroup | Really a place holder for a CharacterTable
sc::R12IntEval | R12IntEval is the top-level class which computes intermediates occuring in linear R12 theories
sc::R12IntEvalInfo | Class R12IntEvalInfo contains information necessary for R12 intermediate evaluators
sc::R12IntsAcc | R12IntsAcc accumulates transformed (MO) integrals stored as (ijxy) where i, j, x, and, y lie in spaces I, J, X, and Y, respectively
sc::R12IntsAcc_MemoryGrp |
sc::R12IntsAcc_MPIIOFile |
sc::R12IntsAcc_MPIIOFile_Ind |
sc::R12IntsAcc_Node0File |
sc::RadialIntegrator | An abstract base class for radial integrators
sc::EulerMaclaurinRadialIntegrator | An implementation of a radial integrator using the Euler-Maclaurin weights and grid points
sc::SCBlockInfo | SCBlockInfo contains blocking information for the SCDimension class
sc::SCDimension | Used to determine the size and blocking of matrices
sc::SCElementOp | Objects of class SCElementOp are used to perform operations on the elements of matrices
sc::BlockedSCElementOp |
sc::LevelShift |
sc::ALevelShift |
sc::BLevelShift |
sc::OneBodyIntOp |
sc::SCElementAccumulateDiagSCMatrix |
sc::SCElementAccumulateSCMatrix |
sc::SCElementAccumulateSCVector |
sc::SCElementAccumulateSymmSCMatrix |
sc::SCElementAssign |
sc::SCElementDot |
sc::SCElementInvert |
sc::SCElementKNorm | Computed k-norm of matrix
sc::SCElementMaxAbs |
sc::SCElementMinAbs |
sc::SCElementRandomize |
sc::SCElementScale |
sc::SCElementScaleDiagonal |
sc::SCElementShiftDiagonal |
sc::SCElementSquareRoot |
sc::SCElementSumAbs |
sc::SCElementOp2 | Very similar to the SCElementOp class except that pairs of blocks are treated simultaneously
sc::BlockedSCElementOp2 |
sc::AccumEffectiveH |
sc::GSGeneralEffH |
sc::GSHighSpinEffH |
sc::PsiEffH |
sc::TestEffH |
sc::MOLagrangian |
sc::SCDestructiveElementProduct |
sc::SCElementScalarProduct |
sc::SCFEnergy |
sc::SCElementOp3 | Very similar to the SCElementOp class except that a triplet of blocks is treated simultaneously
sc::BlockedSCElementOp3 |
sc::OneBody3IntOp |
sc::SCExtrapData | SCExtrapData hold the data to be extrapolated needed by SelfConsistentExtrapolation
sc::SymmSCMatrix2SCExtrapData |
sc::SymmSCMatrix4SCExtrapData |
sc::SymmSCMatrixNSCExtrapData |
sc::SymmSCMatrixSCExtrapData |
sc::SCExtrapError | SCExtrapError holds the error data needed by SelfConsistentExtrapolation
sc::SymmSCMatrixSCExtrapError |
sc::SCMatrixBlock | SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors

sc::SCMatrixDiagBlock

    The SCMatrixDiagBlock describes a diagonal piece of a

matrix

sc::SCMatrixDiagSubBlock

    The SCMatrixDiagSubBlock describes a diagonal subblock of a

matrix

sc::SCMatrixLTriBlock

    The SCMatrixLTriBlock describes a triangular piece of a

matrix

sc::SCMatrixLTriSubBlock

    The SCMatrixLTriSubBlock describes a triangular subblock of a

matrix

sc::SCMatrixRectBlock

    The SCMatrixRectBlock describes a rectangular piece of a

matrix

sc::SCMatrixRectSubBlock

    The SCMatrixRectSubBlock describes a rectangular piece of a

matrix

sc::SCVectorSimpleBlock

    The SCVectorSimpleBlock describes a piece of a

vector

sc::SCVectorSimpleSubBlock

    The SCVectorSimpleSubBlock describes a subblock of a

vector

sc::SCMatrixBlockList |

sc::SelfConsistentExtrapolation

    The SelfConsistentExtrapolation abstract class is used to iteratively

solve equations requiring a self consistent solution, such as,

sc::DIIS | DIIS extrapolation
sc::SetIntCoor | Describes a set of internal coordinates
sc::ShellPairCints | ShellPairCints provides all primitive pair data for a given shell pair
sc::ShellPairsCints | ShellPairsCints contains primitive pair data for all shell pairs
sc::TwoBodyGrid | Class TwoBodyGrid describes a set of coordinates of 2 particles
sc::TwoBodyMOIntsTransform | TwoBodyMOIntsTransform computes two-body integrals in MO basis using parallel integrals-direct AO->MO transformation
sc::TwoBodyMOIntsTransform_ijxy | TwoBodyMOIntsTransform_ijxy computes (ij|xy) integrals using parallel integrals-direct AO->MO transformation
sc::TwoBodyMOIntsTransform_ikjy | TwoBodyMOIntsTransform_ikjy computes (ik|jy) integrals using parallel integrals-direct AO->MO transformation
sc::TwoBodyMOIntsTransform_ixjy | TwoBodyMOIntsTransform_ixjy computes (ix|jy) integrals using parallel integrals-direct AO->MO transformation
sc::Units | Used to perform unit converions
sc::SCMatrix | Abstract base class for general double valued n by m matrices
sc::BlockedSCMatrix |
sc::DistSCMatrix |
sc::LocalSCMatrix |
sc::ReplSCMatrix |

sc::SCMatrixKit

    The SCMatrixKit abstract class acts as a factory for producing

matrices

sc::BlockedSCMatrixKit |

sc::DistSCMatrixKit

    The DistSCMatrixKit produces matrices that work in a many processor

environment

sc::LocalSCMatrixKit

    The LocalSCMatrixKit produces matrices that work in a single processor

environment

sc::ReplSCMatrixKit

    The ReplSCMatrixKit produces matrices that work in a many processor

environment

sc::SCVector | Abstract base class for double valued vectors
sc::BlockedSCVector |
sc::DistSCVector |
sc::LocalSCVector |
sc::ReplSCVector |
sc::StateIn | Restores objects that derive from SavableState
sc::MsgStateBufRecv | The MsgStateBufRecv is an abstract base class that buffers objects sent through a MessageGrp
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::MsgStateRecv | The MsgStateRecv is an abstract base class that receives objects from nodes in a MessageGrp
sc::BcastStateRecv | BcastStateRecv does the receive part of a broadcast of an object to all nodes
sc::StateRecv | StateRecv is a concrete specialization of MsgStateRecv that does the receive part of point to point communication in a MessageGrp
sc::StateInFile | Reads state information from a file
sc::StateInBin | Read objects written with StateOutBin
sc::StateInText | Reads state information written with StateOutText
sc::StateOut | Serializes objects that derive from SavableState
sc::MsgStateSend | The MsgStateSend is an abstract base class that sends objects to nodes in a MessageGrp
sc::BcastStateSend | BcastStateSend does the send part of a broadcast of an object to all nodes
sc::StateSend | StateSend is a concrete specialization of MsgStateSend that does the send part of point to point communication in a MessageGrp
sc::StateOutFile | Writes state information to files
sc::StateOutBin | Save state to a binary file
sc::StateOutText | Writes out state information in an almost human readable format
sc::SymmSCMatrix | Abstract base class for symmetric double valued matrices
sc::BlockedSymmSCMatrix |
sc::DistSymmSCMatrix |
sc::LocalSymmSCMatrix |
sc::ReplSymmSCMatrix |
sc::ThreadGrp | The ThreadGrp abstract class provides a means to manage separate threads of control
sc::ProcThreadGrp | Privides a concrete thread group appropriate for an environment where there is only one thread
sc::PthreadThreadGrp | Privides a concrete thread group appropriate for an environment where pthreads is available
sc::PumaThreadGrp | Privides a concrete thread group appropriate for the intel teraflops machine
sc::Transform |
sc::TriangleIntegrator |
sc::GaussTriangleIntegrator |
sc::TriangulatedSurface |
sc::TriangulatedImplicitSurface |
sc::DipoleData |
sc::Edge |
sc::EfieldDotVectorData |
sc::FJT |
sc::GenPetite4 | This class is an abstract base to a generalized four index petite list
sc::GPetite4< C4 > | This class provides a generalized four index petite list
sc::Int1eCCA | Int1eCCA adapts CCA integrals components for use within SC
sc::Int1eCints | Int1eCints is used by OneBodyIntCints and OneBodyDerivIntCints to implement IntegralCints
sc::Int1eV3 | Int1eV3 is a class wrapper for the one body part of the C language IntV3 library
sc::Int2eCCA | Int2eCCA adapts CCA integrals components for use within SC
sc::Int2eCints | Int2eCints is an interface to various specializations of two-electron integral evaluators implemented in Cints
sc::EriCints | EriCints is a specialization of Int2eCints that computes electron repulsion integrals
sc::GRTCints | GRTCints is a specialization of Int2eCints that computes two-electron integrals specific to linear R12 methods
sc::Int2eV3 | Int2eV3 is a class wrapper for the two body part of the C language IntV3 library
sc::KeyVal | Designed to simplify the process of allowing a user to specify keyword/value associations to a C++ program
sc::AggregateKeyVal | This takes several KeyVal objects and makes them look like one KeyVal object
sc::AssignedKeyVal | This class allows keyval associations to be set up by the program, rather than determined by an external file
sc::PrefixKeyVal | PrefixKeyVal is a KeyVal that searches a different KeyVal using modified keys
sc::StringKeyVal | StringKeyVal is a base class for KeyVal implementations that store all values in a string format
sc::ParsedKeyVal | Converts textual information into keyword/value assocations
sc::KeyValValue |
sc::KeyValValueboolean |
sc::KeyValValuechar |
sc::KeyValValuedouble |
sc::KeyValValuefloat |
sc::KeyValValueint |
sc::KeyValValuepchar |
sc::KeyValValueRefDescribedClass |
sc::KeyValValuesize |
sc::KeyValValueString |
sc::KeyValValuestring |
sc::MOPairIter | MOPairIter gives the ordering of orbital pairs
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::NonlinearTransform | Transforms between two nonlinear coordinate systems
sc::IdentityTransform | The IdentityTransform is a special case of NonlinearTransform were no transformation takes place
sc::OneBodyDerivInt | OneBodyDerivInt is an abstract base class for objects that compute one body derivative integrals
sc::OneBodyDerivIntCCA | This implements one body derivative integrals
sc::OneBodyDerivIntV3 | This implements one body derivative integrals in the IntV3 library
sc::OneBodyInt | OneBodyInt is an abstract base class for objects that compute integrals between two basis functions
sc::DipoleIntV3 |
sc::EfieldDotVectorIntV3 |
sc::OneBodyIntCCA | This implements one body integrals through the CCA interface
sc::OneBodyIntCints | This implements most one body integrals in the Cints library
sc::OneBodyIntV3 | This implements most one body integrals in the IntV3 library
sc::PointChargeIntV3 |
sc::OneBodyIntIter |
sc::SymmOneBodyIntIter |
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::OneBodySOInt |
sc::PetiteList |
sc::PointChargeData |
sc::PrimPairsCints | PrimPairsCints contains primitive pair data
sc::PsiFile11 | PsiFile11 is a Psi gradient file
sc::PsiInput | PsiInput is a Psi input file
sc::R12Amplitudes | R12Amplitudes gives the amplitudes of some linear-R12-ansatz-related terms in wave function
sc::SCMatrixSubblockIter | Objects of class SCMatrixSubblockIter are used to iterate through the blocks of a matrix
sc::SCMatrixCompositeSubblockIter |
sc::SCMatrixJointSubblockIter |
sc::SCMatrixListSubblockIter |
sc::DistSCMatrixListSubblockIter |
sc::ReplSCMatrixListSubblockIter |
sc::SCMatrixNullSubblockIter |
sc::SCMatrixSimpleSubblockIter |
sc::ShellExtent |
sc::SOBasis | A SOBasis object describes the transformation from an atomic orbital basis to a symmetry orbital basis
sc::ThreadLock | The ThreadLock abstract class provides mutex locks to be used in conjunction with ThreadGrp's
sc::Triangle |
sc::TriInterpCoef |
sc::TwoBodyDerivInt | This is an abstract base type for classes that compute integrals involving two electrons
sc::TwoBodyDerivIntCCA | This implements two body derivative integrals through the CCA interface
sc::TwoBodyDerivIntCints | This implements electron repulsion derivative integrals in the IntV3 library
sc::TwoBodyDerivIntV3 | This implements electron repulsion derivative integrals in the IntV3 library
sc::TwoBodyInt | This is an abstract base type for classes that compute integrals involving two electrons
sc::TwoBodyIntCCA | This implements two body integrals through the CCA interface
sc::TwoBodyIntCints | This implements electron repulsion integrals in the IntCints library
sc::TwoBodyIntV3 | This implements electron repulsion integrals in the IntV3 library
sc::TwoBodySOInt |
sc::TwoBodyThreeCenterDerivInt | This is an abstract base type for classes that compute three centers integrals involving two electrons
sc::TwoBodyThreeCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in three Gaussian functions
sc::TwoBodyThreeCenterIntV3 | This implements electron repulsion integrals involving three centers in the IntV3 library
sc::TwoBodyTwoCenterDerivInt | This is an abstract base type for classes that compute two centers integrals involving two electrons
sc::TwoBodyTwoCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in two Gaussian functions
sc::TwoBodyTwoCenterIntV3 | This implements electron repulsion integrals involving two centers in the IntV3 library
sc::Vertex |
sc::X |
sc::Y |
MPQC::IntegralEvaluator2_impl | Symbol "MPQC.IntegralEvaluator2" (version 0.2)
MPQC::IntegralEvaluator3_impl | Symbol "MPQC.IntegralEvaluator3" (version 0.2)
MPQC::IntegralEvaluator4_impl | Symbol "MPQC.IntegralEvaluator4" (version 0.2)
MPQC::IntegralEvaluatorFactory_impl | Symbol "MPQC.IntegralEvaluatorFactory" (version 0.2)
sc::IntegralKey |
sc::IntegralLink |
sc::intlist_struct |
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::ImplicitSurfacePolygonizer |
sc::AVLMap< K, T >::iterator |
sc::AVLSet< K >::iterator |
sc::EAVLMMap< K, T >::iterator |
sc::LibintStaticInterface |
sc::Libr12StaticInterface |
sc::LocalCLHFContribution |
sc::LocalCLHFEnergyContribution |
sc::LocalCLHFGradContribution |
sc::LocalCLKSContribution |
sc::LocalCLKSEnergyContribution |
LocalHSOSContribution |
LocalHSOSEnergyContribution |
LocalHSOSGradContribution |
sc::LocalHSOSKSContribution |
sc::LocalHSOSKSEnergyContribution |
sc::LocalOSSContribution |
sc::LocalOSSEnergyContribution |
sc::LocalOSSGradContribution |
sc::LocalTCContribution |
sc::LocalTCEnergyContribution |
sc::LocalTCGradContribution |
sc::LocalUHFContribution |
sc::LocalUHFEnergyContribution |
sc::LocalUHFGradContribution |
sc::LocalUKSContribution |
sc::LocalUKSEnergyContribution |
sc::mat3 |
sc::mat4 |
sc::MemoryDataRequest |
sc::MemoryDataRequestQueue |
sc::MemoryGrpBuf< data_t > | The MemoryGrpBuf class provides access to pieces of the global shared memory that have been obtained with MemoryGrp
sc::MemoryIter |
sc::message_struct |
sc::MolecularFormula | Used to calculate the molecular formula of a Molecule
sc::MOPairIterFactory | This class produces MOPairIter objects
sc::TwoBodyMOIntsTransform::MOSpaces | Predefined enumerated type for the MO spaces
sc::MPQCIn |
sc::MPQCInDatum< T > |
sc::MPQCInDatum< char * > |
sc::MPQCInDatum< const char * > |
sc::MPQCInDatum< int > |
sc::MPQCInDatum< std::vector< int > * > |
sc::msgbuf_struct |
sc::R12IntsAcc_MPIIOFile::PairBlkInfo |
sc::Parameter< T > |
sc::Parameter< int > |
sc::Parameter< sc::Color > |
sc::ParentClass | Gives one parent class of a class
sc::ParentClasses | Gives a list of parent classes of a class
MPQC::Physics_Units_impl | Symbol "MPQC.Physics_Units" (version 0.2)
point |
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::prim_pair_t |
sc::RangeLock |
sc::RangeLockItem |
sc::RedundantCartesianIter | RedundantCartesianIter objects loop through all possible combinations of a given number of axes
sc::RedundantCartesianIterCCA |
sc::RedundantCartesianIterCints |
sc::RedundantCartesianIterV3 |
sc::RedundantCartesianSubIter | Like RedundantCartesianIter, except a, b, and c are fixed to a given value
sc::RedundantCartesianSubIterCCA |
sc::RedundantCartesianSubIterCints |
sc::RedundantCartesianSubIterV3 |
sc::RefBase | Provides a few utility routines common to all Ref template instantiations
sc::Ref< DiagSCMatrix > |
sc::RefDiagSCMatrix | Smart pointer to an DiagSCMatrix specialization
sc::Ref< GaussianBasisSet > |
sc::Ref< GaussianShell > |
sc::Ref< Integral > |
sc::Ref< OneBodyDerivInt > |
sc::Ref< OneBodyInt > |
sc::Ref< sc::AccumH > |
sc::Ref< sc::AngularIntegrator > |
sc::Ref< sc::Appearance > |
sc::Ref< sc::AtomInfo > |
sc::Ref< sc::BatchElectronDensity > |
sc::Ref< sc::BEMSolvent > |
sc::Ref< sc::Convergence > |
sc::Ref< sc::DenFunctional > |
sc::Ref< sc::DenIntegrator > |
sc::Ref< sc::DescribedClass > |
sc::Ref< sc::DipoleData > |
sc::Ref< sc::Edge > |
sc::Ref< sc::EfieldDotVectorData > |
sc::Ref< sc::FJT > |
sc::Ref< sc::Function > |
sc::Ref< sc::GaussianBasisSet > |
sc::Ref< sc::HessianUpdate > |
sc::Ref< sc::Int1eCCA > |
sc::Ref< sc::Int1eCints > |
sc::Ref< sc::Int1eV3 > |
sc::Ref< sc::Int2eCCA > |
sc::Ref< sc::Int2eCints > |
sc::Ref< sc::Int2eV3 > |
sc::Ref< sc::IntCoor > |
sc::Ref< sc::IntCoorGen > |
sc::Ref< sc::Integral > |
sc::Ref< sc::IntegralCCA > |
sc::Ref< sc::IntegralStorer > |
sc::Ref< sc::IntegrationWeight > |
sc::Ref< sc::KeyVal > |
sc::Ref< sc::LineOpt > |
sc::Ref< sc::LSDACFunctional > |
sc::Ref< sc::MachineTopology > |
sc::Ref< sc::Material > |
sc::Ref< sc::MemoryGrp > |
sc::Ref< sc::MessageGrp > |
sc::Ref< sc::MOIndexSpace > |
sc::Ref< sc::MOIntsTransformFactory > |
sc::Ref< sc::MolecularCoor > |
sc::Ref< sc::MolecularEnergy > |
sc::Ref< sc::MolecularFrequencies > |
sc::Ref< sc::MolecularHessian > |
sc::Ref< sc::Molecule > |
sc::Ref< sc::MoleculeColorizer > |
sc::Ref< sc::MP2R12Energy > |
sc::Ref< sc::OneBodyInt > |
sc::Ref< sc::OneBodyIntIter > |
sc::Ref< sc::OneBodyWavefunction > |
sc::Ref< sc::OverlapOrthog > |
sc::Ref< sc::PetiteList > |
sc::Ref< sc::PointChargeData > |
sc::Ref< sc::PointGroup > |
sc::Ref< sc::PrimPairsCints > |
sc::Ref< sc::PsiExEnv > |
sc::Ref< sc::PsiFile11 > |
sc::Ref< sc::PsiInput > |
sc::Ref< sc::PsiSCF > |
sc::Ref< sc::R12Amplitudes > |
sc::Ref< sc::R12IntEval > |
sc::Ref< sc::R12IntEvalInfo > |
sc::Ref< sc::R12IntsAcc > |
sc::Ref< sc::RadialIntegrator > |
sc::Ref< sc::RegionTimer > |
sc::Ref< sc::RenderedMolecule > |
sc::Ref< sc::RenderedObject > |
sc::Ref< sc::SavableState > |
sc::Ref< sc::sc::Int1eCCA > |
sc::Ref< sc::SCBlockInfo > |
sc::Ref< sc::SCExtrapData > |
sc::Ref< sc::SCExtrapError > |
sc::Ref< sc::SCF > |
sc::Ref< sc::SCMatrixBlock > |
sc::Ref< sc::SCMatrixBlockList > |
sc::Ref< sc::SCMatrixDiagBlock > |
sc::Ref< sc::SCMatrixKit > |
sc::Ref< sc::SCMatrixLTriBlock > |
sc::Ref< sc::SCMatrixRectBlock > |
sc::Ref< sc::SCMatrixSubblockIter > |
sc::Ref< sc::SCVector > |
sc::Ref< sc::SCVectorSimpleBlock > |
sc::Ref< sc::SelfConsistentExtrapolation > |
sc::Ref< sc::SetIntCoor > |
sc::Ref< sc::ShellPairCints > |
sc::Ref< sc::ShellPairsCints > |
sc::Ref< sc::SOBasis > |
sc::Ref< sc::ThreadGrp > |
sc::Ref< sc::ThreadLock > |
sc::Ref< sc::Transform > |
sc::Ref< sc::TriangleIntegrator > |
sc::Ref< sc::TriangulatedImplicitSurface > |
sc::Ref< sc::TriangulatedSurface > |
sc::Ref< sc::TriInterpCoef > |
sc::Ref< sc::TwoBodyDerivInt > |
sc::Ref< sc::TwoBodyGrid > |
sc::Ref< sc::TwoBodyInt > |
sc::Ref< sc::TwoBodyMOIntsTransform > |
sc::Ref< sc::Units > |
sc::Ref< sc::Vertex > |
sc::Ref< sc::Volume > |
sc::Ref< sc::Wavefunction > |
sc::Ref< SCDimension > |
sc::RefSCDimension | Smart pointer to an SCDimension specialization
sc::Ref< SCMatrix > |
sc::RefSCMatrix | Smart pointer to an SCMatrix specialization
sc::Ref< SCVector > |
sc::RefSCVector | Smart pointer to an SCVector specialization
sc::Ref< SymmSCMatrix > |
sc::RefSymmSCMatrix | Smart pointer to an SCSymmSCMatrix specialization
sc::Ref< T > | A template class that maintains references counts
RefCount |
Taylor_Fjt_Eval |
sc::ResultInfo | This is a base class for all of Compute's result types
sc::AccResultInfo | This is like ResultInfo but the accuracy with which a result was computed as well as the desired accuracy are stored
sc::AccResult< RefDiagSCMatrix > |
sc::AccResult< RefSCMatrix > |
sc::AccResult< RefSCVector > |
sc::AccResult< RefSymmSCMatrix > |
sc::NCAccResult< double > |
sc::AccResult< T > | This associates a result datum with an accuracy
sc::NCAccResult< T > | This associates a result non-class datum with an accuracy
sc::SSAccResult< T > | This associates a result datum with an accuracy
sc::NCResult< T > | This is similar to Result, but can be used with non-class types
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::SCFormIO | This utility class is used to print only on node 0 and to provide attractive indentation of output
sc::SCMatrix3 |
sc::SCMatrixBlockIter | Used to described iterates that loop through the elements in a block
sc::SCMatrixDiagBlockIter |
sc::SCMatrixDiagSubBlockIter |
sc::SCMatrixLTriBlockIter |
sc::SCMatrixLTriSubBlockIter |
sc::SCMatrixRectBlockIter |
sc::SCMatrixRectSubBlockIter |
sc::SCVectorSimpleBlockIter |
sc::SCVectorSimpleSubBlockIter |
sc::SCMatrixBlockListIter |
sc::SCMatrixBlockListLink |
sc::SCMatrixdouble |
sc::scprintf | This class allows `printf` like output to put sent to an `ostream`
sc::SCVector3 |
sc::SCVectordouble |
sc::DistShellPair::SharedData | This is used to store data that must be shared between all cooperating shell pairs
sc::ShellPairIter |
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
MPQC::SimpleDriver_impl | Symbol "MPQC.SimpleDriver" (version 0.2)
sc::SO |
sc::SO_block |
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::SphericalTransform | This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation
sc::ISphericalTransform | This describes a solid harmonic to Cartesian transform
sc::ISphericalTransformCCA |
sc::ISphericalTransformCints |
sc::ISphericalTransformV3 |
sc::SphericalTransformCCA |
sc::SphericalTransformCints |
sc::SphericalTransformV3 |
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::SphericalTransformComponentV3 |
sc::SphericalTransformIter | This iterates through the components of a SphericalTransform
sc::PointInputData::SpinData |
sc::Stack< T > |
sc::Stack< sc::Ref< sc::Appearance > > |
sc::Stack< sc::Ref< sc::Material > > |
sc::Stack< sc::Ref< sc::Transform > > |
sc::StateClassData |
sc::StateInData |
sc::StateOutData |
sc::Int2eV3::store_list |
sc::SymmetryOperation | 3 by 3 matrix representation of a symmetry operation, such as a rotation or reflection
sc::SymmSCMatrixdouble |
sc::SymRep | N dimensional matrix representation of a symmetry operation, such as a rotation or reflection
TCPSocket |
TCPIOSocket |
TCPClientConnection |
TCPServerConnection |
TCPServerSocket |
sc::Thread | The Thread abstract class defines an interface which must be implemented by classes wishing to be run as threads
sc::CSGrad34Qbtr |
sc::CSGradErep12Qtr |
sc::CSGradS2PDM |
sc::GBuild< T > |
sc::LocalGBuild< T > |
sc::LocalLBGBuild< T > |
sc::HSOSV1Erep1Qtr |
sc::TBGrad< T > |
sc::LocalTBGrad< T > |
sc::TwoBodyMOIntsTransform_123Inds |
sc::TwoBodyMOIntsTransform_12Inds |
sc::TwoBodyMOIntsTransform_13Inds |
sc::ThreadLockHolder | Acquire a lock on creation and release it on destruction
sc::TimedRegion |

sc::Timer

    The Timer class uses RegionTimer to time intervals in an exception safe

manner

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::TriangulatedSurfaceIntegrator |
sc::TriInterpCoefKey |
sc::TwoBodyIntIter |
sc::SymmTwoBodyIntIter |
sc::type_info_key |
sc::UsedData |
sc::GaussianBasisSet::ValueData | This holds scratch data needed to compute basis function values
sc::vec2 |
sc::vec3 |
sc::vec4 |
vertex |
vertices |
YYSTYPE |