t8_forest_private.h

Go to the documentation of this file.

/*
  This file is part of t8code.
  t8code is a C library to manage a collection (a forest) of multiple
  connected adaptive space-trees of general element classes in parallel.
 
  Copyright (C) 2015 the developers
 
  t8code 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.
 
  t8code 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 t8code; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/* TODO: begin documenting this file: make doxygen 2>&1 | grep t8_forest_private */
 
#ifndef T8_FOREST_PRIVATE_H
#define T8_FOREST_PRIVATE_H
 
#include <t8.h>
#include <t8_forest.h>
 
T8_EXTERN_C_BEGIN ();
 
/* TODO: document */
 
/* For each tree in a forest compute its first and last descendant */
void                t8_forest_compute_desc (t8_forest_t forest);
 
/* Create the elements on this process given a uniform partition
 * of the coarse mesh. */
void                t8_forest_populate (t8_forest_t forest);
 
t8_eclass_scheme_c *t8_forest_get_eclass_scheme_before_commit (t8_forest_t
                                                               forest,
                                                               t8_eclass_t
                                                               eclass);
 
void                t8_forest_compute_maxlevel (t8_forest_t forest);
 
int                 t8_forest_min_nonempty_level (t8_cmesh_t cmesh,
                                                  t8_scheme_cxx_t *scheme);
 
int                 t8_forest_first_tree_shared (t8_forest_t forest);
 
int                 t8_forest_last_tree_shared (t8_forest_t forest);
 
/* Allocate memory for trees and set their values as in from.
 * For each tree allocate enough element memory to fit the elements of from.
 * If copy_elements is true, copy the elements of from into the element memory.
 */
void                t8_forest_copy_trees (t8_forest_t forest,
                                          t8_forest_t from,
                                          int copy_elements);
 
t8_ctree_t          t8_forest_get_coarse_tree_ext (t8_forest_t forest,
                                                   t8_locidx_t ltreeid,
                                                   t8_locidx_t **face_neigh,
                                                   int8_t **ttf);
 
void                t8_forest_compute_elements_offset (t8_forest_t forest);
 
t8_element_t       *t8_forest_get_tree_element (t8_tree_t tree,
                                                t8_locidx_t elem_in_tree);
 
t8_element_array_t *t8_forest_get_tree_element_array (t8_forest_t forest,
                                                      t8_locidx_t ltreeid);
 
/* TODO: This finds the owner of the first descendant of element.
 *       We call this in owners_at_face where element is a descendant,
 *       add a flag that is true is element is a descendant, such that the
 *       first desc must not be created */
/* TODO: ext  version with parameters: lower_bound, upper_bound, is_desc/is_leaf
 *       is it really needed to construct the tree owners? Cant we just use the global
 *       offset array?
 */
int                 t8_forest_element_find_owner_old (t8_forest_t forest,
                                                      t8_gloidx_t gtreeid,
                                                      t8_element_t *element,
                                                      t8_eclass_t eclass,
                                                      sc_array_t
                                                      *all_owners_of_tree);
 
int                 t8_forest_element_find_owner (t8_forest_t forest,
                                                  t8_gloidx_t gtreeid,
                                                  t8_element_t *element,
                                                  t8_eclass_t eclass);
 
int                 t8_forest_element_find_owner_ext (t8_forest_t forest,
                                                      t8_gloidx_t gtreeid,
                                                      t8_element_t *element,
                                                      t8_eclass_t eclass,
                                                      int lower_bound,
                                                      int upper_bound,
                                                      int guess,
                                                      int element_is_desc);
 
int                 t8_forest_element_check_owner (t8_forest_t forest,
                                                   t8_element_t *element,
                                                   t8_gloidx_t gtreeid,
                                                   t8_eclass_t eclass,
                                                   int rank,
                                                   int element_is_desc);
 
void                t8_forest_element_owners_at_face (t8_forest_t forest,
                                                      t8_gloidx_t gtreeid,
                                                      const t8_element_t
                                                      *element,
                                                      t8_eclass_t eclass,
                                                      int face,
                                                      sc_array_t *owners);
 
void                t8_forest_element_owners_bounds (t8_forest_t forest,
                                                     t8_gloidx_t gtreeid,
                                                     const t8_element_t
                                                     *element,
                                                     t8_eclass_t eclass,
                                                     int *lower, int *upper);
 
void                t8_forest_element_owners_at_face_bounds (t8_forest_t
                                                             forest,
                                                             t8_gloidx_t
                                                             gtreeid,
                                                             const
                                                             t8_element_t
                                                             *element,
                                                             t8_eclass_t
                                                             eclass, int face,
                                                             int *lower,
                                                             int *upper);
 
void                t8_forest_element_owners_at_neigh_face (t8_forest_t
                                                            forest,
                                                            t8_locidx_t
                                                            ltreeid,
                                                            const t8_element_t
                                                            *element,
                                                            int face,
                                                            sc_array_t
                                                            *owners);
 
void                t8_forest_element_owners_at_neigh_face_bounds (t8_forest_t
                                                                   forest,
                                                                   t8_locidx_t
                                                                   ltreeid,
                                                                   const
                                                                   t8_element_t
                                                                   *element,
                                                                   int face,
                                                                   int *lower,
                                                                   int
                                                                   *upper);
 
t8_gloidx_t         t8_forest_element_half_face_neighbors (t8_forest_t forest,
                                                           t8_locidx_t
                                                           ltreeid,
                                                           const t8_element_t
                                                           *elem,
                                                           t8_element_t
                                                           *neighs[],
                                                           t8_eclass_scheme_c
                                                           *neigh_scheme,
                                                           int face,
                                                           int num_neighs,
                                                           int dual_faces[]);
 
void                t8_forest_print_all_leaf_neighbors (t8_forest_t forest);
 
int                 t8_forest_element_has_leaf_desc (t8_forest_t forest,
                                                     t8_gloidx_t gtreeid,
                                                     const t8_element_t
                                                     *element,
                                                     t8_eclass_scheme_c *ts);
 
T8_EXTERN_C_END ();
 
#endif /* !T8_FOREST_PRIVATE_H! */