|
Palabos
Version 1.0
|
|
Palabos
Version 1.0
|
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 DATA_PROCESSING_FUNCTIONAL_3D_H 00029 #define 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 class BoxProcessingFunctional3D { 00055 public: 00056 BoxProcessingFunctional3D(); 00057 virtual ~BoxProcessingFunctional3D() { } 00058 virtual void processGenericBlocks(Box3D domain, 00059 std::vector<AtomicBlock3D*> atomicBlocks) =0; 00060 virtual BlockDomain::DomainT appliesTo() const; 00062 virtual void rescale(double dxScale, double dtScale); 00063 virtual void setscale(int dxScale_, int dtScale_); 00065 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00066 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0; 00067 virtual BoxProcessingFunctional3D* clone() const =0; 00068 int getDxScale() const; 00069 int getDtScale() const; 00070 virtual void serialize(std::string& data) const; 00071 virtual void unserialize(std::string& data); 00072 virtual int getStaticId() const; 00073 private: 00074 int dxScale, dtScale; 00075 }; 00076 00078 class BoxProcessor3D : public DataProcessor3D { 00079 public: 00080 BoxProcessor3D(BoxProcessingFunctional3D* functional_, 00081 Box3D domain_, std::vector<AtomicBlock3D*> atomicBlocks_); 00082 BoxProcessor3D(BoxProcessor3D const& rhs); 00083 BoxProcessor3D& operator=(BoxProcessor3D const& rhs); 00084 ~BoxProcessor3D(); 00085 Box3D getDomain() const; 00086 virtual void process(); 00087 virtual BoxProcessor3D* clone() const; 00088 virtual int getStaticId() const; 00089 private: 00090 BoxProcessingFunctional3D* functional; 00091 Box3D domain; 00092 std::vector<AtomicBlock3D*> atomicBlocks; 00093 }; 00094 00096 class BoxProcessorGenerator3D : public BoxedDataProcessorGenerator3D { 00097 public: 00098 BoxProcessorGenerator3D(BoxProcessingFunctional3D* functional_, Box3D domain); 00099 ~BoxProcessorGenerator3D(); 00100 BoxProcessorGenerator3D(BoxProcessorGenerator3D const& rhs); 00101 BoxProcessorGenerator3D& operator=(BoxProcessorGenerator3D const& rhs); 00102 virtual BlockDomain::DomainT appliesTo() const; 00104 virtual void rescale(double dxScale, double dtScale); 00105 virtual void setscale(int dxScale_, int dtScale_); 00106 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00107 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const; 00108 virtual DataProcessor3D* generate(std::vector<AtomicBlock3D*> atomicBlocks) const; 00109 virtual BoxProcessorGenerator3D* clone() const; 00110 virtual void serialize(Box3D& domain, std::string& data) const; 00111 virtual int getStaticId() const; 00112 private: 00113 BoxProcessingFunctional3D* functional; 00114 }; 00115 00116 00118 template<typename T, template<typename U> class Descriptor> 00119 struct BoxProcessingFunctional3D_L : public BoxProcessingFunctional3D { 00120 virtual void process(Box3D domain, BlockLattice3D<T,Descriptor>& lattice) =0; 00122 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00123 }; 00124 00126 template<typename T, template<typename U> class Descriptor> 00127 struct MaskedBoxProcessingFunctional3D_L : public BoxProcessingFunctional3D { 00128 virtual void process( Box3D domain, 00129 BlockLattice3D<T,Descriptor>& lattice, 00130 NTensorField3D<int>& mask) =0; 00132 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00133 }; 00134 00136 template<typename T> 00137 struct BoxProcessingFunctional3D_S : public BoxProcessingFunctional3D { 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 BoxProcessingFunctional3D_T : public BoxProcessingFunctional3D { 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 BoxProcessingFunctional3D_N : public BoxProcessingFunctional3D { 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 MaskedBoxProcessingFunctional3D_N : public BoxProcessingFunctional3D { 00162 virtual void process(Box3D domain, NTensorField3D<T>& field, 00163 NTensorField3D<int>& mask) =0; 00165 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00166 }; 00167 00169 template<typename T1, template<typename U1> class Descriptor1, 00170 typename T2, template<typename U2> class Descriptor2> 00171 struct BoxProcessingFunctional3D_LL : public BoxProcessingFunctional3D { 00172 virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor1>& lattice1, 00173 BlockLattice3D<T2,Descriptor2>& lattice2) =0; 00175 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00176 }; 00177 00179 template<typename T1, typename T2> 00180 struct BoxProcessingFunctional3D_SS : public BoxProcessingFunctional3D { 00181 virtual void process(Box3D domain, ScalarField3D<T1>& field1, 00182 ScalarField3D<T2>& field2) =0; 00184 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00185 }; 00186 00188 template<typename T1, int nDim1, 00189 typename T2, int nDim2> 00190 struct BoxProcessingFunctional3D_TT : public BoxProcessingFunctional3D { 00191 virtual void process(Box3D domain, TensorField3D<T1,nDim1>& field1, 00192 TensorField3D<T2,nDim2>& field2) =0; 00194 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00195 }; 00196 00198 template<typename T1, typename T2, int nDim> 00199 struct BoxProcessingFunctional3D_ST : public BoxProcessingFunctional3D { 00200 virtual void process(Box3D domain, ScalarField3D<T1>& field1, 00201 TensorField3D<T2,nDim>& field2) =0; 00203 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00204 }; 00205 00207 template<typename T1, typename T2> 00208 struct BoxProcessingFunctional3D_NN : public BoxProcessingFunctional3D { 00209 virtual void process(Box3D domain, NTensorField3D<T1>& field1, 00210 NTensorField3D<T2>& field2) =0; 00212 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00213 }; 00214 00216 template<typename T1, typename T2> 00217 struct MaskedBoxProcessingFunctional3D_NN : public BoxProcessingFunctional3D { 00218 virtual void process(Box3D domain, NTensorField3D<T1>& field1, 00219 NTensorField3D<T2>& field2, 00220 NTensorField3D<int>& mask) =0; 00222 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00223 }; 00224 00226 template<typename T1, typename T2> 00227 struct BoxProcessingFunctional3D_SN : public BoxProcessingFunctional3D { 00228 virtual void process(Box3D domain, ScalarField3D<T1>& field1, 00229 NTensorField3D<T2>& field2) =0; 00231 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00232 }; 00233 00235 template<typename T1, template<typename U> class Descriptor, typename T2> 00236 struct BoxProcessingFunctional3D_LS : public BoxProcessingFunctional3D { 00237 virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00238 ScalarField3D<T2>& field) =0; 00240 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00241 }; 00242 00244 template<typename T1, template<typename U> class Descriptor, 00245 typename T2, int nDim> 00246 struct BoxProcessingFunctional3D_LT : public BoxProcessingFunctional3D { 00247 virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00248 TensorField3D<T2,nDim>& field) =0; 00250 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00251 }; 00252 00254 template<typename T1, template<typename U> class Descriptor, typename T2> 00255 struct BoxProcessingFunctional3D_LN : public BoxProcessingFunctional3D { 00256 virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00257 NTensorField3D<T2>& field) =0; 00259 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00260 }; 00261 00263 template<typename T1, template<typename U> class Descriptor, typename T2> 00264 struct MaskedBoxProcessingFunctional3D_LN : public BoxProcessingFunctional3D { 00265 virtual void process(Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00266 NTensorField3D<T2>& field, 00267 NTensorField3D<int>& mask) =0; 00269 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00270 }; 00271 00273 template<typename T, template<typename U> class Descriptor> 00274 struct LatticeBoxProcessingFunctional3D : public BoxProcessingFunctional3D { 00275 virtual void process(Box3D domain, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0; 00277 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00278 }; 00279 00281 template<typename T> 00282 struct ScalarFieldBoxProcessingFunctional3D : public BoxProcessingFunctional3D { 00283 virtual void process(Box3D domain, std::vector<ScalarField3D<T>*> scalarFields) =0; 00285 virtual void processGenericBlocks( Box3D domain, 00286 std::vector<AtomicBlock3D*> atomicBlocks ); 00287 }; 00288 00290 template<typename T, int nDim> 00291 struct TensorFieldBoxProcessingFunctional3D : public BoxProcessingFunctional3D { 00292 virtual void process(Box3D domain, std::vector<TensorField3D<T,nDim>*> tensorFields) =0; 00294 virtual void processGenericBlocks( Box3D domain, 00295 std::vector<AtomicBlock3D*> atomicBlocks ); 00296 }; 00297 00299 template<typename T> 00300 struct NTensorFieldBoxProcessingFunctional3D : public BoxProcessingFunctional3D { 00301 virtual void process(Box3D domain, std::vector<NTensorField3D<T>*> tensorFields) =0; 00303 virtual void processGenericBlocks( Box3D domain, 00304 std::vector<AtomicBlock3D*> atomicBlocks ); 00305 }; 00306 00308 template<typename T> 00309 struct MaskedNTensorFieldBoxProcessingFunctional3D : public BoxProcessingFunctional3D { 00310 virtual void process( Box3D domain, 00311 std::vector<NTensorField3D<T>*> tensorFields, 00312 NTensorField3D<int>& mask ) =0; 00314 virtual void processGenericBlocks( Box3D domain, 00315 std::vector<AtomicBlock3D*> atomicBlocks ); 00316 }; 00317 00318 00319 /* *************** All flavors of Dot processing functionals ********* */ 00320 00322 struct DotProcessingFunctional3D { 00323 virtual ~DotProcessingFunctional3D() { } 00324 virtual void processGenericBlocks( DotList3D const& dotList, 00325 std::vector<AtomicBlock3D*> atomicBlocks ) =0; 00326 virtual BlockDomain::DomainT appliesTo() const; 00327 virtual void rescale(double dxScale, double dtScale); 00328 virtual void setscale(int dxScale, int dtScale); 00330 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00331 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0; 00332 virtual DotProcessingFunctional3D* clone() const =0; 00333 }; 00334 00336 class DotProcessor3D : public DataProcessor3D { 00337 public: 00338 DotProcessor3D(DotProcessingFunctional3D* functional_, 00339 DotList3D const& dotList_, std::vector<AtomicBlock3D*> atomicBlocks_); 00340 DotProcessor3D(DotProcessor3D const& rhs); 00341 DotProcessor3D& operator=(DotProcessor3D const& rhs); 00342 ~DotProcessor3D(); 00343 virtual void process(); 00344 virtual DotProcessor3D* clone() const; 00345 DotList3D const& getDotList() const; 00346 private: 00347 DotProcessingFunctional3D* functional; 00348 DotList3D dotList; 00349 std::vector<AtomicBlock3D*> atomicBlocks; 00350 }; 00351 00353 class DotProcessorGenerator3D : public DottedDataProcessorGenerator3D { 00354 public: 00355 DotProcessorGenerator3D(DotProcessingFunctional3D* functional_, 00356 DotList3D const& dotList); 00357 ~DotProcessorGenerator3D(); 00358 DotProcessorGenerator3D(DotProcessorGenerator3D const& rhs); 00359 DotProcessorGenerator3D& operator=(DotProcessorGenerator3D const& rhs); 00360 virtual BlockDomain::DomainT appliesTo() const; 00361 virtual void rescale(double dxScale, double dtScale); 00362 virtual void setscale(int dxScale, int dtScale); 00363 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00364 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const; 00365 virtual DataProcessor3D* generate(std::vector<AtomicBlock3D*> atomicBlocks) const; 00366 virtual DotProcessorGenerator3D* clone() const; 00367 private: 00368 DotProcessingFunctional3D* functional; 00369 }; 00370 00372 template<typename T, template<typename U> class Descriptor> 00373 struct DotProcessingFunctional3D_L : public DotProcessingFunctional3D { 00374 virtual void process(DotList3D const& dotList, BlockLattice3D<T,Descriptor>& lattice) =0; 00376 virtual void processGenericBlocks(DotList3D const& dotList, std::vector<AtomicBlock3D*> atomicBlocks); 00377 }; 00378 00380 template<typename T> 00381 struct DotProcessingFunctional3D_S : public DotProcessingFunctional3D { 00382 virtual void process(DotList3D const& dotList, ScalarField3D<T>& field) =0; 00384 virtual void processGenericBlocks( DotList3D const& dotList, 00385 std::vector<AtomicBlock3D*> atomicBlocks ); 00386 }; 00387 00389 template<typename T, int nDim> 00390 struct DotProcessingFunctional3D_T : public DotProcessingFunctional3D { 00391 virtual void process(DotList3D const& dotList, TensorField3D<T,nDim>& field) =0; 00393 virtual void processGenericBlocks( DotList3D const& dotList, 00394 std::vector<AtomicBlock3D*> atomicBlocks ); 00395 }; 00396 00398 template<typename T> 00399 struct DotProcessingFunctional3D_N : public DotProcessingFunctional3D { 00400 virtual void process(DotList3D const& dotList, NTensorField3D<T>& field) =0; 00402 virtual void processGenericBlocks( DotList3D const& dotList, 00403 std::vector<AtomicBlock3D*> atomicBlocks ); 00404 }; 00405 00407 template<typename T1, template<typename U1> class Descriptor1, 00408 typename T2, template<typename U2> class Descriptor2> 00409 struct DotProcessingFunctional3D_LL : public DotProcessingFunctional3D { 00410 virtual void process(DotList3D const& dotList, 00411 BlockLattice3D<T1,Descriptor1>& lattice1, 00412 BlockLattice3D<T2,Descriptor2>& lattice2) =0; 00414 virtual void processGenericBlocks( DotList3D const& dotList, 00415 std::vector<AtomicBlock3D*> atomicBlocks ); 00416 }; 00417 00419 template<typename T1, typename T2> 00420 struct DotProcessingFunctional3D_SS : public DotProcessingFunctional3D { 00421 virtual void process(DotList3D const& dotList, ScalarField3D<T1>& field1, 00422 ScalarField3D<T2>& field2) =0; 00424 virtual void processGenericBlocks( DotList3D const& dotList, 00425 std::vector<AtomicBlock3D*> atomicBlocks ); 00426 }; 00427 00429 template<typename T1, int nDim1, typename T2, int nDim2> 00430 struct DotProcessingFunctional3D_TT : public DotProcessingFunctional3D { 00431 virtual void process(DotList3D const& dotList, 00432 TensorField3D<T1,nDim1>& field1, 00433 TensorField3D<T2,nDim2>& field2) =0; 00435 virtual void processGenericBlocks( DotList3D const& dotList, 00436 std::vector<AtomicBlock3D*> atomicBlocks ); 00437 }; 00438 00440 template<typename T1, typename T2, int nDim> 00441 struct DotProcessingFunctional3D_ST : public DotProcessingFunctional3D { 00442 virtual void process(DotList3D const& dotList, 00443 ScalarField3D<T1>& field1, 00444 TensorField3D<T2,nDim>& field2) =0; 00446 virtual void processGenericBlocks( DotList3D const& dotList, 00447 std::vector<AtomicBlock3D*> atomicBlocks ); 00448 }; 00449 00451 template<typename T1, typename T2> 00452 struct DotProcessingFunctional3D_NN : public DotProcessingFunctional3D { 00453 virtual void process(DotList3D const& dotList, 00454 NTensorField3D<T1>& field1, 00455 NTensorField3D<T2>& field2) =0; 00457 virtual void processGenericBlocks( DotList3D const& dotList, 00458 std::vector<AtomicBlock3D*> atomicBlocks ); 00459 }; 00460 00462 template<typename T1, typename T2> 00463 struct DotProcessingFunctional3D_SN : public DotProcessingFunctional3D { 00464 virtual void process(DotList3D const& dotList, 00465 ScalarField3D<T1>& field1, 00466 NTensorField3D<T2>& field2) =0; 00468 virtual void processGenericBlocks( DotList3D const& dotList, 00469 std::vector<AtomicBlock3D*> atomicBlocks ); 00470 }; 00471 00473 template<typename T1, template<typename U> class Descriptor, typename T2> 00474 struct DotProcessingFunctional3D_LS : public DotProcessingFunctional3D { 00475 virtual void process(DotList3D const& dotList, 00476 BlockLattice3D<T1,Descriptor>& lattice, 00477 ScalarField3D<T2>& field) =0; 00479 virtual void processGenericBlocks( DotList3D const& dotList, 00480 std::vector<AtomicBlock3D*> atomicBlocks ); 00481 }; 00482 00484 template<typename T1, template<typename U> class Descriptor, 00485 typename T2, int nDim> 00486 struct DotProcessingFunctional3D_LT : public DotProcessingFunctional3D { 00487 virtual void process(DotList3D const& dotList, 00488 BlockLattice3D<T1,Descriptor>& lattice, 00489 TensorField3D<T2,nDim>& field) =0; 00491 virtual void processGenericBlocks( DotList3D const& dotList, 00492 std::vector<AtomicBlock3D*> atomicBlocks ); 00493 }; 00494 00496 template<typename T1, template<typename U> class Descriptor, typename T2> 00497 struct DotProcessingFunctional3D_LN : public DotProcessingFunctional3D { 00498 virtual void process(DotList3D const& dotList, 00499 BlockLattice3D<T1,Descriptor>& lattice, 00500 NTensorField3D<T2>& field) =0; 00502 virtual void processGenericBlocks( DotList3D const& dotList, 00503 std::vector<AtomicBlock3D*> atomicBlocks ); 00504 }; 00505 00507 template<typename T, template<typename U> class Descriptor> 00508 struct LatticeDotProcessingFunctional3D : public DotProcessingFunctional3D { 00509 virtual void process(DotList3D const& dotList, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0; 00511 virtual void processGenericBlocks( DotList3D const& dotList, 00512 std::vector<AtomicBlock3D*> atomicBlocks ); 00513 }; 00514 00516 template<typename T> 00517 struct ScalarFieldDotProcessingFunctional3D : public DotProcessingFunctional3D { 00518 virtual void process(DotList3D const& dotList, std::vector<ScalarField3D<T>*> scalarFields) =0; 00520 virtual void processGenericBlocks( DotList3D const& dotList, 00521 std::vector<AtomicBlock3D*> atomicBlocks ); 00522 }; 00523 00525 template<typename T, int nDim> 00526 struct TensorFieldDotProcessingFunctional3D : public DotProcessingFunctional3D { 00527 virtual void process(DotList3D const& dotList, std::vector<TensorField3D<T,nDim>*> tensorFields) =0; 00529 virtual void processGenericBlocks( DotList3D const& dotList, 00530 std::vector<AtomicBlock3D*> atomicBlocks ); 00531 }; 00532 00533 00535 template<typename T> 00536 struct NTensorFieldDotProcessingFunctional3D : public DotProcessingFunctional3D { 00537 virtual void process(DotList3D const& dotList, std::vector<NTensorField3D<T>*> tensorFields) =0; 00539 virtual void processGenericBlocks( DotList3D const& dotList, 00540 std::vector<AtomicBlock3D*> atomicBlocks ); 00541 }; 00542 00543 00544 /* *************** All flavors of Bounded Box processing functionals ********* */ 00545 00547 class BoundedBoxProcessingFunctional3D { 00548 public: 00549 BoundedBoxProcessingFunctional3D(); 00550 virtual ~BoundedBoxProcessingFunctional3D() { } 00551 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks) =0; 00552 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00553 std::vector<AtomicBlock3D*> atomicBlocks ) =0; 00554 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00555 std::vector<AtomicBlock3D*> atomicBlocks ) =0; 00556 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00557 std::vector<AtomicBlock3D*> atomicBlocks ) =0; 00558 virtual BlockDomain::DomainT appliesTo() const; 00560 virtual void rescale(double dxScale, double dtScale); 00561 virtual void setscale(int dxScale_, int dtScale_); 00563 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00564 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const =0; 00565 virtual BoundedBoxProcessingFunctional3D* clone() const =0; 00566 BoxProcessingFunctional3D* getBulkProcessor() const; 00567 BoxProcessingFunctional3D* getPlaneProcessor(int direction, int orientation) const; 00568 BoxProcessingFunctional3D* getEdgeProcessor(int plane, int normal1, int normal2) const; 00569 BoxProcessingFunctional3D* getCornerProcessor(int normalX, int normalY, int normalZ) const; 00570 void getGenerators ( 00571 Box3D const& fullDomain, plint boundaryWidth_, 00572 std::vector<BoxProcessorGenerator3D*>& generators ); 00573 int getDxScale() const; 00574 int getDtScale() const; 00575 private: 00576 int dxScale, dtScale; 00577 public: 00578 class BulkWrapperFunctional : public BoxProcessingFunctional3D { 00579 public: 00580 BulkWrapperFunctional(BoundedBoxProcessingFunctional3D* boundedFunctional_); 00581 BulkWrapperFunctional(BulkWrapperFunctional const& rhs); 00582 ~BulkWrapperFunctional(); 00583 BulkWrapperFunctional& operator=(BulkWrapperFunctional const& rhs); 00584 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00585 virtual BlockDomain::DomainT appliesTo() const; 00586 virtual void rescale(double dxScale, double dtScale); 00587 virtual void setscale(int dxScale_, int dtScale_); 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 private: 00592 BoundedBoxProcessingFunctional3D* boundedFunctional; 00593 }; 00594 class PlaneWrapperFunctional : public BoxProcessingFunctional3D { 00595 public: 00596 PlaneWrapperFunctional(BoundedBoxProcessingFunctional3D* boundedFunctional_, 00597 int direction_, int orientation_); 00598 PlaneWrapperFunctional(PlaneWrapperFunctional const& rhs); 00599 ~PlaneWrapperFunctional(); 00600 PlaneWrapperFunctional& operator=(PlaneWrapperFunctional const& rhs); 00601 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00602 virtual BlockDomain::DomainT appliesTo() const; 00604 virtual void rescale(double dxScale, double dtScale); 00605 virtual void setscale(int dxScale_, int dtScale_); 00606 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00607 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const; 00608 virtual PlaneWrapperFunctional* clone() const; 00609 private: 00610 BoundedBoxProcessingFunctional3D* boundedFunctional; 00611 int direction, orientation; 00612 }; 00613 class EdgeWrapperFunctional : public BoxProcessingFunctional3D { 00614 public: 00615 EdgeWrapperFunctional(BoundedBoxProcessingFunctional3D* boundedFunctional_, 00616 int plane_, int normal1_, int normal2_); 00617 EdgeWrapperFunctional(EdgeWrapperFunctional const& rhs); 00618 ~EdgeWrapperFunctional(); 00619 EdgeWrapperFunctional& operator=(EdgeWrapperFunctional const& rhs); 00620 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00621 virtual BlockDomain::DomainT appliesTo() const; 00623 virtual void rescale(double dxScale, double dtScale); 00624 virtual void setscale(int dxScale_, int dtScale_); 00625 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00626 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const; 00627 virtual EdgeWrapperFunctional* clone() const; 00628 private: 00629 BoundedBoxProcessingFunctional3D* boundedFunctional; 00630 int plane, normal1, normal2; 00631 }; 00632 class CornerWrapperFunctional : public BoxProcessingFunctional3D { 00633 public: 00634 CornerWrapperFunctional(BoundedBoxProcessingFunctional3D* boundedFunctional_, 00635 int normalX_, int normalY_, int normalZ_); 00636 CornerWrapperFunctional(CornerWrapperFunctional const& rhs); 00637 ~CornerWrapperFunctional(); 00638 CornerWrapperFunctional& operator=(CornerWrapperFunctional const& rhs); 00639 virtual void processGenericBlocks(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00640 virtual BlockDomain::DomainT appliesTo() const; 00642 virtual void rescale(double dxScale, double dtScale); 00643 virtual void setscale(int dxScale_, int dtScale_); 00644 virtual void getModificationPattern(std::vector<bool>& isWritten) const; 00645 virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const; 00646 virtual CornerWrapperFunctional* clone() const; 00647 private: 00648 BoundedBoxProcessingFunctional3D* boundedFunctional; 00649 int normalX, normalY, normalZ; 00650 }; 00651 }; 00652 00654 template<typename T, template<typename U> class Descriptor> 00655 struct BoundedBoxProcessingFunctional3D_L : public BoundedBoxProcessingFunctional3D { 00656 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00657 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00658 std::vector<AtomicBlock3D*> atomicBlocks ); 00659 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00660 std::vector<AtomicBlock3D*> atomicBlocks ); 00661 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00662 std::vector<AtomicBlock3D*> atomicBlocks ); 00663 00664 virtual void processBulk(Box3D domain, BlockLattice3D<T,Descriptor>& lattice) =0; 00665 virtual void processPlane( int direction, int orientation, Box3D domain, 00666 BlockLattice3D<T,Descriptor>& lattice ) =0; 00667 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00668 BlockLattice3D<T,Descriptor>& lattice ) =0; 00669 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00670 BlockLattice3D<T,Descriptor>& lattice ) =0; 00671 }; 00672 00674 template<typename T> 00675 struct BoundedBoxProcessingFunctional3D_S : public BoundedBoxProcessingFunctional3D { 00676 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00677 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00678 std::vector<AtomicBlock3D*> atomicBlocks ); 00679 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00680 std::vector<AtomicBlock3D*> atomicBlocks ); 00681 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00682 std::vector<AtomicBlock3D*> atomicBlocks ); 00683 00684 virtual void processBulk(Box3D domain, ScalarField3D<T>& field) =0; 00685 virtual void processPlane( int direction, int orientation, Box3D domain, 00686 ScalarField3D<T>& field ) =0; 00687 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00688 ScalarField3D<T>& field ) =0; 00689 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00690 ScalarField3D<T>& field ) =0; 00691 }; 00692 00694 template<typename T, int nDim> 00695 struct BoundedBoxProcessingFunctional3D_T : public BoundedBoxProcessingFunctional3D { 00696 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00697 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00698 std::vector<AtomicBlock3D*> atomicBlocks ); 00699 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00700 std::vector<AtomicBlock3D*> atomicBlocks ); 00701 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00702 std::vector<AtomicBlock3D*> atomicBlocks ); 00703 00704 virtual void processBulk(Box3D domain, TensorField3D<T,nDim>& lattice) =0; 00705 virtual void processPlane( int direction, int orientation, Box3D domain, 00706 TensorField3D<T,nDim>& field ) =0; 00707 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00708 TensorField3D<T,nDim>& field ) =0; 00709 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00710 TensorField3D<T,nDim>& field ) =0; 00711 }; 00712 00714 template<typename T> 00715 struct BoundedBoxProcessingFunctional3D_N : public BoundedBoxProcessingFunctional3D { 00716 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00717 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00718 std::vector<AtomicBlock3D*> atomicBlocks ); 00719 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00720 std::vector<AtomicBlock3D*> atomicBlocks ); 00721 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00722 std::vector<AtomicBlock3D*> atomicBlocks ); 00723 00724 virtual void processBulk(Box3D domain, NTensorField3D<T>& field) =0; 00725 virtual void processPlane( int direction, int orientation, Box3D domain, 00726 NTensorField3D<T>& field ) =0; 00727 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00728 NTensorField3D<T>& field ) =0; 00729 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00730 NTensorField3D<T>& field ) =0; 00731 }; 00732 00734 template<typename T> 00735 struct BoundedMaskedBoxProcessingFunctional3D_N : public BoundedBoxProcessingFunctional3D { 00736 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00737 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00738 std::vector<AtomicBlock3D*> atomicBlocks ); 00739 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00740 std::vector<AtomicBlock3D*> atomicBlocks ); 00741 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00742 std::vector<AtomicBlock3D*> atomicBlocks ); 00743 00744 virtual void processBulk(Box3D domain, 00745 NTensorField3D<T>& field, 00746 NTensorField3D<int>& mask) =0; 00747 virtual void processPlane( int direction, int orientation, Box3D domain, 00748 NTensorField3D<T>& field, 00749 NTensorField3D<int>& mask) =0; 00750 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00751 NTensorField3D<T>& field, 00752 NTensorField3D<int>& mask) =0; 00753 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00754 NTensorField3D<T>& field, 00755 NTensorField3D<int>& mask) =0; 00756 }; 00757 00759 template<typename T1, template<typename U1> class Descriptor1, 00760 typename T2, template<typename U2> class Descriptor2> 00761 struct BoundedBoxProcessingFunctional3D_LL : public BoundedBoxProcessingFunctional3D { 00762 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00763 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00764 std::vector<AtomicBlock3D*> atomicBlocks ); 00765 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00766 std::vector<AtomicBlock3D*> atomicBlocks ); 00767 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00768 std::vector<AtomicBlock3D*> atomicBlocks ); 00769 00770 virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor1>& lattice1, 00771 BlockLattice3D<T2,Descriptor2>& lattice2 ) =0; 00772 virtual void processPlane( int direction, int orientation, Box3D domain, 00773 BlockLattice3D<T1,Descriptor1>& lattice1, 00774 BlockLattice3D<T2,Descriptor2>& lattice2 ) =0; 00775 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00776 BlockLattice3D<T1,Descriptor1>& lattice1, 00777 BlockLattice3D<T2,Descriptor2>& lattice2 ) =0; 00778 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00779 BlockLattice3D<T1,Descriptor1>& lattice1, 00780 BlockLattice3D<T2,Descriptor2>& lattice2 ) =0; 00781 }; 00782 00784 template<typename T1, typename T2> 00785 struct BoundedBoxProcessingFunctional3D_SS : public BoundedBoxProcessingFunctional3D { 00786 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00787 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00788 std::vector<AtomicBlock3D*> atomicBlocks ); 00789 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00790 std::vector<AtomicBlock3D*> atomicBlocks ); 00791 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00792 std::vector<AtomicBlock3D*> atomicBlocks ); 00793 00794 virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1, 00795 ScalarField3D<T2>& field2 ) =0; 00796 virtual void processPlane( int direction, int orientation, Box3D domain, 00797 ScalarField3D<T1>& field1, 00798 ScalarField3D<T2>& field2 ) =0; 00799 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00800 ScalarField3D<T1>& field1, 00801 ScalarField3D<T2>& field2 ) =0; 00802 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00803 ScalarField3D<T1>& field1, 00804 ScalarField3D<T2>& field2 ) =0; 00805 }; 00806 00808 template<typename T1, int nDim1, typename T2, int nDim2> 00809 struct BoundedBoxProcessingFunctional3D_TT : public BoundedBoxProcessingFunctional3D { 00810 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00811 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00812 std::vector<AtomicBlock3D*> atomicBlocks ); 00813 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00814 std::vector<AtomicBlock3D*> atomicBlocks ); 00815 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00816 std::vector<AtomicBlock3D*> atomicBlocks ); 00817 00818 virtual void processBulk( Box3D domain, TensorField3D<T1,nDim1>& field1, 00819 TensorField3D<T2,nDim2>& field2 ) =0; 00820 virtual void processPlane( int direction, int orientation, Box3D domain, 00821 TensorField3D<T1,nDim1>& field1, 00822 TensorField3D<T2,nDim2>& field2 ) =0; 00823 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00824 TensorField3D<T1,nDim1>& field1, 00825 TensorField3D<T2,nDim2>& field2 ) =0; 00826 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00827 TensorField3D<T1,nDim1>& field1, 00828 TensorField3D<T2,nDim2>& field2 ) =0; 00829 }; 00830 00832 template<typename T1, typename T2, int nDim> 00833 struct BoundedBoxProcessingFunctional3D_ST : public BoundedBoxProcessingFunctional3D { 00834 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00835 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00836 std::vector<AtomicBlock3D*> atomicBlocks ); 00837 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00838 std::vector<AtomicBlock3D*> atomicBlocks ); 00839 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00840 std::vector<AtomicBlock3D*> atomicBlocks ); 00841 00842 virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1, 00843 TensorField3D<T2,nDim>& field2 ) =0; 00844 virtual void processPlane( int direction, int orientation, Box3D domain, 00845 ScalarField3D<T1>& field1, 00846 TensorField3D<T2,nDim>& field2 ) =0; 00847 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00848 ScalarField3D<T1>& field1, 00849 TensorField3D<T2,nDim>& field2 ) =0; 00850 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00851 ScalarField3D<T1>& field1, 00852 TensorField3D<T2,nDim>& field2 ) =0; 00853 }; 00854 00856 template<typename T1, typename T2> 00857 struct BoundedBoxProcessingFunctional3D_NN : public BoundedBoxProcessingFunctional3D { 00858 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00859 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00860 std::vector<AtomicBlock3D*> atomicBlocks ); 00861 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00862 std::vector<AtomicBlock3D*> atomicBlocks ); 00863 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00864 std::vector<AtomicBlock3D*> atomicBlocks ); 00865 00866 virtual void processBulk( Box3D domain, NTensorField3D<T1>& field1, 00867 NTensorField3D<T2>& field2 ) =0; 00868 virtual void processPlane( int direction, int orientation, Box3D domain, 00869 NTensorField3D<T1>& field1, 00870 NTensorField3D<T2>& field2 ) =0; 00871 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00872 NTensorField3D<T1>& field1, 00873 NTensorField3D<T2>& field2 ) =0; 00874 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00875 NTensorField3D<T1>& field1, 00876 NTensorField3D<T2>& field2 ) =0; 00877 }; 00878 00880 template<typename T1, typename T2> 00881 struct BoundedMaskedBoxProcessingFunctional3D_NN : public BoundedBoxProcessingFunctional3D { 00882 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00883 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00884 std::vector<AtomicBlock3D*> atomicBlocks ); 00885 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00886 std::vector<AtomicBlock3D*> atomicBlocks ); 00887 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00888 std::vector<AtomicBlock3D*> atomicBlocks ); 00889 00890 virtual void processBulk( Box3D domain, NTensorField3D<T1>& field1, 00891 NTensorField3D<T2>& field2, 00892 NTensorField3D<int>& mask) =0; 00893 virtual void processPlane( int direction, int orientation, Box3D domain, 00894 NTensorField3D<T1>& field1, 00895 NTensorField3D<T2>& field2, 00896 NTensorField3D<int>& mask) =0; 00897 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00898 NTensorField3D<T1>& field1, 00899 NTensorField3D<T2>& field2, 00900 NTensorField3D<int>& mask) =0; 00901 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00902 NTensorField3D<T1>& field1, 00903 NTensorField3D<T2>& field2, 00904 NTensorField3D<int>& mask) =0; 00905 }; 00906 00908 template<typename T1, typename T2> 00909 struct BoundedBoxProcessingFunctional3D_SN : public BoundedBoxProcessingFunctional3D { 00910 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00911 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00912 std::vector<AtomicBlock3D*> atomicBlocks ); 00913 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00914 std::vector<AtomicBlock3D*> atomicBlocks ); 00915 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00916 std::vector<AtomicBlock3D*> atomicBlocks ); 00917 00918 virtual void processBulk( Box3D domain, ScalarField3D<T1>& field1, 00919 NTensorField3D<T2>& field2 ) =0; 00920 virtual void processPlane( int direction, int orientation, Box3D domain, 00921 ScalarField3D<T1>& field1, 00922 NTensorField3D<T2>& field2 ) =0; 00923 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00924 ScalarField3D<T1>& field1, 00925 NTensorField3D<T2>& field2 ) =0; 00926 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00927 ScalarField3D<T1>& field1, 00928 NTensorField3D<T2>& field2 ) =0; 00929 }; 00930 00932 template<typename T1, template<typename U> class Descriptor, typename T2> 00933 struct BoundedBoxProcessingFunctional3D_LS : public BoundedBoxProcessingFunctional3D { 00934 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00935 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00936 std::vector<AtomicBlock3D*> atomicBlocks ); 00937 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00938 std::vector<AtomicBlock3D*> atomicBlocks ); 00939 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00940 std::vector<AtomicBlock3D*> atomicBlocks ); 00941 00942 virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00943 ScalarField3D<T2>& field ) =0; 00944 virtual void processPlane( int direction, int orientation, Box3D domain, 00945 BlockLattice3D<T1,Descriptor>& lattice, 00946 ScalarField3D<T2>& field ) =0; 00947 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00948 BlockLattice3D<T1,Descriptor>& lattice, 00949 ScalarField3D<T2>& field ) =0; 00950 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00951 BlockLattice3D<T1,Descriptor>& lattice, 00952 ScalarField3D<T2>& field ) =0; 00953 }; 00954 00956 template<typename T1, template<typename U> class Descriptor, typename T2, int nDim> 00957 struct BoundedBoxProcessingFunctional3D_LT : public BoundedBoxProcessingFunctional3D { 00958 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00959 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00960 std::vector<AtomicBlock3D*> atomicBlocks ); 00961 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00962 std::vector<AtomicBlock3D*> atomicBlocks ); 00963 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00964 std::vector<AtomicBlock3D*> atomicBlocks ); 00965 00966 virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00967 TensorField3D<T2,nDim>& field ) =0; 00968 virtual void processPlane( int direction, int orientation, Box3D domain, 00969 BlockLattice3D<T1,Descriptor>& lattice, 00970 TensorField3D<T2,nDim>& field ) =0; 00971 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00972 BlockLattice3D<T1,Descriptor>& lattice, 00973 TensorField3D<T2,nDim>& field ) =0; 00974 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00975 BlockLattice3D<T1,Descriptor>& lattice, 00976 TensorField3D<T2,nDim>& field ) =0; 00977 }; 00978 00980 template<typename T1, template<typename U> class Descriptor, typename T2> 00981 struct BoundedBoxProcessingFunctional3D_LN : public BoundedBoxProcessingFunctional3D { 00982 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 00983 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 00984 std::vector<AtomicBlock3D*> atomicBlocks ); 00985 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 00986 std::vector<AtomicBlock3D*> atomicBlocks ); 00987 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 00988 std::vector<AtomicBlock3D*> atomicBlocks ); 00989 00990 virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 00991 NTensorField3D<T2>& field ) =0; 00992 virtual void processPlane( int direction, int orientation, Box3D domain, 00993 BlockLattice3D<T1,Descriptor>& lattice, 00994 NTensorField3D<T2>& field ) =0; 00995 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 00996 BlockLattice3D<T1,Descriptor>& lattice, 00997 NTensorField3D<T2>& field ) =0; 00998 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 00999 BlockLattice3D<T1,Descriptor>& lattice, 01000 NTensorField3D<T2>& field ) =0; 01001 }; 01002 01004 template<typename T1, template<typename U> class Descriptor, typename T2> 01005 struct BoundedMaskedBoxProcessingFunctional3D_LN : public BoundedBoxProcessingFunctional3D { 01006 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 01007 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 01008 std::vector<AtomicBlock3D*> atomicBlocks ); 01009 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 01010 std::vector<AtomicBlock3D*> atomicBlocks ); 01011 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 01012 std::vector<AtomicBlock3D*> atomicBlocks ); 01013 01014 virtual void processBulk( Box3D domain, BlockLattice3D<T1,Descriptor>& lattice, 01015 NTensorField3D<T2>& field, 01016 NTensorField3D<int>& mask) =0; 01017 virtual void processPlane( int direction, int orientation, Box3D domain, 01018 BlockLattice3D<T1,Descriptor>& lattice, 01019 NTensorField3D<T2>& field, 01020 NTensorField3D<int>& mask) =0; 01021 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 01022 BlockLattice3D<T1,Descriptor>& lattice, 01023 NTensorField3D<T2>& field, 01024 NTensorField3D<int>& mask) =0; 01025 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 01026 BlockLattice3D<T1,Descriptor>& lattice, 01027 NTensorField3D<T2>& field, 01028 NTensorField3D<int>& mask) =0; 01029 }; 01030 01032 template<typename T, template<typename U> class Descriptor> 01033 struct BoundedLatticeBoxProcessingFunctional3D : public BoundedBoxProcessingFunctional3D { 01034 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 01035 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 01036 std::vector<AtomicBlock3D*> atomicBlocks ); 01037 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 01038 std::vector<AtomicBlock3D*> atomicBlocks ); 01039 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 01040 std::vector<AtomicBlock3D*> atomicBlocks ); 01041 01042 virtual void processBulk(Box3D domain, std::vector<BlockLattice3D<T,Descriptor>*> lattices) =0; 01043 virtual void processPlane( int direction, int orientation, Box3D domain, 01044 std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0; 01045 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 01046 std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0; 01047 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 01048 std::vector<BlockLattice3D<T,Descriptor>*> lattices ) =0; 01049 }; 01050 01052 template<typename T> 01053 struct BoundedScalarFieldBoxProcessingFunctional3D : public BoundedBoxProcessingFunctional3D { 01054 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 01055 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 01056 std::vector<AtomicBlock3D*> atomicBlocks ); 01057 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 01058 std::vector<AtomicBlock3D*> atomicBlocks ); 01059 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 01060 std::vector<AtomicBlock3D*> atomicBlocks ); 01061 01062 virtual void processBulk(Box3D domain, std::vector<ScalarField3D<T>*> field) =0; 01063 virtual void processPlane( int direction, int orientation, Box3D domain, 01064 std::vector<ScalarField3D<T>*> field ) =0; 01065 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 01066 std::vector<ScalarField3D<T>*> field ) =0; 01067 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 01068 std::vector<ScalarField3D<T>*> field ) =0; 01069 }; 01070 01072 template<typename T, int nDim> 01073 struct BoundedTensorFieldBoxProcessingFunctional3D : public BoundedBoxProcessingFunctional3D { 01074 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 01075 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 01076 std::vector<AtomicBlock3D*> atomicBlocks ); 01077 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 01078 std::vector<AtomicBlock3D*> atomicBlocks ); 01079 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 01080 std::vector<AtomicBlock3D*> atomicBlocks ); 01081 01082 virtual void processBulk(Box3D domain, std::vector<TensorField3D<T,nDim>*> field) =0; 01083 virtual void processPlane( int direction, int orientation, Box3D domain, 01084 std::vector<TensorField3D<T,nDim>*> field ) =0; 01085 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 01086 std::vector<TensorField3D<T,nDim>*> field ) =0; 01087 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 01088 std::vector<TensorField3D<T,nDim>*> field ) =0; 01089 }; 01090 01092 template<typename T> 01093 struct BoundedNTensorFieldBoxProcessingFunctional3D : public BoundedBoxProcessingFunctional3D { 01094 virtual void processBulkGeneric(Box3D domain, std::vector<AtomicBlock3D*> atomicBlocks); 01095 virtual void processPlaneGeneric( int direction, int orientation, Box3D domain, 01096 std::vector<AtomicBlock3D*> atomicBlocks ); 01097 virtual void processEdgeGeneric( int plane, int normal1, int normal2, Box3D domain, 01098 std::vector<AtomicBlock3D*> atomicBlocks ); 01099 virtual void processCornerGeneric( int normalX, int normalY, int normalZ, Box3D domain, 01100 std::vector<AtomicBlock3D*> atomicBlocks ); 01101 01102 virtual void processBulk(Box3D domain, std::vector<NTensorField3D<T>*> field) =0; 01103 virtual void processPlane( int direction, int orientation, Box3D domain, 01104 std::vector<NTensorField3D<T>*> field ) =0; 01105 virtual void processEdge( int plane, int normal1, int normal2, Box3D domain, 01106 std::vector<NTensorField3D<T>*> field ) =0; 01107 virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain, 01108 std::vector<NTensorField3D<T>*> field ) =0; 01109 }; 01110 01111 } // namespace plb 01112 01113 #endif // DATA_PROCESSING_FUNCTIONAL_3D_H
1.7.5.1 
