ghost_shells.cpp File Reference

#include <iostream>
#include <vector>
#include <algorithm>

Go to the source code of this file.

Typedefs
using	Ghosts = std::vector<std::vector<int>>

Functions
bool	is_shell_ghost_on_proc (int shell_index, int process_id, int *shells, int *mask, int nspmd, int max_node_id)
Ghosts *	cpp_build_ghosts (int *shells, int nb_shells, int *mask, int nspmd, int numnod)
int *	cpp_get_shells_list (void *c, int pc, int *n)
int	cpp_get_shells_list_size (void *c, int pc)
void	cpp_copy_shells_list (void *c, int pc, int *shells, int n)
void	cpp_destroy_ghosts (void *c)

Typedef Documentation

Ghosts

using Ghosts = std::vector<std::vector<int>>

Definition at line 28 of file ghost_shells.cpp.

Function Documentation

cpp_build_ghosts()

Ghosts * cpp_build_ghosts	(	int *	shells,
		int	nb_shells,
		int *	mask,
		int	nspmd,
		int	numnod )

Definition at line 60 of file ghost_shells.cpp.

    {
        if (!shells || !mask || nb_shells < 0 || nspmd <= 0 || numnod <= 0)
        {
            return nullptr;
        }
 
        auto *ghost_data = new Ghosts(nspmd);
        const int max_node_id = numnod;
 
        // Build ghost shell lists for each process
        for (int shell_idx = 0; shell_idx < nb_shells; ++shell_idx)
        {
            for (int process_idx = 0; process_idx < nspmd; ++process_idx)
            {
                if (is_shell_ghost_on_proc(shell_idx, process_idx, shells, mask, nspmd, max_node_id))
                {
                    (*ghost_data)[process_idx].push_back(shell_idx + 1); // Convert to 1-based for Fortran
                }
            }
        }
 
        // Remove duplicates from each process's shell list
        if (nb_shells > 0)
        {
            for (int process_idx = 0; process_idx < nspmd; ++process_idx)
            {
                auto &shell_list = (*ghost_data)[process_idx];
                std::sort(shell_list.begin(), shell_list.end());
                auto new_end = std::unique(shell_list.begin(), shell_list.end());
                shell_list.erase(new_end, shell_list.end());
            }
        }
 
        return ghost_data;
    }

cpp_copy_shells_list()

void cpp_copy_shells_list	(	void *	c,
		int	pc,
		int *	shells,
		int	n )

Definition at line 146 of file ghost_shells.cpp.

    {
        if (!c || !shells)
        {
            return;
        }
 
        auto *ghost_data = static_cast<Ghosts *>(c);
        const int process_idx = pc - 1; // Fortran to C index conversion
 
        // Check bounds
        if (process_idx < 0 || process_idx >= static_cast<int>(ghost_data->size()))
        {
            return;
        }
 
        // Copy the shells list to the output array
        const auto &shell_list = (*ghost_data)[process_idx];
        std::copy(shell_list.begin(), shell_list.end(), shells);
    }

cpp_destroy_ghosts()

void cpp_destroy_ghosts

(

void *

c

)

Definition at line 167 of file ghost_shells.cpp.

    {
        if (!c)
        {
            return;
        }
 
        auto *ghost_data = static_cast<Ghosts *>(c);
        delete ghost_data;
    }

cpp_get_shells_list()

int * cpp_get_shells_list	(	void *	c,
		int	pc,
		int *	n )

Definition at line 102 of file ghost_shells.cpp.

    {
        if (!c || !n)
        {
            if (n)
                *n = 0;
            return nullptr;
        }
 
        auto *ghost_data = static_cast<Ghosts *>(c);
        const int process_idx = pc - 1; // Fortran to C index conversion
 
        // Check bounds
        if (process_idx < 0 || process_idx >= static_cast<int>(ghost_data->size()))
        {
            *n = 0;
            return nullptr;
        }
 
        auto &shell_list = (*ghost_data)[process_idx];
        *n = static_cast<int>(shell_list.size());
 
        return *n == 0 ? nullptr : shell_list.data();
    }

cpp_get_shells_list_size()

int cpp_get_shells_list_size	(	void *	c,
		int	pc )

Definition at line 127 of file ghost_shells.cpp.

    {
        if (!c)
        {
            return 0;
        }
 
        auto *ghost_data = static_cast<Ghosts *>(c);
        const int process_idx = pc - 1; // Fortran to C index conversion
 
        // Check bounds
        if (process_idx < 0 || process_idx >= static_cast<int>(ghost_data->size()))
        {
            return 0;
        }
 
        return static_cast<int>((*ghost_data)[process_idx].size());
    }

is_shell_ghost_on_proc()

bool is_shell_ghost_on_proc	(	int	shell_index,
		int	process_id,
		int *	shells,
		int *	mask,
		int	nspmd,
		int	max_node_id )

Definition at line 30 of file ghost_shells.cpp.

{
    // A shell should be included if at least one of its nodes has mask == 1
    constexpr int nodes_per_shell = 4;
 
    for (int j = 0; j < nodes_per_shell; ++j)
    {
        const int node_id = shells[shell_index * nodes_per_shell + j];
        if (node_id > 0 && node_id <= max_node_id)
        {
            // For a Fortran array mask(nspmd,numnodes)
            // Access mask(p,node_id) as mask[(node_id-1)*nspmd + (p)]
            const int mask_index = (node_id - 1) * nspmd + process_id;
            if (mask[mask_index] == 1)
            {
                return true; // Found at least one node with mask == 1
            }
        }
    }
    return false; // No nodes have mask == 1
}