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

MPQC |
CartesianIterCCA |
Chemistry_Molecule_impl | Symbol "MPQC.Chemistry_Molecule" (version 0.2)
Chemistry_MoleculeViewer_impl | Symbol "MPQC.Chemistry_MoleculeViewer" (version 0.2)
Chemistry_QC_Model_impl | Symbol "MPQC.Chemistry_QC_Model" (version 0.2)
Chemistry_QC_ModelFactory_impl | Symbol "MPQC.Chemistry_QC_ModelFactory" (version 0.2)
ChemistryOpt_CoordinateModel_impl | Symbol "MPQC.ChemistryOpt_CoordinateModel" (version 0.2)
ComponentClassDescription_impl | Symbol "MPQC.ComponentClassDescription" (version 0.2)
ComponentFactory_impl | Symbol "MPQC.ComponentFactory" (version 0.2)
GaussianBasis_Atomic_impl | Symbol "MPQC.GaussianBasis_Atomic" (version 0.2)
GaussianBasis_Molecular_impl | Symbol "MPQC.GaussianBasis_Molecular" (version 0.2)
GaussianBasis_Shell_impl | Symbol "MPQC.GaussianBasis_Shell" (version 0.2)
IntegralEvaluator2_impl | Symbol "MPQC.IntegralEvaluator2" (version 0.2)
IntegralEvaluator3_impl | Symbol "MPQC.IntegralEvaluator3" (version 0.2)
IntegralEvaluator4_impl | Symbol "MPQC.IntegralEvaluator4" (version 0.2)
IntegralEvaluatorFactory_impl | Symbol "MPQC.IntegralEvaluatorFactory" (version 0.2)
Physics_Units_impl | Symbol "MPQC.Physics_Units" (version 0.2)
SimpleDriver_impl | Symbol "MPQC.SimpleDriver" (version 0.2)
sc |
MPQCInDatum |
MPQCIn |
AtomInfo | Information about atoms

IntCoor

    The IntCoor abstract class describes an internal coordinate of a

molecule

SumIntCoor

    SumIntCoor is used to construct linear combinations of internal

coordinates

SetIntCoor | Describes a set of internal coordinates
IntCoorGen | IntCoorGen generates a set of simple internal coordinates for a molecule

MolecularCoor

    The MolecularCoor abstract class describes the coordinate system used

to describe a molecule

IntMolecularCoor

    The IntMolecularCoor abstract class describes a molecule's coordinates

in terms of internal coordinates

SymmMolecularCoor | Derives from IntMolecularCoor

RedundMolecularCoor

    The RedundMolecularCoor class provides a redundant set of simple

internal coordinates

CartMolecularCoor | Implements Cartesian coordinates in a way suitable for use in geometry optimizations
MolecularEnergy | The MolecularEnergy abstract class inherits from the Function class
SumMolecularEnergy |
MolEnergyConvergence |
FinDispMolecularHessian | Computes the molecular hessian by finite displacements of gradients
MolecularFormula | Used to calculate the molecular formula of a Molecule
MolecularHessian | MolecularHessian is an abstract class that computes a molecule's second derivatives of the energy with respect to changes in the nuclear coordinates
ReadMolecularHessian | ReadMolecularHessian is an implementation of MolecularHessian that reads the hessian from a file
GuessMolecularHessian | GuessMolecularHessian is an implementation of MolecularHessian that estimates the hessian based on the internal coordinates
DiagMolecularHessian | DiagMolecularHessian is an implementation of MolecularHessian that returns a hessian that is a diagonal matrix
Molecule | Information about molecules

MolecularFrequencies

    The MolecularFrequencies class is used to compute the molecular

frequencies and thermodynamic information

MolFreqAnimate |
RenderedMolecule |
RenderedStickMolecule |
RenderedBallMolecule |
MoleculeColorizer |
AtomProximityColorizer |
RenderedMolecularSurface |
VDWShape | Describes the surface of a molecule as the union of atom centered spheres, each the van der Waals radius of the atom
DiscreteConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result
CS2Sphere |
ConnollyShape | DiscreteConnollyShape and ConnollyShape should produce the same result
SimpleCo | The SimpleCo abstract class describes a simple internal coordinate of a molecule
StreSimpleCo | Describes an stretch internal coordinate of a molecule

BendSimpleCo

    The BendSimpleCo class describes an bend internal coordinate of a

molecule

TorsSimpleCo | Describes an torsion internal coordinate of a molecule
ScaledTorsSimpleCo | Describes an scaled torsion internal coordinate of a molecule
OutSimpleCo |

LinIPSimpleCo

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

bend internal coordinate of a molecule

LinOPSimpleCo

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

bend internal coordinate of a molecule

TaylorMolecularEnergy |
CartesianIter | CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integrals specialization
RedundantCartesianIter | RedundantCartesianIter objects loop through all possible combinations of a given number of axes
RedundantCartesianSubIter | Like RedundantCartesianIter, except a, b, and c are fixed to a given value
DerivCenters | DerivCenters keeps track the centers that derivatives are taken with respect to
DistShellPair | Distributes shell pairs either statically or dynamically
SharedData | This is used to store data that must be shared between all cooperating shell pairs
ExtentData |
ShellExtent |
BasisFileSet |

GaussianBasisSet

    The GaussianBasisSet class is used describe a basis set composed of

atomic gaussian orbitals

ValueData | This holds scratch data needed to compute basis function values
GaussianShell | A Gaussian orbital shell
canonical_aaaa | If the shell loop structure has 8 fold symmetry, then this should be used as the template argument to GPetite4
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
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
canonical_abcd | If the shell loop structure has no symmetry, then this should be used as the template argument to GPetite4
GenPetite4 | This class is an abstract base to a generalized four index petite list
GPetite4 | This class provides a generalized four index petite list

Integral

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

compute one and two electron integrals

EfieldDotVectorData |
DipoleData |
PointChargeData |
OneBodyInt | OneBodyInt is an abstract base class for objects that compute integrals between two basis functions
OneBodyOneCenterInt | OneBodyOneCenterInt is an abstract base class for objects that compute integrals between two basis functions
OneBodyOneCenterWrapper |
ShellPairIter |
OneBodyIntIter |
OneBodyIntOp |
OneBody3IntOp |
OneBodyDerivInt | OneBodyDerivInt is an abstract base class for objects that compute one body derivative integrals
OneBodyOneCenterDerivInt | OneBodyOneCenterDerivInt is an abstract base class for objects that compute one body derivative integrals on a single center
OverlapOrthog | This class computes the orthogonalizing transform for a basis set
contribution |
SO |
SO_block |
PetiteList |
ShellRotation | Compute the transformation matrices that maps a set of Cartesian functions to another set of Cartesian functions in a rotated coordinate system
SOTransformFunction | SOTransformShell describes how an AO function contributes to an SO function in a particular SO shell
SOTransformShell | SOTransformShell maintains a list of AO functions contribute to an SO function in a particular SO shell
SOTransform | SOTransform maintains a list of AO shells that are be used to compute the SO
SOBasis | A SOBasis object describes the transformation from an atomic orbital basis to a symmetry orbital basis
OneBodySOInt |
TwoBodySOInt |
SymmOneBodyIntIter |
SymmTwoBodyIntIter |
TwoBodyInt | This is an abstract base type for classes that compute integrals involving two electrons
TwoBodyThreeCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in three Gaussian functions
TwoBodyTwoCenterInt | This is an abstract base type for classes that compute integrals involving two electrons in two Gaussian functions
ShellQuartetIter |
TwoBodyIntIter |
TwoBodyDerivInt | This is an abstract base type for classes that compute integrals involving two electrons
TwoBodyThreeCenterDerivInt | This is an abstract base type for classes that compute three centers integrals involving two electrons
TwoBodyTwoCenterDerivInt | This is an abstract base type for classes that compute two centers integrals involving two electrons
SphericalTransformComponent | This is a base class for a container for a component of a sparse Cartesian to solid harmonic basis function transformation
SphericalTransform | This is a base class for a container for a sparse Cartesian to solid harmonic basis function transformation
ISphericalTransform | This describes a solid harmonic to Cartesian transform
SphericalTransformIter | This iterates through the components of a SphericalTransform
CartesianIterCints |
RedundantCartesianIterCints |
RedundantCartesianSubIterCints |
IntegralCints | IntegralCints computes integrals between Gaussian basis functions
EriCints | EriCints is a specialization of Int2eCints that computes electron repulsion integrals
LibintStaticInterface |
GRTCints | GRTCints is a specialization of Int2eCints that computes two-electron integrals specific to linear R12 methods
Libr12StaticInterface |
Int1eCints | Int1eCints is used by OneBodyIntCints and OneBodyDerivIntCints to implement IntegralCints
Int2eCints | Int2eCints is an interface to various specializations of two-electron integral evaluators implemented in Cints
OneBodyIntCints | This implements most one body integrals in the Cints library
prim_pair_t |
PrimPairsCints | PrimPairsCints contains primitive pair data
ShellPairCints | ShellPairCints provides all primitive pair data for a given shell pair
ShellPairsCints | ShellPairsCints contains primitive pair data for all shell pairs
TwoBodyIntCints | This implements electron repulsion integrals in the IntCints library
TwoBodyDerivIntCints | This implements electron repulsion derivative integrals in the IntV3 library
SphericalTransformComponentCints |
SphericalTransformCints |
ISphericalTransformCints |
CLKS | This provides a Kohn-Sham implementation for closed-shell systems
LocalCLKSContribution |
LocalCLKSEnergyContribution |
PointInputData | Contains data needed at each point by a DenFunctional
SpinData |
PointOutputData | Contains data generated at each point by a DenFunctional
DenFunctional | An abstract base class for density functionals
NElFunctional | The NElFunctional computes the number of electrons
SumDenFunctional | The SumDenFunctional computes energies and densities using the a sum of energy density functions method
StdDenFunctional | Used to construct the standard density functionals
LSDACFunctional | An abstract base class for local correlation functionals
PBECFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) correlation functional
PW91CFunctional | The Perdew-Wang 1991 correlation functional computes energies and densities using the designated local correlation functional
P86CFunctional | Implements the Perdew 1986 (P86) correlation functional
NewP86CFunctional |
SlaterXFunctional | Implements the Slater exchange functional
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
VWN1LCFunctional | The VWN1LCFunctional computes energies and densities using the VWN1 local correlation term (from Vosko, Wilk, and Nusair)
VWN2LCFunctional | The VWN2LCFunctional computes energies and densities using the VWN2 local correlation term (from Vosko, Wilk, and Nusair)
VWN3LCFunctional | The VWN3LCFunctional computes energies and densities using the VWN3 local correlation term (from Vosko, Wilk, and Nusair)
VWN4LCFunctional | The VWN4LCFunctional computes energies and densities using the VWN4 local correlation term (from Vosko, Wilk, and Nusair)
VWN5LCFunctional | The VWN5LCFunctional computes energies and densities using the VWN5 local correlation term (from Vosko, Wilk, and Nusair)
PW92LCFunctional | Implements the PW92 local (LSDA) correlation term
PZ81LCFunctional | Implements the PZ81 local (LSDA) correlation functional
XalphaFunctional | Implements the Xalpha exchange functional
Becke88XFunctional | Implements Becke's 1988 exchange functional
LYPCFunctional | Implements the Lee, Yang, and Parr functional
PW86XFunctional | Implements the Perdew-Wang 1986 (PW86) Exchange functional
PBEXFunctional | Implements the Perdew-Burke-Ernzerhof (PBE) exchange functional
PW91XFunctional | The Perdew-Wang 1991 exchange functional computes energies and densities using the designated local correlation functional
mPW91XFunctional | Implements a modified 1991 Perdew-Wang exchange functional
G96XFunctional | Implements the Gill 1996 (G96) exchange functional
HSOSKS | This provides a Kohn-Sham implementation for restricted-orbital high-spin open-shell systems
LocalHSOSKSContribution |
LocalHSOSKSEnergyContribution |
DenIntegrator | An abstract base class for integrating the electron density
IntegrationWeight | An abstract base class for computing grid weights
BeckeIntegrationWeight | Implements Becke's integration weight scheme
RadialIntegrator | An abstract base class for radial integrators
AngularIntegrator | An abstract base class for angular integrators
EulerMaclaurinRadialIntegrator | An implementation of a radial integrator using the Euler-Maclaurin weights and grid points
LebedevLaikovIntegrator | An implementation of a Lebedev angular integrator
GaussLegendreAngularIntegrator | An implementation of an angular integrator using the Gauss-Legendre weights and grid points
RadialAngularIntegrator | An implementation of an integrator using any combination of a RadialIntegrator and an AngularIntegrator
UKS | This provides a Kohn-Sham implementation for unrestricted-orbital open-shell systems
LocalUKSContribution |
LocalUKSEnergyContribution |
CartesianIterCCA |
RedundantCartesianIterCCA |
RedundantCartesianSubIterCCA |
Int1eCCA | Int1eCCA adapts CCA integrals components for use within SC
Int2eCCA | Int2eCCA adapts CCA integrals components for use within SC
IntegralCCA | IntegralCCA provides an SC client for CCA IntegralEvaluator components
OneBodyIntCCA | This implements one body integrals through the CCA interface
OneBodyDerivIntCCA | This implements one body derivative integrals
TwoBodyIntCCA | This implements two body integrals through the CCA interface
TwoBodyDerivIntCCA | This implements two body derivative integrals through the CCA interface
SphericalTransformComponentCCA |
SphericalTransformCCA |
ISphericalTransformCCA |
IntV3Arraydouble2 |
IntV3Arraydouble3 |
IntV3Arraydoublep2 |
IntV3Arraydoublep3 |
IntV3Arraydoublep4 |
IntV3Arrayint3 |
IntV3Arrayint4 |
CartesianIterV3 |
RedundantCartesianIterV3 |
RedundantCartesianSubIterV3 |
FJT |
Int1eV3 | Int1eV3 is a class wrapper for the one body part of the C language IntV3 library
Int2eV3 | Int2eV3 is a class wrapper for the two body part of the C language IntV3 library
store_list |
IntegralV3 | IntegralV3 computes integrals between Gaussian basis functions
OneBodyIntV3 | This implements most one body integrals in the IntV3 library
PointChargeIntV3 |
EfieldDotVectorIntV3 |
DipoleIntV3 |
OneBodyDerivIntV3 | This implements one body derivative integrals in the IntV3 library
IntegralKey |
IntegralLink |
IntegralStorer |
TwoBodyIntV3 | This implements electron repulsion integrals in the IntV3 library
TwoBodyThreeCenterIntV3 | This implements electron repulsion integrals involving three centers in the IntV3 library
TwoBodyTwoCenterIntV3 | This implements electron repulsion integrals involving two centers in the IntV3 library
TwoBodyDerivIntV3 | This implements electron repulsion derivative integrals in the IntV3 library
SphericalTransformComponentV3 |
SphericalTransformV3 |
ISphericalTransformV3 |
der_centersv3_t |
CSGrad34Qbtr |
CSGradErep12Qtr |
CSGradS2PDM |
HSOSV1Erep1Qtr |

MBPT2

    The MBPT2 class implements several second-order perturbation theory

methods

MP2BasisExtrap |
BiggestContribs |

MBPT2_R12

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

methods

MOIndexSpace | Class MOIndexSpace describes a range of molecular orbitals or similar objects that are linear combinations of basis functions (e.g
MP2R12Energy | Class MP2R12Energy is the object that computes and maintains MP2-R12 energies
MOPairIter | MOPairIter gives the ordering of orbital pairs
SpatialMOPairIter | SpatialMOPairIter gives the ordering of pairs of spatial orbitals
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
SpatialMOPairIter_neq | SpatialMOPairIter_neq gives the ordering of pairs of spatial orbitals from different spaces
MOPairIterFactory | This class produces MOPairIter objects
R12Amplitudes | R12Amplitudes gives the amplitudes of some linear-R12-ansatz-related terms in wave function
R12IntsAcc | R12IntsAcc accumulates transformed (MO) integrals stored as (ijxy) where i, j, x, and, y lie in spaces I, J, X, and Y, respectively
R12IntsAcc_MemoryGrp |
R12IntsAcc_MPIIOFile |
PairBlkInfo |
R12IntsAcc_MPIIOFile_Ind |
R12IntsAcc_Node0File |
R12IntEval | R12IntEval is the top-level class which computes intermediates occuring in linear R12 theories
TwoBodyMOIntsTransform_123Inds |
TwoBodyMOIntsTransform_12Inds |
TwoBodyMOIntsTransform_13Inds |
MOIntsTransformFactory | MOIntsTransformFactory is a factory that produces MOIntsTransform objects
TwoBodyMOIntsTransform_ijxy | TwoBodyMOIntsTransform_ijxy computes (ij|xy) integrals using parallel integrals-direct AO->MO transformation
TwoBodyMOIntsTransform_ikjy | TwoBodyMOIntsTransform_ikjy computes (ik|jy) integrals using parallel integrals-direct AO->MO transformation
TwoBodyMOIntsTransform_ixjy | TwoBodyMOIntsTransform_ixjy computes (ix|jy) integrals using parallel integrals-direct AO->MO transformation
TwoBodyMOIntsTransform | TwoBodyMOIntsTransform computes two-body integrals in MO basis using parallel integrals-direct AO->MO transformation
MOSpaces | Predefined enumerated type for the MO spaces
TwoBodyGrid | Class TwoBodyGrid describes a set of coordinates of 2 particles
R12IntEvalInfo | Class R12IntEvalInfo contains information necessary for R12 intermediate evaluators
BuildIntV3 |
PsiExEnv | PsiExEnv specifies a Psi calculation
PsiFile11 | PsiFile11 is a Psi gradient file
PsiInput | PsiInput is a Psi input file
PsiWavefunction | PsiWavefunction is an abstract base for all Psi wave functions
PsiSCF | PsiSCF is an abstract base for all Psi SCF wave functions
PsiCLHF | PsiCLHF is a concrete implementation of Psi RHF wave function
PsiHSOSHF | PsiHSOSHF is a concrete implementation of Psi ROHF wave function
PsiUHF | PsiUHF is a concrete implementation of Psi UHF wave function
PsiCCSD | PsiCCSD is a concrete implementation of Psi CCSD wave function
PsiCCSD_T | PsiCCSD_T is a concrete implementation of Psi CCSD(T) wave function
CLHF | CLHF is a Hartree-Fock specialization of CLSCF
LocalCLHFContribution |
LocalCLHFEnergyContribution |
LocalCLHFGradContribution |

CLSCF

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

procedure for closed-shell molecules

AccumEffectiveH |
GSGeneralEffH |
GSHighSpinEffH |
TestEffH |
PsiEffH |
GBuild |
HSOSHF | HSOSHF is a Hartree-Fock specialization of HSOSSCF

HSOSSCF

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

procedure for high-spin open-shell molecules

LocalLBGBuild |
LocalGBuild |
LocalTBGrad |
OSSHF |
LocalOSSContribution |
LocalOSSEnergyContribution |
LocalOSSGradContribution |
OSSSCF |

SCF

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

field procedure to solve an effective one body problem

SCFEnergy |
LevelShift |
ALevelShift |
BLevelShift |
MOLagrangian |
TBGrad |
TCHF |
LocalTCContribution |
LocalTCEnergyContribution |
LocalTCGradContribution |
TCSCF |
UHF | This provides an unrestricted Hartree-Fock implementation
LocalUHFContribution |
LocalUHFEnergyContribution |
LocalUHFGradContribution |
UnrestrictedSCF | A base class for unrestricted self-consistent-field methods
AccumH |
AccumHNull |
SumAccumH |
ElectronDensity | This is a Volume that computer the electron density
BatchElectronDensity | This a more highly optimized than ElectronDensity since everything is precomputed
DensityColorizer |
GradDensityColorizer |
ExtendedHuckelWfn |
OneBodyWavefunction | A OneBodyWavefunction is a MolecularEnergy that solves an effective one-body problem
HCoreWfn |
Orbital |
BEMSolventH |
Wavefunction | A Wavefunction is a MolecularEnergy that utilizies a GaussianBasisSet
BEMSolvent |
Edge |
IsosurfaceGen |
ImplicitSurfacePolygonizer |
Shape | A Shape is a Volume represents an 3D solid
SphereShape |
UncappedTorusHoleShape |
NonreentrantUncappedTorusHoleShape |
ReentrantUncappedTorusHoleShape |
Uncapped5SphereExclusionShape |
UnionShape | A UnionShape is volume enclosed by a set of Shape's
TriangulatedSurface |
TriangulatedSurfaceIntegrator |
TriangulatedImplicitSurface |
Triangle |
TriangleIntegrator |
GaussTriangleIntegrator |
TriInterpCoefKey |
TriInterpCoef |
Vertex |
Volume | A Volume is a Function of three variables

Convergence

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

optimization is converged

DIIS | DIIS extrapolation
EFCOpt | Implements eigenvector following as described by Baker in J
Function | Abstract base class that, given a set of coordinates, will compute a value and possibly a gradient and hessian at that point
GDIISOpt |
MCSearch | This performs line searches with cubic steps
NewtonOpt |
Optimize | Abstract base class for classes that find the extreme points of Function's

LineOpt

    The LineOpt abstract class is used to perform one dimensional

optimizations

Backtrack |
QNewtonOpt | The QNewtonOpt implements a quasi-Newton optimization scheme
SCExtrapData | SCExtrapData hold the data to be extrapolated needed by SelfConsistentExtrapolation
SCExtrapError | SCExtrapError holds the error data needed by SelfConsistentExtrapolation

SelfConsistentExtrapolation

    The SelfConsistentExtrapolation abstract class is used to iteratively

solve equations requiring a self consistent solution, such as,

SymmSCMatrixSCExtrapData |
SymmSCMatrix2SCExtrapData |
SymmSCMatrix4SCExtrapData |
SymmSCMatrixNSCExtrapData |
SymmSCMatrixSCExtrapError |
SteepestDescentOpt |
NonlinearTransform | Transforms between two nonlinear coordinate systems
IdentityTransform | The IdentityTransform is a special case of NonlinearTransform were no transformation takes place

HessianUpdate

    The HessianUpdate abstract class is used to specify a hessian update

scheme

DFPUpdate

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

hessian update scheme

BFGSUpdate

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

and Shanno hessian update scheme

PowellUpdate | Used to specify a Powell hessian update

SCMatrixKit

    The SCMatrixKit abstract class acts as a factory for producing

matrices

SCVector | Abstract base class for double valued vectors
SCMatrix | Abstract base class for general double valued n by m matrices
SymmSCMatrix | Abstract base class for symmetric double valued matrices
DiagSCMatrix | The SymmSCMatrix class is the abstract base class for diagonal double valued matrices
SCMatrixBlockIter | Used to described iterates that loop through the elements in a block
SCMatrixRectBlockIter |
SCMatrixRectSubBlockIter |
SCMatrixLTriBlockIter |
SCMatrixLTriSubBlockIter |
SCMatrixDiagBlockIter |
SCMatrixDiagSubBlockIter |
SCVectorSimpleBlockIter |
SCVectorSimpleSubBlockIter |
SCMatrixBlock | SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors
SCMatrixBlockListLink |
SCMatrixBlockListIter |
SCMatrixBlockList |

SCVectorSimpleBlock

    The SCVectorSimpleBlock describes a piece of a

vector

SCVectorSimpleSubBlock

    The SCVectorSimpleSubBlock describes a subblock of a

vector

SCMatrixRectBlock

    The SCMatrixRectBlock describes a rectangular piece of a

matrix

SCMatrixRectSubBlock

    The SCMatrixRectSubBlock describes a rectangular piece of a

matrix

SCMatrixLTriBlock

    The SCMatrixLTriBlock describes a triangular piece of a

matrix

SCMatrixLTriSubBlock

    The SCMatrixLTriSubBlock describes a triangular subblock of a

matrix

SCMatrixDiagBlock

    The SCMatrixDiagBlock describes a diagonal piece of a

matrix

SCMatrixDiagSubBlock

    The SCMatrixDiagSubBlock describes a diagonal subblock of a

matrix

SCMatrixSubblockIter | Objects of class SCMatrixSubblockIter are used to iterate through the blocks of a matrix
SCMatrixSimpleSubblockIter |
SCMatrixListSubblockIter |
SCMatrixNullSubblockIter |
SCMatrixCompositeSubblockIter |
SCMatrixJointSubblockIter |
BlockedSCMatrixKit |
BlockedSCVector |
BlockedSCMatrix |
BlockedSymmSCMatrix |
BlockedDiagSCMatrix |
BlockedSCElementOp |
BlockedSCElementOp2 |
BlockedSCElementOp3 |
SCBlockInfo | SCBlockInfo contains blocking information for the SCDimension class
SCDimension | Used to determine the size and blocking of matrices
RefSCDimension | Smart pointer to an SCDimension specialization

DistSCMatrixKit

    The DistSCMatrixKit produces matrices that work in a many processor

environment

DistSCVector |
DistSCMatrix |
DistSymmSCMatrix |
DistDiagSCMatrix |
DistSCMatrixListSubblockIter |
SCElementOp | Objects of class SCElementOp are used to perform operations on the elements of matrices
SCElementOp2 | Very similar to the SCElementOp class except that pairs of blocks are treated simultaneously
SCElementOp3 | Very similar to the SCElementOp class except that a triplet of blocks is treated simultaneously
SCElementScalarProduct |
SCDestructiveElementProduct |
SCElementScale |
SCElementRandomize |
SCElementAssign |
SCElementSquareRoot |
SCElementInvert |
SCElementScaleDiagonal |
SCElementShiftDiagonal |
SCElementMaxAbs |
SCElementMinAbs |
SCElementSumAbs |
SCElementKNorm | Computed k-norm of matrix
SCElementDot |
SCElementAccumulateSCMatrix |
SCElementAccumulateSymmSCMatrix |
SCElementAccumulateDiagSCMatrix |
SCElementAccumulateSCVector |

LocalSCMatrixKit

    The LocalSCMatrixKit produces matrices that work in a single processor

environment

LocalSCVector |
LocalSCMatrix |
LocalSymmSCMatrix |
LocalDiagSCMatrix |
RefSCVector | Smart pointer to an SCVector specialization
RefSCMatrix | Smart pointer to an SCMatrix specialization
RefSymmSCMatrix | Smart pointer to an SCSymmSCMatrix specialization
RefDiagSCMatrix | Smart pointer to an DiagSCMatrix specialization
SCVectordouble |
SCMatrixdouble |
SymmSCMatrixdouble |
DiagSCMatrixdouble |
SCMatrix3 |

ReplSCMatrixKit

    The ReplSCMatrixKit produces matrices that work in a many processor

environment

ReplSCMatrixListSubblockIter |
ReplSCVector |
ReplSCMatrix |
ReplSymmSCMatrix |
ReplDiagSCMatrix |
SCVector3 |
CorrelationTable | Correlation table between two point groups
SymmetryOperation | 3 by 3 matrix representation of a symmetry operation, such as a rotation or reflection
SymRep | N dimensional matrix representation of a symmetry operation, such as a rotation or reflection
IrreducibleRepresentation | Information associated with a particular irreducible representation of a point group
CharacterTable | Workable character table for all of the non-cubic point groups
PointGroup | Really a place holder for a CharacterTable
DescribedMemberDatum |
ParentClass | Gives one parent class of a class
ParentClasses | Gives a list of parent classes of a class
type_info_key |
ClassDesc | This class is used to contain information about classes
DescribedClass | Classes which need runtime information about themselves and their relationship to other classes can virtually inherit from DescribedClass
ForceLinkBase | This, together with ForceLink, is used to force code for particular classes to be linked into executables

ForceLink

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

classes to be linked into executables

DescribedClassProxy |
SCException | This is a std::exception specialization that records information about where an exception took place
ProgrammingError | This is thrown when a situations arises that should be impossible
FeatureNotImplemented | This is thrown when an attempt is made to use a feature that is not yet implemented
InputError | This is thrown when invalid input is provided
SystemException | This is thrown when a system problem occurs
MemAllocFailed | This is thrown when a memory allocation fails
FileOperationFailed | This is thrown when an operation on a file fails
SyscallFailed | This is thrown when an system call fails with an errno
AlgorithmException | This exception is thrown whenever a problem with an algorithm is encountered
MaxIterExceeded | This is thrown when an iterative algorithm attempts to use more iterations than allowed
ToleranceExceeded | This is thrown when when some tolerance is exceeded
LimitExceeded | This is thrown when a limit is exceeded
AVLMapNode |
AVLMap |
iterator |
AVLSet |
iterator |
BitArrayLTri |
EAVLMMapNode |
EAVLMMap |
iterator |

FileGrp

    The FileGrp abstract class provides a way of accessing distributed

file in a parallel machine

ProcFileGrp

    The ProcFileGrp concrete class provides an implementation of

FileGrp for a single processor

GlobalCounter |
HypercubeGMI |
HypercubeTopology |
MemoryDataRequest |
MemoryDataRequestQueue |

ActiveMsgMemoryGrp

    The ActiveMsgMemoryGrp abstract class specializes the MsgMemoryGrp

class

ARMCIMemoryGrp | The ARMCIMemoryGrp concrete class provides an implementation of MsgMemoryGrp
MemoryIter |
MsgMemoryGrp | A MsgMemoryGrp that initializes its data using a messagegrp
MTMPIMemoryGrp | This MemoryGrp class requires a MT-safe MPI implementation
distsize_t |

MemoryGrp

    The MemoryGrp abstract class provides a way of accessing distributed

memory in a parallel machine

MemoryGrpBuf | The MemoryGrpBuf class provides access to pieces of the global shared memory that have been obtained with MemoryGrp

ProcMemoryGrp

    The ProcMemoryGrp concrete class provides an implementation of

MemoryGrp for a single processor

RDMAMemoryGrp

    The RDMAMemoryGrp abstract class specializes the MsgMemoryGrp

class

ShmMemoryGrp

    The ShmMemoryGrp concrete class provides an implementation of

MsgMemoryGrp

GrpReduce |
GrpSumReduce |
GrpMinReduce |
GrpMaxReduce |
GrpArithmeticAndReduce |
GrpArithmeticOrReduce |
GrpArithmeticXOrReduce |
GrpProductReduce |
GrpFunctionReduce |
MessageGrp | The MessageGrp abstract class provides a mechanism for moving data and objects between nodes in a parallel machine
message_struct |
ProcMessageGrp | ProcMessageGrp provides a concrete specialization of MessageGrp that supports only one node
intMessageGrp | Uses integer message types to send and receive messages

MPIMessageGrp

    The MPIMessageGrp class is an concrete implementation of MessageGrp

that uses the MPI 1 library

commbuf_struct |
msgbuf_struct |

ShmMessageGrp

    The ShmMessageGrp class is an implementation of MessageGrp that

allows multiple process to be started that communicate with shared memory

MsgStateSend | The MsgStateSend is an abstract base class that sends objects to nodes in a MessageGrp
MsgStateBufRecv | The MsgStateBufRecv is an abstract base class that buffers objects sent through a MessageGrp
MsgStateRecv | The MsgStateRecv is an abstract base class that receives objects from nodes in a MessageGrp
StateSend | StateSend is a concrete specialization of MsgStateSend that does the send part of point to point communication in a MessageGrp
StateRecv | StateRecv is a concrete specialization of MsgStateRecv that does the receive part of point to point communication in a MessageGrp
BcastStateSend | BcastStateSend does the send part of a broadcast of an object to all nodes
BcastStateRecv | BcastStateRecv does the receive part of a broadcast of an object to all nodes
BcastState | This creates and forwards/retrieves data from either a BcastStateRecv or a BcastStateSend depending on the value of the argument to constructor
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
FreeData |
UsedData |
PoolData |
Pool |
ParallelRegionTimer |
RangeLockItem |
RangeLock |
PthreadThreadGrp | Privides a concrete thread group appropriate for an environment where pthreads is available
PumaThreadGrp | Privides a concrete thread group appropriate for the intel teraflops machine
ThreadLock | The ThreadLock abstract class provides mutex locks to be used in conjunction with ThreadGrp's
ThreadLockHolder | Acquire a lock on creation and release it on destruction
Thread | The Thread abstract class defines an interface which must be implemented by classes wishing to be run as threads
ThreadGrp | The ThreadGrp abstract class provides a means to manage separate threads of control
ProcThreadGrp | Privides a concrete thread group appropriate for an environment where there is only one thread
GlobalMsgIter |
MachineTopology |
intlist_struct |
ip_keyword_tree_struct |
ip_keyword_tree_list_struct |
ip_cwk_stack_struct |
IPV2 |
ip_string_list_struct |
KeyVal | Designed to simplify the process of allowing a user to specify keyword/value associations to a C++ program
AssignedKeyVal | This class allows keyval associations to be set up by the program, rather than determined by an external file
StringKeyVal | StringKeyVal is a base class for KeyVal implementations that store all values in a string format
AggregateKeyVal | This takes several KeyVal objects and makes them look like one KeyVal object
PrefixKeyVal | PrefixKeyVal is a KeyVal that searches a different KeyVal using modified keys
ParsedKeyVal | Converts textual information into keyword/value assocations
KeyValValue |
KeyValValuedouble |
KeyValValueboolean |
KeyValValuefloat |
KeyValValuechar |
KeyValValueint |
KeyValValuesize |
KeyValValuepchar |
KeyValValuestring |
KeyValValueRefDescribedClass |
KeyValValueString |
auto_vec | The auto_vec class functions much like auto_ptr, except it contains references to arrays

Debugger

    The Debugger class describes what should be done when a catastrophic

error causes unexpected program termination

CCAEnv | Handles embedded CCA frameworks
Result | Result are members of Compute specializations that keep track of whether or not a particular result should be computed or if it has already been computed
NCResult | This is similar to Result, but can be used with non-class types
AccResult | This associates a result datum with an accuracy
SSAccResult | This associates a result datum with an accuracy
NCAccResult | This associates a result non-class datum with an accuracy
Compute | Means of keeping results up to date
ResultInfo | This is a base class for all of Compute's result types
AccResultInfo | This is like ResultInfo but the accuracy with which a result was computed as well as the desired accuracy are stored
ExEnv | Used to find out about how the program is being run
SCFormIO | This utility class is used to print only on node 0 and to provide attractive indentation of output
scprintf | This class allows `printf` like output to put sent to an `ostream`
TimedRegion |

RegionTimer

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

code

Timer

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

manner

Units | Used to perform unit converions
GetLongOpt |
Identifier | Identifier's are used to distinguish and order objects
Identity | Identity gives objects a unique identity and ordering relationship relative to all other objects
RefCount | The base class for all reference counted objects
RefBase | Provides a few utility routines common to all Ref template instantiations
Ref | A template class that maintains references counts
X |
Y |
vec2 |
vec3 |
vec4 |
mat3 |
mat4 |
AnimatedObject |
Appearance |
Color |
Material |
RenderedObject |
RenderedObjectSet |
OOGLRender |
Parameter |
RenderedPolygons |
RenderedPolylines |
Render |
FileRender |
RenderedSphere |
Stack |
Transform |
SavableStateProxy | Create a proxy for a SavableState object
SavableState | Base class for objects that can save/restore state
StateOutBin | Save state to a binary file
StateInBin | Read objects written with StateOutBin
StateOutFile | Writes state information to files
StateInFile | Reads state information from a file
StateOutText | Writes out state information in an almost human readable format
StateInText | Reads state information written with StateOutText
StateInData |
StateClassData |
StateIn | Restores objects that derive from SavableState
StateOutData |
StateOut | Serializes objects that derive from SavableState
TranslateData | Generic data translation
TranslateDataByteSwap | Data translation to an external representation with bytes swapped
TranslateDataOut | Convert data to other formats
TranslateDataIn | Convert data from other formats
errno_exception |
LocalHSOSContribution |
LocalHSOSEnergyContribution |
LocalHSOSGradContribution |
point |
Taylor_Fjt_Eval |
TCPClientConnection |
TCPIOSocket |
TCPServerConnection |
TCPServerSocket |
TCPSocket |
vertex |
vertices |
YYSTYPE |