Nektar::Utilities::InputTec Class Reference

Converter for VTK files. More...

#include <InputStarTec.h>

Inheritance diagram for Nektar::Utilities::InputTec:

Collaboration diagram for Nektar::Utilities::InputTec:

Public Member Functions
	InputTec (MeshSharedPtr m)
virtual	~InputTec ()
virtual void	Process ()
	Populate and validate required data structures. More...
void	ReadZone (int &nComposite)
Public Member Functions inherited from Nektar::Utilities::InputModule
	InputModule (FieldSharedPtr p_m)
void	AddFile (string fileType, string fileName)
	InputModule (MeshSharedPtr p_m)
void	OpenStream ()
	Open a file for input. More...
Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)
virtual void	Process (po::variables_map &vm)=0
virtual std::string	GetModuleName ()=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 ModuleSharedPtr	create (MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	className

Protected Member Functions
void	GenElement3D (std::vector< NodeSharedPtr > &Nodes, int i, std::vector< int > &ElementFaces, std::vector< std::vector< int > > &FaceNodes, int ncomposite, bool DoOrient)
void	GenElement2D (std::vector< NodeSharedPtr > &Nodes, int i, std::vector< int > &ElementFaces, std::vector< std::vector< int > > &FaceNodes, int ncomposite)
Array< OneD, int >	SortEdgeNodes (std::vector< NodeSharedPtr > &Nodes, std::vector< int > &ElementFaces, std::vector< std::vector< int > > &FaceNodes)
Array< OneD, int >	SortFaceNodes (std::vector< NodeSharedPtr > &Nodes, std::vector< int > &ElementFaces, std::vector< std::vector< int > > &FaceNodes)
void	ResetNodes (std::vector< NodeSharedPtr > &Nodes, Array< OneD, std::vector< int > > &ElementFaces, std::vector< std::vector< int > > &FaceNodes)
Protected Member Functions inherited from Nektar::Utilities::InputModule
void	PrintSummary ()
	Print summary of elements. More...
void	PrintSummary ()
	Print summary of elements. More...
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)

Additional Inherited Members
Protected Attributes inherited from Nektar::Utilities::InputModule
set< string >	m_allowedFiles
std::ifstream	m_mshFile
	Input stream. More...
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

Converter for VTK files.

Definition at line 46 of file InputStarTec.h.

Constructor & Destructor Documentation

Nektar::Utilities::InputTec::InputTec

(

MeshSharedPtr

m

)

Definition at line 56 of file InputStarTec.cpp.

                                  : InputModule(m)
{
}

Nektar::Utilities::InputTec::~InputTec ( )

virtual

Definition at line 60 of file InputStarTec.cpp.

{
}

Member Function Documentation

static ModuleSharedPtr Nektar::Utilities::InputTec::create ( MeshSharedPtr  m )

inlinestatic

Creates an instance of this class.

Definition at line 50 of file InputStarTec.h.

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

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

void Nektar::Utilities::InputTec::GenElement2D ( std::vector< NodeSharedPtr > &  Nodes, int  i, std::vector< int > &  ElementFaces, std::vector< std::vector< int > > &  FaceNodes, int  ncomposite  )

protected

Definition at line 673 of file InputStarTec.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTriangle, Nektar::NekMeshUtils::GetElementFactory(), Nektar::Utilities::Module::m_mesh, and SortEdgeNodes().

Referenced by ReadZone().

{
    LibUtilities::ShapeType elType;
    // set up Node list

    if (ElementFaces.size() == 3)
    {
        elType = LibUtilities::eTriangle;
    }
    else if (ElementFaces.size() == 4)
    {
        elType = LibUtilities::eQuadrilateral;
    }
    else
    {
        ASSERTL0(false, "Not set up for elements which are not Tets or Prism");
    }

    // Create element tags
    vector<int> tags;
    tags.push_back(nComposite);

    // make unique node list
    vector<NodeSharedPtr> nodeList;
    Array<OneD, int> Nodes = SortEdgeNodes(VertNodes, ElementFaces, FaceNodes);
    for (int j = 0; j < Nodes.num_elements(); ++j)
    {
        nodeList.push_back(VertNodes[Nodes[j]]);
    }

    // Create element
    ElmtConfig conf(elType, 1, true, true);
    ElementSharedPtr E =
        GetElementFactory().CreateInstance(elType, conf, nodeList, tags);

    m_mesh->m_element[E->GetDim()].push_back(E);
}

void Nektar::Utilities::InputTec::GenElement3D ( std::vector< NodeSharedPtr > &  Nodes, int  i, std::vector< int > &  ElementFaces, std::vector< std::vector< int > > &  FaceNodes, int  ncomposite, bool  DoOrient  )

protected

Definition at line 715 of file InputStarTec.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::ePrism, Nektar::LibUtilities::ePyramid, Nektar::LibUtilities::eTetrahedron, Nektar::NekMeshUtils::GetElementFactory(), Nektar::Utilities::Module::m_mesh, and SortFaceNodes().

Referenced by ReadZone().

{
    LibUtilities::ShapeType elType;
    // set up Node list
    Array<OneD, int> Nodes = SortFaceNodes(VertNodes, ElementFaces, FaceNodes);
    int nnodes             = Nodes.num_elements();
    map<LibUtilities::ShapeType, int> domainComposite;

    // Set Nodes  -- Not sure we need this so could
    // m_mesh->m_node = VertNodes;

    // element type
    if (nnodes == 4)
    {
        elType = LibUtilities::eTetrahedron;
    }
    else if (nnodes == 5)
    {
        elType = LibUtilities::ePyramid;
    }
    else if (nnodes == 6)
    {
        elType = LibUtilities::ePrism;
    }
    else
    {

        ASSERTL0(false, "Not set up for elements which are not Tets or Prism");
    }

    // Create element tags
    vector<int> tags;
    tags.push_back(nComposite);

    // make unique node list
    vector<NodeSharedPtr> nodeList;
    for (int j = 0; j < Nodes.num_elements(); ++j)
    {
        nodeList.push_back(VertNodes[Nodes[j]]);
    }

    // Create element
    if (elType != LibUtilities::ePyramid)
    {
        ElmtConfig conf(elType, 1, true, true, DoOrient);
        ElementSharedPtr E =
            GetElementFactory().CreateInstance(elType, conf, nodeList, tags);

        m_mesh->m_element[E->GetDim()].push_back(E);
    }
    else
    {
        cout << "Warning: Pyramid detected " << endl;
    }
}

void Nektar::Utilities::InputTec::Process ( )

virtual

Populate and validate required data structures.

Tecplot file Polyhedron format contains a list of nodes, a node count per face, the node ids, Element ids that are on the left of each face and Element ids which are on the right of each face. There are then a series of zone of each surface. In the case of a surface the number of nodes is not provided indicating it is a 2D zone

Parameters

pFilename

Filename of Tecplot file to read.

Implements Nektar::Utilities::Module.

Definition at line 74 of file InputStarTec.cpp.

References Nektar::Utilities::Module::m_mesh, Nektar::Utilities::InputModule::m_mshFile, Nektar::Utilities::InputModule::OpenStream(), Nektar::Utilities::InputModule::PrintSummary(), Nektar::Utilities::Module::ProcessComposites(), Nektar::Utilities::Module::ProcessEdges(), Nektar::Utilities::Module::ProcessElements(), Nektar::Utilities::Module::ProcessFaces(), and ReadZone().

{
    m_mesh->m_expDim   = 3;
    m_mesh->m_spaceDim = 3;

    if (m_mesh->m_verbose)
    {
        cout << "InputStarTec: Start reading file..." << endl;
    }

    string line, word;

    // Open the file stream.
    OpenStream();

    int nComposite = 0;

    // read first zone (Hopefully 3D)
    while (!m_mshFile.eof())
    {
        getline(m_mshFile, line);
        if (line.find("ZONE") != string::npos)
        {
            ReadZone(nComposite);
            break;
        }
    }

    // read remaining 2D zones
    while (!m_mshFile.eof())
    {
        if (line.find("ZONE") != string::npos)
        {
            ReadZone(nComposite);
        }
    }

    PrintSummary();
    m_mshFile.close();

    ProcessEdges();
    ProcessFaces();
    ProcessElements();
    ProcessComposites();
}

void Nektar::Utilities::InputTec::ReadZone

(

int &

nComposite

)

Definition at line 120 of file InputStarTec.cpp.

References ASSERTL0, GenElement2D(), GenElement3D(), Nektar::iterator, Nektar::Utilities::Module::m_mesh, Nektar::Utilities::InputModule::m_mshFile, Nektar::Utilities::Module::ProcessVertices(), and ResetNodes().

Referenced by Process().

{
    int i;
    string line, tag;
    int nfaces, nnodes, nelements;
    int start, end;
    stringstream s;
    NekDouble value;
    streampos pos;
    static int zcnt = 1;

    // Read Zone Header
    nnodes = nfaces = nelements = 0;
    while (!m_mshFile.eof())
    {
        pos = m_mshFile.tellg();

        getline(m_mshFile, line);

        boost::to_upper(line);

        // cehck to see if readable data.
        if (sscanf(line.c_str(), "%lf", &value) == 1)
        {
            m_mshFile.seekg(pos);
            break;
        }

        if ((line.find("NODES") != string::npos) &&
            (line.find("TOTALNUMFACENODES") == string::npos))
        {
            s.clear();
            s.str(line);

            tag    = s.str();
            start  = tag.find("NODES=");
            end    = tag.find_first_of(',', start);
            nnodes = atoi(tag.substr(start + 6, end).c_str());
        }

        if ((line.find("FACES") != string::npos) &&
            (line.find("NUMCONNECTEDBOUNDARYFACES") == string::npos))
        {
            s.clear();
            s.str(line);

            tag    = s.str();
            start  = tag.find("FACES=");
            end    = tag.find_first_of(',', start);
            nfaces = atoi(tag.substr(start + 6, end).c_str());
        }

        if (line.find("ELEMENTS") != string::npos)
        {
            s.clear();
            s.str(line);

            tag       = s.str();
            start     = tag.find("ELEMENTS=");
            end       = tag.find_first_of(',', start);
            nelements = atoi(tag.substr(start + 9, end).c_str());
        }

        if (line.find("ZONETYPE") != string::npos)
        {
            s.clear();
            s.str(line);

            if ((line.find("FEPOLYGON") == string::npos) &&
                (line.find("FEPOLYHEDRON") == string::npos))
            {
                ASSERTL0(false,
                         "Routine only set up for FEPolygon or FEPolyhedron");
            }
        }
    }
    if (!nnodes) // No zone found
    {
        return;
    }

    cout << "Setting up zone " << zcnt++;

    vector<NekDouble> x, y, z;

    // Read in Nodes
    for (i = 0; i < nnodes; ++i)
    {
        m_mshFile >> value;
        x.push_back(value);
    }

    for (i = 0; i < nnodes; ++i)
    {
        m_mshFile >> value;
        y.push_back(value);
    }

    for (i = 0; i < nnodes; ++i)
    {
        m_mshFile >> value;
        z.push_back(value);
    }

    std::vector<NodeSharedPtr> Nodes;
    for (i = 0; i < nnodes; ++i)
    {
        Nodes.push_back(boost::shared_ptr<Node>(new Node(i, x[i], y[i], z[i])));
    }

    // Read Node count per face
    getline(m_mshFile, line);
    if (line.find("node count per face") == string::npos)
    {
        if (line.find("face nodes") == string::npos)
        {
            getline(m_mshFile, line);
        }
    }

    s.clear();
    s.str(line);

    vector<int> Nodes_per_face;
    if (line.find("node count per face") != string::npos)
    {
        int nodes;
        for (i = 0; i < nfaces; ++i)
        {
            m_mshFile >> nodes;
            ASSERTL0(nodes <= 4,
                     "Can only handle meshes with "
                     "up to four nodes per face");
            Nodes_per_face.push_back(nodes);
        }
        // Read next line
        getline(m_mshFile, line);
    }

    // Read face nodes;
    if (line.find("face nodes") == string::npos)
    {
        getline(m_mshFile, line);
    }
    s.clear();
    s.str(line);

    vector<vector<int> > FaceNodes;

    if (line.find("face nodes") != string::npos)
    {

        for (i = 0; i < nfaces; ++i)
        {
            // check to see if Nodes_per_face is defined and
            // if not assume 2 nodes for 2D case
            int nodes = (Nodes_per_face.size()) ? Nodes_per_face[i] : 2;

            int nodeID;
            vector<int> Fnodes;
            for (int j = 0; j < nodes; ++j)
            {

                m_mshFile >> nodeID;

                Fnodes.push_back(nodeID - 1);
            }

            FaceNodes.push_back(Fnodes);
        }
    }
    else
    {
        ASSERTL0(false, "Failed to find face node section");
    }

    // Read left elements
    Array<OneD, vector<int> > ElementFaces(nelements);

    // check to see if next line contains left elements
    getline(m_mshFile, line);
    if (line.find("left elements") == string::npos)
    {
        getline(m_mshFile, line);
    }

    if (line.find("left elements") != string::npos)
    {
        int elmtID;

        for (i = 0; i < nfaces; ++i)
        {
            m_mshFile >> elmtID;

            if (elmtID > 0)
            {
                ElementFaces[elmtID - 1].push_back(i);
            }
        }
    }
    else
    {
        ASSERTL0(false, "Left element not found");
    }

    // check to see if next line contains right elements
    getline(m_mshFile, line);
    if (line.find("right elements") == string::npos)
    {
        getline(m_mshFile, line);
    }

    if (line.find("right elements") != string::npos)

    {
        int elmtID;

        for (i = 0; i < nfaces; ++i)
        {
            m_mshFile >> elmtID;

            if (elmtID > 0)
            {
                ElementFaces[elmtID - 1].push_back(i);
            }
        }

        // read to end of line
        getline(m_mshFile, line);
    }
    else
    {
        ASSERTL0(false, "Left element not found");
    }

    if (Nodes_per_face.size()) // 3D Zone
    {
        cout << " (3D) " << endl;

        // Reset node ordering so that all prism faces have
        // consistent numbering for singular vertex re-ordering
        ResetNodes(Nodes, ElementFaces, FaceNodes);

        m_mesh->m_node = Nodes;

        // create Prisms/Pyramids first
        for (i = 0; i < nelements; ++i)
        {
            if (ElementFaces[i].size() > 4)
            {
                GenElement3D(
                    Nodes, i, ElementFaces[i], FaceNodes, nComposite, true);
            }
        }

        nComposite++;

        // create Tets second
        for (i = 0; i < nelements; ++i)
        {
            if (ElementFaces[i].size() == 4)
            {
                GenElement3D(
                    Nodes, i, ElementFaces[i], FaceNodes, nComposite, true);
            }
        }
        nComposite++;

        ProcessVertices();
    }
    else // 2D Zone
    {
        cout << " (2D)" << endl;

        // find ids of VertNodes from m_mesh->m_vertexSet so that we can
        // identify
        for (i = 0; i < Nodes.size(); ++i)
        {
            NodeSet::iterator it = m_mesh->m_vertexSet.find(Nodes[i]);

            if (it == m_mesh->m_vertexSet.end())
            {
                ASSERTL0(false, "Failed to find face vertex in 3D list");
            }
            else
            {
                Nodes[i] = *it;
            }
        }

        for (i = 0; i < nelements; ++i)
        {
            GenElement2D(Nodes, i, ElementFaces[i], FaceNodes, nComposite);
        }

        nComposite++;
    }
}

void Nektar::Utilities::InputTec::ResetNodes ( std::vector< NodeSharedPtr > &  Nodes, Array< OneD, std::vector< int > > &  ElementFaces, std::vector< std::vector< int > > &  FaceNodes  )

protected

Definition at line 425 of file InputStarTec.cpp.

References ASSERTL1, Nektar::iterator, Nektar::Utilities::PrismLineFaces(), and SortFaceNodes().

Referenced by ReadZone().

{
    int i, j;
    Array<OneD, int> NodeReordering(Vnodes.size(), -1);
    int face1_map[3] = {0, 1, 4};
    int face3_map[3] = {3, 2, 5};
    int nodeid       = 0;
    map<int, bool> FacesRenumbered;

    // Determine Prism triangular face connectivity.
    vector<vector<int> > FaceToPrisms(FaceNodes.size());
    vector<vector<int> > PrismToFaces(ElementFaces.num_elements());
    map<int, int> Prisms;
    map<int, int>::iterator PrismIt;

    // generate map of prism-faces to prisms and prism to
    // triangular-faces as well as ids of each prism.
    for (i = 0; i < ElementFaces.num_elements(); ++i)
    {
        // Find Prism (and pyramids!).
        if (ElementFaces[i].size() == 5)
        {
            vector<int> LocTriFaces;
            // Find triangular faces
            for (j = 0; j < ElementFaces[i].size(); ++j)
            {
                if (FaceNodes[ElementFaces[i][j]].size() == 3)
                {
                    LocTriFaces.push_back(j);
                }
            }

            if (LocTriFaces.size() == 2) // prism otherwise a pyramid
            {
                Prisms[i] = i;

                PrismToFaces[i].push_back(ElementFaces[i][LocTriFaces[0]]);
                PrismToFaces[i].push_back(ElementFaces[i][LocTriFaces[1]]);

                FaceToPrisms[ElementFaces[i][LocTriFaces[0]]].push_back(i);
                FaceToPrisms[ElementFaces[i][LocTriFaces[1]]].push_back(i);
            }
        }
    }

    vector<bool> FacesDone(FaceNodes.size(), false);
    vector<bool> PrismDone(ElementFaces.num_elements(), false);

    // For every prism find the list of prismatic elements
    // that represent an aligned block of cells. Then renumber
    // these blocks consecutativiesly
    for (PrismIt = Prisms.begin(); PrismIt != Prisms.end(); ++PrismIt)
    {
        int elmtid = PrismIt->first;
        map<int, int> facelist;
        map<int, int>::iterator faceIt;

        if (PrismDone[elmtid])
        {
            continue;
        }
        else
        {
            // Generate list of faces in list
            PrismLineFaces(
                elmtid, facelist, FaceToPrisms, PrismToFaces, PrismDone);

            // loop over faces and number vertices of associated prisms.
            for (faceIt = facelist.begin(); faceIt != facelist.end(); faceIt++)
            {
                int faceid = faceIt->second;

                for (i = 0; i < FaceToPrisms[faceid].size(); ++i)
                {
                    int prismid = FaceToPrisms[faceid][i];

                    if ((FacesDone[PrismToFaces[prismid][0]] == true) &&
                        (FacesDone[PrismToFaces[prismid][1]] == true))
                    {
                        continue;
                    }

                    Array<OneD, int> Nodes =
                        SortFaceNodes(Vnodes, ElementFaces[prismid], FaceNodes);

                    if ((FacesDone[PrismToFaces[prismid][0]] == false) &&
                        (FacesDone[PrismToFaces[prismid][1]] == false))
                    {
                        // number all nodes consecutive since
                        // already correctly re-arranged.
                        for (i = 0; i < 3; ++i)
                        {
                            if (NodeReordering[Nodes[face1_map[i]]] == -1)
                            {
                                NodeReordering[Nodes[face1_map[i]]] = nodeid++;
                            }
                        }

                        for (i = 0; i < 3; ++i)
                        {
                            if (NodeReordering[Nodes[face3_map[i]]] == -1)
                            {
                                NodeReordering[Nodes[face3_map[i]]] = nodeid++;
                            }
                        }
                    }
                    else if ((FacesDone[PrismToFaces[prismid][0]] == false) &&
                             (FacesDone[PrismToFaces[prismid][1]] == true))
                    {
                        // find node of highest id
                        int max_id1, max_id2;

                        max_id1 = (NodeReordering[Nodes[face3_map[0]]] <
                                   NodeReordering[Nodes[face3_map[1]]])
                                      ? 1
                                      : 0;
                        max_id2 = (NodeReordering[Nodes[face3_map[max_id1]]] <
                                   NodeReordering[Nodes[face3_map[2]]])
                                      ? 2
                                      : max_id1;

                        // add numbering according to order of
                        int id0 = (max_id1 == 1) ? 0 : 1;

                        if (NodeReordering[Nodes[face1_map[id0]]] == -1)
                        {
                            NodeReordering[Nodes[face1_map[id0]]] = nodeid++;
                        }

                        if (NodeReordering[Nodes[face1_map[max_id1]]] == -1)
                        {
                            NodeReordering[Nodes[face1_map[max_id1]]] =
                                nodeid++;
                        }

                        if (NodeReordering[Nodes[face1_map[max_id2]]] == -1)
                        {
                            NodeReordering[Nodes[face1_map[max_id2]]] =
                                nodeid++;
                        }
                    }
                    else if ((FacesDone[PrismToFaces[prismid][0]] == true) &&
                             (FacesDone[PrismToFaces[prismid][1]] == false))
                    {
                        // find node of highest id
                        int max_id1, max_id2;

                        max_id1 = (NodeReordering[Nodes[face1_map[0]]] <
                                   NodeReordering[Nodes[face1_map[1]]])
                                      ? 1
                                      : 0;
                        max_id2 = (NodeReordering[Nodes[face1_map[max_id1]]] <
                                   NodeReordering[Nodes[face1_map[2]]])
                                      ? 2
                                      : max_id1;

                        // add numbering according to order of
                        int id0 = (max_id1 == 1) ? 0 : 1;

                        if (NodeReordering[Nodes[face3_map[id0]]] == -1)
                        {
                            NodeReordering[Nodes[face3_map[id0]]] = nodeid++;
                        }

                        if (NodeReordering[Nodes[face3_map[max_id1]]] == -1)
                        {
                            NodeReordering[Nodes[face3_map[max_id1]]] =
                                nodeid++;
                        }

                        if (NodeReordering[Nodes[face3_map[max_id2]]] == -1)
                        {
                            NodeReordering[Nodes[face3_map[max_id2]]] =
                                nodeid++;
                        }
                    }
                }
            }
        }
    }

    // fill in any unset nodes at from other shapes
    for (i = 0; i < NodeReordering.num_elements(); ++i)
    {
        if (NodeReordering[i] == -1)
        {
            NodeReordering[i] = nodeid++;
        }
    }

    ASSERTL1(nodeid == NodeReordering.num_elements(),
             "Have not renumbered all nodes");

    // Renumbering successfull so resort nodes and faceNodes;
    for (i = 0; i < FaceNodes.size(); ++i)
    {
        for (j = 0; j < FaceNodes[i].size(); ++j)
        {
            FaceNodes[i][j] = NodeReordering[FaceNodes[i][j]];
        }
    }

    vector<NodeSharedPtr> save(Vnodes);
    for (i = 0; i < Vnodes.size(); ++i)
    {
        Vnodes[NodeReordering[i]] = save[i];
        Vnodes[NodeReordering[i]]->SetID(NodeReordering[i]);
    }
}

Array< OneD, int > Nektar::Utilities::InputTec::SortEdgeNodes ( std::vector< NodeSharedPtr > &  Nodes, std::vector< int > &  ElementFaces, std::vector< std::vector< int > > &  FaceNodes  )

protected

Definition at line 776 of file InputStarTec.cpp.

References ASSERTL1, Nektar::NekMeshUtils::Node::curl(), and Nektar::NekMeshUtils::Node::dot().

Referenced by GenElement2D().

{
    int i, j;
    Array<OneD, int> returnval;

    if (ElementFaces.size() == 3) // Triangle
    {
        returnval = Array<OneD, int>(3);

        returnval[0] = FaceNodes[ElementFaces[0]][0];
        returnval[1] = FaceNodes[ElementFaces[0]][1];

        // Find third node index;
        for (i = 0; i < 2; ++i)
        {
            if ((FaceNodes[ElementFaces[1]][i] != returnval[0]) &&
                (FaceNodes[ElementFaces[1]][i] != returnval[1]))
            {
                returnval[2] = FaceNodes[ElementFaces[1]][i];
                break;
            }
        }
    }
    else if (ElementFaces.size() == 4) // quadrilateral
    {
        returnval = Array<OneD, int>(4);

        int indx0 = FaceNodes[ElementFaces[0]][0];
        int indx1 = FaceNodes[ElementFaces[0]][1];
        int indx2, indx3;

        indx2 = indx3 = -1;
        // Find third, fourth node index;
        for (j = 1; j < 4; ++j)
        {
            for (i = 0; i < 2; ++i)
            {
                if ((FaceNodes[ElementFaces[j]][i] != indx0) &&
                    (FaceNodes[ElementFaces[j]][i] != indx1))
                {
                    if (indx2 == -1)
                    {
                        indx2 = FaceNodes[ElementFaces[j]][i];
                    }
                    else if (indx2 != -1)
                    {
                        if (FaceNodes[ElementFaces[j]][i] != indx2)
                        {
                            indx3 = FaceNodes[ElementFaces[j]][i];
                        }
                    }
                }
            }
        }

        ASSERTL1((indx2 != -1) && (indx3 != -1),
                 "Failed to find vertex 3 or 4");

        // calculate 0-1,
        Node a = *(Vnodes[indx1]) - *(Vnodes[indx0]);
        // calculate 0-2,
        Node b      = *(Vnodes[indx2]) - *(Vnodes[indx0]);
        Node acurlb = a.curl(b);

        // calculate 2-1,
        Node c = *(Vnodes[indx1]) - *(Vnodes[indx2]);
        // calculate 3-2,
        Node d      = *(Vnodes[indx3]) - *(Vnodes[indx2]);
        Node acurld = a.curl(d);

        NekDouble acurlb_dot_acurld = acurlb.dot(acurld);
        if (acurlb_dot_acurld > 0.0)
        {
            returnval[0] = indx0;
            returnval[1] = indx1;
            returnval[2] = indx2;
            returnval[3] = indx3;
        }
        else
        {
            returnval[0] = indx0;
            returnval[1] = indx1;
            returnval[2] = indx3;
            returnval[3] = indx2;
        }
    }

    return returnval;
}

Array< OneD, int > Nektar::Utilities::InputTec::SortFaceNodes ( std::vector< NodeSharedPtr > &  Nodes, std::vector< int > &  ElementFaces, std::vector< std::vector< int > > &  FaceNodes  )

protected

Definition at line 868 of file InputStarTec.cpp.

References ASSERTL0, ASSERTL1, Nektar::NekMeshUtils::Node::curl(), and Nektar::NekMeshUtils::Node::dot().

Referenced by GenElement3D(), and ResetNodes().

{

    int i, j;
    Array<OneD, int> returnval;

    if (ElementFaces.size() == 4) // Tetrahedron
    {
        ASSERTL1(FaceNodes[ElementFaces[0]].size() == 3,
                 "Face is not triangular");

        returnval = Array<OneD, int>(4);

        int indx0 = FaceNodes[ElementFaces[0]][0];
        int indx1 = FaceNodes[ElementFaces[0]][1];
        int indx2 = FaceNodes[ElementFaces[0]][2];
        int indx3 = -1;

        // calculate 0-1,
        Node a = *(Vnodes[indx1]) - *(Vnodes[indx0]);
        // calculate 0-2,
        Node b = *(Vnodes[indx2]) - *(Vnodes[indx0]);

        // Find fourth node index;
        ASSERTL1(FaceNodes[ElementFaces[1]].size() == 3,
                 "Face is not triangular");
        for (i = 0; i < 3; ++i)
        {

            if ((FaceNodes[ElementFaces[1]][i] != indx0) &&
                (FaceNodes[ElementFaces[1]][i] != indx1) &&
                (FaceNodes[ElementFaces[1]][i] != indx2))
            {
                indx3 = FaceNodes[ElementFaces[1]][i];
                break;
            }
        }

        // calculate 0-3,
        Node c      = *(Vnodes[indx3]) - *(Vnodes[indx0]);
        Node acurlb = a.curl(b);

        NekDouble acurlb_dotc = acurlb.dot(c);
        if (acurlb_dotc < 0.0)
        {
            returnval[0] = indx0;
            returnval[1] = indx1;
            returnval[2] = indx2;
            returnval[3] = indx3;
        }
        else
        {
            returnval[0] = indx1;
            returnval[1] = indx0;
            returnval[2] = indx2;
            returnval[3] = indx3;
        }
    }
    else if (ElementFaces.size() == 5) // prism or pyramid
    {
        int triface0, triface1;
        int quadface0, quadface1, quadface2;
        bool isPrism = true;

        // find ids of tri faces and first quad face
        triface0 = triface1 = -1;
        quadface0 = quadface1 = quadface2 = -1;
        for (i = 0; i < 5; ++i)
        {
            if (FaceNodes[ElementFaces[i]].size() == 3)
            {
                if (triface0 == -1)
                {
                    triface0 = i;
                }
                else if (triface1 == -1)
                {
                    triface1 = i;
                }
                else
                {
                    isPrism = false;
                }
            }

            if (FaceNodes[ElementFaces[i]].size() == 4)
            {
                if (quadface0 == -1)
                {
                    quadface0 = i;
                }
                else if (quadface1 == -1)
                {
                    quadface1 = i;
                }
                else if (quadface2 == -1)
                {
                    quadface2 = i;
                }
            }
        }

        if (isPrism) // Prism
        {
            returnval = Array<OneD, int>(6);
        }
        else // Pyramid
        {
            returnval = Array<OneD, int>(5);
        }

        // find matching nodes between triface0 and triquad0
        int indx0, indx1, indx2, indx3, indx4;

        indx0 = indx1 = indx2 = indx3 = indx4 = -1;
        // Loop over all quad nodes and if they match any
        // triangular nodes If they do set these to indx0 and
        // indx1 and if not set it to indx2, indx3

        for (i = 0; i < 4; ++i)
        {
            for (j = 0; j < 3; ++j)
            {
                if (FaceNodes[ElementFaces[triface0]][j] ==
                    FaceNodes[ElementFaces[quadface0]][i])
                {
                    break; // same node break
                }
            }

            if (j == 3) // Vertex not in quad face
            {
                if (indx2 == -1)
                {
                    indx2 = FaceNodes[ElementFaces[quadface0]][i];
                }
                else if (indx3 == -1)
                {
                    indx3 = FaceNodes[ElementFaces[quadface0]][i];
                }
                else
                {
                    ASSERTL0(
                        false,
                        "More than two vertices do not match triangular face");
                }
            }
            else // if found match then set indx0,indx1;
            {
                if (indx0 == -1)
                {
                    indx0 = FaceNodes[ElementFaces[quadface0]][i];
                }
                else
                {
                    indx1 = FaceNodes[ElementFaces[quadface0]][i];
                }
            }
        }

        // Finally check for top vertex
        for (int i = 0; i < 3; ++i)
        {
            if ((FaceNodes[ElementFaces[triface0]][i] != indx0) &&
                (FaceNodes[ElementFaces[triface0]][i] != indx1) &&
                (FaceNodes[ElementFaces[triface0]][i] != indx2))
            {
                indx4 = FaceNodes[ElementFaces[triface0]][i];
                break;
            }
        }

        // calculate 0-1,
        Node a = *(Vnodes[indx1]) - *(Vnodes[indx0]);
        // calculate 0-4,
        Node b = *(Vnodes[indx4]) - *(Vnodes[indx0]);
        // calculate 0-2,
        Node c      = *(Vnodes[indx2]) - *(Vnodes[indx0]);
        Node acurlb = a.curl(b);

        NekDouble acurlb_dotc = acurlb.dot(c);
        if (acurlb_dotc < 0.0)
        {
            returnval[0] = indx0;
            returnval[1] = indx1;
            returnval[4] = indx4;
        }
        else
        {
            returnval[0] = indx1;
            returnval[1] = indx0;
            returnval[4] = indx4;
        }

        // check to see if two vertices are shared between one of the other
        // faces
        // to define which is indx2 and indx3

        int cnt = 0;
        for (int i = 0; i < 4; ++i)
        {
            if ((FaceNodes[ElementFaces[quadface1]][i] == returnval[1]) ||
                (FaceNodes[ElementFaces[quadface1]][i] == indx2))
            {
                cnt++;
            }
        }

        if (cnt == 2) // have two matching vertices
        {
            returnval[2] = indx2;
            returnval[3] = indx3;
        }
        else
        {
            cnt = 0;
            for (int i = 0; i < 4; ++i)
            {
                if ((FaceNodes[ElementFaces[quadface2]][i] == returnval[1]) ||
                    (FaceNodes[ElementFaces[quadface2]][i] == indx2))
                {
                    cnt++;
                }
            }

            if (cnt != 2) // neither of the other faces has two matching nodes
                          // so reverse
            {
                returnval[2] = indx3;
                returnval[3] = indx2;
            }
            else // have two matching vertices
            {
                returnval[2] = indx2;
                returnval[3] = indx3;
            }
        }

        if (isPrism == true)
        {
            // finally need to find last vertex from second triangular face.
            for (int i = 0; i < 3; ++i)
            {
                if ((FaceNodes[ElementFaces[triface1]][i] != indx2) &&
                    (FaceNodes[ElementFaces[triface1]][i] != indx3) &&
                    (FaceNodes[ElementFaces[triface1]][i] != indx3))
                {
                    returnval[5] = FaceNodes[ElementFaces[triface1]][i];
                    break;
                }
            }
        }
    }
    else
    {
        ASSERTL0(false, "SortFaceNodes not set up for this number of faces");
    }

    return returnval;
}

Member Data Documentation

ModuleKey Nektar::Utilities::InputTec::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eInputModule, "dat"),
    InputTec::create,
    "Reads Tecplot polyhedron ascii format converted from Star CCM (.dat).")

Definition at line 54 of file InputStarTec.h.