structural_element_base.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__structural_element_base__
#define __mast__structural_element_base__

// C++ includes
#include <memory>
#include <map>

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


namespace MAST {
    
    // Forward declerations
    class GeomElem;
    class ElementPropertyCardBase;
    class BoundaryConditionBase;
    class FEMOperatorMatrix;
    class StressStrainOutputBase;
    template <typename ValType> class FieldFunction;
    
    
    class StructuralElementBase:
    public MAST::ElementBase
    {
    public:
        StructuralElementBase(MAST::SystemInitialization& sys,
                              MAST::AssemblyBase& assembly,
                              const MAST::GeomElem& elem,
                              const MAST::ElementPropertyCardBase& p);
        
        virtual ~StructuralElementBase();

        
        virtual void set_solution(const RealVectorX& vec,
                                  bool if_sens = false);

        
        virtual void set_perturbed_solution(const RealVectorX& vec,
                                            bool if_sens = false);

        
        virtual void set_velocity(const RealVectorX& vec,
                                  bool if_sens = false);

        virtual void set_perturbed_velocity(const RealVectorX& vec,
                                            bool if_sens = false);

        
        virtual void set_acceleration(const RealVectorX& vec,
                                      bool if_sens = false);

        
        virtual void set_perturbed_acceleration(const RealVectorX& vec,
                                                bool if_sens = false);

        
        const RealVectorX& local_solution(bool if_sens = false) const {
            
            if (!if_sens)
                return _local_sol;
            else
                return _local_sol_sens;
        }
        
        const MAST::ElementPropertyCardBase& elem_property()  {
            return _property;
        }
        
        
        virtual bool internal_residual (bool request_jacobian,
                                        RealVectorX& f,
                                        RealMatrixX& jac) = 0;

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

        virtual void
        internal_residual_boundary_velocity(const MAST::FunctionBase& p,
                                            const unsigned int s,
                                            const MAST::FieldFunction<RealVectorX>& vel_f,
                                            bool request_jacobian,
                                            RealVectorX& f,
                                            RealMatrixX& jac) = 0;
        
        virtual bool
        internal_residual_jac_dot_state_sensitivity (RealMatrixX& jac) = 0;
        
        
        
        virtual bool damping_residual (bool request_jacobian,
                                       RealVectorX& f,
                                       RealMatrixX& jac_xdot,
                                       RealMatrixX& jac) {
            
            // to be implemented nothing is done yet
            return false;
        }
        
        virtual bool inertial_residual (bool request_jacobian,
                                        RealVectorX& f,
                                        RealMatrixX& jac_xddot,
                                        RealMatrixX& jac_xdot,
                                        RealMatrixX& jac);

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

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

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

        bool
        linearized_frequency_domain_side_external_residual
        (bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         std::multimap<libMesh::boundary_id_type, MAST::BoundaryConditionBase*>& bc);
        
        
        virtual bool prestress_residual (bool request_jacobian,
                                         RealVectorX& f,
                                         RealMatrixX& jac) = 0;
        
        bool volume_external_residual (bool request_jacobian,
                                       RealVectorX& f,
                                       RealMatrixX& jac_xdot,
                                       RealMatrixX& jac,
                                       std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*>& bc);

        
        void volume_external_residual_boundary_velocity
        (const MAST::FunctionBase& p,
         const unsigned int s,
         const MAST::FieldFunction<RealVectorX>& vel_f,
         std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*>& bc,
         bool request_jacobian,
         RealVectorX& f,
         RealMatrixX& jac);

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

        
        bool
        linearized_frequency_domain_volume_external_residual
        (bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*>& bc);
        
        
        
        virtual bool internal_residual_sensitivity (const MAST::FunctionBase& p,
                                                    bool request_jacobian,
                                                    RealVectorX& f,
                                                    RealMatrixX& jac) = 0;

        virtual bool damping_residual_sensitivity (const MAST::FunctionBase& p,
                                                   bool request_jacobian,
                                                   RealVectorX& f,
                                                   RealMatrixX& jac_xdot,
                                                   RealMatrixX& jac) {
            return false;
        }
        
        virtual bool inertial_residual_sensitivity (const MAST::FunctionBase& p,
                                                    bool request_jacobian,
                                                    RealVectorX& f,
                                                    RealMatrixX& jac_xddot,
                                                    RealMatrixX& jac_xdot,
                                                    RealMatrixX& jac);

        virtual void
        inertial_residual_boundary_velocity (const MAST::FunctionBase& p,
                                             const unsigned int s,
                                             const MAST::FieldFunction<RealVectorX>& vel_f,
                                             bool request_jacobian,
                                             RealVectorX& f,
                                             RealMatrixX& jac_xddot,
                                             RealMatrixX& jac_xdot,
                                             RealMatrixX& jac);

        bool side_external_residual_sensitivity (const MAST::FunctionBase& p,
                                                 bool request_jacobian,
                                                 RealVectorX& f,
                                                 RealMatrixX& jac_xdot,
                                                 RealMatrixX& jac,
                                                 std::multimap<libMesh::boundary_id_type, MAST::BoundaryConditionBase*>& bc);
        
        virtual bool prestress_residual_sensitivity (const MAST::FunctionBase& p,
                                                     bool request_jacobian,
                                                     RealVectorX& f,
                                                     RealMatrixX& jac) = 0;
        
        bool volume_external_residual_sensitivity (const MAST::FunctionBase& p,
                                                   bool request_jacobian,
                                                   RealVectorX& f,
                                                   RealMatrixX& jac_xdot,
                                                   RealMatrixX& jac,
                                                   std::multimap<libMesh::subdomain_id_type, MAST::BoundaryConditionBase*>& bc);
        


        virtual bool if_incompatible_modes() const = 0;

        
        virtual unsigned int incompatible_mode_size() const {
            // needs to be implemented only in inherited elements
            // that use incompatible modes
            libmesh_error();
            return 0;
        }

        
        void set_incompatible_mode_solution(RealVectorX& vec) {
            _incompatible_sol = &vec;
        }
        
        
        virtual void update_incompatible_mode_solution(const RealVectorX& dsol) {
            // should be implemented in derived classes, if relevant
            libmesh_error();
        }

        
        virtual bool calculate_stress(bool request_derivative,
                                      const MAST::FunctionBase* f,
                                      MAST::StressStrainOutputBase& output) = 0;
        

        virtual void
        calculate_stress_boundary_velocity(const MAST::FunctionBase& p,
                                           MAST::StressStrainOutputBase& output,
                                           const unsigned int s,
                                           const MAST::FieldFunction<RealVectorX>& vel_f) = 0;

        virtual void
        calculate_stress_temperature_derivative(MAST::FEBase& fe_thermal,
                                                MAST::StressStrainOutputBase& output) = 0;
        
        virtual void
        thermal_residual_temperature_derivative (const MAST::FEBase& fe_thermal,
                                                 RealMatrixX& m) = 0;

        bool follower_forces;
        

        template <typename ValType>
        void transform_matrix_to_global_system(const ValType& local_mat,
                                               ValType& global_mat) const;
        
        template <typename ValType>
        void transform_vector_to_local_system(const ValType& global_vec,
                                              ValType& local_vec) const;
        
        template <typename ValType>
        void transform_vector_to_global_system(const ValType& local_vec,
                                               ValType& global_vec) const;
        
    protected:
        
        virtual bool
        surface_pressure_residual(bool request_jacobian,
                                  RealVectorX& f,
                                  RealMatrixX& jac,
                                  const unsigned int side,
                                  MAST::BoundaryConditionBase& bc) = 0;
        
        
        virtual bool
        surface_pressure_residual(bool request_jacobian,
                                  RealVectorX& f,
                                  RealMatrixX& jac,
                                  MAST::BoundaryConditionBase& bc);

        virtual void
        surface_pressure_boundary_velocity(const MAST::FunctionBase& p,
                                           const unsigned int s,
                                           const MAST::FieldFunction<RealVectorX>& vel_f,
                                           MAST::BoundaryConditionBase& bc,
                                           bool request_jacobian,
                                           RealVectorX& f,
                                           RealMatrixX& jac);

        virtual bool
        linearized_surface_pressure_residual(bool request_jacobian,
                                             RealVectorX& f,
                                             RealMatrixX& jac,
                                             MAST::BoundaryConditionBase& bc);

        
        Real piston_theory_cp(const unsigned int order,
                              const Real vel_U,
                              const Real gamma,
                              const Real mach);

        
        
        Real piston_theory_dcp_dv(const unsigned int order,
                                  const Real vel_U,
                                  const Real gamma,
                                  const Real mach);

        
        virtual bool piston_theory_residual(bool request_jacobian,
                                            RealVectorX &f,
                                            RealMatrixX& jac_xdot,
                                            RealMatrixX& jac,
                                            MAST::BoundaryConditionBase& bc) = 0;
        
        virtual bool piston_theory_residual(bool request_jacobian,
                                            RealVectorX &f,
                                            RealMatrixX& jac_xdot,
                                            RealMatrixX& jac,
                                            const unsigned int side,
                                            MAST::BoundaryConditionBase& bc) = 0;

        
        
        virtual bool piston_theory_residual_sensitivity(const MAST::FunctionBase& p,
                                                        bool request_jacobian,
                                                        RealVectorX &f,
                                                        RealMatrixX& jac_xdot,
                                                        RealMatrixX& jac,
                                                        MAST::BoundaryConditionBase& bc) = 0;
        
        virtual bool piston_theory_residual_sensitivity(const MAST::FunctionBase& p,
                                                        bool request_jacobian,
                                                        RealVectorX &f,
                                                        RealMatrixX& jac_xdot,
                                                        RealMatrixX& jac,
                                                        const unsigned int side,
                                                        MAST::BoundaryConditionBase& bc) = 0;

        
        virtual bool
        linearized_frequency_domain_surface_pressure_residual
        (bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         const unsigned int side,
         MAST::BoundaryConditionBase& bc) = 0;
        
        
        virtual bool
        linearized_frequency_domain_surface_pressure_residual
        (bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         MAST::BoundaryConditionBase& bc);
        
        
        virtual bool
        linearized_frequency_domain_surface_pressure_residual_sensitivity
        (const MAST::FunctionBase& p,
         bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         const unsigned int side,
         MAST::BoundaryConditionBase& bc) = 0;
        
        
        virtual bool
        linearized_frequency_domain_surface_pressure_residual_sensitivity
        (const MAST::FunctionBase& p,
         bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         MAST::BoundaryConditionBase& bc) {
            
            libmesh_error(); // to be implemented
        }
        
        
        virtual bool
        surface_pressure_residual_sensitivity(const MAST::FunctionBase& p,
                                              bool request_jacobian,
                                              RealVectorX& f,
                                              RealMatrixX& jac,
                                              const unsigned int side,
                                              MAST::BoundaryConditionBase& bc) = 0;
        
        virtual bool
        surface_pressure_residual_sensitivity(const MAST::FunctionBase& p,
                                              bool request_jacobian,
                                              RealVectorX& f,
                                              RealMatrixX& jac,
                                              MAST::BoundaryConditionBase& bc);

        
        
        virtual bool thermal_residual(bool request_jacobian,
                                      RealVectorX& f,
                                      RealMatrixX& jac,
                                      MAST::BoundaryConditionBase& bc) = 0;
        
        virtual bool thermal_residual_sensitivity(const MAST::FunctionBase& p,
                                                  bool request_jacobian,
                                                  RealVectorX& f,
                                                  RealMatrixX& jac,
                                                  MAST::BoundaryConditionBase& bc) = 0;
        
        virtual void thermal_residual_boundary_velocity(const MAST::FunctionBase& p,
                                                        const unsigned int s,
                                                        const MAST::FieldFunction<RealVectorX>& vel_f,
                                                        MAST::BoundaryConditionBase& bc,
                                                        bool request_jacobian,
                                                        RealVectorX& f,
                                                        RealMatrixX& jac) = 0;
        
        const MAST::ElementPropertyCardBase& _property;
        
        
        RealVectorX _local_sol;


        RealVectorX _local_delta_sol;

        
        RealVectorX _local_sol_sens;


        RealVectorX _local_delta_sol_sens;

        
        RealVectorX _local_vel;

        
        RealVectorX _local_delta_vel;

        
        RealVectorX _local_vel_sens;

        
        RealVectorX _local_delta_vel_sens;

        
        RealVectorX _local_accel;

        
        RealVectorX _local_delta_accel;

        
        RealVectorX _local_accel_sens;

        
        RealVectorX _local_delta_accel_sens;

        
        RealVectorX* _incompatible_sol;
        
    };
    
    
    std::unique_ptr<MAST::StructuralElementBase>
    build_structural_element(MAST::SystemInitialization& sys,
                             MAST::AssemblyBase& assembly,
                             const MAST::GeomElem& elem,
                             const MAST::ElementPropertyCardBase& p);
    
}


#endif // __mast__structural_element_base__