stress_output_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__stress_output_base__
#define __mast__stress_output_base__

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

// MAST includes
#include "base/mast_data_types.h"
#include "base/physics_discipline_base.h"
#include "base/output_assembly_elem_operations.h"


// libMesh includes
#include "libmesh/elem.h"

namespace MAST {


    // Forward declerations
    class FunctionBase;
    

    class StressStrainOutputBase:
    public MAST::OutputAssemblyElemOperations {
        
    public:
    
        
        class Data {
            
        public:
            Data(const RealVectorX& stress,
                 const RealVectorX& strain,
                 const libMesh::Point& qp,
                 const libMesh::Point& xyz,
                 Real JxW);
 
            
            void clear_sensitivity_data();
            
            
            const libMesh::Point&
            point_location_in_element_coordinate() const;
            
            const RealVectorX& stress() const;

            
            const RealVectorX& strain() const;
            
            
            Real quadrature_point_JxW() const;
            
            Real von_Mises_stress() const;

            
            RealVectorX dvon_Mises_stress_dX() const;

            
            Real dvon_Mises_stress_dp(const MAST::FunctionBase& f) const;


            void set_derivatives(const RealMatrixX& dstress_dX,
                                 const RealMatrixX& dstrain_dX);

            
            const RealMatrixX& get_dstress_dX() const;

            
            const RealMatrixX& get_dstrain_dX() const;

            
            void set_sensitivity(const MAST::FunctionBase& f,
                                 const RealVectorX& dstress_df,
                                 const RealVectorX& dstrain_df);

            
            bool
            has_stress_sensitivity(const MAST::FunctionBase& f) const;

            const RealVectorX&
            get_stress_sensitivity(const MAST::FunctionBase& f) const;

            
            const RealVectorX&
            get_strain_sensitivity(const MAST::FunctionBase& f) const;

            
        protected:

            RealVectorX                   _stress;
            
            
            RealVectorX                   _strain;
            
            
            std::map<const MAST::FunctionBase*, RealVectorX> _stress_sensitivity;

            
            std::map<const MAST::FunctionBase*, RealVectorX> _strain_sensitivity;

            
            RealMatrixX   _dstress_dX;

            RealMatrixX   _dstrain_dX;

            
            libMesh::Point            _qp;
            
            
            libMesh::Point            _xyz;
            
            
            Real _JxW;
        };
        

        
        StressStrainOutputBase();
        
        virtual ~StressStrainOutputBase();
        
        
        void set_aggregation_coefficients(Real p1, Real p2, Real rho, Real sigma0) {
            
            _p_norm_stress =  p1;
            _p_norm_weight =  p2;
            _rho           =  rho;
            _sigma0        =  sigma0;
        }
        
        Real get_p_stress_val() {
            
            return _p_norm_stress;
        }
        
        
        void set_stress_plot_mode(bool f) {
            
            _if_stress_plot_mode = f;
        }
         
        
        virtual void
        set_elem_data(unsigned int dim,
                      const libMesh::Elem& ref_elem,
                      MAST::GeomElem& elem) const;

        virtual void init(const MAST::GeomElem& elem);

        virtual void zero_for_analysis();
        
        
        virtual void zero_for_sensitivity();

        virtual void evaluate();

        virtual void evaluate_sensitivity(const MAST::FunctionBase& f);

        virtual void evaluate_shape_sensitivity(const MAST::FunctionBase& f) {
            
            libmesh_assert(false); // to be implemented
        }
        
        virtual void
        evaluate_topology_sensitivity(const MAST::FunctionBase& f);


        virtual void
        evaluate_topology_sensitivity(const MAST::FunctionBase& f,
                                      const MAST::FieldFunction<RealVectorX>& vel);
        
        virtual Real output_for_elem() {
            //
            libmesh_error();
        }
        
        virtual Real output_total();

        virtual Real output_sensitivity_for_elem(const MAST::FunctionBase& p);
        
        virtual Real output_sensitivity_total(const MAST::FunctionBase& p);

        
        virtual void output_derivative_for_elem(RealVectorX& dq_dX);

        
        
        bool stress_plot_mode() const {
            return _if_stress_plot_mode;
        }
        
        bool primal_data_initialized() const {
            return _primal_data_initialized;
        }
        
        void clear();
        
        virtual void clear_sensitivity_data();

        
        MAST::BoundaryConditionBase*
        get_thermal_load_for_elem(const MAST::GeomElem& elem);

        
        unsigned int
        n_stress_strain_data_for_elem(const MAST::GeomElem& e) const;

        
        unsigned int
        n_boundary_stress_strain_data_for_elem(const GeomElem& e) const;

        
        
        virtual MAST::StressStrainOutputBase::Data&
        add_stress_strain_at_qp_location(const MAST::GeomElem& e,
                                         const unsigned int qp,
                                         const libMesh::Point& quadrature_pt,
                                         const libMesh::Point& physical_pt,
                                         const RealVectorX& stress,
                                         const RealVectorX& strain,
                                         Real JxW);

        
        virtual MAST::StressStrainOutputBase::Data&
        add_stress_strain_at_boundary_qp_location(const MAST::GeomElem& e,
                                                  const unsigned int s,
                                                  const unsigned int qp,
                                                  const libMesh::Point& quadrature_pt,
                                                  const libMesh::Point& physical_pt,
                                                  const RealVectorX& stress,
                                                  const RealVectorX& strain,
                                                  Real JxW_Vn);
        
        
        
        virtual const std::map<const libMesh::dof_id_type,
        std::vector<MAST::StressStrainOutputBase::Data*> >&
        get_stress_strain_data() const;

        
        Real get_maximum_von_mises_stress() const;
        
        virtual const std::vector<MAST::StressStrainOutputBase::Data*>&
        get_stress_strain_data_for_elem(const MAST::GeomElem& e) const;

        
        virtual MAST::StressStrainOutputBase::Data&
        get_stress_strain_data_for_elem_at_qp(const MAST::GeomElem& e,
                                              const unsigned int qp);

        
        
        virtual void functional_for_all_elems();
        
        
        virtual void functional_sensitivity_for_all_elems
        (const MAST::FunctionBase& f,
         Real& dsigma_vm_val_df) const;

        
        virtual void functional_boundary_sensitivity_for_all_elems
        (const MAST::FunctionBase& f,
         Real& dsigma_vm_val_df) const;


        virtual void functional_sensitivity_for_elem
        (const MAST::FunctionBase& f,
         const libMesh::dof_id_type e_id,
         Real& dsigma_vm_val_df) const;

        
        virtual void functional_boundary_sensitivity_for_elem
        (const MAST::FunctionBase& f,
         const libMesh::dof_id_type e_id,
         Real& dsigma_vm_val_df) const;

        

        virtual void functional_state_derivartive_for_elem
        (const libMesh::dof_id_type e_id,
         RealVectorX& dq_dX) const;

        
        
    protected:

        Real _p_norm_stress, _p_norm_weight;
        
        Real _rho;
        
        Real _sigma0;

        Real _exp_arg_lim;
        
        bool _primal_data_initialized;
        Real _JxW_val, _sigma_vm_int, _sigma_vm_p_norm;
        
        bool _if_stress_plot_mode;
        
        std::map<const libMesh::dof_id_type, std::vector<MAST::StressStrainOutputBase::Data*>>
        _stress_data;


        std::map<const libMesh::dof_id_type, std::vector<MAST::StressStrainOutputBase::Data*>>
        _boundary_stress_data;
    };
}

#endif // __mast__stress_output_base__