Palabos  Version 1.0
dataProcessorWrapper2D.h
Go to the documentation of this file.
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 
00039 #ifndef DATA_PROCESSOR_WRAPPER_2D_H
00040 #define DATA_PROCESSOR_WRAPPER_2D_H
00041 
00042 #include "atomicBlock/dataProcessingFunctional2D.h"
00043 
00044 namespace plb {
00045 
00046 /* *************** Generic wrappers, boxed functionals ********************** */
00047 
00050 void applyProcessingFunctional(BoxProcessingFunctional2D* functional,
00051                                Box2D domain,
00052                                std::vector<AtomicBlock2D*> atomicBlocks);
00053 
00056 void integrateProcessingFunctional(BoxProcessingFunctional2D* functional,
00057                                    Box2D domain,
00058                                    std::vector<AtomicBlock2D*> atomicBlocks,
00059                                    plint level=0);
00060 
00064 template<typename T, template<typename U> class Descriptor>
00065 void applyProcessingFunctional (
00066         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00067         Box2D domain,
00068         std::vector<BlockLattice2D<T,Descriptor>*> lattices );
00069 
00073 template<typename T, template<typename U> class Descriptor>
00074 void integrateProcessingFunctional (
00075         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00076         Box2D domain,
00077         std::vector<BlockLattice2D<T,Descriptor>*> lattices, plint level=0 );
00078 
00082 template<typename T>
00083 void applyProcessingFunctional (
00084         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00085         Box2D domain,
00086         std::vector<ScalarField2D<T>*> fields );
00087 
00091 template<typename T>
00092 void integrateProcessingFunctional (
00093         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00094         Box2D domain,
00095         std::vector<ScalarField2D<T>*> fields, plint level=0 );
00096 
00100 template<typename T, int nDim>
00101 void applyProcessingFunctional (
00102         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00103         Box2D domain,
00104         std::vector<TensorField2D<T,nDim>*> fields );
00105 
00109 template<typename T, int nDim>
00110 void integrateProcessingFunctional (
00111         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00112         Box2D domain,
00113         std::vector<TensorField2D<T,nDim>*> fields, plint level=0 );
00114 
00115 
00119 template<typename T>
00120 void applyProcessingFunctional (
00121         NTensorFieldBoxProcessingFunctional2D<T>* functional,
00122         Box2D domain,
00123         std::vector<NTensorField2D<T>*> fields );
00124 
00128 template<typename T>
00129 void integrateProcessingFunctional (
00130         NTensorFieldBoxProcessingFunctional2D<T>* functional,
00131         Box2D domain,
00132         std::vector<NTensorField2D<T>*> fields, plint level=0 );
00133 
00134 
00135 /* *************** Typed wrappers with a single argument, boxed functionals * */
00136 
00137 template<typename T, template<typename U> class Descriptor>
00138 void applyProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00139                                Box2D domain, BlockLattice2D<T,Descriptor>& lattice);
00140 
00141 template<typename T, template<typename U> class Descriptor>
00142 void integrateProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00143                                    Box2D domain, BlockLattice2D<T,Descriptor>& lattice,
00144                                    plint level=0);
00145 
00146 template<typename T>
00147 void applyProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00148                                Box2D domain, ScalarField2D<T>& field);
00149 template<typename T>
00150 void integrateProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00151                                    Box2D domain, ScalarField2D<T>& field,
00152                                    plint level=0);
00153 
00154 template<typename T, int nDim>
00155 void applyProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00156                                Box2D domain, TensorField2D<T,nDim>& field);
00157 template<typename T, int nDim>
00158 void integrateProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00159                                    Box2D domain, TensorField2D<T,nDim>& field,
00160                                    plint level=0);
00161 
00162 template<typename T>
00163 void applyProcessingFunctional(BoxProcessingFunctional2D_N<T>* functional,
00164                                Box2D domain, NTensorField2D<T>& field);
00165 template<typename T>
00166 void integrateProcessingFunctional(BoxProcessingFunctional2D_N<T>* functional,
00167                                    Box2D domain, NTensorField2D<T>& field,
00168                                    plint level=0);
00169 
00170 /* *************** Typed wrappers with two arguments ************************ */
00171 
00172 template<typename T1, template<typename U1> class Descriptor1,
00173          typename T2, template<typename U2> class Descriptor2>
00174 void applyProcessingFunctional (
00175         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00176         Box2D domain,
00177         BlockLattice2D<T1,Descriptor1>& lattice1,
00178         BlockLattice2D<T2,Descriptor2>& lattice2 );
00179 
00180 template<typename T1, template<typename U1> class Descriptor1,
00181          typename T2, template<typename U2> class Descriptor2>
00182 void integrateProcessingFunctional (
00183         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00184         Box2D domain,
00185         BlockLattice2D<T1,Descriptor1>& lattice1,
00186         BlockLattice2D<T2,Descriptor2>& lattice2, plint level=0 );
00187 
00188 template<typename T1, typename T2>
00189 void applyProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00190                                Box2D domain,
00191                                ScalarField2D<T1>& field1,
00192                                ScalarField2D<T2>& field2);
00193 
00194 template<typename T1, typename T2>
00195 void integrateProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00196                                    Box2D domain,
00197                                    ScalarField2D<T1>& field1,
00198                                    ScalarField2D<T2>& field2, plint level=0);
00199 
00200 template<typename T1, int nDim1, typename T2, int nDim2>
00201 void applyProcessingFunctional (
00202         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00203         Box2D domain,
00204         TensorField2D<T1,nDim1>& field1,
00205         TensorField2D<T2,nDim2>& field2 );
00206 
00207 template<typename T1, int nDim1, typename T2, int nDim2>
00208 void integrateProcessingFunctional (
00209         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional, Box2D domain,
00210         TensorField2D<T1,nDim1>& field1,
00211         TensorField2D<T2,nDim2>& field2, plint level=0 );
00212 
00213 template<typename T1, typename T2>
00214 void applyProcessingFunctional (
00215         BoxProcessingFunctional2D_NN<T1,T2>* functional,
00216         Box2D domain,
00217         NTensorField2D<T1>& field1,
00218         NTensorField2D<T2>& field2 );
00219 
00220 template<typename T1, typename T2>
00221 void integrateProcessingFunctional (
00222         BoxProcessingFunctional2D_NN<T1,T2>* functional, Box2D domain,
00223         NTensorField2D<T1>& field1,
00224         NTensorField2D<T2>& field2, plint level=0 );
00225 
00226 template<typename T1, typename T2, int nDim>
00227 void applyProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00228                                Box2D domain,
00229                                ScalarField2D<T1>& field1,
00230                                TensorField2D<T2,nDim>& field2);
00231 
00232 template<typename T1, typename T2, int nDim>
00233 void integrateProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00234                                    Box2D domain,
00235                                    ScalarField2D<T1>& field1,
00236                                    TensorField2D<T2,nDim>& field2, plint level=0);
00237 
00238 template<typename T1, typename T2>
00239 void applyProcessingFunctional(BoxProcessingFunctional2D_SN<T1,T2>* functional,
00240                                Box2D domain,
00241                                ScalarField2D<T1>& field1,
00242                                NTensorField2D<T2>& field2);
00243 
00244 template<typename T1, typename T2>
00245 void integrateProcessingFunctional(BoxProcessingFunctional2D_SN<T1,T2>* functional,
00246                                    Box2D domain,
00247                                    ScalarField2D<T1>& field1,
00248                                    NTensorField2D<T2>& field2, plint level=0);
00249 
00250 template<typename T1, template<typename U> class Descriptor, typename T2>
00251 void applyProcessingFunctional (
00252         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00253         Box2D domain,
00254         BlockLattice2D<T1,Descriptor>& lattice,
00255         ScalarField2D<T2>& field );
00256 
00257 template<typename T1, template<typename U> class Descriptor, typename T2>
00258 void integrateProcessingFunctional (
00259         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00260         Box2D domain,
00261         BlockLattice2D<T1,Descriptor>& lattice,
00262         ScalarField2D<T2>& field, plint level=0 );
00263 
00264 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00265 void applyProcessingFunctional (
00266         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00267         Box2D domain,
00268         BlockLattice2D<T1,Descriptor>& lattice,
00269         TensorField2D<T2,nDim>& field );
00270 
00271 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00272 void integrateProcessingFunctional (
00273         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00274         Box2D domain,
00275         BlockLattice2D<T1,Descriptor>& lattice,
00276         TensorField2D<T2,nDim>& field, plint level=0 );
00277 
00278 template<typename T1, template<typename U> class Descriptor, typename T2>
00279 void applyProcessingFunctional (
00280         BoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00281         Box2D domain,
00282         BlockLattice2D<T1,Descriptor>& lattice,
00283         NTensorField2D<T2>& field );
00284 
00285 template<typename T1, template<typename U> class Descriptor, typename T2>
00286 void integrateProcessingFunctional (
00287         BoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00288         Box2D domain,
00289         BlockLattice2D<T1,Descriptor>& lattice,
00290         NTensorField2D<T2>& field, plint level=0 );
00291 
00292 
00293 /* *************** Generic wrappers, dotted functionals ********************* */
00294 
00295 void applyProcessingFunctional(DotProcessingFunctional2D* functional,
00296                                DotList2D const& dotList,
00297                                std::vector<AtomicBlock2D*> atomicBlocks);
00298 
00299 void integrateProcessingFunctional(DotProcessingFunctional2D* functional,
00300                                    DotList2D const& dotList,
00301                                    std::vector<AtomicBlock2D*> atomicBlocks,
00302                                    plint level=0);
00303 
00304 template<typename T, template<typename U> class Descriptor>
00305 void applyProcessingFunctional (
00306         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00307         DotList2D const& dotList,
00308         std::vector<BlockLattice2D<T,Descriptor>*> lattices );
00309 
00310 template<typename T, template<typename U> class Descriptor>
00311 void integrateProcessingFunctional (
00312         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00313         DotList2D const& dotList,
00314         std::vector<BlockLattice2D<T,Descriptor>*> lattices, plint level=0 );
00315 
00316 template<typename T>
00317 void applyProcessingFunctional (
00318         ScalarFieldDotProcessingFunctional2D<T>* functional,
00319         DotList2D const& dotList,
00320         std::vector<ScalarField2D<T>*> fields );
00321 
00322 template<typename T>
00323 void integrateProcessingFunctional (
00324         ScalarFieldDotProcessingFunctional2D<T>* functional,
00325         DotList2D const& dotList,
00326         std::vector<ScalarField2D<T>*> fields, plint level=0 );
00327 
00328 template<typename T, int nDim>
00329 void applyProcessingFunctional (
00330         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00331         DotList2D const& dotList,
00332         std::vector<TensorField2D<T,nDim>*> fields );
00333 
00334 template<typename T, int nDim>
00335 void integrateProcessingFunctional (
00336         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00337         DotList2D const& dotList,
00338         std::vector<TensorField2D<T,nDim>*> fields, plint level=0 );
00339 
00340 template<typename T>
00341 void applyProcessingFunctional (
00342         NTensorFieldDotProcessingFunctional2D<T>* functional,
00343         DotList2D const& dotList,
00344         std::vector<NTensorField2D<T>*> fields );
00345 
00346 template<typename T>
00347 void integrateProcessingFunctional (
00348         NTensorFieldDotProcessingFunctional2D<T>* functional,
00349         DotList2D const& dotList,
00350         std::vector<NTensorField2D<T>*> fields, plint level=0 );
00351 
00352 
00353 /* *************** Typed wrappers with a single argument, dotted functionals* */
00354 
00355 template<typename T, template<typename U> class Descriptor>
00356 void applyProcessingFunctional (
00357         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00358         DotList2D const& dotList,
00359         BlockLattice2D<T,Descriptor>& lattice );
00360 
00361 template<typename T, template<typename U> class Descriptor>
00362 void integrateProcessingFunctional (
00363         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00364         DotList2D const& dotList,
00365         BlockLattice2D<T,Descriptor>& lattice, plint level=0 );
00366 
00367 template<typename T>
00368 void applyProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00369                                DotList2D const& dotList,
00370                                ScalarField2D<T>& field);
00371 
00372 template<typename T>
00373 void integrateProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00374                                    DotList2D const& dotList,
00375                                    ScalarField2D<T>& field, plint level=0);
00376 
00377 template<typename T, int nDim>
00378 void applyProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00379                                DotList2D const& dotList,
00380                                TensorField2D<T,nDim>& field);
00381 
00382 template<typename T, int nDim>
00383 void integrateProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00384                                    DotList2D const& dotList,
00385                                    TensorField2D<T,nDim>& field, plint level=0);
00386 
00387 template<typename T>
00388 void applyProcessingFunctional(DotProcessingFunctional2D_N<T>* functional,
00389                                DotList2D const& dotList,
00390                                NTensorField2D<T>& field);
00391 
00392 template<typename T>
00393 void integrateProcessingFunctional(DotProcessingFunctional2D_N<T>* functional,
00394                                    DotList2D const& dotList,
00395                                    NTensorField2D<T>& field, plint level=0);
00396 
00397 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00398 
00400 template<typename T1, template<typename U1> class Descriptor1,
00401          typename T2, template<typename U2> class Descriptor2>
00402 void applyProcessingFunctional (
00403         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00404         DotList2D const& dotList,
00405         BlockLattice2D<T1,Descriptor1>& lattice1,
00406         BlockLattice2D<T2,Descriptor2>& lattice2 );
00407 
00408 template<typename T1, template<typename U1> class Descriptor1,
00409          typename T2, template<typename U2> class Descriptor2>
00410 void integrateProcessingFunctional (
00411         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00412         DotList2D const& dotList,
00413         BlockLattice2D<T1,Descriptor1>& lattice1,
00414         BlockLattice2D<T2,Descriptor2>& lattice2, plint level=0 );
00415 
00416 template<typename T1, typename T2>
00417 void applyProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00418                                DotList2D const& dotList,
00419                                ScalarField2D<T1>& field1,
00420                                ScalarField2D<T2>& field2);
00421 
00422 template<typename T1, typename T2>
00423 void integrateProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00424                                    DotList2D const& dotList,
00425                                    ScalarField2D<T1>& field1,
00426                                    ScalarField2D<T2>& field2, plint level=0);
00427 
00429 template<typename T1, int nDim1, typename T2, int nDim2>
00430 void applyProcessingFunctional (
00431         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00432         DotList2D const& dotList,
00433         TensorField2D<T1,nDim1>& field1,
00434         TensorField2D<T2,nDim2>& field2 );
00435 
00436 template<typename T1, int nDim1, typename T2, int nDim2>
00437 void integrateProcessingFunctional (
00438         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00439         DotList2D const& dotList,
00440         TensorField2D<T1,nDim1>& field1,
00441         TensorField2D<T2,nDim2>& field2, plint level=0 );
00442 
00444 template<typename T1, typename T2>
00445 void applyProcessingFunctional (
00446         DotProcessingFunctional2D_NN<T1,T2>* functional,
00447         DotList2D const& dotList,
00448         NTensorField2D<T1>& field1,
00449         NTensorField2D<T2>& field2 );
00450 
00451 template<typename T1, typename T2>
00452 void integrateProcessingFunctional (
00453         DotProcessingFunctional2D_NN<T1,T2>* functional,
00454         DotList2D const& dotList,
00455         NTensorField2D<T1>& field1,
00456         NTensorField2D<T2>& field2, plint level=0 );
00457 
00458 template<typename T1, typename T2, int nDim>
00459 void applyProcessingFunctional (
00460         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00461         DotList2D const& dotList,
00462         ScalarField2D<T1>& field1,
00463         TensorField2D<T2,nDim>& field2 );
00464 
00465 template<typename T1, typename T2, int nDim>
00466 void integrateProcessingFunctional (
00467         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00468         DotList2D const& dotList,
00469         ScalarField2D<T1>& field1,
00470         TensorField2D<T2,nDim>& field2, plint level=0 );
00471 
00472 template<typename T1, typename T2>
00473 void applyProcessingFunctional (
00474         DotProcessingFunctional2D_SN<T1,T2>* functional,
00475         DotList2D const& dotList,
00476         ScalarField2D<T1>& field1,
00477         NTensorField2D<T2>& field2 );
00478 
00479 template<typename T1, typename T2>
00480 void integrateProcessingFunctional (
00481         DotProcessingFunctional2D_SN<T1,T2>* functional,
00482         DotList2D const& dotList,
00483         ScalarField2D<T1>& field1,
00484         NTensorField2D<T2>& field2, plint level=0 );
00485 
00486 template<typename T1, template<typename U> class Descriptor, typename T2>
00487 void applyProcessingFunctional (
00488         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00489         DotList2D const& dotList,
00490         BlockLattice2D<T1,Descriptor>& lattice,
00491         ScalarField2D<T2>& field );
00492 
00493 template<typename T1, template<typename U> class Descriptor, typename T2>
00494 void integrateProcessingFunctional (
00495         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00496         DotList2D const& dotList,
00497         BlockLattice2D<T1,Descriptor>& lattice,
00498         ScalarField2D<T2>& field, plint level=0 );
00499 
00500 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00501 void applyProcessingFunctional (
00502         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00503         DotList2D const& dotList,
00504         BlockLattice2D<T1,Descriptor>& lattice,
00505         TensorField2D<T2,nDim>& field );
00506 
00507 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00508 void integrateProcessingFunctional (
00509         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00510         DotList2D const& dotList,
00511         BlockLattice2D<T1,Descriptor>& lattice,
00512         TensorField2D<T2,nDim>& field, plint level=0 );
00513 
00514 template<typename T1, template<typename U> class Descriptor, typename T2>
00515 void applyProcessingFunctional (
00516         DotProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00517         DotList2D const& dotList,
00518         BlockLattice2D<T1,Descriptor>& lattice,
00519         NTensorField2D<T2>& field );
00520 
00521 template<typename T1, template<typename U> class Descriptor, typename T2>
00522 void integrateProcessingFunctional (
00523         DotProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00524         DotList2D const& dotList,
00525         BlockLattice2D<T1,Descriptor>& lattice,
00526         NTensorField2D<T2>& field, plint level=0 );
00527 
00528 
00529 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00530 
00531 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D* functional,
00532                                Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks,
00533                                plint boundaryWidth );
00534 
00535 void integrateProcessingFunctional (
00536         BoundedBoxProcessingFunctional2D* functional,
00537         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks,
00538         plint boundaryWidth, plint level=0 );
00539 
00540 
00541 template<typename T, template<typename U> class Descriptor>
00542 void applyProcessingFunctional (
00543         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00544         Box2D domain,
00545         std::vector<BlockLattice2D<T,Descriptor>*> lattices,
00546         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00547 
00548 template<typename T, template<typename U> class Descriptor>
00549 void integrateProcessingFunctional (
00550         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00551         Box2D domain, std::vector<BlockLattice2D<T,Descriptor>*> lattices,
00552         plint boundaryWidth = Descriptor<T>::boundaryWidth, plint level=0 );
00553 
00554 template<typename T>
00555 void applyProcessingFunctional (
00556         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00557         Box2D domain, std::vector<ScalarField2D<T>*> fields,
00558         plint boundaryWidth );
00559 
00560 template<typename T>
00561 void integrateProcessingFunctional (
00562         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00563         Box2D domain, std::vector<ScalarField2D<T>*> fields,
00564         plint boundaryWidth );
00565 
00566 template<typename T, int nDim>
00567 void applyProcessingFunctional (
00568         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00569         Box2D domain, std::vector<TensorField2D<T,nDim>*> fields,
00570         plint boundaryWidth );
00571 
00572 template<typename T, int nDim>
00573 void integrateProcessingFunctional (
00574         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00575         Box2D domain,
00576         std::vector<TensorField2D<T,nDim>*> fields, plint boundaryWidth );
00577 
00578 template<typename T>
00579 void applyProcessingFunctional (
00580         BoundedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00581         Box2D domain, std::vector<NTensorField2D<T>*> fields,
00582         plint boundaryWidth );
00583 
00584 template<typename T>
00585 void integrateProcessingFunctional (
00586         BoundedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00587         Box2D domain,
00588         std::vector<NTensorField2D<T>*> fields, plint boundaryWidth );
00589 
00590 
00591 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00592 
00593 template<typename T, template<typename U> class Descriptor>
00594 void applyProcessingFunctional (
00595         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00596         Box2D domain,
00597         BlockLattice2D<T,Descriptor>& lattice,
00598         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00599 
00600 template<typename T, template<typename U> class Descriptor>
00601 void integrateProcessingFunctional (
00602         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00603         Box2D domain,
00604         BlockLattice2D<T,Descriptor>& lattice,
00605         plint boundaryWidth = Descriptor<T>::boundaryWidth, plint level=0 );
00606 
00607 template<typename T>
00608 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00609                                Box2D domain, ScalarField2D<T>& field,
00610                                plint boundaryWidth);
00611 
00612 template<typename T>
00613 void integrateProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00614                                    Box2D domain, ScalarField2D<T>& field,
00615                                    plint boundaryWidth, plint level=0);
00616 
00617 template<typename T, int nDim>
00618 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00619                                Box2D domain, TensorField2D<T,nDim>& field,
00620                                plint boundaryWidth);
00621 
00622 template<typename T, int nDim>
00623 void integrateProcessingFunctional (
00624         BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00625         Box2D domain,
00626         TensorField2D<T,nDim>& field,
00627         plint boundaryWidth, plint level=0 );
00628 
00629 template<typename T>
00630 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_N<T>* functional,
00631                                Box2D domain, NTensorField2D<T>& field,
00632                                plint boundaryWidth);
00633 
00634 template<typename T>
00635 void integrateProcessingFunctional (
00636         BoundedBoxProcessingFunctional2D_N<T>* functional,
00637         Box2D domain,
00638         NTensorField2D<T>& field,
00639         plint boundaryWidth, plint level=0 );
00640 
00641 
00642 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00643 
00644 template<typename T1, template<typename U1> class Descriptor1,
00645          typename T2, template<typename U2> class Descriptor2>
00646 void applyProcessingFunctional (
00647         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00648         Box2D domain,
00649         BlockLattice2D<T1,Descriptor1>& lattice1,
00650         BlockLattice2D<T2,Descriptor2>& lattice2,
00651         plint boundaryWidth = Descriptor1<T1>::boundaryWidth );
00652 
00653 template<typename T1, template<typename U1> class Descriptor1,
00654          typename T2, template<typename U2> class Descriptor2>
00655 void integrateProcessingFunctional (
00656         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00657         Box2D domain,
00658         BlockLattice2D<T1,Descriptor1>& lattice1,
00659         BlockLattice2D<T2,Descriptor2>& lattice2,
00660         plint boundaryWidth = Descriptor1<T1>::boundaryWidth, plint level=0 );
00661 
00662 template<typename T1, typename T2>
00663 void applyProcessingFunctional (
00664         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00665         Box2D domain,
00666         ScalarField2D<T1>& field1,
00667         ScalarField2D<T2>& field2,
00668         plint boundaryWidth );
00669 
00670 template<typename T1, typename T2>
00671 void integrateProcessingFunctional (
00672         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00673         Box2D domain,
00674         ScalarField2D<T1>& field1,
00675         ScalarField2D<T2>& field2,
00676         plint boundaryWidth, plint level=0 );
00677 
00678 template<typename T1, int nDim1, typename T2, int nDim2>
00679 void applyProcessingFunctional (
00680         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00681         Box2D domain,
00682         TensorField2D<T1,nDim1>& field1,
00683         TensorField2D<T2,nDim2>& field2,
00684         plint boundaryWidth );
00685 
00686 template<typename T1, int nDim1, typename T2, int nDim2>
00687 void integrateProcessingFunctional (
00688         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00689         Box2D domain,
00690         TensorField2D<T1,nDim1>& field1,
00691         TensorField2D<T2,nDim2>& field2,
00692         plint boundaryWidth, plint level=0 );
00693 
00694 template<typename T1, typename T2>
00695 void applyProcessingFunctional (
00696         BoundedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00697         Box2D domain,
00698         NTensorField2D<T1>& field1,
00699         NTensorField2D<T2>& field2,
00700         plint boundaryWidth );
00701 
00702 template<typename T1, typename T2>
00703 void integrateProcessingFunctional (
00704         BoundedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00705         Box2D domain,
00706         NTensorField2D<T1>& field1,
00707         NTensorField2D<T2>& field2,
00708         plint boundaryWidth, plint level=0 );
00709 
00710 template<typename T1, typename T2, int nDim>
00711 void applyProcessingFunctional (
00712         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00713         Box2D domain,
00714         ScalarField2D<T1>& field1,
00715         TensorField2D<T2,nDim>& field2,
00716         plint boundaryWidth );
00717 
00718 template<typename T1, typename T2, int nDim>
00719 void integrateProcessingFunctional (
00720         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00721         Box2D domain,
00722         ScalarField2D<T1>& field1,
00723         TensorField2D<T2,nDim>& field2,
00724         plint boundaryWidth, plint level=0 );
00725 
00726 template<typename T1, typename T2>
00727 void applyProcessingFunctional (
00728         BoundedBoxProcessingFunctional2D_SN<T1,T2>* functional,
00729         Box2D domain,
00730         ScalarField2D<T1>& field1,
00731         NTensorField2D<T2>& field2,
00732         plint boundaryWidth );
00733 
00734 template<typename T1, typename T2>
00735 void integrateProcessingFunctional (
00736         BoundedBoxProcessingFunctional2D_SN<T1,T2>* functional,
00737         Box2D domain,
00738         ScalarField2D<T1>& field1,
00739         NTensorField2D<T2>& field2,
00740         plint boundaryWidth, plint level=0 );
00741 
00742 template<typename T1, template<typename U> class Descriptor, typename T2>
00743 void applyProcessingFunctional (
00744         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00745         Box2D domain,
00746         BlockLattice2D<T1,Descriptor>& lattice,
00747         ScalarField2D<T2>& field,
00748         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00749 
00750 template<typename T1, template<typename U> class Descriptor, typename T2>
00751 void integrateProcessingFunctional (
00752         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00753         Box2D domain,
00754         BlockLattice2D<T1,Descriptor>& lattice,
00755         ScalarField2D<T2>& field,
00756         plint boundaryWidth = Descriptor<T1>::boundaryWidth, plint level=0 );
00757 
00758 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00759 void applyProcessingFunctional (
00760         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00761         Box2D domain,
00762         BlockLattice2D<T1,Descriptor>& lattice,
00763         TensorField2D<T2,nDim>& field,
00764         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00765 
00766 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00767 void integrateProcessingFunctional (
00768         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00769         Box2D domain,
00770         BlockLattice2D<T1,Descriptor>& lattice,
00771         TensorField2D<T2,nDim>& field,
00772         plint boundaryWidth = Descriptor<T1>::boundaryWidth, plint level=0 );
00773 
00774 template<typename T1, template<typename U> class Descriptor, typename T2>
00775 void applyProcessingFunctional (
00776         BoundedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00777         Box2D domain,
00778         BlockLattice2D<T1,Descriptor>& lattice,
00779         NTensorField2D<T2>& field,
00780         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00781 
00782 template<typename T1, template<typename U> class Descriptor, typename T2>
00783 void integrateProcessingFunctional (
00784         BoundedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00785         Box2D domain,
00786         BlockLattice2D<T1,Descriptor>& lattice,
00787         NTensorField2D<T2>& field,
00788         plint boundaryWidth = Descriptor<T1>::boundaryWidth, plint level=0 );
00789 
00790 }  // namespace plb
00791 
00792 #endif  // DATA_PROCESSOR_WRAPPER_2D_H