reductiveDataProcessingFunctional2D.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_2D_H
00029 #define REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_2D_H
00030 
00031 #include "core/globalDefs.h"
00032 #include "core/geometry2D.h"
00033 #include "core/blockSurface2D.h"
00034 #include "atomicBlock/dataProcessor2D.h"
00035 #include <vector>
00036 
00037 namespace plb {
00038 
00039 // Forward declarations.
00040 
00041 template<typename T, template<typename U> class Descriptor> class BlockLatticeBase2D;
00042 template<typename T, template<typename U> class Descriptor> class BlockLattice2D;
00043 template<typename T> class ScalarFieldBase2D;
00044 template<typename T> class ScalarField2D;
00045 template<typename T, int nDim> class TensorFieldBase2D;
00046 template<typename T, int nDim> class TensorField2D;
00047 template<typename T> class NTensorFieldBase2D;
00048 template<typename T> class NTensorField2D;
00049 
00050 
00051 /* *************** All flavors of Box processing functionals ********* */
00052 
00054 struct ReductiveBoxProcessingFunctional2D {
00055     virtual ~ReductiveBoxProcessingFunctional2D() { }
00056     virtual void processGenericBlocks(Box2D domain,
00057                                       std::vector<AtomicBlock2D*> 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 ReductiveBoxProcessingFunctional2D* 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 PlainReductiveBoxProcessingFunctional2D : public ReductiveBoxProcessingFunctional2D {
00075 public:
00076     virtual BlockStatistics const& getStatistics() const;
00077     virtual BlockStatistics& getStatistics();
00078 private:
00079     BlockStatistics statistics;
00080 };
00081 
00083 class ReductiveBoxProcessor2D : public DataProcessor2D {
00084 public:
00088     ReductiveBoxProcessor2D(ReductiveBoxProcessingFunctional2D* functional_,
00089                             Box2D domain_, std::vector<AtomicBlock2D*> atomicBlocks_);
00090     Box2D getDomain() const;
00091     virtual void process();
00092     virtual ReductiveBoxProcessor2D* clone() const;
00093     virtual int getStaticId() const;
00094 private:
00095     ReductiveBoxProcessingFunctional2D* functional;
00096     Box2D domain;
00097     std::vector<AtomicBlock2D*> atomicBlocks;
00098 };
00099 
00101 class ReductiveBoxProcessorGenerator2D : public BoxedReductiveDataProcessorGenerator2D {
00102 public:
00106     ReductiveBoxProcessorGenerator2D(ReductiveBoxProcessingFunctional2D* functional_, Box2D domain);
00107     ~ReductiveBoxProcessorGenerator2D();
00108     ReductiveBoxProcessorGenerator2D(ReductiveBoxProcessorGenerator2D const& rhs);
00109     ReductiveBoxProcessorGenerator2D& operator=(ReductiveBoxProcessorGenerator2D 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 DataProcessor2D* generate(std::vector<AtomicBlock2D*> atomicBlocks);
00117     virtual ReductiveBoxProcessorGenerator2D* clone() const;
00118     virtual BlockStatistics const& getStatistics() const;
00119     virtual BlockStatistics& getStatistics();
00120     ReductiveBoxProcessingFunctional2D const& getFunctional() const;
00121     virtual void serialize(Box2D& domain, std::string& data) const;
00122     virtual int getStaticId() const;
00123 private:
00124     ReductiveBoxProcessingFunctional2D* functional;
00125 };
00126 
00128 template<typename T, template<typename U> class Descriptor>
00129 struct ReductiveBoxProcessingFunctional2D_L : public PlainReductiveBoxProcessingFunctional2D {
00130     virtual void process(Box2D domain, BlockLattice2D<T,Descriptor>& lattice) =0;
00132     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00133 };
00134 
00136 template<typename T>
00137 struct ReductiveBoxProcessingFunctional2D_S : public PlainReductiveBoxProcessingFunctional2D {
00138     virtual void process(Box2D domain, ScalarField2D<T>& field) =0;
00140     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00141 };
00142 
00144 template<typename T, int nDim>
00145 struct ReductiveBoxProcessingFunctional2D_T : public PlainReductiveBoxProcessingFunctional2D {
00146     virtual void process(Box2D domain, TensorField2D<T,nDim>& field) =0;
00148     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00149 };
00150 
00152 template<typename T>
00153 struct ReductiveBoxProcessingFunctional2D_N : public PlainReductiveBoxProcessingFunctional2D {
00154     virtual void process(Box2D domain, NTensorField2D<T>& field) =0;
00156     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00157 };
00158 
00160 template<typename T>
00161 struct MaskedReductiveBoxProcessingFunctional2D_N : public PlainReductiveBoxProcessingFunctional2D {
00162     virtual void process(Box2D domain,
00163                          NTensorField2D<T>& field,
00164                          NTensorField2D<int>& mask) =0;
00166     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00167 };
00168 
00170 template<typename T1, template<typename U1> class Descriptor1,
00171          typename T2, template<typename U2> class Descriptor2>
00172 struct ReductiveBoxProcessingFunctional2D_LL : public PlainReductiveBoxProcessingFunctional2D {
00173     virtual void process(Box2D domain, BlockLattice2D<T1,Descriptor1>& lattice1,
00174                                        BlockLattice2D<T2,Descriptor2>& lattice2) =0;
00176     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00177 };
00178 
00180 template<typename T1, typename T2>
00181 struct ReductiveBoxProcessingFunctional2D_SS : public PlainReductiveBoxProcessingFunctional2D {
00182     virtual void process(Box2D domain, ScalarField2D<T1>& field1,
00183                                        ScalarField2D<T2>& field2) =0;
00185     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00186 };
00187 
00189 template<typename T1, int nDim1,
00190          typename T2, int nDim2>
00191 struct ReductiveBoxProcessingFunctional2D_TT : public PlainReductiveBoxProcessingFunctional2D {
00192     virtual void process(Box2D domain, TensorField2D<T1,nDim1>& field1,
00193                                        TensorField2D<T2,nDim2>& field2) =0;
00195     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00196 };
00197 
00199 template<typename T1, typename T2, int nDim>
00200 struct ReductiveBoxProcessingFunctional2D_ST : public PlainReductiveBoxProcessingFunctional2D {
00201     virtual void process(Box2D domain, ScalarField2D<T1>& field1,
00202                                        TensorField2D<T2,nDim>& field2) =0;
00204     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00205 };
00206 
00208 template<typename T1, typename T2>
00209 struct ReductiveBoxProcessingFunctional2D_NN : public PlainReductiveBoxProcessingFunctional2D {
00210     virtual void process(Box2D domain, NTensorField2D<T1>& field1,
00211                                        NTensorField2D<T2>& field2) =0;
00213     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00214 };
00215 
00217 template<typename T1, typename T2>
00218 struct MaskedReductiveBoxProcessingFunctional2D_NN : public PlainReductiveBoxProcessingFunctional2D {
00219     virtual void process(Box2D domain, NTensorField2D<T1>& field1,
00220                                        NTensorField2D<T2>& field2,
00221                                        NTensorField2D<int>& mask) =0;
00223     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00224 };
00225 
00227 template<typename T1, typename T2>
00228 struct ReductiveBoxProcessingFunctional2D_SN : public PlainReductiveBoxProcessingFunctional2D {
00229     virtual void process(Box2D domain, ScalarField2D<T1>& field1,
00230                                        NTensorField2D<T2>& field2) =0;
00232     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00233 };
00234 
00236 template<typename T1, template<typename U> class Descriptor, typename T2>
00237 struct ReductiveBoxProcessingFunctional2D_LS : public PlainReductiveBoxProcessingFunctional2D {
00238     virtual void process(Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00239                                        ScalarField2D<T2>& field) =0;
00241     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00242 };
00243 
00245 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim>
00246 struct ReductiveBoxProcessingFunctional2D_LT : public PlainReductiveBoxProcessingFunctional2D {
00247     virtual void process(Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00248                                        TensorField2D<T2,nDim>& field) =0;
00250     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00251 };
00252 
00254 template<typename T1, template<typename U> class Descriptor, typename T2>
00255 struct ReductiveBoxProcessingFunctional2D_LN : public PlainReductiveBoxProcessingFunctional2D {
00256     virtual void process(Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00257                                        NTensorField2D<T2>& field) =0;
00259     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00260 };
00261 
00263 template<typename T1, template<typename U> class Descriptor, typename T2>
00264 struct MaskedReductiveBoxProcessingFunctional2D_LN : public PlainReductiveBoxProcessingFunctional2D {
00265     virtual void process(Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00266                                        NTensorField2D<T2>& field,
00267                                        NTensorField2D<int>& mask) =0;
00269     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00270 };
00271 
00273 template<typename T, template<typename U> class Descriptor>
00274 struct ReductiveLatticeBoxProcessingFunctional2D : public PlainReductiveBoxProcessingFunctional2D {
00275     virtual void process(Box2D domain, std::vector<BlockLattice2D<T,Descriptor>*> lattices) =0;
00277     virtual void processGenericBlocks(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00278 };
00279 
00281 template<typename T>
00282 struct ReductiveScalarFieldBoxProcessingFunctional2D : public PlainReductiveBoxProcessingFunctional2D {
00283     virtual void process(Box2D domain, std::vector<ScalarField2D<T>*> scalarFields) =0;
00285     virtual void processGenericBlocks( Box2D domain,
00286                                        std::vector<AtomicBlock2D*> atomicBlocks );
00287 };
00288 
00290 template<typename T, int nDim>
00291 struct ReductiveTensorFieldBoxProcessingFunctional2D : public PlainReductiveBoxProcessingFunctional2D {
00292     virtual void process(Box2D domain, std::vector<TensorField2D<T,nDim>*> tensorFields) =0;
00294     virtual void processGenericBlocks( Box2D domain,
00295                                        std::vector<AtomicBlock2D*> atomicBlocks );
00296 };
00297 
00299 template<typename T>
00300 struct ReductiveNTensorFieldBoxProcessingFunctional2D : public PlainReductiveBoxProcessingFunctional2D {
00301     virtual void process(Box2D domain, std::vector<NTensorField2D<T>*> tensorFields) =0;
00303     virtual void processGenericBlocks( Box2D domain,
00304                                        std::vector<AtomicBlock2D*> atomicBlocks );
00305 };
00306 
00307 
00308 /* *************** All flavors of Dot processing functionals ********* */
00309 
00311 class ReductiveDotProcessingFunctional2D {
00312 public:
00313     virtual ~ReductiveDotProcessingFunctional2D() { }
00314     virtual void processGenericBlocks(DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks) =0;
00315     virtual BlockDomain::DomainT appliesTo() const;
00316     virtual void rescale(double dxScale, double dtScale);
00317     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00318     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00319     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00320     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0;
00321     virtual ReductiveDotProcessingFunctional2D* clone() const =0;
00322     virtual BlockStatistics const& getStatistics() const =0;
00323     virtual BlockStatistics& getStatistics() =0;
00324 };
00325 
00327 class PlainReductiveDotProcessingFunctional2D : public ReductiveDotProcessingFunctional2D {
00328 public:
00329     virtual BlockStatistics const& getStatistics() const;
00330     virtual BlockStatistics& getStatistics();
00331 private:
00332     BlockStatistics statistics;
00333 };
00334 
00335 
00337 class ReductiveDotProcessor2D : public DataProcessor2D {
00338 public:
00342     ReductiveDotProcessor2D(ReductiveDotProcessingFunctional2D* functional_,
00343                             DotList2D const& dotList_, std::vector<AtomicBlock2D*> atomicBlocks_);
00344     DotList2D const& getDotList() const;
00345     virtual void process();
00346     virtual ReductiveDotProcessor2D* clone() const;
00347 private:
00348     ReductiveDotProcessingFunctional2D* functional;
00349     DotList2D dotList;
00350     std::vector<AtomicBlock2D*> atomicBlocks;
00351 };
00352 
00354 class ReductiveDotProcessorGenerator2D : public DottedReductiveDataProcessorGenerator2D {
00355 public:
00356     ReductiveDotProcessorGenerator2D(ReductiveDotProcessingFunctional2D* functional_, DotList2D const& dotList);
00357     ~ReductiveDotProcessorGenerator2D();
00358     ReductiveDotProcessorGenerator2D(ReductiveDotProcessorGenerator2D const& rhs);
00359     ReductiveDotProcessorGenerator2D& operator=(ReductiveDotProcessorGenerator2D const& rhs);
00360     virtual BlockDomain::DomainT appliesTo() const;
00361     virtual void rescale(double dxScale, double dtScale);
00362     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00363     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00364     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00365     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00366     virtual DataProcessor2D* generate(std::vector<AtomicBlock2D*> atomicBlocks);
00367     virtual ReductiveDotProcessorGenerator2D* clone() const;
00368     virtual BlockStatistics const& getStatistics() const;
00369     virtual BlockStatistics& getStatistics();
00370     ReductiveDotProcessingFunctional2D const& getFunctional() const;
00371 private:
00372     ReductiveDotProcessingFunctional2D* functional;
00373 };
00374 
00376 template<typename T, template<typename U> class Descriptor>
00377 struct ReductiveDotProcessingFunctional2D_L : public PlainReductiveDotProcessingFunctional2D {
00378     virtual void process(DotList2D const& dotList, BlockLattice2D<T,Descriptor>& lattice) =0;
00380     virtual void processGenericBlocks(DotList2D const& dotList, std::vector<AtomicBlock2D*> atomicBlocks);
00381 };
00382 
00384 template<typename T>
00385 struct ReductiveDotProcessingFunctional2D_S : public PlainReductiveDotProcessingFunctional2D {
00386     virtual void process(DotList2D const& dotList, ScalarField2D<T>& field) =0;
00388     virtual void processGenericBlocks( DotList2D const& dotList,
00389                                        std::vector<AtomicBlock2D*> atomicBlocks );
00390 };
00391 
00393 template<typename T, int nDim>
00394 struct ReductiveDotProcessingFunctional2D_T : public PlainReductiveDotProcessingFunctional2D {
00395     virtual void process(DotList2D const& dotList, TensorField2D<T,nDim>& field) =0;
00397     virtual void processGenericBlocks( DotList2D const& dotList,
00398                                        std::vector<AtomicBlock2D*> atomicBlocks );
00399 };
00400 
00402 template<typename T>
00403 struct ReductiveDotProcessingFunctional2D_N : public PlainReductiveDotProcessingFunctional2D {
00404     virtual void process(DotList2D const& dotList, NTensorField2D<T>& field) =0;
00406     virtual void processGenericBlocks( DotList2D const& dotList,
00407                                        std::vector<AtomicBlock2D*> atomicBlocks );
00408 };
00409 
00411 template<typename T1, template<typename U1> class Descriptor1,
00412          typename T2, template<typename U2> class Descriptor2>
00413 struct ReductiveDotProcessingFunctional2D_LL : public PlainReductiveDotProcessingFunctional2D {
00414     virtual void process(DotList2D const& dotList,
00415                          BlockLattice2D<T1,Descriptor1>& lattice1,
00416                          BlockLattice2D<T2,Descriptor2>& lattice2) =0;
00418     virtual void processGenericBlocks( DotList2D const& dotList,
00419                                        std::vector<AtomicBlock2D*> atomicBlocks );
00420 };
00421 
00423 template<typename T1, typename T2>
00424 struct ReductiveDotProcessingFunctional2D_SS : public PlainReductiveDotProcessingFunctional2D {
00425     virtual void process(DotList2D const& dotList, ScalarField2D<T1>& field1,
00426                                                    ScalarField2D<T2>& field2) =0;
00428     virtual void processGenericBlocks( DotList2D const& dotList,
00429                                        std::vector<AtomicBlock2D*> atomicBlocks );
00430 };
00431 
00433 template<typename T1, int nDim1, typename T2, int nDim2>
00434 struct ReductiveDotProcessingFunctional2D_TT : public PlainReductiveDotProcessingFunctional2D {
00435     virtual void process(DotList2D const& dotList,
00436                          TensorField2D<T1,nDim1>& field1,
00437                          TensorField2D<T2,nDim2>& field2) =0;
00439     virtual void processGenericBlocks( DotList2D const& dotList,
00440                                        std::vector<AtomicBlock2D*> atomicBlocks );
00441 };
00442 
00444 template<typename T1, typename T2, int nDim>
00445 struct ReductiveDotProcessingFunctional2D_ST : public PlainReductiveDotProcessingFunctional2D {
00446     virtual void process(DotList2D const& dotList,
00447                          ScalarField2D<T1>& field1,
00448                          TensorField2D<T2,nDim>& field2) =0;
00450     virtual void processGenericBlocks( DotList2D const& dotList,
00451                                        std::vector<AtomicBlock2D*> atomicBlocks );
00452 };
00453 
00455 template<typename T1, typename T2>
00456 struct ReductiveDotProcessingFunctional2D_NN : public PlainReductiveDotProcessingFunctional2D {
00457     virtual void process(DotList2D const& dotList,
00458                          NTensorField2D<T1>& field1,
00459                          NTensorField2D<T2>& field2) =0;
00461     virtual void processGenericBlocks( DotList2D const& dotList,
00462                                        std::vector<AtomicBlock2D*> atomicBlocks );
00463 };
00464 
00466 template<typename T1, typename T2>
00467 struct ReductiveDotProcessingFunctional2D_SN : public PlainReductiveDotProcessingFunctional2D {
00468     virtual void process(DotList2D const& dotList,
00469                          ScalarField2D<T1>& field1,
00470                          NTensorField2D<T2>& field2) =0;
00472     virtual void processGenericBlocks( DotList2D const& dotList,
00473                                        std::vector<AtomicBlock2D*> atomicBlocks );
00474 };
00475 
00477 template<typename T1, template<typename U> class Descriptor, typename T2>
00478 struct ReductiveDotProcessingFunctional2D_LS : public PlainReductiveDotProcessingFunctional2D {
00479     virtual void process(DotList2D const& dotList,
00480                          BlockLattice2D<T1,Descriptor>& lattice,
00481                          ScalarField2D<T2>& field) =0;
00483     virtual void processGenericBlocks( DotList2D const& dotList,
00484                                        std::vector<AtomicBlock2D*> atomicBlocks );
00485 };
00486 
00488 template<typename T1, template<typename U> class Descriptor,
00489          typename T2, int nDim>
00490 struct ReductiveDotProcessingFunctional2D_LT : public PlainReductiveDotProcessingFunctional2D {
00491     virtual void process(DotList2D const& dotList,
00492                          BlockLattice2D<T1,Descriptor>& lattice,
00493                          TensorField2D<T2,nDim>& field) =0;
00495     virtual void processGenericBlocks( DotList2D const& dotList,
00496                                        std::vector<AtomicBlock2D*> atomicBlocks );
00497 };
00498 
00500 template<typename T1, template<typename U> class Descriptor, typename T2>
00501 struct ReductiveDotProcessingFunctional2D_LN : public PlainReductiveDotProcessingFunctional2D {
00502     virtual void process(DotList2D const& dotList,
00503                          BlockLattice2D<T1,Descriptor>& lattice,
00504                          NTensorField2D<T2>& field) =0;
00506     virtual void processGenericBlocks( DotList2D const& dotList,
00507                                        std::vector<AtomicBlock2D*> atomicBlocks );
00508 };
00509 
00511 template<typename T, template<typename U> class Descriptor>
00512 struct ReductiveLatticeDotProcessingFunctional2D : public PlainReductiveDotProcessingFunctional2D {
00513     virtual void process(DotList2D const& dotList, std::vector<BlockLattice2D<T,Descriptor>*> lattices) =0;
00515     virtual void processGenericBlocks( DotList2D const& dotList,
00516                                        std::vector<AtomicBlock2D*> atomicBlocks );
00517 };
00518 
00520 template<typename T>
00521 struct ReductiveScalarFieldDotProcessingFunctional2D : public PlainReductiveDotProcessingFunctional2D {
00522     virtual void process(DotList2D const& dotList, std::vector<ScalarField2D<T>*> scalarFields) =0;
00524     virtual void processGenericBlocks( DotList2D const& dotList,
00525                                        std::vector<AtomicBlock2D*> atomicBlocks );
00526 };
00527 
00529 template<typename T, int nDim>
00530 struct ReductiveTensorFieldDotProcessingFunctional2D : public PlainReductiveDotProcessingFunctional2D {
00531     virtual void process(DotList2D const& dotList, std::vector<TensorField2D<T,nDim>*> tensorFields) =0;
00533     virtual void processGenericBlocks( DotList2D const& dotList,
00534                                        std::vector<AtomicBlock2D*> atomicBlocks );
00535 };
00536 
00538 template<typename T>
00539 struct ReductiveNTensorFieldDotProcessingFunctional2D : public PlainReductiveDotProcessingFunctional2D {
00540     virtual void process(DotList2D const& dotList, std::vector<NTensorField2D<T>*> tensorFields) =0;
00542     virtual void processGenericBlocks( DotList2D const& dotList,
00543                                        std::vector<AtomicBlock2D*> atomicBlocks );
00544 };
00545 
00546 
00547 /* *************** All flavors of Bounded Box processing functionals ********* */
00548 
00550 class BoundedReductiveBoxProcessingFunctional2D {
00551 public:
00552     virtual ~BoundedReductiveBoxProcessingFunctional2D() { }
00553     virtual void processBulkGeneric(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks) =0;
00554     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00555                                      std::vector<AtomicBlock2D*> atomicBlocks ) =0;
00556     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00557                                        std::vector<AtomicBlock2D*> atomicBlocks ) =0;
00558     virtual BlockDomain::DomainT appliesTo() const;
00559     virtual void rescale(double dxScale, double dtScale);
00560     virtual void getDimensionsX(std::vector<int>& dimensions) const;
00561     virtual void getDimensionsT(std::vector<int>& dimensions) const;
00562     virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00563     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0;
00564     virtual BoundedReductiveBoxProcessingFunctional2D* clone() const =0;
00565     ReductiveBoxProcessingFunctional2D* getBulkProcessor() const; 
00566     ReductiveBoxProcessingFunctional2D* getEdgeProcessor(int direction, int orientation) const; 
00567     ReductiveBoxProcessingFunctional2D* getCornerProcessor(int normalX, int normalY) const; 
00568     BlockStatistics const& getStatistics() const;
00569     BlockStatistics& getStatistics();
00570     void getGenerators (
00571             Box2D const& fullDomain, plint boundaryWidth_,
00572             std::vector<ReductiveBoxProcessorGenerator2D*>& generators );
00573 private:
00574     BlockStatistics statistics;
00575 public:
00576     class BulkWrapperFunctional : public ReductiveBoxProcessingFunctional2D {
00577     public:
00578         BulkWrapperFunctional(BoundedReductiveBoxProcessingFunctional2D* boundedFunctional_);
00579         BulkWrapperFunctional(BulkWrapperFunctional const& rhs);
00580         ~BulkWrapperFunctional();
00581         BulkWrapperFunctional& operator=(BulkWrapperFunctional const& rhs);
00582         virtual void processGenericBlocks(Box2D domain,
00583                                           std::vector<AtomicBlock2D*> atomicBlocks);
00584         virtual BlockDomain::DomainT appliesTo() const;
00585         virtual void rescale(double dxScale, double dtScale);
00586         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00587         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00588         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00589         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00590         virtual BulkWrapperFunctional* clone() const;
00591         virtual BlockStatistics const& getStatistics() const;
00592         virtual BlockStatistics& getStatistics();
00593     private:
00594         BoundedReductiveBoxProcessingFunctional2D* boundedFunctional;
00595     };
00596     class EdgeWrapperFunctional : public ReductiveBoxProcessingFunctional2D {
00597     public:
00598         EdgeWrapperFunctional(BoundedReductiveBoxProcessingFunctional2D* boundedFunctional_,
00599                               int direction_, int orientation_);
00600         EdgeWrapperFunctional(EdgeWrapperFunctional const& rhs);
00601         ~EdgeWrapperFunctional();
00602         EdgeWrapperFunctional& operator=(EdgeWrapperFunctional const& rhs);
00603         virtual void processGenericBlocks(Box2D domain,
00604                                           std::vector<AtomicBlock2D*> atomicBlocks);
00605         virtual BlockDomain::DomainT appliesTo() const;
00606         virtual void rescale(double dxScale, double dtScale);
00607         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00608         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00609         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00610         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00611         virtual EdgeWrapperFunctional* clone() const;
00612         virtual BlockStatistics const& getStatistics() const;
00613         virtual BlockStatistics& getStatistics();
00614     private:
00615         BoundedReductiveBoxProcessingFunctional2D* boundedFunctional;
00616         int direction, orientation;
00617     };
00618     class CornerWrapperFunctional : public ReductiveBoxProcessingFunctional2D {
00619     public:
00620         CornerWrapperFunctional(BoundedReductiveBoxProcessingFunctional2D* boundedFunctional_,
00621                                 int normalX_, int normalY_);
00622         CornerWrapperFunctional(CornerWrapperFunctional const& rhs);
00623         ~CornerWrapperFunctional();
00624         CornerWrapperFunctional& operator=(CornerWrapperFunctional const& rhs);
00625         virtual void processGenericBlocks(Box2D domain,
00626                                           std::vector<AtomicBlock2D*> atomicBlocks);
00627         virtual BlockDomain::DomainT appliesTo() const;
00628         virtual void rescale(double dxScale, double dtScale);
00629         virtual void getDimensionsX(std::vector<int>& dimensions) const;
00630         virtual void getDimensionsT(std::vector<int>& dimensions) const;
00631         virtual void getModificationPattern(std::vector<bool>& isWritten) const;
00632         virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00633         virtual CornerWrapperFunctional* clone() const;
00634         virtual BlockStatistics const& getStatistics() const;
00635         virtual BlockStatistics& getStatistics();
00636     private:
00637         BoundedReductiveBoxProcessingFunctional2D* boundedFunctional;
00638         int normalX, normalY;
00639     };
00640 };
00641 
00643 template<typename T, template<typename U> class Descriptor>
00644 struct BoundedReductiveBoxProcessingFunctional2D_L : public BoundedReductiveBoxProcessingFunctional2D {
00645     virtual void processBulkGeneric(Box2D domain,
00646                                     std::vector<AtomicBlock2D*> atomicBlocks);
00647     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00648                                      std::vector<AtomicBlock2D*> atomicBlocks );
00649     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00650                                        std::vector<AtomicBlock2D*> atomicBlocks );
00651 
00652     virtual void processBulk(Box2D domain, BlockLattice2D<T,Descriptor>& lattice) =0;
00653     virtual void processEdge( int direction, int orientation, Box2D domain,
00654                               BlockLattice2D<T,Descriptor>& lattice ) =0;
00655     virtual void processCorner( int normalX, int normalY, Box2D domain,
00656                                 BlockLattice2D<T,Descriptor>& lattice ) =0;
00657 };
00658 
00660 template<typename T>
00661 struct BoundedReductiveBoxProcessingFunctional2D_S : public BoundedReductiveBoxProcessingFunctional2D {
00662     virtual void processBulkGeneric(Box2D domain,
00663                                     std::vector<AtomicBlock2D*> atomicBlocks);
00664     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00665                                      std::vector<AtomicBlock2D*> atomicBlocks );
00666     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00667                                        std::vector<AtomicBlock2D*> atomicBlocks );
00668 
00669     virtual void processBulk(Box2D domain, ScalarField2D<T>& field) =0;
00670     virtual void processEdge( int direction, int orientation, Box2D domain,
00671                               ScalarField2D<T>& field ) =0;
00672     virtual void processCorner( int normalX, int normalY, Box2D domain,
00673                                 ScalarField2D<T>& field ) =0;
00674 };
00675 
00677 template<typename T, int nDim>
00678 struct BoundedReductiveBoxProcessingFunctional2D_T : public BoundedReductiveBoxProcessingFunctional2D {
00679     virtual void processBulkGeneric(Box2D domain,
00680                                     std::vector<AtomicBlock2D*> atomicBlocks);
00681     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00682                                      std::vector<AtomicBlock2D*> atomicBlocks );
00683     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00684                                        std::vector<AtomicBlock2D*> atomicBlocks );
00685 
00686     virtual void processBulk(Box2D domain, TensorField2D<T,nDim>& field) =0;
00687     virtual void processEdge( int direction, int orientation, Box2D domain,
00688                               TensorField2D<T,nDim>& field ) =0;
00689     virtual void processCorner( int normalX, int normalY, Box2D domain,
00690                                 TensorField2D<T,nDim>& field ) =0;
00691 };
00692 
00694 template<typename T>
00695 struct BoundedReductiveBoxProcessingFunctional2D_N : public BoundedReductiveBoxProcessingFunctional2D {
00696     virtual void processBulkGeneric(Box2D domain,
00697                                     std::vector<AtomicBlock2D*> atomicBlocks);
00698     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00699                                      std::vector<AtomicBlock2D*> atomicBlocks );
00700     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00701                                        std::vector<AtomicBlock2D*> atomicBlocks );
00702 
00703     virtual void processBulk(Box2D domain, NTensorField2D<T>& field) =0;
00704     virtual void processEdge( int direction, int orientation, Box2D domain,
00705                               NTensorField2D<T>& field ) =0;
00706     virtual void processCorner( int normalX, int normalY, Box2D domain,
00707                                 NTensorField2D<T>& field ) =0;
00708 };
00709 
00711 template<typename T>
00712 struct BoundedMaskedReductiveBoxProcessingFunctional2D_N : public BoundedReductiveBoxProcessingFunctional2D {
00713     virtual void processBulkGeneric(Box2D domain,
00714                                     std::vector<AtomicBlock2D*> atomicBlocks);
00715     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00716                                      std::vector<AtomicBlock2D*> atomicBlocks );
00717     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00718                                        std::vector<AtomicBlock2D*> atomicBlocks );
00719 
00720     virtual void processBulk(Box2D domain,
00721                              NTensorField2D<T>& field,
00722                              NTensorField2D<int>& mask) =0;
00723     virtual void processEdge( int direction, int orientation, Box2D domain,
00724                               NTensorField2D<T>& field,
00725                               NTensorField2D<int>& mask) =0;
00726     virtual void processCorner( int normalX, int normalY, Box2D domain,
00727                                 NTensorField2D<T>& field,
00728                                 NTensorField2D<int>& mask) =0;
00729 };
00730 
00732 template<typename T1, template<typename U1> class Descriptor1,
00733          typename T2, template<typename U2> class Descriptor2>
00734 struct BoundedReductiveBoxProcessingFunctional2D_LL : public BoundedReductiveBoxProcessingFunctional2D {
00735     virtual void processBulkGeneric(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00736     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00737                                      std::vector<AtomicBlock2D*> atomicBlocks );
00738     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00739                                        std::vector<AtomicBlock2D*> atomicBlocks );
00740 
00741     virtual void processBulk( Box2D domain, BlockLattice2D<T1,Descriptor1>& lattice1,
00742                                             BlockLattice2D<T2,Descriptor2>& lattice2 ) =0;
00743     virtual void processEdge( int direction, int orientation, Box2D domain,
00744                               BlockLattice2D<T1,Descriptor1>& lattice1,
00745                               BlockLattice2D<T2,Descriptor2>& lattice2 ) =0;
00746     virtual void processCorner( int normalX, int normalY, Box2D domain,
00747                                 BlockLattice2D<T1,Descriptor1>& lattice1,
00748                                 BlockLattice2D<T2,Descriptor2>& lattice2 ) =0;
00749 };
00750 
00753 template<typename T1, typename T2>
00754 struct BoundedReductiveBoxProcessingFunctional2D_SS : public BoundedReductiveBoxProcessingFunctional2D {
00755     virtual void processBulkGeneric( Box2D domain,
00756                                      std::vector<AtomicBlock2D*> atomicBlocks );
00757     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00758                                      std::vector<AtomicBlock2D*> atomicBlocks );
00759     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00760                                        std::vector<AtomicBlock2D*> atomicBlocks );
00761 
00762     virtual void processBulk( Box2D domain, ScalarField2D<T1>& field1,
00763                                             ScalarField2D<T2>& field2 ) =0;
00764     virtual void processEdge( int direction, int orientation, Box2D domain,
00765                               ScalarField2D<T1>& field1,
00766                               ScalarField2D<T2>& field2 ) =0;
00767     virtual void processCorner( int normalX, int normalY, Box2D domain,
00768                                 ScalarField2D<T1>& field1,
00769                                 ScalarField2D<T2>& field2 ) =0;
00770 };
00771 
00774 template<typename T1, int nDim1, typename T2, int nDim2>
00775 struct BoundedReductiveBoxProcessingFunctional2D_TT : public BoundedReductiveBoxProcessingFunctional2D {
00776     virtual void processBulkGeneric(Box2D domain,
00777                                     std::vector<AtomicBlock2D*> atomicBlocks);
00778     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00779                                      std::vector<AtomicBlock2D*> atomicBlocks );
00780     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00781                                        std::vector<AtomicBlock2D*> atomicBlocks );
00782 
00783     virtual void processBulk( Box2D domain, TensorField2D<T1,nDim1>& field1,
00784                                             TensorField2D<T2,nDim2>& field2 ) =0;
00785     virtual void processEdge( int direction, int orientation, Box2D domain,
00786                               TensorField2D<T1,nDim1>& field1,
00787                               TensorField2D<T2,nDim2>& field2 ) =0;
00788     virtual void processCorner( int normalX, int normalY, Box2D domain,
00789                                 TensorField2D<T1,nDim1>& field1,
00790                                 TensorField2D<T2,nDim2>& field2 ) =0;
00791 };
00792 
00795 template<typename T1, typename T2, int nDim>
00796 struct BoundedReductiveBoxProcessingFunctional2D_ST : public BoundedReductiveBoxProcessingFunctional2D {
00797     virtual void processBulkGeneric( Box2D domain,
00798                                      std::vector<AtomicBlock2D*> atomicBlocks );
00799     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00800                                      std::vector<AtomicBlock2D*> atomicBlocks );
00801     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00802                                        std::vector<AtomicBlock2D*> atomicBlocks );
00803 
00804     virtual void processBulk( Box2D domain, ScalarField2D<T1>& field1,
00805                                             TensorField2D<T2,nDim>& field2 ) =0;
00806     virtual void processEdge( int direction, int orientation, Box2D domain,
00807                               ScalarField2D<T1>& field1,
00808                               TensorField2D<T2,nDim>& field2 ) =0;
00809     virtual void processCorner( int normalX, int normalY, Box2D domain,
00810                                 ScalarField2D<T1>& field1,
00811                                 TensorField2D<T2,nDim>& field2 ) =0;
00812 };
00813 
00816 template<typename T1, typename T2>
00817 struct BoundedReductiveBoxProcessingFunctional2D_NN : public BoundedReductiveBoxProcessingFunctional2D {
00818     virtual void processBulkGeneric(Box2D domain,
00819                                     std::vector<AtomicBlock2D*> atomicBlocks);
00820     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00821                                      std::vector<AtomicBlock2D*> atomicBlocks );
00822     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00823                                        std::vector<AtomicBlock2D*> atomicBlocks );
00824 
00825     virtual void processBulk( Box2D domain, NTensorField2D<T1>& field1,
00826                                             NTensorField2D<T2>& field2 ) =0;
00827     virtual void processEdge( int direction, int orientation, Box2D domain,
00828                               NTensorField2D<T1>& field1,
00829                               NTensorField2D<T2>& field2 ) =0;
00830     virtual void processCorner( int normalX, int normalY, Box2D domain,
00831                                 NTensorField2D<T1>& field1,
00832                                 NTensorField2D<T2>& field2 ) =0;
00833 };
00834 
00837 template<typename T1, typename T2>
00838 struct BoundedMaskedReductiveBoxProcessingFunctional2D_NN : public BoundedReductiveBoxProcessingFunctional2D {
00839     virtual void processBulkGeneric(Box2D domain,
00840                                     std::vector<AtomicBlock2D*> atomicBlocks);
00841     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00842                                      std::vector<AtomicBlock2D*> atomicBlocks );
00843     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00844                                        std::vector<AtomicBlock2D*> atomicBlocks );
00845 
00846     virtual void processBulk( Box2D domain, NTensorField2D<T1>& field1,
00847                                             NTensorField2D<T2>& field2,
00848                                             NTensorField2D<int>& mask) =0;
00849     virtual void processEdge( int direction, int orientation, Box2D domain,
00850                               NTensorField2D<T1>& field1,
00851                               NTensorField2D<T2>& field2,
00852                               NTensorField2D<int>& mask) =0;
00853     virtual void processCorner( int normalX, int normalY, Box2D domain,
00854                                 NTensorField2D<T1>& field1,
00855                                 NTensorField2D<T2>& field2,
00856                                 NTensorField2D<int>& mask) =0;
00857 };
00858 
00861 template<typename T1, typename T2>
00862 struct BoundedReductiveBoxProcessingFunctional2D_SN : public BoundedReductiveBoxProcessingFunctional2D {
00863     virtual void processBulkGeneric( Box2D domain,
00864                                      std::vector<AtomicBlock2D*> atomicBlocks );
00865     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00866                                      std::vector<AtomicBlock2D*> atomicBlocks );
00867     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00868                                        std::vector<AtomicBlock2D*> atomicBlocks );
00869 
00870     virtual void processBulk( Box2D domain, ScalarField2D<T1>& field1,
00871                                             NTensorField2D<T2>& field2 ) =0;
00872     virtual void processEdge( int direction, int orientation, Box2D domain,
00873                               ScalarField2D<T1>& field1,
00874                               NTensorField2D<T2>& field2 ) =0;
00875     virtual void processCorner( int normalX, int normalY, Box2D domain,
00876                                 ScalarField2D<T1>& field1,
00877                                 NTensorField2D<T2>& field2 ) =0;
00878 };
00879 
00881 template<typename T1, template<typename U> class Descriptor, typename T2>
00882 struct BoundedReductiveBoxProcessingFunctional2D_LS : public BoundedReductiveBoxProcessingFunctional2D {
00883     virtual void processBulkGeneric(Box2D domain, std::vector<AtomicBlock2D*> atomicBlocks);
00884     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00885                                      std::vector<AtomicBlock2D*> atomicBlocks );
00886     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00887                                        std::vector<AtomicBlock2D*> atomicBlocks );
00888 
00889     virtual void processBulk( Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00890                                             ScalarField2D<T2>& field ) =0;
00891     virtual void processEdge( int direction, int orientation, Box2D domain,
00892                               BlockLattice2D<T1,Descriptor>& lattice,
00893                               ScalarField2D<T2>& field ) =0;
00894     virtual void processCorner( int normalX, int normalY, Box2D domain,
00895                                 BlockLattice2D<T1,Descriptor>& lattice,
00896                                 ScalarField2D<T2>& field ) =0;
00897 };
00898 
00900 template<typename T1, template<typename U> class Descriptor,
00901          typename T2, int nDim>
00902 struct BoundedReductiveBoxProcessingFunctional2D_LT : public BoundedReductiveBoxProcessingFunctional2D {
00903     virtual void processBulkGeneric( Box2D domain,
00904                                      std::vector<AtomicBlock2D*> atomicBlocks );
00905     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00906                                      std::vector<AtomicBlock2D*> atomicBlocks );
00907     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00908                                        std::vector<AtomicBlock2D*> atomicBlocks );
00909 
00910     virtual void processBulk( Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00911                                             TensorField2D<T2,nDim>& field ) =0;
00912     virtual void processEdge( int direction, int orientation, Box2D domain,
00913                               BlockLattice2D<T1,Descriptor>& lattice,
00914                               TensorField2D<T2,nDim>& field ) =0;
00915     virtual void processCorner( int normalX, int normalY, Box2D domain,
00916                                 BlockLattice2D<T1,Descriptor>& lattice,
00917                                 TensorField2D<T2,nDim>& field ) =0;
00918 };
00919 
00921 template<typename T1, template<typename U> class Descriptor, typename T2>
00922 struct BoundedReductiveBoxProcessingFunctional2D_LN : public BoundedReductiveBoxProcessingFunctional2D {
00923     virtual void processBulkGeneric( Box2D domain,
00924                                      std::vector<AtomicBlock2D*> atomicBlocks );
00925     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00926                                      std::vector<AtomicBlock2D*> atomicBlocks );
00927     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00928                                        std::vector<AtomicBlock2D*> atomicBlocks );
00929 
00930     virtual void processBulk( Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00931                                             NTensorField2D<T2>& field ) =0;
00932     virtual void processEdge( int direction, int orientation, Box2D domain,
00933                               BlockLattice2D<T1,Descriptor>& lattice,
00934                               NTensorField2D<T2>& field ) =0;
00935     virtual void processCorner( int normalX, int normalY, Box2D domain,
00936                                 BlockLattice2D<T1,Descriptor>& lattice,
00937                                 NTensorField2D<T2>& field ) =0;
00938 };
00939 
00941 template<typename T1, template<typename U> class Descriptor, typename T2>
00942 struct BoundedMaskedReductiveBoxProcessingFunctional2D_LN : public BoundedReductiveBoxProcessingFunctional2D {
00943     virtual void processBulkGeneric( Box2D domain,
00944                                      std::vector<AtomicBlock2D*> atomicBlocks );
00945     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00946                                      std::vector<AtomicBlock2D*> atomicBlocks );
00947     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00948                                        std::vector<AtomicBlock2D*> atomicBlocks );
00949 
00950     virtual void processBulk( Box2D domain, BlockLattice2D<T1,Descriptor>& lattice,
00951                                             NTensorField2D<T2>& field,
00952                                             NTensorField2D<int>& mask ) =0;
00953     virtual void processEdge( int direction, int orientation, Box2D domain,
00954                               BlockLattice2D<T1,Descriptor>& lattice,
00955                               NTensorField2D<T2>& field,
00956                               NTensorField2D<int>& mask ) =0;
00957     virtual void processCorner( int normalX, int normalY, Box2D domain,
00958                                 BlockLattice2D<T1,Descriptor>& lattice,
00959                                 NTensorField2D<T2>& field,
00960                                 NTensorField2D<int>& mask ) =0;
00961 };
00962 
00964 template<typename T, template<typename U> class Descriptor>
00965 struct BoundedReductiveLatticeBoxProcessingFunctional2D
00966     : public BoundedReductiveBoxProcessingFunctional2D
00967 {
00968     virtual void processBulkGeneric( Box2D domain,
00969                                      std::vector<AtomicBlock2D*> atomicBlocks );
00970     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00971                                      std::vector<AtomicBlock2D*> atomicBlocks );
00972     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00973                                        std::vector<AtomicBlock2D*> atomicBlocks );
00974 
00975     virtual void processBulk( Box2D domain,
00976                               std::vector<BlockLattice2D<T,Descriptor>*> lattices ) =0;
00977     virtual void processEdge( int direction, int orientation, Box2D domain,
00978                               std::vector<BlockLattice2D<T,Descriptor>*> lattices ) =0;
00979     virtual void processCorner( int normalX, int normalY, Box2D domain,
00980                                 std::vector<BlockLattice2D<T,Descriptor>*> lattices ) =0;
00981 };
00982 
00984 template<typename T>
00985 struct BoundedReductiveScalarFieldBoxProcessingFunctional2D
00986     : public BoundedReductiveBoxProcessingFunctional2D
00987 {
00988     virtual void processBulkGeneric( Box2D domain,
00989                                      std::vector<AtomicBlock2D*> atomicBlocks );
00990     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
00991                                      std::vector<AtomicBlock2D*> atomicBlocks );
00992     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
00993                                        std::vector<AtomicBlock2D*> atomicBlocks );
00994 
00995     virtual void processBulk(Box2D domain, std::vector<ScalarField2D<T>*> field) =0;
00996     virtual void processEdge( int direction, int orientation, Box2D domain,
00997                               std::vector<ScalarField2D<T>*> field ) =0;
00998     virtual void processCorner( int normalX, int normalY, Box2D domain,
00999                                 std::vector<ScalarField2D<T>*> field ) =0;
01000 };
01001 
01003 template<typename T, int nDim>
01004 struct BoundedReductiveTensorFieldBoxProcessingFunctional2D
01005     : public BoundedReductiveBoxProcessingFunctional2D
01006 {
01007     virtual void processBulkGeneric( Box2D domain,
01008                                      std::vector<AtomicBlock2D*> atomicBlocks );
01009     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
01010                                      std::vector<AtomicBlock2D*> atomicBlocks );
01011     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
01012                                        std::vector<AtomicBlock2D*> atomicBlocks );
01013 
01014     virtual void processBulk(Box2D domain, std::vector<TensorField2D<T,nDim>*> field) =0;
01015     virtual void processEdge( int direction, int orientation, Box2D domain,
01016                               std::vector<TensorField2D<T,nDim>*> field ) =0;
01017     virtual void processCorner( int normalX, int normalY, Box2D domain,
01018                                 std::vector<TensorField2D<T,nDim>*> field ) =0;
01019 };
01020 
01022 template<typename T>
01023 struct BoundedReductiveNTensorFieldBoxProcessingFunctional2D
01024     : public BoundedReductiveBoxProcessingFunctional2D
01025 {
01026     virtual void processBulkGeneric( Box2D domain,
01027                                      std::vector<AtomicBlock2D*> atomicBlocks );
01028     virtual void processEdgeGeneric( int direction, int orientation, Box2D domain,
01029                                      std::vector<AtomicBlock2D*> atomicBlocks );
01030     virtual void processCornerGeneric( int normalX, int normalY, Box2D domain,
01031                                        std::vector<AtomicBlock2D*> atomicBlocks );
01032 
01033     virtual void processBulk(Box2D domain, std::vector<NTensorField2D<T>*> field) =0;
01034     virtual void processEdge( int direction, int orientation, Box2D domain,
01035                               std::vector<NTensorField2D<T>*> field ) =0;
01036     virtual void processCorner( int normalX, int normalY, Box2D domain,
01037                                 std::vector<NTensorField2D<T>*> field ) =0;
01038 };
01039 
01040 }  // namespace plb
01041 
01042 #endif  // REDUCTIVE_DATA_PROCESSING_FUNCTIONAL_2D_H