cpp_reorder_elements.cpp File Reference

#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <set>
#include <unordered_map>
#include <algorithm>
#include <map>
#include <deque>
#include <list>

Go to the source code of this file.

Data Structures
struct	ElementPartition
class	NodeMapping
class	Adjacency

Macros
#define	_FCALL

Typedefs
typedef vector< int >	Vint
typedef vector< NodeMapping >	Vorder

Functions
bool	is_permutation (const Vint &v)
void	splitPerDomain (int nel, int nodesPerElt, size_t nspmd, int *domain, int lda, int offset, int *elt2Nodes, Vorder &nodes, ElementPartition &elts)
void	cpp_reorder_elements (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)
void	CPP_REORDER_ELEMENTS_ (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)
void	CPP_REORDER_ELEMENTS__ (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)
void _FCALL	CPP_REORDER_ELEMENTS (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)
void	cpp_reorder_elements_ (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)
void	cpp_reorder_elements__ (int *NEL, int *NSPMD, int *NODES_PER_ELT, int *OFFSET, int *LDA, int *domain, int *elt2Nodes, int *permutation)

Macro Definition Documentation

_FCALL

#define _FCALL

Definition at line 40 of file cpp_reorder_elements.cpp.

Typedef Documentation

Vint

typedef vector<int> Vint

Definition at line 42 of file cpp_reorder_elements.cpp.

Vorder

typedef vector<NodeMapping> Vorder

Definition at line 82 of file cpp_reorder_elements.cpp.

Function Documentation

CPP_REORDER_ELEMENTS()

void _FCALL CPP_REORDER_ELEMENTS	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 408 of file cpp_reorder_elements.cpp.

    {
        cpp_reorder_elements(NEL, NSPMD, NODES_PER_ELT, OFFSET, LDA, domain, elt2Nodes, permutation);
    }

cpp_reorder_elements()

void cpp_reorder_elements	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 318 of file cpp_reorder_elements.cpp.

    {
        const int nel = *NEL; // number of elements
        const size_t nspmd = (size_t)*NSPMD; // number of subdomains
        const int nodesPerElt = *NODES_PER_ELT; // number of nodes per element
        const int offset = *OFFSET; // padding size of array elt2Nodes (see cgrtails.F)
        const int lda = *LDA;       // leading dimension of elt2Nodes array
        // elt2Nodes is a 2D array of size nel x nodesPerElt such as elt2Nodes[i*lda + j + offset] is the global id of the jth node of the ith element
 
        Vorder nodesMapping(nspmd);
        ElementPartition eltsParition;
        vector<Adjacency> adjacencies(nspmd);
        vector<vector<Vint>> node2Elts(nspmd);
        vector<Vint> elt2LocalNodes(nspmd);
 
        splitPerDomain(nel, nodesPerElt, nspmd, domain, lda, offset, elt2Nodes, nodesMapping, eltsParition);
 
        for (size_t p = 0; p < nspmd; p++)
        {
            const int nb_local_elts = eltsParition.globalId[p].size();
            const int nb_local_nodes = nodesMapping[p].size();
            node2Elts[p].resize(nb_local_nodes);
            adjacencies[p].setNbVertices(nb_local_elts);
            adjacencies[p].reserve(30); // estimation of the maximum number of neighbor per element
            elt2LocalNodes[p].resize(nb_local_elts * nodesPerElt);
        }
 
        // Fill node2Elts[domain][local_node_id] = set of local element id
        // Fill elt2LocalNodes[domain][position in connectivity] = local_node_id
        for (int i = 0; i < nel; i++)
        {
            const int p = domain[i];
            // local id of the element
            const int e = eltsParition.localId[i];
            for (int j = 0; j < nodesPerElt; j++)
            {
                // local id of the neighbouring node
                const int local_node_id = nodesMapping[p].getCompactId(elt2Nodes[i * lda + j + offset]);
                elt2LocalNodes[p][nodesPerElt * e + j] = local_node_id;
                node2Elts[p][local_node_id].push_back(e);
            }
        }
 
        // Fill Adjacency
        for(size_t p = 0; p < nspmd; p++) //for each domain
        {
            const size_t nel_local = eltsParition.globalId[p].size();
            Vint last(nel_local, -1);
            for(size_t e1 = 0 ; e1 < nel_local ; e1++) //for each element e1
            {
                for(size_t j = 0 ; j < nodesPerElt ; j++) //for each node n of e1
                {
                    const int n = elt2LocalNodes[p][nodesPerElt * e1 + j];
                    for(auto & e2 : node2Elts[p][n]) //for each element e2 connected to n
                    {
                        if(last[e2] != e1)
                        {
                            last[e2] = e1;
                            adjacencies[p].addEdge(e1, e2);
                        }
                    }
                }
            }
        }
 
        // for each domain, compute the local permutation (index)
        // and fill the global permutation
        int start = 0;
        for (size_t p = 0; p < nspmd; ++p)
        {
            Vint index = adjacencies[p].CuthillMckee();
            //adjacencies[p].printStats(index);
            for (size_t i = 0; i < index.size(); ++i)
            {
                // permutation["new"] = "old"
                permutation[(size_t)(start + index[i])] = 1 + eltsParition.globalId[p][i];
            }
            start += index.size();
        }
    };

CPP_REORDER_ELEMENTS_()

void CPP_REORDER_ELEMENTS_	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 400 of file cpp_reorder_elements.cpp.

    {
        cpp_reorder_elements(NEL, NSPMD, NODES_PER_ELT, OFFSET, LDA, domain, elt2Nodes, permutation);
    }

cpp_reorder_elements_()

void cpp_reorder_elements_	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 412 of file cpp_reorder_elements.cpp.

    {
        cpp_reorder_elements(NEL, NSPMD, NODES_PER_ELT, OFFSET, LDA, domain, elt2Nodes, permutation);
    }

CPP_REORDER_ELEMENTS__()

void CPP_REORDER_ELEMENTS__	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 404 of file cpp_reorder_elements.cpp.

    {
        cpp_reorder_elements(NEL, NSPMD, NODES_PER_ELT, OFFSET, LDA, domain, elt2Nodes, permutation);
    }

cpp_reorder_elements__()

void cpp_reorder_elements__	(	int *	NEL,
		int *	NSPMD,
		int *	NODES_PER_ELT,
		int *	OFFSET,
		int *	LDA,
		int *	domain,
		int *	elt2Nodes,
		int *	permutation )

Definition at line 416 of file cpp_reorder_elements.cpp.

    {
        cpp_reorder_elements(NEL, NSPMD, NODES_PER_ELT, OFFSET, LDA, domain, elt2Nodes, permutation);
    }

is_permutation()

bool is_permutation

(

const Vint &

v

)

Definition at line 280 of file cpp_reorder_elements.cpp.

{
    Vint r(v.size(), 0);
    for (const auto &i : v)
    {
        if (i < 0 || ((size_t)i) > v.size())
        {
            return false;
        }
        r[i] = 1;
    }
    size_t sum = 0;
    for (auto &n : r)
    {
        sum += n;
    }
    return sum == v.size();
}

splitPerDomain()

void splitPerDomain	(	int	nel,
		int	nodesPerElt,
		size_t	nspmd,
		int *	domain,
		int	lda,
		int	offset,
		int *	elt2Nodes,
		Vorder &	nodes,
		ElementPartition &	elts )

Definition at line 298 of file cpp_reorder_elements.cpp.

{ // Distribute the elements according to domain[i = 0:nspmd-1]
  // defines local-to-domain ids of elements and nodes
    elts.globalId = vector<Vint>(nspmd);
    elts.localId = Vint(nel, -1);
    for (int i = 0; i < nel; i++)
    {
        const int p = domain[i];
        elts.localId[i] = elts.globalId[p].size();
        elts.globalId[p].push_back(i);
        for (int j = 0; j < nodesPerElt; j++)
        {
            nodes[p].addGlobalId(elt2Nodes[i * lda + j + offset]);
        }
    }
}