BaseFabMacros.H

Go to the documentation of this file.

/*   _______              __
    / ___/ /  ___  __ _  / /  ___
   / /__/ _ \/ _ \/  V \/ _ \/ _ \
   \___/_//_/\___/_/_/_/_.__/\___/
*/
// CHOMBO Copyright (c) 2000-2004, The Regents of the University of
// California, through Lawrence Berkeley National Laboratory (subject to
// receipt of any required approvals from U.S. Dept. of Energy).  All
// rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// (2) Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// (3) Neither the name of Lawrence Berkeley National Laboratory, U.S.
// Dept. of Energy nor the names of its contributors may be used to endorse
// or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You are under no obligation whatsoever to provide any bug fixes,
// patches, or upgrades to the features, functionality or performance of
// the source code ("Enhancements") to anyone; however, if you choose to
// make your Enhancements available either publicly, or directly to
// Lawrence Berkeley National Laboratory, without imposing a separate
// written license agreement for such Enhancements, then you hereby grant
// the following license: a non-exclusive, royalty-free perpetual license
// to install, use, modify, prepare derivative works, incorporate into
// other computer software, distribute, and sublicense such Enhancements or
// derivative works thereof, in binary and source code form.
//
// TRADEMARKS. Product and company names mentioned herein may be the
// trademarks of their respective owners.  Any rights not expressly granted
// herein are reserved.
//

#ifndef _BASEFABMACROS_H_
#define _BASEFABMACROS_H_

#include "SPACE.H"

#ifdef DOXYGEN
#define CH_SPACEDIM  1
#endif

#if (CH_SPACEDIM == 1)

#define ForAllThisPencil(T,b,ns,nc)                                     \
{                                                                       \
    CH_assert(contains(b));                                                \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size();                                     \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        T *_th_pp = _th_p                                               \
            + ((_b_lo[0] - _th_plo[0])                                  \
               + _n * _th_plen[0]);                                     \
        T &thisR = * _th_pp;                                            \
        const int thisLen = _b_len[0];                                  \


#define ForAllXBPencil(T,x,b,ns,nc)                                     \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_assert((ns) >= 0 && (ns) + (nc) <= x.nComp());                      \
    const int *_th_plo = x.loVect();                                    \
    const int *_th_plen = x.size();                                     \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size();                                     \
    T* _th_p = x.dataPtr();                                             \
    for (int nR = (ns); nR < (ns)+(nc); ++nR) {                         \
        T * xR = _th_p                                                  \
            + ((_b_lo[0] - _th_plo[0])                                  \
               + nR * _th_plen[0]);                                     \
    const int thisLen = _b_len[0];

#define ForAllThisCPencil(T,b,ns,nc)                                    \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size();                                     \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        const T *_th_pp = _th_p                                         \
            + ((_b_lo[0] - _th_plo[0])                                  \
               + _n * _th_plen[0]);                                     \
        const T &thisR = * _th_pp;                                      \
        const int thisLen = _b_len[0];

#define ForAllXBNN(T,x,b,ns,nc)                                         \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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) {                         \
        const int nR = _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) {               \
            const int iR = _i + _b_lo[0];                               \
            T &x##R = * _x_pp;

// undocumented interface
// Same as ForALLXBNN() except the index variables are not declared.
// Of course, this assumes they aren't used in the loop.
// This exists only for LevelFluxRegister.cpp, to eliminate the annoying
// 'unused variable' compiler warning msgs.
// dbs  Apr2004
#define ForAllXBNNnoindx(T,x,b,ns,nc)                                   \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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 ForAllXCBNN(T,x,b,ns,nc)                                        \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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().getVect();                           \
    const T* _x_p = (x).dataPtr();                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        const T *_x_pp = _x_p                                           \
            + ((_b_lo[0] - _x_plo[0])                                   \
               + _n * _x_plen[0]);                                      \
        for (int _i = 0; _i < _b_len[0]; ++_i) {                        \
            const int iR = _i + _b_lo[0];                               \
            const T & x##R = _x_pp[_i];

#define ForAllThisBNN(T,b,ns,nc)                                        \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        T *_th_pp = _th_p                                               \
            + ((_b_lo[0] - _th_plo[0])                                  \
               + _n * _th_plen[0]);                                     \
        for (int _i = 0; _i < _b_len[0]; ++_i, ++_th_pp) {              \
            int iR = _i + _b_lo[0]; iR += 0;                            \
            T &thisR = * _th_pp;

#define ForAllThisCBNN(T,b,ns,nc)                                       \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        const T *_th_pp = _th_p                                         \
            + ((_b_lo[0] - _th_plo[0])                                  \
               + _n * _th_plen[0]);                                     \
        for (int _i = 0; _i < _b_len[0]; ++_i) {                        \
            const int iR = _i + _b_lo[0];                               \
            const T &thisR = _th_pp[_i];

#define ForAllThisBNNXC(T,b,ns,nc,x,nss)                                \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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();             \
        T* _th_p = dataPtr(ns);                                         \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n; nR += 0;                                       \
            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;                   \
                T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllThisCBNNXC(T,b,ns,nc,x,nss)                               \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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 = this->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 ForAllThisBNNXCBN(T,b,ns,nc,x,bx,nss)                           \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    CH_assert(bx.sameSize((b)));                                           \
    if (!((b).isEmpty())) {                                             \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        const int *_x_plo = (x).loVect();                               \
        const int *_x_plen = (x).size();                                \
        const int *_subbox_lo = (b).loVect();                           \
        const int *_subbox_len = (b).size().getVect();                  \
        const int *_bx_lo = (bx).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n + ns; nR += 0;                                  \
            int n##x##R = _n + nss; n##x##R += 0;                       \
            T *_th_pp = _th_p                                           \
                + ((_subbox_lo[0] - _th_plo[0])                         \
                   + _n * _th_plen[0]);                                 \
            const T *_x_pp = _x_p                                       \
                + ((_bx_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;                   \
                int i##x##R = _i + _bx_lo[0]; i##x##R += 0;             \
                T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllThisBNNXCBNYCBN(T,b,ns,nc,x,bx,nsx,y,by,nsy)              \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    Box _subbox_ = this->box();                                         \
    _subbox_ &= b;                                                      \
    CH_assert((bx).sameSize(_subbox_));                                    \
    CH_assert((by).sameSize(_subbox_));                                    \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        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 *_subbox_lo = _subbox_.loVect();                      \
        const int *_subbox_len = _subbox_.size().getVect();             \
        const int *_bx_lo = (bx).loVect();                              \
        const int *_by_lo = (by).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nsx);                              \
        const T* _y_p  = (y).dataPtr(nsy);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR      = _n + ns;  nR      += 0;                       \
            int n##x##R = _n + nsx; n##x##R += 0;                       \
            int n##y##R = _n + nsy; n##y##R += 0;                       \
            T *_th_pp = _th_p                                           \
                + ((_subbox_lo[0] - _th_plo[0])                         \
                   + _n * _th_plen[0]);                                 \
            const T *_x_pp = _x_p                                       \
                + ((_bx_lo[0] - _x_plo[0])                              \
                   + _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 < _subbox_len[0]; ++_i, ++_th_pp) {     \
                int iR = _i + _subbox_lo[0];  iR += 0;                  \
                int i##x##R = _i + _bx_lo[0]; i##x##R += 0;             \
                int i##y##R = _i + _by_lo[0]; i##y##R += 0;             \
                T &thisR = * _th_pp;                                    \
                const T & x##R = _x_pp[_i];                             \
                const T & y##R = _y_pp[_i];

#define ForAllRevXBNYCBNNN(T,x,bx,nsx,y,by,nsy,nc,ri)                   \
{                                                                       \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    CH_assert((x).contains(bx));                                           \
    CH_assert((y).contains(by));                                           \
    CH_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];

#define EndForTX }}}}

#define EndFor }}}

#define EndForPencil }}

#elif (CH_SPACEDIM == 2)

#define ForAllThisCPencil(T,b,ns,nc)                                    \
{                                                                       \
    CH_assert(contains(b));                                                \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            const T *_th_pp = _th_p                                     \
                + ((_b_lo[0] - _th_plo[0])                              \
                   + _th_plen[0]*(                                      \
                       (jR - _th_plo[1])                                \
                       + _n * _th_plen[1]));                            \
            const T &thisR = * _th_pp;                                  \
            const int thisLen = _b_len[0];

#define ForAllThisPencil(T,b,ns,nc)                                     \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            T *_th_pp = _th_p                                           \
                + ((_b_lo[0] - _th_plo[0])                              \
                   + _th_plen[0]*(                                      \
                       (jR - _th_plo[1])                                \
                       + _n * _th_plen[1]));                            \
            T &thisR = * _th_pp;                                        \
            const int thisLen = _b_len[0];                              \

#define ForAllXBPencil(T,x,b,ns,nc)                                     \
{                                                                       \
    CH_assert((x).contains(b));                                            \
    CH_assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());                    \
    const int *_th_plo = (x).loVect();                                  \
    const int *_th_plen =(x).size();                                    \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = (x) .dataPtr();                                          \
    for (int nR = (ns); nR < (ns)+(nc); ++nR) {                         \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            T *xR = _th_p                                               \
                + ((_b_lo[0] - _th_plo[0])                              \
                   + _th_plen[0]*(                                      \
                       (jR - _th_plo[1])                                \
                       + nR * _th_plen[1]));                            \
            const int thisLen = _b_len[0];                              \

#define ForAllXBNN(T,x,b,ns,nc)                                         \
{                                                                       \
    CH_assert((x).contains(b));                                            \
    CH_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().getVect();                           \
    T* _x_p = (x) .dataPtr();                                           \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            T *_x_pp = _x_p                                             \
                + ((_b_lo[0] - _x_plo[0])                               \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _n * _x_plen[1]));                         \
            for (int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {           \
                const int iR = _i + _b_lo[0];                           \
                T &x##R = * _x_pp;

#define ForAllXBNNnoindx(T,x,b,ns,nc)                                   \
{                                                                       \
    CH_assert((x).contains(b));                                            \
    CH_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().getVect();                           \
    T* _x_p = (x) .dataPtr();                                           \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            T *_x_pp = _x_p                                             \
                + ((_b_lo[0] - _x_plo[0])                               \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _n * _x_plen[1]));                         \
            for (int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {           \
                T &x##R = * _x_pp;

#define ForAllXCBNN(T,x,b,ns,nc)                                        \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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().getVect();                           \
    const T* _x_p = (x).dataPtr();                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            const T *_x_pp = _x_p                                       \
                + ((_b_lo[0] - _x_plo[0])                               \
                       + _x_plen[0]*(                                   \
                           (jR  - _x_plo[1])                            \
                           + _n * _x_plen[1]));                         \
            for (int _i = 0; _i < _b_len[0]; ++_i) {                    \
                const int iR = _i + _b_lo[0];                           \
                const T & x##R = _x_pp[_i];

#define ForAllThisBNN(T,b,ns,nc)                                        \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            T *_th_pp = _th_p                                           \
                + ((_b_lo[0] - _th_plo[0])                              \
                   + _th_plen[0]*(                                      \
                       (jR - _th_plo[1])                                \
                       + _n * _th_plen[1]));                            \
            for (int _i = 0; _i < _b_len[0]; ++_i, ++_th_pp) {          \
                int iR = _i + _b_lo[0]; iR += 0;                        \
                T &thisR = * _th_pp;

#define ForAllThisCBNN(T,b,ns,nc)                                       \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _j = 0; _j < _b_len[1]; ++_j) {                        \
            const int jR = _j + _b_lo[1];                               \
            const T *_th_pp = _th_p                                     \
                + ((_b_lo[0] - _th_plo[0])                              \
                   + _th_plen[0]*(                                      \
                       (_j + _b_lo[1] - _th_plo[1])                     \
                       + _n * _th_plen[1]));                            \
            for (int _i = 0; _i < _b_len[0]; ++_i) {                    \
                const int iR = _i + _b_lo[0];                           \
                const T &thisR = _th_pp[_i];

#define ForAllThisBNNXC(T,b,ns,nc,x,nss)                                \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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();             \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n; nR += 0;                                       \
            for (int _j = 0; _j < _subbox_len[1]; ++_j) {               \
                const int jR = _j + _subbox_lo[1];                      \
                T *_th_pp = _th_p                                       \
                    + ((_subbox_lo[0] - _th_plo[0])                     \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _n * _th_plen[1]));                        \
                const T *_x_pp = _x_p                                   \
                    + ((_subbox_lo[0] - _x_plo[0])                      \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _n * _x_plen[1]));                         \
                for (int _i = 0; _i < _subbox_len[0]; ++_i, ++_th_pp) { \
                    int iR = _i + _subbox_lo[0]; iR += 0;               \
                    T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllThisCBNNXC(T,b,ns,nc,x,nss)                               \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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 = this->dataPtr(ns);                             \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n; nR += 0;                                       \
            for (int _j = 0; _j < _subbox_len[1]; ++_j) {               \
                const int jR = _j + _subbox_lo[1];                      \
                const T *_th_pp = _th_p                                 \
                    + ((_subbox_lo[0] - _th_plo[0])                     \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _n * _th_plen[1]));                        \
                const T *_x_pp = _x_p                                   \
                    + ((_subbox_lo[0] - _x_plo[0])                      \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _n * _x_plen[1]));                         \
                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 ForAllThisBNNXCBN(T,b,ns,nc,x,bx,nss)                           \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    CH_assert(bx.sameSize((b)));                                           \
    if (!((b).isEmpty())) {                                             \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        const int *_x_plo = (x).loVect();                               \
        const int *_x_plen = (x).size();                                \
        const int *_subbox_lo = (b).loVect();                           \
        const int *_subbox_len = (b).size().getVect();                  \
        const int *_bx_lo = (bx).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        int nR = ns; int n##x##R = nss;                                 \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n, ++nR, ++n##x##R ) {           \
            for (int _j = 0; _j < _subbox_len[1]; ++_j) {               \
                const int jR = _j + _subbox_lo[1];                      \
                const int j##x##R = _j + _bx_lo[1];                     \
                T *_th_pp = _th_p                                       \
                    + ((_subbox_lo[0] - _th_plo[0])                     \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _n * _th_plen[1]));                        \
                const T *_x_pp = _x_p                                   \
                    + ((_bx_lo[0] - _x_plo[0])                          \
                       + _x_plen[0]*(                                   \
                           (j##x##R - _x_plo[1])                        \
                           + _n * _x_plen[1]));                         \
                int iR = _subbox_lo[0]; int i##x##R = _bx_lo[0];        \
                for (int _i = 0; _i < _subbox_len[0];                   \
                     ++_i, ++_th_pp, ++_x_pp, ++iR, ++i##x##R) {        \
                    T &thisR = * _th_pp; const T & x##R = * _x_pp;

#define ForAllThisBNNXCBNYCBN(T,b,ns,nc,x,bx,nsx,y,by,nsy)              \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    Box _subbox_ = this->box();                                         \
    _subbox_ &= b;                                                      \
    CH_assert((bx).sameSize(_subbox_));                                    \
    CH_assert((by).sameSize(_subbox_));                                    \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        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 *_subbox_lo = _subbox_.loVect();                      \
        const int *_subbox_len = _subbox_.size().getVect();             \
        const int *_bx_lo = (bx).loVect();                              \
        const int *_by_lo = (by).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nsx);                              \
        const T* _y_p  = (y).dataPtr(nsy);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n + ns; nR += 0;                                  \
            int n##x##R = _n + nsx; n##x##R += 0;                       \
            int n##y##R = _n + nsy; n##y##R += 0;                       \
            for (int _j = 0; _j < _subbox_len[1]; ++_j) {               \
                const int jR = _j + _subbox_lo[1];                      \
                const int j##x##R = _j + _bx_lo[1];                     \
                const int j##y##R = _j + _by_lo[1];                     \
                T *_th_pp = _th_p                                       \
                    + ((_subbox_lo[0] - _th_plo[0])                     \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _n * _th_plen[1]));                        \
                const T *_x_pp = _x_p                                   \
                    + ((_bx_lo[0] - _x_plo[0])                          \
                       + _x_plen[0]*(                                   \
                           (j##x##R - _x_plo[1])                        \
                           + _n * _x_plen[1]));                         \
                const T *_y_pp = _y_p                                   \
                    + ((_by_lo[0] - _y_plo[0])                          \
                       + _y_plen[0]*(                                   \
                           (j##y##R - _y_plo[1])                        \
                           + _n * _y_plen[1]));                         \
                for (int _i = 0; _i < _subbox_len[0]; ++_i, ++_th_pp) { \
                    int iR = _i + _subbox_lo[0];  iR += 0;              \
                    int i##x##R = _i + _bx_lo[0]; i##x##R += 0;         \
                    int i##y##R = _i + _by_lo[0]; i##y##R += 0;         \
                    T &thisR = * _th_pp;                                \
                    const T & x##R = _x_pp[_i];                         \
                    const T & y##R = _y_pp[_i];

#define ForAllRevXBNYCBNNN(T,x,bx,nsx,y,by,nsy,nc,ir)                   \
{                                                                       \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    CH_assert((ir) >= 0 && (ir) < SpaceDim);                               \
    CH_assert((x).contains(bx));                                           \
    CH_assert((y).contains(by));                                           \
    CH_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 *_bx_lo = (bx).loVect();                                  \
    const int *_by_lo = (by).loVect();                                  \
    const int *_len = (bx).size().getVect();                            \
    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;                           \
        for (int _j = 0; _j < _len[1]; ++_j) {                          \
            const int j##x##R = _j + _bx_lo[1];                         \
            const int jrev##x##R = _len[1]-1-_j + _bx_lo[1];            \
            const int j##y##R = _j + _by_lo[1];                         \
            T *_x_pp;                                                   \
            int _ix = 0;                                                \
            int _istrd;                                                 \
            if (ir == 0) {                                              \
                _x_pp = _x_p                                            \
                    + ((_bx_lo[0] - _x_plo[0]) + _len[0] - 1            \
                       + _x_plen[0]*(                                   \
                           (j##x##R - _x_plo[1])                        \
                           + _n * _x_plen[1]));                         \
                _istrd = -1;                                            \
            } else {                                                    \
                _x_pp = _x_p                                            \
                    + ((_bx_lo[0] - _x_plo[0])                          \
                       + _x_plen[0]*(                                   \
                           (jrev##x##R - _x_plo[1])                     \
                           + _n * _x_plen[1]));                         \
                _istrd = 1;                                             \
            }                                                           \
            const T *_y_pp = _y_p                                       \
                    + ((_by_lo[0] - _y_plo[0])                          \
                       + _y_plen[0]*(                                   \
                           (j##y##R - _y_plo[1])                        \
                           + _n * _y_plen[1]));                         \
            int _x_rev = _len[0]-1; _x_rev += 0;                        \
            for (int _i = 0; _i < _len[0]; ++_i, _ix+=_istrd) {         \
                T & x##R = _x_pp[_ix];                                  \
                const T & y##R = _y_pp[_i];

#define EndFor }}}}
#define EndForTX }}}}}
#define EndForPencil }}}

#elif (CH_SPACEDIM == 3)

#define ForAllThisCPencil(T,b,ns,nc)                                    \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                const T *_th_pp = _th_p                                 \
                    + ((_b_lo[0] - _th_plo[0])                          \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _th_plen[1]*(                              \
                               (kR - _th_plo[2])                        \
                               + _n * _th_plen[2])));                   \
                const T &thisR = * _th_pp;                              \
                const int thisLen = _b_len[0];

#define ForAllThisPencil(T,b,ns,nc)                                     \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                T *_th_pp = _th_p                                       \
                    + ((_b_lo[0] - _th_plo[0])                          \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _th_plen[1]*(                              \
                               (kR - _th_plo[2])                        \
                               + _n * _th_plen[2])));                   \
                T &thisR = * _th_pp;                                    \
                const int thisLen = _b_len[0];                          \

#define ForAllXBPencil(T,x,b,ns,nc)                                     \
{                                                                       \
    CH_assert((x).contains(b));                                            \
    CH_assert((ns) >= 0 && (ns) + (nc) <= (x).nComp());                    \
    const int *_th_plo = (x).loVect();                                  \
    const int *_th_plen = (x).size();                                   \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = (x) .dataPtr();                                          \
    for (int nR = (ns); nR < (ns)+(nc); ++nR) {                         \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                T *xR = _th_p                                           \
                    + ((_b_lo[0] - _th_plo[0])                          \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _th_plen[1]*(                              \
                               (kR - _th_plo[2])                        \
                               + nR * _th_plen[2])));                   \
                const int thisLen = _b_len[0];

#define ForAllXBNN(T,x,b,ns,nc)                                         \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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().getVect();                           \
    T* _x_p = (x) .dataPtr();                                           \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                T *_x_pp = _x_p                                         \
                    + ((_b_lo[0] - _x_plo[0])                           \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _x_plen[1]*(                               \
                               (kR - _x_plo[2])                         \
                               + _n * _x_plen[2])));                    \
                for (int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {       \
                    const int iR = _i + _b_lo[0];                       \
                    T &x##R = * _x_pp;

#define ForAllXBNNnoindx(T,x,b,ns,nc)                                   \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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().getVect();                           \
    T* _x_p = (x) .dataPtr();                                           \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                T *_x_pp = _x_p                                         \
                    + ((_b_lo[0] - _x_plo[0])                           \
                       + _x_plen[0]*(                                   \
                           (jR - _x_plo[1])                             \
                           + _x_plen[1]*(                               \
                               (kR - _x_plo[2])                         \
                               + _n * _x_plen[2])));                    \
                for (int _i = 0; _i < _b_len[0]; ++_i, ++_x_pp) {       \
                    T &x##R = * _x_pp;

#define ForAllXCBNN(T,x,b,ns,nc)                                        \
{                                                                       \
    CH_assert(x.contains(b));                                              \
    CH_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().getVect();                           \
    const T* _x_p = (x).dataPtr();                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                const T *_x_pp = _x_p                                   \
                    + ((_b_lo[0] - _x_plo[0])                           \
                       + _x_plen[0]*(                                   \
                           (jR  - _x_plo[1])                            \
                           + _x_plen[1]*(                               \
                               (kR - _x_plo[2])                         \
                               + _n * _x_plen[2])));                    \
                for (int _i = 0; _i < _b_len[0]; ++_i) {                \
                    const int iR = _i + _b_lo[0];                       \
                    const T & x##R = _x_pp[_i];

#define ForAllThisBNN(T,b,ns,nc)                                        \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    T* _th_p = this->m_dptr;                                            \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        int nR = _n; nR += 0;                                           \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                T *_th_pp = _th_p                                       \
                    + ((_b_lo[0] - _th_plo[0])                          \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _th_plen[1]*(                              \
                               (kR - _th_plo[2])                        \
                               + _n * _th_plen[2])));                   \
                for (int _i = 0; _i < _b_len[0]; ++_i, ++_th_pp) {      \
                    int iR = _i + _b_lo[0]; iR += 0;                    \
                    T &thisR = * _th_pp;

#define ForAllThisCBNN(T,b,ns,nc)                                       \
{                                                                       \
    CH_assert(this->contains(b));                                          \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    const int *_th_plo = this->loVect();                                \
    const int *_th_plen = this->size();                                 \
    const int *_b_lo = (b).loVect();                                    \
    const int *_b_len = (b).size().getVect();                           \
    const T* _th_p = this->m_dptr;                                      \
    for (int _n = (ns); _n < (ns)+(nc); ++_n) {                         \
        const int nR = _n;                                              \
        for (int _k = 0; _k < _b_len[2]; ++_k) {                        \
            const int kR = _k + _b_lo[2];                               \
            for (int _j = 0; _j < _b_len[1]; ++_j) {                    \
                const int jR = _j + _b_lo[1];                           \
                const T *_th_pp = _th_p                                 \
                    + ((_b_lo[0] - _th_plo[0])                          \
                       + _th_plen[0]*(                                  \
                           (jR - _th_plo[1])                            \
                           + _th_plen[1]*(                              \
                               (kR - _th_plo[2])                        \
                               + _n * _th_plen[2])));                   \
                for (int _i = 0; _i < _b_len[0]; ++_i) {                \
                    const int iR = _i + _b_lo[0];                       \
                    const T &thisR = _th_pp[_i];

#define ForAllThisBNNXC(T,b,ns,nc,x,nss)                                \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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();             \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n; nR += 0;                                       \
            for (int _k = 0; _k < _subbox_len[2]; ++_k) {               \
                const int kR = _k + _subbox_lo[2];                      \
                for (int _j = 0; _j < _subbox_len[1]; ++_j) {           \
                    const int jR = _j + _subbox_lo[1];                  \
                    T *_th_pp = _th_p                                   \
                        + ((_subbox_lo[0] - _th_plo[0])                 \
                           + _th_plen[0]*(                              \
                               (jR - _th_plo[1])                        \
                               + _th_plen[1]*(                          \
                                   (kR - _th_plo[2])                    \
                                   + _n * _th_plen[2])));               \
                    const T *_x_pp = _x_p                               \
                        + ((_subbox_lo[0] - _x_plo[0])                  \
                           + _x_plen[0]*(                               \
                               (jR - _x_plo[1])                         \
                               + _x_plen[1]*(                           \
                                   (kR - _x_plo[2])                     \
                                   + _n * _x_plen[2])));                \
                    for (int _i = 0; _i < _subbox_len[0];               \
                         ++_i, ++_th_pp) {                              \
                        int iR = _i + _subbox_lo[0]; iR += 0;           \
                        T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllThisCBNNXC(T,b,ns,nc,x,nss)                               \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    Box _subbox_((x).box());                                            \
    _subbox_ &= this->box();                                            \
    _subbox_ &= b;                                                      \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->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 = this->dataPtr(ns);                             \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n; nR += 0;                                       \
            for (int _k = 0; _k < _subbox_len[2]; ++_k) {               \
                const int kR = _k + _subbox_lo[2];                      \
                for (int _j = 0; _j < _subbox_len[1]; ++_j) {           \
                    const int jR = _j + _subbox_lo[1];                  \
                    const T *_th_pp = _th_p                             \
                        + ((_subbox_lo[0] - _th_plo[0])                 \
                           + _th_plen[0]*(                              \
                               (jR - _th_plo[1])                        \
                               + _th_plen[1]*(                          \
                                   (kR - _th_plo[2])                    \
                                   + _n * _th_plen[2])));               \
                    const T *_x_pp = _x_p                               \
                        + ((_subbox_lo[0] - _x_plo[0])                  \
                           + _x_plen[0]*(                               \
                               (jR - _x_plo[1])                         \
                               + _x_plen[1]*(                           \
                                   (kR - _x_plo[2])                     \
                                   + _n * _x_plen[2])));                \
                    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 ForAllThisBNNXCBN(T,b,ns,nc,x,bx,nss)                           \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nss) >= 0 && (nss) + (nc) <= (x).nComp());                  \
    CH_assert((bx).sameSize((b)));                                         \
    if (!((b).isEmpty())) {                                             \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        const int *_x_plo = (x).loVect();                               \
        const int *_x_plen = (x).size();                                \
        const int *_subbox_lo = (b).loVect();                           \
        const int *_subbox_len = (b).size().getVect();                  \
        const int *_bx_lo = (bx).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nss);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n + ns; nR += 0;                                  \
            int n##x##R = _n + nss; n##x##R += 0;                       \
            for (int _k = 0; _k < _subbox_len[2]; ++_k) {               \
                const int kR = _k + _subbox_lo[2];                      \
                const int k##x##R = _k + _bx_lo[2];                     \
                for (int _j = 0; _j < _subbox_len[1]; ++_j) {           \
                    const int jR = _j + _subbox_lo[1];                  \
                    const int j##x##R = _j + _bx_lo[1];                 \
                    T *_th_pp = _th_p                                   \
                        + ((_subbox_lo[0] - _th_plo[0])                 \
                           + _th_plen[0]*(                              \
                               (jR - _th_plo[1])                        \
                               + _th_plen[1]*(                          \
                                   (kR - _th_plo[2])                    \
                                   + _n * _th_plen[2])));               \
                    const T *_x_pp = _x_p                               \
                        + ((_bx_lo[0] - _x_plo[0])                      \
                           + _x_plen[0]*(                               \
                               (j##x##R - _x_plo[1])                    \
                               + _x_plen[1]*(                           \
                                   (k##x##R - _x_plo[2])                \
                                   + _n * _x_plen[2])));                \
                    for (int _i = 0; _i < _subbox_len[0];               \
                         ++_i, ++_th_pp) {                              \
                        int iR = _i + _subbox_lo[0]; iR += 0;           \
                        int i##x##R = _i + _bx_lo[0]; i##x##R += 0;     \
                        T &thisR = * _th_pp; const T & x##R = _x_pp[_i];

#define ForAllThisBNNXCBNYCBN(T,b,ns,nc,x,bx,nsx,y,by,nsy)              \
{                                                                       \
    CH_assert((ns) >= 0 && (ns) + (nc) <= this->nComp());                  \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    Box _subbox_(this->box());                                          \
    _subbox_ &= b;                                                      \
    CH_assert((bx).sameSize(_subbox_));                                    \
    CH_assert((by).sameSize(_subbox_));                                    \
    if (!_subbox_.isEmpty()) {                                          \
        const int *_th_plo = this->loVect();                            \
        const int *_th_plen = this->size();                             \
        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 *_subbox_lo = _subbox_.loVect();                      \
        const int *_subbox_len = _subbox_.size().getVect();             \
        const int *_bx_lo = (bx).loVect();                              \
        const int *_by_lo = (by).loVect();                              \
        T* _th_p = this->dataPtr(ns);                                   \
        const T* _x_p  = (x).dataPtr(nsx);                              \
        const T* _y_p  = (y).dataPtr(nsy);                              \
        for (int _n = 0; _n < (nc); ++_n) {                             \
            int nR = _n + ns; nR += 0;                                  \
            int n##x##R = _n + nsx; n##x##R += 0;                       \
            int n##y##R = _n + nsy; n##y##R += 0;                       \
            for (int _k = 0; _k < _subbox_len[2]; ++_k) {               \
                const int kR = _k + _subbox_lo[2];                      \
                const int k##x##R = _k + _bx_lo[2];                     \
                const int k##y##R = _k + _by_lo[2];                     \
                for (int _j = 0; _j < _subbox_len[1]; ++_j) {           \
                    const int jR = _j + _subbox_lo[1];                  \
                    const int j##x##R = _j + _bx_lo[1];                 \
                    const int j##y##R = _j + _by_lo[1];                 \
                    T *_th_pp = _th_p                                   \
                        + ((_subbox_lo[0] - _th_plo[0])                 \
                           + _th_plen[0]*(                              \
                               (jR - _th_plo[1])                        \
                               + _th_plen[1]*(                          \
                                   (kR - _th_plo[2])                    \
                                   + _n * _th_plen[2])));               \
                    const T *_x_pp = _x_p                               \
                        + ((_bx_lo[0] - _x_plo[0])                      \
                           + _x_plen[0]*(                               \
                               (j##x##R - _x_plo[1])                    \
                               + _x_plen[1]*(                           \
                                   (k##x##R - _x_plo[2])                \
                                   + _n * _x_plen[2])));                \
                    const T *_y_pp = _y_p                               \
                        + ((_by_lo[0] - _y_plo[0])                      \
                           + _y_plen[0]*(                               \
                               (j##y##R - _y_plo[1])                    \
                               + _y_plen[1]*(                           \
                                   (k##y##R - _y_plo[2])                \
                                   + _n * _y_plen[2])));                \
                    for (int _i = 0; _i < _subbox_len[0];               \
                         ++_i, ++_th_pp) {                              \
                        int iR = _i + _subbox_lo[0];  iR += 0;          \
                        int i##x##R = _i + _bx_lo[0]; i##x##R += 0;     \
                        int i##y##R = _i + _by_lo[0]; i##y##R += 0;     \
                        T &thisR = * _th_pp;                            \
                        const T & x##R = _x_pp[_i];                     \
                        const T & y##R = _y_pp[_i];

#define ForAllRevXBNYCBNNN(T,x,bx,nsx,y,by,nsy,nc,ir)                   \
{                                                                       \
    CH_assert((ir) >= 0 && (ir) < SpaceDim);                               \
    CH_assert((nsx) >= 0 && (nsx) + (nc) <= (x).nComp());                  \
    CH_assert((nsy) >= 0 && (nsy) + (nc) <= (y).nComp());                  \
    CH_assert((x).contains(bx));                                           \
    CH_assert((y).contains(by));                                           \
    CH_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 *_bx_lo = (bx).loVect();                                  \
    const int *_by_lo = (by).loVect();                                  \
    const int *_len = (bx).size().getVect();                            \
    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;                           \
        for (int _k = 0; _k < _len[2]; ++_k) {                          \
            const int k##x##R = _k + _bx_lo[2];                         \
            const int krev##x##R = _len[2]-1-_k + _bx_lo[2];            \
            const int k##y##R = _k + _by_lo[2];                         \
            for (int _j = 0; _j < _len[1]; ++_j) {                      \
                const int j##x##R = _j + _bx_lo[1];                     \
                const int jrev##x##R = _len[1]-1-_j + _bx_lo[1];        \
                const int j##y##R = _j + _by_lo[1];                     \
                T *_x_pp;                                               \
                int _ix = 0;                                            \
                int _istrd = 1;                                         \
                if (ir == 0) {                                          \
                    _x_pp = _x_p                                        \
                        + ((_bx_lo[0] - _x_plo[0]) + _len[0]-1          \
                           + _x_plen[0]*(                               \
                               (j##x##R - _x_plo[1])                    \
                               + _x_plen[1]*(                           \
                                   (k##x##R - _x_plo[2])                \
                                   + _n * _x_plen[2])));                \
                    _istrd = -1;                                        \
                } else if (ir == 1) {                                   \
                    _x_pp = _x_p                                        \
                        + ((_bx_lo[0] - _x_plo[0])                      \
                           + _x_plen[0]*(                               \
                               (jrev##x##R - _x_plo[1])                 \
                               + _x_plen[1]*(                           \
                                   (k##x##R - _x_plo[2])                \
                                   + _n * _x_plen[2])));                \
                } else {                                                \
                    _x_pp = _x_p                                        \
                        + ((_bx_lo[0] - _x_plo[0])                      \
                           + _x_plen[0]*(                               \
                               (j##x##R - _x_plo[1])                    \
                               + _x_plen[1]*(                           \
                                   (krev##x##R - _x_plo[2])             \
                                   + _n * _x_plen[2])));                \
                }                                                       \
                const T *_y_pp = _y_p                                   \
                    + ((_by_lo[0] - _y_plo[0])                          \
                       + _y_plen[0]*(                                   \
                           (j##y##R - _y_plo[1])                        \
                           + _y_plen[1]*(                               \
                               (k##y##R - _y_plo[2])                    \
                               + _n * _y_plen[2])));                    \
                for (int _i = 0; _i < _len[0]; ++_i, _ix += _istrd) {   \
                    T & x##R = _x_pp[_ix];                              \
                    const T & y##R = _y_pp[_i];

#define EndFor }}}}}
#define EndForTX }}}}}}
#define EndForPencil }}}}

#endif

#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,this->m_domain,0,this->nComp())

#define ForAllThisC(T)          ForAllThisCBNN(T,this->m_domain,0,this->nComp())

#define ForAllThisB(T,b)        ForAllThisBNN(T,(b),0,this->nComp())

#define ForAllThisCB(T,b)       ForAllThisCBNN(T,(b),0,this->nComp())

#define ForAllThisNN(T,ns,nc)     ForAllThisBNN(T,this->m_domain,ns,nc)

#define ForAllThisXC(T,x)       ForAllThisBNNXC(T,this->m_domain,0,this->nComp(),x,0)

#ifdef DOXYGEN
#undef CH_SPACEDIM
#endif /* Doxygen */

#endif

---