codedFixedValuePointPatchField.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2012-2016 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 Class
25  Foam::codedFixedValuePointPatchField
26 
27 Description
28  Constructs on-the-fly a new boundary condition (derived from
29  fixedValuePointPatchField) which is then used to evaluate.
30 
31  Example:
32  \verbatim
33  movingWall
34  {
35  type codedFixedValue;
36  value uniform 0;
37  name rampedFixedValue; // name of generated bc
38 
39  code
40  #{
41  operator==
42  (
43  vector(0,0,1)
44  *min(10, 0.1*this->db().time().value())
45  );
46  #};
47 
48  //codeInclude
49  //#{
50  // #include "fvCFD.H"
51  //#};
52 
53  //codeOptions
54  //#{
55  // -I$(LIB_SRC)/finiteVolume/lnInclude
56  //#};
57  }
58  \endverbatim
59 
60  A special form is if the \c code section is not supplied. In this case
61  the code gets read from a (runTimeModifiable!) dictionary system/codeDict
62  which would have a corresponding entry
63 
64  \verbatim
65  rampedFixedValue
66  {
67  code
68  #{
69  operator==(min(10, 0.1*this->db().time().value()));
70  #};
71  }
72  \endverbatim
73 
74 See also
75  codedFixedValueFvPatchField
76 
77 SourceFiles
78  codedFixedValuePointPatchField.C
79 
80 \*---------------------------------------------------------------------------*/
81 
82 #ifndef codedFixedValuePointPatchField_H
83 #define codedFixedValuePointPatchField_H
84 
86 #include "codedBase.H"
87 
88 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
89 
90 namespace Foam
91 {
92 
93 // Forward declaration of classes
94 class dynamicCode;
95 class dynamicCodeContext;
96 class IOdictionary;
97 
98 /*---------------------------------------------------------------------------*\
99  Class codedFixedValuePointPatchField Declaration
100 \*---------------------------------------------------------------------------*/
101 
102 template<class Type>
104 :
105  public fixedValuePointPatchField<Type>,
106  public codedBase
107 {
108  // Private data
109 
110  //- Dictionary contents for the boundary condition
111  mutable dictionary dict_;
112 
113  const word name_;
114 
115  mutable autoPtr<pointPatchField<Type>> redirectPatchFieldPtr_;
116 
117 
118  // Private Member Functions
119 
120  const IOdictionary& dict() const;
121 
122  //- Set the rewrite vars controlling the Type
123  static void setFieldTemplates(dynamicCode& dynCode);
124 
125  //- Get the loaded dynamic libraries
126  virtual dlLibraryTable& libs() const;
127 
128  //- Adapt the context for the current object
129  virtual void prepare(dynamicCode&, const dynamicCodeContext&) const;
130 
131  // Return a description (type + name) for the output
132  virtual string description() const;
133 
134  // Clear the ptr to the redirected object
135  virtual void clearRedirect() const;
136 
137  // Get the dictionary to initialize the codeContext
138  virtual const dictionary& codeDict() const;
139 
140 
141 public:
142 
143  // Static data members
144 
145  //- Name of the C code template to be used
146  static const word codeTemplateC;
147 
148  //- Name of the H code template to be used
149  static const word codeTemplateH;
150 
151 
152  //- Runtime type information
153  TypeName("codedFixedValue");
154 
155 
156  // Constructors
157 
158  //- Construct from patch and internal field
160  (
161  const pointPatch&,
163  );
164 
165  //- Construct from patch, internal field and dictionary
167  (
168  const pointPatch&,
170  const dictionary&,
171  const bool valueRequired=true
172  );
173 
174  //- Construct by mapping given codedFixedValuePointPatchField
175  // onto a new patch
177  (
179  const pointPatch&,
181  const pointPatchFieldMapper&
182  );
183 
184  //- Construct as copy
186  (
188  );
189 
190  //- Construct and return a clone
191  virtual autoPtr<pointPatchField<Type>> clone() const
192  {
194  (
196  );
197  }
198 
199  //- Construct as copy setting internal field reference
201  (
204  );
205 
206  //- Construct and return a clone setting internal field reference
208  (
210  ) const
211  {
213  (
215  (
216  *this,
217  iF
218  )
219  );
220  }
221 
222 
223  // Member functions
224 
225  //- Get reference to the underlying patch
227 
228  //- Update the coefficients associated with the patch field
229  virtual void updateCoeffs();
230 
231  //- Evaluate the patch field, sets Updated to false
232  virtual void evaluate
233  (
234  const Pstream::commsTypes commsType=Pstream::blocking
235  );
236 
237  //- Write
238  virtual void write(Ostream&) const;
239 };
240 
241 
242 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
243 
244 } // End namespace Foam
245 
246 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
247 
248 #ifdef NoRepository
250 #endif
251 
252 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
253 
254 #endif
255 
256 // ************************************************************************* //
const pointPatchField< Type > & redirectPatchField() const
Get reference to the underlying patch.
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:137
static const word codeTemplateH
Name of the H code template to be used.
codedFixedValuePointPatchField(const pointPatch &, const DimensionedField< Type, pointMesh > &)
Construct from patch and internal field.
commsTypes
Types of communications.
Definition: UPstream.H:64
A FixedValue boundary condition for pointField.
Foam::pointPatchFieldMapper.
static const word codeTemplateC
Name of the C code template to be used.
virtual void evaluate(const Pstream::commsTypes commsType=Pstream::blocking)
Evaluate the patch field, sets Updated to false.
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:53
Abstract base class for point-mesh patch fields.
TypeName("codedFixedValue")
Runtime type information.
Constructs on-the-fly a new boundary condition (derived from fixedValuePointPatchField) which is then...
A class for handling words, derived from string.
Definition: word.H:59
virtual autoPtr< pointPatchField< Type > > clone() const
Construct and return a clone.
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
virtual void write(Ostream &) const
Write.
Tools for handling dynamic code compilation.
Definition: dynamicCode.H:56
Encapsulation of dynamic code dictionaries.
Basic pointPatch represents a set of points from the mesh.
Definition: pointPatch.H:56
virtual void updateCoeffs()
Update the coefficients associated with the patch field.
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:53
Namespace for OpenFOAM.