Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
AbsorbBC< T >Here is an example of adding a new particle boundary condition
AddNewDomain2Dimensions< T1, T2 >
AffinityCombineThis trivial combiner returns the left-most object in an expression
AllDomain< Dim >AllDomain is a special domain class which is used as a 'wildcard'
AndCombine
AntisymmetricLike this, for the 3D case; just chop off pieces for 1D and 2D:
ApplyMultiArgLoc< MultiArg1< A1 >, Function >
ApplyMultiArgLoc< MultiArg2< A1, A2 >, Function >
ApplyMultiArgLoc< MultiArg3< A1, A2, A3 >, Function >
ApplyMultiArgLoc< MultiArg4< A1, A2, A3, A4 >, Function >
ApplyMultiArgLoc< MultiArg5< A1, A2, A3, A4, A5 >, Function >
ApplyMultiArgLoc< MultiArg6< A1, A2, A3, A4, A5, A6 >, Function >
ApplyMultiArgLoc< MultiArg7< A1, A2, A3, A4, A5, A6, A7 >, Function >
Cheetah::ARRAY
Array< Dim, T, EngineTag >Arrays are used to apply operations to N-dimensional (N <= 7) logically rectangular, logically dense sets of elements
AssertEqualsAssertEquals is a handy class for asserting conformance of an integer value in expressions
Pete::Assertion
Pooma::AssertionAssertion: exception notification class for assertions
AssignFunction
AssignFunctionForClass
AssignOpReadWriteTraits< Op >
AssignOpReadWriteTraits< OpAssign >
TensorEngine< D, T, Antisymmetric >::AssignProxy
TensorEngine< D, T, Diagonal >::AssignProxy
AttributeAttribute is an abstract base class used to implement an external polymorphism interface to DynamicArray objects
AttributeList
AttributeWrapper< T >AttributeWrapper<T> is a subclass of the abstract base class Attribute
BackFillBackFill: A tag class used to indicate that delete operation should proceed by 'backfilling', that is, moving data up from the end of a list to fill in holes
BasicTypeProperties< T >Basic types are the C basic types
BenchmarkBenchmark provides a user interface for creating, running, and tabulating results for benchmarks
BinaryAssignBoolOp
BinaryAssignOp
BinaryBoolOp
BinaryFunction
BinaryLeftOp
BinaryNode< Op, Left, Right >
BinaryOp
BinaryReturn< T1, T2, Op >
BinaryReturn< complex< T >, int, FnPow >
BinaryReturn< MinusOne< T >, MinusOne< T >, OpEQ >
BinaryReturn< MinusOne< T >, MinusOne< T >, OpMultiply >
BinaryReturn< MinusOne< T >, MinusOne< T >, OpSubtract >
BinaryReturn< MinusOne< T >, One< T >, OpAdd >
BinaryReturn< MinusOne< T >, One< T >, OpDivide >
BinaryReturn< MinusOne< T >, One< T >, OpMultiply >
BinaryReturn< MinusOne< T >, T, OpMultiply >
BinaryReturn< MinusOne< T1 >, MinusOne< T2 >, Op >
BinaryReturn< MinusOne< T1 >, One< T2 >, Op >
BinaryReturn< MinusOne< T1 >, Zero< T2 >, Op >
BinaryReturn< One< T >, MinusOne< T >, OpAdd >
BinaryReturn< One< T >, MinusOne< T >, OpDivide >
BinaryReturn< One< T >, MinusOne< T >, OpMultiply >
BinaryReturn< One< T >, One< T >, OpEQ >
BinaryReturn< One< T >, One< T >, OpMultiply >
BinaryReturn< One< T >, One< T >, OpSubtract >
BinaryReturn< One< T >, T, OpMultiply >
BinaryReturn< One< T1 >, MinusOne< T2 >, Op >
BinaryReturn< One< T1 >, One< T2 >, Op >
BinaryReturn< One< T1 >, Zero< T2 >, Op >
BinaryReturn< T, MinusOne< T >, OpDivide >
BinaryReturn< T, MinusOne< T >, OpMultiply >
BinaryReturn< T, One< T >, OpDivide >
BinaryReturn< T, One< T >, OpMultiply >
BinaryReturn< T, Zero< T >, OpAdd >
BinaryReturn< T, Zero< T >, OpMultiply >
BinaryReturn< T, Zero< T >, OpSubtract >
BinaryReturn< T1, T2, FnAndAssign >
BinaryReturn< T1, T2, FnMaxAssign >
BinaryReturn< T1, T2, FnMinAssign >
BinaryReturn< T1, T2, FnOrAssign >
BinaryReturn< T1, T2, OpAddAssign >
BinaryReturn< T1, T2, OpAnd >
BinaryReturn< T1, T2, OpAssign >
BinaryReturn< T1, T2, OpBitwiseAndAssign >
BinaryReturn< T1, T2, OpBitwiseOrAssign >
BinaryReturn< T1, T2, OpBitwiseXorAssign >
BinaryReturn< T1, T2, OpDivideAssign >
BinaryReturn< T1, T2, OpEQ >
BinaryReturn< T1, T2, OpEQ2 >
BinaryReturn< T1, T2, OpGE >
BinaryReturn< T1, T2, OpGE2 >
BinaryReturn< T1, T2, OpGT >
BinaryReturn< T1, T2, OpGT2 >
BinaryReturn< T1, T2, OpLE >
BinaryReturn< T1, T2, OpLE2 >
BinaryReturn< T1, T2, OpLeftShift >
BinaryReturn< T1, T2, OpLeftShiftAssign >
BinaryReturn< T1, T2, OpLT >
BinaryReturn< T1, T2, OpLT2 >
BinaryReturn< T1, T2, OpMask< Op > >
BinaryReturn< T1, T2, OpModAssign >
BinaryReturn< T1, T2, OpMultiplyAssign >
BinaryReturn< T1, T2, OpNE >
BinaryReturn< T1, T2, OpNE2 >
BinaryReturn< T1, T2, OpOr >
BinaryReturn< T1, T2, OpRightShift >
BinaryReturn< T1, T2, OpRightShiftAssign >
BinaryReturn< T1, T2, OpSubtractAssign >
BinaryReturn< T1, T2, WhereMask >
BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, FnDot >
BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, OpEQ >
BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, OpNE >
BinaryReturn< Tensor< D, T1, E1 >, Vector< D, T2, E2 >, FnDot >
BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, OpEQ >
BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, OpNE >
BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, TinyMatrix< D2, D3, T2, E2 >, FnDot >
BinaryReturn< TinyMatrix< D1, D2, T1, E1 >, Vector< D2, T2, E2 >, FnDot >
BinaryReturn< Vector< D, T1, E1 >, Tensor< D, T2, E2 >, FnDot >
BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, FnDot >
BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, FnOuterProduct >
BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, FnOuterProductAsTinyMatrix >
BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, OpEQ >
BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, OpNE >
BinaryReturn< Vector< D1, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, FnDot >
BinaryReturn< Zero< T >, MinusOne< T >, OpSubtract >
BinaryReturn< Zero< T >, One< T >, OpSubtract >
BinaryReturn< Zero< T >, T, OpAdd >
BinaryReturn< Zero< T >, T, OpDivide >
BinaryReturn< Zero< T >, T, OpMultiply >
BinaryReturn< Zero< T >, T, OpSubtract >
BinaryReturn< Zero< T >, Zero< T >, OpAdd >
BinaryReturn< Zero< T >, Zero< T >, OpMultiply >
BinaryReturn< Zero< T >, Zero< T >, OpSubtract >
BinaryReturn< Zero< T1 >, MinusOne< T2 >, Op >
BinaryReturn< Zero< T1 >, One< T2 >, Op >
BinaryReturn< Zero< T1 >, Zero< T2 >, Op >
BinaryReturn< Zero< T1 >, Zero< T2 >, OpEQ >
BinarySpecialOp
BisectionMapper< Dim >BisectionMapper is a ContextMapper implementation
BlockAffinityDataObjectRequest<BlockAffinity> Used to get the affinity for an array
BrickThese are tag classes used to select the "Brick" and "BrickView" specializations of the Engine class template
Pooma::BrickBase< Dim >BrickBase<Dim> is the base-class for engines that have a Brick-like interpretation of a block of data; i.e
BrickView
Pooma::BrickViewBase< Dim >BrickViewBase<Dim> is the base-class for engines that are "views" into brick-like engines
BrickViewU
CanonicalCentering< Dim >This object makes available some canonical centerings
Cartesian< Dim >
CellVolumesTraits< Mesh >
Centering< Dim >Centering indicates the positions of values within a field's cell
Pooma::CenteringViewTag
Cheetah::CHEETAH
CIC
CICCacheData< Dim, T >
CICGather< FC, Dim, T >
CICGatherFillCache< FC, Dim, T >
CICGatherUseCache< FC, Dim, T >
CICScatter< FC, Dim, T >
CICScatterFillCache< FC, Dim, T >
CICScatterUseCache< FC, Dim, T >
CICScatterValue< FC, Dim, T, ValueT >
CICScatterValueFillCache< FC, Dim, T, ValueT >
CICScatterValueUseCache< FC, Dim, T, ValueT >
ClassDescriptor
Pooma::ClockClock provides a running timer, utilizing high-speed SGI timers if available
CollectFromContexts< T >
Combine1< A, Op, Tag >
Combine1< A, Op, OpCombine >
Combine1< A, Op, TreeCombine >
Combine1< Field< G1, T1, E1 >, Op, FarLeftTag >
Combine2< A, B, Op, Tag >
Combine2< A, B, Op, OpCombine >
Combine2< A, B, Op, TreeCombine >
Combine2< bool, bool, Op, AndCombine >
Combine2< bool, bool, Op, OrCombine >
Combine2< Domain, Domain, Op, DomainFunctorTag >Anything on a domain can be added to the something on the same domain
Combine2< Domain, NullDomain, Op, DomainFunctorTag >Something plus a scalar should return the domain type of the something
Combine2< Domain1, Domain2, Op, DomainFunctorTag >Here we supply combiners that work with DomainFunctorTag to combine domains
Combine2< ErrorType, T, Op, FarLeftTag >
Combine2< Eval1, Eval2, Op, EvaluatorCombineTag >
Combine2< Field< G1, T1, E1 >, Field< G2, T2, E2 >, Op, FarLeftTag >
Combine2< Field< G1, T1, E1 >, T, Op, FarLeftTag >
Combine2< int, int, Op, AffinityCombine >
Combine2< int, int, Op, AssertEquals >
Combine2< int, int, Op, NullCombine >
Combine2< int, int, Op, SumCombine >
Combine2< NullDomain, Domain, Op, DomainFunctorTag >
Combine2< T, ErrorType, Op, FarLeftTag >
Combine2< T, Field< G2, T2, E2 >, Op, FarLeftTag >
Combine2< WrappedInt< A >, WrappedInt< B >, Op, AndCombine >
Combine3< A, B, C, Op, Tag >
Combine3< A, B, C, Op, FarLeftTag >
Combine3< A, B, C, Op, OpCombine >
Combine3< A, B, C, Op, TreeCombine >
CombineDomain< RT, CT, DS >CombineDomain is a utility class used only by the 'fill*' methods of NewDomain2
CombineDomainOpt< NewDomain, false >Multi-valued version
CombineDomainOpt< NewDomain, true >Single valued specialization
CombineExpressionTraits< A, B >CombineExpressionTraits<Trait1,Trait2>::Type_t is used to describe the result of various expression types
CombineExpressionTraits< ExpressionIsArray, ExpressionIsArray >
CombineExpressionTraits< ExpressionIsArray, ExpressionIsField >
CombineExpressionTraits< ExpressionIsArray, ExpressionIsScalar >
CombineExpressionTraits< ExpressionIsField, ExpressionIsArray >
CombineExpressionTraits< ExpressionIsField, ExpressionIsField >
CombineExpressionTraits< ExpressionIsField, ExpressionIsScalar >
CombineExpressionTraits< ExpressionIsScalar, ExpressionIsArray >
CombineExpressionTraits< ExpressionIsScalar, ExpressionIsField >
CombineSliceDomain< RT, UT, CT, DS, SliceDS, incl >General version of CombineSliceDomain
CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, incl, wc >General version of CombineSliceDomainWC
CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, false, true >Specialization of CombineSliceDomainWC in which we only fill in total domain values, using wildcards
CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, true, false >Specialization of CombineSliceDomainWC in which we fill in slice domain values and full domain values, but without using wildcards
CombineSliceDomainWC< RT, UT, CT, DS, SliceDS, true, true >Specialization of CombineSliceDomainWC in which we fill in slice domain values and full domain values, using wildcards
CompFwd< Eng, Components >The component forwarding tag class
ComponentAccess< T, Components >ComponentAccess is an interface class that is used to provide an API for accessing components of a composite type
ComponentAccess< RNG, RNGAdvance >
ComponentAccess< RNG, RNGSeed >
ComponentAccess< RNG, RNGValue >
ComponentAccess< Tensor< D, T, E >, Loc< N > >
ComponentAccess< TinyMatrix< D1, D2, T, E >, Loc< N > >
ComponentAccess< Vector< D, T, E >, Loc< N > >
ComponentView< Components, Array< Dim, T, EngineTag > >ComponentView specialization for Array
ComponentView< Components, DynamicArray< T, EngineTag > >
ComponentView< Components, Field< Mesh, T, EngineTag > >
ComponentWrapper< Components >Wrapper class to encapsulate a component specification
Compressed
CompressedBrickIsWholeView
CompressedRead
CompressedReadWrite
CompressibleCompressible<Engine> CompressedRead<Engine> CompressedReadWrite<Engine>
CompressibleBlock< T >CompressibleBlock (CBlock) provides the storage for Pooma's compressible brick engine
CompressibleBrickThese are tag classes used to select the "CompressibleBrick" and "CompressibleBrickView" specializations of the Engine class template
CompressibleBrickView
CompressibleKernel< lhsComp, rhsComp >
CompressibleKernel< false, false >
CompressibleKernel< false, true >
CompressibleKernel< true, false >
CompressibleKernel< true, true >
CompressibleKernelTag
CompressibleReduce< T, Op >
CompressibleReduce< T, OpAddAssign >
CompressibleReduce< T, OpMultiplyAssign >
CompressibleViewKernelTag
ConformTag< D >When evaluating expressions, we need to check to make sure that the left hand side has the same domain as the right
Connection< T >Declaration of the Connection class, that users will need to specialize
Connection< Lux >
Connection< Paws >
ConnectionBaseConnectionBase and Connection<Tag> are part of the POOMA external data connection API
Connector< D, C >Declaration of the Connector class, that users will need to specialize
Connector< Array< Dim, T, EngineTag >, Lux >
Connector< Array< Dim, T, EngineTag >, Paws >
Connector< ConnectPair< DynamicArray< T1, E >, DynamicArray< T2, E > >, Lux >
Connector< DynamicArray< T, EngineTag >, Paws >
Connector< Field< Geom, T, EngineTag >, Paws >
Connector< Field< Mesh, T, EngineTag >, Lux >
Connector< std::string, Paws >
Connector< T, Paws >
ConnectorBaseConnectionBase and Connection<Tag> are part of the POOMA external data connection API
ConnectPair< T1, T2 >ConnectPair<T1,T2> stores two items of types T1 and T2, basically the same as std::pair from the STL
ConstantFaceBC< Dim, T >ConstantFaceBC is an Relation functor class
ConstantFunctionConstantFunction is just a tag class for the constant-function engine, which makes a scalar look like an Array
ConstDerefIterator< T >
ContainsDomain< T1, T2, Dim >ContainsDomain implements a basic template meta-program to compare each dimension separately of the multidimensional domains for whether a contains b
ContainsDomain< T1, T2, 1 >
ContainsDomainSingle< T1, T2, strided >ContainsDomainSingle<T1,T2,bool strided>::contains(a,b) compares two domains a and b of type T1 and T2, and returns true if a contains b
ContainsDomainSingle< T1, T2, true >The non-unit-stride version of ContainsDomainSingle, which does extra work for the case where a and b do not have unit stride
ContextMapper< Dim >
ContiguousMapper< Dim >ContiguousMapper is a ContextMapper implementation
ConvertWhereProxy< ETrait, Tree >We need the tools to convert a WhereProxy into an Array or Field or whatever, so users need to specialize
ConvertWhereProxy< ExpressionIsArray, Tree >
ConvertWhereProxy< ExpressionIsField, Tree >
CopyEvent< Dom >CopyEvent: A class derived from ObserverEvent that stores information on how what elements to copy in an engine
CopyLocStorage< Dim, T >CopyLocStorage is a simple struct with one static member 'copy' that copies data out of a given single domain into the given Loc
CopyLocStorageImpl< Dim, T, DimT, wildcard >Implementation for CopyLocStorage
CopyLocStorageImpl< Dim, T, 1, false >
CopyLocStorageImpl< Dim, T, DimT, false >
CopyPatchEventCopyPatchEvent: A class derived from ObserverEvent that stores information on what elements to copy in an engine
CountBlocks
Pooma::CountingSemaphore
CreateEventCreateEvent: A class derived from ObserverEvent that stores information on how many elements to create, in what patch, for an engine
CreateLeaf< T >
CreateLeaf< Array< Dim, T, EngineTag > >Arrays are leaf objects, we just pass them through unless they have Expression engines
CreateLeaf< Array< Dim, T, ExpressionTag< Expr > > >
CreateLeaf< DynamicArray< T, EngineTag > >A traits class that tells PETE how to make a DynamicArray into an expression element
CreateLeaf< Expression< T > >
CreateLeaf< Field< GeometryTag, T, EngineTag > >
CreateLeaf< Field< GeometryTag, T, ExpressionTag< Expr > > >CreateLeaf is an external functor class used to convert objects into the leaves of the expression tree
CreateLeaf< Scalar< Array< Dim, T, EngineTag > > >Special case for Scalar<Array> returns ErrorType to avoid hairy type computations
CreateLeaf< Scalar< Field< GeometryTag, T, EngineTag > > >
Cylindrical
DataBlockController< T >
DataBlockPtr< T, BoundsChecked >DataBlockPtr is a customized RefCountedBlockPtr for use in various Pooma Engines
DataBrowser< DataBrowserTag >
DataBrowser< ArrayPrintDataBrowser< Dim > >
Smarts::DataObject< SerialAsync >Implements a asynchronous scheduler for a data driven execution
Smarts::DataObject< Stub >
DataObjectApply< Block >DataObjectApply is used to wrap the two cases of whether an object has a smarts data object or not
DataObjectApply< false >
DataObjectApply< true >
DataObjectRequest< RequestType >This class has two functions
DataObjectRequest< BlockAffinity >
DataObjectRequest< CountBlocks >
DataObjectRequest< ReadRelease >
DataObjectRequest< ReadRequest >
DataObjectRequest< WriteRelease >
DataObjectRequest< WriteRequest >
DecrementLeaf
DefaultEngineView< Engine, RemoteView >
DefaultExpressionApply< Eng, DataObjectRequest< Tag > >
DefaultExpressionApply< Eng, IntersectorTag< Intersect > >The default behaviour for IntersectEngine is to simply return true
DefaultExpressionApply< Eng, SimpleIntersector< Dim > >
DefaultExpressionApply< Engine, RemoteSend >
DefaultSPmapper
DefaultTPmapper< Dim >
DeReference< T >
DeReference< Reference< T > >
DereferenceLeaf
DerefIterator< T >DerefIterator<T> and ConstDerefIterator<T> are STL-style iterators that are used to properly handle iterating through lists of pointers
DescriptorBase< N >
DestroyEvent< Dom >DestroyEvent: A class derived from ObserverEvent that stores information on how what elements to destroy in an engine
DiagonalLike this, for the 3D case; just chop off pieces for 1D and 2D:
DiskLayout< Dim >Class encapsulating the reading of a "DiscField" .layout file
DiskMetaDiskMeta - reads in information in an r1 "DiscField" meta file, which is a file in the format
DiskNode< Dim >Simple struct containing a context + domain, and a constructor that can construct these from an array of 6*Dim ints
DistributedMapper< Dim >DistributedMapper is a ContextMapper implementation
DistributedTagTag class specifying domain distribution between all nodes, implying a use of DistributedMapper for mapping patches to contexts
DistributionTraits< ETag >
DistributionTraits< Remote< ETag > >
DivCellToVert< Vector< Dim, T2 >, UniformRectilinearMesh< Dim, TM > >
DivSameToSame< Vector< Dim, T2 >, UniformRectilinearMesh< Dim, TM >, OC >
DivVertToCell< Vector< Dim, T2 >, UniformRectilinearMesh< Dim, TM > >
Dom1Initialize< I >Template metaprogram for initializing the storage arrays of onedimensional domain objects
Dom1Initialize< 0 >
Domain< Dim, DT >Domain<Dim,DT> provides the bulk of the public interface for all domain objects
Domain< 1, DT >The 1D-specialized version of Domain, which acts much like the ND version but also provides a number of new or redefined interface functions:
DomainArithOpsTraits< T1, T2 >
DomainArithOpsTraits< Grid< Dim >, Loc< 1 > >
DomainArithOpsTraits< Grid< Dim >, Loc< Dim2 > >
DomainArithOpsTraits< IndirectionList< int >, Loc< 1 > >
DomainArithOpsTraits< Interval< Dim >, Loc< 1 > >
DomainArithOpsTraits< Interval< Dim >, Loc< Dim2 > >
DomainArithOpsTraits< Loc< 1 >, Grid< Dim > >
DomainArithOpsTraits< Loc< 1 >, IndirectionList< int > >
DomainArithOpsTraits< Loc< 1 >, Interval< Dim > >
DomainArithOpsTraits< Loc< 1 >, Loc< 1 > >
DomainArithOpsTraits< Loc< 1 >, Loc< Dim > >
DomainArithOpsTraits< Loc< 1 >, Range< Dim > >
DomainArithOpsTraits< Loc< Dim >, Grid< Dim2 > >
DomainArithOpsTraits< Loc< Dim >, Interval< Dim2 > >
DomainArithOpsTraits< Loc< Dim >, Loc< 1 > >
DomainArithOpsTraits< Loc< Dim >, Loc< Dim2 > >
DomainArithOpsTraits< Loc< Dim >, Range< Dim2 > >
DomainArithOpsTraits< Range< Dim >, Loc< 1 > >
DomainArithOpsTraits< Range< Dim >, Loc< Dim2 > >
DomainBase< DT >DomainBase

is the common base class for all Domain<Dim, DT> objects, regardless of the value of Dim

DomainBlockIterator< Dom >A simple iterator class to iterate through all of the points in a given domain of type Dom
DomainChangeDim< T, Dim >DomainChangeDim is a struct which is templated on a domain of type T, which has some original number of dimensions oldDim, and a new number of dimensions Dim
DomainChangeDim< Grid< Dim1 >, Dim2 >DomainChangeDim<T, int> is used to convert from a domain of one dimension to another dimension (the second template parameter)
DomainChangeDim< Interval< Dim1 >, Dim2 >DomainChangeDim<T, int> is used to convert from a domain of one dimension to another dimension (the second template parameter)
DomainChangeDim< Loc< Dim1 >, Dim2 >DomainChangeDim<T, int> is used to convert from a domain of one dimension to another dimension (the second template parameter)
DomainChangeDim< Range< Dim1 >, Dim2 >DomainChangeDim<T, int> is used to convert from a domain of one dimension to another dimension (the second template parameter)
DomainChangeDim< Region< Dim1, T >, Dim2 >DomainChangeDim<T, int> is used to convert from a domain of one dimension to another dimension (the second template parameter)
DomainFunctorTagDomainFunctorTag is a functor tag used to divine domains
DomainIterator< Dom >A simple iterator class to iterate through all of the points in a given domain of type Dom
DomainLayout< Dim >DomainLayout is used to act as a layout object for all engines that just need a simple layout for a single domain of dimension Dim
DomainMap< Dom, T >DomainMap<Domain,Data> is templated on the type of domains it is storing, and the Data type it stores for each Domain
DomainMapConstIterator< Dom, T >An iterator for a DomainMap
DomainMapIterator< Dom, T >An iterator for a DomainMap
DomainMapNode< Dom, T >DomainMapNode is a node in a tree, where each Node has a list of domains and a left and right branch
DomainMapTouchIterator< Dom, T >The touch iterator for a DomainMap
DomainTagDomainTag class
DomainTraits< T >So now, finally, we can define the default version of DomainTraits<T> which just inherits from DomainTraitsScalar<T, T, T>
DomainTraits< AllDomain< Dim > >DomainTraits<AllDomain<Dim>> provides traits information about AllDomain, which is one of the domain wildcards
DomainTraits< char >
DomainTraits< Grid< 1 > >DomainTraits<Grid<1>>: The specialization of DomainTraits for Grid, for dimension == 1
DomainTraits< Grid< Dim > >DomainTraits<Grid<Dim>>: The specialization of DomainTraits for Grid, for dimensions greater than one
DomainTraits< INode< Dim > >
DomainTraits< int >
DomainTraits< Interval< 1 > >DomainTraits<Interval<1>>: The specialization of DomainTraits for Interval, for dimension == 1
DomainTraits< Interval< Dim > >DomainTraits<Interval<Dim>>: The specialization of DomainTraits for Interval, for dimensions greater than one
DomainTraits< LeftDomain< Dim > >DomainTraits<LeftDomain<Dim>> provides traits information about LeftDomain, which is one of the domain wildcards
DomainTraits< Loc< 1 > >DomainTraits<Loc<1>>: The specialization of DomainTraits for Loc, for dimension == 1
DomainTraits< Loc< Dim > >DomainTraits<Loc<Dim>>: The specialization of DomainTraits for Loc, for dimensions greater than one
DomainTraits< long >
DomainTraits< Node< Dom, OrigDom > >
DomainTraits< Range< 1 > >DomainTraits<Range<1>>: The specialization of DomainTraits for Range, for dimension == 1
DomainTraits< Range< Dim > >DomainTraits<Range<Dim>>: The specialization of DomainTraits for Range, for dimensions greater than one
DomainTraits< Region< 1, T > >DomainTraits<Region<Dim,T>>: The traits for an 1-dimensional Region domain
DomainTraits< Region< Dim, T > >DomainTraits<Region<Dim,T>>: The traits for an N-dimensional Region domain
DomainTraits< RightDomain< Dim > >DomainTraits<RightDomain<Dim>> provides traits info about RightDomain, which is one of the domain wildcards
DomainTraits< short >
DomainTraits< SliceInterval< TotalDim, SliceDim > >DomainTraits<SliceInterval<Dim,SliceDim>> stores the characteristics and much of the implementation details for SliceInterval domain objects
DomainTraits< SliceRange< TotalDim, SliceDim > >DomainTraits<SliceRange<Dim,SliceDim>> stores the characteristics and much of the implementation details for SliceRange domain objects
DomainTraits< unsigned char >
DomainTraits< unsigned int >
DomainTraits< unsigned long >
DomainTraits< unsigned short >
DomainTraitsDomain< DomT, T, Dim >DomainTraitsDomain<DomT, T, Dim> can act as a base class for the partially- specialized versions of DomainTraits for domain-like classes, that is, classes which are derived from Domain
DomainTraitsDomain< DomT, T, 1 >1-dimensional specialized version of DomainTraitsDomain
DomainTraitsScalar< DomT, T, NewDom1T >DomainTraitsScalar<DomT, T, NewDom1T> can act as a base class for partially specialized versions of DomainTraits for non-domain classes and types, such as the basic scalar types
DomPair< T1, T2, SV >
DomPair< T1, T2, false >
Pooma::DontCopyRelationsThis tag is used to tell constructors not to copy relations
Pooma::DummyMutex
DynamicThese are tag classes used to select the "Dynamic" and "DynamicView" specializations of the Engine class template
DynamicArray< T, EngineTag >A DynamicArray is a read-write array with extra create/destroy methods
DynamicEventsA simple class that just defines enums for items involving dynamic operations on layouts and data
DynamicEventType< T >DynamicEventType is a simple partially-specialized class used to determine the event code type based on the input domain type for destroy and copy operations
DynamicEventType< IndirectionList< IndirectionList< int > > >
DynamicEventType< int >
DynamicEventType< Interval< Dim > >
DynamicEventType< IteratorPairDomain< const int * > >
DynamicEventType< IteratorPairDomain< int * > >
DynamicEventType< Loc< Dim > >
DynamicEventType< Range< Dim > >
DynamicLayoutDynamicLayout is a Layout class that breaks an N-dimensional Interval into sub-domains arranged in an N-dimensional grid, where the sub-domain sizes are specified by a Grid domain object
DynamicLayoutDataHolds the data for a DynamicLayout
DynamicLayoutViewDynamicLayoutView is a Layout class that provides a view of an existing DynamicLayout object
DynamicLayoutViewDataThe data object held by a DynamicLayoutView object
DynamicTag
DynamicViewThese are tag classes used to select the "Dynamic" and "DynamicView" specializations of the Engine class template
EdgeLengthsTraits< Mesh >
ElementProperties< T >Traits class for determining, and possibly modifying, the construction and destruction properties of elements of type T
ElementProperties< Array< Dim, T, EngineTag > >Traits class telling RefCountedBlockPointer that this class has shallow semantics and a makeOwnCopy method
ElementProperties< bool >
ElementProperties< char >
ElementProperties< CICCacheData< Dim, T > >
ElementProperties< double >
ElementProperties< DynamicArray< T, EngineTag > >Traits class telling RefCountedBlockPointer that this class has shallow semantics and a makeOwnCopy method
ElementProperties< Engine< 1, T, Dynamic > >Traits class telling RefCountedBlockPointer that this class has shallow semantics and a makeOwnCopy method
ElementProperties< Engine< Dim, T, Brick > >Traits class telling RefCountedBlockPointer that this class has shallow semantics and a makeOwnCopy method
ElementProperties< Engine< Dim, T, CompressibleBrick > >Traits class telling RefCountedBlockPointer that this class has shallow semantics and a makeOwnCopy method
ElementProperties< Engine< Dim, T, Remote< Eng > > >
ElementProperties< float >
ElementProperties< int >
ElementProperties< long >
ElementProperties< NGPCacheData< Dim, T > >
ElementProperties< short >
ElementProperties< std::complex< FloatType > >
ElementProperties< SUDSCacheData< Dim, T > >
ElementProperties< Tensor< D, T, E > >
ElementProperties< TinyMatrix< D1, D2, T, E > >
ElementProperties< unsigned char >
ElementProperties< unsigned int >
ElementProperties< unsigned long >
ElementProperties< unsigned short >
ElementProperties< Vector< D, T, E > >
Engine< 1, T, Dynamic >Engine<1,T,Dynamic> (aka Dynamic-Engine) is an Engine that manages a contiguous, local, 1-dimensional, dynamically resizable, block of data
Engine< 1, T, DynamicView >A DynamicView-Engine is an Engine that manages a view of a Dynamic-Engine
Engine< 1, T, Remote< Dynamic > >
Engine< D, T, StencilEngine< Function, Expression > >A specialization of Engine for StencilEngine
Engine< D, T, UserFunctionEngine< UserFunction, Expression > >A specialization of Engine for UserFunctionEngine
Engine< Dim, T, Brick >Engine<Dim,T,Brick> (aka Brick-Engine)
Engine< Dim, T, BrickView >Engine<T,Dim,BrickView> (aka BrickView-Engine)
Engine< Dim, T, BrickViewU >Engine<T,Dim,BrickView> (aka BrickView-Engine)
Engine< Dim, T, CompFwd< Eng, Components > >A ForwardingEngine is used to forward indices to the elements of another engine
Engine< Dim, T, CompressibleBrick >Engine<Dim,T,CompressibleBrick> (aka CompressibleBrick-Engine)
Engine< Dim, T, CompressibleBrickView >Engine<T,Dim,CompressibleBrickView> (aka CompressibleBrickView-Engine)
Engine< Dim, T, ConstantFunction >Engine<Dim, T, ConstantFunction> is a specialization of Engine for ConstantFunction
Engine< Dim, T, ExpressionTag< Expr > >This engine stores the expression tree Expr and acts like an engine that lets you look at the values of the expression as if it were an ordinary Brick type engine
Engine< Dim, T, FieldShift< Expression > >Engine<Dim, T, FieldShift<Expression> > is a specialization of Engine for FieldShift<Expression>
Engine< Dim, T, IndexFunction< Functor > >Engine<Dim, T, IndexFunction<Functor> > is a specialization of Engine for IndexFunction
Engine< Dim, T, IndirectionTag< A1, A2 > >The indirection engine combines two arrays to represent ind = a1(a2), where ind(i,j) = a1(a2(i,j))
Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >The multi-patch engine manages a Dim-dimensional logical "brick" of data of type T
Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >Multi-patch-view-engine manages a view of a multi-patch engine
Engine< Dim, T, Remote< Tag > >Engine<Dim, T, Remote<Tag> > is
Engine< Dim, T, ViewEngine< OriginalDim, ViewedEngineTag > >
EngineBlockSerialize
EngineConstructTagEngineConstructTag is used by Array to disambiguate engine-based constructor calls
EngineFunctor< Eng, Tag >EngineFunctor<Eng,Tag> defines the action corresponding to Tag on the engine of type Eng
EngineFunctor< Array< Dim, T, E >, Tag >A specialization of EngineFunctor for arrays
EngineFunctor< Engine< D, T, CompFwd< E, Comp > >, EnginePatch >Version of EnginePatch that gets the patch from the viewed engine
EngineFunctor< Engine< D, T, StencilEngine< S, E > >, DataObjectRequest< RequestType > >
EngineFunctor< Engine< Dim, T, CompFwd< Eng, Components > >, CompressedRead >
EngineFunctor< Engine< Dim, T, CompFwd< Eng, Components > >, CompressedReadWrite >
EngineFunctor< Engine< Dim, T, CompFwd< Eng, Components > >, Compressible >Component forward engine can be compressed if it contains compressed engines
EngineFunctor< Engine< Dim, T, CompFwd< Eng, Components > >, EFTag >General version of engineFunctor to passes the request to the contained engine
EngineFunctor< Engine< Dim, T, CompFwd< Eng, Components > >, UnCompressedViewEngine >
EngineFunctor< Engine< Dim, T, CompressibleBrick >, Compressed >
EngineFunctor< Engine< Dim, T, CompressibleBrick >, CompressedBrickIsWholeView >
EngineFunctor< Engine< Dim, T, CompressibleBrick >, CompressedRead >
EngineFunctor< Engine< Dim, T, CompressibleBrick >, CompressedReadWrite >
EngineFunctor< Engine< Dim, T, CompressibleBrick >, Compressible >CompressibleBricks are the simplest case since all the functions of Compressible just mirror the engine's functions
EngineFunctor< Engine< Dim, T, CompressibleBrick >, UnCompressedViewEngine >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, Compressed >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, CompressedBrickIsWholeView >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, CompressedRead >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, CompressedReadWrite >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, Compressible >
EngineFunctor< Engine< Dim, T, CompressibleBrickView >, UnCompressedViewEngine >
EngineFunctor< Engine< Dim, T, ConstantFunction >, Compressed >
EngineFunctor< Engine< Dim, T, ConstantFunction >, CompressedRead >
EngineFunctor< Engine< Dim, T, ConstantFunction >, Compressible >Constant function engine is definitely compressed
EngineFunctor< Engine< Dim, T, ExpressionTag< Expr > >, EnginePatch >EnginePatch is a special case because we want to package up the patched expression in an expression engine
EngineFunctor< Engine< Dim, T, ExpressionTag< Expr > >, Tag >EngineFunctors get applied to expressions using ForEach, with the combiner supplied by the Tag
EngineFunctor< Engine< Dim, T, FieldShift< Expression > >, DataObjectRequest< RequestType > >
EngineFunctor< Engine< Dim, T, IndirectionTag< A1, A2 > >, DataObjectRequest< RequestType > >
EngineFunctor< Engine< Dim, T, IndirectionTag< A1, A2 > >, DataObjectRequest< WriteRelease > >
EngineFunctor< Engine< Dim, T, IndirectionTag< A1, A2 > >, DataObjectRequest< WriteRequest > >
EngineFunctor< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, EngineNumPatches >
EngineFunctor< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, EnginePatch >
EngineFunctor< Engine< Dim, T, MultiPatch< LayoutTag, Remote< Tag > > >, EnginePatch >
EngineFunctor< Engine< Dim, T, MultiPatch< SparseTileTag, ptag > >, IsValid< Dim > >
EngineFunctor< Engine< Dim, T, Remote< Tag > >, GatherContexts >
EngineFunctor< Engine< Dim, T, UserFunctionEngine< S, E > >, EFTag >
EngineFunctor< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, DataObjectRequest< RequestType > >
EngineFunctor< Field< Mesh, T, EngineTag >, Tag >
EngineFunctorDefault< Eng, Tag >The most generic version of EngineFunctor falls through to EngineFunctorDefault
EngineFunctorDefault< Eng, DataObjectRequest< RequestType > >
EngineFunctorDefault< Eng, EngineNumPatches >
EngineFunctorDefault< Eng, EnginePatch >
EngineFunctorDefault< Engine, Compressed >
EngineFunctorDefault< Engine, Compressible >General engines are not compressible, so the general Compressible returns false for compressed()
EngineFunctorDefault< Engine, GatherContexts >
EngineFunctorDefault< Engine, IsValid< Dim > >
EngineFunctorScalar< T, Tag >Users must specialize this struct for all tags
EngineFunctorScalar< T, Compressed >Scalars are always compressed
EngineFunctorScalar< T, CompressedRead >PETE functors to perform compressed assignment
EngineFunctorScalar< T, Compressible >Compressible is used to query if an engine can be compressed, which is a compile time trait
EngineFunctorScalar< T, DataObjectRequest< RequestType > >LeafFunctors for DataObjectRequest
EngineFunctorScalar< T, EngineNumPatches >
EngineFunctorScalar< T, GatherContexts >
EngineFunctorScalar< T, IsValid< Dim > >
EngineFunctorTag< Tag >EngineFunctorTag is used to apply an EngineFunctor to an expression containing several engines
EngineNumPatchesEngineNumPatches is used to find out how many patches an engine has
EnginePatchEnginePatch is a tag used with engineFunctor to return the ith patch from a multi-patch engine in a generic way
EngineView< RemoteView >
EngineWriteNotifier
EquivSubsetDomain< T1, T2, T3, Dim >EquivSubsetDomain implements a basic template meta-program to find the equiv subset of each dimension separately of the multidimensional domains
EquivSubsetDomain< T1, T2, T3, 1 >
EquivSubsetDomainSingle< T1, T2, T3, Dim, strided >The default (unit-stride) version of EquivSubsetDomainSingle, which assumes that all arguments to 'equiv' are domains with unit stride
EquivSubsetDomainSingle< T1, T2, T3, Dim, true >The non-unit-stride version of EquivSubsetDomainSingle, which does extra work for the case where a, b, or c do not have unit stride
EquivSubsetReturnType< T1, T2, T3 >A simple struct used to figure out the return type when examining types T1,T2,T3
ErrorDomainNullDomain and ErrorDomain are special "domains"
ErrorKernelTag
ErrorType
EvalLeaf< Dim >EvalLeaf is used by Expression-Engine to evaluate itself at a point, specified by a Loc<Dim>
EvalLeaf1
EvalLeaf2
EvalLeaf3
EvalLeaf4
EvalLeaf5
EvalLeaf6
EvalLeaf7
EvalLeaf< 1 >
EvalLeaf< 2 >
EvalLeaf< 3 >
EvalLeaf< 4 >
EvalLeaf< 5 >
EvalLeaf< 6 >
EvalLeaf< 7 >
EvaluateLocLoop< Function, Dim >
EvaluatePatch< Function, Dim >
Evaluator< EvalTag >The point of this class is to input an expression with the 'evaluate' member function and evaluate it by breaking it up into appropriate sub-blocks, looping over the whole domain, and evaluating the expression at each point
Evaluator< MainEvaluatorTag >This evaluator is the one that gets called for a data-parallel expression
Evaluator< MultiPatchEvaluatorTag >The multiple patch version makes patches and sends them out to the single patch evaluator
Evaluator< RemoteMultiPatchEvaluatorTag >
Evaluator< RemoteSinglePatchEvaluatorTag >
Evaluator< SinglePatchEvaluatorTag >The single patch version just passes the tag on to generate an expression kernel
EvaluatorCombine< Eval1, Eval2 >EvaluatorCombine<LHSEval, RHSEval>
EvaluatorCombine< MultiPatchEvaluatorTag, MultiPatchEvaluatorTag >
EvaluatorCombine< MultiPatchEvaluatorTag, RemoteSinglePatchEvaluatorTag >
EvaluatorCombine< MultiPatchEvaluatorTag, SinglePatchEvaluatorTag >
EvaluatorCombine< RemoteSinglePatchEvaluatorTag, MultiPatchEvaluatorTag >
EvaluatorCombine< RemoteSinglePatchEvaluatorTag, RemoteSinglePatchEvaluatorTag >
EvaluatorCombine< RemoteSinglePatchEvaluatorTag, SinglePatchEvaluatorTag >
EvaluatorCombine< SinglePatchEvaluatorTag, MultiPatchEvaluatorTag >
EvaluatorCombine< SinglePatchEvaluatorTag, RemoteSinglePatchEvaluatorTag >
EvaluatorCombine< SinglePatchEvaluatorTag, SinglePatchEvaluatorTag >
EvaluatorCombineTag
EvaluatorEngineTraits< EngineTag >
EvaluatorEngineTraits< Brick >
EvaluatorEngineTraits< BrickView >
EvaluatorEngineTraits< BrickViewU >
EvaluatorEngineTraits< CompFwd< Eng, Components > >
EvaluatorEngineTraits< CompressibleBrick >
EvaluatorEngineTraits< CompressibleBrickView >
EvaluatorEngineTraits< ConstantFunction >
EvaluatorEngineTraits< Dynamic >
EvaluatorEngineTraits< DynamicView >
EvaluatorEngineTraits< ExpressionTag< Expr > >
EvaluatorEngineTraits< FieldShift< Expression > >Specializations for selecting the appropriate evaluator for the Shift engine
EvaluatorEngineTraits< IndexFunction< Functor > >
EvaluatorEngineTraits< IndexFunctionView< Dim2, Functor > >
EvaluatorEngineTraits< IndirectionTag< A1, A2 > >
EvaluatorEngineTraits< MultiPatch< LayoutTag, PatchTag > >
EvaluatorEngineTraits< MultiPatch< LayoutTag, Remote< Tag > > >
EvaluatorEngineTraits< MultiPatchView< LayoutTag, PatchTag, Dim2 > >
EvaluatorEngineTraits< MultiPatchView< LayoutTag, Remote< Tag >, Dim2 > >
EvaluatorEngineTraits< Remote< Tag > >
EvaluatorEngineTraits< ScalarEngineTag >
EvaluatorEngineTraits< StencilEngine< UserFunction, Expression > >Specializations for selecting the appropriate evaluator for the Stencil engine
EvaluatorEngineTraits< UserFunctionEngine< UserFunction, Expression > >Specializations for selecting the appropriate evaluator for the UserFunction engine
EvaluatorEngineTraits< ViewEngine< OriginalDim, ViewedEngineTag > >
EvaluatorTag< LHS, RHS >
EvaluatorTag1< Expr >
EvaluatorTypeTag
Expression< T >
ExpressionApply< Tag >The default version of ExpressionApply contains a reference to the tag class, which is typically empty
ExpressionIsArrayTraits class for expressions containing arrays
ExpressionIsField
ExpressionIsScalarExpressionIsScalar is the return type for scalar expression objects
ExpressionKernel< LHS, Op, RHS, EvalTag >An ExpressionKernel is a specific kind of iterate which evaluates a particular expression with a loop over a given domain
ExpressionTag< Expr >Tag class used to encode the type of an Expression for Engine
ExpressionTraits< T >ExpressionTraits<Expr>::Type_t is a traits class for expression objects
ExpressionTraits< Array< Dim, T, EngineTag > >
ExpressionTraits< BinaryNode< Op, Left, Right > >
ExpressionTraits< Field< Mesh, T, EngineTag > >
ExpressionTraits< Reference< T > >Determine the ExpressionTraits for all the expression objects:
ExpressionTraits< Scalar< T > >
ExpressionTraits< TrinaryNode< Op, Left, Middle, Right > >
ExpressionTraits< UnaryNode< Op, Child > >
FaceAreasTraits< Mesh >
FarLeftTag
Field< Mesh, T, EngineTag >Field
FieldEngine< Mesh, T, EngineTag >FieldEngineBase manages a hierarchy of engines, making it possible for FieldEngine specializations to implement geometry-specific behavior only
FieldEngine< Mesh, T, ExpressionTag< Expr > >
FieldEngineBaseData< Dim, T, EngineTag >FieldEngineBaseData holds an engine and the relations
FieldEnginePatch< Dim >Fields know about two domains, a physical and total domain
FieldOffset< Dim >Given a field f, a Loc loc, and a field offset (offset,num), a field value can be obtained
FieldOffsetList< Dim >A set of FieldOffset's can be stored in a FieldOffsetList
FieldOffsetReduction< T, Dim, Accumulate >
FieldShiftIntersector< Dim, Intersect >FieldShiftIntersector is a special intersector that gets used when we come across a stencil object in an expression
FieldShiftSimple< Expression >There are potentially many ways to construct field stencils
FieldStencilSimple< Functor, Expression >There are potentially many ways to construct field stencils
FileSetReader< Dim >FileSetReader<Dim> manages the reading of Arrays and Fields from "DiscField" format files (as designed for Pooma r1 by Bill Humphrey)
FileSetWriter< Dim >
FillAllLocStorage< i >Template metaprogram that fills all of a loc with the one-dimensional initializer a
FillAllLocStorage< 0 >
FillLocStorage< dstIndex, toGo >Template metaprogram for filling a loc from a different domain object
FillLocStorage< dstIndex, 0 >
FixPositionFunctorUR< Dim, TM >
FnAbs
FnAndAssign
FnArcCos
FnArcSin
FnArcTan
FnArcTan2
FnArg
FnCeil
FnConj
FnCos
FnDet
FnDot
FnDotDot
FnExp
FnFabs
FnFloor
FnFmod
FnHypCos
FnHypSin
FnHypTan
FnImag
FnLdexp
FnLog
FnLog10
FnMagnitude
FnMax
FnMaxAssign
FnMin
FnMinAssign
FnNorm
FnOrAssign
FnOuterProduct
FnOuterProductAsTinyMatrix
FnPolar
FnPow
FnPow2
FnPow3
FnPow4
FnReal
FnSin
FnSqrt
FnSymmetrize< OutputSymmetry >
FnTan
FnTrace
FnTranspose
FnWhere
fomax< T >Return the maximum value of the field locations
fomin< T >Return the minimum value of the field locations
ForEach< Expr, FTag, CTag >
ForEach< BinaryNode< Op, A, B >, FTag, CTag >
ForEach< BinaryNode< WhereMask, A, B >, FTag, OpCombine >
ForEach< Expression< T >, FTag, CTag >
ForEach< Reference< T >, FTag, CTag >
ForEach< TrinaryNode< Op, A, B, C >, FTag, CTag >
ForEach< UnaryNode< Op, A >, FTag, CTag >
ForEachRef< Expr, FTag, CTag >
ForEachRef< BinaryNode< Op, A, B >, FTag, CTag >
ForEachRef< Expression< T >, FTag, CTag >
ForEachRef< Reference< T >, FTag, CTag >
ForEachRef< TrinaryNode< Op, A, B, C >, FTag, CTag >
ForEachRef< UnaryNode< Op, A >, FTag, CTag >
FullFull storage (general tensor):
FunctorResult< Functor, ArgumentType >Where Pooma uses functor objects, STL functors can typically be used, where operator() is used to define the function
GatherContextsEngineFunctor for gathering up the contexts in an expression and returning the most common
SparseTileLayoutData< Dim >::GCBorderFillInfo
LayoutBaseData< Dim >::GCFillInfo
RectilinearMesh< Dim, T >::GeneralVolumesFunctorGeneral "volume" functor: works for edges, faces and cells
GlobalIDDataBaseGlobalIDDataBase stores global patch ID's for INodes
GradCellToVert< T2, UniformRectilinearMesh< Dim, TM > >
GradSameToSame< T2, UniformRectilinearMesh< Dim, TM >, OC >
GradVertToCell< T2, UniformRectilinearMesh< Dim, TM > >
Grid< Dim >Grid<N> is a domain representing a set of N numeric sequences, one for each dimension N
Grid< 1 >Grid<1> is a 1D specialization of Grid<N>; for the 1D case, there are only a restricted set of constructors available
GridLayout< Dim >GridLayout is a Layout class that breaks an N-dimensional Interval into sub-domains arranged in an N-dimensional grid, where the sub-domain sizes are specified by a Grid domain object
GridLayoutData< Dim >Holds the data for a GridLayout
GridLayoutView< Dim, Dim2 >GridLayoutView is a Layout class that provides a view of an existing GridLayout object
GridLayoutViewData< Dim, Dim2 >The data object held by a GridLayoutView object
GridPartition< Dim >GridPartition is a layout partitioner; it is created with the info needed to partition a global domain into subdomains using N 1-dim upper sub-domain specifications along each axis, or any of the specifiers used for the UniformGridPartition
GridTagGridTag class
GuardLayers< Dim >This class is a simple container for two arrays of Dim integers, specifying the numbers of guard layers at the upper and lower extent of each dimension
HDF5Object< T >Upon construction, object gets updated, upon destruction after write, object gets marked dirty
HDF5TypeTraits< T >Traits class specialized for types that qualify as primitive
ImplementationImplementation provides a framework for implementing a benchmark in a specific way
IncrementLeaf
IndexFunction< Functor >IndexFunction is just a tag class for the index-function-engine engine, which makes a function of indices look like an array
IndexFunctionView< Dim, Functor >IndexFunctionView is the view analog of IndexFunction
IndirectionList< T >IndirectionList is a domain representing a N dimension set of integer sequences
IndirectionListIterator< T >A random access iterator class that iterates through all of the elements of an IndirectionList<T>, returning T's when dereferenced
IndirectionTag< A1, A2 >
InfluenceRelationInfluenceRelation supports the relation package by allowing fields that have been modified---resulting in their dirty flag being set---to notify dependent fields and set their relations' dirty flags as well
InformA message is sent to an Inform object by treating it as an ostream, then ending the message by sending the 'inform' manipulator
InformIterator< T >
InitializeUninitializedVector< T, I >InitializeUninitializedVector is a simple functor with an N-D and 1-D version used for template meta-programs to initialize the first 'Dim' elems of the data in the given UninitializedVector
InitializeUninitializedVector< T, 0 >Zeroth-index specialization of InitializeUninitializedVector
InlineKernelTag
INode< Dim >INode is a class for communicating information regarding intersections of layouts
InsertOp
InterpolatorInterpolator is a general template for a class that performs interpolation of data between arbitrary points in space (e.g., particle positions) and field element positions
Interpolator< Dim, T, CIC >
Interpolator< Dim, T, NGP >
Interpolator< Dim, T, SUDS >
IntersectDomain< T1, T2, T3, Dim >IntersectDomain implements a basic template meta-program to intersect each dimension separately of the multidimensional domains
IntersectDomain< T1, T2, T3, 1 >
IntersectDomainSingle< T1, T2, T3, Dim, strided >IntersectDomainSingle<T1,T2,T3,int Dim,bool strided>::intersect(a,b,c) finds the intersection of two domains a and b of type T1 and T2, and puts the domain intersection in c[Dim-1]
IntersectDomainSingle< T1, T2, T3, Dim, true >The non-unit-stride version of IntersectDomainSingle, which does extra work for the case where a or b do not have unit stride
Intersector< Dim >
IntersectorData< Dim >
IntersectorTag< Inter >ExpressionApply<IntersectorTag<Intersector> >
IntersectReturnType< T1, T2 >Simple struct used to figure out the return type when intersecting types T1 and T2
Interval< Dim >Interval<N> is a domain representing a set of N numeric sequences, one for each dimension N
Interval< 1 >Interval<1> is a 1D specialization of Interval<N>; for the 1D case, there are only a restricted set of constructors available
IntervalIteratorA random access iterator class that iterates through all of the points of an Interval<1>, returning ints when dereferenced
Iota< Dim >
IotaFunctor
Pooma::Algorithms::IsConcrete< type >
IsValid< Dim >
Smarts::Iterate< SerialAsync >Iterate<SerialAsync> is used to implement the SerialAsync scheduling policy
Smarts::Iterate< Stub >
Smarts::IterateScheduler< SerialAsync >Implements a asynchronous scheduler for a data driven execution
Smarts::IterateScheduler< Stub >
Pooma::IteratorPairDomain< Iter >Like IndirectionList<T>, IteratorPairDomain<T_Iter> provides access to an arbitrary sequence of T values
KernelEvaluator< CompressibleKernelTag >
KernelEvaluator< CompressibleViewKernelTag >
KernelEvaluator< InlineKernelTag >The point of this class is to input an expression with the 'evaluate' member function and evaluate it by looping over the whole domain
KernelTag< LHS, RHS >
KernelTag1< Expr >
KillBC< T >Here is an example of adding a new particle boundary condition
LayoutBase< Dim, LBD >Base class for all layouts
LayoutBaseData< Dim >Data container for LayoutBase class
LayoutBaseView< Dim, Dim2, lvd >LayoutBaseView is a base class for all Layout classes that provides a view of an existing LayoutBase object
LayoutBaseViewData< Dim, Dim2, L >This is the actual data for the LayoutBaseView class, which is simply a wrapper that holds a reference counted instance of this data class
LeafFunctor< LeafType, LeafTag >
LeafFunctor< A, EvaluatorTypeTag >
LeafFunctor< Array< Dim, T, E >, EngineFunctorTag< Tag > >Generalized Engine Functors
LeafFunctor< Array< Dim, T, E >, EngineView< Tag > >EngineView functor acting on array
LeafFunctor< Array< Dim, T, E >, ExpressionApply< Tag > >ExpressionApply functor acting on Array
LeafFunctor< Array< Dim, T, EngineTag >, ConformTag< Dim > >Apply the ConformTag to the leaves of the tree
LeafFunctor< Array< Dim, T, EngineTag >, DomainFunctorTag >This specialization of LeafFunctor is used to get the domain type or the domain itself from an Array
LeafFunctor< Array< Dim, T, EngineTag >, EvalLeaf< Dim > >This version of LeafFunctor is used by Expression-Engines to used to evaluate an Array using indices
LeafFunctor< Array< Dim, T, EngineTag >, FarLeftTag >
LeafFunctor< Array< Dim, T, EngineTag >, NotifyPreReadTag >Do what needs to be done prior to reading
LeafFunctor< Array< Dim, T, EngineTag >, SubFieldViewFunctorTag >
LeafFunctor< Array< Dim, T, EngineTag >, ViewFunctorTag< Domain > >This specialization of LeafFunctor is used to apply a view (subsetting) operation to an Array
LeafFunctor< Array< Dim1, T, EngineTag >, ConformTag< Dim2 > >Now the case where the rank of the Array is not the same as the ConformTag
LeafFunctor< DynamicArray< T, E >, EngineFunctorTag< Tag > >Generalized Engine Functors
LeafFunctor< Engine< 1, T, Remote< Dynamic > >, EngineView< RemoteView > >
LeafFunctor< Engine< 1, T, Remote< DynamicView > >, EngineView< RemoteView > >
LeafFunctor< Engine< D, T, CompFwd< E, Comp > >, EngineView< Tag > >
LeafFunctor< Engine< D, T, CompFwd< E, Comp > >, ExpressionApply< Tag > >
LeafFunctor< Engine< D, T, StencilEngine< S, E > >, EngineView< Tag > >
LeafFunctor< Engine< D, T, StencilEngine< S, E > >, ExpressionApply< IntersectorTag< Intersect > > >
LeafFunctor< Engine< D, T, StencilEngine< S, E > >, ExpressionApply< Tag > >
LeafFunctor< Engine< D, T, UserFunctionEngine< Func, Expr > >, EngineView< Tag > >
LeafFunctor< Engine< D, T, UserFunctionEngine< Func, Expr > >, ExpressionApply< Tag > >
LeafFunctor< Engine< D, T, ViewEngine< D2, E > >, ExpressionApply< Tag > >
LeafFunctor< Engine< Dim, T, E >, EngineFunctorTag< Tag > >Engines could appear at expression leaves
LeafFunctor< Engine< Dim, T, E >, EngineView< Tag > >
LeafFunctor< Engine< Dim, T, E >, EvalLeaf< Dim > >If an engine appears at the leaf, then we hand the engine to the EvalLeaf object which determine whether or not to subtract off the first indices
LeafFunctor< Engine< Dim, T, E >, ExpressionApply< Tag > >
LeafFunctor< Engine< Dim, T, ExpressionTag< Expr > >, EngineView< Tag > >EngineView acting on an expression returns an expression engine containing the result of applying that functor to the leaves
LeafFunctor< Engine< Dim, T, ExpressionTag< Expr > >, ExpressionApply< Tag > >ExpressionApply acting on an expression gets applied to the leaves
LeafFunctor< Engine< Dim, T, FieldShift< Expression > >, EngineView< Tag > >The generic version of EngineView just accesses the contained engine and applies EngineView to it
LeafFunctor< Engine< Dim, T, FieldShift< Expression > >, ExpressionApply< IntersectorTag< Intersect > > >IntersectEngine specialization
LeafFunctor< Engine< Dim, T, FieldShift< Expression > >, ExpressionApply< Tag > >
LeafFunctor< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, ExpressionApply< IntersectorTag< Intersect > > >
LeafFunctor< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, ExpressionApply< SimpleIntersector< Dim > > >
LeafFunctor< Engine< Dim, T, MultiPatchView< LT, PatchTag, BD > >, ExpressionApply< IntersectorTag< Intersect > > >
LeafFunctor< Engine< Dim, T, MultiPatchView< LT, PatchTag, BD > >, ExpressionApply< SimpleIntersector< Dim > > >
LeafFunctor< Engine< Dim, T, Remote< Brick > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< BrickView > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< BrickViewU > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< CompressibleBrick > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< CompressibleBrickView > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< Tag > >, EngineView< RemoteView > >
LeafFunctor< Engine< Dim, T, Remote< Tag > >, ExpressionApply< RemoteSend > >
LeafFunctor< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, ExpressionApply< IntersectorTag< Intersect > > >
LeafFunctor< Field< GeometryTag, T, EngineTag >, FarLeftTag >
LeafFunctor< Field< Mesh, T, EngineTag >, ConformTag< Dim > >
LeafFunctor< Field< Mesh, T, EngineTag >, DataObjectRequest< RequestType > >
LeafFunctor< Field< Mesh, T, EngineTag >, DomainFunctorTag >
LeafFunctor< Field< Mesh, T, EngineTag >, EngineFunctorTag< Tag > >
LeafFunctor< Field< Mesh, T, EngineTag >, EngineView< Tag > >
LeafFunctor< Field< Mesh, T, EngineTag >, EvalLeaf< Dim > >
LeafFunctor< Field< Mesh, T, EngineTag >, ExpressionApply< Tag > >
LeafFunctor< Field< Mesh, T, EngineTag >, PerformUpdateTag >
LeafFunctor< Field< Mesh, T, EngineTag >, SubFieldViewFunctorTag >
LeafFunctor< Field< Mesh, T, EngineTag >, ViewFunctorTag< Domain > >
LeafFunctor< Field< Mesh, T, ExpressionTag< Expr > >, PerformUpdateTag >
LeafFunctor< FieldEngine< Mesh, T, EngineTag >, DataObjectRequest< RequestType > >
LeafFunctor< FieldEngine< Mesh, T, EngineTag >, ExpressionApply< Tag > >
LeafFunctor< FieldEngine< Mesh, T, ExpressionTag< Expr > >, ExpressionApply< Tag > >
LeafFunctor< ForwardIterator, DereferenceLeaf >
LeafFunctor< MultiArg1< A1 >, EngineView< Tag > >
LeafFunctor< MultiArg1< A1 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg2< A1, A2 >, EngineView< Tag > >
LeafFunctor< MultiArg2< A1, A2 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg3< A1, A2, A3 >, EngineView< Tag > >
LeafFunctor< MultiArg3< A1, A2, A3 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg4< A1, A2, A3, A4 >, EngineView< Tag > >
LeafFunctor< MultiArg4< A1, A2, A3, A4 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg5< A1, A2, A3, A4, A5 >, EngineView< Tag > >
LeafFunctor< MultiArg5< A1, A2, A3, A4, A5 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg6< A1, A2, A3, A4, A5, A6 >, EngineView< Tag > >
LeafFunctor< MultiArg6< A1, A2, A3, A4, A5, A6 >, ExpressionApply< Tag > >
LeafFunctor< MultiArg7< A1, A2, A3, A4, A5, A6, A7 >, EngineView< Tag > >
LeafFunctor< MultiArg7< A1, A2, A3, A4, A5, A6, A7 >, ExpressionApply< Tag > >
LeafFunctor< Node, EngineFunctorTag< Tag > >EngineFunctorTag applied to a general node is an error
LeafFunctor< Node, EnginePatch >
LeafFunctor< Node, EngineView< Tag > >LeafFunctor specializations for EngineView
LeafFunctor< Node, ExpressionApply< Tag > >LeafFunctor specializations for ExpressionApply
LeafFunctor< Node, PerformUpdateTag >
LeafFunctor< Scalar< T >, ConformTag< D > >Scalars conform with anything, so always return true
LeafFunctor< Scalar< T >, DecrementLeaf >
LeafFunctor< Scalar< T >, DereferenceLeaf >
LeafFunctor< Scalar< T >, DomainFunctorTag >
LeafFunctor< Scalar< T >, EngineFunctorTag< Tag > >Scalar<T> specialization for LeafFunctor uses EngineFunctorScalar to evaluate scalar leaf nodes
LeafFunctor< Scalar< T >, EnginePatch >
LeafFunctor< Scalar< T >, EngineView< Tag > >
LeafFunctor< Scalar< T >, EvalLeaf1 >
LeafFunctor< Scalar< T >, EvalLeaf2 >
LeafFunctor< Scalar< T >, EvalLeaf3 >
LeafFunctor< Scalar< T >, EvalLeaf4 >
LeafFunctor< Scalar< T >, EvalLeaf5 >
LeafFunctor< Scalar< T >, EvalLeaf6 >
LeafFunctor< Scalar< T >, EvalLeaf7 >
LeafFunctor< Scalar< T >, EvalLeaf< Dim > >We provide specializations for Scalars
LeafFunctor< Scalar< T >, EvaluatorTypeTag >
LeafFunctor< Scalar< T >, ExpressionApply< Tag > >
LeafFunctor< Scalar< T >, FarLeftTag >
LeafFunctor< Scalar< T >, IncrementLeaf >
LeafFunctor< Scalar< T >, NotifyPreReadTag >
LeafFunctor< Scalar< T >, SubFieldViewFunctorTag >
LeafFunctor< Scalar< T >, ViewFunctorTag< Domain > >
LeafFunctor< T, DecrementLeaf >
LeafFunctor< T, DomainFunctorTag >
LeafFunctor< T, IncrementLeaf >
LeftDomain< Dim >LeftDomain is a special domain class which is used as a 'wildcard'
Lexer
Loc< Dim >Loc<N> is a domain representing a single N-dimensional point
Loc< 1 >Loc<1> is a 1D specialization of Loc<N>; for the 1D case, there are only a restricted set of constructors available
LocalMapper< Dim >
LoopApplyEvaluator
LoopUtils< N >Template meta-program loop class with the following functions:
LoopUtils< 1 >
LuxAppPointer
LuxDataType< T >
LuxDataType< Tensor< Dim, T, E > >
LuxDataType< Vector< Dim, T, E > >
MainEvaluatorTag
MakeFieldReturn< BinaryNode< Op, Left, Right > >
MakeFieldReturn< TrinaryNode< Op, Left, Middle, Right > >
MakeFieldReturn< UnaryNode< Op, Leaf > >
MakeOwnCopyProperties< T >Classes that have shallow copy semantics and "makeOwnCopy" methods can specialize ElementProperties<T> by simply inheriting from this
MakeReturn< T >
MakeReturn< BinaryNode< Op, Left, Right > >Binary node version
MakeReturn< TrinaryNode< Op, Cl, Tr, Fl > >Trinary node version
MakeReturn< UnaryNode< Op, Leaf > >Unary node version
MaskAssign< T >
Pooma::MaterialViewTag
Pooma::MetaTokenIteratorMetaTokenIterator is a helper class designed to efficiently parse a line from the "DiscField" .meta file
MinusOne< T >The point of this class is to be a number of type T which is known at compile time to be minus one
ModelElement< T >
MPDynamicSpatial< Mesh, FL >
MPDynamicUniform
MPRemoteDynamicSpatial< Mesh, FL >
MPRemoteDynamicUniform
MultiArg1< A1 >
MultiArg2< A1, A2 >
MultiArg3< A1, A2, A3 >
MultiArg4< A1, A2, A3, A4 >
MultiArg5< A1, A2, A3, A4, A5 >
MultiArg6< A1, A2, A3, A4, A5, A6 >
MultiArg7< A1, A2, A3, A4, A5, A6, A7 >
MultiArgEvaluator< EvalTag >Implements: MultiArgEvaluator<MainEvaluatorTag>::evaluate (multiArg, function, domain, kernel)
  • multiArg: a MultiArgX object containing several fields
  • function: a function that is used to construct the function applied to a patch (see kernel)
  • domain: the domain over which the evaluation is performed
  • kernel: this object is just used to provide a type, which is the actual function applied to the patch
MultiArgEvaluator< MainEvaluatorTag >
MultiArgEvaluator< MultiPatchEvaluatorTag >
MultiArgEvaluator< RemoteMultiPatchEvaluatorTag >
MultiArgEvaluator< RemoteSinglePatchEvaluatorTag >
MultiArgEvaluator< SinglePatchEvaluatorTag >
MultiArgEvaluatorTag< MultiArg1< A1 > >
MultiArgEvaluatorTag< MultiArg2< A1, A2 > >
MultiArgEvaluatorTag< MultiArg3< A1, A2, A3 > >
MultiArgEvaluatorTag< MultiArg4< A1, A2, A3, A4 > >
MultiArgEvaluatorTag< MultiArg5< A1, A2, A3, A4, A5 > >
MultiArgEvaluatorTag< MultiArg6< A1, A2, A3, A4, A5, A6 > >
MultiArgEvaluatorTag< MultiArg7< A1, A2, A3, A4, A5, A6, A7 > >
MultiArgKernel< MultiArg, Function >
MultiArgView1< A1, Dom >
MultiArgView2< A1, A2, Dom >
MultiArgView3< A1, A2, A3, Dom >
MultiArgView4< A1, A2, A3, A4, Dom >
MultiArgView5< A1, A2, A3, A4, A5, Dom >
MultiArgView6< A1, A2, A3, A4, A5, A6, Dom >
MultiArgView7< A1, A2, A3, A4, A5, A6, A7, Dom >
MultiPatch< LayoutTag, PatchTag >These are tag classes used to select the "MultiPatch" and "MultiPatchView" specializations of the Engine class template
MultiPatchEvaluatorTag
MultiPatchLayoutTraits< LayoutTag, Dim >General version of the MultiPatchLayoutTraits class: All layouts that are to be used by the MultiPatch-engine need to define a layout tag and specialize this class to define their type and their view type
MultiPatchLayoutTraits< DynamicTag, 1 >Specialization of MultiPatchLayoutTraits for DynamicLayout
MultiPatchLayoutTraits< GridTag, Dim >Specialization of MultiPatchLayoutTraits for GridLayout
MultiPatchLayoutTraits< SparseTileTag, Dim >Specialization of MultiPatchLayoutTraits for SparseTileLayout
MultiPatchLayoutTraits< UniformTag, Dim >Specialization of MultiPatchLayoutTraits for UniformGridLayout
MultiPatchView< LayoutTag, PatchTag, Dim2 >
NearestNeighborClass< Dim, IntraCellOnly >This class implements the work of nearestNeighbors()
NewDomain1< T1 >
NewDomain1< DomainLayout< Dim > >NewDomain1 traits classes for DomainLayout
NewDomain1< DynamicLayout >
NewDomain1< DynamicLayoutView >
NewDomain1< GridLayout< Dim > >
NewDomain1< GridLayoutView< Dim, Dim2 > >
NewDomain1< SparseTileLayout< Dim > >
NewDomain1< SparseTileLayoutView< Dim, Dim2 > >
NewDomain1< UniformGridLayout< Dim > >
NewDomain1< UniformGridLayoutView< Dim, Dim2 > >
NewDomain2< T1, T2 >
NewDomain2< Grid< D >, IndirectionList< int > >
NewDomain2< IndirectionList< int >, Grid< D > >
NewDomain2< Loc< D1 >, Loc< D2 > >
NewDomain2Base< T1, T2, TCombine, TSCombine >
NewDomain3< T1, T2, T3 >
NewDomain4< T1, T2, T3, T4 >
NewDomain5< T1, T2, T3, T4, T5 >
NewDomain6< T1, T2, T3, T4, T5, T6 >
NewDomain7< T1, T2, T3, T4, T5, T6, T7 >
NewDomainNBase< ND, T >
NewEngine< Engine, SubDomain >Traits class for determining the type obtained by subsetting a particular Engine with a particular SubDomain
NewEngine< Engine< 1, T, Dynamic >, INode< 1 > >
NewEngine< Engine< 1, T, Dynamic >, Interval< 1 > >Several specializations of NewEngine for combinations of Engines and Domains that produce DynamicView-Engines
NewEngine< Engine< 1, T, Dynamic >, Node< Interval< 1 > > >
NewEngine< Engine< 1, T, Dynamic >, Range< 1 > >
NewEngine< Engine< 1, T, DynamicView >, INode< 1 > >
NewEngine< Engine< 1, T, DynamicView >, Interval< 1 > >
NewEngine< Engine< 1, T, DynamicView >, Node< Interval< 1 > > >
NewEngine< Engine< 1, T, DynamicView >, Range< 1 > >
NewEngine< Engine< Dim, T, Brick >, INode< Dim > >
NewEngine< Engine< Dim, T, Brick >, Interval< Dim > >NewEngine<Engine,SubDomain>
NewEngine< Engine< Dim, T, Brick >, Node< Interval< Dim > > >
NewEngine< Engine< Dim, T, Brick >, Range< Dim > >
NewEngine< Engine< Dim, T, Brick >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, Brick >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, BrickView >, INode< Dim > >
NewEngine< Engine< Dim, T, BrickView >, Interval< Dim > >
NewEngine< Engine< Dim, T, BrickView >, Node< Interval< Dim > > >
NewEngine< Engine< Dim, T, BrickView >, Range< Dim > >
NewEngine< Engine< Dim, T, BrickView >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, BrickView >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, BrickViewU >, INode< Dim > >
NewEngine< Engine< Dim, T, BrickViewU >, Interval< Dim > >
NewEngine< Engine< Dim, T, BrickViewU >, Node< Interval< Dim > > >
NewEngine< Engine< Dim, T, BrickViewU >, Range< Dim > >
NewEngine< Engine< Dim, T, BrickViewU >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, BrickViewU >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, CompFwd< Eng, Components > >, Domain >Specialization allowing a view to be taken of a forwarding engine
NewEngine< Engine< Dim, T, CompressibleBrick >, INode< Dim > >
NewEngine< Engine< Dim, T, CompressibleBrick >, Interval< Dim > >NewEngine<Engine,SubDomain>
NewEngine< Engine< Dim, T, CompressibleBrick >, Node< Interval< Dim > > >
NewEngine< Engine< Dim, T, CompressibleBrick >, Range< Dim > >
NewEngine< Engine< Dim, T, CompressibleBrick >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, CompressibleBrick >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, INode< Dim > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, Interval< Dim > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, Node< Interval< Dim > > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, Range< Dim > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, CompressibleBrickView >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ConstantFunction >, INode< Dim > >
NewEngine< Engine< Dim, T, ConstantFunction >, Interval< Dim > >NewEngine<Engine,SubDomain>
NewEngine< Engine< Dim, T, ConstantFunction >, Node< Domain > >
NewEngine< Engine< Dim, T, ConstantFunction >, Range< Dim > >
NewEngine< Engine< Dim, T, ConstantFunction >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ConstantFunction >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ExpressionTag< Expr > >, Domain >Here we supply the NewEngine traits class for Expression-Engine
NewEngine< Engine< Dim, T, ExpressionTag< Expr > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ExpressionTag< Expr > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, FieldShift< E > >, INode< Dim > >
NewEngine< Engine< Dim, T, FieldShift< E > >, Interval< Dim > >NewEngine<Engine,SubDomain>
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, INode< Dim > >
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, Interval< Dim > >NewEngine<Engine,SubDomain>
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, Node< Domain > >
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, Range< Dim > >
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, IndexFunction< Functor > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, IndirectionTag< A1, A2 > >, Domain >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, INode< Dim > >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, Interval< Dim > >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, Node< Domain > >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, Range< Dim > >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim > >, INode< Dim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim > >, Node< Domain > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, INode< Dim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, Interval< Dim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, Node< Domain > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, Range< Dim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, Remote< Tag > >, Domain >
NewEngine< Engine< Dim, T, StencilEngine< S, E > >, INode< Dim > >
NewEngine< Engine< Dim, T, StencilEngine< S, E > >, Interval< Dim > >Specializations of NewEngine for subsetting a StencilEngine with an arbitrary domain
NewEngine< Engine< Dim, T, StencilEngine< S, E > >, Range< Dim > >
NewEngine< Engine< Dim, T, StencilEngine< S, E > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, StencilEngine< S, E > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, UserFunctionEngine< S, E > >, Domain >Specializations of NewEngine for subsetting a UserFunctionEngine with an arbitrary domain
NewEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, INode< Dim > >
NewEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, Interval< Dim > >Specializations of NewEngine for subsetting a view-engines with an arbitrary domain
NewEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, Range< Dim > >
NewEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, SliceInterval< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, SliceRange< Dim, SliceDim > >
NewEngine< Engine< Dim, T, ViewEngine< Dim, ViewedTag > >, INode< Dim > >
NewEngineDomain< Engine, SubDomain >
NewEngineDomain< Engine< 1, T, Dynamic >, INode< 1 > >
NewEngineDomain< Engine< 1, T, Dynamic >, Node< Interval< 1 > > >Several specializations of NewEngineDomain for combinations of Dynamic/DynamicView-Engines and Node/INode
NewEngineDomain< Engine< 1, T, DynamicView >, INode< 1 > >
NewEngineDomain< Engine< 1, T, DynamicView >, Node< Interval< 1 > > >
NewEngineDomain< Engine< Dim, T, Brick >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, Brick >, Node< Interval< Dim > > >NewEngineDomain<Engine,SubDomain>
NewEngineDomain< Engine< Dim, T, BrickView >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, BrickView >, Node< Interval< Dim > > >
NewEngineDomain< Engine< Dim, T, BrickViewU >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, BrickViewU >, Node< Interval< Dim > > >
NewEngineDomain< Engine< Dim, T, FieldShift< E > >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, FieldShift< E > >, Interval< Dim > >
NewEngineDomain< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, Node< Domain > >
NewEngineDomain< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, Node< Domain > >
NewEngineDomain< Engine< Dim, T, Remote< Tag > >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, INode< Dim > >
NewEngineDomain< Engine< Dim, T, ViewEngine< Dim, ViewedTag > >, INode< Dim > >
NewEngineEngine< Engine, SubDomain >NewEngineEngine<Engine,SubDomain> NewEngineDomain<Engine,SubDomain>
NewEngineEngine< Engine< Dim, T, FieldShift< E > >, INode< Dim > >
NewEngineEngine< Engine< Dim, T, FieldShift< E > >, Interval< Dim > >
NewEngineEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, INode< Dim > >
NewEngineEngine< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > >, Node< Domain > >
NewEngineEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, INode< Dim > >
NewEngineEngine< Engine< Dim, T, MultiPatchView< LayoutTag, PatchTag, Dim2 > >, Node< Domain > >
NewEngineEngine< Engine< Dim, T, ViewEngine< D2, ViewedTag > >, INode< Dim > >
NewEngineEngine< Engine< Dim, T, ViewEngine< Dim, ViewedTag > >, INode< Dim > >
NewMeshTag< Dim, Mesh, Domain >
NewMeshTag< Dim, Mesh, INode< Dim > >
NewMeshTag< Dim, Mesh, Interval< Dim > >
NGP
NGPCacheData< Dim, T >
NGPGather< FC, Dim >
NGPGatherFillCache< FC, Dim >
NGPGatherUseCache< FC, Dim >
NGPScatter< FC, Dim >
NGPScatterFillCache< FC, Dim >
NGPScatterUseCache< FC, Dim >
NGPScatterValue< FC, Dim, ValueT >
NGPScatterValueFillCache< FC, Dim, ValueT >
NGPScatterValueUseCache< FC, Dim, ValueT >
Node< Dom, OrigDom >Node is a quite simple object which stores information about where a subdomain should be located
Pooma::NoInitTag class used to signal constructors that certain initializations are to be skipped
RefBlockController< T >::NoInitTag
RefCountedBlockPtr< T, BoundsChecked, Controller >::NoInitTag
NoMesh< Dim >NoMesh is an extremely lightweight class that indicates a Field cannot answer mesh-type questions
NoMeshData< Dim >Holds the data for a NoMesh mesh
ParticleEvaluator::NoOp
NormalsTraits< Mesh >
NotifyEngineWrite< Engine >NotifyEngineWrite is a general wrapper class that is used to tell an engine that we're going to write to it
NotifyEngineWrite< Engine< Dim, T, CompFwd< Eng, Components > > >Tell contained engine that it's dirty
NotifyEngineWrite< Engine< Dim, T, MultiPatch< LayoutTag, PatchTag > > >
NotifyEngineWrite< Engine< Dim, T, MultiPatchView< LT, PatchTag, BD > > >
NotifyPreReadTag
NullCombine
NullDomainNullDomain and ErrorDomain are special "domains"
Observable< T >The Observable class, along with the Observer class, are used to implement the observer pattern
Observer< T >The Observer class, along with the Observable class, are used to implement the observer pattern
ObserverEventThe Observer class, along with the Observable class, are used to implement the observer pattern
Pooma::OffsetCalc< pos, max >Template metaprogram for offset calculations
Pooma::OffsetCalc< 1, 0 >
Pooma::OffsetCalc< end, end >
One< T >The point of this class is to be a number of type T which is known at compile time to be one
OpAdd
OpAddAssign
OpAnd
OpAssign
OpBitwiseAnd
OpBitwiseAndAssign
OpBitwiseNot
OpBitwiseOr
OpBitwiseOrAssign
OpBitwiseXor
OpBitwiseXorAssign
OpCast< T1 >
OpCombine
OpDivide
OpDivideAssign
OpEQ
OpEQ2
OperatorDescriptor
OpGE
OpGE2
OpGT
OpGT2
OpIdentity
OpLE
OpLE2
OpLeftShift
OpLeftShiftAssign
OpLT
OpLT2
OpMask< Op >
OpMod
OpModAssign
OpMultiply
OpMultiplyAssign
OpNE
OpNE2
OpNot
OpOr
OpRightShift
OpRightShiftAssign
OpSubtract
OpSubtractAssign
Pooma::OptionsOptions stores the list of run-time configurable options for POOMA
OpUnaryMinus
OpUnaryPlus
OrCombine
PackLocalPatches< InputField >
Parser< Descriptor >
PartialReduction< T >Class to hold static array for partial reduction results and routine for final reduction
ParticleBC< Subject, Object, BCType >
ParticleBC< Subject, Object, AbsorbBC< T > >
ParticleBC< Subject, Object, KillBC< T > >
ParticleBC< Subject, Object, PeriodicBC< T > >
ParticleBC< Subject, Object, ReflectBC< T > >
ParticleBC< Subject, Object, ReverseBC< T > >
ParticleBCItem
ParticleBCList
ParticleBCType< BCType >
ParticleCompBC< Dim, BCType >
ParticleCompBC< 1, BCType >
ParticleCompBC< 2, BCType >
ParticleEvaluator
ParticleKernel< Array, Function >
ParticleKernel2< Array1, Array2, Function >
ParticleKernel2Block< Array1, Array2, Function >
ParticleKernel3< Array1, Array2, Array3, Function >
ParticleKernel3Block< Array1, Array2, Array3, Function >
ParticleKernelBlock< Array, Function >
Particles< ParticleTraits >The Particles class is the base class to be used for development of user-defined particles classes that describe application-specific particle populations
Patch< Container >PatchView is the traits class used to describe the result of .patch(i) for a container class
Patch< Array< Dim, T, EngineTag > >Patch specialization for Array
Patch< DynamicArray< T, EngineTag > >
Patch< Field< Mesh, T, EngineTag > >
Patch< Field< Mesh, T, MultiPatch< LTag, EngineTag > > >
PatchCode< Function >PatchCode is a Stencil like operation that allows for more than one field to be operated on
PatchEvaluator< EvalTag >
PatchEvaluator< MainEvaluatorTag >
PatchEvaluator< MultiPatchEvaluatorTag >
PatchEvaluator< SinglePatchEvaluatorTag >
PatchFunction< Function, Patch >
PatchFunction< Function, PatchParticle1< Write1 > >
PatchFunction< Function, PatchParticle2< Write1, Write2 > >
PatchFunction< Function, PatchParticle3< Write1, Write2, Write3 > >
PatchFunction< Function, PatchReadTag1 >
PatchFunction< Function, PatchTag1 >
PatchFunction< Function, PatchTag2 >
PatchFunction< Function, PatchTag3 >
PatchKernel< A1, Function >
PatchKernel2< A1, A2, Function >
PatchKernel3< A1, A2, A3, Function >
PatchParticle1< Write1 >
PatchParticle2< Write1, Write2 >
PatchParticle3< Write1, Write2, Write3 >
PatchReadTag1
Pooma::PatchSizeSyncerThis class encapsulates the communication that must occur when synchronizing the patch domains for a DynamicLayout
PatchSwapFunctor< P >
PatchSwapInfo
PatchSwapLayout< L >
PatchTag1
PatchTag2
PatchTag3
PatchView< Container >
PawsAppPointer
PerformPrintArray< S, A, Dim, DomainType >PerformPrintArray struct: a simple wrapper around the templated 'print' method of PrintArray
PerformPrintArray< S, A, 1, DomainType >
PerformPrintField< Dim >PerformPrintField struct: a simple wrapper around the templated 'print' method of PrintField
PerformPrintField< 1 >
PerformUpdateTagThese leaf functor specializations are used to notify a field or expression that it is going to be read and, therefore, needs to update itself
PeriodicBC< T >Here is an example of adding a new particle boundary condition
PeriodicFaceBC< Dim >PeriodicFaceBC is an Relation functor class
PeteCTAssert< B >
PeteCTAssert< true >
Polar
PoolA Pool maintains a set of page-sized chunks of memory, and hands out small blocks very quickly
Pooled< T >This mixin class provides two functions: new and delete
PoomaCTAssert< B >
PoomaCTAssert< true >
Pooma::PoomaDA< Dim >Struct to wrap extra global information about a DA
Pooma::PoomaDACopy< 1 >
Pooma::PoomaDACopy< 2 >
Pooma::PoomaDACopy< 3 >
Pooma::PoomaDAGetDomain< 1 >
Pooma::PoomaDAGetDomain< 2 >
Pooma::PoomaDAGetDomain< 3 >
PositionFunctorUR< Dim, TM >Computes position locations for Uniform Rectilinear meshes
UniformRectilinearMesh< Dim, T >::PositionsFunctorSupport for the positions() function
RectilinearMesh< Dim, T >::PositionsFunctorSupport for the positions() function
PositionsTraits< Mesh >
PosReflectFaceBC< Dim >PosReflectFaceBC is an Relation functor class
PrintArrayPrintArray is a utility program for Array objects, used to print (nicely) the contents of an array to a provided stream
PrintFieldPrintField is a utility program for ConstField and Field object, used to print (nicely) the contents of an field to a provided stream
Promote< T1, T2 >
Promote< bool, bool >
Promote< bool, char >
Promote< bool, double >
Promote< bool, float >
Promote< bool, int >
Promote< bool, long >
Promote< bool, short >
Promote< char, bool >
Promote< char, char >
Promote< char, double >
Promote< char, float >
Promote< char, int >
Promote< char, long >
Promote< char, short >
Promote< complex< T >, complex< T > >
Promote< complex< T >, T >
Promote< double, bool >
Promote< double, char >
Promote< double, double >
Promote< double, float >
Promote< double, int >
Promote< double, long >
Promote< double, short >
Promote< float, bool >
Promote< float, char >
Promote< float, double >
Promote< float, float >
Promote< float, int >
Promote< float, long >
Promote< float, short >
Promote< int, bool >
Promote< int, char >
Promote< int, double >
Promote< int, float >
Promote< int, int >
Promote< int, long >
Promote< int, short >
Promote< long, bool >
Promote< long, char >
Promote< long, double >
Promote< long, float >
Promote< long, int >
Promote< long, long >
Promote< long, short >
Promote< short, bool >
Promote< short, char >
Promote< short, double >
Promote< short, float >
Promote< short, int >
Promote< short, long >
Promote< short, short >
Promote< T, complex< T > >
Range< Dim >Range<N> is a domain representing a set of N numeric sequences, one for each dimension N
Range< 1 >Range<1> is a 1D specialization of Range<N>; for the 1D case, there are only a restricted set of constructors available
RangeIteratorA random access iterator class that iterates through all of the points of an Range<1>, returning ints when dereferenced
RangeMaker< 1, 1 >
RangeMaker< 1, 2 >
RangeMaker< 1, 3 >
RangeMaker< 2, 1 >
RangeMaker< 2, 2 >
RangeMaker< 2, 4 >
RangeMaker< 2, 6 >
RangeMaker< 3, 1 >
RangeMaker< 3, 3 >
RangeMaker< 3, 6 >
RangeMaker< 3, 9 >
RangeMaker< 4, 1 >
RangeMaker< 4, 12 >
RangeMaker< 4, 4 >
RangeMaker< 4, 6 >
ReadRelease
ReadRequest
Receive< IncomingView >
RectilinearMesh< Dim, T >RectilinearMesh is a rectilinear mesh sometimes called a "cartesian product" or "tensor product" mesh
RectilinearMeshData< Dim, T >Holds the data for a rectilinear mesh
ReduceOverContexts< T, ReductionOp >This class is used to implement the final reduction over contexts used in Reduction<RemoteMultiPatchTag>::evaluate()
Reduction< EvalTag >The point of this class is to input an expression with the 'evaluate' member function and reduce it by breaking it up into appropriate sub-blocks, looping over the whole domain, and evaluating the expression at each point
Reduction< MainEvaluatorTag >This reduction is the one that gets called for a data-parallel expression
Reduction< MultiPatchEvaluatorTag >Multiple-patch Reduction:
Reduction< RemoteMultiPatchEvaluatorTag >
Reduction< RemoteSinglePatchEvaluatorTag >
Reduction< SinglePatchEvaluatorTag >Single-patch Reduction:
ReductionEvaluator< CompressibleKernelTag >
ReductionEvaluator< InlineKernelTag >The point of this class is to input an expression with the 'evaluate' member function and reduce it by looping over the whole domain
ReductionKernel< T, Op, Expr, KernelTag >A ReductionKernel is a specific kind of iterate which reduces a particular expression with over a given domain
ReductionTraits< Op, T >Traits class defining identity element for type T under operation Op
ReductionTraits< FnAndAssign, T >
ReductionTraits< FnMaxAssign, T >
ReductionTraits< FnMinAssign, T >
ReductionTraits< FnOrAssign, T >
ReductionTraits< OpAddAssign, T >
ReductionTraits< OpBitwiseAndAssign, T >
ReductionTraits< OpBitwiseOrAssign, T >
ReductionTraits< OpMask< Op >, T >
ReductionTraits< OpMultiplyAssign, T >
ReductionValue< T >This class associates a value with a flag that indicates whether or not it is valid
RefBlockController< T >This class manages the actual data allocation, reference counting, and optional bounds checking for the RefCountedBlockPtr class
RefCountedRefCounted is a mix-in class that supports reference counting of an object
RefCountedBlockPtr< T, BoundsChecked, Controller >RefCountedBlockPtr<T> is a smart-pointer class that provides reference counting for arrays of objects of type T
RefCountedPtr< T >RefCountedPtr<T> is a smart-pointer class that provides reference counting for objects of type T
Reference< T >
ReflectBC< T >Here is an example of adding a new particle boundary condition
Region< Dim, T >Region<N,T> is a domain representing a set of N continuous 1D regions, one for each dimension N
Region< 1, T >Region<1> is a 1D specialization of Region<N>; for the 1D case, there are only a restricted set of constructors available
Relation0< Target, RelationFunctor >Relation0 is a template used to construct relations, such as boundary conditions, that do not depend on additional fields
Relation1< Target, R1, RelationFunctor >Relation1 is a template used to construct relations that depend on one additional field (e.g., a = b)
Relation2< Target, R1, R2, RelationFunctor >Relation2 is a template used to construct relations that depend on two additional fields (e.g., a = b + c)
Relation3< Target, R1, R2, R3, RelationFunctor >Relation3 is a template used to construct relations that depend on three additional fields (e.g., a = b + c + d)
Relation4< Target, R1, R2, R3, R4, RelationFunctor >Relation4 is a template used to construct relations that depend on four additional fields (e.g., a = b + c + d + e)
Relation5< Target, R1, R2, R3, R4, R5, RelationFunctor >Relation5 is a template used to construct relations that depend on five additional fields (e.g., a = b + c + d + e + f)
Relation6< Target, R1, R2, R3, R4, R5, R6, RelationFunctor >Relation6 is a template used to construct relations that depend on six additional fields (e.g., a = b + c + d + e + f + g)
RelationBase< Target, Functor >RelationBase is an abstract base class for all automatic relations
RelationFunctionPtr0< L >Relation functors supporting the use of function pointers
RelationFunctionPtr1< L, R1 >
RelationFunctionPtr2< L, R1, R2 >
RelationFunctionPtr3< L, R1, R2, R3 >
RelationFunctionPtr4< L, R1, R2, R3, R4 >
RelationFunctionPtr5< L, R1, R2, R3, R4, R5 >
RelationFunctionPtr6< L, R1, R2, R3, R4, R5, R6 >
RelationFunctorTraits< RelationFunctor >RelationFunctorTraits is used to specify characteristics of a Relation functor
RelationFunctorTraits< ConstantFaceBC< Dim, T > >
RelationFunctorTraits< PeriodicFaceBC< Dim > >
RelationFunctorTraits< PosReflectFaceBC< Dim > >
RelationListRelationList is a container that dispatches events to the list of boundary conditions it contains
RelationListDataRelationListData is a ref-counted object that holds the data for an relation list
RelationListItemRelationListItem is an abstract base class for all relations:
RelationMemberPtr0< C, L >Relation functors supporting the use of member function pointers
RelationMemberPtr1< C, L, R1 >
RelationMemberPtr2< C, L, R1, R2 >
RelationMemberPtr3< C, L, R1, R2, R3 >
RelationMemberPtr4< C, L, R1, R2, R3, R4 >
RelationMemberPtr5< C, L, R1, R2, R3, R4, R5 >
RelationMemberPtr6< C, L, R1, R2, R3, R4, R5, R6 >
RelationRetargetBase< Target >RelationRetargetBase is an abstract base class for all relations:
Remote< Tag >Tag class used to select the "RemoteBrick" and "RemoteBrickView" specializations of the Engine class template
RemoteMultiPatchEvaluatorTag
RemoteProxy< T >This class is the return type of the remote brick engine operator()
RemoteSend
RemoteSinglePatchEvaluatorTag
RemoteViewThese two functor tags are used with engineFunctor() to generate brick-views from expressions or engines containing remote-brick-views
ReplicatedTagTag class specifying domain replication on all nodes, implying a use of LocalMapper for mapping patches to the only context
Resize< T >
Resize< Array< 1, T, MultiPatch< GridTag, Brick > > >
Resize< Array< 1, T, SharedBrick > >
Resize< Array< Dim, T, E > >
ReverseBC< T >Here is an example of adding a new particle boundary condition
Rho
RhoZ
RightDomain< Dim >RightDomain is a special domain class which is used as a 'wildcard'
RNGAdvance
RNGAdvanceProxy< RNG >
RNGSeed
RNGSeedProxy< RNG >
RNGSimple
RNGValue
RoundedStaticPool< SP >All this does is define alloc and free as static functions, and the static pool itself
Smarts::RunnableRunnable is the base class for system classes "Thread" and "Iterate"
SameType< T1, T2 >SameType: SameType can be used to check types at compile time
SameType< T1, T1 >
Scalar< T >
ScalarCode< Function >ScalarCode is a Stencil like operation that allows for more than one field to be operated on
ScalarCodeInfo
ScalarEngineTag
SendReceiveThe non-cheetah versions of send and receive are empty and should never actually be used, since a remote view should only happen when the data lives on another context
Smarts::SerialAsyncTag class for specializing IterateScheduler, Iterate and DataObject
Cheetah::Serialize< Tag, T >
Cheetah::Serialize< ::Cheetah::ARRAY, T >
Cheetah::Serialize< ::Cheetah::CHEETAH, T >
SetDomainFunctor< DT, ST, T, UT, wildcard >SetDomainFunctor is a simple wrapper around the setDomain method in the DomainTraits class
SetDomainFunctor< DT, ST, T, UT, true >
Shared< T >Simple template class encapsulating a single data item and inheriting from RefCounted
ShiftUpShiftUp: A tag class used to indicate that delete operations should proceed by 'shifting up', that is, moving the entire list up as a whole
SimpleIntersector< Dim >This intersector handles matching layouts only
SimpleIntersectorData< Dim >
SingleObservable< T >SingleObservable is an optimized observable that can only be observed by one observer
SingleObserver< T >
SinglePatchEvaluatorTag
SizeTypePromotion< T >
SizeTypePromotion< float >
SizeTypePromotion< int >
SliceDomain< DT >SliceDomain

provides the bulk of the public interface for all sliced domain objects

SliceInterval< Dim, SliceDim >SliceInterval<N,M> is a special form of domain object which stores a total domain and a slice domain, both as Interval<N> or <M> objects
SliceRange< Dim, SliceDim >SliceRange<N,M> is a special form of domain object which stores a total domain and a slice domain, both as Range<N> or <M> objects
SparseTileLayout< Dim >
SparseTileLayoutData< Dim >
SparseTileLayoutView< Dim, Dim2 >
SparseTileLayoutViewData< Dim, Dim2 >The data object held by a SparseTileLayoutView object
SparseTileTagSparseTileTag class
SpatialLayout< M, FL >SpatialLayout is one of the particle layout classes that determine where particles should be located
SpatialPartition< ReferenceLayout >SpatialPartition is a layout partitioner; it is created with the info needed to partition a global domain into subdomains based on information in a second "reference" layout
Spherical
SplitDomain< T, Dim >SplitDomain implements a basic template meta-program to split each dimension separately of the multidimensional domain
SplitDomain< T, 1 >
SplitDomainSingle< T, Dim, strided >SplitDomainSingle<T,Dim,bool strided>::split(a,b,c) splits just the Dim dimension of the first argument into the second and third argument
SplitDomainSingle< int, Dim, strided >Special version of SplitDomainSingle for int's, which must be handled uniquely
SplitDomainSingle< T, Dim, true >The non-unit-stride version of SplitDomainSingle
StaticPool< T >This is a wrapper class on RoundedStaticPool, which just rounds up its input block size and inherits from RoundedStaticPool
Pooma::StatisticsStatistics keeps statistics about a given POOMA job, and can report on a summary of these statistics when asked
Pooma::StatisticsData
Stencil< Function >Stencil
StencilEngine< Function, Expression >This is just a tag class for the stencil engine
StencilIntersector< Dim, Intersect >
Smarts::Stub
SubDomainTraits< D1, D2 >Helper traits class for MultiPatchView - should never need SliceRange if Dim == Dim2
SubDomainTraits< D1, D1 >
SubFieldView< Field< Mesh, T, EngineTag > >SubFieldView is used to implement the syntax f[i], which selects the ith SubField for field f
SubFieldView< Field< Mesh, T, ExpressionTag< Expr > > >
SUDS
SUDSCacheData< Dim, T >
SUDSGather< FC, Dim, T >
SUDSGatherFillCache< FC, Dim, T >
SUDSGatherUseCache< FC, Dim, T >
SUDSScatter< FC, Dim, T >
SUDSScatterFillCache< FC, Dim, T >
SUDSScatterUseCache< FC, Dim, T >
SUDSScatterValue< FC, Dim, T, ValueT >
SUDSScatterValueFillCache< FC, Dim, T, ValueT >
SUDSScatterValueUseCache< FC, Dim, T, ValueT >
SumCombine
SymmetricLike this, for the 3D case:
Symmetrize< OutputEngineTag, D, T, EngineTag >
Symmetrize< Antisymmetric, D, T, Diagonal >
Symmetrize< Antisymmetric, D, T, EngineTag >
Symmetrize< Antisymmetric, D, T, Symmetric >
Symmetrize< Diagonal, D, T, Antisymmetric >
Symmetrize< Diagonal, D, T, EngineTag >
Symmetrize< Diagonal, D, T, Symmetric >
Symmetrize< Full, D, T, EngineTag >
Symmetrize< Symmetric, D, T, Antisymmetric >
Symmetrize< Symmetric, D, T, Diagonal >
Symmetrize< Symmetric, D, T, EngineTag >
SyncEventSyncEvent: A class derived from ObserverEvent that stores information about doing a sync
Smarts::SystemContext
TagGeneratorThere exist situations where pooma needs to generate identifying tags for data being transferred from one context to another
TemporaryNewDomain1< Domain, Sub >
TemporaryNewDomain1< Domain, AllDomain< N > >
TemporaryNewDomain1< Domain, INode< N > >
TemporaryNewDomain1< Domain, Node< OwnedDomain, AllocatedDomain > >
Tensor< D, T, EngineTag >Tensor is an interface class that takes three template parameters:
  • int D: The number of components in each rank (row or col) of the Tensor
TensorAssign< T1, T2, Op, B1, L1, B2, L2 >
TensorAssign< T1, T2, Op, B1, 1, B2, 1 >
TensorAssign< T1, T2, Op, B1, 1, B2, L2 >
TensorAssign< T1, T2, Op, B1, 2, B2, 2 >
TensorAssign< T1, T2, Op, B1, 3, B2, 3 >
TensorAssign< T1, T2, Op, B1, L1, B2, 1 >
TensorAssign< TensorEngine< 1, T, Antisymmetric >, T2, Op, 0, 1, 0, 1 >Special antisymmetric assignment class: Has specializations for different dimensionalities (for 1, 2, and 3, so far)
TensorAssign< TensorEngine< 2, T, Antisymmetric >, T2, Op, 0, 2, 0, 2 >
TensorAssign< TensorEngine< 2, T, Diagonal >, T2, Op, 0, 2, 0, 2 >Special diagonal assignment class: Has specializations for different dimensionalities (for 2, and 3, so far)
TensorAssign< TensorEngine< 2, T, Symmetric >, T2, Op, 0, 2, 0, 2 >Special symmetric assignment class: Has specializations for different dimensionalities (for 2, and 3, so far)
TensorAssign< TensorEngine< 3, T, Antisymmetric >, T2, Op, 0, 3, 0, 3 >
TensorAssign< TensorEngine< 3, T, Diagonal >, T2, Op, 0, 3, 0, 3 >
TensorAssign< TensorEngine< 3, T, Symmetric >, T2, Op, 0, 3, 0, 3 >
TensorDotTensor< T1, T2, I, J, K, L >
TensorDotTensor< T1, T2, I, J, K, 1 >
TensorDotVector< T1, V2, I, B, L >
TensorDotVector< T1, V2, I, B, 1 >
TensorElem< V, I, J >The general templates for the class TensorElem
TensorElem< Tensor< D, T, E >, I, J >
TensorElem< TensorEngine< D, T, Antisymmetric >, I, J >
TensorElem< TensorEngine< D, T, Diagonal >, I, J >
TensorElem< TensorEngine< D, T, E >, I, J >
TensorElem< TensorEngine< D, T, Full >, I, J >
TensorElem< TensorEngine< D, T, Symmetric >, I, J >
TensorEngine< D, T, Antisymmetric >TensorEngine definitions for an Antisymmetric Tensor
TensorEngine< D, T, BinaryTensorOp< V1, V2, Op > >Specialization of TensorEngine for BinaryTensorOp
TensorEngine< D, T, Diagonal >TensorEngine definitions for a Diagonal Tensor
TensorEngine< D, T, Full >TensorEngine definitions for a Full Tensor
TensorEngine< D, T, Symmetric >TensorEngine definitions for a Symmetric Tensor
TensorEngine< D, T, UnaryTensorOp< V1, Op > >
TensorEngineElem< D, T, BinaryTensorOp< T1, T2, FnDot >, I, J, 1 >
TensorEngineElem< D, T, BinaryTensorOp< V1, V2, Op >, I, J, 1 >Specialization of TensorElem for BinaryTensorOp
TensorEngineElem< D, T, E, I, J, 0 >
TensorEngineElem< D, T, E, I, J, 1 >
TensorEngineElem< D, T, UnaryTensorOp< V1, Op >, I, J, 1 >
TensorStorageSize< D, EngineTag >
TensorStorageSize< D, Antisymmetric >
TensorStorageSize< D, Diagonal >
TensorStorageSize< D, Full >
TensorStorageSize< D, Symmetric >
Pooma::TesterTester is used to help make it easier to write simple test programs
TilePartition< Dim >TilePartition is a layout partitioner; it is created with the info needed to partition a global domain into a (possibly sparse) list of Dim dimensional non-overlapping patches
TinyMatrix< D1, D2, T, EngineTag >TinyMatrix is an interface class that takes three template parameters:
  • int D1, int D2: The number of components in each rank of the TinyMatrix
TinyMatrixAssign< T1, T2, Op, B1, L1, B2, L2 >
TinyMatrixAssign< T1, T2, Op, B1, 1, B2, 1 >
TinyMatrixAssign< T1, T2, Op, B1, 1, B2, L2 >
TinyMatrixAssign< T1, T2, Op, B1, 2, B2, 2 >
TinyMatrixAssign< T1, T2, Op, B1, 3, B2, 3 >
TinyMatrixAssign< T1, T2, Op, B1, L1, B2, 1 >
TinyMatrixDotTinyMatrix< T1, T2, I, J, K, L >
TinyMatrixDotTinyMatrix< T1, T2, I, J, K, 1 >
TinyMatrixDotVector< T1, V2, I, B, L >
TinyMatrixDotVector< T1, V2, I, B, 1 >
TinyMatrixElem< V, I, J >
TinyMatrixElem< TinyMatrix< D1, D2, T, E >, I, J >
TinyMatrixElem< TinyMatrixEngine< D1, D2, T, Full >, I, J >
TinyMatrixEngine< D1, D2, T, BinaryTinyMatrixOp< V1, V2, FnDot > >
TinyMatrixEngine< D1, D2, T, BinaryTinyMatrixOp< V1, V2, Op > >Specialization of TinyMatrixEngine for BinaryTinyMatrixOp
TinyMatrixEngine< D1, D2, T, Full >Definitions for a Full TinyMatrix
TinyMatrixEngine< D1, D2, T, UnaryTinyMatrixOp< V1, Op > >
TinyMatrixEngineElem< D1, D2, T, E, I, J >
TinyMatrixEngineElem< D1, D2, T, BinaryTinyMatrixOp< T1, T2, FnDot >, I, J >
TinyMatrixEngineElem< D1, D2, T, BinaryTinyMatrixOp< V1, V2, Op >, I, J >Specialization of TinyMatrixElem for BinaryTinyMatrixOp
TinyMatrixEngineElem< D1, D2, T, UnaryTinyMatrixOp< V1, Op >, I, J >
Token
TouchesConstructINode< Dim >TouchesConstructINode is used to construct an INode during the touches() operation in layouts
TouchesConstructNodeObj
TouchesConstructNodePtr
TouchesDomain< T1, T2, Dim >TouchesDomain implements a basic template meta-program to compare each dimension separately of the multidimensional domains for whether they touch
TouchesDomain< T1, T2, 1 >
TouchesDomainSingle< T1, T2, strided >TouchesDomainSingle<T1,T2,bool strided>::touches(a,b) compares two domains a and b of type T1 and T2, and returns true if they touch
TouchesDomainSingle< T1, T2, true >The non-unit-stride version of TouchesDomainSingle, which does extra work for the case where a and b do not have unit stride
TransformPatch< Dim, Function >
TreeCombine
TrinaryFunction
TrinaryNode< Op, Left, Middle, Right >
TrinaryOp
TrinaryReturn< T1, T2, T3, Op >
TrivialElementProperties< T >
TrivialElementPropertiesBase< T >Concrete types that have trivial default construction and destruction semantics can just inherit from this:
TypeInfo< T >
TypeInfo< Array< D, T, E > >
TypeInfo< BinaryNode< Op, Left, Right > >
TypeInfo< Brick >
TypeInfo< BrickView >
TypeInfo< Cartesian< Dim > >
TypeInfo< CompressibleBrick >
TypeInfo< ConstantFunction >
TypeInfo< double >
TypeInfo< ExpressionTag< Expr > >
TypeInfo< Field< GeometryTag, T, EngineTag > >
TypeInfo< FieldEngine< GeometryTag, T, EngineTag > >
TypeInfo< FieldEngineBase< Dim, T, EngineTag > >
TypeInfo< GridTag >
TypeInfo< int >
TypeInfo< MultiPatch< LayoutTag, PatchTag > >
TypeInfo< MultiPatchView< LayoutTag, PatchTag, D2 > >
TypeInfo< NoGeometry< Dim > >
TypeInfo< OpAdd >
TypeInfo< OpMultiply >
TypeInfo< Reference< Expr > >
TypeInfo< Scalar< T > >
TypeInfo< UnaryNode< Op, Child > >
TypeInfo< UniformRectilinear< Dim, T, CoordinateSystem > >
TypeInfoInt< D >
TypeInfoInt< 1 >
TypeInfoInt< 2 >
UnaryBoolOp
UnaryCastFunction
UnaryCastOp
UnaryFunction
UnaryNode< Op, Child >
UnaryOp
UnaryReturn< T, Op >
UnaryReturn< complex< T >, FnAbs >
UnaryReturn< complex< T >, FnArg >
UnaryReturn< complex< T >, FnConj >
UnaryReturn< complex< T >, FnImag >
UnaryReturn< complex< T >, FnNorm >
UnaryReturn< complex< T >, FnReal >
UnaryReturn< MinusOne< T >, OpUnaryMinus >
UnaryReturn< One< T >, OpUnaryMinus >
UnaryReturn< T, FnAbs >
UnaryReturn< T, FnPow2 >
UnaryReturn< T, FnPow3 >
UnaryReturn< T, FnPow4 >
UnaryReturn< T, OpNot >
UnaryReturn< T2, OpCast< T1 > >
UnaryReturn< Tensor< D, T, E >, FnDet >
UnaryReturn< Tensor< D, T, E >, FnSymmetrize< OutputEngineTag > >
UnaryReturn< Tensor< D, T, E >, FnTrace >
UnaryReturn< Tensor< D, T, E >, FnTranspose >
UnaryReturn< Vector< D, T, E >, FnNorm >
UnaryReturn< Zero< T >, OpUnaryMinus >
UnaryReturn< Zero< T >, OpUnaryPlus >
UnarySpecialOp
UnCompressedViewEngine
UniformGridLayout< Dim >UniformGridLayout is a Layout class that breaks an N-dimensional Interval into equal sized sub-domains arranged in an N-dimensional grid
UniformGridLayoutData< Dim >This is the actual data for the UniformGridLayout class, which is simply a wrapper that holds a reference counted instance of this data class
UniformGridLayoutView< Dim, Dim2 >UniformGridLayoutView is a Layout class that provides a view of an existing UniformGridLayout object
UniformGridLayoutViewData< Dim, Dim2 >This is the actual data for the UniformGridLayoutView class, which is simply a wrapper that holds a reference counted instance of this data class
UniformGridPartition< Dim >UniformGridPartition is a layout partitioner; it is created with the information needed to partition a global domain into subdomains using a grid layout
UniformLayoutUniformLayout is a very simple particle layout class that is used to determine where particles will be located in a parallel environment
UniformMapperUniformMapper is a ContextMapper specifically for 1D patches
UniformRectilinearMesh< Dim, T >UniformRectilinearMesh is the simplest form of rectilinear mesh in that it has uniform spacing between vertices
UniformRectilinearMeshData< Dim, T >Holds the data for a uniform rectilinear mesh
UniformTag
UninitializedVector< T, Dim, Elem >UninitializedVector<T,Dim> stores internally an array of object of type 'Elem', of length sizeof(T) * Dim / sizeof(Elem), where T and Elem are some arbitrary types
UniqueThe Overview pretty much sums it up
UnPackLocalPatches< InputField >
UnwritableTrivial class for returning something that can't assigned into:
UpdateNotifier
UserFunction< Func >To construct a user function class using UserFunction, define:
UserFunctionEngine< UserFunction, Expression >This is just a tag class for the user function engine
Vector< Dim, T, EngineTag >Vector is an interface class that takes three template parameters:
  • int Dim: The number of components in the vector
VectorAssign< V1, V2, Op, B, L >
VectorAssign< V1, V2, Op, B, 0 >
VectorAssign< V1, V2, Op, B, 1 >
VectorAssign< V1, V2, Op, B, 2 >
VectorAssign< V1, V2, Op, B, 3 >
VectorDotTensor< V1, T2, I, B, L >
VectorDotTensor< V1, T2, I, B, 1 >
VectorDotTinyMatrix< V1, T2, I, B, L >
VectorDotTinyMatrix< V1, T2, I, B, 1 >
VectorDotVector< V1, V2, B, L >
VectorDotVector< V1, V2, B, 1 >
VectorElem< V, I >
VectorElem< Vector< D, T, E >, I >
VectorElem< VectorEngine< D, T, Full >, I >
VectorEngine< D, T, BinaryVectorOp< V1, V2, Op > >
VectorEngine< D, T, Full >Definitions for a Full vector
VectorEngine< D, T, UnaryVectorOp< V1, Op > >
VectorEngineElem< D, T, E, I >
VectorEngineElem< D, T, BinaryVectorOp< V1, V2, Op >, I >Specialization of VectorElem for BinaryVectorOp
VectorEngineElem< D, T, UnaryVectorOp< V1, Op >, I >
VectorEngineElem< D, T3, BinaryVectorOp< Tensor< D, T1, E1 >, Vector< D, T2, E2 >, FnDot >, I >
VectorEngineElem< D, T3, BinaryVectorOp< Vector< D, T1, E1 >, Tensor< D, T2, E2 >, FnDot >, I >
VectorEngineElem< D1, T3, BinaryVectorOp< TinyMatrix< D1, D2, T1, E1 >, Vector< D2, T2, E2 >, FnDot >, I >
VectorEngineElem< D2, T3, BinaryVectorOp< Vector< D1, T1, E1 >, TinyMatrix< D1, D2, T2, E2 >, FnDot >, I >
VectorEqualsVector< V1, V2, B, L >
VectorEqualsVector< V1, V2, B, 1 >
MultiPatchLayoutTraits< DynamicTag, 1 >::View< ViewDim >
MultiPatchLayoutTraits< GridTag, Dim >::View< ViewDim >
MultiPatchLayoutTraits< SparseTileTag, Dim >::View< ViewDim >
MultiPatchLayoutTraits< UniformTag, Dim >::View< ViewDim >
View0< Thing >View0 enables you to write:
View0< Array< Dim, T, EngineTag > >
View1< Thing, Sub >View1 enables you to write:
View1< Array< D, T1, E1 >, DynamicArray< T2, E2 > >
View1< Array< D1, T1, E1 >, Array< D2, T2, E2 > >
View1< Array< Dim, T, EngineTag >, Domain >
View1< Array< Dim, T, EngineTag >, int >
View1< Array< Dim, T, EngineTag >, Loc< Dim > >
View1< DynamicArray< T, EngineTag >, Sub1 >General versions. Just defer to Array<1>
View1< DynamicArray< T1, E1 >, Array< 1, T2, E2 > >
View1< DynamicArray< T1, E1 >, DynamicArray< T2, E2 > >
View1< Field< Mesh, T, EngineTag >, int >View1<Field, int> specialization for indexing a field with an int
View1< Field< Mesh, T, EngineTag >, Loc< Mesh::dimensions > >View1<Field, Loc> specialization for indexing a field with a Loc
View1< Field< Mesh, T, EngineTag >, Sub1 >View1<Field, S1> specialization for indexing a field with a single domain
View1< MultiArg1< A1 >, Dom >
View1< MultiArg2< A1, A2 >, Dom >
View1< MultiArg3< A1, A2, A3 >, Dom >
View1< MultiArg4< A1, A2, A3, A4 >, Dom >
View1< MultiArg5< A1, A2, A3, A4, A5 >, Dom >
View1< MultiArg6< A1, A2, A3, A4, A5, A6 >, Dom >
View1< MultiArg7< A1, A2, A3, A4, A5, A6, A7 >, Dom >
View1< Stencil< Function >, Array< D, T, E > >
View1< UserFunction< Func >, Array< D, T, E > >
View1Implementation< Array< Dim, T, EngineTag >, Domain, false >
View1Implementation< Array< Dim, T, EngineTag >, Domain, true >
View1Implementation< Field< Mesh, T, EngineTag >, Domain, false >
View1Implementation< Field< Mesh, T, EngineTag >, Domain, true >View1Implementation<Field, D, SV> specialization for indexing a field with a single domain
View2< Thing, Sub1, Sub2 >View2 enables you to write:
View2< Array< Dim, T, EngineTag >, int, int >
View2< Array< Dim, T, EngineTag >, Sub1, Sub2 >
View2< Field< Mesh, T, EngineTag >, FieldOffset< Dim >, Loc< Dim > >View2<Field, FieldOffset<Dim>, Loc<Dim> > specialization for indexing a field with a FieldOffset and a Loc
View2< Field< Mesh, T, EngineTag >, int, int >View2<Field, int, int> specialization for indexing a field with two integers
View2< Field< Mesh, T, EngineTag >, Sub1, Sub2 >View2<Field, S1, S2> specialization for indexing a field with two domains
View2< Field< MeshTag, T, EngineTag >, FieldOffset< Dim >, Centering< Dim > >View2<Field, FieldOffset, Centering> specialization for indexing a field with a FieldOffset
View2< Field< MeshTag, T, EngineTag >, std::vector< FieldOffset< Dim > >, Centering< Dim > >View2<Field, vector<FieldOffset>, Centering> specialization for indexing a field with a vector<FieldOffset>
View2< Stencil< Function >, ArrayIn, Dom >
View2< Stencil< Function >, ArrayIn, Interval< Dim > >
View3< Thing, Sub1, Sub2, Sub3 >View3 enables you to write:
View3< Array< Dim, T, EngineTag >, int, int, int >
View3< Array< Dim, T, EngineTag >, Sub1, Sub2, Sub3 >
View3< Field< Mesh, T, EngineTag >, int, int, int >View3<Field, int, int, int> specialization for indexing a field with three integers
View3< Field< Mesh, T, EngineTag >, Sub1, Sub2, Sub3 >View3<Field, S1, S2, S3> specialization for indexing a field with three domains
View4< Thing, Sub1, Sub2, Sub3, Sub4 >View4 enables you to write:
View4< Array< Dim, T, EngineTag >, int, int, int, int >
View4< Array< Dim, T, EngineTag >, Sub1, Sub2, Sub3, Sub4 >
View5< Thing, Sub1, Sub2, Sub3, Sub4, Sub5 >View5 enables you to write:
View5< Array< Dim, T, EngineTag >, int, int, int, int, int >
View5< Array< Dim, T, EngineTag >, Sub1, Sub2, Sub3, Sub4, Sub5 >
View6< Thing, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6 >View6 enables you to write:
View6< Array< Dim, T, EngineTag >, int, int, int, int, int, int >
View6< Array< Dim, T, EngineTag >, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6 >
View7< Thing, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6, Sub7 >View7 enables you to write:
View7< Array< Dim, T, EngineTag >, int, int, int, int, int, int, int >
View7< Array< Dim, T, EngineTag >, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6, Sub7 >
ViewEngine< OriginalDim, ViewedEngineTag >
ViewFunctorTag< Domain >NewEngine<Engine<Dim,T,ExpressionTag<Expr> >, Domain >Type_t is supposed to give the type of ExpressionEngine that you would get by taking views of all of the expressions leaves based on the domain Domain
ViewIndexer< Dim, Dim2 >ViewIndexer translates indices in a Dim-dimensional domain back to the corresponding indices in the original Dim2-dimensional domain, taking into account things like slices
ViewIndexer< Dim, Dim >This is an extra-special version of View indexer that optimizes indexing for the case where we have not taken a slice
ViewIntersector< Dim, ViewD1, ViewD2 >
WhereMask
WhereProxy< F, B >The only legal use of where(a,b) is in an expression like:
WhereProxy< F, B >::WhereProxyTraits< Cond, Val, F1, B1 >
WhereProxy< F, B >::WhereProxyTraits< Cond, Scalar< T >, F1, B1 >
WhereProxy< F, B >::WhereProxyTraits< Scalar< T >, Val, F1, B1 >
WhereProxy< F, B >::WhereProxyTraits< Scalar< T1 >, Scalar< T2 >, F1, B1 >
DataBlockController< T >::WithAffinity
WrapNoInit< Domain >WrapNoInit is a wrapper class around Domain that changes the default constructor behavior to not init the storage
Cheetah::WrappedBool< flag >
WrappedInt< Integer >Helper class: WrappedInt<int>
Writable< D, E, I, J >Returns true or false (compile-time value, really an enum = 0 or 1) for whether element (I,J) of a Tensor type is writable
Writable< D, Antisymmetric, I, J >
Writable< D, Diagonal, I, J >
Writable< D, Symmetric, I, J >
WriteRelease
WriteRequest
XField< Geom >
XField< UniformRectilinearMesh< Dim, TM > >
Zero< T >The point of this class is to be a number of type T which is known at compile time to be zero

Generated on Wed Mar 16 06:19:40 2011 for FreePOOMA by  doxygen 1.5.9