Class List
Here are the classes, structs, unions and interfaces with brief descriptions:| PlayaFunctors::Abs< Scalar > | Elementwise absolute value |
| Sundance::AbstractEvalMediator | Base class for evaluation mediator objects |
| Sundance::ADReal | First-order automatic differentiation of a multivariable function |
| Sundance::AlgebraSpecifier | AlgebraSpecifier is used to indicate whether a given object represents a vector, scalar, component of a vector, etc |
| Playa::AmesosSolver | |
| Playa::AnasaziEigensolver< Scalar > | Object wrapper for Anasazi eigenvalue solver |
| Sundance::ApplySimpleDiffOp | Apply a simple diff op |
| Sundance::ArrayOfTuples< T > | Class ArrayOfTuples packs an heterogeneous array of tuples into a single 1D array |
| Sundance::Assembler | |
| Sundance::AssemblyKernelBase | AssemblyKernelBase abstracts the operations that must be done in an assembly loop |
| Sundance::AssociateHungryDiffOpWithOperand | Transform a product by associating any hungry diff op in the left operand with the right operand:
|
| Sundance::AToCDensitySampler | AToCDensitySampler samples a distribution of particles to compute a density function on a discrete space |
| Sundance::AToCPointLocator | AToCPointLocator finds the cell index for a point within an unstructured mesh |
| Playa::AztecSolver | |
| Sundance::BamgMeshReader | BamgMeshReader reads a mesh stored in Frederic Hecht's g format |
| Playa::BasicLMBFGS | Implements the L-BFGS algorithm |
| Playa::BasicLMBFGSDirection | |
| Sundance::BasicSimplicialMesh | A no-frills parallel simplicial mesh |
| Sundance::BasicSimplicialMeshType | BasicSimplicialMeshType is used to create BasicSimplicialMesh objects |
| Sundance::BasisArray | |
| Sundance::BasisDOFTopologyBase | Abstract interface for specification of the topology of degree-of-freedom (DOF) assignments on reference cells in any dimension |
| Sundance::BasisFamily | BasisFamily is the user-level handle class for specifying the basis with which a test, unknown, or discrete function is represented |
| Sundance::BasisFamilyBase | |
| Sundance::BasisReferenceEvaluationBase | Abstract interface for evaluation of basis functions and their spatial derivatives on reference cells |
| Playa::BelosSolver | |
| Sundance::Bernstein | Bernstein basis |
| Playa::BICGSTABSolver< Scalar > | |
| Sundance::BinaryCellFilter | BinaryCellFilter implements cell filters that do binary logical operations on cell sets |
| Sundance::BinaryEvaluator< ExprType > | |
| Sundance::BinaryExpr | BinaryExpr is a base class for binary expressions, e.g., sums and products |
| Sundance::Block | |
| Sundance::BlockArray | |
| Playa::BlockIterator< Scalar > | BlockIterator can locate a block within an arbitrarily nested block vector space |
| Playa::BlockOperatorBase< Scalar > | Class BlockOperatorBase provides an abstract interface for accessing blocks of block operators |
| Playa::BlockTriangularSolver< Scalar > | |
| Playa::BlockVectorBase< Scalar > | Base class for blocked vectors |
| Playa::BlockVectorSpaceBase< Scalar > | This is a base class for a blocked vector space |
| Sundance::BoundaryCellFilter | BoundaryCellFilter identifies all cells of dimension  on the boundary |
| Sundance::BoundaryCellPredicate | BoundaryCellPredicate tests whether a cell is on the boundary of the domain |
| Sundance::BoundedDomain | |
| PlayaFunctors::BoundedMaxLocFunctor< Scalar > | Find maximum element below an upper bound, returning value and location |
| PlayaFunctors::BoundedMinLocFunctor< Scalar > | Find minimum element above a lower bound, returning value and location |
| Sundance::BrickQuadrature | Get abscissas and weights for Gaussian quadrature on Brick cells (cuboids) |
| Sundance::BringConstantOutsideDiffOp | Bring a constant outside a diff op
|
| Sundance::Bubble | Bubble function for use in error estimation |
| Sundance::CartesianCoordinateSystem | |
| Sundance::CellCurvePredicate | |
| Sundance::CellDiameterExpr | Expression that returns a characteristic size for each cell on which it is evaluated |
| Sundance::CellDiameterExprEvaluator | |
| Sundance::CellFilter | CellFilter is a user-level object representing a filter that selects from a mesh all cells that satisfy some condition |
| Sundance::CellFilterBase | Base class for CellFilter objects |
| Sundance::CellIterator | CellIterator is an iterator for walking through cell sets |
| Sundance::CellJacobianBatch | A CellJacobianBatch is a collection of Jacobian matrices for many quadrature points distributed over batch of cells |
| Sundance::CellLIDMappedFieldWrapper | |
| Sundance::CellPredicate | User-level handle for predicates (deriving from CellPredicateBase) used to decide whether a given cell passes a CellFilter |
| Sundance::CellPredicateBase | CellPredicateBase is the base class for predicate objects that test cells against some condition |
| Sundance::CellPredicateFunctorBase | |
| Sundance::CellReorderer | User-level handle class for abstract specification of cell reordering algorithms |
| Sundance::CellReordererFactoryBase | Factory class to instantiate cell reorderers for specific meshes |
| Sundance::CellReordererImplemBase | Abstract interface for the low-level objects that implement cell reordering |
| Sundance::CellSet | CellSet is, you guessed it, a set of cells in a mesh |
| Sundance::CellSetBase | CellSetBase is the base class for cell sets |
| Sundance::CellVectorEvaluator | |
| Sundance::CellVectorExpr | Expression that returns a component of a cell-determined vector for each cell on which it is evaluated |
| Sundance::CFMeshPair | |
| Sundance::ChainRuleEvaluator | |
| Sundance::ChainRuleSum | |
| Sundance::ClosedNewtonCotes | Closed Newton-Cotes quadrature rules for lines and triangles |
| Sundance::ClosedNewtonCotesType | Generates closed Newton-Cotes quadrature rules |
| Playa::CollectivelyConfigurableMatrixFactory | Class CollectivelyConfigurableMatrixFactory provides an abstract interface for all-at-once matrix structure configuration |
| Sundance::CommonFuncDataStub | CommonFuncDataStub is a placeholder for data to be shared between multiple components of a symbolic or discrete function |
| Sundance::ComplexExpr | Complex expression |
| Playa::CompoundTester< Scalar > | |
| Sundance::ConstantEvaluator | |
| Sundance::ConstantExpr | ConstantExpr contains an immutable constant, to be distinguished from a parameter that is constant in space but can change during the course of a simulation |
| Playa::ConstDataChunk< Scalar > | This class wraps a pointer to a single contiguous chunk of scalar data |
| Playa::ConstHandleTraits< X > | This traits class is used to extract the non-const version of a template argument |
| Playa::ConstHandleTraits< const X > | Specialization of CHT to types "const X" |
| Playa::ConvergenceMonitor | |
| Sundance::CoordDeriv | CoordDeriv represents a single first-order derivative with respect to a coordinate function |
| Sundance::CoordExpr | CoordExpr is an expression that returns one of the cartesian coordinates for each point at which it evaluated |
| Sundance::CoordExprEvaluator | |
| Sundance::CoordinateSystem | |
| Sundance::CoordinateSystemBase | |
| Sundance::CoordinateSystemBuilder | |
| Sundance::CoordinateValueCellPredicate | |
| Sundance::CoordinateValueCellPredicateFunctor | |
| Coupled1DTest | |
| Sundance::CToAInterpolator | CToAInterpolator interpolates a discrete function at particle positions |
| Sundance::CubicHermite | CubicHermite basis |
| Sundance::CurveDomain | Class defines mesh domain based on parametrized curve |
| Sundance::CurveEvalMediator | |
| Sundance::CurveExpr | Class which serves as expression for interface (curve or surface) values |
| Sundance::CurveIntegralCalc | Class to compute the intersection/quadrature points of a cell with a curve in 2/3D |
| Sundance::CurveNormEvaluator | Evaluator for the normal vector component (normal to one parameterized curve) |
| Sundance::CurveNormExpr | CurveNormExpr is an expression that returns the Cartesian coordinate component of the normal vector |
| Sundance::CurveQuadratureIntegral | Integration by quadrature over a maximal cell |
| Playa::Debug | |
| Playa::DefaultBlockVector< Scalar > | Base class for blocked vectors |
| Playa::DefaultBlockVectorSpace< Scalar > | This is the default implementation of a blocked vector space, which simply stores blocks in an array |
| Sundance::DefaultExprComparison | Default comparison computes Euclidean distance between vectors |
| Sundance::DefaultIterCallback | Default callback writes all variables to disk at a specified frequency |
| Playa::DefaultOptConvergenceTest | A simple convergence test |
| Playa::DenseLUSolver | |
| Playa::DenseSerialMatrix | Linear operator implemented as a dense matrix |
| Playa::DenseSerialMatrixFactory | |
| Sundance::Deriv | The purpose of this class is to represent first-order spatial or functional differential operators |
| Sundance::Derivative | Derivative is an expression subtype representing a first-order spatial partial derivative operator |
| Sundance::DerivOfSymbFunc | Specialization of DiffOp to the case where the argument is a symbolic function, allowing optimized evaluation |
| Sundance::DerivOfSymbFuncEvaluator | |
| Sundance::DerivProduct | |
| Sundance::DerivSet | DerivSet is a set of multiple derivatives, sorted by increasing differentiation order |
| Sundance::DiffOp | |
| Sundance::DiffOpEvaluator | |
| Sundance::DimensionalCellFilter | DimensionalCellFilter is a filter that identifies all cells of a specified dimension |
| Playa::DirectionGeneratorBase | |
| Sundance::DiscreteFuncDataStub | DiscreteFuncDataStub is a placeholder for data to be shared between multiple components of a discrete function |
| Sundance::DiscreteFuncElement | DiscreteFuncElement represents a scalar-valued element of a (possibly) vector-valued discrete function |
| Sundance::DiscreteFuncElementEvaluator | |
| Sundance::DiscreteFunction | DiscreteFunction represents a function that is discretized on a finite-element space |
| Sundance::DiscreteFunctionData | DiscreteFunctionData |
| Sundance::DiscreteFunctionStub | DiscreteFunctionStub is the base class for discrete functions |
| Sundance::DiscreteSpace | DiscreteSpace represents a discrete finite-element space (i.e., a mesh and a basis) |
| Sundance::DistributeSumOfDiffOps | Distribute a sum of diff ops over their operand
|
| Sundance::DOFMapBase | Base interface for implementations of a degree of freedom map |
| Sundance::DOFMapBuilder | |
| PlayaFunctors::DotProduct< Scalar > | Dot product of two vectors |
| PlayaFunctors::DotSlash< Scalar > | Elementwise quotient (matlab dot slash) |
| PlayaFunctors::DotStar< Scalar > | Elementwise product (matlab dot star) |
| Sundance::DoublingStepController | |
| Sundance::DSVWriter | DSVWriter writes a 1D mesh to delimiter-separated file |
| Sundance::DSVWriterFactory | DSVWriterFactory produces a DSV writer in contexts where a user cannot do so directly |
| Sundance::Rivara::Edge | Class Edge is a one-dimensional edge in a simplicial mesh |
| Sundance::EdgeLocalizedBasis | EdgeLocalizedBasis is a basis function defined only on edges |
| Sundance::EFDEEvaluator | |
| Sundance::Eigensolution | |
| Playa::Eigensolver< Scalar > | Handle class for eigensolvers |
| Playa::EigensolverBase< Scalar > | Base class for eigensolvers for linear eigenvalue problems
|
| Sundance::Rivara::Element | Class Element is a maximal-dimension element in a simplicial mesh |
| Sundance::ElementIntegral | ElementIntegral encapsulates the common data needed for the integration of groups of related zero-forms, one-forms, and two-forms |
| Sundance::Rivara::ElementIterator | |
| Sundance::EnumTypeField< T > | |
| Epetra::Epetra_PlayaOperator | |
| Playa::EpetraGhostImporter | Ghost element importer for Epetra vectors |
| Playa::EpetraGhostView | Ghost element viewer for Epetra vectors |
| Playa::EpetraMatrix | Playa wrapper for epetra matrix |
| Playa::EpetraMatrixFactory | |
| Playa::EpetraVector | Playa::VectorBase wrapper for Epetra_Vector |
| Playa::EpetraVectorSpace | Adaptor wrapping Epetra map in the Thyra vector space system |
| Playa::EpetraVectorType | \!brief Epetra vector type is a factory for epetra vector spaces |
| Sundance::EquationSet | Source: SundanceEquationSet.cpp |
| Sundance::ErrNormCalculatorBase | Base class for objects that compute error norms |
| Playa::ErrorPolling | ErrorPolling provides utilities for establishing agreement between processors on whether an std::exception has been detected on any one processor |
| Sundance::EvalContext | Different contexts might require the same expression to be evaluated to different orders of functional differentiation; for example, in setting up a linear system, second-order derivatives are required, but in evaluating a functional only zeroth derivs are required |
| Sundance::EvalContextStub | |
| Sundance::EvalManager | EvalManager provides methods for interfacing to the framework through an AbstractEvalMediator and managing temporary variables through a TempStack |
| Sundance::EvaluatableExpr | |
| Sundance::Evaluator | Base class for evaluator objects |
| Sundance::EvaluatorFactory | |
| Sundance::EvalVector | |
| Sundance::EvalVectorArray | |
| Sundance::EventDetectorBase | |
| Sundance::ExodusMeshReader | ExodusMeshReader reads a mesh from an ExodusII file |
| Sundance::ExodusNetCDFMeshReader | ExodusNetCDFMeshReader reads a mesh from a NetCDF dump of an Exodus file |
| Sundance::ExodusWriter | ExodusWriter writes a mesh or fields to an ExodusII file |
| Sundance::ExodusWriterFactory | ExodusWriterFactory produces an Exodus writer in contexts where a user cannot do so directly |
| Sundance::ExplicitCellIterator | |
| Sundance::ExplicitCellSet | ExplicitCellSet is a cell set subtype where the cell LIDs are stored explicitly in an STL set |
| Sundance::ExplicitFunctionalDerivativeElement | Scalar element of an explicit user-level functional derivative |
| Sundance::Expr | User-level expression class |
| Sundance::ExprBase | |
| Sundance::ExprComparisonBase | Base class for callback that computes distance between discrete functions |
| Sundance::ExprFieldWrapper | |
| Sundance::ExprWithChildren | ExprWithChildren is a base class for any evaluatable expression that has child nodes, for example, sums and unary operators |
| Sundance::ExtrusionMeshTransformation | ExtrusionMeshTransformation extrudes a 2D mesh to 3D |
| Sundance::Rivara::Face | Class Face is a two-dimensional face in a simplicial mesh |
| Sundance::Rivara::FaceNodes | |
| Sundance::FeketeBrickQuadrature | Get abscissas and weights for Gauss-Lobatto quadrature on brick cells (cuboids) (Gauss-Lobatto points are Fekete points on tensor elements) |
| Sundance::FeketeQuadQuadrature | Get abscissas and weights for Gauss-Lobatto quadrature on quadrilateral (Gauss-Lobatto points are Fekete points on tensor elements) |
| Sundance::FeketeQuadrature | Family of Fekete approach integration rules, suitable for integration over arbitrary regions (For tensor elements the Gauss-Lobatto points are Fekete points) |
| Sundance::FeketeQuadratureType | Family of Fekete approach integration rules, suitable for integration over arbitrary regions (For tensor elements the Gauss-Lobatto points are Fekete points) |
| Sundance::FeketeTriangleQuadrature | Get abscissas and weights for Fekete point quadrature on triangles |
| Sundance::FieldBase | |
| Sundance::FieldWriter | FieldWriter is the user level object for writing fields and meshes to output stream |
| Sundance::FieldWriterBase | FieldWriterBase is a base class for objects that write fields and/or meshes to a stream |
| Sundance::FieldWriterFactory | In some contexts the user can't construct a writer directly; for example, during timestepping the writer might be constructed by the step controller |
| Sundance::FieldWriterFactoryBase | FieldWriterFactoryBase |
| Sundance::FileIOChacoPartitioner | This partitioner makes a system call to run Chaco, passing partitioning information to it through file IO |
| Sundance::FixedArray< N, T > | A simple fixed-size array |
| Sundance::ForwardProblemTestBase | |
| Sundance::Fourier | Fourier basis |
| Sundance::FuncElementBase | FuncElementBase defines the interface for scalar-valued elements of Sundance functions |
| Sundance::FuncSetAccumulator | This abstract class defines the interface for accumulating sets of functions that are available in an expression |
| Sundance::Functional | |
| Sundance::FunctionalAssemblyKernel | FunctionalAssemblyKernel does assembly of a functional value |
| Sundance::FunctionalEvaluator | |
| Sundance::FunctionalEvaluatorBase | Abstract interface for the FunctionalEvaluator class it contains only empty functions |
| Sundance::FunctionalGradientAssemblyKernel | FunctionalGradientAssemblyKernel does assembly of a functional and its gradient |
| Sundance::FunctionalPolynomial | Specialized class for representing polynomials in symbolic functions and their derivatives |
| Sundance::FunctionIdentifier | FunctionIdentifier provides a means for distinguishing between different functions and different vector components of the same function |
| Sundance::FunctionSupportResolver | |
| Sundance::FunctionWithID | This is a base class for functions or elements that need an ID object |
| Sundance::FunctorDomain | |
| Sundance::FuncWithBasis | |
| Sundance::Gauss1D | Get abscissas and weights for Gauss-Legendre quadrature on a line segement |
| Sundance::GaussianQuadrature | Family of optimal Gaussian integration rules, e.g., Gauss-Legendre on lines, Dunavant on triangles |
| Sundance::GaussianQuadratureType | Family of optimal Gaussian integration rules, e.g., Gauss-Legendre on lines, Dunavant on triangles |
| Sundance::GaussLobatto1D | Get abscissas and weights for Gauss-Lobatto-Legendre quadrature on a line segment |
| Sundance::GaussLobattoQuadrature | |
| Playa::GeneralizedIndex | GeneralizedIndex is a locator for an element in vector with arbitrary block structure |
| Sundance::GenericCellReordererFactory< T > | Factory class to instantiate cell reorderers for specific meshes |
| Sundance::GenericEvaluatorFactory< ExprT, EvalT > | |
| Playa::GenericLeftPreconditioner< Scalar > | A one-size-fits-most left preconditioner that can be constructed by accepting an operator for the left op of the preconditioner |
| Playa::GenericRightPreconditioner< Scalar > | A one-size-fits-most right preconditioner that can be constructed by accepting an operator for the right op of the preconditioner |
| Playa::GhostImporter< Scalar > | In many applications it is necessary to view some subset of off-processor, or "ghost", elements of a vector |
| Playa::GhostView< Scalar > | GhostView is an interface for read-only views of vector elements including selected off-processor elements |
| Sundance::GIDCellPredicate | GIDCellPredicate tests whether a cell's GID is contained in a specified set of GIDs |
| NOX::NOXPlaya::Group | |
| Sundance::GrouperBase | Grouper |
| Playa::Handle< PointerType > | Class Playa::Handle provides a general implementation of the common features of reference-counted handles |
| Playa::Handleable< Base > | Class Handleable provides an abstract interface for polymorphic conversion from raw pointers to smart pointers |
| Sundance::HCurlVectorBasis | Base class for bases living in H(curl) |
| Sundance::HDivVectorBasis | Base class for bases living in H(div) |
| Playa::HeatOperator1D | |
| Helmholtz1DTest | Solves the Helmholtz equation in 1D with Lagrange(2) basis functions |
| Sundance::HNDoFMapBase | The abstract class which extends the functionalities of the DOF map The only additional functionality is that we have a restriction on the DOFs , with the pre-fill transformations these constraints can be build in into the matrix |
| Sundance::HNDoFMapBaseHomogeneous | The abstract class which extends the functionalities of the DOF map The only additional functionality is that we have a restriction on the DOFs , with the pre-fill transformations these constraints can be build in into the matrix |
| Sundance::HNMesh2D | Class for 2D hierarchical structured quad Mesh The main internal idea of the mesh ist that there are different numberings of the elements ID -> each element has an ID (also those which are completely outside the mesh domain, and those which are not leaf) In the code sometimes internaly LID is used instead of ID due to legacy !! :-P GID -> all leaf elements which are visible to Sundance (only the leaf elements should be visible) LID -> all the elements which have GID and belong and either belong to the local processor or are in the ghost cells |
| Sundance::HNMesh3D | Class for 3D hierarchical structured quad Mesh The main internal idea of the mesh ist that there are different numberings of the elements ID -> each element has an ID (also those which are completely outside the mesh domain, and those which are not leaf) In the code sometimes internaly LID is used instead of ID due to legacy !! :-P GID -> all leaf elements which are visible to Sundance (only the leaf elements should be visible) LID -> all the elements which have GID and belong and either belong to the local processor or are in the ghost cells |
| Sundance::HNMesher2D | |
| Sundance::HNMesher3D | |
| Sundance::HNMeshType2D | Class for a simple capable to refine, and to work in parallel structured 2D mesh type Mesh is based on the trisection refinement |
| Sundance::HNMeshType3D | Class for a simple capable to refine, and to work in parallel structured 3D mesh type Mesh is based on the trisection refinement |
| Sundance::HomogeneousDOFMap | A HomogeneousDOFMap is a DOF map for the special (and common) case in which every function has the same basis and is defined on every cell in the mesh |
| Sundance::IdentifyPolynomialSum | Rewrite a sum as a polynomial object, if possible |
| PlayaFunctors::Identity< Scalar > | Identity functor, used for copying |
| Sundance::IdentityReorderer | |
| Sundance::IdentityReordererImplem | The identity reorderer walks through cells in whatever order they are numbered the the mesh |
| Playa::IfpackOperator | |
| Playa::ILUFactorizableOp< Scalar > | Base interface for operators for which incomplete LU factorizations can be obtained |
| Playa::ILUKPreconditionerFactory< Scalar > | |
| Sundance::ImplicitCellSet | ImplicitCellSet is a cell set subtype where the set of cell LIDs is never stored |
| Sundance::increasingOrder< T > | |
| Sundance::increasingOrder< MultipleDeriv > | Functor increasingOrder() is used as a comparison method for MultipleDeriv objects |
| Playa::IncrementallyConfigurableMatrixFactory | Class IncrementallyConfigurableMatrixFactory provides an abstract interface for row-at-a-time configuration of matrix factories |
| Sundance::IncrementallyCreatableMesh | IncrementallyCreatableMesh is an interface for the creation of meshes by adding vertices, then elements |
| PlayaFunctors::IndexedValue< Scalar > | IndexedValue is the return type for reduction operations such as MinLoc that return a location and a value |
| Sundance::IndexPair | |
| Sundance::InhomogeneousDOFMapHN | A MixedDOFMapHN is a DOF map for the case where every function is defined on every cell in the mesh, but where functions may have different bases |
| Sundance::InhomogeneousNodalDOFMap | |
| Playa::InitTraits< MV, OP > | |
| Playa::InitTraits< SimpleMV, LinearOperator< double > > | |
| Sundance::IntegralGroup | IntegralGroup collects together several integrals having common properties that can be used either to eliminate redundant computations or to share storage an eliminate repeated allocations |
| Playa::InternalError | InternalError is thrown when an "impossible" case is detected in Playa's internals |
| Sundance::IntHashSet | |
| Sundance::IntVec | An integer vector class for use in the generalized chain rule of Constantine and Savits (1996) |
| Playa::InverseOperator< Scalar > | PlayaInverseOperator represents the inverse of some other operator |
| Playa::IterativeSolver< Scalar > | |
| Sundance::IterCallbackBase | IterCallbackBase provides an abstract interface for callbacks to be performed at the start of each optimization iteration |
| Sundance::KillDiffOpOnConstant | Kill a diff op acting on a constant
|
| Playa::KrylovSolver< Scalar > | |
| Sundance::L2NormCalculator | Object to compute L2 norms of errors |
| Sundance::L2Projector | L2Projector projects an expression onto a DiscreteSpace |
| Sundance::LabelCellPredicate | LabelCellPredicate tests whether a cell's label is equal to a reference label |
| Sundance::LabeledSubsetCellFilter | |
| Sundance::Lagrange | Lagrange basis |
| PlayaFunctors::LC2< Scalar > | Linear combination of two vectors |
| PlayaFunctors::LC3< Scalar > | Linear combination of three vectors |
| Playa::LCN< Scalar, N > | |
| Playa::LCN< Scalar, 1 > | |
| Playa::LCN< Scalar, 2 > | |
| Playa::LCN< Scalar, 3 > | |
| Playa::LCNBase< Scalar, N > | |
| Sundance::Legendre | Legendre basis |
| Playa::LinearCombinationTester< Scalar > | |
| Sundance::LinearEigenproblem | |
| Playa::LinearOperator< Scalar > | User-level linear operator class |
| Playa::LinearOperatorBase< Scalar > | Base class for linear operators |
| Playa::LinearOpWithSpaces< Scalar > | LinearOpWithSpaces provides a simple implementation of the domain() and range() methods of LinearOperatorBase |
| Sundance::LinearPDEConstrainedObj | LinearPDEConstrainedObj is a base class for objective functions of the reduced-space variable where the constraint is a linear PDE in the state variables |
| Sundance::LinearProblem | LinearProblem encapsulates all information needed to form a discrete linear problem |
| Sundance::LinearSolveDriver | |
| Playa::LinearSolver< Scalar > | User-level linear solver object |
| Playa::LinearSolverBase< Scalar > | |
| Playa::LinearSolverBuilder | |
| Sundance::LineDomain | This class bundles together a sequence of uniform meshes of the 1D interval [a,b] with cell filters defining the interior and boundaries |
| Playa::LineSearchBase | Base class for line search methods |
| Playa::LineSearchBasedOptBase | Base class for optimizers based on line search methods |
| Playa::LineSearchBuilder | Builder class for line search objects |
| Sundance::ListExpr | |
| Playa::LoadableMatrix< Scalar > | Class LoadableMatrix provides an abstract interface for loading elements into a matrix |
| Sundance::LoadableVector | LoadableVector is the interface through which a framework inserts values into a symbolic expression |
| Playa::LoadableVector< Scalar > | LoadableVector defines an interface through which elements can be loaded into a vector |
| Sundance::LocalDOFMap | LocalDOFMap bundles several compact tables used for fast lookup of local DOFs |
| Sundance::LocalMatrixContainer | LocalMatrixContainer is a container for local matrix and vector values |
| Sundance::LowerBoundedDomain | |
| Sundance::LP1DTestBase | |
| Sundance::LPRectTestBase | |
| Sundance::LPTestBase | |
| Sundance::LPTestSpec | |
| Sundance::LPTestSuite | |
| map | |
| Sundance::Map< Key, Value, Compare > | Extension of STL map, adding some nicer put/get/contains syntax and an iostream insertion operator |
| Sundance::MapBundle | MapBundle collects several data structures needed for DOF mapping |
| Sundance::MapStructure | |
| Playa::MassMatrix1D | |
| Sundance::MatlabWriter | MatlabWriter writes a 1D mesh to a space-delimited file |
| Sundance::MatlabWriterFactory | MatlabWriterFactory produces a Matlab writer in contexts where a user cannot do so directly |
| Playa::MatrixFactory< Scalar > | MatrixFactory is an abstract builder for empty matrices |
| Playa::MatrixLaplacian1D | |
| Playa::MatrixMatrixTester< Scalar > | |
| Sundance::MatrixVectorAssemblyKernel | MatrixVectorAssemblyKernel does assembly of a matrix and vector |
| PlayaFunctors::Max< Scalar > | Find value of minimum element of a vector |
| Sundance::MaximalCellFilter | MaximalCellFilter is a filter that identifies all mesh cells of maximal dimension |
| Sundance::MaximalCellSet | |
| Sundance::MaximalCofacetBatch | MaximalCofacetBatch is used to store the maximal cofacets of a batch of cells of codimension one |
| Sundance::MaximalQuadratureIntegral | Integration by quadrature over a maximal cell |
| Sundance::MeridionalCylindricalCoordinateSystem | |
| Sundance::Mesh | Mesh is the user-level object representing discrete geometry |
| Sundance::MeshBase | Abstract interface to a mesh |
| Sundance::MeshBuilder | |
| Sundance::MeshDomainBase | Base class for mesh refinement , but also to define computational domain (which must not be the same as the mesh domain) |
| Sundance::MeshDomainDef | |
| Sundance::MeshReaderBase | MeshReaderBase is a base class for mesh sources that get a mesh from a file |
| Sundance::MeshSource | MeshSource is the user-level interface for objects such as mesh generators and mesh file readers |
| Sundance::MeshSourceBase | MeshSourceBase provides the internal interface for mesh sources, i.e., objects such as mesh generators and file readers that can produce a mesh object |
| Sundance::MeshTransformation | MeshTransformation is the user-level interface for mesh filters, i.e., objects that take an input mesh and produce a new mesh |
| Sundance::MeshTransformationBase | MeshSourceBase provides the internal interface for mesh filters, i.e., objects that take an input mesh and produce a new mesh |
| Sundance::MeshType | Class MeshType is a user-level object for specification of which internal mesh representation is to be used when building or reading a mesh |
| Sundance::MeshTypeBase | MeshTypeBase is a factory class for empty meshes, allowing generic mesh sources to build a mesh of user-specified type |
| PlayaFunctors::Min< Scalar > | Find value of minimum element of a vector |
| Sundance::MixedDOFMap | A MixedDOFMap is a DOF map for the case where every function is defined on every cell in the mesh, but where functions may have different bases |
| Sundance::MixedDOFMapHN | A MixedDOFMapHN is a DOF map for the case where every function is defined on every cell in the mesh, but where functions may have different bases |
| Playa::MLOperator | |
| Sundance::MoveConstantsToLeftOfProduct | Transform a product by moving any constants to the left:
|
| Sundance::MoveConstantsToLeftOfSum | Transform a sum by moving any constants to the left:
|
| Sundance::MoveUnaryMinusOutsideProduct | Transform a product by any unary minus operations outside the product
|
| Playa::MPIComm | Object representation of an MPI communicator |
| Playa::MPIContainerComm< T > | Object representation of an MPI communicator for templated containers |
| Playa::MPIContainerComm< std::string > | Specialiaztion of MPIContainerComm<T> to std::string |
| Playa::MPISession | This class provides methods for initializing, finalizing, and querying the global MPI session |
| Playa::MPITraits< T > | Templated traits class that binds MPI types to C++ types |
| Playa::MPITraits< char > | Binds MPI_CHAR to char |
| Playa::MPITraits< double > | Binds MPI_DOUBLE to double |
| Playa::MPITraits< float > | Binds MPI_FLOAT to float |
| Playa::MPITraits< int > | Binds MPI_INT to int |
| Sundance::MultiIndex | An integer vector representing a multivariate derivative |
| Sundance::MultipleDeriv | Class MultipleDeriv is a multiple functional derivative operator represented as a multiset of first-order derivatives |
| Sundance::MultiplyConstants | Multiply two constant exprs without transformation |
| multiset | |
| Sundance::MultiSet< Key > | Extension of STL multiset, adding some nicer syntax and an iostream insertion operator |
| Playa::MultiVectorOperator< Scalar > | A MultiVectorOperator is a linear operator whose rows or columns are represented as a multivector |
| Belos::MultiVecTraits< double, SimpleMV > | |
| Anasazi::MultiVecTraits< double, SimpleMV > | |
| Sundance::NamedObject | NamedObject provides an interface for getting and setting names of an object |
| Sundance::Nedelec | Lowest-order Nedelec basis |
| Playa::NewtonArmijoSolver< Scalar > | Playa implementation of Newton's method with Armijo line search |
| Sundance::NLOp | NLOp encapsulates a discrete nonlinear problem, and can be passed to a nonlinear solver such as NOX |
| Sundance::NodalDOFMap | |
| Sundance::NodalDOFMapHN | |
| Sundance::Rivara::Node | Class Node is a vertex in a simplicial mesh |
| Playa::NonConstDataChunk< Scalar > | This class wraps a pointer to a single contiguous chunk of scalar data |
| Sundance::Noncopyable | Noncopyable has a private copy ctor and assignment operator, which prevents any classes dervied from it from being copied |
| Playa::NonlinearOperator< Scalar > | User-level nonlinear operator class |
| Playa::NonlinearOperatorBase< Scalar > | Base class for nonlinear operators |
| Sundance::NonlinearPDEConstrainedObj | NonlinearPDEConstrainedObj is a base class for objective functions of the reduced-space variable where the constraint is a nonlinear PDE in the state variables |
| Sundance::NonlinearProblem | NonlinearProblem encapsulates a discrete nonlinear problem |
| Playa::NonlinearSolver< Scalar > | |
| Playa::NonlinearSolverBase< Scalar > | Base interface for nonlinear solvers |
| Sundance::NonlinearUnaryOp | |
| Sundance::NonlinearUnaryOpEvaluator | |
| Sundance::NonzeroDomain | |
| PlayaFunctors::Norm1< Scalar > | 1-norm of a vector |
| PlayaFunctors::Norm1Dist< Scalar > | One-norm distance between two vectors |
| PlayaFunctors::Norm2< Scalar > | Euclidean norm of a vector |
| PlayaFunctors::Norm2Dist< Scalar > | Euclidean distance between two vectors |
| PlayaFunctors::NormInf< Scalar > | Infinity norm of a vector |
| PlayaFunctors::NormInfDist< Scalar > | Infinity-norm distance between two vectors |
| Playa::NOXSolver | Playa wrapper for NOX solver |
| Sundance::NullCellFilter | NullCellFilter is used as a placeholder cell filter in those equations defined independently of geometry, i.e., equations involving only global parameters |
| Sundance::NullEvaluator | |
| Playa::ObjectiveBase | Base class for differentiable objective functions |
| Sundance::ObjectWithClassVerbosity< X > | ObjectWithClassVerbosity and the related verbosity() method provide a method for getting/setting verbosity flags for entire classes |
| Sundance::ObjectWithInstanceID< T > | ObjectWithInstanceID provides a common method for the generation of instance-specific ID numbers |
| Playa::ObjectWithVerbosity | ObjectWithVerbosity provides a common interface for reading and setting verbosity levels |
| Sundance::OneTetMesher | Create a mesh having one tet |
| Sundance::OneTriangleMesher | Create a mesh having one triangle |
| Playa::OperatorBuilder< Scalar > | Base class for building test operators |
| Anasazi::OperatorTraits< double, SimpleMV, LinearOperator< double > > | |
| Belos::OperatorTraits< double, SimpleMV, LinearOperator< double > > | |
| Playa::OptBuilder | Builder class for optimizer objects |
| Playa::OptConvergenceTestBase | Base class for convergence tests for optimization algorithms |
| Playa::OptConvergenceTestBuilder | Builder class for optimizer convergence tests |
| Playa::OptState | OptState encapsulates the current state of an optimization run, for use in convergence testing |
| Sundance::OrderedHandle< PointerType > | Class OrderedHandle is an extension to Playa::Handle that includes a comparison operator ("<" operator) so that the handle can be used in ordered containers such as STL maps and sets |
| Sundance::OrderedPair< A, B > | OrderedPair provides a means of lexigraphic comparison of a pair of objects |
| Sundance::OrderedQuartet< A, B, C, D > | Lexigraphically-comparable quartet of objects |
| Sundance::OrderedTriple< A, B, C > | Lexigraphically-comparable triple of objects |
| Playa::Out | Class Out provides standardized access to fancy streams for writing diagnostic output |
| Sundance::OutputControlParameters | |
| Sundance::Pair< T > | |
| Sundance::Parameter | A Parameter is an expression subtype used to represent a spatially-constant parameter that may change during the course of a simulation, for example, the time in a transient simulation or a continuation parameter when using a homotopy method |
| Sundance::ParameterControlledObjectWithVerbosity< X > | |
| Sundance::ParameterData | ParameterData is the specialization of DiscreteFuncDataStub to the case of a constant-valued discrete function |
| Playa::ParameterListPreconditionerFactory | |
| Sundance::PartialElementDOFMap | PartialElementDOFMap is a DOF map specialized to the case of element-based DOFs on a subset of cells in the domain |
| Sundance::PartitionedLineMesher | PartitionedLineMesher meshes the one-dimensional interval ![$\left[a_x, b_x\right]$](form_156.png) with  elements per processor |
| Sundance::PartitionedRectangleMesher | PartitionedRectangleMesher meshes the rectangle ![$ \left[a_x, b_x\right] \otimes \left[a_y, b_y\right] $](form_158.png) with  elements per processor |
| Playa::PCDPreconditionerFactory | |
| Sundance::PDEConstrainedObjBase | PDEConstrainedObj is a base class for objective functions of the reduced-space variable where the constraint is a PDE in the state variables |
| Sundance::PeanoMesher2D | |
| Sundance::PeanoMesher3D | |
| Sundance::PeanoMeshType2D | PeanoMeshType is used to create PeanoMesh objects |
| Sundance::PeanoMeshType3D | PeanoMeshType is used to create PeanoMesh objects |
| Sundance::PeriodicLineMesher | Create a mesh having one triangle |
| Sundance::PeriodicMesh1D | Periodic mesh in 1D |
| Sundance::PeriodicMeshType1D | |
| Sundance::PeriodicSingleCellMesh1D | Periodic one-element mesh in 1D |
| Sundance::Point | Point represents a spatial point |
| Sundance::PointCellPredicate | |
| Sundance::PointCellPredicateFunctor | |
| Sundance::PointData | PointData is a utility class that helps create the Sundance objects required to include point measurements in an inversion problem |
| Sundance::PointDataCellPredicateFunctor | This is a functor that allows a positional cell predicate to test against the locations of the sensors |
| Sundance::PointDataExprFunctor | This is a functor that allows the sensor readings to be obtained through a Sundance user-defined expression |
| Sundance::PointwiseUserDefFunctor0 | PointwiseUserDefFunctor0 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Sundance::PointwiseUserDefFunctor1 | PointwiseUserDefFunctor1 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Sundance::PointwiseUserDefFunctor2 | PointwiseUserDefFunctor2 is an implementation of UserDefFunctor for which the user writes code to evaluate the function at a single quadrature point |
| Poisson1DTest | Solves the Poisson equation in 1D with user-specified basis functions |
| Playa::PoissonBoltzmannJacobian | |
| Playa::PoissonBoltzmannOp | |
| Sundance::PolygonQuadrature | Quadrature special for the polygon curve integration |
| Sundance::PositionalCellPredicate | PositionalCellPredicate tests whether the cell's nodes satisfy a condition on their positions |
| Sundance::PositiveDomain | |
| Sundance::PowerFunctor | |
| Playa::Preconditioner< Scalar > | Preconditioner stores left and/or right operators for use in preconditioning |
| Playa::PreconditionerBase< Scalar > | Base class for preconditioners |
| Playa::PreconditionerFactory< Scalar > | PreconditionerFactory builds an implementation-specific preconditioner from an abstract specification |
| Playa::PreconditionerFactoryBase< Scalar > | Base class for preconditioner factories |
| Playa::Printable | Printable defines an interface for writing an object to a stream |
| Sundance::ProductEvaluator | |
| Sundance::ProductExpr | ProductExpr represents a product of two scalar-valued expressions |
| Sundance::ProductTransformation | ProductTransformation is a base class for any transformation which takes the two operands of a product (left, right) and produces a new expression mathematically equivalent to the original product |
| Sundance::ProductTransformationSequence | ProductTransformationSequence is a sequence of transformations to be applied to a product, producing a transformed expression |
| Projection1DTest | Performs L2 projection in 1D with user-specified basis functions |
| Sundance::QuadQuadrature | Get abscissas and weights for Gaussian quadrature on quadrilateral |
| Sundance::QuadratureEvalMediator | |
| Sundance::QuadratureFamily | QuadratureFamily is a geometry-independent specification of a method by which quadrature is to be carried out |
| Sundance::QuadratureFamilyBase | QuadratureFamilyBase extends QuadratureFamilyStub to provide an interface for getting quadrature points for a given cell type |
| Sundance::QuadratureFamilyStub | |
| Sundance::QuadratureIntegral | |
| Sundance::QuadratureIntegralBase | |
| Sundance::QuadratureType | QuadratureFamily is a geometry-independent specification of a method by which quadrature is to be carried out |
| Sundance::QuadratureTypeBase | QuadratureTypeBase |
| Sundance::RadialSphericalCoordinateSystem | |
| Playa::Rand | |
| PlayaFunctors::Random< Scalar > | Set each element to a random scalar |
| Playa::RandomBlockMatrixBuilder< Scalar > | |
| Playa::RandomSparseMatrixBuilder< Scalar > | |
| Sundance::RaviartThomas | Lowest-order Raviart-Thomas basis |
| Sundance::RearrangeLeftProductWithConstant | Rearrange a product whose left operand is a product including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeLeftSumWithConstant | Rearrange a sum whose left operand is a sum including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeRightProductWithConstant | Rearrange a product whose right operand is a product including a constant such that constants are grouped on the left:
|
| Sundance::RearrangeRightSumWithConstant | Rearrange a sum whose right operand is a sum including a constant such that constants are grouped on the left:
|
| PlayaFunctors::Reciprocal< Scalar > | Elementwise reciprocal |
| Sundance::RectangleDomain | This class bundles together a sequence of uniform meshes of the 2D rectangle [ax,bx] times [ay,by] with cell filters defining the interior and boundaries |
| PlayaFunctors::ReductionFunctorBase< Scalar > | Base class for reduction functors |
| Sundance::RefinementTransformation | |
| Sundance::RefIntegral | RefIntegral represents the integrals of a product of basis functions (or their derivatives) over a reference cell |
| Sundance::RegionQuadCombo | Expressions may appear in more than one subregions of a problem, for instance in an internal domain and also on a boundary |
| Sundance::RemoveMinusOneFromProduct | Transform a product by removing multiplication by -1.0:
|
| Sundance::RemoveOneFromProduct | Transform a product by removing multiplication by 1.0:
|
| Sundance::RemoveUnaryMinusFromSum | Simplify sums involving unary minuses
|
| Sundance::RemoveZeroFromProduct | Transform a product by removing a zero term:
|
| Sundance::RemoveZeroFromSum | Transform a sum by removing a zero term:
|
| Sundance::ReorderSum | Put terms in a standard order |
| Sundance::Rivara::RivaraMesh | |
| Playa::RowAccessibleOp< Scalar > | Base interface for operators for which a row may be extracted |
| Playa::RuntimeError | RuntimeError is an exception that occurs as a result of invalid user-level code |
| NOX::StatusTest::SafeCombo | Arbitrary combination of status tests, implemented with safe memory management |
| Sundance::ScalarBasis | Base class for scalar-valued basis families |
| Sundance::ScalarExpr | |
| PlayaFunctors::ScalarMult< Scalar > | Multiplication by a scalar |
| Playa::SerialGhostImporter | Ghost element importer for serial vectors |
| Playa::SerialGhostView | Dummy ghost element viewer for serial vectors |
| Sundance::SerialPartitionerBase | Base class for mesh partitioners that run in serial |
| Playa::SerialVector | Playa implementation of a serial vector, implementing the LoadableVector interface allowing an application to access elements |
| Playa::SerialVectorSpace | |
| Playa::SerialVectorType | \!brief Serial vector type is a factory for serial vector spaces |
| Sundance::Set< Key, Compare > | Extension of STL set, adding some nicer syntax and an iostream insertion operator |
| Playa::SetableBlockOperatorBase< Scalar > | Class SetableBlockOperatorBase provides an abstract interface for setting blocks of block operators |
| PlayaFunctors::SetConstant< Scalar > | Setting all elements to a constant |
| Sundance::SideCellFilter | |
| Playa::SimpleAddedOp< Scalar > | Represent a sum of operators A_0 + A_1 + |
| Playa::SimpleBacktracking | Simple backtracking line search |
| Playa::SimpleBlockOp< Scalar > | Array-based block operator |
| Playa::SimpleComposedOp< Scalar > | Represent a composed operator A_0 * A_1 * |
| Playa::SimpleDiagonalOp< Scalar > | |
| Playa::SimpleIdentityOp< Scalar > | |
| Anasazi::SimpleMV | |
| SimplePoisson1DTest | This class sets up a test that checks convergence rate for solution of the Poisson equation in 1D with Lagrange(2) basis functions |
| Playa::SimpleScaledOp< Scalar > | Represent a scaled operator |
| Playa::SimpleTransposedOp< Scalar > | Represent the transpose of an operator |
| Playa::SimpleZeroOp< Scalar > | |
| Playa::SingleChunkVector< Scalar > | Base class for vector types that have all on-processor data in a single contiguous chunk |
| Sundance::SloppyPointComparitor | Do lexigraphic comparison on points, including a bit of sloppiness |
| Playa::SolverState< Scalar > | SolverState provides information about the result of a linear or nonlinear solve |
| Sundance::SortedPair< T > | |
| Sundance::SparsitySuperset | |
| Sundance::SpatialDerivSpecifier | This class is a compact description of type of spatial derivative acting on an operative function: partial derivative, divergence, or normal derivative |
| Sundance::SpatiallyConstantExpr | |
| Sundance::SpatiallyHomogeneousDOFMapBase | |
| NOX::NOXPlaya::StatusTestBuilder | |
| Sundance::StdFwkEvalMediator | StdFwkEvalMediator evaluates mesh-dependent functions in the standard framework |
| Sundance::StdProductTransformations | Apply a standard set of transformations |
| Sundance::StdSumTransformations | Apply a standard set of transformations |
| Playa::SteepestDescent | Implements the steepest descent method, used here mainly for debugging objective functions and gradients |
| Playa::SteepestDescentDirection | |
| Sundance::StepControlParameters | |
| Sundance::StochBlockJacobiSolver | |
| Sundance::StrictlyPositiveDomain | |
| Sundance::StringEvalMediator | |
| Sundance::SubsetCellFilter | |
| Sundance::SubsetManager | SubsetManager keeps maps from cell filters to their subsets |
| Sundance::SubtypeEvaluator< ExprType > | |
| Sundance::SumConstants | Sum two constant exprs without transformation |
| Sundance::SumEvaluator | |
| Sundance::SumExpr | SumExpr is the internal representation of an addition or subtraction node in the expression tree |
| Sundance::SumIntegrals | Transform sum of integrals to SumOfIntegral objects |
| Sundance::SumOfBCs | SumOfBCs represents a sum of essential boundary conditions in integral form |
| Sundance::SumOfIntegrals | SumOfIntegrals represents a sum of integrals, grouped by region and quadrature rule |
| Sundance::SumTransformation | SumTransformation is a base class for any transformation which takes the two operands of a sum (left, right) and produces a new expression mathematically equivalent to the original sum |
| Sundance::SumTransformationSequence | SumTransformationSequence is a sequence of transformations to be applied to a sum, producing a transformed expression |
| Sundance::SundanceGlobal | Class Sundance provides several static methods for managing the environment of a simulation |
| Sundance::SundanceSurf3DCalc | This class contains the computational methods which are necessary for the 3D surface and cut-cell calculations |
| Sundance::SurfQuadrature | The surface integral class |
| Sundance::SymbolicFunc | SymbolicFunc is a base class for functions such as test and unknown functions that are "variables" in a weak form |
| Sundance::SymbolicFuncDescriptor | This is a base class for functions or elements that need to report whether they're test or unknown functions |
| Sundance::SymbolicFuncElement | SymbolicFuncElement represents a scalar-valued element of a (possibly) list-valued SymbolicFunction |
| Sundance::SymbolicFuncElementEvaluator | |
| Sundance::SymbolicTransformation | SumTransformation is a base class for any transformation which takes the two operands of a sum (left, right) and produces a new expression mathematically equivalent to the original sum |
| Sundance::SymbPreprocessor | |
| Playa::Tabs | Tabbing utility for output |
| Sundance::TakeConstantUnderIntegralSign | Rearrange a product of a constant and an integral so that the constant is under the integral sign:
|
| Sundance::TempStack | TempStack provides a stack of temporary variables for use during evaluation |
| Sundance::TensorBasisBase | |
| Playa::TesterBase< Scalar > | |
| Sundance::TestFuncDataStub | TestFuncDataStub is a placeholder for data to be shared between multiple components of a test function |
| Sundance::TestFuncElement | TestFuncElement represents a scalar-valued element of a (possibly) list-valued TestFunction |
| Sundance::TestFunction | TestFunction represents a test function in a finite element problem |
| Sundance::TestFunctionData | TestFunctionData contains the specification of a test function's basis |
| Sundance::TestFunctionStub | TestFunctionStub is the base class for unknown functions |
| Playa::TestSpecifier< Scalar > | |
| Sundance::TetQuadrature | Get abscissas and weights for Gaussian quadrature on tetrahedra |
| Sundance::ThresholdEventDetector | |
| Sundance::TransientStepProblem | |
| Sundance::TrapesoidQuadrature | |
| Sundance::Rivara::TreeNode | Class TreeNode represents a node in a Rivara mesh refinement tree |
| Sundance::TriangleMeshReader | TriangleMeshReader reads a mesh stored in Shewchuk's Triangle format |
| Sundance::TriangleQuadrature | Get abscissas and weights for Gaussian quadrature on triangles |
| Sundance::TriangleWriter | TriangleWriter writes a mesh or fields to a file in Shewchuk's Triangle format |
| Sundance::TriangleWriterFactory | TriangleWriterFactory produces an Triangle writer in contexts where a user cannot do so directly |
| Sundance::TrivialGrouper | Grouper |
| Sundance::UnaryEvaluator< ExprType > | |
| Sundance::UnaryExpr | UnaryExpr is a base class for operators that map a single scalar expr to another scalar expr |
| Sundance::UnaryFunctor | |
| Sundance::UnaryMinus | |
| Sundance::UnaryMinusEvaluator | |
| Sundance::UnboundedDomain | |
| Playa::UnconstrainedOptimizerBase | Base class for unconstrained optimizers |
| Sundance::UniformRefinementPair | |
| Sundance::UnknownFuncDataStub | UnknownFuncDataStub is a placeholder for data to be shared between multiple components of an unknown function |
| Sundance::UnknownFuncElement | UnknownFuncElement represents a scalar-valued element of a (possibly) list-valued UnknownFunction |
| Sundance::UnknownFunction | UnknownFunction represents an unknown function in a finite element problem |
| Sundance::UnknownFunctionData | UnknownFunctionData contains the specification of an unknown function's basis |
| Sundance::UnknownFunctionStub | UnknownFunctionStub is the base class for unknown functions |
| Sundance::UnknownParameter | |
| Sundance::UnknownParameterElement | UnknownParameterElement represents an element of an unknown spatially-constant parameter |
| Sundance::UserDefFunctor | UserDefFunctor defines an interface for callbacks used to implement user-defined nonlinear operators in the Sundance Expr system |
| Sundance::UserDefFunctorElement | Scalar-valued element of a vector-valued functor |
| Sundance::UserDefOp | UserDefOp provides a hook for inserting a user-defined nonlinear function into the Sundance Expr system |
| Sundance::UserDefOpCommonEvaluator | UserDefOpCommonEvaluator provides a single evaluation point for all components of a vector-valued functor |
| Sundance::UserDefOpElement | Scalar element of a vector-valued user-defined expression |
| Sundance::UserDefOpEvaluator | |
| NOX::NOXPlaya::Vector | Implementation of the NOX::Abstract::Vector interface for Playa::Vector<double> (using Playa handle to PlayaCore) |
| Playa::Vector< Scalar > | User-level vector class |
| Sundance::VectorAssemblyKernel | VectorAssemblyKernel builds load vectors |
| Playa::VectorBase< Scalar > | |
| Sundance::VectorBasis | |
| Sundance::VectorBasisComponent | This class is for the representation of a single component of a vector-valued basis family |
| Sundance::VectorFillingAssemblyKernel | VectorFillingAssemblyKernel provides a common implementation of multivector-filling capabilities needed by matrix-vector assembly, multivector assembly, and functional gradient evaluation |
| PlayaFunctors::VectorFunctorTraits< Scalar, FunctorType > | This traits class specifies the return type of a reduction functor |
| PlayaFunctors::VectorFunctorTraits< Scalar, BoundedMaxLocFunctor< Scalar > > | Specify return type of BoundedMaxLocFunctor |
| PlayaFunctors::VectorFunctorTraits< Scalar, BoundedMinLocFunctor< Scalar > > | Specify return type of BoundedMinLocFunctor |
| Playa::VectorSpace< Scalar > | User-level VectorSpace class |
| Playa::VectorSpaceBase< Scalar > | |
| Playa::VectorTester< Scalar > | Run comparisons between element-wise calculations and Vector member functions |
| Playa::VectorType< Scalar > | Vector type objects are used by the application code to create vector spaces and operators of a given type |
| Playa::VectorTypeBase< Scalar > | |
| Sundance::VerboseFieldWriter | VerboseFieldWriter dumps every imaginable bit of information about a mesh |
| Sundance::VerbosityTraits< X > | Defines traits for getting default verbosity parameters from a class |
| Sundance::VersionString | |
| Sundance::VertexView | VertexView is a read-only "view" of a cell's vertices, where the vertices are stored contiguously in a large master array |
| Sundance::VTKWriter | VTKWriter writes a mesh or fields to a VTK file |
| Sundance::VTKWriterFactory | Create a VTKWriter |
| Sundance::WatchFlag | Class WatchFlag is used to mark individual expressions for possibly increased verbosity for diagnostic output |
| PlayaFunctors::WeightedNorm2< Scalar > | Weighted 2-norm of a vector |
| PlayaFunctors::XPlusBetaY< Scalar > | X + b*y |
| Sundance::ZeroExpr |
![\[ (u D_x) v \rightarrow u D_x u \]](form_128.png)
![\[ D_x (\alpha u) \rightarrow \alpha D_x u \]](form_131.png)
![\[ (D_1 + D_2) u \rightarrow D_1 u + D_2 u \]](form_132.png)
![\[ K x = \lambda M x. \]](form_192.png)
![\[ D_x \alpha \rightarrow 0 \]](form_129.png)
![\[ D_x (\alpha + u) \rightarrow D_x u \]](form_130.png)
![\[ x \times a \rightarrow a \times x \]](form_124.png)
![\[ x + a \rightarrow a + x \]](form_142.png)
![\[ (-x) \times y \rightarrow -(x \times y) \]](form_125.png)
![\[ x \times (-y) \rightarrow -(x \times y) \]](form_126.png)
![\[ )-x) \times (-y) \rightarrow x \times y \]](form_127.png)
![\[ (\alpha u)\beta \rightarrow \alpha\beta u \]](form_135.png)
![\[ (\alpha u)v \rightarrow \alpha (u v) \]](form_136.png)
![\[ (\alpha + s_1 u) + s_2 \beta \rightarrow (\alpha + s_2 \beta) + s_1 u \]](form_145.png)
![\[ (\alpha + s_1 u) + s_2 v \rightarrow \alpha + (s_1 u + s_2 v) \]](form_146.png)
![\[ \alpha (\beta u) \rightarrow (\alpha\beta) u \]](form_133.png)
![\[ u (\alpha v) \rightarrow \alpha (u v) \]](form_134.png)
![\[ \alpha + s_1 (\beta + s_2 u) \rightarrow (\alpha + s_1 \beta) + s_1 s_2 u \]](form_143.png)
![\[ u + s_1 (\alpha + s_2 v) \rightarrow s_1 \alpha + (u + s_1 s_2 v) \]](form_144.png)
![\[ x \times (-1.0) \rightarrow -x. \]](form_122.png)
![\[ -1.0 \times x \rightarrow -x. \]](form_123.png)
![\[ x \times 1.0 \rightarrow x. \]](form_120.png)
![\[ 1.0 \times x \rightarrow x. \]](form_121.png)
![\[ x + (-y) \rightarrow x-y. \]](form_138.png)
![\[ (-x) + (-y) \rightarrow -(x+y). \]](form_139.png)
![\[ (-x) + y \rightarrow y-x. \]](form_140.png)
![\[ x \times 0 \rightarrow 0. \]](form_118.png)
![\[ 0 \times x \rightarrow 0. \]](form_119.png)
![\[ x + 0 \rightarrow x. \]](form_141.png)
![\[ \alpha \int u \rightarrow \int \alpha u \]](form_137.png)