CompositeBathe.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] Finite Element Procedures, Bathe, K.J., Chapter 6: pages 779-782. 
//       Prentice-Hall, 1996. 
//   [2] Conserving Energy and Momentum in Nonlinear Dynamics: A Simple Impicit 
//       Time Integration Scheme, Bathe, K.J., Computers and Structures, Vol(85),
//       437-445, 2007.
//   [3] Insight into an implicit time integration scheme for structural dynamics,
//       Klaus-Jurgen Bathe, Gunwoo Noh, Computers and Structures, Vol(98-99),
//       1-6, 2012. 
//
// Description: 
//------------------------------------------------------------------------------

#ifndef _COMPOSITEBATHE_HPP_
#define _COMPOSITEBATHE_HPP_

#include <Eigen/Dense>
#include <Eigen/SparseCore>

#include "Mesh.hpp"
#include "LoadCombo.hpp"
#include "Assembler.hpp"
#include "Algorithm.hpp"
#include "Integrator.hpp"

class CompositeBathe : public Integrator{

    public:
        CompositeBathe(std::shared_ptr<Mesh> &mesh, double TimeStep, double mtol=1E-12, double ktol=1E-12, double ftol=1E-12);

        ~CompositeBathe();

        void Initialize(std::shared_ptr<Mesh> &mesh);

        void SetLoadCombination(std::shared_ptr<LoadCombo> &combo);

        void SetAlgorithm(std::shared_ptr<Algorithm> &algorithm);

        const Eigen::VectorXd& GetDisplacements();    

        const Eigen::VectorXd& GetVelocities();

        const Eigen::VectorXd& GetAccelerations();

        const Eigen::VectorXd& GetPMLHistoryVector();  

        bool ComputeNewStep(std::shared_ptr<Mesh> &mesh, unsigned int k=0);

        Eigen::VectorXd ComputeReactionForce(std::shared_ptr<Mesh> &mesh, unsigned int k=0);

        Eigen::VectorXd ComputeProgressiveForce(std::shared_ptr<Mesh> &mesh, unsigned int k=0);

        void ComputeSupportMotionVector(std::shared_ptr<Mesh> &mesh, Eigen::VectorXd &Feff, double factor=1.00, unsigned int k=0);

        void ComputeEffectiveForce(std::shared_ptr<Mesh> &mesh, Eigen::VectorXd &Feff, double factor=1.00, unsigned int k=0);

        void ComputeEffectiveStiffness(std::shared_ptr<Mesh> &mesh, Eigen::SparseMatrix<double> &Keff);

    protected:
        double dt;

        bool flag;

        Eigen::VectorXd U;

        Eigen::VectorXd V;

        Eigen::VectorXd A;

        Eigen::VectorXd Um;

        Eigen::VectorXd Vm;

        Eigen::VectorXd Ubar;

        Eigen::VectorXd Fbar;

        Eigen::SparseMatrix<double> M; 

        Eigen::SparseMatrix<double> C; 

        Eigen::SparseMatrix<double> K; 

        std::weak_ptr<Algorithm> theAlgorithm;

        std::unique_ptr<Assembler> theAssembler;
};

#endif