nonlinear_system.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2020  Manav Bhatia and MAST authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __mast__nonlinear_system_h__
#define __mast__nonlinear_system_h__

// C++ includes
#include <memory>

// MAST includes
#include "base/mast_data_types.h"

// libMesh includes
#include "libmesh/nonlinear_implicit_system.h"
#include "libmesh/enum_eigen_solver_type.h"
#include "libmesh/eigen_system.h"


namespace MAST {
    
    
    // Forward declerations
    class Parameter;
    class SlepcEigenSolver;
    class AssemblyBase;
    class PhysicsDisciplineBase;
    class AssemblyElemOperations;
    class OutputAssemblyElemOperations;
    class FunctionBase;
    class EigenproblemAssembly;
    
    
    class NonlinearSystem:
    public libMesh::NonlinearImplicitSystem {
        
    public:
        
        NonlinearSystem(libMesh::EquationSystems& es,
                         const std::string& name,
                         const unsigned int number);
        
        
        virtual ~NonlinearSystem();

        
        enum Operation {
            NONLINEAR_SOLVE,
            EIGENPROBLEM_SOLVE,
            FORWARD_SENSITIVITY_SOLVE,
            ADJOINT_SOLVE,
            NONE
        };
        
        
        MAST::NonlinearSystem::Operation operation() {
            
            return _operation;
        }

        
        void set_operation(MAST::NonlinearSystem::Operation op) {
            
            _operation = op;
        }

        void set_init_B_matrix() {
            _initialize_B_matrix = true;
        }
        
        
        virtual void clear () libmesh_override;
        
        
        virtual void reinit () libmesh_override;


        virtual std::pair<unsigned int, Real>
        get_linear_solve_parameters();

        
        virtual void solve(MAST::AssemblyElemOperations& elem_ops,
                           MAST::AssemblyBase&           assembly);
        
        
        virtual void sensitivity_solve(const libMesh::NumericVector<Real>& X,
                                       bool if_localize_sol,
                                       MAST::AssemblyElemOperations&   elem_ops,
                                       MAST::AssemblyBase&             assembly,
                                       const MAST::FunctionBase&       p,
                                       bool if_assemble_jacobian = true);

        
        virtual void adjoint_solve(const libMesh::NumericVector<Real>& X,
                                   bool if_localize_sol,
                                   MAST::AssemblyElemOperations&       elem_ops,
                                   MAST::OutputAssemblyElemOperations& output,
                                   MAST::AssemblyBase&                 assembly,
                                   bool if_assemble_jacobian           = true);
        
        
        virtual void eigenproblem_solve(MAST::AssemblyElemOperations& elem_ops,
                                        MAST::EigenproblemAssembly&   assembly);
        
        virtual void
        eigenproblem_sensitivity_solve (MAST::AssemblyElemOperations& elem_ops,
                                        MAST::EigenproblemAssembly& assembly,
                                        const MAST::FunctionBase& f,
                                        std::vector<Real>& sens,
                                        const std::vector<unsigned int>* indices=nullptr);

        
        virtual void
        get_eigenvalue (unsigned int i, Real&  re, Real&  im);

        
        virtual void
        get_eigenpair (unsigned int i,
                       Real&  re,
                       Real&  im,
                       libMesh::NumericVector<Real>& vec_re,
                       libMesh::NumericVector<Real>* vec_im = nullptr);
        
        void set_exchange_A_and_B (bool flag) {_exchange_A_and_B = flag;}

        void set_n_requested_eigenvalues (unsigned int n)
        { _n_requested_eigenpairs = n; };

        
        unsigned int
        get_n_converged_eigenvalues () const {return _n_converged_eigenpairs;}

        unsigned int
        get_n_requested_eigenvalues () const {return _n_requested_eigenpairs;}

        unsigned int get_n_iterations () const {return _n_iterations;}
        
        void set_eigenproblem_type (libMesh::EigenProblemType ept);
        
        libMesh::EigenProblemType
        get_eigenproblem_type () const {return _eigen_problem_type;}
        
        bool generalized () const { return _is_generalized_eigenproblem; }
        
        
        libMesh::SparseMatrix<Real> *matrix_A;
        
        libMesh::SparseMatrix<Real> *matrix_B;
        
        
        std::unique_ptr<MAST::SlepcEigenSolver> eigen_solver;
        
        std::unique_ptr<libMesh::LinearSolver<Real>> linear_solver;
        
        void initialize_condensed_dofs(MAST::PhysicsDisciplineBase& physics);
        
        unsigned int n_global_non_condensed_dofs() const;
        
        
        void write_out_vector(libMesh::NumericVector<Real>& vec,
                              const std::string & directory_name,
                              const std::string & data_name,
                              const bool write_binary_vectors);

        
        void read_in_vector(libMesh::NumericVector<Real>& vec,
                            const std::string & directory_name,
                            const std::string & data_name,
                            const bool read_binary_vectors);

        void
        project_vector_without_dirichlet (libMesh::NumericVector<Real> & new_vector,
                                          libMesh::FunctionBase<Real>& f) const;
        
    protected:
        
        
        virtual void init_data () libmesh_override;
        
        
        void set_n_converged (unsigned int nconv)
        { _n_converged_eigenpairs = nconv; }
        
        void set_n_iterations (unsigned int its)
        { _n_iterations = its;}
        
        
        bool _initialize_B_matrix;
        
        
        bool                               _condensed_dofs_initialized;
        
        unsigned int                       _n_requested_eigenpairs;
        
        bool                               _exchange_A_and_B;
        
        unsigned int                       _n_converged_eigenpairs;
        
        unsigned int                       _n_iterations;
        
        bool                               _is_generalized_eigenproblem;
        
        libMesh::EigenProblemType          _eigen_problem_type;
        
        MAST::NonlinearSystem::Operation  _operation;
        
        std::vector<libMesh::dof_id_type>  _local_non_condensed_dofs_vector;
        
    };
}


#endif // __mast__nonlinear_system_h__