p6est.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 P6EST_H
#define P6EST_H
 
/* 2+1D refinement is based on the 2D p4est datatypes */
#include <p4est.h>
/* We need p8est_connect_type_t typedef from p8est_connectivity */
#include <p8est_connectivity.h>
 
SC_EXTERN_C_BEGIN;
 
typedef struct p6est_connectivity
{
  p4est_connectivity_t *conn4;  
  double             *top_vertices;     
  double              height[3];        
}
p6est_connectivity_t;
 
p6est_connectivity_t *p6est_connectivity_new (p4est_connectivity_t * conn4,
                                              double *top_vertices,
                                              double height[3]);
 
void                p6est_connectivity_destroy (p6est_connectivity_t * conn);
 
void                p6est_tree_get_vertices (p6est_connectivity_t * conn,
                                             p4est_topidx_t which_tree,
                                             double vertices[24]);
 
void                p6est_qcoord_to_vertex (p6est_connectivity_t *
                                            connectivity,
                                            p4est_topidx_t treeid,
                                            p4est_qcoord_t x,
                                            p4est_qcoord_t y,
                                            p4est_qcoord_t z, double vxyz[3]);
 
typedef struct p2est_quadrant
{
  p4est_qcoord_t      z;                
  int8_t              level,            
                      pad8;             
  int16_t             pad16;            
  union p6est_quadrant_data
  {
    void               *user_data;      
    long                user_long;      
    int                 user_int;       
    p4est_topidx_t      which_tree;     
    struct
    {
      p4est_topidx_t      which_tree;
      int                 owner_rank;
    }
    piggy1; 
    struct
    {
      p4est_topidx_t      which_tree;
      p4est_topidx_t      from_tree;
    }
    piggy2; 
    struct
    {
      p4est_topidx_t      which_tree;
      p4est_locidx_t      local_num;
    }
    piggy3; 
  }
  p; 
}
p2est_quadrant_t;
 
typedef struct p6est
{
  sc_MPI_Comm         mpicomm;          
  int                 mpisize,          
                      mpirank;          
  int                 mpicomm_owned;    
  size_t              data_size;        
  void               *user_pointer;     
  p6est_connectivity_t *connectivity;   
  p4est_t            *columns;  
  sc_array_t         *layers;   
  sc_mempool_t       *user_data_pool;   
  /* WARNING: This is NULL if data size
   *          equals zero.  */
  sc_mempool_t       *layer_pool;       
  p4est_gloidx_t     *global_first_layer; 
  p4est_qcoord_t      root_len; 
}
p6est_t;
 
typedef void        (*p6est_init_t) (p6est_t * p6est,
                                     p4est_topidx_t which_tree,
                                     p4est_quadrant_t * column,
                                     p2est_quadrant_t * layer);
 
typedef void        (*p6est_replace_t) (p6est_t * p6est,
                                        p4est_topidx_t which_tree,
                                        int num_outcolumns,
                                        int num_outlayers,
                                        p4est_quadrant_t * outcolumns[],
                                        p2est_quadrant_t * outlayers[],
                                        int num_incolumns,
                                        int num_inlayers,
                                        p4est_quadrant_t * incolumns[],
                                        p2est_quadrant_t * inlayers[]);
 
typedef int         (*p6est_refine_column_t) (p6est_t * p6est,
                                              p4est_topidx_t which_tree,
                                              p4est_quadrant_t * column);
 
typedef int         (*p6est_refine_layer_t) (p6est_t * p6est,
                                             p4est_topidx_t which_tree,
                                             p4est_quadrant_t * column,
                                             p2est_quadrant_t * layer);
 
typedef int         (*p6est_coarsen_column_t) (p6est_t * p6est,
                                               p4est_topidx_t which_tree,
                                               p4est_quadrant_t * columns[]);
 
typedef int         (*p6est_coarsen_layer_t) (p6est_t * p6est,
                                              p4est_topidx_t which_tree,
                                              p4est_quadrant_t * column,
                                              p2est_quadrant_t * layers[]);
 
typedef int         (*p6est_weight_t) (p6est_t * p6est,
                                       p4est_topidx_t which_tree,
                                       p4est_quadrant_t * column,
                                       p2est_quadrant_t * layer);
 
extern void        *P2EST_DATA_UNINITIALIZED;
 
#define P2EST_QUADRANT_INIT(q) \
  ((void) memset ((q), -1, sizeof (p2est_quadrant_t)))
 
p6est_t            *p6est_new (sc_MPI_Comm mpicomm,
                               p6est_connectivity_t * connectivity,
                               size_t data_size,
                               p6est_init_t init_fn, void *user_pointer);
 
p6est_t            *p6est_new_from_p4est (p4est_t * p4est,
                                          double *top_vertices,
                                          double height[3], int min_zlevel,
                                          size_t data_size,
                                          p6est_init_t init_fn,
                                          void *user_pointer);
 
void                p6est_destroy (p6est_t * p6est);
 
p6est_t            *p6est_copy (p6est_t * input, int copy_data);
 
void                p6est_reset_data (p6est_t * p6est, size_t data_size,
                                      p6est_init_t init_fn,
                                      void *user_pointer);
 
void                p6est_refine_columns (p6est_t * p6est,
                                          int refine_recursive,
                                          p6est_refine_column_t refine_fn,
                                          p6est_init_t init_fn);
 
void                p6est_refine_layers (p6est_t * p6est,
                                         int refine_recursive,
                                         p6est_refine_layer_t refine_fn,
                                         p6est_init_t init_fn);
 
void                p6est_coarsen_columns (p6est_t * p6est,
                                           int coarsen_recursive,
                                           p6est_coarsen_column_t coarsen_fn,
                                           p6est_init_t init_fn);
 
void                p6est_coarsen_layers (p6est_t * p6est,
                                          int coarsen_recursive,
                                          p6est_coarsen_layer_t coarsen_fn,
                                          p6est_init_t init_fn);
 
void                p6est_balance (p6est_t * p6est,
                                   p8est_connect_type_t btype,
                                   p6est_init_t init_fn);
 
typedef enum
{
  P6EST_COMM_PARTITION = 1,
  P6EST_COMM_GHOST,
  P6EST_COMM_BALANCE
}
p6est_comm_tag_t;
 
p4est_gloidx_t      p6est_partition (p6est_t * p6est,
                                     p6est_weight_t weight_fn);
void                p6est_partition_correct (p6est_t * p6est,
                                             p4est_locidx_t *
                                             num_layers_in_proc);
void                p6est_partition_to_p4est_partition (p6est_t * p6est,
                                                        p4est_locidx_t *
                                                        num_layers_in_proc,
                                                        p4est_locidx_t *
                                                        num_columns_in_proc);
void                p4est_partition_to_p6est_partition (p6est_t * p6est,
                                                        p4est_locidx_t *
                                                        num_columns_in_proc,
                                                        p4est_locidx_t *
                                                        num_layers_in_proc);
 
p4est_gloidx_t      p6est_partition_for_coarsening (p6est_t * p6est,
                                                    p4est_locidx_t *
                                                    num_layers_in_proc);
p4est_gloidx_t      p6est_partition_given (p6est_t * p6est,
                                           p4est_locidx_t *
                                           num_layers_in_proc);
 
unsigned            p6est_checksum (p6est_t * p6est);
 
void                p6est_save (const char *filename, p6est_t * p6est,
                                int save_data);
 
p6est_t            *p6est_load (const char *filename, sc_MPI_Comm mpicomm,
                                size_t data_size, int load_data,
                                void *user_pointer,
                                p6est_connectivity_t ** connectivity);
 
/*@unused@*/
static inline p2est_quadrant_t *
p2est_quadrant_array_index (sc_array_t * array, size_t it)
{
  P4EST_ASSERT (array->elem_size == sizeof (p2est_quadrant_t));
  P4EST_ASSERT (it < array->elem_count);
 
  return (p2est_quadrant_t *) (array->array + sizeof (p2est_quadrant_t) * it);
}
 
/*@unused@*/
static inline p2est_quadrant_t *
p2est_quadrant_array_push (sc_array_t * array)
{
  p2est_quadrant_t *q;
 
  P4EST_ASSERT (array->elem_size == sizeof (p2est_quadrant_t));
 
  q = (p2est_quadrant_t *) sc_array_push (array);
  P2EST_QUADRANT_INIT(q);
  return q;
}
 
/*@unused@*/
static inline p2est_quadrant_t *
p2est_quadrant_mempool_alloc (sc_mempool_t * mempool)
{
  P4EST_ASSERT (mempool->elem_size == sizeof (p2est_quadrant_t));
 
  return (p2est_quadrant_t *) sc_mempool_alloc (mempool);
}
 
/*@unused@*/
static inline p2est_quadrant_t *
p2est_quadrant_list_pop (sc_list_t * list)
{
  return (p2est_quadrant_t *) sc_list_pop (list);
}
 
#define P6EST_COLUMN_GET_RANGE(q,f,l)                \
  do {                                               \
    *(f) = (size_t) (q)->p.piggy3.local_num;         \
    *(l) = *(f) + (size_t) (q)->p.piggy3.which_tree; \
  } while (0);
 
#define P6EST_COLUMN_SET_RANGE(q,f,l)                        \
  do {                                                       \
    (q)->p.piggy3.local_num = (p4est_locidx_t) (f);          \
    (q)->p.piggy3.which_tree = (p4est_topidx_t) ((l) - (f)); \
  } while (0);
 
/*@unused@*/
static inline void
p6est_layer_init_data (p6est_t * p6est, p4est_topidx_t which_tree,
                       p4est_quadrant_t * column,
                       p2est_quadrant_t * layer, p6est_init_t init_fn)
{
  if (p6est->data_size > 0) {
    layer->p.user_data = sc_mempool_alloc (p6est->user_data_pool);
  }
  else {
    layer->p.user_data = NULL;
  }
  if (init_fn != NULL) {
    init_fn (p6est, which_tree, column, layer);
  }
}
 
/*@unused@*/
static inline void
p6est_layer_free_data (p6est_t * p6est, p2est_quadrant_t * layer)
{
  if (p6est->data_size > 0) {
    sc_mempool_free (p6est->user_data_pool, layer->p.user_data);
  }
  layer->p.user_data = NULL;
}
 
void                p6est_compress_columns (p6est_t * p6est);
void                p6est_update_offsets (p6est_t * p6est);
 
SC_EXTERN_C_END;
 
#endif /* !P6EST_H */