strain_tensor.h

#pragma once

#include <funcy/concepts.h>
#include <funcy/linalg/concepts.h>
#include <funcy/linalg/transpose.h>
#include <funcy/util/chainer.h>
#include <funcy/util/mathop_traits.h>

namespace funcy::linalg
{
    template < class Mat >
    class RightCauchyGreenStrainTensor : public Chainer< RightCauchyGreenStrainTensor< Mat > >
    {
    public:
        RightCauchyGreenStrainTensor() = default;
        explicit RightCauchyGreenStrainTensor( const Mat& F )
        {
            update( F );
        }

        void update( const Mat& F )
        {
            FT = detail::transpose( F );
            FTF = multiply_via_traits( FT, F );
        }

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

        Mat d1( const Mat& dF1 ) const
        {
            Mat FTdF1 = multiply_via_traits( FT, dF1 );
            return detail::add_transposed( FTdF1 );
        }

        Mat d2( const Mat& dF1, const Mat& dF2 ) const
        {
            Mat dF2TdF1 = multiply_via_traits( detail::transpose( dF2 ), dF1 );
            return detail::add_transposed( dF2TdF1 );
        }

    private:
        Mat FT, FTF;
    };

    template < class Mat >
    class LeftCauchyGreenStrainTensor : public Chainer< LeftCauchyGreenStrainTensor< Mat > >
    {
    public:
        LeftCauchyGreenStrainTensor() = default;
        explicit LeftCauchyGreenStrainTensor( const Mat& F )
        {
            update( F );
        }

        void update( const Mat& F )
        {
            FT = detail::transpose( F );
            FFT = multiply_via_traits( F, FT );
        }

        const Mat& d0() const noexcept
        {
            return FFT;
        }

        Mat d1( const Mat& dF1 ) const
        {
            Mat FTdF1 = multiply_via_traits( dF1, FT );
            return detail::add_transposed( FTdF1 );
        }

        Mat d2( const Mat& dF1, const Mat& dF2 ) const
        {
            Mat dF1dF2T = multiply_via_traits( dF1, detail::transpose( dF2 ) );
            return detail::add_transposed( dF1dF2T );
        }

    private:
        Mat FT, FFT;
    };

    template < class Mat >
    auto strain_tensor( const Mat& A )
    {
        return RightCauchyGreenStrainTensor{ A };
    }

    template < Function F >
    auto strain_tensor( const F& f )
    {
        return RightCauchyGreenStrainTensor< decay_t< decltype( f() ) > >{ f() }( f );
    }

    template < class Mat >
    auto left_strain_tensor( const Mat& A )
    {
        return LeftCauchyGreenStrainTensor{ A };
    }

    template < Function F >
    auto left_strain_tensor( const F& f )
    {
        return LeftCauchyGreenStrainTensor< decay_t< decltype( f() ) > >{ f() }( f );
    }
} // namespace funcy::linalg