reductiveDataProcessorWrapper3D.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_DATA_PROCESSOR_WRAPPER_3D_H
00040 #define REDUCTIVE_DATA_PROCESSOR_WRAPPER_3D_H
00041 
00042 #include "atomicBlock/reductiveDataProcessingFunctional3D.h"
00043 
00044 namespace plb {
00045 
00046 /* *************** Generic wrappers, boxed functionals ********************** */
00047 
00050 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D& functional,
00051                                Box3D domain,
00052                                std::vector<AtomicBlock3D*> atomicBlocks);
00053 
00057 template<typename T, template<typename U> class Descriptor>
00058 void applyProcessingFunctional (
00059         ReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>& functional,
00060         Box3D domain,
00061         std::vector<BlockLattice3D<T,Descriptor>*> lattices );
00062 
00066 template<typename T>
00067 void applyProcessingFunctional (
00068         ReductiveScalarFieldBoxProcessingFunctional3D<T>& functional,
00069         Box3D domain,
00070         std::vector<ScalarField3D<T>*> fields );
00071 
00075 template<typename T, int nDim>
00076 void applyProcessingFunctional (
00077         ReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>& functional,
00078         Box3D domain,
00079         std::vector<TensorField3D<T,nDim>*> fields );
00080 
00084 template<typename T>
00085 void applyProcessingFunctional (
00086         ReductiveNTensorFieldBoxProcessingFunctional3D<T>& functional,
00087         Box3D domain,
00088         std::vector<NTensorField3D<T>*> fields );
00089 
00090 /* *************** Typed wrappers with a single argument, boxed functionals * */
00091 
00092 template<typename T, template<typename U> class Descriptor>
00093 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_L<T,Descriptor>& functional,
00094                                Box3D domain, BlockLattice3D<T,Descriptor>& lattice);
00095 
00096 template<typename T>
00097 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_S<T>& functional,
00098                                Box3D domain, ScalarField3D<T>& field);
00099 
00100 template<typename T, int nDim>
00101 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_T<T,nDim>& functional,
00102                                Box3D domain, TensorField3D<T,nDim>& field);
00103 
00104 template<typename T>
00105 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_N<T>& functional,
00106                                Box3D domain, NTensorField3D<T>& field);
00107 
00108 /* *************** Typed wrappers with two arguments ************************ */
00109 
00110 template<typename T1, template<typename U1> class Descriptor1,
00111          typename T2, template<typename U2> class Descriptor2>
00112 void applyProcessingFunctional (
00113         ReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00114         Box3D domain,
00115         BlockLattice3D<T1,Descriptor1>& lattice1,
00116         BlockLattice3D<T2,Descriptor2>& lattice2 );
00117 
00118 template<typename T1, typename T2>
00119 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_SS<T1,T2>& functional,
00120                                Box3D domain,
00121                                ScalarField3D<T1>& field1,
00122                                ScalarField3D<T2>& field2);
00123 
00124 template<typename T1, int nDim1, typename T2, int nDim2>
00125 void applyProcessingFunctional (
00126         ReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00127         Box3D domain,
00128         TensorField3D<T1,nDim1>& field1,
00129         TensorField3D<T2,nDim2>& field2 );
00130 
00131 template<typename T1, typename T2, int nDim>
00132 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00133                                Box3D domain,
00134                                ScalarField3D<T1>& field1,
00135                                TensorField3D<T2,nDim>& field2);
00136 
00137 template<typename T1, typename T2>
00138 void applyProcessingFunctional (
00139         ReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00140         Box3D domain,
00141         NTensorField3D<T1>& field1,
00142         NTensorField3D<T2>& field2 );
00143 
00144 template<typename T1, typename T2>
00145 void applyProcessingFunctional(ReductiveBoxProcessingFunctional3D_SN<T1,T2>& functional,
00146                                Box3D domain,
00147                                ScalarField3D<T1>& field1,
00148                                NTensorField3D<T2>& field2);
00149 
00150 template<typename T1, template<typename U> class Descriptor, typename T2>
00151 void applyProcessingFunctional (
00152         ReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00153         Box3D domain,
00154         BlockLattice3D<T1,Descriptor>& lattice,
00155         ScalarField3D<T2>& field );
00156 
00157 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00158 void applyProcessingFunctional (
00159         ReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>& functional,
00160         Box3D domain,
00161         BlockLattice3D<T1,Descriptor>& lattice,
00162         TensorField3D<T2,nDim>& field );
00163 
00164 template<typename T1, template<typename U> class Descriptor, typename T2>
00165 void applyProcessingFunctional (
00166         ReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00167         Box3D domain,
00168         BlockLattice3D<T1,Descriptor>& lattice,
00169         NTensorField3D<T2>& field );
00170 
00171 
00172 /* *************** Generic wrappers, dotted functionals ********************* */
00173 
00174 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D& functional,
00175                                DotList3D const& dotList,
00176                                std::vector<AtomicBlock3D*> atomicBlocks);
00177 
00178 template<typename T, template<typename U> class Descriptor>
00179 void applyProcessingFunctional (
00180         ReductiveLatticeDotProcessingFunctional3D<T,Descriptor>& functional,
00181         DotList3D const& dotList,
00182         std::vector<BlockLattice3D<T,Descriptor>*> lattices );
00183 
00184 template<typename T>
00185 void applyProcessingFunctional (
00186         ReductiveScalarFieldDotProcessingFunctional3D<T>& functional,
00187         DotList3D const& dotList,
00188         std::vector<ScalarField3D<T>*> fields );
00189 
00190 template<typename T, int nDim>
00191 void applyProcessingFunctional (
00192         ReductiveTensorFieldDotProcessingFunctional3D<T,nDim>& functional,
00193         DotList3D const& dotList,
00194         std::vector<TensorField3D<T,nDim>*> fields );
00195 
00196 template<typename T>
00197 void applyProcessingFunctional (
00198         ReductiveNTensorFieldDotProcessingFunctional3D<T>& functional,
00199         DotList3D const& dotList,
00200         std::vector<NTensorField3D<T>*> fields );
00201 
00202 
00203 /* *************** Typed wrappers with a single argument, dotted functionals* */
00204 
00205 template<typename T, template<typename U> class Descriptor>
00206 void applyProcessingFunctional (
00207         ReductiveDotProcessingFunctional3D_L<T,Descriptor>& functional,
00208         DotList3D const& dotList,
00209         BlockLattice3D<T,Descriptor>& lattice );
00210 
00211 template<typename T>
00212 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_S<T>& functional,
00213                                DotList3D const& dotList,
00214                                ScalarField3D<T>& field);
00215 
00216 template<typename T, int nDim>
00217 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_T<T,nDim>& functional,
00218                                DotList3D const& dotList,
00219                                TensorField3D<T,nDim>& field);
00220 
00221 template<typename T>
00222 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_N<T>& functional,
00223                                DotList3D const& dotList,
00224                                NTensorField3D<T>& field);
00225 
00226 /* *************** Typed wrappers with two arguments, dotted functionals* *****/
00227 
00229 template<typename T1, template<typename U1> class Descriptor1,
00230          typename T2, template<typename U2> class Descriptor2>
00231 void applyProcessingFunctional (
00232         ReductiveDotProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00233         DotList3D const& dotList,
00234         BlockLattice3D<T1,Descriptor1>& lattice1,
00235         BlockLattice3D<T2,Descriptor2>& lattice2 );
00236 
00237 template<typename T1, typename T2>
00238 void applyProcessingFunctional(ReductiveDotProcessingFunctional3D_SS<T1,T2>& functional,
00239                                DotList3D const& dotList,
00240                                ScalarField3D<T1>& field1,
00241                                ScalarField3D<T2>& field2);
00242 
00244 template<typename T1, int nDim1, typename T2, int nDim2>
00245 void applyProcessingFunctional (
00246         ReductiveDotProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00247         DotList3D const& dotList,
00248         TensorField3D<T1,nDim1>& field1,
00249         TensorField3D<T2,nDim2>& field2 );
00250 
00251 template<typename T1, typename T2, int nDim>
00252 void applyProcessingFunctional (
00253         ReductiveDotProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00254         DotList3D const& dotList,
00255         ScalarField3D<T1>& field1,
00256         TensorField3D<T2,nDim>& field2 );
00257 
00259 template<typename T1, typename T2>
00260 void applyProcessingFunctional (
00261         ReductiveDotProcessingFunctional3D_NN<T1,T2>& functional,
00262         DotList3D const& dotList,
00263         NTensorField3D<T1>& field1,
00264         NTensorField3D<T2>& field2 );
00265 
00266 template<typename T1, typename T2>
00267 void applyProcessingFunctional (
00268         ReductiveDotProcessingFunctional3D_SN<T1,T2>& functional,
00269         DotList3D const& dotList,
00270         ScalarField3D<T1>& field1,
00271         NTensorField3D<T2>& field2 );
00272 
00273 template<typename T1, template<typename U> class Descriptor, typename T2>
00274 void applyProcessingFunctional (
00275         ReductiveDotProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00276         DotList3D const& dotList,
00277         BlockLattice3D<T1,Descriptor>& lattice,
00278         ScalarField3D<T2>& field );
00279 
00280 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00281 void applyProcessingFunctional (
00282         ReductiveDotProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>& functional,
00283         DotList3D const& dotList,
00284         BlockLattice3D<T1,Descriptor>& lattice,
00285         TensorField3D<T2,nDim>& field );
00286 
00287 template<typename T1, template<typename U> class Descriptor, typename T2>
00288 void applyProcessingFunctional (
00289         ReductiveDotProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00290         DotList3D const& dotList,
00291         BlockLattice3D<T1,Descriptor>& lattice,
00292         NTensorField3D<T2>& field );
00293 
00294 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00295 
00296 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D& functional,
00297                                Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks,
00298                                plint boundaryWidth );
00299 
00300 template<typename T, template<typename U> class Descriptor>
00301 void applyProcessingFunctional (
00302         BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>& functional,
00303         Box3D domain,
00304         std::vector<BlockLattice3D<T,Descriptor>*> lattices,
00305         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00306 
00307 template<typename T>
00308 void applyProcessingFunctional (
00309         BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>& functional,
00310         Box3D domain, std::vector<ScalarField3D<T>*> fields,
00311         plint boundaryWidth );
00312 
00313 template<typename T, int nDim>
00314 void applyProcessingFunctional (
00315         BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>& functional,
00316         Box3D domain, std::vector<TensorField3D<T,nDim>*> fields,
00317         plint boundaryWidth );
00318 
00319 template<typename T>
00320 void applyProcessingFunctional (
00321         BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>& functional,
00322         Box3D domain, std::vector<NTensorField3D<T>*> fields,
00323         plint boundaryWidth );
00324 
00325 
00326 /* ** Typed wrappers with a single argument, bounded and boxed functionals * */
00327 
00328 template<typename T, template<typename U> class Descriptor>
00329 void applyProcessingFunctional (
00330         BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>& functional,
00331         Box3D domain,
00332         BlockLattice3D<T,Descriptor>& lattice,
00333         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00334 
00335 template<typename T>
00336 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional3D_S<T>& functional,
00337                                Box3D domain, ScalarField3D<T>& field,
00338                                plint boundaryWidth);
00339 
00340 
00341 /* ** Typed wrappers with two arguments, bounded and boxed functionals *** */
00342 
00343 template<typename T1, template<typename U1> class Descriptor1,
00344          typename T2, template<typename U2> class Descriptor2>
00345 void applyProcessingFunctional (
00346         BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00347         Box3D domain,
00348         BlockLattice3D<T1,Descriptor1>& lattice1,
00349         BlockLattice3D<T2,Descriptor2>& lattice2,
00350         plint boundaryWidth = Descriptor1<T1>::boundaryWidth );
00351 
00352 template<typename T1, typename T2>
00353 void applyProcessingFunctional (
00354         BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>& functional,
00355         Box3D domain,
00356         ScalarField3D<T1>& field1,
00357         ScalarField3D<T2>& field2,
00358         plint boundaryWidth );
00359 
00360 template<typename T1, int nDim1, typename T2, int nDim2>
00361 void applyProcessingFunctional (
00362         BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>& functional,
00363         Box3D domain,
00364         TensorField3D<T1,nDim1>& field1,
00365         TensorField3D<T2,nDim2>& field2,
00366         plint boundaryWidth );
00367 
00368 template<typename T1, typename T2, int nDim>
00369 void applyProcessingFunctional (
00370         BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>& functional,
00371         Box3D domain,
00372         ScalarField3D<T1>& field1,
00373         TensorField3D<T2,nDim>& field2,
00374         plint boundaryWidth );
00375 
00376 template<typename T1, typename T2>
00377 void applyProcessingFunctional (
00378         BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>& functional,
00379         Box3D domain,
00380         NTensorField3D<T1>& field1,
00381         NTensorField3D<T2>& field2,
00382         plint boundaryWidth );
00383 
00384 template<typename T1, typename T2>
00385 void applyProcessingFunctional (
00386         BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>& functional,
00387         Box3D domain,
00388         ScalarField3D<T1>& field1,
00389         NTensorField3D<T2>& field2,
00390         plint boundaryWidth );
00391 
00392 template<typename T1, template<typename U> class Descriptor, typename T2>
00393 void applyProcessingFunctional (
00394         BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>& functional,
00395         Box3D domain,
00396         BlockLattice3D<T1,Descriptor>& lattice,
00397         ScalarField3D<T2>& field,
00398         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00399 
00400 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00401 void applyProcessingFunctional (
00402         BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>& functional,
00403         Box3D domain,
00404         BlockLattice3D<T1,Descriptor>& lattice,
00405         TensorField3D<T2,nDim>& field,
00406         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00407 
00408 template<typename T1, template<typename U> class Descriptor, typename T2>
00409 void applyProcessingFunctional (
00410         BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>& functional,
00411         Box3D domain,
00412         BlockLattice3D<T1,Descriptor>& lattice,
00413         NTensorField3D<T2>& field,
00414         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00415 
00416 }  // namespace plb
00417 
00418 #endif  // REDUCTIVE_DATA_PROCESSOR_WRAPPER_3D_H