p4est_algorithms.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_ALGORITHMS_H
#define P4EST_ALGORITHMS_H
 
#include <p4est_extended.h>
 
SC_EXTERN_C_BEGIN;
 
sc_mempool_t       *p4est_quadrant_mempool_new (void);
 
void                p4est_quadrant_init_data (p4est_t * p4est,
                                              p4est_topidx_t which_tree,
                                              p4est_quadrant_t * quad,
                                              p4est_init_t init_fn);
 
void                p4est_quadrant_free_data (p4est_t * p4est,
                                              p4est_quadrant_t * quad);
 
unsigned            p4est_quadrant_checksum (sc_array_t * quadrants,
                                             sc_array_t * checkarray,
                                             size_t first_quadrant);
 
int                 p4est_quadrant_in_range (const p4est_quadrant_t * fd,
                                             const p4est_quadrant_t * ld,
                                             const p4est_quadrant_t *
                                             quadrant);
 
int                 p4est_tree_is_sorted (p4est_tree_t * tree);
 
int                 p4est_tree_is_linear (p4est_tree_t * tree);
 
int                 p4est_tree_is_complete (p4est_tree_t * tree);
 
int                 p4est_tree_is_almost_sorted (p4est_tree_t * tree,
                                                 int check_linearity);
 
void                p4est_tree_print (int log_priority, p4est_tree_t * tree);
 
int                 p4est_is_equal (p4est_t * p4est1, p4est_t * p4est2,
                                    int compare_data);
 
int                 p4est_is_valid (p4est_t * p4est);
 
void                p4est_tree_compute_overlap (p4est_t * p4est,
                                                sc_array_t * in,
                                                sc_array_t * out,
                                                p4est_connect_type_t balance,
                                                sc_array_t * borders,
                                                sc_array_t * inseeds);
 
void                p4est_tree_uniqify_overlap (sc_array_t * out);
 
size_t              p4est_tree_remove_nonowned (p4est_t * p4est,
                                                p4est_topidx_t which_tree);
 
void                p4est_complete_region (p4est_t * p4est,
                                           const p4est_quadrant_t * q1,
                                           int include_q1,
                                           const p4est_quadrant_t * q2,
                                           int include_q2,
                                           p4est_tree_t * tree,
                                           p4est_topidx_t which_tree,
                                           p4est_init_t init_fn);
 
void                p4est_complete_subtree (p4est_t * p4est,
                                            p4est_topidx_t which_tree,
                                            p4est_init_t init_fn);
 
void                p4est_balance_subtree (p4est_t * p4est,
                                           p4est_connect_type_t btype,
                                           p4est_topidx_t which_tree,
                                           p4est_init_t init_fn);
 
void                p4est_balance_border (p4est_t * p4est,
                                          p4est_connect_type_t btype,
                                          p4est_topidx_t which_tree,
                                          p4est_init_t init_fn,
                                          p4est_replace_t replace_fn,
                                          sc_array_t * borders);
 
size_t              p4est_linearize_tree (p4est_t * p4est,
                                          p4est_tree_t * tree);
 
p4est_locidx_t      p4est_partition_correction (p4est_gloidx_t *
                                                partition,
                                                int num_procs,
                                                int rank,
                                                p4est_gloidx_t
                                                min_quadrant_id,
                                                p4est_gloidx_t
                                                max_quadrant_id);
 
p4est_gloidx_t      p4est_partition_for_coarsening (p4est_t * p4est,
                                                    p4est_locidx_t *
                                                    num_quadrants_in_proc);
 
int                 p4est_next_nonempty_process (int rank,
                                                 int num_procs,
                                                 p4est_locidx_t *
                                                 num_quadrants_in_proc);
 
p4est_gloidx_t      p4est_partition_given (p4est_t * p4est,
                                           const p4est_locidx_t *
                                           num_quadrants_in_proc);
 
int                 p4est_quadrant_on_face_boundary (p4est_t * p4est,
                                                     p4est_topidx_t treeid,
                                                     int face,
                                                     const p4est_quadrant_t *
                                                     q);
 
SC_EXTERN_C_END;
 
#endif /* !P4EST_ALGORITHMS_H */