shellKinematics.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2019-2019 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef SHELLKINEMATICS
#define SHELLKINEMATICS
 
#include "dune/common/fmatrix.hh"
#include "dune/common/fvector.hh"
 
#include "fem/diffops/materialLaws.hh"
#include "fem/fixdune.hh"
#include "fem/shapefunctioncache.hh"
 
 
namespace Kaskade::Elastomechanics
{
  template <int dim=2, class Real=double>
  class ShellKinematicsDerivative
  {
  public:
    using Vector = Dune::FieldVector<Real,dim+1>;
 
    using Matrix = Dune::FieldMatrix<Real,dim+1,dim+1>;
    using MatrixPair = std::pair<Matrix,Matrix>;
 
    ShellKinematicsDerivative();
 
    ShellKinematicsDerivative(Dune::FieldMatrix<Real,dim+1,dim> const& dphi_dx_,
                              Tensor<Real,dim+1,dim,dim> const& ddphi_ddx_,
                              Real t, Dune::FieldVector<Real,dim> const& dt_dx_);
 
    void setLinearizationPoint(Dune::FieldMatrix<Real,dim+1,dim> const& dphi_dx_,
                               Tensor<Real,dim+1,dim,dim> const& ddphi_ddx_,
                               Real t, Dune::FieldVector<Real,dim> const& dt_dx_);
 
    MatrixPair d0() const;
 
    MatrixPair d1(VariationalArg<Real,dim,1> const& v, int i) const;
 
    MatrixPair d2(VariationalArg<Real,dim,1> const& v, int i,
                  VariationalArg<Real,dim,1> const& w, int j) const;
 
  private:
    Dune::FieldVector<Real,dim+1>     phi, n;
    Dune::FieldMatrix<Real,dim+1,dim> dphi_dx, dn_dx;
    Tensor<Real,dim+1,dim,dim>        ddphi_ddx;
    Real                              t;
    Dune::FieldVector<Real,dim>       dt_dx;
  };
 
  template <int dim=2, class Real=double>
  class ShellKinematics
  {
  public:
    using Vector = Dune::FieldVector<Real,dim+1>;
 
    ShellKinematics(Vector const& phi, Dune::FieldMatrix<Real,dim+1,dim> const& dphi_dx, Real t);
 
    ShellKinematicsDerivative<dim,Real> derivative() const;
 
    Vector d0() const
    {
    }
 
    template <int row>
    auto d1(VariationalArg<Real,dim,1> const& v) const;
 
  private:
    Dune::FieldVector<Real,dim+1>     phi, n;
    Dune::FieldMatrix<Real,dim+1,dim> dphi_dx;
    Real                              t;
  };
 
  // ----------------------------------------------------------------------------------------------
 
  template <class Energy=MaterialLaws::StVenantKirchhoff<3,double>,
            class Real=double>
  class ShellEnergy
  {
  public:
    static int const dim = Energy::dim-1;
 
    ShellEnergy(Energy const& W, Real tau);
 
    ShellEnergy(Energy const& W, Real tau,
                Dune::FieldMatrix<Real,dim+1,dim> const& dphi_dx,
                Tensor<Real,dim+1,dim,dim> const& ddphi_ddx,
                Real t, Dune::FieldVector<Real,dim> const& dt_dx)
    : ShellEnergy(W,tau)
    {
      setLinearizationPoint(dphi_dx,ddphi_ddx,t,dt_dx);
    }
 
    void setLinearizationPoint(Dune::FieldMatrix<Real,dim+1,dim> const& dphi_dx,
                               Tensor<Real,dim+1,dim,dim> const& ddphi_ddx,
                               Real t, Dune::FieldVector<Real,dim> const& dt_dx);
 
    Real d0() const;
 
    template <int row>
    Dune::FieldVector<Real,row==0?dim+1:1> d1(VariationalArg<Real,dim,1> const& v) const;
 
    template <int row, int col>
    Dune::FieldMatrix<Real,row==0?dim+1:1,col==0?dim+1:1> d2(VariationalArg<Real,dim,1> const& v,
                                                             VariationalArg<Real,dim,1> const& w) const;
 
  private:
    Energy                              W;
    Real                                tau;
    ShellKinematicsDerivative<dim,Real> dPhi;
 
    using Matrix = typename ShellKinematicsDerivative<dim,Real>::Matrix;
 
    Matrix A, B, E, BtB, BtA, BtA_AtB;
 
    // compute first directional derivative of energy, given the first directional derivatives of contributing matrices A and B
    Real d1(std::pair<Matrix,Matrix> const& dAdB) const;
 
    // compute second directional derivative of energy, given the first and second directional derivatives of contributing matrices A and B
    // first derivatives need to be given in both directions, whereas the second derivative needs only one value
    // (order of differentiation irrelevant)
    Real d2(std::pair<Matrix,Matrix> const& dAdB1, std::pair<Matrix,Matrix> const& dAdB2,
            std::pair<Matrix,Matrix> const& ddAddB) const;
  };
}
 
#endif