Nektar::Utilities::NodeOpti3D3D Class Reference

#include <NodeOpti.h>

Inheritance diagram for Nektar::Utilities::NodeOpti3D3D:

Public Member Functions
	NodeOpti3D3D (NodeSharedPtr n, std::vector< ElUtilSharedPtr > e, ResidualSharedPtr r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr > d, optiType o)
	~NodeOpti3D3D ()
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, int dim)
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
std::mutex	mtx
std::map< LibUtilities::ShapeType, std::vector< ElUtilSharedPtr > >	m_data
std::vector< NekDouble >	m_grad
std::vector< NekDouble >	m_tmpStore
std::unordered_map< LibUtilities::ShapeType, DerivArray, EnumHash >	m_derivs
NekDouble	m_minJac
ResidualSharedPtr	m_res
std::map< LibUtilities::ShapeType, DerivUtilSharedPtr >	m_derivUtils
optiType	m_opti

Detailed Description

Definition at line 144 of file NodeOpti.h.

Constructor & Destructor Documentation

NodeOpti3D3D()

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

inline

Definition at line 147 of file NodeOpti.h.

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

~NodeOpti3D3D()

Nektar::Utilities::NodeOpti3D3D::~NodeOpti3D3D ( )

inline

Definition at line 155 of file NodeOpti.h.

References Nektar::Utilities::NodeOpti::Optimise().

{};

Member Function Documentation

create()

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

inlinestatic

Definition at line 160 of file NodeOpti.h.

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

Optimise()

void Nektar::Utilities::NodeOpti3D3D::Optimise ( )

virtual

Implements Nektar::Utilities::NodeOpti.

Definition at line 163 of file NodeOpti.cpp.

References Nektar::Utilities::mtx.

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

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

        vector<NekDouble> sk(3);
        NekDouble val;

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

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

        // calculate sk
        NekDouble det =
            m_grad[3] * (m_grad[6] * m_grad[8] - m_grad[7] * m_grad[7]) -
            m_grad[4] * (m_grad[4] * m_grad[8] - m_grad[5] * m_grad[7]) +
            m_grad[5] * (m_grad[4] * m_grad[7] - m_grad[5] * m_grad[6]);

        sk[0] = m_grad[0] * (m_grad[6] * m_grad[8] - m_grad[7] * m_grad[7]) +
                m_grad[1] * (m_grad[5] * m_grad[7] - m_grad[4] * m_grad[8]) +
                m_grad[2] * (m_grad[4] * m_grad[7] - m_grad[3] * m_grad[7]);
        sk[1] = m_grad[0] * (m_grad[7] * m_grad[5] - m_grad[4] * m_grad[5]) +
                m_grad[1] * (m_grad[3] * m_grad[8] - m_grad[5] * m_grad[5]) +
                m_grad[2] * (m_grad[4] * m_grad[5] - m_grad[3] * m_grad[7]);
        sk[2] = m_grad[0] * (m_grad[4] * m_grad[7] - m_grad[6] * m_grad[5]) +
                m_grad[1] * (m_grad[4] * m_grad[5] - m_grad[3] * m_grad[7]) +
                m_grad[2] * (m_grad[3] * m_grad[6] - m_grad[4] * m_grad[4]);

        sk[0] /= det * -1.0;
        sk[1] /= det * -1.0;
        sk[2] /= det * -1.0;

        bool found = false;

        NekDouble pg =
            (m_grad[0] * sk[0] + m_grad[1] * sk[1] + m_grad[2] * sk[2]);

        // 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];
            m_node->m_z = zc + alpha * sk[2];

            newVal = GetFunctional<3>(minJacNew, false);
            // dont need the hessian again this function updates G to be the new
            // location
            //
            // Wolfe conditions
            if (newVal <= currentW + c1() * alpha * pg)
            {
                found = true;
                break;
            }

            alpha /= 2.0;
        }

        if (!found)
        {
            m_node->m_x = xc;
            m_node->m_y = yc;
            m_node->m_z = zc;

            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_node->m_z - zc) * (m_node->m_z - zc)),
                         m_res->val);
        mtx.unlock();
    }
    mtx.lock();
    m_res->func += newVal;
    mtx.unlock();
}

Member Data Documentation

m_type

int Nektar::Utilities::NodeOpti3D3D::m_type

static

Initial value:

= GetNodeOptiFactory().RegisterCreatorFunction(
    33, NodeOpti3D3D::create, "3D3D")

Definition at line 159 of file NodeOpti.h.