Merge branch 'master' into embb_size_fix

Author: dcwhite

src/Core/Datatypes/Dyadic3DTensor.h

@@ -42,23 +42,47 @@ namespace Core {
      public:
       using parent = DyadicTensorGeneric<Number, 3>;
       using VectorType = Eigen::Matrix<Number, 3, 1>;
+      using SizeType = long;
       Dyadic3DTensorGeneric() : parent() {}
       using parent::parent;
       using parent::operator=;
       using parent::operator==;
+      using parent::reorderTensorValues;
+      using parent::mandel;
+      using parent::trace;
 
-      explicit Dyadic3DTensorGeneric(
-          const std::initializer_list<VectorType>& eigvecs)
-          : parent()
+      explicit Dyadic3DTensorGeneric(const std::initializer_list<VectorType>& eigvecs) : parent()
       {
         if (eigvecs.size() != DIM_)
           THROW_INVALID_ARGUMENT("The number of input parameters must be " + std::to_string(DIM_));
         parent::setEigenVectors(eigvecs);
       }
 
-      Dyadic3DTensorGeneric(const VectorType& eigvec0,
-          const VectorType& eigvec1,
-          const VectorType& eigvec2)
+      Dyadic3DTensorGeneric(const Dyadic3DTensorGeneric<Number>& other) : parent()
+      {
+        for (SizeType i = 0; i < DIM_; ++i)
+          for (SizeType j = 0; j < DIM_; ++j)
+            (*this)(i, j) = other(i, j);
+        if (other.haveEigens_)
+        {
+          parent::eigvecs_ = other.eigvecs_;
+          parent::eigvals_ = other.eigvals_;
+          parent::haveEigens_ = true;
+        }
+      }
+
+      Dyadic3DTensorGeneric(const Dyadic3DTensorGeneric<Number>&& other) : parent()
+      {
+        this->m_storage = std::move(other.m_storage);
+        parent::eigvecs_ = std::move(other.eigvecs_);
+        parent::eigvals_ = std::move(other.eigvals_);
+        parent::haveEigens_ = true;
+      }
+
+      Dyadic3DTensorGeneric(const parent& other) : parent(other) {}
+
+      Dyadic3DTensorGeneric(
+          const VectorType& eigvec0, const VectorType& eigvec1, const VectorType& eigvec2)
           : parent()
       {
         parent::setEigenVectors({eigvec0, eigvec1, eigvec2});
@@ -73,43 +97,69 @@ namespace Core {
         (*this)(0, 1) = (*this)(1, 0) = v2;
         (*this)(0, 2) = (*this)(2, 0) = v3;
         (*this)(1, 2) = (*this)(2, 1) = v5;
-        parent::buildEigens();
       }
 
-      Number linearCertainty()
+      Number linearCertainty() const
       {
         auto eigvals = parent::getEigenvalues();
-        return (eigvals[0] - eigvals[1]) / parent::eigenValueSum();
+        return (eigvals[0] - eigvals[1]) / parent::eigenvalueSum();
       }
 
-      Number planarCertainty()
+      Number planarCertainty() const
       {
         auto eigvals = parent::getEigenvalues();
-        return 2.0 * (eigvals[1] - eigvals[2]) / parent::eigenValueSum();
+        return 2.0 * (eigvals[1] - eigvals[2]) / parent::eigenvalueSum();
       }
 
-      Number sphericalCertainty()
+      Number sphericalCertainty() const
       {
         auto eigvals = parent::getEigenvalues();
-        return 3.0 * eigvals[2] / parent::eigenValueSum();
+        return 3.0 * eigvals[2] / parent::eigenvalueSum();
       }
 
-      VectorType mandel()
+      Dyadic3DTensorGeneric<Number> operator=(Dyadic3DTensorGeneric<Number>&& other)
       {
-        auto eigvals = parent::getEigenvalues();
-        auto eigvecs = parent::getEigenvectors();
+        parent::operator=(other);
+        return *this;
+      }
+
+      Dyadic3DTensorGeneric<Number> operator=(const Dyadic3DTensorGeneric<Number>& other)
+      {
+        parent::operator=(static_cast<parent>(other));
+        return *this;
+      }
 
-        for (size_t i = 0; i < DIM_; ++i)
-          eigvecs[i] *= eigvals[i];
+      template <typename OtherDerived>
+      Dyadic3DTensorGeneric<Number> operator*(const OtherDerived& other) const
+      {
+        Dyadic3DTensorGeneric<Number> newTensor(parent::operator*(other));
+        return newTensor;
+      }
 
-        static const double sqrt2 = std::sqrt(2);
-        VectorType mandel({eigvecs[0][0], eigvecs[1][1], eigvecs[2][2],
-            eigvecs[0][1] * sqrt2, eigvecs[0][2] * sqrt2, eigvecs[1][2] * sqrt2});
-        return mandel;
+      template <typename OtherDerived>
+      Dyadic3DTensorGeneric<Number> operator+(const OtherDerived& other) const
+      {
+        Dyadic3DTensorGeneric<Number> newTensor(parent::operator+(other));
+        return newTensor;
+      }
+
+      template <typename OtherDerived>
+      Dyadic3DTensorGeneric<Number> operator-(const OtherDerived& other) const
+      {
+        Dyadic3DTensorGeneric<Number> newTensor(parent::operator-(other));
+        return newTensor;
+      }
+
+      using parent::makePositive;
+      Number fractionalAnisotropy() const
+      {
+        const static Number sqrtHalf = std::sqrt(0.5);
+        const auto eigvals = parent::getEigenvalues();
+        return sqrtHalf * std::sqrt(std::pow(eigvals[0] - eigvals[1], 2) + std::pow(eigvals[1] - eigvals[2], 2) + std::pow(eigvals[2] - eigvals[0], 2)) / parent::frobeniusNorm();
       }
 
      private:
-      const size_t DIM_ = 3;
+      const SizeType DIM_ = 3;
     };
 
     template <typename Indexable>
@@ -126,14 +176,6 @@ namespace Core {
       if (vec.size() != 6) THROW_INVALID_ARGUMENT("This function requires 6 values.");
       return Dyadic3DTensorGeneric<double>(vec[0], vec[1], vec[2], vec[3], vec[4], vec[5]);
     }
-
-    template <typename Indexable>
-    Dyadic3DTensor symmetricTensorFromMandel(const Indexable& array)
-    {
-      static const double sqrt2 = std::sqrt(2);
-      return Dyadic3DTensor(
-          array[0], array[3] / sqrt2, array[4] / sqrt2, array[1], array[5] / sqrt2, array[2]);
-    }
   }
 }
 }