Nektar::MultiRegions::MultiLevelBisectedGraph Class Reference

#include <SubStructuredGraph.h>

Public Member Functions
	MultiLevelBisectedGraph (const Array< OneD, const int > sepTree)
	MultiLevelBisectedGraph (MultiLevelBisectedGraphSharedPtr oldLevel, const int nPartition)
	MultiLevelBisectedGraph (const int nBndDofs)
	~MultiLevelBisectedGraph (void)
int	GetTotDofs () const
void	SetGlobalNumberingOffset ()
void	DumpNBndDofs (void) const
void	CollectLeaves (std::vector< SubGraphSharedPtr > &leaves) const
int	CutLeaves ()
int	CutEmptyLeaves ()
int	GetNdaughterGraphs () const
const SubGraphSharedPtr	GetBndDofsGraph () const

Protected Attributes
SubGraphSharedPtr	m_BndDofs
MultiLevelBisectedGraphSharedPtr	m_leftDaughterGraph
MultiLevelBisectedGraphSharedPtr	m_rightDaughterGraph

Detailed Description

Definition at line 153 of file SubStructuredGraph.h.

Constructor & Destructor Documentation

Nektar::MultiRegions::MultiLevelBisectedGraph::MultiLevelBisectedGraph

(

const Array< OneD, const int >

sepTree

)

Definition at line 88 of file SubStructuredGraph.cpp.

References ErrorUtil::efatal, m_BndDofs, m_leftDaughterGraph, m_rightDaughterGraph, and NEKERROR.

                                                  :
            m_BndDofs           (),
            m_leftDaughterGraph (),
            m_rightDaughterGraph()
        {
            static int offset = -5;
            offset += 5;

            int recurLevel    = sepTree[offset+0];
            int nLeftIntDofs  = sepTree[offset+2];
            int nRightIntDofs = sepTree[offset+3];
            int nBndDofs      = sepTree[offset+4];

            bool daughtersConstructed[2] = {false,false};
            
            if ((offset + 5) < sepTree.num_elements())
            {
                while (sepTree[offset+5] > recurLevel) 
                {         
                    switch (sepTree[offset+6])
                    {
                        case 1:
                        {
                            m_leftDaughterGraph = MemoryManager<
                                MultiLevelBisectedGraph>::AllocateSharedPtr(
                                    sepTree);
                            daughtersConstructed[0] = true;
                            break;
                        }
                        case 2:
                        {
                            m_rightDaughterGraph = MemoryManager<
                                MultiLevelBisectedGraph>::AllocateSharedPtr(
                                    sepTree);
                            daughtersConstructed[1] = true;
                            break;
                        }
                        default:
                        {
                            NEKERROR(ErrorUtil::efatal,"Invalid branch id");
                        }
                    }
                    if ((offset + 5) >= sepTree.num_elements())
                    {
                        break;
                    }
                }
            }

            m_BndDofs = MemoryManager<SubGraph>::AllocateSharedPtr(nBndDofs);
                
            if (!daughtersConstructed[0] && nLeftIntDofs)
            {
                m_leftDaughterGraph = MemoryManager<
                    MultiLevelBisectedGraph>::AllocateSharedPtr(nLeftIntDofs);
            }
            
            if (!daughtersConstructed[1] && nRightIntDofs)
            {
                m_rightDaughterGraph = MemoryManager<
                    MultiLevelBisectedGraph>::AllocateSharedPtr(nRightIntDofs);
            }

            if (recurLevel == 1)
            {
                offset = -5;
            }