gsDynamicBathe.h

Go to the documentation of this file.

#pragma once
#include <gsCore/gsLinearAlgebra.h>

#include <gsStructuralAnalysis/src/gsDynamicSolvers/gsDynamicBase.h>
#include <gsStructuralAnalysis/src/gsDynamicSolvers/gsDynamicNewmark.h>
#include <gsIO/gsOptionList.h>

namespace gismo
{

template <class T, bool _NL>
class gsDynamicBathe : public gsDynamicNewmark<T,_NL>
{
    typedef gsDynamicNewmark<T,_NL> Base;

protected:

    typedef typename gsStructuralAnalysisOps<T>::Force_t     Force_t;
    typedef typename gsStructuralAnalysisOps<T>::TForce_t    TForce_t;
    typedef typename gsStructuralAnalysisOps<T>::Residual_t  Residual_t;
    typedef typename gsStructuralAnalysisOps<T>::TResidual_t TResidual_t;
    typedef typename gsStructuralAnalysisOps<T>::Mass_t      Mass_t;
    typedef typename gsStructuralAnalysisOps<T>::TMass_t     TMass_t;
    typedef typename gsStructuralAnalysisOps<T>::Damping_t   Damping_t;
    typedef typename gsStructuralAnalysisOps<T>::TDamping_t  TDamping_t;
    typedef typename gsStructuralAnalysisOps<T>::Stiffness_t Stiffness_t;
    typedef typename gsStructuralAnalysisOps<T>::Jacobian_t  Jacobian_t;
    typedef typename gsStructuralAnalysisOps<T>::TJacobian_t TJacobian_t;

public:

    virtual ~gsDynamicBathe() {};

    gsDynamicBathe(
                    const Mass_t        & Mass,
                    const Damping_t     & Damping,
                    const Stiffness_t   & Stiffness,
                    const Force_t       & Force
                )
    :
    Base(Mass,Damping,Stiffness,Force)
    {
        this->defaultOptions();
    }

    gsDynamicBathe(
                    const Mass_t        & Mass,
                    const Damping_t     & Damping,
                    const Stiffness_t   & Stiffness,
                    const TForce_t      & TForce
                )
    :
    Base(Mass,Damping,Stiffness,TForce)
    {
        this->defaultOptions();
    }

    gsDynamicBathe(
                    const Mass_t        & Mass,
                    const Damping_t     & Damping,
                    const Jacobian_t    & Jacobian,
                    const Residual_t    & Residual
                )
    :
    Base(Mass,Damping,Jacobian,Residual)
    {
        this->defaultOptions();
    }

    gsDynamicBathe(
                    const Mass_t        & Mass,
                    const Damping_t     & Damping,
                    const Jacobian_t    & Jacobian,
                    const TResidual_t   & TResidual
                )
    :
    Base(Mass,Damping,Jacobian,TResidual)
    {
        this->defaultOptions();
    }

    gsDynamicBathe(
                    const Mass_t        & Mass,
                    const Damping_t     & Damping,
                    const TJacobian_t   & TJacobian,
                    const TResidual_t   & TResidual
                )
    :
    Base(Mass,Damping,TJacobian,TResidual)
    {
        this->defaultOptions();
    }

    gsDynamicBathe(
                    const TMass_t       & TMass,
                    const TDamping_t    & TDamping,
                    const TJacobian_t   & TJacobian,
                    const TResidual_t   & TResidual
                )
    :
    Base(TMass,TDamping,TJacobian,TResidual)
    {
        this->defaultOptions();
    }

    virtual void defaultOptions() override;

// General functions
protected:

    gsStatus _step(const T t, const T dt, gsVector<T> & U, gsVector<T> & V, gsVector<T> & A) const  override;

    void _initOutput() const;
    void _stageOutput(index_t stage) const;
    void _stepOutput(const index_t it, const T resnorm, const T updatenorm) const;

    gsSparseMatrix<T> m_sysmat;

    using Base::_computeForce;
    using Base::_computeResidual;
    using Base::_computeMass;
    using Base::_computeMassInverse;
    using Base::_computeDamping;
    using Base::_computeJacobian;

protected:

    using Base::m_solver;

    using Base::m_numIterations;

    using Base::m_options;


private:
    template <bool _nonlinear>
    typename std::enable_if<(_nonlinear==false), gsStatus>::type 
    _step_impl(const T t, const T dt, gsVector<T> & U, gsVector<T> & V, gsVector<T> & A) const;

    template <bool _nonlinear>
    typename std::enable_if<(_nonlinear==true), gsStatus>::type 
    _step_impl(const T t, const T dt, gsVector<T> & U, gsVector<T> & V, gsVector<T> & A) const;
};

} // namespace gismo

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsDynamicBathe.hpp)
#endif