multiDataProcessorWrapper2D.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 
00039 #ifndef MULTI_DATA_PROCESSOR_WRAPPER_2D_H
00040 #define MULTI_DATA_PROCESSOR_WRAPPER_2D_H
00041 
00042 #include "atomicBlock/dataProcessingFunctional2D.h"
00043 
00044 namespace plb {
00045 
00046 class MultiBlock2D;
00047 template<typename T, template<typename U> class Descriptor> class MultiBlockLattice2D;
00048 template<typename T> class MultiScalarField2D;
00049 template<typename T, int nDim> class MultiTensorField2D;
00050 template<typename T> class MultiNTensorField2D;
00051 
00052 /* *************** Generic wrappers, boxed functionals ********************** */
00053 
00056 void applyProcessingFunctional(BoxProcessingFunctional2D* functional,
00057                                Box2D domain,
00058                                std::vector<MultiBlock2D*> multiBlocks);
00059 
00062 void integrateProcessingFunctional(BoxProcessingFunctional2D* functional,
00063                                    Box2D domain,
00064                                    std::vector<MultiBlock2D*> multiBlocks,
00065                                    plint level=0);
00066 
00070 template<typename T, template<typename U> class Descriptor>
00071 void applyProcessingFunctional (
00072         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00073         Box2D domain,
00074         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices );
00075 
00079 template<typename T, template<typename U> class Descriptor>
00080 void integrateProcessingFunctional (
00081         LatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00082         Box2D domain,
00083         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices, plint level=0 );
00084 
00088 template<typename T>
00089 void applyProcessingFunctional (
00090         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00091         Box2D domain,
00092         std::vector<MultiScalarField2D<T>*> fields );
00093 
00097 template<typename T>
00098 void integrateProcessingFunctional (
00099         ScalarFieldBoxProcessingFunctional2D<T>* functional,
00100         Box2D domain,
00101         std::vector<MultiScalarField2D<T>*> fields, plint level=0 );
00102 
00106 template<typename T, int nDim>
00107 void applyProcessingFunctional (
00108         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00109         Box2D domain,
00110         std::vector<MultiTensorField2D<T,nDim>*> fields );
00111 
00115 template<typename T, int nDim>
00116 void integrateProcessingFunctional (
00117         TensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00118         Box2D domain,
00119         std::vector<MultiTensorField2D<T,nDim>*> fields, plint level=0 );
00120 
00124 template<typename T>
00125 void applyProcessingFunctional (
00126         NTensorFieldBoxProcessingFunctional2D<T>* functional,
00127         Box2D domain,
00128         std::vector<MultiNTensorField2D<T>*> fields );
00129 
00133 template<typename T>
00134 void applyProcessingFunctional (
00135         MaskedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00136         Box2D domain,
00137         std::vector<MultiNTensorField2D<T>*> fields,
00138         MultiNTensorField2D<int>& mask);
00139 
00143 template<typename T>
00144 void integrateProcessingFunctional (
00145         NTensorFieldBoxProcessingFunctional2D<T>* functional,
00146         Box2D domain,
00147         std::vector<MultiNTensorField2D<T>*> fields, plint level=0 );
00148 
00152 template<typename T>
00153 void integrateProcessingFunctional (
00154         MaskedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00155         Box2D domain,
00156         std::vector<MultiNTensorField2D<T>*> fields,
00157         MultiNTensorField2D<int>& mask,
00158         plint level=0 );
00159 
00160 
00161 /* *************** Typed wrappers with a single argument, boxed functionals * */
00162 
00163 template<typename T, template<typename U> class Descriptor>
00164 void applyProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00165                                Box2D domain, MultiBlockLattice2D<T,Descriptor>& lattice);
00166 
00167 template<typename T, template<typename U> class Descriptor>
00168 void integrateProcessingFunctional(BoxProcessingFunctional2D_L<T,Descriptor>* functional,
00169                                    Box2D domain, MultiBlockLattice2D<T,Descriptor>& lattice,
00170                                    plint level=0);
00171 
00172 template<typename T, template<typename U> class Descriptor>
00173 void applyProcessingFunctional(MaskedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00174                                Box2D domain,
00175                                MultiBlockLattice2D<T,Descriptor>& lattice,
00176                                MultiNTensorField2D<int>& mask);
00177 
00178 template<typename T, template<typename U> class Descriptor>
00179 void integrateProcessingFunctional(MaskedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00180                                    Box2D domain,
00181                                    MultiBlockLattice2D<T,Descriptor>& lattice,
00182                                    MultiNTensorField2D<int>& mask,
00183                                    plint level=0);
00184 
00185 template<typename T>
00186 void applyProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00187                                Box2D domain, MultiScalarField2D<T>& field);
00188 template<typename T>
00189 void integrateProcessingFunctional(BoxProcessingFunctional2D_S<T>* functional,
00190                                    Box2D domain, MultiScalarField2D<T>& field,
00191                                    plint level=0);
00192 
00193 template<typename T, int nDim>
00194 void applyProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00195                                Box2D domain, MultiTensorField2D<T,nDim>& field);
00196 template<typename T, int nDim>
00197 void integrateProcessingFunctional(BoxProcessingFunctional2D_T<T,nDim>* functional,
00198                                    Box2D domain, MultiTensorField2D<T,nDim>& field,
00199                                    plint level=0);
00200 
00201 template<typename T>
00202 void applyProcessingFunctional(BoxProcessingFunctional2D_N<T>* functional,
00203                                Box2D domain, MultiNTensorField2D<T>& field);
00204 template<typename T>
00205 void integrateProcessingFunctional(BoxProcessingFunctional2D_N<T>* functional,
00206                                    Box2D domain, MultiNTensorField2D<T>& field,
00207                                    plint level=0);
00208 
00209 template<typename T>
00210 void applyProcessingFunctional(MaskedBoxProcessingFunctional2D_N<T>* functional,
00211                                Box2D domain,
00212                                MultiNTensorField2D<T>& field,
00213                                MultiNTensorField2D<int>& mask);
00214 template<typename T>
00215 void integrateProcessingFunctional(MaskedBoxProcessingFunctional2D_N<T>* functional,
00216                                    Box2D domain,
00217                                    MultiNTensorField2D<T>& field,
00218                                    MultiNTensorField2D<int>& mask,
00219                                    plint level=0);
00220 
00221 /* *************** Typed wrappers with two arguments ************************ */
00222 
00223 template<typename T1, template<typename U1> class Descriptor1,
00224          typename T2, template<typename U2> class Descriptor2>
00225 void applyProcessingFunctional (
00226         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00227         Box2D domain,
00228         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00229         MultiBlockLattice2D<T2,Descriptor2>& lattice2 );
00230 
00231 template<typename T1, template<typename U1> class Descriptor1,
00232          typename T2, template<typename U2> class Descriptor2>
00233 void integrateProcessingFunctional (
00234         BoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00235         Box2D domain,
00236         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00237         MultiBlockLattice2D<T2,Descriptor2>& lattice2, plint level=0 );
00238 
00239 template<typename T1, typename T2>
00240 void applyProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00241                                Box2D domain,
00242                                MultiScalarField2D<T1>& field1,
00243                                MultiScalarField2D<T2>& field2);
00244 
00245 template<typename T1, typename T2>
00246 void integrateProcessingFunctional(BoxProcessingFunctional2D_SS<T1,T2>* functional,
00247                                    Box2D domain,
00248                                    MultiScalarField2D<T1>& field1,
00249                                    MultiScalarField2D<T2>& field2, plint level=0);
00250 
00251 template<typename T1, int nDim1, typename T2, int nDim2>
00252 void applyProcessingFunctional (
00253         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00254         Box2D domain,
00255         MultiTensorField2D<T1,nDim1>& field1,
00256         MultiTensorField2D<T2,nDim2>& field2 );
00257 
00258 template<typename T1, int nDim1, typename T2, int nDim2>
00259 void integrateProcessingFunctional (
00260         BoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional, Box2D domain,
00261         MultiTensorField2D<T1,nDim1>& field1,
00262         MultiTensorField2D<T2,nDim2>& field2, plint level=0 );
00263 
00264 template<typename T1, typename T2>
00265 void applyProcessingFunctional (
00266         BoxProcessingFunctional2D_NN<T1,T2>* functional,
00267         Box2D domain,
00268         MultiNTensorField2D<T1>& field1,
00269         MultiNTensorField2D<T2>& field2 );
00270 
00271 template<typename T1, typename T2>
00272 void integrateProcessingFunctional (
00273         BoxProcessingFunctional2D_NN<T1,T2>* functional, Box2D domain,
00274         MultiNTensorField2D<T1>& field1,
00275         MultiNTensorField2D<T2>& field2, plint level=0 );
00276 
00277 template<typename T1, typename T2>
00278 void applyProcessingFunctional (
00279         MaskedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00280         Box2D domain,
00281         MultiNTensorField2D<T1>& field1,
00282         MultiNTensorField2D<T2>& field2,
00283         MultiNTensorField2D<int>& mask );
00284 
00285 template<typename T1, typename T2>
00286 void integrateProcessingFunctional (
00287         MaskedBoxProcessingFunctional2D_NN<T1,T2>* functional, Box2D domain,
00288         MultiNTensorField2D<T1>& field1,
00289         MultiNTensorField2D<T2>& field2,
00290         MultiNTensorField2D<int>& mask,
00291         plint level=0 );
00292 
00293 template<typename T1, typename T2, int nDim>
00294 void applyProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00295                                Box2D domain,
00296                                MultiScalarField2D<T1>& field1,
00297                                MultiTensorField2D<T2,nDim>& field2);
00298 
00299 template<typename T1, typename T2, int nDim>
00300 void integrateProcessingFunctional(BoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00301                                    Box2D domain,
00302                                    MultiScalarField2D<T1>& field1,
00303                                    MultiTensorField2D<T2,nDim>& field2, plint level=0);
00304 
00305 template<typename T1, typename T2>
00306 void applyProcessingFunctional(BoxProcessingFunctional2D_SN<T1,T2>* functional,
00307                                Box2D domain,
00308                                MultiScalarField2D<T1>& field1,
00309                                MultiNTensorField2D<T2>& field2);
00310 
00311 template<typename T1, typename T2>
00312 void integrateProcessingFunctional(BoxProcessingFunctional2D_SN<T1,T2>* functional,
00313                                    Box2D domain,
00314                                    MultiScalarField2D<T1>& field1,
00315                                    MultiNTensorField2D<T2>& field2, plint level=0);
00316 
00317 template<typename T1, template<typename U> class Descriptor, typename T2>
00318 void applyProcessingFunctional (
00319         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00320         Box2D domain,
00321         MultiBlockLattice2D<T1,Descriptor>& lattice,
00322         MultiScalarField2D<T2>& field );
00323 
00324 template<typename T1, template<typename U> class Descriptor, typename T2>
00325 void integrateProcessingFunctional (
00326         BoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00327         Box2D domain,
00328         MultiBlockLattice2D<T1,Descriptor>& lattice,
00329         MultiScalarField2D<T2>& field, plint level=0 );
00330 
00331 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00332 void applyProcessingFunctional (
00333         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00334         Box2D domain,
00335         MultiBlockLattice2D<T1,Descriptor>& lattice,
00336         MultiTensorField2D<T2,nDim>& field );
00337 
00338 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00339 void integrateProcessingFunctional (
00340         BoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00341         Box2D domain,
00342         MultiBlockLattice2D<T1,Descriptor>& lattice,
00343         MultiTensorField2D<T2,nDim>& field, plint level=0 );
00344 
00345 template<typename T1, template<typename U> class Descriptor, typename T2>
00346 void applyProcessingFunctional (
00347         BoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00348         Box2D domain,
00349         MultiBlockLattice2D<T1,Descriptor>& lattice,
00350         MultiNTensorField2D<T2>& field );
00351 
00352 template<typename T1, template<typename U> class Descriptor, typename T2>
00353 void integrateProcessingFunctional (
00354         BoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00355         Box2D domain,
00356         MultiBlockLattice2D<T1,Descriptor>& lattice,
00357         MultiNTensorField2D<T2>& field, plint level=0 );
00358 
00359 template<typename T1, template<typename U> class Descriptor, typename T2>
00360 void applyProcessingFunctional (
00361         MaskedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00362         Box2D domain,
00363         MultiBlockLattice2D<T1,Descriptor>& lattice,
00364         MultiNTensorField2D<T2>& field,
00365         MultiNTensorField2D<int>& mask );
00366 
00367 template<typename T1, template<typename U> class Descriptor, typename T2>
00368 void integrateProcessingFunctional (
00369         MaskedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00370         Box2D domain,
00371         MultiBlockLattice2D<T1,Descriptor>& lattice,
00372         MultiNTensorField2D<T2>& field,
00373         MultiNTensorField2D<int>& mask,
00374         plint level=0 );
00375 
00376 
00377 /* *************** Generic wrappers, dotted functionals ********************* */
00378 
00379 void applyProcessingFunctional(DotProcessingFunctional2D* functional,
00380                                DotList2D const& dotList,
00381                                std::vector<MultiBlock2D*> multiBlocks);
00382 
00383 void integrateProcessingFunctional(DotProcessingFunctional2D* functional,
00384                                    DotList2D const& dotList,
00385                                    std::vector<MultiBlock2D*> multiBlocks,
00386                                    plint level=0);
00387 
00388 template<typename T, template<typename U> class Descriptor>
00389 void applyProcessingFunctional (
00390         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00391         DotList2D const& dotList,
00392         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices );
00393 
00394 template<typename T, template<typename U> class Descriptor>
00395 void integrateProcessingFunctional (
00396         LatticeDotProcessingFunctional2D<T,Descriptor>* functional,
00397         DotList2D const& dotList,
00398         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices, plint level=0 );
00399 
00400 template<typename T>
00401 void applyProcessingFunctional (
00402         ScalarFieldDotProcessingFunctional2D<T>* functional,
00403         DotList2D const& dotList,
00404         std::vector<MultiScalarField2D<T>*> fields );
00405 
00406 template<typename T>
00407 void integrateProcessingFunctional (
00408         ScalarFieldDotProcessingFunctional2D<T>* functional,
00409         DotList2D const& dotList,
00410         std::vector<MultiScalarField2D<T>*> fields, plint level=0 );
00411 
00412 template<typename T, int nDim>
00413 void applyProcessingFunctional (
00414         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00415         DotList2D const& dotList,
00416         std::vector<MultiTensorField2D<T,nDim>*> fields );
00417 
00418 template<typename T, int nDim>
00419 void integrateProcessingFunctional (
00420         TensorFieldDotProcessingFunctional2D<T,nDim>* functional,
00421         DotList2D const& dotList,
00422         std::vector<MultiTensorField2D<T,nDim>*> fields, plint level=0 );
00423 
00424 template<typename T>
00425 void applyProcessingFunctional (
00426         NTensorFieldDotProcessingFunctional2D<T>* functional,
00427         DotList2D const& dotList,
00428         std::vector<MultiNTensorField2D<T>*> fields );
00429 
00430 template<typename T>
00431 void integrateProcessingFunctional (
00432         NTensorFieldDotProcessingFunctional2D<T>* functional,
00433         DotList2D const& dotList,
00434         std::vector<MultiNTensorField2D<T>*> fields, plint level=0 );
00435 
00436 
00437 /* *************** Typed wrappers with a single argument, dotted functionals* */
00438 
00439 template<typename T, template<typename U> class Descriptor>
00440 void applyProcessingFunctional (
00441         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00442         DotList2D const& dotList,
00443         MultiBlockLattice2D<T,Descriptor>& lattice );
00444 
00445 template<typename T, template<typename U> class Descriptor>
00446 void integrateProcessingFunctional (
00447         DotProcessingFunctional2D_L<T,Descriptor>* functional,
00448         DotList2D const& dotList,
00449         MultiBlockLattice2D<T,Descriptor>& lattice, plint level=0 );
00450 
00451 template<typename T>
00452 void applyProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00453                                DotList2D const& dotList,
00454                                MultiScalarField2D<T>& field);
00455 
00456 template<typename T>
00457 void integrateProcessingFunctional(DotProcessingFunctional2D_S<T>* functional,
00458                                    DotList2D const& dotList,
00459                                    MultiScalarField2D<T>& field, plint level=0);
00460 
00461 template<typename T, int nDim>
00462 void applyProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00463                                DotList2D const& dotList,
00464                                MultiTensorField2D<T,nDim>& field);
00465 
00466 template<typename T, int nDim>
00467 void integrateProcessingFunctional(DotProcessingFunctional2D_T<T,nDim>* functional,
00468                                    DotList2D const& dotList,
00469                                    MultiTensorField2D<T,nDim>& field, plint level=0);
00470 
00471 template<typename T>
00472 void applyProcessingFunctional(DotProcessingFunctional2D_N<T>* functional,
00473                                DotList2D const& dotList,
00474                                MultiNTensorField2D<T>& field);
00475 
00476 template<typename T>
00477 void integrateProcessingFunctional(DotProcessingFunctional2D_N<T>* functional,
00478                                    DotList2D const& dotList,
00479                                    MultiNTensorField2D<T>& field, plint level=0);
00480 
00481 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00482 
00484 template<typename T1, template<typename U1> class Descriptor1,
00485          typename T2, template<typename U2> class Descriptor2>
00486 void applyProcessingFunctional (
00487         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00488         DotList2D const& dotList,
00489         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00490         MultiBlockLattice2D<T2,Descriptor2>& lattice2 );
00491 
00492 template<typename T1, template<typename U1> class Descriptor1,
00493          typename T2, template<typename U2> class Descriptor2>
00494 void integrateProcessingFunctional (
00495         DotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00496         DotList2D const& dotList,
00497         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00498         MultiBlockLattice2D<T2,Descriptor2>& lattice2, plint level=0 );
00499 
00500 template<typename T1, typename T2>
00501 void applyProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00502                                DotList2D const& dotList,
00503                                MultiScalarField2D<T1>& field1,
00504                                MultiScalarField2D<T2>& field2);
00505 
00506 template<typename T1, typename T2>
00507 void integrateProcessingFunctional(DotProcessingFunctional2D_SS<T1,T2>* functional,
00508                                    DotList2D const& dotList,
00509                                    MultiScalarField2D<T1>& field1,
00510                                    MultiScalarField2D<T2>& field2, plint level=0);
00511 
00513 template<typename T1, int nDim1, typename T2, int nDim2>
00514 void applyProcessingFunctional (
00515         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00516         DotList2D const& dotList,
00517         MultiTensorField2D<T1,nDim1>& field1,
00518         MultiTensorField2D<T2,nDim2>& field2 );
00519 
00520 template<typename T1, int nDim1, typename T2, int nDim2>
00521 void integrateProcessingFunctional (
00522         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00523         DotList2D const& dotList,
00524         MultiTensorField2D<T1,nDim1>& field1,
00525         MultiTensorField2D<T2,nDim2>& field2, plint level=0 );
00526 
00527 template<typename T1, int nDim1, typename T2, int nDim2>
00528 void applyProcessingFunctional (
00529         DotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00530         DotList2D const& dotList,
00531         MultiTensorField2D<T1,nDim1>& field1,
00532         MultiTensorField2D<T2,nDim2>& field2 );
00533 
00534 template<typename T1, typename T2>
00535 void integrateProcessingFunctional (
00536         DotProcessingFunctional2D_NN<T1,T2>* functional,
00537         DotList2D const& dotList,
00538         MultiNTensorField2D<T1>& field1,
00539         MultiNTensorField2D<T2>& field2, plint level=0 );
00540 
00541 template<typename T1, typename T2, int nDim>
00542 void applyProcessingFunctional (
00543         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00544         DotList2D const& dotList,
00545         MultiScalarField2D<T1>& field1,
00546         MultiTensorField2D<T2,nDim>& field2 );
00547 
00548 template<typename T1, typename T2, int nDim>
00549 void integrateProcessingFunctional (
00550         DotProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00551         DotList2D const& dotList,
00552         MultiScalarField2D<T1>& field1,
00553         MultiTensorField2D<T2,nDim>& field2, plint level=0 );
00554 
00555 template<typename T1, typename T2>
00556 void applyProcessingFunctional (
00557         DotProcessingFunctional2D_SN<T1,T2>* functional,
00558         DotList2D const& dotList,
00559         MultiScalarField2D<T1>& field1,
00560         MultiNTensorField2D<T2>& field2 );
00561 
00562 template<typename T1, typename T2>
00563 void integrateProcessingFunctional (
00564         DotProcessingFunctional2D_SN<T1,T2>* functional,
00565         DotList2D const& dotList,
00566         MultiScalarField2D<T1>& field1,
00567         MultiNTensorField2D<T2>& field2, plint level=0 );
00568 
00569 template<typename T1, template<typename U> class Descriptor, typename T2>
00570 void applyProcessingFunctional (
00571         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00572         DotList2D const& dotList,
00573         MultiBlockLattice2D<T1,Descriptor>& lattice,
00574         MultiScalarField2D<T2>& field );
00575 
00576 template<typename T1, template<typename U> class Descriptor, typename T2>
00577 void integrateProcessingFunctional (
00578         DotProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00579         DotList2D const& dotList,
00580         MultiBlockLattice2D<T1,Descriptor>& lattice,
00581         MultiScalarField2D<T2>& field, plint level=0 );
00582 
00583 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00584 void applyProcessingFunctional (
00585         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00586         DotList2D const& dotList,
00587         MultiBlockLattice2D<T1,Descriptor>& lattice,
00588         MultiTensorField2D<T2,nDim>& field );
00589 
00590 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00591 void integrateProcessingFunctional (
00592         DotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00593         DotList2D const& dotList,
00594         MultiBlockLattice2D<T1,Descriptor>& lattice,
00595         MultiTensorField2D<T2,nDim>& field, plint level=0 );
00596 
00597 template<typename T1, template<typename U> class Descriptor, typename T2>
00598 void applyProcessingFunctional (
00599         DotProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00600         DotList2D const& dotList,
00601         MultiBlockLattice2D<T1,Descriptor>& lattice,
00602         MultiNTensorField2D<T2>& field );
00603 
00604 template<typename T1, template<typename U> class Descriptor, typename T2>
00605 void integrateProcessingFunctional (
00606         DotProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00607         DotList2D const& dotList,
00608         MultiBlockLattice2D<T1,Descriptor>& lattice,
00609         MultiNTensorField2D<T2>& field, plint level=0 );
00610 
00611 
00612 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00613 
00614 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D* functional,
00615                                Box2D domain, std::vector<MultiBlock2D*> multiBlocks,
00616                                plint boundaryWidth );
00617 
00618 void integrateProcessingFunctional (
00619         BoundedBoxProcessingFunctional2D* functional,
00620         Box2D domain, std::vector<MultiBlock2D*> multiBlocks,
00621         plint boundaryWidth, plint level=0 );
00622 
00623 
00624 template<typename T, template<typename U> class Descriptor>
00625 void applyProcessingFunctional (
00626         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00627         Box2D domain,
00628         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices,
00629         plint boundaryWidth = Descriptor<T>::vicinity );
00630 
00631 template<typename T, template<typename U> class Descriptor>
00632 void integrateProcessingFunctional (
00633         BoundedLatticeBoxProcessingFunctional2D<T,Descriptor>* functional,
00634         Box2D domain, std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices,
00635         plint boundaryWidth = Descriptor<T>::vicinity, plint level=0 );
00636 
00637 template<typename T>
00638 void applyProcessingFunctional (
00639         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00640         Box2D domain, std::vector<MultiScalarField2D<T>*> fields,
00641         plint boundaryWidth );
00642 
00643 template<typename T>
00644 void integrateProcessingFunctional (
00645         BoundedScalarFieldBoxProcessingFunctional2D<T>* functional,
00646         Box2D domain, std::vector<MultiScalarField2D<T>*> fields,
00647         plint boundaryWidth );
00648 
00649 template<typename T, int nDim>
00650 void applyProcessingFunctional (
00651         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00652         Box2D domain, std::vector<MultiTensorField2D<T,nDim>*> fields,
00653         plint boundaryWidth );
00654 
00655 template<typename T, int nDim>
00656 void integrateProcessingFunctional (
00657         BoundedTensorFieldBoxProcessingFunctional2D<T,nDim>* functional,
00658         Box2D domain,
00659         std::vector<MultiTensorField2D<T,nDim>*> fields, plint boundaryWidth );
00660 
00661 template<typename T>
00662 void applyProcessingFunctional (
00663         BoundedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00664         Box2D domain, std::vector<MultiNTensorField2D<T>*> fields,
00665         plint boundaryWidth );
00666 
00667 template<typename T>
00668 void integrateProcessingFunctional (
00669         BoundedNTensorFieldBoxProcessingFunctional2D<T>* functional,
00670         Box2D domain,
00671         std::vector<MultiNTensorField2D<T>*> fields, plint boundaryWidth );
00672 
00673 
00674 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00675 
00676 template<typename T, template<typename U> class Descriptor>
00677 void applyProcessingFunctional (
00678         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00679         Box2D domain,
00680         MultiBlockLattice2D<T,Descriptor>& lattice,
00681         plint boundaryWidth = Descriptor<T>::vicinity );
00682 
00683 template<typename T, template<typename U> class Descriptor>
00684 void integrateProcessingFunctional (
00685         BoundedBoxProcessingFunctional2D_L<T,Descriptor>* functional,
00686         Box2D domain,
00687         MultiBlockLattice2D<T,Descriptor>& lattice,
00688         plint boundaryWidth = Descriptor<T>::vicinity, plint level=0 );
00689 
00690 template<typename T>
00691 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00692                                Box2D domain, MultiScalarField2D<T>& field,
00693                                plint boundaryWidth);
00694 
00695 template<typename T>
00696 void integrateProcessingFunctional(BoundedBoxProcessingFunctional2D_S<T>* functional,
00697                                    Box2D domain, MultiScalarField2D<T>& field,
00698                                    plint boundaryWidth, plint level=0);
00699 
00700 template<typename T, int nDim>
00701 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00702                                Box2D domain, MultiTensorField2D<T,nDim>& field,
00703                                plint boundaryWidth);
00704 
00705 template<typename T, int nDim>
00706 void integrateProcessingFunctional (
00707         BoundedBoxProcessingFunctional2D_T<T,nDim>* functional,
00708         Box2D domain,
00709         MultiTensorField2D<T,nDim>& field,
00710         plint boundaryWidth, plint level=0 );
00711 
00712 template<typename T>
00713 void applyProcessingFunctional(BoundedBoxProcessingFunctional2D_N<T>* functional,
00714                                Box2D domain, MultiNTensorField2D<T>& field,
00715                                plint boundaryWidth);
00716 
00717 template<typename T>
00718 void integrateProcessingFunctional (
00719         BoundedBoxProcessingFunctional2D_N<T>* functional,
00720         Box2D domain,
00721         MultiNTensorField2D<T>& field,
00722         plint boundaryWidth, plint level=0 );
00723 
00724 
00725 template<typename T>
00726 void applyProcessingFunctional(BoundedMaskedBoxProcessingFunctional2D_N<T>* functional,
00727                                Box2D domain,
00728                                MultiNTensorField2D<T>& field,
00729                                MultiNTensorField2D<int>& mask,
00730                                plint boundaryWidth);
00731 
00732 template<typename T>
00733 void integrateProcessingFunctional (
00734         BoundedMaskedBoxProcessingFunctional2D_N<T>* functional,
00735         Box2D domain,
00736         MultiNTensorField2D<T>& field,
00737         MultiNTensorField2D<int>& mask,
00738         plint boundaryWidth, plint level=0 );
00739 
00740 
00741 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00742 
00743 template<typename T1, template<typename U1> class Descriptor1,
00744          typename T2, template<typename U2> class Descriptor2>
00745 void applyProcessingFunctional (
00746         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00747         Box2D domain,
00748         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00749         MultiBlockLattice2D<T2,Descriptor2>& lattice2,
00750         plint boundaryWidth = Descriptor1<T1>::vicinity );
00751 
00752 template<typename T1, template<typename U1> class Descriptor1,
00753          typename T2, template<typename U2> class Descriptor2>
00754 void integrateProcessingFunctional (
00755         BoundedBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>* functional,
00756         Box2D domain,
00757         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00758         MultiBlockLattice2D<T2,Descriptor2>& lattice2,
00759         plint boundaryWidth = Descriptor1<T1>::vicinity, plint level=0 );
00760 
00761 template<typename T1, typename T2>
00762 void applyProcessingFunctional (
00763         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00764         Box2D domain,
00765         MultiScalarField2D<T1>& field1,
00766         MultiScalarField2D<T2>& field2,
00767         plint boundaryWidth );
00768 
00769 template<typename T1, typename T2>
00770 void integrateProcessingFunctional (
00771         BoundedBoxProcessingFunctional2D_SS<T1,T2>* functional,
00772         Box2D domain,
00773         MultiScalarField2D<T1>& field1,
00774         MultiScalarField2D<T2>& field2,
00775         plint boundaryWidth, plint level=0 );
00776 
00777 template<typename T1, int nDim1, typename T2, int nDim2>
00778 void applyProcessingFunctional (
00779         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00780         Box2D domain,
00781         MultiTensorField2D<T1,nDim1>& field1,
00782         MultiTensorField2D<T2,nDim2>& field2,
00783         plint boundaryWidth );
00784 
00785 template<typename T1, int nDim1, typename T2, int nDim2>
00786 void integrateProcessingFunctional (
00787         BoundedBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>* functional,
00788         Box2D domain,
00789         MultiTensorField2D<T1,nDim1>& field1,
00790         MultiTensorField2D<T2,nDim2>& field2,
00791         plint boundaryWidth, plint level=0 );
00792 
00793 template<typename T1, typename T2>
00794 void applyProcessingFunctional (
00795         BoundedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00796         Box2D domain,
00797         MultiNTensorField2D<T1>& field1,
00798         MultiNTensorField2D<T2>& field2,
00799         plint boundaryWidth );
00800 
00801 template<typename T1, typename T2>
00802 void integrateProcessingFunctional (
00803         BoundedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00804         Box2D domain,
00805         MultiNTensorField2D<T1>& field1,
00806         MultiNTensorField2D<T2>& field2,
00807         plint boundaryWidth, plint level=0 );
00808 
00809 template<typename T1, typename T2>
00810 void applyProcessingFunctional (
00811         BoundedMaskedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00812         Box2D domain,
00813         MultiNTensorField2D<T1>& field1,
00814         MultiNTensorField2D<T2>& field2,
00815         MultiNTensorField2D<int>& mask,
00816         plint boundaryWidth );
00817 
00818 template<typename T1, typename T2>
00819 void integrateProcessingFunctional (
00820         BoundedMaskedBoxProcessingFunctional2D_NN<T1,T2>* functional,
00821         Box2D domain,
00822         MultiNTensorField2D<T1>& field1,
00823         MultiNTensorField2D<T2>& field2,
00824         MultiNTensorField2D<int>& mask,
00825         plint boundaryWidth, plint level=0 );
00826 
00827 template<typename T1, typename T2, int nDim>
00828 void applyProcessingFunctional (
00829         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00830         Box2D domain,
00831         MultiScalarField2D<T1>& field1,
00832         MultiTensorField2D<T2,nDim>& field2,
00833         plint boundaryWidth );
00834 
00835 template<typename T1, typename T2, int nDim>
00836 void integrateProcessingFunctional (
00837         BoundedBoxProcessingFunctional2D_ST<T1,T2,nDim>* functional,
00838         Box2D domain,
00839         MultiScalarField2D<T1>& field1,
00840         MultiTensorField2D<T2,nDim>& field2,
00841         plint boundaryWidth, plint level=0 );
00842 
00843 template<typename T1, typename T2>
00844 void applyProcessingFunctional (
00845         BoundedBoxProcessingFunctional2D_SN<T1,T2>* functional,
00846         Box2D domain,
00847         MultiScalarField2D<T1>& field1,
00848         MultiNTensorField2D<T2>& field2,
00849         plint boundaryWidth );
00850 
00851 template<typename T1, typename T2>
00852 void integrateProcessingFunctional (
00853         BoundedBoxProcessingFunctional2D_SN<T1,T2>* functional,
00854         Box2D domain,
00855         MultiScalarField2D<T1>& field1,
00856         MultiNTensorField2D<T2>& field2,
00857         plint boundaryWidth, plint level=0 );
00858 
00859 template<typename T1, template<typename U> class Descriptor, typename T2>
00860 void applyProcessingFunctional (
00861         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00862         Box2D domain,
00863         MultiBlockLattice2D<T1,Descriptor>& lattice,
00864         MultiScalarField2D<T2>& field,
00865         plint boundaryWidth = Descriptor<T1>::vicinity );
00866 
00867 template<typename T1, template<typename U> class Descriptor, typename T2>
00868 void integrateProcessingFunctional (
00869         BoundedBoxProcessingFunctional2D_LS<T1,Descriptor,T2>* functional,
00870         Box2D domain,
00871         MultiBlockLattice2D<T1,Descriptor>& lattice,
00872         MultiScalarField2D<T2>& field,
00873         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00874 
00875 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00876 void applyProcessingFunctional (
00877         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00878         Box2D domain,
00879         MultiBlockLattice2D<T1,Descriptor>& lattice,
00880         MultiTensorField2D<T2,nDim>& field,
00881         plint boundaryWidth = Descriptor<T1>::vicinity );
00882 
00883 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00884 void integrateProcessingFunctional (
00885         BoundedBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>* functional,
00886         Box2D domain,
00887         MultiBlockLattice2D<T1,Descriptor>& lattice,
00888         MultiTensorField2D<T2,nDim>& field,
00889         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00890 
00891 template<typename T1, template<typename U> class Descriptor, typename T2>
00892 void applyProcessingFunctional (
00893         BoundedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00894         Box2D domain,
00895         MultiBlockLattice2D<T1,Descriptor>& lattice,
00896         MultiNTensorField2D<T2>& field,
00897         plint boundaryWidth = Descriptor<T1>::vicinity );
00898 
00899 template<typename T1, template<typename U> class Descriptor, typename T2>
00900 void integrateProcessingFunctional (
00901         BoundedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00902         Box2D domain,
00903         MultiBlockLattice2D<T1,Descriptor>& lattice,
00904         MultiNTensorField2D<T2>& field,
00905         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00906 
00907 template<typename T1, template<typename U> class Descriptor, typename T2>
00908 void applyProcessingFunctional (
00909         BoundedMaskedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00910         Box2D domain,
00911         MultiBlockLattice2D<T1,Descriptor>& lattice,
00912         MultiNTensorField2D<T2>& field,
00913         MultiNTensorField2D<int>& mask,
00914         plint boundaryWidth = Descriptor<T1>::vicinity );
00915 
00916 template<typename T1, template<typename U> class Descriptor, typename T2>
00917 void integrateProcessingFunctional (
00918         BoundedMaskedBoxProcessingFunctional2D_LN<T1,Descriptor,T2>* functional,
00919         Box2D domain,
00920         MultiBlockLattice2D<T1,Descriptor>& lattice,
00921         MultiNTensorField2D<T2>& field,
00922         MultiNTensorField2D<int>& mask,
00923         plint boundaryWidth = Descriptor<T1>::vicinity, plint level=0 );
00924 
00925 }  // namespace plb
00926 
00927 #endif  // MULTI_DATA_PROCESSOR_WRAPPER_2D_H