Engine< D, T, StencilEngine< Function, Expression > > Class Template Reference

A specialization of Engine for StencilEngine. More...

#include <Stencil.h>

Collaboration diagram for Engine< D, T, StencilEngine< Function, Expression > >:

Collaboration graph
[legend]

List of all members.

Public Types

enum  { dimensions = D }
enum  { hasDataObject = ExprEngine_t::hasDataObject }
enum  { dynamic = false }
enum  { multiPatch = ExprEngine_t::multiPatch }
enum  { zeroBased = true }
typedef StencilEngine
< Function, Expression
Tag_t
typedef Engine< D, T, Tag_tThis_t
typedef This_t Engine_t
typedef Interval< D > Domain_t
typedef DomainLayout< D > Layout_t
typedef T Element_t
typedef ErrorType ElementRef_t
typedef Expression::Engine_t ExprEngine_t

Public Member Functions

 Engine ()
template<class Layout2 >
 Engine (const Layout2 &layout)
 Engine (const Function &f, const Expression &e)
 Engine (const Function &f, const Expression &e, const Interval< D > &domain)
 Construct StencilEngine from stencil functor, expression and output domain.
template<int Dim, class Tx , class EngineTag >
void initExpressionFromModel (const Array< Dim, Tx, EngineTag > &model)
template<class Mesh , class Tx , class EngineTag >
void initExpressionFromModel (const Field< Mesh, Tx, EngineTag > &model)
This_toperator= (const This_t &model)
const Domain_tdomain () const
Layout_t layout () const
int first (int i) const
Interval< D > viewDomain (const Interval< D > &domain) const
 viewDomain() translates the provided output domain to the appropriate input domain.
INode< D > viewDomain (const INode< D > &inode) const
 viewDomain implementation for INode.
Interval< D > intersectDomain () const
 intersectDomain() gives the "original", unshifted output domain.
const Function & function () const
const Expressionexpression () const
int offset (int d) const
Viewing constructors
template<class OtherE >
 Engine (const Engine< D, T, StencilEngine< Function, OtherE > > &e, const INode< D > &node)
 INode view of a StencilEngine.
 Engine (const Engine_t &e, const Interval< D > &domain)
 Interval view of a StencilEngine.
Indexing
Element_t read (int i) const
Element_t read (int i, int j) const
Element_t read (int i, int j, int k) const
Element_t read (const Loc< 1 > &loc) const
Element_t read (const Loc< 2 > &loc) const
Element_t read (const Loc< 3 > &loc) const
Element_t operator() (int i) const
Element_t operator() (int i, int j) const
Element_t operator() (int i, int j, int k) const


Detailed Description

template<int D, class T, class Function, class Expression>
class Engine< D, T, StencilEngine< Function, Expression > >

A specialization of Engine for StencilEngine.

This does all of the usual Engine things:


Member Typedef Documentation

template<int D, class T , class Function , class Expression >
typedef StencilEngine<Function, Expression> Engine< D, T, StencilEngine< Function, Expression > >::Tag_t

template<int D, class T , class Function , class Expression >
typedef Engine<D, T, Tag_t> Engine< D, T, StencilEngine< Function, Expression > >::This_t

template<int D, class T , class Function , class Expression >
typedef This_t Engine< D, T, StencilEngine< Function, Expression > >::Engine_t

template<int D, class T , class Function , class Expression >
typedef Interval<D> Engine< D, T, StencilEngine< Function, Expression > >::Domain_t

template<int D, class T , class Function , class Expression >
typedef DomainLayout<D> Engine< D, T, StencilEngine< Function, Expression > >::Layout_t

template<int D, class T , class Function , class Expression >
typedef T Engine< D, T, StencilEngine< Function, Expression > >::Element_t

template<int D, class T , class Function , class Expression >
typedef ErrorType Engine< D, T, StencilEngine< Function, Expression > >::ElementRef_t

template<int D, class T , class Function , class Expression >
typedef Expression::Engine_t Engine< D, T, StencilEngine< Function, Expression > >::ExprEngine_t


Member Enumeration Documentation

template<int D, class T , class Function , class Expression >
anonymous enum

Enumerator:
dimensions 

template<int D, class T , class Function , class Expression >
anonymous enum

Enumerator:
hasDataObject 

template<int D, class T , class Function , class Expression >
anonymous enum

Enumerator:
dynamic 

template<int D, class T , class Function , class Expression >
anonymous enum

Enumerator:
multiPatch 

template<int D, class T , class Function , class Expression >
anonymous enum

Enumerator:
zeroBased 


Constructor & Destructor Documentation

template<int D, class T , class Function , class Expression >
Engine< D, T, StencilEngine< Function, Expression > >::Engine (  )  [inline]

template<int D, class T , class Function , class Expression >
template<class Layout2 >
Engine< D, T, StencilEngine< Function, Expression > >::Engine ( const Layout2 &  layout  )  [inline, explicit]

template<int D, class T , class Function , class Expression >
Engine< D, T, StencilEngine< Function, Expression > >::Engine ( const Function &  f,
const Expression e 
) [inline]

References insetDomain().

template<int D, class T , class Function , class Expression >
Engine< D, T, StencilEngine< Function, Expression > >::Engine ( const Function &  f,
const Expression e,
const Interval< D > &  domain 
) [inline]

Construct StencilEngine from stencil functor, expression and output domain.

The output domain specifies the domain the resulting StencilEngine can be indexed with.

template<int D, class T , class Function , class Expression >
template<class OtherE >
Engine< D, T, StencilEngine< Function, Expression > >::Engine ( const Engine< D, T, StencilEngine< Function, OtherE > > &  e,
const INode< D > &  node 
) [inline]

INode view of a StencilEngine.

Apply the view to the expression and update our input domain and offset accordingly.

References INode< Dim >::domain().

template<int D, class T , class Function , class Expression >
Engine< D, T, StencilEngine< Function, Expression > >::Engine ( const Engine_t e,
const Interval< D > &  domain 
) [inline]

Interval view of a StencilEngine.

Adjust domain and offset, but do not apply a view to the expression itself. Note that this means any possible bounds checking will be deferred to later indexing of the engine.


Member Function Documentation

template<int D, class T , class Function , class Expression >
template<int Dim, class Tx , class EngineTag >
void Engine< D, T, StencilEngine< Function, Expression > >::initExpressionFromModel ( const Array< Dim, Tx, EngineTag > &  model  )  [inline]

template<int D, class T , class Function , class Expression >
template<class Mesh , class Tx , class EngineTag >
void Engine< D, T, StencilEngine< Function, Expression > >::initExpressionFromModel ( const Field< Mesh, Tx, EngineTag > &  model  )  [inline]

template<int D, class T , class Function , class Expression >
This_t& Engine< D, T, StencilEngine< Function, Expression > >::operator= ( const This_t model  )  [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( int  i  )  const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( int  i,
int  j 
) const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( int  i,
int  j,
int  k 
) const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( const Loc< 1 > &  loc  )  const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( const Loc< 2 > &  loc  )  const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::read ( const Loc< 3 > &  loc  )  const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::operator() ( int  i  )  const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::operator() ( int  i,
int  j 
) const [inline]

template<int D, class T , class Function , class Expression >
Element_t Engine< D, T, StencilEngine< Function, Expression > >::operator() ( int  i,
int  j,
int  k 
) const [inline]

template<int D, class T , class Function , class Expression >
const Domain_t& Engine< D, T, StencilEngine< Function, Expression > >::domain (  )  const [inline]

template<int D, class T , class Function , class Expression >
Layout_t Engine< D, T, StencilEngine< Function, Expression > >::layout (  )  const [inline]

template<int D, class T , class Function , class Expression >
int Engine< D, T, StencilEngine< Function, Expression > >::first ( int  i  )  const [inline]

References PAssert.

template<int D, class T , class Function , class Expression >
Interval<D> Engine< D, T, StencilEngine< Function, Expression > >::viewDomain ( const Interval< D > &  domain  )  const [inline]

viewDomain() translates the provided output domain to the appropriate input domain.

That is, it returns a domain that should be used in viewing the StencilEngine expression from the domain that was used viewing the StencilEngine itself.

template<int D, class T , class Function , class Expression >
INode<D> Engine< D, T, StencilEngine< Function, Expression > >::viewDomain ( const INode< D > &  inode  )  const [inline]

viewDomain implementation for INode.

References INode< Dim >::domain().

template<int D, class T , class Function , class Expression >
Interval<D> Engine< D, T, StencilEngine< Function, Expression > >::intersectDomain (  )  const [inline]

intersectDomain() gives the "original", unshifted output domain.

That is, the output domain in the notion of the expression domains.

template<int D, class T , class Function , class Expression >
const Function& Engine< D, T, StencilEngine< Function, Expression > >::function (  )  const [inline]

template<int D, class T , class Function , class Expression >
const Expression& Engine< D, T, StencilEngine< Function, Expression > >::expression (  )  const [inline]

template<int D, class T , class Function , class Expression >
int Engine< D, T, StencilEngine< Function, Expression > >::offset ( int  d  )  const [inline]


The documentation for this class was generated from the following file:

Generated on Wed Mar 16 06:20:07 2011 for FreePOOMA by  doxygen 1.5.9