Nektar::Utilities::OutputNekpp Class Reference

Converter for Gmsh files. More...

#include <OutputNekpp.h>

Inheritance diagram for Nektar::Utilities::OutputNekpp:

Public Member Functions
	OutputNekpp (NekMeshUtils::MeshSharedPtr m)
virtual	~OutputNekpp ()
virtual void	Process ()
	Write mesh to output file. More...
Public Member Functions inherited from Nektar::NekMeshUtils::OutputModule
NEKMESHUTILS_EXPORT	OutputModule (MeshSharedPtr p_m)
NEKMESHUTILS_EXPORT void	OpenStream ()
	Open a file for output. More...
Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT	Module (MeshSharedPtr p_m)
NEKMESHUTILS_EXPORT void	RegisterConfig (std::string key, std::string value=std::string())
	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 std::shared_ptr< Module >	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className1
static NekMeshUtils::ModuleKey	className2

Private Member Functions
void	TransferVertices (SpatialDomains::MeshGraphSharedPtr graph)
void	TransferEdges (SpatialDomains::MeshGraphSharedPtr graph, std::unordered_map< int, SpatialDomains::SegGeomSharedPtr > &edgeMap)
void	TransferFaces (SpatialDomains::MeshGraphSharedPtr graph, std::unordered_map< int, SpatialDomains::SegGeomSharedPtr > &edgeMap)
void	TransferElements (SpatialDomains::MeshGraphSharedPtr graph)
void	TransferCurves (SpatialDomains::MeshGraphSharedPtr graph)
void	TransferComposites (SpatialDomains::MeshGraphSharedPtr graph)
void	TransferDomain (SpatialDomains::MeshGraphSharedPtr graph)

Private Attributes
LibUtilities::Interpreter	m_strEval

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::OutputModule
io::filtering_ostream	m_mshFile
	Output stream. More...
std::ofstream	m_mshFileStream
	Input stream. More...
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

Converter for Gmsh files.

Definition at line 46 of file OutputNekpp.h.

Constructor & Destructor Documentation

OutputNekpp()

Nektar::Utilities::OutputNekpp::OutputNekpp

(

NekMeshUtils::MeshSharedPtr

m

)

Definition at line 73 of file OutputNekpp.cpp.

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

                                        : OutputModule(m)
{
    m_config["test"] = ConfigOption(
        true, "0", "Attempt to load resulting mesh and create meshgraph.");
    m_config["stats"] = ConfigOption(
        true, "0", "Print out basic mesh statistics.");
    m_config["uncompress"] = ConfigOption(true, "0", "Uncompress xml sections");
    m_config["order"] = ConfigOption(false, "-1", "Enforce a polynomial order");
    m_config["testcond"] = ConfigOption(
        false, "", "Test a condition.");
}

~OutputNekpp()

Nektar::Utilities::OutputNekpp::~OutputNekpp ( )

virtual

Definition at line 85 of file OutputNekpp.cpp.

{
}

Member Function Documentation

create()

static std::shared_ptr<Module> Nektar::Utilities::OutputNekpp::create ( NekMeshUtils::MeshSharedPtr  m )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file OutputNekpp.h.

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

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

Process()

void Nektar::Utilities::OutputNekpp::Process ( )

virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 143 of file OutputNekpp.cpp.

References Nektar::LibUtilities::SessionReader::CreateInstance(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::ePolyEvenlySpaced, Nektar::SpatialDomains::GetMeshGraphFactory(), Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Module::m_mesh, m_strEval, Nektar::SpatialDomains::MeshGraph::Read(), Nektar::Utilities::TestElmts(), TransferComposites(), TransferCurves(), TransferDomain(), TransferEdges(), TransferElements(), TransferFaces(), and TransferVertices().

{
    if (m_mesh->m_verbose)
    {
        cout << "OutputNekpp: Writing file..." << endl;
    }

    int order = m_config["order"].as<int>();

    if (order != -1)
    {
        m_mesh->MakeOrder(order, LibUtilities::ePolyEvenlySpaced);
    }

    string file = m_config["outfile"].as<string>();
    string ext = boost::filesystem::extension(file);

    if (m_config["stats"].beenSet)
    {
        m_mesh->PrintStats(std::cout);
    }

    // Default to compressed XML output.
    std::string type = "XmlCompressed";

    // Extract the output filename and extension
    string filename = m_config["outfile"].as<string>();

    // Compress output and append .gz extension
    if(boost::iequals(ext, ".xml") && m_config["uncompress"].beenSet)
    {
        type = "Xml";
    }
    else if(boost::iequals(ext, ".nekg"))
    {
        type = "HDF5";
    }

    SpatialDomains::MeshGraphSharedPtr graph =
        SpatialDomains::GetMeshGraphFactory().CreateInstance(type);
    graph->Empty(m_mesh->m_expDim, m_mesh->m_spaceDim);

    TransferVertices(graph);

    std::unordered_map<int, SegGeomSharedPtr> segMap;
    TransferEdges(graph, segMap);
    TransferFaces(graph, segMap);
    TransferElements(graph);
    TransferCurves(graph);
    TransferComposites(graph);
    TransferDomain(graph);

    string out = m_config["outfile"].as<string>();
    graph->WriteGeometry(out, true, m_mesh->m_metadata);

    // Test the resulting XML file (with a basic test) by loading it
    // with the session reader, generating the MeshGraph and testing if
    // each element is valid.
    if (m_config["test"].beenSet)
    {
        // Create an equation based on the test condition. Should evaluate to 1
        // or 0 using boolean logic.
        string testcond = m_config["testcond"].as<string>();
        int exprId = -1;

        if (testcond.length() > 0)
        {
            exprId = m_strEval.DefineFunction("x y z", testcond);
        }

        vector<string> filenames(1);

        if (type == "HDF5")
        {
            vector<string> tmp;
            boost::split(tmp, filename, boost::is_any_of("."));
            filenames[0] = tmp[0] + ".xml";
        }
        else
        {
            filenames[0] = filename;
        }

        char *prgname = const_cast<char *>("NekMesh");
        LibUtilities::SessionReaderSharedPtr vSession =
            LibUtilities::SessionReader::CreateInstance(1, &prgname, filenames,
                                                        m_mesh->m_comm);
        SpatialDomains::MeshGraphSharedPtr graph =
            SpatialDomains::MeshGraph::Read(vSession);

        TestElmts(graph->GetAllSegGeoms(),   graph, m_strEval, exprId);
        TestElmts(graph->GetAllTriGeoms(),   graph, m_strEval, exprId);
        TestElmts(graph->GetAllQuadGeoms(),  graph, m_strEval, exprId);
        TestElmts(graph->GetAllTetGeoms(),   graph, m_strEval, exprId);
        TestElmts(graph->GetAllPrismGeoms(), graph, m_strEval, exprId);
        TestElmts(graph->GetAllPyrGeoms(),   graph, m_strEval, exprId);
        TestElmts(graph->GetAllHexGeoms(),   graph, m_strEval, exprId);
    }
}

TransferComposites()

void Nektar::Utilities::OutputNekpp::TransferComposites ( SpatialDomains::MeshGraphSharedPtr  graph )

private

Definition at line 558 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    SpatialDomains::CompositeMap &comps = graph->GetComposites();
    map<int, string> &compLabels = graph->GetCompositesLabels();

    int j = 0;

    for(auto &it : m_mesh->m_composite)
    {
        if(it.second->m_items.size() > 0)
        {
            int indx = it.second->m_id;
            SpatialDomains::CompositeSharedPtr curVector =
                            MemoryManager<SpatialDomains::Composite>::AllocateSharedPtr();

            if(it.second->m_label.size())
            {
                compLabels[indx] = it.second->m_label;
            }

            switch (it.second->m_tag[0])
            {
                case 'V':
                {
                    PointGeomMap &pointMap = graph->GetAllPointGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(pointMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'S':
                case 'E':
                {
                    SegGeomMap &segMap = graph->GetAllSegGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(segMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'Q':
                {
                    QuadGeomMap &quadMap = graph->GetAllQuadGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(quadMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'T':
                {
                    TriGeomMap &triMap = graph->GetAllTriGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(triMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'F':
                {
                    QuadGeomMap &quadMap = graph->GetAllQuadGeoms();
                    TriGeomMap &triMap = graph->GetAllTriGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        auto f = quadMap.find(it.second->m_items[i]->GetId());
                        if(f != quadMap.end())
                        {
                            curVector->m_geomVec.push_back(f->second);
                        }
                        else
                        {
                            auto f2 = triMap.find(it.second->m_items[i]->GetId());
                            curVector->m_geomVec.push_back(f2->second);
                        }
                    }
                }
                break;
                case 'A':
                {
                    TetGeomMap &tetMap = graph->GetAllTetGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(tetMap[it.second->m_items[i]->GetId()]);
                    };
                }
                break;
                case 'P':
                {
                    PyrGeomMap &pyrMap = graph->GetAllPyrGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(pyrMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'R':
                {
                    PrismGeomMap &prismMap = graph->GetAllPrismGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(prismMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                case 'H':
                {
                    HexGeomMap &hexMap = graph->GetAllHexGeoms();
                    for(int i = 0; i < it.second->m_items.size(); i++)
                    {
                        curVector->m_geomVec.push_back(hexMap[it.second->m_items[i]->GetId()]);
                    }
                }
                break;
                default:
                    ASSERTL0(false, "Unknown element type");
            }

            comps[indx] = curVector;
        }
        j++;
    }
}

TransferCurves()

void Nektar::Utilities::OutputNekpp::TransferCurves ( SpatialDomains::MeshGraphSharedPtr  graph )

private

Definition at line 444 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    CurveMap &edges = graph->GetCurvedEdges();

    int edgecnt = 0;

    for(auto &it : m_mesh->m_edgeSet)
    {
        if(it->m_edgeNodes.size() > 0)
        {
            CurveSharedPtr curve = MemoryManager<Curve>::AllocateSharedPtr(it->m_id,
                                            it->m_curveType);
            vector<NodeSharedPtr> ns;
            it->GetCurvedNodes(ns);
            for(int i = 0; i < ns.size(); i++)
            {
                PointGeomSharedPtr vert = MemoryManager<PointGeom>::AllocateSharedPtr(
                    m_mesh->m_spaceDim, edgecnt, ns[i]->m_x, ns[i]->m_y, ns[i]->m_z);
                curve->m_points.push_back(vert);
            }

            edges[it->m_id] = curve;
            edgecnt++;
        }
    }

    if(m_mesh->m_expDim == 1 && m_mesh->m_spaceDim > 1)
    {
        for(int e = 0; e < m_mesh->m_element[1].size(); e++)
        {
            ElementSharedPtr el = m_mesh->m_element[1][e];
            vector<NodeSharedPtr> ns;
            el->GetCurvedNodes(ns);
            if(ns.size() > 2)
            {
                CurveSharedPtr curve = MemoryManager<Curve>::AllocateSharedPtr(
                    el->GetId(), el->GetCurveType());

                for(int i = 0; i < ns.size(); i++)
                {
                    PointGeomSharedPtr vert = MemoryManager<PointGeom>::AllocateSharedPtr(
                        m_mesh->m_spaceDim, edgecnt, ns[i]->m_x, ns[i]->m_y, ns[i]->m_z);
                    curve->m_points.push_back(vert);
                }

                edges[el->GetId()] = curve;
                edgecnt++;
            }
        }
    }

    CurveMap &faces = graph->GetCurvedFaces();

    int facecnt = 0;

    for(auto &it : m_mesh->m_faceSet)
    {
        if(it->m_faceNodes.size() > 0)
        {
            CurveSharedPtr curve =
                MemoryManager<Curve>::AllocateSharedPtr(it->m_id,
                                                        it->m_curveType);
            vector<NodeSharedPtr> ns;
            it->GetCurvedNodes(ns);
            for(int i = 0; i < ns.size(); i++)
            {
                PointGeomSharedPtr vert =
                    MemoryManager<PointGeom>::AllocateSharedPtr
                    (m_mesh->m_spaceDim, facecnt, ns[i]->m_x, ns[i]->m_y,
                     ns[i]->m_z);
                curve->m_points.push_back(vert);
            }

            faces[it->m_id] = curve;
            facecnt++;
        }
    }

    /*
    if(m_mesh->m_expDim == 2 && m_mesh->m_spaceDim == 3)
    {
        //manifold case
        for(int e = 0; e < m_mesh->m_element[2].size(); e++)
        {
            ElementSharedPtr el = m_mesh->m_element[2][e];

            if(el->GetVolumeNodes().size() > 0) // needed for extract surf case
            {
                vector<NodeSharedPtr> ns;
                el->GetCurvedNodes(ns);
                if(ns.size() > 4)
                {
                    CurveSharedPtr curve =
                        MemoryManager<Curve>::AllocateSharedPtr
                        (el->GetId(), el->GetCurveType());

                    for(int i = 0; i < ns.size(); i++)
                    {
                        PointGeomSharedPtr vert =
                            MemoryManager<PointGeom>::AllocateSharedPtr
                            (m_mesh->m_spaceDim, facecnt, ns[i]->m_x, ns[i]->m_y,
                             ns[i]->m_z);
                        curve->m_points.push_back(vert);
                    }

                    faces[el->GetId()] = curve;
                    facecnt++;
                }
            }
        }
    }
    */
}

TransferDomain()

void Nektar::Utilities::OutputNekpp::TransferDomain ( SpatialDomains::MeshGraphSharedPtr  graph )

private

Definition at line 682 of file OutputNekpp.cpp.

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

Referenced by Process().

{
    vector<SpatialDomains::CompositeMap> &domain = graph->GetDomain();

    string list;

    for(auto &it : m_mesh->m_composite)
    {
        if(it.second->m_items[0]->GetDim() == m_mesh->m_expDim)
        {
            if(list.length() > 0)
            {
                list += ",";
            }
            list += boost::lexical_cast<string>(it.second->m_id);
        }
    }

    SpatialDomains::CompositeMap fullDomain;
    graph->GetCompositeList(list, fullDomain);
    domain.push_back(fullDomain);
}

TransferEdges()

void Nektar::Utilities::OutputNekpp::TransferEdges ( SpatialDomains::MeshGraphSharedPtr  graph, std::unordered_map< int, SpatialDomains::SegGeomSharedPtr > &  edgeMap  )

private

Definition at line 255 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    if (m_mesh->m_expDim >= 2)
    {
        SegGeomMap &segMap = graph->GetAllSegGeoms();
        for(auto &it : m_mesh->m_edgeSet)
        {
            PointGeomSharedPtr verts[2] = {graph->GetVertex(it->m_n1->m_id),
                                           graph->GetVertex(it->m_n2->m_id)};
            SegGeomSharedPtr edge = MemoryManager<SegGeom>::AllocateSharedPtr(
                                it->m_id, m_mesh->m_spaceDim, verts);
            segMap [it->m_id] = edge;
            edgeMap[it->m_id] = edge;
        }
    }
}

TransferElements()

void Nektar::Utilities::OutputNekpp::TransferElements ( SpatialDomains::MeshGraphSharedPtr  graph )

private

Definition at line 313 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTriangle, and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    vector<ElementSharedPtr> &elmt = m_mesh->m_element[m_mesh->m_expDim];

    SegGeomMap &segMap = graph->GetAllSegGeoms();
    TriGeomMap &triMap = graph->GetAllTriGeoms();
    QuadGeomMap &quadMap = graph->GetAllQuadGeoms();
    TetGeomMap &tetMap = graph->GetAllTetGeoms();
    PyrGeomMap &pyrMap = graph->GetAllPyrGeoms();
    PrismGeomMap &prismMap = graph->GetAllPrismGeoms();
    HexGeomMap &hexMap = graph->GetAllHexGeoms();

    for (int i = 0; i < elmt.size(); ++i)
    {
        switch (elmt[i]->GetTag()[0])
        {
            case 'S':
            {
                int id = elmt[i]->GetId();
                PointGeomSharedPtr vertices[2] = {
                    graph->GetVertex(elmt[i]->GetVertex(0)->m_id),
                    graph->GetVertex(elmt[i]->GetVertex(1)->m_id)};
                segMap[id] = MemoryManager<SegGeom>::AllocateSharedPtr(id, m_mesh->m_spaceDim, vertices);
            }
            break;
            case 'T':
            {
                int id = elmt[i]->GetId();
                SegGeomSharedPtr edges[TriGeom::kNedges] = {
                        graph->GetSegGeom(elmt[i]->GetEdge(0)->m_id),
                        graph->GetSegGeom(elmt[i]->GetEdge(1)->m_id),
                        graph->GetSegGeom(elmt[i]->GetEdge(2)->m_id)};

                triMap[id] = MemoryManager<TriGeom>::AllocateSharedPtr(id, edges);
            }
            break;
            case 'Q':
            {
                int id = elmt[i]->GetId();
                SegGeomSharedPtr edges[QuadGeom::kNedges] = {
                        graph->GetSegGeom(elmt[i]->GetEdge(0)->m_id),
                        graph->GetSegGeom(elmt[i]->GetEdge(1)->m_id),
                        graph->GetSegGeom(elmt[i]->GetEdge(2)->m_id),
                        graph->GetSegGeom(elmt[i]->GetEdge(3)->m_id)};

                quadMap[id] = MemoryManager<QuadGeom>::AllocateSharedPtr(id, edges);
            }
            break;
            case 'A':
            {
                int id = elmt[i]->GetId();
                TriGeomSharedPtr tfaces[4];
                for(int j = 0; j < 4; ++j)
                {
                    Geometry2DSharedPtr face =
                        graph->GetGeometry2D(elmt[i]->GetFace(j)->m_id);
                    tfaces[j] = static_pointer_cast<TriGeom>(face);
                }

                tetMap[id] = MemoryManager<TetGeom>::AllocateSharedPtr(id, tfaces);
            }
            break;
            case 'P':
            {
                Geometry2DSharedPtr faces[5];

                int id = elmt[i]->GetId();
                for(int j = 0; j < 5; ++j)
                {
                    Geometry2DSharedPtr face =
                        graph->GetGeometry2D(elmt[i]->GetFace(j)->m_id);

                    if (face->GetShapeType() ==
                                LibUtilities::eTriangle)
                    {
                        faces[j] = static_pointer_cast<TriGeom>(face);
                    }
                    else if (face->GetShapeType() ==
                                LibUtilities::eQuadrilateral)
                    {
                        faces[j] = static_pointer_cast<QuadGeom>(face);
                    }
                }
                pyrMap[id] = MemoryManager<PyrGeom>::AllocateSharedPtr(id, faces);
            }
            break;
            case 'R':
            {
                Geometry2DSharedPtr faces[5];

                int id = elmt[i]->GetId();
                for(int j = 0; j < 5; ++j)
                {
                    Geometry2DSharedPtr face =
                        graph->GetGeometry2D(elmt[i]->GetFace(j)->m_id);

                    if (face->GetShapeType() ==
                                LibUtilities::eTriangle)
                    {
                        faces[j] = static_pointer_cast<TriGeom>(face);
                    }
                    else if (face->GetShapeType() ==
                                LibUtilities::eQuadrilateral)
                    {
                        faces[j] = static_pointer_cast<QuadGeom>(face);
                    }
                }
                prismMap[id] = MemoryManager<PrismGeom>::AllocateSharedPtr(id, faces);
            }
            break;
            case 'H':
            {
                QuadGeomSharedPtr faces[6];

                int id = elmt[i]->GetId();
                for(int j = 0; j < 6; ++j)
                {
                    Geometry2DSharedPtr face =
                        graph->GetGeometry2D(elmt[i]->GetFace(j)->m_id);
                    faces[j] = static_pointer_cast<QuadGeom>(face);
                }

                hexMap[id] = MemoryManager<HexGeom>::AllocateSharedPtr(id, faces);
            }
            break;
            default:
                ASSERTL0(false, "Unknown element type");
        }
    }
}

TransferFaces()

void Nektar::Utilities::OutputNekpp::TransferFaces ( SpatialDomains::MeshGraphSharedPtr  graph, std::unordered_map< int, SpatialDomains::SegGeomSharedPtr > &  edgeMap  )

private

Definition at line 274 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    if(m_mesh->m_expDim == 3)
    {
        TriGeomMap &triMap = graph->GetAllTriGeoms();
        QuadGeomMap &quadMap = graph->GetAllQuadGeoms();
        for(auto &it : m_mesh->m_faceSet)
        {
            if(it->m_edgeList.size() == 3)
            {
                SegGeomSharedPtr edges[TriGeom::kNedges] =
                {
                    edgeMap[it->m_edgeList[0]->m_id],
                    edgeMap[it->m_edgeList[1]->m_id],
                    edgeMap[it->m_edgeList[2]->m_id]
                };

                TriGeomSharedPtr tri = MemoryManager<TriGeom>::AllocateSharedPtr(it->m_id, edges);
                triMap[it->m_id] = tri;
            }
            else
            {
                SegGeomSharedPtr edges[QuadGeom::kNedges] =
                {
                    edgeMap[it->m_edgeList[0]->m_id],
                    edgeMap[it->m_edgeList[1]->m_id],
                    edgeMap[it->m_edgeList[2]->m_id],
                    edgeMap[it->m_edgeList[3]->m_id]
                };

                QuadGeomSharedPtr quad = MemoryManager<QuadGeom>::AllocateSharedPtr(it->m_id, edges);
                quadMap[it->m_id] = quad;
            }
        }
    }
}

TransferVertices()

void Nektar::Utilities::OutputNekpp::TransferVertices ( SpatialDomains::MeshGraphSharedPtr  graph )

private

Definition at line 243 of file OutputNekpp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::NekMeshUtils::Module::m_mesh.

Referenced by Process().

{
    PointGeomMap &pointMap = graph->GetAllPointGeoms();
    for(auto &it : m_mesh->m_vertexSet)
    {
        PointGeomSharedPtr vert = MemoryManager<PointGeom>::AllocateSharedPtr(
                        m_mesh->m_spaceDim, it->m_id, it->m_x, it->m_y, it->m_z);
        vert->SetGlobalID(it->m_id);
        pointMap[it->m_id] = vert;
    }
}

Member Data Documentation

className1

ModuleKey Nektar::Utilities::OutputNekpp::className1

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eOutputModule, "xml"),
                                               OutputNekpp::create,
                                               "Writes a Nektar++ xml file.")

Definition at line 54 of file OutputNekpp.h.

className2

ModuleKey Nektar::Utilities::OutputNekpp::className2

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eOutputModule, "nekg"),
                                               OutputNekpp::create,
                                               "Writes a Nektar++ file with hdf5.")

Definition at line 54 of file OutputNekpp.h.

m_strEval

LibUtilities::Interpreter Nektar::Utilities::OutputNekpp::m_strEval

private

Definition at line 63 of file OutputNekpp.h.

Referenced by Process().