cl_Mesh_ConnectivityCalculator.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef CL_MESH_CONNECTIVITYCALCULATOR_HPP
#define CL_MESH_CONNECTIVITYCALCULATOR_HPP
#include "typedefs.hpp"
#include "cl_Mesh.hpp"
#include "op_Node_Index.hpp"
namespace belfem
{
    namespace mesh
    {
        class ConnectivityCalculator
        {
            const proc_t mCommRank ;

            const proc_t mCommSize ;

            Mesh * mMesh ;
 
            Cell< Node * >    & mNodes ;
            Cell< Edge * >    & mEdges  ;
            Cell< Face * >    & mFaces;
            Cell< Element * > & mElements ;
            Cell< Facet * >   & mFacets ;
            Cell< ControlPoint * > & mControlPoints ;

            Vector< id_t >    mSelectedBlockIDs;

            bool mPartialOnly = false ;
 
            Vector< proc_t > mElementOwners ;
            Vector< proc_t > mNodeOwners ;
 
            key128_t ( ConnectivityCalculator:: * mKey )( Cell< Node * > & aNodes ) const ;
 
//------------------------------------------------------------------------------
            public:
//------------------------------------------------------------------------------
 
            ConnectivityCalculator( Mesh * aMesh );

            ~ConnectivityCalculator();
 
            void
            connect_nodes_to_elements() ;
 
            void
            connect_facets_to_elements();
 
            void
            connect_nodes_to_facets();
 
            void
            connect_facets_to_facets();
 
            void
            connect_faces_to_edges_and_edges_to_faces();
 
            void
            connect_faces_to_faces();
 
            void
            connect_nodes_to_edges();
 
            void
            connect_edges_to_elements( Cell< Element * > & aElements );
 
            void
            connect_edges_to_ghost_facets();
 
            void
            connect_faces_to_ghost_facets();
 
            void
            connect_edges_to_edges();

            void
            connect_nodes_to_nodes();

            void
            connect_elements_to_elements();
 
            void
            connect_thin_shells_to_thin_shells();
 
            void
            connect_control_points_to_elements() ;
 
            void
            connect_control_points_to_control_points() ;

            void
            save_connectivity_data( const string & aPath );
 
        private:
 
            void
            connect_elements_to_elements_sub( Cell< Element * > & aElements );
 
            key128_t
            facet_key2( Cell< Node * > & aNodes ) const ;
 
            key128_t
            facet_key3( Cell< Node * > & aNodes ) const ;
 
        };
 
        inline key128_t ConnectivityCalculator::facet_key2( Cell< Node * > & aNodes ) const
        {
            sort( aNodes, opNodeIndex );
            key128_t tNumNodes = mMesh->number_of_nodes();
            return aNodes( 1 )->index() * tNumNodes + aNodes( 0 )->index();
        }
 
        inline key128_t ConnectivityCalculator::facet_key3( Cell< Node * > & aNodes ) const
        {
            sort( aNodes, opNodeIndex );
            key128_t tNumNodes = mMesh->number_of_nodes();
            return ( aNodes( 2 )->index() * tNumNodes + aNodes( 1 )->index() )
                * tNumNodes+ aNodes( 0 )->index();
        }
 
    }
}
#endif //CL_MESH_CONNECTIVITYCALCULATOR_HPP