ASL  0.1.7
Advanced Simulation Library
aslLBGKBC.h
Go to the documentation of this file.
1 /*
2  * Advanced Simulation Library <http://asl.org.il>
3  *
4  * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5  *
6  *
7  * This file is part of Advanced Simulation Library (ASL).
8  *
9  * ASL is free software: you can redistribute it and/or modify it
10  * under the terms of the GNU Affero General Public License as
11  * published by the Free Software Foundation, version 3 of the License.
12  *
13  * ASL is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU Affero General Public License for more details.
17  *
18  * You should have received a copy of the GNU Affero General Public License
19  * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22 
23 
24 #ifndef ASLLBGKBC_H
25 #define ASLLBGKBC_H
26 
27 #include "aslBCond.h"
28 #include "acl/aclMath/aclVectorOfElementsDef.h"
29 
30 namespace acl{
31  class Kernel;
33  class KernelMerger;
35 }
36 
37 namespace asl
38 {
39  class LBGK;
41  class PositionFunction;
43 
44 
45  class BCLBGKCommon:public BCond
46  {
47  protected:
48  SPLBGK num;
49  std::vector<acl::SPKernel> kernels;
51 
52  AVec<int> directionGroupsShifts;
53  AVec<int> directionGroupsSizes;
54 
55  void sortDirections();
56  public:
57  BCLBGKCommon(SPLBGK nm);
58  virtual void execute();
59  };
60 
62 
67  class BCNoSlip: public BCLBGKCommon
68  {
69  public:
70  BCNoSlip(SPLBGK nm);
71  virtual void init();
72  };
73 
75 
79  class BCConstantPressure: public BCLBGKCommon
80  {
81  protected:
82  acl::VectorOfElements pressure;
83  public:
84  BCConstantPressure(SPLBGK nm, const acl::VectorOfElements & p);
85  virtual void init();
86  };
87 
89 
99  class BCConstantVelocity: public BCLBGKCommon
100  {
101  protected:
102  acl::VectorOfElements velocity;
103  public:
104  BCConstantVelocity(SPLBGK nm, const acl::VectorOfElements & v);
105  virtual void init();
106  };
107 
109 
116  class BCConstantPressureVelocity: public BCLBGKCommon
117  {
118  protected:
119  acl::VectorOfElements pressure;
120  acl::VectorOfElements velocity;
121  public:
122  BCConstantPressureVelocity(SPLBGK nm,
123  const acl::VectorOfElements & p,
124  const acl::VectorOfElements & v);
125  virtual void init();
126  };
127 
129 
133  class BCNoSlipMap:public BCondWithMap
134  {
135  protected:
136  std::unique_ptr<acl::Kernel> kernel;
137  SPLBGK num;
138  public:
139  BCNoSlipMap(SPLBGK nm, SPAbstractDataWithGhostNodes map);
140  ~BCNoSlipMap();
141  virtual void execute();
142  virtual void init();
143  };
144 
146 
149  class BCVelocityMap:public BCondWithMap
150  {
151  protected:
152  std::unique_ptr<acl::Kernel> kernel;
153  SPLBGK num;
154  SPPositionFunction velocity;
155 
156  public:
157  BCVelocityMap(SPLBGK nm,
158  SPPositionFunction v,
160  BCVelocityMap(SPLBGK nm,
161  SPPositionFunction v,
163  SPAbstractDataWithGhostNodes computationalDomain);
164  ~BCVelocityMap();
165  virtual void execute();
166  virtual void init();
167  };
168 
172  class BCConstantPressureVelocityMap:public BCondWithMap
173  {
174  protected:
175  std::unique_ptr<acl::Kernel> kernel;
176  SPLBGK num;
177  acl::VectorOfElements pressure;
178  acl::VectorOfElements velocity;
179  public:
180  BCConstantPressureVelocityMap(SPLBGK nm,
183  BCConstantPressureVelocityMap(SPLBGK nm,
187  ~BCConstantPressureVelocityMap();
188  virtual void execute();
189  virtual void init();
190  };
191 
193 
200  class BCTransportLimitedDepositionMap:public BCondWithMap
201  {
202  protected:
203  std::unique_ptr<acl::Kernel> kernel;
204  SPLBGK num;
206  acl::VectorOfElements limitingFactor;
207  public:
208  BCTransportLimitedDepositionMap(SPLBGK nm,
212  ~BCTransportLimitedDepositionMap();
213  virtual void execute();
214  virtual void init();
215  };
216 
218 
224  class BCKineticsLimitedDepositionMap:public BCondWithMap
225  {
226  protected:
227  std::unique_ptr<acl::Kernel> kernel;
228  SPLBGK num;
230  acl::VectorOfElements limitingFactor;
232  public:
233  BCKineticsLimitedDepositionMap(SPLBGK nm,
238  ~BCKineticsLimitedDepositionMap();
239  virtual void execute();
240  virtual void init();
241  };
242 
247  class ComputeSurfaceFluxMap:public BCondWithMap
248  {
249  protected:
250  std::unique_ptr<acl::Kernel> kernel;
251  SPLBGK num;
252  SPDataWithGhostNodesACLData fluxField;
253  public:
254  ComputeSurfaceFluxMap(SPLBGK nm,
257  ~ComputeSurfaceFluxMap();
258  virtual void execute();
259  virtual void init();
260  };
261 
265  class ComputeSurfaceForceMap:public BCondWithMap
266  {
267  protected:
268  std::unique_ptr<acl::Kernel> kernel;
269  SPLBGK num;
270  SPDataWithGhostNodesACLData forceField;
271  public:
272  ComputeSurfaceForceMap(SPLBGK nm,
275  ~ComputeSurfaceForceMap();
276  virtual void execute();
277  virtual void init();
278  };
279 
281  SPBCond generateBCNoSlip(SPLBGK nm, const std::vector<SlicesNames> & sl);
283  SPBCond generateBCConstantVelocity(SPLBGK nm, AVec<> v, const std::vector<SlicesNames> & sl);
285  SPBCond generateBCConstantPressure(SPLBGK nm, double p, const std::vector<SlicesNames> & sl);
288  double p,
289  AVec<> v,
290  const std::vector<SlicesNames> & sl);
295  double p,
296  AVec<> v,
305  SPNumMethod generateBCVelocity(SPLBGK nm,
306  SPPositionFunction v,
309  SPNumMethod generateBCVelocity(SPLBGK nm,
310  SPPositionFunction v,
312  SPAbstractDataWithGhostNodes computationalDomain);
315  SPPositionFunction v,
319  double p0,
320  double limitingFactor,
324  double beta,
325  double p0,
326  double limitingFactor,
332 
337 
338 } //asl
339 
340 #endif //ASLBGKBC_H
std::shared_ptr< PositionFunction > SPPositionFunction
Advanced Simulation Library.
Definition: aslDataInc.h:30
Advanced Computational Language.
Definition: acl.h:40
std::shared_ptr< Kernel > SPKernel
std::shared_ptr< NumMethod > SPNumMethod
Definition: aslNumMethod.h:44
std::shared_ptr< DataWithGhostNodesACLData > SPDataWithGhostNodesACLData
Definition: aslGenerators.h:47
std::shared_ptr< BCond > SPBCond
Definition: aslBCond.h:88
SPNumMethod generateBCKineticsLimitedDeposition(SPLBGK nm, double beta, double p0, double limitingFactor, SPAbstractDataWithGhostNodes map)
SPNumMethod generateBCConstantPressure(SPLBGK nm, double p, SPAbstractDataWithGhostNodes map)
SPNumMethod generateBCNoSlipRho(SPLBGK nmU, SPAbstractDataWithGhostNodes map)
SPNumMethod generateComputeSurfaceFlux(SPLBGK nm, SPDataWithGhostNodesACLData fF, SPAbstractDataWithGhostNodes map)
SPNumMethod generateBCConstantPressureVelocity(SPLBGK nm, double p, AVec<> v, SPAbstractDataWithGhostNodes map)
std::shared_ptr< LBGK > SPLBGK
Definition: aslLBGK.h:133
SPBCond generateBCConstantVelocity(SPLBGK nm, AVec<> v, const std::vector< SlicesNames > &sl)
SPNumMethod generateBCNoSlip(SPLBGK nm, SPAbstractDataWithGhostNodes map)
SPNumMethod generateBCVelocity(SPLBGK nm, SPPositionFunction v, SPAbstractDataWithGhostNodes map, SPAbstractDataWithGhostNodes computationalDomain)
The class represents several Element.
SPNumMethod generateBCVelocityVel(SPLBGK nm, SPPositionFunction v, SPAbstractDataWithGhostNodes map)
std::shared_ptr< T > map(ElementData m)
Definition: aclMemBlock.h:68
std::shared_ptr< acl::KernelMerger > SPKernelMerger
Definition: aslLBGKBC.h:33
SPNumMethod generateComputeSurfaceForce(SPLBGK nm, SPDataWithGhostNodesACLData fF, SPAbstractDataWithGhostNodes map)
SPNumMethod generateBCTransportLimitedDeposition(SPLBGK nm, double p0, double limitingFactor, SPAbstractDataWithGhostNodes map)
std::shared_ptr< AbstractDataWithGhostNodes > SPAbstractDataWithGhostNodes
Definition: aslGenerators.h:50
SPNumMethod generateBCNoSlipVel(SPLBGK nmU, SPAbstractDataWithGhostNodes map)
for velocity field