SchedulerPatchData.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/DistributedData.hpp"
#include "shamrock/patch/Patch.hpp"
#include "shamrock/patch/PatchDataLayer.hpp"
#include "shamrock/patch/PatchDataLayerLayout.hpp"
#include "shamrock/patch/SimBox.hpp"
#include "shamrock/scheduler/HilbertLoadBalance.hpp"
#include "shamrock/scheduler/scheduler_patch_list.hpp"
#include <cmath>
#include <map>
#include <utility>
 
namespace shamrock::scheduler {
 
    using Patch                = shamrock::patch::Patch;
    using PatchData            = shamrock::patch::PatchDataLayer;
    using PatchDataLayerLayout = shamrock::patch::PatchDataLayerLayout;
    using SimulationBoxInfo    = shamrock::patch::SimulationBoxInfo;
 
    class SchedulerPatchData {
        public:
        std::shared_ptr<PatchDataLayerLayout> pdl_ptr;
 
        inline shamrock::patch::PatchDataLayerLayout &pdl() {
            return shambase::get_check_ref(pdl_ptr);
        }
 
        inline std::shared_ptr<shamrock::patch::PatchDataLayerLayout> get_layout_ptr() const {
            return pdl_ptr;
        }
 
        shambase::DistributedData<PatchData> owned_data;
 
        inline bool has_patch(u64 id) { return owned_data.has_key(id); }
 
        inline PatchData &get_pdat(u64 id) { return owned_data.get(id); }
 
        inline void for_each_patchdata(std::function<void(u64, PatchData &)> &&f) {
            owned_data.for_each(std::forward<std::function<void(u64, PatchData &)>>(f));
        }
 
        shamrock::patch::SimulationBoxInfo sim_box;
 
        void apply_change_list(
            const shamrock::scheduler::LoadBalancingChangeList &change_list,
            SchedulerPatchList &patch_list);
 
        void split_patchdata(u64 key_orginal, const std::array<shamrock::patch::Patch, 8> patches);
 
        void merge_patchdata(u64 new_key, const std::array<u64, 8> old_keys);
 
        inline SchedulerPatchData(
            const std::shared_ptr<shamrock::patch::PatchDataLayerLayout> &pdl_ptr,
            shamrock::patch::PatchCoord<3> patch_coord_range)
            : pdl_ptr(pdl_ptr), sim_box(pdl(), patch_coord_range) {}
    };
 
} // namespace shamrock::scheduler