p4est_connectivity.h

Go to the documentation of this file.

/*
  This file is part of p4est.
  p4est is a C library to manage a collection (a forest) of multiple
  connected adaptive quadtrees or octrees in parallel.
 
  Copyright (C) 2010 The University of Texas System
  Additional copyright (C) 2011 individual authors
  Written by Carsten Burstedde, Lucas C. Wilcox, and Tobin Isaac
 
  p4est is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
 
  p4est is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with p4est; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
#ifndef P4EST_CONNECTIVITY_H
#define P4EST_CONNECTIVITY_H
 
#ifdef P4_TO_P8
#error "Including a p4est header with P4_TO_P8 defined"
#endif
 
#include <sc_io.h>
#include <p4est_base.h>
 
SC_EXTERN_C_BEGIN;
 
#define P4EST_DIM 2
#define P4EST_FACES (2 * P4EST_DIM)
#define P4EST_CHILDREN 4
#define P4EST_HALF (P4EST_CHILDREN / 2)
#define P4EST_INSUL 9
 
#define P4EST_ONLY_P8_LAND(x)
 
#define P4EST_ONLY_P8_COMMA(x)
 
#define P4EST_DIM_POW(a) ((a) * (a))
 
#define P4EST_FTRANSFORM 9
 
#define P4EST_STRING "p4est"
 
#define P4EST_ONDISK_FORMAT 0x2000009
 
typedef enum
{
  /* make sure to have different values 2D and 3D */
  P4EST_CONNECT_SELF = 20,      
  P4EST_CONNECT_FACE = 21,      
  P4EST_CONNECT_ALMOST = P4EST_CONNECT_FACE,    
  P4EST_CONNECT_CORNER = 22,    
  P4EST_CONNECT_FULL = P4EST_CONNECT_CORNER     
}
p4est_connect_type_t;
 
#ifdef P4EST_BACKWARD_DEALII
typedef p4est_connect_type_t p4est_balance_type_t;
#endif
 
typedef enum
{
  P4EST_CONN_ENCODE_NONE = SC_IO_ENCODE_NONE,
  P4EST_CONN_ENCODE_LAST        
}
p4est_connectivity_encode_t;
 
int                 p4est_connect_type_int (p4est_connect_type_t btype);
 
const char         *p4est_connect_type_string (p4est_connect_type_t btype);
 
typedef struct p4est_connectivity
{
  p4est_topidx_t      num_vertices; 
  p4est_topidx_t      num_trees;    
  p4est_topidx_t      num_corners;  
  double             *vertices;     
  p4est_topidx_t     *tree_to_vertex; 
  size_t              tree_attr_bytes;  
  char               *tree_to_attr;     
  p4est_topidx_t     *tree_to_tree; 
  int8_t             *tree_to_face; 
  p4est_topidx_t     *tree_to_corner; 
  p4est_topidx_t     *ctt_offset; 
  p4est_topidx_t     *corner_to_tree; 
  int8_t             *corner_to_corner; 
}
p4est_connectivity_t;
 
size_t              p4est_connectivity_memory_used (p4est_connectivity_t *
                                                    conn);
 
typedef struct
{
  p4est_topidx_t      ntree; 
  int8_t              ncorner; 
}
p4est_corner_transform_t;
 
typedef struct
{
  p4est_topidx_t      icorner; 
  sc_array_t          corner_transforms; 
}
p4est_corner_info_t;
 
typedef struct
{
  p4est_connect_type_t neighbor_type; 
  p4est_topidx_t      neighbor;   
  int8_t              index_self; 
  int8_t              index_neighbor; 
  int8_t              perm[P4EST_DIM]; 
  int8_t              sign[P4EST_DIM]; 
  p4est_qcoord_t      origin_self[P4EST_DIM]; 
  p4est_qcoord_t      origin_neighbor[P4EST_DIM]; 
}
p4est_neighbor_transform_t;
 
/* *INDENT-OFF* */
 
void                p4est_neighbor_transform_coordinates
                      (const p4est_neighbor_transform_t * nt,
                       const p4est_qcoord_t self_coords[P4EST_DIM],
                       p4est_qcoord_t neigh_coords[P4EST_DIM]);
 
void                p4est_neighbor_transform_coordinates_reverse
                      (const p4est_neighbor_transform_t * nt,
                       const p4est_qcoord_t neigh_coords[P4EST_DIM],
                       p4est_qcoord_t self_coords[P4EST_DIM]);
 
void                p4est_connectivity_get_neighbor_transforms
                      (p4est_connectivity_t *conn,
                       p4est_topidx_t tree_id,
                       p4est_connect_type_t boundary_type,
                       int boundary_index,
                       sc_array_t *neighbor_transform_array);
 
/* *INDENT-ON* */
 
extern const int    p4est_face_corners[4][2];
 
extern const int    p4est_face_dual[4];
 
extern const int    p4est_corner_faces[4][2];
 
extern const int    p4est_corner_face_corners[4][4];
 
extern const int    p4est_child_corner_faces[4][4];
 
int                 p4est_connectivity_face_neighbor_face_corner
  (int fc, int f, int nf, int o);
 
int                 p4est_connectivity_face_neighbor_corner
  (int c, int f, int nf, int o);
 
p4est_connectivity_t *p4est_connectivity_new (p4est_topidx_t num_vertices,
                                              p4est_topidx_t num_trees,
                                              p4est_topidx_t num_corners,
                                              p4est_topidx_t num_ctt);
 
p4est_connectivity_t *p4est_connectivity_new_copy (p4est_topidx_t
                                                   num_vertices,
                                                   p4est_topidx_t num_trees,
                                                   p4est_topidx_t num_corners,
                                                   const double *vertices,
                                                   const p4est_topidx_t * ttv,
                                                   const p4est_topidx_t * ttt,
                                                   const int8_t * ttf,
                                                   const p4est_topidx_t * ttc,
                                                   const p4est_topidx_t *
                                                   coff,
                                                   const p4est_topidx_t * ctt,
                                                   const int8_t * ctc);
 
p4est_connectivity_t *p4est_connectivity_bcast (p4est_connectivity_t *
                                                conn_in, int root,
                                                sc_MPI_Comm comm);
 
void                p4est_connectivity_destroy (p4est_connectivity_t *
                                                connectivity);
 
void                p4est_connectivity_set_attr (p4est_connectivity_t * conn,
                                                 size_t bytes_per_tree);
 
int                 p4est_connectivity_is_valid (p4est_connectivity_t *
                                                 connectivity);
 
int                 p4est_connectivity_is_equal (p4est_connectivity_t * conn1,
                                                 p4est_connectivity_t *
                                                 conn2);
 
int                 p4est_connectivity_sink (p4est_connectivity_t * conn,
                                             sc_io_sink_t * sink);
 
sc_array_t         *p4est_connectivity_deflate (p4est_connectivity_t * conn,
                                                p4est_connectivity_encode_t
                                                code);
 
int                 p4est_connectivity_save (const char *filename,
                                             p4est_connectivity_t *
                                             connectivity);
 
p4est_connectivity_t *p4est_connectivity_source (sc_io_source_t * source);
 
p4est_connectivity_t *p4est_connectivity_inflate (sc_array_t * buffer);
 
p4est_connectivity_t *p4est_connectivity_load (const char *filename,
                                               size_t *bytes);
 
p4est_connectivity_t *p4est_connectivity_new_unitsquare (void);
 
p4est_connectivity_t *p4est_connectivity_new_periodic (void);
 
p4est_connectivity_t *p4est_connectivity_new_rotwrap (void);
 
p4est_connectivity_t *p4est_connectivity_new_circle (void);
 
p4est_connectivity_t *p4est_connectivity_new_drop (void);
 
p4est_connectivity_t *p4est_connectivity_new_twotrees (int l_face,
                                                       int r_face,
                                                       int orientation);
 
p4est_connectivity_t *p4est_connectivity_new_corner (void);
 
p4est_connectivity_t *p4est_connectivity_new_pillow (void);
 
p4est_connectivity_t *p4est_connectivity_new_moebius (void);
 
p4est_connectivity_t *p4est_connectivity_new_star (void);
 
p4est_connectivity_t *p4est_connectivity_new_cubed (void);
 
p4est_connectivity_t *p4est_connectivity_new_disk_nonperiodic (void);
 
p4est_connectivity_t *p4est_connectivity_new_disk (int periodic_a,
                                                   int periodic_b);
 
p4est_connectivity_t *p4est_connectivity_new_icosahedron (void);
 
p4est_connectivity_t *p4est_connectivity_new_shell2d (void);
 
p4est_connectivity_t *p4est_connectivity_new_disk2d (void);
 
p4est_connectivity_t *p4est_connectivity_new_bowtie (void);
 
p4est_connectivity_t *p4est_connectivity_new_brick (int mi, int ni,
                                                    int periodic_a,
                                                    int periodic_b);
 
p4est_connectivity_t *p4est_connectivity_new_byname (const char *name);
 
p4est_connectivity_t *p4est_connectivity_refine (p4est_connectivity_t * conn,
                                                 int num_per_dim);
 
void                p4est_expand_face_transform (int iface, int nface,
                                                 int ftransform[]);
 
p4est_topidx_t      p4est_find_face_transform (p4est_connectivity_t *
                                               connectivity,
                                               p4est_topidx_t itree,
                                               int iface, int ftransform[]);
 
void                p4est_find_corner_transform (p4est_connectivity_t *
                                                 connectivity,
                                                 p4est_topidx_t itree,
                                                 int icorner,
                                                 p4est_corner_info_t * ci);
 
void                p4est_connectivity_complete (p4est_connectivity_t * conn);
 
void                p4est_connectivity_reduce (p4est_connectivity_t * conn);
 
void                p4est_connectivity_permute (p4est_connectivity_t * conn,
                                                sc_array_t * perm,
                                                int is_current_to_new);
#ifdef P4EST_WITH_METIS
 
void                p4est_connectivity_reorder (sc_MPI_Comm comm, int k,
                                                p4est_connectivity_t * conn,
                                                p4est_connect_type_t ctype);
 
sc_array_t         *p4est_connectivity_reorder_newid (sc_MPI_Comm comm, int k,
                                                      p4est_connectivity_t *
                                                      conn,
                                                      p4est_connect_type_t
                                                      ctype,
                                                      sc_array_t * newid);
 
#endif /* P4EST_WITH_METIS */
 
void                p4est_connectivity_join_faces (p4est_connectivity_t *
                                                   conn,
                                                   p4est_topidx_t tree_left,
                                                   p4est_topidx_t tree_right,
                                                   int face_left,
                                                   int face_right,
                                                   int orientation);
 
int                 p4est_connectivity_is_equivalent (p4est_connectivity_t *
                                                      conn1,
                                                      p4est_connectivity_t *
                                                      conn2);
 
/*@unused@*/
static inline p4est_corner_transform_t *
p4est_corner_array_index (sc_array_t * array, size_t it)
{
  P4EST_ASSERT (array->elem_size == sizeof (p4est_corner_transform_t));
  P4EST_ASSERT (it < array->elem_count);
 
  return
    (p4est_corner_transform_t *) (array->array +
                                  sizeof (p4est_corner_transform_t) * it);
}
 
int                 p4est_connectivity_read_inp_stream (FILE * stream,
                                                        p4est_topidx_t *
                                                        num_vertices,
                                                        p4est_topidx_t *
                                                        num_trees,
                                                        double *vertices,
                                                        p4est_topidx_t *
                                                        tree_to_vertex);
 
p4est_connectivity_t *p4est_connectivity_read_inp (const char *filename);
 
SC_EXTERN_C_END;
 
#endif /* !P4EST_CONNECTIVITY_H */