Implement unwrapSelection method with cluster-based parallel optimization

[Copilot]

Adds unwrapSelection to _EditKernelsService to transform selected cell positions from periodic/modulo space to flat Euclidean space. This will be used for calculating mass center and relative positions.

Changes

EditKernelsService.cuh/cu:

• New public method unwrapSelection(CudaSettings const&, SimulationData const&, float2 const& refPos) with GPU memory for iteration tracking

EditKernels.cuh/cu - CUDA kernels:

• cudaInitUnwrapSelection: Initializes all selected cells for cluster-based unwrapping (clusterIndex, tempValue, shared1, shared2)
• cudaFindUnwrapClusters: Finds connected components among selected cells using atomicMin propagation (same pattern as ClusterProcessor)
• cudaFindNearestInCluster: Finds the nearest cell to refPos per cluster using atomicMin with distance+index encoding
• cudaMarkUnwrapStartCells: Marks starting cells for all clusters in parallel
• cudaUnwrapSelectionStep: BFS-style propagation through connected cells using atomicCAS for thread safety

Algorithm

1. Initialize all selected cells with clusterIndex set to self
2. Find connected components by propagating minimum clusterIndex through connected selected cells
3. For each cluster, find the nearest cell to refPos using atomicMin (all clusters processed in parallel)
4. Mark all starting cells with corrected positions relative to refPos
5. Propagate unwrapping through all connected cells in all components simultaneously

Performance

The cluster-based approach processes all connected components in parallel, reducing kernel calls from O(components × iterations) to O(iterations). This is critical when many disconnected components exist in the selection.

void unwrapSelection(CudaSettings const& gpuSettings, SimulationData const& data, float2 const& refPos);
// After call: selected cells have unwrapped positions in Cell::shared1
// Cell::tempValue.as_uint64 == 1 indicates cell was processed

Original prompt

Implement a new method
void unwrapSelection(CudaSettings const& gpuSettings, SimulationData const& data, float2 const& refPos);
in _EditKernelsService which unrolls the selection from the periodic/modulo space (the particles are simulated in 2d space with periodic boundary conditions)
to a flat Euclidean space. This method will later be used for calculating the mass center and relative positions to it.
The unwrapping should be performed on the connected component of the selection (the cells where the member Cell::selected equals 1 or 2).
For unwrapSelection there are maybe several kernels necessary, which should be implemented in EditKernels.cuh/cu.
The refPosition (=referencePosition) should be used to identify the initial cells for unwrapping in the connected components.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[chrxh]

@copilot 3 problems in this method: (1) There could be no cells within the radius of refPosition.
(2) There could be 2 cells of the same connected cell component within radius which should be actually far distant in unwrapped space.
(3) There could be many other connected cell components which are selected and would not be captured by this method.

[Copilot]

Fixed in commit 9e18708. The revised implementation:

1. No cells within radius: Now finds the closest cell to refPos regardless of distance using cudaFindClosestUnwrappedCell with atomicMin.

2. Multiple cells in same component within radius: Only one cell is marked as starting point per component - the closest unprocessed cell.

3. Multiple disconnected components: The outer loop continues until all selected cells are processed. Each component gets its own starting cell (the closest unprocessed cell to refPos at that iteration).

New kernels:

• cudaInitUnwrapSelection: Initialize all selected cells
• cudaFindClosestUnwrappedCell: Find closest unprocessed cell
• cudaMarkUnwrapStartCell: Mark single cell as start
• cudaUnwrapSelectionStep: BFS propagation (unchanged)

[chrxh]

@copilot Your approach is problematic for the performamce if there are many connected components. Instead determine all connected components first (see logic for cluster members in Cell). Then determin for each component its nearest to refPosition (can be done in one or two kernel calls for all components together). Here one can tag the cluster for the nearest cell.

[Copilot]

@copilot Your approach is problematic for the performamce if there are many connected components. Instead determine all connected components first (see logic for cluster members in Cell). Then deter...

Fixed in commit 8cebaf4. The new implementation uses the cluster-based parallel approach:

1. Find clusters (cudaFindUnwrapClusters): Uses the same atomicMin pattern as ClusterProcessor to identify connected components among selected cells
2. Find nearest per cluster (cudaFindNearestInCluster): Each cell computes its distance to refPos and atomically updates its cluster head's shared2 if closer (using distance+index encoding with atomicMin)
3. Mark starting cells (cudaMarkUnwrapStartCells): Each cluster head marks its nearest cell as unwrapped

This processes all components in parallel, reducing kernel calls from O(components × iterations) to O(iterations).