gsALMCrisfield.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsStructuralAnalysis/src/gsALMSolvers/gsALMBase.h>
 
namespace gismo
{
 
template <class T>
class gsALMCrisfield : public gsALMBase<T>
{
 
    typedef gsALMBase<T> Base;
 
    typedef typename Base::ALResidual_t  ALResidual_t;
    typedef typename Base::Jacobian_t    Jacobian_t;
    typedef typename Base::dJacobian_t   dJacobian_t;
 
public:
 
    using Base::setLength;
    using Base::computeStability;
 
protected:
 
    using Base::computeJacobian;
    using Base::computeResidual;
    using Base::computeResidualNorms;
    using Base::computeUt;
    using Base::computeUbar;
    using Base::computeLength;
 
public:
 
    gsALMCrisfield( const Jacobian_t  &Jacobian,
                    const ALResidual_t&ALResidual,
                    const gsVector<T> &Force )
    : Base(Jacobian,ALResidual,Force)
    {
        defaultOptions();
        getOptions();
 
        initMethods();
    }
 
    gsALMCrisfield( const dJacobian_t &dJacobian,
                    const ALResidual_t&ALResidual,
                    const gsVector<T> &Force )
    : Base(dJacobian,ALResidual,Force)
    {
        defaultOptions();
        getOptions();
 
        initMethods();
    }
 
public:
    T distance(const gsVector<T>& DeltaU, const T DeltaL) const
    {
        T A0 = math::pow(m_phi,2)*m_forcing.dot(m_forcing);
        return math::pow(DeltaU.dot(DeltaU) + A0*math::pow(DeltaL,2.0),0.5);
    }
 
protected:
 
    void initMethods();
    void initiateStep();
    void iterationFinish();
 
    void quasiNewtonPredictor();
    void quasiNewtonIteration();
 
    void predictor();
    void predictorGuess();
    void iteration();
 
    void initOutput();
    void stepOutput();
 
    void defaultOptions();
    void getOptions();
 
    void computeLambdas();
    void computeLambdasSimple();
    void computeLambdasModified();
    void computeLambdasComplex();
    void computeLambdasEta();
    void computeLambdaDET();
    void computeLambdaDOT();
    void computeLambdaMU();
 
protected:
 
    // Number of degrees of freedom
    using Base::m_numDof;
 
    using Base::m_jacobian;
    using Base::m_djacobian;
    using Base::m_residualFun;
    using Base::m_forcing;
 
    using Base::m_options;
 
    using Base::m_numIterations;
 
    using Base::m_maxIterations;
 
    using Base::m_arcLength;
 
    using Base::m_verbose;
 
    using Base::m_note;
 
    using Base::m_converged;
 
    using Base::m_residueF;
 
    using Base::m_residueU;
 
    using Base::m_residueL;
 
    using Base::m_indicator;
    using Base::m_negatives;
 
    using Base::m_relax;
 
    // Previous update
    using Base::m_DeltaUold;
    using Base::m_DeltaLold;
    using Base::m_U;
    using Base::m_Uprev;
    using Base::m_Uguess;
    using Base::m_DeltaU;
    using Base::m_deltaUbar;
    using Base::m_deltaUt;
    using Base::m_deltaU;
 
    using Base::m_L;
    using Base::m_Lprev;
    using Base::m_Lguess;
    using Base::m_DeltaL;
    using Base::m_deltaL;
    using Base::m_deltaLs;
 
    using Base::m_jacMat;
    using Base::m_detKT;
 
    // Angle determination method: 0: determine based on previous load step. 1: determine based on previous iteration
    index_t m_angleDetermine;
 
    T m_phi;
    bool m_phi_user;
 
    // MODIFIED ARC LENGTH METHOD
    T m_eta;
 
    // discriminant
    T m_discriminant;
 
    T m_alpha1;
    T m_alpha2;
    T m_alpha3;
 
    T m_a0;
    T m_b0,m_b1;
    T m_c0,m_c1,m_c2;
 
protected:
    struct angmethod
    {
        enum type
        {
            Step = 0,
            Iteration  = 1,
            Predictor  = 2,
        };
    };
 
};
 
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsALMCrisfield.hpp)
#endif