Nektar::NekMeshUtils::Octant Class Reference

this class contains the infomration and methods for individal octants in the Octree More...

#include <Octant.h>

Collaboration diagram for Nektar::NekMeshUtils::Octant:

Public Member Functions
	Octant (int i, OctantSharedPtr p, Array< OneD, OctantFace > dir)
	Defualt constructor. More...
	Octant (int i, NekDouble x, NekDouble y, NekDouble z, NekDouble dx, const std::vector< SPBaseSharedPtr > &splist)
	constructor for master octant More...
void	Subdivide (OctantSharedPtr p, int &numoct)
	Subdivide the octant. More...
void	CompileLeaves (std::vector< OctantSharedPtr > &Octants)
	Recursive method which gets a list of the leaf octants Moves down levels if octant is not a leaf. More...
int	GetId ()
	Get the Id of the octant. More...
Array< OneD, NekDouble >	GetLoc ()
	Get the location of the center of the octant. More...
NekDouble	DX ()
	Get the octants half dimension. More...
std::vector< SPBaseSharedPtr >	GetSPList ()
	Get the list of curvature points that are within this octant. More...
SPBaseSharedPtr	GetABoundPoint ()
int	NumCurvePoint ()
	Get the number of points in the octants cp list. More...
int	NumValidCurvePoint ()
	Get the number of valid cp points in the octants list. More...
void	SetDelta (NekDouble d)
	Set the value for delta for this octant. More...
NekDouble	GetDelta ()
	Get value of delta. More...
void	SetChildren (Array< OneD, OctantSharedPtr > c)
	Set the children of this octant. More...
bool	IsLeaf ()
	Get whether the octant is a leaf or not. More...
NekDouble	FX (OctantFace f)
	Get the far dimension in a given direction f. More...
void	RemoveNeigbour (int id, OctantFace f)
	Remove a neigbour from this octants list. More...
void	SetNeigbour (OctantSharedPtr o, OctantFace f)
std::map< OctantFace, std::vector< OctantSharedPtr > >	GetNeigbours ()
	Get the map of neigbours. More...
bool	NeedDivide ()
	Get whether this octants needs to divide based on the curvature sampling. More...
NekDouble	Distance (OctantSharedPtr o)
	Get the distance from this octant to another. More...
bool	IsDeltaKnown ()
	Get whether a value of delta has been set or not. More...
void	SetLocation (OctantLocation l)
	set the location of the octant with respect to the CAD More...
OctantLocation	GetLocation ()
	Get the location of the octant with respect to the geometry. More...
OctantSharedPtr	GetChild (int q)
	Get a specific child of this octant. More...
int	GetNumBoundary ()

Private Attributes
int	m_id
	id More...
bool	m_leaf
	leaf identifer More...
OctantSharedPtr	m_parent
	parent id More...
Array< OneD, OctantSharedPtr >	m_children
	list of child ids More...
Array< OneD, NekDouble >	m_loc
	x,y,z location of the octant More...
NekDouble	m_hd
	half dimension of the octant More...
std::vector< SPBaseSharedPtr >	m_localSPList
	curvature sampling point list More...
int	m_numValidPoints
	number of valid cp points More...
int	m_numBoundaryPoints
std::pair< bool, NekDouble >	m_delta
	mesh sizing parameter More...
bool	m_needToDivide
	idenify if division is needed More...
OctantLocation	m_location
	idenify if delta has ben set More...
std::map< OctantFace, std::vector< OctantSharedPtr > >	m_neigbours
	list of neighbours More...

Friends
class	MemoryManager< Octant >

Detailed Description

this class contains the infomration and methods for individal octants in the Octree

Definition at line 81 of file Octant.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::Octant::Octant	(	int	i,
		OctantSharedPtr	p,
		Array< OneD, OctantFace >	dir
	)

Defualt constructor.

Definition at line 65 of file Octant.cpp.

References DX(), Nektar::NekMeshUtils::eBack, Nektar::NekMeshUtils::eDown, Nektar::NekMeshUtils::eForward, Nektar::NekMeshUtils::eLeft, Nektar::NekMeshUtils::eOnBoundary, Nektar::NekMeshUtils::eRight, Nektar::NekMeshUtils::eUnknown, Nektar::NekMeshUtils::eUp, GetDelta(), GetNumBoundary(), m_delta, m_hd, m_leaf, m_loc, m_localSPList, m_location, m_needToDivide, m_neigbours, m_numBoundaryPoints, m_numValidPoints, m_parent, NumValidCurvePoint(), and SetDelta().

Referenced by Subdivide().

    : m_id(i), m_parent(p)
{
    // initialise variables to defualt states
    m_leaf              = true;
    m_needToDivide      = false;
    m_numValidPoints    = 0;
    m_numBoundaryPoints = 0;
    m_delta             = pair<bool, NekDouble>(false, 0.0);
    NekDouble maxDif    = 0;
    NekDouble minDif    = numeric_limits<double>::max();
    m_location          = eUnknown;

    // build empty neigbour map
    m_neigbours[eUp]      = vector<OctantSharedPtr>();
    m_neigbours[eDown]    = vector<OctantSharedPtr>();
    m_neigbours[eForward] = vector<OctantSharedPtr>();
    m_neigbours[eBack]    = vector<OctantSharedPtr>();
    m_neigbours[eLeft]    = vector<OctantSharedPtr>();
    m_neigbours[eRight]   = vector<OctantSharedPtr>();

    // pull information from parent
    Array<OneD, NekDouble> parentloc = m_parent->GetLoc();
    m_hd                             = m_parent->DX() / 2.0;
    m_loc = Array<OneD, NekDouble>(3);
    if (dir[0] == eForward)
    {
        m_loc[0] = parentloc[0] + m_hd;
    }
    else
    {
        m_loc[0] = parentloc[0] - m_hd;
    }
    if (dir[1] == eUp)
    {
        m_loc[1] = parentloc[1] + m_hd;
    }
    else
    {
        m_loc[1] = parentloc[1] - m_hd;
    }
    if (dir[2] == eLeft)
    {
        m_loc[2] = parentloc[2] + m_hd;
    }
    else
    {
        m_loc[2] = parentloc[2] - m_hd;
    }

    vector<SPBaseSharedPtr> SourcePointList = m_parent->GetSPList();

    // setup complete

    // look over the curvature point list provided by the parent,
    // firstly look to see if it is in the new octant and if so
    // add it to the conserdation of the delta specification
    for (int i = 0; i < SourcePointList.size(); i++)
    {
        Array<OneD, NekDouble> cploc = SourcePointList[i]->GetLoc();
        if (!(cploc[0] > m_loc[0] + m_hd || cploc[0] < m_loc[0] - m_hd ||
              cploc[1] > m_loc[1] + m_hd || cploc[1] < m_loc[1] - m_hd ||
              cploc[2] > m_loc[2] + m_hd || cploc[2] < m_loc[2] - m_hd))
        {
            m_localSPList.push_back(SourcePointList[i]);

            if (SourcePointList[i]->HasDelta())
            {
                if (SourcePointList[i]->GetDelta() > maxDif)
                {
                    maxDif = SourcePointList[i]->GetDelta();
                }

                if (SourcePointList[i]->GetDelta() < minDif)
                {
                    minDif = SourcePointList[i]->GetDelta();
                }
                m_numValidPoints++;
            }
            if (SourcePointList[i]->Isboundary())
            {
                m_numBoundaryPoints++;
            }
        }
    }

    // if it has valid points delta can be calculated
    if (NumValidCurvePoint() > 0)
    {
        // geometrically octant should subdivide
        if (maxDif / minDif > 1.5)
        {
            m_needToDivide = true;
        }

        SetDelta(minDif);

        //encourage subdivision to keep spec smooth
        if (GetDelta() < 5.0 * DX())
        {
            m_needToDivide = true;
        }
    }

    if (GetNumBoundary() > 0)
    {
        m_location = eOnBoundary;
    }
}

Nektar::NekMeshUtils::Octant::Octant	(	int	i,
		NekDouble	x,
		NekDouble	y,
		NekDouble	z,
		NekDouble	dx,
		const std::vector< SPBaseSharedPtr > &	splist
	)

constructor for master octant

Definition at line 176 of file Octant.cpp.

References Nektar::NekMeshUtils::eBack, Nektar::NekMeshUtils::eDown, Nektar::NekMeshUtils::eForward, Nektar::NekMeshUtils::eLeft, Nektar::NekMeshUtils::eOnBoundary, Nektar::NekMeshUtils::eRight, Nektar::NekMeshUtils::eUp, m_delta, m_leaf, m_loc, m_localSPList, m_location, m_needToDivide, m_neigbours, and m_numValidPoints.

    : m_id(i), m_hd(dx)
{
    m_neigbours[eUp]      = vector<OctantSharedPtr>();
    m_neigbours[eDown]    = vector<OctantSharedPtr>();
    m_neigbours[eForward] = vector<OctantSharedPtr>();
    m_neigbours[eBack]    = vector<OctantSharedPtr>();
    m_neigbours[eLeft]    = vector<OctantSharedPtr>();
    m_neigbours[eRight]   = vector<OctantSharedPtr>();

    // initialise variables to defualt states
    m_leaf           = true;
    m_needToDivide   = true;
    m_numValidPoints = 0;
    m_delta          = pair<bool, NekDouble>(false, 0.0);

    m_loc    = Array<OneD, NekDouble>(3);
    m_loc[0] = x;
    m_loc[1] = y;
    m_loc[2] = z;

    m_localSPList = splist;

    for (int i = 0; i < m_localSPList.size(); i++)
    {
        if (m_localSPList[i]->HasDelta())
        {
            m_numValidPoints++;
        }
    }

    m_location = eOnBoundary;
}

Member Function Documentation

void Nektar::NekMeshUtils::Octant::CompileLeaves ( std::vector< OctantSharedPtr > &  Octants )

inline

Recursive method which gets a list of the leaf octants Moves down levels if octant is not a leaf.

Definition at line 110 of file Octant.h.

References IsLeaf(), and m_children.

    {
        for (int i = 0; i < 8; i++)
        {
            if (m_children[i]->IsLeaf())
            {
                Octants.push_back(m_children[i]);
            }
            else
            {
                m_children[i]->CompileLeaves(Octants);
            }
        }
    }

NekDouble Nektar::NekMeshUtils::Octant::Distance ( OctantSharedPtr  o )

inline

Get the distance from this octant to another.

Definition at line 285 of file Octant.h.

References m_loc.

    {
        Array<OneD, NekDouble> loc = o->GetLoc();
        return sqrt((loc[0] - m_loc[0]) * (loc[0] - m_loc[0]) +
                    (loc[1] - m_loc[1]) * (loc[1] - m_loc[1]) +
                    (loc[2] - m_loc[2]) * (loc[2] - m_loc[2]));
    }

NekDouble Nektar::NekMeshUtils::Octant::DX ( )

inline

Get the octants half dimension.

Definition at line 142 of file Octant.h.

References m_hd.

Referenced by Octant().

    {
        return m_hd;
    }

NekDouble Nektar::NekMeshUtils::Octant::FX ( OctantFace  f )

inline

Get the far dimension in a given direction f.

Definition at line 229 of file Octant.h.

References Nektar::NekMeshUtils::eBack, Nektar::NekMeshUtils::eDown, Nektar::NekMeshUtils::eForward, Nektar::NekMeshUtils::eLeft, Nektar::NekMeshUtils::eRight, Nektar::NekMeshUtils::eUp, m_hd, and m_loc.

    {
        switch (f)
        {
            case eUp:
                return m_loc[1] + m_hd;
                break;
            case eDown:
                return m_loc[1] - m_hd;
                break;
            case eForward:
                return m_loc[0] + m_hd;
                break;
            case eBack:
                return m_loc[0] - m_hd;
                break;
            case eLeft:
                return m_loc[2] + m_hd;
                break;
            case eRight:
                return m_loc[2] - m_hd;
                break;
        }
        return 0.0;
    }

SPBaseSharedPtr Nektar::NekMeshUtils::Octant::GetABoundPoint ( )

inline

Definition at line 155 of file Octant.h.

References ASSERTL0, Nektar::NekMeshUtils::eCBoundary, Nektar::NekMeshUtils::ePBoundary, and m_localSPList.

    {
        SPBaseSharedPtr ret;
        bool found = false;
        for(int i = 0; i < m_localSPList.size(); i++)
        {
            if(m_localSPList[i]->GetType() == eCBoundary ||
               m_localSPList[i]->GetType() == ePBoundary)
            {
                ret = m_localSPList[i];
                found = true;
                break;
            }
        }
        ASSERTL0(found,"failed to find point");
        return ret;
    }

OctantSharedPtr Nektar::NekMeshUtils::Octant::GetChild ( int  q )

inline

Get a specific child of this octant.

Definition at line 320 of file Octant.h.

References m_children.

    {
        return m_children[q];
    }

NekDouble Nektar::NekMeshUtils::Octant::GetDelta ( )

inline

Get value of delta.

Definition at line 201 of file Octant.h.

References ASSERTL0, and m_delta.

Referenced by Octant().

    {
        ASSERTL0(m_delta.first,
                 "Tried to acsess delta of octant"
                 "which has not been set");

        return m_delta.second;
    }

int Nektar::NekMeshUtils::Octant::GetId ( )

inline

Get the Id of the octant.

Definition at line 126 of file Octant.h.

References m_id.

Referenced by RemoveNeigbour(), and Subdivide().

    {
        return m_id;
    }

Array<OneD, NekDouble> Nektar::NekMeshUtils::Octant::GetLoc ( )

inline

Get the location of the center of the octant.

Definition at line 134 of file Octant.h.

References m_loc.

    {
        return m_loc;
    }

OctantLocation Nektar::NekMeshUtils::Octant::GetLocation ( )

inline

Get the location of the octant with respect to the geometry.

Definition at line 312 of file Octant.h.

References m_location.

    {
        return m_location;
    }

std::map<OctantFace, std::vector<OctantSharedPtr> > Nektar::NekMeshUtils::Octant::GetNeigbours ( )

inline

Get the map of neigbours.

Definition at line 268 of file Octant.h.

References m_neigbours.

    {
        return m_neigbours;
    }

int Nektar::NekMeshUtils::Octant::GetNumBoundary ( )

inline

Definition at line 325 of file Octant.h.

References m_numBoundaryPoints.

Referenced by Octant().

    {
        return m_numBoundaryPoints;
    }

std::vector<SPBaseSharedPtr> Nektar::NekMeshUtils::Octant::GetSPList ( )

inline

Get the list of curvature points that are within this octant.

Definition at line 150 of file Octant.h.

References m_localSPList.

    {
        return m_localSPList;
    }

bool Nektar::NekMeshUtils::Octant::IsDeltaKnown ( )

inline

Get whether a value of delta has been set or not.

Definition at line 296 of file Octant.h.

References m_delta.

    {
        return m_delta.first;
    }

bool Nektar::NekMeshUtils::Octant::IsLeaf ( )

inline

Get whether the octant is a leaf or not.

Definition at line 221 of file Octant.h.

References m_leaf.

Referenced by CompileLeaves().

    {
        return m_leaf;
    }

bool Nektar::NekMeshUtils::Octant::NeedDivide ( )

inline

Get whether this octants needs to divide based on the curvature sampling.

Definition at line 277 of file Octant.h.

References m_needToDivide.

    {
        return m_needToDivide;
    }

int Nektar::NekMeshUtils::Octant::NumCurvePoint ( )

inline

Get the number of points in the octants cp list.

Definition at line 176 of file Octant.h.

References m_localSPList.

    {
        return m_localSPList.size();
    }

int Nektar::NekMeshUtils::Octant::NumValidCurvePoint ( )

inline

Get the number of valid cp points in the octants list.

Definition at line 184 of file Octant.h.

References m_numValidPoints.

Referenced by Octant().

    {
        return m_numValidPoints;
    }

void Nektar::NekMeshUtils::Octant::RemoveNeigbour	(	int	id,
		OctantFace	f
	)

Remove a neigbour from this octants list.

Definition at line 497 of file Octant.cpp.

References GetId(), and m_neigbours.

{
    vector<OctantSharedPtr> tmp = m_neigbours[f];
    m_neigbours[f].clear();
    for (int i = 0; i < tmp.size(); i++)
    {
        if (tmp[i]->GetId() != id)
        {
            m_neigbours[f].push_back(tmp[i]);
        }
    }
}

void Nektar::NekMeshUtils::Octant::SetChildren ( Array< OneD, OctantSharedPtr >  c )

inline

Set the children of this octant.

Definition at line 213 of file Octant.h.

References m_children.

Referenced by Subdivide().

    {
        m_children = c;
    }

void Nektar::NekMeshUtils::Octant::SetDelta ( NekDouble  d )

inline

Set the value for delta for this octant.

Definition at line 192 of file Octant.h.

References m_delta.

Referenced by Octant().

    {
        m_delta.first  = true;
        m_delta.second = d;
    }

void Nektar::NekMeshUtils::Octant::SetLocation ( OctantLocation  l )

inline

set the location of the octant with respect to the CAD

Definition at line 304 of file Octant.h.

References m_location.

    {
        m_location = l;
    }

void Nektar::NekMeshUtils::Octant::SetNeigbour ( OctantSharedPtr  o, OctantFace  f  )

inline

Definition at line 260 of file Octant.h.

References m_neigbours.

    {
        m_neigbours[f].push_back(o);
    }

void Nektar::NekMeshUtils::Octant::Subdivide	(	OctantSharedPtr	p,
		int &	numoct
	)

Subdivide the octant.

Definition at line 215 of file Octant.cpp.

References ASSERTL0, Nektar::NekMeshUtils::eBack, Nektar::NekMeshUtils::eDown, Nektar::NekMeshUtils::eForward, Nektar::NekMeshUtils::eLeft, Nektar::NekMeshUtils::eRight, Nektar::NekMeshUtils::eUp, GetId(), Nektar::NekMeshUtils::GetReverseFace(), m_leaf, m_neigbours, Octant(), and SetChildren().

{
    ASSERTL0(m_leaf, "octant must be a leaf for subdivision");

    m_leaf = false; // set as not leaf and make children

    // need to loop over all neigbours and remove this octant from their lists
    for (int i = 0; i < 6; i++)
    {
        OctantFace f               = static_cast<OctantFace>(i);
        vector<OctantSharedPtr> os = m_neigbours[f];
        for (int j = 0; j < os.size(); j++)
        {
            os[j]->RemoveNeigbour(GetId(), GetReverseFace(f));
        }
    }

    Array<OneD, OctantSharedPtr> children(8);

    for (int i = 0; i < 8; i++)
    {
        // set up x,y,z ordering of the 8 octants
        Array<OneD, OctantFace> dir(3);
        if (i < 4)
        {
            dir[0] = eForward;
            if (i < 2)
            {
                dir[1] = eUp;
            }
            else
            {
                dir[1] = eDown;
            }
            if (i == 0 || i == 2)
            {
                dir[2] = eLeft;
            }
            else
            {
                dir[2] = eRight;
            }
        }
        else
        {
            dir[0] = eBack;
            if (i < 6)
            {
                dir[1] = eUp;
            }
            else
            {
                dir[1] = eDown;
            }
            if (i == 4 || i == 6)
            {
                dir[2] = eLeft;
            }
            else
            {
                dir[2] = eRight;
            }
        }

        children[i] = boost::shared_ptr<Octant>(new Octant(numoct++, p, dir));
    }

    SetChildren(children);

    // this set of neibours are based on the children of the octant, only covers
    // three sides
    children[0]->SetNeigbour(children[1], eRight);
    children[0]->SetNeigbour(children[4], eBack);
    children[0]->SetNeigbour(children[2], eDown);

    children[1]->SetNeigbour(children[0], eLeft);
    children[1]->SetNeigbour(children[5], eBack);
    children[1]->SetNeigbour(children[3], eDown);

    children[2]->SetNeigbour(children[3], eRight);
    children[2]->SetNeigbour(children[6], eBack);
    children[2]->SetNeigbour(children[0], eUp);

    children[3]->SetNeigbour(children[2], eLeft);
    children[3]->SetNeigbour(children[7], eBack);
    children[3]->SetNeigbour(children[1], eUp);

    children[4]->SetNeigbour(children[5], eRight);
    children[4]->SetNeigbour(children[0], eForward);
    children[4]->SetNeigbour(children[6], eDown);

    children[5]->SetNeigbour(children[4], eLeft);
    children[5]->SetNeigbour(children[1], eForward);
    children[5]->SetNeigbour(children[7], eDown);

    children[6]->SetNeigbour(children[7], eRight);
    children[6]->SetNeigbour(children[2], eForward);
    children[6]->SetNeigbour(children[4], eUp);

    children[7]->SetNeigbour(children[6], eLeft);
    children[7]->SetNeigbour(children[3], eForward);
    children[7]->SetNeigbour(children[5], eUp);

    // need to obtain the remaning information from the parents neigbours
    // (m_neigbours)
    // consider top face
    if (m_neigbours[eUp].size() == 1)
    {
        children[0]->SetNeigbour(m_neigbours[eUp][0], eUp);
        children[1]->SetNeigbour(m_neigbours[eUp][0], eUp);
        children[4]->SetNeigbour(m_neigbours[eUp][0], eUp);
        children[5]->SetNeigbour(m_neigbours[eUp][0], eUp);
        m_neigbours[eUp][0]->SetNeigbour(children[0], eDown);
        m_neigbours[eUp][0]->SetNeigbour(children[1], eDown);
        m_neigbours[eUp][0]->SetNeigbour(children[4], eDown);
        m_neigbours[eUp][0]->SetNeigbour(children[5], eDown);
    }
    else if (m_neigbours[eUp].size() == 4)
    {
        children[0]->SetNeigbour(m_neigbours[eUp][0], eUp); // 2
        children[1]->SetNeigbour(m_neigbours[eUp][1], eUp); // 3
        children[4]->SetNeigbour(m_neigbours[eUp][2], eUp); // 6
        children[5]->SetNeigbour(m_neigbours[eUp][3], eUp); // 7
        m_neigbours[eUp][0]->SetNeigbour(children[0], eDown);
        m_neigbours[eUp][1]->SetNeigbour(children[1], eDown);
        m_neigbours[eUp][2]->SetNeigbour(children[4], eDown);
        m_neigbours[eUp][3]->SetNeigbour(children[5], eDown);
    }
    else if (m_neigbours[eUp].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eUp].size() << endl;
    }

    if (m_neigbours[eDown].size() == 1)
    {
        children[2]->SetNeigbour(m_neigbours[eDown][0], eDown);
        children[3]->SetNeigbour(m_neigbours[eDown][0], eDown);
        children[6]->SetNeigbour(m_neigbours[eDown][0], eDown);
        children[7]->SetNeigbour(m_neigbours[eDown][0], eDown);
        m_neigbours[eDown][0]->SetNeigbour(children[2], eUp);
        m_neigbours[eDown][0]->SetNeigbour(children[3], eUp);
        m_neigbours[eDown][0]->SetNeigbour(children[6], eUp);
        m_neigbours[eDown][0]->SetNeigbour(children[7], eUp);
    }
    else if (m_neigbours[eDown].size() == 4)
    {
        children[2]->SetNeigbour(m_neigbours[eDown][0], eDown); // 0
        children[3]->SetNeigbour(m_neigbours[eDown][1], eDown); // 1
        children[6]->SetNeigbour(m_neigbours[eDown][2], eDown); // 4
        children[7]->SetNeigbour(m_neigbours[eDown][3], eDown); // 5
        m_neigbours[eDown][0]->SetNeigbour(children[2], eUp);
        m_neigbours[eDown][1]->SetNeigbour(children[3], eUp);
        m_neigbours[eDown][2]->SetNeigbour(children[6], eUp);
        m_neigbours[eDown][3]->SetNeigbour(children[7], eUp);
    }
    else if (m_neigbours[eDown].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eDown].size() << endl;
    }

    if (m_neigbours[eForward].size() == 1)
    {
        children[0]->SetNeigbour(m_neigbours[eForward][0], eForward);
        children[1]->SetNeigbour(m_neigbours[eForward][0], eForward);
        children[2]->SetNeigbour(m_neigbours[eForward][0], eForward);
        children[3]->SetNeigbour(m_neigbours[eForward][0], eForward);
        m_neigbours[eForward][0]->SetNeigbour(children[0], eBack);
        m_neigbours[eForward][0]->SetNeigbour(children[1], eBack);
        m_neigbours[eForward][0]->SetNeigbour(children[2], eBack);
        m_neigbours[eForward][0]->SetNeigbour(children[3], eBack);
    }
    else if (m_neigbours[eForward].size() == 4)
    {
        children[0]->SetNeigbour(m_neigbours[eForward][0], eForward); // 4
        children[1]->SetNeigbour(m_neigbours[eForward][1], eForward); // 5
        children[2]->SetNeigbour(m_neigbours[eForward][2], eForward); // 6
        children[3]->SetNeigbour(m_neigbours[eForward][3], eForward); // 7
        m_neigbours[eForward][0]->SetNeigbour(children[0], eBack);
        m_neigbours[eForward][1]->SetNeigbour(children[1], eBack);
        m_neigbours[eForward][2]->SetNeigbour(children[2], eBack);
        m_neigbours[eForward][3]->SetNeigbour(children[3], eBack);
    }
    else if (m_neigbours[eForward].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eForward].size() << endl;
    }

    if (m_neigbours[eBack].size() == 1)
    {
        children[4]->SetNeigbour(m_neigbours[eBack][0], eBack);
        children[5]->SetNeigbour(m_neigbours[eBack][0], eBack);
        children[6]->SetNeigbour(m_neigbours[eBack][0], eBack);
        children[7]->SetNeigbour(m_neigbours[eBack][0], eBack);
        m_neigbours[eBack][0]->SetNeigbour(children[4], eForward);
        m_neigbours[eBack][0]->SetNeigbour(children[5], eForward);
        m_neigbours[eBack][0]->SetNeigbour(children[6], eForward);
        m_neigbours[eBack][0]->SetNeigbour(children[7], eForward);
    }
    else if (m_neigbours[eBack].size() == 4)
    {
        children[4]->SetNeigbour(m_neigbours[eBack][0], eBack); // 0
        children[5]->SetNeigbour(m_neigbours[eBack][1], eBack); // 1
        children[6]->SetNeigbour(m_neigbours[eBack][2], eBack); // 2
        children[7]->SetNeigbour(m_neigbours[eBack][3], eBack); // 3
        m_neigbours[eBack][0]->SetNeigbour(children[4], eForward);
        m_neigbours[eBack][1]->SetNeigbour(children[5], eForward);
        m_neigbours[eBack][2]->SetNeigbour(children[6], eForward);
        m_neigbours[eBack][3]->SetNeigbour(children[7], eForward);
    }
    else if (m_neigbours[eBack].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eBack].size() << endl;
    }

    if (m_neigbours[eLeft].size() == 1)
    {
        children[0]->SetNeigbour(m_neigbours[eLeft][0], eLeft);
        children[2]->SetNeigbour(m_neigbours[eLeft][0], eLeft);
        children[4]->SetNeigbour(m_neigbours[eLeft][0], eLeft);
        children[6]->SetNeigbour(m_neigbours[eLeft][0], eLeft);
        m_neigbours[eLeft][0]->SetNeigbour(children[0], eRight);
        m_neigbours[eLeft][0]->SetNeigbour(children[2], eRight);
        m_neigbours[eLeft][0]->SetNeigbour(children[4], eRight);
        m_neigbours[eLeft][0]->SetNeigbour(children[6], eRight);
    }
    else if (m_neigbours[eLeft].size() == 4)
    {
        children[0]->SetNeigbour(m_neigbours[eLeft][0], eLeft); // 1
        children[2]->SetNeigbour(m_neigbours[eLeft][1], eLeft); // 3
        children[4]->SetNeigbour(m_neigbours[eLeft][2], eLeft); // 5
        children[6]->SetNeigbour(m_neigbours[eLeft][3], eLeft); // 7
        m_neigbours[eLeft][0]->SetNeigbour(children[0], eRight);
        m_neigbours[eLeft][1]->SetNeigbour(children[2], eRight);
        m_neigbours[eLeft][2]->SetNeigbour(children[4], eRight);
        m_neigbours[eLeft][3]->SetNeigbour(children[6], eRight);
    }
    else if (m_neigbours[eLeft].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eLeft].size() << endl;
        cout << m_neigbours[eLeft].size() << endl;
    }

    if (m_neigbours[eRight].size() == 1)
    {
        children[1]->SetNeigbour(m_neigbours[eRight][0], eRight);
        children[3]->SetNeigbour(m_neigbours[eRight][0], eRight);
        children[5]->SetNeigbour(m_neigbours[eRight][0], eRight);
        children[7]->SetNeigbour(m_neigbours[eRight][0], eRight);
        m_neigbours[eRight][0]->SetNeigbour(children[1], eLeft);
        m_neigbours[eRight][0]->SetNeigbour(children[3], eLeft);
        m_neigbours[eRight][0]->SetNeigbour(children[5], eLeft);
        m_neigbours[eRight][0]->SetNeigbour(children[7], eLeft);
    }
    else if (m_neigbours[eRight].size() == 4)
    {
        children[1]->SetNeigbour(m_neigbours[eRight][0], eRight); // 0
        children[3]->SetNeigbour(m_neigbours[eRight][1], eRight); // 2
        children[5]->SetNeigbour(m_neigbours[eRight][2], eRight); // 4
        children[7]->SetNeigbour(m_neigbours[eRight][3], eRight); // 6
        m_neigbours[eRight][0]->SetNeigbour(children[1], eLeft);
        m_neigbours[eRight][1]->SetNeigbour(children[3], eLeft);
        m_neigbours[eRight][2]->SetNeigbour(children[5], eLeft);
        m_neigbours[eRight][3]->SetNeigbour(children[7], eLeft);
    }
    else if (m_neigbours[eRight].size() != 0)
    {
        cout << "!!!!!"
             << "NOT GOOD"
             << "!!!!! " << m_neigbours[eRight].size() << endl;
    }
}

Friends And Related Function Documentation

friend class MemoryManager< Octant >

friend

Definition at line 84 of file Octant.h.

Member Data Documentation

Array<OneD, OctantSharedPtr> Nektar::NekMeshUtils::Octant::m_children

private

list of child ids

Definition at line 338 of file Octant.h.

Referenced by CompileLeaves(), GetChild(), and SetChildren().

std::pair<bool, NekDouble> Nektar::NekMeshUtils::Octant::m_delta

private

mesh sizing parameter

Definition at line 349 of file Octant.h.

Referenced by GetDelta(), IsDeltaKnown(), Octant(), and SetDelta().

NekDouble Nektar::NekMeshUtils::Octant::m_hd

private

half dimension of the octant

Definition at line 342 of file Octant.h.

Referenced by DX(), FX(), and Octant().

int Nektar::NekMeshUtils::Octant::m_id

private

id

Definition at line 332 of file Octant.h.

Referenced by GetId().

bool Nektar::NekMeshUtils::Octant::m_leaf

private

leaf identifer

Definition at line 334 of file Octant.h.

Referenced by IsLeaf(), Octant(), and Subdivide().

Array<OneD, NekDouble> Nektar::NekMeshUtils::Octant::m_loc

private

x,y,z location of the octant

Definition at line 340 of file Octant.h.

Referenced by Distance(), FX(), GetLoc(), and Octant().

std::vector<SPBaseSharedPtr> Nektar::NekMeshUtils::Octant::m_localSPList

private

curvature sampling point list

Definition at line 344 of file Octant.h.

Referenced by GetABoundPoint(), GetSPList(), NumCurvePoint(), and Octant().

OctantLocation Nektar::NekMeshUtils::Octant::m_location

private

idenify if delta has ben set

Definition at line 353 of file Octant.h.

Referenced by GetLocation(), Octant(), and SetLocation().

bool Nektar::NekMeshUtils::Octant::m_needToDivide

private

idenify if division is needed

Definition at line 351 of file Octant.h.

Referenced by NeedDivide(), and Octant().

std::map<OctantFace, std::vector<OctantSharedPtr> > Nektar::NekMeshUtils::Octant::m_neigbours

private

list of neighbours

Definition at line 355 of file Octant.h.

Referenced by GetNeigbours(), Octant(), RemoveNeigbour(), SetNeigbour(), and Subdivide().

int Nektar::NekMeshUtils::Octant::m_numBoundaryPoints

private

Definition at line 347 of file Octant.h.

Referenced by GetNumBoundary(), and Octant().

int Nektar::NekMeshUtils::Octant::m_numValidPoints

private

number of valid cp points

Definition at line 346 of file Octant.h.

Referenced by NumValidCurvePoint(), and Octant().

OctantSharedPtr Nektar::NekMeshUtils::Octant::m_parent

private

parent id

Definition at line 336 of file Octant.h.

Referenced by Octant().