Classes
class	Composite
	A composite is a collection of elements. More...

struct	Condition
	Defines a boundary condition. More...

struct	ConfigOption
	Represents a command-line configuration option. More...

class	Edge
	Represents an edge which joins two points. More...

struct	EdgeHash
	Defines a hash function for edges. More...

struct	EdgeInfo

class	Element
	Base class for element definitions. More...

struct	element_id_less_than
	Define element ordering based on ID. More...

struct	ElmtConfig
	Basic information about an element. More...

struct	ElmtConfigHash

class	Face
	Represents a face comprised of three or more edges. More...

struct	FaceHash

struct	Field

class	FieldConvertComm

class	Hexahedron
	A 3-dimensional six-faced element. More...

struct	HOSurfHash

struct	HOTriangle
	A lightweight struct for dealing with high-order triangle alignment. More...

class	InputDat
	Input module for Xml files. More...

class	InputFld

class	InputGmsh

class	InputModule
	Abstract base class for input modules. More...

class	InputNek

class	InputNekpp

class	InputPly
	Converter for Ply files. More...

class	InputPts

class	InputSem

class	InputStar
	Converter for VTK files. More...

class	InputSwan
	Converter for Swansea mesh format. More...

class	InputTec
	Converter for VTK files. More...

class	InputVtk
	Converter for VTK files. More...

class	InputXml

class	Iso

class	IsoVertex

class	Line
	A 1-dimensional line between two vertex nodes. More...

class	Mesh

class	Module

class	Node
	Represents a point in the domain. More...

struct	NodeHash
	Defines a hash function for nodes. More...

class	OutputFld
	Converter from fld to vtk. More...

class	OutputGmsh
	Converter for Gmsh files. More...

class	OutputInfo

class	OutputModule
	Abstract base class for output modules. More...

class	OutputNekpp
	Converter for Gmsh files. More...

class	OutputTecplot
	Converter from fld to dat. More...

class	OutputVtk
	Converter from fld to vtk. More...

class	OutputXml
	Converter from fld to vtk. More...

class	Point
	A 0-dimensional vertex. More...

class	Prism
	A 3-dimensional five-faced element (2 triangles, 3 quadrilaterals). More...

class	ProcessAddFld
	This processing module scales the input fld file. More...

class	ProcessBL
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessBoundaryExtract
	This processing module sets up for the boundary field to be extracted. More...

class	ProcessC0Projection
	This processing module calculates the Q Criterion and adds it as an extra-field to the output file. More...

class	ProcessConcatenateFld
	This processing module sets up for the boundary field to be extracted. More...

class	ProcessCyl

class	ProcessDeform

class	ProcessDetectSurf
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessDisplacement

class	ProcessEquiSpacedOutput
	This processing module interpolates one field to another. More...

class	ProcessExtractSurf
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessExtractTetPrismInterface
	Module to extract interface between prismatic and tetrahedral elements. More...

class	ProcessGrad
	This processing module calculates the vorticity and adds it as an extra-field to the output file. More...

class	ProcessInterpField
	This processing module interpolates one field to another. More...

class	ProcessInterpPointDataToFld
	This processing module interpolates one field to another. More...

class	ProcessInterpPoints
	This processing module interpolates one field to another. More...

class	ProcessIsoContour
	This processing module extracts an isocontour. More...

class	ProcessJac
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessJacobianEnergy
	This processing module scales the input fld file. More...

class	ProcessModule
	Abstract base class for processing modules. More...

class	ProcessMultiShear
	This processing module calculates the shear stress metrics and writes it to a surface output file. More...

class	ProcessPerAlign

class	ProcessPrintFldNorms
	This processing module prints the L2 and LInf norms of the variables in the field. More...

class	ProcessQCriterion
	This processing module calculates the Q Criterion and adds it as an extra-field to the output file. More...

class	ProcessScalar
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessScaleInFld
	This processing module scales the input fld file. More...

class	ProcessScalGrad
	This processing module calculates the scalar gradient field and writes it to a surface output file. More...

class	ProcessSpherigon

class	ProcessSurfDistance
	This processing module calculates the height of an element connected to a surface and adds it as an extra-field to the output file. More...

class	ProcessTetSplit
	This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

class	ProcessVorticity
	This processing module calculates the vorticity and adds it as an extra-field to the output file. More...

class	ProcessWSS
	This processing module calculates the wall shear stress and adds it as an extra-field to the output file, and writes it to a surface output file. More...

class	Pyramid
	A 3-dimensional square-based pyramidic element. More...

class	Quadrilateral
	A 2-dimensional four-sided element. More...

struct	SplitEdgeHelper

struct	SplitMapHelper

struct	TetOrient

struct	TetOrientHash

class	Tetrahedron
	A 3-dimensional four-faced element. More...

class	Triangle
	A 2-dimensional three-sided element. More...

struct	TriFaceHash

struct	TriFaceIDs

Typedefs
typedef boost::shared_ptr< Field >	FieldSharedPtr

typedef boost::shared_ptr< InputModule >	InputModuleSharedPtr

typedef pair< ModuleType, string >	ModuleKey

typedef boost::shared_ptr< Module >	ModuleSharedPtr

typedef LibUtilities::NekFactory< ModuleKey, Module, FieldSharedPtr >	ModuleFactory

typedef boost::unordered_map< TriFaceIDs, int, TriFaceHash >	TriFaceMap

typedef boost::shared_ptr< Iso >	IsoSharedPtr

typedef HOTriangle< NodeSharedPtr >	HOSurf

typedef boost::shared_ptr< HOSurf >	HOSurfSharedPtr

typedef boost::unordered_set< HOSurfSharedPtr, HOSurfHash >	HOSurfSet

typedef boost::shared_ptr< InputPly >	InputPlySharedPtr

typedef boost::unordered_set< struct TetOrient, TetOrientHash >	TetOrientSet

typedef boost::shared_ptr< Element >	ElementSharedPtr
	Shared pointer to an element. More...

typedef boost::shared_ptr< Node >	NodeSharedPtr
	Shared pointer to a Node. More...

typedef boost::unordered_set< NodeSharedPtr, NodeHash >	NodeSet

typedef boost::shared_ptr< Edge >	EdgeSharedPtr
	Shared pointer to an edge. More...

typedef boost::unordered_set< EdgeSharedPtr, EdgeHash >	EdgeSet

typedef boost::shared_ptr< Face >	FaceSharedPtr
	Shared pointer to a face. More...

typedef boost::unordered_set< FaceSharedPtr, FaceHash >	FaceSet

typedef std::map< unsigned int, std::vector< ElementSharedPtr > >	ElementMap
	Container for elements; key is expansion dimension, value is vector of elements of that dimension. More...

typedef Nektar::LibUtilities::NekFactory< LibUtilities::ShapeType, Element, ElmtConfig, std::vector< NodeSharedPtr >, std::vector< int > >	ElementFactory
	Element factory definition. More...

typedef boost::shared_ptr< Composite >	CompositeSharedPtr
	Shared pointer to a composite. More...

typedef std::map< unsigned int, CompositeSharedPtr >	CompositeMap
	Container of composites; key is the composite id, value is the composite. More...

typedef boost::shared_ptr< Condition >	ConditionSharedPtr

typedef std::map< int, ConditionSharedPtr >	ConditionMap

typedef boost::shared_ptr< Mesh >	MeshSharedPtr
	Shared pointer to a mesh. More...

typedef map< int, pair< FaceSharedPtr, vector< int > > >	PerMap

typedef std::pair< int, int >	ipair

Enumerations
enum	ModuleType { eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType, eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType }

enum	TecOutType { eFullBlockZone, eFullBlockZoneEquiSpaced, eSeperateZones }

enum	NekCurve { eFile, eRecon }

enum	ConditionType { eDirichlet, eNeumann, eRobin, ePeriodic, eHOPCondition, SIZE_ConditionType }

enum	ModuleType { eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType, eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType }

Functions
ModuleFactory &	GetModuleFactory ()

std::ostream &	operator<< (std::ostream &os, const ModuleKey &rhs)

bool	operator== (TriFaceIDs const &p1, TriFaceIDs const &p2)

void	TwoPairs (Array< OneD, NekDouble > &cx, Array< OneD, NekDouble > &cy, Array< OneD, NekDouble > &cz, int &pr)

void	ThreeSimilar (const int i, const int j, const int k, int &pr, int &ps)

bool	operator== (const IsoVertex &x, const IsoVertex &y)

bool	operator!= (const IsoVertex &x, const IsoVertex &y)

bool	same (NekDouble x1, NekDouble y1, NekDouble z1, NekDouble x2, NekDouble y2, NekDouble z2)

std::vector< int >	quadTensorNodeOrdering (const std::vector< int > &nodes, int n)
	Reorder a quadrilateral to appear in Nektar++ ordering from Gmsh. More...

std::vector< int >	triTensorNodeOrdering (const std::vector< int > &nodes, int n)

bool	operator== (HOSurfSharedPtr const &p1, HOSurfSharedPtr const &p2)
	Compares two HOSurf objects referred to as shared pointers. More...

static void	PrismLineFaces (int prismid, map< int, int > &facelist, vector< vector< int > > &FacesToPrisms, vector< vector< int > > &PrismsToFaces, vector< bool > &PrismDone)

static void	PrismLineFaces (int prismid, map< int, int > &facelist, vector< vector< int > > &FacesToPrisms, vector< vector< int > > &PrismsToFaces, vector< bool > &PrismDone)

ElementFactory &	GetElementFactory ()

bool	operator== (ConditionSharedPtr const &c1, ConditionSharedPtr const &c2)
	Test equality of two conditions - i.e. compare types, fields and values but not composite ids. More...

bool	operator== (NodeSharedPtr const &p1, NodeSharedPtr const &p2)
	Defines equality between two NodeSharedPtr objects. More...

bool	operator< (NodeSharedPtr const &p1, NodeSharedPtr const &p2)
	Defines ordering between two NodeSharedPtr objects. More...

std::ostream &	operator<< (std::ostream &os, const NodeSharedPtr &n)

bool	operator== (EdgeSharedPtr const &p1, EdgeSharedPtr const &p2)
	Defines equality of two edges (equal if IDs of end nodes match in either ordering). More...

bool	operator< (EdgeSharedPtr const &p1, EdgeSharedPtr const &p2)
	Defines ordering between two edges (based on ID of edges). More...

bool	operator== (FaceSharedPtr const &p1, FaceSharedPtr const &p2)
	Defines equality of two faces (equal if IDs of vertices are the same.) More...

bool	operator< (FaceSharedPtr const &p1, FaceSharedPtr const &p2)
	Defines ordering between two faces (depending on ID of faces). More...

bool	operator== (const struct TetOrient &a, const struct TetOrient &b)

bool	operator== (ElmtConfig const &p1, ElmtConfig const &p2)

int **	helper2d (int lda, int arr[][2])

int **	helper2d (int lda, int arr[][4])

Variables
const char *const	ModuleTypeMap []

NekDouble	SQ_PNT_TOL =1e-16

Typedef Documentation

typedef std::map<unsigned int, CompositeSharedPtr> Nektar::Utilities::CompositeMap

Container of composites; key is the composite id, value is the composite.

Definition at line 1065 of file MeshElements.h.

typedef boost::shared_ptr<Composite> Nektar::Utilities::CompositeSharedPtr

Shared pointer to a composite.

Definition at line 1062 of file MeshElements.h.

typedef std::map<int,ConditionSharedPtr> Nektar::Utilities::ConditionMap

Definition at line 1097 of file MeshElements.h.

typedef boost::shared_ptr<Condition> Nektar::Utilities::ConditionSharedPtr

Definition at line 1096 of file MeshElements.h.

typedef boost::unordered_set<EdgeSharedPtr, EdgeHash> Nektar::Utilities::EdgeSet

Definition at line 342 of file MeshElements.h.

typedef boost::shared_ptr<Edge> Nektar::Utilities::EdgeSharedPtr

Shared pointer to an edge.

Definition at line 318 of file MeshElements.h.

typedef Nektar::LibUtilities::NekFactory<LibUtilities::ShapeType, Element, ElmtConfig, std::vector<NodeSharedPtr>, std::vector<int> > Nektar::Utilities::ElementFactory

Element factory definition.

Definition at line 1010 of file MeshElements.h.

typedef std::map<unsigned int, std::vector<ElementSharedPtr> > Nektar::Utilities::ElementMap

Container for elements; key is expansion dimension, value is vector of elements of that dimension.

Definition at line 1007 of file MeshElements.h.

typedef boost::shared_ptr<Element> Nektar::Utilities::ElementSharedPtr

Shared pointer to an element.

Definition at line 63 of file MeshElements.h.

typedef boost::unordered_set<FaceSharedPtr, FaceHash> Nektar::Utilities::FaceSet

Definition at line 574 of file MeshElements.h.

typedef boost::shared_ptr<Face> Nektar::Utilities::FaceSharedPtr

Shared pointer to a face.

Definition at line 550 of file MeshElements.h.

typedef boost::shared_ptr<Field> Nektar::Utilities::FieldSharedPtr

Definition at line 677 of file Field.hpp.

typedef HOTriangle<NodeSharedPtr> Nektar::Utilities::HOSurf

Definition at line 51 of file InputNek.h.

typedef boost::unordered_set<HOSurfSharedPtr, HOSurfHash> Nektar::Utilities::HOSurfSet

Definition at line 78 of file InputNek.h.

typedef boost::shared_ptr<HOSurf> Nektar::Utilities::HOSurfSharedPtr

Definition at line 52 of file InputNek.h.

typedef boost::shared_ptr<InputModule> Nektar::Utilities::InputModuleSharedPtr

Definition at line 193 of file FieldConvert/Module.h.

typedef boost::shared_ptr<InputPly> Nektar::Utilities::InputPlySharedPtr

Definition at line 65 of file InputPly.h.

typedef std::pair<int,int> Nektar::Utilities::ipair

Definition at line 54 of file ProcessTetSplit.cpp.

typedef boost::shared_ptr<Iso> Nektar::Utilities::IsoSharedPtr

Definition at line 186 of file ProcessIsoContour.h.

typedef boost::shared_ptr<Mesh> Nektar::Utilities::MeshSharedPtr

Shared pointer to a mesh.

Definition at line 1147 of file MeshElements.h.

typedef LibUtilities::NekFactory< ModuleKey, Module, MeshSharedPtr > Nektar::Utilities::ModuleFactory

Definition at line 228 of file FieldConvert/Module.h.

typedef std::pair< ModuleType, std::string > Nektar::Utilities::ModuleKey

Definition at line 223 of file FieldConvert/Module.h.

typedef boost::shared_ptr< Module > Nektar::Utilities::ModuleSharedPtr

Definition at line 226 of file FieldConvert/Module.h.

typedef boost::unordered_set<NodeSharedPtr, NodeHash> Nektar::Utilities::NodeSet

Definition at line 218 of file MeshElements.h.

typedef boost::shared_ptr<Node> Nektar::Utilities::NodeSharedPtr

Shared pointer to a Node.

Definition at line 195 of file MeshElements.h.

typedef map<int, pair<FaceSharedPtr, vector<int> > > Nektar::Utilities::PerMap

Definition at line 67 of file MeshConvert/Module.h.

typedef boost::unordered_set<struct TetOrient, TetOrientHash> Nektar::Utilities::TetOrientSet

Definition at line 1158 of file MeshElements.cpp.

typedef boost::unordered_map<TriFaceIDs, int, TriFaceHash> Nektar::Utilities::TriFaceMap

Definition at line 100 of file ProcessDisplacement.cpp.

Enumeration Type Documentation

enum Nektar::Utilities::ConditionType

Enumeration of condition types (Dirichlet, Neumann, etc).

Enumerator
eDirichlet
eNeumann
eRobin
ePeriodic
eHOPCondition
SIZE_ConditionType

Definition at line 1070 of file MeshElements.h.

         {
             eDirichlet,
             eNeumann,
             eRobin,
             ePeriodic,
             eHOPCondition,
             SIZE_ConditionType
         };

enum Nektar::Utilities::ModuleType

Denotes different types of mesh converter modules: so far only input, output and process modules are defined.

Enumerator
eInputModule
eProcessModule
eOutputModule
SIZE_ModuleType
eInputModule
eProcessModule
eOutputModule
SIZE_ModuleType

Definition at line 53 of file MeshConvert/Module.h.

                         {
             eInputModule,
             eProcessModule,
             eOutputModule,
             SIZE_ModuleType
         };

enum Nektar::Utilities::ModuleType

Denotes different types of mesh converter modules: so far only input, output and process modules are defined.

Enumerator
eInputModule
eProcessModule
eOutputModule
SIZE_ModuleType
eInputModule
eProcessModule
eOutputModule
SIZE_ModuleType

Definition at line 64 of file FieldConvert/Module.h.

         {
             eInputModule,
             eProcessModule,
             eOutputModule,
             SIZE_ModuleType
         };

enum Nektar::Utilities::NekCurve

Enumerator
eFile
eRecon

Definition at line 45 of file InputNek.h.

         {
             eFile,
             eRecon
         };

enum Nektar::Utilities::TecOutType

Enumerator
eFullBlockZone
eFullBlockZoneEquiSpaced
eSeperateZones

Definition at line 47 of file OutputTecplot.h.

 {
     eFullBlockZone,
     eFullBlockZoneEquiSpaced,
     eSeperateZones
 };

Function Documentation

ElementFactory & Nektar::Utilities::GetElementFactory ( )

Definition at line 60 of file MeshElements.cpp.

         {
             typedef Loki::SingletonHolder<ElementFactory,
                 Loki::CreateUsingNew,
                 Loki::NoDestroy > Type;
             return Type::Instance();
         }

ModuleFactory & Nektar::Utilities::GetModuleFactory ( )

Returns an instance of the module factory, held as a singleton.

Definition at line 49 of file FieldConvert/Module.cpp.

Referenced by main().

         {
             typedef Loki::SingletonHolder<ModuleFactory,
                 Loki::CreateUsingNew,
                 Loki::NoDestroy,
                 Loki::SingleThreaded> Type;
             return Type::Instance();
         }

int** Nektar::Utilities::helper2d	(	int	lda,
		int	arr[][2]
	)

Definition at line 59 of file ProcessBL.cpp.

Referenced by Nektar::Utilities::ProcessBL::Process().

         {
             int **ret = new int*[lda];
             for (int i = 0; i < lda; ++i)
             {
                 ret[i] = new int[2];
                 ret[i][0] = arr[i][0];
                 ret[i][1] = arr[i][1];
             }
             return ret;
         }

int** Nektar::Utilities::helper2d	(	int	lda,
		int	arr[][4]
	)

Definition at line 71 of file ProcessBL.cpp.

         {
             int **ret = new int*[lda];
             for (int i = 0; i < lda; ++i)
             {
                 ret[i] = new int[4];
                 ret[i][0] = arr[i][0];
                 ret[i][1] = arr[i][1];
                 ret[i][2] = arr[i][2];
                 ret[i][3] = arr[i][3];
             }
             return ret;
         }

bool Nektar::Utilities::operator!=	(	const IsoVertex &	x,
		const IsoVertex &	y
	)

Definition at line 644 of file ProcessIsoContour.cpp.

References Nektar::Utilities::IsoVertex::m_x, Nektar::Utilities::IsoVertex::m_y, and Nektar::Utilities::IsoVertex::m_z.

 {
     return ((x.m_x-y.m_x)*(x.m_x-y.m_x) + (x.m_y-y.m_y)*(x.m_y-y.m_y) +
             (x.m_z-y.m_z)*(x.m_z-y.m_z) < SQ_PNT_TOL)? 0:1;
 }

bool Nektar::Utilities::operator<	(	NodeSharedPtr const &	p1,
		NodeSharedPtr const &	p2
	)

Defines ordering between two NodeSharedPtr objects.

Definition at line 162 of file MeshElements.cpp.

         {
             return *p1 < *p2;
         }

bool Nektar::Utilities::operator<	(	EdgeSharedPtr const &	p1,
		EdgeSharedPtr const &	p2
	)

Defines ordering between two edges (based on ID of edges).

Definition at line 186 of file MeshElements.cpp.

         {
             return p1->m_id < p2->m_id;
         }

bool Nektar::Utilities::operator<	(	FaceSharedPtr const &	p1,
		FaceSharedPtr const &	p2
	)

Defines ordering between two faces (depending on ID of faces).

Definition at line 213 of file MeshElements.cpp.

         {
             return p1->m_id < p2->m_id;
         }

std::ostream & Nektar::Utilities::operator<<	(	std::ostream &	os,
		const ModuleKey &	rhs
	)

Prints a given module key to a stream.

Definition at line 61 of file FieldConvert/Module.cpp.

References ModuleTypeMap.

         {
             return os << ModuleTypeMap[rhs.first] << ": " << rhs.second;
         }

std::ostream & Nektar::Utilities::operator<<	(	std::ostream &	os,
		const NodeSharedPtr &	n
	)

Definition at line 167 of file MeshElements.cpp.

         {
             os << n->m_x << " " << n->m_y << " " << n->m_z;
             return os;
         }

bool Nektar::Utilities::operator==	(	ElmtConfig const &	p1,
		ElmtConfig const &	p2
	)

Definition at line 60 of file OutputGmsh.h.

References Nektar::Utilities::ElmtConfig::m_e, Nektar::Utilities::ElmtConfig::m_faceNodes, Nektar::Utilities::ElmtConfig::m_order, and Nektar::Utilities::ElmtConfig::m_volumeNodes.

         {
             return p1.m_e           == p2.m_e           &&
                    p1.m_faceNodes   == p2.m_faceNodes   &&
                    p1.m_volumeNodes == p2.m_volumeNodes &&
                    p1.m_order       == p2.m_order;
         }

bool Nektar::Utilities::operator==	(	TriFaceIDs const &	p1,
		TriFaceIDs const &	p2
	)

Definition at line 81 of file ProcessDisplacement.cpp.

References Nektar::Utilities::TriFaceIDs::a, Nektar::Utilities::TriFaceIDs::b, and Nektar::Utilities::TriFaceIDs::c.

     {
         std::vector<int> ids1(3), ids2(3);
 
         ids1[0] = p1.a;
         ids1[1] = p1.b;
         ids1[2] = p1.c;
         ids2[0] = p2.a;
         ids2[1] = p2.b;
         ids2[2] = p2.c;
 
         std::sort(ids1.begin(), ids1.end());
         std::sort(ids2.begin(), ids2.end());
 
         return ids1[0] == ids2[0] &&
                ids1[1] == ids2[1] &&
                ids1[2] == ids2[2];
     }

bool Nektar::Utilities::operator==	(	ConditionSharedPtr const &	c1,
		ConditionSharedPtr const &	c2
	)

Test equality of two conditions - i.e. compare types, fields and values but not composite ids.

Definition at line 126 of file MeshElements.cpp.

         {
             int i, n = c1->type.size();
             
             if (n != c2->type.size())
             {
                 return false;
             }
             
             for (i = 0; i < n; ++i)
             {
                 if (c1->type[i] != c2->type[i])
                 {
                     return false;
                 }
                 
                 if (c1->field[i] != c2->field[i] || c1->value[i] != c2->value[i])
                 {
                     return false;
                 }
             }
             
             return true;
         }

bool Nektar::Utilities::operator==	(	NodeSharedPtr const &	p1,
		NodeSharedPtr const &	p2
	)

Defines equality between two NodeSharedPtr objects.

Definition at line 154 of file MeshElements.cpp.

         {
             return *p1 == *p2;
         }

bool Nektar::Utilities::operator==	(	EdgeSharedPtr const &	p1,
		EdgeSharedPtr const &	p2
	)

Defines equality of two edges (equal if IDs of end nodes match in either ordering).

Definition at line 177 of file MeshElements.cpp.

         {
             return ( ((*(p1->m_n1) == *(p2->m_n1)) && (*(p1->m_n2) == *(p2->m_n2)))
                   || ((*(p1->m_n2) == *(p2->m_n1)) && (*(p1->m_n1) == *(p2->m_n2))));
         }

bool Nektar::Utilities::operator==	(	FaceSharedPtr const &	p1,
		FaceSharedPtr const &	p2
	)

Defines equality of two faces (equal if IDs of vertices are the same.)

Definition at line 195 of file MeshElements.cpp.

References Nektar::StdRegions::find(), and Nektar::iterator.

         {
             std::vector<NodeSharedPtr>::iterator it1, it2;
             for (it1 = p1->m_vertexList.begin(); it1 != p1->m_vertexList.end(); ++it1)
             {
                 if (find(p2->m_vertexList.begin(), p2->m_vertexList.end(), *it1)
                     == p2->m_vertexList.end())
                 {
                     return false;
                 }
             }
             return true;
         }

bool Nektar::Utilities::operator==	(	const IsoVertex &	x,
		const IsoVertex &	y
	)

Definition at line 637 of file ProcessIsoContour.cpp.

References Nektar::Utilities::IsoVertex::m_x, Nektar::Utilities::IsoVertex::m_y, and Nektar::Utilities::IsoVertex::m_z.

 {
     return ((x.m_x-y.m_x)*(x.m_x-y.m_x) + (x.m_y-y.m_y)*(x.m_y-y.m_y) +
             (x.m_z-y.m_z)*(x.m_z-y.m_z) < SQ_PNT_TOL)? true:false;
 }

bool Nektar::Utilities::operator==	(	HOSurfSharedPtr const &	p1,
		HOSurfSharedPtr const &	p2
	)

Compares two HOSurf objects referred to as shared pointers.

Two HOSurf objects are defined to be equal if they contain identical vertex ids contained in HOSurf::vertId.

Definition at line 1086 of file InputNek.cpp.

         {
             if (p1->vertId.size() != p2->vertId.size())
             {
                 return false;
             }
 
             vector<int> ids1 = p1->vertId;
             vector<int> ids2 = p2->vertId;
             sort(ids1.begin(), ids1.end());
             sort(ids2.begin(), ids2.end());
             
             for (int i = 0; i < ids1.size(); ++i)
             {
                 if (ids1[i] != ids2[i])
                     return false;
             }
             
             return true;
         }

bool Nektar::Utilities::operator==	(	const struct TetOrient &	a,
		const struct TetOrient &	b
	)

Definition at line 1160 of file MeshElements.cpp.

References Nektar::Utilities::TetOrient::nid.

         {
             if (a.nid.size() != b.nid.size())
             {
                 return false;
             }
             
             for (int i = 0; i < a.nid.size(); ++i)
             {
                 if (a.nid[i] != b.nid[i])
                 {
                     return false;
                 }
             }
             
             return true;
         }

static void Nektar::Utilities::PrismLineFaces	(	int	prismid,
		map< int, int > &	facelist,
		vector< vector< int > > &	FacesToPrisms,
		vector< vector< int > > &	PrismsToFaces,
		vector< bool > &	PrismDone
	)

static

Definition at line 423 of file InputStar.cpp.

Referenced by PrismLineFaces(), Nektar::Utilities::InputStar::ResetNodes(), and Nektar::Utilities::InputTec::ResetNodes().

         {
             if(PrismDone[prismid] == false)
             {
                 PrismDone[prismid] = true;
                 
                 // Add faces0  
                 int face = PrismToFaces[prismid][0];
                 facelist[face] = face;
                 for(int i = 0; i < FaceToPrisms[face].size(); ++i)
                 {
                     PrismLineFaces(FaceToPrisms[face][i], facelist, FaceToPrisms, 
                                    PrismToFaces, PrismDone);
                 }
                 
                 // Add faces1
                 face = PrismToFaces[prismid][1];
                 facelist[face] = face;
                 for(int i = 0; i < FaceToPrisms[face].size(); ++i)
                 {
                     PrismLineFaces(FaceToPrisms[face][i], facelist, FaceToPrisms, 
                                    PrismToFaces, PrismDone);
                 }
             }
         }         

static void Nektar::Utilities::PrismLineFaces	(	int	prismid,
		map< int, int > &	facelist,
		vector< vector< int > > &	FacesToPrisms,
		vector< vector< int > > &	PrismsToFaces,
		vector< bool > &	PrismDone
	)

static

Definition at line 647 of file InputStarTec.cpp.

References PrismLineFaces().

         {
             if(PrismDone[prismid] == false)
             {
                 PrismDone[prismid] = true;
                 
                 // Add faces0  
                 int face = PrismToFaces[prismid][0];
                 facelist[face] = face;
                 for(int i = 0; i < FaceToPrisms[face].size(); ++i)
                 {
                     PrismLineFaces(FaceToPrisms[face][i], facelist, FaceToPrisms, 
                              PrismToFaces, PrismDone);
                 }
                 
                 // Add faces1
                 face = PrismToFaces[prismid][1];
                 facelist[face] = face;
                 for(int i = 0; i < FaceToPrisms[face].size(); ++i)
                 {
                     PrismLineFaces(FaceToPrisms[face][i], facelist, FaceToPrisms, 
                              PrismToFaces, PrismDone);
                 }
             }
         }         

std::vector<int> Nektar::Utilities::quadTensorNodeOrdering	(	const std::vector< int > &	nodes,
		int	n
	)

Reorder a quadrilateral to appear in Nektar++ ordering from Gmsh.

Definition at line 59 of file InputGmsh.cpp.

Referenced by Nektar::Utilities::InputGmsh::HexReordering(), and Nektar::Utilities::InputGmsh::QuadReordering().

         {
             std::vector<int> nodeList;
 
             // Triangle
             nodeList.resize(nodes.size());
 
             // Vertices and edges
             nodeList[0] = nodes[0];
             if (n > 1)
             {
                 nodeList[n-1] = nodes[1];
                 nodeList[n*n-1] = nodes[2];
                 nodeList[n*(n-1)] = nodes[3];
             }
             for (int i = 1; i < n-1; ++i)
             {
                 nodeList[i] = nodes[4+i-1];
             }
             for (int i = 1; i < n-1; ++i)
             {
                 nodeList[n*n-1-i] = nodes[4+2*(n-2)+i-1];
             }
 
             // Interior (recursion)
             if (n > 2)
             {
                 // Reorder interior nodes
                 std::vector<int> interior((n-2)*(n-2));
                 std::copy(nodes.begin() + 4+4*(n-2), nodes.end(), interior.begin());
                 interior = quadTensorNodeOrdering(interior, n-2);
 
                 // Copy into full node list
                 for (int j = 1; j < n-1; ++j)
                 {
                     nodeList[j*n] = nodes[4+3*(n-2)+n-2-j];
                     for (int i = 1; i < n-1; ++i)
                     {
                         nodeList[j*n+i] = interior[(j-1)*(n-2)+(i-1)];
                     }
                     nodeList[(j+1)*n-1] = nodes[4+(n-2)+j-1];
                 }
             }
 
             return nodeList;
         }

bool Nektar::Utilities::same	(	NekDouble	x1,
		NekDouble	y1,
		NekDouble	z1,
		NekDouble	x2,
		NekDouble	y2,
		NekDouble	z2
	)

Definition at line 651 of file ProcessIsoContour.cpp.

Referenced by Nektar::SpatialDomains::GeomFactors::ComputeDeriv(), and Nektar::Utilities::Iso::globalcondense().

 {
     if((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2) < SQ_PNT_TOL)
     {
         return true;
     }
 
     return false;
 }

void Nektar::Utilities::ThreeSimilar	(	const int	i,
		const int	j,
		const int	k,
		int &	pr,
		int &	ps
	)

Definition at line 227 of file ProcessIsoContour.cpp.

References ASSERTL0.

Referenced by Nektar::Utilities::ProcessIsoContour::ExtractContour().

 {
     switch (i + j + k)
     {
         case (3):
             pr = 3;
             ps = 4;
             break;
         case (4):
             pr = 2;
             ps = 4;
             break;
         case (5):
             if (j == 1)
             {
                 pr = 2;
                 ps = 3;
             }
             else
             {
                 pr = 1;
                 ps = 4;
             }
             break;
         case (6):
             if (i == 0)
             {
                 pr = 1;
                 ps = 3;
             }
             else
             {
                 pr = 0;
                 ps = 4;
             }
             break;
         case (7):
             if (i == 0)
             {
                 pr = 1;
                 ps = 2;
             }
             else
             {
                 pr = 0;
                 ps = 3;
             }
             break;
         case (8):
             pr = 0;
             ps = 2;
             break;
         case (9):
             pr = 0;
             ps = 1;
             break;
         default:
             ASSERTL0(false,"Error in 5-point triangulation in ThreeSimilar");
             break;
     }
 }

std::vector<int> Nektar::Utilities::triTensorNodeOrdering	(	const std::vector< int > &	nodes,
		int	n
	)

Definition at line 107 of file InputGmsh.cpp.

Referenced by Nektar::Utilities::InputGmsh::TetReordering(), and Nektar::Utilities::InputGmsh::TriReordering().

         {
             std::vector<int> nodeList;
             int cnt2;
 
             nodeList.resize(nodes.size());
 
             // Vertices
             nodeList[0] = nodes[0];
             if (n > 1)
             {
                 nodeList[n-1] = nodes[1];
                 nodeList[n*(n+1)/2 - 1] = nodes[2];
             }
 
             // Edges
             int cnt = n;
             for (int i = 1; i < n-1; ++i)
             {
                 nodeList[i]         = nodes[3+i-1];
                 nodeList[cnt]       = nodes[3+3*(n-2)-i];
                 nodeList[cnt+n-i-1] = nodes[3+(n-2)+i-1];
                 cnt += n-i;
             }
 
             // Interior (recursion)
             if (n > 3)
             {
                 // Reorder interior nodes
                 std::vector<int> interior((n-3)*(n-2)/2);
                 std::copy(nodes.begin() + 3+3*(n-2), nodes.end(), interior.begin());
                 interior = triTensorNodeOrdering(interior, n-3);
 
                 // Copy into full node list
                 cnt = n;
                 cnt2 = 0;
                 for (int j = 1; j < n-2; ++j)
                 {
                     for (int i = 0; i < n-j-2; ++i)
                     {
                         nodeList[cnt+i+1] = interior[cnt2+i];
                     }
                     cnt += n-j;
                     cnt2 += n-2-j;
                 }
             }
 
             return nodeList;
         }

void Nektar::Utilities::TwoPairs	(	Array< OneD, NekDouble > &	cx,
		Array< OneD, NekDouble > &	cy,
		Array< OneD, NekDouble > &	cz,
		int &	pr
	)

Definition at line 195 of file ProcessIsoContour.cpp.

Referenced by Nektar::Utilities::ProcessIsoContour::ExtractContour().

 {
     if (((cx[0]-cx[1])==0.0)&&
         ((cy[0]-cy[1])==0.0)&&
         ((cz[0]-cz[1])==0.0))
     {
         if (((cx[2]-cx[3])==0.0)&&
             ((cy[2]-cy[3])==0.0)&&
             ((cz[2]-cz[3])==0.0))
         {
             pr=4;
         }
         else
         {
             pr=3;
         }
     }
     else
     {
         pr=1;
     }
 }

Variable Documentation

const char *const Nektar::Utilities::ModuleTypeMap

Initial value:

=
        {
            "Input",
            "Process",
            "Output"
        }

Definition at line 72 of file FieldConvert/Module.h.

Referenced by operator<<().

NekDouble Nektar::Utilities::SQ_PNT_TOL =1e-16

Definition at line 634 of file ProcessIsoContour.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation