Skip to content

refactor: new trial set algebra #387

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 18 commits into
base: master
Choose a base branch
from
Open

refactor: new trial set algebra #387

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
18 commits
Select commit Hold shift + click to select a range
6111bd7
feurst
Sep 16, 2025
4d876c6
FixedCapacityArray corrected
Sep 17, 2025
66deefd
with pre-commit
Sep 17, 2025
5bcc53a
expand
Sep 29, 2025
25b470f
memorypool bugged
Oct 1, 2025
c2682eb
memorypool and projection corrected - expand is next
Oct 1, 2025
1015846
stuff
Oct 1, 2025
2982c88
with pre-commit
Oct 1, 2025
1f6794b
minor update
Oct 1, 2025
de91bbd
minor update
Oct 1, 2025
dfa353d
minor update
Oct 1, 2025
dbe1c8c
minor update
Oct 1, 2025
2eb0c70
minor update
Oct 1, 2025
2c4f65d
a
Oct 3, 2025
a575628
added a 'list of interval' option for projection
Oct 6, 2025
35cfcbf
started to add traverser ranges
Oct 7, 2025
b6bbedf
started to add traverser ranges
Oct 7, 2025
6bda7b4
range partly implemented
Oct 8, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 2 additions & 1 deletion demos/FiniteVolume/linear_convection_obstacle.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -136,7 +136,8 @@ int main(int argc, char* argv[])
}

double t = 0;
while (t != Tf)
//~ while (t != Tf)
for (int ite = 0; ite != 23; ++ite)
{
// Move to next timestep
t += dt;
Expand Down
2 changes: 1 addition & 1 deletion demos/tutorial/set_operator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -98,7 +98,7 @@ int main()
u[cell] = cell.indices[0];
});

auto subset1 = samurai::intersection(ca[0], samurai::contraction(ca[1], 1));
auto subset1 = samurai::intersection(ca[0], samurai::contract(ca[1], 1));
subset1.on(0)(
[&](const auto& i, auto)
{
Expand Down
25 changes: 19 additions & 6 deletions include/samurai/algorithm.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,9 @@
#include "cell.hpp"
#include "mesh_holder.hpp"

#include "concepts.hpp"
#include "subset/node.hpp"

using namespace xt::placeholders;

namespace samurai
Expand Down Expand Up @@ -111,18 +114,28 @@ namespace samurai
}
}

template <class Mesh, class Func>
template <IsMesh Mesh, class Func>
inline void for_each_interval(const Mesh& mesh, Func&& f)
{
using mesh_id_t = typename Mesh::config::mesh_id_t;
for_each_interval(mesh[mesh_id_t::cells], std::forward<Func>(f));
}

template <class Op, class StartEndOp, class... S>
class Subset;

template <class Func, class Op, class StartEndOp, class... S>
inline void for_each_interval(Subset<Op, StartEndOp, S...>& set, Func&& f)
//~ template <class Op, class StartEndOp, class... S>
//~ class Subset;

//~ template <class Func, class Op, class StartEndOp, class... S>
//~ inline void for_each_interval(Subset<Op, StartEndOp, S...>& set, Func&& f)
//~ {
//~ set(
//~ [&](const auto& i, const auto& index)
//~ {
//~ f(set.level(), i, index);
//~ });
//~ }

template <class Func, class Set>
inline void for_each_interval(const SetBase<Set>& set, Func&& f)
{
set(
[&](const auto& i, const auto& index)
Expand Down
4 changes: 2 additions & 2 deletions include/samurai/boundary.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@ namespace samurai
{
using mesh_id_t = typename Mesh::mesh_id_t;

auto& cells = mesh[mesh_id_t::cells][level];
const auto& cells = mesh[mesh_id_t::cells][level];

return difference(cells, translate(self(domain).on(level), -layer_width * direction));
}
Expand Down Expand Up @@ -43,7 +43,7 @@ namespace samurai
{
using mesh_id_t = typename Mesh::mesh_id_t;

auto& cells = mesh[mesh_id_t::cells][level];
const auto& cells = mesh[mesh_id_t::cells][level];

return difference(cells, contract(self(mesh.domain()).on(level), 1));
}
Expand Down
3 changes: 2 additions & 1 deletion include/samurai/interval.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -362,7 +362,8 @@ namespace samurai
template <class value_t, class index_t>
inline bool operator==(const Interval<value_t, index_t>& i1, const Interval<value_t, index_t>& i2)
{
return !(i1.start != i2.start || i1.end != i2.end || i1.step != i2.step || i1.index != i2.index);
//~ return !(i1.start != i2.start || i1.end != i2.end || i1.step != i2.step || i1.index != i2.index);
return !(i1.start != i2.start || i1.end != i2.end || i1.step != i2.step);
}

template <class value_t, class index_t>
Expand Down
49 changes: 45 additions & 4 deletions include/samurai/level_cell_array.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -94,8 +94,11 @@ namespace samurai
LevelCellArray() = default;
LevelCellArray(const LevelCellList<Dim, TInterval>& lcl);

template <class Op, class StartEndOp, class... S>
LevelCellArray(Subset<Op, StartEndOp, S...> set);
template <class Set>
explicit LevelCellArray(const SetBase<Set>& set);

template <class Set>
LevelCellArray(const SetBase<Set>& set, const coords_t& origin_point, const double scaling_factor);

LevelCellArray(std::size_t level, const Box<value_t, dim>& box);
LevelCellArray(std::size_t level,
Expand Down Expand Up @@ -344,9 +347,21 @@ namespace samurai
}
}

//~ template <std::size_t Dim, class TInterval>
//~ template <class Op, class StartEndOp, class... S>
//~ inline LevelCellArray<Dim, TInterval>::LevelCellArray(Subset<Op, StartEndOp, S...> set)
//~ : m_level(set.level())
//~ {
//~ set(
//~ [this](const auto& i, const auto& index)
//~ {
//~ add_interval_back(i, index);
//~ });
//~ }

template <std::size_t Dim, class TInterval>
template <class Op, class StartEndOp, class... S>
inline LevelCellArray<Dim, TInterval>::LevelCellArray(Subset<Op, StartEndOp, S...> set)
template <class Set>
inline LevelCellArray<Dim, TInterval>::LevelCellArray(const SetBase<Set>& set)
: m_level(set.level())
{
set(
Expand All @@ -356,6 +371,32 @@ namespace samurai
});
}

template <std::size_t Dim, class TInterval>
template <class Set>
inline LevelCellArray<Dim, TInterval>::LevelCellArray(const SetBase<Set>& set, const coords_t& origin_point, const double scaling_factor)
: m_level(set.level())
, m_origin_point(origin_point)
, m_scaling_factor(scaling_factor)
{
set(
[this](const auto& i, const auto& index)
{
add_interval_back(i, index);
});
}

//~ template <std::size_t Dim, class TInterval>
//~ template <class Op, class StartEndOp, class... S>
//~ inline LevelCellArray<Dim, TInterval>::LevelCellArray(Subset<Op, StartEndOp, S...> set)
//~ : m_level(set.level())
//~ {
//~ set(
//~ [this](const auto& i, const auto& index)
//~ {
//~ add_interval_back(i, index);
//~ });
//~ }

template <std::size_t Dim, class TInterval>
inline LevelCellArray<Dim, TInterval>::LevelCellArray(std::size_t level, const Box<value_t, dim>& box)
: m_level{level}
Expand Down
5 changes: 5 additions & 0 deletions include/samurai/list_of_intervals.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -62,6 +62,11 @@ namespace samurai

void add_point(value_t point);
void add_interval(const interval_t& interval);

void clear()
{
std::forward_list<Interval<TValue, TIndex>>::clear();
}
};

////////////////////////////////////
Expand Down
10 changes: 6 additions & 4 deletions include/samurai/mesh.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -815,16 +815,18 @@ namespace samurai
{
if constexpr (dim == 2)
{
m_corners.push_back(difference(
m_domain,
union_(translate(m_domain, direction_t{-direction[0], 0}), translate(m_domain, direction_t{0, -direction[1]}))));
m_corners.push_back(difference(m_domain,
union_(translate(m_domain, direction_t{-direction[0], 0}),
translate(m_domain, direction_t{0, -direction[1]})))
.to_lca());
}
else if constexpr (dim == 3)
{
m_corners.push_back(difference(m_domain,
union_(translate(m_domain, direction_t{-direction[0], 0, 0}),
translate(m_domain, direction_t{0, -direction[1], 0}),
translate(m_domain, direction_t{0, 0, -direction[2]}))));
translate(m_domain, direction_t{0, 0, -direction[2]})))
.to_lca());
}
});
}
Expand Down
2 changes: 2 additions & 0 deletions include/samurai/samurai_config.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,8 @@ namespace samurai
static constexpr std::size_t graduation_width = 1;
static constexpr std::size_t prediction_order = 1;

static constexpr bool prediction_with_list_of_intervals = false;

using index_t = signed long long int;
using value_t = int;
using interval_t = Interval<value_t, index_t>;
Expand Down
117 changes: 24 additions & 93 deletions include/samurai/subset/apply.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,119 +3,50 @@

#pragma once

#include "concepts.hpp"
#include "utils.hpp"
#include "set_base.hpp"

namespace samurai
{
namespace detail
{
template <std::size_t dim, class Set, class Func, class Container>
bool apply_impl(Set&& global_set, Func&& func, Container& index)
template <class Set, class Func, class Index, std::size_t d>
void apply_rec(const SetBase<Set>& set, Func&& func, Index& index, std::integral_constant<std::size_t, d> d_ic)
{
auto set = global_set.template get_local_set<dim>(global_set.level(), index);
auto start_and_stop = global_set.template get_start_and_stop_function<dim>();
using traverser_t = typename Set::template traverser_t<d>;
using current_interval_t = typename traverser_t::current_interval_t;

if constexpr (dim != 1)
set.init_get_traverser_work(1, d_ic);

for (traverser_t traverser = set.get_traverser(index, d_ic); !traverser.is_empty(); traverser.next_interval())
{
auto func_int = [&](const auto& interval)
current_interval_t interval = traverser.current_interval();

if constexpr (d == 0)
{
for (auto i = interval.start; i < interval.end; ++i)
func(interval, index);
}
else
{
for (index[d - 1] = interval.start; index[d - 1] != interval.end; ++index[d - 1])
{
index[dim - 2] = i;
if (apply_impl<dim - 1>(std::forward<Set>(global_set), std::forward<Func>(func), index))
{
return true;
}
apply_rec(set, std::forward<Func>(func), index, std::integral_constant<std::size_t, d - 1>{});
}
return false;
};
return apply(set, start_and_stop, func_int);
}
else
{
auto func_int = [&](const auto& interval)
{
return func(interval, index);
};
return apply(set, start_and_stop, func_int);
}
}

set.clear_get_traverser_work(d_ic);
}
}

template <class Set, class Func>
void apply(Set&& global_set, Func&& user_func)
void apply(const SetBase<Set>& set, Func&& func)
{
constexpr std::size_t dim = std::decay_t<Set>::dim;
xt::xtensor_fixed<int, xt::xshape<dim - 1>> index;

auto func = [&](const auto& interval, const auto& yz)
{
user_func(interval, yz);
return false;
};
constexpr std::size_t dim = Set::dim;

if (global_set.exist())
{
detail::apply_impl<dim>(std::forward<Set>(global_set), func, index);
}
}

template <class Set>
bool empty_check(Set&& global_set)
{
constexpr std::size_t dim = std::decay_t<Set>::dim;
xt::xtensor_fixed<int, xt::xshape<dim - 1>> index;

auto func = [](const auto&, const auto&)
if (set.exist())
{
return true;
};

if (global_set.exist())
{
return !detail::apply_impl<dim>(std::forward<Set>(global_set), func, index);
}
return true;
}

template <class Set, class StartEnd, class Func>
requires IsSetOp<Set> || IsIntervalListVisitor<Set>
bool apply(Set&& set, StartEnd&& start_and_stop, Func&& func)
{
using interval_t = typename std::decay_t<Set>::interval_t;
using value_t = typename interval_t::value_t;

interval_t result;
int r_ipos = 0;
set.next(0, std::forward<StartEnd>(start_and_stop));
auto scan = set.min();

while (scan < sentinel<value_t> && !set.is_empty())
{
bool is_in = set.is_in(scan);

if (is_in && r_ipos == 0)
{
result.start = scan;
r_ipos = 1;
}
else if (!is_in && r_ipos == 1)
{
result.end = scan;
r_ipos = 0;

auto true_result = set.shift() >= 0 ? result >> static_cast<std::size_t>(set.shift())
: result << -static_cast<std::size_t>(set.shift());
if (func(true_result))
{
return true;
}
}

set.next(scan, std::forward<StartEnd>(start_and_stop));
scan = set.min();
detail::apply_rec(set, std::forward<Func>(func), index, std::integral_constant<std::size_t, dim - 1>{});
}
return false;
}
}
Loading
Loading