DiffSymmetrize.hpp

Go to the documentation of this file.

/**
 * @file DiffSymmetrize.hpp
 *
 */
 
#pragma once
 
namespace FTensor {
 
/**
 * @brief Fourth-order symmetrization tensor
 *
 * @tparam T
 */
template <class T = int> class DiffSymmetrize {
public:
  using value_type = typename promote<T, double>::V;
 
  constexpr value_type operator()(const int N0, const int N1, const int N2,
                                  const int N3) const {
    const auto first =
        (N0 == N2 && N1 == N3) ? value_type(1) : value_type(0);
    const auto second =
        (N0 == N3 && N1 == N2) ? value_type(1) : value_type(0);
    return (first + second) / value_type(2);
  }
 
  template <char i, char j, char k, char l, int Dim0, int Dim1, int Dim2,
            int Dim3>
  Tensor4_Expr<DiffSymmetrize<T>, value_type, Dim0, Dim1, Dim2, Dim3, i, j, k,
               l>
  operator()(const Index<i, Dim0> &, const Index<j, Dim1> &,
             const Index<k, Dim2> &, const Index<l, Dim3> &) const {
    return Tensor4_Expr<DiffSymmetrize<T>, value_type, Dim0, Dim1, Dim2, Dim3,
                        i, j, k, l>(*this);
  };
};
 
template <class T = int> constexpr auto diff_symmetrize() {
  return DiffSymmetrize<T>();
}
 
template <class T = int, char i, char j, char k, char l, int Dim0, int Dim1,
          int Dim2, int Dim3>
Tensor4_Expr<DiffSymmetrize<T>, typename DiffSymmetrize<T>::value_type, Dim0,
             Dim1, Dim2, Dim3, i, j, k, l>
diff_symmetrize(const Index<i, Dim0> &, const Index<j, Dim1> &,
                const Index<k, Dim2> &, const Index<l, Dim3> &) {
  return DiffSymmetrize<T>()(Index<i, Dim0>(), Index<j, Dim1>(),
                             Index<k, Dim2>(), Index<l, Dim3>());
}
 
} // namespace FTensor