Nektar::Utilities::NodeOpti1D3D Class Reference

#include <NodeOptiCAD.h>

Inheritance diagram for Nektar::Utilities::NodeOpti1D3D:

Public Member Functions
	NodeOpti1D3D (NodeSharedPtr n, std::vector< ElUtilSharedPtr > e, ResidualSharedPtr r, std::map< LibUtilities::ShapeType, DerivUtilSharedPtr > d, optiType o, CADCurveSharedPtr c)
	~NodeOpti1D3D ()
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

Private Member Functions
void	ProcessGradient ()

Private Attributes
CADCurveSharedPtr	curve

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 47 of file NodeOptiCAD.h.

Constructor & Destructor Documentation

NodeOpti1D3D()

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

inline

Definition at line 50 of file NodeOptiCAD.h.

Referenced by create().

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

~NodeOpti1D3D()

Nektar::Utilities::NodeOpti1D3D::~NodeOpti1D3D ( )

inline

Definition at line 58 of file NodeOptiCAD.h.

References Optimise().

{};

Member Function Documentation

create()

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

inlinestatic

Definition at line 63 of file NodeOptiCAD.h.

References NodeOpti1D3D(), and ProcessGradient().

    {
        std::vector<CADCurveSharedPtr> cs = n->GetCADCurves();
        return NodeOptiSharedPtr(new NodeOpti1D3D(n, e, r, d, o, cs[0]));
    }

Optimise()

void Nektar::Utilities::NodeOpti1D3D::Optimise ( )

virtual

Implements Nektar::Utilities::NodeOpti.

Definition at line 51 of file NodeOptiCAD.cpp.

References Nektar::Utilities::GetNodeOptiFactory(), and Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::RegisterCreatorFunction().

Referenced by ~NodeOpti1D3D(), and Nektar::Utilities::NodeOpti2D3D::~NodeOpti2D3D().

{
    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())
    {
        // modify the gradient to be on the cad system
        ProcessGradient();

        // needs to optimise
        NekDouble tc = m_node->GetCADCurveInfo(curve->GetId());
        NekDouble xc = m_node->m_x;
        NekDouble yc = m_node->m_y;
        NekDouble zc = m_node->m_z;
        NekDouble nt;

        vector<NekDouble> sk(1);

        if (m_grad[1] < 1e-6)
        {
            m_grad[1] = 1e-6 - m_grad[1];
        }

        sk[0] = m_grad[0] / m_grad[1] * -1.0;

        vector<NekDouble> bd(2);
        curve->GetBounds(bd[0], bd[1]);

        bool found = false;

        NekDouble pg = m_grad[0] * sk[0];

        // normal gradient line Search
        NekDouble alpha = 1.0;

        while (alpha > alphaTol())
        {
            // Update node
            nt = tc + alpha * sk[0];
            if (nt < bd[0] || nt > bd[1])
            {
                alpha /= 2.0;
                continue;
            }

            curve->P(nt, m_node->m_x, m_node->m_y, m_node->m_z);

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

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

            alpha /= 2.0;
        }

        if (!found)
        {
            // reset the node
            nt = tc;
            curve->P(nt, m_node->m_x, m_node->m_y, m_node->m_z);

            mtx.lock();
            m_res->nReset[0]++;
            mtx.unlock();
        }
        else
        {
            m_minJac = minJacNew;
            m_node->Move(m_node->m_x, m_node->m_y, m_node->m_z, curve->GetId(),
                         nt);
        }
        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();
}

ProcessGradient()

void Nektar::Utilities::NodeOpti1D3D::ProcessGradient ( )

private

Definition at line 252 of file NodeOptiCAD.cpp.

Referenced by create(), and Nektar::Utilities::NodeOpti2D3D::create().

{
    NekDouble tc           = m_node->GetCADCurveInfo(curve->GetId());
    vector<NekDouble> grad = m_grad;
    m_grad                 = vector<NekDouble>(2, 0.0);

    // Grab first and second order CAD derivatives
    Array<OneD, NekDouble> d2 = curve->D2(tc);

    // Multiply gradient by derivative of CAD
    m_grad[0] = grad[0] * d2[3] + grad[1] * d2[4] + grad[2] * d2[5];

    // Second order: product rule of above, so multiply gradient by second
    // order CAD derivatives and Hessian by gradient of CAD
    m_grad[1] = grad[0] * d2[6] + grad[1] * d2[7] + grad[2] * d2[8] +
                d2[3] * (grad[3] * d2[3] + grad[4] * d2[4] + grad[5] * d2[5]) +
                d2[4] * (grad[4] * d2[3] + grad[6] * d2[4] + grad[7] * d2[5]) +
                d2[5] * (grad[5] * d2[3] + grad[7] * d2[4] + grad[8] * d2[5]);
}

Member Data Documentation

curve

CADCurveSharedPtr Nektar::Utilities::NodeOpti1D3D::curve

private

Definition at line 73 of file NodeOptiCAD.h.

m_type

int Nektar::Utilities::NodeOpti1D3D::m_type

static

Initial value:

= GetNodeOptiFactory().RegisterCreatorFunction(
    13, NodeOpti1D3D::create, "1D3D")

Definition at line 62 of file NodeOptiCAD.h.