cl_FEM_DofManager.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 BELFEM_CL_FEM_DOFMANAGER_HPP
#define BELFEM_CL_FEM_DOFMANAGER_HPP
 
#include "typedefs.hpp"
#include "cl_Cell.hpp"
#include "cl_Vector.hpp"
#include "cl_Map.hpp"
#include "cl_Mesh.hpp"
#include "cl_IWG.hpp"
 
#include "cl_FEM_Dof.hpp"
#include "cl_FEM_Bearing.hpp"
#include "cl_FEM_Block.hpp"
#include "cl_FEM_SideSet.hpp"
 
#include "en_IntegrationScheme.hpp"
 
#include "cl_FEM_DofManagerBase.hpp"
#include "cl_FEM_DofMgr_Parameters.hpp"
#include "cl_FEM_DofMgr_DofData.hpp"
#include "cl_FEM_DofMgr_BlockData.hpp"
#include "cl_FEM_DofMgr_SideSetData.hpp"
#include "cl_FEM_DofMgr_BearingData.hpp"
#include "cl_FEM_DofMgr_FieldData.hpp"
#include "cl_FEM_DofMgr_SolverData.hpp"
#include "cl_FEM_DofMgr_EigenValues.hpp"
 
namespace belfem
{
    namespace fem
    {
        class Kernel;
        class Postprocessor ;

        class DofManager : public DofManagerBase
        {
            const index_t mIndex ;

            dofmgr::Parameters  * mParams ;

            dofmgr::DofData     * mDofData ;

            dofmgr::BlockData   * mBlockData ;

            dofmgr::SideSetData * mSideSetData ;

            dofmgr::BearingData * mBearingData ;

            dofmgr::FieldData   * mFieldData ;

            dofmgr::SolverData  * mSolverData ;

            dofmgr::EigenValues  * mEigenValues ;

            bool mInitializedFlag = false ;

            Cell< Postprocessor * > mPostprocessors ;

            bool mJacobianIsUpToDate = false ;

            Map< id_t, Element * > mElementMap ;
 
            Cell< string > mPostprocessorSourceFields ;
            Cell< string > mPostprocessorTargetFields ;
 
//------------------------------------------------------------------------------
        public:
//------------------------------------------------------------------------------

            DofManager(
                          Kernel         * aParent,
                    const index_t          aIndex );
 
//-----------------------------------------------------------------------------
 
            ~DofManager() override;
 
//-----------------------------------------------------------------------------

             void
             set_equation( IWG * aIWG );
 
//-----------------------------------------------------------------------------

             void
             print( const proc_t aRank=0 ) ;
 
//------------------------------------------------------------------------------
 
             uint
             sideset_integration_order() const override ;
 
//------------------------------------------------------------------------------
 
             uint
             block_integration_order() const override ;
 
//------------------------------------------------------------------------------
 
             IntegrationScheme
             integration_scheme() const override ;
 
//------------------------------------------------------------------------------
 
             bool
             is_initialized() const override
             {
                 return mInitializedFlag ;
             }
 
//------------------------------------------------------------------------------
 
            Dof *
            dof( const id_t aID ) override;
 
//------------------------------------------------------------------------------
 
            bool
            dof_exists( const id_t aID ) const override ;
 
//------------------------------------------------------------------------------

            Cell< Dof * > &
            dofs();
 
//-----------------------------------------------------------------------------
 
            Bearing *
            bearing( const id_t aID );
 
//-----------------------------------------------------------------------------
 
            SideSet *
            sideset( const id_t aID ) override;
 
//------------------------------------------------------------------------------
 
            Block *
            block( const id_t aID ) override;
 
//------------------------------------------------------------------------------
 
            void
            extract_abstract_dofs_from_mesh() ;
 
//------------------------------------------------------------------------------
 
            id_t
            calculate_dof_id( const mesh::Node * aNode , const uint aDofType )  const override;
 
//------------------------------------------------------------------------------
 
            id_t
            calculate_dof_id( const mesh::Edge * aEdge , const uint aDofType )  const override;
 
//------------------------------------------------------------------------------
 
            id_t
            calculate_dof_id( const mesh::Face * aFace , const uint aDofType )  const;
 
//------------------------------------------------------------------------------
 
            id_t
            calculate_dof_id( const mesh::Facet * aFacet , const uint aDofType )  const override;
 
//-----------------------------------------------------------------------------
 
            void
            initialize() override;
 
//-----------------------------------------------------------------------------

            void
            initialize( const bool aSeedFreeDofsOnly );
 
//------------------------------------------------------------------------------
 
            void
            zero();
 
//-----------------------------------------------------------------------------

            void
            compute_jacobian( const bool aReset=true );
 
//-----------------------------------------------------------------------------
 
            void
            compute_rhs( const bool aReset=true );
 
//-----------------------------------------------------------------------------
 
            void
            compute_jacobian_and_rhs( const bool aReset=true );
 
//-----------------------------------------------------------------------------
 
            void
            compute_full_matrices();
 
//------------------------------------------------------------------------------

            void
            set_solver( const SolverParameters & aParams );
 
//------------------------------------------------------------------------------
 
            dofmgr::SolverData *
            solver_data() ;
 
//------------------------------------------------------------------------------
            Solver *
            solver();
 
//-----------------------------------------------------------------------------

            void
            solve();
 
//-----------------------------------------------------------------------------

            void
            compute_residual();
 
//-----------------------------------------------------------------------------

            void
            solve_from_residual();
 
//-----------------------------------------------------------------------------

            real
            residual( const uint aIteration );
 
//-----------------------------------------------------------------------------

            real
            absolute_residual() const ;
 
//-----------------------------------------------------------------------------

            real
            pre_update_residual() const ;
 
//-----------------------------------------------------------------------------

            real
            fixed_point_residual() const ;
 
//-----------------------------------------------------------------------------

            bool
            solve_failed() ;
 
//-----------------------------------------------------------------------------

            void
            collect_fields( const Cell< string > & aFieldLabels ) override ;
 
//-----------------------------------------------------------------------------

            void
            collect_field( const string & aFieldLabel ) ;
 
//-----------------------------------------------------------------------------

            void
            distribute_fields( const Cell< string > & aFieldLabels ) override ;
 
//-----------------------------------------------------------------------------

            void
            synchronize_fields( const Cell< string > & aFieldLabels ) override ;
 
//-----------------------------------------------------------------------------

            void
            compute_volume_loads( const Vector< id_t > & aBlockIDs );
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            system_matrix() ; // A: Free → Free coupling ( the Picard operator )
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            dirichlet() ;     // D matrix: Free → Fixed (Dirichlet BCs)
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            enforcement() ;   // E matrix: Fixed → Free (enforces constraints, computes forces)
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            imposition() ;    // I matrix: Fixed → Fixed (self-coupling of imposed values)
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            full_mass();
 
//-----------------------------------------------------------------------------
 
            SpMatrix *
            full_stiffness();
 
//-----------------------------------------------------------------------------

            void
            full_lhs( Vector< real > & aLHS );
 
//-----------------------------------------------------------------------------

            Vector< real >  &
            rhs_vector();
 
//------------------------------------------------------------------------------
 
            real
            rhs_norm();
 
//------------------------------------------------------------------------------
 
            void
            load_system( const string & aPath );
 
//------------------------------------------------------------------------------
 
            void
            save_system( const string & aPath );
 
//------------------------------------------------------------------------------
 
            void
            init_dof_values();
 
//------------------------------------------------------------------------------

            void
            seed_dof_values();
 
//------------------------------------------------------------------------------
 
            void
            reset_convection();
 
//------------------------------------------------------------------------------
#ifdef BELFEM_HDF5
 
            void
            load_system( HDF5 & aFile );
 
            void
            save_system( HDF5 & aFile );
 
#endif
//-----------------------------------------------------------------------------
 
            bool
            sideset_exists( const id_t & aID ) const override ;
 
//-----------------------------------------------------------------------------
 
            bool
            block_exists( const id_t & aID ) const override ;
 
//-----------------------------------------------------------------------------

            void
            create_fields( IWG * aIWG );
 
//-----------------------------------------------------------------------------

             Cell< Postprocessor * > &
             postprocessors();
 
//-----------------------------------------------------------------------------

             void
             initialize_postprocessors();
 
//-----------------------------------------------------------------------------

            void
            postprocess();
 
//------------------------------------------------------------------------------

            Cell< Block * > &
            blocks();
 
//------------------------------------------------------------------------------

            Cell< SideSet * > &
            sidesets();
 
//------------------------------------------------------------------------------
             index_t
             number_of_wetted_nodes() const ;
 
//------------------------------------------------------------------------------
 
             void
             disconnect_dofs_from_mesh();
 
//------------------------------------------------------------------------------

            dofmgr::EigenValues *
            eigen_values() ;
 
//------------------------------------------------------------------------------

             Element *
             element( const id_t aID );
 
             bool
             element_exists( const id_t aID ) const ;
 
//------------------------------------------------------------------------------
 
            Cell< Dof * > &
            abstract_dofs();
 
//-----------------------------------------------------------------------------
        private:
//-----------------------------------------------------------------------------
 
            void
            reset();
 
//------------------------------------------------------------------------------
 
            void
            init_dofs( const bool aSeedFreeDofsOnly );
 
//------------------------------------------------------------------------------
 
            void
            init_work();
 
//------------------------------------------------------------------------------
 
            void
            init_matrices();
 
//-----------------------------------------------------------------------------
 
            void
            compute_rhs_vector();
 
//-----------------------------------------------------------------------------
 
            void
            compute_rhs_matrix();
 
//---------------------------------------------v--------------------------------
 
            void
            auto_set_materials();
 
//------------------------------------------------------------------------------
 
            void
            consolidate_dofs();
 
//------------------------------------------------------------------------------
 
            void
            consolidate_dofs( Element * aElement );
 
//-----------------------------------------------------------------------------
 
            void
            link_bearings_with_dofs();
 
//-----------------------------------------------------------------------------
 
            void
            create_element_map();
 
//-----------------------------------------------------------------------------
        };
 
//-----------------------------------------------------------------------------
 
        inline uint
        DofManager::sideset_integration_order() const
        {
            return mParams->sideset_integration_order() ;
        }
 
//------------------------------------------------------------------------------
 
        inline IntegrationScheme
        DofManager::integration_scheme() const
        {
            return mParams->integration_scheme() ;
        }
 
//------------------------------------------------------------------------------
 
        inline uint
        DofManager::block_integration_order() const
        {
            return mParams->block_integration_order() ;
        }
 
 
//------------------------------------------------------------------------------
 
        inline Dof *
        DofManager::dof( const id_t aID )
        {
            return mDofData->dof( aID );
        }
 
//------------------------------------------------------------------------------
 
        inline Cell< Dof * > &
        DofManager::dofs()
        {
            return mDofData->dofs() ;
        }
 
//------------------------------------------------------------------------------
 
        inline id_t
        DofManager::calculate_dof_id( const mesh::Node * aNode , const uint aDofType )  const
        {
            return mDofData->node_dof_id( aNode->id(), aDofType );
        }
 
//------------------------------------------------------------------------------
 
        inline id_t
        DofManager::calculate_dof_id( const mesh::Facet * aFacet , const uint aDofType )  const
        {
            return mDofData->lambda_dof_id( aFacet->id(), aDofType );
        }
 
//------------------------------------------------------------------------------
 
        inline id_t
        DofManager::calculate_dof_id( const mesh::Edge * aEdge , const uint aDofType ) const
        {
            return mDofData->edge_dof_id( aEdge->id(), aDofType );
        }
 
//------------------------------------------------------------------------------
 
        inline id_t
        DofManager::calculate_dof_id( const mesh::Face * aFace , const uint aDofType ) const
        {
            return mDofData->face_dof_id( aFace->id(), aDofType );
        }
 
//------------------------------------------------------------------------------
 
        inline Bearing *
        DofManager::bearing( const id_t aID )
        {
            return mBearingData->bearing( aID );
        }
 
//------------------------------------------------------------------------------
 
        inline SideSet *
        DofManager::sideset( const id_t aID )
        {
            return mSideSetData->sideset( aID );
        }
 
//------------------------------------------------------------------------------
 
        inline Block *
        DofManager::block( const id_t aID )
        {
            return mBlockData->block( aID );
        }
 
//------------------------------------------------------------------------------
 
        inline dofmgr::SolverData *
        DofManager::solver_data()
        {
            return mSolverData ;
        }
 
//------------------------------------------------------------------------------
 
        inline Solver *
        DofManager::solver()
        {
            return mSolverData->solver() ;
        }
 
//------------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::system_matrix()
        {
            return mSolverData->system_matrix() ;
        }
 
//------------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::dirichlet()
        {
            return mSolverData->dirichlet() ;
        }
 
 //------------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::enforcement()
        {
            return mSolverData->enforcement() ;
        }
 
//------------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::imposition()
        {
            return mSolverData->imposition() ;
        }
 
//-----------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::full_mass()
        {
            return mSolverData->matrix( dofmgr::FullMass );
        }
 
//-----------------------------------------------------------------------------
 
        inline SpMatrix *
        DofManager::full_stiffness()
        {
            return mSolverData->matrix( dofmgr::FullStiffness );
        }
 
//------------------------------------------------------------------------------
 
        inline Vector< real >  &
        DofManager::rhs_vector()
        {
            return mSolverData->rhs_vector() ;
        }
 
//-----------------------------------------------------------------------------
 
        inline real
        DofManager::rhs_norm()
        {
            return mSolverData->rhs_norm() ;
        }
 
//-----------------------------------------------------------------------------
 
        inline bool
        DofManager::sideset_exists( const id_t & aID ) const
        {
            return mSideSetData->sideset_exists( aID );
        }
 
//-----------------------------------------------------------------------------
 
        inline bool
        DofManager::block_exists( const id_t & aID ) const
        {
            return mBlockData->block_exists( aID );
        }
 
//------------------------------------------------------------------------------
 
        inline bool
        DofManager::dof_exists( const id_t aID ) const
        {
            return mDofData->dof_exists( aID );
        }
 
//-----------------------------------------------------------------------------

        inline Cell< Postprocessor * > &
        DofManager::postprocessors()
        {
            return mPostprocessors ;
        }
 
//------------------------------------------------------------------------------
 
        inline Cell< Block * > &
        DofManager::blocks()
        {
            return mBlockData->blocks() ;
        }
 
//------------------------------------------------------------------------------
 
        inline  Cell< SideSet * > &
        DofManager::sidesets()
        {
            return mSideSetData->sidesets() ;
        }
 
//------------------------------------------------------------------------------
 
        inline index_t
        DofManager::number_of_wetted_nodes() const
        {
            return mSideSetData->number_of_wetted_nodes() ;
        }
 
//------------------------------------------------------------------------------
 
        inline dofmgr::EigenValues *
        DofManager::eigen_values()
        {
            return mEigenValues ;
        }
 
        inline Element *
        DofManager::element( const id_t aID )
        {
            return mElementMap( aID );
        }
 
        inline bool
        DofManager::element_exists( const id_t aID ) const
        {
            return mElementMap.key_exists( aID );
        }
        
//------------------------------------------------------------------------------
 
        inline Cell< Dof * > &
        DofManager::abstract_dofs()
        {
            return mDofData->abstract_dofs() ;
        }
 
//-----------------------------------------------------------------------------
    } /* end namespace fem */
} /* end namespace belfem */
#endif //BELFEM_CL_FEM_DOFMANAGER_HPP