For now a two-dimensional geometry is based on an outer rectangle and some inner (non-intersecting) rectangles.
Do we want to allow different shapes?

Make proper examples for the scenarios:

• Constraints
• Periodic Transforms
• Diffeomorphis Transforms
• Remove or update old examples with old syntax

Generalize the concept of adding holes

General functionality

• A hole individually can represent a void or a composite added in parallel.
• Holes can be added everywhere. In particular Stellar that touch more than one edge currently cause errors and will not be added.
• Give holes individual entities and level.
• Boundary clipping with intersection point computation.

Merging and intersections

• Option to respect collision with user defined distance value. The collision should not exist on a continuous level, as finer discretization may cause collision that not appear on coarser discretization.
• If two holes are voids, enable merging if they have intersection. Simple cases: Intersection at 1 point. Intersection on a whole edge, then this edge can be removed. If the intersection cuts out an area of positive measure should be keep it (in case there is a point connection to remaining domain, e.g. touching moons) or remove it ( isolated subdomain).
  The latter involves the case, where a single void cuts a corner of the whole domain.
• A merging of two holes that represent submaterial with intersection with positive measure should only be possible if composites have the same entity. Add a merge_allowed flag possibly. Such merged holes may be summarized in a complex_geometry object for future merging. which represents a polygon in discrete level and piecewise (switching at intersection points) the single hole geometry at continuous level.
• If two material holes share a common edge (e.g. chessboard), in case of no collision option, there intersection interface should respect the discretization of both. (e.g. rectangles of different sizes). Here no entity restriction is necessary.
• inclusions finally stored as Polygon ( with possible multiple interior)
• the main domain must be flagged (level = 0) and is a list of Polygons.
• if a polygon representing a inclusion (level > 0 ) intersection with main domain (level= 0) then clipping
• inclusions have different entities and level, the higher level has priority in its full shape representation
• additional flag mark if its a hole or an inclusion (realized via add_hole, add_inclusion - methods)

1. topo.add_hole( hole, level = 2)
2. topo.add_inclusion( hole_2, level = 1, entity = "copper")

• i.e. if inclusion has smaller level and is completely contained in higher level polygon, don't add
• if level is the same merge if allowed
• Write Output information if a added Bubble is actually added (due to given rules)

Domain Concepts

• The main domain can be choosen as a polygon. Complex polygons may be obtained from merging simpler shapes (circle + rectangular ) example.
• API format :
• domain = subdomain1 + subdomain2 (for merge), domain = subdomain1 - subdomain2 (for subset minus)
• Periodische Randbedingungen auf main domains die rectangles sind.
• #40
• Periodische Randbedingungen und nicht periodische in parallel (nur kanten basiert)
• Geometrieobject have is_reference_domain(), is_void(), is_inclusion() knowledge
• Hole classes for special treatment: convex classes, stellar classes, rectangles.

Pass multiple transform or constraint methods.

Make some nice logo picture.

Ideas:

• Write Bubbles with bubbles
• Make a Bubbles background (Rectangle) and add bubbles as holes to make the bubbles writing.

Is Dolfin's dependence needed? Is it just for testing purposes? I would prefer to remove it from the core package.

As extension of hole.py

• Remove topology_deprecated
• Remove old Bubbles files.
• Build package based on the relevant files:

bubbles/two_d :

1. topology.py
2. geometry.py
3. utils.py
4. transform.py
5. constraints.py

bubbles/gmsh_api:

1. bubbles.gmsh_api.py

The presents of geometry intersection with possible coarse boundary elements can cause very poor meshes when applying gmsh.

For this reason it is required to have more vertices on the boundary interface, in particular the intersection sub manifold of composite and domain boundary.

Here are multiple solutions:

1. Solve with lc from gmsh.
2. shapely segmentize, but this has to respect aligned amount of vertices in case of periodic domains to ensure proper periodic functions spaces later in fenics.

Samplers

• Provide Collision respecting sampler
• Provide Volume constraint sampler

Improve the projection, a point on the manifold should be approximated on a hyperplane

Now: euclidean projection, just change the height

Remove deprecated code.

Goal functionality: module + module = new module

smallest module unit is a box

--> construct sandwich this way

Use the Python API provided by GMSH.

Questions:

• Create holes, by defining physical groups and not assigning the hole to any PH, Gmsh claims that this mesh will be ignored and not be saved. (Test if true)

Run formatter, linter and add some type-hints.

Write a .GEO parser, s.t. the gmsh UI can be used to create e.g. shapely geometries.

Themodule bubbles.two_d.holehas much redundant code, I think with pydantic it would become leaner.

• Create reference mesh on a sphere via Gmsh with nodes in physical space. Compute reference coordinates (theta, phi) and map those through the Bubble transformation to obtain a discretization of the 2d manifold itself.

• Introduce clipping based on projection ( non linear optimization with nonlinear constraints). Possible use mystic package for penalty based free optimization to incoorperate the constraint.

• Introduce a framework that allows to decide how the triangles are "extended" or "clipped" to preserve high quality triangulation. This might based on a simple compare the choices of triangle that would arise via multiple projections of its vertices and compare those (angle based).

• In the clipping plane separate lineloops need to be indified. Build a vertex (index) to connected line (hashmap : int -> list) Based on the idea to not allow lines with more than 2 neighbours, independend line loops can be detected.

• A bubble should be placed within a Box. For this introduce a Box class, possible name : BoxWithBubbles. This class should handle box intersections with bubbles.

• Build the actual geo / msh / xml file to have a bubble within a box.

• Develop bubble subclasses, that allow for more complex structures.

• Test periodicity of trafo via scatter plot

Solve the remaining TODOs in the topology.py module.

Construct classes derived from an abstractclass BoxWithFeatures

• BoxWithLayers. Given a height/width/depth of a layer (per standard value > 0 ) gets a number n€IN of layers. Each layer should have an own physical attribute ( for later material differentiation.

• BoxWithBubbles:

  • A box consists of 6 finite hyperplanes ( not necessary orthogonal), e.g. rectangle extruded or trapezoidal extruded.
    parameters : Height / widht/ depth , angle (controls trapezoidal) parameter.
  • manages bubbles and intersection of bubbles with its boundary (clipping),
  • a bubble is allowed to intersect with 1 or 2 ( optional even 3 ) sides

• Merge 2 BoxWidthFeatures, s.t. a common grid is possible, e.g. with application to build a sandwich.

• Build a sandwich BoxWithLayers / BoxWithBubbles / BoxWithLayers, where is width of the Boxwith layers is larger to equal to the frontal width of the BoxWithBubbles.

The gmsh api consist of two separate blocks:

Not dependend on gmsh installation:
Classes/method to write a geo file.

dependend on gmsh installation
Classes/methods that require python install of gmsh

• WIthin gmsh api try catch import of gmsh if additional features should be used else disable them.
• Make gmsh independent block available independent of gmsh installation

Remove prints and add loggings.

Add warning for #14: mock data is used!

If periodic boundaries are given, the mesh at the respective periodic edges (i.e. the vertices), must be aligned.

• Check if it is already the case.
• If not, solve it. For instance, write a python script that postprocesses the .MSH file. Maybe this is an iterative process.

Idea: Here the shapely.segmentize method might become handy, replacing lc handling from the shapely POV.

@Drachiro add some description.

• Boundary edges need individual entities
• Hole boundary edges optionally get own identity (with default = none)

The method discretize_reference in File bubbles/three_d/bubble.py needs dolfin to be installed.
TODO: Check how to avoid this.

• check intersection between bubbles

We always directly wrote the .GEO file, instead of using the GMSH API. Is there a specific reason for?

For now, adding new holes to a Topology object is only possible as long they are not intersecting old ones.
Do we want to lose this?

• List all annoying edge cases.
• How to parametrize non-stellar holes?

Following code creates filled sub-rects, instead of empty one.

rect_out = [(0, 0), (2, 2)]
rect_in_1 = [(0.25, 0.25), (0.75, 0.75)]
rect_in_2 = [(1.25, 0.25), (1.75, 0.75)]
rect_in_3 = [(1.25, 1.25), (1.75, 1.75)]
rect_in_4 = [(0.25, 1.25), (0.75, 1.75)]

topo = Topology(
  rect_out, [rect_in_1, rect_in_2, rect_in_3, rect_in_4], periodic_boundary=True
)
geo = topo.get_geometry(lc=1.0, lc_subrects=0.1, filled=False)
write_geo(geo, DATA_DIR/"domain_without_holes_empty")

• Provide minimal code example of needed but buggy functionality
• Write test if possible
• Open related issue for the solution

• Extend Period Transform to the case where objects can have periodicity with respect to rotation with given origin.

I would suggest to rename hole.py to geometry.py.

and clean the existing stuff / or add geometries.

Maybe refactor the discretize_hole mechanics ?

• Update readme: How to set the environment up, What functionality is provided and how to use it?
• Add module comments
• Add requirements

Just test the pipeline