From d999f4ef98dad3ec7cb539fa40a94afa6b3cf939 Mon Sep 17 00:00:00 2001 From: Fei Yang <2501213217@stu.pku.edu.cn> Date: Thu, 5 Nov 2026 14:12:22 +0800 Subject: [PATCH 1/5] refactor(cell): extract domain ghost exchange implementation --- source/Makefile.Objects | 1 + source/source_cell/CMakeLists.txt | 2 +- source/source_cell/domain_decomposition.cpp | 387 ----------------- .../domain_decomposition_ghost.cpp | 402 ++++++++++++++++++ .../module_neighlist/test/CMakeLists.txt | 6 +- source/source_md/test/CMakeLists.txt | 1 + 6 files changed, 408 insertions(+), 391 deletions(-) create mode 100644 source/source_cell/domain_decomposition_ghost.cpp diff --git a/source/Makefile.Objects b/source/Makefile.Objects index 3aa07144a0c..c2791a05317 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -250,6 +250,7 @@ OBJS_CELL=atom_pseudo.o\ mdcell_reader.o\ mdcell.o\ domain_decomposition.o\ + domain_decomposition_ghost.o\ cif_io.o\ ucell_io.o\ diff --git a/source/source_cell/CMakeLists.txt b/source/source_cell/CMakeLists.txt index 8e759788772..f4d5b332d32 100644 --- a/source/source_cell/CMakeLists.txt +++ b/source/source_cell/CMakeLists.txt @@ -2,7 +2,7 @@ add_subdirectory(module_symmetry) add_subdirectory(module_neighbor) add_subdirectory(module_neighlist) -add_library(domain_decomposition OBJECT domain_decomposition.cpp) +add_library(domain_decomposition OBJECT domain_decomposition.cpp domain_decomposition_ghost.cpp) add_library( cell OBJECT diff --git a/source/source_cell/domain_decomposition.cpp b/source/source_cell/domain_decomposition.cpp index b0bca2908fb..e79c12f6c0b 100644 --- a/source/source_cell/domain_decomposition.cpp +++ b/source/source_cell/domain_decomposition.cpp @@ -17,9 +17,6 @@ namespace { const int tag_migration_count_base = 100; const int tag_migration_atoms_base = 200; -const int tag_ghost_count = 9100; -const int tag_ghost_atoms = 9101; -const int tag_ghost_positions = 9110; const int tag_ghost_force_size = 9200; const int tag_ghost_forces = 9201; } @@ -43,31 +40,6 @@ DomainDecomposition::~DomainDecomposition() #endif } -GhostExchangePlanView GhostExchangePlan::make_view() -{ - GhostExchangePlanView view; - view.nswap = static_cast(sendnum.size()); - view.sendnum = sendnum.empty() ? NULL : sendnum.data(); - view.recvnum = recvnum.empty() ? NULL : recvnum.data(); - view.firstrecv = firstrecv.empty() ? NULL : firstrecv.data(); - view.sendproc = sendproc.empty() ? NULL : sendproc.data(); - view.recvproc = recvproc.empty() ? NULL : recvproc.data(); - view.mapping = mapping.empty() ? NULL : mapping.data(); - view.sendlist_storage.resize(send_atom_indices.size()); - for (std::size_t iswap = 0; iswap < send_atom_indices.size(); ++iswap) - { - if (!send_atom_indices[iswap].empty()) - { - view.sendlist_storage[iswap] = send_atom_indices[iswap].data(); - } - else - { - view.sendlist_storage[iswap] = NULL; - } - } - return view; -} - void DomainDecomposition::init(const ModuleBase::CommunicationDomain& comm_domain, const ModuleBase::Matrix3& latvec, double lat0, @@ -195,275 +167,6 @@ void DomainDecomposition::migrate_owned_atoms(MDCell& cell) exchange_ghost_atoms(cell); } -void DomainDecomposition::exchange_ghost_atoms(MDCell& cell) -{ - synchronize_geometry_(cell); - const std::vector& owned_atoms = cell.owned_atoms_; - std::vector& ghost_atoms = cell.ghost_atoms_; - ghost_atoms.clear(); - ghost_layout_valid_ = false; - cell.clear_ghost_exchange_plan_(); - ghost_slots_.clear(); - build_ghost_exchange_slots(ghost_slots_); - std::vector& slots = ghost_slots_; - - const int nlayer[3] = {neighbor_layer(0), neighbor_layer(1), neighbor_layer(2)}; - const int span_y = 2 * nlayer[1] + 1; - const int span_z = 2 * nlayer[2] + 1; - const int lookup_size = (2 * nlayer[0] + 1) * span_y * span_z; - std::vector slot_lookup(static_cast(lookup_size), -1); - for (std::size_t islot = 0; islot < slots.size(); ++islot) - { - const std::array& offset = slots[islot].offset; - const int index = (offset[0] + nlayer[0]) * span_y * span_z - + (offset[1] + nlayer[1]) * span_z - + (offset[2] + nlayer[2]); - slot_lookup[static_cast(index)] = static_cast(islot); - } - - const auto collect_offsets = [&](const LocalAtom& atom, const int dim, std::vector& offsets) { - offsets.clear(); - for (int delta = -nlayer[dim]; delta <= nlayer[dim]; ++delta) - { - if (delta == 0) - { - offsets.push_back(0); - continue; - } - - const std::array offset = {{dim == 0 ? delta : 0, - dim == 1 ? delta : 0, - dim == 2 ? delta : 0}}; - std::array target_coords; - std::array image_shift; - target_for_offset(offset, target_coords, image_shift); - - const double frac_values[3] = { - atom.frac.x + image_shift[0], - atom.frac.y + image_shift[1], - atom.frac.z + image_shift[2] - }; - const double lo = static_cast(target_coords[dim]) / dims_[dim]; - const double hi = static_cast(target_coords[dim] + 1) / dims_[dim]; - if (frac_values[dim] >= lo - margin_[dim] && - frac_values[dim] < hi + margin_[dim]) - { - offsets.push_back(delta); - } - } - }; - - std::vector> send_buffers(slots.size()); - std::vector x_offsets; - std::vector y_offsets; - std::vector z_offsets; - for (size_t iat = 0; iat < owned_atoms.size(); ++iat) - { - const LocalAtom& atom = owned_atoms[iat]; - collect_offsets(atom, 0, x_offsets); - collect_offsets(atom, 1, y_offsets); - collect_offsets(atom, 2, z_offsets); - - for (const int dx : x_offsets) - { - for (const int dy : y_offsets) - { - for (const int dz : z_offsets) - { - if (dx == 0 && dy == 0 && dz == 0) - { - continue; - } - const int lookup_index = (dx + nlayer[0]) * span_y * span_z - + (dy + nlayer[1]) * span_z - + (dz + nlayer[2]); - const int slot_index = slot_lookup[static_cast(lookup_index)]; - assert(slot_index >= 0); - const GhostExchangeSlot& slot = slots[static_cast(slot_index)]; - send_buffers[static_cast(slot_index)].push_back(pack_atom(atom, slot.image_shift)); - slots[static_cast(slot_index)].send_atom_indices.push_back(static_cast(iat)); - } - } - } - } - - for (std::size_t islot = 0; islot < slots.size(); ++islot) - { - GhostExchangeSlot& slot = slots[islot]; - const std::vector& send_atoms = send_buffers[islot]; - slot.previous_fracs.clear(); - slot.dynamic_image_shifts.clear(); - slot.previous_fracs.reserve(slot.send_atom_indices.size()); - slot.dynamic_image_shifts.reserve(slot.send_atom_indices.size()); - for (const int index : slot.send_atom_indices) - { - const LocalAtom& atom = owned_atoms[static_cast(index)]; - slot.previous_fracs.push_back({{atom.frac.x, atom.frac.y, atom.frac.z}}); - slot.dynamic_image_shifts.push_back(slot.image_shift); - } - slot.ghost_begin = ghost_atoms.size(); - - if (send_atoms.size() > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("DomainDecomposition ghost send count exceeds int range."); - } - - int send_count = static_cast(send_atoms.size()); - int recv_count = 0; - exchange_bytes_(&send_count, sizeof(send_count), &recv_count, sizeof(recv_count), - slot.send_rank, slot.recv_rank, tag_ghost_count); - if (recv_count < 0) - { - throw std::runtime_error("Invalid ghost receive count."); - } - - std::vector recv_atoms(static_cast(recv_count)); - const std::size_t send_bytes_size = send_atoms.size() * sizeof(PackedAtom); - const std::size_t recv_bytes_size = recv_atoms.size() * sizeof(PackedAtom); - if (send_bytes_size > static_cast(std::numeric_limits::max()) || - recv_bytes_size > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("DomainDecomposition ghost message exceeds MPI int byte count range."); - } - const int send_bytes = static_cast(send_bytes_size); - const int recv_bytes = static_cast(recv_bytes_size); - - exchange_bytes_(send_atoms.data(), send_bytes, recv_atoms.data(), recv_bytes, - slot.send_rank, slot.recv_rank, tag_ghost_atoms); - - for (size_t i = 0; i < recv_atoms.size(); ++i) - { - ghost_atoms.push_back(unpack_ghost_atom(recv_atoms[i])); - } - slot.ghost_count = recv_count; - } - ghost_layout_valid_ = true; - cell.set_ghost_exchange_plan_(build_ghost_exchange_plan(cell)); - cell.clear_forces_(ghost_atoms); - cell.neighbor_layout_valid_ = false; -} - -GhostExchangePlan DomainDecomposition::build_ghost_exchange_plan(const MDCell& cell) const -{ - if (!initialized_ || !ghost_layout_valid_) - { - throw std::runtime_error("Ghost exchange plan is not available."); - } - - GhostExchangePlan plan; - plan.nprocs = size_; - plan.sendnum.reserve(ghost_slots_.size()); - plan.recvnum.reserve(ghost_slots_.size()); - plan.firstrecv.reserve(ghost_slots_.size()); - plan.send_atom_indices.reserve(ghost_slots_.size()); - plan.sendproc.reserve(ghost_slots_.size()); - plan.recvproc.reserve(ghost_slots_.size()); - - for (const GhostExchangeSlot& slot : ghost_slots_) - { - if (slot.send_atom_indices.size() > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("Ghost send list exceeds int range."); - } - if (slot.ghost_begin > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("Ghost receive offset exceeds int range."); - } - if (slot.ghost_count < 0) - { - throw std::runtime_error("Invalid ghost receive count."); - } - - plan.sendnum.push_back(static_cast(slot.send_atom_indices.size())); - plan.recvnum.push_back(slot.ghost_count); - const std::size_t firstrecv = cell.owned_atoms_.size() + slot.ghost_begin; - if (firstrecv > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("Ghost receive index exceeds int range."); - } - plan.firstrecv.push_back(static_cast(firstrecv)); - plan.send_atom_indices.push_back(slot.send_atom_indices); - plan.sendproc.push_back(slot.send_rank); - plan.recvproc.push_back(slot.recv_rank); - } - - if (plan.nprocs == 1) - { - const std::size_t natom = cell.owned_atoms_.size() + cell.ghost_atoms_.size(); - plan.mapping.resize(natom, 0); - std::map, int> owned_lookup; - for (std::size_t iat = 0; iat < cell.owned_atoms_.size(); ++iat) - { - const LocalAtom& atom = cell.owned_atoms_[iat]; - owned_lookup[std::make_pair(atom.type, atom.type_index)] = static_cast(iat); - plan.mapping[iat] = static_cast(iat); - } - for (std::size_t iat = 0; iat < cell.ghost_atoms_.size(); ++iat) - { - const LocalAtom& atom = cell.ghost_atoms_[iat]; - const std::map, int>::const_iterator owner - = owned_lookup.find(std::make_pair(atom.type, atom.type_index)); - if (owner == owned_lookup.end()) - { - throw std::runtime_error("Cannot match a single-rank ghost atom to an owned atom."); - } - plan.mapping[cell.owned_atoms_.size() + iat] = owner->second; - } - } - - return plan; -} - -void DomainDecomposition::update_ghost_atom_positions(MDCell& cell) -{ - synchronize_geometry_(cell); - if (!ghost_layout_valid_) - { - exchange_ghost_atoms(cell); - return; - } - - const std::vector& owned_atoms = cell.owned_atoms_; - std::vector& ghost_atoms = cell.ghost_atoms_; - for (std::size_t islot = 0; islot < ghost_slots_.size(); ++islot) - { - GhostExchangeSlot& slot = ghost_slots_[islot]; - // Keep wrapped fractional coordinates for metadata and send the - // dynamically selected image coordinates in the same message. - std::vector send_frac(6 * slot.send_atom_indices.size(), 0.0); - for (std::size_t i = 0; i < slot.send_atom_indices.size(); ++i) - { - const LocalAtom& atom = owned_atoms[static_cast(slot.send_atom_indices[i])]; - const std::array image_shift = image_shift_for_update( - atom, slot.previous_fracs[i], slot.dynamic_image_shifts[i], slot); - slot.previous_fracs[i] = {{atom.frac.x, atom.frac.y, atom.frac.z}}; - slot.dynamic_image_shifts[i] = image_shift; - send_frac[3 * i] = atom.frac.x; - send_frac[3 * i + 1] = atom.frac.y; - send_frac[3 * i + 2] = atom.frac.z; - send_frac[3 * slot.send_atom_indices.size() + 3 * i] = atom.frac.x + image_shift[0]; - send_frac[3 * slot.send_atom_indices.size() + 3 * i + 1] = atom.frac.y + image_shift[1]; - send_frac[3 * slot.send_atom_indices.size() + 3 * i + 2] = atom.frac.z + image_shift[2]; - } - std::vector recv_frac(6 * static_cast(slot.ghost_count), 0.0); - exchange_bytes_(send_frac.data(), send_frac.size() * sizeof(double), - recv_frac.data(), recv_frac.size() * sizeof(double), - slot.send_rank, slot.recv_rank, tag_ghost_positions); - for (int i = 0; i < slot.ghost_count; ++i) - { - LocalAtom& ghost = ghost_atoms[slot.ghost_begin + static_cast(i)]; - ghost.frac.set(recv_frac[3 * i], recv_frac[3 * i + 1], recv_frac[3 * i + 2]); - const ModuleBase::Vector3 image_frac( - recv_frac[3 * static_cast(slot.ghost_count) + 3 * i], - recv_frac[3 * static_cast(slot.ghost_count) + 3 * i + 1], - recv_frac[3 * static_cast(slot.ghost_count) + 3 * i + 2]); - ghost.cart = image_frac * latvec_; - ghost.force.set(0.0, 0.0, 0.0); - } - } - cell.clear_forces_(ghost_atoms); -} - void DomainDecomposition::accumulate_ghost_forces(MDCell& cell) { // Do not recreate geometry or ghost mappings between force evaluation and return. @@ -885,96 +588,6 @@ std::vector DomainDecomposition::split_owned_atoms_from_ucell(const U return owned_atoms; } -void DomainDecomposition::target_for_offset(const std::array& offset, - std::array& target_coords, - std::array& image_shift) const -{ - for (int idim = 0; idim < 3; ++idim) - { - const int unwrapped = coords_[idim] + offset[idim]; - const int period_shift = floor_div(unwrapped, dims_[idim]); - target_coords[idim] = positive_mod(unwrapped, dims_[idim]); - image_shift[idim] = -period_shift; - } -} - -std::array DomainDecomposition::image_shift_for_update( - const LocalAtom& atom, - const std::array& previous_frac, - const std::array& previous_image_shift, - const GhostExchangeSlot& slot) const -{ - std::array image_shift = previous_image_shift; - const double frac[3] = {atom.frac.x, atom.frac.y, atom.frac.z}; - for (int idim = 0; idim < 3; ++idim) - { - if (slot.offset[idim] == 0) - { - continue; - } - - const int crossing = static_cast(std::nearbyint(frac[idim] - previous_frac[idim])); - if (crossing == 0) - { - continue; - } - - // A positive wrapped displacement changes the image index in the - // opposite direction for a positive offset, and vice versa. This - // preserves the same physical image continuously across a boundary. - image_shift[idim] -= slot.offset[idim] > 0 ? crossing : -crossing; - } - return image_shift; -} - -int DomainDecomposition::neighbor_layer(int dim) const -{ - return std::max(1, static_cast(std::ceil(margin_[dim] * dims_[dim]))); -} - -void DomainDecomposition::build_ghost_exchange_slots(std::vector& slots) const -{ - slots.clear(); - - const int nlayer_x = neighbor_layer(0); - const int nlayer_y = neighbor_layer(1); - const int nlayer_z = neighbor_layer(2); - - slots.reserve(static_cast((2 * nlayer_x + 1) - * (2 * nlayer_y + 1) - * (2 * nlayer_z + 1) - - 1)); - for (int dx = -nlayer_x; dx <= nlayer_x; ++dx) - { - for (int dy = -nlayer_y; dy <= nlayer_y; ++dy) - { - for (int dz = -nlayer_z; dz <= nlayer_z; ++dz) - { - if (dx == 0 && dy == 0 && dz == 0) - { - continue; - } - - GhostExchangeSlot slot; - slot.offset = {{dx, dy, dz}}; - const std::array recv_offset = {{-dx, -dy, -dz}}; - std::array recv_coords; - target_for_offset(slot.offset, slot.target_coords, slot.image_shift); - target_for_offset(recv_offset, recv_coords, slot.recv_image_shift); - // target_for_offset gives our image in the receiving domain. - // Incoming coordinates need the inverse shift back into ours. - for (int dim = 0; dim < 3; ++dim) - { - slot.recv_image_shift[dim] = -slot.recv_image_shift[dim]; - } - slot.send_rank = rank_from_coords(slot.target_coords); - slot.recv_rank = rank_from_coords(recv_coords); - slots.push_back(slot); - } - } - } -} - DomainDecomposition::PackedAtom DomainDecomposition::pack_atom( const LocalAtom& atom, const std::array& image_shift) const diff --git a/source/source_cell/domain_decomposition_ghost.cpp b/source/source_cell/domain_decomposition_ghost.cpp new file mode 100644 index 00000000000..508fb4208e7 --- /dev/null +++ b/source/source_cell/domain_decomposition_ghost.cpp @@ -0,0 +1,402 @@ +#include "source_cell/domain_decomposition.h" +#include "source_cell/ghost_exchange_plan.h" +#include "source_cell/mdcell.h" + +#include +#include +#include +#include +#include +#include + +namespace +{ +const int tag_ghost_count = 9100; +const int tag_ghost_atoms = 9101; +const int tag_ghost_positions = 9110; +} + +GhostExchangePlanView GhostExchangePlan::make_view() +{ + GhostExchangePlanView view; + view.nswap = static_cast(sendnum.size()); + view.sendnum = sendnum.empty() ? NULL : sendnum.data(); + view.recvnum = recvnum.empty() ? NULL : recvnum.data(); + view.firstrecv = firstrecv.empty() ? NULL : firstrecv.data(); + view.sendproc = sendproc.empty() ? NULL : sendproc.data(); + view.recvproc = recvproc.empty() ? NULL : recvproc.data(); + view.mapping = mapping.empty() ? NULL : mapping.data(); + view.sendlist_storage.resize(send_atom_indices.size()); + for (std::size_t iswap = 0; iswap < send_atom_indices.size(); ++iswap) + { + if (!send_atom_indices[iswap].empty()) + { + view.sendlist_storage[iswap] = send_atom_indices[iswap].data(); + } + else + { + view.sendlist_storage[iswap] = NULL; + } + } + return view; +} + +void DomainDecomposition::exchange_ghost_atoms(MDCell& cell) +{ + synchronize_geometry_(cell); + const std::vector& owned_atoms = cell.owned_atoms_; + std::vector& ghost_atoms = cell.ghost_atoms_; + ghost_atoms.clear(); + ghost_layout_valid_ = false; + cell.clear_ghost_exchange_plan_(); + ghost_slots_.clear(); + build_ghost_exchange_slots(ghost_slots_); + std::vector& slots = ghost_slots_; + + const int nlayer[3] = {neighbor_layer(0), neighbor_layer(1), neighbor_layer(2)}; + const int span_y = 2 * nlayer[1] + 1; + const int span_z = 2 * nlayer[2] + 1; + const int lookup_size = (2 * nlayer[0] + 1) * span_y * span_z; + std::vector slot_lookup(static_cast(lookup_size), -1); + for (std::size_t islot = 0; islot < slots.size(); ++islot) + { + const std::array& offset = slots[islot].offset; + const int index = (offset[0] + nlayer[0]) * span_y * span_z + + (offset[1] + nlayer[1]) * span_z + + (offset[2] + nlayer[2]); + slot_lookup[static_cast(index)] = static_cast(islot); + } + + const auto collect_offsets = [&](const LocalAtom& atom, const int dim, std::vector& offsets) { + offsets.clear(); + for (int delta = -nlayer[dim]; delta <= nlayer[dim]; ++delta) + { + if (delta == 0) + { + offsets.push_back(0); + continue; + } + + const std::array offset = {{dim == 0 ? delta : 0, + dim == 1 ? delta : 0, + dim == 2 ? delta : 0}}; + std::array target_coords; + std::array image_shift; + target_for_offset(offset, target_coords, image_shift); + + const double frac_values[3] = { + atom.frac.x + image_shift[0], + atom.frac.y + image_shift[1], + atom.frac.z + image_shift[2] + }; + const double lo = static_cast(target_coords[dim]) / dims_[dim]; + const double hi = static_cast(target_coords[dim] + 1) / dims_[dim]; + if (frac_values[dim] >= lo - margin_[dim] && + frac_values[dim] < hi + margin_[dim]) + { + offsets.push_back(delta); + } + } + }; + + std::vector> send_buffers(slots.size()); + std::vector x_offsets; + std::vector y_offsets; + std::vector z_offsets; + for (size_t iat = 0; iat < owned_atoms.size(); ++iat) + { + const LocalAtom& atom = owned_atoms[iat]; + collect_offsets(atom, 0, x_offsets); + collect_offsets(atom, 1, y_offsets); + collect_offsets(atom, 2, z_offsets); + + for (const int dx : x_offsets) + { + for (const int dy : y_offsets) + { + for (const int dz : z_offsets) + { + if (dx == 0 && dy == 0 && dz == 0) + { + continue; + } + const int lookup_index = (dx + nlayer[0]) * span_y * span_z + + (dy + nlayer[1]) * span_z + + (dz + nlayer[2]); + const int slot_index = slot_lookup[static_cast(lookup_index)]; + assert(slot_index >= 0); + const GhostExchangeSlot& slot = slots[static_cast(slot_index)]; + send_buffers[static_cast(slot_index)].push_back(pack_atom(atom, slot.image_shift)); + slots[static_cast(slot_index)].send_atom_indices.push_back(static_cast(iat)); + } + } + } + } + + for (std::size_t islot = 0; islot < slots.size(); ++islot) + { + GhostExchangeSlot& slot = slots[islot]; + const std::vector& send_atoms = send_buffers[islot]; + slot.previous_fracs.clear(); + slot.dynamic_image_shifts.clear(); + slot.previous_fracs.reserve(slot.send_atom_indices.size()); + slot.dynamic_image_shifts.reserve(slot.send_atom_indices.size()); + for (const int index : slot.send_atom_indices) + { + const LocalAtom& atom = owned_atoms[static_cast(index)]; + slot.previous_fracs.push_back({{atom.frac.x, atom.frac.y, atom.frac.z}}); + slot.dynamic_image_shifts.push_back(slot.image_shift); + } + slot.ghost_begin = ghost_atoms.size(); + + if (send_atoms.size() > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("DomainDecomposition ghost send count exceeds int range."); + } + + int send_count = static_cast(send_atoms.size()); + int recv_count = 0; + exchange_bytes_(&send_count, sizeof(send_count), &recv_count, sizeof(recv_count), + slot.send_rank, slot.recv_rank, tag_ghost_count); + if (recv_count < 0) + { + throw std::runtime_error("Invalid ghost receive count."); + } + + std::vector recv_atoms(static_cast(recv_count)); + const std::size_t send_bytes_size = send_atoms.size() * sizeof(PackedAtom); + const std::size_t recv_bytes_size = recv_atoms.size() * sizeof(PackedAtom); + if (send_bytes_size > static_cast(std::numeric_limits::max()) || + recv_bytes_size > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("DomainDecomposition ghost message exceeds MPI int byte count range."); + } + const int send_bytes = static_cast(send_bytes_size); + const int recv_bytes = static_cast(recv_bytes_size); + + exchange_bytes_(send_atoms.data(), send_bytes, recv_atoms.data(), recv_bytes, + slot.send_rank, slot.recv_rank, tag_ghost_atoms); + + for (size_t i = 0; i < recv_atoms.size(); ++i) + { + ghost_atoms.push_back(unpack_ghost_atom(recv_atoms[i])); + } + slot.ghost_count = recv_count; + } + ghost_layout_valid_ = true; + cell.set_ghost_exchange_plan_(build_ghost_exchange_plan(cell)); + cell.clear_forces_(ghost_atoms); + cell.neighbor_layout_valid_ = false; +} + +GhostExchangePlan DomainDecomposition::build_ghost_exchange_plan(const MDCell& cell) const +{ + if (!initialized_ || !ghost_layout_valid_) + { + throw std::runtime_error("Ghost exchange plan is not available."); + } + + GhostExchangePlan plan; + plan.nprocs = size_; + plan.sendnum.reserve(ghost_slots_.size()); + plan.recvnum.reserve(ghost_slots_.size()); + plan.firstrecv.reserve(ghost_slots_.size()); + plan.send_atom_indices.reserve(ghost_slots_.size()); + plan.sendproc.reserve(ghost_slots_.size()); + plan.recvproc.reserve(ghost_slots_.size()); + + for (const GhostExchangeSlot& slot : ghost_slots_) + { + if (slot.send_atom_indices.size() > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("Ghost send list exceeds int range."); + } + if (slot.ghost_begin > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("Ghost receive offset exceeds int range."); + } + if (slot.ghost_count < 0) + { + throw std::runtime_error("Invalid ghost receive count."); + } + + plan.sendnum.push_back(static_cast(slot.send_atom_indices.size())); + plan.recvnum.push_back(slot.ghost_count); + const std::size_t firstrecv = cell.owned_atoms_.size() + slot.ghost_begin; + if (firstrecv > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("Ghost receive index exceeds int range."); + } + plan.firstrecv.push_back(static_cast(firstrecv)); + plan.send_atom_indices.push_back(slot.send_atom_indices); + plan.sendproc.push_back(slot.send_rank); + plan.recvproc.push_back(slot.recv_rank); + } + + if (plan.nprocs == 1) + { + const std::size_t natom = cell.owned_atoms_.size() + cell.ghost_atoms_.size(); + plan.mapping.resize(natom, 0); + std::map, int> owned_lookup; + for (std::size_t iat = 0; iat < cell.owned_atoms_.size(); ++iat) + { + const LocalAtom& atom = cell.owned_atoms_[iat]; + owned_lookup[std::make_pair(atom.type, atom.type_index)] = static_cast(iat); + plan.mapping[iat] = static_cast(iat); + } + for (std::size_t iat = 0; iat < cell.ghost_atoms_.size(); ++iat) + { + const LocalAtom& atom = cell.ghost_atoms_[iat]; + const std::map, int>::const_iterator owner + = owned_lookup.find(std::make_pair(atom.type, atom.type_index)); + if (owner == owned_lookup.end()) + { + throw std::runtime_error("Cannot match a single-rank ghost atom to an owned atom."); + } + plan.mapping[cell.owned_atoms_.size() + iat] = owner->second; + } + } + + return plan; +} + +void DomainDecomposition::update_ghost_atom_positions(MDCell& cell) +{ + synchronize_geometry_(cell); + if (!ghost_layout_valid_) + { + exchange_ghost_atoms(cell); + return; + } + + const std::vector& owned_atoms = cell.owned_atoms_; + std::vector& ghost_atoms = cell.ghost_atoms_; + for (std::size_t islot = 0; islot < ghost_slots_.size(); ++islot) + { + GhostExchangeSlot& slot = ghost_slots_[islot]; + // Keep wrapped fractional coordinates for metadata and send the + // dynamically selected image coordinates in the same message. + std::vector send_frac(6 * slot.send_atom_indices.size(), 0.0); + for (std::size_t i = 0; i < slot.send_atom_indices.size(); ++i) + { + const LocalAtom& atom = owned_atoms[static_cast(slot.send_atom_indices[i])]; + const std::array image_shift = image_shift_for_update( + atom, slot.previous_fracs[i], slot.dynamic_image_shifts[i], slot); + slot.previous_fracs[i] = {{atom.frac.x, atom.frac.y, atom.frac.z}}; + slot.dynamic_image_shifts[i] = image_shift; + send_frac[3 * i] = atom.frac.x; + send_frac[3 * i + 1] = atom.frac.y; + send_frac[3 * i + 2] = atom.frac.z; + send_frac[3 * slot.send_atom_indices.size() + 3 * i] = atom.frac.x + image_shift[0]; + send_frac[3 * slot.send_atom_indices.size() + 3 * i + 1] = atom.frac.y + image_shift[1]; + send_frac[3 * slot.send_atom_indices.size() + 3 * i + 2] = atom.frac.z + image_shift[2]; + } + std::vector recv_frac(6 * static_cast(slot.ghost_count), 0.0); + exchange_bytes_(send_frac.data(), send_frac.size() * sizeof(double), + recv_frac.data(), recv_frac.size() * sizeof(double), + slot.send_rank, slot.recv_rank, tag_ghost_positions); + for (int i = 0; i < slot.ghost_count; ++i) + { + LocalAtom& ghost = ghost_atoms[slot.ghost_begin + static_cast(i)]; + ghost.frac.set(recv_frac[3 * i], recv_frac[3 * i + 1], recv_frac[3 * i + 2]); + const ModuleBase::Vector3 image_frac( + recv_frac[3 * static_cast(slot.ghost_count) + 3 * i], + recv_frac[3 * static_cast(slot.ghost_count) + 3 * i + 1], + recv_frac[3 * static_cast(slot.ghost_count) + 3 * i + 2]); + ghost.cart = image_frac * latvec_; + ghost.force.set(0.0, 0.0, 0.0); + } + } + cell.clear_forces_(ghost_atoms); +} + +void DomainDecomposition::target_for_offset(const std::array& offset, + std::array& target_coords, + std::array& image_shift) const +{ + for (int idim = 0; idim < 3; ++idim) + { + const int unwrapped = coords_[idim] + offset[idim]; + const int period_shift = floor_div(unwrapped, dims_[idim]); + target_coords[idim] = positive_mod(unwrapped, dims_[idim]); + image_shift[idim] = -period_shift; + } +} + +std::array DomainDecomposition::image_shift_for_update( + const LocalAtom& atom, + const std::array& previous_frac, + const std::array& previous_image_shift, + const GhostExchangeSlot& slot) const +{ + std::array image_shift = previous_image_shift; + const double frac[3] = {atom.frac.x, atom.frac.y, atom.frac.z}; + for (int idim = 0; idim < 3; ++idim) + { + if (slot.offset[idim] == 0) + { + continue; + } + + const int crossing = static_cast(std::nearbyint(frac[idim] - previous_frac[idim])); + if (crossing == 0) + { + continue; + } + + // A positive wrapped displacement changes the image index in the + // opposite direction for a positive offset, and vice versa. This + // preserves the same physical image continuously across a boundary. + image_shift[idim] -= slot.offset[idim] > 0 ? crossing : -crossing; + } + return image_shift; +} + +int DomainDecomposition::neighbor_layer(int dim) const +{ + return std::max(1, static_cast(std::ceil(margin_[dim] * dims_[dim]))); +} + +void DomainDecomposition::build_ghost_exchange_slots(std::vector& slots) const +{ + slots.clear(); + + const int nlayer_x = neighbor_layer(0); + const int nlayer_y = neighbor_layer(1); + const int nlayer_z = neighbor_layer(2); + + slots.reserve(static_cast((2 * nlayer_x + 1) + * (2 * nlayer_y + 1) + * (2 * nlayer_z + 1) + - 1)); + for (int dx = -nlayer_x; dx <= nlayer_x; ++dx) + { + for (int dy = -nlayer_y; dy <= nlayer_y; ++dy) + { + for (int dz = -nlayer_z; dz <= nlayer_z; ++dz) + { + if (dx == 0 && dy == 0 && dz == 0) + { + continue; + } + + GhostExchangeSlot slot; + slot.offset = {{dx, dy, dz}}; + const std::array recv_offset = {{-dx, -dy, -dz}}; + std::array recv_coords; + target_for_offset(slot.offset, slot.target_coords, slot.image_shift); + target_for_offset(recv_offset, recv_coords, slot.recv_image_shift); + // target_for_offset gives our image in the receiving domain. + // Incoming coordinates need the inverse shift back into ours. + for (int dim = 0; dim < 3; ++dim) + { + slot.recv_image_shift[dim] = -slot.recv_image_shift[dim]; + } + slot.send_rank = rank_from_coords(slot.target_coords); + slot.recv_rank = rank_from_coords(recv_coords); + slots.push_back(slot); + } + } + } +} + diff --git a/source/source_cell/module_neighlist/test/CMakeLists.txt b/source/source_cell/module_neighlist/test/CMakeLists.txt index 58d56bd9daa..c0f57d69318 100644 --- a/source/source_cell/module_neighlist/test/CMakeLists.txt +++ b/source/source_cell/module_neighlist/test/CMakeLists.txt @@ -8,7 +8,7 @@ addtest( TARGET MODULE_CELL_NEIGHBOR_neighbor_search LIBS parameter base device cell neighbor symmetry SOURCES test_neighbor_search.cpp ../neighbor_search.cpp - ../../domain_decomposition.cpp ../bin_manager.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../bin_manager.cpp ../page_allocator.cpp) addtest( @@ -41,7 +41,7 @@ if(ENABLE_MPI) test_mdcell_migrate_mpi.cpp test_domain_decomposition.cpp ../../mdcell.cpp - ../../domain_decomposition.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) @@ -86,7 +86,7 @@ if(ENABLE_MPI) ../../mdcell.cpp ../../print_cell.cpp ../../stru_frame_io.cpp - ../../domain_decomposition.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) diff --git a/source/source_md/test/CMakeLists.txt b/source/source_md/test/CMakeLists.txt index 65143d5486e..ac8fb43c7ea 100644 --- a/source/source_md/test/CMakeLists.txt +++ b/source/source_md/test/CMakeLists.txt @@ -56,6 +56,7 @@ list( ../../source_cell/module_neighlist/bin_manager.cpp ../../source_cell/module_neighlist/page_allocator.cpp ../../source_cell/domain_decomposition.cpp + ../../source_cell/domain_decomposition_ghost.cpp ../../source_cell/mdcell.cpp ../../source_base/output.cpp ../../source_io/module_output/output_log.cpp From 600d3d67639cc50bc17a216828c4fef0df15eecb Mon Sep 17 00:00:00 2001 From: Fei Yang <2501213217@stu.pku.edu.cn> Date: Thu, 5 Nov 2026 14:13:19 +0800 Subject: [PATCH 2/5] refactor(cell): extract domain atom migration implementation --- source/Makefile.Objects | 1 + source/source_cell/CMakeLists.txt | 2 +- source/source_cell/domain_decomposition.cpp | 228 ----------------- .../domain_decomposition_migration.cpp | 238 ++++++++++++++++++ .../module_neighlist/test/CMakeLists.txt | 6 +- source/source_md/test/CMakeLists.txt | 1 + 6 files changed, 244 insertions(+), 232 deletions(-) create mode 100644 source/source_cell/domain_decomposition_migration.cpp diff --git a/source/Makefile.Objects b/source/Makefile.Objects index c2791a05317..18541831942 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -251,6 +251,7 @@ OBJS_CELL=atom_pseudo.o\ mdcell.o\ domain_decomposition.o\ domain_decomposition_ghost.o\ + domain_decomposition_migration.o\ cif_io.o\ ucell_io.o\ diff --git a/source/source_cell/CMakeLists.txt b/source/source_cell/CMakeLists.txt index f4d5b332d32..2926beb0877 100644 --- a/source/source_cell/CMakeLists.txt +++ b/source/source_cell/CMakeLists.txt @@ -2,7 +2,7 @@ add_subdirectory(module_symmetry) add_subdirectory(module_neighbor) add_subdirectory(module_neighlist) -add_library(domain_decomposition OBJECT domain_decomposition.cpp domain_decomposition_ghost.cpp) +add_library(domain_decomposition OBJECT domain_decomposition.cpp domain_decomposition_ghost.cpp domain_decomposition_migration.cpp) add_library( cell OBJECT diff --git a/source/source_cell/domain_decomposition.cpp b/source/source_cell/domain_decomposition.cpp index e79c12f6c0b..08d038d97c9 100644 --- a/source/source_cell/domain_decomposition.cpp +++ b/source/source_cell/domain_decomposition.cpp @@ -15,8 +15,6 @@ namespace { -const int tag_migration_count_base = 100; -const int tag_migration_atoms_base = 200; const int tag_ghost_force_size = 9200; const int tag_ghost_forces = 9201; } @@ -76,97 +74,6 @@ void DomainDecomposition::init(const ModuleBase::CommunicationDomain& comm_domai update_geometry_(latvec, lat0, cutoff, skin); } -void DomainDecomposition::migrate_owned_atoms(MDCell& cell) -{ - synchronize_geometry_(cell); - std::vector& owned_atoms = cell.owned_atoms_; - const int direction_count = 6; - const int axis[direction_count] = {0, 0, 1, 1, 2, 2}; - const int step[direction_count] = {-1, 1, -1, 1, -1, 1}; - std::array neighbors; - for (int idir = 0; idir < direction_count; ++idir) - { - std::array neighbor_coords = coords_; - neighbor_coords[axis[idir]] = positive_mod(neighbor_coords[axis[idir]] + step[idir], dims_[axis[idir]]); - neighbors[idir] = rank_from_coords(neighbor_coords); - } - - std::vector pending_atoms; - pending_atoms.swap(owned_atoms); - std::vector retained_atoms; - retained_atoms.reserve(pending_atoms.size()); - const std::array no_shift = {{0, 0, 0}}; - - long long global_outgoing = 0; - do - { - std::array, direction_count> send_atoms; - for (std::size_t i = 0; i < pending_atoms.size(); ++i) - { - LocalAtom atom = std::move(pending_atoms[i]); - atom.frac = wrapped_frac_from_cart(atom.cart); - atom.cart = atom.frac * latvec_; - - std::array owner_coords; - const double frac[3] = {atom.frac.x, atom.frac.y, atom.frac.z}; - for (int idim = 0; idim < 3; ++idim) - { - owner_coords[idim] = std::min(static_cast(std::floor(frac[idim] * dims_[idim])), dims_[idim] - 1); - } - atom.owner_rank = rank_from_coords(owner_coords); - if (atom.owner_rank == rank_) - { - retained_atoms.push_back(std::move(atom)); - continue; - } - - int direction = -1; - for (int idim = 0; idim < 3 && direction < 0; ++idim) - { - int delta = owner_coords[idim] - coords_[idim]; - if (delta > dims_[idim] / 2) delta -= dims_[idim]; - if (delta < -dims_[idim] / 2) delta += dims_[idim]; - if (delta != 0) direction = 2 * idim + (delta > 0 ? 1 : 0); - } - assert(direction >= 0); - send_atoms[direction].push_back(pack_atom(atom, no_shift)); - } - pending_atoms.clear(); - - std::array send_counts; - long long local_outgoing = 0; - for (int idir = 0; idir < direction_count; ++idir) - { - const std::size_t bytes = send_atoms[idir].size() * sizeof(PackedAtom); - if (bytes > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("DomainDecomposition migration send count exceeds int range."); - } - send_counts[idir] = static_cast(bytes); - local_outgoing += static_cast(send_atoms[idir].size()); - } - global_outgoing = local_outgoing; -#ifdef __MPI - MPI_Allreduce(MPI_IN_PLACE, &global_outgoing, 1, MPI_LONG_LONG, MPI_SUM, comm_); -#endif - if (global_outgoing == 0) break; - - std::array, direction_count> recv_atoms; - exchange_migration_(neighbors, send_atoms, send_counts, recv_atoms); - - for (int idir = 0; idir < direction_count; ++idir) - { - for (std::size_t i = 0; i < recv_atoms[idir].size(); ++i) - { - pending_atoms.push_back(unpack_owned_atom(recv_atoms[idir][i])); - } - } - } while (global_outgoing > 0); - - owned_atoms.swap(retained_atoms); - exchange_ghost_atoms(cell); -} - void DomainDecomposition::accumulate_ghost_forces(MDCell& cell) { // Do not recreate geometry or ghost mappings between force evaluation and return. @@ -453,58 +360,6 @@ void DomainDecomposition::exchange_bytes_(const void* send, std::size_t send_byt #endif } -void DomainDecomposition::exchange_migration_( - const std::array& neighbors, - const std::array, 6>& send_atoms, - const std::array& send_counts, - std::array, 6>& recv_atoms) const -{ - const int direction_count = 6; - if (size_ == 1) - { - for (int idir = 0; idir < direction_count; ++idir) - { - recv_atoms[idir] = send_atoms[idir ^ 1]; - } - return; - } -#ifdef __MPI - std::array recv_counts; - std::array requests; - for (int idir = 0; idir < direction_count; ++idir) - { - const int opposite = idir ^ 1; - MPI_Irecv(&recv_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + opposite, comm_, &requests[idir]); - MPI_Isend(&send_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + idir, comm_, &requests[direction_count + idir]); - } - MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); - - for (int idir = 0; idir < direction_count; ++idir) - { - if (recv_counts[idir] < 0 || recv_counts[idir] % static_cast(sizeof(PackedAtom)) != 0) - { - throw std::runtime_error("Invalid DomainDecomposition migration receive count."); - } - recv_atoms[idir].resize(static_cast(recv_counts[idir] / static_cast(sizeof(PackedAtom)))); - } - - for (int idir = 0; idir < direction_count; ++idir) - { - const int opposite = idir ^ 1; - MPI_Irecv(recv_atoms[idir].empty() ? NULL : reinterpret_cast(&recv_atoms[idir][0]), - recv_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + opposite, comm_, &requests[idir]); - MPI_Isend(send_atoms[idir].empty() ? NULL : reinterpret_cast(&send_atoms[idir][0]), - send_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + idir, comm_, &requests[direction_count + idir]); - } - MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); - -#else - static_cast(neighbors); - static_cast(send_counts); - throw std::runtime_error("A serial communication domain cannot migrate to a remote rank."); -#endif -} - double DomainDecomposition::wrap_fractional(double value) { value -= std::floor(value); @@ -587,86 +442,3 @@ std::vector DomainDecomposition::split_owned_atoms_from_ucell(const U } return owned_atoms; } - -DomainDecomposition::PackedAtom DomainDecomposition::pack_atom( - const LocalAtom& atom, - const std::array& image_shift) const -{ - PackedAtom packed; - packed.frac[0] = atom.frac.x; - packed.frac[1] = atom.frac.y; - packed.frac[2] = atom.frac.z; - packed.vel[0] = atom.vel.x; - packed.vel[1] = atom.vel.y; - packed.vel[2] = atom.vel.z; - packed.force[0] = atom.force.x; - packed.force[1] = atom.force.y; - packed.force[2] = atom.force.z; - packed.mbl[0] = atom.mbl.x; - packed.mbl[1] = atom.mbl.y; - packed.mbl[2] = atom.mbl.z; - for (int axis = 0; axis < 3; ++axis) - { - packed.displacement[axis] = atom.displacement[axis]; - packed.boundary_shift[axis] = atom.boundary_shift[axis]; - } - packed.mass = atom.mass; - packed.image_shift[0] = image_shift[0]; - packed.image_shift[1] = image_shift[1]; - packed.image_shift[2] = image_shift[2]; - packed.type = atom.type; - packed.type_index = atom.type_index; - packed.owner_rank = atom.owner_rank; - return packed; -} - -LocalAtom DomainDecomposition::unpack_ghost_atom(const PackedAtom& packed) const -{ - const ModuleBase::Vector3 frac(packed.frac[0], packed.frac[1], packed.frac[2]); - const ModuleBase::Vector3 image_frac(packed.frac[0] + packed.image_shift[0], - packed.frac[1] + packed.image_shift[1], - packed.frac[2] + packed.image_shift[2]); - const ModuleBase::Vector3 cart = image_frac * latvec_; - const ModuleBase::Vector3 vel(packed.vel[0], packed.vel[1], packed.vel[2]); - const ModuleBase::Vector3 force(packed.force[0], packed.force[1], packed.force[2]); - const ModuleBase::Vector3 mbl(packed.mbl[0], packed.mbl[1], packed.mbl[2]); - LocalAtom atom(cart, - frac, - vel, - force, - mbl, - packed.mass, - packed.type, - packed.type_index, - packed.owner_rank); - for (int axis = 0; axis < 3; ++axis) - { - atom.displacement[axis] = packed.displacement[axis]; - atom.boundary_shift[axis] = packed.boundary_shift[axis]; - } - return atom; -} - -LocalAtom DomainDecomposition::unpack_owned_atom(const PackedAtom& packed) const -{ - const ModuleBase::Vector3 frac(packed.frac[0], packed.frac[1], packed.frac[2]); - const ModuleBase::Vector3 cart = frac * latvec_; - const ModuleBase::Vector3 vel(packed.vel[0], packed.vel[1], packed.vel[2]); - const ModuleBase::Vector3 force(packed.force[0], packed.force[1], packed.force[2]); - const ModuleBase::Vector3 mbl(packed.mbl[0], packed.mbl[1], packed.mbl[2]); - LocalAtom atom(cart, - frac, - vel, - force, - mbl, - packed.mass, - packed.type, - packed.type_index, - packed.owner_rank); - for (int axis = 0; axis < 3; ++axis) - { - atom.displacement[axis] = packed.displacement[axis]; - atom.boundary_shift[axis] = packed.boundary_shift[axis]; - } - return atom; -} diff --git a/source/source_cell/domain_decomposition_migration.cpp b/source/source_cell/domain_decomposition_migration.cpp new file mode 100644 index 00000000000..db2a9707565 --- /dev/null +++ b/source/source_cell/domain_decomposition_migration.cpp @@ -0,0 +1,238 @@ +#include "source_cell/domain_decomposition.h" +#include "source_cell/mdcell.h" + +#include +#include +#include + +namespace +{ +const int tag_migration_count_base = 100; +const int tag_migration_atoms_base = 200; +} + +void DomainDecomposition::migrate_owned_atoms(MDCell& cell) +{ + synchronize_geometry_(cell); + std::vector& owned_atoms = cell.owned_atoms_; + const int direction_count = 6; + const int axis[direction_count] = {0, 0, 1, 1, 2, 2}; + const int step[direction_count] = {-1, 1, -1, 1, -1, 1}; + std::array neighbors; + for (int idir = 0; idir < direction_count; ++idir) + { + std::array neighbor_coords = coords_; + neighbor_coords[axis[idir]] = positive_mod(neighbor_coords[axis[idir]] + step[idir], dims_[axis[idir]]); + neighbors[idir] = rank_from_coords(neighbor_coords); + } + + std::vector pending_atoms; + pending_atoms.swap(owned_atoms); + std::vector retained_atoms; + retained_atoms.reserve(pending_atoms.size()); + const std::array no_shift = {{0, 0, 0}}; + + long long global_outgoing = 0; + do + { + std::array, direction_count> send_atoms; + for (std::size_t i = 0; i < pending_atoms.size(); ++i) + { + LocalAtom atom = std::move(pending_atoms[i]); + atom.frac = wrapped_frac_from_cart(atom.cart); + atom.cart = atom.frac * latvec_; + + std::array owner_coords; + const double frac[3] = {atom.frac.x, atom.frac.y, atom.frac.z}; + for (int idim = 0; idim < 3; ++idim) + { + owner_coords[idim] = std::min(static_cast(std::floor(frac[idim] * dims_[idim])), dims_[idim] - 1); + } + atom.owner_rank = rank_from_coords(owner_coords); + if (atom.owner_rank == rank_) + { + retained_atoms.push_back(std::move(atom)); + continue; + } + + int direction = -1; + for (int idim = 0; idim < 3 && direction < 0; ++idim) + { + int delta = owner_coords[idim] - coords_[idim]; + if (delta > dims_[idim] / 2) delta -= dims_[idim]; + if (delta < -dims_[idim] / 2) delta += dims_[idim]; + if (delta != 0) direction = 2 * idim + (delta > 0 ? 1 : 0); + } + assert(direction >= 0); + send_atoms[direction].push_back(pack_atom(atom, no_shift)); + } + pending_atoms.clear(); + + std::array send_counts; + long long local_outgoing = 0; + for (int idir = 0; idir < direction_count; ++idir) + { + const std::size_t bytes = send_atoms[idir].size() * sizeof(PackedAtom); + if (bytes > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("DomainDecomposition migration send count exceeds int range."); + } + send_counts[idir] = static_cast(bytes); + local_outgoing += static_cast(send_atoms[idir].size()); + } + global_outgoing = local_outgoing; +#ifdef __MPI + MPI_Allreduce(MPI_IN_PLACE, &global_outgoing, 1, MPI_LONG_LONG, MPI_SUM, comm_); +#endif + if (global_outgoing == 0) break; + + std::array, direction_count> recv_atoms; + exchange_migration_(neighbors, send_atoms, send_counts, recv_atoms); + + for (int idir = 0; idir < direction_count; ++idir) + { + for (std::size_t i = 0; i < recv_atoms[idir].size(); ++i) + { + pending_atoms.push_back(unpack_owned_atom(recv_atoms[idir][i])); + } + } + } while (global_outgoing > 0); + + owned_atoms.swap(retained_atoms); + exchange_ghost_atoms(cell); +} + +void DomainDecomposition::exchange_migration_( + const std::array& neighbors, + const std::array, 6>& send_atoms, + const std::array& send_counts, + std::array, 6>& recv_atoms) const +{ + const int direction_count = 6; + if (size_ == 1) + { + for (int idir = 0; idir < direction_count; ++idir) + { + recv_atoms[idir] = send_atoms[idir ^ 1]; + } + return; + } +#ifdef __MPI + std::array recv_counts; + std::array requests; + for (int idir = 0; idir < direction_count; ++idir) + { + const int opposite = idir ^ 1; + MPI_Irecv(&recv_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + opposite, comm_, &requests[idir]); + MPI_Isend(&send_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + idir, comm_, &requests[direction_count + idir]); + } + MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); + + for (int idir = 0; idir < direction_count; ++idir) + { + if (recv_counts[idir] < 0 || recv_counts[idir] % static_cast(sizeof(PackedAtom)) != 0) + { + throw std::runtime_error("Invalid DomainDecomposition migration receive count."); + } + recv_atoms[idir].resize(static_cast(recv_counts[idir] / static_cast(sizeof(PackedAtom)))); + } + + for (int idir = 0; idir < direction_count; ++idir) + { + const int opposite = idir ^ 1; + MPI_Irecv(recv_atoms[idir].empty() ? NULL : reinterpret_cast(&recv_atoms[idir][0]), + recv_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + opposite, comm_, &requests[idir]); + MPI_Isend(send_atoms[idir].empty() ? NULL : reinterpret_cast(&send_atoms[idir][0]), + send_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + idir, comm_, &requests[direction_count + idir]); + } + MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); + +#else + static_cast(neighbors); + static_cast(send_counts); + throw std::runtime_error("A serial communication domain cannot migrate to a remote rank."); +#endif +} + +DomainDecomposition::PackedAtom DomainDecomposition::pack_atom( + const LocalAtom& atom, + const std::array& image_shift) const +{ + PackedAtom packed; + packed.frac[0] = atom.frac.x; + packed.frac[1] = atom.frac.y; + packed.frac[2] = atom.frac.z; + packed.vel[0] = atom.vel.x; + packed.vel[1] = atom.vel.y; + packed.vel[2] = atom.vel.z; + packed.force[0] = atom.force.x; + packed.force[1] = atom.force.y; + packed.force[2] = atom.force.z; + packed.mbl[0] = atom.mbl.x; + packed.mbl[1] = atom.mbl.y; + packed.mbl[2] = atom.mbl.z; + for (int axis = 0; axis < 3; ++axis) + { + packed.displacement[axis] = atom.displacement[axis]; + packed.boundary_shift[axis] = atom.boundary_shift[axis]; + } + packed.mass = atom.mass; + packed.image_shift[0] = image_shift[0]; + packed.image_shift[1] = image_shift[1]; + packed.image_shift[2] = image_shift[2]; + packed.type = atom.type; + packed.type_index = atom.type_index; + packed.owner_rank = atom.owner_rank; + return packed; +} + +LocalAtom DomainDecomposition::unpack_ghost_atom(const PackedAtom& packed) const +{ + const ModuleBase::Vector3 frac(packed.frac[0], packed.frac[1], packed.frac[2]); + const ModuleBase::Vector3 image_frac(packed.frac[0] + packed.image_shift[0], + packed.frac[1] + packed.image_shift[1], + packed.frac[2] + packed.image_shift[2]); + const ModuleBase::Vector3 cart = image_frac * latvec_; + const ModuleBase::Vector3 vel(packed.vel[0], packed.vel[1], packed.vel[2]); + const ModuleBase::Vector3 force(packed.force[0], packed.force[1], packed.force[2]); + const ModuleBase::Vector3 mbl(packed.mbl[0], packed.mbl[1], packed.mbl[2]); + LocalAtom atom(cart, + frac, + vel, + force, + mbl, + packed.mass, + packed.type, + packed.type_index, + packed.owner_rank); + for (int axis = 0; axis < 3; ++axis) + { + atom.displacement[axis] = packed.displacement[axis]; + atom.boundary_shift[axis] = packed.boundary_shift[axis]; + } + return atom; +} + +LocalAtom DomainDecomposition::unpack_owned_atom(const PackedAtom& packed) const +{ + const ModuleBase::Vector3 frac(packed.frac[0], packed.frac[1], packed.frac[2]); + const ModuleBase::Vector3 cart = frac * latvec_; + const ModuleBase::Vector3 vel(packed.vel[0], packed.vel[1], packed.vel[2]); + const ModuleBase::Vector3 force(packed.force[0], packed.force[1], packed.force[2]); + const ModuleBase::Vector3 mbl(packed.mbl[0], packed.mbl[1], packed.mbl[2]); + LocalAtom atom(cart, + frac, + vel, + force, + mbl, + packed.mass, + packed.type, + packed.type_index, + packed.owner_rank); + for (int axis = 0; axis < 3; ++axis) + { + atom.displacement[axis] = packed.displacement[axis]; + atom.boundary_shift[axis] = packed.boundary_shift[axis]; + } + return atom; +} diff --git a/source/source_cell/module_neighlist/test/CMakeLists.txt b/source/source_cell/module_neighlist/test/CMakeLists.txt index c0f57d69318..f6ba6418b72 100644 --- a/source/source_cell/module_neighlist/test/CMakeLists.txt +++ b/source/source_cell/module_neighlist/test/CMakeLists.txt @@ -8,7 +8,7 @@ addtest( TARGET MODULE_CELL_NEIGHBOR_neighbor_search LIBS parameter base device cell neighbor symmetry SOURCES test_neighbor_search.cpp ../neighbor_search.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../bin_manager.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp ../bin_manager.cpp ../page_allocator.cpp) addtest( @@ -41,7 +41,7 @@ if(ENABLE_MPI) test_mdcell_migrate_mpi.cpp test_domain_decomposition.cpp ../../mdcell.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) @@ -86,7 +86,7 @@ if(ENABLE_MPI) ../../mdcell.cpp ../../print_cell.cpp ../../stru_frame_io.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp + ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) diff --git a/source/source_md/test/CMakeLists.txt b/source/source_md/test/CMakeLists.txt index ac8fb43c7ea..e915a700d64 100644 --- a/source/source_md/test/CMakeLists.txt +++ b/source/source_md/test/CMakeLists.txt @@ -57,6 +57,7 @@ list( ../../source_cell/module_neighlist/page_allocator.cpp ../../source_cell/domain_decomposition.cpp ../../source_cell/domain_decomposition_ghost.cpp + ../../source_cell/domain_decomposition_migration.cpp ../../source_cell/mdcell.cpp ../../source_base/output.cpp ../../source_io/module_output/output_log.cpp From 94339899f8b0ae494c8f550749e54ceb99cc0365 Mon Sep 17 00:00:00 2001 From: Fei Yang <2501213217@stu.pku.edu.cn> Date: Thu, 5 Nov 2026 14:14:58 +0800 Subject: [PATCH 3/5] refactor(cell): extract domain ghost force accumulation --- source/Makefile.Objects | 1 + source/source_cell/CMakeLists.txt | 6 +- source/source_cell/domain_decomposition.cpp | 166 ++++++------------ .../domain_decomposition_force.cpp | 122 +++++++++++++ .../domain_decomposition_migration.cpp | 59 ------- .../module_neighlist/test/CMakeLists.txt | 16 +- source/source_md/test/CMakeLists.txt | 1 + 7 files changed, 196 insertions(+), 175 deletions(-) create mode 100644 source/source_cell/domain_decomposition_force.cpp diff --git a/source/Makefile.Objects b/source/Makefile.Objects index 18541831942..687ef0e0c1c 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -252,6 +252,7 @@ OBJS_CELL=atom_pseudo.o\ domain_decomposition.o\ domain_decomposition_ghost.o\ domain_decomposition_migration.o\ + domain_decomposition_force.o\ cif_io.o\ ucell_io.o\ diff --git a/source/source_cell/CMakeLists.txt b/source/source_cell/CMakeLists.txt index 2926beb0877..3745c30ff8e 100644 --- a/source/source_cell/CMakeLists.txt +++ b/source/source_cell/CMakeLists.txt @@ -2,7 +2,11 @@ add_subdirectory(module_symmetry) add_subdirectory(module_neighbor) add_subdirectory(module_neighlist) -add_library(domain_decomposition OBJECT domain_decomposition.cpp domain_decomposition_ghost.cpp domain_decomposition_migration.cpp) +add_library(domain_decomposition OBJECT + domain_decomposition.cpp + domain_decomposition_ghost.cpp + domain_decomposition_migration.cpp + domain_decomposition_force.cpp) add_library( cell OBJECT diff --git a/source/source_cell/domain_decomposition.cpp b/source/source_cell/domain_decomposition.cpp index 08d038d97c9..a937344d2d8 100644 --- a/source/source_cell/domain_decomposition.cpp +++ b/source/source_cell/domain_decomposition.cpp @@ -1,6 +1,5 @@ #include "source_cell/domain_decomposition.h" #include "source_base/parallel_cell.h" -#include "source_cell/ghost_exchange_plan.h" #include "source_cell/unitcell.h" #include "source_cell/mdcell.h" #include "source_cell/module_neighlist/neighbor_search.h" @@ -9,14 +8,12 @@ #include #include #include -#include #include -#include namespace { -const int tag_ghost_force_size = 9200; -const int tag_ghost_forces = 9201; +const int tag_migration_count_base = 100; +const int tag_migration_atoms_base = 200; } // MPI-dependent transport and communicator management are confined to helpers. @@ -74,113 +71,6 @@ void DomainDecomposition::init(const ModuleBase::CommunicationDomain& comm_domai update_geometry_(latvec, lat0, cutoff, skin); } -void DomainDecomposition::accumulate_ghost_forces(MDCell& cell) -{ - // Do not recreate geometry or ghost mappings between force evaluation and return. - if (!initialized_ || !ghost_layout_valid_) - { - throw std::runtime_error("Ghost forces require an initialized exchange layout."); - } - - std::vector& owned_atoms = cell.owned_atoms_; - std::vector& ghost_atoms = cell.ghost_atoms_; - std::map, std::size_t> owned_lookup; - for (std::size_t iat = 0; iat < owned_atoms.size(); ++iat) - { - const LocalAtom& atom = owned_atoms[iat]; - owned_lookup[std::make_pair(atom.type, atom.type_index)] = iat; - } - - std::vector peer_ranks; - peer_ranks.reserve(ghost_slots_.size() * 2); - for (const GhostExchangeSlot& slot : ghost_slots_) - { - if (slot.send_rank != rank_) - { - peer_ranks.push_back(slot.send_rank); - } - if (slot.recv_rank != rank_) - { - peer_ranks.push_back(slot.recv_rank); - } - } - std::sort(peer_ranks.begin(), peer_ranks.end()); - peer_ranks.erase(std::unique(peer_ranks.begin(), peer_ranks.end()), peer_ranks.end()); - - std::vector > send_buffers(peer_ranks.size()); - for (std::size_t iat = 0; iat < ghost_atoms.size(); ++iat) - { - LocalAtom& atom = ghost_atoms[iat]; - if (atom.owner_rank == rank_) - { - const std::map, std::size_t>::const_iterator found - = owned_lookup.find(std::make_pair(atom.type, atom.type_index)); - if (found == owned_lookup.end()) - { - throw std::runtime_error("Cannot match a local ghost force to an owned atom."); - } - owned_atoms[found->second].force += atom.force; - } - else - { - ForceRecord record; - record.type = atom.type; - record.type_index = atom.type_index; - record.force[0] = atom.force.x; - record.force[1] = atom.force.y; - record.force[2] = atom.force.z; - const std::vector::const_iterator peer = std::lower_bound(peer_ranks.begin(), - peer_ranks.end(), - atom.owner_rank); - if (peer == peer_ranks.end() || *peer != atom.owner_rank) - { - throw std::runtime_error("Ghost force owner is outside the ghost communication stencil."); - } - send_buffers[static_cast(peer - peer_ranks.begin())].push_back(record); - } - atom.force.set(0.0, 0.0, 0.0); - } - - for (std::size_t ipeer = 0; ipeer < peer_ranks.size(); ++ipeer) - { - const std::vector& send_records = send_buffers[ipeer]; - const std::size_t bytes = send_records.size() * sizeof(ForceRecord); - if (bytes > static_cast(std::numeric_limits::max())) - { - throw std::overflow_error("DomainDecomposition ghost force message exceeds MPI int range."); - } - const int send_bytes = static_cast(bytes); - int recv_bytes = 0; - const int peer_rank = peer_ranks[ipeer]; - exchange_bytes_(&send_bytes, sizeof(send_bytes), &recv_bytes, sizeof(recv_bytes), - peer_rank, peer_rank, tag_ghost_force_size); - if (recv_bytes < 0 || recv_bytes % static_cast(sizeof(ForceRecord)) != 0) - { - throw std::runtime_error("Invalid ghost force message size."); - } - - std::vector recv_records( - static_cast(recv_bytes / static_cast(sizeof(ForceRecord)))); - exchange_bytes_(send_records.data(), send_bytes, recv_records.data(), recv_bytes, - peer_rank, peer_rank, tag_ghost_forces); - - for (std::size_t irecord = 0; irecord < recv_records.size(); ++irecord) - { - const ForceRecord& record = recv_records[irecord]; - const std::map, std::size_t>::const_iterator found - = owned_lookup.find(std::make_pair(record.type, record.type_index)); - if (found == owned_lookup.end()) - { - throw std::runtime_error("Cannot match a received ghost force to an owned atom."); - } - LocalAtom& atom = owned_atoms[found->second]; - atom.force.x += record.force[0]; - atom.force.y += record.force[1]; - atom.force.z += record.force[2]; - } - } -} - void DomainDecomposition::prepare_neighbors(MDCell& cell) { if (cell.cutoff_ <= 0.0) @@ -360,6 +250,58 @@ void DomainDecomposition::exchange_bytes_(const void* send, std::size_t send_byt #endif } +void DomainDecomposition::exchange_migration_( + const std::array& neighbors, + const std::array, 6>& send_atoms, + const std::array& send_counts, + std::array, 6>& recv_atoms) const +{ + const int direction_count = 6; + if (size_ == 1) + { + for (int idir = 0; idir < direction_count; ++idir) + { + recv_atoms[idir] = send_atoms[idir ^ 1]; + } + return; + } +#ifdef __MPI + std::array recv_counts; + std::array requests; + for (int idir = 0; idir < direction_count; ++idir) + { + const int opposite = idir ^ 1; + MPI_Irecv(&recv_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + opposite, comm_, &requests[idir]); + MPI_Isend(&send_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + idir, comm_, &requests[direction_count + idir]); + } + MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); + + for (int idir = 0; idir < direction_count; ++idir) + { + if (recv_counts[idir] < 0 || recv_counts[idir] % static_cast(sizeof(PackedAtom)) != 0) + { + throw std::runtime_error("Invalid DomainDecomposition migration receive count."); + } + recv_atoms[idir].resize(static_cast(recv_counts[idir] / static_cast(sizeof(PackedAtom)))); + } + + for (int idir = 0; idir < direction_count; ++idir) + { + const int opposite = idir ^ 1; + MPI_Irecv(recv_atoms[idir].empty() ? NULL : reinterpret_cast(&recv_atoms[idir][0]), + recv_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + opposite, comm_, &requests[idir]); + MPI_Isend(send_atoms[idir].empty() ? NULL : reinterpret_cast(&send_atoms[idir][0]), + send_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + idir, comm_, &requests[direction_count + idir]); + } + MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); + +#else + static_cast(neighbors); + static_cast(send_counts); + throw std::runtime_error("A serial communication domain cannot migrate to a remote rank."); +#endif +} + double DomainDecomposition::wrap_fractional(double value) { value -= std::floor(value); diff --git a/source/source_cell/domain_decomposition_force.cpp b/source/source_cell/domain_decomposition_force.cpp new file mode 100644 index 00000000000..eb2f0b661c3 --- /dev/null +++ b/source/source_cell/domain_decomposition_force.cpp @@ -0,0 +1,122 @@ +#include "source_cell/domain_decomposition.h" +#include "source_cell/mdcell.h" + +#include +#include +#include +#include +#include + +namespace +{ +const int tag_ghost_force_size = 9200; +const int tag_ghost_forces = 9201; +} + +void DomainDecomposition::accumulate_ghost_forces(MDCell& cell) +{ + // Do not recreate geometry or ghost mappings between force evaluation and return. + if (!initialized_ || !ghost_layout_valid_) + { + throw std::runtime_error("Ghost forces require an initialized exchange layout."); + } + + std::vector& owned_atoms = cell.owned_atoms_; + std::vector& ghost_atoms = cell.ghost_atoms_; + std::map, std::size_t> owned_lookup; + for (std::size_t iat = 0; iat < owned_atoms.size(); ++iat) + { + const LocalAtom& atom = owned_atoms[iat]; + owned_lookup[std::make_pair(atom.type, atom.type_index)] = iat; + } + + std::vector peer_ranks; + peer_ranks.reserve(ghost_slots_.size() * 2); + for (const GhostExchangeSlot& slot : ghost_slots_) + { + if (slot.send_rank != rank_) + { + peer_ranks.push_back(slot.send_rank); + } + if (slot.recv_rank != rank_) + { + peer_ranks.push_back(slot.recv_rank); + } + } + std::sort(peer_ranks.begin(), peer_ranks.end()); + peer_ranks.erase(std::unique(peer_ranks.begin(), peer_ranks.end()), peer_ranks.end()); + + std::vector > send_buffers(peer_ranks.size()); + for (std::size_t iat = 0; iat < ghost_atoms.size(); ++iat) + { + LocalAtom& atom = ghost_atoms[iat]; + if (atom.owner_rank == rank_) + { + const std::map, std::size_t>::const_iterator found + = owned_lookup.find(std::make_pair(atom.type, atom.type_index)); + if (found == owned_lookup.end()) + { + throw std::runtime_error("Cannot match a local ghost force to an owned atom."); + } + owned_atoms[found->second].force += atom.force; + } + else + { + ForceRecord record; + record.type = atom.type; + record.type_index = atom.type_index; + record.force[0] = atom.force.x; + record.force[1] = atom.force.y; + record.force[2] = atom.force.z; + const std::vector::const_iterator peer = std::lower_bound(peer_ranks.begin(), + peer_ranks.end(), + atom.owner_rank); + if (peer == peer_ranks.end() || *peer != atom.owner_rank) + { + throw std::runtime_error("Ghost force owner is outside the ghost communication stencil."); + } + send_buffers[static_cast(peer - peer_ranks.begin())].push_back(record); + } + atom.force.set(0.0, 0.0, 0.0); + } + + for (std::size_t ipeer = 0; ipeer < peer_ranks.size(); ++ipeer) + { + const std::vector& send_records = send_buffers[ipeer]; + const std::size_t bytes = send_records.size() * sizeof(ForceRecord); + if (bytes > static_cast(std::numeric_limits::max())) + { + throw std::overflow_error("DomainDecomposition ghost force message exceeds MPI int range."); + } + const int send_bytes = static_cast(bytes); + int recv_bytes = 0; + const int peer_rank = peer_ranks[ipeer]; + exchange_bytes_(&send_bytes, sizeof(send_bytes), &recv_bytes, sizeof(recv_bytes), + peer_rank, peer_rank, tag_ghost_force_size); + if (recv_bytes < 0 || recv_bytes % static_cast(sizeof(ForceRecord)) != 0) + { + throw std::runtime_error("Invalid ghost force message size."); + } + + std::vector recv_records( + static_cast(recv_bytes / static_cast(sizeof(ForceRecord)))); + exchange_bytes_(send_records.data(), send_bytes, recv_records.data(), recv_bytes, + peer_rank, peer_rank, tag_ghost_forces); + + for (std::size_t irecord = 0; irecord < recv_records.size(); ++irecord) + { + const ForceRecord& record = recv_records[irecord]; + const std::map, std::size_t>::const_iterator found + = owned_lookup.find(std::make_pair(record.type, record.type_index)); + if (found == owned_lookup.end()) + { + throw std::runtime_error("Cannot match a received ghost force to an owned atom."); + } + LocalAtom& atom = owned_atoms[found->second]; + atom.force.x += record.force[0]; + atom.force.y += record.force[1]; + atom.force.z += record.force[2]; + } + } +} + diff --git a/source/source_cell/domain_decomposition_migration.cpp b/source/source_cell/domain_decomposition_migration.cpp index db2a9707565..a0510086977 100644 --- a/source/source_cell/domain_decomposition_migration.cpp +++ b/source/source_cell/domain_decomposition_migration.cpp @@ -2,15 +2,8 @@ #include "source_cell/mdcell.h" #include -#include #include -namespace -{ -const int tag_migration_count_base = 100; -const int tag_migration_atoms_base = 200; -} - void DomainDecomposition::migrate_owned_atoms(MDCell& cell) { synchronize_geometry_(cell); @@ -102,58 +95,6 @@ void DomainDecomposition::migrate_owned_atoms(MDCell& cell) exchange_ghost_atoms(cell); } -void DomainDecomposition::exchange_migration_( - const std::array& neighbors, - const std::array, 6>& send_atoms, - const std::array& send_counts, - std::array, 6>& recv_atoms) const -{ - const int direction_count = 6; - if (size_ == 1) - { - for (int idir = 0; idir < direction_count; ++idir) - { - recv_atoms[idir] = send_atoms[idir ^ 1]; - } - return; - } -#ifdef __MPI - std::array recv_counts; - std::array requests; - for (int idir = 0; idir < direction_count; ++idir) - { - const int opposite = idir ^ 1; - MPI_Irecv(&recv_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + opposite, comm_, &requests[idir]); - MPI_Isend(&send_counts[idir], 1, MPI_INT, neighbors[idir], tag_migration_count_base + idir, comm_, &requests[direction_count + idir]); - } - MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); - - for (int idir = 0; idir < direction_count; ++idir) - { - if (recv_counts[idir] < 0 || recv_counts[idir] % static_cast(sizeof(PackedAtom)) != 0) - { - throw std::runtime_error("Invalid DomainDecomposition migration receive count."); - } - recv_atoms[idir].resize(static_cast(recv_counts[idir] / static_cast(sizeof(PackedAtom)))); - } - - for (int idir = 0; idir < direction_count; ++idir) - { - const int opposite = idir ^ 1; - MPI_Irecv(recv_atoms[idir].empty() ? NULL : reinterpret_cast(&recv_atoms[idir][0]), - recv_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + opposite, comm_, &requests[idir]); - MPI_Isend(send_atoms[idir].empty() ? NULL : reinterpret_cast(&send_atoms[idir][0]), - send_counts[idir], MPI_BYTE, neighbors[idir], tag_migration_atoms_base + idir, comm_, &requests[direction_count + idir]); - } - MPI_Waitall(2 * direction_count, &requests[0], MPI_STATUSES_IGNORE); - -#else - static_cast(neighbors); - static_cast(send_counts); - throw std::runtime_error("A serial communication domain cannot migrate to a remote rank."); -#endif -} - DomainDecomposition::PackedAtom DomainDecomposition::pack_atom( const LocalAtom& atom, const std::array& image_shift) const diff --git a/source/source_cell/module_neighlist/test/CMakeLists.txt b/source/source_cell/module_neighlist/test/CMakeLists.txt index f6ba6418b72..9f4c96942c1 100644 --- a/source/source_cell/module_neighlist/test/CMakeLists.txt +++ b/source/source_cell/module_neighlist/test/CMakeLists.txt @@ -8,7 +8,11 @@ addtest( TARGET MODULE_CELL_NEIGHBOR_neighbor_search LIBS parameter base device cell neighbor symmetry SOURCES test_neighbor_search.cpp ../neighbor_search.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp ../bin_manager.cpp + ../../domain_decomposition.cpp + ../../domain_decomposition_ghost.cpp + ../../domain_decomposition_migration.cpp + ../../domain_decomposition_force.cpp + ../bin_manager.cpp ../page_allocator.cpp) addtest( @@ -41,7 +45,10 @@ if(ENABLE_MPI) test_mdcell_migrate_mpi.cpp test_domain_decomposition.cpp ../../mdcell.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp + ../../domain_decomposition.cpp + ../../domain_decomposition_ghost.cpp + ../../domain_decomposition_migration.cpp + ../../domain_decomposition_force.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) @@ -86,7 +93,10 @@ if(ENABLE_MPI) ../../mdcell.cpp ../../print_cell.cpp ../../stru_frame_io.cpp - ../../domain_decomposition.cpp ../../domain_decomposition_ghost.cpp ../../domain_decomposition_migration.cpp + ../../domain_decomposition.cpp + ../../domain_decomposition_ghost.cpp + ../../domain_decomposition_migration.cpp + ../../domain_decomposition_force.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) diff --git a/source/source_md/test/CMakeLists.txt b/source/source_md/test/CMakeLists.txt index e915a700d64..d9b0c81b699 100644 --- a/source/source_md/test/CMakeLists.txt +++ b/source/source_md/test/CMakeLists.txt @@ -58,6 +58,7 @@ list( ../../source_cell/domain_decomposition.cpp ../../source_cell/domain_decomposition_ghost.cpp ../../source_cell/domain_decomposition_migration.cpp + ../../source_cell/domain_decomposition_force.cpp ../../source_cell/mdcell.cpp ../../source_base/output.cpp ../../source_io/module_output/output_log.cpp From 0056698ef948364050285ce982cec593b48d39a2 Mon Sep 17 00:00:00 2001 From: Fei Yang <2501213217@stu.pku.edu.cn> Date: Thu, 5 Nov 2026 14:18:15 +0800 Subject: [PATCH 4/5] style(cell): remove trailing blank lines from split sources --- source/source_cell/domain_decomposition_force.cpp | 1 - source/source_cell/domain_decomposition_ghost.cpp | 1 - 2 files changed, 2 deletions(-) diff --git a/source/source_cell/domain_decomposition_force.cpp b/source/source_cell/domain_decomposition_force.cpp index eb2f0b661c3..3151ada032b 100644 --- a/source/source_cell/domain_decomposition_force.cpp +++ b/source/source_cell/domain_decomposition_force.cpp @@ -119,4 +119,3 @@ void DomainDecomposition::accumulate_ghost_forces(MDCell& cell) } } } - diff --git a/source/source_cell/domain_decomposition_ghost.cpp b/source/source_cell/domain_decomposition_ghost.cpp index 508fb4208e7..fcf5c7fd614 100644 --- a/source/source_cell/domain_decomposition_ghost.cpp +++ b/source/source_cell/domain_decomposition_ghost.cpp @@ -399,4 +399,3 @@ void DomainDecomposition::build_ghost_exchange_slots(std::vector Date: Thu, 5 Nov 2026 19:11:42 +0800 Subject: [PATCH 5/5] refactor(cell): shorten domain file names and add direct includes --- source/Makefile.Objects | 8 +++---- source/source_cell/CMakeLists.txt | 8 +++---- ...{domain_decomposition.cpp => dom_core.cpp} | 2 +- .../{domain_decomposition.h => dom_decomp.h} | 6 ++--- ..._decomposition_force.cpp => dom_force.cpp} | 2 +- ..._decomposition_ghost.cpp => dom_ghost.cpp} | 3 ++- ...position_migration.cpp => dom_migrate.cpp} | 6 ++++- source/source_cell/mdcell_reader.cpp | 2 +- .../module_neighlist/test/CMakeLists.txt | 24 +++++++++---------- .../test/test_domain_decomposition.cpp | 2 +- .../test/test_mdcell_migrate_mpi.cpp | 2 +- .../test/test_mdcell_reader.cpp | 2 +- source/source_main/driver_run.cpp | 2 +- source/source_md/md_func.cpp | 2 +- source/source_md/run_md.cpp | 2 +- source/source_md/test/CMakeLists.txt | 8 +++---- source/source_md/test/fire_test.cpp | 2 +- source/source_md/test/langevin_test.cpp | 2 +- source/source_md/test/lj_pot_test.cpp | 2 +- source/source_md/test/md_func_test.cpp | 2 +- source/source_md/test/md_test_fixture.h | 2 +- source/source_md/test/msst_test.cpp | 2 +- source/source_md/test/nhchain_test.cpp | 2 +- source/source_md/test/run_md_test.cpp | 2 +- source/source_md/test/test_md_func.cpp | 2 +- source/source_md/test/verlet_test.cpp | 2 +- source/source_md/unittests/test_md_base.cpp | 2 +- 27 files changed, 54 insertions(+), 49 deletions(-) rename source/source_cell/{domain_decomposition.cpp => dom_core.cpp} (99%) rename source/source_cell/{domain_decomposition.h => dom_decomp.h} (98%) rename source/source_cell/{domain_decomposition_force.cpp => dom_force.cpp} (99%) rename source/source_cell/{domain_decomposition_ghost.cpp => dom_ghost.cpp} (99%) rename source/source_cell/{domain_decomposition_migration.cpp => dom_migrate.cpp} (98%) diff --git a/source/Makefile.Objects b/source/Makefile.Objects index 687ef0e0c1c..adc49e84ea4 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -249,10 +249,10 @@ OBJS_CELL=atom_pseudo.o\ cal_ux.o\ mdcell_reader.o\ mdcell.o\ - domain_decomposition.o\ - domain_decomposition_ghost.o\ - domain_decomposition_migration.o\ - domain_decomposition_force.o\ + dom_core.o\ + dom_ghost.o\ + dom_migrate.o\ + dom_force.o\ cif_io.o\ ucell_io.o\ diff --git a/source/source_cell/CMakeLists.txt b/source/source_cell/CMakeLists.txt index 3745c30ff8e..535891ec64c 100644 --- a/source/source_cell/CMakeLists.txt +++ b/source/source_cell/CMakeLists.txt @@ -3,10 +3,10 @@ add_subdirectory(module_neighbor) add_subdirectory(module_neighlist) add_library(domain_decomposition OBJECT - domain_decomposition.cpp - domain_decomposition_ghost.cpp - domain_decomposition_migration.cpp - domain_decomposition_force.cpp) + dom_core.cpp + dom_ghost.cpp + dom_migrate.cpp + dom_force.cpp) add_library( cell OBJECT diff --git a/source/source_cell/domain_decomposition.cpp b/source/source_cell/dom_core.cpp similarity index 99% rename from source/source_cell/domain_decomposition.cpp rename to source/source_cell/dom_core.cpp index a937344d2d8..dee26f570d1 100644 --- a/source/source_cell/domain_decomposition.cpp +++ b/source/source_cell/dom_core.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_base/parallel_cell.h" #include "source_cell/unitcell.h" #include "source_cell/mdcell.h" diff --git a/source/source_cell/domain_decomposition.h b/source/source_cell/dom_decomp.h similarity index 98% rename from source/source_cell/domain_decomposition.h rename to source/source_cell/dom_decomp.h index 053ee512c5a..d2d345cda73 100644 --- a/source/source_cell/domain_decomposition.h +++ b/source/source_cell/dom_decomp.h @@ -1,5 +1,5 @@ -#ifndef DOMAIN_DECOMPOSITION_H -#define DOMAIN_DECOMPOSITION_H +#ifndef DOM_DECOMP_H +#define DOM_DECOMP_H #include "source_base/matrix3.h" #include "source_base/vector3.h" @@ -145,4 +145,4 @@ class DomainDecomposition bool ghost_layout_valid_ = false; }; -#endif // DOMAIN_DECOMPOSITION_H +#endif // DOM_DECOMP_H diff --git a/source/source_cell/domain_decomposition_force.cpp b/source/source_cell/dom_force.cpp similarity index 99% rename from source/source_cell/domain_decomposition_force.cpp rename to source/source_cell/dom_force.cpp index 3151ada032b..b035247892d 100644 --- a/source/source_cell/domain_decomposition_force.cpp +++ b/source/source_cell/dom_force.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/mdcell.h" #include diff --git a/source/source_cell/domain_decomposition_ghost.cpp b/source/source_cell/dom_ghost.cpp similarity index 99% rename from source/source_cell/domain_decomposition_ghost.cpp rename to source/source_cell/dom_ghost.cpp index fcf5c7fd614..92430a41f7b 100644 --- a/source/source_cell/domain_decomposition_ghost.cpp +++ b/source/source_cell/dom_ghost.cpp @@ -1,8 +1,9 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/ghost_exchange_plan.h" #include "source_cell/mdcell.h" #include +#include #include #include #include diff --git a/source/source_cell/domain_decomposition_migration.cpp b/source/source_cell/dom_migrate.cpp similarity index 98% rename from source/source_cell/domain_decomposition_migration.cpp rename to source/source_cell/dom_migrate.cpp index a0510086977..25cb0e718fa 100644 --- a/source/source_cell/domain_decomposition_migration.cpp +++ b/source/source_cell/dom_migrate.cpp @@ -1,8 +1,12 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/mdcell.h" #include +#include +#include +#include #include +#include void DomainDecomposition::migrate_owned_atoms(MDCell& cell) { diff --git a/source/source_cell/mdcell_reader.cpp b/source/source_cell/mdcell_reader.cpp index 0a2113a720d..456efd81b19 100644 --- a/source/source_cell/mdcell_reader.cpp +++ b/source/source_cell/mdcell_reader.cpp @@ -5,7 +5,7 @@ #include "source_base/vector3.h" #include "source_cell/mdcell.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include #include diff --git a/source/source_cell/module_neighlist/test/CMakeLists.txt b/source/source_cell/module_neighlist/test/CMakeLists.txt index 9f4c96942c1..b5ffaf299e0 100644 --- a/source/source_cell/module_neighlist/test/CMakeLists.txt +++ b/source/source_cell/module_neighlist/test/CMakeLists.txt @@ -8,10 +8,10 @@ addtest( TARGET MODULE_CELL_NEIGHBOR_neighbor_search LIBS parameter base device cell neighbor symmetry SOURCES test_neighbor_search.cpp ../neighbor_search.cpp - ../../domain_decomposition.cpp - ../../domain_decomposition_ghost.cpp - ../../domain_decomposition_migration.cpp - ../../domain_decomposition_force.cpp + ../../dom_core.cpp + ../../dom_ghost.cpp + ../../dom_migrate.cpp + ../../dom_force.cpp ../bin_manager.cpp ../page_allocator.cpp) @@ -45,10 +45,10 @@ if(ENABLE_MPI) test_mdcell_migrate_mpi.cpp test_domain_decomposition.cpp ../../mdcell.cpp - ../../domain_decomposition.cpp - ../../domain_decomposition_ghost.cpp - ../../domain_decomposition_migration.cpp - ../../domain_decomposition_force.cpp + ../../dom_core.cpp + ../../dom_ghost.cpp + ../../dom_migrate.cpp + ../../dom_force.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) @@ -93,10 +93,10 @@ if(ENABLE_MPI) ../../mdcell.cpp ../../print_cell.cpp ../../stru_frame_io.cpp - ../../domain_decomposition.cpp - ../../domain_decomposition_ghost.cpp - ../../domain_decomposition_migration.cpp - ../../domain_decomposition_force.cpp + ../../dom_core.cpp + ../../dom_ghost.cpp + ../../dom_migrate.cpp + ../../dom_force.cpp ../neighbor_search.cpp ../bin_manager.cpp ../page_allocator.cpp) diff --git a/source/source_cell/module_neighlist/test/test_domain_decomposition.cpp b/source/source_cell/module_neighlist/test/test_domain_decomposition.cpp index d615f3856c7..8b3d9aa23ee 100644 --- a/source/source_cell/module_neighlist/test/test_domain_decomposition.cpp +++ b/source/source_cell/module_neighlist/test/test_domain_decomposition.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/module_neighlist/neighbor_search.h" #include "source_cell/mdcell.h" #include "source_base/parallel_cell.h" diff --git a/source/source_cell/module_neighlist/test/test_mdcell_migrate_mpi.cpp b/source/source_cell/module_neighlist/test/test_mdcell_migrate_mpi.cpp index 865ef7f8254..4a857136695 100644 --- a/source/source_cell/module_neighlist/test/test_mdcell_migrate_mpi.cpp +++ b/source/source_cell/module_neighlist/test/test_mdcell_migrate_mpi.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include #include "source_cell/mdcell.h" diff --git a/source/source_cell/module_neighlist/test/test_mdcell_reader.cpp b/source/source_cell/module_neighlist/test/test_mdcell_reader.cpp index 043e256c06f..bbe5fa0d672 100644 --- a/source/source_cell/module_neighlist/test/test_mdcell_reader.cpp +++ b/source/source_cell/module_neighlist/test/test_mdcell_reader.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include #include diff --git a/source/source_main/driver_run.cpp b/source/source_main/driver_run.cpp index ee4bf08fcb0..b400100f983 100644 --- a/source/source_main/driver_run.cpp +++ b/source/source_main/driver_run.cpp @@ -1,7 +1,7 @@ #include "source_base/global_variable.h" #include "source_base/kernels/math_kernel_op.h" #include "source_cell/check_atomic_stru.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/mdcell.h" #include "source_esolver/esolver_factory.h" #include "source_hsolver/kernels/hegvd_op.h" diff --git a/source/source_md/md_func.cpp b/source/source_md/md_func.cpp index 5649df9ba0d..fcfd27b5aa5 100644 --- a/source/source_md/md_func.cpp +++ b/source/source_md/md_func.cpp @@ -1,5 +1,5 @@ #include "md_func.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_base/global_variable.h" #include "source_base/parallel_cell.h" diff --git a/source/source_md/run_md.cpp b/source/source_md/run_md.cpp index ac49e5317ea..df8e2bb5899 100644 --- a/source/source_md/run_md.cpp +++ b/source/source_md/run_md.cpp @@ -7,7 +7,7 @@ #include "source_base/parallel_cell.h" #include "source_cell/mdcell_reader.h" #include "source_cell/mdcell.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_io/module_parameter/parameter.h" #include "fire.h" #include "langevin.h" diff --git a/source/source_md/test/CMakeLists.txt b/source/source_md/test/CMakeLists.txt index d9b0c81b699..416666ef54d 100644 --- a/source/source_md/test/CMakeLists.txt +++ b/source/source_md/test/CMakeLists.txt @@ -55,10 +55,10 @@ list( ../../source_cell/module_neighlist/neighbor_search.cpp ../../source_cell/module_neighlist/bin_manager.cpp ../../source_cell/module_neighlist/page_allocator.cpp - ../../source_cell/domain_decomposition.cpp - ../../source_cell/domain_decomposition_ghost.cpp - ../../source_cell/domain_decomposition_migration.cpp - ../../source_cell/domain_decomposition_force.cpp + ../../source_cell/dom_core.cpp + ../../source_cell/dom_ghost.cpp + ../../source_cell/dom_migrate.cpp + ../../source_cell/dom_force.cpp ../../source_cell/mdcell.cpp ../../source_base/output.cpp ../../source_io/module_output/output_log.cpp diff --git a/source/source_md/test/fire_test.cpp b/source/source_md/test/fire_test.cpp index 8655b5aa90b..dc0e4c51914 100644 --- a/source/source_md/test/fire_test.cpp +++ b/source/source_md/test/fire_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "setcell.h" diff --git a/source/source_md/test/langevin_test.cpp b/source/source_md/test/langevin_test.cpp index 784b6a9fd18..06806794788 100644 --- a/source/source_md/test/langevin_test.cpp +++ b/source/source_md/test/langevin_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "setcell.h" diff --git a/source/source_md/test/lj_pot_test.cpp b/source/source_md/test/lj_pot_test.cpp index 9bfd08d1c02..483b197ac00 100644 --- a/source/source_md/test/lj_pot_test.cpp +++ b/source/source_md/test/lj_pot_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gtest/gtest.h" #include "setcell.h" #include "source_esolver/esolver_lj.h" diff --git a/source/source_md/test/md_func_test.cpp b/source/source_md/test/md_func_test.cpp index 7eeccd78691..18c75d4196a 100644 --- a/source/source_md/test/md_func_test.cpp +++ b/source/source_md/test/md_func_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "md_test_fixture.h" diff --git a/source/source_md/test/md_test_fixture.h b/source/source_md/test/md_test_fixture.h index 853ccd1a3fc..4099f8a7683 100644 --- a/source/source_md/test/md_test_fixture.h +++ b/source/source_md/test/md_test_fixture.h @@ -5,7 +5,7 @@ #include "source_esolver/esolver_lj.h" #include "source_io/module_parameter/input_parameter.h" #include "source_md/md_base.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "setcell.h" #include diff --git a/source/source_md/test/msst_test.cpp b/source/source_md/test/msst_test.cpp index 6a7e7cd3d29..d2a1e8afd91 100644 --- a/source/source_md/test/msst_test.cpp +++ b/source/source_md/test/msst_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "setcell.h" diff --git a/source/source_md/test/nhchain_test.cpp b/source/source_md/test/nhchain_test.cpp index a73b9811c41..b194d26b50b 100644 --- a/source/source_md/test/nhchain_test.cpp +++ b/source/source_md/test/nhchain_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "setcell.h" diff --git a/source/source_md/test/run_md_test.cpp b/source/source_md/test/run_md_test.cpp index 7d0265c657c..db4c13f5cad 100644 --- a/source/source_md/test/run_md_test.cpp +++ b/source/source_md/test/run_md_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gtest/gtest.h" #include "source_cell/mdcell.h" diff --git a/source/source_md/test/test_md_func.cpp b/source/source_md/test/test_md_func.cpp index 5e335a4572b..5dd997fb836 100644 --- a/source/source_md/test/test_md_func.cpp +++ b/source/source_md/test/test_md_func.cpp @@ -1,6 +1,6 @@ #include "source_md/md_func.h" #include "source_cell/mdcell.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_base/parallel_cell.h" #include "source_esolver/esolver.h" diff --git a/source/source_md/test/verlet_test.cpp b/source/source_md/test/verlet_test.cpp index 8d960f04d38..5782a952aa6 100644 --- a/source/source_md/test/verlet_test.cpp +++ b/source/source_md/test/verlet_test.cpp @@ -1,4 +1,4 @@ -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "gmock/gmock.h" #include "gtest/gtest.h" #include "setcell.h" diff --git a/source/source_md/unittests/test_md_base.cpp b/source/source_md/unittests/test_md_base.cpp index d5da2528817..a0444b505bd 100644 --- a/source/source_md/unittests/test_md_base.cpp +++ b/source/source_md/unittests/test_md_base.cpp @@ -3,7 +3,7 @@ #include "source_base/constants.h" #include "source_base/parallel_cell.h" #include "source_base/parallel_global.h" -#include "source_cell/domain_decomposition.h" +#include "source_cell/dom_decomp.h" #include "source_cell/unitcell.h" #include "source_cell/update_cell.h" #include "source_lcao/module_rt/boundary_fix.h"