codedMixedFvPatchField.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 
26 #include "codedMixedFvPatchField.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::codedMixedFvPatchField<Type>::codeTemplateC
38  = "mixedFvPatchFieldTemplate.C";
39 
40 template<class Type>
41 const Foam::word Foam::codedMixedFvPatchField<Type>::codeTemplateH
42  = "mixedFvPatchFieldTemplate.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 (
193  const codedMixedFvPatchField<Type>& ptf,
194  const fvPatch& p,
196  const fvPatchFieldMapper& mapper
197 )
198 :
199  mixedFvPatchField<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 (
247  const codedMixedFvPatchField<Type>& ptf,
249 )
250 :
251  mixedFvPatchField<Type>(ptf, iF),
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  // Write the data from the mixed b.c.
271  OStringStream os;
273  IStringStream is(os.str());
274  // Construct dictionary from it.
275  dictionary dict(is);
276 
277  // Override the type to enforce the fvPatchField::New constructor
278  // to choose our type
279  dict.set("type", name_);
280 
281  redirectPatchFieldPtr_.set
282  (
283  dynamic_cast<mixedFvPatchField<Type>*>
284  (
286  (
287  this->patch(),
288  this->internalField(),
289  dict
290  ).ptr()
291  )
292  );
293  }
294  return redirectPatchFieldPtr_();
295 }
296 
297 
298 template<class Type>
300 {
301  if (this->updated())
302  {
303  return;
304  }
305 
306  // Make sure library containing user-defined fvPatchField is up-to-date
307  updateLibrary(name_);
308 
309  const mixedFvPatchField<Type>& fvp = redirectPatchField();
310 
311  const_cast<mixedFvPatchField<Type>&>(fvp).updateCoeffs();
312 
313  // Copy through coefficients
314  this->refValue() = fvp.refValue();
315  this->refGrad() = fvp.refGrad();
316  this->valueFraction() = fvp.valueFraction();
317 
319 }
320 
321 
322 template<class Type>
324 (
325  const Pstream::commsTypes commsType
326 )
327 {
328  // Make sure library containing user-defined fvPatchField is up-to-date
329  updateLibrary(name_);
330 
331  const mixedFvPatchField<Type>& fvp = redirectPatchField();
332 
333  // - updates the value of fvp (though not used)
334  // - resets the updated() flag
335  const_cast<mixedFvPatchField<Type>&>(fvp).evaluate(commsType);
336 
337  // Update the value (using the coefficients) locally
339 }
340 
341 
342 template<class Type>
344 {
346  os.writeKeyword("name") << name_
347  << token::END_STATEMENT << nl;
348 
349  if (dict_.found("codeInclude"))
350  {
351  os.writeKeyword("codeInclude")
352  << token::HASH << token::BEGIN_BLOCK;
353 
354  os.writeQuoted(string(dict_["codeInclude"]), false)
355  << token::HASH << token::END_BLOCK
356  << token::END_STATEMENT << nl;
357  }
358 
359  if (dict_.found("localCode"))
360  {
361  os.writeKeyword("localCode")
362  << token::HASH << token::BEGIN_BLOCK;
363 
364  os.writeQuoted(string(dict_["localCode"]), false)
365  << token::HASH << token::END_BLOCK
366  << token::END_STATEMENT << nl;
367  }
368 
369  if (dict_.found("code"))
370  {
371  os.writeKeyword("code")
372  << token::HASH << token::BEGIN_BLOCK;
373 
374  os.writeQuoted(string(dict_["code"]), false)
375  << token::HASH << token::END_BLOCK
376  << token::END_STATEMENT << nl;
377  }
378 
379  if (dict_.found("codeOptions"))
380  {
381  os.writeKeyword("codeOptions")
382  << token::HASH << token::BEGIN_BLOCK;
383 
384  os.writeQuoted(string(dict_["codeOptions"]), false)
385  << token::HASH << token::END_BLOCK
386  << token::END_STATEMENT << nl;
387  }
388 
389  if (dict_.found("codeLibs"))
390  {
391  os.writeKeyword("codeLibs")
392  << token::HASH << token::BEGIN_BLOCK;
393 
394  os.writeQuoted(string(dict_["codeLibs"]), false)
395  << token::HASH << token::END_BLOCK
396  << token::END_STATEMENT << nl;
397  }
398 }
399 
400 
401 // ************************************************************************* //
dictionary dict
bool found(const word &, bool recursive=false, bool patternMatch=true) const
Search dictionary for given keyword.
Definition: dictionary.C:431
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
This boundary condition provides a base class for &#39;mixed&#39; type boundary conditions, i.e. conditions that mix fixed value and patch-normal gradient conditions.
Abstract base class with a fat-interface to all derived classes covering all possible ways in which t...
Definition: fvPatchField.H:66
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.
const mixedFvPatchField< Type > & redirectPatchField() const
Get reference to the underlying patchField.
virtual Field< Type > & refValue()
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.
void clear()
Clear the list, i.e. set size to zero.
Definition: ListI.H:124
A class for handling words, derived from string.
Definition: word.H:59
virtual scalarField & valueFraction()
Foam::fvPatchFieldMapper.
Base class for function objects and boundary conditions using dynamic code.
Definition: codedBase.H:53
A table of dynamically loaded libraries.
virtual void evaluate(const Pstream::commsTypes commsType=Pstream::commsTypes::blocking)
Evaluate the patch field.
codedMixedFvPatchField(const fvPatch &, const DimensionedField< Type, volMesh > &)
Construct from patch and internal field.
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
virtual void write(Ostream &) const
Write.
Constructs on-the-fly a new boundary condition (derived from mixedFvPatchField) which is then used to...
Input from memory buffer stream.
Definition: IStringStream.H:49
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 updateCoeffs()
Update the coefficients associated with the patch field.
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
virtual Field< Type > & refGrad()
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