multiGridDataProcessorWrapper2D.hh

00001 /* This file is part of the Palabos library.
00002  *
00003  * Copyright (C) 2011 FlowKit Sarl
00004  * Avenue de Chailly 23
00005  * 1012 Lausanne, Switzerland
00006  * E-mail contact: contact@flowkit.com
00007  *
00008  * The most recent release of Palabos can be downloaded at 
00009  * <http://www.palabos.org/>
00010  *
00011  * The library Palabos is free software: you can redistribute it and/or
00012  * modify it under the terms of the GNU Affero General Public License as
00013  * published by the Free Software Foundation, either version 3 of the
00014  * License, or (at your option) any later version.
00015  *
00016  * The library is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU Affero General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU Affero General Public License
00022  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00023 */
00024 
00025 /* Main author: Daniel Lagrava
00026  **/
00027 
00028 
00029 #ifndef MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_HH
00030 #define MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_HH
00031 
00032 #include "multiGrid/multiGridDataProcessorWrapper2D.h"
00033 #include "multiGrid/multiGridLattice2D.h"
00034 #include "multiGrid/multiGridDataField2D.h"
00035 #include "multiGrid/multiGridOperations2D.h"
00036 
00037 namespace plb {
00038 
00039 /* *************** LatticeBoxProcessing2D ****************************************** */
00040 
00041 template<typename T, template<typename U> class Descriptor>
00042 void applyProcessingFunctional (
00043         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00044         Box2D domain,
00045         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel )
00046 {
00047     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00048     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00049         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00050     }
00051     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), multiBlocks, referenceLevel );
00052 }
00053 
00054 template<typename T, template<typename U> class Descriptor>
00055 void integrateProcessingFunctional (
00056         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00057         Box2D domain,
00058         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel, plint level )
00059 {
00060     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00061     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00062         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00063     }
00064     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00065                           multiBlocks, referenceLevel, level );
00066 }
00067 
00068 
00069 /* *************** MultiScalarFieldBoxProcessing2D ******************************* */
00070 
00071 template<typename T>
00072 void applyProcessingFunctional(ScalarFieldBoxProcessingFunctional2D<T>* functional,
00073                                Box2D domain,
00074                                std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel )
00075 {
00076     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00077     for (pluint iField=0; iField<fields.size(); ++iField) {
00078         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00079     }
00080     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), multiBlocks, referenceLevel );
00081 }
00082 
00083 template<typename T>
00084 void integrateProcessingFunctional(ScalarFieldBoxProcessingFunctional2D<T>* functional,
00085                                    Box2D domain,
00086                                    std::vector<MultiGridScalarField2D<T>*> fields, 
00087                                    plint referenceLevel, plint level )
00088 {
00089     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00090     for (pluint iField=0; iField<fields.size(); ++iField) {
00091         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00092     }
00093     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00094                           multiBlocks, referenceLevel, level );
00095 }
00096 
00097 
00098 /* *************** TensorFieldBoxProcessing2D ******************************* */
00099 
00100 template<typename T, int nDim>
00101 void applyProcessingFunctional (
00102         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00103         Box2D domain,
00104         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel )
00105 {
00106     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00107     for (pluint iField=0; iField<fields.size(); ++iField) {
00108         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00109     }
00110     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), multiBlocks, referenceLevel );
00111 }
00112 
00113 template<typename T, int nDim>
00114 void integrateProcessingFunctional (
00115         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00116         Box2D domain,
00117         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel, plint level )
00118 {
00119     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00120     for (pluint iField=0; iField<fields.size(); ++iField) {
00121         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00122     }
00123     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00124                           multiBlocks, referenceLevel, level );
00125 }
00126 
00127 /* *************** BoxProcessing2D_L ******************************************* */
00128 
00129 template<typename T, template<typename U> class Descriptor>
00130 void applyProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00131                                Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel)
00132 {
00133     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), lattice, referenceLevel );
00134 }
00135 
00136 template<typename T, template<typename U> class Descriptor>
00137 void integrateProcessingFunctional (
00138         BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00139         Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel, plint level )
00140 {
00141     addInternalProcessor( BoxProcessorGenerator2D(functional, domain), lattice, referenceLevel, level );
00142 }
00143 
00144 
00145 /* *************** BoxProcessing2D_S ******************************************* */
00146 
00147 template<typename T>
00148 void applyProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00149                                Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel)
00150 {
00151     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), field, referenceLevel );
00152 }
00153 
00154 template<typename T>
00155 void integrateProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00156                                    Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel, plint level)
00157 {
00158     addInternalProcessor( BoxProcessorGenerator2D(functional, domain), field, referenceLevel, level );
00159 }
00160 
00161 
00162 /* *************** BoxProcessing2D_T ******************************************* */
00163 
00164 template<typename T, int nDim>
00165 void applyProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00166                                Box2D domain, MultiGridTensorField2D<T,nDim>& field, plint referenceLevel)
00167 {
00168     executeDataProcessor( BoxProcessorGenerator2D(functional, domain), field, referenceLevel );
00169 }
00170 
00171 template<typename T, int nDim>
00172 void integrateProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00173                                    Box2D domain, MultiGridTensorField2D<T,nDim>& field, 
00174                                    plint referenceLevel, plint level)
00175 {
00176     addInternalProcessor( BoxProcessorGenerator2D(functional, domain), field, referenceLevel, level );
00177 }
00178 
00179 
00180 /* *************** BoxProcessing2D_LL******************************************* */
00181 
00182 template<typename T1, template<typename U1> class Descriptor1,
00183          typename T2, template<typename U2> class Descriptor2>
00184 void applyProcessingFunctional (
00185         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00186         Box2D domain,
00187         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00188         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel )
00189 {
00190     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00191                           lattice1, lattice2, referenceLevel );
00192 }
00193 
00194 template<typename T1, template<typename U1> class Descriptor1,
00195          typename T2, template<typename U2> class Descriptor2>
00196 void integrateProcessingFunctional (
00197         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional, Box2D domain,
00198         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00199         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel, plint level )
00200 {
00201     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00202                           lattice1, lattice2, referenceLevel, level );
00203 }
00204 
00205 
00206 
00207 
00208 /* *************** BoxProcessing2D_SS ****************************************** */
00209 
00210 template<typename T1, typename T2>
00211 void applyProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00212                                Box2D domain,
00213                                MultiGridScalarField2D<T1>& field1,
00214                                MultiGridScalarField2D<T2>& field2, plint referenceLevel )
00215 {
00216     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00217                           field1, field2, referenceLevel );
00218 }
00219 
00220 template<typename T1, typename T2>
00221 void integrateProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00222                                    Box2D domain,
00223                                    MultiGridScalarField2D<T1>& field1,
00224                                    MultiGridScalarField2D<T2>& field2, 
00225                                    plint referenceLevel, plint level)
00226 {
00227     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00228                           field1, field2, referenceLevel, level );
00229 }
00230 
00231 
00232 /* *************** BoxProcessing2D_TT ****************************************** */
00233 
00234 template<typename T1, int nDim1, typename T2, int nDim2>
00235 void applyProcessingFunctional (
00236         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00237         Box2D domain,
00238         MultiGridTensorField2D<T1,nDim1>& field1,
00239         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel )
00240 {
00241     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00242                           field1, field2, referenceLevel );
00243 }
00244 
00245 template<typename T1, int nDim1, typename T2, int nDim2>
00246 void integrateProcessingFunctional (
00247         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00248         Box2D domain,
00249         MultiGridTensorField2D<T1,nDim1>& field1,
00250         MultiGridTensorField2D<T2,nDim2>& field2,
00251         plint referenceLevel, plint level)
00252 {
00253     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00254                           field1, field2, referenceLevel, level );
00255 }
00256 
00257 /* *************** BoxProcessing2D_ST ****************************************** */
00258 
00259 template<typename T1, typename T2, int nDim>
00260 void applyProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00261                                Box2D domain,
00262                                MultiGridScalarField2D<T1>& field1,
00263                                MultiGridTensorField2D<T2,nDim>& field2, 
00264                                plint referenceLevel )
00265 {
00266     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00267                           field1, field2, referenceLevel );
00268 }
00269 
00270 template<typename T1, typename T2, int nDim>
00271 void integrateProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00272                                    Box2D domain,
00273                                    MultiGridScalarField2D<T1>& field1,
00274                                    MultiGridTensorField2D<T2,nDim>& field2, 
00275                                    plint referenceLevel, plint level)
00276 {
00277     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00278                           field1, field2, referenceLevel, level );
00279 }
00280 
00281 
00282 /* *************** BoxProcessing2D_LS ****************************************** */
00283 
00284 template<typename T1, template<typename U> class Descriptor, typename T2>
00285 void applyProcessingFunctional (
00286         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00287         Box2D domain,
00288         MultiGridLattice2D<T1,Descriptor>& lattice,
00289         MultiGridScalarField2D<T2>& field, plint referenceLevel )
00290 {
00291     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00292                           lattice, field, referenceLevel );
00293 }
00294 
00295 template<typename T1, template<typename U> class Descriptor, typename T2>
00296 void integrateProcessingFunctional (
00297         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00298         Box2D domain,
00299         MultiGridLattice2D<T1,Descriptor>& lattice,
00300         MultiGridScalarField2D<T2>& field, plint referenceLevel, plint level )
00301 {
00302     addInternalProcessor( BoxProcessorGenerator2D(functional, domain),
00303                           lattice, field, referenceLevel, level );
00304 }
00305 
00306 
00307 /* *************** BoxProcessing2D_LT ****************************************** */
00308 
00309 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00310 void applyProcessingFunctional (
00311         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00312         Box2D domain,
00313         MultiGridLattice2D<T1,Descriptor>& lattice,
00314         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel )
00315 {
00316     executeDataProcessor( BoxProcessorGenerator2D(functional, domain),
00317                           lattice, field, referenceLevel );
00318 }
00319 
00320 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00321 void integrateProcessingFunctional (
00322         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00323         Box2D domain,
00324         MultiGridLattice2D<T1,Descriptor>& lattice,
00325         MultiGridTensorField2D<T2,nDim>& field, 
00326         plint referenceLevel, plint level )
00327 {
00328     addInternalProcessor( BoxProcessorGenerator3D(functional, domain),
00329                           lattice, field, referenceLevel, level );
00330 }
00331 
00332 
00333 /* *************** LatticeDotProcessing2D ****************************************** */
00334 
00335 template<typename T, template<typename U> class Descriptor>
00336 void applyProcessingFunctional (
00337         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00338         DotList2D const& dotList,
00339         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel )
00340 {
00341     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00342     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00343         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00344     }
00345     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), multiBlocks, referenceLevel );
00346 }
00347 
00348 
00349 template<typename T, template<typename U> class Descriptor>
00350 void integrateProcessingFunctional (
00351         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00352         DotList2D const& dotList,
00353         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, 
00354         plint referenceLevel, plint level )
00355 {
00356     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00357     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00358         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00359     }
00360     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00361                           multiBlocks, referenceLevel, level );
00362 }
00363 
00364 
00365 /* *************** ScalarFieldDotProcessing2D ****************************************** */
00366 
00367 template<typename T>
00368 void applyProcessingFunctional(ScalarFieldDotProcessingFunctional2D<T>* functional,
00369                                DotList2D const& dotList,
00370                                std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel )
00371 {
00372     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00373     for (pluint iField=0; iField<fields.size(); ++iField) {
00374         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00375     }
00376     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), multiBlocks, referenceLevel );
00377 }
00378 
00379 
00380 template<typename T>
00381 void integrateProcessingFunctional(ScalarFieldDotProcessingFunctional2D<T>* functional,
00382                                    DotList2D const& dotList,
00383                                    std::vector<MultiGridScalarField2D<T>*> fields, 
00384                                    plint referenceLevel, plint level )
00385 {
00386     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00387     for (pluint iField=0; iField<fields.size(); ++iField) {
00388         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00389     }
00390     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00391                           multiBlocks, referenceLevel, level );
00392 }
00393 
00394 
00395 /* *************** TensorFieldDotProcessing2D ****************************************** */
00396 
00397 template<typename T, int nDim>
00398 void applyProcessingFunctional (
00399         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00400         DotList2D const& dotList,
00401         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel )
00402 {
00403     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00404     for (pluint iField=0; iField<fields.size(); ++iField) {
00405         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00406     }
00407     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), multiBlocks, referenceLevel );
00408 }
00409 
00410 template<typename T, int nDim>
00411 void integrateProcessingFunctional (
00412         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00413         DotList2D const& dotList,
00414         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel, plint level )
00415 {
00416     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00417     for (pluint iField=0; iField<fields.size(); ++iField) {
00418         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00419     }
00420     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00421                           multiBlocks, referenceLevel, level );
00422 }
00423 
00424 /* *************** DotProcessing2D_L ******************************************* */
00425 
00426 template<typename T, template<typename U> class Descriptor>
00427 void applyProcessingFunctional(DotProcessingFunctional2D_L<T,Descriptor>* functional,
00428                                DotList2D const& dotList,
00429                                MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel)
00430 {
00431     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), lattice, referenceLevel );
00432 }
00433 
00434 template<typename T, template<typename U> class Descriptor>
00435 void integrateProcessingFunctional(DotProcessingFunctional2D_L<T,Descriptor>* functional,
00436                                    DotList2D const& dotList,
00437                                    MultiGridLattice2D<T,Descriptor>& lattice,
00438                                    plint referenceLevel, plint level)
00439 {
00440     addInternalProcessor( DotProcessorGenerator2D(functional, dotList), lattice, referenceLevel, level );
00441 }
00442 
00443 
00444 /* *************** DotProcessing2D_S ******************************************* */
00445 
00446 template<typename T>
00447 void applyProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00448                                DotList2D const& dotList, MultiGridScalarField2D<T>& field, plint referenceLevel)
00449 {
00450     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), field, referenceLevel );
00451 }
00452 
00453 template<typename T>
00454 void integrateProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00455                                    DotList2D const& dotList, MultiGridScalarField2D<T>& field, 
00456                                    plint referenceLevel, plint level)
00457 {
00458     addInternalProcessor( DotProcessorGenerator2D(functional, dotList), field, referenceLevel, level );
00459 }
00460 
00461 
00462 /* *************** DotProcessing2D_T ******************************************* */ 
00463 template<typename T, int nDim>
00464 void applyProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00465                                DotList2D const& dotList,
00466                                MultiGridTensorField2D<T,nDim>& field, plint referenceLevel)
00467 {
00468     executeDataProcessor( DotProcessorGenerator2D(functional, dotList), field, referenceLevel );
00469 }
00470 
00471 template<typename T, int nDim>
00472 void integrateProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00473                                    DotList2D const& dotList,
00474                                    MultiGridTensorField2D<T,nDim>& field,
00475                                    plint referenceLevel, plint level)
00476 {
00477     addInternalProcessor( DotProcessorGenerator2D(functional, dotList), field, referenceLevel, level );
00478 }
00479 
00480 
00481 /* *************** DotProcessing2D_LL******************************************* */
00482 
00483 template<typename T1, template<typename U1> class Descriptor1,
00484          typename T2, template<typename U2> class Descriptor2>
00485 void applyProcessingFunctional (
00486         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00487         DotList2D const& dotList,
00488         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00489         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel )
00490 {
00491     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00492                           lattice1, lattice2, referenceLevel );
00493 }
00494 
00495 template<typename T1, template<typename U1> class Descriptor1,
00496          typename T2, template<typename U2> class Descriptor2>
00497 void integrateProcessingFunctional (
00498         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00499         DotList2D const& dotList,
00500         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00501         MultiGridLattice2D<T2,Descriptor2>& lattice2, 
00502         plint referenceLevel, plint level )
00503 {
00504     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00505                           lattice1, lattice2, referenceLevel, level );
00506 }
00507 
00508 
00509 /* *************** DotProcessing2D_SS ****************************************** */
00510 
00511 template<typename T1, typename T2>
00512 void applyProcessingFunctional (
00513         DotProcessingFunctional2D_SS<T1,T2>* functional,
00514         DotList2D const& dotList,
00515         MultiGridScalarField2D<T1>& field1,
00516         MultiGridScalarField2D<T2>& field2, plint referenceLevel )
00517 {
00518     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00519                           field1, field2, referenceLevel );
00520 }
00521 
00522 template<typename T1, typename T2>
00523 void integrateProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00524                                    DotList2D const& dotList,
00525                                    MultiGridScalarField2D<T1>& field1,
00526                                    MultiGridScalarField2D<T2>& field2, 
00527                                    plint referenceLevel, plint level)
00528 {
00529     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00530                           field1, field2, referenceLevel, level );
00531 }
00532 
00533 
00534 /* *************** DotProcessing2D_TT ****************************************** */
00535 
00536 template<typename T1, int nDim1, typename T2, int nDim2>
00537 void applyProcessingFunctional (
00538         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00539         DotList2D const& dotList,
00540         MultiGridTensorField2D<T1,nDim1>& field1,
00541         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel )
00542 {
00543     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00544                           field1, field2, referenceLevel );
00545 }
00546 
00547 template<typename T1, int nDim1, typename T2,  int nDim2>
00548 void integrateProcessingFunctional (
00549         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00550         DotList2D const& dotList,
00551         MultiGridTensorField2D<T1,nDim1>& field1,
00552         MultiGridTensorField2D<T2,nDim2>& field2,
00553         plint referenceLevel, plint level )
00554 {
00555     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00556                           field1, field2, referenceLevel, level );
00557 }
00558 
00559 
00560 /* *************** DotProcessing2D_ST ****************************************** */
00561 
00562 template<typename T1, typename T2, int nDim>
00563 void applyProcessingFunctional(DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00564                                DotList2D const& dotList,
00565                                MultiGridScalarField2D<T1>& field1,
00566                                MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel )
00567 {
00568     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00569                           field1, field2, referenceLevel );
00570 }
00571 
00572 template<typename T1, typename T2, int nDim>
00573 void integrateProcessingFunctional(DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00574                                    DotList2D const& dotList,
00575                                    MultiGridScalarField2D<T1>& field1,
00576                                    MultiGridTensorField2D<T2,nDim>& field2,
00577                                    plint referenceLevel, plint level)
00578 {
00579     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00580                           field1, field2, referenceLevel, level );
00581 }
00582 
00583 
00584 /* *************** DotProcessing2D_LS ****************************************** */
00585 
00586 template<typename T1, template<typename U> class Descriptor, typename T2>
00587 void applyProcessingFunctional (
00588         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00589         DotList2D const& dotList,
00590         MultiGridLattice2D<T1,Descriptor>& lattice,
00591         MultiGridScalarField2D<T2>& field, plint referenceLevel )
00592 {
00593     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00594                           lattice, field, referenceLevel );
00595 }
00596 
00597 template<typename T1, template<typename U> class Descriptor, typename T2>
00598 void integrateProcessingFunctional (
00599         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00600         DotList2D const& dotList,
00601         MultiGridLattice2D<T1,Descriptor>& lattice,
00602         MultiGridScalarField2D<T2>& field, plint referenceLevel, plint level )
00603 {
00604     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00605                           lattice, field, referenceLevel, level );
00606 }
00607 
00608 
00609 /* *************** DotProcessing2D_LT ****************************************** */
00610 
00611 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00612 void applyProcessingFunctional (
00613         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00614         DotList2D const& dotList,
00615         MultiGridLattice2D<T1,Descriptor>& lattice,
00616         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel )
00617 {
00618     executeDataProcessor( DotProcessorGenerator2D(functional, dotList),
00619                           lattice, field, referenceLevel );
00620 }
00621 
00622 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00623 void integrateProcessingFunctional (
00624         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00625         DotList2D const& dotList,
00626         MultiGridLattice2D<T1,Descriptor>& lattice,
00627         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel, plint level)
00628 {
00629     addInternalProcessor( DotProcessorGenerator2D(functional, dotList),
00630                           lattice, field, referenceLevel, level );
00631 }
00632 
00633 /* *************** BoundedLatticeBoxProcessing2D **************************** */
00634 
00635 template<typename T, template<typename U> class Descriptor>
00636 void applyProcessingFunctional (
00637         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00638         Box2D domain,
00639         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, 
00640         plint referenceLevel, plint boundaryWidth )
00641 {
00642     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00643     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00644         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00645     }
00646     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00647 }
00648 
00649 template<typename T, template<typename U> class Descriptor>
00650 void integrateProcessingFunctional (
00651         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00652         Box2D domain,
00653         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel,
00654         plint boundaryWidth, plint level )
00655 {
00656     std::vector<MultiGrid2D*> multiBlocks(lattices.size());
00657     for (pluint iLattice=0; iLattice<lattices.size(); ++iLattice) {
00658         multiBlocks[iLattice] = dynamic_cast<MultiGrid2D*>(lattices[iLattice]);
00659     }
00660     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00661                                   boundaryWidth, level);
00662 }
00663 
00664 
00665 /* *************** BoundedMultiScalarFieldBoxProcessing2D ************************ */
00666 
00667 template<typename T>
00668 void applyProcessingFunctional (
00669         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00670         Box2D domain,
00671         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel,
00672         plint boundaryWidth )
00673 {
00674     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00675     for (pluint iField=0; iField<fields.size(); ++iField) {
00676         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00677     }
00678     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00679 }
00680 
00681 template<typename T>
00682 void integrateProcessingFunctional (
00683         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00684         Box2D domain,
00685         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel, 
00686         plint boundaryWidth, plint level )
00687 {
00688     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00689     for (pluint iField=0; iField<fields.size(); ++iField) {
00690         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00691     }
00692     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00693                                   boundaryWidth, level);
00694 }
00695 
00696 
00697 /* *************** BoundedTensorFieldBoxProcessing2D ************************ */
00698 
00699 template<typename T, int nDim>
00700 void applyProcessingFunctional (
00701         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00702         Box2D domain,
00703         std::vector<MultiGridTensorField2D<T,nDim>*> fields, 
00704         plint referenceLevel, plint boundaryWidth )
00705 {
00706     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00707     for (pluint iField=0; iField<fields.size(); ++iField) {
00708         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00709     }
00710     applyProcessingFunctional(functional, domain,
00711                               multiBlocks, referenceLevel, boundaryWidth);
00712 }
00713 
00714 template<typename T, int nDim>
00715 void integrateProcessingFunctional (
00716         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00717         Box2D domain,
00718         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel,
00719         plint boundaryWidth, plint level )
00720 {
00721     std::vector<MultiGrid2D*> multiBlocks(fields.size());
00722     for (pluint iField=0; iField<fields.size(); ++iField) {
00723         multiBlocks[iField] = dynamic_cast<MultiGrid2D*>(fields[iField]);
00724     }
00725     integrateProcessingFunctional(functional, domain,
00726                                   multiBlocks, referenceLevel, boundaryWidth, level);
00727 }
00728 
00729 /* *************** BoundedBoxProcessing2D_L ********************************* */
00730 
00731 template<typename T, template<typename U> class Descriptor>
00732 void applyProcessingFunctional (
00733         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00734         Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel, plint boundaryWidth )
00735 {
00736     std::vector<MultiGrid2D*> multiBlocks(1);
00737     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00738     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00739 }
00740 
00741 template<typename T, template<typename U> class Descriptor>
00742 void integrateProcessingFunctional (
00743         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00744         Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel,
00745         plint boundaryWidth, plint level )
00746 {
00747     std::vector<MultiGrid2D*> multiBlocks(1);
00748     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00749     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel, 
00750                                   boundaryWidth, level);
00751 }
00752 
00753 
00754 /* *************** BoundedBoxProcessing2D_S ********************************* */
00755 
00756 template<typename T>
00757 void applyProcessingFunctional (
00758         BoundedBoxProcessingFunctional2D_S<T>* functional,
00759         Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel, plint boundaryWidth )
00760 {
00761     std::vector<MultiGrid2D*> multiBlocks(1);
00762     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field);
00763     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00764 }
00765 
00766 template<typename T>
00767 void integrateProcessingFunctional (
00768         BoundedBoxProcessingFunctional2D_S<T>* functional,
00769         Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel,
00770         plint boundaryWidth, plint level )
00771 {
00772     std::vector<MultiGrid2D*> multiBlocks(1);
00773     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field);
00774     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00775                                   boundaryWidth, level);
00776 }
00777 
00778 
00779 /* *************** BoundedBoxProcessing2D_T ********************************* */
00780 
00781 template<typename T, int nDim>
00782 void applyProcessingFunctional (
00783         BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00784         Box2D domain, MultiGridTensorField2D<T,nDim>& field, plint referenceLevel, plint boundaryWidth )
00785 {
00786     std::vector<MultiGrid2D*> multiBlocks(1);
00787     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field);
00788     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00789 }
00790 
00791 template<typename T, int nDim>
00792 void integrateProcessingFunctional (
00793         BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00794         Box2D domain, MultiGridTensorField2D<T,nDim>& field, plint referenceLevel,
00795         plint boundaryWidth, plint level )
00796 {
00797     std::vector<MultiGrid2D*> multiBlocks(1);
00798     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field);
00799     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00800                                   boundaryWidth, level);
00801 }
00802 
00803 
00804 /* *************** BoundedBoxProcessing2D_LL********************************* */
00805 
00806 template<typename T1, template<typename U1> class Descriptor1,
00807          typename T2, template<typename U2> class Descriptor2>
00808 void applyProcessingFunctional (
00809         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00810         Box2D domain,
00811         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00812         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel,
00813         plint boundaryWidth )
00814 {
00815     std::vector<MultiGrid2D*> multiBlocks(2);
00816     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice1);
00817     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&lattice2);
00818     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00819 }
00820 
00821 template<typename T1, template<typename U1> class Descriptor1,
00822          typename T2, template<typename U2> class Descriptor2>
00823 void integrateProcessingFunctional (
00824         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00825         Box2D domain,
00826         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00827         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel,
00828         plint boundaryWidth, plint level )
00829 {
00830     std::vector<MultiGrid2D*> multiBlocks(2);
00831     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice1);
00832     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&lattice2);
00833     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00834                                   boundaryWidth, level);
00835 }
00836 
00837 
00838 /* *************** BoundedBoxProcessing2D_SS ****************************************** */
00839 
00840 template<typename T1, typename T2>
00841 void applyProcessingFunctional (
00842         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00843         Box2D domain,
00844         MultiGridScalarField2D<T1>& field1,
00845         MultiGridScalarField2D<T2>& field2, plint referenceLevel,
00846         plint boundaryWidth )
00847 {
00848     std::vector<MultiGrid2D*> multiBlocks(2);
00849     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00850     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00851     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00852 }
00853 
00854 template<typename T1, typename T2>
00855 void integrateProcessingFunctional (
00856         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00857         Box2D domain,
00858         MultiGridScalarField2D<T1>& field1,
00859         MultiGridScalarField2D<T2>& field2, plint referenceLevel,
00860         plint boundaryWidth, plint level )
00861 {
00862     std::vector<MultiGrid2D*> multiBlocks(2);
00863     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00864     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00865     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00866                                   boundaryWidth, level);
00867 }
00868 
00869 /* *************** BoundedBoxProcessing2D_TT ********************************** */
00870 
00871 template<typename T1, int nDim1, typename T2, int nDim2>
00872 void applyProcessingFunctional (
00873         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00874         Box2D domain,
00875         MultiGridTensorField2D<T1,nDim1>& field1,
00876         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel,
00877         plint boundaryWidth )
00878 {
00879     std::vector<MultiGrid2D*> multiBlocks(2);
00880     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00881     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00882     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00883 }
00884 
00885 template<typename T1, int nDim1, typename T2, int nDim2>
00886 void integrateProcessingFunctional (
00887         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00888         Box2D domain,
00889         MultiGridTensorField2D<T1,nDim1>& field1,
00890         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel,
00891         plint boundaryWidth, plint level )
00892 {
00893     std::vector<MultiGrid2D*> multiBlocks(2);
00894     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00895     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00896     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00897                                   boundaryWidth, level);
00898 }
00899 
00900 
00901 /* *************** BoundedBoxProcessing2D_ST ******************************** */
00902 
00903 template<typename T1, typename T2, int nDim>
00904 void applyProcessingFunctional (
00905         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00906         Box2D domain,
00907         MultiGridScalarField2D<T1>& field1,
00908         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel,
00909         plint boundaryWidth )
00910 {
00911     std::vector<MultiGrid2D*> multiBlocks(2);
00912     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00913     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00914     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00915 }
00916 
00917 template<typename T1, typename T2, int nDim>
00918 void integrateProcessingFunctional (
00919         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00920         Box2D domain,
00921         MultiGridScalarField2D<T1>& field1,
00922         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel,
00923         plint boundaryWidth, plint level )
00924 {
00925     std::vector<MultiGrid2D*> multiBlocks(2);
00926     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&field1);
00927     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field2);
00928     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00929                                   boundaryWidth, level);
00930 }
00931 
00932 
00933 /* *************** BoundedBoxProcessing2D_LS ******************************** */
00934 
00935 template<typename T1, template<typename U> class Descriptor, typename T2>
00936 void applyProcessingFunctional (
00937         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00938         Box2D domain,
00939         MultiGridLattice2D<T1,Descriptor>& lattice,
00940         MultiGridScalarField2D<T2>& field, plint referenceLevel,
00941         plint boundaryWidth )
00942 {
00943     std::vector<MultiGrid2D*> multiBlocks(2);
00944     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00945     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field);
00946     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00947 }
00948 
00949 template<typename T1, template<typename U> class Descriptor, typename T2>
00950 void integrateProcessingFunctional (
00951         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00952         Box2D domain,
00953         MultiGridLattice2D<T1,Descriptor>& lattice,
00954         MultiGridScalarField2D<T2>& field, plint referenceLevel,
00955         plint boundaryWidth, plint level )
00956 {
00957     std::vector<MultiGrid2D*> multiBlocks(2);
00958     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00959     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field);
00960     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00961                                   boundaryWidth, level);
00962 }
00963 
00964 
00965 /* *************** BoundedBoxProcessing2D_LT ****************************************** */
00966 
00967 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00968 void applyProcessingFunctional (
00969         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00970         Box2D domain,
00971         MultiGridLattice2D<T1,Descriptor>& lattice,
00972         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel,
00973         plint boundaryWidth )
00974 {
00975     std::vector<MultiGrid2D*> multiBlocks(2);
00976     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00977     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field);
00978     applyProcessingFunctional(functional, domain, multiBlocks, referenceLevel, boundaryWidth);
00979 }
00980 
00981 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00982 void integrateProcessingFunctional (
00983         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00984         Box2D domain,
00985         MultiGridLattice2D<T1,Descriptor>& lattice,
00986         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel,
00987         plint boundaryWidth, plint level )
00988 {
00989     std::vector<MultiGrid2D*> multiBlocks(2);
00990     multiBlocks[0] = dynamic_cast<MultiGrid2D*>(&lattice);
00991     multiBlocks[1] = dynamic_cast<MultiGrid2D*>(&field);
00992     integrateProcessingFunctional(functional, domain, multiBlocks, referenceLevel,
00993                                   boundaryWidth, level);
00994 }
00995 
00996 
00997 } // namespace plb
00998 
00999 #endif // MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_HH
01000