lin3DShell4.hpp

Go to the documentation of this file.

//==============================================================================
//
//                       Seismo Virtual Laboratory
//             Module for Serial and Parallel Analysis of seismic 
//         wave propagation and soil-structure interaction simulation
//         Copyright (C) 2018-2021, The California Institute of Technology
//                         All Rights Reserved.
//
// Commercial use of this program without express permission of the California
// Institute of Technology, is strictly  prohibited. See  file "COPYRIGHT"  in
// main  directory  for  information on  usage  and  redistribution, and for a
// DISCLAIMER OF ALL WARRANTIES.
//
//==============================================================================
//
// Written by:
//   Danilo S. Kusanovic (dkusanov@caltech.edu)
//   Elnaz E. Seylabi    (elnaze@unr.edu)
//
// Supervised by:
//   Domniki M. Asimaki  (domniki@caltech.edu)
//
// References : 
//  [1] Adnan Ibrahimbegovic, "Quadrilateral finite elements for analysis of 
//      thick and thin plates", Computer Methods in Applied Mechanics and 
//      Engineering 110 (1993) 195-209.
//  [2] Adnan Ibrahimbegovic, Robert Taylor, and Edward Wilson, "A Robust 
//      Quadrilateral Membrane Finite Element with Drilling degrees of freedom", 
//      International Journal for Numerical Methods in Engineering, vol. 30, 
//      445-457 (1990) 
//
// Description:
//------------------------------------------------------------------------------

#ifndef _LIN3DSHELL4_HPP_
#define _LIN3DSHELL4_HPP_

#include <map>
#include <memory>
#include <string>
#include <Eigen/Dense>

#include "Node.hpp"
#include "Load.hpp"
#include "Section.hpp"
#include "Element.hpp"
#include "Damping.hpp"
#include "QuadratureRule.hpp"

class lin3DShell4 : public Element{

    public:
        lin3DShell4(const std::vector<unsigned int> nodes, std::unique_ptr<Section> &section, const std::string quadrature="GAUSS", const unsigned int nGauss=9);

        ~lin3DShell4();

        void CommitState();

        void ReverseState();

        void InitialState();

        void UpdateState();

        void SetDomain(std::map<unsigned int, std::shared_ptr<Node> > &nodes);

        void SetDamping(const std::shared_ptr<Damping> &damping);

        std::vector<unsigned int> GetTotalDegreeOfFreedom() const;

        Eigen::MatrixXd GetStrain() const;

        Eigen::MatrixXd GetStress() const;

        Eigen::MatrixXd GetStrainRate() const;

        Eigen::MatrixXd GetStrainAt(double x3, double x2) const;

        Eigen::MatrixXd GetStressAt(double x3, double x2) const;

        Eigen::VectorXd GetVTKResponse(std::string response) const;

        double ComputeEnergy();

        Eigen::MatrixXd ComputeMassMatrix();

        Eigen::MatrixXd ComputeStiffnessMatrix();

        Eigen::MatrixXd ComputeDampingMatrix();

        Eigen::MatrixXd ComputePMLMatrix();

        Eigen::VectorXd ComputeInternalForces();

        Eigen::VectorXd ComputeInternalDynamicForces();

        Eigen::VectorXd ComputeSurfaceForces(const std::shared_ptr<Load> &surface, unsigned int face);

        Eigen::VectorXd ComputeBodyForces(const std::shared_ptr<Load> &body, unsigned int k=0);

        Eigen::VectorXd ComputeDomainReductionForces(const std::shared_ptr<Load> &drm, unsigned int k);

    private:
        std::shared_ptr<Damping> theDamping;

        std::vector<std::shared_ptr<Node> > theNodes;

        std::vector<std::unique_ptr<Section> > theSection;

        std::unique_ptr<QuadratureRule> QuadraturePoints;

        double ComputeTotalMass();

        Eigen::MatrixXd ComputeLocalAxes() const;

        Eigen::MatrixXd ComputeRotation() const;

        Eigen::MatrixXd ComputeLocalCoordinates() const;

        Eigen::VectorXd ComputeStrain(Eigen::MatrixXd &BM12, Eigen::MatrixXd &xyloc, double ri, double si);

        Eigen::VectorXd ComputeStrainRate(Eigen::MatrixXd &BM12, Eigen::MatrixXd &xyloc, double ri, double si);

        Eigen::MatrixXd ComputeConstantTensionMatrix();

        void AssemblePlateMembraneEffects(Eigen::MatrixXd &A, const Eigen::MatrixXd &Am, const Eigen::MatrixXd &Ap);

        void ConstantTensionMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, Eigen::MatrixXd &BM12, Eigen::MatrixXd &Jij);

        void ComputeLoadShapeFunctionMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, Eigen::MatrixXd &Hij, Eigen::MatrixXd &Jij);

        void ComputePlateShapeFunctionMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, Eigen::MatrixXd &Hij, Eigen::MatrixXd &Jij);

        void ComputeMembraneShapeFunctionMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, Eigen::MatrixXd &Hij, Eigen::MatrixXd &Jij);

        void ComputePlateStrainDisplacementMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, Eigen::MatrixXd &Bij, Eigen::MatrixXd &Jij); 

        void ComputeMembraneStrainDisplacementMatrix(const double ri, const double si, const Eigen::MatrixXd &xyloc, const Eigen::MatrixXd &Bij, Eigen::MatrixXd &BM12, Eigen::MatrixXd &Pij, Eigen::MatrixXd &Jij);

        Eigen::MatrixXd ComputeInitialStiffnessMatrix();
};

#endif