emerge 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

emerge/_emerge/geo/step.py

@@ -1,11 +1,70 @@
 import gmsh
 from ..geometry import GeoPoint, GeoEdge, GeoVolume, GeoSurface, GeoObject
+from ..selection import FaceSelection
+from .shapes import Box
+from .operations import unite
+
 from pathlib import Path
 import numpy as np
+from typing import Callable
 
-class STEPItems:
+def _select_num(num1: float | None, num2: float | None) -> float:
+    if num1 is None and num2 is None:
+        return 0.0
+    if isinstance(num1, float) and num2 is None:
+        return num1
+    if num1 is None and isinstance(num2, float):
+        return num2
+    return max(num1, num2)
+
+class _FaceSliceSelector:
+    
+    def __init__(self, face_numbers: list[int], selector: Callable):
+        self.numbers: list[str] = face_numbers
+        self.selector: Callable = selector
+        
+    def __getitem__(self, slice) -> FaceSelection:
+        nums = self.numbers.__getitem__(slice)
+        if isinstance(nums, int):
+            nums = [nums,]
+        return self.selector(*nums)
+    
+class StepVolume(GeoVolume):
+    """The StepVoume class extens the EMerge GeoVolume class to add easier
+    face selection functionalities based on numbers as face names are not 
+    imported currently
+
+    Args:
+        GeoVolume (_type_): _description_
+
+    Returns:
+        _type_: _description_
+    """
+    
+        
+    @property
+    def _face_numbers(self) -> list[int]:
+        return sorted([int(name[4:]) for name in self._face_pointers.keys()])
+    
+    @property
+    def face_slice(self) -> _FaceSliceSelector:
+        return _FaceSliceSelector(self._face_numbers, self.faces)
+    
+    def faces(self, *numbers: int) -> FaceSelection:
+        """Select a set of faces by number
+
+        Returns:
+            FaceSelection: _description_
+        """
+        names = [f'Face{num}' for num in numbers]
+        return super().faces(*names)
+        
 
-    def __init__(self, filename: str, unit: float = 1.0):
+class STEPItems:
+    """STEPItems imports geometries form a STEP file and exposes them to the user.
+    
+    """
+    def __init__(self, name: str, filename: str, unit: float = 1.0):
         """Imports the provided STEP file.
         Specify the unit in case of scaling issues where mm units are not taken into consideration.
 
@@ -16,62 +75,139 @@ class STEPItems:
         Raises:
             FileNotFoundError: If a file does not exist
         """
+        self.name: str = name
+
         stl_path = Path(filename)
-        gmsh.option.setNumber("Geometry.OCCScaling", 1)
-        gmsh.option.setNumber("Geometry.OCCImportLabels", 2) 
+        gmsh.option.setNumber("Geometry.OCCScaling", unit)
+        gmsh.option.setNumber("Geometry.OCCImportLabels", 1) 
 
         if not stl_path.exists:
             raise FileNotFoundError(f'File with name {stl_path} does not exist.')
         
         dimtags = gmsh.model.occ.import_shapes(filename, format='step')
-
-        gmsh.model.occ.affine_transform(dimtags, np.array([unit, 0, 0, 0,
-                                                           0, unit, 0, 0,
-                                                           0, 0, unit, 0,
-                                                           0, 0, 0, 1]))
-        #dimtags = gmsh.model.occ.heal_shapes(dimtags, tolerance=1e-6)
         
-        self.points: dict[str, GeoPoint] = dict()
-        self.edges: dict[str, GeoEdge] = dict()
-        self.surfaces: dict[str, GeoSurface] = dict()
-        self.volumes: dict[str, GeoVolume] = dict()
-
+        self.points: list[GeoPoint] = []
+        self.edges: list[GeoEdge] = []
+        self.surfaces: list[GeoSurface] = []
+        self.volumes: list[GeoVolume] = []
+        
         i = 0
         for dim, tag in dimtags:
-            name = gmsh.model.getPhysicalName(dim, tag)
+            name = gmsh.model.getPhysicalName(dim, tag) #for now, this doesn't actually ever work.
             if name == '':
                 name = f'Obj{i}'
                 i+=1
             if dim == 0:
-                self.points[name] = GeoPoint(tag)
+                self.points.append(GeoPoint(tag, name=f'{self.name}_{name}'))
             elif dim == 1:
-                self.edges[name] = GeoEdge(tag)
+                self.edges.append(GeoEdge(tag, name=f'{self.name}_{name}'))
             elif dim == 2:
-                self.surfaces[name] = GeoSurface(tag)
+                self.surfaces.append(GeoSurface(tag, name=f'{self.name}_{name}'))
             elif dim == 3:
-                self.volumes[name] = GeoVolume(tag)
-    
+                self.volumes.append(StepVolume(tag, name=f'{self.name}_{name}'))
+        
+        gmsh.model.occ.synchronize()
+        
     @property
-    def _dicts(self):
-        yield self.points
-        yield self.edges
-        yield self.surfaces
-        yield self.volumes
-
+    def dictionary(self) -> dict[str, GeoObject]:
+        return {obj.name: obj for obj in self.objects}
+    
     @property
     def objects(self) -> tuple[GeoObject,...]:
-        objects = tuple()
-        for dct in self._dicts:
-            objects = objects + tuple(dct.values())
-        return objects
+        """Returns a list of all objects in the STEP file
+
+        Returns:
+            tuple[GeoObject,...]: _description_
+        """
+        return tuple(self.points+self.edges+self.surfaces+self.volumes)
+    
+    def __getitem__(self, name: str) -> GeoObject | None:
+        return self.dictionary.get(name, None)
+    
+    def as_volume(self) -> StepVolume:
+        """Returns the 3D volumetric part of the STEP file as a single geometry
+
+        Returns:
+            StepVolume: The resultant StepVolume(GeoVolume) object.
+        """
+        if len(self.volumes)==1:
+            return self.volumes[0]
+        return unite(*self.volumes)._auto_face_tag()
+    
+    def as_surface(self) -> GeoSurface:
+        """Returns the 2D surface part of the STEP file as a single geometry
+
+
+        Returns:
+            GeoSurface: The resultant GeoSurface object
+        """
+        if len(self.surfaces)==1:
+            return self.surfaces[0]
+        return unite(*self.surfaces)
+    
+    def as_edge(self) -> GeoEdge:
+        """Returns the 1D Edge part of the STEP file as a single geometry
+
+        Returns:
+            GeoEdge: The resultant GeoEdge object
+        """
+        if len(self.edges)==1:
+            return self.edges[1]
+        return unite(*self.edges)
     
-    def __getitem__(self, name: str) -> GeoObject:
-        if name in self.points:
-            return self.points[name]
-        elif name in self.edges:
-            return self.edges[name]
-        elif name in self.surfaces:
-            return self.surfaces[name]
-        elif name in self.volumes:
-            return self.volumes[name]
-            
+    def as_point(self) -> GeoPoint:
+        """Returns the 0D Point part of the STEP file as a single geometry
+
+        Returns:
+            GeoPoint: The resultant GeoPoint object.
+        """
+        if len(self.points)==1:
+            return self.points[0]
+        return unite(*self.points)
+    
+    def enclose(self, 
+                margin: float = None,
+                x_margins: tuple[float, float] = (None, None),
+                y_margins: tuple[float, float] = (None, None),
+                z_margins: tuple[float, float] = (None, None)) -> Box:
+        """Create an enclosing bounding box for the step model.
+
+        Args:
+            margin (float, optional): _description_. Defaults to 0.
+            x_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+            y_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+            z_margins (tuple[float, float], optional): _description_. Defaults to (0., 0.).
+
+        Returns:
+            Box: _description_
+        """
+        xminm = _select_num(margin, x_margins[0])
+        xmaxm = _select_num(margin, x_margins[1])
+        yminm = _select_num(margin, y_margins[0])
+        ymaxm = _select_num(margin, y_margins[1])
+        zminm = _select_num(margin, z_margins[0])
+        zmaxm = _select_num(margin, z_margins[1])
+        
+        xmin = 1000000
+        xmax = -1000000
+        ymin = 1000000
+        ymax = -1000000
+        zmin = 1000000
+        zmax = -1000000
+        
+        for obj in self.objects:
+            for dim, tag in obj.dimtags:
+                x1, y1, z1, x2, y2, z2 = gmsh.model.occ.getBoundingBox(dim, tag)
+                xmin = min(xmin, x1)
+                xmax = max(xmax, x2)
+                ymin = min(ymin, y1)
+                ymax = max(ymax, y2)
+                zmin = min(zmin, z1)
+                zmax = max(zmax, z2)
+        
+        width = xmax-xmin + xminm + xmaxm
+        depth = ymax-ymin + yminm + ymaxm
+        height = zmax -zmin + zminm + zmaxm
+
+        return Box(width, depth, height, (xmin-xminm, ymin-yminm, zmin-zminm)).background()
+    

emerge/_emerge/geometry.py

@@ -18,13 +18,12 @@
 from __future__ import annotations
 import gmsh # type: ignore
 from .material import Material, AIR
-from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection
+from .selection import FaceSelection, DomainSelection, EdgeSelection, PointSelection, Selection, SelectionError
 from loguru import logger
-from typing import Literal, Any, Iterable, TypeVar
+from typing import Literal, Any, Iterable, Callable
 import numpy as np
 
 
-
 def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
     new_tags = []
     for tag in tags:
@@ -34,6 +33,7 @@ def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
 def _bbcenter(x1, y1, z1, x2, y2, z2):
     return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
 
+
 FaceNames = Literal['back','front','left','right','top','bottom']
 
 class _KEY_GENERATOR:
@@ -232,6 +232,8 @@ class _FacePointer:
     def copy(self) -> _FacePointer:
         return _FacePointer(self.o, self.n)
 
+    def __eq__(self, other: _FacePointer) -> bool:
+        return (np.linalg.norm(self.o - other.o) + np.linalg.norm(self.n - other.n)) < 1e-6
 
 _GENERATOR = _KEY_GENERATOR()
 _GEOMANAGER = _GeometryManager()
@@ -241,6 +243,7 @@ class GeoObject:
     """
     dim: int = -1
     _default_name: str = 'GeoObject'
+    
     def __init__(self, tags: list[int] | None = None, name: str | None = None):
         if tags is None:
             tags = []
@@ -263,7 +266,24 @@ class GeoObject:
         
         self.give_name(name)
         _GEOMANAGER.submit_geometry(self)
-
+        self._fill_face_pointers()
+        
+    def _fill_face_pointers(self) -> None:
+        """ Fills the list of all face pointers of this object
+        """
+        current = list(self._face_pointers.values())
+        ctr = 0
+        gmsh.model.occ.synchronize()
+        for dim, tag in gmsh.model.get_boundary(self.dimtags, True, False):
+            if dim != 2:
+                continue
+            o = gmsh.model.occ.get_center_of_mass(2, tag)
+            n = gmsh.model.get_normal(tag, (0,0))
+            fp = _FacePointer(o, n)
+            if fp not in current:
+                self._face_pointers[f'Face{ctr}'] = fp
+                ctr += 1
+            
     def _store(self, name: str, data: Any) -> None:
         """Store a property as auxilliary data under a given name
 
@@ -361,6 +381,19 @@ class GeoObject:
     def _data(self, *labels) -> tuple[Any | None, ...]:
         return tuple([self._aux_data[lab] for lab in labels])
     
+    def _replace_pointer(self, name: str, face_pointer: _FacePointer) -> None:
+        """Will be used to replace face pointers so only one unique one exists.
+
+        Args:
+            name (str): _description_
+            face_pointer (_FacePointer): _description_
+        """
+        for key, fp in self._face_pointers.items():
+            if fp == face_pointer:
+                self._face_pointers.pop(key)
+                break
+        self._face_pointers[name] = face_pointer
+
     def _add_face_pointer(self, 
                           name: str,
                           origin: np.ndarray | None = None,
@@ -378,15 +411,16 @@ class GeoObject:
             ValueError: _description_
         """
         if tag is not None:
-            o = gmsh.model.occ.get_center_of_mass(2, tag)
-            n = gmsh.model.get_normal(tag, (0,0))
-            self._face_pointers[name] = _FacePointer(o, n)
-            return
-        if origin is not None and normal is not None:
-            self._face_pointers[name] = _FacePointer(origin, normal)
-            return
-        raise ValueError('Eitehr a tag or an origin + normal must be provided!')
-    
+            origin = gmsh.model.occ.get_center_of_mass(2, tag)
+            normal = gmsh.model.get_normal(tag, (0,0))
+        
+        if origin is None or normal is None:
+            raise ValueError('Eitehr a tag or an origin + normal must be provided!')
+        fp = _FacePointer(origin, normal)
+        self._face_pointers[name] = fp
+        #self._replace_pointer(name, fp) <-- Will be added in later versions
+        
+        
     def make_copy(self) -> GeoObject:
         """ Copies this object and returns a new object (also in GMSH)"""
         new_dimtags = gmsh.model.occ.copy(self.dimtags)
@@ -452,7 +486,7 @@ class GeoObject:
     def _face_tags(self, name: FaceNames, tool: GeoObject | None = None) -> list[int]:
         names = self._all_pointer_names
         if name not in names:
-            raise ValueError(f'The face {name} does not exist in {self}')
+            raise ValueError(f'The face {name} does not exist in {self}. Only {list(self._face_pointers.keys())}')
         
         gmsh.model.occ.synchronize()
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
@@ -467,6 +501,7 @@ class GeoObject:
         logger.info(f'Selected face {tags}.')
         return tags
 
+    
     def set_material(self, material: Material) -> GeoObject:
         self.material = material
         return self
@@ -563,6 +598,9 @@ class GeoObject:
         Returns:
             FaceSelection: The selected faces
         """
+        # if not self._exists:
+        #     raise SelectionError('Cannot select faces from an object that no longer exists.')
+        
         if isinstance(exclude, str):
             exclude = (exclude,)
             
@@ -572,11 +610,13 @@ class GeoObject:
         if tags is None:
             tags = []
         
-        
         for name in exclude:
             tags.extend(self.face(name, tool=tool).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
-        return FaceSelection([t for d,t in dimtags if t not in tags])
+        selname = 'Boundary'
+        if exclude:
+            selname = selname + 'Except[' + ','.join(exclude) + ']'
+        return FaceSelection([t for d,t in dimtags if t not in tags])._named(selname)
     
     def face(self, name: FaceNames = None, tool: GeoObject | None = None, no: FaceNames = None) -> FaceSelection:
         """Returns the FaceSelection for a given face name.
@@ -596,8 +636,16 @@ class GeoObject:
         if no is not None:
             return self.boundary(exclude=no)
         
-        return FaceSelection(self._face_tags(name, tool))
+        return FaceSelection(self._face_tags(name, tool))._named(name)
+
+    def all_faces(self) -> list[FaceSelection]:
+        """Returns a list of all face selections of this object
 
+        Returns:
+            list[FaceSelection]: A list of all face selections
+        """
+        return [self.face(name) for name in self._face_pointers]
+    
     def faces(self, *names: FaceNames, tool: GeoObject | None = None) -> FaceSelection:
         """Returns the FaceSelection for a given face names.
         
@@ -613,7 +661,7 @@ class GeoObject:
         tags = []
         for name in names:
             tags.extend(self._face_tags(name, tool))
-        return FaceSelection(tags)
+        return FaceSelection(tags)._named('Faces[' + ','.join(names) + ']')
     
     def hide(self) -> GeoObject:
         """Hides the object from views
@@ -658,7 +706,22 @@ class GeoObject:
     def remove(self) -> None:
         self._exists = False
         gmsh.model.occ.remove(self.dimtags, True)
-        
+    
+    def extract(self, tags: int | list[int]) -> GeoObject:
+        """Returns a new GeoObject of the same dimensional type that isolates a set of given tags
+
+        Args:
+            tags (list[int]): A list of GMSH tags
+
+        Returns:
+            GeoObject: _description_
+        """
+        if isinstance(tags, int):
+            tags = [tags,]
+        self.tags = [t for t in self.tags if t not in tags]
+        dts = [(self.dim, t) for t in tags]
+        return GeoObject.from_dimtags(dts)
+    
 class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
@@ -675,10 +738,94 @@ class GeoVolume(GeoObject):
         else:
             self.tags = [tag,]
 
+        self._fill_face_pointers()
+        self._autoname()
+        
     @property
     def selection(self) -> DomainSelection:
         return DomainSelection(self.tags)
     
+    def _auto_face_tag(self) -> GeoVolume:
+        self._face_pointers = dict()
+        self._tools = dict()
+        logger.trace('Automatically assigning face pointers.')
+        ctr = 0
+        for tag in self.tags:
+            loops = gmsh.model.occ.getSurfaceLoops(tag)
+            for loopcluster in loops[1]:
+                for st in loopcluster:
+                    self._add_face_pointer(f'Face{ctr}', tag=st)
+                    ctr += 1
+        return self
+    
+    def exterior_faces(self, base_object: GeoObject) -> FaceSelection:
+        """Select the exterior faces of an object based on the face
+        pointers of an original base object. For example
+        
+        Example:
+        >>> cheese = em.geo.Box(...)
+        >>> hole = em.geo.Box(...) 
+        >>> holed_cheese = em.geo.subtract(cheese, hole)
+        >>> holed_cheese.exterior_faces(cheese)
+
+        Args:
+            base_object (GeoObject): The object to base the selection on.
+
+        Returns:
+            FaceSelection: The resultant face selection
+        """
+        dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
+        
+        normals = [gmsh.model.get_normal(t, [0,0]) for d,t, in dimtags]
+        origins = [gmsh.model.occ.get_center_of_mass(d, t) for d,t in dimtags]
+        
+        tool_tags = []
+        for key, tool in self._tools.items():
+            if key == base_object._key:
+                continue
+            for name in tool.keys():
+                tags = tool[name].find(dimtags, origins, normals)
+                tool_tags.extend(tags)
+        tags = [dt[1] for dt in dimtags if dt[1] not in tool_tags]
+        return FaceSelection(tags)
+    
+    def _find_fp(self, condition: Callable):
+        for key, fp in self._face_pointers.items():
+            if condition(fp):
+                return key, fp
+        return None, None
+    
+    def _rename_fp(self, new_name: str, condition: Callable):
+        name, fp = self._find_fp(condition)
+        if fp is not None:
+            self._face_pointers.pop(name)
+            self._face_pointers[new_name] = fp
+        
+    def _autoname(self) -> None:
+        if len(self._face_pointers)==0:
+            return
+        
+        xs = []
+        ys = []
+        zs = []
+        for fp in self._face_pointers.values():
+            xs.append(fp.o[0])
+            ys.append(fp.o[1])
+            zs.append(fp.o[2])
+        minx = min(xs)
+        maxx = max(xs)
+        miny = min(ys)
+        maxy = max(ys)
+        minz = min(zs)
+        maxz = max(zs)
+        
+        self._rename_fp('-x', lambda fp: (fp.o[0]==minx) and np.abs(np.dot(fp.n, np.array([1,0,0])))>0.999)
+        self._rename_fp('+x', lambda fp: (fp.o[0]==maxx) and np.abs(np.dot(fp.n, np.array([1,0,0])))>0.999)
+        self._rename_fp('-y', lambda fp: (fp.o[1]==miny) and np.abs(np.dot(fp.n, np.array([0,1,0])))>0.999)
+        self._rename_fp('+y', lambda fp: (fp.o[1]==maxy) and np.abs(np.dot(fp.n, np.array([0,1,0])))>0.999)
+        self._rename_fp('-z', lambda fp: (fp.o[2]==minz) and np.abs(np.dot(fp.n, np.array([0,0,1])))>0.999)
+        self._rename_fp('+z', lambda fp: (fp.o[2]==maxz) and np.abs(np.dot(fp.n, np.array([0,0,1])))>0.999)
+        
 class GeoPoint(GeoObject):
     dim = 0
     _default_name: str = 'GeoPoint'

emerge/_emerge/material.py

@@ -244,6 +244,7 @@ class FreqCoordDependent(MatProperty):
         if scalar is not None:
             def _func(f, x, y, z) -> np.ndarray:
                 return np.eye(3)[:, :, None] * scalar(f,x,y,z)[None, None, :]
+        
         if vector is not None:
             def _func(f,x, y, z) -> np.ndarray:
                 N = x.shape[0]
@@ -251,6 +252,7 @@ class FreqCoordDependent(MatProperty):
                 idx = np.arange(3)
                 out[idx, idx, :] = vector(f,x,y,z)
                 return out
+        
         if matrix is not None:
             _func = matrix
 

emerge/_emerge/mesh3d.py

@@ -420,7 +420,7 @@ class Mesh3D(Mesh):
         self.tet_to_edge_sign = np.zeros((6, self.tets.shape[1]), dtype=int) + _MISSING_ID
         self.tet_to_tri = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
         self.tet_to_tri_sign = np.zeros((4, self.tets.shape[1]), dtype=int) + _MISSING_ID
-
+        
         tri_to_tet = defaultdict(list)
         for itet in range(self.tets.shape[1]):
             edge_ids = [self.get_edge(self.tets[i-1,itet],self.tets[j-1,itet]) for i,j in zip([1, 1, 1, 2, 4, 3], [2, 3, 4, 3, 2, 4])]
@@ -503,7 +503,6 @@ class Mesh3D(Mesh):
                 continue
             self.etag_to_edge[t] = [int(self.edge_t2i.get(tag,None)) for tag in edge_tags[0] if tag in self.edge_t2i]
         
-        
         ## Tag bindings
         logger.trace('Constructing geometry to mesh mappings.')
         face_dimtags = gmsh.model.get_entities(2)
@@ -512,7 +511,6 @@ class Mesh3D(Mesh):
             node_tags = [self.n_t2i[int(t)] for t in node_tags[0]]
             self.ftag_to_node[t] = node_tags
             node_tags = np.squeeze(np.array(node_tags)).reshape(-1,3).T
-            
             self.ftag_to_tri[t] = [self.get_tri(node_tags[0,i], node_tags[1,i], node_tags[2,i]) for i in range(node_tags.shape[1])]
             self.ftag_to_edge[t] = sorted(list(np.unique(self.tri_to_edge[:,self.ftag_to_tri[t]].flatten())))
         

emerge/_emerge/mesher.py

@@ -75,9 +75,13 @@ class Mesher:
         self.objects: list[GeoObject] = []
         self.size_definitions: list[tuple[int, float]] = []
         self.mesh_fields: list[int] = []
+        
         self._amr_fields: list[int] = []
         self._amr_coords: np.ndarray = None
         self._amr_sizes: np.ndarray = None
+        self._amr_ratios: np.ndrray = None
+        self._amr_new: np.ndarray = None
+
         self.min_size: float = None
         self.max_size: float = None
         self.periodic_cell: PeriodicCell = None
@@ -152,7 +156,6 @@ class Mesher:
                                         3: dict()}
         if len(objects) > 0: # type: ignore
             dimtags, output_mapping = gmsh.model.occ.fragment(final_dimtags, embedding_dimtags)
-
             for domain, mapping in zip(final_dimtags + embedding_dimtags, output_mapping):
                 tag_mapping[domain[0]][domain[1]] = [o[1] for o in mapping]
             for dom in objects: # type: ignore
@@ -289,7 +292,7 @@ class Mesher:
             gmsh.model.mesh.setSizeFromBoundary(dimtag[0], dimtag[1], 0)
     
     
-    def add_refinement_points(self, coords: np.ndarray, sizes: np.ndarray) -> None:
+    def add_refinement_points(self, coords: np.ndarray, sizes: np.ndarray, ratios: np.ndarray):
         if self._amr_coords is None:
             self._amr_coords = coords
         else:
@@ -299,25 +302,46 @@ class Mesher:
             self._amr_sizes = sizes
         else:
             self._amr_sizes = np.hstack((self._amr_sizes, sizes))
-            
+        
+        if self._amr_ratios is None:
+            self._amr_ratios = ratios
+        else:
+            self._amr_ratios = np.hstack((self._amr_ratios, ratios))
+        
+        if self._amr_new is None:
+            self._amr_new = np.ones_like(sizes)
+        else:
+            self._amr_new = np.hstack((0.0*self._amr_new, np.ones_like(sizes)))
+        
+        
     def set_refinement_function(self,
-                                refinement: float,
                                 gr: float = 1.5,
                                 _qf: float = 1.0):
         xs = self._amr_coords[0,:]
         ys = self._amr_coords[1,:]
         zs = self._amr_coords[2,:]
-        newsize = refinement*self._amr_sizes
+        newsize = self._amr_ratios*self._amr_sizes
         A = newsize/gr
         B = (1-gr)/gr
         from numba import njit, i8, f8
 
         @njit(f8(i8,i8,f8,f8,f8,f8), nogil=True, fastmath=True, parallel=False)
         def func(dim, tag, x, y, z, lc):
-            sizes = np.maximum(newsize, A - B * _qf*np.sqrt((x-xs)**2 + (y-ys)**2 + (z-zs)**2))
+            sizes = np.maximum(newsize, A - B * _qf*np.clip(np.sqrt((x-xs)**2 + (y-ys)**2 + (z-zs)**2) - newsize/3, a_min=0, a_max=None))
             return min(lc,  float(np.min(sizes)))
-        gmsh.model.mesh.setSizeCallback(func)
         
+        gmsh.model.mesh.setSizeCallback(func)
+    
+    def refine_finer(self, factor: float):
+        newids = self._amr_new==1
+        self._amr_ratios[newids] = self._amr_ratios[newids]*(0.85**factor)
+        return self._amr_ratios[newids][0]
+    
+    def refine_coarser(self, factor: float):
+        newids = self._amr_new==1
+        self._amr_ratios[newids] = self._amr_ratios[newids]/(0.85**factor)
+        return self._amr_ratios[newids][0]
+    
     def add_refinement_point(self,
                              coordinate: np.ndarray,
                              refinement: float,
@@ -389,7 +413,7 @@ class Mesher:
             if obj.dim==2:
                 logger.warning('Forwarding to set_face_size')
                 self.set_face_size(obj, size)
-        logger.debug(f'Setting size {size*1000:.3f}ff for object {obj}')
+        logger.debug(f'Setting size {size*1000:.3f}mm for object {obj}')
         self._set_size_in_domain(obj.tags, size)
 
     def set_face_size(self, obj: GeoSurface | Selection, size: float):
@@ -405,7 +429,7 @@ class Mesher:
                 logger.warning('Forwarding to set_domain_size')
                 self.set_face_size(obj, size)
         
-        logger.debug(f'Setting size {size*1000:.3f}ff for face {obj}')
+        logger.debug(f'Setting size {size*1000:.3f}mm for face {obj}')
         self._set_size_on_face(obj.tags, size)
     
     def set_size(self, obj: GeoObject, size: float) -> None: