From: Robin Görmer Date: Tue, 27 Aug 2024 08:17:34 +0000 (+0200) Subject: Extended documentation of CellAccesor::neighbor() to include anisotropic refinements... X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=refs%2Fpull%2F17614%2Fhead;p=dealii.git Extended documentation of CellAccesor::neighbor() to include anisotropic refinements as well. Modified the example accordingly. --- diff --git a/doc/doxygen/images/limit_level_difference_at_vertices_anisotropic.png b/doc/doxygen/images/limit_level_difference_at_vertices_anisotropic.png new file mode 100644 index 0000000000..be06141eaf Binary files /dev/null and b/doc/doxygen/images/limit_level_difference_at_vertices_anisotropic.png differ diff --git a/include/deal.II/grid/tria_accessor.h b/include/deal.II/grid/tria_accessor.h index d81e961d8d..80699efb0c 100644 --- a/include/deal.II/grid/tria_accessor.h +++ b/include/deal.II/grid/tria_accessor.h @@ -3302,25 +3302,48 @@ public: * Return an iterator to the neighboring cell on the other side of the face * with number @p face_no. If the neighbor does not exist, * i.e., if the face with number @p face_no of the current object is at the boundary, then - * an invalid iterator is returned. + * an invalid iterator is returned. In detail, the smallest cell `neighbor` + * for which `cell->face(face_no)` is a subset of + * `neighbor->face(opposite_face_no)`, where `opposite_face_no` is the face + * number opposite to `face_no`. * * Consequently, the index @p face_no must be less than n_faces(). * - * The neighbor of a cell has at most the same level as this cell. For - * example, consider the following situation: - * @image html limit_level_difference_at_vertices.png "" - * Here, if you are on the top right cell and you ask for its left neighbor - * (which is, according to the conventions spelled out in the GeometryInfo - * class, its zeroth neighbor), then you will get the mother cell of - * the four small cells at the top left. In other words, the cell you get as - * neighbor has the same refinement level as the one you're on right now - * (the top right one) and it may have children. - * - * On the other hand, if you were at the top right cell of the four small - * cells at the top left, and you asked for the right neighbor (which is - * associated with index face_no=1), then you would get the large - * cell at the top right which in this case has a lower refinement level and - * no children of its own. + * For example, consider the following situation: + * @image html limit_level_difference_at_vertices_anisotropic.png "" + * + * Here, if you are on cell `1.3` and ask for its left neighbor (which is, + * according to the conventions spelled out in the GeometryInfo class, its + * zeroth neighbor), then you will get the mother cell of `3.5`, since + * this is the smallest cell for which we have `(1.3)->face(0) == + * (3.5)->parent()->face(1)`. Note, that you will not obtain the mother cell + * of `2.8`. + * + * Further, if you ask for the right (i.e. the first) neighbor of cell + * `4.1`, then you will get cell `1.3`. Consequently, there are two + * neighboring cells that differ by three in their levels. In fact, using + * anisotropic refinement it is possible to generate arbitrary large + * differences in the level of neighboring cells. Perform e.g. arbitrarily + * many `y`-refinements of cell `4.1` and its children. While the second and + * third neighbors are being refined as well, due to the avoidance of multiple + * hanging nodes, cell `1.3` always remains as neighbor of the resulting + * right-most child. + * + * On the other hand, if you were at cell `3.3` and ask for its third + * neighbor, cell `4.1` will be returned, since it is the smallest cell that + * fulfills the described property. This shows, that the neighbor can + * have a higher level than the cell itself. + * + * However, using only isotropic refinement, the neighbor will have at + * most the level as the cell itself. This can be verified in the bottom + * half of the image, where only isotropic refinement was done: The first + * neighbor of `3.3` is given by `2.6`. Further refinement of `2.6` will + * generate a new first neighbor with level 3, but any further refinements of + * that child will not affect the neighbor of cell `3.3`. Due to the avoidance + * of multiple hanging nodes on a mesh, it is also impossible to obtain a + * coarser cell than `2.6` as the first neighbor of `3.3`. Consequently, the + * neighbor of a fully isotropic refined mesh has either the same level as the + * cell itself, or is exactly one level coarser. */ TriaIterator> neighbor(const unsigned int face_no) const; diff --git a/tests/grid/tria_accessor_neighbors.cc b/tests/grid/tria_accessor_neighbors.cc new file mode 100644 index 0000000000..0eabcff1c5 --- /dev/null +++ b/tests/grid/tria_accessor_neighbors.cc @@ -0,0 +1,387 @@ +// ------------------------------------------------------------------------ +// +// SPDX-License-Identifier: LGPL-2.1-or-later +// Copyright (C) 2012 - 2018 by the deal.II authors +// +// This file is part of the deal.II library. +// +// Part of the source code is dual licensed under Apache-2.0 WITH +// LLVM-exception OR LGPL-2.1-or-later. Detailed license information +// governing the source code and code contributions can be found in +// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II. +// +// ------------------------------------------------------------------------ + + +// check the neighbors of cell iterators in 2D +#include +#include +#include + +#include // for rand() + +#include "../tests.h" + +void +print_log(const typename Triangulation<2, 2>::cell_iterator c1, + const typename Triangulation<2, 2>::cell_iterator c2, + const unsigned int face) +{ + std::cout << "Neighbor of " << c1->level() << "." << c1->index() + << " at face " << face << " should be " << c2->level() << "." + << c2->index() << std::endl; + return; +} + +void +print_log_either(const typename Triangulation<2, 2>::cell_iterator c1, + const typename Triangulation<2, 2>::cell_iterator c2, + const typename Triangulation<2, 2>::cell_iterator c3, + const unsigned int face) +{ + std::cout << "Neighbor of " << c1->level() << "." << c1->index() + << " at face " << face << " should be either " << c2->level() << "." + << c3->index() << " or " << c3->level() << "." << c3->index() + << std::endl; + return; +} + +// Output grid +void +output_grid(const Triangulation<2, 2> *tria) +{ + GridOutFlags::Svg svg_flags; + svg_flags.label_level_number = true; + svg_flags.label_cell_index = true; + svg_flags.coloring = GridOutFlags::Svg::level_number; + svg_flags.background = GridOutFlags::Svg::transparent; + svg_flags.line_thickness = 1; + svg_flags.boundary_line_thickness = 2; + GridOut grid_out; + grid_out.set_flags(svg_flags); + grid_out.write_svg(*tria, deallog.get_file_stream()); + return; +} + +void +check_neighbors(const typename Triangulation<2, 2>::cell_iterator cell) +{ + // cell corresponds to the refined cell + for (unsigned int face = 0; face < 4; face++) + { + if (cell->face(face)->at_boundary()) // skip boundary faces + continue; + + // Check if the cells neighbor is refined + if (cell->neighbor(face)->has_children()) + { + // Yes: + for (unsigned int child = 0; child < cell->n_children(); child++) + { + // Is this cell anisotropically refined, s.t. the + // child face matches the face of its parent? + if (cell->face(face) == cell->child(child)->face(face)) + { // yes + if (cell->child(child)->neighbor(face) != + cell->neighbor(face)) + { + print_log(cell->child(child), cell->neighbor(face), face); + output_grid(&cell->get_triangulation()); + } + + Assert(cell->child(child)->neighbor(face) == + cell->neighbor(face), + ExcInternalError()); // Neighbors must coincide + } + + // If not, neighbor of the children must be either of the children + // of the neighbor of the parent + for (unsigned int neighbor_child = 0; + neighbor_child < cell->neighbor(face)->n_children(); + neighbor_child++) + { + // Get matching face + if (cell->child(child)->face(face) == + cell->neighbor(face) + ->child(neighbor_child) + ->face(cell->neighbor_of_neighbor(face))) + { + // face matches. Is the child refined? This is important + // in the following setup + // + // + --------- + --- + --- + + // | | | | + // | | | | + // | | | | + // + --------- + --- + --- + + // | | | + // | | | + // | | | + // + --------- + --- + --- + + // + // Where the parent of the left two anisotropically + // refined cells is the cell we are checking. The + // neighbor at face 1 then returns the coarsest cell on + // the right. Iterating its children gives the unrefined + // and refined cell. the face matches for the already + // refined face. So this will throw an error. This only + // happens in anisotropic refinement. If the cell were + // to be refined isotropically, as below + // + // + --------- + --- + --- + + // | | | | + // | + --- + --- + + // | | | | + // + --------- + --- + --- + + // | | | + // | | | + // | | | + // + --------- + --- + --- + + // + // Then the neighbor should be the parent of the small + // four children. + // + if (cell->neighbor(face) + ->child(neighbor_child) + ->has_children() && + cell->neighbor(face) + ->child(neighbor_child) + ->n_children() < 3) + { // yes! Then, it must be either of the children. + if (cell->child(child)->neighbor(face) != + cell->neighbor(face) + ->child(neighbor_child) + ->child(0) && + cell->child(child)->neighbor(face) != + cell->neighbor(face) + ->child(neighbor_child) + ->child(1)) + { + print_log_either(cell->child(child), + cell->neighbor(face) + ->child(neighbor_child) + ->child(0), + cell->neighbor(face) + ->child(neighbor_child) + ->child(1), + face); + output_grid(&cell->get_triangulation()); + } + + Assert(cell->child(child)->neighbor(face) == + cell->neighbor(face) + ->child(neighbor_child) + ->child(0) || + cell->child(child)->neighbor(face) == + cell->neighbor(face) + ->child(neighbor_child) + ->child(1), + ExcInternalError()); + } + else + { + if (cell->child(child)->neighbor(face) != + cell->neighbor(face)->child(neighbor_child)) + { + print_log(cell->child(child), + cell->neighbor(face)->child( + neighbor_child), + face); + output_grid(&cell->get_triangulation()); + } + + Assert(cell->child(child)->neighbor(face) == + cell->neighbor(face)->child(neighbor_child), + ExcInternalError()); + } + } + } + } + } + else + { + // No: + for (unsigned int child = 0; child < cell->n_children(); child++) + { + if (cell->face(face) == cell->child(child)->face(face)) + { + if (cell->child(child)->neighbor(face) != + cell->neighbor(face)) + { + print_log(cell->child(child), cell->neighbor(face), face); + output_grid(&cell->get_triangulation()); + } + + Assert(cell->child(child)->neighbor(face) == + cell->neighbor(face), + ExcInternalError()); + } + } + } + } +} + +std::vector> +get_refinement_cases() +{ + std::vector> out = { + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(1), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::cut_axis(0), + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement, + RefinementCase<2>::isotropic_refinement}; + return out; +} + +std::vector +get_cell_numbers() +{ + std::vector out = { + 2, 5, 5, 12, 2, 16, 2, 4, 18, 15, 8, 21, 13, 19, 11, + 15, 10, 9, 56, 50, 63, 23, 50, 89, 82, 96, 38, 105, 4, 73, + 38, 81, 89, 29, 143, 65, 166, 135, 12, 130, 46, 213, 132, 71, 106, + 102, 0, 226, 258, 175, 278, 196, 57, 272, 288, 260, 218, 33, 337, 86, + 255, 267, 163, 179, 223, 175, 291, 347, 260, 272, 410, 369, 4, 90, 170, + 417, 361, 275, 413, 287, 218, 362, 375, 476, 69, 24, 138, 195, 149, 32, + 219, 252, 112, 127, 583, 415, 583, 522, 288, 125}; + return out; +} + + +void +test() +{ + // Get a grid in 2D + Triangulation<2> triangulation; + GridGenerator::hyper_cube(triangulation); + triangulation.refine_global(); + + const std::vector> refinements = get_refinement_cases(); + const std::vector cell_numbers = get_cell_numbers(); + + // Generate some random refinement + // The idea is as follows + // ref_type is a random number between 0 and 2. + // -> If ref_type is 0, 1 we refine that axis + // -> If ref_type is 2 we use isotropic refinement + // cell_number refers to the cell we want to refine + // obtained by advancing triangulation.begin_active() + // cell_number times + for (unsigned int r = 0; r < 100; r++) + { + auto cell = triangulation.begin_active(); + std::advance(cell, cell_numbers[r]); + + cell->set_refine_flag(refinements[r]); + + triangulation.execute_coarsening_and_refinement(); + check_neighbors(cell); + } + output_grid(&triangulation); +} + + +int +main() +{ + initlog(); + + test(); + + return 0; +} diff --git a/tests/grid/tria_accessor_neighbors.output b/tests/grid/tria_accessor_neighbors.output new file mode 100644 index 0000000000..511eef332c --- /dev/null +++ b/tests/grid/tria_accessor_neighbors.output @@ -0,0 +1,1420 @@ + + + + + + + + + + + 3.2 + + + + 3.29 + + + 3.36 + + + 3.38 + + + 3.40 + + + + 3.42 + + + 3.49 + + + 3.52 + + + 3.53 + + + + 3.54 + + 3.55 + + + 3.56 + + + 3.57 + + + 3.58 + + 3.59 + + 4.6 + + + 4.10 + + + 4.12 + + 4.21 + + 4.23 + + 4.24 + + 4.26 + + 4.27 + + 4.28 + + 4.29 + + 4.32 + + + 4.33 + + + 4.35 + + 4.36 + + 4.37 + + 4.40 + + + 4.41 + + 4.44 + + 4.46 + + 4.47 + + 4.48 + + 4.50 + + 4.60 + + 4.62 + + 4.63 + + 4.70 + + 4.71 + + 4.73 + + 4.74 + + 4.75 + + + 4.76 + + 4.78 + + 4.79 + + 4.80 + + + 4.81 + + + 4.86 + + + 4.87 + + + 4.89 + + 4.90 + + 4.94 + + 4.95 + + 4.97 + + 4.99 + + 4.100 + + 4.103 + + + 4.104 + + 4.105 + + 4.106 + + 4.107 + + 4.109 + + 4.110 + + 4.111 + + 4.113 + + + 4.114 + + + 4.115 + + + + 4.116 + + 4.118 + + 4.119 + + 4.121 + + + 4.122 + + 4.123 + + 4.125 + + 4.126 + + 4.127 + + + 4.128 + + 4.129 + + + 4.133 + + 4.134 + + 4.135 + + 4.136 + + 4.139 + + 4.140 + + 4.141 + + 4.142 + + 4.143 + + 4.144 + + 4.146 + + + 4.147 + + + 4.148 + + 4.149 + + 4.150 + + 4.151 + + 4.152 + + 4.153 + + 4.154 + + 4.155 + + 4.156 + + 4.157 + + 4.158 + + + 4.159 + + + 4.161 + + 4.162 + + 4.163 + + 4.164 + + 4.165 + + 4.166 + + 4.167 + + 4.168 + + 4.169 + + 5.0 + + 5.1 + + 5.2 + + 5.3 + + 5.4 + + 5.5 + + 5.6 + + 5.7 + + 5.8 + + 5.9 + + 5.10 + + 5.16 + + + 5.17 + + + 5.20 + + 5.21 + + 5.22 + + 5.23 + + 5.24 + + 5.26 + + + 5.27 + + + 5.28 + + 5.30 + + + 5.36 + + 5.38 + + 5.39 + + 5.41 + + 5.44 + + 5.46 + + 5.47 + + 5.51 + + 5.53 + + 5.56 + + 5.57 + + 5.58 + + 5.59 + + 5.60 + + 5.64 + + 5.68 + + + 5.74 + + 5.75 + + 5.76 + + 5.78 + + 5.79 + + 5.81 + + 5.82 + + 5.83 + + 5.84 + + + 5.85 + + + 5.86 + + 5.88 + + 5.89 + + 5.90 + + 5.91 + + 5.92 + + 5.93 + + 5.94 + + 5.95 + + 5.96 + + 5.97 + + 5.98 + + 5.99 + + 5.102 + + 5.103 + + 5.104 + + 5.105 + + 5.107 + + 5.109 + + 5.110 + + 5.111 + + 5.112 + + 5.113 + + 5.114 + + 5.115 + + 5.116 + + 5.117 + + 5.118 + + 5.120 + + 5.121 + + 5.122 + + 5.124 + + + 5.125 + + + 5.126 + + 5.127 + + 5.128 + + 5.129 + + 5.131 + + 5.132 + + 5.134 + + 5.136 + + 5.137 + + 5.138 + + + 5.139 + + + 5.140 + + 5.141 + + 5.142 + + 5.143 + + 5.144 + + 5.145 + + 5.147 + + 5.148 + + 5.149 + + 5.150 + + 5.151 + + 5.152 + + 5.153 + + 5.154 + + 5.158 + + 5.159 + + 5.160 + + + 5.161 + + 5.162 + + + 5.163 + + 5.164 + + 5.165 + + 5.167 + + 5.168 + + 5.169 + + 5.170 + + 5.171 + + 5.172 + + 5.173 + + 5.174 + + 5.175 + + 5.176 + + 5.177 + + 5.178 + + 5.179 + + 5.180 + + 5.181 + + 5.182 + + 5.184 + + + 5.185 + + + 5.186 + + 5.187 + + 5.188 + + 5.189 + + 5.190 + + 5.191 + + 5.192 + + 5.193 + + 5.194 + + 5.195 + + 5.196 + + 5.197 + + 5.198 + + 5.199 + + 5.200 + + 5.201 + + 5.202 + + 5.203 + + 5.204 + + 5.205 + + 5.206 + + 5.207 + + 5.208 + + 5.209 + + 5.210 + + 5.211 + + 5.212 + + 5.213 + + 5.214 + + 5.215 + + 5.216 + + 5.217 + + 5.218 + + + 5.219 + + 5.220 + + + 5.221 + + 5.222 + + 5.223 + + 5.224 + + 5.226 + + 5.227 + + 5.228 + + 5.229 + + 5.230 + + 5.231 + + 5.232 + + 5.233 + + 5.234 + + 5.235 + + 5.236 + + 5.237 + + 5.238 + + 5.239 + + 5.240 + + + 5.241 + + + 5.242 + + 5.243 + + 5.244 + + 5.245 + + 5.246 + + 5.247 + + 5.248 + + 5.249 + + 5.250 + + 5.251 + + 5.252 + + 5.253 + + 5.254 + + 5.255 + + 5.256 + + 5.257 + + 5.258 + + 5.259 + + 5.260 + + 5.261 + + 5.262 + + 5.263 + + 6.4 + + 6.5 + + 6.7 + + 6.10 + + 6.13 + + 6.15 + + 6.17 + + 6.18 + + 6.19 + + 6.20 + + 6.21 + + 6.22 + + 6.23 + + 6.24 + + 6.29 + + 6.30 + + 6.31 + + 6.34 + + 6.36 + + 6.37 + + 6.38 + + 6.39 + + 6.40 + + 6.41 + + 6.43 + + 6.44 + + 6.45 + + 6.46 + + 6.47 + + 6.48 + + 6.49 + + 6.50 + + 6.51 + + 6.52 + + 6.53 + + 6.54 + + 6.55 + + 6.56 + + 6.57 + + 6.59 + + 6.62 + + 6.63 + + 6.64 + + 6.65 + + 6.66 + + 6.67 + + 6.68 + + 6.69 + + 6.70 + + 6.71 + + 6.72 + + 6.73 + + 6.74 + + 6.75 + + 6.76 + + 6.77 + + 6.78 + + 6.79 + + 6.80 + + 6.81 + + 6.82 + + 6.83 + + 6.84 + + + 6.85 + + + 6.86 + + 6.87 + + 6.88 + + 6.89 + + 6.90 + + 6.91 + + 6.94 + + 6.95 + + 6.96 + + 6.97 + + 6.98 + + 6.99 + + 6.100 + + 6.101 + + 6.102 + + 6.104 + + 6.105 + + 6.106 + + 6.107 + + 6.109 + + 6.111 + + 6.112 + + 6.113 + + 6.114 + + 6.115 + + 6.116 + + 6.117 + + 6.120 + + 6.121 + + 6.122 + + 6.123 + + 6.125 + + 6.126 + + 6.127 + + 6.128 + + 6.129 + + 6.130 + + 6.131 + + 6.132 + + + 6.133 + + + 6.134 + + 6.135 + + 6.136 + + 6.137 + + 6.138 + + 6.139 + + 6.140 + + 6.141 + + 6.142 + + 6.143 + + 6.144 + + 6.145 + + 6.146 + + 6.147 + + 6.148 + + 6.149 + + 6.150 + + 6.151 + + 6.152 + + 6.153 + + 6.154 + + 6.155 + + 6.156 + + 6.157 + + 6.158 + + 6.159 + + 6.160 + + 6.161 + + 6.162 + + 6.163 + + 6.164 + + 6.165 + + 6.166 + + 6.167 + + 6.168 + + 6.169 + + 6.170 + + 6.171 + + 6.172 + + 6.173 + + 6.174 + + 6.175 + + 6.176 + + 6.177 + + 6.178 + + 6.179 + + 6.180 + + 6.181 + + 6.182 + + 6.183 + + 6.184 + + 6.185 + + 6.186 + + 6.187 + + 6.188 + + 6.189 + + 6.190 + + 6.191 + + 6.192 + + 6.193 + + 6.194 + + 6.195 + + 6.196 + + 6.197 + + 6.198 + + 6.199 + + 6.200 + + 6.201 + + 6.202 + + 6.203 + + 6.204 + + 6.205 + + 6.206 + + 6.207 + + 6.208 + + 6.209 + + 6.210 + + 6.211 + + 6.212 + + 6.213 + + 7.0 + + 7.4 + + 7.5 + + 7.6 + + 7.8 + + 7.9 + + 7.10 + + 7.11 + + 7.12 + + 7.13 + + 7.14 + + 7.15 + + 7.16 + + 7.17 + + 7.18 + + 7.19 + + 7.21 + + 7.22 + + 7.23 + + 7.24 + + 7.25 + + 7.26 + + 7.27 + + 7.29 + + 7.31 + + 7.33 + + 7.35 + + 7.38 + + 7.39 + + 7.40 + + 7.41 + + 7.42 + + 7.43 + + 7.44 + + 7.45 + + 7.47 + + 7.48 + + 7.50 + + 7.51 + + 7.52 + + 7.53 + + 7.54 + + 7.55 + + 7.56 + + 7.57 + + 7.58 + + 7.59 + + 7.60 + + 7.61 + + 7.62 + + 7.63 + + 7.64 + + 7.65 + + 7.66 + + 7.67 + + 7.68 + + 7.69 + + 7.70 + + 7.71 + + 7.72 + + 7.74 + + 7.76 + + 7.77 + + 7.78 + + 7.79 + + 7.80 + + 7.81 + + 7.82 + + 7.83 + + 7.84 + + 7.85 + + 7.86 + + 7.87 + + 7.88 + + 7.89 + + 7.90 + + 7.91 + + 7.92 + + 7.93 + + 7.94 + + 7.95 + + 7.96 + + 7.97 + + 7.98 + + 7.99 + + 7.100 + + 7.101 + + 7.102 + + 7.103 + + 7.104 + + 7.105 + + 7.106 + + 7.107 + + 8.0 + + 8.2 + + 8.3 + + 8.4 + + 8.5 + + 8.6 + + 8.7 + + 8.8 + + 8.9 + + 8.10 + + 8.11 + + 8.12 + + 8.13 + + 8.14 + + 8.15 + + 8.16 + + 8.18 + + 8.19 + + 8.20 + + 8.21 + + 8.22 + + 8.23 + + 8.24 + + 8.25 + + 8.26 + + 8.28 + + 8.29 + + 8.30 + + 8.31 + + 8.32 + + 8.33 + + 8.34 + + 8.35 + + 8.36 + + 8.37 + + 8.38 + + 8.39 + + 8.40 + + 8.41 + + 8.42 + + 8.43 + + 8.44 + + 8.45 + + 8.46 + + 8.47 + + 8.48 + + 8.49 + + 9.0 + + 9.1 + + 9.2 + + 9.3 + + 9.4 + + 9.5 + + 9.6 + + 9.7 + + \ No newline at end of file