ngsolve 6.2.2501.post21.dev1__cp312-cp312-macosx_10_15_universal2.whl → 6.2.2501.post37.dev1__cp312-cp312-macosx_10_15_universal2.whl

netgen/include/hdivdivfe.hpp

@@ -1,2923 +0,0 @@
-#ifndef FILE_HDIVDIVFE
-#define FILE_HDIVDIVFE
-
-/*********************************************************************/
-/* File:   hdivdivfe.hpp                                             */
-/* Author: Astrid Pechstein, Joachim Schoeberl                       */
-/* Date:   orig 2006, redesign Dec 2016                              */
-/*********************************************************************/
-
-#include "finiteelement.hpp"
-#include "fe_interfaces.hpp"
-
-#include "hcurlfe.hpp" // for Cross (AD,AD)
-#include "recursive_pol.hpp"
-#include "recursive_pol_trig.hpp"
-#include "recursive_pol_tet.hpp"
-#include "shapefunction_utils.hpp"
-
-namespace ngfem
-{
-
-  class BaseHDivDivFiniteElement : public FiniteElement
-  {
-  public:
-
-    using FiniteElement::ndof;
-    using FiniteElement::order;
-    bool algebraic_mapping = true;
-    
-    INLINE BaseHDivDivFiniteElement () { ; } 
-    INLINE BaseHDivDivFiniteElement (int andof, int aorder)
-      : FiniteElement (andof, aorder) { ; }
-
-    void SetAlgebraicMapping (bool am) { algebraic_mapping = am; }
-    
-    virtual void CalcShape (const IntegrationPoint & ip, 
-			    BareSliceMatrix<double> shape) const = 0;
-
-    virtual void CalcDivShape (const IntegrationPoint & ip,
-			       BareSliceMatrix<double> divshape) const = 0;
-  };
-  template <int DIM>
-  class HDivDivFiniteElement : public BaseHDivDivFiniteElement
-  {
-  public:
-    using BaseHDivDivFiniteElement::BaseHDivDivFiniteElement;
-    using BaseHDivDivFiniteElement::ndof;
-    using BaseHDivDivFiniteElement::order;
-
-    // old style
-    virtual void CalcShape (const IntegrationPoint & ip, 
-                            BareSliceMatrix<double> shape) const = 0;
-
-    virtual void CalcDivShape (const IntegrationPoint & ip, 
-                               BareSliceMatrix<double> divshape) const = 0;
-
-    // new implementation
-    virtual void CalcMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM> & mip,
-      BareSliceMatrix<double> shape) const = 0;
-
-    /*
-    virtual void CalcDDMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM> & mip,
-                                           BareSliceMatrix<double> shape) const = 0;
-    */
-    
-    virtual void CalcMappedShape_Vector (const MappedIntegrationPoint<DIM,DIM> & mip,
-      BareSliceMatrix<double> shape) const = 0;
-
-    virtual void CalcMappedDivShape (const BaseMappedIntegrationPoint & mip,
-      BareSliceMatrix<double> shape) const = 0;
-
-
-    virtual void CalcMappedShape_Matrix (const SIMD_BaseMappedIntegrationRule & mir, 
-                                         BareSliceMatrix<SIMD<double>> shapes) const = 0;
-    
-    virtual void Evaluate_Matrix (const SIMD_BaseMappedIntegrationRule & ir,
-                                  BareSliceVector<> coefs,
-                                  BareSliceMatrix<SIMD<double>> values) const = 0;
-
-    virtual void AddTrans_Matrix (const SIMD_BaseMappedIntegrationRule & ir,
-                                  BareSliceMatrix<SIMD<double>> values,
-                                  BareSliceVector<> coefs) const = 0;
-
-    virtual void CalcDualShape (const BaseMappedIntegrationPoint & bmip, BareSliceMatrix<> shape) const = 0;
-    virtual void CalcDualShape (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceMatrix<SIMD<double>> shape) const = 0;
-    virtual void EvaluateDual (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs, BareSliceMatrix<SIMD<double>> values) const = 0;
-    virtual void AddDualTrans (const SIMD_BaseMappedIntegrationRule& bmir, BareSliceMatrix<SIMD<double>> values, BareSliceVector<double> coefs) const = 0;
-
-
-    virtual void CalcMappedDivShape (const SIMD_BaseMappedIntegrationRule & bmir, 
-                      BareSliceMatrix<SIMD<double>> divshapes) const = 0;
-
-    virtual void EvaluateDiv (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs,
-			      BareSliceMatrix<SIMD<double>> values) const = 0;
-
-    virtual void AddDivTrans (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceMatrix<SIMD<double>> values,
-			      BareSliceVector<> coefs) const=0;
-
-    virtual void CalcShape_NormalComponent (const SIMD_BaseMappedIntegrationRule & mir, 
-                                            BareSliceMatrix<SIMD<double>> shapes) const = 0;
-    
-    virtual list<tuple<string,double>> Timing () const;
-  };
-
-  template <int D,typename VEC,typename MAT>
-  void VecToSymMat(const VEC & vec,MAT && mat)
-  {
-    switch(D)
-    {
-    case 2:
-      mat(0) = vec(0);
-      mat(3) = vec(1);
-      mat(1) = mat(2) = vec(2);
-      break;
-    case 3:
-      auto v0 = vec(0);
-      auto v1 = vec(1);
-      auto v2 = vec(2);
-      auto v3 = vec(3);
-      auto v4 = vec(4);
-      auto v5 = vec(5);
-      mat(0) = v0;
-      mat(1) = v5;
-      mat(2) = v4;
-      mat(3) = v5;
-      mat(4) = v1;
-      mat(5) = v3;
-      mat(6) = v4;
-      mat(7) = v3;
-      mat(8) = v2;
-      /*
-      mat(0) = vec(0);
-      mat(4) = vec(1);
-      mat(8) = vec(2);
-      mat(1) = mat(3) = vec(5);
-      mat(2) = mat(6) = vec(4);
-      mat(5) = mat(7) = vec(3);
-      */
-      break;
-    }
-  }
-  
-  template <typename T>
-  auto SymMatToVecDual (const Mat<2,2,T> & mat) 
-  {
-    return Vec<3,T> { mat(0,0), mat(1,1), mat(0,1)+mat(1,0) };
-  }
-  
-  template <typename T>
-  auto SymMatToVecDual (const Mat<3,3,T> & mat) 
-  {
-    return Vec<6,T> { mat(0,0), mat(1,1), mat(2,2), mat(1,2)+mat(2,1), mat(0,2)+mat(2,0), mat(0,1)+mat(1,0) };
-  }
-
-  
-  template <typename T>
-  Mat<2,2,T> DyadProd(Vec<2,T> a, Vec<2,T> b)
-  {
-    // return Matrix<T>({{a(0)*b(0), a(0)*b(1)}, {a(1)*b(0), a(1)*b(1)}} );
-    return { a(0)*b(0), a(0)*b(1),  a(1)*b(0), a(1)*b(1) };
-  }
-
-  template <typename T>
-  Mat<3,3,T> DyadProd(Vec<3,T> a, Vec<3,T> b)
-  {
-    // return Matrix<T>( {{a(0)*b(0), a(0)*b(1), a(0)*b(2)}, {a(1)*b(0), a(1)*b(1), a(1)*b(2)}, {a(2)*b(0), a(2)*b(1), a(2)*b(2)}} );
-    return { a(0)*b(0), a(0)*b(1), a(0)*b(2),   a(1)*b(0), a(1)*b(1), a(1)*b(2),   a(2)*b(0), a(2)*b(1), a(2)*b(2) };
-  }
-
-  template <ELEMENT_TYPE ET> class HDivDivFE;
-
-  
-  template <ELEMENT_TYPE ET, typename SHAPES = HDivDivFE<ET>>
-  class T_HDivDivFE : public HDivDivFiniteElement<ET_trait<ET>::DIM>,
-    public VertexOrientedFE<ET>
-  {
-  protected:
-    enum { DIM = ET_trait<ET>::DIM };
-    enum { DIM_STRESS = (DIM*(DIM+1))/2 };
-    
-    using VertexOrientedFE<ET>::vnums;
-    using HDivDivFiniteElement<ET_trait<ET>::DIM>::ndof;
-    using HDivDivFiniteElement<ET_trait<ET>::DIM>::order;
-
-    //enum { N_VERTEX = ET_trait<ET>::N_VERTEX };
-    //enum { N_FACET   = ET_trait<ET>::N_FACET };    
-    //
-    //size_t vnums[N_VERTEX];
-    IVec<DIM-1> order_facet[ET_trait<ET>::N_FACET];
-    IVec<DIM> order_inner;
-
-    // additional div-div free bubbles
-    bool plus;
-
-  public:
-    using VertexOrientedFE<ET>::SetVertexNumbers;
-    
-    T_HDivDivFE (int aorder, bool _plus = false)
-      : plus(_plus)
-    {
-      order = aorder;
-      for (auto & of : order_facet) of = aorder;
-      order_inner = aorder;
-      //ndof = DIM*(DIM+1)/2 * ET_trait<ET>::PolDimension(aorder);
-
-    }
-    
-    virtual ELEMENT_TYPE ElementType() const override { return ET; }
-    // const HDivDivFE<ET> * Cast() const { return static_cast<const HDivDivFE<ET>*> (this); }
-    auto * Cast() const { return static_cast<const SHAPES*> (this); } 
-    
-    INLINE void SetOrderFacet (int nr, IVec<DIM-1,int> order) { order_facet[nr] = order; }
-    INLINE void SetOrderInner (IVec<DIM,int> order) { order_inner = order; }
-
-    virtual void ComputeNDof()
-    {
-      cout << "Error, T_HDivDivFE<ET>:: ComputeNDof not available, only for ET == TRIG" << endl;
-    }
-
-   template <typename T, typename TFA> 
-   void T_CalcShape (TIP<DIM,AutoDiff<DIM,T>> tip, TFA & shape) const
-    {
-      if constexpr (DIM == 2)
-                     Cast() -> T_CalcShape (TIP<DIM,AutoDiffDiff<DIM,T>> (tip), shape);
-      else
-        Cast() -> T_CalcShape (tip, shape);        
-    }
-
-   template <typename T, typename TFA> 
-   void T_CalcShape (TIP<DIM,AutoDiffDiff<DIM,T>> tip, TFA & shape) const
-    {
-      if constexpr (DIM == 2)
-                     Cast() -> T_CalcShape (tip, shape);
-      else
-        throw Exception ("dd shapes are not supported in 3D");
-    }
-
-    
-    // old style
-    virtual void CalcShape (const IntegrationPoint & ip, 
-                            BareSliceMatrix<double> shape) const override
-    {
-      // Vec<DIM, AutoDiff<DIM> > adp = ip;
-      /*
-      Vec<DIM, AutoDiff<DIM>> adp;
-      for ( int i=0; i<DIM; i++)
-        adp(i) = AutoDiff<DIM>(ip(i),i);
-      auto tip = TIP<DIM, AutoDiff<DIM>> (adp, ip.FacetNr(), ip.VB());
-      */
-      /* Cast() -> */ T_CalcShape (GetTIPGrad<DIM>(ip), 
-                                   SBLambda([&] (int nr, auto val)
-                                            {
-                                              shape.Row(nr).Range(0,DIM_STRESS) = val.Shape();
-                                            }));
-    }
-
-    virtual void CalcDualShape (const BaseMappedIntegrationPoint & bmip, BareSliceMatrix<> shape) const override
-    {
-      shape.AddSize(ndof, sqr(bmip.DimSpace())) = 0.0;
-      Switch<4-DIM>
-        (bmip.DimSpace()-DIM,[this, &bmip, shape](auto CODIM)
-         {
-           auto & mip = static_cast<const MappedIntegrationPoint<DIM,DIM+CODIM.value>&> (bmip);
-
-           Cast() -> CalcDualShape2 (mip, SBLambda([&] (size_t nr, auto val)
-                                                   {
-                                                     shape.Row(nr) = val.AsVector();
-                                                   }));
-         });
-      
-    }
-
-    virtual void CalcDualShape (const SIMD_BaseMappedIntegrationRule& bmir, BareSliceMatrix<SIMD<double>> shapes) const override
-    {
-      Switch<4-DIM>
-        (bmir.DimSpace()-DIM,[this, &bmir, shapes](auto CODIM)
-         {
-           constexpr int DIMSPACE = DIM+CODIM.value;
-           auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM+CODIM.value>&> (bmir);
-
-           shapes.AddSize(ndof*sqr(DIMSPACE), mir.Size()) = 0.0;
-           for (size_t i = 0; i < mir.Size(); i++)
-             {
-               Cast() -> CalcDualShape2 (mir[i], SBLambda([shapes,i,DIMSPACE] (size_t j, auto val)
-                                                          {
-                                                            shapes.Rows(j*sqr(DIMSPACE), (j+1)*sqr(DIMSPACE)).Col(i).Range(0,sqr(DIMSPACE)) = val.AsVector();
-                                                          }));
-             }
-         });
-    }
-    
-    virtual void EvaluateDual (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs, BareSliceMatrix<SIMD<double>> values) const override
-    {
-      Switch<4-DIM>
-        (bmir.DimSpace()-DIM,[this,&bmir,coefs,values](auto CODIM)
-                             {
-                               constexpr int DIMSPACE = DIM+CODIM.value;
-                               auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM+CODIM.value>&> (bmir);
-                               for (size_t i = 0; i < mir.Size(); i++)
-                                 {
-                                   Mat<DIMSPACE,DIMSPACE,SIMD<double>> sum (SIMD<double>(0.0));
-                                   Cast() -> CalcDualShape2 (mir[i], SBLambda([&sum, coefs] (size_t j, auto val)
-                                                                              {
-                                                                                sum += coefs(j) * val;
-                                                                              }));
-                                   for (size_t k = 0; k < sqr(DIMSPACE); k++)
-                                     values(k, i) = sum(k);
-                                 }});
-    }
-    
-    virtual void AddDualTrans (const SIMD_BaseMappedIntegrationRule& bmir, BareSliceMatrix<SIMD<double>> values, BareSliceVector<double> coefs) const override
-    {
-      Switch<4-DIM>
-        (bmir.DimSpace()-DIM,[this,&bmir,coefs,values](auto CODIM)
-                             {
-                               constexpr int DIMSPACE = DIM+CODIM.value;
-                               auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM+CODIM.value>&> (bmir);
-                               for (size_t i = 0; i < mir.Size(); i++)
-                                 {
-                                   Mat<DIMSPACE,DIMSPACE,SIMD<double>> value;
-                                   for (size_t k = 0; k < sqr(DIMSPACE); k++)
-                                     value(k) = values(k, i);
-                                   
-                                   Cast()-> CalcDualShape2 (mir[i], SBLambda([value, coefs] (size_t j, auto val)
-                                                                             {
-                                                                               coefs(j) += HSum(InnerProduct(val,value));
-                                                                             }));
-                                 }});
-    }
-
-
-    virtual void CalcDivShape (const IntegrationPoint & ip,
-                               BareSliceMatrix<double> shape) const override
-    {
-      // MSVC internal compiler error
-      // Vec<DIM, AutoDiff<DIM> > adp = ip;
-      // TIP<DIM,AutoDiffDiff<DIM>> addp(adp);      
-      Vec<DIM, AutoDiff<DIM>> adp;
-      for (int i = 0; i < DIM; i++)
-        adp[i] = AutoDiff<DIM>(ip(i),i);
-
-      /* Cast() -> */ T_CalcShape (TIP<DIM, AutoDiff<DIM>> (adp, ip.FacetNr(), ip.VB()),
-                             SBLambda([shape] (int nr, auto val)
-                                      {
-                                        shape.Row(nr).Range(0,DIM) = val.DivShape();
-                                      }));
-    }
-
-    // new style
-    virtual void CalcMappedShape_Vector (const MappedIntegrationPoint<DIM,DIM> & mip,
-                            BareSliceMatrix<double> shape) const override
-    {
-      Vec<DIM, AutoDiff<DIM>> adp = mip;
-      /*
-      Vec<DIM, AutoDiffDiff<DIM>> addp;
-      for (int i=0; i<DIM; i++)
-      {
-        addp[i] = adp[i].Value();
-        addp[i].LoadGradient(&adp[i].DValue(0));
-      }
-      */
-      /* Cast() -> */ T_CalcShape (TIP<DIM, AutoDiff<DIM>> (adp, mip.IP().FacetNr(), mip.IP().VB()),
-                             SBLambda([&] (int nr, auto val)
-                                      {
-                                        shape.Row(nr).Range(0,DIM_STRESS) = val.Shape();
-                                      }));
-    }
-
-
-    virtual void CalcMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM> & mip,
-                                         BareSliceMatrix<double> shape) const override
-    {
-      /*
-      auto tip = this->algebraic_mapping ? TIP<DIM, AutoDiffDiff<DIM>>(GetTIP(mip)) : GetTIPHesse(mip);
-      T_CalcShape (tip, 
-                   SBLambda([&](int nr,auto val)
-                            {
-                              VecToSymMat<DIM> (val.Shape(), shape.Row(nr));
-                            }));
-      */
-      if (this->algebraic_mapping)
-        T_CalcShape (GetTIP(mip), 
-                     SBLambda([&](int nr,auto val)
-                              {
-                                VecToSymMat<DIM> (val.Shape(), shape.Row(nr));
-                              }));
-      else
-        T_CalcShape (GetTIPHesse(mip), 
-                     SBLambda([&](int nr,auto val)
-                              {
-                                VecToSymMat<DIM> (val.Shape(), shape.Row(nr));
-                              }));
-    }
-
-    /*
-    virtual void CalcDDMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM> & mip,
-                                           BareSliceMatrix<double> shape) const override
-    {
-      T_CalcShape (GetTIPHesse(mip), 
-                   SBLambda([&](int nr,auto val)
-                            {
-                              VecToSymMat<DIM> (val.Shape(), shape.Row(nr));
-                            }));
-    }
-    */
-    
-
-    virtual void CalcMappedDivShape (const BaseMappedIntegrationPoint & bmip,
-                                     BareSliceMatrix<double> shape) const override
-    {
-      auto & mip = static_cast<const MappedIntegrationPoint<DIM,DIM>&> (bmip);
-      if (!this->algebraic_mapping)
-        {
-          T_CalcShape (GetTIPHesse(mip), 
-                       SBLambda([&](int nr,auto val)
-                                {
-                                  shape.Row(nr).Range(0,DIM) = val.DivShape();
-                                }));
-          return;
-        }
-
-      if (!mip.GetTransformation().IsCurvedElement()) // non-curved element
-        {
-          T_CalcShape (GetTIP(mip), 
-                       SBLambda([&](int nr,auto val)
-                                {
-                                  shape.Row(nr).Range(0,DIM) = val.DivShape();
-                                }));
-          return;
-        }
-      // curved element
-      
-      if (false) // eval on physical element
-        {
-          Mat<DIM> inv = mip.GetJacobianInverse();
-
-          Vec<DIM,Mat<DIM>> hesse, hesse_inv;
-          mip.CalcHesse (hesse);
-
-          /*
-            
-            div ( 1/J F sigma_ref  F^T 1/J ) 
-            = deriv (1/J F)  sigma_ref F^T 1/J  +  1/J F div(sigma_ref F^T 1/J) = I + II
-
-            I  ... Hessian : sigma + grad(1/J) sigma 
-            II ... by DivShape of SigmaGrad templates, as for non-curved elements
-
-           */ 
-
-          /*
-          for (int k = 0; k < DIM; k++)
-            hesse_inv(k) = Trans(inv) * hesse(k) * inv;
-
-          Vec<DIM> gradJ_xi;
-          for (int k = 0; k < DIM; k++)
-            {
-              double sum = 0;
-              for (int i = 0; i < DIM; i++)
-                for (int j = 0; j < DIM; j++)
-                  sum += inv(j,i) * hesse(i)(j,k);
-              gradJ_xi(k) = sum;
-            }
-          Vec<DIM> gradJ = Trans(inv) * gradJ_xi;
-          for (int k = 0; k < DIM; k++)
-            for (int l = 0; l < DIM; l++)
-              hesse_inv(k)(l,k) -= gradJ(l);
-          */
-
-          // saving a view operations ...
-          Vec<DIM, Mat<DIM>> hesse_inv1;
-          
-          for (int k = 0; k < DIM; k++)
-            hesse_inv1(k) = hesse(k) * inv;          
-          
-          Vec<DIM> gradJ_xi = 0.0;
-          for (int i = 0; i < DIM; i++)
-            gradJ_xi += hesse_inv1(i).Col(i);
-          
-          for (int k = 0; k < DIM; k++)
-            hesse_inv1(k).Col(k) -= gradJ_xi;
-
-          for (int k = 0; k < DIM; k++)
-            hesse_inv(k) = Trans(inv) * hesse_inv1(k);
-
-          Mat<DIM,DIM_STRESS> hesse_inv_vec;
-          for (int k = 0; k < DIM; k++)
-            hesse_inv_vec.Row(k) = SymMatToVecDual(hesse_inv(k));
-
-          T_CalcShape (GetTIP(mip),  
-                       SBLambda([&] (int nr,auto val)
-                                {
-                                  shape.Row(nr).Range(0,DIM) = val.DivShape() + hesse_inv_vec * val.Shape();
-                                }));
-          return;
-        }
-
-
-      if (true) 
-        {
-          // eval on reference element
-          
-          Mat<DIM> inv = mip.GetJacobianInverse();
-          Mat<DIM> jac = mip.GetJacobian();
-          double det = Det(jac);
-          
-          Vec<DIM,Mat<DIM>> hesse = mip.CalcHesse();
-          
-          Vec<DIM> gradJ_xi = 0.0;
-          for (int i = 0; i < DIM; i++)
-            for (int j = 0; j < DIM; j++)
-              gradJ_xi += inv(j,i) * hesse(i).Col(j);
-
-          for (int i = 0; i < DIM; i++)
-            for (int j = 0; j < DIM; j++)
-              hesse(i).Col(j) -= jac(i,j) * gradJ_xi;
-          
-          Mat<DIM,DIM_STRESS> hesse_inv_vec;
-          for (int k = 0; k < DIM; k++)
-            hesse_inv_vec.Row(k) = 1/(det*det) * SymMatToVecDual(hesse(k));            
-          Mat<DIM> trans_div = 1/(det*det) * jac;
-          
-          T_CalcShape (GetTIPGrad<DIM>(mip.IP()),  
-                       SBLambda([&] (int nr,auto val) LAMBDA_INLINE
-                                {
-                                  shape.Row(nr).Range(0,DIM) = trans_div * val.DivShape() + hesse_inv_vec * val.Shape();
-                                }));
-          return;
-        }
-
-      
-
-      
-        /*  
-        Mat<DIM> jac = mip.GetJacobian();
-        Mat<DIM> inv_jac = mip.GetJacobianInverse();
-        Mat<DIM> hesse[3],finvT_h_tilde_finv[3];
-        mip.CalcHesse (hesse[0],hesse[1],hesse[2]);
-
-        Mat<DIM,DIM,AutoDiff<DIM> > f_tilde;
-        for(int i = 0; i < DIM; i++)
-        {
-          for(int j = 0; j < DIM; j++)
-          {
-            f_tilde(i,j).Value() = jac(i,j);
-            for(int k = 0; k < DIM; k++)
-              f_tilde(i,j).DValue(k) = hesse[i](j,k);
-          }
-        }
-
-        AutoDiff<DIM> ad_det = Det (f_tilde);
-        AutoDiff<DIM> iad_det = 1.0 / ad_det;
-        f_tilde *= iad_det;
-
-        for(int i=0; i<DIM; i++)
-        {
-          finvT_h_tilde_finv[i] = 0;
-          for(int alpha=0; alpha<DIM; alpha++)
-            for(int beta=0; beta<DIM; beta++)
-              for(int gamma=0; gamma<DIM; gamma++)
-                for(int delta=0; delta<DIM; delta++)
-                  finvT_h_tilde_finv[i](alpha,beta) += inv_jac(gamma,alpha)*f_tilde(i,gamma).DValue(delta)*inv_jac(delta,beta);
-        }
-
-        T_CalcShape (GetTIP(mip),  // TIP<DIM,AutoDiff<DIM>> (adp),
-                               SBLambda([&](int nr,auto val)
-                                  {
-                                    shape.Row(nr).Range(0,DIM) = val.DivShape();
-                                    BareVector<double> divshape = shape.Row(nr);
-                                    Vec<DIM_STRESS> vecshape = val.Shape();
-                                    Vec<DIM*DIM> matshape;
-                                    VecToSymMat<DIM> (vecshape, matshape);
-
-                                    for(int k=0; k<DIM; k++)
-                                    {
-                                      for(int j=0; j<DIM*DIM; j++)
-                                      {
-                                        divshape(k) += mip.GetJacobiDet() * finvT_h_tilde_finv[k](j) * matshape(j);
-                                      }
-                                    }
-                                    
-                                  }));
-      }
-        */
-      
-    }
-
-    template <int DIMSPACE>
-    void CalcMappedShape_Matrix2 (const SIMD_MappedIntegrationRule<DIM,DIMSPACE> & mir, 
-                                 BareSliceMatrix<SIMD<double>> shapes) const
-    {
-      // static Timer t("HDivDivFE - Matrix2", NoTracing);
-      // RegionTracer regtr(TaskManager::GetThreadId(), t);    
-
-      for (size_t i = 0; i < mir.Size(); i++)
-        {
-          if (DIM == DIMSPACE)
-            {
-              const SIMD_BaseMappedIntegrationRule & bmir = mir;
-              auto & mir2 = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&>(bmir);
-              // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = mir2[i];
-              auto shapesi = shapes.Col(i);
-              /* this->Cast() -> */ T_CalcShape (GetTIP(mir2[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                           SBLambda ([shapesi] (size_t j, auto val) 
-                                                     {
-                                                       auto shapeij = shapesi.Range(j*sqr(DIMSPACE),(j+1)*sqr(DIMSPACE));
-                                                       // VecToSymMat<DIM> (val.Shape(), shapeij);
-                                                       Mat<DIM,DIM,SIMD<double>> shapemat;
-                                                       VecToSymMat<DIM> (val.Shape(), shapemat);
-                                                       for (size_t i = 0; i < DIMSPACE*DIMSPACE; i++)
-                                                         shapeij(i) = shapemat(i);
-                                                     }));
-            }
-          else
-            {
-              auto jac = mir[i].GetJacobian();
-              auto d2 = sqr(mir[i].GetJacobiDet());
-              Vec<DIM_STRESS,SIMD<double>> hv;
-              Mat<DIM,DIM,SIMD<double>> mat;
-              SIMD<double> mem[DIMSPACE*DIMSPACE*DIM_STRESS];
-              // FlatMatrix<SIMD<double>> trans(DIMSPACE*DIMSPACE,DIM_STRESS,&mem[0]);
-              FlatMatrixFixWidth<DIM_STRESS, SIMD<double>> trans(DIMSPACE*DIMSPACE,&mem[0]);
-              for (int k = 0; k < DIM_STRESS; k++)
-                {
-                  hv = SIMD<double>(0.0);
-                  hv(k) = SIMD<double>(1.0);
-                  VecToSymMat<DIM> (hv, mat);
-                  Mat<DIMSPACE,DIMSPACE,SIMD<double>> physmat = 1/d2*(jac * mat * Trans(jac));
-                  trans.Col(k) = physmat.AsVector();
-                }
-              
-              
-              // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = mir.IR()[i];
-              // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-              
-              /* this->Cast() -> */ T_CalcShape (GetTIPGrad<DIM> (mir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                           SBLambda ([i,shapes,trans] (size_t j, auto val) 
-                                                     {
-                                                       shapes.Rows(j*sqr(DIMSPACE),(j+1)*sqr(DIMSPACE)).Col(i).Range(0,sqr(DIMSPACE)) = trans * val.Shape();
-                                                     }));
-            }
-        }
-    }
-
-    virtual void CalcShape_NormalComponent (const SIMD_BaseMappedIntegrationRule & bmir, 
-                                            BareSliceMatrix<SIMD<double>> shapes) const override
-    {
-      auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
-
-      for (size_t i = 0; i < mir.Size(); i++)
-        {
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = mir[i];
-          Vec<DIM,SIMD<double>> nv = mir[i].GetNV();
-          auto shapesi = shapes.Col(i);
-          /* this->Cast() -> */ T_CalcShape (GetTIP(mir[i]),   // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                       SBLambda ([shapesi, nv] (size_t j, auto val) 
-                                                 {
-                                                   auto shapeij = shapesi.Range(j*DIM,(j+1)*DIM);
-                                                   Mat<DIM,DIM,SIMD<double>> shapemat;
-                                                   VecToSymMat<DIM> (val.Shape(), shapemat);
-                                                   Vec<DIM,SIMD<double>> mnv = shapemat * nv;
-                                                   for (size_t i = 0; i < DIM; i++)
-                                                     shapeij(i) = mnv(i);
-                                                 }));
-        }
-    }
-    
-    virtual void CalcMappedShape_Matrix (const SIMD_BaseMappedIntegrationRule & bmir, 
-                                         BareSliceMatrix<SIMD<double>> shapes) const override
-    {
-      Iterate<4-DIM>
-        ([this, &bmir, shapes](auto CODIM) LAMBDA_INLINE
-         {
-           constexpr int CD = CODIM.value;
-           constexpr int DIMSPACE = DIM+CD;
-           if (bmir.DimSpace() == DIMSPACE)
-             {
-               auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
-               this->CalcMappedShape_Matrix2 (mir, shapes);
-#ifdef XXX
-               
-               for (size_t i = 0; i < mir.Size(); i++)
-                 {
-                   auto jac = mir[i].GetJacobian();
-                   auto d2 = sqr(mir[i].GetJacobiDet());
-
-                   Vec<DIM_STRESS,SIMD<double>> hv;
-                   Mat<DIM,DIM,SIMD<double>> mat;
-                   // Mat<DIMSPACE*DIMSPACE, DIM_STRESS,SIMD<double>> trans;
-                   SIMD<double> mem[DIMSPACE*DIMSPACE*DIM_STRESS];
-                   FlatMatrix<SIMD<double>> trans(DIMSPACE*DIMSPACE,DIM_STRESS,&mem[0]);
-                   for (int k = 0; k < DIM_STRESS; k++)
-                     {
-                       hv = SIMD<double>(0.0);
-                       hv(k) = SIMD<double>(1.0);
-                       VecToSymMat<DIM> (hv, mat);
-                       Mat<DIMSPACE,DIMSPACE,SIMD<double>> physmat =
-                         1/d2 * (jac * mat * Trans(jac));
-                       for (int j = 0; j < DIMSPACE*DIMSPACE; j++)
-                         trans(j,k) = physmat(j);
-                     }
-                   
-          
-                   Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = bmir.IR()[i];
-                   // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-
-                   this->Cast() -> T_CalcShape (adp,
-                                                SBLambda ([i,shapes,trans] (size_t j, auto val) LAMBDA_INLINE
-                                                    {
-                                                      /*
-                                                      Mat<DIM,DIM,SIMD<double>> mat;
-                                                      VecToSymMat<DIM> (val.Shape(), mat);
-                                                      Mat<DIMSPACE,DIMSPACE,SIMD<double>> physmat =
-                                                        1/d2 * (jac * mat * Trans(jac));
-                                                      for (size_t k = 0; k < sqr(DIMSPACE); k++)
-                                                        shapes(j*sqr(DIMSPACE)+k,i) = physmat(k);
-                                                      */
-                                                      Vec<DIMSPACE*DIMSPACE,SIMD<double>> transvec;
-                                                      transvec = (trans * val.Shape()).AsVector();
-                                                      for (size_t k = 0; k < sqr(DIMSPACE); k++)
-                                                        shapes(j*sqr(DIMSPACE)+k,i) = transvec(k);
-                                                    }));
-                 }
-#endif
-             }
-         });
-    }
-
-    virtual void Evaluate_Matrix (const SIMD_BaseMappedIntegrationRule & bmir,
-                                  BareSliceVector<> coefs,
-                                  BareSliceMatrix<SIMD<double>> values) const override
-    {
-      if (this->algebraic_mapping == false)
-        {
-          if (bmir.DimSpace() != DIM)
-            throw Exception ("sequential mapping only for volume space");
-          
-          auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
-          for (size_t i = 0; i < bmir.Size(); i++)
-            {
-              double *pcoefs = &coefs(0);
-              const size_t dist = coefs.Dist();
-              
-              Vec<DIM_STRESS,SIMD<double>> sum(0.0);
-              T_CalcShape (GetTIPHesse(mir[i]), 
-                           SBLambda ([&sum,&pcoefs,dist] (size_t j, auto val)
-                                     {
-                                       sum += (*pcoefs)*val.Shape();
-                                       pcoefs += dist;
-                                     }));
-              for (size_t k = 0; k < DIM_STRESS; k++)
-                values(k,i) = sum(k);
-            }
-          return;
-        }
-      
-      for (size_t i = 0; i < bmir.Size(); i++)
-        {
-          double *pcoefs = &coefs(0);
-          const size_t dist = coefs.Dist();
-          
-          Vec<DIM_STRESS,SIMD<double>> sum(0.0);
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = bmir.IR()[i];
-          // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-          
-          /* Cast() -> */ T_CalcShape (GetTIPGrad<DIM>(bmir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                 SBLambda ([&sum,&pcoefs,dist] (size_t j, auto val)
-                                           {
-                                             sum += (*pcoefs)*val.Shape();
-                                             pcoefs += dist;
-                                           }));
-
-          Mat<DIM,DIM,SIMD<double>> summat;
-          VecToSymMat<DIM> (sum, summat);
-          
-          Iterate<4-DIM>
-            ([values,&bmir,i,summat](auto CODIM)
-             {
-               constexpr auto DIMSPACE = DIM+CODIM.value;
-               if (bmir.DimSpace() == DIMSPACE)
-                 {
-                   auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
-                   auto jac = mir[i].GetJacobian();
-                   auto d2 = sqr(mir[i].GetJacobiDet());
-                   Mat<DIMSPACE,DIMSPACE,SIMD<double>> physmat = 1/d2 * (jac * summat * Trans(jac));
-                   for (size_t k = 0; k < sqr(DIMSPACE); k++)
-                     values(k,i) = physmat(k);
-                 }
-             });
-        }
-    }
-
-    virtual void AddTrans_Matrix (const SIMD_BaseMappedIntegrationRule & bmir,
-                                  BareSliceMatrix<SIMD<double>> values,
-                                  BareSliceVector<> coefs) const override
-    {
-       for (size_t i = 0; i < bmir.Size(); i++)
-        {
-          Mat<DIM,DIM,SIMD<double>> mat;
-          
-          Iterate<4-DIM>
-            ([&bmir,i,&mat,values](auto CODIM)
-             {
-               constexpr auto DIMSPACE = DIM+CODIM.value;
-               if (bmir.DimSpace() == DIMSPACE)
-                 {
-                   auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
-
-                   auto jac = mir[i].GetJacobian();
-                   auto d2 = sqr(mir[i].GetJacobiDet());
-
-                   Mat<DIMSPACE,DIMSPACE,SIMD<double>> physmat{};
-                   // physmat = values.Col(i);
-                   physmat.AsVector() = values.Col(i);                   
-                   mat = 1/d2 * Trans(jac) * physmat * jac;
-                 }
-             });
-          
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = bmir.IR()[i];
-          // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-          double *pcoefs = &coefs(0);
-          const size_t dist = coefs.Dist();
-
-          /* Cast() -> */ T_CalcShape (GetTIPGrad<DIM>(bmir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>  (adp),
-                                 SBLambda ([mat,&pcoefs,dist] (size_t j, auto val)
-                                           {
-                                             Mat<DIM,DIM,SIMD<double>> mat2;
-                                             VecToSymMat<DIM> (val.Shape(), mat2);
-                                             
-                                             *pcoefs += HSum(InnerProduct(mat,mat2));
-                                             pcoefs += dist;
-                                           }));
-        }
-    }
-
-
-    virtual void CalcMappedDivShape (const SIMD_BaseMappedIntegrationRule & bmir, 
-                      BareSliceMatrix<SIMD<double>> divshapes) const override
-    {
-      auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
-
-
-      if(!mir.GetTransformation().IsCurvedElement()) // non-curved element
-      {
-	for (size_t i = 0; i < mir.Size(); i++)
-	{
-          auto jac = mir[i].GetJacobian();
-          auto d2 = sqr(mir[i].GetJacobiDet());
-          
-          Vec<DIM,SIMD<double>> vec;
-          SIMD<double> mem[DIM*DIM_STRESS];
-          FlatMatrix<SIMD<double>> trans(DIM,DIM,&mem[0]);
-          trans = 1/d2 * jac;
-            /*
-            {
-              vec = SIMD<double>(0.0);
-              vec(k) = SIMD<double>(1.0);
-              Vec<DIM,SIMD<double>> physvec = 1/d2 * (jac * vec);
-              trans.Col(k) = physvec;
-            }
-            */
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = mir.IR()[i];
-          // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-	  /* Cast() -> */ T_CalcShape
-            (GetTIPGrad<DIM>(mir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-             SBLambda([divshapes,i,trans](int j,auto val)
-                      {
-                        divshapes.Rows(j*DIM,(j+1)*DIM).Col(i).Range(0,DIM) = trans * val.DivShape();
-                      }));
-	}
-      }
-      else
-      {
-        // throw ExceptionNOSIMD(string("HDivDiv - CalcMappedDivShape SIMD only for noncurved elements"));
-        for (size_t i = 0; i < mir.Size(); i++)
-          {
-            // static Timer t0("HDivDivFE - hesse", NoTracing);
-            // static Timer t1("HDivDivFE - prepare div", NoTracing);
-            // static Timer t2("HDivDivFE - calc div", NoTracing);
-            
-            Mat<DIM,DIM,SIMD<double>> jac = mir[i].GetJacobian();
-            Mat<DIM,DIM,SIMD<double>> inv_jac = mir[i].GetJacobianInverse();
-            Mat<DIM,DIM,SIMD<double>> finvT_h_tilde_finv[DIM];
-
-            // RegionTracer reg0(TaskManager::GetThreadId(), t0);
-            
-            Vec<DIM, Mat<DIM,DIM,SIMD<double>>> hesse;
-            mir.GetTransformation().CalcHesse (mir.IR()[i], hesse);
-
-            // RegionTracer reg1(TaskManager::GetThreadId(), t1);    
-
-            Mat<DIM,DIM,AutoDiff<DIM,SIMD<double>> > f_tilde;
-            for(int i = 0; i < DIM; i++)
-              for(int j = 0; j < DIM; j++)
-                {
-                  f_tilde(i,j).Value() = jac(i,j);
-                  for(int k = 0; k < DIM; k++)
-                    f_tilde(i,j).DValue(k) = hesse[i](j,k);
-                }
-            
-            AutoDiff<DIM,SIMD<double>> ad_det = Det (f_tilde);
-            AutoDiff<DIM, SIMD<double>> iad_det = 1.0 / ad_det;
-            f_tilde *= iad_det;
-            
-            for(int i=0; i<DIM; i++)
-              {
-                finvT_h_tilde_finv[i] = 0;
-                for(int alpha=0; alpha<DIM; alpha++)
-                  for(int beta=0; beta<DIM; beta++)
-                    for(int gamma=0; gamma<DIM; gamma++)
-                      for(int delta=0; delta<DIM; delta++)
-                        finvT_h_tilde_finv[i](alpha,beta) += inv_jac(gamma,alpha)*f_tilde(i,gamma).DValue(delta)*inv_jac(delta,beta);
-              }
-            for (int j = 0; j < DIM; j++)
-              finvT_h_tilde_finv[j] *= mir[i].GetJacobiDet();
-            
-            // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = mir[i];
-            // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-            // TIP<DIM,AutoDiff<DIM,SIMD<double>>> addp(adp);
-            // RegionTracer reg2(TaskManager::GetThreadId(), t2);    
-            /* Cast() -> */ T_CalcShape
-              (GetTIP(mir[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-               SBLambda([&](int nr,auto val)
-                              {
-                                BareSliceVector<SIMD<double>> divshape = divshapes.Rows(nr*DIM,(nr+1)*DIM).Col(i);
-
-                                Vec<DIM,SIMD<double>> div1 = val.DivShape();
-                                Vec<DIM_STRESS,SIMD<double>> vecshape = val.Shape();
-                                Vec<DIM*DIM,SIMD<double>> matshape;
-                                VecToSymMat<DIM> (vecshape, matshape);
-                                
-                                for(size_t k = 0; k < DIM; k++)
-                                  {
-                                    SIMD<double> sum = div1(k);
-                                    for(size_t j = 0; j < DIM*DIM; j++)
-                                      sum += finvT_h_tilde_finv[k](j) * matshape(j);
-                                    divshape(k) = sum;
-                                  }
-                              }));
-          }
-      }
-    }
-
-    virtual void EvaluateDiv (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs,
-			      BareSliceMatrix<SIMD<double>> values) const override
-    {
-      auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
-      if(!mir.GetTransformation().IsCurvedElement()) // non-curved element
-      {
-      for (size_t i = 0; i < bmir.Size(); i++)
-        {
-          double *pcoefs = &coefs(0);
-          const size_t dist = coefs.Dist();
-          
-          Vec<DIM,SIMD<double>> sum(0.0);
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = bmir.IR()[i];
-          // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-          
-          /* Cast() -> */ T_CalcShape (GetTIPGrad<DIM>(bmir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                 SBLambda ([&sum,&pcoefs,dist] (size_t j, auto val)
-                                           {
-                                             sum += (*pcoefs)*val.DivShape();
-                                             pcoefs += dist;
-                                           }));
-
-          Iterate<4-DIM>
-            ([values,&bmir,i,sum](auto CODIM)
-             {
-               constexpr auto DIMSPACE = DIM+CODIM.value;
-               if (bmir.DimSpace() == DIMSPACE)
-                 {
-                   auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
-                   auto jac = mir[i].GetJacobian();
-                   auto d2 = sqr(mir[i].GetJacobiDet());
-                   Vec<DIMSPACE,SIMD<double>> physvec = 1/d2 * (jac * sum);
-                   for (size_t k=0; k < DIMSPACE; k++)
-                     values(k,i) = physvec(k);
-                 }
-             });
-        }
-      }
-      else
-      {
-        throw ExceptionNOSIMD(string("HDivDiv - EvaluateDiv SIMD only for noncurved elements"));
-      }
-    }
-
-    virtual void AddDivTrans (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceMatrix<SIMD<double>> values,
-			      BareSliceVector<> coefs) const override
-    {
-      auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIM>&> (bmir);
-      if(!mir.GetTransformation().IsCurvedElement()) // non-curved element
-      {
-      for (size_t i = 0; i < bmir.Size(); i++)
-        {
-          Vec<DIM,SIMD<double>> vec;
-          
-          Iterate<4-DIM>
-            ([&bmir,i,&vec,values](auto CODIM)
-             {
-               constexpr auto DIMSPACE = DIM+CODIM.value;
-               if (bmir.DimSpace() == DIMSPACE)
-                 {
-                   auto & mir = static_cast<const SIMD_MappedIntegrationRule<DIM,DIMSPACE>&> (bmir);
-
-                   auto jac = mir[i].GetJacobian();
-                   auto d2 = sqr(mir[i].GetJacobiDet());
-
-                   Vec<DIMSPACE,SIMD<double>> physvec{};
-                   for (size_t k = 0; k < DIMSPACE; k++)
-                     physvec(k) = values(k,i);
-                   vec = 1/d2 * Trans(jac) * physvec;
-                 }
-             });
-          
-          // Vec<DIM,AutoDiff<DIM,SIMD<double>>> adp = bmir.IR()[i];
-          // TIP<DIM,AutoDiffDiff<DIM,SIMD<double>>> addp(adp);
-          double *pcoefs = &coefs(0);
-          const size_t dist = coefs.Dist();
-
-          /* Cast() -> */ T_CalcShape (GetTIPGrad<DIM> (bmir.IR()[i]), // TIP<DIM,AutoDiff<DIM,SIMD<double>>>(adp),
-                                 SBLambda ([vec,&pcoefs,dist] (size_t j, auto val)
-                                           {
-                                             *pcoefs += HSum(InnerProduct(vec,val.DivShape()));
-                                             pcoefs += dist;
-                                           }));
-        }
-      }
-      else
-      {
-        throw ExceptionNOSIMD(string("HDivDiv - AddTrans SIMD only for noncurved elements"));
-
-      }
-    }
-
-  };
-
-
-
-#ifdef FILE_HDIVDIVFE_CPP
-#define HDIVDIVFE_EXTERN
-#else
-#define HDIVDIVFE_EXTERN extern
-#endif
-
-  extern template class HDivDivFiniteElement<2>;
-  extern template class HDivDivFiniteElement<3>;
-  
-  
-  // ***************** SigmaGrad ****************************** */
-  // sigma (nabla u)
-  
-  template <int D, typename T> class T_SigmaGrad;
-  template <typename T> class T_SigmaGrad<2,T>
-  {
-    AutoDiffDiff<2,T> u;
-  public:
-    T_SigmaGrad  (AutoDiffDiff<2,T> au) : u(au) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> (u.DDValue(1,1), u.DDValue(0,0), -u.DDValue(1,0)); }
-    Vec<2,T> DivShape() { return Vec<2,T> (0.0, 0.0); }
-  };
-  
-  template <int D, typename T>
-  auto SigmaGrad (AutoDiffDiff<D,T> au) { return T_SigmaGrad<D,T>(au); }
-  
-  
-  // ***************** Sigma_u_Gradv ****************************** */
-  // sigma (u nabla v)
-  
-  template <int D, typename T> class T_Sigma_u_Gradv;
-  template <typename T> class T_Sigma_u_Gradv<2,T>
-  {
-    AutoDiffDiff<2,T> u, v;
-  public:
-    T_Sigma_u_Gradv  (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av) : u(au), v(av) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> ((u.Value()*v.DDValue(1,1) + u.DValue(1)*v.DValue(1)),
-                                        (u.Value()*v.DDValue(0,0) + u.DValue(0)*v.DValue(0)),
-                                        -u.Value()*v.DDValue(1,0) - 0.5 * (u.DValue(0)*v.DValue(1)+u.DValue(1)*v.DValue(0))); }
-    Vec<2,T> DivShape()
-    {
-      T uxx = u.DDValue(0,0), uyy = u.DDValue(1,1), uxy = u.DDValue(0,1);
-      T ux = u.DValue(0), uy = u.DValue(1);
-      T vxx = v.DDValue(0,0), vyy = v.DDValue(1,1), vxy = v.DDValue(0,1);
-      T vx = v.DValue(0), vy = v.DValue(1);
-      
-      return -0.5 * Vec<2,T> (uyy*vx - uxy*vy + uy*vxy - ux*vyy,
-                            -uxy*vx + uxx*vy - uy*vxx + ux*vxy);
-    }
-  };
-  
-  template <int D, typename T>
-  auto Sigma_u_Gradv (AutoDiffDiff<D,T> au, AutoDiffDiff<D,T> av) { return T_Sigma_u_Gradv<D,T>(au, av); }
-  
-  // ***************** Type2 ****************************** */
-  // ????
-  
-  template <int D, typename T> class T_Type2;
-  template <typename T> class T_Type2<2,T>
-  {
-    AutoDiffDiff<2,T> u,v;
-  public:
-    T_Type2  (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av) : u(au), v(av) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> (u.DDValue(1,1)*v.Value() - 2*u.DValue(1)*v.DValue(1) + u.Value()*v.DDValue(1,1),
-                                        u.DDValue(0,0)*v.Value() - 2*u.DValue(0)*v.DValue(0) + u.Value()*v.DDValue(0,0),
-                                        -(u.DDValue(0,1)*v.Value() - u.DValue(0)*v.DValue(1) -
-                                          u.DValue(1)*v.DValue(0) + u.Value()*v.DDValue(1,0))); }
-
-    Vec<2,T> DivShape()
-    {
-      T uxx = u.DDValue(0,0), uyy = u.DDValue(1,1), uxy = u.DDValue(0,1);
-      T ux = u.DValue(0), uy = u.DValue(1);
-      T vxx = v.DDValue(0,0), vyy = v.DDValue(1,1), vxy = v.DDValue(0,1);
-      T vx = v.DValue(0), vy = v.DValue(1);
-      
-      return Vec<2,T> (2*uyy*vx + 2*ux*vyy - 2*uxy*vy - 2*uy*vxy, 2*uxx*vy + 2*uy*vxx - 2*uxy*vx - 2*ux*vxy);
-    }
-  };
-  
-  template <int D, typename T>
-  auto Type2 (AutoDiffDiff<D,T> au, AutoDiffDiff<D,T> av) { return T_Type2<D,T>(au, av); }
-  
-  // ***************** Type3 ****************************** */
-  // ????
-  
-  template <int D, typename T> class T_Type3;
-  template <typename T> class T_Type3<2,T>
-  {
-    AutoDiffDiff<2,T> u,v;
-  public:
-    T_Type3  (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av) : u(au), v(av) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> (u.DDValue(1,1)*v.Value() - u.Value()*v.DDValue(1,1),
-                                    u.DDValue(0,0)*v.Value() - u.Value()*v.DDValue(0,0),
-                                    -(u.DDValue(0,1)*v.Value() - u.Value()*v.DDValue(1,0))); }
-    Vec<2,T> DivShape()
-    {
-      T uxx = u.DDValue(0,0), uyy = u.DDValue(1,1), uxy = u.DDValue(0,1);
-      T ux = u.DValue(0), uy = u.DValue(1);
-      T vxx = v.DDValue(0,0), vyy = v.DDValue(1,1), vxy = v.DDValue(0,1);
-      T vx = v.DValue(0), vy = v.DValue(1);
-
-      return Vec<2,T> (uyy*vx - uxy*vy - ux*vyy + uy*vxy, uxx*vy - uxy*vx - uy*vxx + ux*vxy);
-    }
-  };
-  
-  template <int D, typename T>
-  auto Type3 (AutoDiffDiff<D,T> au, AutoDiffDiff<D,T> av) { return T_Type3<D,T>(au, av); }
-
- 
-  template <int D, typename T> class T_vSigmaGradu;
-  template <typename T> class T_vSigmaGradu<2,T>
-  {
-    AutoDiffDiff<2,T> u,v;
-  public:
-    T_vSigmaGradu  (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av) : u(au), v(av) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> (u.DDValue(1,1)*v.Value(),
-                                      u.DDValue(0,0)*v.Value(),  -(u.DDValue(0,1)*v.Value()));}
-    Vec<2,T> DivShape()
-    {
-      T uxx = u.DDValue(0,0), uyy = u.DDValue(1,1), uxy = u.DDValue(0,1);
-      // T ux = u.DValue(0), uy = u.DValue(1);
-      // T vxx = v.DDValue(0,0), vyy = v.DDValue(1,1), vxy = v.DDValue(0,1);
-      T vx = v.DValue(0), vy = v.DValue(1);
-
-      return Vec<2,T> (uyy*vx- uxy*vy, uxx*vy- uxy*vx);
-    }
-  };
-  
-  template <int D, typename T>
-  auto vSigmaGradu (AutoDiffDiff<D,T> au, AutoDiffDiff<D,T> av) { return T_vSigmaGradu<D,T>(au, av); }
-
-  // ***************** Sigma ((vDu - uDv) w) ****************************** */
-  // where u, v are NOW POSSIBLY NON-linear hat basis functions (i.e. vDu - uDv is Nedelec0 edge basis function)
-  template <int D, typename T> class T_Sigma_Duv_minus_uDv_w;
-  template <typename T> class T_Sigma_Duv_minus_uDv_w<2,T>
-  {
-    AutoDiffDiff<2,T> u,v,w;
-  public:
-    T_Sigma_Duv_minus_uDv_w  (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiffDiff<2,T> aw) : u(au), v(av), w(aw) { ; }
-    Vec<3,T> Shape() { return Vec<3,T> (w.DValue(1)*(v.DValue(1)*u.Value()-u.DValue(1)*v.Value()), 
-      w.DValue(0)*(v.DValue(0)*u.Value()-u.DValue(0)*v.Value()),
-      -0.5*( w.DValue(0)*(v.DValue(1)*u.Value()-u.DValue(1)*v.Value()) +
-        w.DValue(1)*(v.DValue(0)*u.Value()-u.DValue(0)*v.Value()) )
-      ); }
-
-    Vec<2,T> DivShape()
-    {
-      T uxx = u.DDValue(0,0), uyy = u.DDValue(1,1), uxy = u.DDValue(0,1);
-      T ux = u.DValue(0), uy = u.DValue(1);
-      T vxx = v.DDValue(0,0), vyy = v.DDValue(1,1), vxy = v.DDValue(0,1);
-      T vx = v.DValue(0), vy = v.DValue(1);
-      T wxx = w.DDValue(0,0), wyy = w.DDValue(1,1), wxy = w.DDValue(0,1);
-      T wx = w.DValue(0), wy = w.DValue(1);
-
-      return Vec<2,T> (0.5*wxy*(vy*u.Value() - uy*v.Value()) 
-        -0.5*wyy*(vx*u.Value() - ux*v.Value())
-        +1.5*wy*(vy*ux - uy*vx) + 0.5*wy*(vxy*u.Value()-uxy*v.Value()) 
-        -0.5*wx*(vyy*u.Value()-uyy*v.Value()),
-        0.5*wxy*(vx*u.Value() - ux*v.Value()) 
-        -0.5*wxx*(vy*u.Value() - uy*v.Value())
-        +1.5*wx*(vx*uy - ux*vy) + 0.5*wx*(vxy*u.Value()-uxy*v.Value()) 
-        -0.5*wy*(vxx*u.Value()-uxx*v.Value())
-        ); 
-    }
-
-  };
-  
-
-  
-
-  class T_SymRotRot_Dl2xDl1_v
-  {
-    AutoDiff<2> l1,l2,v;
-  public:
-    T_SymRotRot_Dl2xDl1_v  (AutoDiff<2> lam1, AutoDiff<2> lam2, AutoDiff<2> av) : l1(lam1), l2(lam2), v(av) { ; }
-    Vec<3> Shape() { return Vec<3> (v.Value()*(l1.DValue(1)*l2.DValue(1)),
-      v.Value()*(l1.DValue(0)*l2.DValue(0)),
-      -0.5*v.Value()*(l1.DValue(1)*l2.DValue(0) + l1.DValue(0)*l2.DValue(1))
-      ); }
-
-    Vec<2> DivShape()
-    {
-      // todo
-      // double lam1 = l1.Value();
-      double lam1x = l1.DValue(0);
-      double lam1y = l1.DValue(1);
-      // double lam2 = l2.Value();
-      double lam2x = l2.DValue(0);
-      double lam2y = l2.DValue(1);
-      return Vec<2> (
-        v.DValue(0)*(lam1y*lam2y) - 0.5*v.DValue(1)*(lam1x*lam2y+lam1y*lam2x),
-        -0.5*v.DValue(0)*(lam1x*lam2y+lam1y*lam2x) + v.DValue(1)*(lam1x*lam2x)
-        ); 
-    }
-
-  };
-
-  template <int D, typename T>
-  auto Sigma_Duv_minus_uDv_w (AutoDiffDiff<D,T> au, AutoDiffDiff<D,T> av, AutoDiffDiff<D,T> aw)
-  { return T_Sigma_Duv_minus_uDv_w<D,T>(au, av, aw); }
-  
-  
-  template <ELEMENT_TYPE ET> class HDivDivFE : public T_HDivDivFE<ET> 
-  {
-  protected:
-    using T_HDivDivFE<ET> :: order;
-    using T_HDivDivFE<ET> :: ndof;
-  public:
-    template <typename T, typename TFA> 
-    void T_CalcShape (TIP<ET_trait<ET>::DIM,AutoDiffDiff<ET_trait<ET>::DIM,T>> ip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-  };
-
-  
-  template <> class HDivDivFE<ET_TRIG> : public T_HDivDivFE<ET_TRIG> 
-  {
-    
-  public:
-    using T_HDivDivFE<ET_TRIG> :: T_HDivDivFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<3; i++)
-      {
-        ndof += order_facet[i][0]+1;
-        order = max2(order, order_facet[i][0]);
-      }
-      int ninner = 3*order_inner[0]*(order_inner[0]+1)/2 ;
-      order = max2(order, order_inner[0]);
-      if (plus)
-      { 
-        order ++;
-        ninner += 2*order_inner[0]; 
-      }
-      ndof += ninner;
-
-    }
-   template <typename T, typename TFA> 
-   void T_CalcShape (TIP<2,AutoDiffDiff<2,T>> ip, TFA & shape) const
-    {
-      // typedef decltype(ip.x.Value()+ip.x.Value()) T;
-      typedef AutoDiffDiff<2, T> Tx;
-      Tx x = ip.x, y = ip.y;
-      Tx ddlami[3] ={ x, y, 1-x-y };
-      
-      int ii = 0;
-      
-      int maxorder_facet =
-        max2(order_facet[0][0],max2(order_facet[1][0],order_facet[2][0]));
-
-      const EDGE * edges = ElementTopology::GetEdges(ET_TRIG);
-
-      ArrayMem<Tx,20> ha(maxorder_facet+1);
-      ArrayMem<Tx,20> u(order_inner[0]+2), v(order_inner[0]+2);
-      
-      for (int i = 0; i < 3; i++)
-        {
-          int es = edges[i][0], ee = edges[i][1];
-          if (vnums[es] > vnums[ee]) swap (es,ee);
-          
-          Tx ls = ddlami[es], le = ddlami[ee];
-          
-          // edge functions are all div-free!
-          IntegratedLegendreMonomialExt::CalcTrigExt(maxorder_facet+2,
-                                                     le-ls, 1-le-ls, ha);
-
-          //ScaledLegendrePolynomial(maxorder_facet,le-ls, 1-le-ls,ha);
-
-          
-          for (int l = 0; l <= order_facet[i][0]; l++)
-            shape[ii++] = SigmaGrad (ha[l]);
-            //shape[ii++] = SymRotRot_Dl2xDl1_v_diffdiff(le, ls, ha[l]);
-        }
-      
-      int es = 0; int ee = 1; int et = 2;
-      Tx ls = ddlami[es];
-      Tx le = ddlami[ee];
-      Tx lt = ddlami[et];
-      
-      int oi=order_inner[0];
-      int oi_plus = oi; //plus ? oi+1 : oi;
-
-
-      IntegratedLegendreMonomialExt::CalcTrigExt(oi_plus+3,le-ls,1-le-ls,u);
-      LegendrePolynomial::EvalMult(oi_plus+1, 2*lt-1, lt, v);
-      
-      
-      for(int i = 0; i <= oi-1; i++)
-      {
-        for(int j = 0; j+i <= oi-1; j++)
-        {
-          shape[ii++] = SigmaGrad(u[i]*v[j]);
-          shape[ii++] = Type2(u[i],v[j]);
-        }
-      }
-      for(int i = 0; i <= oi_plus-1; i++)
-      {
-        for(int j = 0; j+i <= oi_plus-1; j++)
-        {
-          if(j > 0)
-            shape[ii++] = Type3(u[i],v[j]);
-        }
-      }
-      
-      for (int i = 0; i < oi_plus; i++)
-        shape[ii++] = Sigma_Duv_minus_uDv_w (le, -ls, v[i]);
-      
-      //// element bubbles for Sigma+ space
-      if (plus)
-        for (int i = 0; i <= oi-1; i++)
-          {
-            Tx bubble = u[i]*v[oi-1-i];
-            shape[ii++] = Sigma_u_Gradv(bubble, x);
-            shape[ii++] = Sigma_u_Gradv(bubble, y);
-          }
-    };
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      auto & ip = mip.IP();
-      typedef typename std::remove_const<typename std::remove_reference<decltype(mip.IP()(0))>::type>::type T;    
-      T x = ip(0), y = ip(1);
-      T lam[3] = { x, y, 1-x-y };
-      Vec<2,T> pnts[3] = { { 1, 0 }, { 0, 1 } , { 0, 0 } };
-      int facetnr = ip.FacetNr();
-
-      int ii = 0;
-
-      // const EDGE * edges = ElementTopology::GetEdges(ET_TRIG);
-
-      if (ip.VB() == BND)
-        { // facet shapes
-          for (int i = 0; i < 3; i++)
-            {
-              int p = order_facet[i][0];
-              
-              if (i == facetnr)
-                {
-                  IVec<2> e = ET_trait<ET_TRIG>::GetEdgeSort (i, vnums);
-                  
-                  T xi = lam[e[0]]-lam[e[1]];
-                  Vec<2,T> tauref = pnts[e[0]] - pnts[e[1]];
-                  
-                  Vec<2,T> nvref = Vec<2,T>(tauref[1],-tauref[0]);
-                  auto nv = Trans(mip.GetJacobianInverse())*nvref;
-                  auto nn = DyadProd(nv,nv);
-                  
-                  LegendrePolynomial::Eval
-                    (p, xi,
-                     SBLambda([&] (size_t nr, T val)
-                              {
-                                shape[nr+ii] = mip.GetMeasure()*val*nn;
-                              }));
-                }
-              ii += (p+1);
-            }
-        }
-      else
-        {
-          for (int i = 0; i < 3; i++)
-            ii += order_facet[i][0]+1;
-        }
-      if (ip.VB() == VOL)
-        {
-          auto p = order_inner[0]-1;
-          if( p >= 0 )
-            {
-              DubinerBasis::Eval (p, lam[0], lam[1],
-                                  SBLambda([&] (size_t nr, T val)
-                                           {
-                                             shape[ii++] = val*mip.GetMeasure()*mip.GetJacobian()*Mat<2,2>({{1,0},{0,0}})*Trans(mip.GetJacobian());
-                                             shape[ii++] = val*mip.GetMeasure()*mip.GetJacobian()*Mat<2,2>({{0,0},{0,1}})*Trans(mip.GetJacobian());
-                                             shape[ii++] = val*mip.GetMeasure()*mip.GetJacobian()*Mat<2,2>({{0,1},{1,0}})*Trans(mip.GetJacobian());
-                                           }));
-            }
-        }
-    }
-    
-  };
-  
-  template <> class HDivDivFE<ET_QUAD> : public T_HDivDivFE<ET_QUAD> 
-  {
-    
-  public:
-    using T_HDivDivFE<ET_QUAD> :: T_HDivDivFE;
-
-    enum {incsg = -1};
-    enum {incsugv = -1};
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<4; i++)
-      {
-        ndof += order_facet[i][0]+1;
-        order = max2(order, order_facet[i][0]);
-      }
-      int ninner = (order_inner[0]+1+incsg)*(order_inner[0]+1+incsg) + 
-        (order_inner[0]+2)*(order_inner[0]) *2 +
-        2*(order_inner[0]+1+incsugv) +1;
-      
-      /*
-      int ninner = (order_inner[0]+1+incsg)*(order_inner[0]+1+incsg) + 
-        (order_inner[0]+1)*(order_inner[0]) *2 +
-        2*(order_inner[0]+1+incsugv) +2;
-      if (plus) ninner += order_inner[0]*2;
-      */
-      order = max2(order, order_inner[0]);
-      order += 1;
-      ndof += ninner;
-
-    }
-   template <typename T, typename TFA> 
-   void T_CalcShape (TIP<2,AutoDiffDiff<2,T>> ip, TFA & shape) const
-    {
-      // typedef decltype(ip.x.Value()+ip.x.Value()) T;
-      typedef AutoDiffDiff<2, T> Tx;
-      
-      Tx x = ip.x, y = ip.y;
-      Tx lx[4] ={1-x, x, x, 1-x};
-      Tx ly[4] = {1-y, 1-y, y, y};
-      
-      int ii = 0;
-
-      const EDGE * edges = ElementTopology::GetEdges(ET_QUAD);
-
-      ArrayMem<Tx,20> u(order+2), v(order+2);
-      
-      for (int i = 0; i < 4; i++)
-        {
-          int es = edges[i][0], ee = edges[i][1];
-          if (vnums[es] > vnums[ee]) swap (es,ee);
-          
-          Tx xi = lx[ee]+ly[ee]-lx[es]-ly[es];
-          Tx eta = lx[es]*ly[es]+lx[ee]*ly[ee];
-
-	  IntegratedLegendreMonomialExt::Calc(order_facet[i][0]+2,xi,u);
-
-          
-          for (int l = 0; l <= order_facet[i][0]; l++)
-            // shape[ii++] = SigmaGrad (eta*u[l]);
-            shape[ii++] = Sigma_u_Gradv (eta, u[l]);
-            // shape[ii++] = vSigmaGradu(u[i],eta);
-        }
-
-
-      int oi=order_inner[0];
-
-      IntegratedLegendreMonomialExt::Calc(oi+3,lx[0]-lx[1],u);
-      IntegratedLegendreMonomialExt::Calc(oi+3,ly[0]-ly[2],v);
-
-      // original 
-      for(int i = 0; i <= oi+incsg; i++)
-      {
-        for(int j = 0; j <= oi+incsg; j++)
-        {
-          shape[ii++] = SigmaGrad(u[i]*v[j]);
-        }
-      }
-      for(int i = 0; i <= oi+1; i++)
-      {
-        for(int j = 0; j <= oi-1; j++)
-        {
-          shape[ii++] = vSigmaGradu(u[i],v[j]);
-          shape[ii++] = vSigmaGradu(v[i],u[j]);
-        }
-      }
-
-      shape[ii++] = Sigma_u_Gradv(lx[0], ly[0]);
-
-      for(int i = 0; i <= oi+incsugv; i++)
-      {
-        shape[ii++] = Sigma_u_Gradv(u[i], ly[0]);
-        shape[ii++] = Sigma_u_Gradv(v[i], lx[0]); //
-      }
-      
-      return;
-
-
-      
-      for (int i = 0; i <= oi+incsg+1; i++)
-        for (int j = 0; j <= oi+incsg+1; j++)
-          shape[ii++] = SigmaGrad(u[i]*v[j]);
-      
-      /*
-      for (int j = 0; j <= oi-1; j++)
-        {
-          shape[ii++] = SigmaGrad(u[oi+incsg+1]*v[j]);
-          shape[ii++] = SigmaGrad(v[oi+incsg+1]*u[j]);
-        }
-      */
-
-      for (int i = 0; i <= oi-1; i++)
-        for (int j = 0; j <= oi-1; j++)
-          {
-            shape[ii++] = vSigmaGradu(u[i],v[j]);
-            shape[ii++] = vSigmaGradu(v[i],u[j]);
-          }
-
-      if (plus)
-        for (int j = 0; j <= oi-1; j++)
-          {
-            // shape[ii++] = vSigmaGradu(u[oi+1],v[j]);
-            // shape[ii++] = vSigmaGradu(v[oi+1],u[j]);
-
-            shape[ii++] = Sigma_u_Gradv(v[j], u[oi]);
-            shape[ii++] = Sigma_u_Gradv(u[j], v[oi]);            
-          }
-
-      // shape[ii++] = Sigma_u_Gradv(lx[0], ly[0]);
-      shape[ii++] = SigmaGrad((2*x-1)*(2*y-1));
-      
-      for (int i = 0; i <= oi+incsugv; i++)
-        {
-          shape[ii++] = Sigma_u_Gradv(u[i], ly[0]);
-          shape[ii++] = Sigma_u_Gradv(v[i], lx[0]); //
-        }
-    };
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-
-  };
-
-
-
-  class HDivDivFE_QuadFullPol : public T_HDivDivFE<ET_QUAD, HDivDivFE_QuadFullPol> 
-  {
-    
-  public:
-    using T_HDivDivFE<ET_QUAD,HDivDivFE_QuadFullPol> :: T_HDivDivFE;
-    
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<4; i++)
-        {
-          ndof += order_facet[i][0]+1;
-          order = max2(order, order_facet[i][0]);
-        }
-      
-      int ninner = 1  //  sigma grad(xy)
-        + 2 * (order_inner[0]+1)*(order_inner[0]+2)  // inner nedelec
-        + sqr(order_inner[0]+1)
-        ;
-      if (plus)
-        ninner += 4*order_inner[0] + 4;
-      order = max2(order, order_inner[0]);
-      order += 2;
-      if (plus) order++;
-      ndof += ninner;
-    }
-    
-    template <typename T, typename TFA> 
-    void T_CalcShape (TIP<2,AutoDiffDiff<2,T>> ip, TFA & shape) const
-    {
-      typedef AutoDiffDiff<2, T> Tx;
-      
-      Tx x = ip.x, y = ip.y;
-      Tx lx[4] ={1-x, x, x, 1-x};
-      Tx ly[4] = {1-y, 1-y, y, y};
-      
-      int ii = 0;
-
-      const EDGE * edges = ElementTopology::GetEdges(ET_QUAD);
-
-      ArrayMem<Tx,20> u(order+2), v(order+2);
-      
-      for (int i = 0; i < 4; i++)
-        {
-          int es = edges[i][0], ee = edges[i][1];
-          if (vnums[es] > vnums[ee]) swap (es,ee);
-          
-          Tx xi = lx[ee]+ly[ee]-lx[es]-ly[es];
-          Tx eta = lx[es]*ly[es]+lx[ee]*ly[ee];
-
-	  IntegratedLegendreMonomialExt::Calc(order_facet[i][0]+2,xi,u);
-          
-          for (int l = 0; l <= order_facet[i][0]; l++)
-            // shape[ii++] = SigmaGrad (eta*u[l]);
-            shape[ii++] = Sigma_u_Gradv (eta, u[l]);
-        }
-
-      // shape[ii++] = SigmaGrad((2*x-1)*(2*y-1));
-      shape[ii++] = Sigma_u_Gradv((2*x-1),(2*y-1));
-
-      int oi=order_inner[0];
-
-      LegendrePolynomial (oi+1, 2*x-1, u);
-      LegendrePolynomial (oi+1, 2*y-1, v);
-      auto bubx = x*(1-x);
-      auto buby = y*(1-y);
-      for (int i = 0; i <= oi; i++)
-        for (int j = 0; j <= oi+1; j++)
-          {
-            shape[ii++] = Sigma_u_Gradv(bubx*u[i]*v[j], 2*y-1);
-            shape[ii++] = Sigma_u_Gradv(buby*u[j]*v[i], 2*x-1);
-          }
-
-      if (plus)
-        {
-          for (int i = 0; i <= oi; i++)
-            {
-              shape[ii++] = Sigma_u_Gradv(bubx*buby*u[i]*v[oi], 2*y-1);            
-              shape[ii++] = Sigma_u_Gradv(bubx*buby*u[oi]*v[i], 2*x-1);
-              shape[ii++] = Sigma_u_Gradv(bubx*buby*u[i]*v[oi+1], 2*y-1);            
-              shape[ii++] = Sigma_u_Gradv(bubx*buby*u[oi+1]*v[i], 2*x-1);
-            }
-        }
-      
-      for (int i = 0; i <= oi; i++)
-        for (int j = 0; j <= oi; j++)
-          shape[ii++] = vSigmaGradu(bubx,u[i]*v[j]*buby);
-
-      
-      if (ii != ndof)
-        cerr << "Hdivdivfe, full quad, ndof = " << ndof << " != ii = " << ii << endl;
-    }
-
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for quadfullpol");
-    }
-    
-  };
-
-
-
-
-
-
-
-
-
-
-  
-  // ***************** S_zz(uvw) ****************************** */
-  // write uvw into zz component
-  template <int D> class T_S_zz;
-  template <> class T_S_zz<3>
-  {
-    AutoDiff<2> u, v;
-    AutoDiff<1> w;
-  public:
-    T_S_zz ( AutoDiff<2> au, AutoDiff<2> av, AutoDiff<1> aw) : u(au), v(av), w(aw) { ; }
-    Vec<6> Shape() 
-    { 
-      Vec<6> sigma(0.);
-      sigma[2] = u.Value()*v.Value()*w.Value();
-      return sigma;
-    }
-
-    Vec<3> DivShape()
-    {
-      return Vec<3> (0., 0., u.Value()*v.Value()*w.DValue(0));
-    }
-
-  };
-  
-  template <int D>
-  auto S_zz (AutoDiff<D> au, AutoDiff<D> av, AutoDiff<1> aw)
-  { return T_S_zz<D+1>(au, av, aw); }
-    
-  // ***************** S_xz ****************************** */
-  template <int D, typename T> class T_S_xz;
-  template <typename T> class T_S_xz<3,T>
-  {
-    AutoDiff<2,T> uv;
-    AutoDiff<1,T> w;
-
-    int comp;
-  public:
-    T_S_xz ( int acomp, AutoDiff<2,T> auv, AutoDiff<1,T> aw) : uv(auv), w(aw), comp(acomp) { ; }
-    Vec<6,T> Shape() 
-    { 
-      Vec<6,T> sigma;
-      sigma = 0.;
-      if (comp==0)
-        sigma[4] = uv.Value()*w.Value();
-      else
-        sigma[3] = uv.Value()*w.Value();
-      return sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      if (comp == 0)
-        return Vec<3,T> (uv.Value()*w.DValue(0), 0, uv.DValue(0)*w.Value() );
-      else
-        return Vec<3,T> (0, uv.Value()*w.DValue(0), uv.DValue(1)*w.Value() );
-    }
-
-  };
-  
-  template <int D, typename T>
-  auto S_xz (int comp, AutoDiff<D,T> auv, AutoDiff<1,T> aw)
-  { return T_S_xz<D+1,T>(comp,auv, aw); }
-
-
-
-  template <typename T>
-  class T_Prism_wSigmaGradu
-  {
-    AutoDiffDiff<2,T> u;
-    AutoDiff<1,T> w;
-  public:
-    T_Prism_wSigmaGradu ( AutoDiffDiff<2,T> au, AutoDiff<1,T> aw) : u(au), w(aw) { ; }
-    Vec<6,T> Shape() 
-    { 
-      Vec<3,T> sigma2d = T_SigmaGrad<2,T>(u).Shape();
-      Vec<6,T> sigma(0.);
-      sigma[0] = w.Value()*sigma2d[0];
-      sigma[1] = w.Value()*sigma2d[1];
-      sigma[5] = w.Value()*sigma2d[2];
-      return sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      return Vec<3,T> (0., 0., 0);
-    }
-
-  };
-
-  template <typename T>
-  auto Prism_wSigmaGradu ( AutoDiffDiff<2,T> au, AutoDiff<1,T> aw)
-  { return T_Prism_wSigmaGradu<T>(au, aw); }
-
-
-  template <typename T>
-  class T_Prism_wType2
-  {
-    AutoDiffDiff<2,T> u, v;
-    AutoDiff<1,T> w;
-  public:
-    T_Prism_wType2 ( AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiff<1,T> aw) : u(au), v(av),  w(aw) { ; }
-    Vec<6,T> Shape() 
-    { 
-      Vec<3,T> sigma2d = T_Type2<2,T>(u,v).Shape();
-      Vec<6,T> sigma(0.);
-      sigma[0] = w.Value()*sigma2d[0];
-      sigma[1] = w.Value()*sigma2d[1];
-      sigma[5] = w.Value()*sigma2d[2];
-      return sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      Vec<2> divsigma2d = w.Value()*T_Type2<2,T>(u,v).DivShape();
-      return Vec<3,T> (divsigma2d[0], divsigma2d[1], 0);
-    }
-
-  };
-
-  template <typename T>
-  auto Prism_wType2 (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiff<1,T> aw)
-  { return T_Prism_wType2<T>(au, av, aw); }
-
-
-  template <typename T>
-  class T_Prism_wType3
-  {
-    AutoDiffDiff<2,T> u, v;
-    AutoDiff<1,T> w;
-  public:
-    T_Prism_wType3 ( AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiff<1,T> aw) : u(au), v(av),  w(aw) { ; }
-    Vec<6> Shape() 
-    { 
-      Vec<3,T> sigma2d = T_Type3<2,T>(u,v).Shape();
-      Vec<6,T> sigma(0.);
-      sigma[0] = w.Value()*sigma2d[0];
-      sigma[1] = w.Value()*sigma2d[1];
-      sigma[5] = w.Value()*sigma2d[2];
-      return sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      Vec<2,T> divsigma2d = w.Value()*T_Type3<2,T>(u,v).DivShape();
-      return Vec<3,T> (divsigma2d[0], divsigma2d[1], 0);
-    }
-  };
-
-  template <typename T>
-  auto Prism_wType3 (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiff<1,T> aw)
-  { return T_Prism_wType3<T>(au, av, aw); }
-
-
-  template <typename T>
-  class T_Prism_wType4
-  {
-    AutoDiffDiff<2,T> u, v, w;
-    AutoDiff<1,T> wz;
-  public:
-    T_Prism_wType4 ( AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiffDiff<2,T> aw, AutoDiff<1,T> awz) : u(au), v(av),  w(aw), wz(awz) { ; }
-    Vec<6,T> Shape() 
-    { 
-      Vec<3,T> sigma2d = wz.Value()*T_Sigma_Duv_minus_uDv_w<2,T>(u,v,w).Shape();
-      Vec<6,T> sigma(0.);
-      sigma[0] = sigma2d[0];
-      sigma[1] = sigma2d[1];
-      sigma[5] = sigma2d[2];
-      return sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      Vec<2,T> divsigma2d = wz.Value()*T_Sigma_Duv_minus_uDv_w<2,T>(u,v,w).DivShape();
-      return Vec<3,T> (divsigma2d[0], divsigma2d[1], 0);
-    }
-
-  };
-
-  template <typename T>
-  auto Prism_wType4 (AutoDiffDiff<2,T> au, AutoDiffDiff<2,T> av, AutoDiffDiff<2,T> aw, AutoDiff<1,T> awz)
-  { return T_Prism_wType4<T>(au, av, aw, awz); }
-
-  
-
-  class Prism_SymRotRot_Dl2xDl1_vw
-  {
-    AutoDiff<2> l1,l2,v;
-    AutoDiff<1> wz;
-  public:
-    Prism_SymRotRot_Dl2xDl1_vw ( AutoDiff<2> lam1, AutoDiff<2> lam2, AutoDiff<2> av, AutoDiff<1> awz) : l1(lam1), l2(lam2), v(av), wz(awz) { ; }
-    Vec<6> Shape() 
-    { 
-      Vec<3> sigma2d = wz.Value()*T_SymRotRot_Dl2xDl1_v(l1,l2,v).Shape();
-      Vec<6> sigma(0.);
-      sigma[0] = sigma2d[0];
-      sigma[1] = sigma2d[1];
-      sigma[5] = sigma2d[2];
-      return sigma;
-    }
-
-    Vec<3> DivShape()
-    {
-      Vec<2> divsigma2d = wz.Value()*T_SymRotRot_Dl2xDl1_v(l1,l2,v).DivShape();
-      return Vec<3> (divsigma2d[0], divsigma2d[1], 0);
-    }
-
-  };
-
-  template <typename T>
-  class Prism_Dl1xDl3_symtensor_Dl2xDl4_u
-  {
-    AutoDiff<3,T> l1,l2,l3, l4;
-    AutoDiff<3,T> u;
-  public:
-    Prism_Dl1xDl3_symtensor_Dl2xDl4_u ( AutoDiff<3,T> lam1, AutoDiff<3,T> lam2, AutoDiff<3,T> alz1, AutoDiff<3,T> alz2, AutoDiff<3,T> av) 
-      : l1(lam1), l2(lam2), l3(alz1), l4(alz2), u(av) { ; }
-    INLINE Vec<6,T> Shape() 
-    { 
-      auto rotlam1 = Cross(l1, l3);
-      auto rotlam2 = Cross(l2, l4);
-
-      Vec<6,T> sigma(0.);
-      sigma[0] = u.Value()*rotlam1.DValue(0)*rotlam2.DValue(0);
-      sigma[1] = u.Value()*rotlam1.DValue(1)*rotlam2.DValue(1);
-      sigma[2] = u.Value()*rotlam1.DValue(2)*rotlam2.DValue(2);
-      sigma[3] = 0.5*u.Value()*(rotlam1.DValue(2)*rotlam2.DValue(1) + rotlam2.DValue(2)*rotlam1.DValue(1));
-      sigma[4] = 0.5*u.Value()*(rotlam1.DValue(2)*rotlam2.DValue(0) + rotlam2.DValue(2)*rotlam1.DValue(0));
-      sigma[5] = 0.5*u.Value()*(rotlam1.DValue(0)*rotlam2.DValue(1) + rotlam2.DValue(0)*rotlam1.DValue(1));
-      return sigma;
-    }
-
-    INLINE AutoDiff<3,T> Cross (const AutoDiff<3,T> & x,
-                                const AutoDiff<3,T> & y)
-    {
-      T hv[3];
-      hv[0] = x.DValue(1)*y.DValue(2)-x.DValue(2)*y.DValue(1);
-      hv[1] = x.DValue(2)*y.DValue(0)-x.DValue(0)*y.DValue(2);
-      hv[2] = x.DValue(0)*y.DValue(1)-x.DValue(1)*y.DValue(0);
-      return AutoDiff<3,T> (0,hv);
-    }
-    Vec<3,T> DivShape()
-    {
-      auto lam1 = Cross(l1, l3);
-      auto lam2 = Cross(l2, l4);
-      return Vec<3,T> (u.DValue(0)*lam1.DValue(0)*lam2.DValue(0) + 
-        0.5*(u.DValue(1)*(lam1.DValue(0)*lam2.DValue(1)+lam2.DValue(0)*lam1.DValue(1)) + u.DValue(2)*(lam1.DValue(0)*lam2.DValue(2)+lam2.DValue(0)*lam1.DValue(2))),
-        u.DValue(1)*lam1.DValue(1)*lam2.DValue(1) + 
-        0.5*(u.DValue(0)*(lam1.DValue(0)*lam2.DValue(1)+lam2.DValue(0)*lam1.DValue(1)) + u.DValue(2)*(lam1.DValue(1)*lam2.DValue(2)+lam2.DValue(1)*lam1.DValue(2))),
-        u.DValue(2)*lam1.DValue(2)*lam2.DValue(2) + 
-        0.5*(u.DValue(0)*(lam1.DValue(0)*lam2.DValue(2)+lam2.DValue(0)*lam1.DValue(2)) + u.DValue(1)*(lam1.DValue(1)*lam2.DValue(2)+lam2.DValue(1)*lam1.DValue(2)))
-        );
-    }
-
-  };
-
-
-  template <typename T>
-  class t1_symtensor_t2_u
-  {
-    AutoDiff<3,T> t1, t2;
-    AutoDiff<3,T> u;
-  public:
-    t1_symtensor_t2_u (AutoDiff<3,T> at1, AutoDiff<3,T> at2, AutoDiff<3,T> au) 
-      : t1(at1), t2(at2), u(au) { ; } 
-    INLINE Vec<6,T> Shape() 
-    { 
-      //auto rotlam1 = t1;
-      //auto rotlam2 = t2;
-
-      Vec<6,T> sigma(0.);
-      sigma[0] = t1.DValue(0)*t2.DValue(0);
-      sigma[1] = t1.DValue(1)*t2.DValue(1);
-      sigma[2] = t1.DValue(2)*t2.DValue(2);
-      sigma[3] = 0.5*(t1.DValue(2)*t2.DValue(1) + t2.DValue(2)*t1.DValue(1));
-      sigma[4] = 0.5*(t1.DValue(2)*t2.DValue(0) + t2.DValue(2)*t1.DValue(0));
-      sigma[5] = 0.5*(t1.DValue(0)*t2.DValue(1) + t2.DValue(0)*t1.DValue(1));
-      return u.Value()*sigma;
-    }
-
-    Vec<3,T> DivShape()
-    {
-      T ut1 = 0.5*(u.DValue(0)*t1.DValue(0) + u.DValue(1)*t1.DValue(1) + u.DValue(2)*t1.DValue(2));
-      T ut2 = 0.5*(u.DValue(0)*t2.DValue(0) + u.DValue(1)*t2.DValue(1) + u.DValue(2)*t2.DValue(2));
-      return Vec<3,T> (ut1*t2.DValue(0) + ut2*t1.DValue(0),
-                       ut1*t2.DValue(1) + ut2*t1.DValue(1),
-                       ut1*t2.DValue(2) + ut2*t1.DValue(2));
-    }
-
-  };
-
-
-
-  
-  template <> class HDivDivFE<ET_PRISM> : public T_HDivDivFE<ET_PRISM> 
-  {
-  public:
-    // order k+1 for certain components, for inner and boundary shapes
-    // analysis from TDNNS paper for case xx1=0, zz1=xx2=zz2=1 for inner and boundary shapes
-    // however, works also when boundary order is not increased.. check
-    enum { incrorder_xx1 = 0};
-    enum { incrorder_zz1 = 1};
-    enum { incrorder_xx2 = 1};
-    enum { incrorder_zz2 = 1};
-    enum { incrorder_xx1_bd = 0};
-    enum { incrorder_zz1_bd = 0};
-    enum { incrorder_xx2_bd = 0};
-    enum { incrorder_zz2_bd = 0};
-    using T_HDivDivFE<ET_PRISM> :: T_HDivDivFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<2; i++)
-      {
-        ndof += (order_facet[i][0]+1+incrorder_zz1_bd)*(order_facet[i][0]+2+incrorder_zz1_bd)/2;
-        order = max2(order, order_facet[i][0]+incrorder_zz1_bd);
-      }
-      for (int i=2; i<5; i++)
-      {
-        ndof += (order_facet[i][0]+1+incrorder_xx1_bd)*(order_facet[i][1]+1+incrorder_xx2_bd);
-        order = max2(order, order_facet[i][0]+incrorder_xx2_bd);
-      }
-      int oi0 = order_inner[0];
-      int oi2 = order_inner[2];
-      int ninner = 3*((oi0+1+incrorder_xx1)*(oi0+incrorder_xx1))/2 *(oi2+1+incrorder_xx2) 
-        + (oi0+1)*(oi0+2)*(oi2+1) 
-        + (oi0+1+incrorder_zz1)*(oi0+2+incrorder_zz1)*(oi2-1+incrorder_zz2)/2;
-      ndof += ninner; 
-
-      order = max3(order, oi0+incrorder_zz1, oi2+incrorder_zz2);
-
-    }
-
-    // works only with old-style Transformation
-    // does not work with CalcMappedShape
-   template <typename Tx, typename TFA> 
-    void T_CalcShape_Complex (TIP<3,Tx> ip, TFA & shape) const
-    {
-      AutoDiffDiff<2> x(ip.x.Value(),0);
-      AutoDiffDiff<2> y(ip.y.Value(),1);
-      AutoDiff<2> xd(ip.x.Value(),0);
-      AutoDiff<2> yd(ip.y.Value(),1);
-      AutoDiff<1> z(ip.z.Value(), 0);
-      AutoDiffDiff<2> lami[6] ={ x,y,1-x-y,x,y,1-x-y };
-      AutoDiff<2> lamid[6] ={ xd,yd,1-xd-yd,xd,yd,1-xd-yd };
-      AutoDiff<1> lamiz[6] ={ 1-z,1-z,1-z,z,z,z };
-
-      int ii = 0;
-      
-      int maxorder_facet =
-        max2(order_facet[0][0],max2(order_facet[1][0],order_facet[2][0]));
-
-      const FACE * faces = ElementTopology::GetFaces(ET_PRISM);
-
-      ArrayMem<AutoDiffDiff<2>,20> ha(maxorder_facet+2);
-      ArrayMem<AutoDiffDiff<2>,20> u(order+2), v(order+3);
-      ArrayMem<AutoDiff<2>,20> leg_u(order+2), leg_v(order+3);
-      ArrayMem<AutoDiff<1>,20> leg_w(order+2);
-
-      
-      // Trig faces, (p+1)(p+2)/2
-      for (int fa=0; fa<2; fa++)
-      {
-        int fav[3] ={faces[fa][0],faces[fa][1],faces[fa][2]};
-
-        //Sort vertices  first edge op minimal vertex
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        if(vnums[fav[1]] > vnums[fav[2]]) swap(fav[1],fav[2]);
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        
-        leg_u.SetSize(order_facet[fa][0]+incrorder_zz1_bd+1);
-        leg_v.SetSize(order_facet[fa][0]+incrorder_zz1_bd+1);
-        ScaledLegendrePolynomial(order_facet[fa][0]+incrorder_zz1_bd,lamid[fav[0]]-lamid[fav[1]],1-lamid[fav[0]]-lamid[fav[1]],leg_u);
-        LegendrePolynomial::Eval(order_facet[fa][0]+incrorder_zz1_bd,2 * lamid[fav[2]] - 1,leg_v);
-
-        for(int j = 0; j <= order_facet[fa][0]+incrorder_zz1_bd; j++)
-          for(int k = 0; k <= order_facet[fa][0]+incrorder_zz1_bd-j; k++)
-            shape[ii++] = S_zz(leg_u[j],leg_v[k],lamiz[fav[0]]);
-      }
-      // quad faces -- use face bubbles of trig multiplied by leg_w
-      // (px+1)(pz+1)
-      for(int fa = 2; fa < 5; fa++)
-      {
-        int fmax = 0;
-        for(int j = 1; j < 4; j++)
-          if(vnums[faces[fa][j]] > vnums[faces[fa][fmax]]) fmax = j;
-
-        int fz,ftrig;
-
-        fz = 3 - fmax;
-        ftrig = fmax^1;
-
-        fmax = faces[fa][fmax];
-        fz = faces[fa][fz];
-        ftrig = faces[fa][ftrig];
-
-
-        // int orderz = order_facet[fa][1];
-
-        bool rotate = false;
-        if(vnums[fz] > vnums[ftrig]) rotate = true;
-        leg_w.SetSize(order_facet[fa][1]+incrorder_xx2_bd+1);
-        ha.SetSize(order_facet[fa][0]+incrorder_xx1_bd+1);
-        LegendrePolynomial::Eval(order_facet[fa][1]+incrorder_xx2_bd,lamiz[fmax]*2-1,leg_w);
-
-
-        // edge functions are all div-free!
-        IntegratedLegendreMonomialExt::CalcTrigExt(order_facet[fa][0]+incrorder_xx1_bd+2,
-          lami[fmax]-lami[ftrig],1-lami[fmax]-lami[ftrig],ha);
-
-        if(rotate)
-          for(int k = 0; k <= order_facet[fa][1]+incrorder_xx2_bd; k++)
-            for(int l = 0; l <= order_facet[fa][0]+incrorder_xx1_bd; l++)
-            {
-              shape[ii++] = Prism_wSigmaGradu(ha[l],leg_w[k]);
-            }
-
-        else
-          for(int l = 0; l <= order_facet[fa][0]+incrorder_xx1_bd; l++)
-            for(int k = 0; k <= order_facet[fa][1]+incrorder_xx2_bd; k++)
-            {
-              shape[ii++] = Prism_wSigmaGradu(ha[l],leg_w[k]);
-            }
-
-
-      }
-
-
-
-      int oi = order_inner[0];
-      leg_u.SetSize(oi+incrorder_zz1+1);
-      leg_v.SetSize(oi+incrorder_zz1+1);
-      leg_w.SetSize(oi+incrorder_xx2+1);
-      u.SetSize(oi-1+incrorder_xx1+1);
-      v.SetSize(oi-1+incrorder_xx1+1);
-
-      ScaledLegendrePolynomial(oi+incrorder_zz1, lamid[0]-lamid[1], 1-lamid[0]-lamid[1], leg_u);
-      LegendrePolynomial::Eval(oi+incrorder_zz1, 2*lamid[2]-1, leg_v);
-      LegendrePolynomial::Eval(oi+incrorder_xx2, 2*lamiz[0]-1, leg_w);
-
-      // ------------------------------------
-      // based on elasticity-complex-based triangle shapes
-      IntegratedLegendreMonomialExt::CalcTrigExt(oi-1+incrorder_xx1+2,lami[0]-lami[1],1-lami[0]-lami[1],u);
-      LegendrePolynomial::EvalMult(oi-1+incrorder_xx1,2*lami[2]-1, lami[2], v);
-      for(int k=0; k<=oi+incrorder_xx2; k++)
-      {
-        for(int i = 0; i <= oi-1+incrorder_xx1; i++)
-        {
-          for(int j = 0; j+i <= oi-1+incrorder_xx1; j++)
-          {
-            shape[ii++] = Prism_wSigmaGradu(u[i]*v[j],leg_w[k]);
-            shape[ii++] = Prism_wType2(u[i],v[j],leg_w[k]);
-          }
-        }
-        for(int i = 0; i <= oi-1+incrorder_xx1; i++)
-        {
-          for(int j = 0; j+i <= oi-1+incrorder_xx1; j++)
-          {
-            if(j > 0)
-            {
-              shape[ii++] = Prism_wType3(u[i],v[j],leg_w[k]);
-            }
-          }
-        }
-        for (int i = 0; i < oi+incrorder_xx1; i++)
-        {
-          shape[ii++] = Prism_wType4 (lami[0], -lami[1], v[i],leg_w[k]);
-        }
-
-      }
-
-      // S_xz
-      for (int i=0; i<=oi; i++)
-      {
-        for (int j=0; j+i<=oi; j++)
-        {
-          AutoDiff<2> uv = leg_u[i]*leg_v[j];
-          for (int k=0; k<=oi; k++)
-          {
-            shape[ii++] = S_xz(0,uv, leg_w[k]);
-            shape[ii++] = S_xz(1,uv, leg_w[k]);
-          }
-        }
-      }
-
-      // S_zz
-      for(int k=0; k<=oi-2+incrorder_zz2; k++)
-      {
-        AutoDiff<1> bubw = leg_w[k]*lamiz[0]*(1-lamiz[0]);
-        for(int i=0; i<=oi+incrorder_zz1; i++)
-        {
-          for(int j=0; j<=oi+incrorder_zz1-i; j++)
-          {
-            shape[ii++] = S_zz(leg_u[i],leg_v[j],bubw);
-          }
-        }
-      }
-
-
-    };
-
-
-
-
-    // alternative to T_CalcShape, with "simpler" shape functions,
-    // that are described in anisotropic paper
-    // works with CalcMappedShape etc. routines, also for curved elements
-    template <typename T, typename TFA> 
-    void T_CalcShape/*_nocomplex*/ (TIP<3,AutoDiff<3,T>> ip, TFA & shape) const
-    {
-      // Tx x = ip.x, y = ip.y, z = ip.z;
-      AutoDiffDiff<3,T> x = ip.x, y = ip.y, z = ip.z;
-      // typedef decltype(x.Value()+x.Value()) T;
-      AutoDiff<3,T> xx(x.Value(), &x.DValue(0));
-      AutoDiff<3,T> yy(y.Value(), &y.DValue(0));
-      AutoDiff<3,T> zz(z.Value(), &z.DValue(0));
-      AutoDiff<3,T> lx[6] ={ xx, yy, 1-xx-yy, xx, yy, 1-xx-yy };
-      AutoDiff<3,T> lz[6] ={ 1-zz,1-zz,1-zz,zz,zz,zz };
-      int ii = 0;
-      
-      // int maxorder_facet =
-      // max2(order_facet[0][0],max2(order_facet[1][0],order_facet[2][0]));
-
-      const FACE * faces = ElementTopology::GetFaces(ET_PRISM);
-
-      ArrayMem<AutoDiff<3,T>,20> leg_u(order+2), leg_v(order+3);
-      ArrayMem<AutoDiff<3,T>,20> leg_w(order+2);
-
-      
-      // Trig faces, (p+1)(p+2)/2
-      for (int fa=0; fa<2; fa++)
-      {
-        int fav[3] ={faces[fa][0],faces[fa][1],faces[fa][2]};
-
-        //Sort vertices  first edge op minimal vertex
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        if(vnums[fav[1]] > vnums[fav[2]]) swap(fav[1],fav[2]);
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        
-        leg_u.SetSize(order_facet[fa][0]+incrorder_zz1_bd+1);
-        leg_v.SetSize(order_facet[fa][0]+incrorder_zz1_bd+1);
-        ScaledLegendrePolynomial(order_facet[fa][0]+incrorder_zz1_bd,lx[fav[0]]-lx[fav[1]],lx[fav[0]]+lx[fav[1]],leg_u);
-        LegendrePolynomial::Eval(order_facet[fa][0]+incrorder_zz1_bd,2 * lx[fav[2]] - 1,leg_v);
-
-        for(int j = 0; j <= order_facet[fa][0]+incrorder_zz1_bd; j++)
-          for(int k = 0; k <= order_facet[fa][0]+incrorder_zz1_bd-j; k++)
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[fav[0]], lx[fav[1]], lx[fav[2]], lx[fav[2]], leg_u[j]*leg_v[k]*lz[fav[0]]);
-      }
-      // quad faces -- use face bubbles of trig multiplied by leg_w
-      // (px+1)(pz+1)
-      for(int fa = 2; fa < 5; fa++)
-      {
-        int fmax = 0;
-        for(int j = 1; j < 4; j++)
-          if(vnums[faces[fa][j]] > vnums[faces[fa][fmax]]) fmax = j;
-
-        int fz,ftrig;
-
-        fz = 3 - fmax;
-        ftrig = fmax^1;
-
-        fmax = faces[fa][fmax];
-        fz = faces[fa][fz];
-        ftrig = faces[fa][ftrig];
-
-
-        // int orderz = order_facet[fa][1];
-
-        bool rotate = false;
-        if(vnums[fz] > vnums[ftrig]) rotate = true;
-        leg_w.SetSize(order_facet[fa][1]+incrorder_xx2_bd+1);
-        LegendrePolynomial::Eval(order_facet[fa][1]+incrorder_xx2_bd,lz[fmax]*2-1,leg_w);
-
-
-        ScaledLegendrePolynomial(order_facet[fa][0]+incrorder_xx1_bd, lx[fmax]-lx[ftrig], lx[fmax]+lx[ftrig], leg_u);      
-
-        if(rotate)
-          for(int k = 0; k <= order_facet[fa][1]+incrorder_xx2_bd; k++)
-            for(int l = 0; l <= order_facet[fa][0]+incrorder_xx1_bd; l++)
-            {
-              shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lz[fmax], lz[fz], lx[fmax], lx[ftrig], leg_u[l]* leg_w[k]);
-            }
-
-        else
-          for(int l = 0; l <= order_facet[fa][0]+incrorder_xx1_bd; l++)
-            for(int k = 0; k <= order_facet[fa][1]+incrorder_xx2_bd; k++)
-            {
-              shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[fmax], lx[ftrig], lz[fmax], lz[fz], leg_u[l]* leg_w[k]);
-            }
-
-
-      }
-
-
-
-      int oi = order_inner[0];
-      leg_u.SetSize(oi+incrorder_zz1+1);
-      leg_v.SetSize(oi+incrorder_zz1+1);
-      leg_w.SetSize(oi+incrorder_xx2+1);
-
-      ScaledLegendrePolynomial(oi+incrorder_zz1, lx[0]-lx[1], lx[0]+lx[1], leg_u);
-      LegendrePolynomial::Eval(oi+incrorder_zz1, 2*lx[2]-1, leg_v);
-      LegendrePolynomial::Eval(oi+incrorder_xx2, 2*lz[0]-1, leg_w);
-
-      for(int k=0; k<=oi+incrorder_xx2; k++)
-      {
-        for(int i = 0; i <= oi-1+incrorder_xx1; i++)
-        {
-          for(int j = 0; j+i <= oi-1+incrorder_xx1; j++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[0], lx[1], lz[0], lz[0], lx[2]*leg_u[i]*leg_v[j]* leg_w[k]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[2], lx[0], lz[0], lz[0], lx[1]*leg_u[i]*leg_v[j]* leg_w[k]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[1], lx[2], lz[0], lz[0], lx[0]*leg_u[i]*leg_v[j]* leg_w[k]);
-          }
-        }
-      }
-
-
-      // S_xz
-      for (int i=0; i<=oi; i++)
-      {
-        for (int j=0; j+i<=oi; j++)
-        {
-          for (int k=0; k<=oi; k++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lz[0], lx[1], lx[0], lx[0], leg_u[i]*leg_v[j]*leg_w[k]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lz[0], lx[0], lx[1], lx[1], leg_u[i]*leg_v[j]*leg_w[k]);
-          }
-        }
-      }
-
-      // S_zz
-      for(int k=0; k<=oi-2+incrorder_zz2; k++)
-      {
-        AutoDiff<3,T> bubw = leg_w[k]*lz[0]*(1-lz[0]);
-        for(int i=0; i<=oi+incrorder_zz1; i++)
-        {
-          for(int j=0; j<=oi+incrorder_zz1-i; j++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[0], lx[2], lx[1], lx[1], leg_u[i]*leg_v[j]*bubw);
-          }
-        }
-      }
-
-
-    };
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-
-
-  };
-
-
-  template <> class HDivDivFE<ET_TET> : public T_HDivDivFE<ET_TET> 
-  {
-  public:
-    using T_HDivDivFE<ET_TET> :: T_HDivDivFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<4; i++)
-      {
-        ndof += (order_facet[i][0]+1)*(order_facet[i][0]+2)/2;
-        order = max2(order, order_facet[i][0]);
-      }
-      int p = order_inner[0];
-      int ninner = (p+1)*(p+2)*(p+1);
-      ndof += ninner; 
-
-      order = max2(order, p);
-      if (plus)
-        {
-          ndof += 2*(p+1)*(p+2);
-          order = max2(order, p+1);
-        }
-    }
-
-
-    template <typename T, typename TFA> 
-    void T_CalcShape (TIP<3,AutoDiff<3,T>> ip, TFA & shape) const
-    {
-      AutoDiff<3,T> lam[4] = { ip.x, ip.y, ip.z, 1.0-ip.x-ip.y-ip.z };
-      size_t ii = 0;
-      
-      //const FACE * faces = ElementTopology::GetFaces(ET_TET);
-
-      /*
-      ArrayMem<AutoDiff<3,T>,20> leg_u(order+2), leg_v(order+3);
-      ArrayMem<AutoDiff<3,T>,20> leg_w(order+2);
-      */
-
-      typedef AutoDiff<3,T> ADT;
-      STACK_ARRAY(ADT, leg_u, order+2);
-      STACK_ARRAY(ADT, leg_v, order+3);
-      
-      for(int fa = 0; fa < 4; fa++)
-      {
-        int p = order_facet[fa][0];
-        /*
-        // int fav[3] = {faces[fa][0], faces[fa][1], faces[fa][2]};
-        //Sort vertices  first edge op minimal vertex
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0], fav[1]);
-        if(vnums[fav[1]] > vnums[fav[2]]) swap(fav[1], fav[2]);
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0], fav[1]);
-        */
-        
-        IVec<4> fav = GetVertexOrientedFace (fa);
-
-        ScaledLegendrePolynomial(p+1, lam[fav[0]]-lam[fav[1]],lam[fav[0]]+lam[fav[1]], &leg_u[0]);
-        LegendrePolynomial::Eval(p+1, 2 * lam[fav[2]] - 1, &leg_v[0]);
-
-        auto t1 = Cross(lam[fav[0]], lam[fav[2]]);
-        auto t2 = Cross(lam[fav[1]], lam[fav[2]]);
-        for(int j = 0; j <= p; j++)
-          for(int k = 0; k+j <= p; k++)
-          {
-            /*
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[fav[0]], lam[fav[1]],
-              lam[fav[2]], lam[fav[2]],leg_u[j]* leg_v[k]);
-            */
-            shape[ii++] = t1_symtensor_t2_u<T>(t1, t2, leg_u[j]* leg_v[k]);
-          }
-      }
-
-      int oi = order_inner[0];
-      /*
-      leg_u.SetSize(oi+1);
-      leg_v.SetSize(oi+1);
-      leg_w.SetSize(oi+1);
-
-      ScaledLegendrePolynomial(oi+1,lam[0]-lam[1],lam[0]+lam[1],leg_u);
-      ScaledLegendrePolynomial(oi+1,lam[2]-lam[0]-lam[1],lam[0]+lam[1]+lam[2],leg_v);
-      LegendrePolynomial::Eval(oi+1,2 * lam[3] - 1,leg_w);
-
-
-      for(int k=0; k<=oi; k++)
-      {
-        for(int i = 0; i+k <= oi; i++)
-        {
-          for(int j = 0; j+i+k <= oi; j++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[0], lam[1], lam[2], lam[3], leg_u[i]*leg_v[k]* leg_w[j]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[0], lam[2], lam[1], lam[3], leg_u[i]*leg_v[j]* leg_w[k]);
-          }
-        }
-      }
-
-      for(int fa = 0; fa < 4; fa++)
-      {
-        int fav[3] = {faces[fa][0], faces[fa][1], faces[fa][2]};
-        for(int k=0; k<=oi-1; k++)
-        {
-          for(int i = 0; i+k <= oi-1; i++)
-          {
-            for(int j = 0; j+i+k <= oi-1; j++)
-            {
-              shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[fav[0]],lam[fav[0]],lam[fav[1]],lam[fav[2]],
-                (1-lam[fav[0]]-lam[fav[1]]-lam[fav[2]])*leg_u[i]*leg_v[k]* leg_w[j]);
-            }
-          }
-        }
-
-      }
-      */
-      auto l0 = lam[0];
-      auto l1 = lam[1];
-      auto l2 = lam[2];
-      auto l3 = lam[3];
-      auto t01 = Cross(lam[0], lam[1]);
-      auto t02 = Cross(lam[0], lam[2]);
-      auto t03 = Cross(lam[0], lam[3]);
-      auto t12 = Cross(lam[1], lam[2]);      
-      auto t13 = Cross(lam[1], lam[3]);
-      auto t23 = Cross(lam[2], lam[3]);
-      DubinerBasis3D::Eval
-	(oi, lam[0], lam[1], lam[2],
-         SBLambda([shape, &ii, t02, t13, t01, t23] (size_t nr, auto val) LAMBDA_INLINE
-                  {
-                    /*
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[0], lam[1], lam[2], lam[3], val);
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[0], lam[2], lam[1], lam[3], val);
-                    */
-                    shape[ii++] = t1_symtensor_t2_u<T>(t02, t13, val);
-                    shape[ii++] = t1_symtensor_t2_u<T>(t01, t23, val);                    
-                  }));
-
-      DubinerBasis3D::Eval
-	(oi-1 + (plus?1:0), lam[0], lam[1], lam[2],
-         SBLambda([shape, &ii, t02, t03, t12, t13, t01, t23, l0,l1,l2,l3] (size_t nr, auto val) LAMBDA_INLINE
-                  {
-                    shape[ii++] = t1_symtensor_t2_u<T>(t01, t02, l3*val);
-                    shape[ii++] = t1_symtensor_t2_u<T>(t03, t13, l2*val);
-                    shape[ii++] = t1_symtensor_t2_u<T>(t23, t02, l1*val);
-                    shape[ii++] = t1_symtensor_t2_u<T>(t12, t13, l0*val);
-                    /*
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[0], lam[0], lam[1], lam[2], lam[3]*val);
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[3], lam[3], lam[0], lam[1], lam[2]*val);
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[2], lam[2], lam[3], lam[0], lam[1]*val);
-                    shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lam[1], lam[1], lam[2], lam[3], lam[0]*val);
-                    */
-                  }));
-
-      /*
-      if (plus)
-        {
-          // needs AutoDiffDiff !!!
-          auto l0 = lam[0];
-          auto l1 = lam[1];
-          auto l2 = lam[2];
-          auto l3 = lam[3];
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l0, l1, l1*l2*l3, l2, AutoDiff<3,T>(1.0));
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l0, l1, l1*l2*l3, l3, AutoDiff<3,T>(1.0));
-
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l1, l2, l0*l2*l3, l0, AutoDiff<3,T>(1.0));
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l1, l2, l0*l2*l3, l3, AutoDiff<3,T>(1.0));
-
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l2, l3, l1*l0*l3, l0, AutoDiff<3,T>(1.0));
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l2, l3, l1*l0*l3, l1, AutoDiff<3,T>(1.0));
-          
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l3, l0, l1*l2*l0, l1, AutoDiff<3,T>(1.0));
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T> (l3, l0, l1*l2*l0, l2, AutoDiff<3,T>(1.0));
-        }
-      */
-    };
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-
-  };
-
-
-
-  template <> class HDivDivFE<ET_HEX> : public T_HDivDivFE<ET_HEX> 
-  {
-  public:
-    using T_HDivDivFE<ET_HEX> :: T_HDivDivFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      for (int i=0; i<6; i++)
-      {
-        ndof += (order_facet[i][0]+1)*(order_facet[i][0]+1);
-        order = max2(order, order_facet[i][0]+1);
-      }
-      int p = order_inner[0];
-      int ninner = 3*p*(p+2)*(p+2) + 3*(p+2)*(p+1)*(p+1);
-      ndof += ninner; 
-
-      order = max2(order, p+1);
-
-    }
-
-
-    template <typename T, typename TFA> 
-    void T_CalcShape (TIP<3,AutoDiff<3,T>> ip, TFA & shape) const
-    {
-      AutoDiffDiff<3,T> x = ip.x, y = ip.y, z = ip.z;
-      // typedef decltype(x.Value()+x.Value()) T;            
-      AutoDiff<3,T> xx(x.Value(), &x.DValue(0));
-      AutoDiff<3,T> yy(y.Value(), &y.DValue(0));
-      AutoDiff<3,T> zz(z.Value(), &z.DValue(0));
-      AutoDiff<3,T> lx[2] ={ 1-xx, xx};
-      AutoDiff<3,T> ly[2] ={ 1-yy, yy};
-      AutoDiff<3,T> lz[2] ={ 1-zz, zz};
-      AutoDiff<3,T> sigma[8] = {1-xx + 1-yy + 1-zz,
-        xx + 1-yy + 1-zz,
-        xx + yy + 1-zz,
-        1-xx + yy + 1-zz,
-        1-xx + 1-yy + zz,
-        xx + 1-yy + zz,
-        xx + yy + zz,
-        1-xx + yy + zz};
-      int ii = 0;
-      
-      // int maxorder_facet =
-      //     max2(order_facet[0][0],max2(order_facet[1][0],order_facet[2][0]));
-
-      const FACE * faces = ElementTopology::GetFaces(ET_HEX);
-
-      ArrayMem<AutoDiff<3,T>,20> leg_u(order+2), leg_v(order+3);
-      ArrayMem<AutoDiff<3,T>,20> leg_w(order+2);
-      AutoDiff<3,T> lam_face;
-      
-      for(int fa = 0; fa < 6; fa++)
-      {
-        int fmax = 0;
-        lam_face = -1 + 0.25*sigma[faces[fa][0]];
-        for(int j = 1; j < 4; j++)
-        {
-          if(vnums[faces[fa][j]] > vnums[faces[fa][fmax]]) fmax = j;
-          lam_face += sigma[faces[fa][j]]*0.25;
-        }
-
-        int fz,ftrig;
-
-        fz = 3 - fmax;
-        ftrig = fmax^1;
-
-        fmax = faces[fa][fmax];
-        fz = faces[fa][fz];
-        ftrig = faces[fa][ftrig];
-
-
-        // int orderz = order_facet[fa][1];
-
-        if(vnums[fz] < vnums[ftrig]) swap(fz, ftrig);
-        int p = order_facet[fa][0];
-        LegendrePolynomial::Eval(p, sigma[fmax] - sigma[ftrig],leg_u);
-        LegendrePolynomial::Eval(p, sigma[fmax] - sigma[fz],leg_v);
-
-        for(int k = 0; k <= p; k++)
-          for(int l = 0; l <= p; l++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(0.5*(sigma[fmax] - sigma[fz]),-0.5*(sigma[fmax] - sigma[fz]),
-              0.5*(sigma[fmax] - sigma[ftrig]),-0.5*(sigma[fmax] - sigma[ftrig]),leg_u[l]* leg_v[k]*lam_face);
-          }
-
-
-
-      }
-
-
-
-      int oi = order_inner[0];
-      leg_u.SetSize(oi+2);
-      leg_v.SetSize(oi+2);
-      leg_w.SetSize(oi+2);
-
-      LegendrePolynomial::Eval(oi+1,sigma[0] - sigma[1],leg_u);
-      LegendrePolynomial::Eval(oi+1,sigma[0] - sigma[3],leg_v);
-      LegendrePolynomial::Eval(oi+1,sigma[0] - sigma[4],leg_w);
-
-      for(int k=0; k<=oi-1; k++)
-      {
-        for(int i = 0; i <= oi+1; i++)
-        {
-          for(int j = 0; j <= oi+1; j++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[0], lx[1], lz[0], lz[1], ly[0]*ly[1]*leg_u[i]*leg_v[k]* leg_w[j]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[0], lx[1], ly[0], ly[1], lz[0]*lz[1]*leg_u[i]*leg_v[j]* leg_w[k]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(ly[0], ly[1], lz[0], lz[1], lx[0]*lx[1]*leg_u[k]*leg_v[j]* leg_w[i]);
-          }
-        }
-      }
-
-
-      // S_xz
-      for (int i=0; i<=oi; i++)
-      {
-        for (int j=0; j<=oi; j++)
-        {
-          for (int k=0; k<=oi+1; k++)
-          {
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[0], lx[0], ly[0], lz[0], leg_u[k]*leg_v[j]*leg_w[i]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(ly[0], ly[0], lx[0], lz[0], leg_u[i]*leg_v[k]*leg_w[j]);
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lz[0], lz[0], lx[0], ly[0], leg_u[i]*leg_v[j]*leg_w[k]);
-          }
-        }
-      }
-
-
-    };
-
-    template <typename MIP, typename TFA>
-    void CalcDualShape2 (const MIP & mip, TFA & shape) const
-    {
-      throw Exception ("Hdivdivfe not implementend for element type");
-    }
-
-
-  };
-
-
-
-
-  ////////////////////// SURFACE ////////////////////////////
-    template <int DIM>
-  class HDivDivSurfaceFiniteElement : public FiniteElement
-  {
-  public:
-    using FiniteElement::FiniteElement;
-    using FiniteElement::ndof;
-    using FiniteElement::order;
-
-    virtual void CalcMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM+1> & mip,
-      BareSliceMatrix<double> shape) const = 0;
-
-    virtual void CalcMappedShape_Vector (const MappedIntegrationPoint<DIM,DIM+1> & mip,
-      BareSliceMatrix<double> shape) const = 0;
-
-  };
-
-
-  template <ELEMENT_TYPE ET> class HDivDivSurfaceFE;
-
-  
-  template <ELEMENT_TYPE ET>
-  class T_HDivDivSurfaceFE : public HDivDivSurfaceFiniteElement<ET_trait<ET>::DIM>,
-    public VertexOrientedFE<ET>
-  {
-  protected:
-    enum { DIM = ET_trait<ET>::DIM };
-    enum { DIM_STRESS = ((DIM+2)*(DIM+1))/2 };
-    
-    using VertexOrientedFE<ET>::vnums;
-    using HDivDivSurfaceFiniteElement<ET_trait<ET>::DIM>::ndof;
-    using HDivDivSurfaceFiniteElement<ET_trait<ET>::DIM>::order;
-
-    IVec<DIM> order_inner;
-
-
-  public:
-    using VertexOrientedFE<ET>::SetVertexNumbers;
-    
-    T_HDivDivSurfaceFE (int aorder)
-    {
-      order = aorder;
-      order_inner = aorder;
-    }
-    
-    virtual ELEMENT_TYPE ElementType() const { return ET; }
-    const HDivDivSurfaceFE<ET> * Cast() const { return static_cast<const HDivDivSurfaceFE<ET>*> (this); } 
-    
-    INLINE void SetOrderInner (IVec<DIM,int> order) { order_inner = order; }
-
-    virtual void ComputeNDof()
-    {
-      cout << "Error, T_HDivDivSurfaceFE<ET>:: ComputeNDof not available for base class" << endl;
-    }
-
-    virtual void CalcMappedShape_Vector (const MappedIntegrationPoint<DIM,DIM+1> & mip,
-                            BareSliceMatrix<double> shape) const
-    {
-      Vec<DIM, AutoDiff<DIM+1>> adp = mip;
-      TIP<DIM, AutoDiffDiff<DIM+1>> addp(adp, mip.IP().FacetNr(), mip.IP().VB());
-   
-      Cast() -> T_CalcShape (addp, SBLambda([&] (int nr, auto val)
-                                          {
-                                            shape.Row(nr).Range(0,DIM_STRESS) = val.Shape();
-                                          }));
-    }
-
-
-    virtual void CalcMappedShape_Matrix (const MappedIntegrationPoint<DIM,DIM+1> & mip,
-                            BareSliceMatrix<double> shape) const
-    {
-      Vec<DIM, AutoDiff<DIM+1>> adp = mip;
-      TIP<DIM, AutoDiffDiff<DIM+1>> addp(adp, mip.IP().FacetNr(), mip.IP().VB());
-      
-      Cast() -> T_CalcShape (addp, SBLambda([&](int nr,auto val)
-      {
-        Vec<DIM_STRESS> vecshape = val.Shape();
-        BareVector<double> matshape = shape.Row(nr);
-        VecToSymMat<DIM+1> (vecshape, matshape);
-      }));
-    }
-
-
-  };
-
-  template <> class HDivDivSurfaceFE<ET_SEGM> : public T_HDivDivSurfaceFE<ET_SEGM> 
-  {
-    
-  public:
-    using T_HDivDivSurfaceFE<ET_SEGM> :: T_HDivDivSurfaceFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      ndof += order_inner[0]+1;
-      order = max2(order,order_inner[0]);
-
-    }
-   template <typename Tx, typename TFA> 
-    void T_CalcShape (TIP<1,Tx> ip/*AutoDiffDiff<2> hx[2]*/, TFA & shape) const
-    {
-      auto x = ip.x;
-      AutoDiffDiff<2> ddlami[2] ={ x, 1-x };
-      
-      int ii = 0;
-      
-      ArrayMem<AutoDiffDiff<2>,20> u(order_inner[0]+2);
-      
-      int es = 0,ee = 1;
-      if(vnums[es] > vnums[ee]) swap (es,ee);
-
-      AutoDiffDiff<2> ls = ddlami[es],le = ddlami[ee];
-
-      IntegratedLegendreMonomialExt::Calc(order_inner[0]+2, le-ls,u);
-
-      for(int l = 0; l <= order_inner[0]; l++)
-        shape[ii++] = SigmaGrad (u[l]);
-
-      
-    };
-  };
-
-
-  template <> class HDivDivSurfaceFE<ET_TRIG> : public T_HDivDivSurfaceFE<ET_TRIG> 
-  {
-    
-  public:
-    using T_HDivDivSurfaceFE<ET_TRIG> :: T_HDivDivSurfaceFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      ndof += (order_inner[0]+1+HDivDivFE<ET_PRISM>::incrorder_zz1_bd)*(order_inner[0]+2+HDivDivFE<ET_PRISM>::incrorder_zz1_bd)/2;
-      order = max2(order, order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd);
-    }
-
-
-    template <typename Tx, typename TFA> 
-    void T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
-    {
-      Tx x = ip.x, y = ip.y;
-      typedef decltype(x.Value()+x.Value()) T;                  
-      AutoDiff<3,T> xx(x.Value(), &x.DValue(0));
-      AutoDiff<3,T> yy(y.Value(), &y.DValue(0));
-      AutoDiff<3,T> lx[6] ={ xx, yy, 1-xx-yy};
-      int ii = 0;
-
-      ArrayMem<AutoDiff<3,T>,20> leg_u(order_inner[0]+2), leg_v(order_inner[0]+3);
-
-      
-        int fav[3] ={0,1,2};
-
-        //Sort vertices  first edge op minimal vertex
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        if(vnums[fav[1]] > vnums[fav[2]]) swap(fav[1],fav[2]);
-        if(vnums[fav[0]] > vnums[fav[1]]) swap(fav[0],fav[1]);
-        
-        leg_u.SetSize(order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd+1);
-        leg_v.SetSize(order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd+1);
-        ScaledLegendrePolynomial(order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd,lx[fav[0]]-lx[fav[1]],lx[fav[0]]+lx[fav[1]],leg_u);
-        LegendrePolynomial::Eval(order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd,2 * lx[fav[2]] - 1,leg_v);
-
-        for(int j = 0; j <= order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd; j++)
-          for(int k = 0; k <= order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_zz1_bd-j; k++)
-            shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(lx[fav[0]], lx[fav[1]], lx[fav[2]], lx[fav[2]], leg_u[j]*leg_v[k]);
-      }
-  };
-
-
-    template <> class HDivDivSurfaceFE<ET_QUAD> : public T_HDivDivSurfaceFE<ET_QUAD> 
-  {
-    
-  public:
-    using T_HDivDivSurfaceFE<ET_QUAD> :: T_HDivDivSurfaceFE;
-
-    virtual void ComputeNDof()
-    {
-      order = 0;
-      ndof = 0;
-      ndof += (order_inner[0]+1+HDivDivFE<ET_PRISM>::incrorder_xx1_bd)*(order_inner[1]+1+HDivDivFE<ET_PRISM>::incrorder_xx2_bd);
-      order = max2(order, order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_xx1_bd);
-      order = max2(order, order_inner[1]+HDivDivFE<ET_PRISM>::incrorder_xx2_bd);
-    }
-
-
-    template <typename Tx, typename TFA> 
-    void T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
-    {
-      AutoDiffDiff<3> x = ip.x, z = ip.y;
-      typedef decltype(x.Value()+x.Value()) T;                  
-      AutoDiff<3> xx(x.Value(), &x.DValue(0));
-      AutoDiff<3> zz(z.Value(), &z.DValue(0));
-      AutoDiff<3> sigma[4] = {1-xx+1-zz, xx+1-zz, xx+zz, 1-xx+zz};
-      int ii = 0;
-      
-
-      ArrayMem<AutoDiff<3>,20> leg_u(order_inner[0]+2);
-      ArrayMem<AutoDiff<3>,20> leg_w(order_inner[1]+2);
-
-      
-      int fmax = 0;
-      for(int j = 1; j < 4; j++)
-        if(vnums[j] > vnums[fmax]) fmax = j;
-
-      int f1, f2;
-      f1 = (fmax+1)%4;
-      f2 = (fmax+3)%4;
-
-
-      if(vnums[f1] > vnums[f2])
-      {
-        swap(f1,f2);
-      }
-
-      LegendrePolynomial::Eval(order_inner[0],sigma[fmax] - sigma[f1],leg_u);
-      LegendrePolynomial::Eval(order_inner[0],sigma[fmax] - sigma[f2],leg_w);
-
-      for(int k = 0; k <= order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_xx2_bd; k++)
-        for(int l = 0; l <= order_inner[0]+HDivDivFE<ET_PRISM>::incrorder_xx1_bd; l++)
-        {
-          shape[ii++] = Prism_Dl1xDl3_symtensor_Dl2xDl4_u<T>(0.5*(sigma[fmax]-sigma[f2]),-0.5*(sigma[fmax]-sigma[f2]),
-            0.5*(sigma[fmax]-sigma[f1]),-0.5*(sigma[fmax]-sigma[f1]),leg_u[l]* leg_w[k]);
-        }
-                
-
-    }
-  };
-
-
-  HDIVDIVFE_EXTERN template class T_HDivDivFE<ET_TRIG>;
-  HDIVDIVFE_EXTERN template class T_HDivDivFE<ET_QUAD>;
-  HDIVDIVFE_EXTERN template class T_HDivDivFE<ET_TET>;
-  HDIVDIVFE_EXTERN template class T_HDivDivFE<ET_PRISM>;
-  HDIVDIVFE_EXTERN template class T_HDivDivFE<ET_HEX>;
-  HDIVDIVFE_EXTERN template class T_HDivDivSurfaceFE<ET_SEGM>;
-  HDIVDIVFE_EXTERN template class T_HDivDivSurfaceFE<ET_QUAD>;
-  HDIVDIVFE_EXTERN template class T_HDivDivSurfaceFE<ET_TRIG>;
-
-}
-
-
-#endif
-