p4est_wrap.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_WRAP_H
#define P4EST_WRAP_H
 
#include <p4est_extended.h>
#include <sc_refcount.h>
 
SC_EXTERN_C_BEGIN;
 
/*** COMPLETE INTERNAL STATE OF P4EST ***/
 
typedef enum p4est_wrap_flags
{
  P4EST_WRAP_NONE = 0,
  P4EST_WRAP_REFINE = 0x01,
  P4EST_WRAP_COARSEN = 0x02
}
p4est_wrap_flags_t;
 
typedef struct
{
  int                 hollow;           
  p4est_mesh_params_t mesh_params;      
  p4est_replace_t     replace_fn;       
  int                 coarsen_delay;    
  int                 coarsen_affect;   
  int                 partition_for_coarsening; 
  int                 store_adapted;    
  void               *user_pointer;     
}
p4est_wrap_params_t;
 
typedef struct p4est_wrap
{
  /* collection of wrap-related parameters */
  p4est_wrap_params_t params;
 
  sc_refcount_t       conn_rc;
  p4est_connectivity_t *conn;
  struct p4est_wrap  *conn_owner;
 
  /* these members are considered public and read-only */
  int                 p4est_dim;
  int                 p4est_half;
  int                 p4est_faces;
  int                 p4est_children;
  p4est_t            *p4est;    
  /* If \a params.store_adapted is true, these arrays store the indices of the
   * quadrants refined and coarsened during the most recent call to
   * \ref p4est_wrap_adapt. The wrap's \a p4est has to be balanced when entering
   * the adaptation, to avoid multi-level refinement.
   * The arrays are allocated during the first call of \ref p4est_wrap_adapt.
   * At every time the arrays index into the local quadrants of the p4est as it
   * was directly after completion of \ref p4est_wrap_adapt. So, they are not
   * updated in \ref p4est_wrap_partition. Newly_refined only stores newly
   * refined quadrants with child id 0. */
  sc_array_t         *newly_refined; 
  sc_array_t         *newly_coarsened; 
  /* anything below here is considered private und should not be touched */
  int                 weight_exponent;
  uint8_t            *flags, *temp_flags;
  p4est_locidx_t      num_refine_flags, inside_counter, num_replaced;
  p4est_gloidx_t     *old_global_first_quadrant;
 
  /* for ghost and mesh use p4est_wrap_get_ghost, _mesh declared below */
  p4est_ghost_t      *ghost;
  p4est_mesh_t       *mesh;
  p4est_ghost_t      *ghost_aux;
  p4est_mesh_t       *mesh_aux;
  int                 match_aux;
}
p4est_wrap_t;
 
void                p4est_wrap_params_init (p4est_wrap_params_t * params);
 
p4est_wrap_t       *p4est_wrap_new_conn (sc_MPI_Comm mpicomm,
                                         p4est_connectivity_t * conn,
                                         int initial_level);
 
p4est_wrap_t       *p4est_wrap_new_p4est (p4est_t * p4est, int hollow,
                                          p4est_connect_type_t btype,
                                          p4est_replace_t replace_fn,
                                          void *user_pointer);
 
p4est_wrap_t       *p4est_wrap_new_p4est_params (p4est_t * p4est,
                                                 p4est_wrap_params_t * params);
 
p4est_wrap_t       *p4est_wrap_new_ext (sc_MPI_Comm mpicomm,
                                        p4est_connectivity_t * conn,
                                        int initial_level, int hollow,
                                        p4est_connect_type_t btype,
                                        p4est_replace_t replace_fn,
                                        void *user_pointer);
 
p4est_wrap_t       *p4est_wrap_new_params (sc_MPI_Comm mpicomm,
                                           p4est_connectivity_t * conn,
                                           int initial_level,
                                           p4est_wrap_params_t * params);
 
p4est_wrap_t       *p4est_wrap_new_copy (p4est_wrap_t * source,
                                         size_t data_size,
                                         p4est_replace_t replace_fn,
                                         void *user_pointer);
 
p4est_wrap_t       *p4est_wrap_new_unitsquare (sc_MPI_Comm mpicomm,
                                               int initial_level);
 
p4est_wrap_t       *p4est_wrap_new_periodic (sc_MPI_Comm mpicomm,
                                             int initial_level);
p4est_wrap_t       *p4est_wrap_new_rotwrap (sc_MPI_Comm mpicomm,
                                            int initial_level);
p4est_wrap_t       *p4est_wrap_new_corner (sc_MPI_Comm mpicomm,
                                           int initial_level);
p4est_wrap_t       *p4est_wrap_new_pillow (sc_MPI_Comm mpicomm,
                                           int initial_level);
p4est_wrap_t       *p4est_wrap_new_moebius (sc_MPI_Comm mpicomm,
                                            int initial_level);
p4est_wrap_t       *p4est_wrap_new_cubed (sc_MPI_Comm mpicomm,
                                          int initial_level);
 
p4est_wrap_t       *p4est_wrap_new_disk (sc_MPI_Comm mpicomm, int px, int py,
                                         int initial_level);
 
p4est_wrap_t       *p4est_wrap_new_brick (sc_MPI_Comm mpicomm,
                                          int bx, int by, int px, int py,
                                          int initial_level);
 
p4est_wrap_t       *p4est_wrap_new_world (int initial_level);
void                p4est_wrap_destroy (p4est_wrap_t * pp);
 
void                p4est_wrap_set_hollow (p4est_wrap_t * pp, int hollow);
 
void                p4est_wrap_set_coarsen_delay (p4est_wrap_t * pp,
                                                  int coarsen_delay,
                                                  int coarsen_affect);
 
void                p4est_wrap_set_partitioning (p4est_wrap_t *pp,
                                                 int partition_for_coarsening);
 
p4est_ghost_t      *p4est_wrap_get_ghost (p4est_wrap_t * pp);
 
p4est_mesh_t       *p4est_wrap_get_mesh (p4est_wrap_t * pp);
 
void                p4est_wrap_mark_refine (p4est_wrap_t * pp,
                                            p4est_topidx_t which_tree,
                                            p4est_locidx_t which_quad);
 
void                p4est_wrap_mark_coarsen (p4est_wrap_t * pp,
                                             p4est_topidx_t which_tree,
                                             p4est_locidx_t which_quad);
 
int                 p4est_wrap_adapt (p4est_wrap_t * pp);
 
int                 p4est_wrap_partition (p4est_wrap_t * pp,
                                          int weight_exponent,
                                          p4est_locidx_t * unchanged_first,
                                          p4est_locidx_t * unchanged_length,
                                          p4est_locidx_t *
                                          unchanged_old_first);
 
void                p4est_wrap_complete (p4est_wrap_t * pp);
 
/*** ITERATOR OVER THE FOREST LEAVES ***/
 
typedef struct p4est_wrap_leaf
{
  p4est_wrap_t       *pp;             
  /* Information about the current quadrant */
  p4est_topidx_t      which_tree;     
  p4est_locidx_t      which_quad;     
  p4est_locidx_t      local_quad;     
  p4est_tree_t       *tree;           
  sc_array_t         *tquadrants;     
  p4est_quadrant_t   *quad;           
#if 0                           /* DEPRECATED -- anyone using them? */
  int                 level;
  double              lowerleft[3];
  double              upperright[3];
#endif
 
  /* Information about parallel neighbors */
  int                 is_mirror;      
  sc_array_t         *mirrors;        
  p4est_locidx_t      nm;             
  p4est_locidx_t      next_mirror_quadrant;     
}
p4est_wrap_leaf_t;
 
#define P4EST_LEAF_IS_FIRST_IN_TREE(wleaf) ((wleaf)->which_quad == 0)
 
/* Create an iterator over the local leaves in the forest.
 * Returns a newly allocated state containing the first leaf,
 * or NULL if the local partition of the tree is empty.
 * \param [in] pp   Legal p4est_wrap structure, hollow or not.
 * \param [in] track_mirrors    If true, \a pp must not be hollow and mirror
 *                              information from the ghost layer is stored.
 * \return          NULL if processor is empty, otherwise a leaf iterator for
 *                  subsequent use with \a p4est_wrap_leaf_next.
 */
p4est_wrap_leaf_t  *p4est_wrap_leaf_first (p4est_wrap_t * pp,
                                           int track_mirrors);
 
/* Move the forest leaf iterator forward.
 * \param [in,out] leaf     A non-NULL leaf iterator created by
 *                          \ref p4est_wrap_leaf_first.
 * \return          The state that was input with updated information for the
 *                  next leaf, or NULL and deallocates the input if called with
 *                  the last leaf on this processor.
 */
p4est_wrap_leaf_t  *p4est_wrap_leaf_next (p4est_wrap_leaf_t * leaf);
 
SC_EXTERN_C_END;
 
#endif /* !P4EST_WRAP_H */