Namespaces
	CADOrientation

	CADType

Classes
class	BLMesh

class	BPoint
	class for a planar boundary based samlping Point More...

class	CADCurve
	base class for CAD curves. More...

class	CADCurveCFI

class	CADCurveOCE

class	CADObject

class	CADSurf
	base class for a cad surface More...

class	CADSurfCFI

class	CADSurfOCE

class	CADSystem
	Base class for CAD interface system. More...

class	CADSystemCFI

class	CADSystemOCE

class	CADVert
	base class for CAD verticies. More...

class	CADVertCFI

class	CADVertOCE

class	CFIMesh
	class containing all surface meshing routines methods and classes More...

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	CPoint
	class for a curvature based samlping Point More...

class	CurveMesh
	class for meshing individual curves (1d meshing) More...

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

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

struct	EdgeLoop
	struct which descibes a collection of cad edges which are a loop on the cad surface More...

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...

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

struct	FaceHash

class	FaceMesh
	class for surface meshes on individual surfaces (paramter plane meshes) More...

class	Generator2D
	class containing all surface meshing routines methods and classes More...

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

struct	HOQuadrilateral
	A lightweight struct for dealing with high-order quadrilateral alignment. More...

class	HOSurfaceMesh

struct	HOSurfHash

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

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

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

struct	linesource

class	Mesh

class	Module

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

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

class	Octant
	this class contains the infomration and methods for individal octants in the Octree More...

class	Octree
	class for octree More...

class	OptiEdge

class	OptiObj

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

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

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

class	ProcessLoadCAD

class	ProcessLoadOctree

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

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

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

class	SPBase
	base class of sizing point for octree construction these carry information the octree needs and have various types More...

class	SrcPoint
	class for a general source point More...

class	SurfaceMesh
	class containing all surface meshing routines methods and classes More...

class	TetGenInterface
	Class for interacting with the external library TetGen. More...

class	TetMesh
	class for taking surface mesh and octree spec and making a 3d tet mesh More...

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

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

class	TriangleInterface
	class for interfacing with external library triangle More...

class	VolumeMesh

Typedefs
typedef std::shared_ptr< CADVert >	CADVertSharedPtr

typedef std::shared_ptr< CADSurf >	CADSurfSharedPtr

typedef std::shared_ptr< CADCurve >	CADCurveSharedPtr

typedef LibUtilities::NekFactory< std::string, CADCurve >	CADCurveFactory

typedef std::shared_ptr< CADObject >	CADObjectSharedPtr

typedef std::shared_ptr< EdgeLoop >	EdgeLoopSharedPtr

typedef LibUtilities::NekFactory< std::string, CADSurf >	CADSurfFactory

typedef std::shared_ptr< CADSystem >	CADSystemSharedPtr

typedef LibUtilities::NekFactory< std::string, CADSystem, std::string >	EngineFactory

typedef std::shared_ptr< Node >	NodeSharedPtr

typedef LibUtilities::NekFactory< std::string, CADVert >	CADVertFactory

typedef std::shared_ptr< CADSystemCFI >	CADSystemCFISharedPtr

typedef std::shared_ptr< CADSystemOCE >	CADSystemOCESharedPtr

typedef std::shared_ptr< TetGenInterface >	TetGenInterfaceSharedPtr

typedef std::shared_ptr< TriangleInterface >	TriangleInterfaceSharedPtr

typedef std::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 std::shared_ptr< Element >	ElementSharedPtr

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

typedef std::unordered_set< EdgeSharedPtr, EdgeHash >	EdgeSet

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 std::shared_ptr< Face >	FaceSharedPtr

typedef std::unordered_set< FaceSharedPtr, FaceHash >	FaceSet

typedef HOTriangle< NodeSharedPtr >	HOSurf

typedef std::shared_ptr< HOSurf >	HOSurfSharedPtr

typedef std::unordered_set< HOSurfSharedPtr, HOSurfHash >	HOSurfSet

typedef std::shared_ptr< Octree >	OctreeSharedPtr

typedef std::shared_ptr< Condition >	ConditionSharedPtr

typedef std::map< int, ConditionSharedPtr >	ConditionMap

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

typedef std::unordered_set< NodeSharedPtr, NodeHash >	NodeSet

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

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

typedef std::shared_ptr< Module >	ModuleSharedPtr

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

typedef std::shared_ptr< Octant >	OctantSharedPtr

typedef std::shared_ptr< SPBase >	SPBaseSharedPtr

typedef std::shared_ptr< CPoint >	CPointSharedPtr

typedef std::shared_ptr< BPoint >	BPointSharedPtr

typedef std::shared_ptr< SrcPoint >	SrcPointSharedPtr

typedef std::shared_ptr< OptiObj >	OptiObjSharedPtr

typedef std::shared_ptr< CurveMesh >	CurveMeshSharedPtr

typedef std::shared_ptr< FaceMesh >	FaceMeshSharedPtr

typedef std::shared_ptr< OptiEdge >	OptiEdgeSharedPtr

typedef std::shared_ptr< BLMesh >	BLMeshSharedPtr

typedef std::shared_ptr< TetMesh >	TetMeshSharedPtr

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

enum	ModuleType { eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType }

enum	OctantFace { eUp, eDown, eForward, eBack, eLeft, eRight }
	enumeration of the 6 faces of a cube/octant More...

enum	OctantLocation { eInside, eOutside, eOnBoundary, eUnknown }
	enumeration of the possible locations of the octree with respect to the CAD More...

enum	SPType { eCBoundary, ePBoundary, eSrcPoint }

Functions
CADCurveFactory &	GetCADCurveFactory ()

CADSurfFactory &	GetCADSurfFactory ()

EngineFactory &	GetEngineFactory ()

CADVertFactory &	GetCADVertFactory ()

void	P (NekDouble t, NekDouble &x, NekDouble &y, NekDouble &z)

void	P (Array< OneD, NekDouble > uv, NekDouble &x, NekDouble &y, NekDouble &z)

void	filterModShape (TopTools_DataMapOfShapeShape &modShape, TopoDS_Shape &S)

bool	operator== (ElmtConfig const &c1, ElmtConfig const &c2)
	Compares two element config structs. More...

bool	operator== (ElementSharedPtr const &e1, ElementSharedPtr const &e2)
	Compares two element shared pointers. More...

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

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)
	Compares two nodes for inequality based on IDs. 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)
	Print description of node to given ostream. More...

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...

ElementFactory &	GetElementFactory ()

template<typename K >
void	sort3 (K &x, K &y, K &z)
	Helper function to sort 3 numbers using sorting network. More...

ModuleFactory &	GetModuleFactory ()

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

OctantFace	GetReverseFace (OctantFace f)

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

bool	BGFSUpdate (OptiObjSharedPtr opti, DNekMat &J, DNekMat &B, DNekMat &H)

NekDouble	Dot (Array< OneD, NekDouble > a, Array< OneD, NekDouble > b)

Array< OneD, NekDouble >	Take (Array< OneD, NekDouble > a, Array< OneD, NekDouble > b)

Array< OneD, NekDouble >	Times (NekDouble t, Array< OneD, NekDouble > a)

Array< OneD, NekDouble >	Add (Array< OneD, NekDouble > a, Array< OneD, NekDouble > b)

box	GetBox (ElementSharedPtr el, NekDouble ov)

box	GetBox (vector< ElementSharedPtr > els, NekDouble ov)

box	GetBox (NodeSharedPtr n, NekDouble ov)

bool	Infont (NodeSharedPtr n, ElementSharedPtr el)

bool	sign (NekDouble a, NekDouble b)

Variables
const char *const	ModuleTypeMap []

Typedef Documentation

◆ BLMeshSharedPtr

typedef std::shared_ptr<BLMesh> Nektar::NekMeshUtils::BLMeshSharedPtr

Definition at line 138 of file BLMesh.h.

◆ BPointSharedPtr

typedef std::shared_ptr<BPoint> Nektar::NekMeshUtils::BPointSharedPtr

Definition at line 240 of file SourcePoint.hpp.

◆ CADCurveFactory

typedef LibUtilities::NekFactory<std::string, CADCurve> Nektar::NekMeshUtils::CADCurveFactory

Definition at line 221 of file CADCurve.h.

◆ CADCurveSharedPtr

typedef std::shared_ptr< CADCurve > Nektar::NekMeshUtils::CADCurveSharedPtr

Definition at line 219 of file CADCurve.h.

◆ CADObjectSharedPtr

typedef std::shared_ptr<CADObject> Nektar::NekMeshUtils::CADObjectSharedPtr

Definition at line 133 of file CADObject.h.

◆ CADSurfFactory

typedef LibUtilities::NekFactory<std::string, CADSurf> Nektar::NekMeshUtils::CADSurfFactory

Definition at line 216 of file CADSurf.h.

◆ CADSurfSharedPtr

typedef std::shared_ptr< CADSurf > Nektar::NekMeshUtils::CADSurfSharedPtr

Definition at line 51 of file CADCurve.h.

◆ CADSystemCFISharedPtr

typedef std::shared_ptr<CADSystemCFI> Nektar::NekMeshUtils::CADSystemCFISharedPtr

Definition at line 104 of file CADSystemCFI.h.

◆ CADSystemOCESharedPtr

typedef std::shared_ptr<CADSystemOCE> Nektar::NekMeshUtils::CADSystemOCESharedPtr

Definition at line 88 of file CADSystemOCE.h.

◆ CADSystemSharedPtr

typedef std::shared_ptr<CADSystem> Nektar::NekMeshUtils::CADSystemSharedPtr

Definition at line 240 of file CADSystem.h.

◆ CADVertFactory

typedef LibUtilities::NekFactory<std::string, CADVert> Nektar::NekMeshUtils::CADVertFactory

Definition at line 139 of file CADVert.h.

◆ CADVertSharedPtr

typedef std::shared_ptr< CADVert > Nektar::NekMeshUtils::CADVertSharedPtr

Definition at line 49 of file CADCurve.h.

◆ CompositeMap

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

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

Definition at line 73 of file Composite.h.

◆ CompositeSharedPtr

typedef std::shared_ptr<Composite> Nektar::NekMeshUtils::CompositeSharedPtr

Shared pointer to a composite.

Definition at line 70 of file Composite.h.

◆ ConditionMap

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

Definition at line 86 of file Mesh.h.

◆ ConditionSharedPtr

typedef std::shared_ptr<Condition> Nektar::NekMeshUtils::ConditionSharedPtr

Definition at line 85 of file Mesh.h.

◆ CPointSharedPtr

typedef std::shared_ptr<CPoint> Nektar::NekMeshUtils::CPointSharedPtr

Definition at line 184 of file SourcePoint.hpp.

◆ CurveMeshSharedPtr

typedef std::shared_ptr<CurveMesh> Nektar::NekMeshUtils::CurveMeshSharedPtr

Definition at line 51 of file CurveMesh.h.

◆ EdgeLoopSharedPtr

typedef std::shared_ptr<EdgeLoop> Nektar::NekMeshUtils::EdgeLoopSharedPtr

Definition at line 65 of file CADSurf.h.

◆ EdgeSet

typedef std::unordered_set<EdgeSharedPtr, EdgeHash> Nektar::NekMeshUtils::EdgeSet

Definition at line 159 of file Edge.h.

◆ EdgeSharedPtr

typedef std::shared_ptr<Edge> Nektar::NekMeshUtils::EdgeSharedPtr

Shared pointer to an edge.

Definition at line 136 of file Edge.h.

◆ ElementFactory

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

Element factory definition.

Definition at line 497 of file Element.h.

◆ ElementMap

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

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

Definition at line 491 of file Element.h.

◆ ElementSharedPtr

typedef std::shared_ptr< Element > Nektar::NekMeshUtils::ElementSharedPtr

Definition at line 49 of file Edge.h.

◆ EngineFactory

typedef LibUtilities::NekFactory<std::string, CADSystem, std::string> Nektar::NekMeshUtils::EngineFactory

Definition at line 242 of file CADSystem.h.

◆ FaceMeshSharedPtr

typedef std::shared_ptr<FaceMesh> Nektar::NekMeshUtils::FaceMeshSharedPtr

Definition at line 165 of file FaceMesh.h.

◆ FaceSet

typedef std::unordered_set<FaceSharedPtr, FaceHash> Nektar::NekMeshUtils::FaceSet

Definition at line 181 of file Face.h.

◆ FaceSharedPtr

typedef std::shared_ptr<Face> Nektar::NekMeshUtils::FaceSharedPtr

Definition at line 155 of file Face.h.

◆ HOSurf

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

Definition at line 179 of file HOAlignment.h.

◆ HOSurfSet

typedef std::unordered_set<HOSurfSharedPtr, HOSurfHash> Nektar::NekMeshUtils::HOSurfSet

Definition at line 202 of file HOAlignment.h.

◆ HOSurfSharedPtr

typedef std::shared_ptr<HOSurf> Nektar::NekMeshUtils::HOSurfSharedPtr

Definition at line 180 of file HOAlignment.h.

◆ MeshSharedPtr

typedef std::shared_ptr<Mesh> Nektar::NekMeshUtils::MeshSharedPtr

Shared pointer to a mesh.

Definition at line 156 of file Mesh.h.

◆ ModuleFactory

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

Definition at line 259 of file NekMeshUtils/Module/Module.h.

◆ ModuleKey

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

Definition at line 255 of file NekMeshUtils/Module/Module.h.

◆ ModuleSharedPtr

typedef std::shared_ptr<Module> Nektar::NekMeshUtils::ModuleSharedPtr

Definition at line 258 of file NekMeshUtils/Module/Module.h.

◆ NodeSet

typedef std::unordered_set<NodeSharedPtr, NodeHash> Nektar::NekMeshUtils::NodeSet

Definition at line 447 of file Node.h.

◆ NodeSharedPtr

typedef std::shared_ptr< Node > Nektar::NekMeshUtils::NodeSharedPtr

Definition at line 49 of file CADVert.h.

◆ OctantSharedPtr

typedef std::shared_ptr<Octant> Nektar::NekMeshUtils::OctantSharedPtr

Definition at line 73 of file Octant.h.

◆ OctreeSharedPtr

typedef std::shared_ptr< Octree > Nektar::NekMeshUtils::OctreeSharedPtr

Definition at line 51 of file Mesh.h.

◆ OptiEdgeSharedPtr

typedef std::shared_ptr<OptiEdge> Nektar::NekMeshUtils::OptiEdgeSharedPtr

Definition at line 81 of file OptimiseFunctions.h.

◆ OptiObjSharedPtr

typedef std::shared_ptr<OptiObj> Nektar::NekMeshUtils::OptiObjSharedPtr

Definition at line 104 of file OptimiseObj.h.

◆ PerMap

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

Definition at line 77 of file NekMeshUtils/Module/Module.h.

◆ SPBaseSharedPtr

typedef std::shared_ptr<SPBase> Nektar::NekMeshUtils::SPBaseSharedPtr

Definition at line 131 of file SourcePoint.hpp.

◆ SrcPointSharedPtr

typedef std::shared_ptr<SrcPoint> Nektar::NekMeshUtils::SrcPointSharedPtr

Definition at line 283 of file SourcePoint.hpp.

◆ TetGenInterfaceSharedPtr

typedef std::shared_ptr<TetGenInterface> Nektar::NekMeshUtils::TetGenInterfaceSharedPtr

Definition at line 99 of file TetGenInterface.h.

◆ TetMeshSharedPtr

typedef std::shared_ptr<TetMesh> Nektar::NekMeshUtils::TetMeshSharedPtr

Definition at line 86 of file TetMesh.h.

◆ TriangleInterfaceSharedPtr

typedef std::shared_ptr<TriangleInterface> Nektar::NekMeshUtils::TriangleInterfaceSharedPtr

Definition at line 131 of file TriangleInterface.h.

Enumeration Type Documentation

◆ ConditionType

enum Nektar::NekMeshUtils::ConditionType

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

Enumerator
eDirichlet
eNeumann
eRobin
ePeriodic
eHOPCondition
SIZE_ConditionType

Definition at line 57 of file Mesh.h.

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

◆ ModuleType

enum Nektar::NekMeshUtils::ModuleType

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

Enumerator
eInputModule
eProcessModule
eOutputModule
SIZE_ModuleType

Definition at line 63 of file NekMeshUtils/Module/Module.h.

                     {
         eInputModule,
         eProcessModule,
         eOutputModule,
         SIZE_ModuleType
     };

◆ OctantFace

enum Nektar::NekMeshUtils::OctantFace

enumeration of the 6 faces of a cube/octant

Enumerator
eUp
eDown
eForward
eBack
eLeft
eRight

Definition at line 51 of file Octant.h.

 {
     eUp,
     eDown,
     eForward,
     eBack,
     eLeft,
     eRight
 };

◆ OctantLocation

enum Nektar::NekMeshUtils::OctantLocation

enumeration of the possible locations of the octree with respect to the CAD

Enumerator
eInside
eOutside
eOnBoundary
eUnknown

Definition at line 65 of file Octant.h.

 {
     eInside,
     eOutside,
     eOnBoundary,
     eUnknown
 };

◆ SPType

enum Nektar::NekMeshUtils::SPType

Enumerator
eCBoundary
ePBoundary
eSrcPoint

Definition at line 48 of file SourcePoint.hpp.

 {
     eCBoundary,  // on a curved boundary
     ePBoundary, // on a planar boundary (R=inf)
     eSrcPoint   // source point
 };

Function Documentation

◆ Add()

Array<OneD, NekDouble> Nektar::NekMeshUtils::Add	(	Array< OneD, NekDouble >	a,
		Array< OneD, NekDouble >	b
	)

Definition at line 64 of file OptimiseFunctions.cpp.

 {
     Array<OneD, NekDouble> ret(3);
     ret[0] = a[0] + b[0];
     ret[1] = a[1] + b[1];
     ret[2] = a[2] + b[2];
     return ret;
 }

◆ BGFSUpdate()

bool Nektar::NekMeshUtils::BGFSUpdate	(	OptiObjSharedPtr	opti,
		DNekMat &	J,
		DNekMat &	B,
		DNekMat &	H
	)

Definition at line 49 of file BGFS-B.cpp.

References Vmath::Vsub().

Referenced by Nektar::NekMeshUtils::HOSurfaceMesh::Process().

 {
 
     Array<OneD, NekDouble> xi = opti->Getxi();
     Array<OneD, NekDouble> ui = opti->Getui();
     Array<OneD, NekDouble> li = opti->Getli();
 
     set<int> Fset;
     Array<OneD, NekDouble> ti(xi.num_elements());
     for (int i = 0; i < ti.num_elements(); i++)
     {
         if (J(i, 0) < 0)
         {
             ti[i] = (xi[i] - ui[i]) / J(i, 0);
         }
         else if (J(i, 0) > 0)
         {
             ti[i] = (xi[i] - li[i]) / J(i, 0);
         }
         else
         {
             ti[i] = numeric_limits<double>::max();
         }
         if (ti[i] > 0)
         {
             Fset.insert(i);
         }
     }
 
     // intitialise d
     DNekMat d(xi.num_elements(), 1);
     for (int i = 0; i < xi.num_elements(); i++)
     {
         if (fabs(ti[i]) < 1E-10)
         {
             d(i, 0) = 0;
         }
         else
         {
             d(i, 0) = -1.0 * J(i, 0);
         }
     }
 
     Array<OneD, NekDouble> xci(xi.num_elements());
 
     for (int i = 0; i < xci.num_elements(); i++)
     {
         if (xi[i] + d(i, 0) < li[i])
         {
             xci[i] = li[i];
             Fset.erase(i);
             continue;
         }
         else
         {
             xci[i] = xi[i] + d(i, 0);
         }
 
         if (xi[i] + d(i, 0) > ui[i])
         {
             xci[i] = ui[i];
             Fset.erase(i);
             continue;
         }
         else
         {
             xci[i] = xi[i] + d(i, 0);
         }
     }
 
     DNekMat Z(xci.num_elements(), xci.num_elements(), 0.0);
 
     set<int>::iterator it;
     for (int i = 0; i < xci.num_elements(); i++)
     {
         it = Fset.find(i);
         if (it != Fset.end())
         {
             Z(i, i) = 1.0;
         }
     }
 
     DNekMat dx(xci.num_elements(), 1, 0.0);
     for (int i = 0; i < xci.num_elements(); i++)
     {
         dx(i, 0) = xci[i] - xi[i];
     }
 
     DNekMat rg = Z * (J + B * dx);
 
     DNekMat du = -1.0 * H * rg;
 
     NekDouble alpha = 1.0;
     for (it = Fset.begin(); it != Fset.end(); it++)
     {
         int i = (*it);
         if (li[i] - xci[i] > alpha * du(i, 0))
         {
             alpha = min(alpha, (li[i] - xci[i]) / du(i, 0));
         }
         else if (ui[i] - xci[i] < alpha * du(i, 0))
         {
             alpha = min(alpha, (ui[i] - xci[i]) / du(i, 0));
         }
     }
 
     DNekMat grad = alpha * du;
 
     Array<OneD, NekDouble> dk(xci.num_elements()), xibar(xci.num_elements());
     for (int i = 0; i < xci.num_elements(); i++)
     {
         set<int>::iterator f = Fset.find(i);
         if (f != Fset.end())
         {
             xibar[i] = xci[i] + grad(i, 0);
         }
         else
         {
             xibar[i] = xci[i];
         }
     }
 
     Vmath::Vsub(xci.num_elements(), &xibar[0], 1, &xi[0], 1, &dk[0], 1);
 
     NekDouble c = 0.0;
     NekDouble r = 0.0;
     NekDouble l = 0.0;
     for (int i = 0; i < dk.num_elements(); i++)
     {
         c += 1E-4 * J(i, 0) * dk[i];
         r += J(i, 0) * dk[i];
     }
 
     /*cout << endl << J << endl << endl;
 
     for(int i = 0; i < dk.num_elements(); i++)
     {
         cout << dk[i] << endl;
     }
     cout << endl;*/
 
     // this section needs a case evaluation for edges on faces
     NekDouble lam = 2.0;
     int iterct    = 0;
     NekDouble fo  = opti->F(xi);
     NekDouble fn;
     Array<OneD, NekDouble> tst(xi.num_elements());
     do
     {
         if (iterct > 100)
         {
             // cout << "failed line search" << endl;
             return false;
         }
         iterct++;
 
         lam *= 0.5;
 
         for (int i = 0; i < xi.num_elements(); i++)
         {
             tst[i] = xi[i] + lam * dk[i];
         }
 
         fn = opti->F(tst);
 
         DNekMat jn = opti->dF(tst);
 
         l = 0.0;
         for (int i = 0; i < dk.num_elements(); i++)
         {
             l += jn(i, 0) * dk[i];
         }
 
     } while (fn > fo + c || fabs(l) > 1.0 * fabs(r));
     // wolfe conditions
 
     // tst at this point is the new all vector
     // now need to update hessians
     DNekMat Jn = opti->dF(tst);
     DNekMat y  = Jn - J;
     DNekMat yT = Jn - J;
     yT.Transpose();
     DNekMat s(dk.num_elements(), 1, 0.0);
     for (int i = 0; i < dk.num_elements(); i++)
     {
         s(i, 0) = lam * dk[i];
     }
     DNekMat sT = s;
     sT.Transpose();
 
     DNekMat d1 = yT * s;
     DNekMat d2 = sT * B * s;
     DNekMat d3 = sT * y;
     DNekMat n1 = yT * H * y;
 
     NekDouble ynorm = 0.0;
     for (int i = 0; i < dk.num_elements(); i++)
     {
         ynorm += y(i, 0) * y(i, 0);
     }
 
     if (d3(0, 0) > 2.2E-16 * ynorm)
     {
         B = B + y * yT * (1.0 / d1(0, 0)) - B * s * sT * B * (1.0 / d2(0, 0));
         H = H + (d3(0, 0) + n1(0, 0)) / d3(0, 0) / d3(0, 0) * s * sT -
             1.0 / d3(0, 0) * (H * y * sT + s * yT * H);
     }
 
     J = Jn;
     opti->Update(tst);
 
     return true;
 }

◆ Dot()

NekDouble Nektar::NekMeshUtils::Dot	(	Array< OneD, NekDouble >	a,
		Array< OneD, NekDouble >	b
	)

inline

Definition at line 44 of file OptimiseFunctions.cpp.

Referenced by Nektar::NekMeshUtils::OptiEdge::dF().

 {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }

◆ filterModShape()

void Nektar::NekMeshUtils::filterModShape	(	TopTools_DataMapOfShapeShape &	modShape,
		TopoDS_Shape &	S
	)

Definition at line 56 of file CADSystemOCE.cpp.

Referenced by Nektar::NekMeshUtils::CADSystemOCE::LoadCAD().

 {
     bool repeat = true;
     while (repeat)
     {
         repeat = false;
         if (modShape.IsBound(S))
         {
             repeat = true;
             S      = modShape.Find(S);
         }
     }
 }

◆ GetBox() [1/3]

box Nektar::NekMeshUtils::GetBox	(	ElementSharedPtr	el,
		NekDouble	ov
	)

inline

Definition at line 63 of file BLMesh.cpp.

 {
     NekDouble xmin = numeric_limits<double>::max(),
               xmax = -1.0 * numeric_limits<double>::max(),
               ymin = numeric_limits<double>::max(),
               ymax = -1.0 * numeric_limits<double>::max(),
               zmin = numeric_limits<double>::max(),
               zmax = -1.0 * numeric_limits<double>::max();
 
     vector<NodeSharedPtr> ns = el->GetVertexList();
     for (int i = 0; i < ns.size(); i++)
     {
         xmin = min(xmin, ns[i]->m_x);
         xmax = max(xmax, ns[i]->m_x);
         ymin = min(ymin, ns[i]->m_y);
         ymax = max(ymax, ns[i]->m_y);
         zmin = min(zmin, ns[i]->m_z);
         zmax = max(zmax, ns[i]->m_z);
     }
 
     return box(point(xmin - ov, ymin - ov, zmin - ov),
                point(xmax + ov, ymax + ov, zmax + ov));
 }

◆ GetBox() [2/3]

box Nektar::NekMeshUtils::GetBox	(	vector< ElementSharedPtr >	els,
		NekDouble	ov
	)

inline

Definition at line 87 of file BLMesh.cpp.

 {
     NekDouble xmin = numeric_limits<double>::max(),
               xmax = -1.0 * numeric_limits<double>::max(),
               ymin = numeric_limits<double>::max(),
               ymax = -1.0 * numeric_limits<double>::max(),
               zmin = numeric_limits<double>::max(),
               zmax = -1.0 * numeric_limits<double>::max();
 
     for (int j = 0; j < els.size(); j++)
     {
         vector<NodeSharedPtr> ns = els[j]->GetVertexList();
         for (int i = 0; i < ns.size(); i++)
         {
             xmin = min(xmin, ns[i]->m_x);
             xmax = max(xmax, ns[i]->m_x);
             ymin = min(ymin, ns[i]->m_y);
             ymax = max(ymax, ns[i]->m_y);
             zmin = min(zmin, ns[i]->m_z);
             zmax = max(zmax, ns[i]->m_z);
         }
     }
 
     return box(point(xmin - ov, ymin - ov, zmin - ov),
                point(xmax + ov, ymax + ov, zmax + ov));
 }

◆ GetBox() [3/3]

box Nektar::NekMeshUtils::GetBox	(	NodeSharedPtr	n,
		NekDouble	ov
	)

inline

Definition at line 114 of file BLMesh.cpp.

Referenced by Nektar::NekMeshUtils::BLMesh::GrowLayers().

 {
     return box(point(n->m_x - ov, n->m_y - ov, n->m_z - ov),
                point(n->m_x + ov, n->m_y + ov, n->m_z + ov));
 }

◆ GetCADCurveFactory()

CADCurveFactory & Nektar::NekMeshUtils::GetCADCurveFactory ( )

Definition at line 59 of file CADSystem.cpp.

Referenced by Nektar::NekMeshUtils::CADSystemOCE::AddCurve(), and Nektar::NekMeshUtils::CADSystemCFI::AddCurve().

 {
     static CADCurveFactory instance;
     return instance;
 }

◆ GetCADSurfFactory()

CADSurfFactory & Nektar::NekMeshUtils::GetCADSurfFactory ( )

Definition at line 65 of file CADSystem.cpp.

Referenced by Nektar::NekMeshUtils::CADSystemOCE::AddSurf(), and Nektar::NekMeshUtils::CADSystemCFI::AddSurf().

 {
     static CADSurfFactory instance;
     return instance;
 }

◆ GetCADVertFactory()

CADVertFactory & Nektar::NekMeshUtils::GetCADVertFactory ( )

Definition at line 53 of file CADSystem.cpp.

Referenced by Nektar::NekMeshUtils::CADSystemOCE::AddVert(), and Nektar::NekMeshUtils::CADSystemCFI::AddVert().

 {
     static CADVertFactory instance;
     return instance;
 }

◆ GetElementFactory()

NEKMESHUTILS_EXPORT ElementFactory & Nektar::NekMeshUtils::GetElementFactory ( )

Definition at line 44 of file Element.cpp.

 {
     static ElementFactory instance;
     return instance;
 }

◆ GetEngineFactory()

EngineFactory & Nektar::NekMeshUtils::GetEngineFactory ( )

Definition at line 47 of file CADSystem.cpp.

Referenced by Nektar::NekMeshUtils::ProcessLoadCAD::Process().

 {
     static EngineFactory instance;
     return instance;
 }

◆ GetModuleFactory()

NEKMESHUTILS_EXPORT ModuleFactory & Nektar::NekMeshUtils::GetModuleFactory ( )

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

Definition at line 50 of file NekMeshUtils/Module/Module.cpp.

 {
     static ModuleFactory instance;
     return instance;
 }

◆ GetReverseFace()

OctantFace Nektar::NekMeshUtils::GetReverseFace ( OctantFace f )

inline

Definition at line 43 of file Octant.cpp.

References eBack, eDown, eForward, eLeft, eRight, and eUp.

Referenced by Nektar::NekMeshUtils::Octant::Subdivide().

 {
     switch (f)
     {
         case eUp:
             return eDown;
         case eDown:
             return eUp;
         case eForward:
             return eBack;
         case eBack:
             return eForward;
         case eLeft:
             return eRight;
         case eRight:
             return eLeft;
     }
 
     return eUp;
 }

◆ Infont()

bool Nektar::NekMeshUtils::Infont	(	NodeSharedPtr	n,
		ElementSharedPtr	el
	)

inline

Definition at line 178 of file BLMesh.cpp.

References Nektar::LibUtilities::ang().

Referenced by Nektar::NekMeshUtils::BLMesh::GrowLayers().

 {
     vector<NodeSharedPtr> ns1 = el->GetVertexList();
     Array<OneD, NekDouble> N1 = el->Normal(true);
 
     Array<OneD, NekDouble> V(3);
     V[0] = n->m_x - ns1[0]->m_x;
     V[1] = n->m_y - ns1[0]->m_y;
     V[2] = n->m_z - ns1[0]->m_z;
 
     NekDouble Vmag = sqrt(V[0] * V[0] + V[1] * V[1] + V[2] * V[2]);
 
     NekDouble ang = (N1[0] * V[0] + N1[1] * V[1] + N1[2] * V[2]) / Vmag;
 
     return ang > 0.17;
 }

◆ operator!=()

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::operator!=	(	NodeSharedPtr const &	p1,
		NodeSharedPtr const &	p2
	)

Compares two nodes for inequality based on IDs.

Definition at line 128 of file BooleanOperators.cpp.

 {
     if (p1->m_id != p2->m_id)
     {
         return true;
     }
     else
     {
         return false;
     }
 }

◆ operator<() [1/3]

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

Defines ordering between two NodeSharedPtr objects.

Definition at line 143 of file BooleanOperators.cpp.

 {
     return *p1 < *p2;
 }

◆ operator<() [2/3]

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

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

Definition at line 170 of file BooleanOperators.cpp.

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

◆ operator<() [3/3]

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

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

Definition at line 197 of file BooleanOperators.cpp.

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

◆ operator<<() [1/2]

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

Prints a given module key to a stream.

Definition at line 59 of file NekMeshUtils/Module/Module.cpp.

References Nektar::FieldUtils::ModuleTypeMap.

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

◆ operator<<() [2/2]

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

Print description of node to given ostream.

Definition at line 151 of file BooleanOperators.cpp.

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

◆ operator==() [1/8]

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::operator==	(	ElmtConfig const &	c1,
		ElmtConfig const &	c2
	)

Compares two element config structs.

Definition at line 48 of file BooleanOperators.cpp.

References Nektar::NekMeshUtils::ElmtConfig::m_e, and Nektar::NekMeshUtils::ElmtConfig::m_order.

Referenced by Nektar::NekMeshUtils::HOSurfHash::operator()().

 {
     return (c1.m_e == c2.m_e && c1.m_order == c2.m_order);
 }

◆ operator==() [2/8]

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::operator==	(	ElementSharedPtr const &	e1,
		ElementSharedPtr const &	e2
	)

Compares two element shared pointers.

Definition at line 56 of file BooleanOperators.cpp.

 {
     return e1->GetId() == e2->GetId();
 }

◆ operator==() [3/8]

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::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 67 of file BooleanOperators.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;
 }

◆ operator==() [4/8]

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::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 92 of file BooleanOperators.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;
 }

◆ operator==() [5/8]

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

Defines equality between two NodeSharedPtr objects.

Shared pointer to a Node.

Definition at line 120 of file BooleanOperators.cpp.

 {
     return *p1 == *p2;
 }

◆ operator==() [6/8]

NEKMESHUTILS_EXPORT bool Nektar::NekMeshUtils::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 161 of file BooleanOperators.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))));
 }

◆ operator==() [7/8]

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

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

Definition at line 179 of file BooleanOperators.cpp.

References Nektar::StdRegions::find().

 {
     std::vector<NodeSharedPtr>::iterator it1;
     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;
 }

◆ operator==() [8/8]

bool Nektar::NekMeshUtils::operator==	(	OctantSharedPtr const &	p1,
		OctantSharedPtr const &	p2
	)

Definition at line 509 of file Octant.cpp.

 {
     if (p1->GetId() == p2->GetId())
     {
         return true;
     }
 
     return false;
 }

◆ P() [1/2]

void Nektar::NekMeshUtils::P	(	Array< OneD, NekDouble >	uv,
		NekDouble &	x,
		NekDouble &	y,
		NekDouble &	z
	)

Definition at line 121 of file CADSurfCFI.cpp.

References CellMLToNektar.cellml_metadata::p.

Referenced by Nektar::NekMeshUtils::CADSurfCFI::D1(), Nektar::NekMeshUtils::CADSurfCFI::D2(), and Nektar::NekMeshUtils::CADSurfCFI::locuv().

 {
     cfi::UVPosition uvp(uv[0], uv[1]);
     cfi::Position p = m_cfiSurface->calcXYZAtUV(uvp);
     x               = p.x * m_scal;
     y               = p.y * m_scal;
     z               = p.z * m_scal;
 }

◆ P() [2/2]

void Nektar::NekMeshUtils::P	(	NekDouble	t,
		NekDouble &	x,
		NekDouble &	y,
		NekDouble &	z
	)

Definition at line 136 of file CADCurveCFI.cpp.

References CellMLToNektar.cellml_metadata::p.

Referenced by Nektar::NekMeshUtils::CADSurf::SetEdges().

 {
     cfi::Position p = m_cfiEdge->calcXYZAtT(t);
 
     x = p.x * m_scal;
     y = p.y * m_scal;
     z = p.z * m_scal;
 }

◆ sign()

bool Nektar::NekMeshUtils::sign	(	NekDouble	a,
		NekDouble	b
	)

inline

Definition at line 350 of file BLMesh.cpp.

References Vmath::Dot().

 {
     return (a * b > 0.0);
 }

◆ sort3()

template<typename K >

void Nektar::NekMeshUtils::sort3	(	K &	x,
		K &	y,
		K &	z
	)

Helper function to sort 3 numbers using sorting network.

Definition at line 443 of file Tetrahedron.cpp.

References SWAP.

Referenced by Nektar::NekMeshUtils::Tetrahedron::OrientTet().

 {
 #define SWAP(a,b) if (a > b) std::swap(a,b);
     SWAP(y, z);
     SWAP(x, z);
     SWAP(x, y);
 #undef SWAP
 }

◆ Take()

Array<OneD, NekDouble> Nektar::NekMeshUtils::Take	(	Array< OneD, NekDouble >	a,
		Array< OneD, NekDouble >	b
	)

Definition at line 48 of file OptimiseFunctions.cpp.

Referenced by Nektar::NekMeshUtils::OptiEdge::dF(), and Nektar::NekMeshUtils::OptiEdge::F().

 {
     Array<OneD, NekDouble> ret(3);
     ret[0] = a[0] - b[0];
     ret[1] = a[1] - b[1];
     ret[2] = a[2] - b[2];
     return ret;
 }

◆ Times()

Array<OneD, NekDouble> Nektar::NekMeshUtils::Times	(	NekDouble	t,
		Array< OneD, NekDouble >	a
	)

Definition at line 56 of file OptimiseFunctions.cpp.

 {
     Array<OneD, NekDouble> ret(3);
     ret[0] = a[0] * t;
     ret[1] = a[1] * t;
     ret[2] = a[2] * t;
     return ret;
 }

Variable Documentation

◆ ModuleTypeMap

const char* const Nektar::NekMeshUtils::ModuleTypeMap[]

Initial value:

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

Definition at line 70 of file NekMeshUtils/Module/Module.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ BLMeshSharedPtr

◆ BPointSharedPtr

◆ CADCurveFactory

◆ CADCurveSharedPtr

◆ CADObjectSharedPtr

◆ CADSurfFactory

◆ CADSurfSharedPtr

◆ CADSystemCFISharedPtr

◆ CADSystemOCESharedPtr

◆ CADSystemSharedPtr

◆ CADVertFactory

◆ CADVertSharedPtr

◆ CompositeMap

◆ CompositeSharedPtr

◆ ConditionMap

◆ ConditionSharedPtr

◆ CPointSharedPtr

◆ CurveMeshSharedPtr

◆ EdgeLoopSharedPtr

◆ EdgeSet

◆ EdgeSharedPtr

◆ ElementFactory

◆ ElementMap

◆ ElementSharedPtr

◆ EngineFactory

◆ FaceMeshSharedPtr

◆ FaceSet

◆ FaceSharedPtr

◆ HOSurf

◆ HOSurfSet

◆ HOSurfSharedPtr

◆ MeshSharedPtr

◆ ModuleFactory

◆ ModuleKey

◆ ModuleSharedPtr

◆ NodeSet

◆ NodeSharedPtr

◆ OctantSharedPtr

◆ OctreeSharedPtr

◆ OptiEdgeSharedPtr

◆ OptiObjSharedPtr

◆ PerMap

◆ SPBaseSharedPtr

◆ SrcPointSharedPtr

◆ TetGenInterfaceSharedPtr

◆ TetMeshSharedPtr

◆ TriangleInterfaceSharedPtr

Enumeration Type Documentation

◆ ConditionType

◆ ModuleType

◆ OctantFace

◆ OctantLocation

◆ SPType

Function Documentation

◆ Add()

◆ BGFSUpdate()

◆ Dot()

◆ filterModShape()

◆ GetBox() [1/3]

◆ GetBox() [2/3]

◆ GetBox() [3/3]

◆ GetCADCurveFactory()

◆ GetCADSurfFactory()

◆ GetCADVertFactory()

◆ GetElementFactory()

◆ GetEngineFactory()

◆ GetModuleFactory()

◆ GetReverseFace()

◆ Infont()

◆ operator!=()

◆ operator<() [1/3]

◆ operator<() [2/3]

◆ operator<() [3/3]