v0.14.0
Public Member Functions | Static Public Member Functions | Static Private Member Functions | Static Private Attributes | List of all members
LieGroups::SO3 Struct Reference

#include <src/interfaces/Lie.hpp>

Collaboration diagram for LieGroups::SO3:
[legend]

Public Member Functions

 SO3 ()=delete
 
 ~SO3 ()=delete
 

Static Public Member Functions

template<typename T >
static auto getVee (T &&w1, T &&w2, T &&w3)
 
template<typename T >
static auto getHat (T &&w1, T &&w2, T &&w3)
 
template<typename A >
static auto getVee (A &&t_w_hat)
 
template<typename A >
static auto getHat (A &&t_w_vee)
 
template<typename A , typename B >
static auto exp (A &&t_w_vee, B &&theta)
 
template<typename A , typename B >
static auto Jl (A &&t_w_vee, B &&theta)
 
template<typename A , typename B >
static auto Jr (A &&t_w_vee, B &&theta)
 
template<typename A , typename B , typename C >
static auto action (A &&t_w_vee, B &&theta, C &&t_A)
 
template<typename A , typename B >
static auto dActionJl (A &&t_w_vee, B &&t_A)
 
template<typename A , typename B >
static auto dActionJr (A &&t_w_vee, B &&t_A)
 
template<typename A , typename B >
static auto diffExp (A &&t_w_vee, B &&theta)
 

Static Private Member Functions

static FTENSOR_INDEX (dim, i)
 
static FTENSOR_INDEX (dim, j)
 
static FTENSOR_INDEX (dim, k)
 
static FTENSOR_INDEX (dim, l)
 
static FTENSOR_INDEX (dim, m)
 
static FTENSOR_INDEX (dim, n)
 
template<typename T >
static auto getVeeImpl (FTensor::Tensor2< T, dim, dim > &t_w_hat)
 
template<typename T >
static auto getHatImpl (FTensor::Tensor1< T, dim > &t_w_vee)
 
template<typename T1 , typename T2 , typename T3 >
static auto genericFormImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 alpha, const T3 beta)
 
template<typename T1 , typename T2 >
static auto expImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
 
template<typename T1 , typename T2 >
static auto diffExpImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
 
template<typename T1 , typename T2 >
static auto JlImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 &theta)
 
template<typename T1 , typename T2 >
static auto JrImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
 
template<typename T1 , typename T2 , typename T3 >
static auto actionImpl (FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta, FTensor::Tensor2_symmetric< T3, dim > &t_A)
 

Static Private Attributes

static constexpr int dim = 3
 

Detailed Description

Definition at line 23 of file Lie.hpp.

Constructor & Destructor Documentation

◆ SO3()

LieGroups::SO3::SO3 ( )
delete

◆ ~SO3()

LieGroups::SO3::~SO3 ( )
delete

Member Function Documentation

◆ action()

template<typename A , typename B , typename C >
static auto LieGroups::SO3::action ( A &&  t_w_vee,
B &&  theta,
C &&  t_A 
)
inlinestatic

Definition at line 64 of file Lie.hpp.

64  {
65  return actionImpl(std::forward<A>(t_w_vee), std::forward<B>(theta),
66  std::forward<C>(t_A));
67  }

◆ actionImpl()

template<typename T1 , typename T2 , typename T3 >
static auto LieGroups::SO3::actionImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2  theta,
FTensor::Tensor2_symmetric< T3, dim > &  t_A 
)
inlinestaticprivate

Definition at line 213 of file Lie.hpp.

215  {
216  using D = typename TensorTypeExtractor<T3>::Type;
217  FTensor::Tensor2<D, dim, dim> t_B;
218  t_B(i, j) = exp(t_w_vee, theta)(i,k) * t_A(k, j);
219  return t_B;
220  }

◆ dActionJl()

template<typename A , typename B >
static auto LieGroups::SO3::dActionJl ( A &&  t_w_vee,
B &&  t_A 
)
inlinestatic

Definition at line 70 of file Lie.hpp.

70  {
71  return dActionJlImpl(std::forward<A>(t_w_vee), std::forward<B>(t_A));
72  }

◆ dActionJr()

template<typename A , typename B >
static auto LieGroups::SO3::dActionJr ( A &&  t_w_vee,
B &&  t_A 
)
inlinestatic

Definition at line 75 of file Lie.hpp.

75  {
76  return dActionJrImpl(std::forward<A>(t_w_vee), std::forward<B>(t_A));
77  }

◆ diffExp()

template<typename A , typename B >
static auto LieGroups::SO3::diffExp ( A &&  t_w_vee,
B &&  theta 
)
inlinestatic
Examples
EshelbianOperators.cpp.

Definition at line 80 of file Lie.hpp.

80  {
81  return diffExpImpl(std::forward<A>(t_w_vee), std::forward<B>(theta));
82  }

◆ diffExpImpl()

template<typename T1 , typename T2 >
static auto LieGroups::SO3::diffExpImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2  theta 
)
inlinestaticprivate

Definition at line 134 of file Lie.hpp.

135  {
136 
137  auto get_tensor = [&t_w_vee](auto a, auto diff_a, auto b, auto diff_b) {
138  FTENSOR_INDEX(3, i);
139  FTENSOR_INDEX(3, j);
140  FTENSOR_INDEX(3, k);
141  FTENSOR_INDEX(3, l);
142 
143  using D = typename TensorTypeExtractor<T1>::Type;
144  FTensor::Tensor3<D, 3, 3, 3> t_diff_exp;
145  auto t_hat = getHat(t_w_vee);
146  t_diff_exp(i, j, k) =
147 
148  a * FTensor::levi_civita<int>(i, j, k)
149 
150  +
151 
152  diff_a * t_hat(i, j) * t_w_vee(k)
153 
154  +
155 
156  b * (t_hat(i, l) * FTensor::levi_civita<int>(l, j, k) +
157  FTensor::levi_civita<int>(i, l, k) * t_hat(l, j))
158 
159  +
160 
161  diff_b * t_hat(i, l) * t_hat(l, j) * t_w_vee(k);
162 
163  return t_diff_exp;
164  };
165 
166  if(std::fabs(theta) < std::numeric_limits<T2>::epsilon()){
167  return get_tensor(1., -1. / 3., 0., 1. / 1.2);
168  }
169 
170  const auto ss = sin(theta);
171  const auto a = ss / theta;
172 
173  const auto theta2 = theta * theta;
174  const auto cc = cos(theta);
175  const auto diff_a = (theta * cc - ss) / (theta2 * theta);
176 
177  const auto ss_2 = sin(theta / 2.);
178  const auto cc_2 = cos(theta / 2.);
179  const auto b = 2. * ss_2 * ss_2 / theta2;
180  const auto diff_b =
181  (2. * theta * ss_2 * cc_2 - 4. * ss_2 * ss_2) / (theta2 * theta2);
182 
183  return get_tensor(a, diff_a, b, diff_b);
184  }

◆ exp()

template<typename A , typename B >
static auto LieGroups::SO3::exp ( A &&  t_w_vee,
B &&  theta 
)
inlinestatic
Examples
EshelbianOperators.cpp, and EshelbianPlasticity.cpp.

Definition at line 49 of file Lie.hpp.

49  {
50  return expImpl(std::forward<A>(t_w_vee), std::forward<B>(theta));
51  }

◆ expImpl()

template<typename T1 , typename T2 >
static auto LieGroups::SO3::expImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2  theta 
)
inlinestaticprivate

Definition at line 121 of file Lie.hpp.

122  {
123  if (std::fabs(theta) < std::numeric_limits<T2>::epsilon()) {
124  return genericFormImpl(t_w_vee, 1, 0.5);
125  }
126  const auto s = sin(theta);
127  const auto s_half = sin(theta / 2);
128  const auto a = s / theta;
129  const auto b = 2 * (s_half / theta) * (s_half / theta);
130  return genericFormImpl(t_w_vee, a, b);
131  }

◆ FTENSOR_INDEX() [1/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
i   
)
inlinestaticprivate

◆ FTENSOR_INDEX() [2/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
j   
)
inlinestaticprivate

◆ FTENSOR_INDEX() [3/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
k   
)
inlinestaticprivate

◆ FTENSOR_INDEX() [4/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
l   
)
inlinestaticprivate

◆ FTENSOR_INDEX() [5/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
m   
)
inlinestaticprivate

◆ FTENSOR_INDEX() [6/6]

static LieGroups::SO3::FTENSOR_INDEX ( dim  ,
n   
)
inlinestaticprivate

◆ genericFormImpl()

template<typename T1 , typename T2 , typename T3 >
static auto LieGroups::SO3::genericFormImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2  alpha,
const T3  beta 
)
inlinestaticprivate

Definition at line 110 of file Lie.hpp.

111  {
112  using D = typename TensorTypeExtractor<T1>::Type;
113  FTensor::Tensor2<D, dim, dim> t_X;
114  auto t_hat = getHat(t_w_vee);
115  t_X(i, j) = FTensor::Kronecker_Delta<int>()(i, j) + alpha * t_hat(i, j) +
116  beta * (t_hat(i, k) * t_hat(k, j));
117  return t_X;
118  }

◆ getHat() [1/2]

template<typename A >
static auto LieGroups::SO3::getHat ( A &&  t_w_vee)
inlinestatic

Definition at line 44 of file Lie.hpp.

44  {
45  return getHatImpl(std::forward<A>(t_w_vee));
46  }

◆ getHat() [2/2]

template<typename T >
static auto LieGroups::SO3::getHat ( T &&  w1,
T &&  w2,
T &&  w3 
)
inlinestatic

Definition at line 36 of file Lie.hpp.

36  {
37  return getHatImpl(std::forward<A>(getVee(w1, w2, w3)));
38  }

◆ getHatImpl()

template<typename T >
static auto LieGroups::SO3::getHatImpl ( FTensor::Tensor1< T, dim > &  t_w_vee)
inlinestaticprivate

Definition at line 102 of file Lie.hpp.

102  {
103  using D = typename TensorTypeExtractor<T>::Type;
104  FTensor::Tensor2<D, dim, dim> t_w_hat;
105  t_w_hat(i, j) = levi_civita(i, j, k) * t_w_vee(k);
106  return t_w_hat;
107  }

◆ getVee() [1/2]

template<typename A >
static auto LieGroups::SO3::getVee ( A &&  t_w_hat)
inlinestatic

Definition at line 40 of file Lie.hpp.

40  {
41  return getVeeImpl(std::forward<A>(t_w_hat));
42  }

◆ getVee() [2/2]

template<typename T >
static auto LieGroups::SO3::getVee ( T &&  w1,
T &&  w2,
T &&  w3 
)
inlinestatic

Definition at line 28 of file Lie.hpp.

28  {
29  return FTensor::Tensor1<T, dim>(
30 
31  std::forward<T>(w1), std::forward<T>(w2), std::forward<T>(w3)
32 
33  );
34  }

◆ getVeeImpl()

template<typename T >
static auto LieGroups::SO3::getVeeImpl ( FTensor::Tensor2< T, dim, dim > &  t_w_hat)
inlinestaticprivate

Definition at line 94 of file Lie.hpp.

94  {
95  using D = typename TensorTypeExtractor<T>::Type;
96  FTensor::Tensor1<D, dim> t_w_vee;
97  t_w_vee(k) = (levi_civita(i, j, k) * t_w_hat(i, j)) / 2;
98  return t_w_vee;
99  }

◆ Jl()

template<typename A , typename B >
static auto LieGroups::SO3::Jl ( A &&  t_w_vee,
B &&  theta 
)
inlinestatic

Definition at line 54 of file Lie.hpp.

54  {
55  return JlImpl(std::forward<A>(t_w_vee), std::forward<B>(theta));
56  }

◆ JlImpl()

template<typename T1 , typename T2 >
static auto LieGroups::SO3::JlImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2 &  theta 
)
inlinestaticprivate

Definition at line 187 of file Lie.hpp.

188  {
189  if (std::fabs(theta) < std::numeric_limits<T2>::epsilon()) {
190  return genericFormImpl(t_w_vee, 0.5, 1. / 6.);
191  }
192  const auto s = sin(theta);
193  const auto s_half = sin(theta / 2);
194  const auto a = 2 * (s_half / theta) * (s_half / theta);
195  const auto b = ((theta - s) / theta) / theta / theta;
196  return genericFormImpl(t_w_vee, a, b);
197  }

◆ Jr()

template<typename A , typename B >
static auto LieGroups::SO3::Jr ( A &&  t_w_vee,
B &&  theta 
)
inlinestatic

Definition at line 59 of file Lie.hpp.

59  {
60  return JrImpl(std::forward<A>(t_w_vee), std::forward<B>(theta));
61  }

◆ JrImpl()

template<typename T1 , typename T2 >
static auto LieGroups::SO3::JrImpl ( FTensor::Tensor1< T1, dim > &  t_w_vee,
const T2  theta 
)
inlinestaticprivate

Definition at line 200 of file Lie.hpp.

201  {
202  if (std::fabs(theta) < std::numeric_limits<T2>::epsilon()) {
203  return genericFormImpl(t_w_vee, -0.5, 1. / 6.);
204  }
205  const auto s = sin(theta);
206  const auto s_half = sin(theta / 2);
207  const auto a = 2 * (s_half / theta) * (s_half / theta);
208  const auto b = ((theta - s) / theta) / theta / theta;
209  return genericFormImpl(t_w_vee, -a, b);
210  }

Member Data Documentation

◆ dim

constexpr int LieGroups::SO3::dim = 3
inlinestaticconstexprprivate

Definition at line 85 of file Lie.hpp.

The documentation for this struct was generated from the following file:
LieGroups::SO3::actionImpl
static auto actionImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta, FTensor::Tensor2_symmetric< T3, dim > &t_A)
Definition: Lie.hpp:213
FTensor::Tensor1
Definition: Tensor1_value.hpp:8
LieGroups::SO3::getVeeImpl
static auto getVeeImpl(FTensor::Tensor2< T, dim, dim > &t_w_hat)
Definition: Lie.hpp:94
FTensor::Kronecker_Delta
Kronecker Delta class.
Definition: Kronecker_Delta.hpp:15
LieGroups::SO3::getHat
static auto getHat(T &&w1, T &&w2, T &&w3)
Definition: Lie.hpp:36
FTensor::levi_civita
constexpr std::enable_if<(Dim0<=2 &&Dim1<=2), Tensor2_Expr< Levi_Civita< T >, T, Dim0, Dim1, i, j > >::type levi_civita(const Index< i, Dim0 > &, const Index< j, Dim1 > &)
levi_civita functions to make for easy adhoc use
Definition: Levi_Civita.hpp:617
LieGroups::SO3::exp
static auto exp(A &&t_w_vee, B &&theta)
Definition: Lie.hpp:49
FTensor::Tensor2
Definition: Tensor2_value.hpp:16
FTensor::Tensor3
Definition: Tensor3_value.hpp:12
a
constexpr double a
Definition: approx_sphere.cpp:30
LieGroups::SO3::diffExpImpl
static auto diffExpImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
Definition: Lie.hpp:134
LieGroups::SO3::expImpl
static auto expImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
Definition: Lie.hpp:121
LieGroups::SO3::getVee
static auto getVee(T &&w1, T &&w2, T &&w3)
Definition: Lie.hpp:28
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
LieGroups::SO3::genericFormImpl
static auto genericFormImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 alpha, const T3 beta)
Definition: Lie.hpp:110
LieGroups::SO3::JrImpl
static auto JrImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 theta)
Definition: Lie.hpp:200
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
LieGroups::SO3::getHatImpl
static auto getHatImpl(FTensor::Tensor1< T, dim > &t_w_vee)
Definition: Lie.hpp:102
LieGroups::SO3::FTENSOR_INDEX
static FTENSOR_INDEX(dim, i)
LieGroups::TensorTypeExtractor::Type
std::remove_pointer< T >::type Type
Definition: Lie.hpp:17
ReactionDiffusionEquation::D
const double D
diffusivity
Definition: reaction_diffusion.cpp:20
LieGroups::SO3::JlImpl
static auto JlImpl(FTensor::Tensor1< T1, dim > &t_w_vee, const T2 &theta)
Definition: Lie.hpp:187
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
Generated by Doxygen 1.8.17 and hosted at University of Glasgow