src/OpenFOAM/fields/pointPatchFields/basic/value/valuePointPatchField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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 "valuePointPatchField.H"
  28 #include "pointPatchFieldMapper.H"
  29
  30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  36
  37 template<class Type>
  38 void valuePointPatchField<Type>::checkFieldSize() const
  39 {
  40     if (size() != this->patch().size())
  41     {
  42         FatalErrorIn
  43         (
  44             "void valuePointPatchField<Type>::checkField() const"
  45         )   << "field does not correspond to patch. " << endl
  46             << "Field size: " << size() << " patch size: "
  47             << this->patch().size()
  48             << abort(FatalError);
  49     }
  50 }
  51
  52
  53 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * * //
  54
  55 template<class Type>
  56 valuePointPatchField<Type>::valuePointPatchField
  57 (
  58     const pointPatch& p,
  59     const DimensionedField<Type, pointMesh>& iF
  60 )
  61 :
  62     pointPatchField<Type>(p, iF),
  63     Field<Type>(p.size())
  64 {}
  65
  66
  67 template<class Type>
  68 valuePointPatchField<Type>::valuePointPatchField
  69 (
  70     const pointPatch& p,
  71     const DimensionedField<Type, pointMesh>& iF,
  72     const dictionary& dict,
  73     const bool valueRequired
  74 )
  75 :
  76     pointPatchField<Type>(p, iF, dict),
  77     Field<Type>(p.size())
  78 {
  79     if (dict.found("value"))
  80     {
  81         Field<Type>::operator=
  82         (
  83             Field<Type>("value", dict, p.size())
  84         );
  85     }
  86     else if (!valueRequired)
  87     {
  88         Field<Type>::operator=(pTraits<Type>::zero);
  89     }
  90     else
  91     {
  92         FatalIOErrorIn
  93         (
  94             "pointPatchField<Type>::pointPatchField"
  95             "("
  96             "const fvPatch& p,"
  97             "const DimensionedField<Type, pointMesh>& iF,"
  98             "const dictionary& dict,"
  99             "const bool valueRequired"
 100             ")",
 101             dict
 102         )   << "Essential entry 'value' missing"
 103             << exit(FatalIOError);
 104     }
 105 }
 106
 107
 108 template<class Type>
 109 valuePointPatchField<Type>::valuePointPatchField
 110 (
 111     const valuePointPatchField<Type>& ptf,
 112     const pointPatch& p,
 113     const DimensionedField<Type, pointMesh>& iF,
 114     const pointPatchFieldMapper& mapper
 115 )
 116 :
 117     pointPatchField<Type>(p, iF),
 118     Field<Type>(ptf, mapper)
 119 {}
 120
 121
 122 template<class Type>
 123 valuePointPatchField<Type>::valuePointPatchField
 124 (
 125     const valuePointPatchField<Type>& ptf,
 126     const DimensionedField<Type, pointMesh>& iF
 127 )
 128 :
 129     pointPatchField<Type>(ptf, iF),
 130     Field<Type>(ptf)
 131 {}
 132
 133
 134 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 135
 136 template<class Type>
 137 void valuePointPatchField<Type>::autoMap
 138 (
 139     const pointPatchFieldMapper& m
 140 )
 141 {
 142     Field<Type>::autoMap(m);
 143 }
 144
 145
 146 template<class Type>
 147 void valuePointPatchField<Type>::rmap
 148 (
 149     const pointPatchField<Type>& ptf,
 150     const labelList& addr
 151 )
 152 {
 153     Field<Type>::rmap
 154     (
 155         refCast<const valuePointPatchField<Type> >
 156         (
 157             ptf
 158         ),
 159         addr
 160     );
 161 }
 162
 163
 164 template<class Type>
 165 void valuePointPatchField<Type>::updateCoeffs()
 166 {
 167     if (this->updated())
 168     {
 169         return;
 170     }
 171
 172     // Get internal field to insert values into
 173     Field<Type>& iF = const_cast<Field<Type>&>(this->internalField());
 174
 175     setInInternalField(iF, *this);
 176
 177     pointPatchField<Type>::updateCoeffs();
 178 }
 179
 180
 181 template<class Type>
 182 void valuePointPatchField<Type>::evaluate(const Pstream::commsTypes)
 183 {
 184     // Get internal field to insert values into
 185     Field<Type>& iF = const_cast<Field<Type>&>(this->internalField());
 186
 187     setInInternalField(iF, *this);
 188
 189     pointPatchField<Type>::evaluate();
 190 }
 191
 192
 193 template<class Type>
 194 void valuePointPatchField<Type>::write(Ostream& os) const
 195 {
 196     pointPatchField<Type>::write(os);
 197     this->writeEntry("value", os);
 198 }
 199
 200
 201 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 202
 203 template<class Type>
 204 void valuePointPatchField<Type>::operator=
 205 (
 206     const valuePointPatchField<Type>& ptf
 207 )
 208 {
 209     Field<Type>::operator=(ptf);
 210 }
 211
 212
 213 template<class Type>
 214 void valuePointPatchField<Type>::operator=
 215 (
 216     const pointPatchField<Type>& ptf
 217 )
 218 {
 219     Field<Type>::operator=(ptf.patchInternalField());
 220 }
 221
 222
 223 template<class Type>
 224 void valuePointPatchField<Type>::operator=
 225 (
 226     const Field<Type>& tf
 227 )
 228 {
 229     Field<Type>::operator=(tf);
 230 }
 231
 232
 233 template<class Type>
 234 void valuePointPatchField<Type>::operator=
 235 (
 236     const Type& t
 237 )
 238 {
 239     Field<Type>::operator=(t);
 240 }
 241
 242
 243 // Force an assignment
 244 template<class Type>
 245 void valuePointPatchField<Type>::operator==
 246 (
 247     const valuePointPatchField<Type>& ptf
 248 )
 249 {
 250     Field<Type>::operator=(ptf);
 251 }
 252
 253
 254 template<class Type>
 255 void valuePointPatchField<Type>::operator==
 256 (
 257     const pointPatchField<Type>& ptf
 258 )
 259 {
 260     Field<Type>::operator=(ptf.patchInternalField());
 261 }
 262
 263
 264 template<class Type>
 265 void valuePointPatchField<Type>::operator==
 266 (
 267     const Field<Type>& tf
 268 )
 269 {
 270     Field<Type>::operator=(tf);
 271 }
 272
 273
 274 template<class Type>
 275 void valuePointPatchField<Type>::operator==
 276 (
 277     const Type& t
 278 )
 279 {
 280     Field<Type>::operator=(t);
 281 }
 282
 283
 284 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 285
 286 } // End namespace Foam
 287
 288 // ************************************************************************* //