www.cemf.ir
rotatingAxisI.hpp
Go to the documentation of this file.
1 #include "rotatingAxis.hpp"
2 /*------------------------------- phasicFlow ---------------------------------
3  O C enter of
4  O O E ngineering and
5  O O M ultiscale modeling of
6  OOOOOOO F luid flow
7 ------------------------------------------------------------------------------
8  Copyright (C): www.cemf.ir
9  email: hamid.r.norouzi AT gmail.com
10 ------------------------------------------------------------------------------
11 Licence:
12  This file is part of phasicFlow code. It is a free software for simulating
13  granular and multiphase flows. You can redistribute it and/or modify it under
14  the terms of GNU General Public License v3 or any other later versions.
15 
16  phasicFlow is distributed to help others in their research in the field of
17  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
18  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19 
20 -----------------------------------------------------------------------------*/
21 
22 INLINE_FUNCTION_HD
23 pFlow::realx3 pFlow::rotatingAxis::linVelocityPoint(const realx3 &p)const
24 {
25 
26  if(!inTimeRange()) return {0,0,0};
27 
28  realx3 L = p - projectPoint(p);
29  return cross(omega_*unitVector(),L);
30 }
31 
32 INLINE_FUNCTION_HD
33 pFlow::realx3 pFlow::rotatingAxis::transferPoint(const realx3 p, real dt)const
34 {
35  return rotate(p, *this, dt);
36 }
37 
38 INLINE_FUNCTION_HD
39 pFlow::realx3 pFlow::rotate(const realx3& p, const rotatingAxis& ax, real dt)
40 {
41 
42  if(!ax.inTimeRange()) return p;
43 
44  realx3 nv = ax.unitVector();
45  real cos_tet = cos(ax.omega()*dt);
46  real sin_tet = sin(ax.omega()*dt);
47  real u2 = nv.x()*nv.x();
48  real v2 = nv.y()*nv.y();
49  real w2 = nv.z()*nv.z();
50  realx3 lp1 = ax.point1();
51 
52  // (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet
53  realx3 res;
54 
55  res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
56  p.x_ * cos_tet +
57  (-lp1.z_*nv.y_ + lp1.y_*nv.z_ - nv.z_*p.y_ + nv.y_*p.z_) * sin_tet;
58 
59 
60  // ( b(u2+w2) - v( au + cw - ux - vy - wz))(1-cos_tet) + y cos_tet + ( cu - aw + wx - uz ) sin_tet
61  res.y_ = (lp1.y_*(u2 + w2) - (nv.y_*(lp1.x_*nv.x_ + lp1.z_*nv.z_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
62  p.y_ * cos_tet +
63  (lp1.z_*nv.x_ - lp1.x_*nv.z_ + nv.z_*p.x_ - nv.x_*p.z_) * sin_tet;
64 
65  // (c(u2+v2) - w( au + bv - ux - vy - wz ))(1-cos_tet) + z cos_tet + (-bu + av - vx + uy) sin_tet
66  res.z_ = (lp1.z_*(u2 + v2) - (nv.z_*(lp1.x_*nv.x_ + lp1.y_*nv.y_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
67  p.z_ * cos_tet +
68  (-lp1.y_*nv.x_ + lp1.x_*nv.y_ - nv.y_*p.x_ + nv.x_*p.y_) * sin_tet;
69 
70  return res;
71 }
72 
73 INLINE_FUNCTION_HD
74 pFlow::realx3 pFlow::rotate(const realx3 &p, const line& ln, real theta)
75 {
76 
77  realx3 nv = ln.unitVector();
78  real cos_tet = cos(theta);
79  real sin_tet = sin(theta);
80  real u2 = nv.x()*nv.x();
81  real v2 = nv.y()*nv.y();
82  real w2 = nv.z()*nv.z();
83  realx3 lp1 = ln.point1();
84 
85  // (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet
86  realx3 res;
87 
88  res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
89  p.x_ * cos_tet +
90  (-lp1.z_*nv.y_ + lp1.y_*nv.z_ - nv.z_*p.y_ + nv.y_*p.z_) * sin_tet;
91 
92 
93  // ( b(u2+w2) - v( au + cw - ux - vy - wz))(1-cos_tet) + y cos_tet + ( cu - aw + wx - uz ) sin_tet
94  res.y_ = (lp1.y_*(u2 + w2) - (nv.y_*(lp1.x_*nv.x_ + lp1.z_*nv.z_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
95  p.y_ * cos_tet +
96  (lp1.z_*nv.x_ - lp1.x_*nv.z_ + nv.z_*p.x_ - nv.x_*p.z_) * sin_tet;
97 
98  // (c(u2+v2) - w( au + bv - ux - vy - wz ))(1-cos_tet) + z cos_tet + (-bu + av - vx + uy) sin_tet
99  res.z_ = (lp1.z_*(u2 + v2) - (nv.z_*(lp1.x_*nv.x_ + lp1.y_*nv.y_ - nv.x_*p.x_ - nv.y_*p.y_ - nv.z_*p.z_)))*(1 - cos_tet) +
100  p.z_ * cos_tet +
101  (-lp1.y_*nv.x_ + lp1.x_*nv.y_ - nv.y_*p.x_ + nv.x_*p.y_) * sin_tet;
102 
103  return res;
104 }
105 
106 INLINE_FUNCTION_HD
107 void pFlow::rotate(realx3* p, uint32 n, const line& ln, real theta)
108 {
109  realx3 nv = ln.unitVector();
110  real cos_tet = cos(theta);
111  real sin_tet = sin(theta);
112  real u2 = nv.x()*nv.x();
113  real v2 = nv.y()*nv.y();
114  real w2 = nv.z()*nv.z();
115  realx3 lp1 = ln.point1();
116 
117  // (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet
118  realx3 res;
119 
120  for(uint32 i=0; i<n; i++ )
121  {
122  res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
123  p[i].x_ * cos_tet +
124  (-lp1.z_*nv.y_ + lp1.y_*nv.z_ - nv.z_*p[i].y_ + nv.y_*p[i].z_) * sin_tet;
125 
126 
127  // ( b(u2+w2) - v( au + cw - ux - vy - wz))(1-cos_tet) + y cos_tet + ( cu - aw + wx - uz ) sin_tet
128  res.y_ = (lp1.y_*(u2 + w2) - (nv.y_*(lp1.x_*nv.x_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
129  p[i].y_ * cos_tet +
130  (lp1.z_*nv.x_ - lp1.x_*nv.z_ + nv.z_*p[i].x_ - nv.x_*p[i].z_) * sin_tet;
131 
132  // (c(u2+v2) - w( au + bv - ux - vy - wz ))(1-cos_tet) + z cos_tet + (-bu + av - vx + uy) sin_tet
133  res.z_ = (lp1.z_*(u2 + v2) - (nv.z_*(lp1.x_*nv.x_ + lp1.y_*nv.y_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
134  p[i].z_ * cos_tet +
135  (-lp1.y_*nv.x_ + lp1.x_*nv.y_ - nv.y_*p[i].x_ + nv.x_*p[i].y_) * sin_tet;
136 
137  p[i] = res;
138  }
139 
140 }
141 
142 INLINE_FUNCTION_HD
143 void pFlow::rotate(realx3* p, uint32 n, const rotatingAxis& ax, real dt)
144 {
145  if(!ax.inTimeRange()) return;
146 
147  realx3 nv = ax.unitVector();
148  real cos_tet = cos(ax.omega()*dt);
149  real sin_tet = sin(ax.omega()*dt);
150  real u2 = nv.x()*nv.x();
151  real v2 = nv.y()*nv.y();
152  real w2 = nv.z()*nv.z();
153  realx3 lp1 = ax.point1();
154 
155  // (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet
156  realx3 res;
157 
158  for(uint32 i=0; i<n; i++ )
159  {
160  res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
161  p[i].x_ * cos_tet +
162  (-lp1.z_*nv.y_ + lp1.y_*nv.z_ - nv.z_*p[i].y_ + nv.y_*p[i].z_) * sin_tet;
163 
164 
165  // ( b(u2+w2) - v( au + cw - ux - vy - wz))(1-cos_tet) + y cos_tet + ( cu - aw + wx - uz ) sin_tet
166  res.y_ = (lp1.y_*(u2 + w2) - (nv.y_*(lp1.x_*nv.x_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
167  p[i].y_ * cos_tet +
168  (lp1.z_*nv.x_ - lp1.x_*nv.z_ + nv.z_*p[i].x_ - nv.x_*p[i].z_) * sin_tet;
169 
170  // (c(u2+v2) - w( au + bv - ux - vy - wz ))(1-cos_tet) + z cos_tet + (-bu + av - vx + uy) sin_tet
171  res.z_ = (lp1.z_*(u2 + v2) - (nv.z_*(lp1.x_*nv.x_ + lp1.y_*nv.y_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
172  p[i].z_ * cos_tet +
173  (-lp1.y_*nv.x_ + lp1.x_*nv.y_ - nv.y_*p[i].x_ + nv.x_*p[i].y_) * sin_tet;
174 
175  p[i] = res;
176  }
177 
178 }
pFlow::real
float real
Definition: builtinTypes.hpp:45
pFlow::line
Definition: line.hpp:36
pFlow::cos
Vector< T, Allocator > cos(const Vector< T, Allocator > &v)
Definition: VectorMath.hpp:93
pFlow::uint32
unsigned int uint32
Definition: builtinTypes.hpp:56
rotatingAxis.hpp
pFlow::triple::y
INLINE_FUNCTION_HD T & y()
access component
Definition: triple.hpp:144
cross
INLINE_FUNCTION_HD triple< T > cross(const triple< T > &v1, const triple< T > &v2)
pFlow::line::projectPoint
INLINE_FUNCTION_HD realx3 projectPoint(const realx3 &p) const
Definition: line.hpp:114
pFlow::rotatingAxis::omega_
real omega_
rotation speed
Definition: rotatingAxis.hpp:69
pFlow::rotatingAxis
An axis which rotates around itself at specified speed.
Definition: rotatingAxis.hpp:61
pFlow::rotatingAxis::linVelocityPoint
INLINE_FUNCTION_HD realx3 linVelocityPoint(const realx3 &p) const
Linear tangential velocity at point p.
Definition: rotatingAxisI.hpp:23
pFlow::rotatingAxis::transferPoint
INLINE_FUNCTION_HD realx3 transferPoint(const realx3 p, real dt) const
Definition: rotatingAxisI.hpp:33
pFlow::timeInterval::inTimeRange
INLINE_FUNCTION_HD bool inTimeRange(real t) const
Definition: timeInterval.hpp:70
pFlow::timeInterval::inTimeRange
INLINE_FUNCTION_HD bool inTimeRange() const
Definition: timeInterval.hpp:76
pFlow::rotatingAxis::omega
INLINE_FUNCTION_HD real omega() const
Return omega.
Definition: rotatingAxis.hpp:115
pFlow::triple::x_
T x_
data members
Definition: triple.hpp:49
pFlow::triple::z
INLINE_FUNCTION_HD T & z()
access component
Definition: triple.hpp:156
pFlow::triple::y_
T y_
Definition: triple.hpp:50
pFlow::triple::z_
T z_
Definition: triple.hpp:51
n
uint32 n
Definition: NBSLoop.hpp:24
pFlow::sin
Vector< T, Allocator > sin(const Vector< T, Allocator > &v)
Definition: VectorMath.hpp:92
pFlow::line::point1
INLINE_FUNCTION_HD realx3 point1() const
Definition: line.hpp:94
pFlow::triple::x
INLINE_FUNCTION_HD T & x()
access component
Definition: triple.hpp:132
INLINE_FUNCTION_HD
#define INLINE_FUNCTION_HD
Definition: pFlowMacros.hpp:55
pFlow::line::unitVector
INLINE_FUNCTION_HD realx3 unitVector() const
Definition: line.hpp:110
pFlow::triple< real >
pFlow::rotate
INLINE_FUNCTION_HD realx3 rotate(const realx3 &p, const line &ln, real theta)
Definition: rotatingAxisI.hpp:74