ddfem 1.0.10__py3-none-any.whl → 1.0.11__py3-none-any.whl

ddfem/data/2.11.dev20250709/localfunction_dd5ab085a9d94f578c1f3d337ea360a3_a524c1196983e65de1c06d7d6afdeb44.cc

@@ -0,0 +1,161 @@
+#ifndef GUARD_dd5ab085a9d94f578c1f3d337ea360a3
+#define GUARD_dd5ab085a9d94f578c1f3d337ea360a3
+
+#define USING_DUNE_PYTHON 1
+#include <config.h>
+#include <dune/alugrid/dgf.hh>
+#include <dune/alugrid/grid.hh>
+#include <dune/fem/gridpart/adaptiveleafgridpart.hh>
+#include <dune/fem/gridpart/filter/simple.hh>
+#include <dune/fem/gridpart/filteredgridpart.hh>
+#include <dune/fempy/py/gridview.hh>
+#include <dune/python/grid/gridview.hh>
+#include <dune/python/grid/hierarchical.hh>
+#include <dune/fem/function/localfunction/bindable.hh>
+#include <dune/fem/common/intersectionside.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/extensions.h>
+#include <dune/fempy/py/grid/gridpart.hh>
+#include <dune/common/exceptions.hh>
+#include <dune/fempy/function/virtualizedgridfunction.hh>
+#include <dune/fempy/py/ufllocalfunction.hh>
+
+namespace UFLLocalFunctions_dd5ab085a9d94f578c1f3d337ea360a3
+{
+
+  // UFLLocalFunction
+// ----------------
+
+template< class GridPart, class Coeffu_h >
+struct UFLLocalFunction
+  : public Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<2>>
+{
+  typedef GridPart GridPartType;
+  typedef typename GridPartType::GridViewType GridView;
+  typedef typename GridView::ctype ctype;
+  typedef Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<2>> BaseType;
+  typedef Dune::Fem::GridFunctionSpace<GridPartType,Dune::Dim<2>> FunctionSpaceType;
+  typedef typename GridPartType::template Codim< 0 >::EntityType EntityType;
+  typedef typename GridPartType::IntersectionType IntersectionType;
+  typedef typename EntityType::Geometry Geometry;
+  typedef typename Geometry::GlobalCoordinate GlobalCoordinateType;
+  typedef Dune::Fem::IntersectionSide Side;
+  typedef std::tuple<> ConstantTupleType;
+  typedef std::tuple< Dune::Fem::GridFunctionSpace< GridPartType, Dune::FieldVector< double, 2 > > > CoefficientFunctionSpaceTupleType;
+  typedef std::tuple< Coeffu_h > CoefficientTupleType;
+  template< std::size_t i >
+  using CoefficientFunctionSpaceType = std::tuple_element_t< i, CoefficientFunctionSpaceTupleType >;
+  template< std::size_t i >
+  using CoefficientRangeType = typename CoefficientFunctionSpaceType< i >::RangeType;
+  template< std::size_t i >
+  using CoefficientJacobianRangeType = typename CoefficientFunctionSpaceType< i >::JacobianRangeType;
+  static constexpr bool gridPartValid = Dune::Fem::checkGridPartValid<GridPartType,Dune::Fem::ConstLocalFunction<Coeffu_h>>();
+  template< std::size_t i >
+  using CoefficientType = std::tuple_element_t< i, CoefficientTupleType >;
+  template< std::size_t i >
+  using ConstantType = typename std::tuple_element_t< i, ConstantTupleType >::element_type;
+  using BaseType::entity;
+  using BaseType::geometry;
+
+  UFLLocalFunction ( const GridPartType &gridPart, const std::string &name, int order, const Coeffu_h &coeffu_h, const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
+    : BaseType(gridPart,name,order),
+      coefficients_( Dune::Fem::ConstLocalFunction< Coeffu_h >( coeffu_h ) )
+  {}
+
+  void bind ( const IntersectionType &intersection, Side side )
+  {
+    BaseType::bind(intersection, side);
+    std::get< 0 >( coefficients_ ).bind( this->entity() );
+  }
+
+  void bind ( const EntityType &entity )
+  {
+    BaseType::bind(entity);
+    std::get< 0 >( coefficients_ ).bind( this->entity() );
+  }
+
+  void unbind ()
+  {
+    BaseType::unbind();
+    std::get< 0 >( coefficients_ ).unbind();
+  }
+
+  template< class Point >
+  void evaluate ( const Point &x, typename FunctionSpaceType::RangeType &result ) const
+  {
+    typename CoefficientFunctionSpaceType< 0 >::JacobianRangeType tmp0 = jacobianCoefficient< 0 >( x );
+    result[ 0 ] = (tmp0[ 0 ])[ 0 ];
+    result[ 1 ] = (tmp0[ 0 ])[ 1 ];
+  }
+
+  template< class Point >
+  void jacobian ( const Point &x, typename FunctionSpaceType::JacobianRangeType &result ) const
+  {
+    typename CoefficientFunctionSpaceType< 0 >::HessianRangeType tmp0 = hessianCoefficient< 0 >( x );
+    (result[ 0 ])[ 0 ] = ((tmp0[ 0 ])[ 0 ])[ 0 ];
+    (result[ 0 ])[ 1 ] = ((tmp0[ 0 ])[ 0 ])[ 1 ];
+    (result[ 1 ])[ 0 ] = ((tmp0[ 0 ])[ 1 ])[ 0 ];
+    (result[ 1 ])[ 1 ] = ((tmp0[ 0 ])[ 1 ])[ 1 ];
+  }
+
+  template< class Point >
+  void hessian ( const Point &x, typename FunctionSpaceType::HessianRangeType &result ) const
+  {
+    DUNE_THROW(Dune::NotImplemented,"hessian method could not be generated for local function (TooHighDerivative('CodeGenerator does not allow for third order derivatives, yet.'))");
+    result=typename FunctionSpaceType::HessianRangeType(0);
+  }
+
+  template< std::size_t i >
+  const ConstantType< i > &constant () const
+  {
+    return *std::get< i >( constants_ );
+  }
+
+  template< std::size_t i >
+  ConstantType< i > &constant ()
+  {
+    return *std::get< i >( constants_ );
+  }
+
+  template< std::size_t i, class Point >
+  typename CoefficientFunctionSpaceType< i >::RangeType evaluateCoefficient ( const Point &x ) const
+  {
+    typename CoefficientFunctionSpaceType< i >::RangeType result;
+    std::get< i >( coefficients_ ).evaluate( x, result );;
+    return result;
+  }
+
+  template< std::size_t i, class Point >
+  typename CoefficientFunctionSpaceType< i >::JacobianRangeType jacobianCoefficient ( const Point &x ) const
+  {
+    typename CoefficientFunctionSpaceType< i >::JacobianRangeType result;
+    std::get< i >( coefficients_ ).jacobian( x, result );;
+    return result;
+  }
+
+  template< std::size_t i, class Point >
+  typename CoefficientFunctionSpaceType< i >::HessianRangeType hessianCoefficient ( const Point &x ) const
+  {
+    typename CoefficientFunctionSpaceType< i >::HessianRangeType result;
+    std::get< i >( coefficients_ ).hessian( x, result );;
+    return result;
+  }
+  ConstantTupleType constants_;
+  std::tuple< Dune::Fem::ConstLocalFunction< Coeffu_h > > coefficients_;
+};
+
+} // namespace UFLLocalFunctions_dd5ab085a9d94f578c1f3d337ea360a3
+
+PYBIND11_MODULE( localfunction_dd5ab085a9d94f578c1f3d337ea360a3_a524c1196983e65de1c06d7d6afdeb44, module )
+{
+  typedef UFLLocalFunctions_dd5ab085a9d94f578c1f3d337ea360a3::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > >, Dune::FemPy::VirtualizedGridFunction< Dune::FemPy::GridPart<Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true >>, Dune::FieldVector< double, 2 > > > LocalFunctionType;
+  if constexpr( LocalFunctionType::gridPartValid )
+  {
+      auto cls = Dune::Python::insertClass<LocalFunctionType>(module,"UFLLocalFunction",Dune::Python::GenerateTypeName("UFLLocalFunctions_dd5ab085a9d94f578c1f3d337ea360a3::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > >, Dune::FemPy::VirtualizedGridFunction< Dune::FemPy::GridPart<Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true >>, Dune::FieldVector< double, 2 > > >"), Dune::Python::IncludeFiles({"python/dune/generated/localfunction_dd5ab085a9d94f578c1f3d337ea360a3_a524c1196983e65de1c06d7d6afdeb44.cc"})).first;
+      Dune::FemPy::registerUFLLocalFunction( module, cls );
+      cls.def( pybind11::init( [] ( pybind11::object gridView, const std::string &name, int order, const Dune::FemPy::VirtualizedGridFunction< Dune::FemPy::GridPart<Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true >>, Dune::FieldVector< double, 2 > > &coeffu_h ) {return new LocalFunctionType( Dune::FemPy::gridPart<Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true >>(gridView),name,order, coeffu_h); } ), pybind11::keep_alive< 1, 2 >(), pybind11::keep_alive< 1, 3 >() );
+      cls.def_property_readonly( "virtualized", [] ( LocalFunctionType& ) -> bool { return true;});
+  }
+}
+
+#endif

ddfem/data/2.11.dev20250709/{localfunction_aeb3d963412cdc65630e0a4c3c0dde0f_a524c1196983e65de1c06d7d6afdeb44.cc → localfunction_e2b19c5987f9b6fb0cd5453bfa7f4f9f_a524c1196983e65de1c06d7d6afdeb44.cc}

@@ -1,5 +1,5 @@
-#ifndef GUARD_aeb3d963412cdc65630e0a4c3c0dde0f
-#define GUARD_aeb3d963412cdc65630e0a4c3c0dde0f
+#ifndef GUARD_e2b19c5987f9b6fb0cd5453bfa7f4f9f
+#define GUARD_e2b19c5987f9b6fb0cd5453bfa7f4f9f
 
 #define USING_DUNE_PYTHON 1
 #include <config.h>
@@ -19,7 +19,7 @@
 #include <dune/common/exceptions.hh>
 #include <dune/fempy/py/ufllocalfunction.hh>
 
-namespace UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f
+namespace UFLLocalFunctions_e2b19c5987f9b6fb0cd5453bfa7f4f9f
 {
 
   // UFLLocalFunction
@@ -27,22 +27,19 @@ namespace UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f
 
 template< class GridPart >
 struct UFLLocalFunction
-  : public Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<1>>
+  : public Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<2>>
 {
   typedef GridPart GridPartType;
   typedef typename GridPartType::GridViewType GridView;
   typedef typename GridView::ctype ctype;
-  typedef Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<1>> BaseType;
-  typedef Dune::Fem::GridFunctionSpace<GridPartType,Dune::Dim<1>> FunctionSpaceType;
+  typedef Dune::Fem::BindableGridFunctionWithSpace<GridPart,Dune::Dim<2>> BaseType;
+  typedef Dune::Fem::GridFunctionSpace<GridPartType,Dune::Dim<2>> FunctionSpaceType;
   typedef typename GridPartType::template Codim< 0 >::EntityType EntityType;
   typedef typename GridPartType::IntersectionType IntersectionType;
   typedef typename EntityType::Geometry Geometry;
   typedef typename Geometry::GlobalCoordinate GlobalCoordinateType;
   typedef Dune::Fem::IntersectionSide Side;
-  typedef double Conc0;
-  typedef std::tuple< std::shared_ptr< Conc0 > > ConstantTupleType;
-  template< std::size_t i >
-  using ConstantsRangeType = typename std::tuple_element_t< i, ConstantTupleType >::element_type;
+  typedef std::tuple<> ConstantTupleType;
   typedef std::tuple<> CoefficientTupleType;
   static constexpr bool gridPartValid = true;
   template< std::size_t i >
@@ -54,9 +51,7 @@ struct UFLLocalFunction
 
   UFLLocalFunction ( const GridPartType &gridPart, const std::string &name, int order, const Dune::Fem::ParameterReader &parameter = Dune::Fem::Parameter::container() )
     : BaseType(gridPart,name,order)
-  {
-    std::get< 0 >( constants_ ) = std::make_shared< Conc0 >( (Conc0(0)) );
-  }
+  {}
 
   void bind ( const IntersectionType &intersection, Side side )
   {
@@ -76,8 +71,8 @@ struct UFLLocalFunction
   template< class Point >
   void evaluate ( const Point &x, typename FunctionSpaceType::RangeType &result ) const
   {
-    double tmp0 = constant< 0 >();
-    result[ 0 ] = tmp0;
+    result[ 0 ] = 0.0;
+    result[ 1 ] = 0.0;
   }
 
   template< class Point >
@@ -103,31 +98,20 @@ struct UFLLocalFunction
   {
     return *std::get< i >( constants_ );
   }
-
-  const Conc0 &conc0 () const
-  {
-    return *std::get< 0 >( constants_ );
-  }
-
-  Conc0 &conc0 ()
-  {
-    return *std::get< 0 >( constants_ );
-  }
   ConstantTupleType constants_;
   std::tuple<  > coefficients_;
 };
 
-} // namespace UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f
+} // namespace UFLLocalFunctions_e2b19c5987f9b6fb0cd5453bfa7f4f9f
 
-PYBIND11_MODULE( localfunction_aeb3d963412cdc65630e0a4c3c0dde0f_a524c1196983e65de1c06d7d6afdeb44, module )
+PYBIND11_MODULE( localfunction_e2b19c5987f9b6fb0cd5453bfa7f4f9f_a524c1196983e65de1c06d7d6afdeb44, module )
 {
-  typedef UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > > LocalFunctionType;
+  typedef UFLLocalFunctions_e2b19c5987f9b6fb0cd5453bfa7f4f9f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > > LocalFunctionType;
   if constexpr( LocalFunctionType::gridPartValid )
   {
-      auto cls = Dune::Python::insertClass<LocalFunctionType>(module,"UFLLocalFunction",Dune::Python::GenerateTypeName("UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > >"), Dune::Python::IncludeFiles({"python/dune/generated/localfunction_aeb3d963412cdc65630e0a4c3c0dde0f_a524c1196983e65de1c06d7d6afdeb44.cc"})).first;
+      auto cls = Dune::Python::insertClass<LocalFunctionType>(module,"UFLLocalFunction",Dune::Python::GenerateTypeName("UFLLocalFunctions_e2b19c5987f9b6fb0cd5453bfa7f4f9f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > >"), Dune::Python::IncludeFiles({"python/dune/generated/localfunction_e2b19c5987f9b6fb0cd5453bfa7f4f9f_a524c1196983e65de1c06d7d6afdeb44.cc"})).first;
       Dune::FemPy::registerUFLLocalFunction( module, cls );
       cls.def( pybind11::init( [] ( pybind11::object gridView, const std::string &name, int order ) {return new LocalFunctionType( Dune::FemPy::gridPart<Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true >>(gridView),name,order); } ), pybind11::keep_alive< 1, 2 >() );
-      cls.def_property( "c0", [] ( LocalFunctionType &self ) -> UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > >::Conc0 { return self.conc0(); }, [] ( LocalFunctionType &self, const UFLLocalFunctions_aeb3d963412cdc65630e0a4c3c0dde0f::UFLLocalFunction< typename Dune::FemPy::GridPart< Dune::Fem::FilteredGridPart< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >, true > > >::Conc0 &v ) { self.conc0() = v; } );
       cls.def_property_readonly( "virtualized", [] ( LocalFunctionType& ) -> bool { return true;});
   }
 }

ddfem/data/extra.modules

@@ -0,0 +1,13 @@
+femspace_11b3436cb033df683615c50d5d4239bd_f14dd0b3b474c0cd816334330f55ad72.cc
+localfunction_3d957c5b2628e5120636b8e3f461bc0d_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_6363af791dde11d699a9a3d876cc5d9a_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_762aa49bc5a47ad3d8d8bbde36b42ee5_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_e2b19c5987f9b6fb0cd5453bfa7f4f9f_a524c1196983e65de1c06d7d6afdeb44.cc
+femscheme_765ef00d995a939c34bdc0d0cc4847ca.cc
+localfunction_22e797a8f3e8c322f33c41e07bd15165_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_32613626342183eafa360dc1f0f18924_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_4976bbef3267846b59f3a26497ffe9db_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_5591a2c803b9658084d8f11d44bf3ae1_a524c1196983e65de1c06d7d6afdeb44.cc
+localfunction_6363af791dde11d699a9a3d876cc5d9a_af122c1df944c95cd395ec0f91d0f970.cc
+localfunction_d4b9ca85d48735ee01f395a42eaa0cee_af122c1df944c95cd395ec0f91d0f970.cc
+localfunction_dd1fb4bd60f2d8b3a062dbbdaedb9fee_a524c1196983e65de1c06d7d6afdeb44.cc

ddfem/examples/beam.py

@@ -1,14 +1,10 @@
 import numpy as np
 import pygmsh
-from dune.alugrid import aluConformGrid as leafGridView
-from dune.fem import adapt, mark, markNeighbors
-from dune.fem.function import gridFunction
-from dune.fem.space import lagrange
-from dune.fem.view import adaptiveLeafGridView
 from dune.grid import cartesianDomain
 from dune.ufl import Constant, Space
 from ufl import SpatialCoordinate, sqrt
 
+from ddfem import GridView
 from ddfem import geometry as gm
 from ddfem.geometry.domain_dune import DomainDune
 
@@ -45,31 +41,42 @@ def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, *args, **kwa
         r_min = epsilon.value
         r_max = radius * epsilon.value
         dist = np.abs(sdf((x, y)))
-        if dist <= r_min:
-            return geom.characteristic_length_min
-        elif dist >= r_max:
-            return geom.characteristic_length_max
-        else:
+
+        gmax = geom.characteristic_length_max
+        gmin = geom.characteristic_length_min
+
+        if False:
             # Linear
-            m = (geom.characteristic_length_max - geom.characteristic_length_min) / (
-                r_max - r_min
-            )
-            return m * (dist - r_min) + geom.characteristic_length_min
+            if dist <= r_min:
+                return gmin
+            elif dist >= r_max:
+                return gmax
+            else:
+                m = (gmax - gmin) / (r_max - r_min)
+                return m * (dist - r_min) + gmin
+
+        else:
+            # Exponential
+            R = int(2 * np.log2(gmax / gmin))
+            j = max(0, min(R, (dist * R) / r_max - 0.5))
+            # j = max(0, min(R, np.floor(dist * R / r_max)))
+            return gmax * 0.5 ** ((R - j) / 2)
+
+    omega.epsilon = get_eps(h_min)
 
     if version == "cartesian":
+        omega.epsilon = get_eps(h)
         domain = cartesianDomain(*domain_range, initial_gridsize)
-        epsilon = get_eps(h)
 
     elif version == "fitted":
         with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
-            epsilon = get_eps(h_min)
+            geom.characteristic_length_max = h_max / sqrt(2)
+            geom.characteristic_length_min = h_min / sqrt(2)
 
             rec = geom.add_rectangle([0, 0, 0], 1, 0.15)
 
             geom.set_mesh_size_callback(
-                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
+                lambda dim, tag, x, y, z, lc: spacing(x, y, omega.epsilon),
                 ignore_other_mesh_sizes=True,
             )
 
@@ -86,12 +93,11 @@ def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, *args, **kwa
 
     elif version == "gmsh_adaptive":
         with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
-            epsilon = get_eps(h_min)
+            geom.characteristic_length_max = h_max / sqrt(2)
+            geom.characteristic_length_min = h_min / sqrt(2)
 
             geom.set_mesh_size_callback(
-                lambda dim, tag, x, y, z, lc: spacing(x, y, epsilon),
+                lambda dim, tag, x, y, z, lc: spacing(x, y, omega.epsilon),
                 ignore_other_mesh_sizes=True,
             )
 
@@ -111,37 +117,24 @@ def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, *args, **kwa
     else:
         raise ValueError("invalid mesh type")
 
-    gridView = adaptiveLeafGridView(leafGridView(domain))
-
     if version == "dune_adaptive":
-        omega.epsilon = get_eps(h_min)
-        omega.epsilon.value *= radius
-        epsilon_value = omega.epsilon.value
-
-        marker = mark
-
         refinements = int(2 * np.log2(h_max / h_min))
-
-        region = gridFunction(
-            omega.phi(x) * (1 - omega.phi(x)), gridView=gridView
-        )  # interface
-
-        for j in range(1, refinements + 1):
-
-            omega.epsilon.value = epsilon_value * j / refinements
-            marker(region, 0.00247262315663, maxLevel=refinements)  # 1 epsilon
-
-            adapt(gridView.hierarchicalGrid)
-
-        h_min = h_max * 0.5 ** (j / 2)
-        epsilon = get_eps(h_min)
-
-    omega.epsilon = epsilon
-    domain = omega
+        gridView = GridView(
+            domain,
+            omega,
+            factor=radius,
+            refinements=refinements,
+            adaptLevels=adaptLevels,
+        )
+        h_min = h_max * 0.5 ** (refinements / 2)
+        omega.epsilon = get_eps(h_min)
+    else:
+        gridView = GridView(domain)
 
     domain = DomainDune(omega, gridView)
-    # domain.adapt(level=adaptLevels)
 
-    print(f"h={h * 0.5 ** (adaptLevels / 2)}, epsilon={epsilon.value}")
+    print(
+        f"h_max={h_max}, h_min={h_min * 0.5 ** (adaptLevels / 2)}, epsilon={omega.epsilon.value}"
+    )
 
     return gridView, domain

ddfem/examples/chemical_reaction.py

@@ -37,7 +37,7 @@ def crModel():
 
         def setup(u_h, DDMPotentialModel, psi_h):
             ChemModel.u_h_n = u_h.copy(name="u_h_n")
-            ChemModel.u_h_n.interpolate(zero(ChemModel.dimRange))
+            ChemModel.u_h_n.clear()
 
             ChemModel.dpsi_h = lambda x: DDMPotentialModel.sigma(
                 0, x, psi_h, grad(psi_h)

ddfem/examples/five_circle_flat.py

@@ -15,14 +15,12 @@ pip install dune-fem
     """
     )
 
-from dune.fem.function import gridFunction
-from dune.fem.space import lagrange
 from dune.grid import cartesianDomain
 from dune.ufl import Constant, Space
 from ufl import SpatialCoordinate, sqrt
 
-from ddfem import geometry as gm
 from ddfem import GridView
+from ddfem import geometry as gm
 from ddfem.geometry.domain_dune import DomainDune
 
 
@@ -75,7 +73,7 @@ def getDomain(
 
     h_max = h * 3
     h_min = h / 2
-    radius = 5
+    radius = 4
 
     x = SpatialCoordinate(Space(2))
     sdf = omega(x)
@@ -84,28 +82,40 @@ def getDomain(
         r_min = epsilon.value
         r_max = radius * epsilon.value
         dist = np.abs(sdf((x, y)))
-        if dist <= r_min:
-            return geom.characteristic_length_min
-        elif dist >= r_max:
-            return geom.characteristic_length_max
-        else:
+
+        gmax = geom.characteristic_length_max
+        gmin = geom.characteristic_length_min
+
+        if False:
             # Linear
-            m = (geom.characteristic_length_max - geom.characteristic_length_min) / (
-                r_max - r_min
-            )
-            return m * (dist - r_min) + geom.characteristic_length_min
+            if dist <= r_min:
+                return gmin
+            elif dist >= r_max:
+                return gmax
+            else:
+                m = (gmax - gmin) / (r_max - r_min)
+                return m * (dist - r_min) + gmin
 
-    omega.epsilon = get_eps(h)
+        else:
+            # Exponential
+            R = int(2 * np.log2(gmax / gmin))
+            j = max(0, min(R, (dist * R) / r_max - 0.5))
+            # j = max(0, min(R, np.floor(dist * R / r_max)))
+            return gmax * 0.5 ** ((R - j) / 2)
+
+    omega.epsilon = get_eps(h_min)
 
     if version == "cartesian":
-        domain = cartesianDomain(*domain_range, initial_gridsize)
+        omega.epsilon = get_eps(h)
+        # domain = cartesianDomain(*domain_range, initial_gridsize)
+        domain = [*domain_range, initial_gridsize]
 
     elif version == "fitted":
         if pygmsh is None:
             raise AttributeError("'fitted' requires install pygmsh")
         with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
+            geom.characteristic_length_max = h_max / sqrt(2)
+            geom.characteristic_length_min = h_min / sqrt(2)
 
             disks = [geom.add_disk([c[1][0], c[1][1], 0.0], c[0]) for c in balls]
 
@@ -136,8 +146,8 @@ def getDomain(
         if pygmsh is None:
             raise AttributeError("'gmsh_adaptive' requires install pygmsh")
         with pygmsh.occ.Geometry() as geom:
-            geom.characteristic_length_max = h_max
-            geom.characteristic_length_min = h_min
+            geom.characteristic_length_max = h_max / sqrt(2)
+            geom.characteristic_length_min = h_min / sqrt(2)
 
             geom.add_rectangle(
                 [domain_range[0][0], domain_range[0][1], 0.0],
@@ -158,18 +168,22 @@ def getDomain(
     else:
         raise ValueError("invalid mesh type")
 
-    if not version == "dune_adaptive":
-        gridView = GridView(domain)
-    else:
+    if version == "dune_adaptive":
         refinements = int(2 * np.log2(h_max / h_min))
-        gridView = GridView(domain,omega,
-                      factor=radius,
-                      refinements=refinements,
-                      adaptLevels=adaptLevels)
+        gridView = GridView(
+            domain,
+            omega,
+            filterTolerance=10 * omega.epsilon.value,
+            factor=radius,
+            refinements=refinements,
+            adaptLevels=adaptLevels,
+        )
         h_min = h_max * 0.5 ** (refinements / 2)
-        omega.epsilon.value = get_eps(h_min)
+        omega.epsilon = get_eps(h_min)
+    else:
+        gridView = GridView(domain)
 
-    domain = DomainDune(omega, gridView)
+    domain = DomainDune(omega, gridView, filterTolerance=10 * omega.epsilon.value)
 
     print(
         f"h_max={h_max}, h_min={h_min * 0.5 ** (adaptLevels / 2)}, epsilon={omega.epsilon.value}"

ddfem/examples/linear_elasticity.py

@@ -1,5 +1,5 @@
 from dune.ufl import Constant
-from ufl import Identity, as_vector, div, grad, sym, tr, zero
+from ufl import Identity, as_vector, inner, sqrt, sym, tr
 
 from ddfem.boundary import BndFlux_v, BndValue
 
@@ -28,6 +28,10 @@ def leModel():
         def S_i(t, x, U, DU):
             return as_vector([0.0, -Model.rho * Model.g])
 
+        def von_Mises(U, DU):
+            s = Model.sigma(U, DU) - (1.0 / 3) * tr(Model.sigma(U, DU)) * Identity(2)
+            return sqrt(3.0 / 2 * inner(s, s))
+
         valD = lambda t, x, U: Model.vd
 
         valN = lambda t, x, U, DU, n: Model.vn