AbsorbBC.h | An absorbing boundary condition for a Particles Attribute |
algorithms.h | Copy, delete_backfill and delete_shiftup algorithms |
AllDomain.h | AllDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules |
array.doxygen | |
Array.h | Array classes |
ArrayOperators.h | |
ArrayOperatorSpecializations.h | Specializations for min()/max() |
Arrays.h | A one-stop-shopping header file that sets up everything one needs to use all Pooma II arrays with Tiny things and complex numbers |
AssertEquals.h | AssertEquals is a handy class for asserting conformance of an integer value in expressions |
Attribute.h | Attribute is a non-templated base class used to provide an interface to DynamicArray objects used as attributes in Particle classes |
AttributeList.h | AttributeList stores a list of Attribute pointers, that are used to store a heterogenous collection of Attributes |
AttributeWrapper.h | AttributeWrapper<T> is a subclass of Attribute that implements the basic Attribute interface by passing on the operations in the interface to an object of type T that AttributeWrapper wraps |
Benchmark.h | Benchmark framework |
BinaryTensorOp.h | An engine class for representing the sum, product, etc |
BinaryTinyMatrixOp.h | An engine class for representing the sum, product, etc |
BinaryVectorOp.h | An engine class for representing the sum, product etc between two vectors |
BisectionMapper.h | BisectionMapper is a ContextMapper implementation |
BrickArrays.h | A one-stop-shopping header file that sets up everything one needs to use brick-based arrays |
BrickBase.h | Base classes for Brick- & BrickView-like engines |
BrickEngine.h | Brick & BrickView |
ByteOrder.h | Defines a general reverseBytes template and a specialization for complex |
Cartesian.h | |
CheetahSerialize.h | |
ClassDescriptor.h | |
Clock.h | Running timer |
CollectFromContexts.h | CollectFromContext encapsulates functionality like MPI_Gather |
CombineDomainOpt.h | CombineDomainOpt is a class that can be used to optimize the operation NewDomainN<>::combineSlice(domain, s1, s2, ...) |
Combiners.h | |
CommonParticleTraits.h | These are some structs which can be used as a particle traits class for defining the Particles' attribute engine tag type and layout strategy type |
ComponentAccess.h | ComponentAccess<Container, Comp> is a general functor class that users can specialize to tell POOMA how to access components inside an object used as an element in expressions |
CompressedFraction.h | External functions that can be applied to any engine or container to answer questions about compression and to force compression or uncompression |
CompressibleBlock.h | A CompressibleBlock (CBlock) manages a block of data that can be compressed to a single value |
CompressibleBrick.h | CompressibleBrick engine |
CompressibleEngines.h | We define EngineFunctor<Engine,Tag> for tags that express the functionality that compressible bricks have |
CompressibleEval.h | These evaluators are used in the iterates that perform evaluation on expressions with CompressibleBricks |
Configuration.h | Main configuration file |
Conform.h | A tag for checking whether the terms in an expression have conforming domains |
connect.doxygen | |
Connection.h | Base class for specialized classes that manage a connection or "channel" to some external agency |
Connector.h | Base class for all objects that are used to take data from a single item and connect it to some connection |
ConnectPair.h | Connect |
ConstantFaceBC.h | Relation functor class setting all guard layers beyond a specified (logically) rectilinear mesh face to a constant value |
ConstantFunctionEngine.h | Constant-function-engine objects provide a way to make a scalar behave like an array |
Contains.h | Bool contains(domain,domain) is a global function which determines if the points in the second domain are all points which are in the first domain |
ContextMapper.h | ContextMapper is the base class for classes used to map a node list to contexts |
ContiguousMapper.h | ContiguousMapper is a ContextMapper implementation |
CoordinateTypeInfo.h | |
Array/CreateLeaf.h | These are the external traits classes that are used to build trees |
PETE/CreateLeaf.h | |
Cylindrical.h | |
DataBlockPtr.h | DataBlockPtr acts like a RefCountedBlockPtr that has two additional pieces of functionality: |
databrowser.doxygen | |
DataBrowser.h | |
DataObject.h | Traits and tags necessary for dealing with the Smarts data object inside some engines |
DerefIterator.h | STL style iterators for lists of pointers |
DescriptorBase.h | |
DiskLayout.h | DiskLayout<Dim> manages the reading of the .layout file in a DiskField fileset and the communication between contexts necessary for each reading process to have full "layout" information |
DiskMeta.h | This .meta format is based on the Pooma r1 "DiscField" .meta format, designed by Bill Humphrey and others |
DistributedMapper.h | DistributedMapper is a ContextMapper implementation |
Div.h | Divergence operator (functor) on discrete Fields |
Div.UR.h | Divergence operator on Fields, using 2nd-order centered differences These are used by the div() template function |
domain.doxygen | |
Domain.h | Domain is a base class for all domain objects, but one which can be specialized for N-dimensional (N>1), and 1-dimensional domain objects |
DomainArithOpsTraits.h | DomainArithOpsTraits is intended to be used to select the return type of arithmetic operations between domains and pseudo-domains |
DomainBase.h | DomainBase is a common base class for all domain objects |
DomainBlockIterator.h | DomainBlockIterator<Dom> - Iterates through domain data (of type Dom), and returns block domains (Interval or Region) |
DomainCalculus.h | This file defines the prototypes for routines used in the domain calculus computations |
DomainIterator.h | DomainIterator<Dom> - Iterates through domain data (of type Dom) |
DomainLayout.h | DomainLayout<int>: Layout class that just wraps around an Interval |
DomainMap.h | DomainMap<Domain,Data> stores a list of N domains (of type Domain), each with an associated piece of data (of type Data) |
DomainRemoveOverlap.h | TBD |
Domains.h | A one-stop-shopping header file that sets up everything one needs to use all Pooma II domain objects and functions |
DomainTraits.Grid.h | DomainTraits<Grid<N>> is a specialization of the general DomainTraits class, for the case of Grid domain objects |
DomainTraits.h | DomainTraits is a traits class for domain objects |
DomainTraits.int.h | DomainTraits<int> is a specialization of the general DomainTraits class, for the case of integers |
DomainTraits.Interval.h | DomainTraits<Interval<N>> is a specialization of the general DomainTraits class, for the case of Interval domain objects |
DomainTraits.Loc.h | DomainTraits<Loc<N>> is a specialization of the general DomainTraits class, for the case of Loc domain objects |
DomainTraits.Range.h | DomainTraits<Range<N>> is a specialization of the general DomainTraits class, for the case of Range domain objects |
DomainTraits.Region.h | DomainTraits<Region<N,T>> is a specialization of the general DomainTraits class, for the case of Region domain objects |
DomainTraits.SliceInterval.h | DomainTraits<SliceInterval<Dim,SliceDim>> is a specialization of the general DomainTraits class, for the case of SliceInterval domain objects |
DomainTraits.SliceRange.h | DomainTraits<SliceRange<Dim,SliceDim>> is a specialization of the general DomainTraits class, for the case of SliceRange domain objects |
DynamicArray.h | Dynamic arrays |
DynamicArrayOperators.h | |
DynamicArrays.h | A one-stop-shopping header file that sets up everything one needs to use all Pooma II DynamicArray's with Tiny things, complex numbers, and other Arrays |
DynamicEngine.h | Dynamic Engine |
DynamicEvents.h | DynamicEvents defines some simple enumerations used as codes to indicate a type of "dynamic event" |
DynamicLayout.h | DynamicLayout |
ElementProperties.h | Traits class for determining, and possibly modifying, the construction and destruction properties of elements of type T |
engine.doxygen | |
Engine.h | Engine |
EngineFunctor.h | EngineFunctor provides a common interface to a variety of engine queries, like "are you compressed" or "are you shifted with respect to another
engine" |
EnginePatch.h | Patch handling with engines: |
EngineTraits.h | EvaluatorEngineTraits<EngineTag> associates evaluator types with engine tags |
EngineTypeInfo.h | Undocumented |
EquivSubset.h | Domain4 equivSubset(domain1,domain2,domain3) is a global function which finds the 'equivalent subset' for domain3 given a linear relationship between domain1 and domain2 |
ErrorType.h | |
evaluator.doxygen | |
Evaluator.h | Evaluator evaluates expressions by examining the engines that are participating in the expression and dispatching to custom code |
EvaluatorTags.h | Evaluator Tags are used for picking the appropriate evaluator given the engines in an expression |
ExpressionEngine.h | Engine<Dim,T,ExpressionTag<Expr> > (aka Expression-Engine) is the engine that contains a PETE expression and provides all the Array interfaces for it |
ExpressionKernel.h | An ExpressionKernel encapsulates evaluating an expression on a domain |
ExpressionTraits.h | Undocumented |
field.doxygen | |
Field.h | Ties together the notions of field-category and mesh |
FieldCentering.h | Value locations within a field's cell |
FieldCreateLeaf.h | CreateLeaf is used to convert arbitrary classes into expression objects |
FieldEngine.ExprEngine.h | FieldEngine specialization for expression engine |
FieldEngine.h | FieldEngine and FieldEngineBaseData classes |
FieldEnginePatch.h | Functor for getting the nth patch out of a field |
FieldMakeReturn.h | MakeFieldReturn is used to combine expressions together with operators |
FieldOffset.h | Relative cell offset and subfield number |
FieldOffsetReduction.h | |
FieldOperators.h | |
FieldOperatorSpecializations.h | Min()/max() specializations |
Fields.h | A one-stop-shopping header file that sets up everything one needs to use all POOMA Fields (and, by inclusion of Arrays.h, Arrays) |
FieldShiftEngine.h | An engine capable of shifting the contents of a field |
FieldStencil.h | This file contains the equipment required to write differential operators that take the form of stencil objects using Fields |
FieldTypeInfo.h | TypeInfo<> specializations for Field things |
FileSetReader.h | FileSetReader<Dim> manages the reading of Arrays and Fields from "DiscField" format files |
FileSetWriter.h | FileSetWriter<Dim> manages the writing of Arrays and Fields from "DiscField" format files |
ForEach.h | |
ForwardingEngine.h | A ForwardingEngine is used to forward indices to the elements of another engine |
FunctorResult.h | FunctorResult<Functor,T>::Type_t is the return type of a pooma functor object |
Functors.h | |
GlobalIDDataBase.h | GlobalIDDataBase stores global patch ID's for INodes |
GMPArrays.h | A one-stop-shopping header file that sets up everything one needs to use GMP-based arrays |
Grad.h | Gradient operator (functor) on discrete Fields |
Grad.UR.h | Gradient operator on Fields, using 2nd-order centered differences These are used by the grad() template function |
Grid.h | Grid is a general type of integer domain, which refers to a set of points a0, a1, .. |
GridLayout.h | Layout with domain breaked into sub-domains specified by a grid |
GridPartition.h | A layout partitioner that will break a given global domain into blocks specified by a domain Grid |
GuardLayers.h | A simple container for a set of guard layer specifications |
HDF5.h | Traits classes for mapping POOMA types to HDF5 objects and wrappers for some HDF5 functions with POOMA style domain specifiers |
Header.h | |
IndexFunctionEngine.h | Index-function-engine objects provide a way to make a function of indices work like an array |
Indices.h | Iota(domain) is a handy function that returns an Array that contains an array of vectors whose elements correspond to index values |
IndirectionEngine.h | Work in progress! |
IndirectionList.h | IndirectionList<T> is a class that takes any object with an Array-like interface and stores the information as a list of elements of type T |
IndirectionListIterator.h | IndirectionListIterator - Iterates through IndirectionList<T> elements |
Inform.h | A general utility class which looks very much like an ostream, which will format output to include an optional prefix string, and will print out results to multiple other ostreams |
InlineEvaluator.h | InlineEvaluator evaluates expressions by inlining a simple loop |
INode.h | Node-like class for communicating information regarding intersections of layouts |
internal.doxygen | |
Interpolation.h | General template for Interpolator class and Gather/Scatter global function declarations for Particle-Field interpolation |
InterpolatorCIC.h | Specialization of Interpolator class template for cloud-in-cell (CIC) interpolation between Particle Attributes and Fields |
InterpolatorNGP.h | Specialization of Interpolator class template for nearest-grid-point (NGP) interpolation between Particle Attributes and Fields |
InterpolatorSUDS.h | Specialization of Interpolator class template for subtracted dipole scheme (SUDS) interpolation between Particle Attributes and Fields |
Intersect.h | Domain3 intersect(domain1,domain2) is a global function which determines if two domains intersect with each other, and if so, what their intersection is |
IntersectEngine.h | IntersectEngine provides a common interface for applying the intersector object to various engines |
Intersector.h | Managing intersections of engines: |
Interval.h | Interval is a very simple type of domain, which refers to a set of points a, a+1, a+2, ..., b |
IntervalIterator.h | IntervalIterator - Iterates through Interval<1> points |
io.doxygen | |
IsValidLocation.h | Helper functions to determine if a particular location or region of a object is defined |
IterateScheduler.h | Templates for the scheduler classes |
IteratorPairDomain.h | IteratorPairDomain<Iter> wraps a pair of iterators and provides a subset of services provided by other 1D domains, and in particular by IndirectionList |
Join.h | |
KernelTags.h | Kernel Tags are used for picking the appropriate Kernel given the engines in an expression |
KillBC.h | A "kill" boundary condition for Particles |
layout.doxygen | |
LayoutBase.h | LayoutBase<Dim> and related classes providing domain access |
LeftDomain.h | LeftDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules |
Loc.h | Loc<N> is a very simple type of domain, which refers to just one point |
LoopApply.h | LoopApplyEvaluator is a simple class that wraps a set of 7 functions that provide efficient loops over Interval<Dim> type domains and call operator() with the integers on a user provided functor |
Lux.h | A one-stop-shopping header file that sets up everything one needs to use the Lux package for run-time visualization |
LuxAppPointer.h | |
LuxConnection.h | |
LuxConnector.Array.h | |
LuxConnector.Field.h | |
LuxConnector.Particles.h | |
main.doxygen | |
MeshFunctions.h | Mesh functions for querying mesh properties |
Messaging.h | Functions and classes needed to support interaction with the cheetah messaging library |
MetaProgs.h | LoopUtils: Template meta-programs for carrying out certain operations on arrays at compile time |
MetaTokenIterator.h | MetaTokenIterator is a helper class designed to efficiently parse a line from the "DiscField" .meta file |
ModelElement.h | A wrapper class used to differentiate overloaded functions |
MultiArg.h | The MultiArg1...N classes are intended to be used to wrap multiple arrays, fields, or particles where a common set of operations need to be performed on the set |
MultiArgEvaluator.h | MultiArgEvaluator is an evaluator that takes a MultiArg object |
MultiArgKernel.h | MultiArgKernel is a generalized iterate object to hand off to smarts |
MultiPatchEngine.h | MultiPatch engine: |
MultiPatchLayoutTraits.h | Traits class specifying the layout and layout view types for a particular layout tag |
NearestNeighbors.h | Yields FieldOffsets corresponding to the given parameters |
NewDomain.h | A set of simple structs which tell how to combine different Domain objects together |
Node.h | A simple class which stores the following information: |
NoInit.h | Pooma::NoInit tag class |
NoMesh.h | NoMesh is an extremely lightweight class that indicates a Field cannot answer mesh-type questions |
NotifyEngineWrite.h | NotifyEngineWrite is a general wrapper class that is used to tell an engine that we're going to write to it |
NotifyPreRead.h | A tag for telling terms they are about to be read |
NullDomain.h | NullDomain and ErrorDomain special domains |
objects.doxygen | |
Observable.h | A base or wrapper class for an object of type T that needs to allow other objects to 'observe' it |
Observer.h | An abstract base class for objects which need to use the observer pattern |
ObserverEvent.h | ObserverEvent class - a base class for all events that will be passed on to observers from observables |
One.h | A numeric class for a number that is always one |
OperatorDescriptor.h | |
OperatorTags.h | |
OpMask.h | These classes implement the two argument where |
PETE/Tools/Options.h | |
Utilities/Options.h | A simple container class that holds information about how POOMA should be used when it starts up |
PackUnpack.h | Pack(field) and unpack(field, rcbp) are used to provide the user with a local 1D view of all the data in a field not including guard layers that belongs to the local processor |
Parser.h | |
ParticleBC.h | ParticleBCType is a tag-like base class for a category of boundary condition applied to an Attribute of a Particles object |
ParticleBCItem.h | ParticleBCItem is an abstract base class for any boundary condition applied to a Particles object |
ParticleBCList.h | ParticleBCList holds a list of ParticleBCItems for the Particles class, storing them in an STL vector of ParticleBCItem pointers |
particles.doxygen | |
Particles/Particles.h | The Particles class is the base class to be used for development of user-defined particles classes that describe application-specific particle populations |
Pooma/Particles.h | A one-stop-shopping header file that sets up everything one needs to use all Pooma II particle objects and layouts |
partition.doxygen | |
PETE/Tools/PAssert.h | |
Utilities/PAssert.h | PAssert macro, PInsist macro, CTAssert struct, SameType struct |
PatchCode.h | PatchCode functionality for applying a functor to a patch |
PatchFunction.h | PatchFunction is mix-in class that encapsulates evaluation of patch-based functors in parallel |
PatchKernel.h | A PatchKernel encapsulates performing operations on a patch of an expression |
PatchSizeSyncer.h | PatchSizeSyncer is used to synchronize a set of Grid objects that are used to represent a set of contiguous patches (e.g |
PatchSwapLayout.h | These classes define storage and functors for use in implementing particle layout classes that manage particles by swapping them from one patch to another |
Paws.h | A one-stop-shopping header file that sets up everything one needs to use Paws for various data types |
PawsAppPointer.h | |
PawsConnection.h | |
PawsConnector.Array.h | |
PawsConnector.DynamicArray.h | |
PawsConnector.Field.h | |
PawsConnector.h | |
PawsConnector.String.h | |
PerformUpdate.h | A tag for updating leafs in an expression |
PeriodicBC.h | A periodic boundary condition for a Particles Attribute |
PeriodicFaceBC.h | Updater setting all guard layers beyond a specified (logically) rectilinear mesh face to the value from the non-guard element symmetrically across the face (the face is defined at the last vertex) |
pete.doxygen | |
PETE.h | |
PETEExtras.h | Pooma Extras for the Portable Expression Template Engine |
PeteOps.h | |
PETETypeInfo.h | |
PETSc.h | Interfacing with the PETSc library of (non-)linear solvers |
Pool.h | A class for maintaining a large chunks of memory and handing out small blocks very quickly |
Pooled.h | A mixin class for providing fast new and delete |
pooma.doxygen | |
Pooma.h | Pooma.h includes all the declarations of the basic POOMA library interface functions |
PoomaArrayOperators.h | |
PoomaCSem.h | |
PoomaDynamicArrayOperators.h | |
PoomaFieldOperators.h | |
PoomaMutex.h | |
PoomaOperatorTags.h | |
PoomaPETE.h | |
PoomaSmarts.h | The POOMA wrapper around defines, includes, and typedefs for the Smarts run-time evaluation system |
PoomaTypeInfo.h | A one-stop-shopping header file that sets up everything one needs to use the compile-time type information provided by TypeInfo<> |
PositionFunctions.h | Computes position locations for Uniform Rectilinear meshes |
PosReflectFaceBC.h | Relation functor class setting all guard layers beyond a specified (logically) rectilinear mesh face to a positively reflected value |
PrintArray.h | Extract the elements of an Array and print out the contents to a stream with some nice formatting |
PrintField.h | Extract the elements of a Field and print out the contents to a stream with some nice formatting |
PrintFunctions.h | |
PrintList.h | |
PrintOperators.h | |
Profile.h | TAU Profiling |
PurifyConstructors.h | |
Range.h | Range is a general type of integer domain, which refers to a set of points a, a+s, a+2s, ..., b |
RangeIterator.h | RangeIterator - Iterates through Range<1> points |
RangeMaker.h | |
RectilinearMesh.h | A rectilinear mesh without uniform spacing between vertices |
ReduceOverContexts.h | ReduceOverContexts encapsulates functionality like MPI_Reduce and MPI_Allreduce by means of the ReduceOverContexts::broadcast() method |
Reduction.h | Reduction performs global reductions on expressions by examining the engines that are participating in the expression and dispatching to custom code |
ReductionEvaluator.h | ReductionEvaluator<InlineKernelTag> reduces expressions by inlining a simple loop |
ReductionKernel.h | A ReductionKernel encapsulates reducing an expression on a domain |
Functions/Reductions.h | Reduction functions for Fields and Arrays |
Tiny/Reductions.h | General global reduction functions |
RefCounted.h | RefCounted and Shared classes |
RefCountedBlockPtr.h | RefCountedBlockPtr and RefBlockController classes |
RefCountedPtr.h | RefCountedPtr<T> - reference counted pointer-to-T |
ReflectBC.h | A reflecting boundary condition for a Particles Attribute |
Region.h | Region is a general type of continuous domain, which refers to all points between two endpoints a and b |
RelationBases.h | RelationRetargetBase & RelationBase: the base classes for all relations |
RelationGroups.h | Functions supporting relation groups (undocumented) |
RelationList.h | Manages a list of relations |
RelationListItem.h | Ultimate base class for all relation objects |
Relations.h | Relation basics |
RemoteDynamicEngine.h | A wrapper engine that remotifies an Engine<1, T, Dynamic> |
RemoteEngine.h | Remote engine support |
RemoteProxy.h | This is like MPI_Bcast |
RequestLocks.h | Classes and functors that are necessary to request locks on an expression |
Resize.h | |
ReverseBC.h | A reversing boundary condition for Particles |
RightDomain.h | RightDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules |
RNGComponent.h | UNSUPPORTED |
RNGSimple.h | UNSUPPORTED |
Runnable.h | Base class for a schedulable object or function to be executed by the scheduler asynchronously |
Scalar.h | |
ScalarCode.h | Undocumented |
ScalarCodeInfo.h | ScalarCodeInfo contains all the information necessary for evaluating a piece of scalar code on several arguments |
Scheduler.h | Scheduler multiplexing based on configuration |
SendReceive.h | SendKernel and ReceiveKernel are special iterates that interact with cheetah to send and receive data that gets used in expressions |
SerialAsync.h | Smarts classes for times when you want no threads but you do want dataflow evaluation |
Shrink.h | Interval<Dim> shrinking and growing domains |
SimpleIntersector.h | Intersector that assumes matching layouts |
SliceDomain.h | SliceDomain is a base class for all sliced domain objects |
SliceInterval.h | Slice domain objects are domains which have N dimensions worth of 1D domain data, but really represent the result of taking an M-dimensional slice (M < N) of another N dimensional domain |
SliceRange.h | Slice domain objects are domains which have N dimensions worth of 1D domain data, but really represent the result of taking an M-dimensional slice (M < N) of another N dimensional domain |
SmartsStubs.h | Stub scheduler for serial in-order evaluation |
SparseTileLayout.h | SparseTileLayout<Dim> |
SpatialLayout.h | SpatialLayout<Mesh,FieldLayout> is a particle layout class that is used to determine where particles will be located in a parallel environment |
SpatialPartition.h | A layout partitioner that will generate a set of initially empty domains for insertion into a layout, based on the information from another layout |
Spherical.h | |
Split.h | Void split(domain,domain,domain) is a global function which splits the first argument into two separate domains, roughly in the moddle |
StaticPool.h | A class that manages a static Pool in which the block size is a template parameter |
Statistics.h | Statistics keeps statistics about a given POOMA job, and can report on a summary of these statistics when asked |
Stencil.h | Stencil objects are a way to build an object which applies a stencil to an array, and returns a new Array for the expression |
Tensor.h | An interface class for an N-dimensional tensor of numeric objects, and engines class for defining a general tensor, using Full and Antisymmetric engine tag classes |
TensorElements.h | |
TensorOperators.h | |
Tester.h | A simple class with some utility methods used to write test programs |
threads.doxygen | |
TilePartition.h | A layout partitioner that will break a given global domain into blocks specified by a domain Tile |
tiny.doxygen | |
Tiny.h | A one-stop-shopping header file that sets up everything one needs to use all Pooma II Tiny things |
TinyMatrix.h | An interface class for an N-dimensional TinyMatrix of numeric objects, and an engine class for defining a general TinyMatrix |
TinyMatrixElements.h | |
TinyMatrixOperators.h | |
Touches.h | Bool touches(domain,domain) is a global function which determines if two domains d1 and d2 overlap in any way |
TouchesConstruct.h | TouchesConstruct is a factory method that is used to build Nodes and INodes by various layout touches methods |
TransformPatch.h | Undocumented |
TreeNodes.h | |
tulip.doxygen | |
TypeComputations.h | |
TypeInfo.h | Undocumented |
UMPArrays.h | A one-stop-shopping header file that sets up everything one needs to use UMP-based arrays |
UnaryTensorOp.h | |
UnaryTinyMatrixOp.h | |
UnaryVectorOp.h | |
UniformGridLayout.h | UniformGridLayout<Dim> |
UniformGridPartition.h | A layout partitioner that will break a given global domain into N equally-sized blocks, where the user specifies how many subdivisions to make along each dimension (S_i) |
UniformLayout.h | UniformLayout is a very simple particle layout class that is used to determine where particles will be located in a parallel environment |
UniformMapper.h | UniformMapper is a ContextMapper implementation specifically for 1D patches |
UniformRectilinearMesh.h | A rectilinear mesh with uniform spacing between vertices |
UninitializedVector.h | UninitializedVector stores an array of objects of type 'T' of length 'Dim' in a way that avoids running the default constructors on the objects unless the 'initialize' method is called |
Unique.h | A simple utility class which can generate a sequence of unique values |
unused.doxygen | |
UserFunction.h | UserFunction objects are a way to build an object which applies a function to an Array, and returns a new Array for the expression |
utility.doxygen | |
Vector.h | An interface class for an N-dimensional vector of numeric objects, and an engine class for defining a general vector |
VectorArrayOperators.h | |
VectorDynamicArrayOperators.h | |
VectorElements.h | |
VectorFieldOperators.h | |
VectorOperators.h | |
VectorTensor.h | |
VectorTinyMatrix.h | |
View.h | View1<Object,Domain>::Type_t is defined for several Pooma objects, and tells you the type of a(b) |
ViewEngine.h | Generalized view engine that can handle intersections for contained multi-patch engines |
ViewIndexer.h | ViewIndexer translates a set of "local" indices for a view of some domain into the "base" coordinates of the domain that ultimately spawned the view |
WhereProxy.h | WhereProxy is used to implement 2 argument where() |
WrapFFTW.h | |
WrappedInt.h | A tag class templated on an integer |
Zero.h | A numeric class for a number that is always zero |