From 4778887b0557fb469aefed3d20d7816a8502c43c Mon Sep 17 00:00:00 2001 From: =?utf8?q?Robin=20G=C3=B6rmer?= Date: Tue, 27 Aug 2024 10:17:34 +0200 Subject: [PATCH] Extended documentation of CellAccesor::neighbor() to include anisotropic refinements as well. Modified the example accordingly. --- ...vel_difference_at_vertices_anisotropic.png | Bin 0 -> 35498 bytes include/deal.II/grid/tria_accessor.h | 55 +- tests/grid/tria_accessor_neighbors.cc | 387 +++++ tests/grid/tria_accessor_neighbors.output | 1420 +++++++++++++++++ 4 files changed, 1846 insertions(+), 16 deletions(-) create mode 100644 doc/doxygen/images/limit_level_difference_at_vertices_anisotropic.png create mode 100644 tests/grid/tria_accessor_neighbors.cc create mode 100644 tests/grid/tria_accessor_neighbors.output 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 0000000000000000000000000000000000000000..be06141eaf9a674884c2b30ac3f2c601b4d0565e GIT binary patch literal 35498 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

F{1&vmjwh}Q^Ye#|Dma_0N_dKk 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 LJ7fPmdHw$Y3s?@{ literal 0 HcmV?d00001 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 -- 2.39.5