simudo.mesh package

Submodules

simudo.mesh.construction_helper module

class simudo.mesh.construction_helper.BaseConstructionHelper

Bases: object

boilerplate

allocate_subdomain_range(length)

compute_facets()

debug_cvs_to_mf(cvs)

debug_fvs_to_mf(fvs, signed=True)

debug_plot()

dim

fix_facets_after_subdivision()

classmethod from_existing_mesh_cf(mesh, cf, cell_regions, run=True, params=None, mesh_unit=None)

gdim

generate_mesh()

by default does nothing. override me

main(params, output_filename)

mesh_data

p

refine_subdomains(subdomains, predicate)

robjs

run()

used_cell_values

user_extra_definitions()

override me

user_mark_external_boundary_facets(mesh, boundary_facet_function)

override me (maybe)

this function is allowed to add new definitions and cell values to self.cell_regions

by default this uses facet.facet2d_angle and defines new regions right/top/left/bottom

this function MUST add an ‘exterior’ key for all external boundary facets

user_modify_meta(meta)

override me

user_refinement()

override me

util_define_internal()

util_init_cf_from_domains()

class simudo.mesh.construction_helper.ConstructionHelperIntervalProduct2DMesh

Bases: simudo.mesh.construction_helper.BaseConstructionHelper

class Interval1DTag(intervals)

Bases: simudo.mesh.interval1dtag.Product2DMeshMixin, simudo.mesh.interval1dtag.MinimumCoordinateDistanceMixin, simudo.mesh.interval1dtag.BaseInterval1DTag

generate_mesh()

by default does nothing. override me

interval_1d_tag

product2d_Ys = (0.0, 1.0)

user_define_interval_regions()

override me

must return ((domain_x0, domain_x1), list_of_intervals) domain is overall domain

class simudo.mesh.construction_helper.ConstructionHelperLayeredStructure

Bases: simudo.mesh.construction_helper.ConstructionHelperIntervalProduct2DMesh

material_to_region

dict – Mapping from material to abstract CellRegion.

layers

material_to_region

simple_overmesh_regions

user_define_interval_regions()

override me

must return ((domain_x0, domain_x1), list_of_intervals) domain is overall domain

user_layer_extra_intervals(intervals, name_interval)

override if necessary

class simudo.mesh.construction_helper.ConstructionHelperManualCellTagging

Bases: simudo.mesh.construction_helper.BaseConstructionHelper

generate_mesh()

by default does nothing. override me

user_just_generate_mesh()

user_tag_cell(cell)

user_tag_cells(cell_function)

class simudo.mesh.construction_helper.ConstructionHelperMshr

Bases: simudo.mesh.construction_helper.BaseConstructionHelper

generate_mesh()

by default does nothing. override me

user_define_mshr_regions()

override me

must return {region_name: mshr_domain} regions[‘domain’] is overall domain

class simudo.mesh.construction_helper.ConstructionHelperPygmsh

Bases: simudo.mesh.construction_helper.BaseConstructionHelper

generate_mesh()

by default does nothing. override me

pygmsh_generate_mesh(geo)

user_define_pygmsh_geo()

override me

Returns:geo_object that will be passed to pygmsh.generate_mesh(). Return type:geo

class simudo.mesh.construction_helper.InvertibleTransform

Bases: object

FIXME: make PlazaRefinementND use alternate definition of longest_edge

This hack is instead used to temporarily modify the mesh coordinates temporarily to alter PlazaRefinementND’s length metric

v[i, j] is vertex i’s jth coordinate

after_modification(mesh)

transform(mesh)

transform_coordinates(v)

untransform(mesh)

untransform_coordinates(v)

v[i, j] is vertex i’s jth coordinate

class simudo.mesh.construction_helper.LinearTransform(matrix)

Bases: simudo.mesh.construction_helper.InvertibleTransform

transform_coordinates(v)

untransform_coordinates(v)

v[i, j] is vertex i’s jth coordinate

simudo.mesh.construction_helper.inplace_dict_map(mapping, func)

simudo.mesh.construction_helper_example module

simudo.mesh.domaintag_mshr module

class simudo.mesh.domaintag_mshr.DomainTag

Bases: object

domain_relationship(A, B)

must return one of {REL_DISJOINT, REL_OVERLAPPING, …}

domain_relationship_tabulate(items)

first_cell_value = 1

generate_intersection_regions(tagitems)

returns frozenset of tagset

region described by tagset is intersection(tagset) - union(all_tags - tagset)

make_subdomains(tags)

dict must be {tag_name: region}

returns (tag_to_cv_dict, subdomains)

tag_to_cv_dict will be {tag_name: cell_values} where all cell_values >= start_value

subdomains is list of (subdomain, cell_value) where subdomain is as returned by the self.region_to_subdomain method

region_to_subdomain(tags, included, excluded)

class simudo.mesh.domaintag_mshr.DomainTagTest(methodName='runTest')

Bases: unittest.case.TestCase

assert_gen_reg(answer, tags)

assert_rel(answer, A, B)

rect(x0, y0, x1, y1)

test_domain_relationship()

test_generate_possibilities()

class simudo.mesh.domaintag_mshr.MshrDomainTag

Bases: simudo.mesh.domaintag_mshr.DomainTag

domain_relationship(A, B)

must return one of {REL_DISJOINT, REL_OVERLAPPING, …}

mshr_make_subdomains(domain, tags)

simudo.mesh.domaintag_mshr.powerset(iterable)

simudo.mesh.facet module

simudo.mesh.facet.facet2d_angle(facet)

right_value=0, up_value=1, left_value=2, down_value=3

simudo.mesh.facet.mark_boundary_facets(mesh, boundary_facet_function, facet_closure, offset=0)

simudo.mesh.facet.mesh_function_map(mesh_function, func, out_type='size_t')

class simudo.mesh.facet.FacetsManager(mesh, cell_function, boundary_facet_function)

Bases: object

Keep track of boundaries between subdomains (cell function values).

boundary(X, Y, intersection=None)

Get signed boundary between X and Y.

If the intersection between X and Y is nonempty, you must pass the intersection argument. This function will pretend that the intersection is actually part of X or Y (depending on the value of intersection). In other words,

• boundary(X, Y, 0) == boundary(X, Y-X), and
• boundary(X, Y, 1) == boundary(X-Y, Y).

Parameters:

• X (set) – X and Y must be sets of cell marker values (representing subdomains). X and Y must be disjoint unless the intersection argument is used.
• Y (set) – See X.
• intersection (int, optional) – Must be 0 or 1, if specified.

Returns:

fvs – Set of tuples (facet_value, sign) representing facets between X and Y.

Return type:

set

cell_value_internal(X)

Get internal facets excluding boundaries across cell values (subdomains).

Parameters:X (set) – Set of cell values (representing subdomains). Returns:fvs – Set of (facet_value, sign) representing facets contained within X and not on the boundary between two cell values. Return type:set

fix_undefined_facets_after_subdivision(mesh, cell_function, facet_function)

Assign markers to facets created by mesh subdivision.

Upon subdivision, cells get split and new facets are created to separate them. The subdivision algorithm cannot know what facet value to assign to these new facets, so it leaves them with a large undefined value.

These facets must be fully internal to a subdomain, so the cells on either side must have the same cell value. That cell value corresponds to a facet value for internal facets, which is precisely the information stored in the internal_facets_dict attribute.

Parameters:

• mesh (dolfin.Mesh) – Mesh on which to operate.
• cell_function (dolfin.CellFunction) – Cell function on mesh representing subdomains.
• facet_function (dolfin.FacetFunction) – Facet function to fix up after subdivision. This will be modified in place.

internal(X)

Get all internal facets.

Parameters:X (set) – Set of cell values (representing subdomains). Returns:fvs – Set of (facet_value, sign) representing facets contained within X and not on its boundary. Return type:set

simudo.mesh.interval1dtag module

simudo.mesh.interval1dtag.clip_intervals(x0, x1, intervals)

in-place modifies intervals

class simudo.mesh.interval1dtag.Interval(x0, x1, tags=())

Bases: object

Represents a single interval, possibly with tags.

class simudo.mesh.interval1dtag.CInterval(x0, x1, tags=(), edge_length=inf)

Bases: simudo.mesh.interval1dtag.Interval

Represents an interval with constant edge length (in the x direction).

Note: you do not need to derive from this class to implement a custom edge length. Instead, you can subclass from Interval and implement a custom local_edge_length method.

local_edge_length(x)

class simudo.mesh.interval1dtag.Product2DMeshMixin

Bases: object

class Product2DMesh(Xs, Ys=None)

Bases: object

cells_at_ix(ix)

copy()

note: does not deepcopy Xs and Ys

create_function_from_x_values(values)

element

ix_from_vertex(v)

iy_from_vertex(v)

mesh

nX

nY

space

vertices_at_ix(ix)

vertices_at_iy(iy)

make_product2d_mesh(coordinates, subdomain_to_coordinate_range, subdomain_to_cell_value, Ys)

product2d_Ys = (0.0, 1.0)

product2d_mesh

Use this to get a readily-constructed Product2D object. Note that an attribute cell_function has been added to it.

class simudo.mesh.interval1dtag.MinimumCoordinateDistanceMixin

Bases: object

make_interval_coordinates(x0, x1, *args, **kwargs)

minimum_coordinate_distance = 1e-10

class simudo.mesh.interval1dtag.BaseInterval1DTag(intervals)

Bases: object

Class that turns a bunch of arbitrary overlapping intervals into a mesh.

coordinates

first_cell_value = 1

intervals_to_subdomains(intervals)

make_coordinates(subdomain_to_intervals, endpoints)

make_interval_coordinates(x0, x1, local_edge_length_function)

Note: this excludes second endpoint

subdomains

tag_to_cell_values

Mapping from a tag to a set of cell values (e.g. values inside self.product2d_mesh.cell_function).

class simudo.mesh.interval1dtag.Interval1DTag(intervals)

Bases: simudo.mesh.interval1dtag.Product2DMeshMixin, simudo.mesh.interval1dtag.MinimumCoordinateDistanceMixin, simudo.mesh.interval1dtag.BaseInterval1DTag

simudo.mesh.mesh1d module

simudo.mesh.mesh1d.make_1d_mesh_from_points(Xs)

simudo.mesh.mesh_entity_predicate module

class simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

Bases: object

classmethod assert_compatible_predicates(predicates)

dim = None

prepare(dictionary)

class simudo.mesh.mesh_entity_predicate.CombiningMeshEntityPredicate(*predicates)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

prepare(dictionary)

class simudo.mesh.mesh_entity_predicate.AndMeshEntityPredicate(*predicates)

Bases: simudo.mesh.mesh_entity_predicate.CombiningMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.OrMeshEntityPredicate(*predicates)

Bases: simudo.mesh.mesh_entity_predicate.CombiningMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.NandMeshEntityPredicate(*predicates)

Bases: simudo.mesh.mesh_entity_predicate.CombiningMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.SubdomainCellPredicate(cell_function, subdomains)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.DimensionAdapterPredicate(predicate, dim)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

prepare(dictionary)

class simudo.mesh.mesh_entity_predicate.InRadiusCellPredicate(threshold, dim)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.MaxEdgeLengthCellPredicate(threshold, dim)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

class simudo.mesh.mesh_entity_predicate.DirectionalEdgeLengthPredicate(direction, threshold=None)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

dim = 1

prepare(dictionary)

class simudo.mesh.mesh_entity_predicate.AlwaysTruePredicate(dim)

Bases: simudo.mesh.mesh_entity_predicate.BaseMeshEntityPredicate

simudo.mesh.product2d module

class simudo.mesh.product2d.Product2DMesh(Xs, Ys=None)

Bases: object

cells_at_ix(ix)

copy()

note: does not deepcopy Xs and Ys

create_function_from_x_values(values)

element

ix_from_vertex(v)

iy_from_vertex(v)

mesh

nX

nY

space

vertices_at_ix(ix)

vertices_at_iy(iy)

simudo.mesh.pygmsh module

class simudo.mesh.pygmsh.PygmshMakeRegions

Bases: object

We want overlapping regions. gmsh and pygmsh make that difficult. gmsh supports overlapping physical surfaces/volumes, but it returns duplicate mesh cells (see meshio issue 175). We can fix this by postprocessing pygmsh’s output, which thankfully contains all the necessarily info. At least for now.

process(cells, cell_data, field_data, dim)

Note: In-place modifies cells and cell_data.

unduplicate_msh3_cells(cells, cell_data)

simudo.mesh.refine module

simudo.mesh.refine.adapt(obj, *args, **kwargs)

simudo.mesh.refine.adapt_mf(mf, new_mesh)

simudo.mesh.refine.cell_predicate_expr_threshold(mesh, function, threshold)

function must be a dolfin.FunctionSpace or pint wrapper around one

simudo.mesh.refine.mark_using_predicate(mf, mesh, predicate)

simudo.mesh.refine.predicate_to_meshfunction(mesh, predicate, dim)

simudo.mesh.refine.refine_forever(refinement_objs, make_predicate)

simudo.mesh.topology module

class simudo.mesh.topology.CellRegion

Abstract cell region.

Can be evaluated down to a set of subdomain markers using MeshData.evaluate_topology().

To access a cell region predefined (named) in the mesh generator, instantiate this class directly with a name argument.

__and__(x)

Return the intersection of this cell region and another.

static __new__(cls, *args, **kwargs)

Create and return a new object. See help(type) for accurate signature.

__or__(x)

Return the union of this cell region and another.

__sub__(x)

Return the subtraction of the other cell region from this one.

__xor__(x)

Return the symmetric difference of this cell region and another.

boundary(x)

Signed boundary between self and x.

internal_facets()

Get all internal facets.

subdomain_internal_facets()

Get internal facets excluding boundaries across cell values (subdomains).

class simudo.mesh.topology.FacetRegion

Abstract facet region.

Can be evaluated down to a set of (facet_marker_value, facet_sign) using MeshData.evaluate_topology().

To access a facet region predefined (named) in the mesh generator, instantiate this class directly with a name argument.

__and__(x)

Return the intersection of this facet region and another.

static __new__(cls, *args, **kwargs)

Create and return a new object. See help(type) for accurate signature.

__or__(x)

Return the union of this facet region and another.

__sub__(x)

Return the subtraction of the other facet region from this one.

__xor__(x)

Return the symmetric difference of this facet region and another.

both()

Both facet sides, i.e.

f.both() == (f | f.flip())

flip()

Invert facet signedness. For example,

X.boundary(Y) == Y.boundary(X).flip()

unsigned()

Erase facet signedness information by setting sign = 1 for every (facet_value, sign) pair.

class simudo.mesh.topology.CellRegions(mapping=None)

Convenient container for cell region objects.

_mapping_

dict – Dictionary of cell regions.

__getitem__(name)

I.e. obj[name]. If name is already in _mapping_, it is retrieved from there; otherwise a CellRegion is created with that name, stored inside _mapping_, and returned.

If name is a set, then a subset of the _mapping_ dictionary is returned with those keys.

__getattr__(name)

I.e. obj.$name. Redirected to obj[name].

class simudo.mesh.topology.FacetRegions(mapping=None)

Convenient container for facet region objects.

See CellRegions.

Module contents