Merge branch 'main' into clean_up_find_owner

Author: spenke91

example/CMakeLists.txt

@@ -59,6 +59,11 @@ function( add_t8_example )
     install( TARGETS ${ADD_T8_EXAMPLE_NAME} DESTINATION RUNTIME)
 endfunction()
 
+#copy example files to the exact same location in the builddir as they are in the source dir
+function( copy_example_file EXAMPLE_FILE_NAME_SUBPATH )
+    configure_file(${CMAKE_CURRENT_LIST_DIR}/${EXAMPLE_FILE_NAME_SUBPATH} ${CMAKE_CURRENT_BINARY_DIR}/${EXAMPLE_FILE_NAME_SUBPATH} COPYONLY)
+endfunction()
+
 add_t8_example( NAME t8_advection                       SOURCES advect/t8_advection.cxx )
 
 add_t8_example( NAME t8_cmesh_partition                 SOURCES cmesh/t8_cmesh_partition.cxx )
@@ -81,6 +86,8 @@ add_t8_example( NAME t8_time_tetgen                     SOURCES IO/cmesh/tetgen/
 add_t8_example( NAME t8_forest_tetgen                   SOURCES IO/cmesh/tetgen/t8_forest_from_tetgen.cxx )
 add_t8_example( NAME t8_read_triangle                   SOURCES IO/cmesh/triangle/t8_read_triangle_file.cxx )
 
+copy_example_file (IO/cmesh/gmsh/circlesquare_hybrid_hole.msh)
+
 if(T8CODE_ENABLE_VTK)
     add_t8_example( NAME t8_cmesh_read_from_vtk             SOURCES IO/cmesh/vtk/t8_cmesh_read_from_vtk.cxx )
 endif()

src/t8_cmesh/t8_cmesh_internal/t8_cmesh_commit.cxx

@@ -218,7 +218,7 @@ t8_cmesh_commit_partitioned_new (t8_cmesh_t cmesh, sc_MPI_Comm comm)
   sc_hash_t *ghost_ids;
   sc_mempool_t *ghost_facejoin_mempool;
   t8_ghost_facejoin_t *ghost_facejoin = NULL, *temp_facejoin, **facejoin_pp;
-  size_t joinfaces_it, iz;
+  size_t joinfaces_it;
   t8_gloidx_t id1, id2;
   t8_locidx_t temp_local_id = 0;
   t8_locidx_t num_hashes;
@@ -341,9 +341,9 @@ t8_cmesh_commit_partitioned_new (t8_cmesh_t cmesh, sc_MPI_Comm comm)
     /* Iterate through classes and add ghosts and trees */
     /* We need a temporary ghost_facejoin to check the hash for existing global ids */
     temp_facejoin->local_id = -10;
-    for (iz = 0; iz < cmesh->stash->classes.elem_count; iz++) {
+    for (size_t iclass = 0; iclass < cmesh->stash->classes.elem_count; iclass++) {
       /* get class and tree id */
-      classentry = (t8_stash_class_struct_t *) sc_array_index (&cmesh->stash->classes, iz);
+      classentry = (t8_stash_class_struct_t *) sc_array_index (&cmesh->stash->classes, iclass);
       temp_facejoin->ghost_id = classentry->id;
       if (cmesh->first_tree <= classentry->id && classentry->id <= last_tree) {
         /* initialize tree */
@@ -390,8 +390,8 @@ t8_cmesh_commit_partitioned_new (t8_cmesh_t cmesh, sc_MPI_Comm comm)
 
     /* Go through all face_neighbour entries and parse every
      * important entry */
-    for (iz = 0; iz < cmesh->stash->joinfaces.elem_count; iz++) {
-      joinface = (t8_stash_joinface_struct_t *) sc_array_index (&cmesh->stash->joinfaces, iz);
+    for (size_t ijoinface = 0; ijoinface < cmesh->stash->joinfaces.elem_count; ijoinface++) {
+      joinface = (t8_stash_joinface_struct_t *) sc_array_index (&cmesh->stash->joinfaces, ijoinface);
       id1 = joinface->id1;
       id2 = joinface->id2;
       id1_istree = cmesh->first_tree <= id1 && last_tree >= id1;

src/t8_cmesh/t8_cmesh_internal/t8_cmesh_copy.c

@@ -36,7 +36,7 @@
 void
 t8_cmesh_copy (t8_cmesh_t cmesh, const t8_cmesh_t cmesh_from, sc_MPI_Comm comm)
 {
-  size_t num_parts, iz;
+  size_t num_parts;
   t8_locidx_t first_tree, num_trees, first_ghost, num_ghosts;
 
   T8_ASSERT (t8_cmesh_is_initialized (cmesh));
@@ -83,10 +83,10 @@ t8_cmesh_copy (t8_cmesh_t cmesh, const t8_cmesh_t cmesh_from, sc_MPI_Comm comm)
     num_parts = t8_cmesh_trees_get_numproc (cmesh_from->trees);
     t8_cmesh_trees_init (&cmesh->trees, num_parts, cmesh_from->num_local_trees, cmesh_from->num_ghosts);
     t8_cmesh_trees_copy_toproc (cmesh->trees, cmesh_from->trees, cmesh_from->num_local_trees, cmesh_from->num_ghosts);
-    for (iz = 0; iz < num_parts; iz++) {
-      t8_cmesh_trees_get_part_data (cmesh_from->trees, iz, &first_tree, &num_trees, &first_ghost, &num_ghosts);
-      t8_cmesh_trees_start_part (cmesh->trees, iz, first_tree, num_trees, first_ghost, num_ghosts, 0);
-      t8_cmesh_trees_copy_part (cmesh->trees, iz, cmesh_from->trees, iz);
+    for (size_t ipart = 0; ipart < num_parts; ipart++) {
+      t8_cmesh_trees_get_part_data (cmesh_from->trees, ipart, &first_tree, &num_trees, &first_ghost, &num_ghosts);
+      t8_cmesh_trees_start_part (cmesh->trees, ipart, first_tree, num_trees, first_ghost, num_ghosts, 0);
+      t8_cmesh_trees_copy_part (cmesh->trees, ipart, cmesh_from->trees, ipart);
     }
   }
 }

src/t8_cmesh/t8_cmesh_internal/t8_cmesh_offset.c

@@ -381,7 +381,6 @@ t8_offset_nosend (const int proc, const int mpisize, const t8_gloidx_t *offset_f
 
     if ((first_not_send && num_trees == 2) || (!first_not_send && num_trees == 1)) {
       int temp_proc;
-      size_t iz;
       t8_gloidx_t last_tree = t8_offset_last (proc, offset_from);
       sc_array_t receivers;
       /* It could be that our last tree is not send either, this is the case
@@ -407,8 +406,8 @@ t8_offset_nosend (const int proc, const int mpisize, const t8_gloidx_t *offset_f
       /* Now we need to find out all process in the new partition that have last_tree
        * and check if any of them did not have it before. */
       t8_offset_all_owners_of_tree (mpisize, last_tree, offset_to, &receivers);
-      for (iz = 0; iz < receivers.elem_count; iz++) {
-        temp_proc = *(int *) sc_array_index (&receivers, iz);
+      for (size_t ireceiver = 0; ireceiver < receivers.elem_count; ireceiver++) {
+        temp_proc = *(int *) sc_array_index (&receivers, ireceiver);
         if (!t8_offset_in_range (last_tree, temp_proc, offset_from)) {
           /* We found at least one process that needs our last tree */
           sc_array_reset (&receivers);

src/t8_cmesh/t8_cmesh_internal/t8_cmesh_partition.cxx

@@ -656,9 +656,9 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
                               sc_array_t *send_as_ghost, const t8_locidx_t send_first, const t8_locidx_t send_last,
                               const size_t total_alloc, const int to_proc)
 {
-  t8_ctree_t tree, tree_cpy;
+  t8_ctree_t tree, tree_copy;
   int num_attributes;
-  size_t temp_offset_tree, temp_offset_att, iz, temp_offset, temp_offset_data, last_offset, last_num_att, last_size,
+  size_t temp_offset_tree, temp_offset_att, temp_offset, temp_offset_data, last_offset, last_num_att, last_size,
     temp_offset_ghost_att, temp_offset_ghost_data, temp_offset_ghost, ghost_attr_info_bytes_sofar;
   size_t ghost_att_size;
   //ssize_t             last_attribute_diff;
@@ -668,7 +668,7 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
   t8_locidx_t ghosts_left;
   t8_locidx_t *face_neighbor, ghost_id, itree;
   t8_gloidx_t *face_neighbor_g, *face_neighbor_gnew, new_neighbor;
-  t8_cghost_t ghost, ghost_cpy;
+  t8_cghost_t ghost, ghost_copy;
   int iface, iatt;
   int8_t *ttf_ghost, *ttf;
 
@@ -724,48 +724,48 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
   temp_offset_tree = 0;
 
   /* Set attribute offsets of trees and attribute data offsets of info objects */
-  tree_cpy = NULL;
+  tree_copy = NULL;
   last_num_att = 0;
   last_size = 0;
   last_offset = attr_info_bytes;
 
   for (itree = send_first; itree <= send_last; itree++) {
     /* Get the current tree */
-    tree_cpy = (t8_ctree_t) (send_buffer + temp_offset_tree);
+    tree_copy = (t8_ctree_t) (send_buffer + temp_offset_tree);
 
     /* new neighbor offset of tree */
-    tree_cpy->neigh_offset = temp_offset - temp_offset_tree;
+    tree_copy->neigh_offset = temp_offset - temp_offset_tree;
 
     /* Set new face neighbor entries, since we store local ids we have to adapt
      * to the local ids of the new process */
-    face_neighbor = (t8_locidx_t *) T8_TREE_FACE (tree_cpy);
-    for (iface = 0; iface < t8_eclass_num_faces[tree_cpy->eclass]; iface++) {
+    face_neighbor = (t8_locidx_t *) T8_TREE_FACE (tree_copy);
+    for (iface = 0; iface < t8_eclass_num_faces[tree_copy->eclass]; iface++) {
       t8_cmesh_partition_send_change_neighbor (cmesh, (t8_cmesh_t) cmesh_from, face_neighbor + iface, to_proc);
     }
 
     /* compute neighbor offset for next tree */
-    temp_offset += t8_eclass_num_faces[tree_cpy->eclass] * (sizeof (t8_locidx_t) + sizeof (int8_t))
-                   + T8_ADD_PADDING (t8_eclass_num_faces[tree_cpy->eclass] * (sizeof (t8_locidx_t) + sizeof (int8_t)));
+    temp_offset += t8_eclass_num_faces[tree_copy->eclass] * (sizeof (t8_locidx_t) + sizeof (int8_t))
+                   + T8_ADD_PADDING (t8_eclass_num_faces[tree_copy->eclass] * (sizeof (t8_locidx_t) + sizeof (int8_t)));
 
     /* new attribute offset for tree */
-    tree_cpy->att_offset = temp_offset_att - temp_offset_tree;
-    if (tree_cpy->num_attributes > 0) {
-      attr_info = T8_TREE_ATTR_INFO (tree_cpy, 0);
+    tree_copy->att_offset = temp_offset_att - temp_offset_tree;
+    if (tree_copy->num_attributes > 0) {
+      attr_info = T8_TREE_ATTR_INFO (tree_copy, 0);
       attr_info->attribute_offset = last_offset + last_size - last_num_att * sizeof (t8_attribute_info_struct_t);
       last_offset = attr_info->attribute_offset;
       last_size = attr_info->attribute_size;
 
       /* set new attribute data offsets */
-      for (iz = 1; iz < (size_t) tree_cpy->num_attributes; iz++) {
+      for (size_t iattribute = 1; iattribute < (size_t) tree_copy->num_attributes; iattribute++) {
         attr_info++;
         attr_info->attribute_offset = last_offset + last_size;
         last_offset = attr_info->attribute_offset;
         last_size = attr_info->attribute_size;
       }
-      temp_offset_att += tree_cpy->num_attributes * sizeof (t8_attribute_info_struct_t);
+      temp_offset_att += tree_copy->num_attributes * sizeof (t8_attribute_info_struct_t);
     }
     temp_offset_tree += sizeof (t8_ctree_struct_t);
-    last_num_att = tree_cpy->num_attributes;
+    last_num_att = tree_copy->num_attributes;
   }
 
   /* Copy all ghosts and set their face entries and offsets */
@@ -780,27 +780,28 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
   temp_offset_ghost_data = 0;
   /* number of bytes of attribute_infos that we already counted */
   ghost_attr_info_bytes_sofar = 0;
-  for (iz = 0; iz < send_as_ghost->elem_count; iz++) {
-    ghost_id = *((t8_locidx_t *) sc_array_index (send_as_ghost, iz));
-    ghost_cpy = (t8_cghost_t) (send_buffer + num_trees * sizeof (t8_ctree_struct_t) + iz * sizeof (t8_cghost_struct_t));
+  for (size_t isendghost = 0; isendghost < send_as_ghost->elem_count; isendghost++) {
+    ghost_id = *((t8_locidx_t *) sc_array_index (send_as_ghost, isendghost));
+    ghost_copy
+      = (t8_cghost_t) (send_buffer + num_trees * sizeof (t8_ctree_struct_t) + isendghost * sizeof (t8_cghost_struct_t));
     /* Get the correct element class from the ghost_id.
      * For this we have to check whether ghost_id points to a local tree or ghost */
-    ghost_cpy->eclass = ghost_id < cmesh_from->num_local_trees
-                          ? t8_cmesh_get_tree_class ((t8_cmesh_t) cmesh_from, ghost_id)
-                          : t8_cmesh_get_ghost_class ((t8_cmesh_t) cmesh_from, ghost_id - cmesh_from->num_local_trees);
-    ghost_cpy->neigh_offset = temp_offset - temp_offset_ghost; /* New face neighbor offset */
-    face_neighbor_gnew = (t8_gloidx_t *) T8_GHOST_FACE (ghost_cpy);
-    ttf_ghost = T8_GHOST_TTF (ghost_cpy);
+    ghost_copy->eclass = ghost_id < cmesh_from->num_local_trees
+                           ? t8_cmesh_get_tree_class ((t8_cmesh_t) cmesh_from, ghost_id)
+                           : t8_cmesh_get_ghost_class ((t8_cmesh_t) cmesh_from, ghost_id - cmesh_from->num_local_trees);
+    ghost_copy->neigh_offset = temp_offset - temp_offset_ghost; /* New face neighbor offset */
+    face_neighbor_gnew = (t8_gloidx_t *) T8_GHOST_FACE (ghost_copy);
+    ttf_ghost = T8_GHOST_TTF (ghost_copy);
     if (ghost_id >= cmesh_from->num_local_trees) {
       /* The ghost that we send was a local ghost */
       ghost = t8_cmesh_trees_get_ghost_ext (cmesh_from->trees, ghost_id - cmesh_from->num_local_trees, &face_neighbor_g,
                                             &ttf);
       tree = NULL;
       /* Set entries of the new ghost */
-      ghost_cpy->eclass = ghost->eclass;
-      ghost_cpy->treeid = ghost->treeid;
-      ghost_cpy->num_attributes = ghost->num_attributes;
-      num_attributes = ghost_cpy->num_attributes;
+      ghost_copy->eclass = ghost->eclass;
+      ghost_copy->treeid = ghost->treeid;
+      ghost_copy->num_attributes = ghost->num_attributes;
+      num_attributes = ghost_copy->num_attributes;
       if (num_attributes > 0) {
         /* get a pointer to the first att_info and the first attribute */
         attr_info = T8_GHOST_ATTR_INFO (ghost, 0);
@@ -814,7 +815,7 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
       }
       /* Copy face_neighbor entries and ttf entries */
       memcpy (face_neighbor_gnew, face_neighbor_g,
-              t8_eclass_num_faces[ghost_cpy->eclass] * (sizeof (t8_gloidx_t) + sizeof (int8_t)));
+              t8_eclass_num_faces[ghost_copy->eclass] * (sizeof (t8_gloidx_t) + sizeof (int8_t)));
     }
     else {
       /* The ghost we send was a local tree */
@@ -823,10 +824,10 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
       ghost = NULL;
       T8_ASSERT (ghost_id == tree->treeid);
       /* Set entries of the new ghost */
-      ghost_cpy->eclass = tree->eclass;
-      ghost_cpy->treeid = ghost_id + cmesh_from->first_tree;
-      ghost_cpy->num_attributes = tree->num_attributes;
-      num_attributes = ghost_cpy->num_attributes;
+      ghost_copy->eclass = tree->eclass;
+      ghost_copy->treeid = ghost_id + cmesh_from->first_tree;
+      ghost_copy->num_attributes = tree->num_attributes;
+      num_attributes = ghost_copy->num_attributes;
       if (num_attributes > 0) {
         /* get a pointer to the first att_info and the first attribute */
         attr_info = T8_TREE_ATTR_INFO (tree, 0);
@@ -840,7 +841,7 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
       }
       /* copy face_neighbor entries, since the ones on the tree are local and
        * we need global, we have to compute each one */
-      for (iface = 0; iface < t8_eclass_num_faces[ghost_cpy->eclass]; iface++) {
+      for (iface = 0; iface < t8_eclass_num_faces[ghost_copy->eclass]; iface++) {
         if (face_neighbor[iface] < 0) {
           /* TODO: think about this */
           new_neighbor = -1; /* boundary indicator */
@@ -852,28 +853,28 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
         face_neighbor_gnew[iface] = new_neighbor;
       }
       /* Copy tree_to_face entries */
-      memcpy (ttf_ghost, ttf, t8_eclass_num_faces[ghost_cpy->eclass] * sizeof (int8_t));
+      memcpy (ttf_ghost, ttf, t8_eclass_num_faces[ghost_copy->eclass] * sizeof (int8_t));
     } /* Done distinction between from tree and from ghost */
 
     /* Compute and store new attribute offset of this ghost */
-    ghosts_left = send_as_ghost->elem_count - iz;
-    ghost_cpy->att_offset = ghosts_left * sizeof (t8_cghost_struct_t) + ghost_neighbor_bytes + tree_neighbor_bytes
-                            + attr_info_bytes + tree_attribute_bytes + temp_offset_ghost_att;
+    ghosts_left = send_as_ghost->elem_count - isendghost;
+    ghost_copy->att_offset = ghosts_left * sizeof (t8_cghost_struct_t) + ghost_neighbor_bytes + tree_neighbor_bytes
+                             + attr_info_bytes + tree_attribute_bytes + temp_offset_ghost_att;
     if (num_attributes > 0) {
       size_t this_ghosts_att_info_size;
       t8_attribute_info_struct_t *first_attr_info;
 
       /* The byte count of this ghosts attribute info structs */
       this_ghosts_att_info_size = num_attributes * sizeof (t8_attribute_info_struct_t);
       /* Copy all attribute info data of this ghost */
-      first_attr_info = (t8_attribute_info_struct_t *) T8_GHOST_FIRST_ATT_INFO (ghost_cpy);
+      first_attr_info = (t8_attribute_info_struct_t *) T8_GHOST_FIRST_ATT_INFO (ghost_copy);
       memcpy (first_attr_info, attr_info, this_ghosts_att_info_size);
       temp_offset_ghost_att += this_ghosts_att_info_size;
 
       /* Compute all new attribute data offsets */
       for (iatt = 0; iatt < num_attributes; iatt++) {
         /* Get the current attribute info */
-        attr_info = T8_GHOST_ATTR_INFO (ghost_cpy, iatt);
+        attr_info = T8_GHOST_ATTR_INFO (ghost_copy, iatt);
         /* The new attribute offset is the offset from the first att_info to the data.
          * Thus, the count of the bytes occupied by the att_info (ghosts_attr_info_bytes)
          * plus the count of all attributes before this attribute (this_data_temp_offset).*/
@@ -883,11 +884,11 @@ t8_cmesh_partition_copy_data (char *send_buffer, t8_cmesh_t cmesh, const t8_cmes
       }
       ghost_attr_info_bytes_sofar += num_attributes * sizeof (t8_attribute_info_struct_t);
       /* Copy all attribute data of this ghost */
-      memcpy (T8_GHOST_ATTR (ghost_cpy, first_attr_info), first_attribute, ghost_att_size);
+      memcpy (T8_GHOST_ATTR (ghost_copy, first_attr_info), first_attribute, ghost_att_size);
     } /* end num_attributes > 0 */
     /* compute new offsets */
-    temp_offset += t8_eclass_num_faces[ghost_cpy->eclass] * (sizeof (t8_gloidx_t) + sizeof (int8_t)) /* offset */
-                   + T8_ADD_PADDING (t8_eclass_num_faces[ghost_cpy->eclass]
+    temp_offset += t8_eclass_num_faces[ghost_copy->eclass] * (sizeof (t8_gloidx_t) + sizeof (int8_t)) /* offset */
+                   + T8_ADD_PADDING (t8_eclass_num_faces[ghost_copy->eclass]
                                      * (sizeof (t8_gloidx_t) + sizeof (int8_t))); /* padding */
     temp_offset_ghost += sizeof (t8_cghost_struct_t);
   }

src/t8_vtk.c

@@ -29,7 +29,7 @@ int
 t8_write_pvtu (const char *filename, int num_procs, int write_tree, int write_rank, int write_level, int write_id,
                int num_data, t8_vtk_data_field_t *data)
 {
-  char pvtufilename[BUFSIZ], filename_cpy[BUFSIZ];
+  char pvtufilename[BUFSIZ], filename_copy[BUFSIZ];
   FILE *pvtufile;
   int p, idata, num_scalars = 0;
   int write_cell_data, wrote_cell_data = 0;
@@ -244,15 +244,15 @@ t8_write_pvtu (const char *filename, int num_procs, int write_tree, int write_ra
     fprintf (pvtufile, "    </PCellData>\n");
   }
 
-  sreturn = snprintf (filename_cpy, BUFSIZ, "%s", filename);
+  sreturn = snprintf (filename_copy, BUFSIZ, "%s", filename);
   if (sreturn >= BUFSIZ) {
     /* The Filename was truncated */
     /* Note: gcc >= 7.1 prints a warning if we 
      * do not check the return value of snprintf. */
-    t8_debugf ("Warning: Truncated vtk file name cpy to '%s'\n", filename_cpy);
+    t8_debugf ("Warning: Truncated vtk file name copy to '%s'\n", filename_copy);
   }
   for (p = 0; p < num_procs; ++p) {
-    fprintf (pvtufile, "    <Piece Source=\"%s_%04d.vtu\"/>\n", basename (filename_cpy), p);
+    fprintf (pvtufile, "    <Piece Source=\"%s_%04d.vtu\"/>\n", basename (filename_copy), p);
   }
   fprintf (pvtufile, "  </PUnstructuredGrid>\n");
   fprintf (pvtufile, "</VTKFile>\n");

test/t8_gtest_custom_assertion.hxx

@@ -112,8 +112,8 @@ dimensional_equality (const char *Dimensional_1_expr, const char *Dimensional_2_
  *
  * \param[in] forest_A_expr The name of the forest \a forest_A
  * \param[in] forest_B_expr The name of the forest \a forest_B
- * \param[in] forest_A      The forest to ompare with \a forest_B
- * \param[in] forest_B      The forest to ompare with \a forest_A
+ * \param[in] forest_A      The forest to compare with \a forest_B
+ * \param[in] forest_B      The forest to compare with \a forest_A
  * \return testing::AssertionResult
  */
 testing::AssertionResult