codedFixedValueFvPatchField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2018 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 
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>
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>
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>
97 {
98  return const_cast<dlLibraryTable&>(this->db().time().libs());
99 }
100 
101 
102 template<class Type>
104 (
105  dynamicCode& dynCode,
106  const dynamicCodeContext& context
107 ) const
108 {
109  // take no chances - typeName must be identical to name_
110  dynCode.setFilterVariable("typeName", name_);
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 " << name_ << " 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>
144 const
145 {
146  // use system/codeDict or in-line
147  return
148  (
149  dict_.found("code")
150  ? dict_
151  : this->dict().subDict(name_)
152  );
153 }
154 
155 
156 template<class Type>
158 {
159  return
160  "patch "
161  + this->patch().name()
162  + " on field "
163  + this->internalField().name();
164 }
165 
166 
167 template<class Type>
169 {
170  // remove instantiation of fvPatchField provided by library
171  redirectPatchFieldPtr_.clear();
172 }
173 
174 
175 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
176 
177 template<class Type>
179 (
180  const fvPatch& p,
182 )
183 :
185  codedBase(),
186  redirectPatchFieldPtr_()
187 {}
188 
189 
190 template<class Type>
192 (
194  const fvPatch& p,
196  const fvPatchFieldMapper& mapper
197 )
198 :
199  fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
200  codedBase(),
201  dict_(ptf.dict_),
202  name_(ptf.name_),
203  redirectPatchFieldPtr_()
204 {}
205 
206 
207 template<class Type>
209 (
210  const fvPatch& p,
212  const dictionary& dict
213 )
214 :
216  codedBase(),
217  dict_(dict),
218  name_
219  (
220  dict.found("redirectType")
221  ? dict.lookup("redirectType")
222  : dict.lookup("name")
223  ),
224  redirectPatchFieldPtr_()
225 {
226  updateLibrary(name_);
227 }
228 
229 
230 template<class Type>
232 (
234 )
235 :
237  codedBase(),
238  dict_(ptf.dict_),
239  name_(ptf.name_),
240  redirectPatchFieldPtr_()
241 {}
242 
243 
244 template<class Type>
246 (
249 )
250 :
252  codedBase(),
253  dict_(ptf.dict_),
254  name_(ptf.name_),
255  redirectPatchFieldPtr_()
256 {}
257 
258 
259 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
260 
261 template<class Type>
264 {
265  if (!redirectPatchFieldPtr_.valid())
266  {
267  // Construct a patch
268  // Make sure to construct the patchfield with up-to-date value
269 
270  OStringStream os;
271  os.writeKeyword("type") << name_ << token::END_STATEMENT
272  << nl;
273  static_cast<const Field<Type>&>(*this).writeEntry("value", os);
274  IStringStream is(os.str());
275  dictionary dict(is);
276 
277  redirectPatchFieldPtr_.set
278  (
280  (
281  this->patch(),
282  this->internalField(),
283  dict
284  ).ptr()
285  );
286  }
287  return redirectPatchFieldPtr_();
288 }
289 
290 
291 template<class Type>
293 {
294  if (this->updated())
295  {
296  return;
297  }
298 
299  // Make sure library containing user-defined fvPatchField is up-to-date
300  updateLibrary(name_);
301 
302  const fvPatchField<Type>& fvp = redirectPatchField();
303 
304  const_cast<fvPatchField<Type>&>(fvp).updateCoeffs();
305 
306  // Copy through value
307  this->operator==(fvp);
308 
310 }
311 
312 
313 template<class Type>
315 (
316  const Pstream::commsTypes commsType
317 )
318 {
319  // Make sure library containing user-defined fvPatchField is up-to-date
320  updateLibrary(name_);
321 
322  const fvPatchField<Type>& fvp = redirectPatchField();
323 
324  const_cast<fvPatchField<Type>&>(fvp).evaluate(commsType);
325 
327 }
328 
329 
330 template<class Type>
332 {
334  os.writeKeyword("name") << name_
335  << token::END_STATEMENT << nl;
336 
337  if (dict_.found("codeInclude"))
338  {
339  os.writeKeyword("codeInclude")
340  << token::HASH << token::BEGIN_BLOCK;
341 
342  os.writeQuoted(string(dict_["codeInclude"]), false)
343  << token::HASH << token::END_BLOCK
344  << token::END_STATEMENT << nl;
345  }
346 
347  if (dict_.found("localCode"))
348  {
349  os.writeKeyword("localCode")
350  << token::HASH << token::BEGIN_BLOCK;
351 
352  os.writeQuoted(string(dict_["localCode"]), false)
353  << token::HASH << token::END_BLOCK
354  << token::END_STATEMENT << nl;
355  }
356 
357  if (dict_.found("code"))
358  {
359  os.writeKeyword("code")
360  << token::HASH << token::BEGIN_BLOCK;
361 
362  os.writeQuoted(string(dict_["code"]), false)
363  << token::HASH << token::END_BLOCK
364  << token::END_STATEMENT << nl;
365  }
366 
367  if (dict_.found("codeOptions"))
368  {
369  os.writeKeyword("codeOptions")
370  << token::HASH << token::BEGIN_BLOCK;
371 
372  os.writeQuoted(string(dict_["codeOptions"]), false)
373  << token::HASH << token::END_BLOCK
374  << token::END_STATEMENT << nl;
375  }
376 
377  if (dict_.found("codeLibs"))
378  {
379  os.writeKeyword("codeLibs")
380  << token::HASH << token::BEGIN_BLOCK;
381 
382  os.writeQuoted(string(dict_["codeLibs"]), false)
383  << token::HASH << token::END_BLOCK
384  << token::END_STATEMENT << nl;
385  }
386 }
387 
388 
389 // ************************************************************************* //
This boundary condition supplies a fixed value constraint, and is the base class for a number of othe...
dictionary dict
bool found(const word &, bool recursive=false, bool patternMatch=true) const
Search dictionary for given keyword.
Definition: dictionary.C:431
virtual void updateCoeffs()
Update the coefficients associated with the patch field.
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:137
commsTypes
Types of communications.
Definition: UPstream.H:64
A finiteVolume patch using a polyPatch and a fvBoundaryMesh.
Definition: fvPatch.H:61
Abstract base class with a fat-interface to all derived classes covering all possible ways in which t...
Definition: fvPatchField.H:66
void writeEntry(const word &keyword, Ostream &os) const
Write the field as a dictionary entry.
Definition: Field.C:726
Macros for easy insertion into run-time selection tables.
virtual Ostream & writeQuoted(const std::string &, const bool quoted=true)=0
Write std::string surrounded by quotes.
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:52
void write(Ostream &, const label, const dictionary &)
Write with dictionary lookup.
virtual void evaluate(const Pstream::commsTypes commsType=Pstream::commsTypes::blocking)
Evaluate the patch field, sets Updated to false.
Pre-declare SubField and related Field type.
Definition: Field.H:57
void clear()
Clear the list, i.e. set size to zero.
Definition: ListI.H:124
tmp< fvMatrix< Type > > operator==(const fvMatrix< Type > &, const fvMatrix< Type > &)
A class for handling words, derived from string.
Definition: word.H:59
Foam::fvPatchFieldMapper.
Base class for function objects and boundary conditions using dynamic code.
Definition: codedBase.H:53
A table of dynamically loaded libraries.
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:53
static const char nl
Definition: Ostream.H:265
Ostream & writeKeyword(const keyType &)
Write the keyword followed by an appropriate indentation.
Definition: Ostream.C:54
Constructs on-the-fly a new boundary condition (derived from fixedValueFvPatchField) which is then us...
Input from memory buffer stream.
Definition: IStringStream.H:49
codedFixedValueFvPatchField(const fvPatch &, const DimensionedField< Type, volMesh > &)
Construct from patch and internal field.
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
string str() const
Return the string.
virtual void write(Ostream &) const
Write.
volScalarField & p
A class for handling character strings derived from std::string.
Definition: string.H:74
Output to memory buffer stream.
Definition: OStringStream.H:49
int system(const std::string &command)
Execute the specified command.
Definition: POSIX.C:1217
ITstream & lookup(const word &, bool recursive=false, bool patternMatch=true) const
Find and return an entry data stream.
Definition: dictionary.C:576
const fvPatchField< Type > & redirectPatchField() const
Get reference to the underlying patch.