v0.14.0
Public Types | Public Member Functions | Private Attributes | Friends | List of all members
EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim > Struct Template Reference

#include <src/ftensor/src/MatrixFunctionTemplate.hpp>

Collaboration diagram for EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >:
[legend]

Public Types

using Val = const FTensor::Tensor1< T1, Dim >
 
using Vec = const FTensor::Tensor2< T2, Dim, Dim >
 
using Fun = boost::function< double(const double)>
 
using V = double
 
template<int N>
using Number = FTensor::Number< N >
 
template<char c>
using I = typename FTensor::Index< c, Dim >
 
using NumberNb = Number< NB >
 
using NumberDim = Number< Dim >
 

Public Member Functions

 EigenMatrixImp (Val &t_val, Vec &t_vec)
 
auto getMat (Fun f)
 Get matrix. More...
 
auto getDiffMat (Fun f, Fun d_f)
 Get derivative of matrix. More...
 
template<typename T >
auto getDiffDiffMat (Fun f, Fun d_f, Fun dd_f, T &t_S)
 Get second directive of matrix. More...
 

Private Attributes

ValtVal
 
VectVec
 
FTensor::Tensor2_symmetric< V, Dim > aM [Dim]
 
FTensor::Ddg< V, Dim, Dim > aMM [Dim][Dim]
 
FTensor::Ddg< V, Dim, Dim > aG [Dim][Dim]
 
FTensor::Ddg< V, Dim, Dim > aS [(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > aSM [(Dim - 1) *Dim][(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > d2MType0 [Dim][(Dim *(Dim+1))/2]
 
FTensor::Ddg< V, Dim, Dim > d2MType1 [Dim][(Dim *(Dim+1))/2]
 
FTensor::Tensor2_symmetric< V, Dim > aF2
 
FTensor::Tensor2< V, Dim, Dim > aF
 
FTensor::Tensor1< V, Dim > fVal
 
FTensor::Tensor1< V, Dim > dfVal
 
FTensor::Tensor1< V, Dim > ddfVal
 

Friends

template<typename E , typename C >
struct d2MCoefficients
 
template<typename E , typename C , typename G >
struct d2MImpl
 
template<typename E , typename C >
struct Fdd4MImpl
 
template<typename E , typename C >
struct ReconstructMatImpl
 
template<typename E , typename C >
struct FirstMatrixDirectiveImpl
 
template<typename E , typename C >
struct SecondMatrixDirectiveImpl
 
template<typename E , typename C , typename T >
struct GetDiffMatImpl
 
template<typename E , typename C , typename T3 , typename T4 >
struct GetDiffDiffMatImpl
 

Detailed Description

template<typename T1, typename T2, int NB, int Dim>
struct EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >

Definition at line 799 of file MatrixFunctionTemplate.hpp.

Member Typedef Documentation

◆ Fun

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Fun = boost::function<double(const double)>

Definition at line 803 of file MatrixFunctionTemplate.hpp.

◆ I

template<typename T1 , typename T2 , int NB, int Dim>
template<char c>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::I = typename FTensor::Index<c, Dim>

Definition at line 807 of file MatrixFunctionTemplate.hpp.

◆ Number

template<typename T1 , typename T2 , int NB, int Dim>
template<int N>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Number = FTensor::Number<N>

Definition at line 806 of file MatrixFunctionTemplate.hpp.

◆ NumberDim

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::NumberDim = Number<Dim>

Definition at line 810 of file MatrixFunctionTemplate.hpp.

◆ NumberNb

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::NumberNb = Number<NB>

Definition at line 809 of file MatrixFunctionTemplate.hpp.

◆ V

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::V = double

Definition at line 804 of file MatrixFunctionTemplate.hpp.

◆ Val

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Val = const FTensor::Tensor1<T1, Dim>

Definition at line 801 of file MatrixFunctionTemplate.hpp.

◆ Vec

template<typename T1 , typename T2 , int NB, int Dim>
using EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::Vec = const FTensor::Tensor2<T2, Dim, Dim>

Definition at line 802 of file MatrixFunctionTemplate.hpp.

Constructor & Destructor Documentation

◆ EigenMatrixImp()

template<typename T1 , typename T2 , int NB, int Dim>
EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::EigenMatrixImp ( Val t_val,
Vec t_vec 
)
inline

Definition at line 812 of file MatrixFunctionTemplate.hpp.

812  : tVal(t_val), tVec(t_vec) {
813 
818 
819  for (auto aa = 0; aa != Dim; ++aa) {
820  auto &M = aM[aa];
821  for (auto ii = 0; ii != Dim; ++ii)
822  for (auto jj = 0; jj <= ii; ++jj)
823  M(ii, jj) = tVec(aa, ii) * tVec(aa, jj);
824  }
825 
826  for (auto aa = 0; aa != Dim; ++aa) {
827  for (auto bb = 0; bb != Dim; ++bb) {
828  auto &Ma = aM[aa];
829  auto &Mb = aM[bb];
830  auto &MM = aMM[aa][bb];
831  MM(i, j, k, l) = Ma(i, j) * Mb(k, l);
832  }
833  }
834 
835  for (auto aa = 0; aa != Dim; ++aa) {
836  for (auto bb = 0; bb != Dim; ++bb) {
837  if (aa != bb) {
838  auto &MM = aMM[aa][bb];
839  auto &G = aG[aa][bb];
840  G(i, j, k, l) = MM(i, k, j, l) || MM(i, l, j, k);
841  }
842  }
843  }
844 
845  for (auto aa = 0; aa != Dim; ++aa) {
846  for (auto bb = 0; bb != Dim; ++bb) {
847  if (aa != bb) {
848  auto &Gab = aG[aa][bb];
849  auto &Gba = aG[bb][aa];
850  auto &S = aS[get_sym_index(aa, bb, Dim)];
851  S(i, j, k, l) = Gab(i, j, k, l) + Gba(i, j, k, l);
852  }
853  }
854  }
855  }

Member Function Documentation

◆ getDiffDiffMat()

template<typename T1 , typename T2 , int NB, int Dim>
template<typename T >
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getDiffDiffMat ( Fun  f,
Fun  d_f,
Fun  dd_f,
T &  t_S 
)
inline

Get second directive of matrix.

\[ LS_{klmn} = S_{ij} \frac{\partial^2 B_{ij}}{\partial A_{kl} \partial A_{mn} } \]

Template Parameters
T
Parameters
t_valeigen values vector
t_veceigen vectors matrix
ffunction
d_fderivative of function
dd_fsecond derivative of function
t_Ssecond rank tensor S
Returns
auto second derivatives, forth order tensor with minor symmetries

Definition at line 940 of file MatrixFunctionTemplate.hpp.

940  {
941 
942  for (auto aa = 0; aa != Dim; ++aa)
943  fVal(aa) = f(tVal(aa));
944 
945  for (auto aa = 0; aa != Dim; ++aa)
946  dfVal(aa) = d_f(tVal(aa));
947 
948  for (auto aa = 0; aa != Dim; ++aa)
949  ddfVal(aa) = dd_f(tVal(aa));
950 
951  for (auto aa = 0; aa != Dim; ++aa)
952  for (auto bb = 0; bb != aa; ++bb) {
953  aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
954  aF(bb, aa) = -aF(aa, bb);
955  aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
956  }
957 
962 
963  for (auto aa = 0; aa != Dim; ++aa) {
964  for (auto bb = 0; bb != Dim; ++bb) {
965  if (aa != bb) {
966  const auto &S = aS[get_sym_index(aa, bb, Dim)];
967  const auto &M = aM[aa];
968  auto &SMmn = aSM[get_nodiag_index(aa, bb, Dim)];
969  for (auto mm = 0; mm != Dim; ++mm) {
970  for (auto nn = mm; nn != Dim; ++nn) {
971  SMmn[get_sym_index(mm, nn, Dim)](i, j, k, l) =
972  S(i, j, k, l) * M(mm, nn);
973  }
974  }
975  }
976  }
977  }
978 
979  for (auto aa = 0; aa != Dim; ++aa) {
980  for (auto mm = 0; mm != Dim; ++mm) {
981  for (auto nn = mm; nn != Dim; ++nn) {
982  d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) = 0;
983  }
984  }
985  }
986 
987  if constexpr (NB == 3)
988  for (auto aa = 0; aa != Dim; ++aa) {
989  for (auto bb = 0; bb != Dim; ++bb) {
990  if (aa != bb) {
991  const V v = dfVal(aa) * aF(aa, bb);
992  for (auto mm = 0; mm != Dim; ++mm) {
993  for (auto nn = mm; nn != Dim; ++nn) {
994  d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
995  v * aSM[get_nodiag_index(aa, bb, Dim)]
996  [get_sym_index(mm, nn, Dim)](i, j, k, l);
997  }
998  }
999  }
1000  }
1001  }
1002 
1003  if constexpr (NB == 2)
1004  for (auto aa = 0; aa != Dim; ++aa) {
1005  for (auto bb = 0; bb != Dim; ++bb) {
1006  if (aa != bb) {
1007  V v;
1008  if (aa == 1 || bb == 1)
1009  v = dfVal(aa) * aF(aa, bb);
1010  else
1011  v = ddfVal(aa) / 2;
1012  for (auto mm = 0; mm != Dim; ++mm) {
1013  for (auto nn = mm; nn != Dim; ++nn) {
1014  d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
1015  v * aSM[get_nodiag_index(aa, bb, Dim)]
1016  [get_sym_index(mm, nn, Dim)](i, j, k, l);
1017  }
1018  }
1019  }
1020  }
1021  }
1022 
1023  if constexpr (NB == 1)
1024  for (auto aa = 0; aa != Dim; ++aa) {
1025  for (auto bb = 0; bb != Dim; ++bb) {
1026  if (aa != bb) {
1027  const V v = ddfVal(aa) / 2;
1028  for (auto mm = 0; mm != Dim; ++mm) {
1029  for (auto nn = mm; nn != Dim; ++nn) {
1030  d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
1031  v * aSM[get_nodiag_index(aa, bb, Dim)]
1032  [get_sym_index(mm, nn, Dim)](i, j, k, l);
1033  }
1034  }
1035  }
1036  }
1037  }
1038 
1039  for (auto aa = 0; aa != Dim; ++aa) {
1040  for (auto mm = 0; mm != Dim; ++mm) {
1041  for (auto nn = 0; nn != Dim; ++nn) {
1042  if (nn != mm)
1043  d2MType1[mm][get_sym_index(aa, nn, Dim)](i, j, k, l) = 0;
1044  }
1045  }
1046  }
1047 
1048  if constexpr (NB == 3)
1049  for (auto aa = 0; aa != Dim; ++aa) {
1050  for (auto bb = 0; bb != Dim; ++bb) {
1051  if (aa != bb) {
1052  const auto &S = aS[get_sym_index(aa, bb, Dim)];
1053  const auto v0 = aF(aa, bb);
1054  for (auto cc = 0; cc != Dim; ++cc) {
1055  for (auto dd = 0; dd != Dim; ++dd) {
1056  if (cc != dd) {
1057  const double v1 = fVal(cc) * aF(cc, dd);
1058  d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1059  (v1 * v0) * S(i, j, k, l);
1060  }
1061  }
1062  }
1063  }
1064  }
1065  }
1066 
1067  if constexpr (NB == 2)
1068  for (auto aa = 0; aa != Dim; ++aa) {
1069  for (auto bb = 0; bb != Dim; ++bb) {
1070  if (aa != bb)
1071  for (auto cc = 0; cc != Dim; ++cc) {
1072  for (auto dd = 0; dd != Dim; ++dd)
1073  if (cc != dd) {
1074 
1075  V r;
1076 
1077  if ((cc == 1 || dd == 1) && (aa == 1 || bb == 1))
1078  r = fVal(cc) * aF(cc, dd) * aF(aa, bb);
1079  else if (cc != 1 && dd != 1 && aa != 1 && bb != 1) {
1080 
1081  if ((aa != bb && bb != dd) && (aa != dd && bb != cc))
1082  r = ddfVal(cc) / 4;
1083  else
1084  r = 0;
1085 
1086  } else if ((cc != 1 && dd != 1) && (aa == 1 || bb == 1))
1087  r = dfVal(cc) * aF(aa, bb) / 2;
1088  else if ((cc == 1 || dd == 1) && (aa != 1 && bb != 1)) {
1089 
1090  if ((cc == 2 && dd == 1) || (cc == 2 && dd == 1))
1091  r = (
1092 
1093  dfVal(cc)
1094 
1095  - (fVal(cc) - fVal(dd)) * aF(cc, dd)
1096 
1097  ) *
1098  aF(cc, dd);
1099 
1100  else
1101  r = 0;
1102 
1103  } else
1104  r = 0;
1105 
1106  if (r)
1107  d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1108  r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
1109  }
1110  }
1111  }
1112  }
1113 
1114  if constexpr (NB == 1)
1115  for (auto aa = 0; aa != Dim; ++aa) {
1116  for (auto bb = 0; bb != Dim; ++bb) {
1117  if (aa != bb) {
1118  for (auto cc = 0; cc != Dim; ++cc) {
1119  for (auto dd = 0; dd != Dim; ++dd) {
1120  if (cc != dd) {
1121  if ((bb != dd) && (aa != dd && bb != cc)) {
1122  const double r = ddfVal(cc) / 4;
1123  d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
1124  r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
1125  }
1126  }
1127  }
1128  }
1129  }
1130  }
1131  }
1132 
1133  using THIS = EigenMatrixImp<T1, T2, NB, Dim>;
1134  using T3 = FTensor::Ddg<V, Dim, Dim>;
1135 
1136  T3 t_diff_A;
1137  GetDiffDiffMatImpl<THIS, V, T3, T>(*this, t_diff_A, t_S)
1138  .set(Number<Dim>(), Number<Dim>(), Number<Dim>(), Number<Dim>());
1139  return t_diff_A;
1140  }

◆ getDiffMat()

template<typename T1 , typename T2 , int NB, int Dim>
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getDiffMat ( Fun  f,
Fun  d_f 
)
inline

Get derivative of matrix.

\[ P_{ijkl} = \frac{\partial B_{ij}}{\partial A_{kl}} \]

Parameters
t_valeiegn values vector
t_veceiegn vectors matrix
ffunction
d_fdirective of function
Returns
auto derivatives, forth order tensor with minor simetries

Definition at line 900 of file MatrixFunctionTemplate.hpp.

900  {
901 
902  for (auto aa = 0; aa != Dim; ++aa)
903  fVal(aa) = f(tVal(aa));
904 
905  for (auto aa = 0; aa != Dim; ++aa)
906  dfVal(aa) = d_f(tVal(aa));
907 
908  for (auto aa = 0; aa != Dim; ++aa)
909  for (auto bb = 0; bb != aa; ++bb) {
910  aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
911  aF(bb, aa) = -aF(aa, bb);
912  aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
913  }
914 
915  using T3 = FTensor::Ddg<V, Dim, Dim>;
916  T3 t_diff_A;
917  GetDiffMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_diff_A)
918  .set(NumberDim(), NumberDim(), NumberDim(), NumberDim());
919  return t_diff_A;
920  }

◆ getMat()

template<typename T1 , typename T2 , int NB, int Dim>
auto EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::getMat ( Fun  f)
inline

Get matrix.

\[ \mathbf{B} = f(\mathbf{A}) \]

\[ B_{ij} = \sum_{a}^3 f(\lambda^a) n^a_i n^a_j \]

where \(a\) is eigen value number.

Parameters
t_valeiegn values vector
t_veceigen vectors matrix
ffunction
Returns
auto function symmetric tensor rank two

Definition at line 874 of file MatrixFunctionTemplate.hpp.

874  {
875 
876  for (auto aa = 0; aa != Dim; ++aa)
877  fVal(aa) = f(tVal(aa));
878 
879  using T3 =
881  T3 t_A;
882  GetMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_A)
883  .set(NumberDim(), NumberDim());
884  return t_A;
885  }

Friends And Related Function Documentation

◆ d2MCoefficients

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct d2MCoefficients
friend

Definition at line 1158 of file MatrixFunctionTemplate.hpp.

◆ d2MImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename G >
friend struct d2MImpl
friend

Definition at line 1159 of file MatrixFunctionTemplate.hpp.

◆ Fdd4MImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct Fdd4MImpl
friend

Definition at line 1160 of file MatrixFunctionTemplate.hpp.

◆ FirstMatrixDirectiveImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct FirstMatrixDirectiveImpl
friend

Definition at line 1162 of file MatrixFunctionTemplate.hpp.

◆ GetDiffDiffMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename T3 , typename T4 >
friend struct GetDiffDiffMatImpl
friend

Definition at line 1166 of file MatrixFunctionTemplate.hpp.

◆ GetDiffMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C , typename T >
friend struct GetDiffMatImpl
friend

Definition at line 1164 of file MatrixFunctionTemplate.hpp.

◆ ReconstructMatImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct ReconstructMatImpl
friend

Definition at line 1161 of file MatrixFunctionTemplate.hpp.

◆ SecondMatrixDirectiveImpl

template<typename T1 , typename T2 , int NB, int Dim>
template<typename E , typename C >
friend struct SecondMatrixDirectiveImpl
friend

Definition at line 1163 of file MatrixFunctionTemplate.hpp.

Member Data Documentation

◆ aF

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aF
private

Definition at line 1153 of file MatrixFunctionTemplate.hpp.

◆ aF2

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2_symmetric<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aF2
private

Definition at line 1152 of file MatrixFunctionTemplate.hpp.

◆ aG

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aG[Dim][Dim]
private

Definition at line 1147 of file MatrixFunctionTemplate.hpp.

◆ aM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor2_symmetric<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aM[Dim]
private

Definition at line 1145 of file MatrixFunctionTemplate.hpp.

◆ aMM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aMM[Dim][Dim]
private

Definition at line 1146 of file MatrixFunctionTemplate.hpp.

◆ aS

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aS[(Dim *(Dim+1))/2]
private

Definition at line 1148 of file MatrixFunctionTemplate.hpp.

◆ aSM

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::aSM[(Dim - 1) *Dim][(Dim *(Dim+1))/2]
private

Definition at line 1149 of file MatrixFunctionTemplate.hpp.

◆ d2MType0

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::d2MType0[Dim][(Dim *(Dim+1))/2]
private

Definition at line 1150 of file MatrixFunctionTemplate.hpp.

◆ d2MType1

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Ddg<V, Dim, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::d2MType1[Dim][(Dim *(Dim+1))/2]
private

Definition at line 1151 of file MatrixFunctionTemplate.hpp.

◆ ddfVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::ddfVal
private

Definition at line 1156 of file MatrixFunctionTemplate.hpp.

◆ dfVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::dfVal
private

Definition at line 1155 of file MatrixFunctionTemplate.hpp.

◆ fVal

template<typename T1 , typename T2 , int NB, int Dim>
FTensor::Tensor1<V, Dim> EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::fVal
private

Definition at line 1154 of file MatrixFunctionTemplate.hpp.

◆ tVal

template<typename T1 , typename T2 , int NB, int Dim>
Val& EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::tVal
private

Definition at line 1143 of file MatrixFunctionTemplate.hpp.

◆ tVec

template<typename T1 , typename T2 , int NB, int Dim>
Vec& EigenMatrix::EigenMatrixImp< T1, T2, NB, Dim >::tVec
private

Definition at line 1144 of file MatrixFunctionTemplate.hpp.


The documentation for this struct was generated from the following file:
EigenMatrix::EigenMatrixImp::ddfVal
FTensor::Tensor1< V, Dim > ddfVal
Definition: MatrixFunctionTemplate.hpp:1156
EigenMatrix::EigenMatrixImp::V
double V
Definition: MatrixFunctionTemplate.hpp:804
EigenMatrix::EigenMatrixImp::tVec
Vec & tVec
Definition: MatrixFunctionTemplate.hpp:1144
HenckyOps::d_f
auto d_f
Definition: HenckyOps.hpp:16
EigenMatrix::get_sym_index
auto get_sym_index(const Number< N1 > &, const Number< N2 > &, const Number< Dim > &)
Definition: MatrixFunctionTemplate.hpp:58
FTensor::Tensor2_symmetric
Definition: Tensor2_symmetric_value.hpp:13
sdf.r
int r
Definition: sdf.py:8
EigenMatrix::EigenMatrixImp::aM
FTensor::Tensor2_symmetric< V, Dim > aM[Dim]
Definition: MatrixFunctionTemplate.hpp:1145
EigenMatrix::EigenMatrixImp::aSM
FTensor::Ddg< V, Dim, Dim > aSM[(Dim - 1) *Dim][(Dim *(Dim+1))/2]
Definition: MatrixFunctionTemplate.hpp:1149
PlasticOps::M
FTensor::Index< 'M', 3 > M
Definition: PlasticOps.hpp:117
EigenMatrix::EigenMatrixImp::aMM
FTensor::Ddg< V, Dim, Dim > aMM[Dim][Dim]
Definition: MatrixFunctionTemplate.hpp:1146
HenckyOps::dd_f
auto dd_f
Definition: HenckyOps.hpp:17
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
FTensor::Index
Definition: Index.hpp:23
EigenMatrix::EigenMatrixImp::aF
FTensor::Tensor2< V, Dim, Dim > aF
Definition: MatrixFunctionTemplate.hpp:1153
EigenMatrix::EigenMatrixImp::d2MType1
FTensor::Ddg< V, Dim, Dim > d2MType1[Dim][(Dim *(Dim+1))/2]
Definition: MatrixFunctionTemplate.hpp:1151
EigenMatrix::EigenMatrixImp::d2MType0
FTensor::Ddg< V, Dim, Dim > d2MType0[Dim][(Dim *(Dim+1))/2]
Definition: MatrixFunctionTemplate.hpp:1150
v
const double v
phase velocity of light in medium (cm/ns)
Definition: initial_diffusion.cpp:40
FTensor::dd
const Tensor2_symmetric_Expr< const ddTensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd(const Tensor0< T * > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: ddTensor0.hpp:33
EigenMatrix::get_nodiag_index
auto get_nodiag_index(const Number< N1 > &, const Number< N2 > &, const Number< Dim > &)
Definition: MatrixFunctionTemplate.hpp:74
EigenMatrix::EigenMatrixImp::aS
FTensor::Ddg< V, Dim, Dim > aS[(Dim *(Dim+1))/2]
Definition: MatrixFunctionTemplate.hpp:1148
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
EigenMatrix::EigenMatrixImp::aF2
FTensor::Tensor2_symmetric< V, Dim > aF2
Definition: MatrixFunctionTemplate.hpp:1152
FTensor::Ddg
Definition: Ddg_value.hpp:7
G
constexpr IntegrationType G
Definition: level_set.cpp:33
EigenMatrix::EigenMatrixImp::fVal
FTensor::Tensor1< V, Dim > fVal
Definition: MatrixFunctionTemplate.hpp:1154
EigenMatrix::EigenMatrixImp::dfVal
FTensor::Tensor1< V, Dim > dfVal
Definition: MatrixFunctionTemplate.hpp:1155
EigenMatrix::EigenMatrixImp::aG
FTensor::Ddg< V, Dim, Dim > aG[Dim][Dim]
Definition: MatrixFunctionTemplate.hpp:1147
EigenMatrix::EigenMatrixImp::NumberDim
Number< Dim > NumberDim
Definition: MatrixFunctionTemplate.hpp:810
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
EigenMatrix::EigenMatrixImp::tVal
Val & tVal
Definition: MatrixFunctionTemplate.hpp:1143
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21