gsStaticOpt.h

#include <gsStructuralAnalysis/src/gsStaticSolvers/gsStaticBase.h>

namespace gismo
{

template <class T>
class gsStaticOpt : public gsStaticBase<T>
{
protected:

    typedef gsStaticBase<T> Base;

    typedef typename Base::Residual_t    Residual_t;
    typedef typename Base::ALResidual_t  ALResidual_t;

public:

    gsStaticOpt( const Residual_t &Residual )
    :
    m_residualFun(Residual),
    m_ALresidualFun(nullptr),
    m_jacobian(nullptr)
    {
        this->_init();
    }

    gsStaticOpt( const Residual_t &Residual,
                 const Jacobian_t &Jacobian )
    :
    m_residualFun(Residual),
    m_ALresidualFun(nullptr),
    m_jacobian(Jacobian)
    {
        this->_init();
    }


    gsStaticOpt( const ALResidual_t  & ALResidual )
    :
    m_ALresidualFun(ALResidual),
    m_jacobian(nullptr)
    {
        m_L = 1.0;
        m_residualFun = [this](gsVector<T> const & x, gsVector<T> & result) -> bool
        {
            return m_ALresidualFun(x,m_L,result);
        };
        this->_init();
    }

    gsStaticOpt( const ALResidual_t  & ALResidual,
                 const Jacobian_t &Jacobian )
    :
    m_ALresidualFun(ALResidual),
    m_jacobian(Jacobian)
    {
        m_L = 1.0;
        m_residualFun = [this](gsVector<T> const & x, gsVector<T> & result) -> bool
        {
            return m_ALresidualFun(x,m_L,result);
        };
        this->_init();
    }

public:
    gsStatus solve() override;

    void initialize() override;

    void initOutput() override;
    
    void stepOutput(index_t k) override;

    void defaultOptions() override;

    void reset() override;

    void getOptions() override;

protected:
    void _solve();
    void _init();

    gsVector<T> _computeResidual(const gsVector<T> & U);

public:

    T residualNorm() const { return m_R.norm(); }

protected:
    Residual_t m_residualFun;
    const ALResidual_t m_ALresidualFun;
    const Jacobian_t m_jacobian;

    // Solution
    using Base::m_U;
    using Base::m_DeltaU;
    using Base::m_deltaU;

    using Base::m_L;
    using Base::m_DeltaL;
    using Base::m_deltaL;

    // Iterations
    using Base::m_numIterations;
    using Base::m_maxIterations;

    // Residuals
    using Base::m_R;

    // Tolerances
    using Base::m_tolF;
    using Base::m_tolU;

    // Residual norms
    using Base::m_residual;
    using Base::m_residualIni;
    using Base::m_residualOld;

    // Options
    using Base::m_options;
    using Base::m_verbose;

    // DoFs
    using Base::m_dofs;

    // Headstart
    using Base::m_headstart;

    // Solver status
    using Base::m_status;
};

template <typename T>
class gsOptProblemStatic : public gsOptProblem<T>
{
public:

    gsOptProblemStatic();

public:

    T evalObj( const gsAsConstVector<T> & u ) const;

    void gradObj_into( const gsAsConstVector<T> & u, gsAsVector<T> & result) const;

    void evalCon_into( const gsAsConstVector<T> & u, gsAsVector<T> & result) const;

    void jacobCon_into( const gsAsConstVector<T> & u, gsAsVector<T> & result) const;

private:

    // Lastly, we forward the memebers of the base clase gsOptProblem
    using gsOptProblem<T>::m_numDesignVars;
    using gsOptProblem<T>::m_numConstraints;
    using gsOptProblem<T>::m_numConJacNonZero;

    using gsOptProblem<T>::m_desLowerBounds;
    using gsOptProblem<T>::m_desUpperBounds;

    using gsOptProblem<T>::m_conLowerBounds;
    using gsOptProblem<T>::m_conUpperBounds;

    using gsOptProblem<T>::m_conJacRows;
    using gsOptProblem<T>::m_conJacCols;

    using gsOptProblem<T>::m_curDesign;
};

} //namespace


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