reductiveDataProcessingFunctional2D.hh

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 
00025 
00026 #ifndef REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_2D_HH
00027 #define REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_2D_HH
00028 
00029 #include "atomicBlock/reductiveDataProcessorWrapper2D.h"
00030 #include "atomicBlock/blockLattice2D.h"
00031 #include "atomicBlock/dataField2D.h"
00032 #include "atomicBlock/dataProcessor2D.h"
00033 #include "core/plbDebug.h"
00034 
00035 namespace plb {
00036 
00037 /* *************** ReductiveBoxProcessing2D_L ******************************************* */
00038 
00039 template<typename T, template<typename U> class Descriptor>
00040 void ReductiveBoxProcessingFunctional2D_L<T,Descriptor>::processGenericBlocks (
00041         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00042 {
00043     process(domain, dynamic_cast<BlockLattice2D<T,Descriptor>&>(*atomicBlocks[0]));
00044 }
00045 
00046 /* *************** ReductiveBoxProcessing2D_S ******************************************* */
00047 
00048 template<typename T>
00049 void ReductiveBoxProcessingFunctional2D_S<T>::processGenericBlocks (
00050         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00051 {
00052     process(domain, dynamic_cast<ScalarField2D<T>&>(*atomicBlocks[0]));
00053 }
00054 
00055 /* *************** ReductiveBoxProcessing2D_T ******************************************* */
00056 
00057 template<typename T, int nDim>
00058 void ReductiveBoxProcessingFunctional2D_T<T,nDim>::processGenericBlocks (
00059         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00060 {
00061     process(domain, dynamic_cast<TensorField2D<T,nDim>&>(*atomicBlocks[0]));
00062 }
00063 
00064 /* *************** ReductiveBoxProcessing2D_N ******************************************* */
00065 
00066 template<typename T>
00067 void ReductiveBoxProcessingFunctional2D_N<T>::processGenericBlocks (
00068         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00069 {
00070     process(domain, dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]));
00071 }
00072 
00073 /* *************** MaskedReductiveBoxProcessing2D_N ******************************************* */
00074 
00075 template<typename T>
00076 void MaskedReductiveBoxProcessingFunctional2D_N<T>::processGenericBlocks (
00077         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00078 {
00079     process(domain,
00080             dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]),
00081             dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[1]));
00082 }
00083 
00084 /* *************** ReductiveBoxProcessing2D_LL******************************************* */
00085 
00086 template<typename T1, template<typename U1> class Descriptor1,
00087          typename T2, template<typename U2> class Descriptor2>
00088 void ReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>::processGenericBlocks (
00089         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00090 {
00091     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00092     process ( domain,
00093               dynamic_cast<BlockLattice2D<T1,Descriptor1>&>(*atomicBlocks[0]),
00094               dynamic_cast<BlockLattice2D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00095 }
00096 
00097 
00098 /* *************** ReductiveBoxProcessing2D_SS ****************************************** */
00099 
00100 template<typename T1, typename T2>
00101 void ReductiveBoxProcessingFunctional2D_SS<T1,T2>::processGenericBlocks (
00102         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00103 {
00104     process ( domain,
00105               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00106               dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00107 }
00108 
00109 
00110 /* *************** ReductiveBoxProcessing2D_TT ****************************************** */
00111 
00112 template<typename T1, int nDim1, typename T2, int nDim2>
00113 void ReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>::processGenericBlocks (
00114         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00115 {
00116     process ( domain,
00117               dynamic_cast<TensorField2D<T1,nDim1>&>(*atomicBlocks[0]),
00118               dynamic_cast<TensorField2D<T2,nDim2>&>(*atomicBlocks[1]) );
00119 }
00120 
00121 
00122 /* *************** ReductiveBoxProcessing2D_NN ****************************************** */
00123 
00124 template<typename T1, typename T2>
00125 void ReductiveBoxProcessingFunctional2D_NN<T1,T2>::processGenericBlocks (
00126         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00127 {
00128     process ( domain,
00129               dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00130               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00131 }
00132 
00133 
00134 /* *************** MaskedReductiveBoxProcessing2D_NN ****************************************** */
00135 
00136 template<typename T1, typename T2>
00137 void MaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processGenericBlocks (
00138         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00139 {
00140     process ( domain,
00141               dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00142               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00143               dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00144 }
00145 
00146 
00147 /* *************** ReductiveBoxProcessing2D_ST ****************************************** */
00148 
00149 template<typename T1, typename T2, int nDim>
00150 void ReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>::processGenericBlocks (
00151         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00152 {
00153     process ( domain,
00154               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00155               dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00156 }
00157 
00158 
00159 /* *************** ReductiveBoxProcessing2D_SN ****************************************** */
00160 
00161 template<typename T1, typename T2>
00162 void ReductiveBoxProcessingFunctional2D_SN<T1,T2>::processGenericBlocks (
00163         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00164 {
00165     process ( domain,
00166               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00167               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00168 }
00169 
00170 
00171 /* *************** ReductiveBoxProcessing2D_LS ****************************************** */
00172 
00173 template<typename T1, template<typename U> class Descriptor, typename T2>
00174 void ReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>::processGenericBlocks (
00175         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00176 {
00177     process ( domain,
00178               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00179               dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00180 }
00181 
00182 /* *************** ReductiveBoxProcessing2D_LT ****************************************** */
00183 
00184 template<typename T1, template<typename U> class Descriptor,
00185          typename T2, int nDim>
00186 void ReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>::processGenericBlocks (
00187         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00188 {
00189     process ( domain,
00190               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00191               dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00192 }
00193 
00194 /* *************** ReductiveBoxProcessing2D_LN ****************************************** */
00195 
00196 template<typename T1, template<typename U> class Descriptor, typename T2>
00197 void ReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processGenericBlocks (
00198         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00199 {
00200     process ( domain,
00201               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00202               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00203 }
00204 
00205 /* *************** MaskedReductiveBoxProcessing2D_LN ****************************************** */
00206 
00207 template<typename T1, template<typename U> class Descriptor, typename T2>
00208 void MaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processGenericBlocks (
00209         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00210 {
00211     process ( domain,
00212               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00213               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00214               dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00215 }
00216 
00217 /* *************** ReductiveLatticeBoxProcessing2D ************************************** */
00218 
00219 template<typename T, template<typename U> class Descriptor>
00220 void ReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>::processGenericBlocks (
00221         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00222 {
00223     std::vector<BlockLattice2D<T,Descriptor>*> lattices(atomicBlocks.size());
00224     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00225         lattices[iLattice] = dynamic_cast<BlockLattice2D<T,Descriptor>*>(atomicBlocks[iLattice]);
00226     }
00227     process(domain, lattices);
00228 }
00229 
00230 /* *************** ReductiveScalarFieldBoxProcessing2D *********************************** */
00231 
00232 template<typename T>
00233 void ReductiveScalarFieldBoxProcessingFunctional2D<T>::processGenericBlocks (
00234         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00235 {
00236     std::vector<ScalarField2D<T>*> fields(atomicBlocks.size());
00237     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00238         fields[iField] = dynamic_cast<ScalarField2D<T>*>(atomicBlocks[iField]);
00239     }
00240     process(domain, fields);
00241 }
00242 
00243 /* *************** ReductiveTensorFieldBoxProcessing2D *********************************** */
00244 
00245 template<typename T, int nDim>
00246 void ReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>::processGenericBlocks (
00247         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00248 {
00249     std::vector<TensorField2D<T,nDim>*> fields(atomicBlocks.size());
00250     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00251         fields[iField] = dynamic_cast<TensorField2D<T,nDim>*>(atomicBlocks[iField]);
00252     }
00253     process(domain, fields);
00254 }
00255 
00256 
00257 /* *************** ReductiveNTensorFieldBoxProcessing2D *********************************** */
00258 
00259 template<typename T>
00260 void ReductiveNTensorFieldBoxProcessingFunctional2D<T>::processGenericBlocks (
00261         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00262 {
00263     std::vector<NTensorField2D<T>*> fields(atomicBlocks.size());
00264     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00265         fields[iField] = dynamic_cast<NTensorField2D<T>*>(atomicBlocks[iField]);
00266     }
00267     process(domain, fields);
00268 }
00269 
00270 
00271 /* *************** ReductiveDotProcessing2D_L ******************************************* */
00272 
00273 template<typename T, template<typename U> class Descriptor>
00274 void ReductiveDotProcessingFunctional2D_L<T,Descriptor>::processGenericBlocks (
00275         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00276 {
00277     process(dotList, dynamic_cast<BlockLattice2D<T,Descriptor>&>(*atomicBlocks[0]));
00278 }
00279 
00280 /* *************** ReductiveDotProcessing2D_S ******************************************* */
00281 
00282 template<typename T>
00283 void ReductiveDotProcessingFunctional2D_S<T>::processGenericBlocks (
00284         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00285 {
00286     process(dotList, dynamic_cast<ScalarField2D<T>&>(*atomicBlocks[0]));
00287 }
00288 
00289 /* *************** ReductiveDotProcessing2D_T ******************************************* */
00290 
00291 template<typename T, int nDim>
00292 void ReductiveDotProcessingFunctional2D_T<T,nDim>::processGenericBlocks (
00293         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00294 {
00295     process(dotList, dynamic_cast<TensorField2D<T,nDim>&>(*atomicBlocks[0]));
00296 }
00297 
00298 /* *************** ReductiveDotProcessing2D_N ******************************************* */
00299 
00300 template<typename T>
00301 void ReductiveDotProcessingFunctional2D_N<T>::processGenericBlocks (
00302         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00303 {
00304     process(dotList, dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]));
00305 }
00306 
00307 /* *************** ReductiveDotProcessing2D_LL******************************************* */
00308 
00309 template<typename T1, template<typename U1> class Descriptor1,
00310          typename T2, template<typename U2> class Descriptor2>
00311 void ReductiveDotProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>::processGenericBlocks (
00312         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks ) {
00313     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00314     process ( dotList,
00315               dynamic_cast<BlockLattice2D<T1,Descriptor1>&>(*atomicBlocks[0]),
00316               dynamic_cast<BlockLattice2D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00317 }
00318 
00319 
00320 /* *************** ReductiveDotProcessing2D_SS ****************************************** */
00321 
00322 template<typename T1, typename T2>
00323 void ReductiveDotProcessingFunctional2D_SS<T1,T2>::processGenericBlocks (
00324         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00325 {
00326     process ( dotList,
00327               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00328               dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00329 }
00330 
00331 
00332 /* *************** ReductiveDotProcessing2D_TT ****************************************** */
00333 
00334 template<typename T1, int nDim1, typename T2, int nDim2>
00335 void ReductiveDotProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>::processGenericBlocks (
00336         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00337 {
00338     process ( dotList,
00339               dynamic_cast<TensorField2D<T1,nDim1>&>(*atomicBlocks[0]),
00340               dynamic_cast<TensorField2D<T2,nDim2>&>(*atomicBlocks[1]) );
00341 }
00342 
00343 
00344 /* *************** ReductiveDotProcessing2D_NN ****************************************** */
00345 
00346 template<typename T1, typename T2>
00347 void ReductiveDotProcessingFunctional2D_NN<T1,T2>::processGenericBlocks (
00348         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00349 {
00350     process ( dotList,
00351               dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00352               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00353 }
00354 
00355 
00356 /* *************** ReductiveDotProcessing2D_ST ****************************************** */
00357 
00358 template<typename T1, typename T2, int nDim>
00359 void ReductiveDotProcessingFunctional2D_ST<T1,T2,nDim>::processGenericBlocks (
00360         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00361 {
00362     process ( dotList,
00363               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00364               dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00365 }
00366 
00367 
00368 /* *************** ReductiveDotProcessing2D_SN ****************************************** */
00369 
00370 template<typename T1, typename T2>
00371 void ReductiveDotProcessingFunctional2D_SN<T1,T2>::processGenericBlocks (
00372         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00373 {
00374     process ( dotList,
00375               dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00376               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00377 }
00378 
00379 
00380 /* *************** ReductiveDotProcessing2D_LS ****************************************** */
00381 
00382 template<typename T1, template<typename U> class Descriptor, typename T2>
00383 void ReductiveDotProcessingFunctional2D_LS<T1,Descriptor,T2>::processGenericBlocks (
00384         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00385 {
00386     process ( dotList,
00387               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00388               dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00389 }
00390 
00391 
00392 /* *************** ReductiveDotProcessing2D_LT ****************************************** */
00393 
00394 template<typename T1, template<typename U> class Descriptor,
00395          typename T2, int nDim>
00396 void ReductiveDotProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>::processGenericBlocks (
00397         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00398 {
00399     process ( dotList,
00400               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00401               dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00402 }
00403 
00404 /* *************** ReductiveDotProcessing2D_LN ****************************************** */
00405 
00406 template<typename T1, template<typename U> class Descriptor, typename T2>
00407 void ReductiveDotProcessingFunctional2D_LN<T1,Descriptor,T2>::processGenericBlocks (
00408         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00409 {
00410     process ( dotList,
00411               dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00412               dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00413 }
00414 
00415 /* *************** ReductiveLatticeDotProcessing2D ******************************************* */
00416 
00417 template<typename T, template<typename U> class Descriptor>
00418 void ReductiveLatticeDotProcessingFunctional2D<T,Descriptor>::processGenericBlocks (
00419         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00420 {
00421     std::vector<BlockLattice2D<T,Descriptor>*> lattices(atomicBlocks.size());
00422     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00423         lattices[iLattice] = dynamic_cast<BlockLattice2D<T,Descriptor>*> (
00424                 atomicBlocks[iLattice] );
00425     }
00426     process(dotList, lattices);
00427 }
00428 
00429 /* *************** ReductiveReductiveScalarFieldDotProcessing2D ********************************* */
00430 
00431 template<typename T>
00432 void ReductiveScalarFieldDotProcessingFunctional2D<T>::processGenericBlocks (
00433         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00434 {
00435     std::vector<ScalarField2D<T>*> fields(atomicBlocks.size());
00436     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00437         fields[iField] = dynamic_cast<ScalarField2D<T>*>(atomicBlocks[iField]);
00438     }
00439     process(dotList, fields);
00440 }
00441 
00442 /* *************** ReductiveTensorFieldDotProcessing2D ********************************* */
00443 
00444 template<typename T, int nDim>
00445 void ReductiveTensorFieldDotProcessingFunctional2D<T,nDim>::processGenericBlocks (
00446         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00447 {
00448     std::vector<TensorField2D<T,nDim>*> fields(atomicBlocks.size());
00449     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00450         fields[iField] = dynamic_cast<TensorField2D<T,nDim>*>(atomicBlocks[iField]);
00451     }
00452     process(dotList, fields);
00453 }
00454 
00455 /* *************** ReductiveNTensorFieldDotProcessing2D ********************************* */
00456 
00457 template<typename T>
00458 void ReductiveNTensorFieldDotProcessingFunctional2D<T>::processGenericBlocks (
00459         DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks )
00460 {
00461     std::vector<NTensorField2D<T>*> fields(atomicBlocks.size());
00462     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00463         fields[iField] = dynamic_cast<NTensorField2D<T>*>(atomicBlocks[iField]);
00464     }
00465     process(dotList, fields);
00466 }
00467 
00468 /* *************** BoundedReductiveBoxProcessing2D_L ********************************* */
00469 
00470 template<typename T, template<typename U> class Descriptor>
00471 void BoundedReductiveBoxProcessingFunctional2D_L<T,Descriptor>::processBulkGeneric (
00472         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00473 {
00474     processBulk(domain, dynamic_cast<BlockLattice2D<T,Descriptor>&>(*atomicBlocks[0]));
00475 }
00476 
00477 template<typename T, template<typename U> class Descriptor>
00478 void BoundedReductiveBoxProcessingFunctional2D_L<T,Descriptor>::processEdgeGeneric (
00479         int direction, int orientation,
00480         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00481 {
00482     processEdge(direction, orientation, domain,
00483                 dynamic_cast<BlockLattice2D<T,Descriptor>&>(*atomicBlocks[0]));
00484 }
00485 
00486 template<typename T, template<typename U> class Descriptor>
00487 void BoundedReductiveBoxProcessingFunctional2D_L<T,Descriptor>::processCornerGeneric (
00488         int normalX, int normalY,
00489         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00490 {
00491     processCorner(normalX, normalY, domain,
00492                   dynamic_cast<BlockLattice2D<T,Descriptor>&>(*atomicBlocks[0]));
00493 }
00494 
00495 /* *************** BoundedReductiveBoxProcessing2D_S ******************************************* */
00496 
00497 template<typename T>
00498 void BoundedReductiveBoxProcessingFunctional2D_S<T>::processBulkGeneric (
00499         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00500 {
00501     processBulk(domain, dynamic_cast<ScalarField2D<T>&>(*atomicBlocks[0]));
00502 }
00503 
00504 template<typename T>
00505 void BoundedReductiveBoxProcessingFunctional2D_S<T>::processEdgeGeneric (
00506         int direction, int orientation,
00507         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00508 {
00509     processEdge(direction, orientation, domain,
00510                 dynamic_cast<ScalarField2D<T>&>(*atomicBlocks[0]));
00511 }
00512 
00513 template<typename T>
00514 void BoundedReductiveBoxProcessingFunctional2D_S<T>::processCornerGeneric (
00515         int normalX, int normalY,
00516         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00517 {
00518     processCorner(normalX, normalY, domain,
00519                   dynamic_cast<ScalarField2D<T>&>(*atomicBlocks[0]));
00520 }
00521 
00522 /* *************** BoundedReductiveBoxProcessing2D_T ********************************* */
00523 
00524 template<typename T, int nDim>
00525 void BoundedReductiveBoxProcessingFunctional2D_T<T,nDim>::processBulkGeneric (
00526         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00527 {
00528     processBulk(domain, dynamic_cast<TensorField2D<T,nDim>&>(*atomicBlocks[0]));
00529 }
00530 
00531 template<typename T, int nDim>
00532 void BoundedReductiveBoxProcessingFunctional2D_T<T,nDim>::processEdgeGeneric (
00533         int direction, int orientation,
00534         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00535 {
00536     processEdge(direction, orientation, domain,
00537                 dynamic_cast<TensorField2D<T,nDim>&>(*atomicBlocks[0]));
00538 }
00539 
00540 template<typename T, int nDim>
00541 void BoundedReductiveBoxProcessingFunctional2D_T<T,nDim>::processCornerGeneric (
00542         int normalX, int normalY,
00543         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00544 {
00545     processCorner(normalX, normalY, domain,
00546                   dynamic_cast<TensorField2D<T,nDim>&>(*atomicBlocks[0]));
00547 }
00548 
00549 /* *************** BoundedReductiveBoxProcessing2D_N ********************************* */
00550 
00551 template<typename T>
00552 void BoundedReductiveBoxProcessingFunctional2D_N<T>::processBulkGeneric (
00553         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00554 {
00555     processBulk(domain, dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]));
00556 }
00557 
00558 template<typename T>
00559 void BoundedReductiveBoxProcessingFunctional2D_N<T>::processEdgeGeneric (
00560         int direction, int orientation,
00561         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00562 {
00563     processEdge(direction, orientation, domain,
00564                 dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]));
00565 }
00566 
00567 template<typename T>
00568 void BoundedReductiveBoxProcessingFunctional2D_N<T>::processCornerGeneric (
00569         int normalX, int normalY,
00570         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00571 {
00572     processCorner(normalX, normalY, domain,
00573                   dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]));
00574 }
00575 
00576 /* *************** BoundedMaskedReductiveBoxProcessing2D_N ********************************* */
00577 
00578 template<typename T>
00579 void BoundedMaskedReductiveBoxProcessingFunctional2D_N<T>::processBulkGeneric (
00580         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00581 {
00582     processBulk(domain,
00583                 dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]),
00584                 dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[1]));
00585 }
00586 
00587 template<typename T>
00588 void BoundedMaskedReductiveBoxProcessingFunctional2D_N<T>::processEdgeGeneric (
00589         int direction, int orientation,
00590         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00591 {
00592     processEdge(direction, orientation, domain,
00593                 dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]),
00594                 dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[1]));
00595 }
00596 
00597 template<typename T>
00598 void BoundedMaskedReductiveBoxProcessingFunctional2D_N<T>::processCornerGeneric (
00599         int normalX, int normalY,
00600         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00601 {
00602     processCorner(normalX, normalY, domain,
00603                   dynamic_cast<NTensorField2D<T>&>(*atomicBlocks[0]),
00604                   dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[1]));
00605 }
00606 
00607 /* *************** BoundedReductiveBoxProcessing2D_LL ****************************************** */
00608 
00609 template<typename T1, template<typename U1> class Descriptor1,
00610          typename T2, template<typename U2> class Descriptor2>
00611 void BoundedReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>::
00612     processBulkGeneric( Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00613 {
00614     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00615     processBulk( domain,
00616                  dynamic_cast<BlockLattice2D<T1,Descriptor1>&>(*atomicBlocks[0]),
00617                  dynamic_cast<BlockLattice2D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00618 }
00619 
00620 template<typename T1, template<typename U1> class Descriptor1,
00621          typename T2, template<typename U2> class Descriptor2>
00622 void BoundedReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>::
00623     processEdgeGeneric( int direction, int orientation,
00624                         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00625 {
00626     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00627     processEdge( direction, orientation, domain,
00628                  dynamic_cast<BlockLattice2D<T1,Descriptor1>&>(*atomicBlocks[0]),
00629                  dynamic_cast<BlockLattice2D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00630 }
00631 
00632 template<typename T1, template<typename U1> class Descriptor1,
00633          typename T2, template<typename U2> class Descriptor2>
00634 void BoundedReductiveBoxProcessingFunctional2D_LL<T1,Descriptor1,T2,Descriptor2>::
00635     processCornerGeneric( int normalX, int normalY,
00636                           Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00637 {
00638     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00639     processCorner( normalX, normalY, domain,
00640                    dynamic_cast<BlockLattice2D<T1,Descriptor1>&>(*atomicBlocks[0]),
00641                    dynamic_cast<BlockLattice2D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00642 }
00643 
00644 /* *************** BoundedReductiveBoxProcessing2D_SS ****************************************** */
00645 
00646 template<typename T1, typename T2>
00647 void BoundedReductiveBoxProcessingFunctional2D_SS<T1,T2>::processBulkGeneric (
00648         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00649 {
00650     processBulk( domain,
00651                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00652                  dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00653 }
00654 
00655 template<typename T1, typename T2>
00656 void BoundedReductiveBoxProcessingFunctional2D_SS<T1,T2>::processEdgeGeneric (
00657         int direction, int orientation,
00658         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00659 {
00660     processEdge( direction, orientation, domain,
00661                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00662                  dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00663 }
00664 
00665 template<typename T1, typename T2>
00666 void BoundedReductiveBoxProcessingFunctional2D_SS<T1,T2>::processCornerGeneric (
00667         int normalX, int normalY,
00668         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00669 {
00670     processCorner( normalX, normalY, domain,
00671                    dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00672                    dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00673 }
00674 
00675 /* *************** BoundedReductiveBoxProcessing2D_TT ****************************************** */
00676 
00677 template<typename T1, int nDim1, typename T2, int nDim2>
00678 void BoundedReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>::processBulkGeneric (
00679         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00680 {
00681     processBulk( domain,
00682                  dynamic_cast<TensorField2D<T1,nDim1>&>(*atomicBlocks[0]),
00683                  dynamic_cast<TensorField2D<T2,nDim2>&>(*atomicBlocks[1]) );
00684 }
00685 
00686 template<typename T1, int nDim1, typename T2, int nDim2>
00687 void BoundedReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>::processEdgeGeneric (
00688         int direction, int orientation,
00689         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00690 {
00691     processEdge( direction, orientation, domain,
00692                  dynamic_cast<TensorField2D<T1,nDim1>&>(*atomicBlocks[0]),
00693                  dynamic_cast<TensorField2D<T2,nDim2>&>(*atomicBlocks[1]) );
00694 }
00695 
00696 template<typename T1, int nDim1, typename T2, int nDim2>
00697 void BoundedReductiveBoxProcessingFunctional2D_TT<T1,nDim1,T2,nDim2>::processCornerGeneric (
00698         int normalX, int normalY,
00699         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00700 {
00701     processCorner( normalX, normalY, domain,
00702                    dynamic_cast<TensorField2D<T1,nDim1>&>(*atomicBlocks[0]),
00703                    dynamic_cast<TensorField2D<T2,nDim2>&>(*atomicBlocks[1]) );
00704 }
00705 
00706 /* *************** BoundedReductiveBoxProcessing2D_NN ****************************************** */
00707 
00708 template<typename T1, typename T2>
00709 void BoundedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processBulkGeneric (
00710         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00711 {
00712     processBulk( domain,
00713                  dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00714                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00715 }
00716 
00717 template<typename T1, typename T2>
00718 void BoundedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processEdgeGeneric (
00719         int direction, int orientation,
00720         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00721 {
00722     processEdge( direction, orientation, domain,
00723                  dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00724                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00725 }
00726 
00727 template<typename T1, typename T2>
00728 void BoundedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processCornerGeneric (
00729         int normalX, int normalY,
00730         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00731 {
00732     processCorner( normalX, normalY, domain,
00733                    dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00734                    dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00735 }
00736 
00737 /* *************** BoundedMaskedReductiveBoxProcessing2D_NN ****************************************** */
00738 
00739 template<typename T1, typename T2>
00740 void BoundedMaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processBulkGeneric (
00741         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00742 {
00743     processBulk( domain,
00744                  dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00745                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00746                  dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00747 }
00748 
00749 template<typename T1, typename T2>
00750 void BoundedMaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processEdgeGeneric (
00751         int direction, int orientation,
00752         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00753 {
00754     processEdge( direction, orientation, domain,
00755                  dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00756                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00757                  dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00758 }
00759 
00760 template<typename T1, typename T2>
00761 void BoundedMaskedReductiveBoxProcessingFunctional2D_NN<T1,T2>::processCornerGeneric (
00762         int normalX, int normalY,
00763         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00764 {
00765     processCorner( normalX, normalY, domain,
00766                    dynamic_cast<NTensorField2D<T1>&>(*atomicBlocks[0]),
00767                    dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00768                    dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00769 }
00770 
00771 /* *************** BoundedReductiveBoxProcessing2D_ST ****************************************** */
00772 
00773 template<typename T1, typename T2, int nDim>
00774 void BoundedReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>::processBulkGeneric (
00775         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00776 {
00777     processBulk( domain,
00778                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00779                  dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00780 }
00781 
00782 template<typename T1, typename T2, int nDim>
00783 void BoundedReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>::processEdgeGeneric (
00784         int direction, int orientation,
00785         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00786 {
00787     processEdge( direction, orientation, domain,
00788                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00789                  dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00790 }
00791 
00792 template<typename T1, typename T2, int nDim>
00793 void BoundedReductiveBoxProcessingFunctional2D_ST<T1,T2,nDim>::processCornerGeneric (
00794         int normalX, int normalY,
00795         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00796 {
00797     processCorner( normalX, normalY, domain,
00798                    dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00799                    dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00800 }
00801 
00802 /* *************** BoundedReductiveBoxProcessing2D_SN ****************************************** */
00803 
00804 template<typename T1, typename T2>
00805 void BoundedReductiveBoxProcessingFunctional2D_SN<T1,T2>::processBulkGeneric (
00806         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00807 {
00808     processBulk( domain,
00809                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00810                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00811 }
00812 
00813 template<typename T1, typename T2>
00814 void BoundedReductiveBoxProcessingFunctional2D_SN<T1,T2>::processEdgeGeneric (
00815         int direction, int orientation,
00816         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00817 {
00818     processEdge( direction, orientation, domain,
00819                  dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00820                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00821 }
00822 
00823 template<typename T1, typename T2>
00824 void BoundedReductiveBoxProcessingFunctional2D_SN<T1,T2>::processCornerGeneric (
00825         int normalX, int normalY,
00826         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00827 {
00828     processCorner( normalX, normalY, domain,
00829                    dynamic_cast<ScalarField2D<T1>&>(*atomicBlocks[0]),
00830                    dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00831 }
00832 
00833 /* *************** BoundedReductiveBoxProcessing2D_LS ****************************************** */
00834 
00835 template<typename T1, template<typename U> class Descriptor, typename T2>
00836 void BoundedReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>::processBulkGeneric (
00837         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00838 {
00839     processBulk( domain,
00840                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00841                  dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00842 }
00843 
00844 template<typename T1, template<typename U> class Descriptor, typename T2>
00845 void BoundedReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>::processEdgeGeneric (
00846         int direction, int orientation,
00847         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00848 {
00849     processEdge( direction, orientation, domain,
00850                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00851                  dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00852 }
00853 
00854 template<typename T1, template<typename U> class Descriptor, typename T2>
00855 void BoundedReductiveBoxProcessingFunctional2D_LS<T1,Descriptor,T2>::processCornerGeneric (
00856         int normalX, int normalY,
00857         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00858 {
00859     processCorner( normalX, normalY, domain,
00860                    dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00861                    dynamic_cast<ScalarField2D<T2>&>(*atomicBlocks[1]) );
00862 }
00863 
00864 /* *************** BoundedReductiveBoxProcessing2D_LT ****************************************** */
00865 
00866 template<typename T1, template<typename U> class Descriptor,
00867          typename T2, int nDim>
00868 void BoundedReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>::processBulkGeneric (
00869         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00870 {
00871     processBulk( domain,
00872                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00873                  dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00874 }
00875 
00876 template<typename T1, template<typename U> class Descriptor,
00877          typename T2, int nDim>
00878 void BoundedReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>::processEdgeGeneric (
00879         int direction, int orientation,
00880         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00881 {
00882     processEdge( direction, orientation, domain,
00883                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00884                  dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00885 }
00886 
00887 template<typename T1, template<typename U> class Descriptor,
00888          typename T2, int nDim>
00889 void BoundedReductiveBoxProcessingFunctional2D_LT<T1,Descriptor,T2,nDim>::processCornerGeneric (
00890         int normalX, int normalY,
00891         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00892 {
00893     processCorner( normalX, normalY, domain,
00894                    dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00895                    dynamic_cast<TensorField2D<T2,nDim>&>(*atomicBlocks[1]) );
00896 }
00897 
00898 /* *************** BoundedReductiveBoxProcessing2D_LN ****************************************** */
00899 
00900 template<typename T1, template<typename U> class Descriptor, typename T2>
00901 void BoundedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processBulkGeneric (
00902         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00903 {
00904     processBulk( domain,
00905                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00906                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00907 }
00908 
00909 template<typename T1, template<typename U> class Descriptor, typename T2>
00910 void BoundedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processEdgeGeneric (
00911         int direction, int orientation,
00912         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00913 {
00914     processEdge( direction, orientation, domain,
00915                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00916                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00917 }
00918 
00919 template<typename T1, template<typename U> class Descriptor, typename T2>
00920 void BoundedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processCornerGeneric (
00921         int normalX, int normalY,
00922         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00923 {
00924     processCorner( normalX, normalY, domain,
00925                    dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00926                    dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]) );
00927 }
00928 
00929 /* *************** BoundedMaskedReductiveBoxProcessing2D_LN ****************************************** */
00930 
00931 template<typename T1, template<typename U> class Descriptor, typename T2>
00932 void BoundedMaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processBulkGeneric (
00933         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00934 {
00935     processBulk( domain,
00936                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00937                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00938                  dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00939 }
00940 
00941 template<typename T1, template<typename U> class Descriptor, typename T2>
00942 void BoundedMaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processEdgeGeneric (
00943         int direction, int orientation,
00944         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00945 {
00946     processEdge( direction, orientation, domain,
00947                  dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00948                  dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00949                  dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00950 }
00951 
00952 template<typename T1, template<typename U> class Descriptor, typename T2>
00953 void BoundedMaskedReductiveBoxProcessingFunctional2D_LN<T1,Descriptor,T2>::processCornerGeneric (
00954         int normalX, int normalY,
00955         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00956 {
00957     processCorner( normalX, normalY, domain,
00958                    dynamic_cast<BlockLattice2D<T1,Descriptor>&>(*atomicBlocks[0]),
00959                    dynamic_cast<NTensorField2D<T2>&>(*atomicBlocks[1]),
00960                    dynamic_cast<NTensorField2D<int>&>(*atomicBlocks[2]) );
00961 }
00962 
00963 /* *************** BoundedReductiveLatticeBoxProcessing2D ********************************* */
00964 
00965 template<typename T, template<typename U> class Descriptor>
00966 void BoundedReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>::processBulkGeneric (
00967         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00968 {
00969     std::vector<BlockLattice2D<T,Descriptor>*> lattices(atomicBlocks.size());
00970     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00971         lattices[iLattice] = dynamic_cast<BlockLattice2D<T,Descriptor>*> (
00972                 atomicBlocks[iLattice] );
00973     }
00974     processBulk(domain, lattices);
00975 }
00976 
00977 template<typename T, template<typename U> class Descriptor>
00978 void BoundedReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>::processEdgeGeneric (
00979         int direction, int orientation,
00980         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00981 {
00982     std::vector<BlockLattice2D<T,Descriptor>*> lattices(atomicBlocks.size());
00983     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00984         lattices[iLattice] = dynamic_cast<BlockLattice2D<T,Descriptor>*> (
00985                 atomicBlocks[iLattice] );
00986     }
00987     processEdge(direction, orientation, domain, lattices);
00988 }
00989 
00990 template<typename T, template<typename U> class Descriptor>
00991 void BoundedReductiveLatticeBoxProcessingFunctional2D<T,Descriptor>::processCornerGeneric (
00992         int normalX, int normalY,
00993         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
00994 {
00995     std::vector<BlockLattice2D<T,Descriptor>*> lattices(atomicBlocks.size());
00996     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00997         lattices[iLattice] = dynamic_cast<BlockLattice2D<T,Descriptor>*> (
00998                 atomicBlocks[iLattice] );
00999     }
01000     processCorner(normalX, normalY, domain, lattices);
01001 }
01002 
01003 /* *************** BoundedReductiveScalarFieldBoxProcessing2D ************************ */
01004 
01005 template<typename T>
01006 void BoundedReductiveScalarFieldBoxProcessingFunctional2D<T>::processBulkGeneric (
01007         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01008 {
01009     std::vector<ScalarField2D<T>*> fields(atomicBlocks.size());
01010     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01011         fields[iField] = dynamic_cast<ScalarField2D<T>*>(atomicBlocks[iField]);
01012     }
01013     processBulk(domain, fields);
01014 }
01015 
01016 template<typename T>
01017 void BoundedReductiveScalarFieldBoxProcessingFunctional2D<T>::processEdgeGeneric (
01018         int direction, int orientation,
01019         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01020 {
01021     std::vector<ScalarField2D<T>*> fields(atomicBlocks.size());
01022     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01023         fields[iField] = dynamic_cast<ScalarField2D<T>*>(atomicBlocks[iField]);
01024     }
01025     processEdge(direction, orientation, domain, fields);
01026 }
01027 
01028 template<typename T>
01029 void BoundedReductiveScalarFieldBoxProcessingFunctional2D<T>::processCornerGeneric (
01030         int normalX, int normalY,
01031         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01032 {
01033     std::vector<ScalarField2D<T>*> fields(atomicBlocks.size());
01034     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01035         fields[iField] = dynamic_cast<ScalarField2D<T>*>(atomicBlocks[iField]);
01036     }
01037     processCorner(normalX, normalY, domain, fields);
01038 }
01039 
01040 
01041 /* *************** BoundedReductiveTensorFieldBoxProcessing2D ************************ */
01042 
01043 template<typename T, int nDim>
01044 void BoundedReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>::processBulkGeneric (
01045         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01046 {
01047     std::vector<TensorField2D<T,nDim>*> fields(atomicBlocks.size());
01048     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01049         fields[iField] = dynamic_cast<TensorField2D<T,nDim>*>(atomicBlocks[iField]);
01050     }
01051     processBulk(domain, fields);
01052 }
01053 
01054 template<typename T, int nDim>
01055 void BoundedReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>::processEdgeGeneric (
01056         int direction, int orientation,
01057         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01058 {
01059     std::vector<TensorField2D<T,nDim>*> fields(atomicBlocks.size());
01060     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01061         fields[iField] = dynamic_cast<TensorField2D<T,nDim>*>(atomicBlocks[iField]);
01062     }
01063     processEdge(direction, orientation, domain, fields);
01064 }
01065 
01066 template<typename T, int nDim>
01067 void BoundedReductiveTensorFieldBoxProcessingFunctional2D<T,nDim>::processCornerGeneric (
01068         int normalX, int normalY,
01069         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01070 {
01071     std::vector<TensorField2D<T,nDim>*> fields(atomicBlocks.size());
01072     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01073         fields[iField] = dynamic_cast<TensorField2D<T,nDim>*>(atomicBlocks[iField]);
01074     }
01075     processCorner(normalX, normalY, domain, fields);
01076 }
01077 
01078 /* *************** BoundedReductiveNTensorFieldBoxProcessing2D ************************ */
01079 
01080 template<typename T>
01081 void BoundedReductiveNTensorFieldBoxProcessingFunctional2D<T>::processBulkGeneric (
01082         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01083 {
01084     std::vector<NTensorField2D<T>*> fields(atomicBlocks.size());
01085     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01086         fields[iField] = dynamic_cast<NTensorField2D<T>*>(atomicBlocks[iField]);
01087     }
01088     processBulk(domain, fields);
01089 }
01090 
01091 template<typename T>
01092 void BoundedReductiveNTensorFieldBoxProcessingFunctional2D<T>::processEdgeGeneric (
01093         int direction, int orientation,
01094         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01095 {
01096     std::vector<NTensorField2D<T>*> fields(atomicBlocks.size());
01097     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01098         fields[iField] = dynamic_cast<NTensorField2D<T>*>(atomicBlocks[iField]);
01099     }
01100     processEdge(direction, orientation, domain, fields);
01101 }
01102 
01103 template<typename T>
01104 void BoundedReductiveNTensorFieldBoxProcessingFunctional2D<T>::processCornerGeneric (
01105         int normalX, int normalY,
01106         Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks )
01107 {
01108     std::vector<NTensorField2D<T>*> fields(atomicBlocks.size());
01109     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01110         fields[iField] = dynamic_cast<NTensorField2D<T>*>(atomicBlocks[iField]);
01111     }
01112     processCorner(normalX, normalY, domain, fields);
01113 }
01114 
01115 }  // namespace plb
01116 
01117 #endif  // REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_2D_HH