reductiveMultiDataProcessorWrapper2D.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 REDUCTIVE_MULTI_DATA_PROCESSOR_WRAPPER_2D_H
00040 #define REDUCTIVE_MULTI_DATA_PROCESSOR_WRAPPER_2D_H
00041 
00042 #include "atomicBlock/reductiveDataProcessingFunctional2D.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(ReductiveBoxProcessingFunctional2D& functional,
00057                                Box2D domain,
00058                                std::vector<MultiBlock2D*> multiBlocks);
00059 
00063 template<typename T, template<typename U> class Descriptor>
00064 void applyProcessingFunctional (
00065         ReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>& functional,
00066         Box2D domain,
00067         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices );
00068 
00072 template<typename T>
00073 void applyProcessingFunctional (
00074         ReductiveScalarFieldBoxProcessingFunctional2D<T>& functional,
00075         Box2D domain,
00076         std::vector<MultiScalarField2D<T>*> fields );
00077 
00081 template<typename T, int nDim>
00082 void applyProcessingFunctional (
00083         ReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>& functional,
00084         Box2D domain,
00085         std::vector<MultiTensorField2D<T,nDim>*> fields );
00086 
00090 template<typename T>
00091 void applyProcessingFunctional (
00092         ReductiveNTensorFieldBoxProcessingFunctional2D<T>& functional,
00093         Box2D domain,
00094         std::vector<MultiNTensorField2D<T>*> fields );
00095 
00096 /* *************** Typed wrappers with a single argument, boxed functionals * */
00097 
00098 template<typename T, template<typename U> class Descriptor>
00099 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_L<T,Descriptor>& functional,
00100                                Box2D domain, MultiBlockLattice2D<T,Descriptor>& lattice);
00101 
00102 template<typename T>
00103 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_S<T>& functional,
00104                                Box2D domain, MultiScalarField2D<T>& field);
00105 
00106 template<typename T, int nDim>
00107 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_T<T,nDim>& functional,
00108                                Box2D domain, MultiTensorField2D<T,nDim>& field);
00109 
00110 template<typename T>
00111 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_N<T>& functional,
00112                                Box2D domain, MultiNTensorField2D<T>& field);
00113 
00114 template<typename T>
00115     void applyProcessingFunctional(MaskedReductiveBoxProcessingFunctional2D_N<T>& functional,
00116                                Box2D domain,
00117                                MultiNTensorField2D<T>& field,
00118                                MultiNTensorField2D<int>& mask);
00119 
00120 /* *************** Typed wrappers with two arguments ************************ */
00121 
00122 template<typename T1, template<typename U1> class Descriptor1,
00123          typename T2, template<typename U2> class Descriptor2>
00124 void applyProcessingFunctional (
00125         ReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00126         Box2D domain,
00127         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00128         MultiBlockLattice2D<T2,Descriptor2>& lattice2 );
00129 
00130 template<typename T1, typename T2>
00131 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_SS<T1,T2>& functional,
00132                                Box2D domain,
00133                                MultiScalarField2D<T1>& field1,
00134                                MultiScalarField2D<T2>& field2);
00135 
00136 template<typename T1, int nDim1, typename T2, int nDim2>
00137 void applyProcessingFunctional (
00138         ReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00139         Box2D domain,
00140         MultiTensorField2D<T1,nDim1>& field1,
00141         MultiTensorField2D<T2,nDim2>& field2 );
00142 
00143 template<typename T1, typename T2>
00144 void applyProcessingFunctional (
00145         ReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00146         Box2D domain,
00147         MultiNTensorField2D<T1>& field1,
00148         MultiNTensorField2D<T2>& field2 );
00149 
00150 template<typename T1, typename T2>
00151 void applyProcessingFunctional (
00152             MaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00153         Box2D domain,
00154         MultiNTensorField2D<T1>& field1,
00155         MultiNTensorField2D<T2>& field2,
00156         MultiNTensorField2D<int>& mask );
00157 
00158 template<typename T1, typename T2, int nDim>
00159 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00160                                Box2D domain,
00161                                MultiScalarField2D<T1>& field1,
00162                                MultiTensorField2D<T2,nDim>& field2);
00163 
00164 template<typename T1, typename T2>
00165 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_SN<T1,T2>& functional,
00166                                Box2D domain,
00167                                MultiScalarField2D<T1>& field1,
00168                                MultiNTensorField2D<T2>& field2);
00169 
00170 template<typename T1, template<typename U> class Descriptor, typename T2>
00171 void applyProcessingFunctional (
00172         ReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00173         Box2D domain,
00174         MultiBlockLattice2D<T1,Descriptor>& lattice,
00175         MultiScalarField2D<T2>& field );
00176 
00177 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00178 void applyProcessingFunctional (
00179         ReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00180         Box2D domain,
00181         MultiBlockLattice2D<T1,Descriptor>& lattice,
00182         MultiTensorField2D<T2,nDim>& field );
00183 
00184 template<typename T1, template<typename U> class Descriptor, typename T2>
00185 void applyProcessingFunctional (
00186         ReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00187         Box2D domain,
00188         MultiBlockLattice2D<T1,Descriptor>& lattice,
00189         MultiNTensorField2D<T2>& field );
00190 
00191 template<typename T1, template<typename U> class Descriptor, typename T2>
00192 void applyProcessingFunctional (
00193             MaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00194         Box2D domain,
00195         MultiBlockLattice2D<T1,Descriptor>& lattice,
00196         MultiNTensorField2D<T2>& field,
00197         MultiNTensorField2D<int>& mask );
00198 
00199 
00200 /* *************** Generic wrappers, dotted functionals ********************* */
00201 
00202 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D& functional,
00203                                DotList2D const& dotList,
00204                                std::vector<MultiBlock2D*> multiBlocks);
00205 
00206 template<typename T, template<typename U> class Descriptor>
00207 void applyProcessingFunctional (
00208         ReductiveLatticeDotProcessingFunctional2D<T,Descriptor>& functional,
00209         DotList2D const& dotList,
00210         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices );
00211 
00212 template<typename T>
00213 void applyProcessingFunctional (
00214         ReductiveScalarFieldDotProcessingFunctional2D<T>& functional,
00215         DotList2D const& dotList,
00216         std::vector<MultiScalarField2D<T>*> fields );
00217 
00218 template<typename T, int nDim>
00219 void applyProcessingFunctional (
00220         ReductiveTensorFieldDotProcessingFunctional2D<T,nDim>& functional,
00221         DotList2D const& dotList,
00222         std::vector<MultiTensorField2D<T,nDim>*> fields );
00223 
00224 template<typename T>
00225 void applyProcessingFunctional (
00226         ReductiveNTensorFieldDotProcessingFunctional2D<T>& functional,
00227         DotList2D const& dotList,
00228         std::vector<MultiNTensorField2D<T>*> fields );
00229 
00230 
00231 /* *************** Typed wrappers with a single argument, dotted functionals* */
00232 
00233 template<typename T, template<typename U> class Descriptor>
00234 void applyProcessingFunctional (
00235         ReductiveDotProcessingFunctional2D_L<T,Descriptor>& functional,
00236         DotList2D const& dotList,
00237         MultiBlockLattice2D<T,Descriptor>& lattice );
00238 
00239 template<typename T>
00240 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_S<T>& functional,
00241                                DotList2D const& dotList,
00242                                MultiScalarField2D<T>& field);
00243 
00244 template<typename T, int nDim>
00245 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_T<T,nDim>& functional,
00246                                DotList2D const& dotList,
00247                                MultiTensorField2D<T,nDim>& field);
00248 
00249 template<typename T>
00250 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_N<T>& functional,
00251                                DotList2D const& dotList,
00252                                MultiNTensorField2D<T>& field);
00253 
00254 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00255 
00257 template<typename T1, template<typename U1> class Descriptor1,
00258          typename T2, template<typename U2> class Descriptor2>
00259 void applyProcessingFunctional (
00260         ReductiveDotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00261         DotList2D const& dotList,
00262         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00263         MultiBlockLattice2D<T2,Descriptor2>& lattice2 );
00264 
00265 template<typename T1, typename T2>
00266 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_SS<T1,T2>& functional,
00267                                DotList2D const& dotList,
00268                                MultiScalarField2D<T1>& field1,
00269                                MultiScalarField2D<T2>& field2);
00270 
00272 template<typename T1, int nDim1, typename T2, int nDim2>
00273 void applyProcessingFunctional (
00274         ReductiveDotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00275         DotList2D const& dotList,
00276         MultiTensorField2D<T1,nDim1>& field1,
00277         MultiTensorField2D<T2,nDim2>& field2 );
00278 
00279 template<typename T1, typename T2>
00280 void applyProcessingFunctional (
00281         ReductiveDotProcessingFunctional2D_NN<T1,T2>& functional,
00282         DotList2D const& dotList,
00283         MultiNTensorField2D<T1>& field1,
00284         MultiNTensorField2D<T2>& field2 );
00285 
00286 template<typename T1, typename T2, int nDim>
00287 void applyProcessingFunctional (
00288         ReductiveDotProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00289         DotList2D const& dotList,
00290         MultiScalarField2D<T1>& field1,
00291         MultiTensorField2D<T2,nDim>& field2 );
00292 
00293 template<typename T1, typename T2>
00294 void applyProcessingFunctional (
00295         ReductiveDotProcessingFunctional2D_SN<T1,T2>& functional,
00296         DotList2D const& dotList,
00297         MultiScalarField2D<T1>& field1,
00298         MultiNTensorField2D<T2>& field2 );
00299 
00300 template<typename T1, template<typename U> class Descriptor, typename T2>
00301 void applyProcessingFunctional (
00302         ReductiveDotProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00303         DotList2D const& dotList,
00304         MultiBlockLattice2D<T1,Descriptor>& lattice,
00305         MultiScalarField2D<T2>& field );
00306 
00307 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00308 void applyProcessingFunctional (
00309         ReductiveDotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00310         DotList2D const& dotList,
00311         MultiBlockLattice2D<T1,Descriptor>& lattice,
00312         MultiTensorField2D<T2,nDim>& field );
00313 
00314 template<typename T1, template<typename U> class Descriptor, typename T2>
00315 void applyProcessingFunctional (
00316         ReductiveDotProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00317         DotList2D const& dotList,
00318         MultiBlockLattice2D<T1,Descriptor>& lattice,
00319         MultiNTensorField2D<T2>& field );
00320 
00321 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00322 
00323 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D& functional,
00324                                Box2D domain, std::vector<MultiBlock2D*> multiBlocks,
00325                                plint boundaryWidth );
00326 
00327 template<typename T, template<typename U> class Descriptor>
00328 void applyProcessingFunctional (
00329         BoundedReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>& functional,
00330         Box2D domain,
00331         std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices,
00332         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00333 
00334 template<typename T>
00335 void applyProcessingFunctional (
00336         BoundedReductiveScalarFieldBoxProcessingFunctional2D<T>& functional,
00337         Box2D domain, std::vector<MultiScalarField2D<T>*> fields,
00338         plint boundaryWidth );
00339 
00340 template<typename T, int nDim>
00341 void applyProcessingFunctional (
00342         BoundedReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>& functional,
00343         Box2D domain, std::vector<MultiTensorField2D<T,nDim>*> fields,
00344         plint boundaryWidth );
00345 
00346 template<typename T>
00347 void applyProcessingFunctional (
00348         BoundedReductiveNTensorFieldBoxProcessingFunctional2D<T>& functional,
00349         Box2D domain, std::vector<MultiNTensorField2D<T>*> fields,
00350         plint boundaryWidth );
00351 
00352 
00353 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00354 
00355 template<typename T, template<typename U> class Descriptor>
00356 void applyProcessingFunctional (
00357         BoundedReductiveBoxProcessingFunctional2D_L<T,Descriptor>& functional,
00358         Box2D domain,
00359         MultiBlockLattice2D<T,Descriptor>& lattice,
00360         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00361 
00362 template<typename T>
00363 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D_S<T>& functional,
00364                                Box2D domain, MultiScalarField2D<T>& field,
00365                                plint boundaryWidth);
00366 
00367 template<typename T, int nDim>
00368 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D_T<T,nDim>& functional,
00369                                Box2D domain, MultiTensorField2D<T,nDim>& field,
00370                                plint boundaryWidth);
00371 
00372 template<typename T>
00373 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D_N<T>& functional,
00374                                Box2D domain, MultiNTensorField2D<T>& field,
00375                                plint boundaryWidth);
00376 
00377 template<typename T>
00378 void applyProcessingFunctional(BoundedMaskedReductiveBoxProcessingFunctional2D_N<T>& functional,
00379                                Box2D domain,
00380                                MultiNTensorField2D<T>& field,
00381                                MultiNTensorField2D<int>& mask,
00382                                plint boundaryWidth);
00383 
00384 
00385 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00386 
00387 template<typename T1, template<typename U1> class Descriptor1,
00388          typename T2, template<typename U2> class Descriptor2>
00389 void applyProcessingFunctional (
00390         BoundedReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00391         Box2D domain,
00392         MultiBlockLattice2D<T1,Descriptor1>& lattice1,
00393         MultiBlockLattice2D<T2,Descriptor2>& lattice2,
00394         plint boundaryWidth = Descriptor1<T1>::boundaryWidth );
00395 
00396 template<typename T1, typename T2>
00397 void applyProcessingFunctional (
00398         BoundedReductiveBoxProcessingFunctional2D_SS<T1,T2>& functional,
00399         Box2D domain,
00400         MultiScalarField2D<T1>& field1,
00401         MultiScalarField2D<T2>& field2,
00402         plint boundaryWidth );
00403 
00404 template<typename T1, int nDim1, typename T2, int nDim2>
00405 void applyProcessingFunctional (
00406         BoundedReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00407         Box2D domain,
00408         MultiTensorField2D<T1,nDim1>& field1,
00409         MultiTensorField2D<T2,nDim2>& field2,
00410         plint boundaryWidth );
00411 
00412 template<typename T1, typename T2>
00413 void applyProcessingFunctional (
00414         BoundedReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00415         Box2D domain,
00416         MultiNTensorField2D<T1>& field1,
00417         MultiNTensorField2D<T2>& field2,
00418         plint boundaryWidth );
00419 
00420 template<typename T1, typename T2>
00421 void applyProcessingFunctional (
00422         BoundedMaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00423         Box2D domain,
00424         MultiNTensorField2D<T1>& field1,
00425         MultiNTensorField2D<T2>& field2,
00426         MultiNTensorField2D<int>& mask,
00427         plint boundaryWidth );
00428 
00429 template<typename T1, typename T2, int nDim>
00430 void applyProcessingFunctional (
00431         BoundedReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00432         Box2D domain,
00433         MultiScalarField2D<T1>& field1,
00434         MultiTensorField2D<T2,nDim>& field2,
00435         plint boundaryWidth );
00436 
00437 template<typename T1, typename T2>
00438 void applyProcessingFunctional (
00439         BoundedReductiveBoxProcessingFunctional2D_SN<T1,T2>& functional,
00440         Box2D domain,
00441         MultiScalarField2D<T1>& field1,
00442         MultiNTensorField2D<T2>& field2,
00443         plint boundaryWidth );
00444 
00445 template<typename T1, template<typename U> class Descriptor, typename T2>
00446 void applyProcessingFunctional (
00447         BoundedReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00448         Box2D domain,
00449         MultiBlockLattice2D<T1,Descriptor>& lattice,
00450         MultiScalarField2D<T2>& field,
00451         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00452 
00453 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00454 void applyProcessingFunctional (
00455         BoundedReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00456         Box2D domain,
00457         MultiBlockLattice2D<T1,Descriptor>& lattice,
00458         MultiTensorField2D<T2,nDim>& field,
00459         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00460 
00461 template<typename T1, template<typename U> class Descriptor, typename T2>
00462 void applyProcessingFunctional (
00463         BoundedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00464         Box2D domain,
00465         MultiBlockLattice2D<T1,Descriptor>& lattice,
00466         MultiNTensorField2D<T2>& field,
00467         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00468 
00469 template<typename T1, template<typename U> class Descriptor, typename T2>
00470 void applyProcessingFunctional (
00471         BoundedMaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00472         Box2D domain,
00473         MultiBlockLattice2D<T1,Descriptor>& lattice,
00474         MultiNTensorField2D<T2>& field,
00475         MultiNTensorField2D<int>& mask,
00476         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00477 
00478 }  // namespace plb
00479 
00480 #endif  // REDUCTIVE_MULTI_DATA_PROCESSOR_WRAPPER_2D_H