reductiveMultiDataProcessorWrapper3D.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_3D_H
00040 #define REDUCTIVE_MULTI_DATA_PROCESSOR_WRAPPER_3D_H
00041 
00042 #include "atomicBlock/reductiveDataProcessingFunctional3D.h"
00043 
00044 namespace plb {
00045 
00046 class MultiBlock3D;
00047 template<typename T, template<typename U> class Descriptor> class MultiBlockLattice3D;
00048 template<typename T> class MultiScalarField3D;
00049 template<typename T, int nDim> class MultiTensorField3D;
00050 template<typename T> class MultiNTensorField3D;
00051 
00052 /* *************** Generic wrappers, boxed functionals ********************** */
00053 
00056 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D& functional,
00057                                Box3D domain,
00058                                std::vector<MultiBlock3D*> multiBlocks);
00059 
00063 template<typename T, template<typename U> class Descriptor>
00064 void applyProcessingFunctional (
00065         ReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>& functional,
00066         Box3D domain,
00067         std::vector<MultiBlockLattice3D<T,Descriptor>*> lattices );
00068 
00072 template<typename T>
00073 void applyProcessingFunctional (
00074         ReductiveScalarFieldBoxProcessingFunctional3D<T>& functional,
00075         Box3D domain,
00076         std::vector<MultiScalarField3D<T>*> fields );
00077 
00081 template<typename T, int nDim>
00082 void applyProcessingFunctional (
00083         ReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>& functional,
00084         Box3D domain,
00085         std::vector<MultiTensorField3D<T,nDim>*> fields );
00086 
00090 template<typename T>
00091 void applyProcessingFunctional (
00092         ReductiveNTensorFieldBoxProcessingFunctional3D<T>& functional,
00093         Box3D domain,
00094         std::vector<MultiNTensorField3D<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(ReductiveBoxProcessingFunctional3D_L<T,Descriptor>& functional,
00100                                Box3D domain, MultiBlockLattice3D<T,Descriptor>& lattice);
00101 
00102 template<typename T>
00103 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_S<T>& functional,
00104                                Box3D domain, MultiScalarField3D<T>& field);
00105 
00106 template<typename T, int nDim>
00107 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_T<T,nDim>& functional,
00108                                Box3D domain, MultiTensorField3D<T,nDim>& field);
00109 
00110 template<typename T>
00111 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_N<T>& functional,
00112                                Box3D domain, MultiNTensorField3D<T>& field);
00113 
00114 template<typename T>
00115     void applyProcessingFunctional(MaskedReductiveBoxProcessingFunctional3D_N<T>& functional,
00116                                Box3D domain,
00117                                MultiNTensorField3D<T>& field,
00118                                MultiNTensorField3D<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         ReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00126         Box3D domain,
00127         MultiBlockLattice3D<T1,Descriptor1>& lattice1,
00128         MultiBlockLattice3D<T2,Descriptor2>& lattice2 );
00129 
00130 template<typename T1, typename T2>
00131 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_SS<T1,T2>& functional,
00132                                Box3D domain,
00133                                MultiScalarField3D<T1>& field1,
00134                                MultiScalarField3D<T2>& field2);
00135 
00136 template<typename T1, int nDim1, typename T2, int nDim2>
00137 void applyProcessingFunctional (
00138         ReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00139         Box3D domain,
00140         MultiTensorField3D<T1,nDim1>& field1,
00141         MultiTensorField3D<T2,nDim2>& field2 );
00142 
00143 template<typename T1, typename T2>
00144 void applyProcessingFunctional (
00145         ReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00146         Box3D domain,
00147         MultiNTensorField3D<T1>& field1,
00148         MultiNTensorField3D<T2>& field2 );
00149 
00150 template<typename T1, typename T2>
00151 void applyProcessingFunctional (
00152             MaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00153         Box3D domain,
00154         MultiNTensorField3D<T1>& field1,
00155         MultiNTensorField3D<T2>& field2,
00156         MultiNTensorField3D<int>& mask );
00157 
00158 template<typename T1, typename T2, int nDim>
00159 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00160                                Box3D domain,
00161                                MultiScalarField3D<T1>& field1,
00162                                MultiTensorField3D<T2,nDim>& field2);
00163 
00164 template<typename T1, typename T2>
00165 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_SN<T1,T2>& functional,
00166                                Box3D domain,
00167                                MultiScalarField3D<T1>& field1,
00168                                MultiNTensorField3D<T2>& field2);
00169 
00170 template<typename T1, template<typename U> class Descriptor, typename T2>
00171 void applyProcessingFunctional (
00172         ReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00173         Box3D domain,
00174         MultiBlockLattice3D<T1,Descriptor>& lattice,
00175         MultiScalarField3D<T2>& field );
00176 
00177 template<typename T1, template<typename U> class Descriptor, typename T2>
00178 void applyProcessingFunctional (
00179         ReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00180         Box3D domain,
00181         MultiBlockLattice3D<T1,Descriptor>& lattice,
00182         MultiNTensorField3D<T2>& field );
00183 
00184 template<typename T1, template<typename U> class Descriptor, typename T2>
00185 void applyProcessingFunctional (
00186             MaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00187         Box3D domain,
00188         MultiBlockLattice3D<T1,Descriptor>& lattice,
00189         MultiNTensorField3D<T2>& field,
00190         MultiNTensorField3D<int>& mask );
00191 
00192 
00193 /* *************** Generic wrappers, dotted functionals ********************* */
00194 
00195 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D& functional,
00196                                DotList3D const& dotList,
00197                                std::vector<MultiBlock3D*> multiBlocks);
00198 
00199 template<typename T, template<typename U> class Descriptor>
00200 void applyProcessingFunctional (
00201         ReductiveLatticeDotProcessingFunctional3D<T,Descriptor>& functional,
00202         DotList3D const& dotList,
00203         std::vector<MultiBlockLattice3D<T,Descriptor>*> lattices );
00204 
00205 template<typename T>
00206 void applyProcessingFunctional (
00207         ReductiveScalarFieldDotProcessingFunctional3D<T>& functional,
00208         DotList3D const& dotList,
00209         std::vector<MultiScalarField3D<T>*> fields );
00210 
00211 template<typename T, int nDim>
00212 void applyProcessingFunctional (
00213         ReductiveTensorFieldDotProcessingFunctional3D<T,nDim>& functional,
00214         DotList3D const& dotList,
00215         std::vector<MultiTensorField3D<T,nDim>*> fields );
00216 
00217 template<typename T>
00218 void applyProcessingFunctional (
00219         ReductiveNTensorFieldDotProcessingFunctional3D<T>& functional,
00220         DotList3D const& dotList,
00221         std::vector<MultiNTensorField3D<T>*> fields );
00222 
00223 
00224 /* *************** Typed wrappers with a single argument, dotted functionals* */
00225 
00226 template<typename T, template<typename U> class Descriptor>
00227 void applyProcessingFunctional (
00228         ReductiveDotProcessingFunctional3D_L<T,Descriptor>& functional,
00229         DotList3D const& dotList,
00230         MultiBlockLattice3D<T,Descriptor>& lattice );
00231 
00232 template<typename T>
00233 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_S<T>& functional,
00234                                DotList3D const& dotList,
00235                                MultiScalarField3D<T>& field);
00236 
00237 template<typename T, int nDim>
00238 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_T<T,nDim>& functional,
00239                                DotList3D const& dotList,
00240                                MultiTensorField3D<T,nDim>& field);
00241 
00242 template<typename T>
00243 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_N<T>& functional,
00244                                DotList3D const& dotList,
00245                                MultiNTensorField3D<T>& field);
00246 
00247 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00248 
00250 template<typename T1, template<typename U1> class Descriptor1,
00251          typename T2, template<typename U2> class Descriptor2>
00252 void applyProcessingFunctional (
00253         ReductiveDotProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00254         DotList3D const& dotList,
00255         MultiBlockLattice3D<T1,Descriptor1>& lattice1,
00256         MultiBlockLattice3D<T2,Descriptor2>& lattice2 );
00257 
00258 template<typename T1, typename T2>
00259 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_SS<T1,T2>& functional,
00260                                DotList3D const& dotList,
00261                                MultiScalarField3D<T1>& field1,
00262                                MultiScalarField3D<T2>& field2);
00263 
00265 template<typename T1, int nDim1, typename T2, int nDim2>
00266 void applyProcessingFunctional (
00267         ReductiveDotProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00268         DotList3D const& dotList,
00269         MultiTensorField3D<T1,nDim1>& field1,
00270         MultiTensorField3D<T2,nDim2>& field2 );
00271 
00272 template<typename T1, typename T2>
00273 void applyProcessingFunctional (
00274         ReductiveDotProcessingFunctional3D_NN<T1,T2>& functional,
00275         DotList3D const& dotList,
00276         MultiNTensorField3D<T1>& field1,
00277         MultiNTensorField3D<T2>& field2 );
00278 
00279 template<typename T1, typename T2, int nDim>
00280 void applyProcessingFunctional (
00281         ReductiveDotProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00282         DotList3D const& dotList,
00283         MultiScalarField3D<T1>& field1,
00284         MultiTensorField3D<T2,nDim>& field2 );
00285 
00286 template<typename T1, typename T2>
00287 void applyProcessingFunctional (
00288         ReductiveDotProcessingFunctional3D_SN<T1,T2>& functional,
00289         DotList3D const& dotList,
00290         MultiScalarField3D<T1>& field1,
00291         MultiNTensorField3D<T2>& field2 );
00292 
00293 template<typename T1, template<typename U> class Descriptor, typename T2>
00294 void applyProcessingFunctional (
00295         ReductiveDotProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00296         DotList3D const& dotList,
00297         MultiBlockLattice3D<T1,Descriptor>& lattice,
00298         MultiScalarField3D<T2>& field );
00299 
00300 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00301 void applyProcessingFunctional (
00302         ReductiveDotProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>& functional,
00303         DotList3D const& dotList,
00304         MultiBlockLattice3D<T1,Descriptor>& lattice,
00305         MultiTensorField3D<T2,nDim>& field );
00306 
00307 template<typename T1, template<typename U> class Descriptor, typename T2>
00308 void applyProcessingFunctional (
00309         ReductiveDotProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00310         DotList3D const& dotList,
00311         MultiBlockLattice3D<T1,Descriptor>& lattice,
00312         MultiNTensorField3D<T2>& field );
00313 
00314 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00315 
00316 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D& functional,
00317                                Box3D domain, std::vector<MultiBlock3D*> multiBlocks,
00318                                plint boundaryWidth );
00319 
00320 template<typename T, template<typename U> class Descriptor>
00321 void applyProcessingFunctional (
00322         BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>& functional,
00323         Box3D domain,
00324         std::vector<MultiBlockLattice3D<T,Descriptor>*> lattices,
00325         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00326 
00327 template<typename T>
00328 void applyProcessingFunctional (
00329         BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>& functional,
00330         Box3D domain, std::vector<MultiScalarField3D<T>*> fields,
00331         plint boundaryWidth );
00332 
00333 template<typename T, int nDim>
00334 void applyProcessingFunctional (
00335         BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>& functional,
00336         Box3D domain, std::vector<MultiTensorField3D<T,nDim>*> fields,
00337         plint boundaryWidth );
00338 
00339 template<typename T>
00340 void applyProcessingFunctional (
00341         BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>& functional,
00342         Box3D domain, std::vector<MultiNTensorField3D<T>*> fields,
00343         plint boundaryWidth );
00344 
00345 
00346 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00347 
00348 template<typename T, template<typename U> class Descriptor>
00349 void applyProcessingFunctional (
00350         BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>& functional,
00351         Box3D domain,
00352         MultiBlockLattice3D<T,Descriptor>& lattice,
00353         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00354 
00355 template<typename T>
00356 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D_S<T>& functional,
00357                                Box3D domain, MultiScalarField3D<T>& field,
00358                                plint boundaryWidth);
00359 
00360 template<typename T, int nDim>
00361 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D_T<T,nDim>& functional,
00362                                Box3D domain, MultiTensorField3D<T,nDim>& field,
00363                                plint boundaryWidth);
00364 
00365 template<typename T>
00366 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D_N<T>& functional,
00367                                Box3D domain, MultiNTensorField3D<T>& field,
00368                                plint boundaryWidth);
00369 
00370 template<typename T>
00371 void applyProcessingFunctional(BoundedMaskedReductiveBoxProcessingFunctional3D_N<T>& functional,
00372                                Box3D domain,
00373                                MultiNTensorField3D<T>& field,
00374                                MultiNTensorField3D<int>& mask,
00375                                plint boundaryWidth);
00376 
00377 
00378 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00379 
00380 template<typename T1, template<typename U1> class Descriptor1,
00381          typename T2, template<typename U2> class Descriptor2>
00382 void applyProcessingFunctional (
00383         BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00384         Box3D domain,
00385         MultiBlockLattice3D<T1,Descriptor1>& lattice1,
00386         MultiBlockLattice3D<T2,Descriptor2>& lattice2,
00387         plint boundaryWidth = Descriptor1<T1>::boundaryWidth );
00388 
00389 template<typename T1, typename T2>
00390 void applyProcessingFunctional (
00391         BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>& functional,
00392         Box3D domain,
00393         MultiScalarField3D<T1>& field1,
00394         MultiScalarField3D<T2>& field2,
00395         plint boundaryWidth );
00396 
00397 template<typename T1, int nDim1, typename T2, int nDim2>
00398 void applyProcessingFunctional (
00399         BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00400         Box3D domain,
00401         MultiTensorField3D<T1,nDim1>& field1,
00402         MultiTensorField3D<T2,nDim2>& field2,
00403         plint boundaryWidth );
00404 
00405 template<typename T1, typename T2>
00406 void applyProcessingFunctional (
00407         BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00408         Box3D domain,
00409         MultiNTensorField3D<T1>& field1,
00410         MultiNTensorField3D<T2>& field2,
00411         plint boundaryWidth );
00412 
00413 template<typename T1, typename T2>
00414 void applyProcessingFunctional (
00415         BoundedMaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00416         Box3D domain,
00417         MultiNTensorField3D<T1>& field1,
00418         MultiNTensorField3D<T2>& field2,
00419         MultiNTensorField3D<int>& mask,
00420         plint boundaryWidth );
00421 
00422 template<typename T1, typename T2, int nDim>
00423 void applyProcessingFunctional (
00424         BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00425         Box3D domain,
00426         MultiScalarField3D<T1>& field1,
00427         MultiTensorField3D<T2,nDim>& field2,
00428         plint boundaryWidth );
00429 
00430 template<typename T1, typename T2>
00431 void applyProcessingFunctional (
00432         BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>& functional,
00433         Box3D domain,
00434         MultiScalarField3D<T1>& field1,
00435         MultiNTensorField3D<T2>& field2,
00436         plint boundaryWidth );
00437 
00438 template<typename T1, template<typename U> class Descriptor, typename T2>
00439 void applyProcessingFunctional (
00440         BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00441         Box3D domain,
00442         MultiBlockLattice3D<T1,Descriptor>& lattice,
00443         MultiScalarField3D<T2>& field,
00444         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00445 
00446 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00447 void applyProcessingFunctional (
00448         BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>& functional,
00449         Box3D domain,
00450         MultiBlockLattice3D<T1,Descriptor>& lattice,
00451         MultiTensorField3D<T2,nDim>& field,
00452         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00453 
00454 template<typename T1, template<typename U> class Descriptor, typename T2>
00455 void applyProcessingFunctional (
00456         BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00457         Box3D domain,
00458         MultiBlockLattice3D<T1,Descriptor>& lattice,
00459         MultiNTensorField3D<T2>& field,
00460         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00461 
00462 template<typename T1, template<typename U> class Descriptor, typename T2>
00463 void applyProcessingFunctional (
00464         BoundedMaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00465         Box3D domain,
00466         MultiBlockLattice3D<T1,Descriptor>& lattice,
00467         MultiNTensorField3D<T2>& field,
00468         MultiNTensorField3D<int>& mask,
00469         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00470 
00471 }  // namespace plb
00472 
00473 #endif  // REDUCTIVE_DATA_PROCESSOR_WRAPPER_3D_H