src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "mixedFaPatchField.H"
  28
  29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  30
  31 namespace Foam
  32 {
  33
  34 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  35
  36 template<class Type>
  37 mixedFaPatchField<Type>::mixedFaPatchField
  38 (
  39     const faPatch& p,
  40     const DimensionedField<Type, areaMesh>& iF
  41 )
  42 :
  43     faPatchField<Type>(p, iF),
  44     refValue_(p.size()),
  45     refGrad_(p.size()),
  46     valueFraction_(p.size())
  47 {}
  48
  49
  50 template<class Type>
  51 mixedFaPatchField<Type>::mixedFaPatchField
  52 (
  53     const mixedFaPatchField<Type>& ptf,
  54     const faPatch& p,
  55     const DimensionedField<Type, areaMesh>& iF,
  56     const faPatchFieldMapper& mapper
  57 )
  58 :
  59     faPatchField<Type>(ptf, p, iF, mapper),
  60     refValue_(ptf.refValue_, mapper),
  61     refGrad_(ptf.refGrad_, mapper),
  62     valueFraction_(ptf.valueFraction_, mapper)
  63 {}
  64
  65
  66 template<class Type>
  67 mixedFaPatchField<Type>::mixedFaPatchField
  68 (
  69     const faPatch& p,
  70     const DimensionedField<Type, areaMesh>& iF,
  71     const dictionary& dict
  72 )
  73 :
  74     faPatchField<Type>(p, iF),
  75     refValue_("refValue", dict, p.size()),
  76     refGrad_("refGradient", dict, p.size()),
  77     valueFraction_("valueFraction", dict, p.size())
  78 {
  79     evaluate();
  80 }
  81
  82
  83 template<class Type>
  84 mixedFaPatchField<Type>::mixedFaPatchField
  85 (
  86     const mixedFaPatchField<Type>& ptf
  87 )
  88 :
  89     faPatchField<Type>(ptf),
  90     refValue_(ptf.refValue_),
  91     refGrad_(ptf.refGrad_),
  92     valueFraction_(ptf.valueFraction_)
  93 {}
  94
  95
  96 template<class Type>
  97 mixedFaPatchField<Type>::mixedFaPatchField
  98 (
  99     const mixedFaPatchField<Type>& ptf,
 100     const DimensionedField<Type, areaMesh>& iF
 101 )
 102 :
 103     faPatchField<Type>(ptf, iF),
 104     refValue_(ptf.refValue_),
 105     refGrad_(ptf.refGrad_),
 106     valueFraction_(ptf.valueFraction_)
 107 {}
 108
 109
 110 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 111
 112 template<class Type>
 113 void mixedFaPatchField<Type>::autoMap
 114 (
 115     const faPatchFieldMapper& m
 116 )
 117 {
 118     Field<Type>::autoMap(m);
 119     refValue_.autoMap(m);
 120     refGrad_.autoMap(m);
 121     valueFraction_.autoMap(m);
 122 }
 123
 124
 125 template<class Type>
 126 void mixedFaPatchField<Type>::rmap
 127 (
 128     const faPatchField<Type>& ptf,
 129     const labelList& addr
 130 )
 131 {
 132     faPatchField<Type>::rmap(ptf, addr);
 133
 134     const mixedFaPatchField<Type>& mptf =
 135         refCast<const mixedFaPatchField<Type> >(ptf);
 136
 137     refValue_.rmap(mptf.refValue_, addr);
 138     refGrad_.rmap(mptf.refGrad_, addr);
 139     valueFraction_.rmap(mptf.valueFraction_, addr);
 140 }
 141
 142
 143 template<class Type>
 144 void mixedFaPatchField<Type>::evaluate(const Pstream::commsTypes)
 145 {
 146     if (!this->updated())
 147     {
 148         this->updateCoeffs();
 149     }
 150
 151     Field<Type>::operator=
 152     (
 153         valueFraction_*refValue_
 154       +
 155         (1.0 - valueFraction_)*
 156         (
 157             this->patchInternalField()
 158           + refGrad_/this->patch().deltaCoeffs()
 159         )
 160     );
 161
 162     faPatchField<Type>::evaluate();
 163 }
 164
 165
 166 template<class Type>
 167 tmp<Field<Type> > mixedFaPatchField<Type>::snGrad() const
 168 {
 169     return
 170         valueFraction_
 171        *(refValue_ - this->patchInternalField())
 172        *this->patch().deltaCoeffs()
 173       + (1.0 - valueFraction_)*refGrad_;
 174 }
 175
 176
 177 template<class Type>
 178 tmp<Field<Type> > mixedFaPatchField<Type>::valueInternalCoeffs
 179 (
 180     const tmp<scalarField>&
 181 ) const
 182 {
 183     return Type(pTraits<Type>::one)*(1.0 - valueFraction_);
 184
 185 }
 186
 187
 188 template<class Type>
 189 tmp<Field<Type> > mixedFaPatchField<Type>::valueBoundaryCoeffs
 190 (
 191     const tmp<scalarField>&
 192 ) const
 193 {
 194     return
 195          valueFraction_*refValue_
 196        + (1.0 - valueFraction_)*refGrad_/this->patch().deltaCoeffs();
 197 }
 198
 199
 200 template<class Type>
 201 tmp<Field<Type> > mixedFaPatchField<Type>::gradientInternalCoeffs() const
 202 {
 203     return -Type(pTraits<Type>::one)*valueFraction_*this->patch().deltaCoeffs();
 204 }
 205
 206
 207 template<class Type>
 208 tmp<Field<Type> > mixedFaPatchField<Type>::gradientBoundaryCoeffs() const
 209 {
 210     return
 211         valueFraction_*this->patch().deltaCoeffs()*refValue_
 212       + (1.0 - valueFraction_)*refGrad_;
 213 }
 214
 215
 216 template<class Type>
 217 void mixedFaPatchField<Type>::write(Ostream& os) const
 218 {
 219     faPatchField<Type>::write(os);
 220     refValue_.writeEntry("refValue", os);
 221     refGrad_.writeEntry("refGradient", os);
 222     valueFraction_.writeEntry("valueFraction", os);
 223     this->writeEntry("value", os);
 224 }
 225
 226
 227 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 228
 229 } // End namespace Foam
 230
 231 // ************************************************************************* //