Nektar::NekMeshUtils::Generator2D Class Reference

class containing all surface meshing routines methods and classes More...

#include <2DGenerator.h>

Inheritance diagram for Nektar::NekMeshUtils::Generator2D:

Collaboration diagram for Nektar::NekMeshUtils::Generator2D:

Public Member Functions
	Generator2D (MeshSharedPtr m)
virtual	~Generator2D ()
virtual void	Process ()
Public Member Functions inherited from Nektar::NekMeshUtils::ProcessModule
NEKMESHUTILS_EXPORT	ProcessModule (MeshSharedPtr p_m)
Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT	Module (MeshSharedPtr p_m)
NEKMESHUTILS_EXPORT void	RegisterConfig (std::string key, std::string value)
	Register a configuration option with a module. More...
NEKMESHUTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...
NEKMESHUTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...
NEKMESHUTILS_EXPORT MeshSharedPtr	GetMesh ()
virtual NEKMESHUTILS_EXPORT void	ProcessVertices ()
	Extract element vertices. More...
virtual NEKMESHUTILS_EXPORT void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...
virtual NEKMESHUTILS_EXPORT void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...
virtual NEKMESHUTILS_EXPORT void	ProcessElements ()
	Generate element IDs. More...
virtual NEKMESHUTILS_EXPORT void	ProcessComposites ()
	Generate composites. More...
virtual NEKMESHUTILS_EXPORT void	ClearElementLinks ()

Static Public Member Functions
static boost::shared_ptr< Module >	create (MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	className

Private Member Functions
void	MakeBLPrep ()
void	MakeBL (int faceid)
void	Report ()

Private Attributes
std::map< int, FaceMeshSharedPtr >	m_facemeshes
	map of individual surface meshes from parametric surfaces More...
std::map< int, CurveMeshSharedPtr >	m_curvemeshes
	map of individual curve meshes of the curves in the domain More...
std::vector< unsigned int >	m_blCurves
LibUtilities::AnalyticExpressionEvaluator	m_thickness
int	m_thickness_ID
std::map< NodeSharedPtr, std::vector< EdgeSharedPtr > >	m_nodesToEdge

Additional Inherited Members
Protected Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
NEKMESHUTILS_EXPORT void	PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)
Protected Attributes inherited from Nektar::NekMeshUtils::Module
MeshSharedPtr	m_mesh
	Mesh object. More...
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

Detailed Description

class containing all surface meshing routines methods and classes

Definition at line 53 of file 2DGenerator.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::Generator2D::Generator2D

(

MeshSharedPtr

m

)

Definition at line 52 of file 2DGenerator.cpp.

References Nektar::NekMeshUtils::Module::m_config.

                                        : ProcessModule(m)
{
    m_config["blcurves"] =
        ConfigOption(false, "", "Generate parallelograms on these curves");
    m_config["blthick"] =
        ConfigOption(false, "0.0", "Parallelogram layer thickness");
}

Nektar::NekMeshUtils::Generator2D::~Generator2D ( )

virtual

Definition at line 60 of file 2DGenerator.cpp.

{
}

Member Function Documentation

static boost::shared_ptr<Module> Nektar::NekMeshUtils::Generator2D::create ( MeshSharedPtr  m )

inlinestatic

Creates an instance of this class.

Definition at line 57 of file 2DGenerator.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

    {
        return MemoryManager<Generator2D>::AllocateSharedPtr(m);
    }

void Nektar::NekMeshUtils::Generator2D::MakeBL ( int  faceid )

private

Definition at line 197 of file 2DGenerator.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::NekMeshUtils::CADOrientation::eBackwards, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::AnalyticExpressionEvaluator::Evaluate(), Nektar::NekMeshUtils::GetElementFactory(), Nektar::iterator, m_blCurves, m_curvemeshes, Nektar::NekMeshUtils::Module::m_mesh, m_nodesToEdge, m_thickness, m_thickness_ID, and class_topology::Node.

Referenced by Process().

{
    map<int, Array<OneD, NekDouble> > edgeNormals;

    int eid = 0;

    for (vector<unsigned>::iterator it = m_blCurves.begin();
         it != m_blCurves.end(); ++it)
    {
        CADOrientation::Orientation edgeo =
            m_mesh->m_cad->GetCurve(*it)->GetOrienationWRT(faceid);

        vector<EdgeSharedPtr> es = m_curvemeshes[*it]->GetMeshEdges();

        // on each !!!EDGE!!! calculate a normal
        // always to the left unless edgeo is 1
        // normal must be done in the parametric space (and then projected back)
        // because of face orientation
        for (int j = 0; j < es.size(); j++)
        {
            es[j]->m_id = eid++;
            Array<OneD, NekDouble> p1, p2;
            p1 = es[j]->m_n1->GetCADSurfInfo(faceid);
            p2 = es[j]->m_n2->GetCADSurfInfo(faceid);
            if (edgeo == CADOrientation::eBackwards)
            {
                swap(p1, p2);
            }
            Array<OneD, NekDouble> n(2);
            n[0]          = p1[1] - p2[1];
            n[1]          = p2[0] - p1[0];
            NekDouble mag = sqrt(n[0] * n[0] + n[1] * n[1]);
            n[0] /= mag;
            n[1] /= mag;

            Array<OneD, NekDouble> np = es[j]->m_n1->GetCADSurfInfo(faceid);
            np[0] += n[0];
            np[1] += n[1];

            Array<OneD, NekDouble> loc  = es[j]->m_n1->GetLoc();
            Array<OneD, NekDouble> locp = m_mesh->m_cad->GetSurf(faceid)->P(np);

            n[0] = locp[0] - loc[0];
            n[1] = locp[1] - loc[1];
            mag  = sqrt(n[0] * n[0] + n[1] * n[1]);
            n[0] /= mag;
            n[1] /= mag;

            edgeNormals[es[j]->m_id] = n;
        }
    }

    map<NodeSharedPtr, NodeSharedPtr> nodeNormals;
    map<NodeSharedPtr, vector<EdgeSharedPtr> >::iterator it;
    for (it = m_nodesToEdge.begin(); it != m_nodesToEdge.end(); it++)
    {
        Array<OneD, NekDouble> n(3);
        ASSERTL0(it->second.size() == 2,
                 "wierdness, most likely bl_surfs are incorrect");
        Array<OneD, NekDouble> n1 = edgeNormals[it->second[0]->m_id];
        Array<OneD, NekDouble> n2 = edgeNormals[it->second[1]->m_id];

        n[0]          = (n1[0] + n2[0]) / 2.0;
        n[1]          = (n1[1] + n2[1]) / 2.0;
        NekDouble mag = sqrt(n[0] * n[0] + n[1] * n[1]);
        n[0] /= mag;
        n[1] /= mag;

        NekDouble t = m_thickness.Evaluate(m_thickness_ID, it->first->m_x,
                                           it->first->m_y, 0.0, 0.0);

        n[0] = n[0] * t + it->first->m_x;
        n[1] = n[1] * t + it->first->m_y;
        n[2] = 0.0;

        NodeSharedPtr nn = boost::shared_ptr<Node>(
            new Node(m_mesh->m_numNodes++, n[0], n[1], 0.0));
        CADSurfSharedPtr s = m_mesh->m_cad->GetSurf(faceid);
        Array<OneD, NekDouble> uv = s->locuv(n);
        nn->SetCADSurf(faceid, s, uv);
        nodeNormals[it->first] = nn;
    }

    for (vector<unsigned>::iterator it = m_blCurves.begin();
         it != m_blCurves.end(); ++it)
    {
        CADOrientation::Orientation edgeo =
            m_mesh->m_cad->GetCurve(*it)->GetOrienationWRT(faceid);

        vector<NodeSharedPtr> ns = m_curvemeshes[*it]->GetMeshPoints();
        vector<NodeSharedPtr> newNs;
        for (int i = 0; i < ns.size(); i++)
        {
            newNs.push_back(nodeNormals[ns[i]]);
        }
        m_curvemeshes[*it] =
            MemoryManager<CurveMesh>::AllocateSharedPtr(*it, m_mesh, newNs);

        if (edgeo == CADOrientation::eBackwards)
        {
            reverse(ns.begin(), ns.end());
        }
        for (int i = 0; i < ns.size() - 1; ++i)
        {
            vector<NodeSharedPtr> qns;

            qns.push_back(ns[i]);
            qns.push_back(ns[i + 1]);
            qns.push_back(nodeNormals[ns[i + 1]]);
            qns.push_back(nodeNormals[ns[i]]);

            ElmtConfig conf(LibUtilities::eQuadrilateral, 1, false, false);

            vector<int> tags;
            tags.push_back(101);

            ElementSharedPtr E = GetElementFactory().CreateInstance(
                LibUtilities::eQuadrilateral, conf, qns, tags);

            E->m_parentCAD = m_mesh->m_cad->GetSurf(faceid);

            for (int j = 0; j < E->GetEdgeCount(); ++j)
            {
                pair<EdgeSet::iterator, bool> testIns;
                EdgeSharedPtr ed = E->GetEdge(j);
                // look for edge in m_mesh edgeset from curves
                EdgeSet::iterator s = m_mesh->m_edgeSet.find(ed);
                if (!(s == m_mesh->m_edgeSet.end()))
                {
                    ed = *s;
                    E->SetEdge(j, *s);
                }
            }
            m_mesh->m_element[2].push_back(E);
        }
    }
}

void Nektar::NekMeshUtils::Generator2D::MakeBLPrep ( )

private

Definition at line 176 of file 2DGenerator.cpp.

References Nektar::iterator, m_blCurves, m_curvemeshes, Nektar::NekMeshUtils::Module::m_mesh, and m_nodesToEdge.

Referenced by Process().

{
    if (m_mesh->m_verbose)
    {
        cout << endl << "\tBoundary layer meshing:" << endl << endl;
    }

    // identify the nodes which will become the boundary layer.

    for (vector<unsigned>::iterator it = m_blCurves.begin();
         it != m_blCurves.end(); ++it)
    {
        vector<EdgeSharedPtr> localedges = m_curvemeshes[*it]->GetMeshEdges();
        for (int i = 0; i < localedges.size(); i++)
        {
            m_nodesToEdge[localedges[i]->m_n1].push_back(localedges[i]);
            m_nodesToEdge[localedges[i]->m_n2].push_back(localedges[i]);
        }
    }
}

void Nektar::NekMeshUtils::Generator2D::Process ( )

virtual

Implements Nektar::NekMeshUtils::Module.

Definition at line 64 of file 2DGenerator.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::AnalyticExpressionEvaluator::DefineFunction(), Nektar::LibUtilities::eSegment, Nektar::StdRegions::find(), Nektar::ParseUtils::GenerateSeqVector(), Nektar::NekMeshUtils::GetElementFactory(), Nektar::iterator, m_blCurves, Nektar::NekMeshUtils::Module::m_config, m_curvemeshes, m_facemeshes, Nektar::NekMeshUtils::Module::m_mesh, m_thickness, m_thickness_ID, MakeBL(), MakeBLPrep(), Nektar::LibUtilities::PrintProgressbar(), Nektar::NekMeshUtils::Module::ProcessComposites(), Nektar::NekMeshUtils::Module::ProcessEdges(), Nektar::NekMeshUtils::Module::ProcessElements(), Nektar::NekMeshUtils::Module::ProcessFaces(), Nektar::NekMeshUtils::Module::ProcessVertices(), and Report().

{
    // Check that cad is 2D
    Array<OneD, NekDouble> bndBox = m_mesh->m_cad->GetBoundingBox();
    ASSERTL0(fabs(bndBox[5] - bndBox[4]) < 1.0e-7, "CAD isn't 2D");
    
    if (m_mesh->m_verbose)
    {
        cout << endl << "2D meshing" << endl;
        cout << endl << "\tCurve meshing:" << endl << endl;
    }

    m_mesh->m_numNodes = m_mesh->m_cad->GetNumVerts();

    m_thickness_ID =
        m_thickness.DefineFunction("x y z", m_config["blthick"].as<string>());

    ParseUtils::GenerateSeqVector(m_config["blcurves"].as<string>().c_str(),
                                  m_blCurves);

    // linear mesh all curves
    for (int i = 1; i <= m_mesh->m_cad->GetNumCurve(); i++)
    {
        if (m_mesh->m_verbose)
        {
            LibUtilities::PrintProgressbar(i, m_mesh->m_cad->GetNumCurve(),
                                           "Curve progress");
        }

        vector<unsigned int>::iterator f =
            find(m_blCurves.begin(), m_blCurves.end(), i);

        if (f == m_blCurves.end())
        {
            m_curvemeshes[i] =
                MemoryManager<CurveMesh>::AllocateSharedPtr(i, m_mesh);
        }
        else
        {
            m_curvemeshes[i] = MemoryManager<CurveMesh>::AllocateSharedPtr(
                i, m_mesh, m_config["blthick"].as<string>());
        }

        m_curvemeshes[i]->Mesh();
    }

    ////////////////////////////////////////

    if (m_config["blcurves"].beenSet)
    {
        // we need to do the boundary layer generation in a face by face basis
        MakeBLPrep();

        for (int i = 1; i <= m_mesh->m_cad->GetNumSurf(); i++)
        {
            MakeBL(i);
        }
    }

    if (m_mesh->m_verbose)
    {
        cout << endl << "\tFace meshing:" << endl << endl;
    }

    // linear mesh all surfaces
    for (int i = 1; i <= m_mesh->m_cad->GetNumSurf(); i++)
    {
        if (m_mesh->m_verbose)
        {
            LibUtilities::PrintProgressbar(i, m_mesh->m_cad->GetNumSurf(),
                                           "Face progress");
        }

        m_facemeshes[i] =
            MemoryManager<FaceMesh>::AllocateSharedPtr(i,m_mesh,
                m_curvemeshes, 99+i);
        m_facemeshes[i]->Mesh();
    }

    ////////////////////////////////////

    EdgeSet::iterator it;
    for (it = m_mesh->m_edgeSet.begin(); it != m_mesh->m_edgeSet.end(); it++)
    {
        vector<NodeSharedPtr> ns;
        ns.push_back((*it)->m_n1);
        ns.push_back((*it)->m_n2);

        // for each iterator create a LibUtilities::eSegement
        // push segment into m_mesh->m_element[1]
        // tag for the elements shoudl be the CAD number of the curves

        ElmtConfig conf(LibUtilities::eSegment, 1, false, false);

        vector<int> tags;
        tags.push_back((*it)->m_parentCAD->GetId());

        ElementSharedPtr E2 = GetElementFactory().CreateInstance(
            LibUtilities::eSegment, conf, ns, tags);

        m_mesh->m_element[1].push_back(E2);
    }

    ProcessVertices();
    ProcessEdges();
    ProcessFaces();
    ProcessElements();
    ProcessComposites();

    Report();
}

void Nektar::NekMeshUtils::Generator2D::Report ( )

private

Definition at line 335 of file 2DGenerator.cpp.

References Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    if (m_mesh->m_verbose)
    {
        int ns = m_mesh->m_vertexSet.size();
        int es = m_mesh->m_edgeSet.size();
        int ts = m_mesh->m_element[2].size();
        int ep = ns - es + ts;
        cout << endl << "\tSurface mesh statistics" << endl;
        cout << "\t\tNodes: " << ns << endl;
        cout << "\t\tEdges: " << es << endl;
        cout << "\t\tTriangles " << ts << endl;
        cout << "\t\tEuler-Poincaré characteristic: " << ep << endl;
    }
}

Member Data Documentation

ModuleKey Nektar::NekMeshUtils::Generator2D::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "2dgenerator"), Generator2D::create,
    "Generates a 2D mesh")

Definition at line 61 of file 2DGenerator.h.

std::vector<unsigned int> Nektar::NekMeshUtils::Generator2D::m_blCurves

private

Definition at line 80 of file 2DGenerator.h.

Referenced by MakeBL(), MakeBLPrep(), and Process().

std::map<int, CurveMeshSharedPtr> Nektar::NekMeshUtils::Generator2D::m_curvemeshes

private

map of individual curve meshes of the curves in the domain

Definition at line 78 of file 2DGenerator.h.

Referenced by MakeBL(), MakeBLPrep(), and Process().

std::map<int, FaceMeshSharedPtr> Nektar::NekMeshUtils::Generator2D::m_facemeshes

private

map of individual surface meshes from parametric surfaces

Definition at line 76 of file 2DGenerator.h.

Referenced by Process().

std::map<NodeSharedPtr, std::vector<EdgeSharedPtr> > Nektar::NekMeshUtils::Generator2D::m_nodesToEdge

private

Definition at line 83 of file 2DGenerator.h.

Referenced by MakeBL(), and MakeBLPrep().

LibUtilities::AnalyticExpressionEvaluator Nektar::NekMeshUtils::Generator2D::m_thickness

private

Definition at line 81 of file 2DGenerator.h.

Referenced by MakeBL(), and Process().

int Nektar::NekMeshUtils::Generator2D::m_thickness_ID

private

Definition at line 82 of file 2DGenerator.h.

Referenced by MakeBL(), and Process().