#include <InputSem.h>

Inheritance diagram for Nektar::Utilities::InputSem:

Collaboration diagram for Nektar::Utilities::InputSem:

Public Member Functions
	InputSem (MeshSharedPtr m)
	Initialises the InputSem class. More...

virtual	~InputSem ()

virtual void	Process ()
	Process a Semtex session file. More...

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

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
	ModuleKey for class. More...

Private Member Functions
void	insertEdge (int elmt, int side, int tagId)

Private Attributes
std::map< std::string, std::streampos >	sectionMap
	Maps Semtex sections to positions inside the input file. More...

Additional Inherited Members
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)

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 Semtex session files.

Definition at line 49 of file InputSem.h.

Constructor & Destructor Documentation

Nektar::Utilities::InputSem::InputSem ( MeshSharedPtr m )

Initialises the InputSem class.

Definition at line 56 of file InputSem.cpp.

                                   : InputModule(m)
 {
 }

Nektar::Utilities::InputSem::~InputSem ( )

virtual

Definition at line 60 of file InputSem.cpp.

61 {

62 }

Member Function Documentation

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

inlinestatic

Creates an instance of this class.

Definition at line 57 of file InputSem.h.

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

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

void Nektar::Utilities::InputSem::insertEdge	(	int	elmt,
		int	side,
		int	tagId
	)

private

Definition at line 662 of file InputSem.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eSegment, Nektar::NekMeshUtils::GetElementFactory(), and Nektar::Utilities::Module::m_mesh.

Referenced by Process().

 {
     EdgeSharedPtr edge              = m_mesh->m_element[2][elmt]->GetEdge(side);
     vector<NodeSharedPtr> edgeNodes = edge->m_edgeNodes;
     edgeNodes.insert(edgeNodes.begin(), edge->m_n2);
     edgeNodes.insert(edgeNodes.begin(), edge->m_n1);
     int order = edgeNodes.size() - 1;
 
     vector<int> tags;
     tags.push_back(tagId);
 
     ElmtConfig conf(LibUtilities::eSegment,
                     order,
                     order > 1,
                     false,
                     true,
                     LibUtilities::eGaussLobattoLegendre);
     ElementSharedPtr E = GetElementFactory().CreateInstance(
         LibUtilities::eSegment, conf, edgeNodes, tags);
     m_mesh->m_element[1].push_back(E);
 }

void Nektar::Utilities::InputSem::Process ( )

virtual

Process a Semtex session file.

Semtex files are defined by a tokenized markup format. We first populate sectionMap which stores the location of the various tags in the session file so that they can be jumped to, since no ordering is defined. The converter only requires the NODES and ELEMENTS sections to exist, but can also read CURVES and SURFACES. High-order curves rely on the meshfile session.msh to be created with the Semtex utility meshpr first.

Parameters

pFilename Filename of Semtex session to read.

Implements Nektar::Utilities::Module.

Definition at line 77 of file InputSem.cpp.

 {
     // Open the file stream.
     OpenStream();
 
     if (m_mesh->m_verbose)
     {
         cout << "InputSem: Start reading file..." << endl;
     }
 
     // Read through input file and populate the section map.
     map<string, streampos>::iterator it;
     string line, word;
     stringstream ss;
     streampos linePos;
 
     sectionMap["NODES"]    = -1;
     sectionMap["ELEMENTS"] = -1;
     sectionMap["CURVES"]   = -1;
     sectionMap["SURFACES"] = -1;
     sectionMap["GROUPS"]   = -1;
     sectionMap["BCS"]      = -1;
     sectionMap["FIELDS"]   = -1;
 
     while (!m_mshFile.eof())
     {
         linePos = m_mshFile.tellg();
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
         ss >> word;
 
         // Iterate over all tokens and see if section exists on this
         // line.
         for (it = sectionMap.begin(); it != sectionMap.end(); ++it)
         {
             if (word == "<" + it->first || word == "<" + it->first + ">")
             {
                 sectionMap[it->first] = linePos;
             }
         }
     }
 
     // Clear eofbit and go back to the beginning of the file.
     m_mshFile.clear();
     m_mshFile.seekg(0);
 
     // Check that required sections exist in the file.
     if (sectionMap["NODES"] == std::streampos(-1))
     {
         cerr << "Unable to locate NODES section in session file." << endl;
         abort();
     }
 
     if (sectionMap["ELEMENTS"] == std::streampos(-1))
     {
         cerr << "Unable to locate ELEMENTS section in session file." << endl;
         abort();
     }
 
     if (sectionMap["SURFACES"] != std::streampos(-1))
     {
         if (sectionMap["BCS"] == std::streampos(-1))
         {
             cerr << "SURFACES section defined but BCS section not "
                  << "found." << endl;
             abort();
         }
 
         if (sectionMap["GROUPS"] == std::streampos(-1))
         {
             cerr << "SURFACES section defined but GROUPS section not "
                  << "found." << endl;
             abort();
         }
 
         if (sectionMap["FIELDS"] == std::streampos(-1))
         {
             cerr << "SURFACES section defined but FIELDS section not "
                  << "found." << endl;
             abort();
         }
     }
 
     m_mesh->m_expDim = 0;
     string tag;
     int start, end, nVertices, nEntities, nCurves, nSurf, nGroups, nBCs;
     int id, i, j, k;
     vector<double> hoXData, hoYData;
     LibUtilities::ShapeType elType = LibUtilities::eQuadrilateral;
     ifstream homeshFile;
 
     // Begin by reading in list of nodes which define the linear
     // elements.
     m_mshFile.seekg(sectionMap["NODES"]);
     getline(m_mshFile, line);
     ss.clear();
     ss.str(line);
     ss >> word;
 
     tag       = ss.str();
     start     = tag.find_first_of('=');
     end       = tag.find_first_of('>');
     nVertices = atoi(tag.substr(start + 1, end).c_str());
 
     i = id = 0;
     while (i < nVertices)
     {
         getline(m_mshFile, line);
         if (line.length() < 7)
             continue;
         ss.clear();
         ss.str(line);
         double x = 0, y = 0, z = 0;
         ss >> id >> x >> y >> z;
 
         if ((y * y) > 0.000001 && m_mesh->m_spaceDim != 3)
         {
             m_mesh->m_spaceDim = 2;
         }
         if ((z * z) > 0.000001)
         {
             m_mesh->m_spaceDim = 3;
         }
         id -= 1; // counter starts at 0
         m_mesh->m_node.push_back(
             boost::shared_ptr<Node>(new Node(id, x, y, z)));
         ++i;
     }
 
     // Now read in elements
     m_mshFile.seekg(sectionMap["ELEMENTS"]);
     getline(m_mshFile, line);
     ss.clear();
     ss.str(line);
     ss >> word;
 
     tag       = ss.str();
     start     = tag.find_first_of('=');
     end       = tag.find_first_of('>');
     nEntities = atoi(tag.substr(start + 1, end).c_str());
 
     i = id = 0;
     while (i < nEntities)
     {
         getline(m_mshFile, line);
         if (line.length() < 18)
         {
             continue;
         }
 
         // Create element tags
         vector<int> tags;
         tags.push_back(0); // composite
 
         // Read element node list
         ss.clear();
         ss.str(line);
         ss >> id >> word;
         vector<NodeSharedPtr> nodeList;
         for (j = 0; j < 4; ++j)
         {
             int node = 0;
             ss >> node;
             nodeList.push_back(m_mesh->m_node[node - 1]);
         }
 
         // Create element
         ElmtConfig conf(elType, 1, false, false);
         ElementSharedPtr E =
             GetElementFactory().CreateInstance(elType, conf, nodeList, tags);
 
         // Determine mesh expansion dimension
         if (E->GetDim() > m_mesh->m_expDim)
         {
             m_mesh->m_expDim = E->GetDim();
         }
         m_mesh->m_element[E->GetDim()].push_back(E);
         ++i;
     }
 
     // Finally, process curves.
     if (sectionMap["CURVES"] != std::streampos(-1))
     {
         int np, nel, nodeId = m_mesh->m_node.size();
 
         m_mshFile.seekg(sectionMap["CURVES"]);
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
         ss >> word;
 
         tag     = ss.str();
         start   = tag.find_first_of('=');
         end     = tag.find_first_of('>');
         nCurves = atoi(tag.substr(start + 1, end).c_str());
 
         // Some session files have empty curves sections; if nCurves
         // is 0, no nead to load high order mesh file.
         if (nCurves > 0)
         {
             string fname    = m_config["infile"].as<string>();
             int ext         = fname.find_last_of('.');
             string meshfile = fname.substr(0, ext) + ".msh";
 
             homeshFile.open(meshfile.c_str());
             if (!homeshFile.is_open())
             {
                 cerr << "Cannot open or find mesh file: " << meshfile << endl
                      << "Make sure to run meshpr on your session "
                      << "file first." << endl;
                 abort();
             }
 
             // Make sure we have matching header.
             getline(homeshFile, line);
             ss.clear();
             ss.str(line);
             ss >> np >> nel >> nel >> nel;
 
             if (nel != m_mesh->m_element[m_mesh->m_expDim].size())
             {
                 cerr << "Number of elements mismatch in mesh file." << endl;
                 abort();
             }
 
             // Now read in all mesh data. This is horribly inefficient
             // since not all elements are curved, but it is the
             // easiest way of finding element data.
             hoXData.resize(nel * np * np);
             hoYData.resize(nel * np * np);
 
             for (j = 0; j < nel * np * np; ++j)
             {
                 getline(homeshFile, line);
                 ss.clear();
                 ss.str(line);
                 ss >> hoXData[j] >> hoYData[j];
             }
 
             homeshFile.close();
         }
 
         i = id = 0;
         while (i < nCurves)
         {
             getline(m_mshFile, line);
             if (line.length() < 18)
             {
                 continue;
             }
             int elmt = 0, side = 0;
             ss.clear();
             ss.str(line);
             ss >> id >> elmt >> side >> word;
             id--;
             elmt--;
 
             vector<NodeSharedPtr> edgeNodes;
 
             if (word != "<SPLINE>" && word != "<ARC>")
             {
                 cerr << "Unknown curve tag: " << word << endl;
                 abort();
             }
 
             // See if we have already retrieved high-order data
             // for this elements; prevents unnecessary computation
             // for elements with multiple curves.
             if (m_mesh->m_element[2][elmt]->GetConf().m_order > 1)
             {
                 ++i;
                 continue;
             }
 
             // Now set high order data for requested element.
             for (int side = 0; side < 4; ++side)
             {
                 int offset = elmt * np * np;
                 int stride = 0;
 
                 switch (side)
                 {
                     case 0: // Bottom edge
                         offset += 0;
                         stride = 1;
                         break;
                     case 1: // Right edge
                         offset += np - 1;
                         stride = np;
                         break;
                     case 2: // Top edge
                         offset += np * np - 1;
                         stride = -1;
                         break;
                     case 3: // Left edge
                         offset += np * (np - 1);
                         stride = -np;
                         break;
                     default:
                         cerr << "Unknown side for curve id " << id << endl;
                         abort();
                 }
 
                 for (j = 1; j < np - 1; ++j, ++nodeId)
                 {
                     double x = hoXData[offset + j * stride];
                     double y = hoYData[offset + j * stride];
                     NodeSharedPtr n =
                         boost::shared_ptr<Node>(new Node(nodeId, x, y, 0.0));
                     edgeNodes.push_back(n);
                 }
             }
 
             // Add internal points.
             for (j = 1; j < np - 1; ++j)
             {
                 int offset = j * np + 1;
                 for (k = 1; k < np - 1; ++k, ++nodeId)
                 {
                     double x = hoXData[offset + k];
                     double y = hoYData[offset + k];
                     NodeSharedPtr n =
                         boost::shared_ptr<Node>(new Node(nodeId, x, y, 0.0));
                     edgeNodes.push_back(n);
                 }
             }
 
             // Grab existing element from list and retrieve tags and
             // vertices; insert these into existing edge nodes.
             ElementSharedPtr e           = m_mesh->m_element[2][elmt];
             vector<NodeSharedPtr> elvert = e->GetVertexList();
             vector<int> tags = e->GetTagList();
             edgeNodes.insert(edgeNodes.begin(), elvert.begin(), elvert.end());
 
             // Create new element and replace with an incomplete
             // quadrilateral of the correct order.
             ElmtConfig conf(elType,
                             np - 1,
                             true,
                             false,
                             true,
                             LibUtilities::eGaussLobattoLegendre);
             m_mesh->m_element[2][elmt] = GetElementFactory().CreateInstance(
                 elType, conf, edgeNodes, tags);
 
             ++i;
         }
     }
 
     // Process field names
     if (sectionMap["FIELDS"] != std::streampos(-1))
     {
         m_mshFile.seekg(sectionMap["FIELDS"]);
         getline(m_mshFile, line);
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
 
         while (ss >> tag)
         {
             m_mesh->m_fields.push_back(tag);
         }
     }
 
     // Process surfaces if they exist. This is deliberately done after
     // curves to ensure high-order points are preserved.
     if (sectionMap["SURFACES"] != std::streampos(-1))
     {
         map<string, int> conditionMap;
         int maxTag = -1;
 
         // First read in list of groups, which defines each condition tag.
         m_mshFile.seekg(sectionMap["GROUPS"]);
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
         ss >> word;
 
         tag     = ss.str();
         start   = tag.find_first_of('=');
         end     = tag.find_first_of('>');
         nGroups = atoi(tag.substr(start + 1, end).c_str());
 
         i = id = 0;
         while (i < nGroups)
         {
             getline(m_mshFile, line);
             ss.clear();
             ss.str(line);
             ss >> id >> tag;
             conditionMap[tag] = i++;
         }
 
         maxTag = i;
 
         // Now read in actual values for boundary conditions from BCS
         // section.
         m_mshFile.seekg(sectionMap["BCS"]);
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
         ss >> word;
 
         tag   = ss.str();
         start = tag.find_first_of('=');
         end   = tag.find_first_of('>');
         nBCs  = atoi(tag.substr(start + 1, end).c_str());
 
         i = id = 0;
         while (i < nBCs)
         {
             int nF;
             string tmp;
             ConditionSharedPtr p;
             getline(m_mshFile, line);
             ss.clear();
             ss.str(line);
             ss >> id >> tag >> nF;
 
             p                                      = ConditionSharedPtr(new Condition());
             m_mesh->m_condition[conditionMap[tag]] = p;
 
             // Read boundary condition.
             j = 0;
             while (j < nF)
             {
                 getline(m_mshFile, line);
                 ss.clear();
                 ss.str(line);
                 ss >> tmp;
 
                 // First string should be condition type.
                 if (tmp == "<D>")
                 {
                     p->type.push_back(eDirichlet);
                 }
                 else if (tmp == "<N>")
                 {
                     p->type.push_back(eNeumann);
                 }
                 else if (tmp == "<H>")
                 {
                     p->type.push_back(eHOPCondition);
                     p->value.push_back("0");
                     p->field.push_back("p");
                     ++j;
                     continue;
                 }
                 else
                 {
                     cerr << "Unsupported boundary condition type " << tmp
                          << endl;
                     abort();
                 }
 
                 // Second string should be field.
                 ss >> tmp;
                 p->field.push_back(tmp);
 
                 // Third string should be equals sign.
                 ss >> tmp;
                 if (tmp != "=")
                 {
                     cerr << "Couldn't read boundary condition type " << tag
                          << endl;
                     abort();
                 }
 
                 // Fourth string should be value. CAUTION: Assumes
                 // expression is defined without any spaces in it!
                 ss >> tmp;
                 p->value.push_back(tmp);
 
                 ++j;
             }
 
             // Finally set composite for condition. In this case, all
             // composites will be lines so there is one set per
             // composite.
             p->m_composite.push_back(conditionMap[tag] + 1);
 
             ++i;
         }
 
         // Finally read surface information.
         m_mshFile.seekg(sectionMap["SURFACES"]);
         getline(m_mshFile, line);
         ss.clear();
         ss.str(line);
         ss >> word;
 
         tag   = ss.str();
         start = tag.find_first_of('=');
         end   = tag.find_first_of('>');
         nSurf = atoi(tag.substr(start + 1, end).c_str());
 
         i = id = 0;
         int elmt, side;
         int periodicTagId = -1;
 
         set<pair<int, int> > visitedPeriodic;
 
         while (i < nSurf)
         {
             getline(m_mshFile, line);
             ss.clear();
             ss.str(line);
             ss >> id >> elmt >> side >> word;
             elmt--;
             side--;
 
             if (word == "<P>")
             {
                 // If this is the first periodic boundary condition
                 // encountered, then set up m_mesh->m_condition with two
                 // periodic conditions.
                 if (periodicTagId == -1)
                 {
                     periodicTagId         = maxTag;
                     ConditionSharedPtr in = ConditionSharedPtr(new Condition());
                     ConditionSharedPtr out =
                         ConditionSharedPtr(new Condition());
                     for (j = 0; j < m_mesh->m_fields.size(); ++j)
                     {
                         in->type.push_back(ePeriodic);
                         out->type.push_back(ePeriodic);
                         in->field.push_back(m_mesh->m_fields[j]);
                         out->field.push_back(m_mesh->m_fields[j]);
                         in->value.push_back("[" + boost::lexical_cast<string>(
                                                       periodicTagId + 1) +
                                             "]");
                         out->value.push_back(
                             "[" + boost::lexical_cast<string>(periodicTagId) +
                             "]");
                     }
                     in->m_composite.push_back(periodicTagId + 1);
                     out->m_composite.push_back(periodicTagId + 2);
                     m_mesh->m_condition[periodicTagId]     = in;
                     m_mesh->m_condition[periodicTagId + 1] = out;
                 }
 
                 int elmtB, sideB;
 
                 ss >> elmtB >> sideB;
                 elmtB--;
                 sideB--;
 
                 pair<int, int> c1(elmt, side);
                 pair<int, int> c2(elmtB, sideB);
 
                 if (visitedPeriodic.count(c1) == 0 &&
                     visitedPeriodic.count(c2) == 0)
                 {
                     visitedPeriodic.insert(make_pair(elmtB, sideB));
                     visitedPeriodic.insert(make_pair(elmt, side));
                     insertEdge(elmt, side, periodicTagId + 1);
                     insertEdge(elmtB, sideB, periodicTagId + 2);
                 }
             }
             else if (word == "<B>")
             {
                 ss >> tag;
                 insertEdge(elmt, side, conditionMap[tag] + 1);
             }
             else
             {
                 cerr << "Unrecognised or unsupported tag " << word << endl;
                 abort();
             }
             ++i;
         }
     }
 
     PrintSummary();
     m_mshFile.close();
 
     // Process rest of mesh.
     ProcessVertices();
     ProcessEdges();
     ProcessFaces();
     ProcessElements();
     ProcessComposites();
 }

Member Data Documentation

ModuleKey Nektar::Utilities::InputSem::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(ModuleKey(eInputModule, "sem"),
                                               InputSem::create,
                                               "Reads Semtex session files.")

ModuleKey for class.

Definition at line 62 of file InputSem.h.

std::map<std::string, std::streampos> Nektar::Utilities::InputSem::sectionMap

private

Maps Semtex sections to positions inside the input file.

Definition at line 68 of file InputSem.h.

Referenced by Process().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation