cl_SolverWrapper.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_SOLVERWRAPPER_HPP
#define BELFEM_CL_SOLVERWRAPPER_HPP
 
#include "typedefs.hpp"
#include "cl_Vector.hpp"
#include "cl_Matrix.hpp"
#include "cl_SpMatrix.hpp"
#include "en_SolverEnums.hpp"
#include "fn_create_graph_from_matrix.hpp"
#include "cl_Communicator.hpp"
 
namespace belfem
{
    namespace solver
    {
        class Wrapper : public CommunicationObject
        {
//------------------------------------------------------------------------------
 
            // rank of this proc
            const proc_t mCommRank ;
 
            const proc_t mCommSize ;
 
            const bool mUsesMPI ;
 
            // label of this solver type
            const string mLabel ;
 
            // flag telling if we have been initialized
            bool mIsInitialized = false ;

            bool mSoftFail = false ;
            bool mFailed   = false ;
 
        protected:

            bool
            soft_fail() const
            {
                return mSoftFail ;
            }
 
            void
            flag_failure()
            {
                mFailed = true ;
            }

            SpMatrix * mMatrix = nullptr ;
 
//------------------------------------------------------------------------------
        public:
//------------------------------------------------------------------------------
 
            Wrapper( const string & aLabel, const bool aUsesMPI );
 
//------------------------------------------------------------------------------
 
            virtual ~Wrapper();
 
//------------------------------------------------------------------------------
 
            const string &
            label() const ;
 
//------------------------------------------------------------------------------

            void
            set_soft_fail( const bool aFlag )
            {
                mSoftFail = aFlag ;
            }

            bool
            failed() const
            {
                return mFailed ;
            }

            void
            clear_failure()
            {
                mFailed = false ;
            }
 
//------------------------------------------------------------------------------

            virtual void
            solve( SpMatrix & aMatrix,
                   Vector <real> & aLHS,
                   Vector <real> & aRHS );
 
//------------------------------------------------------------------------------
 
            virtual void
            solve( SpMatrix & aMatrix,
                   Matrix <real> & aLHS,
                   Matrix <real> & aRHS );
 
//------------------------------------------------------------------------------

            bool
            is_initialized() const ;
 
//------------------------------------------------------------------------------

            proc_t
            rank() const ;
 
//------------------------------------------------------------------------------

            proc_t
            comm_size() const ;
 
//------------------------------------------------------------------------------
 
            bool
            uses_mpi() const ;
 
//------------------------------------------------------------------------------
 
        virtual void
        initialize(
                SpMatrix & aMatrix,
                // UNSYMMETRIC, and it must stay identical to the MUMPS override's
                // default: default arguments bind STATICALLY, so a base/derived
                // mismatch would silently change the mode with the static type
                // of the pointer the call goes through
                const SymmetryMode aSymmetryMode = SymmetryMode::Unsymmetric,
                const int_t aNumRhsColumns = 1 );
 
//------------------------------------------------------------------------------
 
        void
        free() override;
 
//------------------------------------------------------------------------------

        virtual real
        get_determinant() const ;
 
//------------------------------------------------------------------------------

        virtual real
        get_cond1() const ;
 
//------------------------------------------------------------------------------

       virtual real
       get_cond2() const ;
 
//------------------------------------------------------------------------------

        virtual real
        get_forward_error() const ;
 
//------------------------------------------------------------------------------

        virtual real
        get_backward_error() const ;
 
//------------------------------------------------------------------------------

        virtual real
        get_omega2() const ;
 
//------------------------------------------------------------------------------

        virtual bool
        supports_factorization_reuse() const ;
 
//------------------------------------------------------------------------------

        virtual void
        freeze_factorization( const SpMatrix & aMatrix );
 
//------------------------------------------------------------------------------

        virtual void
        unfreeze_factorization();
 
//------------------------------------------------------------------------------

        virtual bool
        factorization_is_frozen() const ;
 
//------------------------------------------------------------------------------
        protected:
//------------------------------------------------------------------------------
 
            virtual void
            initialize();
 
//------------------------------------------------------------------------------

            void
            hatch_turtle();
 
//------------------------------------------------------------------------------

            void
            mat2vec( const Matrix< real > & aM,
                           Vector< real > & aV );
 
//------------------------------------------------------------------------------
 
            void
            vec2mat( const Vector< real > & aV,
                           Matrix< real > & aM );
 
 
//------------------------------------------------------------------------------

            SpMatrix *
            matrix() ;
 
//------------------------------------------------------------------------------
        };
 
//------------------------------------------------------------------------------
 
        inline bool
        Wrapper::is_initialized() const
        {
            return mIsInitialized ;
        }
 
//------------------------------------------------------------------------------
 
        inline proc_t
        Wrapper::rank() const
        {
            return mCommRank ;
        }
 
//------------------------------------------------------------------------------
 
        inline proc_t
        Wrapper::comm_size() const
        {
            return mCommSize ;
        }
 
//------------------------------------------------------------------------------
 
        inline bool Wrapper::uses_mpi() const
        {
            return mUsesMPI ;
        }
 
//------------------------------------------------------------------------------
 
        inline SpMatrix *
        Wrapper::matrix()
        {
            return mMatrix ;
        }
 
//------------------------------------------------------------------------------
    }
}
 
#endif //BELFEM_CL_SOLVERWRAPPER_HPP