converter.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*  This file is part of the library KASKADE 7                               */
/*  https://www.zib.de/research/projects/kaskade7-finite-element-toolbox     */
/*                                                                           */
/*  Copyright (C) 2002-2019 Zuse Institute Berlin                            */
/*                                                                           */
/*  KASKADE 7 is distributed under the terms of the ZIB Academic License.    */
/*    see $KASKADE/academic.txt                                              */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#ifndef CONVERTER_HH
#define CONVERTER_HH
 
#include <cassert>
 
#include "dune/common/fmatrix.hh"
 
#include "fem/fixdune.hh"
#include "fem/variables.hh"
 
namespace Kaskade
{
  template <class ScalarA, class ScalarB, int r, int c>
  Dune::FieldMatrix<ScalarA,r,c> castMatrixEntries(Dune::FieldMatrix<ScalarB,r,c> const& m) {
    Dune::FieldMatrix<ScalarA,r,c> res;
    for(int i=0;i<r;++i)
      for(int j=0;j<r;++j)
        res[i][j] = static_cast<ScalarA>(m[i][j]);
    return res;
  }
 
  template <class Cell, class Scalar>
  class ScalarConverter
  {
    static int const dim = Cell::dimension;
    static int const dimw = Cell::Geometry::coorddimension;
 
  public:
    ScalarConverter(): cell_(0) {}
 
    ScalarConverter(Cell const& cell): cell_(&cell) {}
 
    void moveTo(Cell const& cell) { cell_ = &cell; }
 
    void setLocalPosition(Dune::FieldVector<typename Cell::Geometry::ctype,dim> const& xi)
    {
      assert(cell_);
      inv = castMatrixEntries<Scalar>(cell_->geometry().jacobianInverseTransposed(xi));
    }
 
    Dune::FieldMatrix<Scalar,1,1> global(Dune::FieldMatrix<Scalar,1,1> const& sf) const { return sf; }
 
    VariationalArg<Scalar,dimw,1> global(VariationalArg<Scalar,dim,1> const& sf, int deriv=1) const
    {
      VariationalArg<Scalar,dimw,1> phi;
      phi.value = sf.value;
      if (deriv >= 1) phi.derivative[0] = inv * sf.derivative[0];
      if (deriv >= 2) phi.hessian[0] = inv * static_cast<Dune::FieldMatrix<Scalar,dim,dim>>(sf.hessian[0]) * transpose(inv);
      return phi;
    }
 
    Dune::FieldMatrix<Scalar,1,1> local(Dune::FieldMatrix<Scalar,1,1> const& glob) const { return glob; }
 
 
  private:
    Cell const*                        cell_;
    Dune::FieldMatrix<Scalar,dimw,dim> inv;
  };
} /* end of namespace Kaskade */
 
 
#endif