File List

Here is a list of all files with brief descriptions:
AbsorbBC.hAn absorbing boundary condition for a Particles Attribute
algorithms.hCopy, delete_backfill and delete_shiftup algorithms
AllDomain.hAllDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules
array.doxygen
Array.hArray classes
ArrayOperators.h
ArrayOperatorSpecializations.hSpecializations for min()/max()
Arrays.hA one-stop-shopping header file that sets up everything one needs to use all Pooma II arrays with Tiny things and complex numbers
AssertEquals.hAssertEquals is a handy class for asserting conformance of an integer value in expressions
Attribute.hAttribute is a non-templated base class used to provide an interface to DynamicArray objects used as attributes in Particle classes
AttributeList.hAttributeList stores a list of Attribute pointers, that are used to store a heterogenous collection of Attributes
AttributeWrapper.hAttributeWrapper<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.hBenchmark framework
BinaryTensorOp.hAn engine class for representing the sum, product, etc
BinaryTinyMatrixOp.hAn engine class for representing the sum, product, etc
BinaryVectorOp.hAn engine class for representing the sum, product etc between two vectors
BisectionMapper.hBisectionMapper is a ContextMapper implementation
BrickArrays.hA one-stop-shopping header file that sets up everything one needs to use brick-based arrays
BrickBase.hBase classes for Brick- & BrickView-like engines
BrickEngine.hBrick & BrickView
  • tag classes used to select specializations of Engine
ByteOrder.hDefines a general reverseBytes template and a specialization for complex
Cartesian.h
CheetahSerialize.h
ClassDescriptor.h
Clock.hRunning timer
CollectFromContexts.hCollectFromContext encapsulates functionality like MPI_Gather
CombineDomainOpt.hCombineDomainOpt is a class that can be used to optimize the operation NewDomainN<>::combineSlice(domain, s1, s2,
Combiners.h
CommonParticleTraits.hThese 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.hComponentAccess<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.hExternal functions that can be applied to any engine or container to answer questions about compression and to force compression or uncompression
CompressibleBlock.hA CompressibleBlock (CBlock) manages a block of data that can be compressed to a single value
CompressibleBrick.hCompressibleBrick engine
CompressibleEngines.hWe define EngineFunctor<Engine,Tag> for tags that express the functionality that compressible bricks have
CompressibleEval.hThese evaluators are used in the iterates that perform evaluation on expressions with CompressibleBricks
Configuration.hMain configuration file
Conform.hA tag for checking whether the terms in an expression have conforming domains
connect.doxygen
Connection.hBase class for specialized classes that manage a connection or "channel" to some external agency
Connector.hBase class for all objects that are used to take data from a single item and connect it to some connection
ConnectPair.hConnect
ConstantFaceBC.hRelation functor class setting all guard layers beyond a specified (logically) rectilinear mesh face to a constant value
ConstantFunctionEngine.hConstant-function-engine objects provide a way to make a scalar behave like an array
Contains.hBool 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.hContextMapper is the base class for classes used to map a node list to contexts
ContiguousMapper.hContiguousMapper is a ContextMapper implementation
CoordinateTypeInfo.h
Array/CreateLeaf.hThese are the external traits classes that are used to build trees
PETE/CreateLeaf.h
Cylindrical.h
DataBlockPtr.hDataBlockPtr acts like a RefCountedBlockPtr that has two additional pieces of functionality:
  1. it contains a pointer to a Smarts DataObject used for constructing and running the Smarts data-flow graph
databrowser.doxygen
DataBrowser.h
DataObject.hTraits and tags necessary for dealing with the Smarts data object inside some engines
DerefIterator.hSTL style iterators for lists of pointers
DescriptorBase.h
DiskLayout.hDiskLayout<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.hThis .meta format is based on the Pooma r1 "DiscField" .meta format, designed by Bill Humphrey and others
DistributedMapper.hDistributedMapper is a ContextMapper implementation
Div.hDivergence operator (functor) on discrete Fields
Div.UR.hDivergence operator on Fields, using 2nd-order centered differences These are used by the div() template function
domain.doxygen
Domain.hDomain 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.hDomainArithOpsTraits is intended to be used to select the return type of arithmetic operations between domains and pseudo-domains
DomainBase.hDomainBase is a common base class for all domain objects
DomainBlockIterator.hDomainBlockIterator<Dom> - Iterates through domain data (of type Dom), and returns block domains (Interval or Region)
DomainCalculus.hThis file defines the prototypes for routines used in the domain calculus computations
DomainIterator.hDomainIterator<Dom> - Iterates through domain data (of type Dom)
DomainLayout.hDomainLayout<int>: Layout class that just wraps around an Interval
DomainMap.hDomainMap<Domain,Data> stores a list of N domains (of type Domain), each with an associated piece of data (of type Data)
DomainRemoveOverlap.hTBD
Domains.hA one-stop-shopping header file that sets up everything one needs to use all Pooma II domain objects and functions
DomainTraits.Grid.hDomainTraits<Grid<N>> is a specialization of the general DomainTraits class, for the case of Grid domain objects
DomainTraits.hDomainTraits is a traits class for domain objects
DomainTraits.int.hDomainTraits<int> is a specialization of the general DomainTraits class, for the case of integers
DomainTraits.Interval.hDomainTraits<Interval<N>> is a specialization of the general DomainTraits class, for the case of Interval domain objects
DomainTraits.Loc.hDomainTraits<Loc<N>> is a specialization of the general DomainTraits class, for the case of Loc domain objects
DomainTraits.Range.hDomainTraits<Range<N>> is a specialization of the general DomainTraits class, for the case of Range domain objects
DomainTraits.Region.hDomainTraits<Region<N,T>> is a specialization of the general DomainTraits class, for the case of Region domain objects
DomainTraits.SliceInterval.hDomainTraits<SliceInterval<Dim,SliceDim>> is a specialization of the general DomainTraits class, for the case of SliceInterval domain objects
DomainTraits.SliceRange.hDomainTraits<SliceRange<Dim,SliceDim>> is a specialization of the general DomainTraits class, for the case of SliceRange domain objects
DynamicArray.hDynamic arrays
DynamicArrayOperators.h
DynamicArrays.hA 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.hDynamic Engine
DynamicEvents.hDynamicEvents defines some simple enumerations used as codes to indicate a type of "dynamic event"
DynamicLayout.hDynamicLayout
  • Layout class that breaks dynamically sized 1-dimensional domain into contiguous sub-domains arranged in a 1-dimensional grid
ElementProperties.hTraits class for determining, and possibly modifying, the construction and destruction properties of elements of type T
engine.doxygen
Engine.hEngine
  • Engine<Dim,T,EngineTag> General Engine template
EngineFunctor.hEngineFunctor provides a common interface to a variety of engine queries, like "are you compressed" or "are you shifted with respect to another engine"
EnginePatch.hPatch handling with engines:
  • EnginePatch, functor for getting the nth patch from an engine
EngineTraits.hEvaluatorEngineTraits<EngineTag> associates evaluator types with engine tags
EngineTypeInfo.hUndocumented
EquivSubset.hDomain4 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.hEvaluator evaluates expressions by examining the engines that are participating in the expression and dispatching to custom code
EvaluatorTags.hEvaluator Tags are used for picking the appropriate evaluator given the engines in an expression
ExpressionEngine.hEngine<Dim,T,ExpressionTag<Expr> > (aka Expression-Engine) is the engine that contains a PETE expression and provides all the Array interfaces for it
ExpressionKernel.hAn ExpressionKernel encapsulates evaluating an expression on a domain
ExpressionTraits.hUndocumented
field.doxygen
Field.hTies together the notions of field-category and mesh
FieldCentering.hValue locations within a field's cell
FieldCreateLeaf.hCreateLeaf is used to convert arbitrary classes into expression objects
FieldEngine.ExprEngine.hFieldEngine specialization for expression engine
FieldEngine.hFieldEngine and FieldEngineBaseData classes
FieldEnginePatch.hFunctor for getting the nth patch out of a field
FieldMakeReturn.hMakeFieldReturn is used to combine expressions together with operators
FieldOffset.hRelative cell offset and subfield number
FieldOffsetReduction.h
FieldOperators.h
FieldOperatorSpecializations.hMin()/max() specializations
Fields.hA one-stop-shopping header file that sets up everything one needs to use all POOMA Fields (and, by inclusion of Arrays.h, Arrays)
FieldShiftEngine.hAn engine capable of shifting the contents of a field
FieldStencil.hThis file contains the equipment required to write differential operators that take the form of stencil objects using Fields
FieldTypeInfo.hTypeInfo<> specializations for Field things
FileSetReader.hFileSetReader<Dim> manages the reading of Arrays and Fields from "DiscField" format files
FileSetWriter.hFileSetWriter<Dim> manages the writing of Arrays and Fields from "DiscField" format files
ForEach.h
ForwardingEngine.hA ForwardingEngine is used to forward indices to the elements of another engine
FunctorResult.hFunctorResult<Functor,T>::Type_t is the return type of a pooma functor object
Functors.h
GlobalIDDataBase.hGlobalIDDataBase stores global patch ID's for INodes
GMPArrays.hA one-stop-shopping header file that sets up everything one needs to use GMP-based arrays
Grad.hGradient operator (functor) on discrete Fields
Grad.UR.hGradient operator on Fields, using 2nd-order centered differences These are used by the grad() template function
Grid.hGrid is a general type of integer domain, which refers to a set of points a0, a1,
GridLayout.hLayout with domain breaked into sub-domains specified by a grid
GridPartition.hA layout partitioner that will break a given global domain into blocks specified by a domain Grid
GuardLayers.hA simple container for a set of guard layer specifications
HDF5.hTraits classes for mapping POOMA types to HDF5 objects and wrappers for some HDF5 functions with POOMA style domain specifiers
Header.h
IndexFunctionEngine.hIndex-function-engine objects provide a way to make a function of indices work like an array
Indices.hIota(domain) is a handy function that returns an Array that contains an array of vectors whose elements correspond to index values
IndirectionEngine.hWork in progress!
IndirectionList.hIndirectionList<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.hIndirectionListIterator - Iterates through IndirectionList<T> elements
Inform.hA 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.hInlineEvaluator evaluates expressions by inlining a simple loop
INode.hNode-like class for communicating information regarding intersections of layouts
internal.doxygen
Interpolation.hGeneral template for Interpolator class and Gather/Scatter global function declarations for Particle-Field interpolation
InterpolatorCIC.hSpecialization of Interpolator class template for cloud-in-cell (CIC) interpolation between Particle Attributes and Fields
InterpolatorNGP.hSpecialization of Interpolator class template for nearest-grid-point (NGP) interpolation between Particle Attributes and Fields
InterpolatorSUDS.hSpecialization of Interpolator class template for subtracted dipole scheme (SUDS) interpolation between Particle Attributes and Fields
Intersect.hDomain3 intersect(domain1,domain2) is a global function which determines if two domains intersect with each other, and if so, what their intersection is
IntersectEngine.hIntersectEngine provides a common interface for applying the intersector object to various engines
Intersector.hManaging intersections of engines:
  • Intersector class for managing intersections of engines
Interval.hInterval is a very simple type of domain, which refers to a set of points a, a+1, a+2,
IntervalIterator.hIntervalIterator - Iterates through Interval<1> points
io.doxygen
IsValidLocation.hHelper functions to determine if a particular location or region of a object is defined
IterateScheduler.hTemplates for the scheduler classes
IteratorPairDomain.hIteratorPairDomain<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.hKernel Tags are used for picking the appropriate Kernel given the engines in an expression
KillBC.hA "kill" boundary condition for Particles
layout.doxygen
LayoutBase.hLayoutBase<Dim> and related classes providing domain access
LeftDomain.hLeftDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules
Loc.hLoc<N> is a very simple type of domain, which refers to just one point
LoopApply.hLoopApplyEvaluator 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.hA 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.hMesh functions for querying mesh properties
Messaging.hFunctions and classes needed to support interaction with the cheetah messaging library
MetaProgs.hLoopUtils: Template meta-programs for carrying out certain operations on arrays at compile time
MetaTokenIterator.hMetaTokenIterator is a helper class designed to efficiently parse a line from the "DiscField" .meta file
ModelElement.hA wrapper class used to differentiate overloaded functions
MultiArg.hThe MultiArg1
MultiArgEvaluator.hMultiArgEvaluator is an evaluator that takes a MultiArg object
MultiArgKernel.hMultiArgKernel is a generalized iterate object to hand off to smarts
MultiPatchEngine.hMultiPatch engine:
  • MultiPatch & MultiPatchView tag classes used to select specializations of Engine
  • Engine<Dim,T,MultiPatch> an Engine that manages data stored in an array of PatchEngines
MultiPatchLayoutTraits.hTraits class specifying the layout and layout view types for a particular layout tag
NearestNeighbors.hYields FieldOffsets corresponding to the given parameters
NewDomain.hA set of simple structs which tell how to combine different Domain objects together
Node.hA simple class which stores the following information:
  1. Two domains (the class is templated on the domain type) specifying the owned and allocated domains for the patch
NoInit.hPooma::NoInit tag class
NoMesh.hNoMesh is an extremely lightweight class that indicates a Field cannot answer mesh-type questions
NotifyEngineWrite.hNotifyEngineWrite is a general wrapper class that is used to tell an engine that we're going to write to it
NotifyPreRead.hA tag for telling terms they are about to be read
NullDomain.hNullDomain and ErrorDomain special domains
objects.doxygen
Observable.hA base or wrapper class for an object of type T that needs to allow other objects to 'observe' it
Observer.hAn abstract base class for objects which need to use the observer pattern
ObserverEvent.hObserverEvent class - a base class for all events that will be passed on to observers from observables
One.hA numeric class for a number that is always one
OperatorDescriptor.h
OperatorTags.h
OpMask.hThese classes implement the two argument where
PETE/Tools/Options.h
Utilities/Options.hA simple container class that holds information about how POOMA should be used when it starts up
PackUnpack.hPack(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.hParticleBCType is a tag-like base class for a category of boundary condition applied to an Attribute of a Particles object
ParticleBCItem.hParticleBCItem is an abstract base class for any boundary condition applied to a Particles object
ParticleBCList.hParticleBCList holds a list of ParticleBCItems for the Particles class, storing them in an STL vector of ParticleBCItem pointers
particles.doxygen
Particles/Particles.hThe Particles class is the base class to be used for development of user-defined particles classes that describe application-specific particle populations
Pooma/Particles.hA 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.hPAssert macro, PInsist macro, CTAssert struct, SameType struct
PatchCode.hPatchCode functionality for applying a functor to a patch
PatchFunction.hPatchFunction is mix-in class that encapsulates evaluation of patch-based functors in parallel
PatchKernel.hA PatchKernel encapsulates performing operations on a patch of an expression
PatchSizeSyncer.hPatchSizeSyncer is used to synchronize a set of Grid objects that are used to represent a set of contiguous patches (e.g
PatchSwapLayout.hThese classes define storage and functors for use in implementing particle layout classes that manage particles by swapping them from one patch to another
Paws.hA 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.hA tag for updating leafs in an expression
PeriodicBC.hA periodic boundary condition for a Particles Attribute
PeriodicFaceBC.hUpdater 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.hPooma Extras for the Portable Expression Template Engine
PeteOps.h
PETETypeInfo.h
PETSc.hInterfacing with the PETSc library of (non-)linear solvers
Pool.hA class for maintaining a large chunks of memory and handing out small blocks very quickly
Pooled.hA mixin class for providing fast new and delete
pooma.doxygen
Pooma.hPooma.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.hThe POOMA wrapper around defines, includes, and typedefs for the Smarts run-time evaluation system
PoomaTypeInfo.hA one-stop-shopping header file that sets up everything one needs to use the compile-time type information provided by TypeInfo<>
PositionFunctions.hComputes position locations for Uniform Rectilinear meshes
PosReflectFaceBC.hRelation functor class setting all guard layers beyond a specified (logically) rectilinear mesh face to a positively reflected value
PrintArray.hExtract the elements of an Array and print out the contents to a stream with some nice formatting
PrintField.hExtract the elements of a Field and print out the contents to a stream with some nice formatting
PrintFunctions.h
PrintList.h
PrintOperators.h
Profile.hTAU Profiling
PurifyConstructors.h
Range.hRange is a general type of integer domain, which refers to a set of points a, a+s, a+2s,
RangeIterator.hRangeIterator - Iterates through Range<1> points
RangeMaker.h
RectilinearMesh.hA rectilinear mesh without uniform spacing between vertices
ReduceOverContexts.hReduceOverContexts encapsulates functionality like MPI_Reduce and MPI_Allreduce by means of the ReduceOverContexts::broadcast() method
Reduction.hReduction performs global reductions on expressions by examining the engines that are participating in the expression and dispatching to custom code
ReductionEvaluator.hReductionEvaluator<InlineKernelTag> reduces expressions by inlining a simple loop
ReductionKernel.hA ReductionKernel encapsulates reducing an expression on a domain
Functions/Reductions.hReduction functions for Fields and Arrays
Tiny/Reductions.hGeneral global reduction functions
RefCounted.hRefCounted and Shared classes
RefCountedBlockPtr.hRefCountedBlockPtr and RefBlockController classes
RefCountedPtr.hRefCountedPtr<T> - reference counted pointer-to-T
ReflectBC.hA reflecting boundary condition for a Particles Attribute
Region.hRegion is a general type of continuous domain, which refers to all points between two endpoints a and b
RelationBases.hRelationRetargetBase & RelationBase: the base classes for all relations
RelationGroups.hFunctions supporting relation groups (undocumented)
RelationList.hManages a list of relations
RelationListItem.hUltimate base class for all relation objects
Relations.hRelation basics
RemoteDynamicEngine.hA wrapper engine that remotifies an Engine<1, T, Dynamic>
RemoteEngine.hRemote engine support
RemoteProxy.hThis is like MPI_Bcast
RequestLocks.hClasses and functors that are necessary to request locks on an expression
Resize.h
ReverseBC.hA reversing boundary condition for Particles
RightDomain.hRightDomain is one of the domain wildcards, which are used when constructing other domains using specific combination rules
RNGComponent.hUNSUPPORTED
RNGSimple.hUNSUPPORTED
Runnable.hBase class for a schedulable object or function to be executed by the scheduler asynchronously
Scalar.h
ScalarCode.hUndocumented
ScalarCodeInfo.hScalarCodeInfo contains all the information necessary for evaluating a piece of scalar code on several arguments
Scheduler.hScheduler multiplexing based on configuration
SendReceive.hSendKernel and ReceiveKernel are special iterates that interact with cheetah to send and receive data that gets used in expressions
SerialAsync.hSmarts classes for times when you want no threads but you do want dataflow evaluation
Shrink.hInterval<Dim> shrinking and growing domains
SimpleIntersector.hIntersector that assumes matching layouts
SliceDomain.hSliceDomain is a base class for all sliced domain objects
SliceInterval.hSlice 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.hSlice 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.hStub scheduler for serial in-order evaluation
SparseTileLayout.hSparseTileLayout<Dim>
  • Layout class that tiles a Dim-dimensional bounding box with non-overlaping sub-domains
SpatialLayout.hSpatialLayout<Mesh,FieldLayout> is a particle layout class that is used to determine where particles will be located in a parallel environment
SpatialPartition.hA 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.hVoid split(domain,domain,domain) is a global function which splits the first argument into two separate domains, roughly in the moddle
StaticPool.hA class that manages a static Pool in which the block size is a template parameter
Statistics.hStatistics keeps statistics about a given POOMA job, and can report on a summary of these statistics when asked
Stencil.hStencil objects are a way to build an object which applies a stencil to an array, and returns a new Array for the expression
Tensor.hAn 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.hA simple class with some utility methods used to write test programs
threads.doxygen
TilePartition.hA layout partitioner that will break a given global domain into blocks specified by a domain Tile
tiny.doxygen
Tiny.hA one-stop-shopping header file that sets up everything one needs to use all Pooma II Tiny things
TinyMatrix.hAn interface class for an N-dimensional TinyMatrix of numeric objects, and an engine class for defining a general TinyMatrix
TinyMatrixElements.h
TinyMatrixOperators.h
Touches.hBool touches(domain,domain) is a global function which determines if two domains d1 and d2 overlap in any way
TouchesConstruct.hTouchesConstruct is a factory method that is used to build Nodes and INodes by various layout touches methods
TransformPatch.hUndocumented
TreeNodes.h
tulip.doxygen
TypeComputations.h
TypeInfo.hUndocumented
UMPArrays.hA one-stop-shopping header file that sets up everything one needs to use UMP-based arrays
UnaryTensorOp.h
UnaryTinyMatrixOp.h
UnaryVectorOp.h
UniformGridLayout.hUniformGridLayout<Dim>
  • Layout class that breaks Dim-dimensional domain into equal sized sub-domains arranged in a Dim-dimensional grid
UniformGridPartition.hA 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.hUniformLayout is a very simple particle layout class that is used to determine where particles will be located in a parallel environment
UniformMapper.hUniformMapper is a ContextMapper implementation specifically for 1D patches
UniformRectilinearMesh.hA rectilinear mesh with uniform spacing between vertices
UninitializedVector.hUninitializedVector 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.hA simple utility class which can generate a sequence of unique values
unused.doxygen
UserFunction.hUserFunction 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.hAn 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.hView1<Object,Domain>::Type_t is defined for several Pooma objects, and tells you the type of a(b)
ViewEngine.hGeneralized view engine that can handle intersections for contained multi-patch engines
ViewIndexer.hViewIndexer 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.hWhereProxy is used to implement 2 argument where()
WrapFFTW.h
WrappedInt.hA tag class templated on an integer
Zero.hA numeric class for a number that is always zero

Generated on Wed Mar 16 06:22:48 2011 for FreePOOMA by  doxygen 1.5.9