Nektar::Utilities::ProcessOptiExtract Class Reference

#include <ProcessOptiExtract.h>

Inheritance diagram for Nektar::Utilities::ProcessOptiExtract:

Collaboration diagram for Nektar::Utilities::ProcessOptiExtract:

Public Member Functions
	ProcessOptiExtract (MeshSharedPtr m)
virtual	~ProcessOptiExtract ()
virtual void	Process ()
	Write mesh to output file. More...
Public Member Functions inherited from Nektar::Utilities::ProcessModule
	ProcessModule ()
	ProcessModule (FieldSharedPtr p_f)
	ProcessModule (MeshSharedPtr p_m)
Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)
virtual void	Process (po::variables_map &vm)=0
void	RegisterConfig (string key, string value)
	Register a configuration option with a module. More...
void	PrintConfig ()
	Print out all configuration options for a module. More...
void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...
bool	GetRequireEquiSpaced (void)
void	SetRequireEquiSpaced (bool pVal)
void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
	Module (MeshSharedPtr p_m)
void	RegisterConfig (std::string key, std::string value)
void	PrintConfig ()
void	SetDefaults ()
MeshSharedPtr	GetMesh ()
virtual void	ProcessVertices ()
	Extract element vertices. More...
virtual void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...
virtual void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...
virtual void	ProcessElements ()
	Generate element IDs. More...
virtual void	ProcessComposites ()
	Generate composites. More...
virtual 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

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

Detailed Description

Definition at line 46 of file ProcessOptiExtract.h.

Constructor & Destructor Documentation

Nektar::Utilities::ProcessOptiExtract::ProcessOptiExtract

(

MeshSharedPtr

m

)

Definition at line 55 of file ProcessOptiExtract.cpp.

References Nektar::Utilities::Module::m_config.

                                                      : ProcessModule(m)
{
    m_config["insert"] =
        ConfigOption(false, "-1", "Name of mesh file to be combined.");
}

Nektar::Utilities::ProcessOptiExtract::~ProcessOptiExtract ( )

virtual

Definition at line 61 of file ProcessOptiExtract.cpp.

{
}

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::ProcessOptiExtract::create ( MeshSharedPtr  m )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file ProcessOptiExtract.h.

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

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

void Nektar::Utilities::ProcessOptiExtract::Process ( )

virtual

Write mesh to output file.

Implements Nektar::Utilities::Module.

Definition at line 65 of file ProcessOptiExtract.cpp.

References Nektar::Utilities::Module::ClearElementLinks(), Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::Utilities::eInputModule, Nektar::LibUtilities::eTriangle, Nektar::NekMeshUtils::GetElementFactory(), Nektar::Utilities::GetModuleFactory(), Nektar::iterator, Nektar::Utilities::Module::m_config, Nektar::Utilities::Module::m_mesh, Nektar::Utilities::Module::ProcessComposites(), and Nektar::Utilities::Module::ProcessFaces().

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

    string ins = m_config["insert"].as<string>();

    bool extract = boost::iequals(ins, "-1");

    if (extract)
    {
        vector<ElementSharedPtr> el = m_mesh->m_element[m_mesh->m_expDim];

        m_mesh->m_element[m_mesh->m_expDim].clear();
        m_mesh->m_element[m_mesh->m_expDim - 1].clear();

        vector<ElementSharedPtr> invalid;

        // get invalid elements
        for (int i = 0; i < el.size(); ++i)
        {
            // Create elemental geometry.
            SpatialDomains::GeometrySharedPtr geom =
                el[i]->GetGeom(m_mesh->m_spaceDim);

            // Generate geometric factors.
            SpatialDomains::GeomFactorsSharedPtr gfac = geom->GetGeomFactors();

            // Get the Jacobian and, if it is negative, print a warning
            // message.
            if (!gfac->IsValid())
            {
                invalid.push_back(el[i]);
            }
        }

        boost::unordered_set<int> inmesh;
        pair<boost::unordered_set<int>::iterator, bool> t;
        vector<ElementSharedPtr> totest;

        for (int i = 0; i < invalid.size(); i++)
        {
            t = inmesh.insert(invalid[i]->GetId());
            if (t.second)
                m_mesh->m_element[m_mesh->m_expDim].push_back(invalid[i]);

            vector<FaceSharedPtr> f = invalid[i]->GetFaceList();
            for (int j = 0; j < f.size(); j++)
            {
                for (int k = 0; k < f[j]->m_elLink.size(); k++)
                {
                    if (f[j]->m_elLink[k].first->GetId() == invalid[i]->GetId())
                        continue;

                    t = inmesh.insert(f[j]->m_elLink[k].first->GetId());
                    if (t.second)
                    {
                        m_mesh->m_element[m_mesh->m_expDim].push_back(
                            f[j]->m_elLink[k].first);
                        totest.push_back(f[j]->m_elLink[k].first);
                    }
                }
            }
        }

        for (int i = 0; i < 12; i++)
        {
            vector<ElementSharedPtr> tmp = totest;
            totest.clear();
            for (int j = 0; j < tmp.size(); j++)
            {
                vector<FaceSharedPtr> f = tmp[j]->GetFaceList();
                for (int k = 0; k < f.size(); k++)
                {
                    for (int l = 0; l < f[k]->m_elLink.size(); l++)
                    {
                        if (f[k]->m_elLink[l].first->GetId() == tmp[j]->GetId())
                            continue;

                        t = inmesh.insert(f[k]->m_elLink[l].first->GetId());
                        if (t.second)
                        {
                            m_mesh->m_element[m_mesh->m_expDim].push_back(
                                f[k]->m_elLink[l].first);
                            totest.push_back(f[k]->m_elLink[l].first);
                        }
                    }
                }
            }
        }

        ClearElementLinks();
        m_mesh->m_vertexSet.clear();
        m_mesh->m_edgeSet.clear();
        m_mesh->m_faceSet.clear();

        el = m_mesh->m_element[m_mesh->m_expDim];

        if (m_mesh->m_verbose)
            cout << el.size() << " elements in blobs" << endl;

        m_mesh->m_faceSet.clear();

        // re build face links
        for (int i = 0; i < el.size(); ++i)
        {
            for (int j = 0; j < el[i]->GetFaceCount(); ++j)
            {
                pair<FaceSet::iterator, bool> testIns;
                testIns = m_mesh->m_faceSet.insert(el[i]->GetFace(j));

                if (testIns.second)
                {
                    (*(testIns.first))
                        ->m_elLink.push_back(
                            pair<ElementSharedPtr, int>(el[i], j));
                }
                else
                {
                    el[i]->SetFace(j, *testIns.first);
                    // Update face to element map.
                    (*(testIns.first))
                        ->m_elLink.push_back(
                            pair<ElementSharedPtr, int>(el[i], j));
                }
            }
        }

        // build surface composite from faces
        for (int i = 0; i < el.size(); i++)
        {
            vector<FaceSharedPtr> f = el[i]->GetFaceList();
            for (int j = 0; j < f.size(); j++)
            {
                if (f[j]->m_elLink.size() ==
                    1) // boundary element make new composite
                {
                    ElmtConfig conf(LibUtilities::eTriangle, 1, false, false);

                    vector<int> tags;
                    tags.push_back(1);
                    ElementSharedPtr E = GetElementFactory().CreateInstance(
                        LibUtilities::eTriangle,
                        conf,
                        f[j]->m_vertexList,
                        tags);
                    m_mesh->m_element[m_mesh->m_expDim - 1].push_back(E);
                }
            }
        }

        ClearElementLinks();
        for (int i = 0; i < el.size(); ++i)
        {
            for (int j = 0; j < el[i]->GetVertexCount(); ++j)
            {
                pair<NodeSet::iterator, bool> testIns =
                    m_mesh->m_vertexSet.insert(el[i]->GetVertex(j));

                if (!testIns.second)
                {
                    el[i]->SetVertex(j, *testIns.first);
                }
            }
        }
        for (int i = 0; i < el.size(); ++i)
        {
            for (int j = 0; j < el[i]->GetEdgeCount(); ++j)
            {
                pair<EdgeSet::iterator, bool> testIns;
                EdgeSharedPtr ed = el[i]->GetEdge(j);
                testIns          = m_mesh->m_edgeSet.insert(ed);

                if (testIns.second)
                {
                    EdgeSharedPtr ed2 = *testIns.first;
                    ed2->m_elLink.push_back(
                        pair<ElementSharedPtr, int>(el[i], j));
                }
                else
                {
                    EdgeSharedPtr e2 = *(testIns.first);
                    el[i]->SetEdge(j, e2);
                    if (e2->m_edgeNodes.size() == 0 &&
                        ed->m_edgeNodes.size() > 0)
                    {
                        e2->m_curveType = ed->m_curveType;
                        e2->m_edgeNodes = ed->m_edgeNodes;

                        // Reverse nodes if appropriate.
                        if (e2->m_n1->m_id != ed->m_n1->m_id)
                        {
                            reverse(e2->m_edgeNodes.begin(),
                                    e2->m_edgeNodes.end());
                        }
                    }

                    // Update edge to element map.
                    e2->m_elLink.push_back(
                        pair<ElementSharedPtr, int>(el[i], j));
                }
            }
        }
        for (int i = 0; i < el.size(); ++i)
        {
            for (int j = 0; j < el[i]->GetFaceCount(); ++j)
            {
                pair<FaceSet::iterator, bool> testIns;
                testIns = m_mesh->m_faceSet.insert(el[i]->GetFace(j));

                if (testIns.second)
                {
                    (*(testIns.first))
                        ->m_elLink.push_back(
                            pair<ElementSharedPtr, int>(el[i], j));
                }
                else
                {
                    el[i]->SetFace(j, *testIns.first);
                    // Update face to element map.
                    (*(testIns.first))
                        ->m_elLink.push_back(
                            pair<ElementSharedPtr, int>(el[i], j));
                }
            }
        }
        ProcessFaces(false);
        ProcessComposites();
    }
    else
    {
        // insert other mesh
        cout << ins << endl;
        MeshSharedPtr inp_mesh = boost::shared_ptr<Mesh>(new Mesh());
        ModuleSharedPtr mod = GetModuleFactory().CreateInstance(
            ModuleKey(eInputModule, "xml"), inp_mesh);
        mod->RegisterConfig("infile", ins);
        mod->Process();

        // need to update the vertices manually then the edges and faces can
        // be updated using more simple means.
        map<int, NodeSharedPtr> nmap;

        NodeSet::iterator nit;
        for (nit = inp_mesh->m_vertexSet.begin();
             nit != inp_mesh->m_vertexSet.end();
             nit++)
        {
            nmap[(*nit)->m_id] = *nit;
        }
        // for all the nodes in the main mesh see if they are in nmap, if so
        // update the node
        for (nit = m_mesh->m_vertexSet.begin();
             nit != m_mesh->m_vertexSet.end();
             nit++)
        {
            if (nmap.count((*nit)->m_id) == 1)
            {
                map<int, NodeSharedPtr>::iterator s;
                s               = nmap.find((*nit)->m_id);
                NodeSharedPtr n = s->second;
                (*nit)->m_x = n->m_x;
                (*nit)->m_y = n->m_y;
                (*nit)->m_z = n->m_z;
            }
        }
        EdgeSet::iterator eit;
        for (eit = inp_mesh->m_edgeSet.begin();
             eit != inp_mesh->m_edgeSet.end();
             eit++)
        {
            EdgeSet::iterator et = m_mesh->m_edgeSet.find(*eit);
            if (et != m_mesh->m_edgeSet.end())
            {
                (*et)->m_edgeNodes = (*eit)->m_edgeNodes;
                (*et)->m_curveType = (*eit)->m_curveType;
            }
        }
        FaceSet::iterator fit;
        for (fit = inp_mesh->m_faceSet.begin();
             fit != inp_mesh->m_faceSet.end();
             fit++)
        {
            FaceSet::iterator ft = m_mesh->m_faceSet.find(*fit);
            if (ft != m_mesh->m_faceSet.end())
            {
                (*ft)->m_faceNodes = (*fit)->m_faceNodes;
                (*ft)->m_curveType = (*fit)->m_curveType;
            }
        }
    }
}

Member Data Documentation

ModuleKey Nektar::Utilities::ProcessOptiExtract::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "opti"),
        ProcessOptiExtract::create,
        "Pulls out blobs for linear elastic solver.")

Definition at line 54 of file ProcessOptiExtract.h.