gsStaticOpt.h

Go to the documentation of this file.

 
#include <gsStructuralAnalysis/src/gsStaticSolvers/gsStaticBase.h>
#include <gsOptimizer/gsGradientDescent.h>
 
#pragma once
namespace gismo
{
 
template <typename T>
class gsOptProblemStatic : public gsOptProblem<T>
{
protected:
 
    typedef gsOptProblem<T> Base;
    typedef typename gsStructuralAnalysisOps<T>::Residual_t   Residual_t;
    typedef typename gsStructuralAnalysisOps<T>::ALResidual_t ALResidual_t;
 
public:
    gsOptProblemStatic(const typename gsStructuralAnalysisOps<T>::Residual_t & residualFun, const T & L, index_t numDesignVars)
    :
    m_residualFun(residualFun),
    m_L(L) // unused, in fact, but needs to be assigned
    {
        m_numDesignVars = numDesignVars;
        m_curDesign.resize(numDesignVars,1);
        m_curDesign.setZero();
    }
 
    gsOptProblemStatic(const typename gsStructuralAnalysisOps<T>::ALResidual_t & ALresidualFun, const T & L, index_t numDesignVars)
    :
    m_ALresidualFun(ALresidualFun),
    m_L(L)
    {
        m_numDesignVars = numDesignVars;
        m_residualFun = [this](gsVector<T> const & x, gsVector<T> & result) -> bool
        {
            return m_ALresidualFun(x,m_L,result);
        };
        m_curDesign.resize(numDesignVars,1);
        m_curDesign.setZero();
    }
 
public:
    T evalObj( const gsAsConstVector<T> & u ) const
    {
        gsVector<T> result;
        m_residualFun(u,result);
        return result.norm();
    }
 
    void gradObj_into( const gsAsConstVector<T> & u, gsAsVector<T> & result) const
    {
        gsVector<T> tmp;
        result.resize(u.rows());
        m_residualFun(u,tmp);
        result = -tmp;
    }
 
private:
 
    Residual_t m_residualFun;
    ALResidual_t m_ALresidualFun;
    const T & m_L;
    // Lastly, we forward the memebers of the base clase gsOptProblem
    using Base::m_numDesignVars;
    using Base::m_numConstraints;
    using Base::m_numConJacNonZero;
 
    using Base::m_desLowerBounds;
    using Base::m_desUpperBounds;
 
    using Base::m_conLowerBounds;
    using Base::m_conUpperBounds;
 
    using Base::m_conJacRows;
    using Base::m_conJacCols;
 
    using Base::m_curDesign;
};
 
template <class T, class Optimizer = gsGradientDescent<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, const index_t numDofs )
    :
    m_optimizer(&m_optProblem),
    m_optProblem(Residual,m_L,numDofs)
    {
        m_dofs = numDofs;
        this->_init();
    }
 
    gsStaticOpt( const ALResidual_t  & ALResidual, const index_t numDofs )
    :
    m_optimizer(&m_optProblem),
    m_optProblem(ALResidual,m_L,numDofs)
    {
        m_L = 1.0;
        m_dofs = numDofs;
        this->_init();
    }
 
public:
    gsOptionList & optimizerOptions() { return m_optimizer.options(); }
 
public:
    gsStatus solve() override;
 
    // /// See \ref gsStaticBase
    // void initialize() override;
 
    // /// See \ref gsStaticBase
    // void initOutput() override;
 
    // /// See \ref gsStaticBase
    // void stepOutput(index_t k) override;
 
    void defaultOptions() override;
 
    // /// See \ref gsStaticBase
    // void reset() override;
 
    void getOptions() override;
 
    T indicator(const gsSparseMatrix<T> &, T)
    {
        GISMO_NO_IMPLEMENTATION;
    }
 
    gsVector<T> stabilityVec(const gsSparseMatrix<T> &, T)
    {
        GISMO_NO_IMPLEMENTATION;
    }
 
protected:
    void _solve();
    void _init();
 
 
protected:
    Optimizer m_optimizer;
    gsOptProblemStatic<T> m_optProblem;
 
    // // 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;
 
    // 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;
};
 
 
 
} //namespace
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsStaticOpt.hpp)
#endif