DSMCParcel.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) 2011-2017 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::DSMCParcel
26 
27 Description
28  DSMC parcel class
29 
30 SourceFiles
31  DSMCParcelI.H
32  DSMCParcel.C
33  DSMCParcelIO.C
34 
35 \*---------------------------------------------------------------------------*/
36 
37 #ifndef DSMCParcel_H
38 #define DSMCParcel_H
39 
40 #include "particle.H"
41 #include "IOstream.H"
42 #include "autoPtr.H"
43 #include "contiguous.H"
44 #include "DSMCCloud.H"
45 
46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
47 
48 namespace Foam
49 {
50 
51 template<class ParcelType>
52 class DSMCParcel;
53 
54 // Forward declaration of friend functions
55 
56 template<class ParcelType>
57 Ostream& operator<<
58 (
59  Ostream&,
61 );
62 
63 /*---------------------------------------------------------------------------*\
64  Class DSMCParcel Declaration
65 \*---------------------------------------------------------------------------*/
66 
67 template<class ParcelType>
68 class DSMCParcel
69 :
70  public ParcelType
71 {
72  // Private member data
73 
74  //- Size in bytes of the fields
75  static const std::size_t sizeofFields_;
76 
77 
78 public:
79 
80  //- Class to hold DSMC particle constant properties
81  class constantProperties
82  {
83  // Private data
84 
85  //- Particle mass [kg] (constant)
86  scalar mass_;
87 
88  //- Particle hard sphere diameter [m] (constant)
89  scalar d_;
90 
91  //- Internal degrees of freedom
92  direction internalDegreesOfFreedom_;
93 
94  //- Viscosity index
95  scalar omega_;
96 
97 
98  public:
99 
100  // Constructors
101 
102  //- Null constructor, allows List of constantProperties to be
103  // created before the contents is initialised
104  inline constantProperties();
105 
106  //- Constructor from dictionary
107  inline constantProperties(const dictionary& dict);
108 
109 
110  // Member functions
111 
112  //- Return const access to the particle mass [kg]
113  inline scalar mass() const;
114 
115  //- Return const access to the hard sphere diameter [m]
116  inline scalar d() const;
117 
118  //- Return the reference total collision cross section
119  inline scalar sigmaT() const;
120 
121  //- Return the internalDegreesOfFreedom
122  inline direction internalDegreesOfFreedom() const;
123 
124  //- Return the viscosity index
125  inline scalar omega() const;
126 
127  };
128 
129 
130  //- Class used to pass kinematic tracking data to the trackToFace function
131  class trackingData
132  :
133  public particle::TrackingData<DSMCCloud<DSMCParcel<ParcelType>>>
134  {
135  public:
136 
137  // Constructors
138 
139  //- Construct from components
141  :
142  particle::TrackingData<DSMCCloud<DSMCParcel<ParcelType>>>
143  (
144  cloud
145  )
146  {}
147  };
148 
149 
150 protected:
151 
152  // Protected member data
153 
154  // Parcel properties
155 
156  //- Velocity of Parcel [m/s]
157  vector U_;
158 
159  //- Internal energy of the Parcel, covering all non-translational
160  // degrees of freedom [J]
161  scalar Ei_;
162 
163  //- Parcel type id
164  label typeId_;
165 
166 
167 public:
168 
169  //- Runtime type information
170  TypeName("DSMCParcel");
172  friend class Cloud<ParcelType>;
173 
174 
175  // Constructors
176 
177  //- Construct from components
178  inline DSMCParcel
179  (
180  const polyMesh& mesh,
181  const barycentric& coordinates,
182  const label celli,
183  const label tetFacei,
184  const label tetPti,
185  const vector& U,
186  const scalar Ei,
187  const label typeId
188  );
189 
190  //- Construct from a position and a cell, searching for the rest of the
191  // required topology
192  inline DSMCParcel
193  (
194  const polyMesh& mesh,
195  const vector& position,
196  const label celli,
197  const vector& U,
198  const scalar Ei,
199  const label typeId
200  );
201 
202  //- Construct from Istream
203  DSMCParcel
204  (
205  const polyMesh& mesh,
206  Istream& is,
207  bool readFields = true
208  );
209 
210  //- Construct and return a clone
211  virtual autoPtr<particle> clone() const
212  {
213  return autoPtr<particle>(new DSMCParcel<ParcelType>(*this));
214  }
215 
216  //- Factory class to read-construct particles used for
217  // parallel transfer
218  class iNew
219  {
220  const polyMesh& mesh_;
221 
222  public:
224  iNew(const polyMesh& mesh)
225  :
226  mesh_(mesh)
227  {}
229  autoPtr<DSMCParcel<ParcelType>> operator()(Istream& is) const
230  {
232  (
233  new DSMCParcel<ParcelType>(mesh_, is, true)
234  );
235  }
236  };
237 
238 
239  // Member Functions
240 
241  // Access
242 
243  //- Return type id
244  inline label typeId() const;
245 
246  //- Return const access to velocity
247  inline const vector& U() const;
248 
249  //- Return const access to internal energy
250  inline scalar Ei() const;
251 
252 
253  // Edit
254 
255  //- Return access to velocity
256  inline vector& U();
257 
258  //- Return access to internal energy
259  inline scalar& Ei();
260 
261 
262  // Main calculation loop
263 
264  // Tracking
265 
266  //- Move the parcel
267  template<class TrackData>
268  bool move(TrackData& td, const scalar trackTime);
269 
270 
271  // Patch interactions
272 
273  //- Overridable function to handle the particle hitting a patch
274  // Executed before other patch-hitting functions
275  template<class TrackData>
276  bool hitPatch
277  (
278  const polyPatch&,
279  TrackData& td,
280  const label patchi,
281  const scalar trackFraction,
282  const tetIndices& tetIs
283  );
284 
285  //- Overridable function to handle the particle hitting a
286  // processorPatch
287  template<class TrackData>
288  void hitProcessorPatch
289  (
290  const processorPolyPatch&,
291  TrackData& td
292  );
293 
294  //- Overridable function to handle the particle hitting a wallPatch
295  template<class TrackData>
296  void hitWallPatch
297  (
298  const wallPolyPatch&,
299  TrackData& td,
300  const tetIndices&
301  );
302 
303  //- Overridable function to handle the particle hitting a polyPatch
304  template<class TrackData>
305  void hitPatch
306  (
307  const polyPatch&,
308  TrackData& td
309  );
310 
311  //- Transform the physical properties of the particle
312  // according to the given transformation tensor
313  virtual void transformProperties(const tensor& T);
314 
315  //- Transform the physical properties of the particle
316  // according to the given separation vector
317  virtual void transformProperties(const vector& separation);
318 
319 
320  // I-O
321 
322  static void readFields(Cloud<DSMCParcel<ParcelType>>& c);
323 
324  static void writeFields(const Cloud<DSMCParcel<ParcelType>>& c);
325 
326 
327  // Ostream Operator
328 
329  friend Ostream& operator<< <ParcelType>
330  (
331  Ostream&,
333  );
334 };
335 
336 
337 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
338 
339 } // End namespace Foam
340 
341 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
342 
343 #include "DSMCParcelI.H"
344 
345 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
346 
347 #ifdef NoRepository
348  #include "DSMCParcel.C"
349 #endif
350 
351 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
352 
353 #endif
354 
355 // ************************************************************************* //
TypeName("DSMCParcel")
Runtime type information.
dictionary dict
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
A list of keyword definitions, which are a keyword followed by any number of values (e...
Definition: dictionary.H:137
void hitWallPatch(const wallPolyPatch &, TrackData &td, const tetIndices &)
Overridable function to handle the particle hitting a wallPatch.
Definition: DSMCParcel.C:107
uint8_t direction
Definition: direction.H:45
An Istream is an abstract base class for all input systems (streams, files, token lists etc)...
Definition: Istream.H:57
bool move(TrackData &td, const scalar trackTime)
Move the parcel.
Definition: DSMCParcel.C:33
label typeId_
Parcel type id.
Definition: DSMCParcel.H:163
Template function to specify if the data of a type are contiguous.
DSMC parcel class.
Definition: DSMCParcel.H:51
Class used to pass kinematic tracking data to the trackToFace function.
Definition: DSMCParcel.H:130
void hitProcessorPatch(const processorPolyPatch &, TrackData &td)
Overridable function to handle the particle hitting a.
Definition: DSMCParcel.C:95
bool hitPatch(const polyPatch &, TrackData &td, const label patchi, const scalar trackFraction, const tetIndices &tetIs)
Overridable function to handle the particle hitting a patch.
Definition: DSMCParcel.C:80
virtual autoPtr< particle > clone() const
Construct and return a clone.
Definition: DSMCParcel.H:210
Base particle class.
Definition: particle.H:81
scalar sigmaT() const
Return the reference total collision cross section.
Definition: DSMCParcelI.H:111
Neighbour processor patch.
static void readFields(Cloud< DSMCParcel< ParcelType >> &c)
Definition: DSMCParcelIO.C:79
static void writeFields(const Cloud< DSMCParcel< ParcelType >> &c)
Definition: DSMCParcelIO.C:113
constantProperties()
Null constructor, allows List of constantProperties to be.
Definition: DSMCParcelI.H:31
scalar omega() const
Return the viscosity index.
Definition: DSMCParcelI.H:128
dynamicFvMesh & mesh
Class to hold DSMC particle constant properties.
Definition: DSMCParcel.H:80
Factory class to read-construct particles used for.
Definition: DSMCParcel.H:217
A cloud is a collection of lagrangian particles.
Definition: cloud.H:51
direction internalDegreesOfFreedom() const
Return the internalDegreesOfFreedom.
Definition: DSMCParcelI.H:119
Foam::wallPolyPatch.
Definition: wallPolyPatch.H:48
scalar mass() const
Return const access to the particle mass [kg].
Definition: DSMCParcelI.H:96
Storage and named access for the indices of a tet which is part of the decomposition of a cell...
Definition: tetIndices.H:81
Base cloud calls templated on particle type.
Definition: Cloud.H:52
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:53
scalar d() const
Return const access to the hard sphere diameter [m].
Definition: DSMCParcelI.H:103
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
virtual void transformProperties(const tensor &T)
Transform the physical properties of the particle.
Definition: DSMCParcel.C:206
label patchi
PtrList< coordinateSystem > coordinates(solidRegions.size())
const dimensionedScalar c
Speed of light in a vacuum.
scalar Ei_
Internal energy of the Parcel, covering all non-translational.
Definition: DSMCParcel.H:160
scalar Ei() const
Return const access to internal energy.
Definition: DSMCParcelI.H:151
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:52
Mesh consisting of general polyhedral cells.
Definition: polyMesh.H:74
vector U_
Velocity of Parcel [m/s].
Definition: DSMCParcel.H:156
A patch is a list of labels that address the faces in the global face list.
Definition: polyPatch.H:66
label typeId() const
Return type id.
Definition: DSMCParcelI.H:137
Templated base class for dsmc cloud.
Definition: DSMCCloud.H:69
DSMCParcel(const polyMesh &mesh, const barycentric &coordinates, const label celli, const label tetFacei, const label tetPti, const vector &U, const scalar Ei, const label typeId)
Construct from components.
Definition: DSMCParcelI.H:56
Namespace for OpenFOAM.
const vector & U() const
Return const access to velocity.
Definition: DSMCParcelI.H:144