Todo List

Class GrAL::boundary_grid< E >

Implement a dimension-independent version

Replace typedef by wrappers of base grid elements

Class GrAL::boundary_range_nd< GRID, GT >

Specialization for grids already supporting boundary ranges.

Support for edge iteration

Member GrAL::cell_as_volume::intersection_check (POLY const &p) const

Does return intersection even if test polytope p is completely inside. Must test the boundary for intersection.

Class GrAL::cell_is_contained< VOLUME, GRIDGEOMETRY, GT >

We should also look into the cogeometry concept

Test

Class GrAL::cell_morphism< G_DEF, G_IMG >

Specialize if grids have consecutive handles

construct from vertex morphism

Class GrAL::cell_seq_ref< Grid >

what's up with end() ?

Class GrAL::closure_iterator< MAJORIT, MINORIT, GT >

Copying may be expensive. By introducing a shared table of numbered visited nodes and adding an extra position parameter, copying may be made cheep while still fulfilling the forward iterator requirements.

Class GrAL::connected_components::component< GT >

Forward other element types defined in GT::grid_type, define iterator types for them.

Class GrAL::edge_facet_intersection< GEOM, GT >

This works only for linear edges and facets with 3 or 4 vertices. In the 3-vertex case, a linear facet is assumed. In the 4-vertex case, the convex hull of the vertices (a tetrahedron) is checked for intersection with the edge.

Class GrAL::element_numbering< E, GT >

Make it deal correctly with grid subranges, where the consecutive_tag of underlying element_handle does not induce the Right Thing.

Class GrAL::element_traits_base< E >

Extend the mechanism to the case where not element_type_tag but dim/codim are given

Class GrAL::enumerated_subrange< Grid, GT >

Make the closure property a compile time or runtime policy. It is not consistent to allow both vertex and cell insertion if mixed insertion will fail. It is better to use a vertex range if only vertices are wanted (In some cases, algorithms formally expect also CellIterator types. Either these algorithms should be redesigned, or formal definitions of empty CellIterator types must be added to element sequences.)

Class GrAL::enumerated_subrange_ref< Grid, GT >

Parameterize over the type of the underlying grid range.

Class GrAL::ExtendedCellOnCellIterator< Grid >

Test

Class GrAL::facet_on_cell_function< GRID, T >

The implementation contains some overhead in terms of storage: The grid function on archetype cells (i.e. cell facets) does not need a grid pointer. It could be optimized for grids with archetypes which have contiguous cell handles, and in particular for grids with a single archetype.

Similar classes could be designed for cell-vertex and cell-edge incidences.

Class GrAL::facet_span_of_vertices_iterator< VertexRange >

shallow copy / copy-on-write

Class GrAL::FacetIterator< FacOnCellIt >

Test

Class GrAL::flag< GRID, DIM >

Flags are implemented only for 2D and 3D.

Class GrAL::cut_grid_view::geom_view< CFG, GEOM >

should allow assigment to coordinates of split vertices

could offer the local outward normal vector at split vertices as an aid to defining new coordinates.

could somehow automatically inherit all geometric stuff from GEOM ... but only if no changes to coordinates are allowed!

Class GrAL::gf_const_iterator< G, GF >

The class restr_gf_iterator_adapter solves a similar problem. Maybe these classes should be fused.

Class GrAL::grid_function< shrink_grid_view::cell_iterator< GRID >, T >

This could reuse underlying grid function on base cells

Class GrAL::grid_function_hash< E, T >

Iteration does not work when a grid function is constructed using only the grid (gives an empty sequence instead a full sequence of undefined values).

Class GrAL::grid_function_hash_base< E, T >

Optimization: Could use hash_table<element_handle,T> instead of hash_table<Element,T>. However, in some cases it is not possible to implement equality testing of the underlying elements without referring to the grid.

Class GrAL::collapsed_grid_view::grid_function_view< GF >

Specialize for vertices. Different strategies could be used to deal with collapsed vertices. Currently, the value of the representant of a collapse set is returned. At least, there should be a possibility to define the value explicitely for collapsed vertices.

Class GrAL::grid_function_view< E, T, GF >

Provide iterators

Class GrAL::disjoint_union_view::grid_view< GRID1, GRID2 >

support archetypes.

grid_function_view

Class GrAL::restricted_grid_view::grid_view< CFG >

Implement conditionally other incidence iterators, and sequence iterators for element types other than vertex/cell.

Class GrAL::shrink_grid_view::grid_view< GRID >

branch in grid_view::NumOfVertices() depending on availability of GRID::CellOnVertexIterator.

Class GrAL::IstreamComplex2DCombFmt

Iterator classes refer to IstreamComplex2DFmt_base.

Class GrAL::IstreamComplex2DFmt

Test

Class GrAL::partial_grid_morphism< GDEF, GIMG >

Implement inverse morphism for the 3D case (inherit from base::inverse_type

Class GrAL::simple_geometry< GRID, COORD >

Move plugin stuff like solid_angle to extra header, and make it optional.

Member GrAL::simple_geometry::space_dimension () const

This does not work for an empty grid - use compile-time dimension if possible, or pass an extra parameter for the dimension if coord_type has a run-time dimension only.

Member GrAL::simple_geometry::outer_normal (FacetOnCellIterator const &f) const

This works only for 2D meshes so far.

Class GrAL::solid_angle_plugin_dim< GEOM, GRID, COORD, 2 >

Move this into separate header

Class GrAL::transformed_geom< Geom, Trafo >

Extend approach to yield transformed (i.e., curved) segments, polygons etc.

Test

Class GrAL::vertex_morphism< G_DEF, G_IMG >

Specialize if both grids have consecutive handles

Make it independent of element being a vertex type (using map_element_iter_name<> like in partial_grid_function)

Can temporary vertex objects be avoided?

Class GrAL::vertex_set< E, EDIM >

specialize to vertex set of edges

Rename to element_vertex_set ?

Class GrAL::vertex_set_of_cells_iterator< CellRange >

shallow copy / copy-on-write

Class GrAL::vertex_set_of_facets_iterator< FacetRange >

shallow copy / copy-on-write

Class GrAL::wrapped_geometry< Geom, Grid >

Test

Namespace GrAL::restricted_grid_component_view

implement Edge/Facet if supported by GRID

Namespace GrAL::restricted_grid_view

implement Edge/Facet if supported by the base grid

Member GrAL::iterator_range_size (It it)

We could use iterator_traits<It>::difference_type for the result.

Member GrAL::calculate_vertex_stars (GRID const &G,GERMS &germs)

Works only for 2D meshes.

Group incidence_hull

Better demos (now only test-incidence-hulls.C)

Member GrAL::fix_orientation (G &g, C guide_cell)

Extend to list of guide cells for disconnected grids.

Group enlargeoperations

EnlargeGrid() , EnlargeGridV() can be defined fully generically in terms of EnlargeGridVC()

Member GrAL::incident (E1 const &e1, E2 const &e2)

branch on iterator capabilities: Use either E1OnE2Iter or E2OnE1Iter.

Member GrAL::incident (E1 const &e1, E2 const &e2)

branch on iterator capabilities: Use either E1OnE2Iter or E2OnE1Iter.

Group gridboundingbox

routines should check at compile time whether geometries are linear.

Member GrAL::get_grid_bounding_box (GRID const &G, GEOM const &Geom)

Specialize to the case that there is a boundary representation of the grid available. (The bounding box of a grid is that of the grid's boundary.)

Group geometrictypes

Include dimension-specific / geometric stuff, from Geometric types for 2D (obsolete)

Group boundarycompiter

A 3D analogue requires more work, as the boundary isn't linearly ordered any more.

Could use partial specialization based on the dimension of Grid to remove the syntactic 2D dependency in the name.

Test

Group generic_edge

Test

Group generic_facet

Test

Group boundaryrange

Rename to boundary_range_2d

Change boundary_range_nd to select boundary_range_2d in the 2D case

Group enum_elementranges_ref

The classes with explicit type names like vertex_range_ref are obsolete and should be removed.

Group enum_elementranges

The classes with explicit type names like enumerated_vertex_range are obsolete and should be removed.

Group boundaryalgorithms

The algorithms could take an additional parameter IsOnBd which is a predicate deciding whether a Facet is on the boundary. Then one could handle also internal boundaries, for example between two partitions.

Test

Group layeredsubrange

Test

Group collapsed_grid_view

add Edge and Facet elements

Group shrunk_grid_view

add Edge and Facet elements