Nektar::Utilities::NodeOpti2D2D Class Reference

#include <NodeOpti.h>

Inheritance diagram for Nektar::Utilities::NodeOpti2D2D:

Collaboration diagram for Nektar::Utilities::NodeOpti2D2D:

Public Member Functions
	NodeOpti2D2D (NodeSharedPtr n, std::vector< ElUtilSharedPtr > e, ResidualSharedPtr r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr > d, optiType o)
	~NodeOpti2D2D ()
void	Optimise ()
Public Member Functions inherited from Nektar::Utilities::NodeOpti
	NodeOpti (NodeSharedPtr n, std::vector< ElUtilSharedPtr > e, ResidualSharedPtr r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr > d, optiType o)
virtual	~NodeOpti ()
void	CalcMinJac ()
NodeOptiJob *	GetJob ()
template<int DIM>
NekDouble	GetFunctional (NekDouble &minJacNew, bool gradient=true)
	Evaluate functional for elements connected to a node. More...
template<int DIM>
void	MinEigen (NekDouble &val)
	Calculates minimum eigenvalue of Hessian matrix. More...
template<>
void	MinEigen (NekDouble &val)
template<>
void	MinEigen (NekDouble &val)

Static Public Member Functions
static NodeOptiSharedPtr	create (NodeSharedPtr n, std::vector< ElUtilSharedPtr > e, ResidualSharedPtr r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr > d, optiType o)

Static Public Attributes
static int	m_type

Additional Inherited Members
Protected Member Functions inherited from Nektar::Utilities::NodeOpti
template<int DIM>
int	IsIndefinite ()
	Returns 1 if Hessian matrix is indefinite and 0 otherwise. More...
template<>
int	IsIndefinite ()
template<>
int	IsIndefinite ()
Static Protected Member Functions inherited from Nektar::Utilities::NodeOpti
static NekDouble	c1 ()
static NekDouble	gradTol ()
static NekDouble	alphaTol ()
Protected Attributes inherited from Nektar::Utilities::NodeOpti
NodeSharedPtr	m_node
boost::mutex	mtx
std::map < LibUtilities::ShapeType, std::vector< ElUtilSharedPtr > >	m_data
Array< OneD, NekDouble >	m_grad
NekDouble	m_minJac
ResidualSharedPtr	m_res
std::map < LibUtilities::ShapeType, DerivUtilSharedPtr >	m_derivUtils
optiType	m_opti

Detailed Description

Definition at line 142 of file NodeOpti.h.

Constructor & Destructor Documentation

Nektar::Utilities::NodeOpti2D2D::NodeOpti2D2D ( NodeSharedPtr  n, std::vector< ElUtilSharedPtr >  e, ResidualSharedPtr  r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr >  d, optiType  o  )

inline

Definition at line 145 of file NodeOpti.h.

Referenced by create().

        : NodeOpti(n, e, r, d, o)
    {
    }

Nektar::Utilities::NodeOpti2D2D::~NodeOpti2D2D ( )

inline

Definition at line 153 of file NodeOpti.h.

{};

Member Function Documentation

static NodeOptiSharedPtr Nektar::Utilities::NodeOpti2D2D::create ( NodeSharedPtr  n, std::vector< ElUtilSharedPtr >  e, ResidualSharedPtr  r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr >  d, optiType  o  )

inlinestatic

Definition at line 158 of file NodeOpti.h.

References NodeOpti2D2D().

    {
        return NodeOptiSharedPtr(new NodeOpti2D2D(n, e, r, d, o));
    }

void Nektar::Utilities::NodeOpti2D2D::Optimise ( )

virtual

Implements Nektar::Utilities::NodeOpti.

Definition at line 74 of file NodeOpti.cpp.

References Nektar::Utilities::mtx.

{
    NekDouble minJacNew;
    NekDouble currentW = GetFunctional<2>(minJacNew);
    NekDouble newVal   = currentW;

    // Gradient already zero
    if (m_grad[0] * m_grad[0] + m_grad[1] * m_grad[1] > gradTol())
    {
        // needs to optimise
        NekDouble xc = m_node->m_x;
        NekDouble yc = m_node->m_y;

        Array<OneD, NekDouble> sk(2);
        NekDouble val;

        // Calculate minimum eigenvalue
        MinEigen<2>(val);

        if (val < 1e-6)
        {
            // Add constant identity to Hessian matrix.
            m_grad[2] += 1e-6 - val;
            m_grad[4] += 1e-6 - val;
        }

        sk[0] = -1.0 / (m_grad[2] * m_grad[4] - m_grad[3] * m_grad[3]) *
                (m_grad[4] * m_grad[0] - m_grad[3] * m_grad[1]);
        sk[1] = -1.0 / (m_grad[2] * m_grad[4] - m_grad[3] * m_grad[3]) *
                (m_grad[2] * m_grad[1] - m_grad[3] * m_grad[0]);

        bool found   = false;
        NekDouble pg = (m_grad[0] * sk[0] + m_grad[1] * sk[1]);
        // normal gradient line Search
        NekDouble alpha = 1.0;

        while (alpha > alphaTol())
        {
            // Update node
            m_node->m_x = xc + alpha * sk[0];
            m_node->m_y = yc + alpha * sk[1];

            newVal = GetFunctional<2>(minJacNew, false);

            // Wolfe conditions
            if (newVal <= currentW + c1() * (alpha * pg))
            {
                found = true;
                break;
            }

            alpha /= 2.0;
        }

        if (!found)
        {
            // reset the node
            m_node->m_x = xc;
            m_node->m_y = yc;

            mtx.lock();
            m_res->nReset[2]++;
            mtx.unlock();
        }
        else
        {
            m_minJac = minJacNew;

            mtx.lock();
            if (alpha < 1.0)
            {
                m_res->alphaI++;
            }
            mtx.unlock();
        }

        mtx.lock();
        m_res->val = max(sqrt((m_node->m_x - xc) * (m_node->m_x - xc) +
                              (m_node->m_y - yc) * (m_node->m_y - yc)),
                         m_res->val);
        mtx.unlock();
    }

    mtx.lock();
    m_res->func += newVal;
    mtx.unlock();
}

Member Data Documentation

int Nektar::Utilities::NodeOpti2D2D::m_type

static

Initial value:

= GetNodeOptiFactory().RegisterCreatorFunction(
    22, NodeOpti2D2D::create, "2D2D")

Definition at line 157 of file NodeOpti.h.