Nektar::Utilities::ProcessLinear Class Reference

This processing module removes all the high-order information from the mesh leaving just the linear elements. More...

#include <ProcessLinear.h>

Inheritance diagram for Nektar::Utilities::ProcessLinear:

Collaboration diagram for Nektar::Utilities::ProcessLinear:

Public Member Functions
	ProcessLinear (NekMeshUtils::MeshSharedPtr m)
virtual	~ProcessLinear ()
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)
	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 (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className

Private Member Functions
bool	Invalid (NekMeshUtils::ElementSharedPtr el, NekDouble thr)

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 removes all the high-order information from the mesh leaving just the linear elements.

Definition at line 49 of file ProcessLinear.h.

Constructor & Destructor Documentation

Nektar::Utilities::ProcessLinear::ProcessLinear

(

NekMeshUtils::MeshSharedPtr

m

)

Definition at line 53 of file ProcessLinear.cpp.

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

                                            : ProcessModule(m)
{
    m_config["all"] =
        ConfigOption(true, "0", "remove curve nodes for all elements.");
    m_config["invalid"] =
        ConfigOption(false, "0", "remove curve nodes if element is invalid.");
    m_config["prismonly"] =
        ConfigOption(true, "0", "only acts on prims");
    m_config["extract"] =
        ConfigOption(false, "", "dump a mesh of the extracted elements");
}

Nektar::Utilities::ProcessLinear::~ProcessLinear ( )

virtual

Definition at line 65 of file ProcessLinear.cpp.

{
}

Member Function Documentation

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

inlinestatic

Creates an instance of this class.

Definition at line 53 of file ProcessLinear.h.

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

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

bool Nektar::Utilities::ProcessLinear::Invalid ( NekMeshUtils::ElementSharedPtr  el, NekDouble  thr  )

private

Definition at line 250 of file ProcessLinear.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::eFULL, Nektar::NekMeshUtils::GetElementFactory(), Nektar::NekMeshUtils::ElmtConfig::m_e, Nektar::NekMeshUtils::ElmtConfig::m_faceNodes, Nektar::NekMeshUtils::Module::m_mesh, Nektar::NekMeshUtils::ElmtConfig::m_order, Nektar::NekMeshUtils::ElmtConfig::m_reorient, Nektar::NekMeshUtils::ElmtConfig::m_volumeNodes, CellMLToNektar.cellml_metadata::p, Vmath::Vdiv(), Vmath::Vmax(), and Vmath::Vmin().

Referenced by Process().

{
    // Create elemental geometry.
    SpatialDomains::GeometrySharedPtr geom =
        el->GetGeom(m_mesh->m_spaceDim);

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

    if(!gfac->IsValid())
    {
        return true;
    }

    vector<NodeSharedPtr> ns = el->GetVertexList();
    ElmtConfig c = el->GetConf();
    c.m_order = 1;
    c.m_faceNodes = false;
    c.m_volumeNodes = false;
    c.m_reorient = false;

    ElementSharedPtr elL = GetElementFactory().CreateInstance(
                c.m_e, c, ns, el->GetTagList());
    SpatialDomains::GeometrySharedPtr geomL = elL->GetGeom(m_mesh->m_spaceDim);
    SpatialDomains::GeomFactorsSharedPtr gfacL = geomL->GetGeomFactors();

    LibUtilities::PointsKeyVector p = geom->GetPointsKeys();
    SpatialDomains::DerivStorage deriv = gfac->GetDeriv(p);
    SpatialDomains::DerivStorage derivL = gfacL->GetDeriv(p);
    const int pts = deriv[0][0].num_elements();
    Array<OneD,NekDouble> jc(pts);
    Array<OneD,NekDouble> jcL(pts);
    for (int k = 0; k < pts; ++k)
    {
        DNekMat jac(m_mesh->m_expDim, m_mesh->m_expDim, 0.0, eFULL);
        DNekMat jacL(m_mesh->m_expDim, m_mesh->m_expDim, 0.0, eFULL);

        for (int l = 0; l < m_mesh->m_expDim; ++l)
        {
            for (int j = 0; j < m_mesh->m_expDim; ++j)
            {
                jac(j,l) = deriv[l][j][k];
                jacL(j,l) = derivL[l][j][k];
            }
        }

        if(m_mesh->m_expDim == 2)
        {
            jc[k] = jac(0,0) * jac(1,1) - jac(0,1)*jac(1,0);
            jcL[k] = jacL(0,0) * jacL(1,1) - jacL(0,1)*jacL(1,0);
        }
        else if(m_mesh->m_expDim == 3)
        {
            jc[k] =  jac(0,0) * (jac(1,1)*jac(2,2) - jac(2,1)*jac(1,2)) -
                     jac(0,1) * (jac(1,0)*jac(2,2) - jac(2,0)*jac(1,2)) +
                     jac(0,2) * (jac(1,0)*jac(2,1) - jac(2,0)*jac(1,1));
            jcL[k] =  jacL(0,0) * (jacL(1,1)*jacL(2,2) - jacL(2,1)*jacL(1,2)) -
                      jacL(0,1) * (jacL(1,0)*jacL(2,2) - jacL(2,0)*jacL(1,2)) +
                      jacL(0,2) * (jacL(1,0)*jacL(2,1) - jacL(2,0)*jacL(1,1));
        }
    }

    Array<OneD, NekDouble> j(pts);
    Vmath::Vdiv(jc.num_elements(),jc,1,jcL,1,j,1);

    NekDouble scaledJac = Vmath::Vmin(j.num_elements(),j,1) /
                          Vmath::Vmax(j.num_elements(),j,1);

    //cout << scaledJac << endl;

    if(scaledJac < thr)
    {
        return true;
    }

    return false;
}

void Nektar::Utilities::ProcessLinear::Process ( )

virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 69 of file ProcessLinear.cpp.

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

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

    bool all     = m_config["all"].as<bool>();
    bool invalid = m_config["invalid"].beenSet;
    NekDouble thr = m_config["invalid"].as<NekDouble>();

    ASSERTL0(all || invalid,
             "Must specify an option: all (to remove all curvature) or invalid "
             "(to remove curvature that makes elements invalid)");

    if (all)
    {
        EdgeSet::iterator eit;
        for (eit = m_mesh->m_edgeSet.begin(); eit != m_mesh->m_edgeSet.end();
             eit++)
        {
            (*eit)->m_edgeNodes.clear();
        }

        FaceSet::iterator fit;
        for (fit = m_mesh->m_faceSet.begin(); fit != m_mesh->m_faceSet.end();
             fit++)
        {
            (*fit)->m_faceNodes.clear();
        }

        for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); i++)
        {
            vector<NodeSharedPtr> empty;
            m_mesh->m_element[m_mesh->m_expDim][i]->SetVolumeNodes(empty);
        }

        if (m_mesh->m_verbose)
        {
            cerr << "Removed all element curvature" << endl;
        }
    }
    else if (invalid)
    {
        map<int,vector<FaceSharedPtr> > eidToFace;
        map<int,vector<ElementSharedPtr> > eidToElm;

        vector<ElementSharedPtr> els = m_mesh->m_element[m_mesh->m_expDim];
        vector<ElementSharedPtr> el = els;

        for(int i = 0; i < el.size(); i++)
        {
            vector<EdgeSharedPtr> e = el[i]->GetEdgeList();
            for(int j = 0; j < e.size(); j++)
            {
                eidToElm[e[j]->m_id].push_back(el[i]);
            }
        }

        if(m_mesh->m_expDim > 2)
        {
            FaceSet::iterator it;
            for(it = m_mesh->m_faceSet.begin();
                it != m_mesh->m_faceSet.end(); it++)
            {
                vector<EdgeSharedPtr> es = (*it)->m_edgeList;
                for(int i = 0; i < es.size(); i++)
                {
                    eidToFace[es[i]->m_id].push_back((*it));
                }
            }
        }

        set<int> neigh;
        vector<NodeSharedPtr> zeroNodes;
        boost::unordered_set<int> clearedEdges, clearedFaces, clearedElmts;

        vector<ElementSharedPtr> dumpEls;

        // Iterate over list of elements of expansion dimension.
        while(el.size() > 0)
        {
            for (int i = 0; i < el.size(); ++i)
            {
                if(m_config["prismonly"].beenSet)
                {
                    if(el[i]->GetConf().m_e != LibUtilities::ePrism)
                    {
                        continue;
                    }
                }

                if (Invalid(el[i],thr))//(!gfac->IsValid())
                {
                    dumpEls.push_back(el[i]);
                    clearedElmts.insert(el[i]->GetId());;
                    el[i]->SetVolumeNodes(zeroNodes);

                    vector<FaceSharedPtr> f = el[i]->GetFaceList();
                    for (int j = 0; j < f.size(); j++)
                    {
                        f[j]->m_faceNodes.clear();
                        clearedFaces.insert(f[j]->m_id);
                    }
                    vector<EdgeSharedPtr> e = el[i]->GetEdgeList();
                    for(int j = 0; j < e.size(); j++)
                    {
                        e[j]->m_edgeNodes.clear();
                        clearedEdges.insert(e[j]->m_id);
                    }

                    if(m_mesh->m_expDim > 2)
                    {
                        for(int j = 0; j < e.size(); j++)
                        {
                            map<int,vector<FaceSharedPtr> >::iterator it =
                                eidToFace.find(e[j]->m_id);
                            for(int k = 0; k < it->second.size(); k++)
                            {
                                clearedEdges.insert(it->second[k]->m_id);
                                it->second[k]->m_faceNodes.clear();
                            }
                        }
                    }

                    for(int j = 0; j < e.size(); j++)
                    {
                        map<int,vector<ElementSharedPtr> >::iterator it =
                                            eidToElm.find(e[j]->m_id);
                        for(int k = 0; k < it->second.size(); k++)
                        {
                            neigh.insert(it->second[k]->GetId());
                        }
                    }
                }
            }

            el.clear();
            set<int>::iterator it1;
            boost::unordered_set<int>::iterator it2;
            for(int i = 0; i < els.size(); i++)
            {
                it1 = neigh.find(els[i]->GetId());
                it2 = clearedElmts.find(els[i]->GetId());
                if(it1 != neigh.end() && it2 == clearedElmts.end())
                {
                    el.push_back(els[i]);
                }
            }
            neigh.clear();
        }

        if (m_mesh->m_verbose)
        {
            cerr << "Removed curvature from " << clearedElmts.size()
                 << " elements (" << clearedEdges.size() << " edges, "
                 << clearedFaces.size() << " faces)" << endl;
        }

        if(m_config["extract"].beenSet)
        {
            MeshSharedPtr dmp = boost::shared_ptr<Mesh>(new Mesh());
            dmp->m_expDim     = 3;
            dmp->m_spaceDim   = 3;
            dmp->m_nummode    = 2;

            dmp->m_element[3] = dumpEls;

            ModuleSharedPtr mod = GetModuleFactory().CreateInstance(
                ModuleKey(eOutputModule, "xml"), dmp);
            mod->RegisterConfig("outfile", m_config["extract"].as<string>().c_str());
            mod->ProcessVertices();
            mod->ProcessEdges();
            mod->ProcessFaces();
            mod->ProcessElements();
            mod->ProcessComposites();
            mod->Process();
        }
    }
}

Member Data Documentation

ModuleKey Nektar::Utilities::ProcessLinear::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "linearise"),
    ProcessLinear::create,
    "Linearises mesh.")

Definition at line 57 of file ProcessLinear.h.