OpenFOAM logo
Open Source CFD Toolkit

expDirectionMixedFvPatchField.H

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002   =========                 |
00003   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
00004    \\    /   O peration     |
00005     \\  /    A nd           | Copyright (C) 1991-2005 OpenCFD Ltd.
00006      \\/     M anipulation  |
00007 -------------------------------------------------------------------------------
00008 License
00009     This file is part of OpenFOAM.
00010 
00011     OpenFOAM is free software; you can redistribute it and/or modify it
00012     under the terms of the GNU General Public License as published by the
00013     Free Software Foundation; either version 2 of the License, or (at your
00014     option) any later version.
00015 
00016     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
00017     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00018     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
00019     for more details.
00020 
00021     You should have received a copy of the GNU General Public License
00022     along with OpenFOAM; if not, write to the Free Software Foundation,
00023     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
00024 
00025 Class
00026     expDirectionMixedFvPatchField
00027 
00028 Description
00029 
00030 SourceFiles
00031     expDirectionMixedFvPatchField.C
00032 
00033 \*---------------------------------------------------------------------------*/
00034 
00035 #ifndef expDirectionMixedFvPatchField_H
00036 #define expDirectionMixedFvPatchField_H
00037 
00038 #include "fvPatchField.H"
00039 
00040 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00041 
00042 namespace Foam
00043 {
00044 
00045 /*---------------------------------------------------------------------------*\
00046                            Class expDirectionMixedFvPatch Declaration
00047 \*---------------------------------------------------------------------------*/
00048 
00049 template<class Type>
00050 class expDirectionMixedFvPatchField
00051 :
00052     public fvPatchField<Type>
00053 {
00054     // Private data
00055 
00056         //- Value field
00057         Field<Type> refValue_;
00058 
00059         //- Normal gradient field
00060         Field<Type> refGrad_;
00061 
00062         //- Fraction (0-1) of value used for boundary condition
00063         scalarField valueFraction_;
00064 
00065 
00066 public:
00067 
00068     //- Runtime type information
00069     TypeName("expDirectionMixedMixed");
00070 
00071 
00072     // Constructors
00073 
00074         //- Construct from patch and internal field
00075         expDirectionMixedFvPatchField
00076         (
00077             const fvPatch&,
00078             const Field<Type>&
00079         );
00080 
00081         //- Construct from patch, internal field and dictionary
00082         expDirectionMixedFvPatchField
00083         (
00084             const fvPatch&,
00085             const Field<Type>&,
00086             const dictionary&
00087         );
00088 
00089         //- Construct by mapping given expDirectionMixedFvPatchField onto a new patch
00090         expDirectionMixedFvPatchField
00091         (
00092             const expDirectionMixedFvPatchField<Type>&,
00093             const fvPatch&,
00094             const Field<Type>&,
00095             const fvPatchFieldMapper&
00096         );
00097 
00098         //- Construct and return a clone
00099         virtual tmp<fvPatchField<Type> > clone() const
00100         {
00101             return tmp<fvPatchField<Type> >
00102             (
00103                 new expDirectionMixedFvPatchField<Type>(*this)
00104             );
00105         }
00106 
00107         //- Construct as copy setting internal field reference
00108         expDirectionMixedFvPatchField
00109         (
00110             const expDirectionMixedFvPatchField<Type>&,
00111             const Field<Type>&
00112         );
00113 
00114         //- Construct and return a clone setting internal field reference
00115         virtual tmp<fvPatchField<Type> > clone(const Field<Type>& iF) const
00116         {
00117             return tmp<fvPatchField<Type> >
00118             (
00119                 new expDirectionMixedFvPatchField<Type>(*this, iF)
00120             );
00121         }
00122 
00123 
00124     // Member functions
00125 
00126         // Access
00127 
00128             //- Return true if this patch field fixes a value.
00129             //  Needed to check if a level has to be specified while solving
00130             //  Poissons equations.
00131             virtual bool fixesrefValue() const
00132             {
00133                 return true;
00134             }
00135 
00136 
00137         // Return defining fields
00138 
00139             virtual Field<Type>& refValue()
00140             {
00141                 return refValue_;
00142             }
00143 
00144             virtual const Field<Type>& refValue() const
00145             {
00146                 return refValue_;
00147             }
00148 
00149             virtual Field<Type>& refGrad()
00150             {
00151                 return refGrad_;
00152             }
00153 
00154             virtual const Field<Type>& refGrad() const
00155             {
00156                 return refGrad_;
00157             }
00158 
00159             virtual scalarField& valueFraction()
00160             {
00161                 return valueFraction_;
00162             }
00163 
00164             virtual const scalarField& valueFraction() const
00165             {
00166                 return valueFraction_;
00167             }
00168 
00169 
00170         // Mapping functions
00171 
00172             //- Map (and resize as needed) from self given a mapping object
00173             virtual void autoMap
00174             (
00175                 const fvPatchFieldMapper&
00176             );
00177 
00178             //- Reverse map the given fvPatchField onto this fvPatchField
00179             virtual void rmap
00180             (
00181                 const fvPatchField<Type>&,
00182                 const labelList&
00183             );
00184 
00185 
00186         // Evaluation functions
00187 
00188             //- Return gradient at boundary
00189             virtual tmp<Field<Type> > snGrad() const;
00190 
00191             //- Evaluate the patch field
00192             virtual void evaluate();
00193 
00194             //- Return the matrix diagonal coefficients corresponding to the
00195             //  evaluation of the value of this patchField with given weights
00196             virtual tmp<Field<Type> > valueInternalCoeffs
00197             (
00198                 const tmp<scalarField>&
00199             ) const;
00200 
00201             //- Return the matrix source coefficients corresponding to the
00202             //  evaluation of the value of this patchField with given weights
00203             virtual tmp<Field<Type> > valueBoundaryCoeffs
00204             (
00205                 const tmp<scalarField>&
00206             ) const;
00207 
00208             //- Return the matrix diagonal coefficients corresponding to the
00209             //  evaluation of the gradient of this patchField
00210             virtual tmp<Field<Type> > gradientInternalCoeffs() const;
00211 
00212             //- Return the matrix source coefficients corresponding to the
00213             //  evaluation of the gradient of this patchField
00214             virtual tmp<Field<Type> > gradientBoundaryCoeffs() const;
00215 
00216 
00217         //- Write
00218         virtual void write(Ostream&) const;
00219 
00220 
00221     // Member operators
00222 
00223         virtual void operator=(const fvPatchField<Type>&) {}
00224         virtual void operator+=(const fvPatchField<Type>&) {}
00225         virtual void operator-=(const fvPatchField<Type>&) {}
00226         virtual void operator*=(const fvPatchField<scalar>&) {}
00227         virtual void operator/=(const fvPatchField<scalar>&) {}
00228 
00229         virtual void operator=(const Field<Type>&) {}
00230         virtual void operator+=(const Field<Type>&) {}
00231         virtual void operator-=(const Field<Type>&) {}
00232         virtual void operator*=(const Field<scalar>&) {}
00233         virtual void operator/=(const Field<scalar>&) {}
00234 
00235         virtual void operator=(const Type&) {}
00236         virtual void operator+=(const Type&) {}
00237         virtual void operator-=(const Type&) {}
00238         virtual void operator*=(const scalar) {}
00239         virtual void operator/=(const scalar) {}
00240 };
00241 
00242 
00243 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00244 
00245 } // End namespace Foam
00246 
00247 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00248 
00249 #ifdef NoRepository
00250 #   include "expDirectionMixedFvPatchField.C"
00251 #endif
00252 
00253 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00254 
00255 #endif
00256 
00257 // ************************************************************************* //
For further information go to www.openfoam.org