p8est_extended.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.
*/
 
/********************************************************************
 *                          IMPORTANT NOTE                          *
 *                                                                  *
 * These interfaces are intended for those who like finer control.  *
 * The API offers extended versions of some basic p4est functions.  *
 * The API may change without notice.                               *
 ********************************************************************/
 
#ifndef P8EST_EXTENDED_H
#define P8EST_EXTENDED_H
 
#include <sc_uint128.h>
#include <p8est_mesh.h>
#include <p8est_iterate.h>
#include <p8est_lnodes.h>
#include <p8est_io.h>
 
SC_EXTERN_C_BEGIN;
 
typedef sc_uint128_t p8est_lid_t;
 
/* Data pertaining to selecting, inspecting, and profiling algorithms.
 * A pointer to this structure is hooked into the p8est main structure.
 *
 * TODO: Describe the purpose of various switches, counters, and timings.
 *
 * The balance_ranges and balance_notify* times are collected
 * whenever an inspect structure is present in p8est.
 */
struct p8est_inspect
{
  int                 use_balance_ranges;
  int                 use_balance_ranges_notify;
  int                 use_balance_verify;
  int                 balance_max_ranges;
  size_t              balance_A_count_in;
  size_t              balance_A_count_out;
  size_t              balance_comm_sent;
  size_t              balance_comm_nzpeers;
  size_t              balance_B_count_in;
  size_t              balance_B_count_out;
  size_t              balance_zero_sends[2], balance_zero_receives[2];
  double              balance_A;
  double              balance_comm;
  double              balance_B;
  double              balance_ranges;   
  double              balance_notify;   
  double              balance_notify_allgather;
  int                 use_B;
};
 
typedef void        (*p8est_replace_t) (p8est_t * p8est,
                                        p4est_topidx_t which_tree,
                                        int num_outgoing,
                                        p8est_quadrant_t * outgoing[],
                                        int num_incoming,
                                        p8est_quadrant_t * incoming[]);
 
int                 p8est_lid_compare (const p8est_lid_t * a,
                                       const p8est_lid_t * b);
 
int                 p8est_lid_is_equal (const p8est_lid_t * a,
                                        const p8est_lid_t * b);
 
void                p8est_lid_init (p8est_lid_t * input, uint64_t high,
                                    uint64_t low);
 
void                p8est_lid_set_zero (p8est_lid_t * input);
 
void                p8est_lid_set_one (p8est_lid_t * input);
 
void                p8est_lid_set_uint64 (p8est_lid_t * input, uint64_t u);
 
int                 p8est_lid_chk_bit (const p8est_lid_t * input,
                                       int bit_number);
 
void                p8est_lid_set_bit (p8est_lid_t * input, int bit_number);
 
void                p8est_lid_copy (const p8est_lid_t * input,
                                    p8est_lid_t * output);
 
void                p8est_lid_add (const p8est_lid_t * a,
                                   const p8est_lid_t * b,
                                   p8est_lid_t * result);
 
void                p8est_lid_sub (const p8est_lid_t * a,
                                   const p8est_lid_t * b,
                                   p8est_lid_t * result);
 
void                p8est_lid_bitwise_neg (const p8est_lid_t * a,
                                           p8est_lid_t * result);
 
void                p8est_lid_bitwise_or (const p8est_lid_t * a,
                                          const p8est_lid_t * b,
                                          p8est_lid_t * result);
 
void                p8est_lid_bitwise_and (const p8est_lid_t * a,
                                           const p8est_lid_t * b,
                                           p8est_lid_t * result);
 
void                p8est_lid_shift_right (const p8est_lid_t * input,
                                           unsigned shift_count,
                                           p8est_lid_t * result);
 
void                p8est_lid_shift_left (const p8est_lid_t * input,
                                          unsigned shift_count,
                                          p8est_lid_t * result);
 
void                p8est_lid_add_inplace (p8est_lid_t * a,
                                           const p8est_lid_t * b);
 
void                p8est_lid_sub_inplace (p8est_lid_t * a,
                                           const p8est_lid_t * b);
 
void                p8est_lid_bitwise_or_inplace (p8est_lid_t * a,
                                                  const p8est_lid_t * b);
 
void                p8est_lid_bitwise_and_inplace (p8est_lid_t * a,
                                                   const p8est_lid_t * b);
void                p8est_quadrant_linear_id_ext128 (const p8est_quadrant_t *
                                                     quadrant, int level,
                                                     p8est_lid_t * id);
 
void                p8est_quadrant_set_morton_ext128 (p8est_quadrant_t *
                                                      quadrant, int level,
                                                      const p8est_lid_t * id);
 
p8est_t            *p8est_new_ext (sc_MPI_Comm mpicomm,
                                   p8est_connectivity_t * connectivity,
                                   p4est_locidx_t min_quadrants,
                                   int min_level, int fill_uniform,
                                   size_t data_size, p8est_init_t init_fn,
                                   void *user_pointer);
 
p8est_mesh_t       *p8est_mesh_new_ext (p8est_t * p8est,
                                        p8est_ghost_t * ghost,
                                        int compute_tree_index,
                                        int compute_level_lists,
                                        p8est_connect_type_t btype);
 
p8est_t            *p8est_copy_ext (p8est_t * input, int copy_data,
                                    int duplicate_mpicomm);
 
void                p8est_refine_ext (p8est_t * p8est,
                                      int refine_recursive, int maxlevel,
                                      p8est_refine_t refine_fn,
                                      p8est_init_t init_fn,
                                      p8est_replace_t replace_fn);
 
void                p8est_coarsen_ext (p8est_t * p8est, int coarsen_recursive,
                                       int callback_orphans,
                                       p8est_coarsen_t coarsen_fn,
                                       p8est_init_t init_fn,
                                       p8est_replace_t replace_fn);
 
void                p8est_balance_ext (p8est_t * p8est,
                                       p8est_connect_type_t btype,
                                       p8est_init_t init_fn,
                                       p8est_replace_t replace_fn);
 
void                p8est_balance_subtree_ext (p8est_t * p8est,
                                               p8est_connect_type_t btype,
                                               p4est_topidx_t which_tree,
                                               p8est_init_t init_fn,
                                               p8est_replace_t replace_fn);
 
p4est_gloidx_t      p8est_partition_ext (p8est_t * p8est,
                                         int partition_for_coarsening,
                                         p8est_weight_t weight_fn);
 
p4est_gloidx_t      p8est_partition_for_coarsening (p8est_t * p8est,
                                                    p4est_locidx_t *
                                                    num_quadrants_in_proc);
 
void                p8est_iterate_ext (p8est_t * p8est,
                                       p8est_ghost_t * ghost_layer,
                                       void *user_data,
                                       p8est_iter_volume_t iter_volume,
                                       p8est_iter_face_t iter_face,
                                       p8est_iter_edge_t iter_edge,
                                       p8est_iter_corner_t iter_corner,
                                       int remote);
 
void                p8est_save_ext (const char *filename, p8est_t * p8est,
                                    int save_data, int save_partition);
 
p8est_t            *p8est_load_ext (const char *filename, sc_MPI_Comm mpicomm,
                                    size_t data_size, int load_data,
                                    int autopartition, int broadcasthead,
                                    void *user_pointer,
                                    p8est_connectivity_t ** connectivity);
 
p8est_t            *p8est_source_ext (sc_io_source_t * src,
                                      sc_MPI_Comm mpicomm, size_t data_size,
                                      int load_data, int autopartition,
                                      int broadcasthead, void *user_pointer,
                                      p8est_connectivity_t ** connectivity);
 
#ifdef P4EST_ENABLE_FILE_DEPRECATED
 
p8est_file_context_t *p8est_file_open_read_ext (sc_MPI_Comm mpicomm,
                                                const char *filename,
                                                char *user_string,
                                                p4est_gloidx_t *
                                                global_num_quadrants,
                                                int *errcode);
 
p8est_file_context_t *p8est_file_read_field_ext (p8est_file_context_t * fc,
                                                 p4est_gloidx_t * gfq,
                                                 size_t quadrant_size,
                                                 sc_array_t * quadrant_data,
                                                 char *user_string,
                                                 int *errcode);
 
#endif /* P4EST_ENABLE_FILE_DEPRECATED */
 
void                p8est_get_plex_data_ext (p8est_t * p8est,
                                             p8est_ghost_t ** ghost,
                                             p8est_lnodes_t ** lnodes,
                                             p8est_connect_type_t ctype,
                                             int overlap,
                                             p4est_locidx_t *
                                             first_local_quad,
                                             sc_array_t * out_points_per_dim,
                                             sc_array_t * out_cone_sizes,
                                             sc_array_t * out_cones,
                                             sc_array_t *
                                             out_cone_orientations,
                                             sc_array_t * out_vertex_coords,
                                             sc_array_t * out_children,
                                             sc_array_t * out_parents,
                                             sc_array_t * out_childids,
                                             sc_array_t * out_leaves,
                                             sc_array_t * out_remotes,
                                             int custom_numbering);
 
SC_EXTERN_C_END;
 
#endif /* !P8EST_EXTENDED_H */