ddfem 1.0.4__py3-none-any.whl → 1.0.6__py3-none-any.whl

ddfem/data/referenceelements_0fff57b283123cc055345ec95574c857.cc

@@ -0,0 +1,24 @@
+#ifndef Guard_referenceelements_0fff57b283123cc055345ec95574c857
+#define Guard_referenceelements_0fff57b283123cc055345ec95574c857
+
+#include <config.h>
+
+#define USING_DUNE_PYTHON 1
+
+#include <dune/python/geometry/referenceelements.hh>
+
+#include <dune/python/common/typeregistry.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/stl.h>
+
+PYBIND11_MODULE( referenceelements_0fff57b283123cc055345ec95574c857, module )
+{
+  using pybind11::operator""_a;
+  pybind11::module cls0 = module;
+  {
+    using DuneType = Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,1> >;
+    auto cls = Dune::Python::insertClass< DuneType >( cls0, "ReferenceElements", Dune::Python::GenerateTypeName("Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,1> >"), Dune::Python::IncludeFiles{"dune/python/geometry/referenceelements.hh"}).first;
+    Dune::Python::registerReferenceElements( cls0, cls );
+  }
+}
+#endif

ddfem/data/referenceelements_de274310a0055100b832a0e8892b0258.cc

@@ -0,0 +1,24 @@
+#ifndef Guard_referenceelements_de274310a0055100b832a0e8892b0258
+#define Guard_referenceelements_de274310a0055100b832a0e8892b0258
+
+#include <config.h>
+
+#define USING_DUNE_PYTHON 1
+
+#include <dune/python/geometry/referenceelements.hh>
+
+#include <dune/python/common/typeregistry.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/stl.h>
+
+PYBIND11_MODULE( referenceelements_de274310a0055100b832a0e8892b0258, module )
+{
+  using pybind11::operator""_a;
+  pybind11::module cls0 = module;
+  {
+    using DuneType = Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,0> >;
+    auto cls = Dune::Python::insertClass< DuneType >( cls0, "ReferenceElements", Dune::Python::GenerateTypeName("Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,0> >"), Dune::Python::IncludeFiles{"dune/python/geometry/referenceelements.hh"}).first;
+    Dune::Python::registerReferenceElements( cls0, cls );
+  }
+}
+#endif

ddfem/data/referenceelements_f4457f35395151d83a965d4cf5fce70d.cc

@@ -0,0 +1,24 @@
+#ifndef Guard_referenceelements_f4457f35395151d83a965d4cf5fce70d
+#define Guard_referenceelements_f4457f35395151d83a965d4cf5fce70d
+
+#include <config.h>
+
+#define USING_DUNE_PYTHON 1
+
+#include <dune/python/geometry/referenceelements.hh>
+
+#include <dune/python/common/typeregistry.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/stl.h>
+
+PYBIND11_MODULE( referenceelements_f4457f35395151d83a965d4cf5fce70d, module )
+{
+  using pybind11::operator""_a;
+  pybind11::module cls0 = module;
+  {
+    using DuneType = Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,2> >;
+    auto cls = Dune::Python::insertClass< DuneType >( cls0, "ReferenceElements", Dune::Python::GenerateTypeName("Dune::Geo::ReferenceElement<Dune::Geo::ReferenceElementImplementation<double,2> >"), Dune::Python::IncludeFiles{"dune/python/geometry/referenceelements.hh"}).first;
+    Dune::Python::registerReferenceElements( cls0, cls );
+  }
+}
+#endif

ddfem/data/view_a524c1196983e65de1c06d7d6afdeb44.cc

@@ -0,0 +1,39 @@
+#ifndef Guard_view_a524c1196983e65de1c06d7d6afdeb44
+#define Guard_view_a524c1196983e65de1c06d7d6afdeb44
+
+#include <config.h>
+
+#define USING_DUNE_PYTHON 1
+
+#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/python/common/typeregistry.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/stl.h>
+
+PYBIND11_MODULE( view_a524c1196983e65de1c06d7d6afdeb44, module )
+{
+  using pybind11::operator""_a;
+  pybind11::module cls0 = module;
+  {
+    using DuneType = 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 >;
+    auto cls = Dune::Python::insertClass< DuneType >( cls0, "GridView",pybind11::dynamic_attr(), Dune::Python::GenerateTypeName("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{"dune/alugrid/dgf.hh","dune/alugrid/grid.hh","dune/fem/gridpart/adaptiveleafgridpart.hh","dune/fem/gridpart/filter/simple.hh","dune/fem/gridpart/filteredgridpart.hh","dune/fempy/py/gridview.hh","dune/python/grid/gridview.hh","dune/python/grid/hierarchical.hh"}).first;
+    Dune::Python::registerGridView( cls0, cls );
+    
+    Dune::FemPy::registerGridView ( cls );
+    cls.def( pybind11::init( [] ( pybind11::handle hostGridView, pybind11::function contains, int domainId ) {auto containsCpp = [ contains ] ( const Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >::Codim< 0 >::EntityType &e ) {
+            return contains( e ).template cast< int >();
+          };
+        Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > &hostGridPart = Dune::FemPy::gridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > >( hostGridView );
+        return 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 > ( hostGridPart, Dune::Fem::SimpleFilter< Dune::FemPy::GridPart< Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > > > >( hostGridPart, containsCpp, domainId ) );
+      } ), pybind11::keep_alive< 1, 2 >() );
+  }
+}
+#endif

ddfem/data/view_af122c1df944c95cd395ec0f91d0f970.cc

@@ -0,0 +1,62 @@
+#ifndef Guard_view_af122c1df944c95cd395ec0f91d0f970
+#define Guard_view_af122c1df944c95cd395ec0f91d0f970
+
+#include <config.h>
+
+#define USING_DUNE_PYTHON 1
+
+#include <dune/alugrid/dgf.hh>
+#include <dune/alugrid/grid.hh>
+#include <dune/fem/gridpart/adaptiveleafgridpart.hh>
+#include <dune/fempy/py/gridview.hh>
+#include <dune/python/grid/gridview.hh>
+#include <dune/python/grid/hierarchical.hh>
+
+#include <dune/python/common/typeregistry.hh>
+#include <dune/python/pybind11/pybind11.h>
+#include <dune/python/pybind11/stl.h>
+
+PYBIND11_MODULE( view_af122c1df944c95cd395ec0f91d0f970, module )
+{
+  using pybind11::operator""_a;
+  pybind11::module cls0 = module;
+  {
+    using DuneType = Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > >;
+    auto cls = Dune::Python::insertClass< DuneType >( cls0, "GridView",pybind11::dynamic_attr(), Dune::Python::GenerateTypeName("Dune::Fem::AdaptiveLeafGridPart< Dune::ALUGrid< 2, 2, Dune::simplex > >"), Dune::Python::IncludeFiles{"dune/alugrid/dgf.hh","dune/alugrid/grid.hh","dune/fem/gridpart/adaptiveleafgridpart.hh","dune/fempy/py/gridview.hh","dune/python/grid/gridview.hh","dune/python/grid/hierarchical.hh"}).first;
+    Dune::Python::registerGridView( cls0, cls );
+    
+    Dune::FemPy::registerGridView ( cls );
+    cls.def( pybind11::pickle(
+      [](const pybind11::object &self) {
+    
+                auto& gv = self.cast<DuneType&>();
+                std::ostringstream stream;
+                Dune::Fem::StandardOutStream outStream(stream);
+                gv.indexSet().write( outStream );
+                pybind11::bytes s(stream.str());
+                /* Return a tuple that fully encodes the state of the object */
+                pybind11::dict d;
+                if (pybind11::hasattr(self, "__dict__")) {
+                  d = self.attr("__dict__");
+                }
+                return pybind11::make_tuple(gv.grid(),s,d);
+          }
+    , [](pybind11::tuple t) {
+    
+                if (t.size() != 3)
+                    throw std::runtime_error("Invalid state in AdaptGV with "+std::to_string(t.size())+"arguments!");
+                pybind11::handle pyHg = t[0];
+                auto& hg = pyHg.cast<typename DuneType::GridType&>();
+                /* Create a new C++ instance */
+                DuneType* gv = new DuneType(hg);
+                pybind11::bytes state(t[1]);
+                std::istringstream stream( state );
+                Dune::Fem::StandardInStream inStream(stream);
+                gv->indexSet().read( inStream );
+                auto py_state = t[2].cast<pybind11::dict>();
+                return std::make_pair(gv, py_state);
+          }
+    ), pybind11::keep_alive<1,2>(), pybind11::prepend() );
+  }
+}
+#endif

ddfem/examples/beam.py

@@ -136,10 +136,10 @@ def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, *args, **kwa
         h_min = h_max * 0.5 ** (j / 2)
         epsilon = get_eps(h_min)
 
-    omega.propagate_epsilon(epsilon)
+    omega.epsilon = epsilon
     domain = omega
 
-    domain = DomainDune(omega, x, gridView)
+    domain = DomainDune(omega, gridView)
     # domain.adapt(level=adaptLevels)
 
     print(f"h={h * 0.5 ** (adaptLevels / 2)}, epsilon={epsilon.value}")

ddfem/examples/five_circle_flat.py

@@ -15,16 +15,14 @@ pip install dune-fem
     """
     )
 
-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 geometry as gm
+from ddfem import GridView
 from ddfem.geometry.domain_dune import DomainDune
 
 
@@ -97,9 +95,10 @@ def getDomain(
             )
             return m * (dist - r_min) + geom.characteristic_length_min
 
+    omega.epsilon = get_eps(h)
+
     if version == "cartesian":
         domain = cartesianDomain(*domain_range, initial_gridsize)
-        epsilon = get_eps(h)
 
     elif version == "fitted":
         if pygmsh is None:
@@ -107,7 +106,6 @@ def getDomain(
         with pygmsh.occ.Geometry() as geom:
             geom.characteristic_length_max = h_max
             geom.characteristic_length_min = h_min
-            epsilon = get_eps(h_min)
 
             disks = [geom.add_disk([c[1][0], c[1][1], 0.0], c[0]) for c in balls]
 
@@ -118,7 +116,7 @@ def getDomain(
             shape = geom.boolean_intersection([disk_add, disks[5]])
 
             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,
             )
             mesh = geom.generate_mesh()
@@ -133,12 +131,13 @@ def getDomain(
         domain = cartesianDomain(*domain_range, gridsize)
 
     elif version == "gmsh_adaptive":
+        # in this version we need to adapt the epsilon since using the
+        # coarse grid h is not really useful
         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
-            epsilon = get_eps(h_min)
 
             geom.add_rectangle(
                 [domain_range[0][0], domain_range[0][1], 0.0],
@@ -147,7 +146,7 @@ def getDomain(
             )
 
             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,
             )
             mesh = geom.generate_mesh()
@@ -159,39 +158,21 @@ def getDomain(
     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
-
+    if not version == "dune_adaptive":
+        gridView = GridView(domain)
+    else:
         refinements = int(2 * np.log2(h_max / h_min))
+        gridView = GridView(domain,omega,
+                      factor=radius,
+                      refinements=refinements,
+                      adaptLevels=adaptLevels)
+        h_min = h_max * 0.5 ** (refinements / 2)
+        omega.epsilon.value = get_eps(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.propagate_epsilon(epsilon)
-    domain = omega
-
-    domain = DomainDune(omega, x, gridView)
-    domain.adapt(level=adaptLevels)
+    domain = DomainDune(omega, gridView)
 
     print(
-        f"h_max={h_max}, h_min={h_min * 0.5 ** (adaptLevels / 2)}, epsilon={epsilon.value}"
+        f"h_max={h_max}, h_min={h_min * 0.5 ** (adaptLevels / 2)}, epsilon={omega.epsilon.value}"
     )
 
     return gridView, domain

ddfem/examples/single_circle.py

@@ -128,7 +128,7 @@ def getDomain(initialRefine, version, inverted, adaptLevels=0, epsFactor=4.5):
 
     gridView = adaptiveLeafGridView(leafGridView(domain))
 
-    domain = DomainDune(omega, x, gridView)
+    domain = DomainDune(omega, gridView)
     domain.adapt(level=adaptLevels)
     gridView.plot()
 

ddfem/examples/triple_circle.py

@@ -204,10 +204,10 @@ def getDomain(
         h_min = h_max * 0.5 ** (j / 2)
         epsilon = get_eps(h_min)
 
-    omega.propagate_epsilon(epsilon)
+    omega.epsilon = epsilon
     domain = omega
 
-    domain = DomainDune(omega, x, gridView)
+    domain = DomainDune(omega, gridView)
     domain.adapt(level=adaptLevels)
 
     print(

ddfem/examples/triple_circle_beam.py

@@ -195,10 +195,10 @@ def getDomain(initialRefine, version, adaptLevels=0, epsFactor=4.5, dirichlet=Tr
         h_min = h_max * 0.5 ** (j / 3)
         epsilon = get_eps(h_min)
 
-    omega.propagate_epsilon(epsilon)
+    omega.epsilon = epsilon
     domain = omega
 
-    domain = DomainDune(omega, x, gridView)
+    domain = DomainDune(omega, gridView)
     # domain.adapt(level=adaptLevels)
 
     print(

ddfem/geometry/domain.py

@@ -7,7 +7,7 @@ class Domain:
     def __init__(self, omega):
         self.omega = omega
 
-    def __call__(self,x):
+    def __call__(self, x):
         return self.omega(x)
 
     def phi(self, x):

ddfem/geometry/domain_dune.py

@@ -1,30 +1,53 @@
 import time
 
-import dune.fem
-import dune.grid
+import dune.ufl
+from dune.fem.function import gridFunction
+from dune.fem import adapt, mark, markNeighbors
+from dune.fem.view import adaptiveLeafGridView, filteredGridView
+from dune.grid import cartesianDomain, Marker
+from dune.alugrid import aluConformGrid as GridView
+from dune.fem.utility import FemThreadPoolExecutor
+import ufl
 
 from .domain import Domain
-
+from .. import GridView
 
 class DomainDune(Domain):
-    def __init__(self, omega, x, gridView, filterTolerance=0):
+    def __init__(self, omega, domain, *,
+                 filterTolerance=0,
+                 factor=0, refinements=0,
+                 adaptLevels=0):
         super().__init__(omega)
-        self.x = x
-        self.gridView = gridView
+        if not hasattr(omega.epsilon,"value"):
+            omega.epsilon = dune.ufl.Constant(omega.epsilon,name="epsilon")
+        self.gridView = GridView(domain, omega,
+                              filterTolerance=filterTolerance,
+                              factor=factor,refinements=refinements,
+                              adaptLevels=adaptLevels)
+        dims = (self.gridView.dimGrid, self.gridView.dimWorld)
+        self.x = ufl.SpatialCoordinate(dune.ufl.domain(dims))
         self.fullSDF = self.gridFunction(self.omega(self.x), name="full-sdf")
-        if filterTolerance>0:
-            self.gridView = self._filter(tolerance=filterTolerance)
-            self.fullSDF = self.gridFunction(self.omega(self.x), name="full-sdf")
-
         self._phi = None
         self._bndProj = None
         self._extProj = None
         self._bndProjSDFs = {}
-
+        self._chi = None
+
+        """
+        print("Setting up projections",flush=True)
+        with FemThreadPoolExecutor(max_workers=8) as executor:
+            executor.submit( self.boundary_projection, self.x )
+            executor.submit( self.external_projection, self.x )
+            executor.submit( self.phi, self.x )
+            executor.submit( self.chi, self.x )
+            for child in self.omega:
+                executor.submit( self.generate_projSDF, child )
+        print("done",flush=True)
+        """
 
     def gridFunction(self, expr, name):
         start_ = time.time()
-        gf = dune.fem.function.gridFunction(expr, name=name, gridView=self.gridView)
+        gf = gridFunction(expr, name=name, gridView=self.gridView)
         # print(f"{name} setup: {time.time() - start_}")
         return gf
 
@@ -35,6 +58,14 @@ class DomainDune(Domain):
 
         return self._phi
 
+    def chi(self, x):
+        return super().chi(self.x)
+        if self._chi is None:
+            p = super().chi(self.x)
+            self._chi = self.gridFunction(p, "chidomain")
+
+        return self._chi
+
     def boundary_projection(self, x):
         if self._bndProj is None:
             p = super().boundary_projection(self.x)
@@ -58,28 +89,15 @@ class DomainDune(Domain):
             projSDF = self._bndProjSDFs[sdf.name]
         return projSDF
 
-    def adapt(self, level, lowerTol=-0.1, upperTol=0.1):
+    def _adapt(self, level, lowerTol=-0.1, upperTol=0.1):
         for _ in range(level):
-
             def mark(e):
                 v = self.fullSDF(e, self.gridView.dimension * [1.0 / 3.0])
                 return (
-                    dune.grid.Marker.refine
+                    Marker.refine
                     if v > lowerTol and v < upperTol
-                    else dune.grid.Marker.keep
+                    else Marker.keep
                 )
-
             self.gridView.hierarchicalGrid.adapt(mark)
-            # print(self.gridView.size(0))
             lowerTol /= 2
             upperTol /= 2
-
-    def _filter(self, tolerance):
-        sd = self.fullSDF
-        tol = tolerance  # * self.epsilon.value: issue here with epsilon being a UFL expression due to CSG approach
-        phiFilter = (
-            lambda e: sd(e, self.gridView.dimension * [1.0 / 3.0]) < tol
-        )  # bary needs fixing for squares
-        return dune.fem.view.filteredGridView(
-            self.gridView, phiFilter, domainId=1, useFilteredIndexSet=True
-        )

ddfem/geometry/primitive_base.py

@@ -18,13 +18,23 @@ ORIGIN = as_vector([0, 0])
 
 class SDF:
     def __init__(self, epsilon=None, name=None, children=None):
-        self.epsilon = epsilon
+        self._epsilon = epsilon
         self.child_sdf = children if children else []
 
         self.name = name
         if self.name is None:
             self.name = repr(self)
 
+    @property
+    def epsilon(self):
+        return self._epsilon
+
+    @epsilon.setter
+    def epsilon(self, eps):
+        self._epsilon = eps
+        for child in self.child_sdf:
+            child.epsilon = eps
+
     def _repr_core(self):
         return f"epsilon={self.epsilon}, name={self.name}, children={self.child_sdf}"
 
@@ -54,11 +64,6 @@ class SDF:
 
         return None
 
-    def propagate_epsilon(self, epsilon):
-        self.epsilon = epsilon
-        for child in self.child_sdf:
-            child.propagate_epsilon(epsilon)
-
     def phi(self, x, epsilon=None):
         if not epsilon:
             epsilon = self.epsilon

ddfem/plot.py

@@ -1,13 +1,73 @@
-from matplotlib import pyplot as plt
 from dune.fem.function import gridFunction
+from matplotlib import pyplot as plt
 from ufl import SpatialCoordinate, triangle
 
-def plotSolution(domain,uh,figsize, **kwargs):
+
+def plotSolution(domain, uh, figsize, **kwargs):
     x = SpatialCoordinate(triangle)
-    fig, axs = plt.subplots(1,2, figsize=[2*figsize[0],figsize[1]])
-    uh.plot(figure=(fig,axs[0]),**kwargs)
-    gridFunction(uh*domain.chi(x)).plot(figure=(fig,axs[1]),**kwargs)
+    fig, axs = plt.subplots(1, 2, figsize=[2 * figsize[0], figsize[1]])
+    uh.plot(figure=(fig, axs[0]), **kwargs)
+    gridFunction(uh * domain.chi(x)).plot(figure=(fig, axs[1]), **kwargs)
     for a in axs:
         gridFunction(domain.phi(x), gridView=uh.space.gridView).plot(
-             onlyContours=True,contours=[0.5],gridLines=None,
-             contourWidth=2, contourColor="black", figure=(fig,a))
+            onlyContours=True,
+            contours=[0.5],
+            gridLines=None,
+            contourWidth=2,
+            contourColor="black",
+            figure=(fig, a),
+        )
+
+
+def plotSdfTree(SDF, gridView, figsize, maxDepth=None, **kwargs):
+    x = SpatialCoordinate(triangle)
+    fig, axs = plt.subplots(1, 2, figsize=[2 * figsize[0], figsize[1]])
+
+    gridFunction(SDF(x), gridView=gridView).plot(figure=(fig, axs[0]), **kwargs)
+
+    def plot_recursive(childSDF, depth):
+        if maxDepth is not None and depth > maxDepth:
+            return
+
+        gridFunction(childSDF(x), gridView=gridView).plot(
+            onlyContours=True,
+            contours=[0],
+            gridLines=None,
+            contourWidth=2,
+            contourColor="black",
+            figure=(fig, axs[0]),
+        )
+
+        for child in childSDF.child_sdf:
+            plot_recursive(child, depth + 1)
+
+    plot_recursive(SDF, 0)
+    gridFunction(SDF(x), gridView=gridView).plot(
+        onlyContours=True,
+        contours=[0],
+        gridLines=None,
+        contourWidth=2,
+        contourColor="white",
+        figure=(fig, axs[0]),
+    )
+    gridFunction(SDF.phi(x), gridView=gridView).plot(figure=(fig, axs[1]), **kwargs)
+
+def plotBndExt(domain, Model, uh, figsize, t=0, **kwargs):
+    from .boundary import BoundaryTerms
+
+    x = SpatialCoordinate(triangle)
+
+    bt = BoundaryTerms(Model, domain)
+    bndExt = bt.BndValueExt(t, x, uh)
+
+    fig, axs = plt.subplots(1, figsize=figsize)
+    gridFunction(bndExt, gridView=uh.space.gridView).plot(figure=(fig, axs), **kwargs)
+
+    gridFunction(domain(x), gridView=uh.space.gridView).plot(
+        onlyContours=True,
+        contours=[0],
+        gridLines=None,
+        contourWidth=2,
+        contourColor="black",
+        figure=(fig, axs),
+    )

{ddfem-1.0.4.dist-info → ddfem-1.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddfem
-Version: 1.0.4
+Version: 1.0.6
 Summary: Diffuse domain finite element solver
 Author-email: Luke Benfield <luke.benfield@warwick.ac.uk>, Andreas Dedner <a.s.dedner@warwick.ac.uk>
 License-Expression: MIT
@@ -15,10 +15,17 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fenics-ufl==2022.2.0
 Requires-Dist: numpy
-Requires-Dist: setuptools<81
+Requires-Dist: setuptools==79
 Provides-Extra: dune
 Requires-Dist: dune-fem; extra == "dune"
 Requires-Dist: pygmsh; extra == "dune"
+Provides-Extra: doc
+Requires-Dist: dune-fem; extra == "doc"
+Requires-Dist: pygmsh; extra == "doc"
+Requires-Dist: jupyter; extra == "doc"
+Requires-Dist: jupytext; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
 Dynamic: license-file
 
 # Diffuse Domain Finite Element Methods