conservative_fluid_element_base.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__conservative_fluid_element_base__
#define __mast__conservative_fluid_element_base__


// MAST includes
#include "base/elem_base.h"
#include "fluid/fluid_elem_base.h"


namespace MAST {
    
    // Forward declerations
    class ElementPropertyCardBase;
    class BoundaryConditionBase;
    class FEMOperatorMatrix;
    class OutputAssemblyElemOperations;

    
    class ConservativeFluidElementBase:
    public MAST::FluidElemBase,
    public MAST::ElementBase {
        
    public:
        
        ConservativeFluidElementBase(MAST::SystemInitialization&  sys,
                                     const MAST::GeomElem&         elem,
                                     const MAST::FlightCondition& f);
        
        virtual ~ConservativeFluidElementBase();
        
        
        virtual bool
        internal_residual (bool request_jacobian,
                           RealVectorX& f,
                           RealMatrixX& jac);
        
        
        virtual bool
        linearized_internal_residual (bool request_jacobian,
                                      RealVectorX& f,
                                      RealMatrixX& jac);

        
        virtual bool
        velocity_residual (bool request_jacobian,
                           RealVectorX& f,
                           RealMatrixX& jac_xdot,
                           RealMatrixX& jac);

        virtual bool
        linearized_velocity_residual (bool request_jacobian,
                                      RealVectorX& f,
                                      RealMatrixX& jac_xdot,
                                      RealMatrixX& jac);

        bool
        side_external_residual (bool request_jacobian,
                                RealVectorX& f,
                                RealMatrixX& jac,
                                std::multimap<libMesh::boundary_id_type, MAST::BoundaryConditionBase*>& bc);

        
        bool
        linearized_side_external_residual (bool request_jacobian,
                                           RealVectorX& f,
                                           RealMatrixX& jac,
                                           std::multimap<libMesh::boundary_id_type, MAST::BoundaryConditionBase*>& bc);

        virtual bool
        internal_residual_sensitivity (const MAST::FunctionBase& p,
                                       bool request_jacobian,
                                       RealVectorX& f,
                                       RealMatrixX& jac);
        virtual bool
        velocity_residual_sensitivity (const MAST::FunctionBase& p,
                                       bool request_jacobian,
                                       RealVectorX& f,
                                       RealMatrixX& jac_xdot,
                                       RealMatrixX& jac);
        
        bool
        side_external_residual_sensitivity (const MAST::FunctionBase& p,
                                            bool request_jacobian,
                                            RealVectorX& f,
                                            RealMatrixX& jac,
                                            std::multimap<libMesh::boundary_id_type, MAST::BoundaryConditionBase*>& bc);
        
        virtual void
        side_integrated_force(const unsigned int s,
                              RealVectorX& f,
                              RealMatrixX* dfdX = nullptr);

        
        virtual void
        side_integrated_force_sensitivity(const MAST::FunctionBase& p,
                                          const unsigned int s,
                                          RealVectorX& f);
        
        
        virtual bool symmetry_surface_residual(bool request_jacobian,
                                               RealVectorX& f,
                                               RealMatrixX& jac,
                                               const unsigned int s,
                                               MAST::BoundaryConditionBase& bc);
        
        virtual bool symmetry_surface_residual_sensitivity(const MAST::FunctionBase& p,
                                                           bool request_jacobian,
                                                           RealVectorX& f,
                                                           RealMatrixX& jac,
                                                           const unsigned int s,
                                                           MAST::BoundaryConditionBase& bc);
        
        virtual bool slip_wall_surface_residual(bool request_jacobian,
                                                RealVectorX& f,
                                                RealMatrixX& jac,
                                                const unsigned int s,
                                                MAST::BoundaryConditionBase& bc);

        
        virtual bool
        linearized_slip_wall_surface_residual(bool request_jacobian,
                                              RealVectorX& f,
                                              RealMatrixX& jac,
                                              const unsigned int s,
                                              MAST::BoundaryConditionBase& bc);

        
        virtual bool noslip_wall_surface_residual_sensitivity(const MAST::FunctionBase& p,
                                                              bool request_jacobian,
                                                              RealVectorX& f,
                                                              RealMatrixX& jac,
                                                              const unsigned int s,
                                                              MAST::BoundaryConditionBase& bc);

        virtual bool noslip_wall_surface_residual(bool request_jacobian,
                                                  RealVectorX& f,
                                                  RealMatrixX& jac,
                                                  const unsigned int s,
                                                  MAST::BoundaryConditionBase& bc);

        
        virtual bool slip_wall_surface_residual_sensitivity(const MAST::FunctionBase& p,
                                                            bool request_jacobian,
                                                            RealVectorX& f,
                                                            RealMatrixX& jac,
                                                            const unsigned int s,
                                                            MAST::BoundaryConditionBase& bc);
        
        virtual bool far_field_surface_residual(bool request_jacobian,
                                                RealVectorX& f,
                                                RealMatrixX& jac,
                                                const unsigned int s,
                                                MAST::BoundaryConditionBase& bc);
        
        virtual bool far_field_surface_residual_sensitivity(const MAST::FunctionBase& p,
                                                            bool request_jacobian,
                                                            RealVectorX& f,
                                                            RealMatrixX& jac,
                                                            const unsigned int s,
                                                            MAST::BoundaryConditionBase& bc);
        
    protected:
        

        void _calculate_surface_integrated_load(bool request_derivative,
                                                const MAST::FunctionBase* p,
                                                const unsigned int s,
                                                MAST::OutputAssemblyElemOperations& output);
        

        void _initialize_fem_interpolation_operator(const unsigned int qp,
                                                    const unsigned int dim,
                                                    const MAST::FEBase& fe,
                                                    MAST::FEMOperatorMatrix& Bmat);
        
        
        void _initialize_fem_gradient_operator(const unsigned int qp,
                                               const unsigned int dim,
                                               const MAST::FEBase& fe,
                                               std::vector<MAST::FEMOperatorMatrix>& dBmat);

        void
        _initialize_fem_second_derivative_operator(const unsigned int qp,
                                                   const unsigned int dim,
                                                   const MAST::FEBase& fe,
                                                   std::vector<std::vector<MAST::FEMOperatorMatrix>>& d2Bmat);
        
    };
}


#endif // __mast__conservative_fluid_element_base__