Namespaces
	CADOrientation

	CADType

Classes
struct	badsubseg

struct	badtriang

struct	behavior

class	BLMesh

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

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

class	CADCurveOCE

class	CADObject

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

class	CADSurfOCE

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

class	CADSystemOCE

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

class	CADVertOCE

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	DelaunayTriangle

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

struct	EdgeHash
	Defines a hash function for edges. 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...

struct	event

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

struct	flipstacker

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

struct	memorypool

struct	mesh

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

struct	osub

struct	otri

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

struct	splaynode

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

struct	TetOrient

struct	TetOrientHash

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

struct	triangulateio

class	VolumeMesh

Typedefs
typedef boost::shared_ptr < CADCurve >	CADCurveSharedPtr

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

typedef boost::shared_ptr < CADObject >	CADObjectSharedPtr

typedef boost::shared_ptr < CADSurf >	CADSurfSharedPtr

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

typedef boost::shared_ptr < CADVert >	CADVertSharedPtr

typedef boost::shared_ptr < CADSystem >	CADSystemSharedPtr

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

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

typedef boost::shared_ptr < TetGenInterface >	TetGenInterfaceSharedPtr

typedef boost::shared_ptr < TriangleInterface >	TriangleInterfaceSharedPtr

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 < Element >	ElementSharedPtr

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

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

typedef boost::unordered_set < FaceSharedPtr, FaceHash >	FaceSet

typedef HOTriangle< NodeSharedPtr >	HOSurf

typedef boost::shared_ptr< HOSurf >	HOSurfSharedPtr

typedef boost::unordered_set < HOSurfSharedPtr, HOSurfHash >	HOSurfSet

typedef boost::shared_ptr< Octree >	OctreeSharedPtr

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 boost::shared_ptr< Node >	NodeSharedPtr

typedef boost::unordered_set < NodeSharedPtr, NodeHash >	NodeSet

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

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

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

typedef boost::shared_ptr< Module >	ModuleSharedPtr

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

typedef boost::shared_ptr< Octant >	OctantSharedPtr

typedef boost::shared_ptr< SPBase >	SPBaseSharedPtr

typedef boost::shared_ptr< CPoint >	CPointSharedPtr

typedef boost::shared_ptr< BPoint >	BPointSharedPtr

typedef boost::shared_ptr < SrcPoint >	SrcPointSharedPtr

typedef boost::shared_ptr < OptiObj >	OptiObjSharedPtr

typedef boost::shared_ptr < CurveMesh >	CurveMeshSharedPtr

typedef boost::shared_ptr < FaceMesh >	FaceMeshSharedPtr

typedef boost::shared_ptr < OptiEdge >	OptiEdgeSharedPtr

typedef double **	triangle

typedef double **	subseg

typedef double *	vertex

typedef boost::shared_ptr< BLMesh >	BLMeshSharedPtr

typedef boost::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 }

enum	locateresult { INTRIANGLE, ONEDGE, ONVERTEX, OUTSIDE }

enum	insertvertexresult { SUCCESSFULVERTEX, ENCROACHINGVERTEX, VIOLATINGVERTEX, DUPLICATEVERTEX }

enum	finddirectionresult { WITHIN, LEFTCOLLINEAR, RIGHTCOLLINEAR }

Functions
CADCurveFactory &	GetCADCurveFactory ()

CADSurfFactory &	GetCADSurfFactory ()

EngineFactory &	GetEngineFactory ()

CADVertFactory &	GetCADVertFactory ()

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 ()

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

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

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

Definition at line 141 of file BLMesh.h.

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

Definition at line 232 of file SourcePoint.hpp.

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

Definition at line 196 of file CADCurve.h.

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

Definition at line 194 of file CADCurve.h.

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

Definition at line 112 of file CADObject.h.

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

Definition at line 174 of file CADSurf.h.

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

Definition at line 172 of file CADSurf.h.

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

Definition at line 218 of file CADSystem.h.

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

Definition at line 130 of file CADVert.h.

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

Definition at line 54 of file CADSystem.h.

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

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

Definition at line 124 of file Composite.h.

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

Shared pointer to a composite.

Definition at line 121 of file Composite.h.

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

Definition at line 83 of file Mesh.h.

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

Definition at line 82 of file Mesh.h.

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

Definition at line 177 of file SourcePoint.hpp.

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

Definition at line 182 of file CurveMesh.h.

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

Definition at line 162 of file Edge.h.

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

Shared pointer to an edge.

Definition at line 136 of file Edge.h.

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

Element factory definition.

Definition at line 415 of file Element.h.

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 409 of file Element.h.

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

Definition at line 49 of file Edge.h.

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

Definition at line 220 of file CADSystem.h.

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

Definition at line 161 of file FaceMesh.h.

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

Definition at line 179 of file Face.h.

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

Definition at line 153 of file Face.h.

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

Definition at line 180 of file HOAlignment.h.

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

Definition at line 209 of file HOAlignment.h.

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

Definition at line 181 of file HOAlignment.h.

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

Shared pointer to a mesh.

Definition at line 147 of file Mesh.h.

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

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

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

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

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

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

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

Definition at line 441 of file Node.h.

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

Definition at line 50 of file Node.h.

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

Definition at line 74 of file Octant.h.

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

Definition at line 48 of file Mesh.h.

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

Definition at line 82 of file OptimiseFunctions.h.

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

Definition at line 90 of file OptimiseObj.h.

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

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

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

Definition at line 124 of file SourcePoint.hpp.

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

Definition at line 274 of file SourcePoint.hpp.

typedef double** Nektar::NekMeshUtils::subseg

Definition at line 708 of file Triangle/Triangle.h.

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

Definition at line 100 of file TetGenInterface.h.

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

Definition at line 89 of file TetMesh.h.

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

Definition at line 371 of file Tetrahedron.cpp.

typedef double** Nektar::NekMeshUtils::triangle

Definition at line 690 of file Triangle/Triangle.h.

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

Definition at line 116 of file TriangleInterface.h.

typedef double* Nektar::NekMeshUtils::vertex

Definition at line 726 of file Triangle/Triangle.h.

Enumeration Type Documentation

enum Nektar::NekMeshUtils::ConditionType

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

Enumerator
eDirichlet
eNeumann
eRobin
ePeriodic
eHOPCondition
SIZE_ConditionType

Definition at line 54 of file Mesh.h.

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

enum Nektar::NekMeshUtils::finddirectionresult

Enumerator
WITHIN
LEFTCOLLINEAR
RIGHTCOLLINEAR

Definition at line 566 of file Triangle/Triangle.h.

 {
     WITHIN,
     LEFTCOLLINEAR,
     RIGHTCOLLINEAR
 };

enum Nektar::NekMeshUtils::insertvertexresult

Enumerator
SUCCESSFULVERTEX
ENCROACHINGVERTEX
VIOLATINGVERTEX
DUPLICATEVERTEX

Definition at line 553 of file Triangle/Triangle.h.

 {
     SUCCESSFULVERTEX,
     ENCROACHINGVERTEX,
     VIOLATINGVERTEX,
     DUPLICATEVERTEX
 };

enum Nektar::NekMeshUtils::locateresult

Enumerator
INTRIANGLE
ONEDGE
ONVERTEX
OUTSIDE

Definition at line 539 of file Triangle/Triangle.h.

 {
     INTRIANGLE,
     ONEDGE,
     ONVERTEX,
     OUTSIDE
 };

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 64 of file NekMeshUtils/Module/Module.h.

                     {
         eInputModule,
         eProcessModule,
         eOutputModule,
         SIZE_ModuleType
     };

enum Nektar::NekMeshUtils::OctantFace

enumeration of the 6 faces of a cube/octant

Enumerator
eUp
eDown
eForward
eBack
eLeft
eRight

Definition at line 52 of file Octant.h.

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

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 66 of file Octant.h.

 {
     eInside,
     eOutside,
     eOnBoundary,
     eUnknown
 };

enum Nektar::NekMeshUtils::SPType

Enumerator
eCBoundary
ePBoundary
eSrcPoint

Definition at line 47 of file SourcePoint.hpp.

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

Function Documentation

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

Definition at line 65 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;
 }

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

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

References Nektar::iterator, and 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;
 }

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

inline

Definition at line 45 of file OptimiseFunctions.cpp.

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

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

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

inline

Definition at line 64 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));
 }

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

inline

Definition at line 88 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));
 }

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

inline

Definition at line 115 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));
 }

CADCurveFactory & Nektar::NekMeshUtils::GetCADCurveFactory ( )

Definition at line 64 of file CADSystem.cpp.

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

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

CADSurfFactory & Nektar::NekMeshUtils::GetCADSurfFactory ( )

Definition at line 72 of file CADSystem.cpp.

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

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

CADVertFactory & Nektar::NekMeshUtils::GetCADVertFactory ( )

Definition at line 56 of file CADSystem.cpp.

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

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

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

Definition at line 47 of file Element.cpp.

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

EngineFactory & Nektar::NekMeshUtils::GetEngineFactory ( )

Definition at line 48 of file CADSystem.cpp.

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

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

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

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

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

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

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

inline

Definition at line 44 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;
 }

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

inline

Definition at line 180 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;
 }

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

Compares two nodes for inequality based on IDs.

Definition at line 129 of file BooleanOperators.cpp.

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

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

Defines ordering between two NodeSharedPtr objects.

Definition at line 144 of file BooleanOperators.cpp.

 {
     return *p1 < *p2;
 }

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 171 of file BooleanOperators.cpp.

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

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 198 of file BooleanOperators.cpp.

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

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

Prints a given module key to a stream.

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

References Nektar::FieldUtils::ModuleTypeMap.

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

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

Print description of node to given ostream.

Definition at line 152 of file BooleanOperators.cpp.

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

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

Compares two element config structs.

Definition at line 49 of file BooleanOperators.cpp.

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

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

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

Compares two element shared pointers.

Definition at line 57 of file BooleanOperators.cpp.

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

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 68 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;
 }

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 93 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;
 }

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 121 of file BooleanOperators.cpp.

 {
     return *p1 == *p2;
 }

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 162 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))));
 }

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 180 of file BooleanOperators.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::NekMeshUtils::operator==	(	const struct TetOrient &	a,
		const struct TetOrient &	b
	)

Definition at line 373 of file Tetrahedron.cpp.

References Nektar::NekMeshUtils::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;
 }

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

Definition at line 510 of file Octant.cpp.

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

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

inline

Definition at line 352 of file BLMesh.cpp.

 {
     return (a * b > 0.0);
 }

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

Definition at line 49 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;
 }

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

Definition at line 57 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

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

Initial value:

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

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation