Nektar::NekMeshUtils::BLMesh Class Reference

#include <BLMesh.h>

Collaboration diagram for Nektar::NekMeshUtils::BLMesh:

Public Member Functions
	BLMesh (MeshSharedPtr m, std::vector< unsigned int > bls, std::vector< unsigned int > syms, NekDouble b)
	default constructor More...
void	Mesh ()
	Execute boundary layer meshing. More...
std::map< int, FaceSharedPtr >	GetSurfToPri ()
	Get the map of surface element id to pseudo surface prism face. More...

Private Attributes
MeshSharedPtr	m_mesh
	Mesh object containing surface mesh. More...
std::vector< unsigned int >	m_blsurfs
	List of surfaces onto which boundary layers are placed. More...
std::vector< unsigned int >	m_symsurfs
	List of symmetry surfaces. More...
NekDouble	m_bl
	Thickness of the boundary layer. More...
std::map< int, FaceSharedPtr >	m_surftopriface
	Map from surface element ID to opposite face of prism. More...

Friends
class	MemoryManager< BLMesh >

Detailed Description

Definition at line 49 of file BLMesh.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::BLMesh::BLMesh ( MeshSharedPtr  m, std::vector< unsigned int >  bls, std::vector< unsigned int >  syms, NekDouble  b  )

inline

default constructor

Definition at line 57 of file BLMesh.h.

        : m_mesh(m), m_blsurfs(bls), m_symsurfs(syms), m_bl(b){};

Member Function Documentation

std::map<int, FaceSharedPtr> Nektar::NekMeshUtils::BLMesh::GetSurfToPri ( )

inline

Get the map of surface element id to pseudo surface prism face.

Definition at line 71 of file BLMesh.h.

References m_surftopriface.

    {
        return m_surftopriface;
    }

void Nektar::NekMeshUtils::BLMesh::Mesh

(

)

Execute boundary layer meshing.

Definition at line 45 of file BLMesh.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::NekMeshUtils::GetElementFactory(), and Nektar::iterator.

{
    // At this stage the surface mesh is complete and the elements know their
    // neighbours through element links in the edges, this includes quads.

    // here elements are made for the boundary layer they will need to know
    // links (maybe facelinks), so that the tetmeshing module can extract the
    // surface upon which it needs to mesh (top of the bl and the rest of the
    // surface).

    vector<ElementSharedPtr> quad;
    vector<ElementSharedPtr> ptri; // triangles to grow prisms onto

    for (int i = 0; i < m_mesh->m_element[2].size(); i++)
    {
        bool onblsurf = false;
        for (int j = 0; j < m_blsurfs.size(); j++)
        {
            if (m_mesh->m_element[2][i]->CADSurfId == m_blsurfs[j])
            {
                onblsurf = true;
                break;
            }
        }
        if (m_mesh->m_element[2][i]->GetConf().m_e ==
            LibUtilities::eQuadrilateral)
        {
            quad.push_back(m_mesh->m_element[2][i]);
        }
        else if (onblsurf)
        {
            ptri.push_back(m_mesh->m_element[2][i]);
        }
    }

    map<int, NodeSharedPtr> blpair;
    for (int i = 0; i < quad.size(); i++)
    {
        vector<EdgeSharedPtr> e = quad[i]->GetEdgeList();
        for (int j = 0; j < e.size(); j++)
        {
            // if both or none are on curve skip
            if ((e[j]->m_n1->GetNumCadCurve() > 0 &&
                 e[j]->m_n2->GetNumCadCurve() > 0) ||
                (!(e[j]->m_n1->GetNumCadCurve() > 0) &&
                 !(e[j]->m_n2->GetNumCadCurve() > 0)))
            {
                continue;
            }

            if (e[j]->m_n1->GetNumCadCurve() > 0)
            {
                blpair[e[j]->m_n1->m_id] = e[j]->m_n2;
            }
            else if (e[j]->m_n2->GetNumCadCurve() > 0)
            {
                blpair[e[j]->m_n2->m_id] = e[j]->m_n1;
            }
            else
            {
                ASSERTL0(false, "that failed");
            }
        }
    }

    map<int, int> nm;
    nm[0] = 0;
    nm[1] = 3;
    nm[2] = 4;
    nm[3] = 5;
    nm[4] = 1;
    nm[5] = 2;

    for (int i = 0; i < ptri.size(); i++)
    {
        vector<NodeSharedPtr> pn(6); // all prism nodes
        vector<NodeSharedPtr> n = ptri[i]->GetVertexList();

        vector<pair<int, CADSurfSharedPtr> > tmpss = n[0]->GetCADSurfs();
        CADSurfSharedPtr tmps;

        for (int j = 0; j < tmpss.size(); j++)
        {
            if (tmpss[j].first == ptri[i]->CADSurfId)
            {
                tmps = tmpss[j].second;
                break;
            }
        }

        if (tmps->IsReversedNormal())
        {
            nm[0] = 0;
            nm[1] = 3;
            nm[2] = 1;
            nm[3] = 2;
            nm[4] = 4;
            nm[5] = 5;
        }

        for (int j = 0; j < n.size(); j++)
        {
            pn[nm[j * 2]] = n[j];

            map<int, NodeSharedPtr>::iterator it;
            it = blpair.find(n[j]->m_id);
            if (it != blpair.end())
            {
                pn[nm[j * 2 + 1]] = blpair[n[j]->m_id];
            }
            else
            {
                Array<OneD, NekDouble> AN(3);

                vector<pair<int, CADSurfSharedPtr> > surfs =
                    n[j]->GetCADSurfs();

                for (int s = 0; s < surfs.size(); s++)
                {
                    Array<OneD, NekDouble> N = surfs[s].second->N(
                        n[j]->GetCADSurfInfo(surfs[s].first));
                    for (int k = 0; k < 3; k++)
                    {
                        AN[k] += N[k];
                    }
                }

                NekDouble mag =
                    sqrt(AN[0] * AN[0] + AN[1] * AN[1] + AN[2] * AN[2]);

                for (int k = 0; k < 3; k++)
                {
                    AN[k] /= mag;
                }

                Array<OneD, NekDouble> loc = n[j]->GetLoc();
                Array<OneD, NekDouble> np(3);
                for (int k = 0; k < 3; k++)
                    np[k]        = loc[k] + AN[k] * m_bl;
                NodeSharedPtr nn = boost::shared_ptr<Node>(
                    new Node(m_mesh->m_numNodes++, np[0], np[1], np[2]));
                pn[nm[j * 2 + 1]]  = nn;
                blpair[n[j]->m_id] = nn;
            }
        }

        ElmtConfig conf(LibUtilities::ePrism, 1, false, false);
        vector<int> tags;
        tags.push_back(1); // all prisms are comp 1
        ElementSharedPtr E = GetElementFactory().CreateInstance(
            LibUtilities::ePrism, conf, pn, tags);

        m_mesh->m_element[3].push_back(E);

        // need to give the surface element some information about
        // which prism is above it
        // so that tetmesh can infer the pseudo surface
        vector<NodeSharedPtr> faceNodes;
        vector<EdgeSharedPtr> edgeList = ptri[i]->GetEdgeList();
        FaceSharedPtr F = boost::shared_ptr<Face>(new Face(
            n, faceNodes, edgeList, ptri[i]->GetConf().m_faceCurveType));
        vector<FaceSharedPtr> f = E->GetFaceList();
        for (int j = 0; j < f.size(); j++)
        {
            if (f[j]->m_vertexList.size() != 3) // quad
                continue;

            // only two triangle faces so if its not this one, this is the
            // pseudo surfaces
            if (!(F == f[j]))
            {
                m_surftopriface[ptri[i]->GetId()] = f[j];
            }
        }
    }
}

Friends And Related Function Documentation

friend class MemoryManager< BLMesh >

friend

Definition at line 52 of file BLMesh.h.

Member Data Documentation

NekDouble Nektar::NekMeshUtils::BLMesh::m_bl

private

Thickness of the boundary layer.

Definition at line 84 of file BLMesh.h.

std::vector<unsigned int> Nektar::NekMeshUtils::BLMesh::m_blsurfs

private

List of surfaces onto which boundary layers are placed.

Definition at line 80 of file BLMesh.h.

MeshSharedPtr Nektar::NekMeshUtils::BLMesh::m_mesh

private

Mesh object containing surface mesh.

Definition at line 78 of file BLMesh.h.

std::map<int, FaceSharedPtr> Nektar::NekMeshUtils::BLMesh::m_surftopriface

private

Map from surface element ID to opposite face of prism.

Definition at line 86 of file BLMesh.h.

Referenced by GetSurfToPri().

std::vector<unsigned int> Nektar::NekMeshUtils::BLMesh::m_symsurfs

private

List of symmetry surfaces.

Definition at line 82 of file BLMesh.h.