Nektar::Utilities::ProcessDetectSurf 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 <ProcessDetectSurf.h>

Inheritance diagram for Nektar::Utilities::ProcessDetectSurf:

Public Member Functions
	ProcessDetectSurf (NekMeshUtils::MeshSharedPtr m)
virtual	~ProcessDetectSurf ()
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

Private Member Functions
void	FindContiguousSurface (NekMeshUtils::ElementSharedPtr start, std::set< int > &doneIds, std::vector< NekMeshUtils::ElementSharedPtr > &block)

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 ProcessDetectSurf.h.

Constructor & Destructor Documentation

ProcessDetectSurf()

Nektar::Utilities::ProcessDetectSurf::ProcessDetectSurf

(

NekMeshUtils::MeshSharedPtr

m

)

Definition at line 53 of file ProcessDetectSurf.cpp.

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

                                                    : ProcessModule(m)
{
    m_config["vol"] =
        ConfigOption(false, "-1", "Tag identifying surface to process.");
}

~ProcessDetectSurf()

Nektar::Utilities::ProcessDetectSurf::~ProcessDetectSurf ( )

virtual

Definition at line 59 of file ProcessDetectSurf.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 55 of file ProcessDetectSurf.h.

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

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

FindContiguousSurface()

void Nektar::Utilities::ProcessDetectSurf::FindContiguousSurface ( NekMeshUtils::ElementSharedPtr  start, std::set< int > &  doneIds, std::vector< NekMeshUtils::ElementSharedPtr > &  block  )

private

Definition at line 214 of file ProcessDetectSurf.cpp.

Referenced by Process().

{
    block.push_back(start);
    doneIds.erase(start->GetId());

    vector<EdgeSharedPtr> edges = start->GetEdgeList();

    for (int i = 0; i < edges.size(); ++i)
    {
        for (int j = 0; j < edges[i]->m_elLink.size(); ++j)
        {
            ElementSharedPtr elmt = edges[i]->m_elLink[j].first;
            if (elmt == start)
            {
                continue;
            }

            if (doneIds.count(elmt->GetId()) == 0)
            {
                continue;
            }

            FindContiguousSurface(elmt, doneIds, block);
        }
    }
}

Process()

void Nektar::Utilities::ProcessDetectSurf::Process ( )

virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 73 of file ProcessDetectSurf.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::eSegment, FindContiguousSurface(), Nektar::ParseUtils::GenerateSeqVector(), Nektar::NekMeshUtils::GetElementFactory(), Nektar::NekMeshUtils::Module::m_config, and Nektar::NekMeshUtils::Module::m_mesh.

{
    if (m_mesh->m_expDim > 2)
    {
        cerr << "Surface detection only implemented for 2D meshes" << endl;
        return;
    }

    int i, j;
    string surf = m_config["vol"].as<string>();

    // Obtain vector of surface IDs from string.
    vector<unsigned int> surfs;
    if (surf != "-1")
    {
        ParseUtils::GenerateSeqVector(surf, surfs);
        sort(surfs.begin(), surfs.end());
    }

    // If we're running in verbose mode print out a list of surfaces.
    if (m_mesh->m_verbose)
    {
        cout << "ProcessDetectSurf: detecting surfaces";
        if (surfs.size() > 0)
        {
            cout << " for surface" << (surfs.size() == 1 ? "" : "s") << " "
                 << surf << endl;
        }
    }

    vector<ElementSharedPtr> &el = m_mesh->m_element[m_mesh->m_expDim];
    map<int, EdgeInfo> edgeCount;
    set<int> doneIds;
    map<int, int> idMap;

    // Iterate over list of surface elements.
    for (i = 0; i < el.size(); ++i)
    {
        // Work out whether this lies on our surface of interest.
        if (surfs.size() > 0)
        {
            vector<int> inter, tags = el[i]->GetTagList();

            sort(tags.begin(), tags.end());
            set_intersection(surfs.begin(),
                             surfs.end(),
                             tags.begin(),
                             tags.end(),
                             back_inserter(inter));

            // It doesn't continue to next element.
            if (inter.size() != 1)
            {
                continue;
            }
        }

        // List all edges.
        ElementSharedPtr elmt = el[i];
        for (j = 0; j < elmt->GetEdgeCount(); ++j)
        {
            EdgeSharedPtr e = elmt->GetEdge(j);
            int eId         = e->m_id;
            edgeCount[eId].count++;
            edgeCount[eId].edge = e;
        }

        doneIds.insert(elmt->GetId());
        ASSERTL0(idMap.count(elmt->GetId()) == 0, "Shouldn't happen");
        idMap[elmt->GetId()] = i;
    }

    unsigned int maxId = 0;

    for (auto &cIt : m_mesh->m_composite)
    {
        maxId = (std::max)(cIt.first, maxId);
    }

    ++maxId;

    while (doneIds.size() > 0)
    {
        ElementSharedPtr start =
            m_mesh->m_element[m_mesh->m_expDim][idMap[*(doneIds.begin())]];

        vector<ElementSharedPtr> block;
        FindContiguousSurface(start, doneIds, block);
        ASSERTL0(block.size() > 0, "Contiguous block not found");

        // Loop over all edges in block.
        for (i = 0; i < block.size(); ++i)
        {
            // Find edge info.
            ElementSharedPtr elmt = block[i];

            for (j = 0; j < elmt->GetEdgeCount(); ++j)
            {
                auto eIt = edgeCount.find(elmt->GetEdge(j)->m_id);
                ASSERTL0(eIt != edgeCount.end(), "Couldn't find edge");
                eIt->second.group = maxId;
            }
        }

        ++maxId;
    }

    for (auto &eIt : edgeCount)
    {
        if (eIt.second.count > 1)
        {
            continue;
        }

        unsigned int compId = eIt.second.group;
        auto cIt            = m_mesh->m_composite.find(compId);

        if (cIt == m_mesh->m_composite.end())
        {
            CompositeSharedPtr comp(new Composite());
            comp->m_id  = compId;
            comp->m_tag = "E";
            cIt =
                m_mesh->m_composite.insert(std::make_pair(compId, comp)).first;
        }

        vector<int> tags(1);
        tags[0] = compId;
        vector<NodeSharedPtr> nodeList(2);
        nodeList[0] = eIt.second.edge->m_n1;
        nodeList[1] = eIt.second.edge->m_n2;

        ElmtConfig conf(LibUtilities::eSegment, 1, false, false);
        ElementSharedPtr elmt = GetElementFactory().CreateInstance(
            LibUtilities::eSegment, conf, nodeList, tags);
        elmt->SetEdgeLink(eIt.second.edge);

        cIt->second->m_items.push_back(elmt);
    }
}

Member Data Documentation

className

ModuleKey Nektar::Utilities::ProcessDetectSurf::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "detect"),
        ProcessDetectSurf::create,
        "Process elements to detect a surface.")

Definition at line 59 of file ProcessDetectSurf.h.