Nektar::Utilities::ProcessPerAlign Class Reference

#include <ProcessPerAlign.h>

Inheritance diagram for Nektar::Utilities::ProcessPerAlign:

Public Member Functions
	ProcessPerAlign (NekMeshUtils::MeshSharedPtr m)
	Default constructor. More...
virtual	~ProcessPerAlign ()
	Destructor. More...
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

Definition at line 45 of file ProcessPerAlign.h.

Constructor & Destructor Documentation

ProcessPerAlign()

Nektar::Utilities::ProcessPerAlign::ProcessPerAlign

(

NekMeshUtils::MeshSharedPtr

m

)

Default constructor.

Definition at line 68 of file ProcessPerAlign.cpp.

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

                                                : ProcessModule(m)
{
    m_config["surf1"] =
        ConfigOption(false, "-1", "Tag identifying first surface.");
    m_config["surf2"] =
        ConfigOption(false, "-1", "Tag identifying first surface.");
    m_config["dir"] = ConfigOption(
        false, "", "Direction in which to align (either x, y, or z; "
        "or vector with components separated by a comma). "
        "If rot is specified this is interpreted as the axis or rotation");
    m_config["rot"] = ConfigOption(
        false, "", "Rotation to align composites in radians, i.e. PI/20");
    m_config["orient"] =
        ConfigOption(true, "0", "Attempt to reorient tets and prisms");
    m_config["tol"] =
        ConfigOption(false, "1e-8", "Tolerance to which to check planes are the same after rotation/translation");
}

~ProcessPerAlign()

Nektar::Utilities::ProcessPerAlign::~ProcessPerAlign ( )

virtual

Destructor.

Definition at line 89 of file ProcessPerAlign.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 49 of file ProcessPerAlign.h.

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

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

Process()

void Nektar::Utilities::ProcessPerAlign::Process ( )

virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 93 of file ProcessPerAlign.cpp.

References Nektar::NekMeshUtils::Node::abs2(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::Interpreter::DefineFunction(), Nektar::LibUtilities::eSegment, Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Node::m_id, Nektar::NekMeshUtils::Module::m_mesh, Nektar::NekMeshUtils::Node::m_x, Nektar::NekMeshUtils::Node::m_y, Nektar::NekMeshUtils::Node::m_z, Nektar::NekMeshUtils::Module::ReorderPrisms(), and Nektar::NekMeshUtils::Node::Rotate().

{
    int surf1   = m_config["surf1"].as<int>();
    int surf2   = m_config["surf2"].as<int>();
    string dir  = m_config["dir"].as<string>();
    string rot  = m_config["rot"].as<string>();
    bool orient = m_config["orient"].as<bool>();
    string tolerance = m_config["tol"].as<string>();
    
    if (surf1 == -1)
    {
        cerr << "WARNING: surf1 must be set to a positive integer. "
             << "Skipping periodic alignment." << endl;
        return;
    }

    if (surf2 == -1)
    {
        cerr << "WARNING: surf2 must be set to a positive integer. "
             << "Skipping periodic alignment." << endl;
        return;
    }

    vector<string> tmp1;
    boost::split(tmp1, dir, boost::is_any_of(","));

    vector<string> tmp2;
    boost::split(tmp2, rot, boost::is_any_of(","));
    bool rotalign = false;

    NekDouble vec[3] = {0.0, 0.0, 0.0};
    NekDouble rotangle = 0.0;

    if (tmp2[0] != "")
    {
        // set up for syntax -m peralign:dir=“x":rot="PI/11":surf1=3:surf2=4:tol=1e-6 
        rotalign = true;
        // Evaluate expression since may be give as function of PI
        LibUtilities::Interpreter strEval;
        int ExprId = strEval.DefineFunction(" ", tmp2[0]);
        rotangle = strEval.Evaluate(ExprId);

        // negate angle since we want to rotate second composite back
        // to this one.
        rotangle *= -1.0; 
        
        ASSERTL0(tmp1.size() == 1,"rot must also be accompanied "
                 "with a dir=\"x\",dir=\"y\" or dir=\"z\" option "
                 "to specify axes of rotation");
    }
    else if (tmp1.size() == 1)
    {
        //if the direction is not specified and its a 2D mesh and there is CAD
        //it can figure out the dir on its own
        if (!dir.size() && m_mesh->m_spaceDim == 2 && m_mesh->m_cad)
        {
            Array<OneD, NekDouble> T =
                m_mesh->m_cad->GetPeriodicTranslationVector(surf1, surf2);
            NekDouble mag = sqrt(T[0] * T[0] + T[1] * T[1]);

            vec[0] = T[0] / mag;
            vec[1] = T[1] / mag;
            vec[2] = T[2] / mag;
        }
        else
        {
            if (dir != "x" && dir != "y" && dir != "z")
            {
                cerr << "WARNING: dir must be set to either x, y or z. "
                    << "Skipping periodic alignment." << endl;
                return;
            }

            vec[0] = (dir == "x") ? 1.0 : 0.0;
            vec[1] = (dir == "y") ? 1.0 : 0.0;
            vec[2] = (dir == "z") ? 1.0 : 0.0;
        }
    }
    else if (tmp1.size() == 3)
    {
        vec[0] = boost::lexical_cast<NekDouble>(tmp1[0]);
        vec[1] = boost::lexical_cast<NekDouble>(tmp1[1]);
        vec[2] = boost::lexical_cast<NekDouble>(tmp1[2]);
    }
    else
    {
        ASSERTL0(false,"expected three components or letter for direction");
    }

    auto it1 = m_mesh->m_composite.find(surf1);
    auto it2 = m_mesh->m_composite.find(surf2);

    if (it1 == m_mesh->m_composite.end())
    {
        cerr << "WARNING: Couldn't find surface " << surf1
             << ". Skipping periodic alignment." << endl;
        return;
    }

    if (it2 == m_mesh->m_composite.end())
    {
        cerr << "WARNING: Couldn't find surface " << surf2 << ", "
             << "skipping periodic alignment." << endl;
        return;
    }

    CompositeSharedPtr c1 = it1->second;
    CompositeSharedPtr c2 = it2->second;

    if (c1->m_items.size() != c2->m_items.size())
    {
        cerr << "WARNING: Surfaces " << surf1 << " and " << surf2
             << " have different numbers of elements. Skipping periodic"
             << " alignment." << endl;
        return;
    }

    c1->m_reorder = false;
    c2->m_reorder = false;

    map<int, pair<FaceSharedPtr, vector<int> > > perFaces;

    // Loop over elements, calculate centroids of elements in c2.
    map<int, Node> centroidMap;
    for (int i = 0; i < c2->m_items.size(); ++i)
    {
        Node centroid;
        for (int j = 0; j < c2->m_items[i]->GetVertexCount(); ++j)
        {
            centroid += *(c2->m_items[i]->GetVertex(j));
        }
        centroid /= (NekDouble)c2->m_items[i]->GetVertexCount();


        if(rotalign) // rotate centroid 
        {
            centroid.Rotate(dir,rotangle);
        }

        centroidMap[i] = centroid;
    }

    std::unordered_set<int> elmtDone;
    map<int, int> elmtPairs;
    map<int, int> vertCheck;

    for (int i = 0; i < c1->m_items.size(); ++i)
    {
        Node centroid;
        for (int j = 0; j < c1->m_items[i]->GetVertexCount(); ++j)
        {
            centroid += *(c1->m_items[i]->GetVertex(j));
        }
        centroid /= (NekDouble)c1->m_items[i]->GetVertexCount();

        bool found = false;
        NekDouble tol = boost::lexical_cast<NekDouble>(tolerance);
        for (auto &it : centroidMap)
        {
            if (elmtDone.count(it.first) > 0)
            {
                continue;
            }

            Node dx = it.second - centroid;
            bool match;
            if(rotalign)
            {
                match = (sqrt(dx.abs2())< tol);
            }
            else
            {
                match = (fabs(fabs(dx.m_x * vec[0] + dx.m_y * vec[1] +
                                   dx.m_z * vec[2]) /
                              sqrt(dx.abs2()) - 1.0) < tol);
            }

            if(match)
            {
                // Found match
                int id1, id2;

                if (c1->m_items[i]->GetConf().m_e == LibUtilities::eSegment)
                {
                    id1 = c1->m_items[i]->GetEdgeLink()->m_id;
                    id2 = c2->m_items[it.first]->GetEdgeLink()->m_id;
                }
                else
                {
                    id1 = c1->m_items[i]->GetFaceLink()->m_id;
                    id2 = c2->m_items[it.first]->GetFaceLink()->m_id;
                }

                elmtDone.insert(it.first);
                elmtPairs[i] = it.first;

                // Identify periodic vertices
                int nVerts = c1->m_items[i]->GetVertexCount();
                vector<int> perVerts(nVerts, 0), perVertsInv(nVerts, 0);

                if (orient)
                {
                    for (int k = 0; k < nVerts; ++k)
                    {
                        NodeSharedPtr n1 =
                            c1->m_items[i]->GetFaceLink()->m_vertexList[k];
                        int l;
                        NekDouble mindn = 1000; 

                        for (l = 0; l < nVerts; ++l)
                        {
                            NodeSharedPtr n2 = c2->m_items[it.first]
                                                   ->GetFaceLink()
                                                   ->m_vertexList[l];

                            if(rotalign) // rotate n2 
                            {
                                Node n2tmp = *n2; 
                                n2tmp.Rotate(dir,rotangle);
                                Node dn = n2tmp - *n1;
                                NekDouble dnabs = sqrt(dn.abs2());
                                match = (dnabs< tol);
                                mindn  = (dnabs < mindn)? dnabs:mindn; 
                            }
                            else
                            {
                                Node dn = *n2 - *n1;
                                
                                NekDouble dnabs = fabs(fabs(dn.m_x * vec[0] +
                                                       dn.m_y * vec[1] +
                                                       dn.m_z * vec[2]) /
                                                       sqrt(dn.abs2()) - 1.0); 
                                match = (dnabs < tol); 
                                mindn  = (dnabs < mindn)? dnabs:mindn;                                 
                            }

                            if(match)
                            {
                                perVerts[k]    = l;
                                perVertsInv[l] = k;

                                int id1 = n1->m_id;
                                int id2 = n2->m_id;
                                if (vertCheck.count(id1) == 0)
                                {
                                    vertCheck[id1] = id2;
                                }
                                else
                                {
                                    ASSERTL0(vertCheck[id1] == id2,
                                             "Periodic vertex already "
                                             "identified!");
                                }
                                break;
                            }
                        }
                        ASSERTL1(l < nVerts,
                                 "Could not identify periodic vertices, nearest distance was " + boost::lexical_cast<string>(mindn));
                    }

                    int tot1 = 0, tot2 = 0;
                    for (int k = 0; k < nVerts; ++k)
                    {
                        tot1 += perVerts[k];
                        tot2 += perVertsInv[k];
                    }
                    ASSERTL0(tot1 == nVerts * (nVerts - 1) / 2 &&
                                 tot2 == nVerts * (nVerts - 1) / 2,
                             "Error identifying periodic vertices");
                }

                if (c2->m_items[i]->GetConf().m_e != LibUtilities::eSegment)
                {
                    perFaces[id1] = make_pair(
                        c2->m_items[it.first]->GetFaceLink(), perVerts);
                    perFaces[id2] =
                        make_pair(c1->m_items[i]->GetFaceLink(), perVertsInv);
                }
                found = true;
                break;
            }
        }

        if (!found)
        {
            cerr << "WARNING: Could not find matching edge for surface "
                 << "element " << c1->m_items[i]->GetId() << ". "
                 << "Skipping periodic alignment." << endl;
            return;
        }
    }

    // Reorder vectors.
    vector<ElementSharedPtr> tmp = c2->m_items;

    for (int i = 0; i < tmp.size(); ++i)
    {
        c2->m_items[i] = tmp[elmtPairs[i]];
    }

    if (orient)
    {
        ReorderPrisms(perFaces);
    }
}

Member Data Documentation

className

ModuleKey Nektar::Utilities::ProcessPerAlign::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "peralign"), ProcessPerAlign::create)

Definition at line 53 of file ProcessPerAlign.h.