p4est_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 P4EST_EXTENDED_H
#define P4EST_EXTENDED_H
 
#include <p4est_mesh.h>
#include <p4est_iterate.h>
#include <p4est_lnodes.h>
#include <p4est_io.h>
 
SC_EXTERN_C_BEGIN;
 
typedef uint64_t    p4est_lid_t;
 
/* TODO: Describe the purpose of various switches, counters, and timings. */
struct p4est_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        (*p4est_replace_t) (p4est_t * p4est,
                                        p4est_topidx_t which_tree,
                                        int num_outgoing,
                                        p4est_quadrant_t * outgoing[],
                                        int num_incoming,
                                        p4est_quadrant_t * incoming[]);
 
int                 p4est_lid_compare (const p4est_lid_t * a,
                                       const p4est_lid_t * b);
 
int                 p4est_lid_is_equal (const p4est_lid_t * a,
                                        const p4est_lid_t * b);
 
void                p4est_lid_init (p4est_lid_t * input, uint64_t high,
                                    uint64_t low);
 
void                p4est_lid_set_zero (p4est_lid_t * input);
 
void                p4est_lid_set_one (p4est_lid_t * input);
 
void                p4est_lid_set_uint64 (p4est_lid_t * input, uint64_t u);
 
int                 p4est_lid_chk_bit (const p4est_lid_t * input,
                                       int bit_number);
 
void                p4est_lid_set_bit (p4est_lid_t * input, int bit_number);
 
void                p4est_lid_copy (const p4est_lid_t * input,
                                    p4est_lid_t * output);
 
void                p4est_lid_add (const p4est_lid_t * a,
                                   const p4est_lid_t * b,
                                   p4est_lid_t * result);
 
void                p4est_lid_sub (const p4est_lid_t * a,
                                   const p4est_lid_t * b,
                                   p4est_lid_t * result);
 
void                p4est_lid_bitwise_neg (const p4est_lid_t * a,
                                           p4est_lid_t * result);
 
void                p4est_lid_bitwise_or (const p4est_lid_t * a,
                                          const p4est_lid_t * b,
                                          p4est_lid_t * result);
 
void                p4est_lid_bitwise_and (const p4est_lid_t * a,
                                           const p4est_lid_t * b,
                                           p4est_lid_t * result);
 
void                p4est_lid_shift_right (const p4est_lid_t * input,
                                           unsigned shift_count,
                                           p4est_lid_t * result);
 
void                p4est_lid_shift_left (const p4est_lid_t * input,
                                          unsigned shift_count,
                                          p4est_lid_t * result);
 
void                p4est_lid_add_inplace (p4est_lid_t * a,
                                           const p4est_lid_t * b);
 
void                p4est_lid_sub_inplace (p4est_lid_t * a,
                                           const p4est_lid_t * b);
 
void                p4est_lid_bitwise_or_inplace (p4est_lid_t * a,
                                                  const p4est_lid_t * b);
 
void                p4est_lid_bitwise_and_inplace (p4est_lid_t * a,
                                                   const p4est_lid_t * b);
 
void                p4est_quadrant_linear_id_ext128 (const p4est_quadrant_t *
                                                     quadrant, int level,
                                                     p4est_lid_t * id);
 
void                p4est_quadrant_set_morton_ext128 (p4est_quadrant_t *
                                                      quadrant, int level,
                                                      const p4est_lid_t * id);
 
p4est_t            *p4est_new_ext (sc_MPI_Comm mpicomm,
                                   p4est_connectivity_t * connectivity,
                                   p4est_locidx_t min_quadrants,
                                   int min_level, int fill_uniform,
                                   size_t data_size, p4est_init_t init_fn,
                                   void *user_pointer);
 
p4est_mesh_t       *p4est_mesh_new_ext (p4est_t * p4est,
                                        p4est_ghost_t * ghost,
                                        int compute_tree_index,
                                        int compute_level_lists,
                                        p4est_connect_type_t btype);
 
p4est_t            *p4est_copy_ext (p4est_t * input, int copy_data,
                                    int duplicate_mpicomm);
 
void                p4est_refine_ext (p4est_t * p4est,
                                      int refine_recursive, int maxlevel,
                                      p4est_refine_t refine_fn,
                                      p4est_init_t init_fn,
                                      p4est_replace_t replace_fn);
 
void                p4est_coarsen_ext (p4est_t * p4est, int coarsen_recursive,
                                       int callback_orphans,
                                       p4est_coarsen_t coarsen_fn,
                                       p4est_init_t init_fn,
                                       p4est_replace_t replace_fn);
 
void                p4est_balance_ext (p4est_t * p4est,
                                       p4est_connect_type_t btype,
                                       p4est_init_t init_fn,
                                       p4est_replace_t replace_fn);
 
void                p4est_balance_subtree_ext (p4est_t * p4est,
                                               p4est_connect_type_t btype,
                                               p4est_topidx_t which_tree,
                                               p4est_init_t init_fn,
                                               p4est_replace_t replace_fn);
 
p4est_gloidx_t      p4est_partition_ext (p4est_t * p4est,
                                         int partition_for_coarsening,
                                         p4est_weight_t weight_fn);
 
p4est_gloidx_t      p4est_partition_for_coarsening (p4est_t * p4est,
                                                    p4est_locidx_t *
                                                    num_quadrants_in_proc);
 
void                p4est_iterate_ext (p4est_t * p4est,
                                       p4est_ghost_t * ghost_layer,
                                       void *user_data,
                                       p4est_iter_volume_t iter_volume,
                                       p4est_iter_face_t iter_face,
                                       p4est_iter_corner_t iter_corner,
                                       int remote);
 
void                p4est_save_ext (const char *filename, p4est_t * p4est,
                                    int save_data, int save_partition);
 
p4est_t            *p4est_load_ext (const char *filename, sc_MPI_Comm mpicomm,
                                    size_t data_size, int load_data,
                                    int autopartition, int broadcasthead,
                                    void *user_pointer,
                                    p4est_connectivity_t ** connectivity);
 
p4est_t            *p4est_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,
                                      p4est_connectivity_t ** connectivity);
 
#ifdef P4EST_ENABLE_FILE_DEPRECATED
 
p4est_file_context_t *p4est_file_open_read_ext (sc_MPI_Comm mpicomm,
                                                const char *filename,
                                                char *user_string,
                                                p4est_gloidx_t *
                                                global_num_quadrants,
                                                int *errcode);
 
p4est_file_context_t *p4est_file_read_field_ext (p4est_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                p4est_get_plex_data_ext (p4est_t * p4est,
                                             p4est_ghost_t ** ghost,
                                             p4est_lnodes_t ** lnodes,
                                             p4est_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 /* !P4EST_EXTENDED_H */