pk_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__pk_flutter_solver_h__
#define __mast__pk_flutter_solver_h__

// C++ includes
#include <memory>


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


namespace MAST {
    
    // Forward declerations
    class Parameter;
    
    class PKFlutterSolver: public MAST::FlutterSolverBase
    {
    public:
        PKFlutterSolver();
        
        
        virtual ~PKFlutterSolver();
        

        virtual void clear();
        
        
        virtual void clear_solutions();
        
        
        void initialize(MAST::Parameter&                             V_param,
                        MAST::Parameter&                             kr_param,
                        MAST::Parameter&                             bref_param,
                        Real                                         rho,
                        Real                                         V_lower,
                        Real                                         V_upper,
                        unsigned int                                 n_V_divs,
                        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 print_sorted_roots();
        
        
        virtual void print_crossover_points();

        virtual void scan_for_roots();
        
        
        virtual void calculate_sensitivity(MAST::FlutterRootBase& root,
                                           const MAST::FunctionBase& f);
        
        
    protected:
        
        
        void _insert_new_solution(const Real k_red_ref,
                                  MAST::FlutterSolutionBase* sol);
        
        
        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);
        
        
        
        /*virtual std::pair<bool, MAST::FlutterSolutionBase*>
        newton_search(const MAST::FlutterSolutionBase& init_sol,
                      const unsigned int root_num,
                      const Real tol,
                      const unsigned int max_iters);*/
        
        virtual std::unique_ptr<MAST::FlutterSolutionBase>
        _analyze(const Real k_red,
                 const Real v_ref,
                 const MAST::FlutterSolutionBase* prev_sol=nullptr);
        
        
        
        void _initialize_matrices(const Real k_red,
                                  const Real v_ref,
                                  ComplexMatrixX& L,   // stiff, aero, damp
                                  ComplexMatrixX& R,   // mass
                                  RealMatrixX& stiff); // stiffness
        
        
        void
        _initialize_matrix_sensitivity_for_param(const MAST::FunctionBase& f,
                                                 const Real k_red,
                                                 const Real U_inf,
                                                 ComplexMatrixX& L,  // stiff, aero, damp
                                                 ComplexMatrixX& R); // mass

        
        virtual void _identify_crossover_points();

        MAST::Parameter*                                _velocity_param;

        MAST::Parameter*                                _kred_param;
        
        Real                                            _rho;

        MAST::Parameter*                                _bref_param;

        std::pair<Real, Real>                           _V_range;
        
        unsigned int                                    _n_V_divs;
        
        std::pair<Real, Real>                           _kr_range;
        
        unsigned int                                    _n_k_red_divs;
        
        std::map<Real, MAST::FlutterSolutionBase*>      _flutter_solutions;
        
        std::multimap<Real, MAST::FlutterRootCrossoverBase*> _flutter_crossovers;

        
    };
}


#endif // __mast__pk_flutter_solver_h__