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

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

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
Val &	tVal

Vec &	tVec

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.

                                          : tVal(t_val), tVec(t_vec) {
  
     FTensor::Index<'i', Dim> i;
     FTensor::Index<'j', Dim> j;
     FTensor::Index<'k', Dim> k;
     FTensor::Index<'l', Dim> l;
  
     for (auto aa = 0; aa != Dim; ++aa) {
       auto &M = aM[aa];
       for (auto ii = 0; ii != Dim; ++ii)
         for (auto jj = 0; jj <= ii; ++jj)
           M(ii, jj) = tVec(aa, ii) * tVec(aa, jj);
     }
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto bb = 0; bb != Dim; ++bb) {
         auto &Ma = aM[aa];
         auto &Mb = aM[bb];
         auto &MM = aMM[aa][bb];
         MM(i, j, k, l) = Ma(i, j) * Mb(k, l);
       }
     }
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto bb = 0; bb != Dim; ++bb) {
         if (aa != bb) {
           auto &MM = aMM[aa][bb];
           auto &G = aG[aa][bb];
           G(i, j, k, l) = MM(i, k, j, l) || MM(i, l, j, k);
         }
       }
     }
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto bb = 0; bb != Dim; ++bb) {
         if (aa != bb) {
           auto &Gab = aG[aa][bb];
           auto &Gba = aG[bb][aa];
           auto &S = aS[get_sym_index(aa, bb, Dim)];
           S(i, j, k, l) = Gab(i, j, k, l) + Gba(i, j, k, l);
         }
       }
     }
   }

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_val	eigen values vector
t_vec	eigen vectors matrix
f	function
d_f	derivative of function
dd_f	second derivative of function
t_S	second rank tensor S

Returns: auto second derivatives, forth order tensor with minor symmetries

Definition at line 940 of file MatrixFunctionTemplate.hpp.

                                                                {
  
     for (auto aa = 0; aa != Dim; ++aa)
       fVal(aa) = f(tVal(aa));
  
     for (auto aa = 0; aa != Dim; ++aa)
       dfVal(aa) = d_f(tVal(aa));
  
     for (auto aa = 0; aa != Dim; ++aa)
       ddfVal(aa) = dd_f(tVal(aa));
  
     for (auto aa = 0; aa != Dim; ++aa)
       for (auto bb = 0; bb != aa; ++bb) {
         aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
         aF(bb, aa) = -aF(aa, bb);
         aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
       }
  
     FTensor::Index<'i', Dim> i;
     FTensor::Index<'j', Dim> j;
     FTensor::Index<'k', Dim> k;
     FTensor::Index<'l', Dim> l;
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto bb = 0; bb != Dim; ++bb) {
         if (aa != bb) {
           const auto &S = aS[get_sym_index(aa, bb, Dim)];
           const auto &M = aM[aa];
           auto &SMmn = aSM[get_nodiag_index(aa, bb, Dim)];
           for (auto mm = 0; mm != Dim; ++mm) {
             for (auto nn = mm; nn != Dim; ++nn) {
               SMmn[get_sym_index(mm, nn, Dim)](i, j, k, l) =
                   S(i, j, k, l) * M(mm, nn);
             }
           }
         }
       }
     }
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto mm = 0; mm != Dim; ++mm) {
         for (auto nn = mm; nn != Dim; ++nn) {
           d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) = 0;
         }
       }
     }
  
     if constexpr (NB == 3)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb) {
             const V v = dfVal(aa) * aF(aa, bb);
             for (auto mm = 0; mm != Dim; ++mm) {
               for (auto nn = mm; nn != Dim; ++nn) {
                 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
                     v * aSM[get_nodiag_index(aa, bb, Dim)]
                            [get_sym_index(mm, nn, Dim)](i, j, k, l);
               }
             }
           }
         }
       }
  
     if constexpr (NB == 2)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb) {
             V v;
             if (aa == 1 || bb == 1)
               v = dfVal(aa) * aF(aa, bb);
             else
               v = ddfVal(aa) / 2;
             for (auto mm = 0; mm != Dim; ++mm) {
               for (auto nn = mm; nn != Dim; ++nn) {
                 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
                     v * aSM[get_nodiag_index(aa, bb, Dim)]
                            [get_sym_index(mm, nn, Dim)](i, j, k, l);
               }
             }
           }
         }
       }
  
     if constexpr (NB == 1)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb) {
             const V v = ddfVal(aa) / 2;
             for (auto mm = 0; mm != Dim; ++mm) {
               for (auto nn = mm; nn != Dim; ++nn) {
                 d2MType0[aa][get_sym_index(mm, nn, Dim)](i, j, k, l) +=
                     v * aSM[get_nodiag_index(aa, bb, Dim)]
                            [get_sym_index(mm, nn, Dim)](i, j, k, l);
               }
             }
           }
         }
       }
  
     for (auto aa = 0; aa != Dim; ++aa) {
       for (auto mm = 0; mm != Dim; ++mm) {
         for (auto nn = 0; nn != Dim; ++nn) {
           if (nn != mm)
             d2MType1[mm][get_sym_index(aa, nn, Dim)](i, j, k, l) = 0;
         }
       }
     }
  
     if constexpr (NB == 3)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb) {
             const auto &S = aS[get_sym_index(aa, bb, Dim)];
             const auto v0 = aF(aa, bb);
             for (auto cc = 0; cc != Dim; ++cc) {
               for (auto dd = 0; dd != Dim; ++dd) {
                 if (cc != dd) {
                   const double v1 = fVal(cc) * aF(cc, dd);
                   d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
                       (v1 * v0) * S(i, j, k, l);
                 }
               }
             }
           }
         }
       }
  
     if constexpr (NB == 2)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb)
             for (auto cc = 0; cc != Dim; ++cc) {
               for (auto dd = 0; dd != Dim; ++dd)
                 if (cc != dd) {
  
                   V r;
  
                   if ((cc == 1 || dd == 1) && (aa == 1 || bb == 1))
                     r = fVal(cc) * aF(cc, dd) * aF(aa, bb);
                   else if (cc != 1 && dd != 1 && aa != 1 && bb != 1) {
  
                     if ((aa != bb && bb != dd) && (aa != dd && bb != cc))
                       r = ddfVal(cc) / 4;
                     else
                       r = 0;
  
                   } else if ((cc != 1 && dd != 1) && (aa == 1 || bb == 1))
                     r = dfVal(cc) * aF(aa, bb) / 2;
                   else if ((cc == 1 || dd == 1) && (aa != 1 && bb != 1)) {
  
                     if ((cc == 2 && dd == 1) || (cc == 2 && dd == 1))
                       r = (
  
                               dfVal(cc)
  
                               - (fVal(cc) - fVal(dd)) * aF(cc, dd)
  
                                   ) *
                           aF(cc, dd);
  
                     else
                       r = 0;
  
                   } else
                     r = 0;
  
                   if (r)
                     d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
                         r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
                 }
             }
         }
       }
  
     if constexpr (NB == 1)
       for (auto aa = 0; aa != Dim; ++aa) {
         for (auto bb = 0; bb != Dim; ++bb) {
           if (aa != bb) {
             for (auto cc = 0; cc != Dim; ++cc) {
               for (auto dd = 0; dd != Dim; ++dd) {
                 if (cc != dd) {
                   if ((bb != dd) && (aa != dd && bb != cc)) {
                     const double r = ddfVal(cc) / 4;
                     d2MType1[dd][get_sym_index(aa, cc, Dim)](i, j, k, l) +=
                         r * aS[get_sym_index(aa, bb, Dim)](i, j, k, l);
                   }
                 }
               }
             }
           }
         }
       }
  
     using THIS = EigenMatrixImp<T1, T2, NB, Dim>;
     using T3 = FTensor::Ddg<V, Dim, Dim>;
  
     T3 t_diff_A;
     GetDiffDiffMatImpl<THIS, V, T3, T>(*this, t_diff_A, t_S)
         .set(Number<Dim>(), Number<Dim>(), Number<Dim>(), Number<Dim>());
     return t_diff_A;
   }

◆ 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_val	eiegn values vector
t_vec	eiegn vectors matrix
f	function
d_f	directive of function

Returns: auto derivatives, forth order tensor with minor simetries

Definition at line 900 of file MatrixFunctionTemplate.hpp.

                                          {
  
     for (auto aa = 0; aa != Dim; ++aa)
       fVal(aa) = f(tVal(aa));
  
     for (auto aa = 0; aa != Dim; ++aa)
       dfVal(aa) = d_f(tVal(aa));
  
     for (auto aa = 0; aa != Dim; ++aa)
       for (auto bb = 0; bb != aa; ++bb) {
         aF(aa, bb) = 1 / (tVal(aa) - tVal(bb));
         aF(bb, aa) = -aF(aa, bb);
         aF2(aa, bb) = aF(aa, bb) * aF(aa, bb);
       }
  
     using T3 = FTensor::Ddg<V, Dim, Dim>;
     T3 t_diff_A;
     GetDiffMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_diff_A)
         .set(NumberDim(), NumberDim(), NumberDim(), NumberDim());
     return t_diff_A;
   }

◆ 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_val	eiegn values vector
t_vec	eigen vectors matrix
f	function

Returns: auto function symmetric tensor rank two

Definition at line 874 of file MatrixFunctionTemplate.hpp.

                             {
  
     for (auto aa = 0; aa != Dim; ++aa)
       fVal(aa) = f(tVal(aa));
  
     using T3 =
         FTensor::Tensor2_symmetric<typename std::remove_const<V>::type, Dim>;
     T3 t_A;
     GetMatImpl<EigenMatrixImp<T1, T2, NB, Dim>, V, T3>(*this, t_A)
         .set(NumberDim(), NumberDim());
     return t_A;
   }