vcbferreira/NuFI_deal.ii
1
0
Fork 0
mirror of https://codeberg.org/vcbferreira/NuFI_deal.ii synced 2026-08-12 14:33:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

testing different locator with while(cell->has_children)

Browse Source
This commit is contained in:
Vasco C. B. Ferreira
2026-07-31 12:47:13 +02:00
parent c91d39d9e1
commit 4d7078d56d
3 changed files with 45 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nufi/cells.h
+43 -122
View File
@@ -1,13 +1,7 @@
#ifndef CELLS_H #ifndef CELLS_H
#define CELLS_H #define CELLS_H
#include <algorithm>
#include <array>
#include <cmath> #include <cmath>
#include <limits>
#include <vector>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/geometry_info.h> #include <deal.II/base/geometry_info.h>
#include <deal.II/base/point.h> #include <deal.II/base/point.h>
#include <deal.II/dofs/dof_handler.h> #include <deal.II/dofs/dof_handler.h>
@@ -15,8 +9,6 @@
using namespace dealii; using namespace dealii;
// Current Locator needs Grid to be a single hypercube coarse cell,
// uniformly refined to `base_level`, with isotropic local refinement on top.
template <int dim> struct CellLocation { template <int dim> struct CellLocation {
typename DoFHandler<dim>::active_cell_iterator cell; typename DoFHandler<dim>::active_cell_iterator cell;
Point<dim> reference_point; Point<dim> reference_point;
@@ -25,144 +17,73 @@ template <int dim> struct CellLocation {
template <int dim> class CellLocator { template <int dim> class CellLocator {
public: public:
void rebuild(const DoFHandler<dim> &dof_handler, void rebuild(const DoFHandler<dim> &dof_handler,
const Triangulation<dim> &triangulation, const Triangulation<dim> &triangulation);
unsigned int base_level);
CellLocation<dim> locate(const Point<dim> &point) const; CellLocation<dim> locate(const Point<dim> &p) const;
private: private:
const DoFHandler<dim> *dof_handler_ = nullptr; const DoFHandler<dim> *dof_handler_ptr = nullptr;
typename Triangulation<dim>::cell_iterator root;
Point<dim> domain_lower_; Point<dim> lower;
Point<dim> domain_upper_; Point<dim> upper;
std::array<unsigned int, dim> base_n_{};
std::array<double, dim> base_dx_{};
// Flat, O(1)-indexable array of the base_level cells.
std::vector<typename DoFHandler<dim>::cell_iterator> base_cells_;
}; };
template <int dim> template <int dim>
void CellLocator<dim>::rebuild(const DoFHandler<dim> &dof_handler, void CellLocator<dim>::rebuild(const DoFHandler<dim> &dof_handler,
const Triangulation<dim> &triangulation, const Triangulation<dim> &triangulation) {
unsigned int base_level) { dof_handler_ptr = &dof_handler;
AssertThrow(&dof_handler.get_triangulation() == &triangulation,
ExcMessage("CellLocator::rebuild(): DoFHandler and Triangulation "
"do not refer to the same mesh."));
dof_handler_ = &dof_handler; // Everything below assumes the mesh is a single hyper_cube coarse cell
// (true for your create_mesh(): GridGenerator::hyper_cube + refine_global).
AssertThrow(triangulation.n_cells(0) == 1,
ExcMessage("CellLocator assumes exactly one coarse/root cell."));
// --- bounding box of the (single) coarse cell --- root = triangulation.begin(0);
auto root = dof_handler.begin(0); lower = root->vertex(0);
AssertThrow(root != dof_handler.end(0), upper = root->vertex(GeometryInfo<dim>::vertices_per_cell - 1);
ExcMessage("CellLocator::rebuild(): no level-zero cell."));
{
auto after_root = root;
++after_root;
AssertThrow(after_root == dof_handler.end(0),
ExcMessage("CellLocator currently requires exactly one "
"coarse cell."));
}
for (unsigned int d = 0; d < dim; ++d) {
domain_lower_[d] = std::numeric_limits<double>::max();
domain_upper_[d] = std::numeric_limits<double>::lowest();
}
for (unsigned int v = 0; v < GeometryInfo<dim>::vertices_per_cell; ++v)
for (unsigned int d = 0; d < dim; ++d) {
domain_lower_[d] = std::min(domain_lower_[d], root->vertex(v)[d]);
domain_upper_[d] = std::max(domain_upper_[d], root->vertex(v)[d]);
}
// --- build the O(1)-indexable array of base_level cells ---
unsigned int total = 1;
for (unsigned int d = 0; d < dim; ++d) {
const double length = domain_upper_[d] - domain_lower_[d];
AssertThrow(length > 0.0,
ExcMessage("CellLocator::rebuild(): non-positive domain "
"extent."));
base_n_[d] =
1u << base_level; // refine_global(base_level) -> 2^level per axis
base_dx_[d] = length / base_n_[d];
total *= base_n_[d];
}
base_cells_.assign(total, typename DoFHandler<dim>::cell_iterator());
for (auto cell = dof_handler.begin(base_level);
cell != dof_handler.end(base_level); ++cell) {
const auto bb = cell->bounding_box();
const auto c_lower = bb.get_boundary_points().first;
unsigned int idx = 0, stride = 1;
for (unsigned int d = 0; d < dim; ++d) {
unsigned int i = static_cast<unsigned int>(
std::round((c_lower[d] - domain_lower_[d]) / base_dx_[d]));
i = std::min(i, base_n_[d] - 1);
idx += i * stride;
stride *= base_n_[d];
}
base_cells_[idx] = cell;
}
for (const auto &c : base_cells_)
AssertThrow(c.state() == IteratorState::valid,
ExcMessage("CellLocator::rebuild(): failed to fill the base "
"grid — mesh isn't uniformly refined to "
"'base_level' as expected."));
} }
template <int dim> template <int dim>
CellLocation<dim> CellLocator<dim>::locate(const Point<dim> &point) const { CellLocation<dim> CellLocator<dim>::locate(const Point<dim> &p) const {
AssertThrow(dof_handler_ != nullptr, AssertThrow(dof_handler_ptr != nullptr,
ExcMessage("CellLocator::locate(): rebuild() has not been " ExcMessage("CellLocator::rebuild() has not been called."));
"called."));
std::array<unsigned int, dim> base_index; // Step 1: periodic wrap into [lower, upper) per axis.
Point<dim> reference_point; // local coords, updated at each descent step Point<dim> p_wrapped;
// 1) periodic wrap + O(1) base-cell index per axis
for (unsigned int d = 0; d < dim; ++d) { for (unsigned int d = 0; d < dim; ++d) {
const double length = domain_upper_[d] - domain_lower_[d]; const double L = upper[d] - lower[d];
double shifted = point[d] - domain_lower_[d]; double x = p[d] - lower[d];
shifted -= length * std::floor(shifted / length); x = x - L * std::floor(x / L);
if (shifted >= length) p_wrapped[d] = lower[d] + x;
shifted = 0.0;
const double xi = shifted / base_dx_[d];
const unsigned int i =
std::min(base_n_[d] - 1, static_cast<unsigned int>(std::floor(xi)));
base_index[d] = i;
reference_point[d] = xi - i; // fraction within the base cell
} }
// 2) O(1) lookup of the base-level cell // Step 2: reference coordinates in the root cell, clamped against
unsigned int idx = 0, stride = 1; // floating-point drift at the domain boundary.
Point<dim> xi;
for (unsigned int d = 0; d < dim; ++d) { for (unsigned int d = 0; d < dim; ++d) {
idx += base_index[d] * stride; xi[d] = (p_wrapped[d] - lower[d]) / (upper[d] - lower[d]);
stride *= base_n_[d]; xi[d] = std::min(std::max(xi[d], 0.0), 1.0);
} }
auto cell = base_cells_[idx];
// 3) O(R_level_max) descent — only costs anything for cells that are // Steps 3-5: descend the refinement tree using deal.II's own
// actually locally refined beyond base_level // reference-cell child logic (branch-free, handles dim=1,2,3 uniformly).
typename Triangulation<dim>::cell_iterator cell = root;
while (cell->has_children()) { while (cell->has_children()) {
AssertThrow(cell->n_children() == GeometryInfo<dim>::max_children_per_cell,
ExcMessage("CellLocator currently supports isotropic "
"refinement only."));
const unsigned int child_index = const unsigned int child_index =
GeometryInfo<dim>::child_cell_from_point(reference_point); GeometryInfo<dim>::child_cell_from_point(xi);
reference_point = GeometryInfo<dim>::cell_to_child_coordinates( xi = GeometryInfo<dim>::cell_to_child_coordinates(xi, child_index);
reference_point, child_index);
cell = cell->child(child_index); cell = cell->child(child_index);
} }
AssertThrow(cell->is_active(), // cell is now active (leaf) -> bind it to the DoFHandler.
ExcMessage("CellLocator tree traversal did not finish on an " typename DoFHandler<dim>::active_cell_iterator dof_cell(
"active cell.")); &cell->get_triangulation(), cell->level(), cell->index(),
dof_handler_ptr);
return CellLocation<dim>{typename DoFHandler<dim>::active_cell_iterator(cell), CellLocation<dim> location;
reference_point}; location.cell = dof_cell;
location.reference_point = xi;
return location;
} }
#endif // CELLS_H #endif // !CELLS_H
nufi/grids.h
+1 -2
View File
@@ -140,8 +140,7 @@ GridStructure<dim> make_grid_snapshot(PoissonProblem<dim> &poisson) {
grid.constraints->close(); grid.constraints->close();
grid.locator = std::make_unique<CellLocator<dim>>(); grid.locator = std::make_unique<CellLocator<dim>>();
grid.locator->rebuild(*grid.dof_handler, *grid.triangulation, grid.locator->rebuild(*grid.dof_handler, *grid.triangulation);
Parameters::GLOBAL_REFINEMENT);
// START: diagnostics // START: diagnostics
AssertThrow( AssertThrow(
nufi/poisson_problem.h
+1 -2
View File
@@ -338,8 +338,7 @@ template <int dim> void PoissonProblem<dim>::setup_system() {
system_rhs.reinit(dof_handler.n_dofs()); system_rhs.reinit(dof_handler.n_dofs());
// used for evaluator to avoid running it anytime there is an eval // used for evaluator to avoid running it anytime there is an eval
cell_locator.rebuild(dof_handler, triangulation, cell_locator.rebuild(dof_handler, triangulation);
Parameters::GLOBAL_REFINEMENT);
} }
template <int dim> void PoissonProblem<dim>::assemble_system() { template <int dim> void PoissonProblem<dim>::assemble_system() {