strainTensor.hh

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                             */
/*   This file is part of the C++-library RFFGen.                              */
/*   Copyright 2015 Lars Lubkoll                                               */
/*                                                                             */
/*   RFFGen is free software: you can redistribute it and/or modify            */
/*   it under the terms of the GNU General Public License as published by      */
/*   the Free Software Foundation, either version 3 of the License, or         */
/*   (at your option) any later version.                                       */
/*                                                                             */
/*   RFFGen is distributed in the hope that it will be useful,                 */
/*   but WITHOUT ANY WARRANTY; without even the implied warranty of            */
/*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
/*   GNU General Public License for more details.                              */
/*                                                                             */
/*   You should have received a copy of the GNU General Public License         */
/*   along with RFFGen.  If not, see <http://www.gnu.org/licenses/>.           */
/*                                                                             */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef RFFGEN_LINEAR_ALGEBRA_STRAIN_TENSOR_HH
#define RFFGEN_LINEAR_ALGEBRA_STRAIN_TENSOR_HH

#include "transpose.hh"
#include "../MathematicalOperations/sum.hh"
#include "../Util/base.hh"
#include "../Util/chainer.hh"
#include "../Util/addTransposedMatrix.hh"

namespace RFFGen
{
  namespace Concepts { template <class> struct SymmetricMatrixConceptCheck; }
  namespace LinearAlgebra
  {
    template <class Matrix, class = Concepts::SymmetricMatrixConceptCheck<Matrix> >
    class LeftCauchyGreenStrainTensor :
        public Base ,
        public Chainer< LeftCauchyGreenStrainTensor<Matrix , Concepts::SymmetricMatrixConceptCheck<Matrix> > >
    {
    public:
      LeftCauchyGreenStrainTensor() = default;
      explicit LeftCauchyGreenStrainTensor(Matrix const& F) { update(F); }

      void update(Matrix const& F)
      {
        FT = transpose(F);
        FTF = FT * F;
      }

      Matrix const& d0() const noexcept
      {
        return FTF;
      }

      template <int>
      Matrix d1(Matrix const& dF1) const
      {
        Matrix FTdF1 = FT * dF1;
        return addTransposed(FTdF1);
      }

      template <int,int>
      Matrix d2(Matrix const& dF1, Matrix const& dF2) const
      {
        Matrix dF2TdF1 = transpose(dF2) * dF1;
        return addTransposed(dF2TdF1);
      }

    private:
      Matrix FT, FTF;
    };

    template <class Matrix, class = Concepts::SymmetricMatrixConceptCheck<Matrix> >
    class LinearizedStrainTensor :
        public Base ,
        public Chainer< LinearizedStrainTensor< Matrix , Concepts::SymmetricMatrixConceptCheck<Matrix> > >
    {
    public:
      explicit LinearizedStrainTensor(const Matrix& F) { update(F); }

      void update(Matrix const& F)
      {
        d0Result = F + transpose(F);
        d0Result *= 0.5;
      }

      Matrix const& d0() const
      {
        return d0Result;
      }

      template <int>
      Matrix d1(const Matrix& dF) const
      {
        return 0.5*(dF + transpose(dF));
      }

    private:
      Matrix d0Result = Matrix{0.};
    };

    template <class Matrix> using GeometricNonlinearity = LeftCauchyGreenStrainTensor<Matrix>;

    template <class Matrix>
    class StrainTensor :
        public MathematicalOperations::Sum< LinearizedStrainTensor<Matrix> , GeometricNonlinearity<Matrix> > ,
        public Chainer< StrainTensor<Matrix> >
    {
      using Base = MathematicalOperations::Sum< LinearizedStrainTensor<Matrix> , GeometricNonlinearity<Matrix> >;
    public:
      explicit StrainTensor(const Matrix& F) : Base(F) {}
    };
  }
}

#endif // RFFGEN_LINEAR_ALGEBRA_STRAIN_TENSOR_HH