$treeview $search $mathjax
Palabos  Version 1.1
$projectbrief
$projectbrief
 $searchbox

reductiveDataProcessingFunctional3D.hh

Go to the documentation of this file.
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_3D_HH
00027 #define REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_3D_HH
00028 
00029 #include "atomicBlock/reductiveDataProcessorWrapper3D.h"
00030 #include "atomicBlock/blockLattice3D.h"
00031 #include "atomicBlock/dataField3D.h"
00032 #include "atomicBlock/dataProcessor3D.h"
00033 #include "core/plbDebug.h"
00034 
00035 namespace plb {
00036 
00037 /* *************** ReductiveBoxProcessing3D_L ******************************************* */
00038 
00039 template<typename T, template<typename U> class Descriptor>
00040 void ReductiveBoxProcessingFunctional3D_L<T,Descriptor>::processGenericBlocks (
00041         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00042 {
00043     process(domain, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00044 }
00045 
00046 /* *************** ReductiveBoxProcessing3D_S ******************************************* */
00047 
00048 template<typename T>
00049 void ReductiveBoxProcessingFunctional3D_S<T>::processGenericBlocks (
00050         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00051 {
00052     process(domain, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00053 }
00054 
00055 /* *************** ReductiveBoxProcessing3D_T ******************************************* */
00056 
00057 template<typename T, int nDim>
00058 void ReductiveBoxProcessingFunctional3D_T<T,nDim>::processGenericBlocks (
00059         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00060 {
00061     process(domain, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00062 }
00063 
00064 /* *************** ReductiveBoxProcessing3D_N ******************************************* */
00065 
00066 template<typename T>
00067 void ReductiveBoxProcessingFunctional3D_N<T>::processGenericBlocks (
00068         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00069 {
00070     process(domain, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00071 }
00072 
00073 /* *************** ReductiveBoxProcessing3D_N ******************************************* */
00074 
00075 template<typename T>
00076 void MaskedReductiveBoxProcessingFunctional3D_N<T>::processGenericBlocks (
00077         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00078 {
00079     process(domain,
00080             dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]),
00081             dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[1]));
00082 }
00083 
00084 /* *************** ReductiveBoxProcessing3D_LL******************************************* */
00085 
00086 template<typename T1, template<typename U1> class Descriptor1,
00087          typename T2, template<typename U2> class Descriptor2>
00088 void ReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processGenericBlocks (
00089         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00090 {
00091     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00092     process ( domain,
00093               dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00094               dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00095 }
00096 
00097 
00098 /* *************** ReductiveBoxProcessing3D_SS ****************************************** */
00099 
00100 template<typename T1, typename T2>
00101 void ReductiveBoxProcessingFunctional3D_SS<T1,T2>::processGenericBlocks (
00102         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00103 {
00104     process ( domain,
00105               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00106               dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00107 }
00108 
00109 
00110 /* *************** ReductiveBoxProcessing3D_TT ****************************************** */
00111 
00112 template<typename T1, int nDim1, typename T2, int nDim2>
00113 void ReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processGenericBlocks (
00114         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00115 {
00116     process ( domain,
00117               dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00118               dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00119 }
00120 
00121 /* *************** ReductiveBoxProcessing3D_NN ****************************************** */
00122 
00123 template<typename T1, typename T2>
00124 void ReductiveBoxProcessingFunctional3D_NN<T1,T2>::processGenericBlocks (
00125         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00126 {
00127     process ( domain,
00128               dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00129               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00130 }
00131 
00132 
00133 /* *************** ReductiveBoxProcessing3D_NN ****************************************** */
00134 
00135 template<typename T1, typename T2>
00136 void MaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processGenericBlocks (
00137         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00138 {
00139     process ( domain,
00140               dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00141               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00142               dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
00143 }
00144 
00145 
00146 /* *************** ReductiveBoxProcessing3D_ST ****************************************** */
00147 
00148 template<typename T1, typename T2, int nDim>
00149 void ReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>::processGenericBlocks (
00150         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00151 {
00152     process ( domain,
00153               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00154               dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00155 }
00156 
00157 /* *************** ReductiveBoxProcessing3D_SN ****************************************** */
00158 
00159 template<typename T1, typename T2>
00160 void ReductiveBoxProcessingFunctional3D_SN<T1,T2>::processGenericBlocks (
00161         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00162 {
00163     process ( domain,
00164               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00165               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00166 }
00167 
00168 
00169 /* *************** ReductiveBoxProcessing3D_LS ****************************************** */
00170 
00171 template<typename T1, template<typename U> class Descriptor, typename T2>
00172 void ReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>::processGenericBlocks (
00173         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00174 {
00175     process ( domain,
00176               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00177               dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00178 }
00179 
00180 /* *************** ReductiveBoxProcessing3D_LT ****************************************** */
00181 
00182 template<typename T1, template<typename U> class Descriptor,
00183          typename T2, int nDim>
00184 void ReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processGenericBlocks (
00185         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00186 {
00187     process ( domain,
00188               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00189               dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00190 }
00191 
00192 /* *************** ReductiveBoxProcessing3D_LN ****************************************** */
00193 
00194 template<typename T1, template<typename U> class Descriptor, typename T2>
00195 void ReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processGenericBlocks (
00196         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00197 {
00198     process ( domain,
00199               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00200               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00201 }
00202 
00203 /* *************** MaskedReductiveBoxProcessing3D_LN ****************************************** */
00204 
00205 template<typename T1, template<typename U> class Descriptor, typename T2>
00206 void MaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processGenericBlocks (
00207         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00208 {
00209     process ( domain,
00210               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00211               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00212               dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
00213 }
00214 
00215 /* *************** ReductiveLatticeBoxProcessing3D ************************************** */
00216 
00217 template<typename T, template<typename U> class Descriptor>
00218 void ReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>::processGenericBlocks (
00219         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00220 {
00221     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
00222     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00223         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*>(atomicBlocks[iLattice]);
00224     }
00225     process(domain, lattices);
00226 }
00227 
00228 /* *************** ReductiveScalarFieldBoxProcessing3D *********************************** */
00229 
00230 template<typename T>
00231 void ReductiveScalarFieldBoxProcessingFunctional3D<T>::processGenericBlocks (
00232         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00233 {
00234     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
00235     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00236         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
00237     }
00238     process(domain, fields);
00239 }
00240 
00241 /* *************** ReductiveTensorFieldBoxProcessing3D *********************************** */
00242 
00243 template<typename T, int nDim>
00244 void ReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>::processGenericBlocks (
00245         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00246 {
00247     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
00248     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00249         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
00250     }
00251     process(domain, fields);
00252 }
00253 
00254 /* *************** ReductiveNTensorFieldBoxProcessing3D *********************************** */
00255 
00256 template<typename T>
00257 void ReductiveNTensorFieldBoxProcessingFunctional3D<T>::processGenericBlocks (
00258         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00259 {
00260     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
00261     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00262         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
00263     }
00264     process(domain, fields);
00265 }
00266 
00267 
00268 /* *************** ReductiveDotProcessing3D_L ******************************************* */
00269 
00270 template<typename T, template<typename U> class Descriptor>
00271 void ReductiveDotProcessingFunctional3D_L<T,Descriptor>::processGenericBlocks (
00272         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00273 {
00274     process(dotList, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00275 }
00276 
00277 /* *************** ReductiveDotProcessing3D_S ******************************************* */
00278 
00279 template<typename T>
00280 void ReductiveDotProcessingFunctional3D_S<T>::processGenericBlocks (
00281         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00282 {
00283     process(dotList, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00284 }
00285 
00286 /* *************** ReductiveDotProcessing3D_T ******************************************* */
00287 
00288 template<typename T, int nDim>
00289 void ReductiveDotProcessingFunctional3D_T<T,nDim>::processGenericBlocks (
00290         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00291 {
00292     process(dotList, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00293 }
00294 
00295 /* *************** ReductiveDotProcessing3D_N ******************************************* */
00296 
00297 template<typename T>
00298 void ReductiveDotProcessingFunctional3D_N<T>::processGenericBlocks (
00299         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00300 {
00301     process(dotList, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00302 }
00303 
00304 /* *************** ReductiveDotProcessing3D_LL******************************************* */
00305 
00306 template<typename T1, template<typename U1> class Descriptor1,
00307          typename T2, template<typename U2> class Descriptor2>
00308 void ReductiveDotProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processGenericBlocks (
00309         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks ) {
00310     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00311     process ( dotList,
00312               dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00313               dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00314 }
00315 
00316 
00317 /* *************** ReductiveDotProcessing3D_SS ****************************************** */
00318 
00319 template<typename T1, typename T2>
00320 void ReductiveDotProcessingFunctional3D_SS<T1,T2>::processGenericBlocks (
00321         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00322 {
00323     process ( dotList,
00324               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00325               dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00326 }
00327 
00328 
00329 /* *************** ReductiveDotProcessing3D_TT ****************************************** */
00330 
00331 template<typename T1, int nDim1, typename T2, int nDim2>
00332 void ReductiveDotProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processGenericBlocks (
00333         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00334 {
00335     process ( dotList,
00336               dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00337               dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00338 }
00339 
00340 /* *************** ReductiveDotProcessing3D_NN ****************************************** */
00341 
00342 template<typename T1, typename T2>
00343 void ReductiveDotProcessingFunctional3D_NN<T1,T2>::processGenericBlocks (
00344         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00345 {
00346     process ( dotList,
00347               dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00348               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00349 }
00350 
00351 
00352 /* *************** ReductiveDotProcessing3D_ST ****************************************** */
00353 
00354 template<typename T1, typename T2, int nDim>
00355 void ReductiveDotProcessingFunctional3D_ST<T1,T2,nDim>::processGenericBlocks (
00356         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00357 {
00358     process ( dotList,
00359               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00360               dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00361 }
00362 
00363 /* *************** ReductiveDotProcessing3D_SN ****************************************** */
00364 
00365 template<typename T1, typename T2>
00366 void ReductiveDotProcessingFunctional3D_SN<T1,T2>::processGenericBlocks (
00367         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00368 {
00369     process ( dotList,
00370               dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00371               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00372 }
00373 
00374 
00375 /* *************** ReductiveDotProcessing3D_LS ****************************************** */
00376 
00377 template<typename T1, template<typename U> class Descriptor, typename T2>
00378 void ReductiveDotProcessingFunctional3D_LS<T1,Descriptor,T2>::processGenericBlocks (
00379         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00380 {
00381     process ( dotList,
00382               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00383               dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00384 }
00385 
00386 
00387 /* *************** ReductiveDotProcessing3D_LT ****************************************** */
00388 
00389 template<typename T1, template<typename U> class Descriptor,
00390          typename T2, int nDim>
00391 void ReductiveDotProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processGenericBlocks (
00392         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00393 {
00394     process ( dotList,
00395               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00396               dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00397 }
00398 
00399 /* *************** ReductiveDotProcessing3D_LN ****************************************** */
00400 
00401 template<typename T1, template<typename U> class Descriptor, typename T2>
00402 void ReductiveDotProcessingFunctional3D_LN<T1,Descriptor,T2>::processGenericBlocks (
00403         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00404 {
00405     process ( dotList,
00406               dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00407               dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00408 }
00409 
00410 /* *************** ReductiveLatticeDotProcessing3D ******************************************* */
00411 
00412 template<typename T, template<typename U> class Descriptor>
00413 void ReductiveLatticeDotProcessingFunctional3D<T,Descriptor>::processGenericBlocks (
00414         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00415 {
00416     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
00417     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
00418         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*> (
00419                 atomicBlocks[iLattice] );
00420     }
00421     process(dotList, lattices);
00422 }
00423 
00424 /* *************** ReductiveReductiveScalarFieldDotProcessing3D ********************************* */
00425 
00426 template<typename T>
00427 void ReductiveScalarFieldDotProcessingFunctional3D<T>::processGenericBlocks (
00428         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00429 {
00430     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
00431     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00432         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
00433     }
00434     process(dotList, fields);
00435 }
00436 
00437 /* *************** ReductiveTensorFieldDotProcessing3D ********************************* */
00438 
00439 template<typename T, int nDim>
00440 void ReductiveTensorFieldDotProcessingFunctional3D<T,nDim>::processGenericBlocks (
00441         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00442 {
00443     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
00444     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00445         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
00446     }
00447     process(dotList, fields);
00448 }
00449 
00450 /* *************** ReductiveNTensorFieldDotProcessing3D ********************************* */
00451 
00452 template<typename T>
00453 void ReductiveNTensorFieldDotProcessingFunctional3D<T>::processGenericBlocks (
00454         DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks )
00455 {
00456     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
00457     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
00458         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
00459     }
00460     process(dotList, fields);
00461 }
00462 
00463 /* *************** BoundedReductiveBoxProcessing3D_L ******************************************* */
00464 
00465 template<typename T, template<typename U> class Descriptor>
00466 void BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>::processBulkGeneric (
00467         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00468 {
00469     processBulk(domain, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00470 }
00471 
00472 template<typename T, template<typename U> class Descriptor>
00473 void BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>::processPlaneGeneric (
00474         int direction, int orientation,
00475         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00476 {
00477     processPlane(direction, orientation, domain, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00478 }
00479 
00480 template<typename T, template<typename U> class Descriptor>
00481 void BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>::processEdgeGeneric (
00482         int plane, int normal1, int normal2,
00483         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00484 {
00485     processEdge(plane,normal1,normal2, domain, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00486 }
00487 
00488 template<typename T, template<typename U> class Descriptor>
00489 void BoundedReductiveBoxProcessingFunctional3D_L<T,Descriptor>::processCornerGeneric (
00490         int normalX, int normalY, int normalZ,
00491         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00492 {
00493     processCorner(normalX, normalY, normalZ, domain, dynamic_cast<BlockLattice3D<T,Descriptor>&>(*atomicBlocks[0]));
00494 }
00495 
00496 /* *************** BoundedReductiveBoxProcessing3D_S ******************************************* */
00497 
00498 template<typename T>
00499 void BoundedReductiveBoxProcessingFunctional3D_S<T>::processBulkGeneric (
00500         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00501 {
00502     processBulk(domain, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00503 }
00504 
00505 template<typename T>
00506 void BoundedReductiveBoxProcessingFunctional3D_S<T>::processPlaneGeneric (
00507         int direction, int orientation,
00508         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00509 {
00510     processPlane(direction, orientation, domain, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00511 }
00512 
00513 template<typename T>
00514 void BoundedReductiveBoxProcessingFunctional3D_S<T>::processEdgeGeneric (
00515         int plane, int normal1, int normal2,
00516         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00517 {
00518     processEdge(plane,normal1,normal2, domain, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00519 }
00520 
00521 template<typename T>
00522 void BoundedReductiveBoxProcessingFunctional3D_S<T>::processCornerGeneric (
00523         int normalX, int normalY, int normalZ,
00524         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00525 {
00526     processCorner(normalX, normalY, normalZ, domain, dynamic_cast<ScalarField3D<T>&>(*atomicBlocks[0]));
00527 }
00528 
00529 /* *************** BoundedReductiveBoxProcessing3D_T ******************************************* */
00530 
00531 template<typename T, int nDim>
00532 void BoundedReductiveBoxProcessingFunctional3D_T<T,nDim>::processBulkGeneric (
00533         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00534 {
00535     processBulk(domain, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00536 }
00537 
00538 template<typename T, int nDim>
00539 void BoundedReductiveBoxProcessingFunctional3D_T<T,nDim>::processPlaneGeneric (
00540         int direction, int orientation,
00541         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00542 {
00543     processPlane(direction, orientation, domain, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00544 }
00545 
00546 template<typename T, int nDim>
00547 void BoundedReductiveBoxProcessingFunctional3D_T<T,nDim>::processEdgeGeneric (
00548         int plane, int normal1, int normal2,
00549         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00550 {
00551     processEdge(plane,normal1,normal2, domain, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00552 }
00553 
00554 template<typename T, int nDim>
00555 void BoundedReductiveBoxProcessingFunctional3D_T<T,nDim>::processCornerGeneric (
00556         int normalX, int normalY, int normalZ,
00557         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00558 {
00559     processCorner(normalX, normalY, normalZ, domain, dynamic_cast<TensorField3D<T,nDim>&>(*atomicBlocks[0]));
00560 }
00561 
00562 
00563 /* *************** BoundedReductiveBoxProcessing3D_N ******************************************* */
00564 
00565 template<typename T>
00566 void BoundedReductiveBoxProcessingFunctional3D_N<T>::processBulkGeneric (
00567         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00568 {
00569     processBulk(domain, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00570 }
00571 
00572 template<typename T>
00573 void BoundedReductiveBoxProcessingFunctional3D_N<T>::processPlaneGeneric (
00574         int direction, int orientation,
00575         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00576 {
00577     processPlane(direction, orientation, domain, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00578 }
00579 
00580 template<typename T>
00581 void BoundedReductiveBoxProcessingFunctional3D_N<T>::processEdgeGeneric (
00582         int plane, int normal1, int normal2,
00583         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00584 {
00585     processEdge(plane,normal1,normal2, domain, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00586 }
00587 
00588 template<typename T>
00589 void BoundedReductiveBoxProcessingFunctional3D_N<T>::processCornerGeneric (
00590         int normalX, int normalY, int normalZ,
00591         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00592 {
00593     processCorner(normalX, normalY, normalZ, domain, dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]));
00594 }
00595 
00596 
00597 /* *************** BoundedMaskedReductiveBoxProcessing3D_N ******************************************* */
00598 
00599 template<typename T>
00600 void BoundedMaskedReductiveBoxProcessingFunctional3D_N<T>::processBulkGeneric (
00601         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00602 {
00603     processBulk(domain,
00604                 dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]),
00605                 dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[1]));
00606 }
00607 
00608 template<typename T>
00609 void BoundedMaskedReductiveBoxProcessingFunctional3D_N<T>::processPlaneGeneric (
00610         int direction, int orientation,
00611         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00612 {
00613     processPlane(direction, orientation, domain,
00614                  dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]),
00615                  dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[1]));
00616 }
00617 
00618 template<typename T>
00619 void BoundedMaskedReductiveBoxProcessingFunctional3D_N<T>::processEdgeGeneric (
00620         int plane, int normal1, int normal2,
00621         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00622 {
00623     processEdge(plane,normal1,normal2, domain,
00624                 dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]),
00625                 dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[1]));
00626 }
00627 
00628 template<typename T>
00629 void BoundedMaskedReductiveBoxProcessingFunctional3D_N<T>::processCornerGeneric (
00630         int normalX, int normalY, int normalZ,
00631         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00632 {
00633     processCorner(normalX, normalY, normalZ, domain,
00634                   dynamic_cast<NTensorField3D<T>&>(*atomicBlocks[0]),
00635                   dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[1]));
00636 }
00637 
00638 
00639 /* *************** BoundedReductiveBoxProcessing3D_LL ****************************************** */
00640 
00641 template<typename T1, template<typename U1> class Descriptor1,
00642          typename T2, template<typename U2> class Descriptor2>
00643 void BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processBulkGeneric (
00644         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00645 {
00646     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00647     processBulk( domain,
00648                  dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00649                  dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00650 }
00651 
00652 template<typename T1, template<typename U1> class Descriptor1,
00653          typename T2, template<typename U2> class Descriptor2>
00654 void BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processPlaneGeneric (
00655         int direction, int orientation,
00656         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00657 {
00658     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00659     processPlane( direction, orientation, domain,
00660                  dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00661                  dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00662 }
00663 
00664 template<typename T1, template<typename U1> class Descriptor1,
00665          typename T2, template<typename U2> class Descriptor2>
00666 void BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processEdgeGeneric (
00667         int plane, int normal1, int normal2,
00668         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00669 {
00670     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00671     processEdge( plane,normal1,normal2, domain,
00672                  dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00673                  dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00674 }
00675 
00676 template<typename T1, template<typename U1> class Descriptor1,
00677          typename T2, template<typename U2> class Descriptor2>
00678 void BoundedReductiveBoxProcessingFunctional3D_LL<T1,Descriptor1,T2,Descriptor2>::processCornerGeneric (
00679         int normalX, int normalY, int normalZ,
00680         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00681 {
00682     PLB_PRECONDITION( atomicBlocks.size() == 2 );
00683     processCorner( normalX, normalY, normalZ, domain,
00684                    dynamic_cast<BlockLattice3D<T1,Descriptor1>&>(*atomicBlocks[0]),
00685                    dynamic_cast<BlockLattice3D<T2,Descriptor2>&>(*atomicBlocks[1]) );
00686 }
00687 
00688 /* *************** BoundedReductiveBoxProcessing3D_SS ****************************************** */
00689 
00690 template<typename T1, typename T2>
00691 void BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>::processBulkGeneric (
00692         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00693 {
00694     processBulk( domain,
00695                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00696                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00697 }
00698 
00699 template<typename T1, typename T2>
00700 void BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>::processPlaneGeneric (
00701         int direction, int orientation,
00702         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00703 {
00704     processPlane( direction, orientation, domain,
00705                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00706                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00707 }
00708 
00709 template<typename T1, typename T2>
00710 void BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>::processEdgeGeneric (
00711         int plane, int normal1, int normal2,
00712         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00713 {
00714     processEdge( plane,normal1,normal2, domain,
00715                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00716                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00717 }
00718 
00719 template<typename T1, typename T2>
00720 void BoundedReductiveBoxProcessingFunctional3D_SS<T1,T2>::processCornerGeneric (
00721         int normalX, int normalY, int normalZ,
00722         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00723 {
00724     processCorner( normalX, normalY, normalZ, domain,
00725                    dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00726                    dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00727 }
00728 
00729 /* *************** BoundedReductiveBoxProcessing3D_TT ****************************************** */
00730 
00731 template<typename T1, int nDim1, typename T2, int nDim2>
00732 void BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processBulkGeneric (
00733         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00734 {
00735     processBulk( domain,
00736                  dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00737                  dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00738 }
00739 
00740 template<typename T1, int nDim1, typename T2, int nDim2>
00741 void BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processPlaneGeneric (
00742         int direction, int orientation,
00743         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00744 {
00745     processPlane( direction, orientation, domain,
00746                  dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00747                  dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00748 }
00749 
00750 template<typename T1, int nDim1, typename T2, int nDim2>
00751 void BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processEdgeGeneric (
00752         int plane, int normal1, int normal2,
00753         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00754 {
00755     processEdge( plane,normal1,normal2, domain,
00756                  dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00757                  dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00758 }
00759 
00760 template<typename T1, int nDim1, typename T2, int nDim2>
00761 void BoundedReductiveBoxProcessingFunctional3D_TT<T1,nDim1,T2,nDim2>::processCornerGeneric (
00762         int normalX, int normalY, int normalZ,
00763         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00764 {
00765     processCorner( normalX, normalY, normalZ, domain,
00766                    dynamic_cast<TensorField3D<T1,nDim1>&>(*atomicBlocks[0]),
00767                    dynamic_cast<TensorField3D<T2,nDim2>&>(*atomicBlocks[1]) );
00768 }
00769 
00770 /* *************** BoundedReductiveBoxProcessing3D_NN ****************************************** */
00771 
00772 template<typename T1, typename T2>
00773 void BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processBulkGeneric (
00774         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00775 {
00776     processBulk( domain,
00777                  dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00778                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00779 }
00780 
00781 template<typename T1, typename T2>
00782 void BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processPlaneGeneric (
00783         int direction, int orientation,
00784         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00785 {
00786     processPlane( direction, orientation, domain,
00787                  dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00788                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00789 }
00790 
00791 template<typename T1, typename T2>
00792 void BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processEdgeGeneric (
00793         int plane, int normal1, int normal2,
00794         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00795 {
00796     processEdge( plane,normal1,normal2, domain,
00797                  dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00798                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00799 }
00800 
00801 template<typename T1, typename T2>
00802 void BoundedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processCornerGeneric (
00803         int normalX, int normalY, int normalZ,
00804         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00805 {
00806     processCorner( normalX, normalY, normalZ, domain,
00807                    dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00808                    dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00809 }
00810 
00811 /* *************** BoundedMaskedReductiveBoxProcessing3D_NN ******************************************* */
00812 
00813     template<typename T1, typename T2>
00814 void BoundedMaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processBulkGeneric (
00815         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00816 {
00817     processBulk(domain,
00818                 dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00819                 dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00820                 dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]));
00821 }
00822 
00823 template<typename T1, typename T2>
00824 void BoundedMaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processPlaneGeneric (
00825         int direction, int orientation,
00826         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00827 {
00828     processPlane(direction, orientation, domain,
00829                  dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00830                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00831                  dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]));
00832 }
00833 
00834 template<typename T1, typename T2>
00835 void BoundedMaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processEdgeGeneric (
00836         int plane, int normal1, int normal2,
00837         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00838 {
00839     processEdge(plane,normal1,normal2, domain,
00840                 dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00841                 dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00842                 dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]));
00843 }
00844 
00845 template<typename T1, typename T2>
00846 void BoundedMaskedReductiveBoxProcessingFunctional3D_NN<T1,T2>::processCornerGeneric (
00847         int normalX, int normalY, int normalZ,
00848         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00849 {
00850     processCorner(normalX, normalY, normalZ, domain,
00851                   dynamic_cast<NTensorField3D<T1>&>(*atomicBlocks[0]),
00852                   dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
00853                   dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]));
00854 }
00855 
00856 
00857 
00858 /* *************** BoundedReductiveBoxProcessing3D_ST ****************************************** */
00859 
00860 template<typename T1, typename T2, int nDim>
00861 void BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>::processBulkGeneric (
00862         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00863 {
00864     processBulk( domain,
00865                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00866                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00867 }
00868 
00869 template<typename T1, typename T2, int nDim>
00870 void BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>::processPlaneGeneric (
00871         int direction, int orientation,
00872         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00873 {
00874     processPlane( direction, orientation, domain,
00875                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00876                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00877 }
00878 
00879 template<typename T1, typename T2, int nDim>
00880 void BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>::processEdgeGeneric (
00881         int plane, int normal1, int normal2,
00882         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00883 {
00884     processEdge( plane,normal1,normal2, domain,
00885                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00886                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00887 }
00888 
00889 template<typename T1, typename T2, int nDim>
00890 void BoundedReductiveBoxProcessingFunctional3D_ST<T1,T2,nDim>::processCornerGeneric (
00891         int normalX, int normalY, int normalZ,
00892         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00893 {
00894     processCorner( normalX, normalY, normalZ, domain,
00895                    dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00896                    dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00897 }
00898 
00899 /* *************** BoundedReductiveBoxProcessing3D_SN ****************************************** */
00900 
00901 template<typename T1, typename T2>
00902 void BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>::processBulkGeneric (
00903         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00904 {
00905     processBulk( domain,
00906                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00907                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00908 }
00909 
00910 template<typename T1, typename T2>
00911 void BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>::processPlaneGeneric (
00912         int direction, int orientation,
00913         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00914 {
00915     processPlane( direction, orientation, domain,
00916                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00917                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00918 }
00919 
00920 template<typename T1, typename T2>
00921 void BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>::processEdgeGeneric (
00922         int plane, int normal1, int normal2,
00923         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00924 {
00925     processEdge( plane,normal1,normal2, domain,
00926                  dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00927                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00928 }
00929 
00930 template<typename T1, typename T2>
00931 void BoundedReductiveBoxProcessingFunctional3D_SN<T1,T2>::processCornerGeneric (
00932         int normalX, int normalY, int normalZ,
00933         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00934 {
00935     processCorner( normalX, normalY, normalZ, domain,
00936                    dynamic_cast<ScalarField3D<T1>&>(*atomicBlocks[0]),
00937                    dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
00938 }
00939 
00940 /* *************** BoundedReductiveBoxProcessing3D_LS ****************************************** */
00941 
00942 template<typename T1, template<typename U> class Descriptor, typename T2>
00943 void BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>::processBulkGeneric (
00944         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00945 {
00946     processBulk( domain,
00947                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00948                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00949 }
00950 
00951 template<typename T1, template<typename U> class Descriptor, typename T2>
00952 void BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>::processPlaneGeneric (
00953         int direction, int orientation,
00954         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00955 {
00956     processPlane( direction, orientation, domain,
00957                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00958                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00959 }
00960 
00961 template<typename T1, template<typename U> class Descriptor, typename T2>
00962 void BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>::processEdgeGeneric (
00963         int plane, int normal1, int normal2,
00964         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00965 {
00966     processEdge( plane,normal1,normal2, domain,
00967                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00968                  dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00969 }
00970 
00971 template<typename T1, template<typename U> class Descriptor, typename T2>
00972 void BoundedReductiveBoxProcessingFunctional3D_LS<T1,Descriptor,T2>::processCornerGeneric (
00973         int normalX, int normalY, int normalZ,
00974         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00975 {
00976     processCorner( normalX, normalY, normalZ, domain,
00977                    dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00978                    dynamic_cast<ScalarField3D<T2>&>(*atomicBlocks[1]) );
00979 }
00980 
00981 /* *************** BoundedReductiveBoxProcessing3D_LT ****************************************** */
00982 
00983 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00984 void BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processBulkGeneric (
00985         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00986 {
00987     processBulk( domain,
00988                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00989                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
00990 }
00991 
00992 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00993 void BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processPlaneGeneric (
00994         int direction, int orientation,
00995         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
00996 {
00997     processPlane( direction, orientation, domain,
00998                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
00999                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
01000 }
01001 
01002 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
01003 void BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processEdgeGeneric (
01004         int plane, int normal1, int normal2,
01005         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01006 {
01007     processEdge( plane,normal1,normal2, domain,
01008                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01009                  dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
01010 }
01011 
01012 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
01013 void BoundedReductiveBoxProcessingFunctional3D_LT<T1,Descriptor,T2,nDim>::processCornerGeneric (
01014         int normalX, int normalY, int normalZ,
01015         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01016 {
01017     processCorner( normalX, normalY, normalZ, domain,
01018                    dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01019                    dynamic_cast<TensorField3D<T2,nDim>&>(*atomicBlocks[1]) );
01020 }
01021 
01022 /* *************** BoundedReductiveBoxProcessing3D_LN ****************************************** */
01023 
01024 template<typename T1, template<typename U> class Descriptor, typename T2>
01025 void BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processBulkGeneric (
01026         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01027 {
01028     processBulk( domain,
01029                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01030                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
01031 }
01032 
01033 template<typename T1, template<typename U> class Descriptor, typename T2>
01034 void BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processPlaneGeneric (
01035         int direction, int orientation,
01036         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01037 {
01038     processPlane( direction, orientation, domain,
01039                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01040                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
01041 }
01042 
01043 template<typename T1, template<typename U> class Descriptor, typename T2>
01044 void BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processEdgeGeneric (
01045         int plane, int normal1, int normal2,
01046         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01047 {
01048     processEdge( plane,normal1,normal2, domain,
01049                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01050                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
01051 }
01052 
01053 template<typename T1, template<typename U> class Descriptor, typename T2>
01054 void BoundedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processCornerGeneric (
01055         int normalX, int normalY, int normalZ,
01056         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01057 {
01058     processCorner( normalX, normalY, normalZ, domain,
01059                    dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01060                    dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]) );
01061 }
01062 
01063 /* *************** BoundedMaskedReductiveBoxProcessing3D_LN ****************************************** */
01064 
01065 template<typename T1, template<typename U> class Descriptor, typename T2>
01066 void BoundedMaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processBulkGeneric (
01067         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01068 {
01069     processBulk( domain,
01070                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01071                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
01072                  dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
01073 }
01074 
01075 template<typename T1, template<typename U> class Descriptor, typename T2>
01076 void BoundedMaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processPlaneGeneric (
01077         int direction, int orientation,
01078         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01079 {
01080     processPlane( direction, orientation, domain,
01081                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01082                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
01083                  dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
01084 }
01085 
01086 template<typename T1, template<typename U> class Descriptor, typename T2>
01087 void BoundedMaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processEdgeGeneric (
01088         int plane, int normal1, int normal2,
01089         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01090 {
01091     processEdge( plane,normal1,normal2, domain,
01092                  dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01093                  dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
01094                  dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
01095 }
01096 
01097 template<typename T1, template<typename U> class Descriptor, typename T2>
01098 void BoundedMaskedReductiveBoxProcessingFunctional3D_LN<T1,Descriptor,T2>::processCornerGeneric (
01099         int normalX, int normalY, int normalZ,
01100         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01101 {
01102     processCorner( normalX, normalY, normalZ, domain,
01103                    dynamic_cast<BlockLattice3D<T1,Descriptor>&>(*atomicBlocks[0]),
01104                    dynamic_cast<NTensorField3D<T2>&>(*atomicBlocks[1]),
01105                    dynamic_cast<NTensorField3D<int>&>(*atomicBlocks[2]) );
01106 }
01107 
01108 /* *************** BoundedReductiveLatticeBoxProcessing3D ******************************************* */
01109 
01110 template<typename T, template<typename U> class Descriptor>
01111 void BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>::processBulkGeneric (
01112         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01113 {
01114     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
01115     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
01116         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*>(atomicBlocks[iLattice]);
01117     }
01118     processBulk(domain, lattices);
01119 }
01120 
01121 template<typename T, template<typename U> class Descriptor>
01122 void BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>::processPlaneGeneric (
01123         int direction, int orientation,
01124         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01125 {
01126     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
01127     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
01128         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*>(atomicBlocks[iLattice]);
01129     }
01130     processPlane(direction, orientation, domain, lattices);
01131 }
01132 
01133 template<typename T, template<typename U> class Descriptor>
01134 void BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>::processEdgeGeneric (
01135         int plane, int normal1, int normal2,
01136         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01137 {
01138     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
01139     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
01140         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*>(atomicBlocks[iLattice]);
01141     }
01142     processEdge(plane,normal1,normal2, domain, lattices);
01143 }
01144 
01145 template<typename T, template<typename U> class Descriptor>
01146 void BoundedReductiveLatticeBoxProcessingFunctional3D<T,Descriptor>::processCornerGeneric (
01147         int normalX, int normalY, int normalZ,
01148         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01149 {
01150     std::vector<BlockLattice3D<T,Descriptor>*> lattices(atomicBlocks.size());
01151     for (pluint iLattice=0; iLattice<atomicBlocks.size(); ++iLattice) {
01152         lattices[iLattice] = dynamic_cast<BlockLattice3D<T,Descriptor>*>(atomicBlocks[iLattice]);
01153     }
01154     processCorner(normalX, normalY, normalZ, domain, lattices);
01155 }
01156 
01157 /* *************** BoundedReductiveScalarFieldBoxProcessing3D ******************************************* */
01158 
01159 template<typename T>
01160 void BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>::processBulkGeneric (
01161         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01162 {
01163     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
01164     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01165         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
01166     }
01167     processBulk(domain, fields);
01168 }
01169 
01170 template<typename T>
01171 void BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>::processPlaneGeneric (
01172         int direction, int orientation,
01173         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01174 {
01175     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
01176     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01177         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
01178     }
01179     processPlane(direction, orientation, domain, fields);
01180 }
01181 
01182 template<typename T>
01183 void BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>::processEdgeGeneric (
01184         int plane, int normal1, int normal2,
01185         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01186 {
01187     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
01188     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01189         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
01190     }
01191     processEdge(plane,normal1,normal2, domain, fields);
01192 }
01193 
01194 template<typename T>
01195 void BoundedReductiveScalarFieldBoxProcessingFunctional3D<T>::processCornerGeneric (
01196         int normalX, int normalY, int normalZ,
01197         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01198 {
01199     std::vector<ScalarField3D<T>*> fields(atomicBlocks.size());
01200     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01201         fields[iField] = dynamic_cast<ScalarField3D<T>*>(atomicBlocks[iField]);
01202     }
01203     processCorner(normalX, normalY, normalZ, domain, fields);
01204 }
01205 
01206 
01207 /* *************** BoundedReductiveTensorFieldBoxProcessing3D ******************************************* */
01208 
01209 template<typename T, int nDim>
01210 void BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>::processBulkGeneric (
01211         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01212 {
01213     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
01214     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01215         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
01216     }
01217     processBulk(domain, fields);
01218 }
01219 
01220 template<typename T, int nDim>
01221 void BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>::processPlaneGeneric (
01222         int direction, int orientation,
01223         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01224 {
01225     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
01226     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01227         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
01228     }
01229     processPlane(direction, orientation, domain, fields);
01230 }
01231 
01232 template<typename T, int nDim>
01233 void BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>::processEdgeGeneric (
01234         int plane, int normal1, int normal2,
01235         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01236 {
01237     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
01238     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01239         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
01240     }
01241     processEdge(plane,normal1,normal2, domain, fields);
01242 }
01243 
01244 template<typename T, int nDim>
01245 void BoundedReductiveTensorFieldBoxProcessingFunctional3D<T,nDim>::processCornerGeneric (
01246         int normalX, int normalY, int normalZ,
01247         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01248 {
01249     std::vector<TensorField3D<T,nDim>*> fields(atomicBlocks.size());
01250     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01251         fields[iField] = dynamic_cast<TensorField3D<T,nDim>*>(atomicBlocks[iField]);
01252     }
01253     processCorner(normalX, normalY, normalZ, domain, fields);
01254 }
01255 
01256 /* *************** BoundedReductiveNTensorFieldBoxProcessing3D ******************************************* */
01257 
01258 template<typename T>
01259 void BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>::processBulkGeneric (
01260         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01261 {
01262     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
01263     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01264         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
01265     }
01266     processBulk(domain, fields);
01267 }
01268 
01269 template<typename T>
01270 void BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>::processPlaneGeneric (
01271         int direction, int orientation,
01272         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01273 {
01274     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
01275     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01276         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
01277     }
01278     processPlane(direction, orientation, domain, fields);
01279 }
01280 
01281 template<typename T>
01282 void BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>::processEdgeGeneric (
01283         int plane, int normal1, int normal2,
01284         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01285 {
01286     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
01287     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01288         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
01289     }
01290     processEdge(plane,normal1,normal2, domain, fields);
01291 }
01292 
01293 template<typename T>
01294 void BoundedReductiveNTensorFieldBoxProcessingFunctional3D<T>::processCornerGeneric (
01295         int normalX, int normalY, int normalZ,
01296         Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks )
01297 {
01298     std::vector<NTensorField3D<T>*> fields(atomicBlocks.size());
01299     for (pluint iField=0; iField<atomicBlocks.size(); ++iField) {
01300         fields[iField] = dynamic_cast<NTensorField3D<T>*>(atomicBlocks[iField]);
01301     }
01302     processCorner(normalX, normalY, normalZ, domain, fields);
01303 }
01304 
01305 }  // namespace plb
01306 
01307 #endif  // REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_3D_HH
  • $generatedby doxygen 1.6.3
    • $generatedby   doxygen 1.6.3