reductiveDataProcessorWrapper2D.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_2D_H
00040 #define REDUCTIVE_DATA_PROCESSOR_WRAPPER_2D_H
00041 
00042 #include "atomicBlock/reductiveDataProcessingFunctional2D.h"
00043 
00044 namespace plb {
00045 
00046 /* *************** Generic wrappers, boxed functionals ********************** */
00047 
00050 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D& functional,
00051                                Box2D domain,
00052                                std::vector<AtomicBlock2D*> atomicBlocks);
00053 
00057 template<typename T, template<typename U> class Descriptor>
00058 void applyProcessingFunctional (
00059         ReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>& functional,
00060         Box2D domain,
00061         std::vector<BlockLattice2D<T,Descriptor>*> lattices );
00062 
00066 template<typename T>
00067 void applyProcessingFunctional (
00068         ReductiveScalarFieldBoxProcessingFunctional2D<T>& functional,
00069         Box2D domain,
00070         std::vector<ScalarField2D<T>*> fields );
00071 
00075 template<typename T, int nDim>
00076 void applyProcessingFunctional (
00077         ReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>& functional,
00078         Box2D domain,
00079         std::vector<TensorField2D<T,nDim>*> fields );
00080 
00084 template<typename T>
00085 void applyProcessingFunctional (
00086         ReductiveNTensorFieldBoxProcessingFunctional2D<T>& functional,
00087         Box2D domain,
00088         std::vector<NTensorField2D<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(ReductiveBoxProcessingFunctional2D_L<T,Descriptor>& functional,
00094                                Box2D domain, BlockLattice2D<T,Descriptor>& lattice);
00095 
00096 template<typename T>
00097 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_S<T>& functional,
00098                                Box2D domain, ScalarField2D<T>& field);
00099 
00100 template<typename T, int nDim>
00101 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_T<T,nDim>& functional,
00102                                Box2D domain, TensorField2D<T,nDim>& field);
00103 
00104 template<typename T>
00105 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_N<T>& functional,
00106                                Box2D domain, NTensorField2D<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         ReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00114         Box2D domain,
00115         BlockLattice2D<T1,Descriptor1>& lattice1,
00116         BlockLattice2D<T2,Descriptor2>& lattice2 );
00117 
00118 template<typename T1, typename T2>
00119 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_SS<T1,T2>& functional,
00120                                Box2D domain,
00121                                ScalarField2D<T1>& field1,
00122                                ScalarField2D<T2>& field2);
00123 
00124 template<typename T1, int nDim1, typename T2, int nDim2>
00125 void applyProcessingFunctional (
00126         ReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00127         Box2D domain,
00128         TensorField2D<T1,nDim1>& field1,
00129         TensorField2D<T2,nDim2>& field2 );
00130 
00131 template<typename T1, typename T2, int nDim>
00132 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00133                                Box2D domain,
00134                                ScalarField2D<T1>& field1,
00135                                TensorField2D<T2,nDim>& field2);
00136 
00137 template<typename T1, typename T2>
00138 void applyProcessingFunctional (
00139         ReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00140         Box2D domain,
00141         NTensorField2D<T1>& field1,
00142         NTensorField2D<T2>& field2 );
00143 
00144 template<typename T1, typename T2>
00145 void applyProcessingFunctional(ReductiveBoxProcessingFunctional2D_SN<T1,T2>& functional,
00146                                Box2D domain,
00147                                ScalarField2D<T1>& field1,
00148                                NTensorField2D<T2>& field2);
00149 
00150 template<typename T1, template<typename U> class Descriptor, typename T2>
00151 void applyProcessingFunctional (
00152         ReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00153         Box2D domain,
00154         BlockLattice2D<T1,Descriptor>& lattice,
00155         ScalarField2D<T2>& field );
00156 
00157 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00158 void applyProcessingFunctional (
00159         ReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00160         Box2D domain,
00161         BlockLattice2D<T1,Descriptor>& lattice,
00162         TensorField2D<T2,nDim>& field );
00163 
00164 template<typename T1, template<typename U> class Descriptor, typename T2>
00165 void applyProcessingFunctional (
00166         ReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00167         Box2D domain,
00168         BlockLattice2D<T1,Descriptor>& lattice,
00169         NTensorField2D<T2>& field );
00170 
00171 
00172 /* *************** Generic wrappers, dotted functionals ********************* */
00173 
00174 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D& functional,
00175                                DotList2D const& dotList,
00176                                std::vector<AtomicBlock2D*> atomicBlocks);
00177 
00178 template<typename T, template<typename U> class Descriptor>
00179 void applyProcessingFunctional (
00180         ReductiveLatticeDotProcessingFunctional2D<T,Descriptor>& functional,
00181         DotList2D const& dotList,
00182         std::vector<BlockLattice2D<T,Descriptor>*> lattices );
00183 
00184 template<typename T>
00185 void applyProcessingFunctional (
00186         ReductiveScalarFieldDotProcessingFunctional2D<T>& functional,
00187         DotList2D const& dotList,
00188         std::vector<ScalarField2D<T>*> fields );
00189 
00190 template<typename T, int nDim>
00191 void applyProcessingFunctional (
00192         ReductiveTensorFieldDotProcessingFunctional2D<T,nDim>& functional,
00193         DotList2D const& dotList,
00194         std::vector<TensorField2D<T,nDim>*> fields );
00195 
00196 template<typename T>
00197 void applyProcessingFunctional (
00198         ReductiveNTensorFieldDotProcessingFunctional2D<T>& functional,
00199         DotList2D const& dotList,
00200         std::vector<NTensorField2D<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         ReductiveDotProcessingFunctional2D_L<T,Descriptor>& functional,
00208         DotList2D const& dotList,
00209         BlockLattice2D<T,Descriptor>& lattice );
00210 
00211 template<typename T>
00212 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_S<T>& functional,
00213                                DotList2D const& dotList,
00214                                ScalarField2D<T>& field);
00215 
00216 template<typename T, int nDim>
00217 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_T<T,nDim>& functional,
00218                                DotList2D const& dotList,
00219                                TensorField2D<T,nDim>& field);
00220 
00221 template<typename T>
00222 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_N<T>& functional,
00223                                DotList2D const& dotList,
00224                                NTensorField2D<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         ReductiveDotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00233         DotList2D const& dotList,
00234         BlockLattice2D<T1,Descriptor1>& lattice1,
00235         BlockLattice2D<T2,Descriptor2>& lattice2 );
00236 
00237 template<typename T1, typename T2>
00238 void applyProcessingFunctional(ReductiveDotProcessingFunctional2D_SS<T1,T2>& functional,
00239                                DotList2D const& dotList,
00240                                ScalarField2D<T1>& field1,
00241                                ScalarField2D<T2>& field2);
00242 
00244 template<typename T1, int nDim1, typename T2, int nDim2>
00245 void applyProcessingFunctional (
00246         ReductiveDotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00247         DotList2D const& dotList,
00248         TensorField2D<T1,nDim1>& field1,
00249         TensorField2D<T2,nDim2>& field2 );
00250 
00252 template<typename T1, typename T2>
00253 void applyProcessingFunctional (
00254         ReductiveDotProcessingFunctional2D_NN<T1,T2>& functional,
00255         DotList2D const& dotList,
00256         NTensorField2D<T1>& field1,
00257         NTensorField2D<T2>& field2 );
00258 
00259 template<typename T1, typename T2, int nDim>
00260 void applyProcessingFunctional (
00261         ReductiveDotProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00262         DotList2D const& dotList,
00263         ScalarField2D<T1>& field1,
00264         TensorField2D<T2,nDim>& field2 );
00265 
00266 template<typename T1, typename T2>
00267 void applyProcessingFunctional (
00268         ReductiveDotProcessingFunctional2D_SN<T1,T2>& functional,
00269         DotList2D const& dotList,
00270         ScalarField2D<T1>& field1,
00271         NTensorField2D<T2>& field2 );
00272 
00273 template<typename T1, template<typename U> class Descriptor, typename T2>
00274 void applyProcessingFunctional (
00275         ReductiveDotProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00276         DotList2D const& dotList,
00277         BlockLattice2D<T1,Descriptor>& lattice,
00278         ScalarField2D<T2>& field );
00279 
00280 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00281 void applyProcessingFunctional (
00282         ReductiveDotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00283         DotList2D const& dotList,
00284         BlockLattice2D<T1,Descriptor>& lattice,
00285         TensorField2D<T2,nDim>& field );
00286 
00287 template<typename T1, template<typename U> class Descriptor, typename T2>
00288 void applyProcessingFunctional (
00289         ReductiveDotProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00290         DotList2D const& dotList,
00291         BlockLattice2D<T1,Descriptor>& lattice,
00292         NTensorField2D<T2>& field );
00293 
00294 /* *************** Generic wrappers, bounded and boxed functionals ********** */
00295 
00296 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D& functional,
00297                                Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks,
00298                                plint boundaryWidth );
00299 
00300 template<typename T, template<typename U> class Descriptor>
00301 void applyProcessingFunctional (
00302         BoundedReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>& functional,
00303         Box2D domain,
00304         std::vector<BlockLattice2D<T,Descriptor>*> lattices,
00305         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00306 
00307 template<typename T>
00308 void applyProcessingFunctional (
00309         BoundedReductiveScalarFieldBoxProcessingFunctional2D<T>& functional,
00310         Box2D domain, std::vector<ScalarField2D<T>*> fields,
00311         plint boundaryWidth );
00312 
00313 template<typename T, int nDim>
00314 void applyProcessingFunctional (
00315         BoundedReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>& functional,
00316         Box2D domain, std::vector<TensorField2D<T,nDim>*> fields,
00317         plint boundaryWidth );
00318 
00319 template<typename T>
00320 void applyProcessingFunctional (
00321         BoundedReductiveNTensorFieldBoxProcessingFunctional2D<T>& functional,
00322         Box2D domain, std::vector<NTensorField2D<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         BoundedReductiveBoxProcessingFunctional2D_L<T,Descriptor>& functional,
00331         Box2D domain,
00332         BlockLattice2D<T,Descriptor>& lattice,
00333         plint boundaryWidth = Descriptor<T>::boundaryWidth );
00334 
00335 template<typename T>
00336 void applyProcessingFunctional(BoundedReductiveBoxProcessingFunctional2D_S<T>& functional,
00337                                Box2D domain, ScalarField2D<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         BoundedReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>& functional,
00347         Box2D domain,
00348         BlockLattice2D<T1,Descriptor1>& lattice1,
00349         BlockLattice2D<T2,Descriptor2>& lattice2,
00350         plint boundaryWidth = Descriptor1<T1>::boundaryWidth );
00351 
00352 template<typename T1, typename T2>
00353 void applyProcessingFunctional (
00354         BoundedReductiveBoxProcessingFunctional2D_SS<T1,T2>& functional,
00355         Box2D domain,
00356         ScalarField2D<T1>& field1,
00357         ScalarField2D<T2>& field2,
00358         plint boundaryWidth );
00359 
00360 template<typename T1, int nDim1, typename T2, int nDim2>
00361 void applyProcessingFunctional (
00362         BoundedReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>& functional,
00363         Box2D domain,
00364         TensorField2D<T1,nDim1>& field1,
00365         TensorField2D<T2,nDim2>& field2,
00366         plint boundaryWidth );
00367 
00368 template<typename T1, typename T2, int nDim>
00369 void applyProcessingFunctional (
00370         BoundedReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>& functional,
00371         Box2D domain,
00372         ScalarField2D<T1>& field1,
00373         TensorField2D<T2,nDim>& field2,
00374         plint boundaryWidth );
00375 
00376 template<typename T1, int nDim1, typename T2>
00377 void applyProcessingFunctional (
00378         BoundedReductiveBoxProcessingFunctional2D_NN<T1,T2>& functional,
00379         Box2D domain,
00380         NTensorField2D<T1>& field1,
00381         NTensorField2D<T2>& field2,
00382         plint boundaryWidth );
00383 
00384 template<typename T1, typename T2>
00385 void applyProcessingFunctional (
00386         BoundedReductiveBoxProcessingFunctional2D_SN<T1,T2>& functional,
00387         Box2D domain,
00388         ScalarField2D<T1>& field1,
00389         NTensorField2D<T2>& field2,
00390         plint boundaryWidth );
00391 
00392 template<typename T1, template<typename U> class Descriptor, typename T2>
00393 void applyProcessingFunctional (
00394         BoundedReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>& functional,
00395         Box2D domain,
00396         BlockLattice2D<T1,Descriptor>& lattice,
00397         ScalarField2D<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         BoundedReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>& functional,
00403         Box2D domain,
00404         BlockLattice2D<T1,Descriptor>& lattice,
00405         TensorField2D<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         BoundedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>& functional,
00411         Box2D domain,
00412         BlockLattice2D<T1,Descriptor>& lattice,
00413         NTensorField2D<T2>& field,
00414         plint boundaryWidth = Descriptor<T1>::boundaryWidth );
00415 
00416 }  // namespace plb
00417 
00418 #endif  // REDUCTIVE_DATA_PROCESSOR_WRAPPER_2D_H