ug_flutter_solver.h

Go to the documentation of this file.

/*
 * MAST: Multidisciplinary-design Adaptation and Sensitivity Toolkit
 * Copyright (C) 2013-2019  Manav Bhatia
 *
 * 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__ug_flutter_solver_h__
#define __mast__ug_flutter_solver_h__

// C++ includes
#include <memory>


// MAST includes
#include "aeroelasticity/flutter_solver_base.h"


namespace MAST {
    
    // Forward declerations
    class Parameter;
    
    class UGFlutterSolver:
    public MAST::FlutterSolverBase {
        
    public:
        
        UGFlutterSolver();
        
        
        virtual ~UGFlutterSolver();
        
        
        
        void clear();
        
        
        virtual void clear_solutions();
        
        
        void initialize(MAST::Parameter&                            kr_param,
                        MAST::Parameter&                            bref_param,
                        Real                                        rho,
                        Real                                        kr_lower,
                        Real                                        kr_upper,
                        unsigned int                                n_kr_divs,
                        std::vector<libMesh::NumericVector<Real>*>& basis);
        
        
        
        virtual unsigned int n_roots_found() const;
        
        
        const MAST::FlutterRootBase& get_root(const unsigned int n) const;
        
                
        virtual std::pair<bool, MAST::FlutterRootBase*>
        find_next_root(const Real g_tol,
                       const unsigned int n_bisection_iters);
        
        
        
        virtual std::pair<bool, MAST::FlutterRootBase*>
        find_critical_root(const Real g_tol,
                           const unsigned int n_bisection_iters);
        
        
        virtual void
        calculate_sensitivity(MAST::FlutterRootBase& root,
                              const MAST::FunctionBase& f,
                              libMesh::NumericVector<Real>* dXdp = nullptr,
                              libMesh::NumericVector<Real>* dXdkr = nullptr);
        
        
        virtual void print_sorted_roots();
        
        
        virtual void print_crossover_points();
        
        
        virtual void scan_for_roots();
        
        
    protected:
        
        
        virtual std::unique_ptr<MAST::FlutterSolutionBase>
        _analyze(const Real kr_ref,
                 const MAST::FlutterSolutionBase* prev_sol=nullptr);
        
        
        
        virtual std::pair<bool, MAST::FlutterSolutionBase*>
        _bisection_search(const std::pair<MAST::FlutterSolutionBase*,
                          MAST::FlutterSolutionBase*>& ref_sol_range,
                          const unsigned int root_num,
                          const Real g_tol,
                          const unsigned int max_iters);
        
        
        void _initialize_matrices(Real kr,
                                  ComplexMatrixX& A,
                                  ComplexMatrixX& B);
        
        
        void
        _initialize_matrix_sensitivity_for_param(const MAST::FunctionBase& f,
                                                 const libMesh::NumericVector<Real>& dXdp,
                                                 Real kr,
                                                 ComplexMatrixX& A,
                                                 ComplexMatrixX& B);

        
        void
        _initialize_matrix_sensitivity_for_kr(Real kr,
                                              ComplexMatrixX& A,
                                              ComplexMatrixX& B);

        
        virtual void _identify_crossover_points();
        
        
        MAST::Parameter*                                _kr_param;
        
        
        MAST::Parameter*                                _bref_param;

        
        Real                                            _rho;
        
        
        std::pair<Real, Real>                           _kr_range;
        
        
        unsigned int                                    _n_kr_divs;
        
        
        std::map<Real, MAST::FlutterSolutionBase*>      _flutter_solutions;

        
        bool _include_highest_kr_unstable;
        
        std::multimap<Real, MAST::FlutterRootCrossoverBase*> _flutter_crossovers;
        
    };
}


#endif // __mast__ug_flutter_solver_h__