AbsorbBC< T > | Here is an example of adding a new particle boundary condition |
AddNewDomain2Dimensions< T1, T2 > | |
AffinityCombine | This 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 | |
Antisymmetric | Like 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 |
AssertEquals | AssertEquals is a handy class for asserting conformance of an integer value in expressions |
Pete::Assertion | |
Pooma::Assertion | Assertion: exception notification class for assertions |
AssignFunction | |
AssignFunctionForClass | |
AssignOpReadWriteTraits< Op > | |
AssignOpReadWriteTraits< OpAssign > | |
TensorEngine< D, T, Antisymmetric >::AssignProxy | |
TensorEngine< D, T, Diagonal >::AssignProxy | |
Attribute | Attribute 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 |
BackFill | BackFill: 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 |
Benchmark | Benchmark 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 |
BlockAffinity | DataObjectRequest<BlockAffinity> Used to get the affinity for an array |
Brick | These 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::Clock | Clock 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 | |
Compressible | Compressible<Engine> CompressedRead<Engine> CompressedReadWrite<Engine> |
CompressibleBlock< T > | CompressibleBlock (CBlock) provides the storage for Pooma's compressible brick engine |
CompressibleBrick | These 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 > | |
ConnectionBase | ConnectionBase 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 > | |
ConnectorBase | ConnectionBase 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 |
ConstantFunction | ConstantFunction 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 > | |
CopyPatchEvent | CopyPatchEvent: A class derived from ObserverEvent that stores information on what elements to copy in an engine |
CountBlocks | |
Pooma::CountingSemaphore | |
CreateEvent | CreateEvent: 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 |
Diagonal | Like this, for the 3D case; just chop off pieces for 1D and 2D: |
DiskLayout< Dim > | Class encapsulating the reading of a "DiscField" .layout file |
DiskMeta | DiskMeta - 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 |
DistributedTag | Tag 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) |
DomainFunctorTag | DomainFunctorTag 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 |
DomainTag | DomainTag 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::DontCopyRelations | This tag is used to tell constructors not to copy relations |
Pooma::DummyMutex | |
Dynamic | These 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 |
DynamicEvents | A 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 > > | |
DynamicLayout | DynamicLayout 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 |
DynamicLayoutData | Holds the data for a DynamicLayout |
DynamicLayoutView | DynamicLayoutView is a Layout class that provides a view of an existing DynamicLayout object |
DynamicLayoutViewData | The data object held by a DynamicLayoutView object |
DynamicTag | |
DynamicView | These 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 | |
EngineConstructTag | EngineConstructTag 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 |
EngineNumPatches | EngineNumPatches is used to find out how many patches an engine has |
EnginePatch | EnginePatch 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 |
ErrorDomain | NullDomain 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 |
ExpressionIsArray | Traits class for expressions containing arrays |
ExpressionIsField | |
ExpressionIsScalar | ExpressionIsScalar 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 > | |
Full | Full 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 |
GatherContexts | EngineFunctor for gathering up the contexts in an expression and returning the most common |
SparseTileLayoutData< Dim >::GCBorderFillInfo | |
LayoutBaseData< Dim >::GCFillInfo | |
RectilinearMesh< Dim, T >::GeneralVolumesFunctor | General "volume" functor: works for edges, faces and cells |
GlobalIDDataBase | GlobalIDDataBase 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 |
GridTag | GridTag 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 |
Implementation | Implementation 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 > | |
InfluenceRelation | InfluenceRelation 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 |
Inform | A 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 | |
Interpolator | Interpolator 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 |
IntervalIterator | A 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::MetaTokenIterator | MetaTokenIterator 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::NoInit | Tag 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 | |
NullDomain | NullDomain 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 |
ObserverEvent | The 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::Options | Options 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::PatchSizeSyncer | This 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 > | |
PerformUpdateTag | These 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 | |
Pool | A 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 >::PositionsFunctor | Support for the positions() function |
RectilinearMesh< Dim, T >::PositionsFunctor | Support for the positions() function |
PositionsTraits< Mesh > | |
PosReflectFaceBC< Dim > | PosReflectFaceBC is an Relation functor class |
PrintArray | PrintArray is a utility program for Array objects, used to print (nicely) the contents of an array to a provided stream |
PrintField | PrintField 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 |
RangeIterator | A 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 |
RefCounted | RefCounted 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 > > | |
RelationList | RelationList is a container that dispatches events to the list of boundary conditions it contains |
RelationListData | RelationListData is a ref-counted object that holds the data for an relation list |
RelationListItem | RelationListItem 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 | |
RemoteView | These two functor tags are used with engineFunctor() to generate brick-views from expressions or engines containing remote-brick-views |
ReplicatedTag | Tag 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::Runnable | Runnable 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 | |
SendReceive | The 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::SerialAsync | Tag 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 |
ShiftUp | ShiftUp: 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 |
SparseTileTag | SparseTileTag 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::Statistics | Statistics 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 | |
Symmetric | Like 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 > | |
SyncEvent | SyncEvent: A class derived from ObserverEvent that stores information about doing a sync |
Smarts::SystemContext | |
TagGenerator | There 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::Tester | Tester 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 |
UniformLayout | UniformLayout is a very simple particle layout class that is used to determine where particles will be located in a parallel environment |
UniformMapper | UniformMapper 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 |
Unique | The Overview pretty much sums it up |
UnPackLocalPatches< InputField > | |
Unwritable | Trivial 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 |