time_domain_flutter_solver.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__time_domain_flutter_solver_h__
#define __mast__time_domain_flutter_solver_h__

// C++ includes
#include <memory>


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



namespace MAST {
    
    // Forward declerations
    class TimeDomainFlutterSolution;
    class Parameter;
    
    
    class TimeDomainFlutterSolver:
    public MAST::FlutterSolverBase {
      
    public:
        
        TimeDomainFlutterSolver();
        
        
        virtual ~TimeDomainFlutterSolver();
        
        
        
        virtual void clear();

        
        virtual void clear_solutions();

        
        void initialize(MAST::Parameter&                            velocity_param,
                        Real                                        V_lower,
                        Real                                        V_upper,
                        unsigned int                                n_V_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 std::pair<bool, MAST::FlutterRootBase*>
        analyze_and_find_critical_root_without_tracking(const Real g_tol,
                                                        const unsigned int n_iters);
        
        
        
        virtual void
        calculate_sensitivity(MAST::FlutterRootBase& root,
                              const MAST::FunctionBase& f,
                              libMesh::NumericVector<Real>* dXdp = nullptr,
                              libMesh::NumericVector<Real>* dXdV = nullptr);
        
        
        virtual void print_sorted_roots();
        
        
        virtual void print_crossover_points();
        
        
        virtual void scan_for_roots();
        
        
    protected:
        
        
        virtual std::unique_ptr<MAST::TimeDomainFlutterSolution>
        _analyze(const Real v_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 U_inf,
                                  RealMatrixX& A,
                                  RealMatrixX& B);

        
        void
        _initialize_matrix_sensitivity_for_param(const MAST::FunctionBase& f,
                                                 const libMesh::NumericVector<Real>& dXdp,
                                                 Real U_inf,
                                                 RealMatrixX& A,
                                                 RealMatrixX& B);

        
        virtual void _identify_crossover_points();


        MAST::Parameter*                                _velocity_param;
        
        
        std::pair<Real, Real>                           _V_range;


        unsigned int                                    _n_V_divs;

        
        std::map<Real, MAST::FlutterSolutionBase*>      _flutter_solutions;
        
        std::multimap<Real, MAST::FlutterRootCrossoverBase*> _flutter_crossovers;

    };
}


#endif // __mast__time_domain_flutter_solver_h__