structural_element_1d.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__structural_element_1d__
#define __mast__structural_element_1d__

// MAST includes
#include "elasticity/bending_structural_element.h"




namespace MAST {
    
    // Forward declerations
    class BendingOperator1D;
    class BoundaryConditionBase;
    class FEMOperatorMatrix;
    
    
    class StructuralElement1D:
    public MAST::BendingStructuralElem {
        
    public:
        StructuralElement1D(MAST::SystemInitialization& sys,
                            const MAST::GeomElem& elem,
                            const MAST::ElementPropertyCardBase& p);
        
        
        virtual ~StructuralElement1D();
        
        
        virtual unsigned int n_direct_strain_components() {
            return 2;
        }
        
        virtual unsigned int n_von_karman_strain_components() {
            return 2;
        }
        
        virtual bool internal_residual(bool request_jacobian,
                                       RealVectorX& f,
                                       RealMatrixX& jac);
        
        virtual bool internal_residual_sensitivity(const MAST::FunctionBase& p,
                                                   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) {
            libmesh_assert(false);
        }

        virtual bool
        internal_residual_jac_dot_state_sensitivity (RealMatrixX& jac);
        
        virtual bool prestress_residual (bool request_jacobian,
                                         RealVectorX& f,
                                         RealMatrixX& jac);
        
        virtual bool prestress_residual_sensitivity (const MAST::FunctionBase& p,
                                                     bool request_jacobian,
                                                     RealVectorX& f,
                                                     RealMatrixX& jac);
        
        virtual bool if_incompatible_modes() const {
            return false;
        }

        virtual bool calculate_stress(bool request_derivative,
                                      const MAST::FunctionBase* p,
                                      MAST::StressStrainOutputBase& output);
        
        virtual void
        calculate_stress_boundary_velocity(const MAST::FunctionBase& p,
                                           MAST::StressStrainOutputBase& output,
                                           const unsigned int s,
                                           const MAST::FieldFunction<RealVectorX>& vel_f) {
            libmesh_error(); // to be implemented
        }

        virtual void
        calculate_stress_temperature_derivative(MAST::FEBase& fe_thermal,
                                                MAST::StressStrainOutputBase& output) {
            libmesh_error(); // to be implemented
        }
        
        virtual void
        thermal_residual_temperature_derivative (const MAST::FEBase& fe_thermal,
                                                 RealMatrixX& m) {
            libmesh_error(); // to be implemented
        }

    protected:
        
        virtual bool
        surface_traction_residual(bool request_jacobian,
                                  RealVectorX& f,
                                  RealMatrixX& jac,
                                  const unsigned int side,
                                  MAST::BoundaryConditionBase& bc){ return false;}


        virtual bool
        surface_traction_residual_sensitivity(const MAST::FunctionBase& p,
                                              bool request_jacobian,
                                              RealVectorX& f,
                                              RealMatrixX& jac,
                                              const unsigned int side,
                                              MAST::BoundaryConditionBase& bc) {}


        virtual bool
        surface_traction_residual_shifted_boundary(bool request_jacobian,
                                                   RealVectorX& f,
                                                   RealMatrixX& jac,
                                                   const unsigned int side,
                                                   MAST::BoundaryConditionBase& bc) {}

        virtual bool
        surface_traction_residual_shifted_boundary_sensitivity(const MAST::FunctionBase& p,
                                                               bool request_jacobian,
                                                               RealVectorX& f,
                                                               RealMatrixX& jac,
                                                               const unsigned int side,
                                                               MAST::BoundaryConditionBase& bc) {}



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

        
        virtual bool thermal_residual(bool request_jacobian,
                                      RealVectorX& f,
                                      RealMatrixX& jac,
                                      MAST::BoundaryConditionBase& bc);
        
        virtual bool thermal_residual_sensitivity(const MAST::FunctionBase& p,
                                                  bool request_jacobian,
                                                  RealVectorX& f,
                                                  RealMatrixX& jac,
                                                  MAST::BoundaryConditionBase& bc);
        
        
        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) {
            
            libmesh_assert(false); // to be implemented
        }

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

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

        
        virtual bool piston_theory_residual(bool request_jacobian,
                                            RealVectorX &f,
                                            RealMatrixX& jac_xdot,
                                            RealMatrixX& jac,
                                            const unsigned int side,
                                            MAST::BoundaryConditionBase& bc) {
            
            libmesh_error_msg("Invalid Function Call: Piston theory force \
                              is not defined for 1D element side.");
        }

        
        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) {
            
            libmesh_error_msg("Invalid Function Call: Piston theory force sensitivity \
                              is not defined for 1D element side.");
        }


        virtual bool
        linearized_frequency_domain_surface_pressure_residual
        (bool request_jacobian,
         ComplexVectorX& f,
         ComplexMatrixX& jac,
         const unsigned int side,
         MAST::BoundaryConditionBase& bc) {
            
            libmesh_error(); // to be implemented
        }
        
        
        
        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) {
            
            libmesh_error(); // to be implemented
        }
        

        virtual void initialize_direct_strain_operator(const unsigned int qp,
                                                       const MAST::FEBase& fe,
                                                       MAST::FEMOperatorMatrix& Bmat);
        
        virtual void
        initialize_von_karman_strain_operator(const unsigned int qp,
                                              const MAST::FEBase& fe,
                                              RealVectorX& vk_strain,
                                              RealMatrixX& vk_dvdxi_mat,
                                              RealMatrixX& vk_dwdxi_mat,
                                              MAST::FEMOperatorMatrix& Bmat_v_vk,
                                              MAST::FEMOperatorMatrix& Bmat_w_vk);
        
        void
        initialize_von_karman_strain_operator_sensitivity
        (const unsigned int qp,
         const MAST::FEBase& fe,
         RealMatrixX& vk_dvdxi_mat_sens,
         RealMatrixX& vk_dwdxi_mat_sens);
        
        
        virtual void _internal_residual_operation(bool if_vk,
                                                  const unsigned int n2,
                                                  const unsigned int qp,
                                                  const MAST::FEBase& fe,
                                                  const std::vector<Real>& JxW,
                                                  bool request_jacobian,
                                                  RealVectorX& local_f,
                                                  RealMatrixX& local_jac,
                                                  MAST::BendingOperator1D* bend_op,
                                                  MAST::FEMOperatorMatrix& Bmat_mem,
                                                  MAST::FEMOperatorMatrix& Bmat_bend_v,
                                                  MAST::FEMOperatorMatrix& Bmat_bend_w,
                                                  MAST::FEMOperatorMatrix& Bmat_v_vk,
                                                  MAST::FEMOperatorMatrix& Bmat_w_vk,
                                                  RealMatrixX& stress,
                                                  RealMatrixX& stress_l,
                                                  RealMatrixX& vk_dvdxi_mat,
                                                  RealMatrixX& vk_dwdxi_mat,
                                                  RealMatrixX& material_A_mat,
                                                  RealMatrixX& material_B_mat,
                                                  RealMatrixX& material_D_mat,
                                                  RealVectorX& vec1_n1,
                                                  RealVectorX& vec2_n1,
                                                  RealVectorX& vec3_n2,
                                                  RealVectorX& vec4_2,
                                                  RealVectorX& vec5_2,
                                                  RealMatrixX& mat1_n1n2,
                                                  RealMatrixX& mat2_n2n2,
                                                  RealMatrixX& mat3,
                                                  RealMatrixX& mat4_2n2);
        
        

        void _convert_prestress_A_mat_to_vector(const RealMatrixX& mat,
                                                RealVectorX& vec) const;

        void _convert_prestress_B_mat_to_vector(const RealMatrixX& mat,
                                                RealVectorX& vec) const;

    };
}


#endif // __mast__structural_element_1d__