Nektar::Utilities::NodeOpti2D3D Class Reference

#include <NodeOptiCAD.h>

Inheritance diagram for Nektar::Utilities::NodeOpti2D3D:

Collaboration diagram for Nektar::Utilities::NodeOpti2D3D:

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

Private Member Functions
void	ProcessGradient ()

Private Attributes
CADSurfSharedPtr	surf

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

Constructor & Destructor Documentation

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

inline

Definition at line 80 of file NodeOptiCAD.h.

Referenced by create().

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

Nektar::Utilities::NodeOpti2D3D::~NodeOpti2D3D ( )

inline

Definition at line 88 of file NodeOptiCAD.h.

{};

Member Function Documentation

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

inlinestatic

Definition at line 93 of file NodeOptiCAD.h.

References NodeOpti2D3D().

    {
        std::vector<std::pair<int, CADSurfSharedPtr> > ss = n->GetCADSurfs();
        return NodeOptiSharedPtr(new NodeOpti2D3D(n, e, r, d, o, ss[0].second));
    }

void Nektar::Utilities::NodeOpti2D3D::Optimise ( )

virtual

Implements Nektar::Utilities::NodeOpti.

Definition at line 151 of file NodeOptiCAD.cpp.

References ASSERTL0, and CellMLToNektar.cellml_metadata::p.

{
    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
        Array<OneD, NekDouble> uvc = m_node->GetCADSurfInfo(surf->GetId());
        NekDouble xc = m_node->m_x;
        NekDouble yc = m_node->m_y;
        NekDouble zc = m_node->m_z;
        Array<OneD, NekDouble> uvt(2);
        Array<OneD, NekDouble> p;
        Array<OneD, NekDouble> bd = surf->GetBounds();

        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())
        {
            uvt[0] = uvc[0] + alpha * sk[0];
            uvt[1] = uvc[1] + alpha * sk[1];

            if (uvt[0] < bd[0] || uvt[0] > bd[1] || uvt[1] < bd[2] ||
                uvt[1] > bd[3])
            {
                alpha /= 2.0;
                continue;
            }

            p           = surf->P(uvt);
            m_node->m_x = p[0];
            m_node->m_y = p[1];
            m_node->m_z = p[2];

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

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

            alpha /= 2.0;
        }

        if (!found)
        {
            // reset the node
            p           = surf->P(uvc);
            m_node->m_x = p[0];
            m_node->m_y = p[1];
            m_node->m_z = p[2];

            mtx.lock();
            m_res->nReset[1]++;
            mtx.unlock();
        }
        else
        {
            m_minJac = minJacNew;
            m_node->Move(p, surf->GetId(), uvt);
        }

        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();

        Array<OneD, NekDouble> uva = m_node->GetCADSurfInfo(surf->GetId());
        if (uva[0] < bd[0] || uva[0] > bd[1] || uva[1] < bd[2] ||
            uva[1] > bd[3])
        {
            ASSERTL0(false, "something when very wrong and the node finished "
                            "out of its parameter plane");
        }
    }

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

void Nektar::Utilities::NodeOpti2D3D::ProcessGradient ( )

private

Definition at line 283 of file NodeOptiCAD.cpp.

{
    Array<OneD, NekDouble> uvc = m_node->GetCADSurfInfo(surf->GetId());

    Array<OneD, NekDouble> grad = m_grad;
    m_grad = Array<OneD, NekDouble>(5, 0.0);

    Array<OneD, NekDouble> d2 = surf->D2(uvc);
    // r[0]   x
    // r[1]   y
    // r[2]   z
    // r[3]   dx/du a
    // r[4]   dy/du b
    // r[5]   dz/du c
    // r[6]   dx/dv d
    // r[7]   dy/dv e
    // r[8]   dz/dv f
    // r[9]   d2x/du2
    // r[10]  d2y/du2
    // r[11]  d2z/du2
    // r[12]  d2x/dv2
    // r[13]  d2y/dv2
    // r[14]  d2z/dv2
    // r[15]  d2x/dudv
    // r[16]  d2y/dudv
    // r[17]  d2z/dudv
    //
    // grad[0] d/dx
    // grad[1] d/dy
    // grad[2] d/dz
    // grad[3] d2/dx2
    // grad[4] d2/dxdy
    // grad[5] d2/dxdz
    // grad[6] d2/dy2
    // grad[7] d2/dydz
    // grad[8] d2/dz2

    // Gradients
    m_grad[0] = d2[3] * grad[0] + d2[4] * grad[1] + d2[5] * grad[2];
    m_grad[1] = d2[6] * grad[0] + d2[7] * grad[1] + d2[8] * grad[2];

    m_grad[2] = grad[0] * d2[9] + grad[1] * d2[10] + grad[2] * d2[11] +
                grad[3] * d2[3] * d2[3] + grad[6] * d2[4] * d2[4] +
                grad[8] * d2[5] * d2[5] + 2.0 * grad[4] * d2[3] * d2[4] +
                2.0 * grad[5] * d2[3] * d2[5] + 2.0 * grad[7] * d2[4] * d2[5];

    m_grad[4] = grad[0] * d2[12] + grad[1] * d2[13] + grad[2] * d2[14] +
                grad[3] * d2[6] * d2[6] + grad[6] * d2[7] * d2[7] +
                grad[8] * d2[8] * d2[8] + 2.0 * grad[4] * d2[6] * d2[7] +
                2.0 * grad[5] * d2[6] * d2[8] + 2.0 * grad[7] * d2[7] * d2[8];

    m_grad[3] = grad[0] * d2[15] + grad[1] * d2[16] + grad[2] * d2[17] +
                grad[3] * d2[3] * d2[6] + grad[6] * d2[4] * d2[7] +
                grad[8] * d2[5] * d2[8] +
                grad[4] * (d2[3] * d2[7] + d2[4] * d2[6]) +
                grad[5] * (d2[3] * d2[8] + d2[5] * d2[6]) +
                grad[7] * (d2[4] * d2[8] + d2[5] * d2[7]);
}

Member Data Documentation

int Nektar::Utilities::NodeOpti2D3D::m_type

static

Initial value:

= GetNodeOptiFactory().RegisterCreatorFunction(
    23, NodeOpti2D3D::create, "2D3D")

Definition at line 92 of file NodeOptiCAD.h.

CADSurfSharedPtr Nektar::Utilities::NodeOpti2D3D::surf

private

Definition at line 103 of file NodeOptiCAD.h.