Palabos  Version 1.0
Namespaces | Functions
dataProcessorWrapper2D.h File Reference
#include "atomicBlock/dataProcessingFunctional2D.h"
Include dependency graph for dataProcessorWrapper2D.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

namespace  plb
 

All OpenLB code is contained in this namespace.


Functions

void plb::applyProcessingFunctional (BoxProcessingFunctional2D *functional, Box2D domain, std::vector< AtomicBlock2D * > atomicBlocks)
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D *functional, Box2D domain, std::vector< AtomicBlock2D * > atomicBlocks, plint level)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (LatticeBoxProcessingFunctional2D< T, Descriptor > *functional, Box2D domain, std::vector< BlockLattice2D< T, Descriptor > * > lattices)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (LatticeBoxProcessingFunctional2D< T, Descriptor > *functional, Box2D domain, std::vector< BlockLattice2D< T, Descriptor > * > lattices, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (ScalarFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< ScalarField2D< T > * > fields)
template<typename T >
void plb::integrateProcessingFunctional (ScalarFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< ScalarField2D< T > * > fields, plint level=0)
template<typename T , int nDim>
void plb::applyProcessingFunctional (TensorFieldBoxProcessingFunctional2D< T, nDim > *functional, Box2D domain, std::vector< TensorField2D< T, nDim > * > fields)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (TensorFieldBoxProcessingFunctional2D< T, nDim > *functional, Box2D domain, std::vector< TensorField2D< T, nDim > * > fields, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (NTensorFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< NTensorField2D< T > * > fields)
template<typename T >
void plb::integrateProcessingFunctional (NTensorFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< NTensorField2D< T > * > fields, plint level=0)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_L< T, Descriptor > *functional, Box2D domain, BlockLattice2D< T, Descriptor > &lattice)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_L< T, Descriptor > *functional, Box2D domain, BlockLattice2D< T, Descriptor > &lattice, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_S< T > *functional, Box2D domain, ScalarField2D< T > &field)
template<typename T >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_S< T > *functional, Box2D domain, ScalarField2D< T > &field, plint level=0)
template<typename T , int nDim>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_T< T, nDim > *functional, Box2D domain, TensorField2D< T, nDim > &field)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_T< T, nDim > *functional, Box2D domain, TensorField2D< T, nDim > &field, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_N< T > *functional, Box2D domain, NTensorField2D< T > &field)
template<typename T >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_N< T > *functional, Box2D domain, NTensorField2D< T > &field, plint level=0)
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2)
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_SS< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_SS< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2, plint level=0)
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, Box2D domain, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2)
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, Box2D domain, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_NN< T1, T2 > *functional, Box2D domain, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_NN< T1, T2 > *functional, Box2D domain, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint level=0)
template<typename T1 , typename T2 , int nDim>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_ST< T1, T2, nDim > *functional, Box2D domain, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2)
template<typename T1 , typename T2 , int nDim>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_ST< T1, T2, nDim > *functional, Box2D domain, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_SN< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_SN< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (BoxProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (BoxProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field, plint level=0)
void plb::applyProcessingFunctional (DotProcessingFunctional2D *functional, DotList2D const &dotList, std::vector< AtomicBlock2D * > atomicBlocks)
void plb::integrateProcessingFunctional (DotProcessingFunctional2D *functional, DotList2D const &dotList, std::vector< AtomicBlock2D * > atomicBlocks, plint level)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (LatticeDotProcessingFunctional2D< T, Descriptor > *functional, DotList2D const &dotList, std::vector< BlockLattice2D< T, Descriptor > * > lattices)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (LatticeDotProcessingFunctional2D< T, Descriptor > *functional, DotList2D const &dotList, std::vector< BlockLattice2D< T, Descriptor > * > lattices, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (ScalarFieldDotProcessingFunctional2D< T > *functional, DotList2D const &dotList, std::vector< ScalarField2D< T > * > fields)
template<typename T >
void plb::integrateProcessingFunctional (ScalarFieldDotProcessingFunctional2D< T > *functional, DotList2D const &dotList, std::vector< ScalarField2D< T > * > fields, plint level=0)
template<typename T , int nDim>
void plb::applyProcessingFunctional (TensorFieldDotProcessingFunctional2D< T, nDim > *functional, DotList2D const &dotList, std::vector< TensorField2D< T, nDim > * > fields)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (TensorFieldDotProcessingFunctional2D< T, nDim > *functional, DotList2D const &dotList, std::vector< TensorField2D< T, nDim > * > fields, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (NTensorFieldDotProcessingFunctional2D< T > *functional, DotList2D const &dotList, std::vector< NTensorField2D< T > * > fields)
template<typename T >
void plb::integrateProcessingFunctional (NTensorFieldDotProcessingFunctional2D< T > *functional, DotList2D const &dotList, std::vector< NTensorField2D< T > * > fields, plint level=0)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_L< T, Descriptor > *functional, DotList2D const &dotList, BlockLattice2D< T, Descriptor > &lattice)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_L< T, Descriptor > *functional, DotList2D const &dotList, BlockLattice2D< T, Descriptor > &lattice, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_S< T > *functional, DotList2D const &dotList, ScalarField2D< T > &field)
template<typename T >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_S< T > *functional, DotList2D const &dotList, ScalarField2D< T > &field, plint level=0)
template<typename T , int nDim>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_T< T, nDim > *functional, DotList2D const &dotList, TensorField2D< T, nDim > &field)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_T< T, nDim > *functional, DotList2D const &dotList, TensorField2D< T, nDim > &field, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_N< T > *functional, DotList2D const &dotList, NTensorField2D< T > &field)
template<typename T >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_N< T > *functional, DotList2D const &dotList, NTensorField2D< T > &field, plint level=0)
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2)
 Easy instantiation of dotted data processor for lattice-lattice coupling.
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_SS< T1, T2 > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_SS< T1, T2 > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2, plint level=0)
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, DotList2D const &dotList, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2)
 Easy instantiation of dotted data processor for TensorField-TensorField coupling.
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, DotList2D const &dotList, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_NN< T1, T2 > *functional, DotList2D const &dotList, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2)
 Easy instantiation of dotted data processor for NTensorField-NTensorField coupling.
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_NN< T1, T2 > *functional, DotList2D const &dotList, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint level=0)
template<typename T1 , typename T2 , int nDim>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_ST< T1, T2, nDim > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2)
template<typename T1 , typename T2 , int nDim>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_ST< T1, T2, nDim > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_SN< T1, T2 > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_SN< T1, T2 > *functional, DotList2D const &dotList, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::applyProcessingFunctional (DotProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (DotProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (DotProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, DotList2D const &dotList, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field, plint level=0)
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D *functional, Box2D domain, std::vector< AtomicBlock2D * > atomicBlocks, plint boundaryWidth)
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D *functional, Box2D domain, std::vector< AtomicBlock2D * > atomicBlocks, plint boundaryWidth, plint level)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (BoundedLatticeBoxProcessingFunctional2D< T, Descriptor > *functional, Box2D domain, std::vector< BlockLattice2D< T, Descriptor > * > lattices, plint boundaryWidth=Descriptor< T >::boundaryWidth)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (BoundedLatticeBoxProcessingFunctional2D< T, Descriptor > *functional, Box2D domain, std::vector< BlockLattice2D< T, Descriptor > * > lattices, plint boundaryWidth=Descriptor< T >::boundaryWidth, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (BoundedScalarFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< ScalarField2D< T > * > fields, plint boundaryWidth)
template<typename T >
void plb::integrateProcessingFunctional (BoundedScalarFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< ScalarField2D< T > * > fields, plint boundaryWidth)
template<typename T , int nDim>
void plb::applyProcessingFunctional (BoundedTensorFieldBoxProcessingFunctional2D< T, nDim > *functional, Box2D domain, std::vector< TensorField2D< T, nDim > * > fields, plint boundaryWidth)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (BoundedTensorFieldBoxProcessingFunctional2D< T, nDim > *functional, Box2D domain, std::vector< TensorField2D< T, nDim > * > fields, plint boundaryWidth)
template<typename T >
void plb::applyProcessingFunctional (BoundedNTensorFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< NTensorField2D< T > * > fields, plint boundaryWidth)
template<typename T >
void plb::integrateProcessingFunctional (BoundedNTensorFieldBoxProcessingFunctional2D< T > *functional, Box2D domain, std::vector< NTensorField2D< T > * > fields, plint boundaryWidth)
template<typename T , template< typename U > class Descriptor>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_L< T, Descriptor > *functional, Box2D domain, BlockLattice2D< T, Descriptor > &lattice, plint boundaryWidth=Descriptor< T >::boundaryWidth)
template<typename T , template< typename U > class Descriptor>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_L< T, Descriptor > *functional, Box2D domain, BlockLattice2D< T, Descriptor > &lattice, plint boundaryWidth=Descriptor< T >::boundaryWidth, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_S< T > *functional, Box2D domain, ScalarField2D< T > &field, plint boundaryWidth)
template<typename T >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_S< T > *functional, Box2D domain, ScalarField2D< T > &field, plint boundaryWidth, plint level=0)
template<typename T , int nDim>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_T< T, nDim > *functional, Box2D domain, TensorField2D< T, nDim > &field, plint boundaryWidth)
template<typename T , int nDim>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_T< T, nDim > *functional, Box2D domain, TensorField2D< T, nDim > &field, plint boundaryWidth, plint level=0)
template<typename T >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_N< T > *functional, Box2D domain, NTensorField2D< T > &field, plint boundaryWidth)
template<typename T >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_N< T > *functional, Box2D domain, NTensorField2D< T > &field, plint boundaryWidth, plint level=0)
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2, plint boundaryWidth=Descriptor1< T1 >::boundaryWidth)
template<typename T1 , template< typename U1 > class Descriptor1, typename T2 , template< typename U2 > class Descriptor2>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor1 > &lattice1, BlockLattice2D< T2, Descriptor2 > &lattice2, plint boundaryWidth=Descriptor1< T1 >::boundaryWidth, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_SS< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2, plint boundaryWidth)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_SS< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, ScalarField2D< T2 > &field2, plint boundaryWidth, plint level=0)
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, Box2D domain, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2, plint boundaryWidth)
template<typename T1 , int nDim1, typename T2 , int nDim2>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 > *functional, Box2D domain, TensorField2D< T1, nDim1 > &field1, TensorField2D< T2, nDim2 > &field2, plint boundaryWidth, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_NN< T1, T2 > *functional, Box2D domain, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint boundaryWidth)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_NN< T1, T2 > *functional, Box2D domain, NTensorField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint boundaryWidth, plint level=0)
template<typename T1 , typename T2 , int nDim>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_ST< T1, T2, nDim > *functional, Box2D domain, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2, plint boundaryWidth)
template<typename T1 , typename T2 , int nDim>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_ST< T1, T2, nDim > *functional, Box2D domain, ScalarField2D< T1 > &field1, TensorField2D< T2, nDim > &field2, plint boundaryWidth, plint level=0)
template<typename T1 , typename T2 >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_SN< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint boundaryWidth)
template<typename T1 , typename T2 >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_SN< T1, T2 > *functional, Box2D domain, ScalarField2D< T1 > &field1, NTensorField2D< T2 > &field2, plint boundaryWidth, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_LS< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, ScalarField2D< T2 > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth)
template<typename T1 , template< typename U > class Descriptor, typename T2 , int nDim>
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, TensorField2D< T2, nDim > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth, plint level=0)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::applyProcessingFunctional (BoundedBoxProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth)
template<typename T1 , template< typename U > class Descriptor, typename T2 >
void plb::integrateProcessingFunctional (BoundedBoxProcessingFunctional2D_LN< T1, Descriptor, T2 > *functional, Box2D domain, BlockLattice2D< T1, Descriptor > &lattice, NTensorField2D< T2 > &field, plint boundaryWidth=Descriptor< T1 >::boundaryWidth, plint level=0)

Detailed Description

Utilities to help users handle data processors -- header file.

This file offers explicit wrappers to execute data-processors on atomic- blocks, or to integrate the data-processors into the atomic-blocks. A wrapper is offered for explicit choices of data types, for one or two block arguments. These wrappers are luxury: it would have been sufficient to have a generic wrapper which takes a single atomic-block as argument, then a generic wrapper for two atomic-blocks. The advantage of having an explicit wrapper for each choice of data types is type safety. It is guaranteed that the type of atomic-blocks fits the type of the data processor, which avoids awkward runtime errors.