Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Compound Members | File Members

BaseFabMacros.H File Reference

#include "SPACE.H"

Include dependency graph for BaseFabMacros.H:

Include dependency graph

This graph shows which files directly or indirectly include this file:

Included by dependency graph

Go to the source code of this file.

Defines

#define CH_SPACEDIM   1
#define ForAllThisPencil(T, b, ns, nc)
#define ForAllXBPencil(T, x, b, ns, nc)
#define ForAllThisCPencil(T, b, ns, nc)
#define ForAllXBNN(T, x, b, ns, nc)
#define ForAllXBNNnoindx(T, x, b, ns, nc)
#define ForAllXCBNN(T, x, b, ns, nc)
#define ForAllThisBNN(T, b, ns, nc)
#define ForAllThisCBNN(T, b, ns, nc)
#define ForAllThisBNNXC(T, b, ns, nc, x, nss)
#define ForAllThisCBNNXC(T, b, ns, nc, x, nss)
#define ForAllThisBNNXCBN(T, b, ns, nc, x, bx, nss)
#define ForAllThisBNNXCBNYCBN(T, b, ns, nc, x, bx, nsx, y, by, nsy)
#define ForAllRevXBNYCBNNN(T, x, bx, nsx, y, by, nsy, nc, ri)
#define EndForTX   }}}}
#define EndFor   }}}
#define EndForPencil   }}
#define ForAllXPencil(T, x)   ForAllXBPencil(T,x,((x).box()),0,((x).nComp()))
#define ForAllX(T, x)   ForAllXBNN(T,x,((x).box()),0,((x).nComp()))
#define ForAllXC(T, x)   ForAllXCBNN(T,x,((x).box()),0,((x).nComp()))
#define ForAllXB(T, x, b)   ForAllXBNN(T,x,(b),0,(x).nComp())
#define ForAllXBC(T, x, b)   ForAllXCBNN(T,x,(b),0,(x).nComp())
#define ForAllThis(T)   ForAllThisBNN(T,domain,0,nComp())
#define ForAllThisC(T)   ForAllThisCBNN(T,domain,0,nComp())
#define ForAllThisB(T, b)   ForAllThisBNN(T,(b),0,nComp())
#define ForAllThisCB(T, b)   ForAllThisCBNN(T,(b),0,nComp())
#define ForAllThisNN(T, ns, nc)   ForAllThisBNN(T,domain,ns,nc)
#define ForAllThisXC(T, x)   ForAllThisBNNXC(T,domain,0,nComp(),x,0)


Define Documentation

#define CH_SPACEDIM   1
 

#define ForAllXBNNnoindx T,
x,
b,
ns,
nc   ) 
 

Value:

{                                                         \
    assert(x.contains(b));                                \
    assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());      \
    const int *_x_plo = (x).loVect();                     \
    const int *_x_plen = (x).size();                      \
    const int *_b_lo = (b).loVect();                      \
    const int *_b_len = (b).size();                       \
    T* _x_p = (x) .dataPtr();                             \
    for(int _n = (ns); _n < (ns)+(nc); ++_n) {            \
        T *_x_pp = _x_p                                   \
            + ((_b_lo[0] - _x_plo[0])                     \
               + _n * _x_plen[0]);                        \
        for(int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {  \
            T &x##R = * _x_pp;

#define ForAllThisCBNNXC T,
b,
ns,
nc,
x,
nss   ) 
 

Value:

{                                                                       \
    assert((ns) >= 0 && (ns) + (nc) <= nComp());                        \
    assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= box();                                                  \
    _subbox_ &= b;                                                      \
    if(!_subbox_.isEmpty()) {                                           \
        const int *_th_plo = loVect();                                  \
        const int *_th_plen = size();                                   \
        const int *_x_plo = (x).loVect();                               \
        const int *_x_plen = (x).size();                                \
        const int *_subbox_lo = _subbox_.loVect();                      \
        const int *_subbox_len = _subbox_.size().getVect();             \
        const T* _th_p = dataPtr(ns);                                         \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for(int _n = 0; _n < (nc); ++_n) {                              \
            int nR = _n; nR += 0;                                       \
            const T *_th_pp = _th_p                                           \
                + ((_subbox_lo[0] - _th_plo[0])                         \
                   + _n * _th_plen[0]);                                 \
            const T *_x_pp = _x_p                                       \
                + ((_subbox_lo[0] - _x_plo[0])                          \
                   + _n * _x_plen[0]);                                  \
            for(int _i = 0; _i < _subbox_len[0]; ++_i, ++_th_pp) {      \
                int iR = _i + _subbox_lo[0]; iR += 0;                   \
                const T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllRevXBNYCBNNN T,
x,
bx,
nsx,
y,
by,
nsy,
nc,
ri   ) 
 

Value:

{                                                                       \
    assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    assert((x).contains(bx));                                           \
    assert((y).contains(by));                                           \
    assert((bx).sameSize(by));                                          \
    const int *_x_plo = (x).loVect();                                   \
    const int *_x_plen = (x).size();                                    \
    const int *_y_plo = (y).loVect();                                   \
    const int *_y_plen = (y).size();                                    \
    const int *_len = (bx).size().getVect();                            \
    const int *_bx_lo = (bx).loVect();                                  \
    const int *_by_lo = (by).loVect();                                  \
    T* _x_p  = (x).dataPtr(nsx);                                        \
    const T* _y_p  = (y).dataPtr(nsy);                                  \
    for(int _n = 0; _n < (nc); ++_n) {                                  \
        int n##x##R = _n + nsx; n##x##R += 0;                           \
        int n##y##R = _n + nsy; n##y##R += 0;                           \
        int _ix = 0;                                                    \
        T *_x_pp = _x_p                                                 \
            + ((_bx_lo[0] - _x_plo[0]) + _len[0] - 1                    \
                + _n * _x_plen[0]);                                     \
        const T *_y_pp = _y_p                                           \
            + ((_by_lo[0] - _y_plo[0])                                  \
                + _n * _y_plen[0]);                                     \
        for(int _i = 0; _i < _len[0]; ++_i, --_ix) {                    \
            T & x##R = _x_pp[_ix];                                      \
            const T & y##R = _y_pp[_i];


Generated on Fri Jul 2 17:53:57 2004 for Chombo by doxygen 1.3.2