Nektar::Utilities::ProcessInsertSurface Class Reference

This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

#include <ProcessInsertSurface.h>

Inheritance diagram for Nektar::Utilities::ProcessInsertSurface:

Public Member Functions
	ProcessInsertSurface (NekMeshUtils::MeshSharedPtr m)
virtual	~ProcessInsertSurface ()
virtual void	Process ()
	Write mesh to output file. More...
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=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	className

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

This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian.

Definition at line 51 of file ProcessInsertSurface.h.

Constructor & Destructor Documentation

ProcessInsertSurface()

Nektar::Utilities::ProcessInsertSurface::ProcessInsertSurface

(

NekMeshUtils::MeshSharedPtr

m

)

Definition at line 59 of file ProcessInsertSurface.cpp.

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

                                                          : ProcessModule(m)
{
    m_config["mesh"] =
        ConfigOption(false, "", "Mesh to be inserted.");
    m_config["nonconforming"] =
        ConfigOption(false,"", "Relax tests for nonconforming boundries");
}

~ProcessInsertSurface()

Nektar::Utilities::ProcessInsertSurface::~ProcessInsertSurface ( )

virtual

Definition at line 67 of file ProcessInsertSurface.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 55 of file ProcessInsertSurface.h.

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

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

Process()

void Nektar::Utilities::ProcessInsertSurface::Process ( )

virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 71 of file ProcessInsertSurface.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::FieldUtils::eInputModule, Nektar::FieldUtils::GetModuleFactory(), Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Module::m_mesh, and CG_Iterations::Mesh.

{
    typedef bg::model::point<NekDouble, 3, bg::cs::cartesian> Point;
    typedef pair<Point, unsigned int> PointI;

    if (m_mesh->m_verbose)
    {
        cout << "ProcessInsertSurface: Inserting mesh... " << endl;
    }

    string file = m_config["mesh"].as<string>();
    bool nonconform = m_config["nonconforming"].beenSet;

    if (m_mesh->m_verbose)
    {
        cout << "inserting surface from " << file << endl;
    }
    MeshSharedPtr inMsh = std::shared_ptr<Mesh>(new Mesh());
    inMsh->m_verbose = m_mesh->m_verbose;
    ModuleSharedPtr mod = GetModuleFactory().CreateInstance(
        ModuleKey(eInputModule, "xml"), inMsh);
    mod->RegisterConfig("infile", file);
    mod->Process();

    //build ann tree of surface verticies from inMsh
    //match surface vertices in ccm mesh to inMsh and copy information

    //tolerance of matching vertices
    NekDouble tol = 1e-5;

    NodeSet surfaceNodes;
    for(int i = 0; i < inMsh->m_element[2].size(); i++)
    {
        vector<NodeSharedPtr> ns = inMsh->m_element[2][i]->GetVertexList();
        for(int j = 0; j < ns.size(); j++)
        {
            surfaceNodes.insert(ns[j]);
        }
    }

    vector<NodeSharedPtr> inMshnodeList(surfaceNodes.begin(), surfaceNodes.end());

    vector<PointI> dataPts;
    for(int i = 0; i < inMshnodeList.size(); i++)
    {
         dataPts.push_back(make_pair(Point( inMshnodeList[i]->m_x,
                                            inMshnodeList[i]->m_y,
                                            inMshnodeList[i]->m_z), i));
    }

    //Build tree
    bgi::rtree<PointI, bgi::rstar<16> > rtree;
    rtree.insert(dataPts.begin(), dataPts.end());

    surfaceNodes.clear();
    for(int i = 0; i < m_mesh->m_element[2].size(); i++)
    {
        vector<NodeSharedPtr> ns = m_mesh->m_element[2][i]->GetVertexList();
        for(int j = 0; j < ns.size(); j++)
        {
            surfaceNodes.insert(ns[j]);
        }
    }

    if(!nonconform)
    {
        ASSERTL0(surfaceNodes.size() == inMshnodeList.size(),
                 "surface mesh node count mismatch, will not work");
    }

    EdgeSet surfEdges;
    for(int i = 0; i < m_mesh->m_element[2].size(); i++)
    {
        FaceSharedPtr f = m_mesh->m_element[2][i]->GetFaceLink();
        vector<EdgeSharedPtr> es = f->m_edgeList;
        for(int j = 0; j < es.size(); j++)
        {
            surfEdges.insert(es[j]);
        }
    }

    for(auto &it : surfEdges)
    {
        Point queryPt1(it->m_n1->m_x, it->m_n1->m_y, it->m_n1->m_z);
        vector<PointI> result;
        rtree.query(bgi::nearest(queryPt1, 1), std::back_inserter(result));

        NekDouble dist1 = bg::distance(result[0].first, queryPt1);
        if(nonconform)
        {
            if(dist1 > tol)
            {
                continue;
            }
        }
        else
        {
            ASSERTL0(dist1 < tol, "cannot locate point accurately enough");
        }

        NodeSharedPtr inN1 = inMshnodeList[result[0].second];

        Point queryPt2(it->m_n2->m_x, it->m_n2->m_y, it->m_n2->m_z);
        result.clear();
        rtree.query(bgi::nearest(queryPt2, 1), std::back_inserter(result));

        NekDouble dist2 = bg::distance(result[0].first, queryPt2);
        if(nonconform)
        {
            if(dist2 > tol)
            {
                continue;
            }
        }
        else
        {
            ASSERTL0(dist2 < tol, "cannot locate point accurately enough");
        }
        NodeSharedPtr inN2 = inMshnodeList[result[0].second];

        EdgeSharedPtr tst = std::shared_ptr<Edge>(new Edge(inN1,inN2));

        auto f = inMsh->m_edgeSet.find(tst);

        ASSERTL0(f != inMsh->m_edgeSet.end(),"could not find edge in input");

        it->m_edgeNodes = (*f)->m_edgeNodes;
        it->m_curveType = (*f)->m_curveType;

        if((*f)->m_n1->Distance(it->m_n1) > tol)
        {
            reverse(it->m_edgeNodes.begin(), it->m_edgeNodes.end());
        }
    }
}

Member Data Documentation

className

ModuleKey Nektar::Utilities::ProcessInsertSurface::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "insertsurface"),
    ProcessInsertSurface::create,
    "Insert high-order surface mesh into current working mesh.")

Definition at line 59 of file ProcessInsertSurface.h.