Converter for VTK files. More...

#include <InputStar.h>

Inheritance diagram for Nektar::Utilities::InputStar:

Collaboration diagram for Nektar::Utilities::InputStar:

Public Member Functions
	InputStar (NekMeshUtils::MeshSharedPtr m)

virtual	~InputStar ()

virtual void	Process ()
	Populate and validate required data structures. More...

void	ReadZone (int &nComposite)

Public Member Functions inherited from Nektar::NekMeshUtils::InputModule
NEKMESHUTILS_EXPORT	InputModule (MeshSharedPtr p_m)

NEKMESHUTILS_EXPORT void	OpenStream ()
	Open a file for input. More...

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 NekMeshUtils::ModuleSharedPtr	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className

Protected Member Functions
void	GenElement3D (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes, int i, std::vector< int > &ElementFaces, std::map< int, std::vector< int > > &FaceNodes, int ncomposite, bool DoOrient)

void	GenElement2D (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes, int i, std::vector< int > &FaceNodes, int ncomposite)

Array< OneD, int >	SortEdgeNodes (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes, std::vector< int > &FaceNodes)

Array< OneD, int >	SortFaceNodes (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes, std::vector< int > &ElementFaces, std::map< int, std::vector< int > > &FaceNodes)

void	ResetNodes (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes, Array< OneD, std::vector< int > > &ElementFaces, std::map< int, std::vector< int > > &FaceNodes)

Protected Member Functions inherited from Nektar::NekMeshUtils::InputModule
NEKMESHUTILS_EXPORT void	PrintSummary ()
	Print summary of elements. More...

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)

Private Member Functions
void	InitCCM (void)

void	ReadNodes (std::vector< NekMeshUtils::NodeSharedPtr > &Nodes)

void	ReadInternalFaces (std::map< int, std::vector< int > > &FacesNodes, Array< OneD, std::vector< int > > &ElementFaces)

void	ReadBoundaryFaces (std::vector< std::vector< int > > &BndElementFaces, std::map< int, std::vector< int > > &FacesNodes, Array< OneD, std::vector< int > > &ElementFaces, std::vector< std::string > &facelabels)

void	SetupElements (void)

Private Attributes
CCMIOError	m_ccmErr

CCMIOID	m_ccmTopology

CCMIOID	m_ccmProcessor

std::map< int, std::string >	m_faceLabels

Additional Inherited Members
Protected Attributes inherited from Nektar::NekMeshUtils::InputModule
io::filtering_istream	m_mshFile
	Input stream. More...

std::ifstream	m_mshFileStream
	Input stream. More...

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

Converter for VTK files.

Definition at line 48 of file InputStar.h.

Constructor & Destructor Documentation

Nektar::Utilities::InputStar::InputStar ( NekMeshUtils::MeshSharedPtr m )

Definition at line 56 of file InputStar.cpp.

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

                                     : InputModule(m)
 {
     m_config["writelabelsonly"] = ConfigOption(
         true,
         "0",
         "Just write out tags from star file for each surface/composite");
 }

Nektar::Utilities::InputStar::~InputStar ( )

virtual

Definition at line 64 of file InputStar.cpp.

65 {

66 }

Member Function Documentation

static NekMeshUtils::ModuleSharedPtr Nektar::Utilities::InputStar::create ( NekMeshUtils::MeshSharedPtr m )

inlinestatic

Creates an instance of this class.

Definition at line 52 of file InputStar.h.

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

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

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

protected

Definition at line 458 of file InputStar.cpp.

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

Referenced by SetupElements().

 {
     LibUtilities::ShapeType elType;
 
     if (FaceNodes.size() == 3)
     {
         elType = LibUtilities::eTriangle;
     }
     else if (FaceNodes.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, 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::InputStar::GenElement3D	(	std::vector< NekMeshUtils::NodeSharedPtr > &	Nodes,
		int	i,
		std::vector< int > &	ElementFaces,
		std::map< int, std::vector< int > > &	FaceNodes,
		int	ncomposite,
		bool	DoOrient
	)

protected

Definition at line 498 of file InputStar.cpp.

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

Referenced by SetupElements().

 {
     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::InputStar::InitCCM ( void )

private

Definition at line 893 of file InputStar.cpp.

References m_ccmErr, m_ccmProcessor, and Nektar::NekMeshUtils::Module::m_config.

Referenced by Process().

 {
     // Open ccm file for reading.
     CCMIOID root;
     // Open the file.  Because we did not initialize 'err' we
     // need to pass in NULL (which always means kCCMIONoErr)
     // and then assign the return value to 'err'.).
     string fname = m_config["infile"].as<string>();
     m_ccmErr     = CCMIOOpenFile(NULL, fname.c_str(), kCCMIORead, &root);
 
     CCMIOSize_t i = CCMIOSIZEC(0);
     CCMIOID state, problem;
 
     // We are going to assume that we have a state with a
     // known name.  We could instead use CCMIONextEntity() to
     // walk through all the states in the file and present the
     // list to the user for selection.
     CCMIOGetState(&m_ccmErr, root, kDefaultState, &problem, &state);
     if (m_ccmErr != kCCMIONoErr)
     {
         cout << "No state named '" << kDefaultState << "'" << endl;
         exit(0);
     }
 
     // Find the first processor (i has previously been
     // initialized to 0) and read the mesh and solution
     // information.
     CCMIONextEntity(&m_ccmErr, state, kCCMIOProcessor, &i, &m_ccmProcessor);
 }

void Nektar::Utilities::InputStar::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::NekMeshUtils::Module.

Definition at line 77 of file InputStar.cpp.

References InitCCM(), Nektar::NekMeshUtils::Module::m_mesh, Nektar::NekMeshUtils::InputModule::PrintSummary(), Nektar::NekMeshUtils::Module::ProcessComposites(), Nektar::NekMeshUtils::Module::ProcessEdges(), Nektar::NekMeshUtils::Module::ProcessElements(), Nektar::NekMeshUtils::Module::ProcessFaces(), and SetupElements().

 {
     m_mesh->m_expDim   = 3;
     m_mesh->m_spaceDim = 3;
 
     if (m_mesh->m_verbose)
     {
         cout << "InputCCM: Start reading file..." << endl;
     }
 
     InitCCM();
 
     SetupElements();
 
     PrintSummary();
 
     ProcessEdges();
     ProcessFaces();
     ProcessElements();
     ProcessComposites();
 }

void Nektar::Utilities::InputStar::ReadBoundaryFaces	(	std::vector< std::vector< int > > &	BndElementFaces,
		std::map< int, std::vector< int > > &	FacesNodes,
		Array< OneD, std::vector< int > > &	ElementFaces,
		std::vector< std::string > &	facelabels
	)

private

Definition at line 1057 of file InputStar.cpp.

References ASSERTL0, m_ccmErr, and m_ccmTopology.

Referenced by SetupElements().

 {
     // Read the boundary faces.
     CCMIOSize_t index = CCMIOSIZEC(0);
     CCMIOID mapID, id;
     CCMIOSize_t nFaces, size;
     vector<int> faces, faceCells, mapData;
     vector<string> facelabel;
 
     while (CCMIONextEntity(
                NULL, m_ccmTopology, kCCMIOBoundaryFaces, &index, &id) ==
            kCCMIONoErr)
     {
         int boundaryVal;
 
         CCMIOEntitySize(&m_ccmErr, id, &nFaces, NULL);
         int nf = TOINT64(nFaces);
         mapData.resize(nf);
         faceCells.resize(nf);
         CCMIOReadFaces(&m_ccmErr,
                        id,
                        kCCMIOBoundaryFaces,
                        NULL,
                        &size,
                        NULL,
                        CCMIOINDEXC(kCCMIOStart),
                        CCMIOINDEXC(kCCMIOEnd));
 
         faces.resize(TOINT64(size));
         CCMIOReadFaces(&m_ccmErr,
                        id,
                        kCCMIOBoundaryFaces,
                        &mapID,
                        NULL,
                        &faces[0],
                        CCMIOINDEXC(kCCMIOStart),
                        CCMIOINDEXC(kCCMIOEnd));
         CCMIOReadFaceCells(&m_ccmErr,
                            id,
                            kCCMIOBoundaryFaces,
                            &faceCells[0],
                            CCMIOINDEXC(kCCMIOStart),
                            CCMIOINDEXC(kCCMIOEnd));
         CCMIOReadMap(&m_ccmErr,
                      mapID,
                      &mapData[0],
                      CCMIOINDEXC(kCCMIOStart),
                      CCMIOINDEXC(kCCMIOEnd));
 
         CCMIOGetEntityIndex(&m_ccmErr, id, &boundaryVal);
 
         // check to see if we have a label for this boundary faces
         int size;
         char *name;
         if (CCMIOReadOptstr(NULL, id, "Label", &size, NULL) == kCCMIONoErr)
         {
             name = new char[size + 1];
             CCMIOReadOptstr(NULL, id, "Label", NULL, name);
             Facelabels.push_back(string(name));
         }
         else
         {
             Facelabels.push_back("Not known");
         }
 
         // Add face nodes
         int cnt = 0;
         for (int i = 0; i < nf; ++i)
         {
             vector<int> Fnodes;
             int j;
             if (cnt < faces.size())
             {
                 int nv = faces[cnt];
                 ASSERTL0(nv <= 4,
                          "Can only handle meshes with "
                          "up to four nodes per face");
 
                 for (j = 0; j < nv; ++j)
                 {
                     if (cnt + 1 + j < faces.size())
                     {
                         Fnodes.push_back(faces[cnt + 1 + j] - 1);
                     }
                 }
                 cnt += nv + 1;
             }
             FacesNodes[mapData[i] - 1] = Fnodes;
         }
 
         vector<int> BndFaces;
         for (int i = 0; i < nf; ++i)
         {
             if (faceCells[i])
             {
                 ElementFaces[faceCells[i] - 1].push_back(mapData[i] - 1);
             }
             BndFaces.push_back(mapData[i] - 1);
         }
         BndElementFaces.push_back(BndFaces);
     }
 }

void Nektar::Utilities::InputStar::ReadInternalFaces	(	std::map< int, std::vector< int > > &	FacesNodes,
		Array< OneD, std::vector< int > > &	ElementFaces
	)

private

Definition at line 963 of file InputStar.cpp.

References ASSERTL0, m_ccmErr, and m_ccmTopology.

Referenced by SetupElements().

 {
 
     CCMIOID mapID, id;
     CCMIOSize_t nFaces, size;
     vector<int> faces, faceCells, mapData;
 
     // Read the internal faces.
     CCMIOGetEntity(&m_ccmErr, m_ccmTopology, kCCMIOInternalFaces, 0, &id);
     CCMIOEntitySize(&m_ccmErr, id, &nFaces, NULL);
 
     int nf = TOINT64(nFaces);
     mapData.resize(nf);
     faceCells.resize(2 * nf);
 
     CCMIOReadFaces(&m_ccmErr,
                    id,
                    kCCMIOInternalFaces,
                    NULL,
                    &size,
                    NULL,
                    CCMIOINDEXC(kCCMIOStart),
                    CCMIOINDEXC(kCCMIOEnd));
     faces.resize(TOINT64(size));
     CCMIOReadFaces(&m_ccmErr,
                    id,
                    kCCMIOInternalFaces,
                    &mapID,
                    NULL,
                    &faces[0],
                    CCMIOINDEXC(kCCMIOStart),
                    CCMIOINDEXC(kCCMIOEnd));
     CCMIOReadFaceCells(&m_ccmErr,
                        id,
                        kCCMIOInternalFaces,
                        &faceCells[0],
                        CCMIOINDEXC(kCCMIOStart),
                        CCMIOINDEXC(kCCMIOEnd));
     CCMIOReadMap(&m_ccmErr,
                  mapID,
                  &mapData[0],
                  CCMIOINDEXC(kCCMIOStart),
                  CCMIOINDEXC(kCCMIOEnd));
 
     // Add face nodes
     int cnt = 0;
     for (int i = 0; i < nf; ++i)
     {
         vector<int> Fnodes;
         int j;
         if (cnt < faces.size())
         {
             int nv = faces[cnt];
             ASSERTL0(nv <= 4,
                      "Can only handle meshes with "
                      "up to four nodes per face");
 
             for (j = 0; j < nv; ++j)
             {
                 if (cnt + 1 + j < faces.size())
                 {
                     Fnodes.push_back(faces[cnt + 1 + j] - 1);
                 }
             }
             cnt += nv + 1;
         }
         FacesNodes[mapData[i] - 1] = Fnodes;
     }
 
     // find number of elements;
     int nelmt = 0;
     for (int i = 0; i < faceCells.size(); ++i)
     {
         nelmt = max(nelmt, faceCells[i]);
     }
 
     ElementFaces = Array<OneD, vector<int> >(nelmt);
     for (int i = 0; i < nf; ++i)
     {
         // left element
         if (faceCells[2 * i])
         {
             ElementFaces[faceCells[2 * i] - 1].push_back(mapData[i] - 1);
         }
 
         // right element
         if (faceCells[2 * i + 1])
         {
             ElementFaces[faceCells[2 * i + 1] - 1].push_back(mapData[i] - 1);
         }
     }
 }

void Nektar::Utilities::InputStar::ReadNodes ( std::vector< NekMeshUtils::NodeSharedPtr > & Nodes )

private

Definition at line 923 of file InputStar.cpp.

References m_ccmErr, m_ccmProcessor, m_ccmTopology, and class_topology::Node.

Referenced by SetupElements().

 {
     CCMIOID mapID, vertices;
     CCMIOSize_t nVertices, size, dims = CCMIOSIZEC(1);
 
     CCMIOReadProcessor(
         &m_ccmErr, m_ccmProcessor, &vertices, &m_ccmTopology, NULL, NULL);
     CCMIOEntitySize(&m_ccmErr, vertices, &nVertices, NULL);
 
     // Read the vertices.  This involves reading both the vertex data and
     // the map, which maps the index into the data array with the ID number.
     // As we process the vertices we need to be sure to scale them by the
     // appropriate scaling factor.  The offset is just to show you can read
     // any chunk.  Normally this would be in a for loop.
     float scale;
     int mapData[nVertices.getValue()];
     float verts[3 * nVertices.getValue()];
     for (int k = 0; k < nVertices; ++k)
     {
         verts[3 * k] = verts[3 * k + 1] = verts[3 * k + 2] = 0.0;
         mapData[k] = 0;
     }
     CCMIOReadVerticesf(&m_ccmErr,
                        vertices,
                        &dims,
                        &scale,
                        &mapID,
                        verts,
                        CCMIOINDEXC(0),
                        CCMIOINDEXC(0 + nVertices));
     CCMIOReadMap(
         &m_ccmErr, mapID, mapData, CCMIOINDEXC(0), CCMIOINDEXC(0 + nVertices));
 
     for (int i = 0; i < nVertices; ++i)
     {
         Nodes.push_back(boost::shared_ptr<Node>(
             new Node(i, verts[3 * i], verts[3 * i + 1], verts[3 * i + 2])));
     }
 }

void Nektar::Utilities::InputStar::ReadZone ( int & nComposite )

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

protected

Definition at line 210 of file InputStar.cpp.

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

Referenced by SetupElements().

 {
     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 reset 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]);
     }
 }

void Nektar::Utilities::InputStar::SetupElements ( void )

private

Definition at line 99 of file InputStar.cpp.

References ASSERTL0, GenElement2D(), GenElement3D(), Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Module::m_mesh, CellMLToNektar.pycml::msg, Nektar::NekMeshUtils::Module::ProcessVertices(), ReadBoundaryFaces(), ReadInternalFaces(), ReadNodes(), and ResetNodes().

Referenced by Process().

 {
     int i;
     string line, tag;
     stringstream s;
     streampos pos;
     int nComposite = 0;
 
     // Read in Nodes
     std::vector<NodeSharedPtr> Nodes;
     ReadNodes(Nodes);
 
     // Get list of faces nodes and adjacents elements.
     map<int, vector<int> > FaceNodes;
     Array<OneD, vector<int> > ElementFaces;
 
     // Read interior faces and set up first part of Element
     // Faces and FaceNodes
     ReadInternalFaces(FaceNodes, ElementFaces);
 
     vector<vector<int> > BndElementFaces;
     vector<string> Facelabels;
     ReadBoundaryFaces(BndElementFaces, FaceNodes, ElementFaces, Facelabels);
 
     if (m_config["writelabelsonly"].beenSet)
     {
         nComposite = 2;
         // write boundary zones/composites
         for (i = 0; i < BndElementFaces.size(); ++i)
         {
             cout << " 2D Zone (composite = " << nComposite
                  << ", label = " << Facelabels[i] << ")" << endl;
             nComposite++;
         }
         exit(1);
     }
 
     // 3D Zone
     // 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
     int nelements = ElementFaces.num_elements();
     cout << " Generating 3D Zones: ";
     int cnt = 0;
     for (i = 0; i < nelements; ++i)
     {
 
         if (ElementFaces[i].size() > 4)
         {
             GenElement3D(
                 Nodes, i, ElementFaces[i], FaceNodes, nComposite, true);
             ++cnt;
         }
     }
     cout << cnt << " Prisms,";
 
     nComposite++;
 
     // create Tets second
     cnt = 0;
     for (i = 0; i < nelements; ++i)
     {
         if (ElementFaces[i].size() == 4)
         {
             GenElement3D(
                 Nodes, i, ElementFaces[i], FaceNodes, nComposite, true);
             ++cnt;
         }
     }
     cout << cnt << " Tets" << endl;
     nComposite++;
 
     ProcessVertices();
 
     // Add boundary zones/composites
     for (i = 0; i < BndElementFaces.size(); ++i)
     {
         cout << " Generating 2D Zone (composite = " << nComposite
              << ", label = " << Facelabels[i] << ")" << endl;
 
         for (int j = 0; j < BndElementFaces[i].size(); ++j)
         {
 
             if (FaceNodes.count(BndElementFaces[i][j]))
             {
                 GenElement2D(
                     Nodes, j, FaceNodes[BndElementFaces[i][j]], nComposite);
             }
             else
             {
                 string msg = "Failed to find FaceNodes for Face ";
                 msg += boost::lexical_cast<string>(BndElementFaces[i][j]);
                 ASSERTL0(false, msg);
             }
         }
 
         m_mesh->m_faceLabels[nComposite] = Facelabels[i];
         nComposite++;
     }
 }

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

protected

Definition at line 559 of file InputStar.cpp.

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

Referenced by GenElement2D().

 {
     Array<OneD, int> returnval;
 
     if (FaceNodes.size() == 3) // Triangle
     {
         returnval = Array<OneD, int>(3);
 
         returnval[0] = FaceNodes[0];
         returnval[1] = FaceNodes[1];
         returnval[2] = FaceNodes[2];
     }
     else if (FaceNodes.size() == 4) // quadrilateral
     {
         returnval = Array<OneD, int>(4);
 
         int indx0 = FaceNodes[0];
         int indx1 = FaceNodes[1];
         int indx2 = FaceNodes[2];
         int indx3 = FaceNodes[3];
 
         // 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::InputStar::SortFaceNodes	(	std::vector< NekMeshUtils::NodeSharedPtr > &	Nodes,
		std::vector< int > &	ElementFaces,
		std::map< int, std::vector< int > > &	FaceNodes
	)

protected

Definition at line 613 of file InputStar.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, triface2, triface3;
         int quadface0, quadface1, quadface2;
         bool isPrism = true;
 
         // find ids of tri faces and first quad face
         triface0 = triface1 = triface2 = triface3 = -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 if (triface2 == -1)
                 {
                     triface2 = i;
                     isPrism = false;
                 }
                 else if (triface3 == -1)
                 {
                     triface3 = i;
                 }
             }
 
             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);
             ASSERTL1(quadface0 != -1, "Quad face 0 not found");
             ASSERTL1(quadface1 != -1, "Quad face 1 not found");
             ASSERTL1(quadface2 != -1, "Quad face 2 not found");
             ASSERTL1(triface0 != -1, "Tri face 0 not found");
             ASSERTL1(triface1 != -1, "Tri face 1 not found");
         }
         else // Pyramid
         {
             ASSERTL1(quadface0 != -1, "Quad face 0 not found");
             ASSERTL1(triface0 != -1, "Tri face 0 not found");
             ASSERTL1(triface1 != -1, "Tri face 1 not found");
             ASSERTL1(triface2 != -1, "Tri face 2 not found");
             ASSERTL1(triface3 != -1, "Tri face 3 not found");
             ASSERTL0(false,"Pyramids still not sorted");
             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::InputStar::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eInputModule, "ccm"),
    InputStar::create,
    "Reads mesh from Star CCM (.ccm).")

Definition at line 56 of file InputStar.h.

CCMIOError Nektar::Utilities::InputStar::m_ccmErr

private

Definition at line 93 of file InputStar.h.

Referenced by InitCCM(), ReadBoundaryFaces(), ReadInternalFaces(), and ReadNodes().

CCMIOID Nektar::Utilities::InputStar::m_ccmProcessor

private

Definition at line 95 of file InputStar.h.

Referenced by InitCCM(), and ReadNodes().

CCMIOID Nektar::Utilities::InputStar::m_ccmTopology

private

Definition at line 94 of file InputStar.h.

Referenced by ReadBoundaryFaces(), ReadInternalFaces(), and ReadNodes().

std::map<int, std::string> Nektar::Utilities::InputStar::m_faceLabels

private

Definition at line 96 of file InputStar.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation