multiGridDataProcessorWrapper2D.h

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 
00033 #ifndef MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_H
00034 #define MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_H
00035 
00036 #include "atomicBlock/dataProcessingFunctional2D.h"
00037 
00038 namespace plb {
00039 
00040 class MultiGrid2D;
00041 template<typename T, template<typename U> class Descriptor> class MultiGridLattice2D;
00042 template<typename T> class MultiGridScalarField2D;
00043 template<typename T, int nDim> class MultiGridTensorField2D;
00044 
00045 /* *************** Generic wrappers, boxed functionals ********************** */
00046 
00049 void applyProcessingFunctional(BoxProcessingFunctional2D* functional,
00050                                Box2D domain,
00051                                std::vector<MultiGrid2D*> multiBlocks, plint referenceLevel );
00052 
00055 void integrateProcessingFunctional(BoxProcessingFunctional2D* functional,
00056                                    Box2D domain,
00057                                    std::vector<MultiGrid2D*> multiBlocks, plint referenceLevel,
00058                                    plint level=0 );
00059 
00063 template<typename T, template<typename U> class Descriptor>
00064 void applyProcessingFunctional (
00065         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00066         Box2D domain,
00067         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel );
00068 
00072 template<typename T, template<typename U> class Descriptor>
00073 void integrateProcessingFunctional (
00074         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00075         Box2D domain,
00076         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel, plint level=0 );
00077 
00081 template<typename T>
00082 void applyProcessingFunctional (
00083         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00084         Box2D domain,
00085         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel );
00086 
00090 template<typename T>
00091 void integrateProcessingFunctional (
00092         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00093         Box2D domain,
00094         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel, plint level=0 );
00095 
00099 template<typename T, int nDim>
00100 void applyProcessingFunctional (
00101         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00102         Box2D domain,
00103         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel );
00104 
00108 template<typename T, int nDim>
00109 void integrateProcessingFunctional (
00110         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00111         Box2D domain,
00112         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel, plint level=0 );
00113 
00114 
00115 /* *************** Typed wrappers with a single argument, boxed functionals * */
00116 
00117 template<typename T, template<typename U> class Descriptor>
00118 void applyProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00119                                Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice,
00120                                plint referenceLevel);
00121 
00122 template<typename T, template<typename U> class Descriptor>
00123 void integrateProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00124                                    Box2D domain, MultiGridLattice2D<T,Descriptor>& lattice,
00125                                    plint referenceLevel, plint level=0);
00126 
00127 template<typename T>
00128 void applyProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00129                                Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel);
00130 template<typename T>
00131 void integrateProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00132                                    Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel,
00133                                    plint level=0);
00134 
00135 template<typename T, int nDim>
00136 void applyProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00137                                Box2D domain, MultiGridTensorField2D<T,nDim>& field, plint referenceLevel);
00138 template<typename T, int nDim>
00139 void integrateProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00140                                    Box2D domain, MultiGridTensorField2D<T,nDim>& field,
00141                                    plint referenceLevel, plint level=0);
00142 
00143 /* *************** Typed wrappers with two arguments ************************ */
00144 
00145 template<typename T1, template<typename U1> class Descriptor1,
00146          typename T2, template<typename U2> class Descriptor2>
00147 void applyProcessingFunctional (
00148         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00149         Box2D domain,
00150         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00151         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel );
00152 
00153 template<typename T1, template<typename U1> class Descriptor1,
00154          typename T2, template<typename U2> class Descriptor2>
00155 void integrateProcessingFunctional (
00156         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00157         Box2D domain,
00158         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00159         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel, plint level=0 );
00160 
00161 template<typename T1, typename T2>
00162 void applyProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00163                                Box2D domain,
00164                                MultiGridScalarField2D<T1>& field1,
00165                                MultiGridScalarField2D<T2>& field2, plint referenceLevel);
00166 
00167 template<typename T1, typename T2>
00168 void integrateProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00169                                    Box2D domain,
00170                                    MultiGridScalarField2D<T1>& field1,
00171                                    MultiGridScalarField2D<T2>& field2, plint referenceLevel, plint level=0);
00172 
00173 template<typename T1, int nDim1, typename T2, int nDim2>
00174 void applyProcessingFunctional (
00175         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00176         Box2D domain,
00177         MultiGridTensorField2D<T1,nDim1>& field1,
00178         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel );
00179 
00180 template<typename T1, int nDim1, typename T2, int nDim2>
00181 void integrateProcessingFunctional (
00182         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional, Box2D domain,
00183         MultiGridTensorField2D<T1,nDim1>& field1,
00184         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel, plint level=0 );
00185 
00186 
00187 template<typename T1, typename T2, int nDim>
00188 void applyProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00189                                Box2D domain,
00190                                MultiGridScalarField2D<T1>& field1,
00191                                MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel);
00192 
00193 template<typename T1, typename T2, int nDim>
00194 void integrateProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00195                                    Box2D domain,
00196                                    MultiGridScalarField2D<T1>& field1,
00197                                    MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel, plint level=0);
00198 
00199 
00200 template<typename T1, template<typename U> class Descriptor, typename T2>
00201 void applyProcessingFunctional (
00202         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00203         Box2D domain,
00204         MultiGridLattice2D<T1,Descriptor>& lattice,
00205         MultiGridScalarField2D<T2>& field, plint referenceLevel );
00206 
00207 template<typename T1, template<typename U> class Descriptor, typename T2>
00208 void integrateProcessingFunctional (
00209         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00210         Box2D domain,
00211         MultiGridLattice2D<T1,Descriptor>& lattice,
00212         MultiGridScalarField2D<T2>& field, plint referenceLevel, plint level=0 );
00213 
00214 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00215 void applyProcessingFunctional (
00216         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00217         Box2D domain,
00218         MultiGridLattice2D<T1,Descriptor>& lattice,
00219         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel );
00220 
00221 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00222 void integrateProcessingFunctional (
00223         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00224         Box2D domain,
00225         MultiGridLattice2D<T1,Descriptor>& lattice,
00226         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel, plint level=0 );
00227 
00228 
00229 /* *************** Generic wrappers, dotted functionals ********************* */
00230 
00231 void applyProcessingFunctional(DotProcessingFunctional2D* functional,
00232                                DotList2D const& dotList,
00233                                std::vector<MultiGrid2D*> multiBlocks, plint referenceLevel);
00234 
00235 void integrateProcessingFunctional(DotProcessingFunctional2D* functional,
00236                                    DotList2D const& dotList,
00237                                    std::vector<MultiGrid2D*> multiBlocks,
00238                                    plint referenceLevel, plint level=0);
00239 
00240 template<typename T, template<typename U> class Descriptor>
00241 void applyProcessingFunctional (
00242         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00243         DotList2D const& dotList,
00244         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel );
00245 
00246 template<typename T, template<typename U> class Descriptor>
00247 void integrateProcessingFunctional (
00248         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00249         DotList2D const& dotList,
00250         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel, plint level=0 );
00251 
00252 template<typename T>
00253 void applyProcessingFunctional (
00254         ScalarFieldDotProcessingFunctional2D<T>* functional,
00255         DotList2D const& dotList,
00256         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel );
00257 
00258 template<typename T>
00259 void integrateProcessingFunctional (
00260         ScalarFieldDotProcessingFunctional2D<T>* functional,
00261         DotList2D const& dotList,
00262         std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel, plint level=0 );
00263 
00264 template<typename T, int nDim>
00265 void applyProcessingFunctional (
00266         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00267         DotList2D const& dotList,
00268         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel );
00269 
00270 template<typename T, int nDim>
00271 void integrateProcessingFunctional (
00272         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00273         DotList2D const& dotList,
00274         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel, plint level=0 );
00275 
00276 
00277 /* *************** Typed wrappers with a single argument, dotted functionals* */
00278 
00279 template<typename T, template<typename U> class Descriptor>
00280 void applyProcessingFunctional (
00281         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00282         DotList2D const& dotList,
00283         MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel );
00284 
00285 template<typename T, template<typename U> class Descriptor>
00286 void integrateProcessingFunctional (
00287         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00288         DotList2D const& dotList,
00289         MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel, plint level=0 );
00290 
00291 template<typename T>
00292 void applyProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00293                                DotList2D const& dotList,
00294                                MultiGridScalarField2D<T>& field, plint referenceLevel);
00295 
00296 template<typename T>
00297 void integrateProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00298                                    DotList2D const& dotList,
00299                                    MultiGridScalarField2D<T>& field, plint referenceLevel, plint level=0);
00300 
00301 template<typename T, int nDim>
00302 void applyProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00303                                DotList2D const& dotList,
00304                                MultiGridTensorField2D<T,nDim>& field, plint referenceLevel);
00305 
00306 template<typename T, int nDim>
00307 void integrateProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00308                                    DotList2D const& dotList,
00309                                    MultiGridTensorField2D<T,nDim>& field, plint referenceLevel, plint level=0);
00310 
00311 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00312 
00314 template<typename T1, template<typename U1> class Descriptor1,
00315          typename T2, template<typename U2> class Descriptor2>
00316 void applyProcessingFunctional (
00317         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00318         DotList2D const& dotList,
00319         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00320         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel );
00321 
00322 template<typename T1, template<typename U1> class Descriptor1,
00323          typename T2, template<typename U2> class Descriptor2>
00324 void integrateProcessingFunctional (
00325         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00326         DotList2D const& dotList,
00327         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00328         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel, plint level=0 );
00329 
00330 template<typename T1, typename T2>
00331 void applyProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00332                                DotList2D const& dotList,
00333                                MultiGridScalarField2D<T1>& field1,
00334                                MultiGridScalarField2D<T2>& field2, plint referenceLevel);
00335 
00336 template<typename T1, typename T2>
00337 void integrateProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00338                                    DotList2D const& dotList,
00339                                    MultiGridScalarField2D<T1>& field1,
00340                                    MultiGridScalarField2D<T2>& field2, plint referenceLevel, plint level=0);
00341 
00343 template<typename T1, int nDim1, typename T2, int nDim2>
00344 void applyProcessingFunctional (
00345         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00346         DotList2D const& dotList,
00347         MultiGridTensorField2D<T1,nDim1>& field1,
00348         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel );
00349 
00350 template<typename T1, int nDim1, typename T2, int nDim2>
00351 void integrateProcessingFunctional (
00352         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00353         DotList2D const& dotList,
00354         MultiGridTensorField2D<T1,nDim1>& field1,
00355         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel, plint level=0 );
00356 
00357 template<typename T1, int nDim1, typename T2, int nDim2>
00358 void applyProcessingFunctional (
00359         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00360         DotList2D const& dotList,
00361         MultiGridTensorField2D<T1,nDim1>& field1,
00362         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel );
00363 
00364 
00365 template<typename T1, typename T2, int nDim>
00366 void applyProcessingFunctional (
00367         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00368         DotList2D const& dotList,
00369         MultiGridScalarField2D<T1>& field1,
00370         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel );
00371 
00372 template<typename T1, typename T2, int nDim>
00373 void integrateProcessingFunctional (
00374         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00375         DotList2D const& dotList,
00376         MultiGridScalarField2D<T1>& field1,
00377         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel, plint level=0 );
00378 
00379 template<typename T1, template<typename U> class Descriptor, typename T2>
00380 void applyProcessingFunctional (
00381         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00382         DotList2D const& dotList,
00383         MultiGridLattice2D<T1,Descriptor>& lattice,
00384         MultiGridScalarField2D<T2>& field, plint referenceLevel );
00385 
00386 template<typename T1, template<typename U> class Descriptor, typename T2>
00387 void integrateProcessingFunctional (
00388         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00389         DotList2D const& dotList,
00390         MultiGridLattice2D<T1,Descriptor>& lattice,
00391         MultiGridScalarField2D<T2>& field, plint referenceLevel, plint level=0 );
00392 
00393 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00394 void applyProcessingFunctional (
00395         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00396         DotList2D const& dotList,
00397         MultiGridLattice2D<T1,Descriptor>& lattice,
00398         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel );
00399 
00400 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00401 void integrateProcessingFunctional (
00402         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00403         DotList2D const& dotList,
00404         MultiGridLattice2D<T1,Descriptor>& lattice,
00405         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel, plint level=0 );
00406 
00407 
00408 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00409 
00410 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D* functional,
00411                                Box2D domain, std::vector<MultiGrid2D*> multiBlocks, plint referenceLevel,
00412                                plint boundaryWidth );
00413 
00414 void integrateProcessingFunctional (
00415         BoundedBoxProcessingFunctional2D* functional,
00416         Box2D domain, std::vector<MultiGrid2D*> multiBlocks,
00417         plint boundaryWidth, plint referenceLevel, plint level=0 );
00418 
00419 
00420 template<typename T, template<typename U> class Descriptor>
00421 void applyProcessingFunctional (
00422         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00423         Box2D domain,
00424         std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel,
00425         plint boundaryWidth = Descriptor<T>::vicinity );
00426 
00427 template<typename T, template<typename U> class Descriptor>
00428 void integrateProcessingFunctional (
00429         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00430         Box2D domain, std::vector<MultiGridLattice2D<T,Descriptor>*> lattices, plint referenceLevel,
00431         plint boundaryWidth = Descriptor<T>::vicinity, plint level=0 );
00432 
00433 template<typename T>
00434 void applyProcessingFunctional (
00435         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00436         Box2D domain, std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel,
00437         plint boundaryWidth );
00438 
00439 template<typename T>
00440 void integrateProcessingFunctional (
00441         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00442         Box2D domain, std::vector<MultiGridScalarField2D<T>*> fields, plint referenceLevel,
00443         plint boundaryWidth );
00444 
00445 template<typename T, int nDim>
00446 void applyProcessingFunctional (
00447         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00448         Box2D domain, std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel,
00449         plint boundaryWidth );
00450 
00451 template<typename T, int nDim>
00452 void integrateProcessingFunctional (
00453         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00454         Box2D domain,
00455         std::vector<MultiGridTensorField2D<T,nDim>*> fields, plint referenceLevel, plint boundaryWidth );
00456 
00457 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00458 
00459 template<typename T, template<typename U> class Descriptor>
00460 void applyProcessingFunctional (
00461         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00462         Box2D domain,
00463         MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel,
00464         plint boundaryWidth = Descriptor<T>::vicinity );
00465 
00466 template<typename T, template<typename U> class Descriptor>
00467 void integrateProcessingFunctional (
00468         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00469         Box2D domain,
00470         MultiGridLattice2D<T,Descriptor>& lattice, plint referenceLevel,
00471         plint boundaryWidth = Descriptor<T>::vicinity, plint level=0 );
00472 
00473 template<typename T>
00474 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00475                                Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel,
00476                                plint boundaryWidth);
00477 
00478 template<typename T>
00479 void integrateProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00480                                    Box2D domain, MultiGridScalarField2D<T>& field, plint referenceLevel,
00481                                    plint boundaryWidth, plint level=0);
00482 
00483 template<typename T, int nDim>
00484 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00485                                Box2D domain, MultiGridTensorField2D<T,nDim>& field, plint referenceLevel,
00486                                plint boundaryWidth);
00487 
00488 template<typename T, int nDim>
00489 void integrateProcessingFunctional (
00490         BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00491         Box2D domain,
00492         MultiGridTensorField2D<T,nDim>& field, plint referenceLevel,
00493         plint boundaryWidth, plint level=0 );
00494 
00495 
00496 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00497 
00498 template<typename T1, template<typename U1> class Descriptor1,
00499          typename T2, template<typename U2> class Descriptor2>
00500 void applyProcessingFunctional (
00501         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00502         Box2D domain,
00503         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00504         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel,
00505         plint boundaryWidth = Descriptor1<T1>::vicinity );
00506 
00507 template<typename T1, template<typename U1> class Descriptor1,
00508          typename T2, template<typename U2> class Descriptor2>
00509 void integrateProcessingFunctional (
00510         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00511         Box2D domain,
00512         MultiGridLattice2D<T1,Descriptor1>& lattice1,
00513         MultiGridLattice2D<T2,Descriptor2>& lattice2, plint referenceLevel,
00514         plint boundaryWidth = Descriptor1<T1>::vicinity, plint level=0 );
00515 
00516 template<typename T1, typename T2>
00517 void applyProcessingFunctional (
00518         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00519         Box2D domain,
00520         MultiGridScalarField2D<T1>& field1,
00521         MultiGridScalarField2D<T2>& field2, plint referenceLevel,
00522         plint boundaryWidth );
00523 
00524 template<typename T1, typename T2>
00525 void integrateProcessingFunctional (
00526         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00527         Box2D domain,
00528         MultiGridScalarField2D<T1>& field1,
00529         MultiGridScalarField2D<T2>& field2, plint referenceLevel,
00530         plint boundaryWidth, plint level=0 );
00531 
00532 template<typename T1, int nDim1, typename T2, int nDim2>
00533 void applyProcessingFunctional (
00534         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00535         Box2D domain,
00536         MultiGridTensorField2D<T1,nDim1>& field1,
00537         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel,
00538         plint boundaryWidth );
00539 
00540 template<typename T1, int nDim1, typename T2, int nDim2>
00541 void integrateProcessingFunctional (
00542         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00543         Box2D domain,
00544         MultiGridTensorField2D<T1,nDim1>& field1,
00545         MultiGridTensorField2D<T2,nDim2>& field2, plint referenceLevel,
00546         plint boundaryWidth, plint level=0 );
00547 
00548 
00549 template<typename T1, typename T2, int nDim>
00550 void applyProcessingFunctional (
00551         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00552         Box2D domain,
00553         MultiGridScalarField2D<T1>& field1,
00554         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel,
00555         plint boundaryWidth );
00556 
00557 template<typename T1, typename T2, int nDim>
00558 void integrateProcessingFunctional (
00559         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00560         Box2D domain,
00561         MultiGridScalarField2D<T1>& field1,
00562         MultiGridTensorField2D<T2,nDim>& field2, plint referenceLevel,
00563         plint boundaryWidth, plint level=0 );
00564 
00565 
00566 template<typename T1, template<typename U> class Descriptor, typename T2>
00567 void applyProcessingFunctional (
00568         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00569         Box2D domain,
00570         MultiGridLattice2D<T1,Descriptor>& lattice,
00571         MultiGridScalarField2D<T2>& field, plint referenceLevel,
00572         plint boundaryWidth = Descriptor<T1>::vicinity );
00573 
00574 template<typename T1, template<typename U> class Descriptor, typename T2>
00575 void integrateProcessingFunctional (
00576         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00577         Box2D domain,
00578         MultiGridLattice2D<T1,Descriptor>& lattice,
00579         MultiGridScalarField2D<T2>& field, plint referenceLevel,
00580         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00581 
00582 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00583 void applyProcessingFunctional (
00584         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00585         Box2D domain,
00586         MultiGridLattice2D<T1,Descriptor>& lattice,
00587         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel,
00588         plint boundaryWidth = Descriptor<T1>::vicinity );
00589 
00590 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00591 void integrateProcessingFunctional (
00592         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00593         Box2D domain,
00594         MultiGridLattice2D<T1,Descriptor>& lattice,
00595         MultiGridTensorField2D<T2,nDim>& field, plint referenceLevel,
00596         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00597 
00598 }  // namespace plb
00599 
00600 #endif  // MULTI_GRID_DATA_PROCESSOR_WRAPPER_2D_H