Nektar::NekMeshUtils::Octant Class Reference

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

#include <Octant.h>

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 80 of file Octant.h.

Constructor & Destructor Documentation

Octant() [1/2]

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

Defualt constructor.

Definition at line 64 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;
    }
}

Octant() [2/2]

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 175 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

CompileLeaves()

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 109 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);
            }
        }
    }

Distance()

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

inline

Get the distance from this octant to another.

Definition at line 284 of file Octant.h.

References CG_Iterations::loc, and 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]));
    }

DX()

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

inline

Get the octants half dimension.

Definition at line 141 of file Octant.h.

References m_hd.

Referenced by Octant().

    {
        return m_hd;
    }

FX()

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

inline

Get the far dimension in a given direction f.

Definition at line 228 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, m_loc, and RemoveNeigbour().

    {
        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;
    }

GetABoundPoint()

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

inline

Definition at line 154 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;
    }

GetChild()

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

inline

Get a specific child of this octant.

Definition at line 319 of file Octant.h.

References m_children.

    {
        return m_children[q];
    }

GetDelta()

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

inline

Get value of delta.

Definition at line 200 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;
    }

GetId()

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

inline

Get the Id of the octant.

Definition at line 125 of file Octant.h.

References m_id.

Referenced by RemoveNeigbour(), and Subdivide().

    {
        return m_id;
    }

GetLoc()

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

inline

Get the location of the center of the octant.

Definition at line 133 of file Octant.h.

References m_loc.

    {
        return m_loc;
    }

GetLocation()

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

inline

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

Definition at line 311 of file Octant.h.

References m_location.

    {
        return m_location;
    }

GetNeigbours()

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

inline

Get the map of neigbours.

Definition at line 267 of file Octant.h.

References m_neigbours.

    {
        return m_neigbours;
    }

GetNumBoundary()

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

inline

Definition at line 324 of file Octant.h.

References m_numBoundaryPoints.

Referenced by Octant().

    {
        return m_numBoundaryPoints;
    }

GetSPList()

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

inline

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

Definition at line 149 of file Octant.h.

References m_localSPList.

    {
        return m_localSPList;
    }

IsDeltaKnown()

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

inline

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

Definition at line 295 of file Octant.h.

References m_delta.

    {
        return m_delta.first;
    }

IsLeaf()

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

inline

Get whether the octant is a leaf or not.

Definition at line 220 of file Octant.h.

References m_leaf.

Referenced by CompileLeaves().

    {
        return m_leaf;
    }

NeedDivide()

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

inline

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

Definition at line 276 of file Octant.h.

References m_needToDivide.

    {
        return m_needToDivide;
    }

NumCurvePoint()

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

inline

Get the number of points in the octants cp list.

Definition at line 175 of file Octant.h.

References m_localSPList.

    {
        return m_localSPList.size();
    }

NumValidCurvePoint()

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

inline

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

Definition at line 183 of file Octant.h.

References m_numValidPoints.

Referenced by Octant().

    {
        return m_numValidPoints;
    }

RemoveNeigbour()

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

Remove a neigbour from this octants list.

Definition at line 496 of file Octant.cpp.

References GetId(), and m_neigbours.

Referenced by FX().

{
    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]);
        }
    }
}

SetChildren()

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

inline

Set the children of this octant.

Definition at line 212 of file Octant.h.

References m_children.

Referenced by Subdivide().

    {
        m_children = c;
    }

SetDelta()

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

inline

Set the value for delta for this octant.

Definition at line 191 of file Octant.h.

References m_delta.

Referenced by Octant().

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

SetLocation()

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

inline

set the location of the octant with respect to the CAD

Definition at line 303 of file Octant.h.

References m_location.

    {
        m_location = l;
    }

SetNeigbour()

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

inline

Definition at line 259 of file Octant.h.

References m_neigbours.

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

Subdivide()

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

Subdivide the octant.

Definition at line 214 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] = std::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

MemoryManager< Octant >

friend class MemoryManager< Octant >

friend

Definition at line 83 of file Octant.h.

Member Data Documentation

m_children

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

private

list of child ids

Definition at line 337 of file Octant.h.

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

m_delta

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

private

mesh sizing parameter

Definition at line 348 of file Octant.h.

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

m_hd

NekDouble Nektar::NekMeshUtils::Octant::m_hd

private

half dimension of the octant

Definition at line 341 of file Octant.h.

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

m_id

int Nektar::NekMeshUtils::Octant::m_id

private

id

Definition at line 331 of file Octant.h.

Referenced by GetId().

m_leaf

bool Nektar::NekMeshUtils::Octant::m_leaf

private

leaf identifer

Definition at line 333 of file Octant.h.

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

m_loc

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

private

x,y,z location of the octant

Definition at line 339 of file Octant.h.

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

m_localSPList

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

private

curvature sampling point list

Definition at line 343 of file Octant.h.

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

m_location

OctantLocation Nektar::NekMeshUtils::Octant::m_location

private

idenify if delta has ben set

Definition at line 352 of file Octant.h.

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

m_needToDivide

bool Nektar::NekMeshUtils::Octant::m_needToDivide

private

idenify if division is needed

Definition at line 350 of file Octant.h.

Referenced by NeedDivide(), and Octant().

m_neigbours

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

private

list of neighbours

Definition at line 354 of file Octant.h.

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

m_numBoundaryPoints

int Nektar::NekMeshUtils::Octant::m_numBoundaryPoints

private

Definition at line 346 of file Octant.h.

Referenced by GetNumBoundary(), and Octant().

m_numValidPoints

int Nektar::NekMeshUtils::Octant::m_numValidPoints

private

number of valid cp points

Definition at line 345 of file Octant.h.

Referenced by NumValidCurvePoint(), and Octant().

m_parent

OctantSharedPtr Nektar::NekMeshUtils::Octant::m_parent

private

parent id

Definition at line 335 of file Octant.h.

Referenced by Octant().