src/finiteVolume/fields/fvPatchFields/derived/codedFixedValue/codedFixedValueFvPatchField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "codedFixedValueFvPatchField.H"
  27 #include "addToRunTimeSelectionTable.H"
  28 #include "fvPatchFieldMapper.H"
  29 #include "volFields.H"
  30 #include "dynamicCode.H"
  31 #include "dynamicCodeContext.H"
  32 #include "stringOps.H"
  33
  34 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  35
  36 template<class Type>
  37 const Foam::word Foam::codedFixedValueFvPatchField<Type>::codeTemplateC
  38     = "fixedValueFvPatchFieldTemplate.C";
  39
  40 template<class Type>
  41 const Foam::word Foam::codedFixedValueFvPatchField<Type>::codeTemplateH
  42     = "fixedValueFvPatchFieldTemplate.H";
  43
  44
  45 // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
  46
  47 template<class Type>
  48 void Foam::codedFixedValueFvPatchField<Type>::setFieldTemplates
  49 (
  50     dynamicCode& dynCode
  51 )
  52 {
  53     word fieldType(pTraits<Type>::typeName);
  54
  55     // template type for fvPatchField
  56     dynCode.setFilterVariable("TemplateType", fieldType);
  57
  58     // Name for fvPatchField - eg, ScalarField, VectorField, ...
  59     fieldType[0] = toupper(fieldType[0]);
  60     dynCode.setFilterVariable("FieldType", fieldType + "Field");
  61 }
  62
  63
  64 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  65
  66 template<class Type>
  67 const Foam::IOdictionary& Foam::codedFixedValueFvPatchField<Type>::dict() const
  68 {
  69     const objectRegistry& obr = this->db();
  70
  71     if (obr.foundObject<IOdictionary>("codeDict"))
  72     {
  73         return obr.lookupObject<IOdictionary>("codeDict");
  74     }
  75     else
  76     {
  77         return obr.store
  78         (
  79             new IOdictionary
  80             (
  81                 IOobject
  82                 (
  83                     "codeDict",
  84                     this->db().time().system(),
  85                     this->db(),
  86                     IOobject::MUST_READ_IF_MODIFIED,
  87                     IOobject::NO_WRITE
  88                 )
  89             )
  90         );
  91     }
  92 }
  93
  94
  95 template<class Type>
  96 Foam::dlLibraryTable& Foam::codedFixedValueFvPatchField<Type>::libs() const
  97 {
  98     return const_cast<dlLibraryTable&>(this->db().time().libs());
  99 }
 100
 101
 102 template<class Type>
 103 void Foam::codedFixedValueFvPatchField<Type>::prepare
 104 (
 105     dynamicCode& dynCode,
 106     const dynamicCodeContext& context
 107 ) const
 108 {
 109     // take no chances - typeName must be identical to redirectType_
 110     dynCode.setFilterVariable("typeName", redirectType_);
 111
 112     // set TemplateType and FieldType filter variables
 113     // (for fvPatchField)
 114     setFieldTemplates(dynCode);
 115
 116     // compile filtered C template
 117     dynCode.addCompileFile(codeTemplateC);
 118
 119     // copy filtered H template
 120     dynCode.addCopyFile(codeTemplateH);
 121
 122
 123     // debugging: make BC verbose
 124     //  dynCode.setFilterVariable("verbose", "true");
 125     //  Info<<"compile " << redirectType_ << " sha1: "
 126     //      << context.sha1() << endl;
 127
 128     // define Make/options
 129     dynCode.setMakeOptions
 130         (
 131             "EXE_INC = -g \\\n"
 132             "-I$(LIB_SRC)/finiteVolume/lnInclude \\\n"
 133             + context.options()
 134             + "\n\nLIB_LIBS = \\\n"
 135             + "    -lOpenFOAM \\\n"
 136             + "    -lfiniteVolume \\\n"
 137             + context.libs()
 138         );
 139 }
 140
 141
 142 template<class Type>
 143 const Foam::dictionary& Foam::codedFixedValueFvPatchField<Type>::codeDict()
 144 const
 145 {
 146     // use system/codeDict or in-line
 147     return
 148     (
 149         dict_.found("code")
 150       ? dict_
 151       : this->dict().subDict(redirectType_)
 152     );
 153 }
 154
 155
 156 template<class Type>
 157 Foam::string Foam::codedFixedValueFvPatchField<Type>::description() const
 158 {
 159     return
 160         "patch "
 161       + this->patch().name()
 162       + " on field "
 163       + this->dimensionedInternalField().name();
 164 }
 165
 166
 167 template<class Type>
 168 void Foam::codedFixedValueFvPatchField<Type>::clearRedirect() const
 169 {
 170     // remove instantiation of fvPatchField provided by library
 171     redirectPatchFieldPtr_.clear();
 172 }
 173
 174
 175 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 176
 177 template<class Type>
 178 Foam::codedFixedValueFvPatchField<Type>::codedFixedValueFvPatchField
 179 (
 180     const fvPatch& p,
 181     const DimensionedField<Type, volMesh>& iF
 182 )
 183 :
 184     fixedValueFvPatchField<Type>(p, iF),
 185     codedBase(),
 186     redirectPatchFieldPtr_()
 187 {}
 188
 189
 190 template<class Type>
 191 Foam::codedFixedValueFvPatchField<Type>::codedFixedValueFvPatchField
 192 (
 193     const codedFixedValueFvPatchField<Type>& ptf,
 194     const fvPatch& p,
 195     const DimensionedField<Type, volMesh>& iF,
 196     const fvPatchFieldMapper& mapper
 197 )
 198 :
 199     fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
 200     codedBase(),
 201     dict_(ptf.dict_),
 202     redirectType_(ptf.redirectType_),
 203     redirectPatchFieldPtr_()
 204 {}
 205
 206
 207 template<class Type>
 208 Foam::codedFixedValueFvPatchField<Type>::codedFixedValueFvPatchField
 209 (
 210     const fvPatch& p,
 211     const DimensionedField<Type, volMesh>& iF,
 212     const dictionary& dict
 213 )
 214 :
 215     fixedValueFvPatchField<Type>(p, iF, dict),
 216     codedBase(),
 217     dict_(dict),
 218     redirectType_(dict.lookup("redirectType")),
 219     redirectPatchFieldPtr_()
 220 {
 221     updateLibrary(redirectType_);
 222 }
 223
 224
 225 template<class Type>
 226 Foam::codedFixedValueFvPatchField<Type>::codedFixedValueFvPatchField
 227 (
 228     const codedFixedValueFvPatchField<Type>& ptf
 229 )
 230 :
 231     fixedValueFvPatchField<Type>(ptf),
 232     codedBase(),
 233     dict_(ptf.dict_),
 234     redirectType_(ptf.redirectType_),
 235     redirectPatchFieldPtr_()
 236 {}
 237
 238
 239 template<class Type>
 240 Foam::codedFixedValueFvPatchField<Type>::codedFixedValueFvPatchField
 241 (
 242     const codedFixedValueFvPatchField<Type>& ptf,
 243     const DimensionedField<Type, volMesh>& iF
 244 )
 245 :
 246     fixedValueFvPatchField<Type>(ptf, iF),
 247     codedBase(),
 248     dict_(ptf.dict_),
 249     redirectType_(ptf.redirectType_),
 250     redirectPatchFieldPtr_()
 251 {}
 252
 253
 254 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 255
 256 template<class Type>
 257 const Foam::fvPatchField<Type>&
 258 Foam::codedFixedValueFvPatchField<Type>::redirectPatchField() const
 259 {
 260     if (!redirectPatchFieldPtr_.valid())
 261     {
 262         // Construct a patch
 263         // Make sure to construct the patchfield with up-to-date value
 264
 265         OStringStream os;
 266         os.writeKeyword("type") << redirectType_ << token::END_STATEMENT
 267             << nl;
 268         static_cast<const Field<Type>&>(*this).writeEntry("value", os);
 269         IStringStream is(os.str());
 270         dictionary dict(is);
 271
 272         redirectPatchFieldPtr_.set
 273         (
 274             fvPatchField<Type>::New
 275             (
 276                 this->patch(),
 277                 this->dimensionedInternalField(),
 278                 dict
 279             ).ptr()
 280         );
 281     }
 282     return redirectPatchFieldPtr_();
 283 }
 284
 285
 286 template<class Type>
 287 void Foam::codedFixedValueFvPatchField<Type>::updateCoeffs()
 288 {
 289     if (this->updated())
 290     {
 291         return;
 292     }
 293
 294     // Make sure library containing user-defined fvPatchField is up-to-date
 295     updateLibrary(redirectType_);
 296
 297     const fvPatchField<Type>& fvp = redirectPatchField();
 298
 299     const_cast<fvPatchField<Type>&>(fvp).updateCoeffs();
 300
 301     // Copy through value
 302     this->operator==(fvp);
 303
 304     fixedValueFvPatchField<Type>::updateCoeffs();
 305 }
 306
 307
 308 template<class Type>
 309 void Foam::codedFixedValueFvPatchField<Type>::evaluate
 310 (
 311     const Pstream::commsTypes commsType
 312 )
 313 {
 314     // Make sure library containing user-defined fvPatchField is up-to-date
 315     updateLibrary(redirectType_);
 316
 317     const fvPatchField<Type>& fvp = redirectPatchField();
 318
 319     const_cast<fvPatchField<Type>&>(fvp).evaluate(commsType);
 320
 321     fixedValueFvPatchField<Type>::evaluate(commsType);
 322 }
 323
 324
 325 template<class Type>
 326 void Foam::codedFixedValueFvPatchField<Type>::write(Ostream& os) const
 327 {
 328     fixedValueFvPatchField<Type>::write(os);
 329     os.writeKeyword("redirectType") << redirectType_
 330         << token::END_STATEMENT << nl;
 331
 332     if (dict_.found("code"))
 333     {
 334         os.writeKeyword("code")
 335             << token::HASH << token::BEGIN_BLOCK;
 336
 337         os.writeQuoted(string(dict_["code"]), false)
 338             << token::HASH << token::END_BLOCK
 339             << token::END_STATEMENT << nl;
 340     }
 341 }
 342
 343
 344 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 345
 346
 347 // ************************************************************************* //