fdFunctional3D.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 FINITE_DIFFERENCE_FUNCTIONAL_3D_H
00029 #define FINITE_DIFFERENCE_FUNCTIONAL_3D_H
00030 
00031 #include "core/globalDefs.h"
00032 #include "atomicBlock/dataProcessingFunctional3D.h"
00033 #include "atomicBlock/reductiveDataProcessingFunctional3D.h"
00034 
00035 namespace plb {
00036 
00037 /* *************** Central finite-difference schemes ***************** */
00038 
00039 template<typename T>
00040 class BoxXderivativeFunctional3D : public BoundedBoxProcessingFunctional3D_SS<T,T>
00041 {
00042 public:
00043     virtual void processBulk( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00044     virtual void processPlane( int direction, int orientation, Box3D domain,
00045                               ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00046     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00047                               ScalarField3D<T>& value, ScalarField3D<T>& derivative);
00048     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00049                                 ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00050     virtual BoxXderivativeFunctional3D<T>* clone() const;
00051     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00052     virtual BlockDomain::DomainT appliesTo() const;
00053 };
00054 
00055 
00056 template<typename T>
00057 class BoxYderivativeFunctional3D : public BoundedBoxProcessingFunctional3D_SS<T,T>
00058 {
00059 public:
00060     virtual void processBulk( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00061     virtual void processPlane( int direction, int orientation, Box3D domain,
00062                               ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00063     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00064                               ScalarField3D<T>& value, ScalarField3D<T>& derivative);
00065     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00066                                 ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00067     virtual BoxYderivativeFunctional3D<T>* clone() const;
00068     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00069     virtual BlockDomain::DomainT appliesTo() const;
00070 };
00071 
00072 template<typename T>
00073 class BoxZderivativeFunctional3D : public BoundedBoxProcessingFunctional3D_SS<T,T>
00074 {
00075 public:
00076     virtual void processBulk( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00077     virtual void processPlane( int direction, int orientation, Box3D domain,
00078                               ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00079     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00080                               ScalarField3D<T>& value, ScalarField3D<T>& derivative);
00081     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00082                                 ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00083     virtual BoxZderivativeFunctional3D<T>* clone() const;
00084     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00085     virtual BlockDomain::DomainT appliesTo() const;
00086 };
00087 
00088 template<typename T>
00089 class BoxGradientNormFunctional3D : public BoundedBoxProcessingFunctional3D_SS<T,T>
00090 {
00091 public:
00092     virtual void processBulk( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& grNorm );
00093     virtual void processPlane( int direction, int orientation, Box3D domain,
00094                               ScalarField3D<T>& value, ScalarField3D<T>& grNorm );
00095     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00096                               ScalarField3D<T>& value, ScalarField3D<T>& grNorm);
00097     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00098                                 ScalarField3D<T>& value, ScalarField3D<T>& grNorm );
00099     virtual BoxGradientNormFunctional3D<T>* clone() const;
00100     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00101     virtual BlockDomain::DomainT appliesTo() const;
00102 };
00103 
00104 /* *************** SOR iterations to solve a Poisson equation ******** */
00105 
00106 template<typename T>
00107 class BoxPoissonIteration3D : public BoundedScalarFieldBoxProcessingFunctional3D<T>
00108 {
00109 public:
00110     BoxPoissonIteration3D(T beta_);
00111     virtual void processBulk( Box3D domain, std::vector<ScalarField3D<T>*> scalarFields);
00112     virtual void processPlane( int direction, int orientation, Box3D domain,
00113                                std::vector<ScalarField3D<T>*> scalarFields );
00114     virtual void processEdge( int plane, int normal1, int normal2, Box3D domain,
00115                               std::vector<ScalarField3D<T>*> scalarFields );
00116     virtual void processCorner( int normalX, int normalY, int normalZ, Box3D domain,
00117                                 std::vector<ScalarField3D<T>*> scalarFields ); 
00118     virtual BoxPoissonIteration3D<T>* clone() const;
00119     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00120     virtual BlockDomain::DomainT appliesTo() const;
00121 private:
00122     T beta; //< Relaxation parameter
00123 };
00124 
00125 template<typename T>
00126 class BoxPoissonResidueFunctional3D : public ReductiveBoxProcessingFunctional3D_SS<T,T>
00127 {
00128 public:
00129     BoxPoissonResidueFunctional3D();
00130     virtual void process(Box3D domain, ScalarField3D<T>& pressure, ScalarField3D<T>& rhs);
00131     virtual BoxPoissonResidueFunctional3D<T>* clone() const;
00132     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const {
00133         modified[0] = modif::nothing;
00134         modified[1] = modif::nothing;
00135     }
00136     T getMaxResidue() const;
00137 private:
00138     plint maxResidueId;
00139 };
00140 
00141 // ========================================================================= //
00142 // PERIODIC VERSIONS OF THE DERIVATIVES AND POISSON SCHEMES //
00143 // ========================================================================= //
00144 
00145 
00146 /* *************** Central finite-difference schemes ***************** */
00147 
00148 template<typename T>
00149 class BoxXperiodicDerivativeFunctional3D : public BoxProcessingFunctional3D_SS<T,T>
00150 {
00151 public:
00152     virtual void process( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00153     virtual BoxXperiodicDerivativeFunctional3D<T>* clone() const;
00154     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00155     virtual BlockDomain::DomainT appliesTo() const;
00156 };
00157 
00158 
00159 template<typename T>
00160 class BoxYperiodicDerivativeFunctional3D : public BoxProcessingFunctional3D_SS<T,T>
00161 {
00162 public:
00163     virtual void process( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00164     virtual BoxYperiodicDerivativeFunctional3D<T>* clone() const;
00165     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00166     virtual BlockDomain::DomainT appliesTo() const;
00167 };
00168 
00169 template<typename T>
00170 class BoxZperiodicDerivativeFunctional3D : public BoxProcessingFunctional3D_SS<T,T>
00171 {
00172 public:
00173     virtual void process( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& derivative );
00174     virtual BoxZperiodicDerivativeFunctional3D<T>* clone() const;
00175     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00176     virtual BlockDomain::DomainT appliesTo() const;
00177 };
00178 
00179 template<typename T>
00180 class BoxPeriodicGradientNormFunctional3D : public BoxProcessingFunctional3D_SS<T,T>
00181 {
00182 public:
00183     virtual void process( Box3D domain, ScalarField3D<T>& value, ScalarField3D<T>& grNorm );
00184     virtual BoxPeriodicGradientNormFunctional3D<T>* clone() const;
00185     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00186     virtual BlockDomain::DomainT appliesTo() const;
00187 };
00188 
00189 /* *************** SOR iterations to solve a Poisson equation ******** */
00190 
00191 template<typename T>
00192 class BoxPeriodicPoissonIteration3D : public ScalarFieldBoxProcessingFunctional3D<T>
00193 {
00194 public:
00195     BoxPeriodicPoissonIteration3D(T beta_);
00196     virtual void process( Box3D domain, std::vector<ScalarField3D<T>*> scalarFields);
00197     virtual BoxPeriodicPoissonIteration3D<T>* clone() const;
00198     virtual void getTypeOfModification(std::vector<modif::ModifT>& modified) const;
00199 private:
00200     T beta; //< Relaxation parameter
00201 };
00202 
00203 }  // namespace plb
00204 
00205 #endif  // FINITE_DIFFERENCE_FUNCTIONAL_3D_H