libsupermesh version 1.0.1

Transcription

1 libsupermesh version James R. Maddison School of Mathematics and Maxwell Institute for Mathematical Sciences, University of Edinburgh, UK Iakovos Panourgias EPCC, University of Edinburgh, UK, Patrick E. Farrell Mathematical Institute, University of Oxford, UK, Center for Biomedical Computing, Simula Research Laboratory, Oslo, Norway January 2017 Contents 1 Introduction 2 2 Building libsupermesh 2 3 Using libsupermesh 3 4 Intersection identification Identifying all candidate intersections sort intersection finder quadtree intersection finder octree intersection finder tree intersection finder rtree intersection finder advancing front intersection finder brute force intersection finder intersection finder Identifying candidate intersections using queryable trees quadtree type octree type tree type rtree type j.r.maddison@ed.ac.uk 1

2 5 Element intersection One dimension Two dimensions Three dimensions General dimensions Parallelisation Algorithm parallel supermesh Callbacks Examples Serial Parallel Copyright libsupermesh Fluidity TinyXML libspatialindex Rtree UseLATEX.cmake Acknowledgements 49 1 Introduction libsupermesh is a Fortran 2008 library for serial and parallel mesh intersection, or supermeshing [Farrell et al., 2009, Farrell, 2009]. libsupermesh specifically includes components used in the local supermeshing approach described in Farrell and Maddison [2011] [see also Gander and Japhet, 2009, 2013]. Here, given two input meshes, elements in each mesh which intersect are identified, and a local mesh of their intersection is generated. 2 Building libsupermesh libsupermesh is built using CMake 1, for example via: cd [LIBSUPERMESH SOURCE PATH] / b u i l d cmake [LIBSUPERMESH SOURCE PATH] \ DCMAKE INSTALL PREFIX=[LIBSUPERMESH INSTALL PATH] make make i n s t a l l where [LIBSUPERMESH_SOURCE_PATH] is the path to the source directory, and [LIBSUPERMESH_INSTALL_PATH] is the path to the installation directory. Note that libsupermesh cannot be built in the source directory, and must be built with double precision Fortran reals

3 CMake options CMAKE BUILD TYPE Build type. Valid options are Release and Debug. Default Release. BUILD SHARED LIBS Build a shared library. Default disabled. LIBSUPERMESH DOUBLE PRECISION Use double precision Fortran reals. Fortran reals are used. Default enabled. If disabled then single precision LIBSUPERMESH AUTO COMPILER FLAGS Choose compiler flags automatically, enabling aggressive optimisation options for the Release build and additional debugging options for the Debug build. Active only if the GNU or Cray compilers are used. This overrides other CMake compiler flag variables. Default enabled. LIBSUPERMESH ENABLE JUDY Use the Judy library 2. Requires an available installation of Judy. Default disabled. LIBSUPERMESH ENABLE TIMERS Enable internal timers for parallel supermeshing. Default disabled. LIBSUPERMESH OVERLAP COMPUTE COMMS Overlaps communication and some calculation in parallel supermeshing. Default disabled. Build targets make Default build. Builds the library and unit tests. make test Runs the unit tests. make doc Builds this manual. 3 Using libsupermesh The libsupermesh Fortran module provides access to all functionality described in this manual. This can be accessed via: use libsupermesh If libsupermesh is compiled with the LIBSUPERMESH_DOUBLE_PRECISION CMake option enabled then libsupermesh Fortran real variables have kind real64. Otherwise libsupermesh Fortran real variables have kind real32. The kind is defined by the default integer real_kind variable. Throughout this manual the real kind is omitted from variable declarations. 4 Intersection identification libsupermesh includes a number of different algorithms for identifying candidate pairs of elements, in two different meshes A and B, which intersect. These algorithms are all based upon an axis-aligned bounding box (AABB) intersection predicate. Hence the different approaches are all guaranteed to return all pairs of elements which have a non-trivial intersection 3, but may additionally return pairs of elements which have zero intersection. The following definitions are used: d Mesh A defines a subset Ω A R d, and mesh B a subset Ω B R d Except for numerical precision related errors. 3

4 l A Number of nodes per element in mesh A. l B Number of nodes per element in mesh B. V A Number of nodes in mesh A. V B Number of nodes in mesh B. E A Number of elements in mesh A. E B Number of elements in mesh B. Element-node graphs are represented as l A E A and l B E B integer arrays respectively. For example, if enlist_a stores the element-node graph for mesh A, then in the following: integer, dimension ( l A, E A) : : e n l i s t a integer, dimension ( l A ) : : nodes a!... nodes a = e n l i s t a ( :, e l e a ) nodes_a contains the indices of nodes in mesh A for element ele_a. Candidate intersection element-element graphs are stored either as a ragged array or as a Compressed Sparse Row (CSR) sparsity 4. For the ragged array variant: type ( i n t e r s e c t i o n s ), dimension (E A) : : map ab integer : : n integer, dimension ( : ), pointer : : v!... n = map ab ( e l e a )%n v => map ab ( e l e a )%v or for the CSR sparsity variant: integer, dimension ( : ), allocatable, target : : map ab indices integer, dimension (E A + 1) : : map ab indptr integer : : n integer, dimension ( : ), pointer : : v!... n = map ab indptr ( e l e a + 1) map ab indptr ( e l e a ) v => map ab indices ( map ab indptr ( e l e a ) : map ab indptr ( e l e a + 1) 1) n contains the number of candidate elements in mesh B which may intersect with element ele_a of mesh A. v points at a vector of length n containing the indices of elements in mesh B which may intersect with element ele_a of mesh A. 4 See e.g. the SciPy documentation, matrix.html. 4

5 4.1 Identifying all candidate intersections The following intersection finders return an element-element graph which associates with all elements in mesh A candidate intersecting elements in mesh B. The ragged array intersections data type, allocated by one of the following intersection finder routines, must be deallocated after use. interface deallocate module procedure d e a l l o c a t e i n t e r s e c t i o n s end interface deallocate pure elemental subroutine d e a l l o c a t e i n t e r s e c t i o n s ( i n t s ) type ( i n t e r s e c t i o n s ), intent ( inout ) : : i n t s ints Candidate intersecting mesh B elements for a mesh A element sort intersection finder An intersection finder for 1D meshes, based upon a combination of a merge sort and a 1D advancing front. interface s o r t i n t e r s e c t i o n f i n d e r module procedure s o r t i n t e r s e c t i o n f i n d e r r a n k 1 i n t e r s e c t i o n s, & & s o r t i n t e r s e c t i o n f i n d e r r a n k 2 i n t e r s e c t i o n s, & & s o r t i n t e r s e c t i o n f i n d e r r a n k 1 c s r s p a r s i t y, & & s o r t i n t e r s e c t i o n f i n d e r r a n k 2 c s r s p a r s i t y end interface s o r t i n t e r s e c t i o n f i n d e r pure subroutine s o r t i n t e r s e c t i o n f i n d e r r a n k 1 i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab positions a Length V A vector. Mesh A node coordinates. enlist a 2 E A array. Mesh A element-node graph. positions b Length V B vector. Mesh B node coordinates. enlist b 2 E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. pure subroutine s o r t i n t e r s e c t i o n f i n d e r r a n k 2 i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab 5

6 positions a 1 V A array. Mesh A node coordinates. enlist a 2 E A array. Mesh A element-node graph. positions b 1 V B array. Mesh B node coordinates. enlist b 2 E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. pure subroutine s o r t i n t e r s e c t i o n f i n d e r r a n k 1 c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a Length V A vector. Mesh A node coordinates. enlist a 2 E A array. Mesh A element-node graph. positions b Length V B vector. Mesh B node coordinates. enlist b 2 E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A + 1. pure subroutine s o r t i n t e r s e c t i o n f i n d e r r a n k 2 c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a 1 V A array. Mesh A node coordinates. enlist a 2 E A array. Mesh A element-node graph. positions b 1 V B array. Mesh B node coordinates. enlist b 2 E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A quadtree intersection finder An intersection finder for 2D meshes, based upon a quadtree data structure [Samet, 1984]. Each interface accepts an optional max_size argument, which specifies the maximum number of elements in a leaf node. This should be greater than the maximum number of elements (in the mesh used to build the quadtree) which can be found in a neighbourhood of an arbitrary point. If not specified then max_size defaults to the maximum of 256, and the maximum number of mesh elements connected to any single node (the maximal node-element graph degree). 6

7 pure function m a x n e l i s t d e g r e e ( nnodes, e n l i s t ) result ( max degree ) integer, intent ( in ) : : nnodes integer, dimension ( :, : ), intent ( in ) : : e n l i s t integer : : max degree nnodes V B. enlist l B E B array. Mesh B element-node graph. max degree Maximal mesh B node-element graph degree. interface q u a d t r e e i n t e r s e c t i o n f i n d e r module procedure q u a d t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & q u a d t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface q u a d t r e e i n t e r s e c t i o n f i n d e r subroutine q u a d t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab, max size ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab integer, optional, intent ( in ) : : max size positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. max size Maximum number of elements in a quadtree leaf node. subroutine q u a d t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr, max size ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr integer, optional, intent ( in ) : : max size positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A + 1. max size Maximum number of elements in a quadtree leaf node. 7

8 4.1.3 octree intersection finder An intersection finder for 3D meshes, based upon an octree data structure. See section for details regarding the optional max_size argument. interface o c t r e e i n t e r s e c t i o n f i n d e r module procedure o c t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & o c t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface o c t r e e i n t e r s e c t i o n f i n d e r subroutine o c t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab, max size ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab integer, optional, intent ( in ) : : max size positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. max size Maximum number of elements in an octree leaf node. subroutine o c t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr, max size ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr integer, optional, intent ( in ) : : max size positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A + 1. max size Maximum number of elements in an octree leaf node tree intersection finder An intersection finder for 2D and 3D meshes, which uses either the quadtree_intersection_finder (section 4.1.2) or octree_intersection_finder (section 4.1.3). 8

9 interface t r e e i n t e r s e c t i o n f i n d e r module procedure t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface t r e e i n t e r s e c t i o n f i n d e r subroutine t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. subroutine t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A rtree intersection finder An intersection finder for 2D and 3D meshes, using a libspatialindex 5 R -tree [Guttman, 1984, Beckmann et al., 1990]. interface r t r e e i n t e r s e c t i o n f i n d e r module procedure r t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & r t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface r t r e e i n t e r s e c t i o n f i n d e r 5 9

10 subroutine r t r e e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. subroutine r t r e e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A advancing front intersection finder An intersection finder for meshes with simplicial or cubical elements, using the algorithm described in Farrell and Maddison [2011] [see also Gander and Japhet, 2009, 2013]. This intersection finder is primarily intended for the case where the meshes A and B cover the same domain. More generally, for correct output the input meshes must satisfy certain properties [Gander and Japhet, 2009]. Correct output is guaranteed if: 1. The first element in each connected sub-domain of mesh A intersects with at least one element of mesh B. 2. The elements of mesh B which intersect with any given element of mesh A define an element-element sub-graph of the mesh B element-element graph 6. All of these sub-graphs should be connected. interface a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r module procedure a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r 6 Here element-element graph edges are defined by elements sharing a common facet. 10

11 subroutine a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. subroutine a d v a n c i n g f r o n t i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A brute force intersection finder A basic brute force intersection finder with quadratic complexity. interface b r u t e f o r c e i n t e r s e c t i o n f i n d e r module procedure b r u t e f o r c e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & b r u t e f o r c e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface b r u t e f o r c e i n t e r s e c t i o n f i n d e r pure subroutine b r u t e f o r c e i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab 11

12 positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. pure subroutine b r u t e f o r c e i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A intersection finder An intersection finder for one, two, and three dimensional meshes. Uses the sort_intersection_finder (section 4.1.1) in the one dimensional case, and the rtree_intersection_finder (section 4.1.5) in the two and three dimensional cases. interface i n t e r s e c t i o n f i n d e r module procedure i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s, & & i n t e r s e c t i o n f i n d e r c s r s p a r s i t y end interface i n t e r s e c t i o n f i n d e r subroutine i n t e r s e c t i o n f i n d e r i n t e r s e c t i o n s ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, map ab ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b type ( i n t e r s e c t i o n s ), dimension ( : ), intent ( out ) : : map ab positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab Length E A vector. Candidate intersection element-element graph. 12

13 subroutine i n t e r s e c t i o n f i n d e r c s r s p a r s i t y ( & & p o s i t i o n s a, e n l i s t a, p o s i t i o n s b, e n l i s t b, & & map ab indices, map ab indptr ) real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s a integer, dimension ( :, : ), intent ( in ) : : e n l i s t a real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s b integer, dimension ( :, : ), intent ( in ) : : e n l i s t b integer, dimension ( : ), allocatable, intent ( out ) : : map ab indices integer, dimension ( : ), intent ( out ) : : map ab indptr positions a d V A array. Mesh A node coordinates. enlist a l A E A array. Mesh A element-node graph. positions b d V B array. Mesh B node coordinates. enlist b l B E B array. Mesh B element-node graph. map ab indices, map ab indptr CSR sparsity. Candidate intersection element-element graph. map_ab_indptr has length E A Identifying candidate intersections using queryable trees The following intersection finders use a given mesh B to construct a tree based structure which can be queried, one mesh A element at a time, for candidate intersecting elements quadtree type An intersection finder for 2D meshes, based upon a quadtree data structure (see section 4.1.2). Allocate a quadtree_type, which can later be queried for candidate intersecting elements. See section for details regarding the optional max_size argument. interface allocate module procedure a l l o c a t e q u a d t r e e end interface allocate subroutine a l l o c a t e q u a d t r e e ( quadtree, p o s i t i o n s, e n l i s t, max size ) type ( quadtree type ), intent ( out ) : : quadtree real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s integer, dimension ( :, : ), intent ( in ) : : e n l i s t integer, optional, intent ( in ) : : max size quadtree Quadtree data structure. positions d V B array. Mesh B node coordinates. enlist l B E B array. Mesh B element-node graph. max size Maximum number of elements in a quadtree leaf node. Query an allocated quadtree_type for candidate intersecting elements. interface query module procedure q u e r y q u a d t r e e a l l o c a t a b l e, q u e r y q u a d t r e e p o i n t e r end interface query 13

14 pure subroutine q u e r y q u a d t r e e a l l o c a t a b l e ( quadtree, element a, e l e s b ) type ( quadtree type ), intent ( inout ) : : quadtree real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), allocatable, intent ( out ) : : e l e s b pure subroutine q u e r y q u a d t r e e p o i n t e r ( quadtree, element a, e l e s b ) type ( quadtree type ), intent ( inout ) : : quadtree real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), pointer, intent ( out ) : : e l e s b quadtree Quadtree data structure. element a d l A array. Node coordinates of a mesh A element. eles b Elements of mesh B whose AABBs intersect with the AABB of the given mesh A element. Must be deallocated by the caller. Deallocate a quadtree_type. interface deallocate module procedure d e a l l o c a t e q u a d t r e e end interface deallocate pure elemental subroutine d e a l l o c a t e q u a d t r e e ( quadtree ) type ( quadtree type ), intent ( inout ) : : quadtree quadtree Quadtree data structure octree type An intersection finder for 3D meshes, based upon an octree data structure (see section 4.1.3). Allocate an octree_type, which can later be queried for candidate intersecting elements. See section for details regarding the optional max_size argument. interface allocate module procedure a l l o c a t e o c t r e e end interface allocate subroutine a l l o c a t e o c t r e e ( octree, p o s i t i o n s, e n l i s t, max size ) type ( o c t r e e t y p e ), intent ( out ) : : o c t r e e real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s integer, dimension ( :, : ), intent ( in ) : : e n l i s t integer, optional, intent ( in ) : : max size octree Octree data structure. positions d V B array. Mesh B node coordinates. enlist l B E B array. Mesh B element-node graph. max size Maximum number of elements in an octree leaf node. Query an allocated octree_type for candidate intersecting elements. 14

15 interface query module procedure q u e r y o c t r e e a l l o c a t a b l e, q u e r y o c t r e e p o i n t e r end interface query pure subroutine q u e r y o c t r e e a l l o c a t a b l e ( octree, element a, e l e s b ) type ( o c t r e e t y p e ), intent ( inout ) : : o c t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), allocatable, intent ( out ) : : e l e s b pure subroutine q u e r y o c t r e e p o i n t e r ( octree, element a, e l e s b ) type ( o c t r e e t y p e ), intent ( inout ) : : o c t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), pointer, intent ( out ) : : e l e s b octree Octree data structure. element a d l A array. Node coordinates of a mesh A element. eles b Elements of mesh B whose AABBs intersect with the AABB of the given mesh A element. Must be deallocated by the caller. Deallocate an octree_type. interface deallocate module procedure d e a l l o c a t e o c t r e e end interface deallocate pure elemental subroutine d e a l l o c a t e o c t r e e ( o c t r e e ) type ( o c t r e e t y p e ), intent ( inout ) : : o c t r e e octree Octree data structure tree type An intersection finder for 2D and 3D meshes, which uses either the quadtree_type (section 4.2.1) or octree_type (section 4.2.2). Allocate a tree_type, which can later be queried for candidate intersecting elements. interface allocate module procedure a l l o c a t e t r e e end interface allocate subroutine a l l o c a t e t r e e ( tree, p o s i t i o n s, e n l i s t ) type ( t r e e t y p e ), intent ( out ) : : t r e e real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s integer, dimension ( :, : ), intent ( in ) : : e n l i s t tree Quadtree or octree data structure. positions d V B array. Mesh B node coordinates. enlist l B E B array. Mesh B element-node graph. 15

16 Query an allocated tree_type for candidate intersecting elements. interface query module procedure q u e r y t r e e a l l o c a t a b l e, q u e r y t r e e p o i n t e r end interface query subroutine q u e r y t r e e a l l o c a t a b l e ( tree, element a, e l e s b ) type ( t r e e t y p e ), intent ( inout ) : : t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), allocatable, intent ( out ) : : e l e s b subroutine q u e r y t r e e p o i n t e r ( tree, element a, e l e s b ) type ( t r e e t y p e ), intent ( inout ) : : t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), pointer, intent ( out ) : : e l e s b tree Quadtree or octree data structure. element a d l A array. Node coordinates of a mesh A element. eles b Elements of mesh B whose AABBs intersect with the AABB of the given mesh A element. Must be deallocated by the caller. Deallocate a tree_type. interface deallocate module procedure d e a l l o c a t e t r e e end interface deallocate subroutine d e a l l o c a t e t r e e ( t r e e ) type ( t r e e t y p e ), intent ( inout ) : : t r e e tree Quadtree or octree data structure rtree type An intersection finder for 2D and 3D meshes, using a libspatialindex R -tree (see section 4.1.5). Allocate an rtree_type, which can later be queried for candidate intersecting elements. interface allocate module procedure a l l o c a t e r t r e e end interface allocate subroutine a l l o c a t e r t r e e ( r t r e e, p o s i t i o n s, e n l i s t ) type ( r t r e e t y p e ), intent ( out ) : : r t r e e real, dimension ( :, : ), intent ( in ) : : p o s i t i o n s integer, dimension ( :, : ), intent ( in ) : : e n l i s t rtree libspatialindex R -tree data structure. positions d V B array. Mesh B node coordinates. enlist l B E B array. Mesh B element-node graph. 16

17 Query an allocated rtree_type for candidate intersecting elements. interface query module procedure q u e r y r t r e e a l l o c a t a b l e, q u e r y r t r e e p o i n t e r end interface query subroutine q u e r y r t r e e a l l o c a t a b l e ( r t r e e, element a, e l e s b ) type ( r t r e e t y p e ), intent ( inout ) : : r t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), allocatable, intent ( out ) : : e l e s b subroutine q u e r y r t r e e p o i n t e r ( r t r e e, element a, e l e s b ) type ( r t r e e t y p e ), intent ( inout ) : : r t r e e real, dimension ( :, : ), intent ( in ) : : element a integer, dimension ( : ), pointer, intent ( out ) : : e l e s b rtree libspatialindex R -tree data structure. element a d l A array. Node coordinates of a mesh A element. eles b Elements of mesh B whose AABBs intersect with the AABB of the given mesh A element. Must be deallocated by the caller. Deallocate an rtree_type. interface deallocate module procedure d e a l l o c a t e r t r e e end interface deallocate subroutine d e a l l o c a t e r t r e e ( r t r e e ) type ( r t r e e t y p e ), intent ( inout ) : : r t r e e rtree libspatialindex R -tree data structure. 5 Element intersection Given two elements, element A from mesh A and element B from mesh B, the following routines are used to construct a simplicial mesh C, which is a mesh of their intersection (the local supermesh ). The following definitions are used: d Mesh A defines a subset Ω A R d, and mesh B a subset Ω B R d. l Number of nodes in an element. l A Number of nodes in element A from mesh A. l B Number of nodes in element B from mesh B. F A F B Number of element A facets. Number of element B facets. l C Number of nodes per element in the intersection mesh C, always equal to d + 1. E C Number of elements in the intersection mesh C. M C An upper bound for the maximum number of elements which can be in any intersection mesh C. 17

18 5.1 One dimension Definition of M C. integer, parameter : : i n t e r v a l b u f s i z e = 1 Interval intersection. interface i n t e r s e c t i n t e r v a l s module procedure i n t e r s e c t i n t e r v a l s r a n k 1, i n t e r s e c t i n t e r v a l s r a n k 2, & & i n t e r s e c t i n t e r v a l s r a n k 3 end interface i n t e r s e c t i n t e r v a l s pure subroutine i n t e r s e c t i n t e r v a l s r a n k 1 ( i n t e r v a l a, i n t e r v a l b, & & i n t e r v a l s c, n i n t e r v a l s c ) real, dimension ( 2 ), intent ( in ) : : i n t e r v a l a real, dimension ( 2 ), intent ( in ) : : i n t e r v a l b real, dimension ( 2 ), intent ( out ) : : i n t e r v a l s c integer, intent ( out ) : : n i n t e r v a l s c interval a Length 2 vector. Element A node coordinates. interval b Length 2 vector. Element B node coordinates. interval c Length 2 vector. Intersection mesh C node coordinates. n intervals c Number of elements in mesh C. Equal to 1 if elements A and B intersect, and 0 otherwise. pure subroutine i n t e r s e c t i n t e r v a l s r a n k 2 ( i n t e r v a l a, i n t e r v a l b, & & i n t e r v a l s c, n i n t e r v a l s c ) real, dimension ( 2 ), intent ( in ) : : i n t e r v a l a real, dimension ( 2 ), intent ( in ) : : i n t e r v a l b real, dimension ( 2, i n t e r v a l b u f s i z e ), intent ( out ) : : i n t e r v a l s c integer, intent ( out ) : : n i n t e r v a l s c interval a Length 2 vector. Element A node coordinates. interval b Length 2 vector. Element B node coordinates. interval c 2 M C array. Intersection mesh C node coordinates. M C = 1. n intervals c Number of elements in mesh C. Equal to 1 if elements A and B intersect, and 0 otherwise. pure subroutine i n t e r s e c t i n t e r v a l s r a n k 3 ( i n t e r v a l a, i n t e r v a l b, & & i n t e r v a l s c, n i n t e r v a l s c ) real, dimension ( 1, 2 ), intent ( in ) : : i n t e r v a l a real, dimension ( 1, 2 ), intent ( in ) : : i n t e r v a l b real, dimension ( 1, 2, i n t e r v a l b u f s i z e ), intent ( out ) : : i n t e r v a l s c integer, intent ( out ) : : n i n t e r v a l s c interval a 1 2 array. Element A node coordinates. interval b 1 2 vector. Element B node coordinates. interval c 1 2 M C array. Intersection mesh C node coordinates. M C = 1. n intervals c Number of elements in mesh C. Equal to 1 if elements A and B intersect, and 0 otherwise. 18

19 Interval length. interface i n t e r v a l s i z e module procedure i n t e r v a l s i z e r a n k 1, i n t e r v a l s i z e r a n k 2 end interface i n t e r v a l s i z e pure function i n t e r v a l s i z e r a n k 1 ( i n t e r v a l ) result ( size ) real, dimension ( 2 ), intent ( in ) : : i n t e r v a l real : : size interval Length 2 vector. Element node coordinates. size Length of the element. pure function i n t e r v a l s i z e r a n k 2 ( i n t e r v a l ) result ( size ) real, dimension ( 1, 2 ), intent ( in ) : : i n t e r v a l real : : size interval 1 2 array. Element node coordinates. size Length of the element. 5.2 Two dimensions Intersection of two-dimensional polygons using the Sutherland and Hodgman [1974] algorithm. triangle_type data type, used to define triangles. type t r i t y p e real, dimension ( 2, 3) : : v end type t r i t y p e v d l array. Triangle node coordinates. line_type data type, used to define the lines which constitute the half-spaces defined by element facets. type l i n e t y p e real, dimension ( 2 ) : : normal real, dimension ( 2 ) : : point end type l i n e t y p e normal Length d vector. Components of an outward pointing facet normal. Need not have unit norm. point Length d vector. Coordinates of a point on the line defining the half-space. Definition of M C for triangle-triangle intersection. integer, parameter : : t r i b u f s i z e = 22 Definition of M C for triangle-polygon intersection. interface m a x n t r i s c module procedure m a x n t r i s c t r i end interface m a x n t r i s c 19

20 pure elemental function m a x n t r i s c t r i ( n l i n e s b ) result ( m a x n t r i s c ) integer, intent ( in ) : : n l i n e s b integer : : m a x n t r i s c n lines b F B, assuming that element A is a triangle. max n tris c M C = 3 ( 2 F B) 2. Definition of M C for polygon-polygon intersection. interface m a x n t r i s c module procedure m a x n t r i s c p o l y end interface m a x n t r i s c pure elemental function m a x n t r i s c p o l y ( n l i n e s a, n l i n e s b ) result ( m a x n t r i s c ) integer, intent ( in ) : : n l i n e s a integer, intent ( in ) : : n l i n e s b integer : : m a x n t r i s c n lines a F A. n lines b F B. max n tris c M C = F A ( 2 F B ) 2. Obtain a line_type representation of the half-spaces defined by facets. interface g e t l i n e s module procedure g e t l i n e s t r i, g e t l i n e s p o l y end interface g e t l i n e s pure function g e t l i n e s t r i ( t r i ) result ( l i n e s ) type ( t r i t y p e ), intent ( in ) : : t r i type ( l i n e t y p e ), dimension ( 3 ) : : l i n e s tri A triangle. lines The three half-spaces. pure function g e t l i n e s p o l y ( poly ) result ( l i n e s ) real, dimension ( :, : ), intent ( in ) : : poly type ( l i n e t y p e ), dimension ( size ( poly, 2 ) ) : : l i n e s poly d l array. Coordinates of the polygon nodes, in either clockwise or anti-clockwise order. The first three nodes must not be co-linear. lines Length l array. The half-spaces defined by the facets of the polygon. Triangle-triangle intersection. interface i n t e r s e c t t r i s module procedure i n t e r s e c t t r i s r e a l, i n t e r s e c t t r i s t r i end interface i n t e r s e c t t r i s 20

21 subroutine i n t e r s e c t t r i s r e a l ( t r i a, t r i b, t r i s c, n t r i s c ) real, dimension ( 2, 3 ), intent ( in ) : : t r i a real, dimension ( 2, 3 ), intent ( in ) : : t r i b real, dimension ( 2, 3, t r i b u f s i z e ), intent ( out ) : : t r i s c integer, intent ( out ) : : n t r i s c tri a d l A array. Element A node coordinates. Element A must be a triangle. tri b d l B array. Element B node coordinates. Element B must be a triangle. tris c d l C M C array. Mesh C node coordinates. M C = 22. n tris c E C. subroutine i n t e r s e c t t r i s t r i ( t r i a, t r i b, t r i s c, n t r i s c ) type ( t r i t y p e ), intent ( in ) : : t r i a type ( t r i t y p e ), intent ( in ) : : t r i b type ( t r i t y p e ), dimension ( t r i b u f s i z e ), intent ( out ) : : t r i s c integer, intent ( out ) : : n t r i s c tri a Element A. tri b Element B. tris c Length M C vector. Triangles in mesh C. M C = 22. n tris c E C. Triangle-quadrilateral intersection. subroutine i n t e r s e c t t r i q u a d ( t r i a, quad b, t r i s c, n t r i s c ) real, dimension ( :, : ), intent ( in ) : : t r i a real, dimension ( :, : ), intent ( in ) : : quad b real, dimension ( :, :, : ), intent ( inout ) : : t r i s c integer, intent ( out ) : : n t r i s c tri a d l A array. Element A node coordinates. Element A must be a triangle. quad b d l B array. Element B node coordinates. Element B must be a convex quadrilateral with the node coordinates in either clockwise or anti-clockwise order, and the first three nodes must not be co-linear. tris c d l C M C array. Mesh C node coordinates. M C = 46. n tris c E C. Quadrilateral-quadrilateral intersection. subroutine i n t e r s e c t q u a d s ( quad a, quad b, t r i s c, n t r i s c ) real, dimension ( :, : ), intent ( in ) : : quad a real, dimension ( :, : ), intent ( in ) : : quad b real, dimension ( :, :, : ), intent ( inout ) : : t r i s c integer, intent ( out ) : : n t r i s c quad a d l A array. Element A node coordinates. Element A must be a quadrilateral with the node coordinates in either clockwise or anti-clockwise order. quad b d l B array. Element B node coordinates. Element B must be a convex quadrilateral with the node coordinates in either clockwise or anti-clockwise order, and the first three nodes must not be co-linear. The intersection of elements A and B must be a convex polygon. 21

22 tris c d l C M C array. Mesh C node coordinates. M C = 62. n tris c E C. Triangle-polygon intersection. interface i n t e r s e c t p o l y s module procedure i n t e r s e c t t r i l i n e s end interface i n t e r s e c t p o l y s pure subroutine i n t e r s e c t t r i l i n e s ( t r i a, l i n e s b, t r i s c, n t r i s c, area b, work ) type ( t r i t y p e ), intent ( in ) : : t r i a type ( l i n e t y p e ), dimension ( : ), intent ( in ) : : l i n e s b type ( t r i t y p e ), dimension ( : ), intent ( out ) : : t r i s c integer, intent ( out ) : : n t r i s c real, optional, intent ( in ) : : area b real, dimension ( :, :, : ), target, optional, intent ( out ) : : work tri a Element A. lines b Element B facet half-spaces. Element B must be a convex polygon. tris c Length M C vector. Triangles in mesh C. n tris c E C. area b Area of element B. Used to discard near-degenerate elements in mesh C. work 2 M C 2 array. Working memory. Polygon-polygon intersection. interface i n t e r s e c t p o l y s module procedure i n t e r s e c t p o l y s r e a l, i n t e r s e c t p o l y s l i n e s end interface i n t e r s e c t p o l y s pure subroutine i n t e r s e c t p o l y s r e a l ( poly a, poly b, t r i s c, n t r i s c, & & area a, area b, work ) real, dimension ( :, : ), intent ( in ) : : poly a real, dimension ( :, : ), intent ( in ) : : poly b type ( t r i t y p e ), dimension ( : ), intent ( out ) : : t r i s c integer, intent ( out ) : : n t r i s c real, optional, intent ( in ) : : a r e a a real, optional, intent ( in ) : : area b real, dimension ( :, :, : ), target, optional, intent ( out ) : : work poly a d l A array. Element A node coordinates. The node coordinates must be in either clockwise or anti-clockwise order. poly b d l B array. Element B node coordinates. The node coordinates must be in either clockwise or anti-clockwise order, the first three nodes must not be co-linear, and the element must be a convex polygon. The intersection of elements A and B must be a convex polygon. tris c Length M C vector. Triangles in mesh C. n tris c E C. area a Area of element A. Used to discard near-degenerate elements in mesh C. area b Area of element B. Used to discard near-degenerate elements in mesh C. work 2 M C 2 array. Working memory. 22

23 pure subroutine i n t e r s e c t p o l y s l i n e s ( poly a, l i n e s b, t r i s c, n t r i s c, & & area a, area b, work ) real, dimension ( :, : ), intent ( in ) : : poly a type ( l i n e t y p e ), dimension ( : ), intent ( in ) : : l i n e s b type ( t r i t y p e ), dimension ( : ), intent ( out ) : : t r i s c integer, intent ( out ) : : n t r i s c real, optional, intent ( in ) : : a r e a a real, optional, intent ( in ) : : area b real, dimension ( :, :, : ), target, optional, intent ( out ) : : work poly a d l A array. Element A node coordinates. The node coordinates must be in either clockwise or anti-clockwise order. lines b d l B array. Element B facet half-spaces. Element B must be a convex polygon. The intersection of elements A and B must be a convex polygon. tris c Length M C vector. Triangles in mesh C. n tris c E C. area a Area of element A. Used to discard near-degenerate elements in mesh C. area b Area of element B. Used to discard near-degenerate elements in mesh C. work 2 M C 2 array. Working memory. Triangle area. interface t r i a n g l e a r e a module procedure t r i a n g l e a r e a r e a l, t r i a n g l e a r e a t r i end interface t r i a n g l e a r e a pure function t r i a n g l e a r e a r e a l ( t r i ) result ( area ) real, dimension ( 2, 3 ), intent ( in ) : : t r i real : : area tri d l array. Triangle node coordinates. area Area of the triangle. pure elemental function t r i a n g l e a r e a t r i ( t r i ) result ( area ) type ( t r i t y p e ), intent ( in ) : : t r i real : : area tri A triangle. area Area of the triangle. 5.3 Three dimensions Intersection of three-dimensional convex polyhedra using the plane-at-a-time clipping algorithm described in Eberly [2007] (section 2.4.3). tet_type data type, used to define tetrahedra. type t e t t y p e real, dimension ( 3, 4) : : v integer, dimension ( 4 ) : : c o l o u r s = 1 end type t e t t y p e 23