reductiveDataProcessingFunctional3D.h

00001 /* This file is part of the Palabos library.
00002  *
00003  * Copyright (C) 2011 FlowKit Sarl
00004  * Avenue de Chailly 23
00005  * 1012 Lausanne, Switzerland
00006  * E-mail contact: contact@flowkit.com
00007  *
00008  * The most recent release of Palabos can be downloaded at 
00009  * <http://www.palabos.org/>
00010  *
00011  * The library Palabos is free software: you can redistribute it and/or
00012  * modify it under the terms of the GNU Affero General Public License as
00013  * published by the Free Software Foundation, either version 3 of the
00014  * License, or (at your option) any later version.
00015  *
00016  * The library is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU Affero General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU Affero General Public License
00022  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00023 */
00024 
00028 #ifndef REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_3D_H
00029 #define REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_3D_H
00030 
00031 #include "core/globalDefs.h"
00032 #include "core/geometry3D.h"
00033 #include "core/blockSurface3D.h"
00034 #include "atomicBlock/dataProcessor3D.h"
00035 #include <vector>
00036 
00037 namespace plb {
00038 
00039 // Forward declarations.
00040 
00041 template<typename T, template<typename U> class Descriptor> class BlockLatticeBase3D;
00042 template<typename T, template<typename U> class Descriptor> class BlockLattice3D;
00043 template<typename T> class ScalarFieldBase3D;
00044 template<typename T> class ScalarField3D;
00045 template<typename T, int nDim> class TensorFieldBase3D;
00046 template<typename T, int nDim> class TensorField3D;
00047 template<typename T> class NTensorFieldBase3D;
00048 template<typename T> class NTensorField3D;
00049 
00050 
00051 /* *************** All flavors of Box processing functionals ********* */
00052 
00054 struct ReductiveBoxProcessingFunctional3D {
00055     virtual ~ReductiveBoxProcessingFunctional3D() { }
00056     virtual void processGenericBlocks(Box3D domain,
00057                                       std::vector<AtomicBlock3D*> atomicBlocks) =0;
00058     virtual BlockDomain::DomainT appliesTo() const;
00059     virtual void rescale(double dxScale, double dtScale);
00060     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00061     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00063     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00064     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0;
00065     virtual ReductiveBoxProcessingFunctional3D* clone() const =0;
00066     virtual BlockStatistics const& getStatistics() const =0;
00067     virtual BlockStatistics& getStatistics() =0;
00068     virtual void serialize(std::string& data) const;
00069     virtual void unserialize(std::string& data);
00070     virtual int getStaticId() const;
00071 };
00072 
00074 class PlainReductiveBoxProcessingFunctional3D : public ReductiveBoxProcessingFunctional3D {
00075 public:
00076     virtual BlockStatistics const& getStatistics() const;
00077     virtual BlockStatistics& getStatistics();
00078 private:
00079     BlockStatistics statistics;
00080 };
00081 
00083 class ReductiveBoxProcessor3D : public DataProcessor3D {
00084 public:
00088     ReductiveBoxProcessor3D(ReductiveBoxProcessingFunctional3D* functional_,
00089                             Box3D domain_, std::vector<AtomicBlock3D*> atomicBlocks_);
00090     Box3D getDomain() const;
00091     virtual void process();
00092     virtual ReductiveBoxProcessor3D* clone() const;
00093     virtual int getStaticId() const;
00094 private:
00095     ReductiveBoxProcessingFunctional3D* functional;
00096     Box3D domain;
00097     std::vector<AtomicBlock3D*> atomicBlocks;
00098 };
00099 
00101 class ReductiveBoxProcessorGenerator3D : public BoxedReductiveDataProcessorGenerator3D {
00102 public:
00106     ReductiveBoxProcessorGenerator3D(ReductiveBoxProcessingFunctional3D* functional_, Box3D domain);
00107     ~ReductiveBoxProcessorGenerator3D();
00108     ReductiveBoxProcessorGenerator3D(ReductiveBoxProcessorGenerator3D const& rhs);
00109     ReductiveBoxProcessorGenerator3D& operator=(ReductiveBoxProcessorGenerator3D const& rhs);
00110     virtual BlockDomain::DomainT appliesTo() const;
00111     virtual void rescale(double dxScale, double dtScale);
00112     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00113     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00114     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00115     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00116     virtual DataProcessor3D* generate(std::vector<AtomicBlock3D*> atomicBlocks);
00117     virtual ReductiveBoxProcessorGenerator3D* clone() const;
00118     virtual BlockStatistics const& getStatistics() const;
00119     virtual BlockStatistics& getStatistics();
00120     ReductiveBoxProcessingFunctional3D const& getFunctional() const;
00121     virtual void serialize(Box3D& domain, std::string& data) const;
00122     virtual int getStaticId() const;
00123 private:
00124     ReductiveBoxProcessingFunctional3D* functional;
00125 };
00126 
00128 template<typename T, template<typename U> class Descriptor>
00129 struct ReductiveBoxProcessingFunctional3D_L : public PlainReductiveBoxProcessingFunctional3D {
00130     virtual void process(Box3D domain, BlockLattice3D<T,Descriptor>& lattice) =0;
00132     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00133 };
00134 
00136 template<typename T>
00137 struct ReductiveBoxProcessingFunctional3D_S : public PlainReductiveBoxProcessingFunctional3D {
00138     virtual void process(Box3D domain, ScalarField3D<T>& field) =0;
00140     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00141 };
00142 
00144 template<typename T, int nDim>
00145 struct ReductiveBoxProcessingFunctional3D_T : public PlainReductiveBoxProcessingFunctional3D {
00146     virtual void process(Box3D domain, TensorField3D<T,nDim>& field) =0;
00148     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00149 };
00150 
00152 template<typename T>
00153 struct ReductiveBoxProcessingFunctional3D_N : public PlainReductiveBoxProcessingFunctional3D {
00154     virtual void process(Box3D domain, NTensorField3D<T>& field) =0;
00156     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00157 };
00158 
00160 template<typename T>
00161 struct MaskedReductiveBoxProcessingFunctional3D_N : public PlainReductiveBoxProcessingFunctional3D {
00162     virtual void process(Box3D domain,
00163                          NTensorField3D<T>& field,
00164                          NTensorField3D<int>& mask) =0;
00166     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00167 };
00168 
00170 template<typename T1, template<typename U1> class Descriptor1,
00171          typename T2, template<typename U2> class Descriptor2>
00172 struct ReductiveBoxProcessingFunctional3D_LL : public PlainReductiveBoxProcessingFunctional3D {
00173     virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor1>& lattice1,
00174                                        BlockLattice3D<T2,Descriptor2>& lattice2) =0;
00176     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00177 };
00178 
00180 template<typename T1, typename T2>
00181 struct ReductiveBoxProcessingFunctional3D_SS : public PlainReductiveBoxProcessingFunctional3D {
00182     virtual void process(Box3D domain, ScalarField3D<T1>& field1,
00183                                        ScalarField3D<T2>& field2) =0;
00185     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00186 };
00187 
00189 template<typename T1, int nDim1,
00190          typename T2, int nDim2>
00191 struct ReductiveBoxProcessingFunctional3D_TT : public PlainReductiveBoxProcessingFunctional3D {
00192     virtual void process(Box3D domain, TensorField3D<T1,nDim1>& field1,
00193                                        TensorField3D<T2,nDim2>& field2) =0;
00195     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00196 };
00197 
00199 template<typename T1, typename T2, int nDim>
00200 struct ReductiveBoxProcessingFunctional3D_ST : public PlainReductiveBoxProcessingFunctional3D {
00201     virtual void process(Box3D domain, ScalarField3D<T1>& field1,
00202                                        TensorField3D<T2,nDim>& field2) =0;
00204     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00205 };
00206 
00208 template<typename T1, typename T2>
00209 struct ReductiveBoxProcessingFunctional3D_NN : public PlainReductiveBoxProcessingFunctional3D {
00210     virtual void process(Box3D domain, NTensorField3D<T1>& field1,
00211                                        NTensorField3D<T2>& field2) =0;
00213     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00214 };
00215 
00217 template<typename T1, typename T2>
00218 struct MaskedReductiveBoxProcessingFunctional3D_NN : public PlainReductiveBoxProcessingFunctional3D {
00219     virtual void process(Box3D domain, NTensorField3D<T1>& field1,
00220                                        NTensorField3D<T2>& field2,
00221                                        NTensorField3D<int>& mask) =0;
00223     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00224 };
00225 
00227 template<typename T1, typename T2>
00228 struct ReductiveBoxProcessingFunctional3D_SN : public PlainReductiveBoxProcessingFunctional3D {
00229     virtual void process(Box3D domain, ScalarField3D<T1>& field1,
00230                                        NTensorField3D<T2>& field2) =0;
00232     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00233 };
00234 
00236 template<typename T1, template<typename U> class Descriptor, typename T2>
00237 struct ReductiveBoxProcessingFunctional3D_LS : public PlainReductiveBoxProcessingFunctional3D {
00238     virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00239                                        ScalarField3D<T2>& field) =0;
00241     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00242 };
00243 
00245 template<typename T1, template<typename U> class Descriptor,
00246          typename T2, int nDim>
00247 struct ReductiveBoxProcessingFunctional3D_LT : public PlainReductiveBoxProcessingFunctional3D {
00248     virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00249                                        TensorField3D<T2,nDim>& field) =0;
00251     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00252 };
00253 
00255 template<typename T1, template<typename U> class Descriptor, typename T2>
00256 struct ReductiveBoxProcessingFunctional3D_LN : public PlainReductiveBoxProcessingFunctional3D {
00257     virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00258                                        NTensorField3D<T2>& field) =0;
00260     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00261 };
00262 
00264 template<typename T1, template<typename U> class Descriptor, typename T2>
00265 struct MaskedReductiveBoxProcessingFunctional3D_LN : public PlainReductiveBoxProcessingFunctional3D {
00266     virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00267                                        NTensorField3D<T2>& field,
00268                                        NTensorField3D<int>& mask) =0;
00270     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00271 };
00272 
00274 template<typename T, template<typename U> class Descriptor>
00275 struct ReductiveLatticeBoxProcessingFunctional3D : public PlainReductiveBoxProcessingFunctional3D {
00276     virtual void process(Box3D domain, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0;
00278     virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00279 };
00280 
00282 template<typename T>
00283 struct ReductiveScalarFieldBoxProcessingFunctional3D : public PlainReductiveBoxProcessingFunctional3D {
00284     virtual void process(Box3D domain, std::vector<ScalarField3D<T>*> scalarFields) =0;
00286     virtual void processGenericBlocks( Box3D domain,
00287                                        std::vector<AtomicBlock3D*> atomicBlocks );
00288 };
00289 
00291 template<typename T, int nDim>
00292 struct ReductiveTensorFieldBoxProcessingFunctional3D : public PlainReductiveBoxProcessingFunctional3D {
00293     virtual void process(Box3D domain, std::vector<TensorField3D<T,nDim>*> tensorFields) =0;
00295     virtual void processGenericBlocks( Box3D domain,
00296                                        std::vector<AtomicBlock3D*> atomicBlocks );
00297 };
00298 
00300 template<typename T>
00301 struct ReductiveNTensorFieldBoxProcessingFunctional3D : public PlainReductiveBoxProcessingFunctional3D {
00302     virtual void process(Box3D domain, std::vector<NTensorField3D<T>*> tensorFields) =0;
00304     virtual void processGenericBlocks( Box3D domain,
00305                                        std::vector<AtomicBlock3D*> atomicBlocks );
00306 };
00307 
00308 
00309 /* *************** All flavors of Dot processing functionals ********* */
00310 
00312 class ReductiveDotProcessingFunctional3D {
00313 public:
00314     virtual ~ReductiveDotProcessingFunctional3D() { }
00315     virtual void processGenericBlocks(DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks) =0;
00316     virtual BlockDomain::DomainT appliesTo() const;
00317     virtual void rescale(double dxScale, double dtScale);
00318     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00319     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00320     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00321     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0;
00322     virtual ReductiveDotProcessingFunctional3D* clone() const =0;
00323     virtual BlockStatistics const& getStatistics() const =0;
00324     virtual BlockStatistics& getStatistics() =0;
00325 };
00326 
00328 class PlainReductiveDotProcessingFunctional3D : public ReductiveDotProcessingFunctional3D {
00329 public:
00330     virtual BlockStatistics const& getStatistics() const;
00331     virtual BlockStatistics& getStatistics();
00332 private:
00333     BlockStatistics statistics;
00334 };
00335 
00336 
00338 class ReductiveDotProcessor3D : public DataProcessor3D {
00339 public:
00343     ReductiveDotProcessor3D(ReductiveDotProcessingFunctional3D* functional_,
00344                             DotList3D const& dotList_, std::vector<AtomicBlock3D*> atomicBlocks_);
00345     DotList3D const& getDotList() const;
00346     virtual void process();
00347     virtual ReductiveDotProcessor3D* clone() const;
00348 private:
00349     ReductiveDotProcessingFunctional3D* functional;
00350     DotList3D dotList;
00351     std::vector<AtomicBlock3D*> atomicBlocks;
00352 };
00353 
00355 class ReductiveDotProcessorGenerator3D : public DottedReductiveDataProcessorGenerator3D {
00356 public:
00357     ReductiveDotProcessorGenerator3D(ReductiveDotProcessingFunctional3D* functional_, DotList3D const& dotList);
00358     ~ReductiveDotProcessorGenerator3D();
00359     ReductiveDotProcessorGenerator3D(ReductiveDotProcessorGenerator3D const& rhs);
00360     ReductiveDotProcessorGenerator3D& operator=(ReductiveDotProcessorGenerator3D const& rhs);
00361     virtual BlockDomain::DomainT appliesTo() const;
00362     virtual void rescale(double dxScale, double dtScale);
00363     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00364     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00365     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00366     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00367     virtual DataProcessor3D* generate(std::vector<AtomicBlock3D*> atomicBlocks);
00368     virtual ReductiveDotProcessorGenerator3D* clone() const;
00369     virtual BlockStatistics const& getStatistics() const;
00370     virtual BlockStatistics& getStatistics();
00371     ReductiveDotProcessingFunctional3D const& getFunctional() const;
00372 private:
00373     ReductiveDotProcessingFunctional3D* functional;
00374 };
00375 
00377 template<typename T, template<typename U> class Descriptor>
00378 struct ReductiveDotProcessingFunctional3D_L : public PlainReductiveDotProcessingFunctional3D {
00379     virtual void process(DotList3D const& dotList, BlockLattice3D<T,Descriptor>& lattice) =0;
00381     virtual void processGenericBlocks(DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks);
00382 };
00383 
00385 template<typename T>
00386 struct ReductiveDotProcessingFunctional3D_S : public PlainReductiveDotProcessingFunctional3D {
00387     virtual void process(DotList3D const& dotList, ScalarField3D<T>& field) =0;
00389     virtual void processGenericBlocks( DotList3D const& dotList,
00390                                        std::vector<AtomicBlock3D*> atomicBlocks );
00391 };
00392 
00394 template<typename T, int nDim>
00395 struct ReductiveDotProcessingFunctional3D_T : public PlainReductiveDotProcessingFunctional3D {
00396     virtual void process(DotList3D const& dotList, TensorField3D<T,nDim>& field) =0;
00398     virtual void processGenericBlocks( DotList3D const& dotList,
00399                                        std::vector<AtomicBlock3D*> atomicBlocks );
00400 };
00401 
00403 template<typename T>
00404 struct ReductiveDotProcessingFunctional3D_N : public PlainReductiveDotProcessingFunctional3D {
00405     virtual void process(DotList3D const& dotList, NTensorField3D<T>& field) =0;
00407     virtual void processGenericBlocks( DotList3D const& dotList,
00408                                        std::vector<AtomicBlock3D*> atomicBlocks );
00409 };
00410 
00412 template<typename T1, template<typename U1> class Descriptor1,
00413          typename T2, template<typename U2> class Descriptor2>
00414 struct ReductiveDotProcessingFunctional3D_LL : public PlainReductiveDotProcessingFunctional3D {
00415     virtual void process(DotList3D const& dotList,
00416                          BlockLattice3D<T1,Descriptor1>& lattice1,
00417                          BlockLattice3D<T2,Descriptor2>& lattice2) =0;
00419     virtual void processGenericBlocks( DotList3D const& dotList,
00420                                        std::vector<AtomicBlock3D*> atomicBlocks );
00421 };
00422 
00424 template<typename T1, typename T2>
00425 struct ReductiveDotProcessingFunctional3D_SS : public PlainReductiveDotProcessingFunctional3D {
00426     virtual void process(DotList3D const& dotList, ScalarField3D<T1>& field1,
00427                                                    ScalarField3D<T2>& field2) =0;
00429     virtual void processGenericBlocks( DotList3D const& dotList,
00430                                        std::vector<AtomicBlock3D*> atomicBlocks );
00431 };
00432 
00434 template<typename T1, int nDim1, typename T2, int nDim2>
00435 struct ReductiveDotProcessingFunctional3D_TT : public PlainReductiveDotProcessingFunctional3D {
00436     virtual void process(DotList3D const& dotList,
00437                          TensorField3D<T1,nDim1>& field1,
00438                          TensorField3D<T2,nDim2>& field2) =0;
00440     virtual void processGenericBlocks( DotList3D const& dotList,
00441                                        std::vector<AtomicBlock3D*> atomicBlocks );
00442 };
00443 
00445 template<typename T1, typename T2, int nDim>
00446 struct ReductiveDotProcessingFunctional3D_ST : public PlainReductiveDotProcessingFunctional3D {
00447     virtual void process(DotList3D const& dotList,
00448                          ScalarField3D<T1>& field1,
00449                          TensorField3D<T2,nDim>& field2) =0;
00451     virtual void processGenericBlocks( DotList3D const& dotList,
00452                                        std::vector<AtomicBlock3D*> atomicBlocks );
00453 };
00454 
00456 template<typename T1, typename T2>
00457 struct ReductiveDotProcessingFunctional3D_NN : public PlainReductiveDotProcessingFunctional3D {
00458     virtual void process(DotList3D const& dotList,
00459                          NTensorField3D<T1>& field1,
00460                          NTensorField3D<T2>& field2) =0;
00462     virtual void processGenericBlocks( DotList3D const& dotList,
00463                                        std::vector<AtomicBlock3D*> atomicBlocks );
00464 };
00465 
00467 template<typename T1, typename T2>
00468 struct ReductiveDotProcessingFunctional3D_SN : public PlainReductiveDotProcessingFunctional3D {
00469     virtual void process(DotList3D const& dotList,
00470                          ScalarField3D<T1>& field1,
00471                          NTensorField3D<T2>& field2) =0;
00473     virtual void processGenericBlocks( DotList3D const& dotList,
00474                                        std::vector<AtomicBlock3D*> atomicBlocks );
00475 };
00476 
00478 template<typename T1, template<typename U> class Descriptor, typename T2>
00479 struct ReductiveDotProcessingFunctional3D_LS : public PlainReductiveDotProcessingFunctional3D {
00480     virtual void process(DotList3D const& dotList,
00481                          BlockLattice3D<T1,Descriptor>& lattice,
00482                          ScalarField3D<T2>& field) =0;
00484     virtual void processGenericBlocks( DotList3D const& dotList,
00485                                        std::vector<AtomicBlock3D*> atomicBlocks );
00486 };
00487 
00489 template<typename T1, template<typename U> class Descriptor,
00490          typename T2, int nDim>
00491 struct ReductiveDotProcessingFunctional3D_LT : public PlainReductiveDotProcessingFunctional3D {
00492     virtual void process(DotList3D const& dotList,
00493                          BlockLattice3D<T1,Descriptor>& lattice,
00494                          TensorField3D<T2,nDim>& field) =0;
00496     virtual void processGenericBlocks( DotList3D const& dotList,
00497                                        std::vector<AtomicBlock3D*> atomicBlocks );
00498 };
00499 
00501 template<typename T1, template<typename U> class Descriptor, typename T2>
00502 struct ReductiveDotProcessingFunctional3D_LN : public PlainReductiveDotProcessingFunctional3D {
00503     virtual void process(DotList3D const& dotList,
00504                          BlockLattice3D<T1,Descriptor>& lattice,
00505                          NTensorField3D<T2>& field) =0;
00507     virtual void processGenericBlocks( DotList3D const& dotList,
00508                                        std::vector<AtomicBlock3D*> atomicBlocks );
00509 };
00510 
00512 template<typename T, template<typename U> class Descriptor>
00513 struct ReductiveLatticeDotProcessingFunctional3D : public PlainReductiveDotProcessingFunctional3D {
00514     virtual void process(DotList3D const& dotList, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0;
00516     virtual void processGenericBlocks( DotList3D const& dotList,
00517                                        std::vector<AtomicBlock3D*> atomicBlocks );
00518 };
00519 
00521 template<typename T>
00522 struct ReductiveScalarFieldDotProcessingFunctional3D : public PlainReductiveDotProcessingFunctional3D {
00523     virtual void process(DotList3D const& dotList, std::vector<ScalarField3D<T>*> scalarFields) =0;
00525     virtual void processGenericBlocks( DotList3D const& dotList,
00526                                        std::vector<AtomicBlock3D*> atomicBlocks );
00527 };
00528 
00530 template<typename T, int nDim>
00531 struct ReductiveTensorFieldDotProcessingFunctional3D : public PlainReductiveDotProcessingFunctional3D {
00532     virtual void process(DotList3D const& dotList, std::vector<TensorField3D<T,nDim>*> tensorFields) =0;
00534     virtual void processGenericBlocks( DotList3D const& dotList,
00535                                        std::vector<AtomicBlock3D*> atomicBlocks );
00536 };
00537 
00539 template<typename T>
00540 struct ReductiveNTensorFieldDotProcessingFunctional3D : public PlainReductiveDotProcessingFunctional3D {
00541     virtual void process(DotList3D const& dotList, std::vector<NTensorField3D<T>*> tensorFields) =0;
00543     virtual void processGenericBlocks( DotList3D const& dotList,
00544                                        std::vector<AtomicBlock3D*> atomicBlocks );
00545 };
00546 
00547 
00548 /* *************** All flavors of Bounded Box processing functionals ********* */
00549 
00551 class BoundedReductiveBoxProcessingFunctional3D {
00552 public:
00553     virtual ~BoundedReductiveBoxProcessingFunctional3D() { }
00554     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks) =0;
00555     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00556                                       std::vector<AtomicBlock3D*> atomicBlocks ) =0;
00557     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00558                                      std::vector<AtomicBlock3D*> atomicBlocks ) =0;
00559     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00560                                        std::vector<AtomicBlock3D*> atomicBlocks ) =0;
00561     virtual BlockDomain::DomainT appliesTo() const;
00562     virtual void rescale(double dxScale, double dtScale);
00563     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00564     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00565     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00566     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0;
00567     virtual BoundedReductiveBoxProcessingFunctional3D* clone() const =0;
00568     ReductiveBoxProcessingFunctional3D* getBulkProcessor() const; 
00569     ReductiveBoxProcessingFunctional3D* getPlaneProcessor(int direction, int orientation) const; 
00570     ReductiveBoxProcessingFunctional3D* getEdgeProcessor(int plane, int normal1, int normal2) const; 
00571     ReductiveBoxProcessingFunctional3D* getCornerProcessor(int normalX, int normalY, int normalZ) const; 
00572     BlockStatistics const& getStatistics() const;
00573     BlockStatistics& getStatistics();
00574     void getGenerators (
00575             Box3D const& fullDomain, plint boundaryWidth_,
00576             std::vector<ReductiveBoxProcessorGenerator3D*>& generators );
00577 private:
00578     BlockStatistics statistics;
00579 public:
00580     class BulkWrapperFunctional : public ReductiveBoxProcessingFunctional3D {
00581     public:
00582         BulkWrapperFunctional(BoundedReductiveBoxProcessingFunctional3D* boundedFunctional_);
00583         BulkWrapperFunctional(BulkWrapperFunctional const& rhs);
00584         ~BulkWrapperFunctional();
00585         BulkWrapperFunctional& operator=(BulkWrapperFunctional const& rhs);
00586         virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00587         virtual BlockDomain::DomainT appliesTo() const;
00588         virtual void rescale(double dxScale, double dtScale);
00589         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00590         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00591         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00592         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00593         virtual BulkWrapperFunctional* clone() const;
00594         virtual BlockStatistics const& getStatistics() const;
00595         virtual BlockStatistics& getStatistics();
00596     private:
00597         BoundedReductiveBoxProcessingFunctional3D* boundedFunctional;
00598     };
00599     class PlaneWrapperFunctional : public ReductiveBoxProcessingFunctional3D {
00600     public:
00601         PlaneWrapperFunctional(BoundedReductiveBoxProcessingFunctional3D* boundedFunctional_,
00602                                int direction_, int orientation_);
00603         PlaneWrapperFunctional(PlaneWrapperFunctional const& rhs);
00604         ~PlaneWrapperFunctional();
00605         PlaneWrapperFunctional& operator=(PlaneWrapperFunctional const& rhs);
00606         virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00607         virtual BlockDomain::DomainT appliesTo() const;
00608         virtual void rescale(double dxScale, double dtScale);
00609         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00610         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00611         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00612         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00613         virtual PlaneWrapperFunctional* clone() const;
00614         virtual BlockStatistics const& getStatistics() const;
00615         virtual BlockStatistics& getStatistics();
00616     private:
00617         BoundedReductiveBoxProcessingFunctional3D* boundedFunctional;
00618         int direction, orientation;
00619     };
00620     class EdgeWrapperFunctional : public ReductiveBoxProcessingFunctional3D {
00621     public:
00622         EdgeWrapperFunctional(BoundedReductiveBoxProcessingFunctional3D* boundedFunctional_,
00623                               int plane_, int normal1_, int normal2_);
00624         EdgeWrapperFunctional(EdgeWrapperFunctional const& rhs);
00625         ~EdgeWrapperFunctional();
00626         EdgeWrapperFunctional& operator=(EdgeWrapperFunctional const& rhs);
00627         virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00628         virtual BlockDomain::DomainT appliesTo() const;
00629         virtual void rescale(double dxScale, double dtScale);
00630         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00631         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00632         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00633         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00634         virtual EdgeWrapperFunctional* clone() const;
00635         virtual BlockStatistics const& getStatistics() const;
00636         virtual BlockStatistics& getStatistics();
00637     private:
00638         BoundedReductiveBoxProcessingFunctional3D* boundedFunctional;
00639         int plane, normal1, normal2;
00640     };
00641     class CornerWrapperFunctional : public ReductiveBoxProcessingFunctional3D {
00642     public:
00643         CornerWrapperFunctional(BoundedReductiveBoxProcessingFunctional3D* boundedFunctional_,
00644                                 int normalX_, int normalY_, int normalZ_);
00645         CornerWrapperFunctional(CornerWrapperFunctional const& rhs);
00646         ~CornerWrapperFunctional();
00647         CornerWrapperFunctional& operator=(CornerWrapperFunctional const& rhs);
00648         virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00649         virtual BlockDomain::DomainT appliesTo() const;
00650         virtual void rescale(double dxScale, double dtScale);
00651         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00652         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00653         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00654         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00655         virtual CornerWrapperFunctional* clone() const;
00656         virtual BlockStatistics const& getStatistics() const;
00657         virtual BlockStatistics& getStatistics();
00658     private:
00659         BoundedReductiveBoxProcessingFunctional3D* boundedFunctional;
00660         int normalX, normalY, normalZ;
00661     };
00662 };
00663 
00665 template<typename T, template<typename U> class Descriptor>
00666 struct BoundedReductiveBoxProcessingFunctional3D_L : public BoundedReductiveBoxProcessingFunctional3D {
00667     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00668     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00669                                        std::vector<AtomicBlock3D*> atomicBlocks );
00670     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00671                                      std::vector<AtomicBlock3D*> atomicBlocks );
00672     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00673                                        std::vector<AtomicBlock3D*> atomicBlocks );
00674 
00675     virtual void processBulk(Box3D domain, BlockLattice3D<T,Descriptor>& lattice) =0;
00676     virtual void processPlane( int direction, int orientation, Box3D domain,
00677                                BlockLattice3D<T,Descriptor>& lattice ) =0;
00678     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00679                               BlockLattice3D<T,Descriptor>& lattice ) =0;
00680     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00681                                 BlockLattice3D<T,Descriptor>& lattice ) =0;
00682 };
00683 
00685 template<typename T>
00686 struct BoundedReductiveBoxProcessingFunctional3D_S : public BoundedReductiveBoxProcessingFunctional3D {
00687     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00688     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00689                                        std::vector<AtomicBlock3D*> atomicBlocks );
00690     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00691                                      std::vector<AtomicBlock3D*> atomicBlocks );
00692     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00693                                        std::vector<AtomicBlock3D*> atomicBlocks );
00694 
00695     virtual void processBulk(Box3D domain, ScalarField3D<T>& field) =0;
00696     virtual void processPlane( int direction, int orientation, Box3D domain,
00697                                ScalarField3D<T>& field ) =0;
00698     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00699                               ScalarField3D<T>& field ) =0;
00700     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00701                                 ScalarField3D<T>& field ) =0;
00702 };
00703 
00705 template<typename T, int nDim>
00706 struct BoundedReductiveBoxProcessingFunctional3D_T : public BoundedReductiveBoxProcessingFunctional3D {
00707     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00708     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00709                                        std::vector<AtomicBlock3D*> atomicBlocks );
00710     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00711                                      std::vector<AtomicBlock3D*> atomicBlocks );
00712     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00713                                        std::vector<AtomicBlock3D*> atomicBlocks );
00714 
00715     virtual void processBulk(Box3D domain, TensorField3D<T,nDim>& lattice) =0;
00716     virtual void processPlane( int direction, int orientation, Box3D domain,
00717                                TensorField3D<T,nDim>& lattice ) =0;
00718     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00719                               TensorField3D<T,nDim>& lattice ) =0;
00720     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00721                                 TensorField3D<T,nDim>& lattice ) =0;
00722 };
00723 
00725 template<typename T>
00726 struct BoundedReductiveBoxProcessingFunctional3D_N : public BoundedReductiveBoxProcessingFunctional3D {
00727     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00728     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00729                                        std::vector<AtomicBlock3D*> atomicBlocks );
00730     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00731                                      std::vector<AtomicBlock3D*> atomicBlocks );
00732     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00733                                        std::vector<AtomicBlock3D*> atomicBlocks );
00734 
00735     virtual void processBulk(Box3D domain, NTensorField3D<T>& lattice) =0;
00736     virtual void processPlane( int direction, int orientation, Box3D domain,
00737                                NTensorField3D<T>& lattice ) =0;
00738     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00739                               NTensorField3D<T>& lattice ) =0;
00740     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00741                                 NTensorField3D<T>& lattice ) =0;
00742 };
00743 
00745 template<typename T>
00746 struct BoundedMaskedReductiveBoxProcessingFunctional3D_N : public BoundedReductiveBoxProcessingFunctional3D {
00747     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00748     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00749                                        std::vector<AtomicBlock3D*> atomicBlocks );
00750     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00751                                      std::vector<AtomicBlock3D*> atomicBlocks );
00752     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00753                                        std::vector<AtomicBlock3D*> atomicBlocks );
00754 
00755     virtual void processBulk(Box3D domain,
00756                              NTensorField3D<T>& lattice,
00757                              NTensorField3D<int>& mask) =0;
00758     virtual void processPlane( int direction, int orientation, Box3D domain,
00759                                NTensorField3D<T>& lattice,
00760                                NTensorField3D<int>& mask ) =0;
00761     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00762                               NTensorField3D<T>& lattice,
00763                               NTensorField3D<int>& mask ) =0;
00764     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00765                                 NTensorField3D<T>& lattice,
00766                                 NTensorField3D<int>& mask ) =0;
00767 };
00768 
00770 template<typename T1, template<typename U1> class Descriptor1,
00771          typename T2, template<typename U2> class Descriptor2>
00772 struct BoundedReductiveBoxProcessingFunctional3D_LL : public BoundedReductiveBoxProcessingFunctional3D {
00773     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00774     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00775                                        std::vector<AtomicBlock3D*> atomicBlocks );
00776     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00777                                      std::vector<AtomicBlock3D*> atomicBlocks );
00778     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00779                                        std::vector<AtomicBlock3D*> atomicBlocks );
00780 
00781     virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor1>& lattice1,
00782                                             BlockLattice3D<T2,Descriptor2>& lattice2 ) =0;
00783     virtual void processPlane( int direction, int orientation, Box3D domain,
00784                                BlockLattice3D<T1,Descriptor1>& lattice1,
00785                                BlockLattice3D<T2,Descriptor2>& lattice2 ) =0;
00786     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00787                               BlockLattice3D<T1,Descriptor1>& lattice1,
00788                               BlockLattice3D<T2,Descriptor2>& lattice2 ) =0;
00789     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00790                                 BlockLattice3D<T1,Descriptor1>& lattice1,
00791                                 BlockLattice3D<T2,Descriptor2>& lattice2 ) =0;
00792 };
00793 
00795 template<typename T1, typename T2>
00796 struct BoundedReductiveBoxProcessingFunctional3D_SS : public BoundedReductiveBoxProcessingFunctional3D {
00797     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00798     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00799                                        std::vector<AtomicBlock3D*> atomicBlocks );
00800     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00801                                      std::vector<AtomicBlock3D*> atomicBlocks );
00802     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00803                                        std::vector<AtomicBlock3D*> atomicBlocks );
00804 
00805     virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1,
00806                                             ScalarField3D<T2>& field2 ) =0;
00807     virtual void processPlane( int direction, int orientation, Box3D domain,
00808                                ScalarField3D<T1>& field1,
00809                                ScalarField3D<T2>& field2 ) =0;
00810     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00811                               ScalarField3D<T1>& field1,
00812                               ScalarField3D<T2>& field2 ) =0;
00813     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00814                                 ScalarField3D<T1>& field1,
00815                                 ScalarField3D<T2>& field2 ) =0;
00816 };
00817 
00819 template<typename T1, int nDim1, typename T2, int nDim2>
00820 struct BoundedReductiveBoxProcessingFunctional3D_TT : public BoundedReductiveBoxProcessingFunctional3D {
00821     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00822     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00823                                        std::vector<AtomicBlock3D*> atomicBlocks );
00824     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00825                                      std::vector<AtomicBlock3D*> atomicBlocks );
00826     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00827                                        std::vector<AtomicBlock3D*> atomicBlocks );
00828 
00829     virtual void processBulk( Box3D domain, TensorField3D<T1,nDim1>& field1,
00830                                             TensorField3D<T2,nDim2>& field2 ) =0;
00831     virtual void processPlane( int direction, int orientation, Box3D domain,
00832                                TensorField3D<T1,nDim1>& field1,
00833                                TensorField3D<T2,nDim2>& field2 ) =0;
00834     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00835                               TensorField3D<T1,nDim1>& field1,
00836                               TensorField3D<T2,nDim2>& field2 ) =0;
00837     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00838                                 TensorField3D<T1,nDim1>& field1,
00839                                 TensorField3D<T2,nDim2>& field2 ) =0;
00840 };
00841 
00843 template<typename T1, typename T2, int nDim>
00844 struct BoundedReductiveBoxProcessingFunctional3D_ST : public BoundedReductiveBoxProcessingFunctional3D {
00845     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00846     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00847                                        std::vector<AtomicBlock3D*> atomicBlocks );
00848     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00849                                      std::vector<AtomicBlock3D*> atomicBlocks );
00850     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00851                                        std::vector<AtomicBlock3D*> atomicBlocks );
00852 
00853     virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1,
00854                                             TensorField3D<T2,nDim>& field2 ) =0;
00855     virtual void processPlane( int direction, int orientation, Box3D domain,
00856                                ScalarField3D<T1>& field1,
00857                                TensorField3D<T2,nDim>& field2 ) =0;
00858     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00859                               ScalarField3D<T1>& field1,
00860                               TensorField3D<T2,nDim>& field2 ) =0;
00861     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00862                                 ScalarField3D<T1>& field1,
00863                                 TensorField3D<T2,nDim>& field2 ) =0;
00864 };
00865 
00867 template<typename T1, typename T2>
00868 struct BoundedReductiveBoxProcessingFunctional3D_NN : public BoundedReductiveBoxProcessingFunctional3D {
00869     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00870     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00871                                        std::vector<AtomicBlock3D*> atomicBlocks );
00872     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00873                                      std::vector<AtomicBlock3D*> atomicBlocks );
00874     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00875                                        std::vector<AtomicBlock3D*> atomicBlocks );
00876 
00877     virtual void processBulk( Box3D domain, NTensorField3D<T1>& field1,
00878                                             NTensorField3D<T2>& field2 ) =0;
00879     virtual void processPlane( int direction, int orientation, Box3D domain,
00880                                NTensorField3D<T1>& field1,
00881                                NTensorField3D<T2>& field2 ) =0;
00882     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00883                               NTensorField3D<T1>& field1,
00884                               NTensorField3D<T2>& field2 ) =0;
00885     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00886                                 NTensorField3D<T1>& field1,
00887                                 NTensorField3D<T2>& field2 ) =0;
00888 };
00889 
00891 template<typename T1, typename T2>
00892 struct BoundedMaskedReductiveBoxProcessingFunctional3D_NN : public BoundedReductiveBoxProcessingFunctional3D {
00893     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00894     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00895                                        std::vector<AtomicBlock3D*> atomicBlocks );
00896     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00897                                      std::vector<AtomicBlock3D*> atomicBlocks );
00898     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00899                                        std::vector<AtomicBlock3D*> atomicBlocks );
00900 
00901     virtual void processBulk( Box3D domain, NTensorField3D<T1>& field1,
00902                                             NTensorField3D<T2>& field2,
00903                                             NTensorField3D<int>& mask ) =0;
00904     virtual void processPlane( int direction, int orientation, Box3D domain,
00905                                NTensorField3D<T1>& field1,
00906                                NTensorField3D<T2>& field2,
00907                                NTensorField3D<int>& mask ) =0;
00908     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00909                               NTensorField3D<T1>& field1,
00910                               NTensorField3D<T2>& field2,
00911                               NTensorField3D<int>& mask ) =0;
00912     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00913                                 NTensorField3D<T1>& field1,
00914                                 NTensorField3D<T2>& field2,
00915                                 NTensorField3D<int>& mask ) =0;
00916 };
00917 
00919 template<typename T1, typename T2>
00920 struct BoundedReductiveBoxProcessingFunctional3D_SN : public BoundedReductiveBoxProcessingFunctional3D {
00921     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00922     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00923                                        std::vector<AtomicBlock3D*> atomicBlocks );
00924     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00925                                      std::vector<AtomicBlock3D*> atomicBlocks );
00926     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00927                                        std::vector<AtomicBlock3D*> atomicBlocks );
00928 
00929     virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1,
00930                                             NTensorField3D<T2>& field2 ) =0;
00931     virtual void processPlane( int direction, int orientation, Box3D domain,
00932                                ScalarField3D<T1>& field1,
00933                                NTensorField3D<T2>& field2 ) =0;
00934     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00935                               ScalarField3D<T1>& field1,
00936                               NTensorField3D<T2>& field2 ) =0;
00937     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00938                                 ScalarField3D<T1>& field1,
00939                                 NTensorField3D<T2>& field2 ) =0;
00940 };
00941 
00943 template<typename T1, template<typename U> class Descriptor, typename T2>
00944 struct BoundedReductiveBoxProcessingFunctional3D_LS : public BoundedReductiveBoxProcessingFunctional3D {
00945     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00946     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00947                                        std::vector<AtomicBlock3D*> atomicBlocks );
00948     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00949                                      std::vector<AtomicBlock3D*> atomicBlocks );
00950     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00951                                        std::vector<AtomicBlock3D*> atomicBlocks );
00952 
00953     virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00954                                             ScalarField3D<T2>& field ) =0;
00955     virtual void processPlane( int direction, int orientation, Box3D domain,
00956                                BlockLattice3D<T1,Descriptor>& lattice,
00957                                ScalarField3D<T2>& field ) =0;
00958     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00959                               BlockLattice3D<T1,Descriptor>& lattice,
00960                               ScalarField3D<T2>& field ) =0;
00961     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00962                                 BlockLattice3D<T1,Descriptor>& lattice,
00963                                 ScalarField3D<T2>& field ) =0;
00964 };
00965 
00967 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00968 struct BoundedReductiveBoxProcessingFunctional3D_LT : public BoundedReductiveBoxProcessingFunctional3D {
00969     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00970     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00971                                        std::vector<AtomicBlock3D*> atomicBlocks );
00972     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00973                                      std::vector<AtomicBlock3D*> atomicBlocks );
00974     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00975                                        std::vector<AtomicBlock3D*> atomicBlocks );
00976 
00977     virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
00978                                             TensorField3D<T2,nDim>& field ) =0;
00979     virtual void processPlane( int direction, int orientation, Box3D domain,
00980                                BlockLattice3D<T1,Descriptor>& lattice,
00981                                TensorField3D<T2,nDim>& field ) =0;
00982     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00983                               BlockLattice3D<T1,Descriptor>& lattice,
00984                               TensorField3D<T2,nDim>& field ) =0;
00985     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00986                                 BlockLattice3D<T1,Descriptor>& lattice,
00987                                 TensorField3D<T2,nDim>& field ) =0;
00988 };
00989 
00991 template<typename T1, template<typename U> class Descriptor, typename T2>
00992 struct BoundedReductiveBoxProcessingFunctional3D_LN : public BoundedReductiveBoxProcessingFunctional3D {
00993     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
00994     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
00995                                        std::vector<AtomicBlock3D*> atomicBlocks );
00996     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
00997                                      std::vector<AtomicBlock3D*> atomicBlocks );
00998     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
00999                                        std::vector<AtomicBlock3D*> atomicBlocks );
01000 
01001     virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
01002                                             NTensorField3D<T2>& field ) =0;
01003     virtual void processPlane( int direction, int orientation, Box3D domain,
01004                                BlockLattice3D<T1,Descriptor>& lattice,
01005                                NTensorField3D<T2>& field ) =0;
01006     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01007                               BlockLattice3D<T1,Descriptor>& lattice,
01008                               NTensorField3D<T2>& field ) =0;
01009     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01010                                 BlockLattice3D<T1,Descriptor>& lattice,
01011                                 NTensorField3D<T2>& field ) =0;
01012 };
01013 
01015 template<typename T1, template<typename U> class Descriptor, typename T2>
01016 struct BoundedMaskedReductiveBoxProcessingFunctional3D_LN : public BoundedReductiveBoxProcessingFunctional3D {
01017     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
01018     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
01019                                        std::vector<AtomicBlock3D*> atomicBlocks );
01020     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
01021                                      std::vector<AtomicBlock3D*> atomicBlocks );
01022     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
01023                                        std::vector<AtomicBlock3D*> atomicBlocks );
01024 
01025     virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice,
01026                                             NTensorField3D<T2>& field,
01027                                             NTensorField3D<int>& mask ) =0;
01028     virtual void processPlane( int direction, int orientation, Box3D domain,
01029                                BlockLattice3D<T1,Descriptor>& lattice,
01030                                NTensorField3D<T2>& field,
01031                                NTensorField3D<int>& mask ) =0;
01032     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01033                               BlockLattice3D<T1,Descriptor>& lattice,
01034                               NTensorField3D<T2>& field,
01035                               NTensorField3D<int>& mask ) =0;
01036     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01037                                 BlockLattice3D<T1,Descriptor>& lattice,
01038                                 NTensorField3D<T2>& field,
01039                                 NTensorField3D<int>& mask ) =0;
01040 };
01041 
01043 template<typename T, template<typename U> class Descriptor>
01044 struct BoundedReductiveLatticeBoxProcessingFunctional3D : public BoundedReductiveBoxProcessingFunctional3D {
01045     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
01046     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
01047                                        std::vector<AtomicBlock3D*> atomicBlocks );
01048     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
01049                                      std::vector<AtomicBlock3D*> atomicBlocks );
01050     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
01051                                        std::vector<AtomicBlock3D*> atomicBlocks );
01052 
01053     virtual void processBulk(Box3D domain, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0;
01054     virtual void processPlane( int direction, int orientation, Box3D domain,
01055                                std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0;
01056     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01057                               std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0;
01058     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01059                                 std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0;
01060 };
01061 
01063 template<typename T>
01064 struct BoundedReductiveScalarFieldBoxProcessingFunctional3D : public BoundedReductiveBoxProcessingFunctional3D {
01065     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
01066     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
01067                                        std::vector<AtomicBlock3D*> atomicBlocks );
01068     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
01069                                      std::vector<AtomicBlock3D*> atomicBlocks );
01070     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
01071                                        std::vector<AtomicBlock3D*> atomicBlocks );
01072 
01073     virtual void processBulk(Box3D domain, std::vector<ScalarField3D<T>*> field) =0;
01074     virtual void processPlane( int direction, int orientation, Box3D domain,
01075                                std::vector<ScalarField3D<T>*> field ) =0;
01076     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01077                               std::vector<ScalarField3D<T>*> field ) =0;
01078     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01079                                 std::vector<ScalarField3D<T>*> field ) =0;
01080 };
01081 
01083 template<typename T, int nDim>
01084 struct BoundedReductiveTensorFieldBoxProcessingFunctional3D : public BoundedReductiveBoxProcessingFunctional3D {
01085     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
01086     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
01087                                        std::vector<AtomicBlock3D*> atomicBlocks );
01088     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
01089                                      std::vector<AtomicBlock3D*> atomicBlocks );
01090     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
01091                                        std::vector<AtomicBlock3D*> atomicBlocks );
01092 
01093     virtual void processBulk(Box3D domain, std::vector<TensorField3D<T,nDim>*> field) =0;
01094     virtual void processPlane( int direction, int orientation, Box3D domain,
01095                                std::vector<TensorField3D<T,nDim>*> field ) =0;
01096     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01097                               std::vector<TensorField3D<T,nDim>*> field ) =0;
01098     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01099                                 std::vector<TensorField3D<T,nDim>*> field ) =0;
01100 };
01101 
01103 template<typename T>
01104 struct BoundedReductiveNTensorFieldBoxProcessingFunctional3D : public BoundedReductiveBoxProcessingFunctional3D {
01105     virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks);
01106     virtual void processPlaneGeneric( int direction, int orientation, Box3D domain,
01107                                        std::vector<AtomicBlock3D*> atomicBlocks );
01108     virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain,
01109                                      std::vector<AtomicBlock3D*> atomicBlocks );
01110     virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain,
01111                                        std::vector<AtomicBlock3D*> atomicBlocks );
01112 
01113     virtual void processBulk(Box3D domain, std::vector<NTensorField3D<T>*> field) =0;
01114     virtual void processPlane( int direction, int orientation, Box3D domain,
01115                                std::vector<NTensorField3D<T>*> field ) =0;
01116     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
01117                               std::vector<NTensorField3D<T>*> field ) =0;
01118     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
01119                                 std::vector<NTensorField3D<T>*> field ) =0;
01120 };
01121 
01122 }  // namespace plb
01123 
01124 #endif  // REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_3D_H