#include <TriGeom.h>

Inheritance diagram for Nektar::SpatialDomains::TriGeom:

Collaboration diagram for Nektar::SpatialDomains::TriGeom:

Public Member Functions
	TriGeom ()

	TriGeom (int id, const int coordim)

	TriGeom (const int id, const PointGeomSharedPtr verts[], const SegGeomSharedPtr edges[], const StdRegions::Orientation eorient[])

	TriGeom (const int id, const SegGeomSharedPtr edges[], const StdRegions::Orientation eorient[])

	TriGeom (const int id, const SegGeomSharedPtr edges[], const StdRegions::Orientation eorient[], const CurveSharedPtr &curve)

	TriGeom (const TriGeom &in)

	~TriGeom ()

NekDouble	GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord)

Public Member Functions inherited from Nektar::SpatialDomains::Geometry2D
	Geometry2D ()

	Geometry2D (const int coordim)

virtual	~Geometry2D ()

int	GetFid () const

const Geometry1DSharedPtr	GetEdge (int i) const

const Geometry2DSharedPtr	GetFace (int i) const

int	WhichEdge (SegGeomSharedPtr edge)

int	WhichFace (Geometry2DSharedPtr face)

const LibUtilities::BasisSharedPtr	GetEdgeBasis (const int i)

StdRegions::Orientation	GetFaceOrient (const int i) const

StdRegions::Orientation	GetCartesianEorient (const int i) const

Public Member Functions inherited from Nektar::SpatialDomains::Geometry
	Geometry ()

	Geometry (int coordim)

virtual	~Geometry ()

bool	IsElmtConnected (int gvo_id, int locid) const

void	AddElmtConnected (int gvo_id, int locid)

int	NumElmtConnected () const

int	GetCoordim () const

void	SetCoordim (int coordim)

GeomFactorsSharedPtr	GetGeomFactors ()

GeomFactorsSharedPtr	GetRefGeomFactors (const Array< OneD, const LibUtilities::BasisSharedPtr > &tbasis)

GeomFactorsSharedPtr	GetMetricInfo ()

LibUtilities::ShapeType	GetShapeType (void)

int	GetGlobalID (void)

void	SetGlobalID (int globalid)

int	GetVid (int i) const

int	GetEid (int i) const

int	GetFid (int i) const

int	GetTid (int i) const

int	GetNumVerts () const

PointGeomSharedPtr	GetVertex (int i) const

StdRegions::Orientation	GetEorient (const int i) const

StdRegions::Orientation	GetPorient (const int i) const

StdRegions::Orientation	GetForient (const int i) const

int	GetNumEdges () const

int	GetNumFaces () const

int	GetShapeDim () const

StdRegions::StdExpansionSharedPtr	GetXmap () const

const Array< OneD, const NekDouble > &	GetCoeffs (const int i) const

bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0)

bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol)

bool	ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &resid)

int	GetVertexEdgeMap (int i, int j) const

int	GetVertexFaceMap (int i, int j) const
	return the id of the $j^{th}$ face attached to the $i^{th}$ vertex More...

int	GetEdgeFaceMap (int i, int j) const

void	FillGeom ()
	Put all quadrature information into face/edge structure and backward transform. More...

NekDouble	GetLocCoords (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)

NekDouble	GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord)
	Given local collapsed coordinate Lcoord return the value of physical coordinate in direction i. More...

void	SetOwnData ()

const LibUtilities::BasisSharedPtr	GetBasis (const int i)
	Return the j-th basis of the i-th co-ordinate dimension. More...

const LibUtilities::PointsKeyVector	GetPointsKeys ()

void	Reset (CurveMap &curvedEdges, CurveMap &curvedFaces)

Static Public Member Functions
static StdRegions::Orientation	GetFaceOrientation (const TriGeom &face1, const TriGeom &face2)

static StdRegions::Orientation	GetFaceOrientation (const PointGeomVector &face1, const PointGeomVector &face2)

Static Public Attributes
static const int	kNedges = 3
	Get the orientation of face1. More...

static const int	kNverts = 3

Protected Member Functions
virtual void	v_AddElmtConnected (int gvo_id, int locid)

virtual int	v_NumElmtConnected () const

virtual bool	v_IsElmtConnected (int gvo_id, int locid) const

virtual int	v_GetFid () const

virtual int	v_GetCoordim () const

virtual const LibUtilities::BasisSharedPtr	v_GetBasis (const int i)

virtual const LibUtilities::BasisSharedPtr	v_GetEdgeBasis (const int i)

virtual NekDouble	v_GetCoord (const int i, const Array< OneD, const NekDouble > &Lcoord)

virtual void	v_GenGeomFactors ()

virtual void	v_SetOwnData ()

virtual void	v_FillGeom ()
	Put all quadrature information into edge structure. More...

virtual NekDouble	v_GetLocCoords (const Array< OneD, const NekDouble > &coords, Array< OneD, NekDouble > &Lcoords)

virtual int	v_GetEid (int i) const

virtual int	v_GetVid (int i) const

virtual PointGeomSharedPtr	v_GetVertex (int i) const

virtual const Geometry1DSharedPtr	v_GetEdge (int i) const

virtual StdRegions::Orientation	v_GetEorient (const int i) const

virtual StdRegions::Orientation	v_GetCartesianEorient (const int i) const

virtual int	v_WhichEdge (SegGeomSharedPtr edge)
	Return the edge number of the given edge. More...

virtual int	v_GetNumVerts () const

virtual int	v_GetNumEdges () const

virtual bool	v_ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, NekDouble tol=0.0)
	Determines if a point specified in global coordinates is located within this tetrahedral geometry. More...

virtual bool	v_ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol)

virtual bool	v_ContainsPoint (const Array< OneD, const NekDouble > &gloCoord, Array< OneD, NekDouble > &locCoord, NekDouble tol, NekDouble &resid)

virtual void	v_Reset (CurveMap &curvedEdges, CurveMap &curvedFaces)
	Reset this geometry object: unset the current state and remove allocated GeomFactors. More...

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry2D
void	NewtonIterationForLocCoord (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &ptsx, const Array< OneD, const NekDouble > &ptsy, Array< OneD, NekDouble > &Lcoords, NekDouble &resid)

Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
void	GenGeomFactors ()

virtual int	v_GetFid (int i) const

virtual StdRegions::Orientation	v_GetPorient (const int i) const

virtual StdRegions::Orientation	v_GetForient (const int i) const

virtual int	v_GetNumFaces () const

virtual StdRegions::StdExpansionSharedPtr	v_GetXmap () const

virtual int	v_GetVertexEdgeMap (int i, int j) const

virtual int	v_GetVertexFaceMap (int i, int j) const

virtual int	v_GetEdgeFaceMap (int i, int j) const

void	SetUpCoeffs (const int nCoeffs)
	Initialise the m_coeffs array. More...

Protected Attributes
PointGeomVector	m_verts

SegGeomVector	m_edges

StdRegions::Orientation	m_eorient [kNedges]

int	m_fid

bool	m_ownVerts

std::list< CompToElmt >	m_elmtMap

CurveSharedPtr	m_curve

Protected Attributes inherited from Nektar::SpatialDomains::Geometry
int	m_coordim
	coordinate dimension More...

GeomFactorsSharedPtr	m_geomFactors

GeomState	m_geomFactorsState

StdRegions::StdExpansionSharedPtr	m_xmap

GeomState	m_state
	enum identifier to determine if quad points are filled More...

GeomType	m_geomType

LibUtilities::ShapeType	m_shapeType

int	m_globalID

Array< OneD, Array< OneD, NekDouble > >	m_coeffs

Private Member Functions
void	SetUpXmap ()

Private Attributes
bool	m_ownData

Additional Inherited Members
Static Protected Member Functions inherited from Nektar::SpatialDomains::Geometry
static GeomFactorsSharedPtr	ValidateRegGeomFactor (GeomFactorsSharedPtr geomFactor)

Static Protected Attributes inherited from Nektar::SpatialDomains::Geometry
static GeomFactorsVector	m_regGeomFactorsManager

Detailed Description

Definition at line 65 of file TriGeom.h.

Constructor & Destructor Documentation

Nektar::SpatialDomains::TriGeom::TriGeom ( )

Definition at line 54 of file TriGeom.cpp.

References Nektar::LibUtilities::eTriangle.

         {
             m_shapeType = LibUtilities::eTriangle;
         }

Nektar::SpatialDomains::TriGeom::TriGeom	(	int	id,
		const int	coordim
	)

Definition at line 62 of file TriGeom.cpp.

References m_fid, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

                                                  :
                                    Geometry2D(coordim), m_fid(id)
         {
             m_globalID = m_fid;
             SetUpXmap();
             SetUpCoeffs(m_xmap->GetNcoeffs());
         }

Nektar::SpatialDomains::TriGeom::TriGeom	(	const int	id,
		const PointGeomSharedPtr	verts[],
		const SegGeomSharedPtr	edges[],
		const StdRegions::Orientation	eorient[]
	)

Copy the vert shared pointers.

Copy the edge shared pointers.

Definition at line 73 of file TriGeom.cpp.

References ASSERTL0, Nektar::LibUtilities::eTriangle, kNedges, kNverts, Nektar::SpatialDomains::Geometry::m_coordim, m_edges, m_eorient, m_fid, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

                                                       :
                 Geometry2D(verts[0]->GetCoordim()),
                 m_fid(id)
         {
             m_globalID = m_fid;
             m_shapeType = LibUtilities::eTriangle;
 
             /// Copy the vert shared pointers.
             m_verts.insert(m_verts.begin(), verts, verts+TriGeom::kNverts);
 
             /// Copy the edge shared pointers.
             m_edges.insert(m_edges.begin(), edges, edges+TriGeom::kNedges);
 
             for (int j=0; j<kNedges; ++j)
             {
                 m_eorient[j] = eorient[j];
             }
 
             m_coordim = verts[0]->GetCoordim();
             ASSERTL0(m_coordim > 1,
                     "Cannot call function with dim == 1");
 
             SetUpXmap();
             SetUpCoeffs(m_xmap->GetNcoeffs());
         }

Nektar::SpatialDomains::TriGeom::TriGeom	(	const int	id,
		const SegGeomSharedPtr	edges[],
		const StdRegions::Orientation	eorient[]
	)

Copy the edge shared pointers.

Definition at line 106 of file TriGeom.cpp.

References ASSERTL0, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::Geometry::GetVertex(), kNedges, Nektar::SpatialDomains::Geometry::m_coordim, m_edges, m_eorient, m_fid, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

                                                       :
                 Geometry2D(edges[0]->GetVertex(0)->GetCoordim()),
                 m_fid(id)
         {
             m_globalID = m_fid;
             m_shapeType = LibUtilities::eTriangle;
 
             /// Copy the edge shared pointers.
             m_edges.insert(m_edges.begin(), edges, edges+TriGeom::kNedges);
 
             for(int j=0; j <kNedges; ++j)
             {
                 if(eorient[j] == StdRegions::eForwards)
                 {
                     m_verts.push_back(edges[j]->GetVertex(0));
                 }
                 else
                 {
                     m_verts.push_back(edges[j]->GetVertex(1));
                 }
             }
 
             for (int j=0; j<kNedges; ++j)
             {
                 m_eorient[j] = eorient[j];
             }
 
             m_coordim = edges[0]->GetVertex(0)->GetCoordim();
             ASSERTL0(m_coordim > 1,"Cannot call function with dim == 1");
 
             SetUpXmap();
             SetUpCoeffs(m_xmap->GetNcoeffs());
         }

Nektar::SpatialDomains::TriGeom::TriGeom	(	const int	id,
		const SegGeomSharedPtr	edges[],
		const StdRegions::Orientation	eorient[],
		const CurveSharedPtr &	curve
	)

Copy the edge shared pointers.

Definition at line 145 of file TriGeom.cpp.

References ASSERTL0, Nektar::StdRegions::eForwards, Nektar::LibUtilities::eTriangle, Nektar::SpatialDomains::Geometry::GetVertex(), kNedges, Nektar::SpatialDomains::Geometry::m_coordim, m_edges, m_eorient, m_fid, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_shapeType, m_verts, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), and SetUpXmap().

             : Geometry2D(edges[0]->GetVertex(0)->GetCoordim()),
               m_fid(id),
               m_curve(curve)
         {
             m_globalID = m_fid;
             m_shapeType =  LibUtilities::eTriangle;
 
             /// Copy the edge shared pointers.
             m_edges.insert(m_edges.begin(), edges, edges+TriGeom::kNedges);
 
             for(int j=0; j <kNedges; ++j)
             {
                 if(eorient[j] == StdRegions::eForwards)
                 {
                     m_verts.push_back(edges[j]->GetVertex(0));
                 }
                 else
                 {
                     m_verts.push_back(edges[j]->GetVertex(1));
                 }
             }
 
             for (int j=0; j<kNedges; ++j)
             {
                 m_eorient[j] = eorient[j];
             }
 
             m_coordim = edges[0]->GetVertex(0)->GetCoordim();
             ASSERTL0(m_coordim > 1,"Cannot call function with dim == 1");
 
             SetUpXmap();
             SetUpCoeffs(m_xmap->GetNcoeffs());
         }

Nektar::SpatialDomains::TriGeom::TriGeom ( const TriGeom & in )

Definition at line 187 of file TriGeom.cpp.

References kNedges, m_edges, m_elmtMap, m_eorient, m_fid, Nektar::SpatialDomains::Geometry::m_globalID, m_ownData, m_ownVerts, Nektar::SpatialDomains::Geometry::m_shapeType, and m_verts.

         {
             // From Geomtry
             m_shapeType = in.m_shapeType;
 
             // From TriFaceComponent
             m_fid = in.m_fid;
             m_globalID = m_fid;
             m_ownVerts = in.m_ownVerts;
             std::list<CompToElmt>::const_iterator def;
             for(def = in.m_elmtMap.begin(); def != in.m_elmtMap.end(); def++)
             {
                 m_elmtMap.push_back(*def);
             }
 
             // From TriGeom
             m_verts = in.m_verts;
             m_edges = in.m_edges;
             for (int i = 0; i < kNedges; i++)
             {
                 m_eorient[i] = in.m_eorient[i];
             }
             m_ownData = in.m_ownData;
         }

Nektar::SpatialDomains::TriGeom::~TriGeom ( )

Definition at line 216 of file TriGeom.cpp.

217 {

218 }

Member Function Documentation

NekDouble Nektar::SpatialDomains::TriGeom::GetCoord	(	const int	i,
		const Array< OneD, const NekDouble > &	Lcoord
	)

Given local collapsed coordinate Lcoord return the value of physical coordinate in direction i

Definition at line 225 of file TriGeom.cpp.

References ASSERTL1, Nektar::SpatialDomains::ePtsFilled, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_state, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by v_GetCoord().

         {
             ASSERTL1(m_state == ePtsFilled,
                 "Geometry is not in physical space");
 
             Array<OneD, NekDouble> tmp(m_xmap->GetTotPoints());
             m_xmap->BwdTrans(m_coeffs[i], tmp);
 
             return m_xmap->PhysEvaluate(Lcoord, tmp);
         }

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::GetFaceOrientation	(	const TriGeom &	face1,
		const TriGeom &	face2
	)

static

Definition at line 237 of file TriGeom.cpp.

References m_verts.

Referenced by Nektar::MultiRegions::DisContField3D::FindPeriodicFaces().

         {
             return GetFaceOrientation(face1.m_verts, face2.m_verts);
         }

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::GetFaceOrientation	(	const PointGeomVector &	face1,
		const PointGeomVector &	face2
	)

static

Definition at line 244 of file TriGeom.cpp.

References ASSERTL0, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, and Nektar::StdRegions::eNoOrientation.

         {
             int i, j, vmap[3] = {-1,-1,-1};
             NekDouble x, y, z, x1, y1, z1, cx = 0.0, cy = 0.0, cz = 0.0;
 
             // For periodic faces, we calculate the vector between the centre
             // points of the two faces. (For connected faces this will be
             // zero). We can then use this to determine alignment later in the
             // algorithm.
             for (i = 0; i < 3; ++i)
             {
                 cx += (*face2[i])(0) - (*face1[i])(0);
                 cy += (*face2[i])(1) - (*face1[i])(1);
                 cz += (*face2[i])(2) - (*face1[i])(2);
             }
             cx /= 3;
             cy /= 3;
             cz /= 3;
 
             // Now construct a mapping which takes us from the vertices of one
             // face to the other. That is, vertex j of face2 corresponds to
             // vertex vmap[j] of face1.
             for (i = 0; i < 3; ++i)
             {
                 x = (*face1[i])(0);
                 y = (*face1[i])(1);
                 z = (*face1[i])(2);
                 for (j = 0; j < 3; ++j)
                 {
                     x1 = (*face2[j])(0)-cx;
                     y1 = (*face2[j])(1)-cy;
                     z1 = (*face2[j])(2)-cz;
                     if (sqrt((x1-x)*(x1-x)+(y1-y)*(y1-y)+(z1-z)*(z1-z)) < 1e-8)
                     {
                         vmap[j] = i;
                         break;
                     }
                 }
             }
 
             if (vmap[1] == (vmap[0]+1) % 3)
             {
                 switch (vmap[0])
                 {
                     case 0:
                         return StdRegions::eDir1FwdDir1_Dir2FwdDir2;
                         break;
                     case 1:
                         return StdRegions::eDir1FwdDir2_Dir2BwdDir1;
                         break;
                     case 2:
                         return StdRegions::eDir1BwdDir1_Dir2BwdDir2;
                         break;
                 }
             }
             else
             {
                 switch (vmap[0])
                 {
                     case 0:
                         return StdRegions::eDir1FwdDir2_Dir2FwdDir1;
                         break;
                     case 1:
                         return StdRegions::eDir1BwdDir1_Dir2FwdDir2;
                         break;
                     case 2:
                         return StdRegions::eDir1BwdDir2_Dir2BwdDir1;
                         break;
                 }
             }
 
             ASSERTL0(false, "Unable to determine triangle orientation");
             return StdRegions::eNoOrientation;
         }

void Nektar::SpatialDomains::TriGeom::SetUpXmap ( )

private

Definition at line 850 of file TriGeom.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::SpatialDomains::Geometry::GetBasis(), m_edges, and Nektar::SpatialDomains::Geometry::m_xmap.

Referenced by TriGeom(), and v_Reset().

         {
             int order0  = m_edges[0]->GetBasis(0)->GetNumModes();
             int order1  = max(order0,
                               max(m_edges[1]->GetBasis(0)->GetNumModes(),
                                   m_edges[2]->GetBasis(0)->GetNumModes()));
 
             const LibUtilities::BasisKey B0(
                 LibUtilities::eModified_A, order0, LibUtilities::PointsKey(
                     order0+1, LibUtilities::eGaussLobattoLegendre));
             const LibUtilities::BasisKey B1(
                 LibUtilities::eModified_B, order1, LibUtilities::PointsKey(
                     order1, LibUtilities::eGaussRadauMAlpha1Beta0));
 
             m_xmap = MemoryManager<StdRegions::StdTriExp>
                 ::AllocateSharedPtr(B0,B1);
         }

void Nektar::SpatialDomains::TriGeom::v_AddElmtConnected	(	int	gvo_id,
		int	locid
	)

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 325 of file TriGeom.cpp.

References m_elmtMap.

         {
             CompToElmt ee(gvo_id,locid);
             m_elmtMap.push_back(ee);
         }

bool Nektar::SpatialDomains::TriGeom::v_ContainsPoint	(	const Array< OneD, const NekDouble > &	gloCoord,
		NekDouble	tol = `0.0`
	)

protectedvirtual

Determines if a point specified in global coordinates is located within this tetrahedral geometry.

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 793 of file TriGeom.cpp.

References Nektar::SpatialDomains::Geometry::GetCoordim().

Referenced by v_ContainsPoint().

         {
             Array<OneD,NekDouble> locCoord(GetCoordim(),0.0);
             return v_ContainsPoint(gloCoord,locCoord,tol);
 
         }

bool Nektar::SpatialDomains::TriGeom::v_ContainsPoint	(	const Array< OneD, const NekDouble > &	gloCoord,
		Array< OneD, NekDouble > &	locCoord,
		NekDouble	tol
	)

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 804 of file TriGeom.cpp.

References v_ContainsPoint().

         {
             NekDouble resid;
             return v_ContainsPoint(gloCoord,stdCoord,tol,resid);
         }

bool Nektar::SpatialDomains::TriGeom::v_ContainsPoint	(	const Array< OneD, const NekDouble > &	gloCoord,
		Array< OneD, NekDouble > &	locCoord,
		NekDouble	tol,
		NekDouble &	resid
	)

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 812 of file TriGeom.cpp.

References ASSERTL1, and Nektar::SpatialDomains::Geometry::GetLocCoords().

         {
             ASSERTL1(gloCoord.num_elements() >= 2,
                     "Two dimensional geometry expects at least two coordinates.");
 
             resid = GetLocCoords(gloCoord, stdCoord);
             if (stdCoord[0] >= -(1+tol) && stdCoord[1] >= -(1+tol)
                     && stdCoord[0] + stdCoord[1] <= tol)
             {
                 return true;
             }
             return false;
         }

void Nektar::SpatialDomains::TriGeom::v_FillGeom ( )

protectedvirtual

Put all quadrature information into edge structure.

Note verts and edges are listed according to anticlockwise convention but points in _coeffs have to be in array format from left to right.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 452 of file TriGeom.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::SpatialDomains::ePtsFilled, Nektar::SpatialDomains::Geometry::GetXmap(), Nektar::LibUtilities::Interp2D(), kNedges, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_coordim, m_curve, m_edges, m_eorient, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_state, Nektar::SpatialDomains::Geometry::m_xmap, npts, and Nektar::LibUtilities::PointsManager().

Referenced by v_GenGeomFactors(), and v_GetLocCoords().

         {
             // check to see if geometry structure is already filled
             if(m_state != ePtsFilled)
             {
                 int i,j,k;
                 int nEdgeCoeffs = m_xmap->GetEdgeNcoeffs(0);
 
                 if (m_curve)
                 {
                     int pdim = LibUtilities::PointsManager()[
                         LibUtilities::PointsKey(2, m_curve->m_ptype)]
                         ->GetPointsDim();
 
                     // Deal with 2D points type separately
                     // (e.g. electrostatic or Fekete points) to 1D tensor
                     // product.
                     if (pdim == 2)
                     {
                         int N = m_curve->m_points.size();
                         int nEdgePts = (
                             -1+(int)sqrt(static_cast<NekDouble>(8*N+1)))/2;
 
                         ASSERTL0(nEdgePts*(nEdgePts+1)/2 == N,
                                  "NUMPOINTS should be a triangle number for"
                                  " triangle "
                                  + boost::lexical_cast<string>(m_globalID));
 
                         for (i = 0; i < kNedges; ++i)
                         {
                             ASSERTL0(
                                 m_edges[i]->GetXmap()->GetNcoeffs() == nEdgePts,
                                 "Number of edge points does not correspond "
                                 "to number of face points in triangle "
                                 + boost::lexical_cast<string>(m_globalID));
                         }
 
                         const LibUtilities::PointsKey P0(
                             nEdgePts, LibUtilities::eGaussLobattoLegendre);
                         const LibUtilities::PointsKey P1(
                             nEdgePts, LibUtilities::eGaussRadauMAlpha1Beta0);
                         const LibUtilities::BasisKey  T0(
                             LibUtilities::eOrtho_A, nEdgePts, P0);
                         const LibUtilities::BasisKey  T1(
                             LibUtilities::eOrtho_B, nEdgePts, P1);
                         Array<OneD, NekDouble> phys(
                             max(nEdgePts*nEdgePts, m_xmap->GetTotPoints()));
                         Array<OneD, NekDouble> tmp(nEdgePts*nEdgePts);
 
                         for(i = 0; i < m_coordim; ++i)
                         {
                             // Create a StdNodalTriExp.
                             StdRegions::StdNodalTriExpSharedPtr t =
                                 MemoryManager<StdRegions::StdNodalTriExp>
                                 ::AllocateSharedPtr(T0, T1, m_curve->m_ptype);
 
                             for (j = 0; j < N; ++j)
                             {
                                 phys[j] = (m_curve->m_points[j]->GetPtr())[i];
                             }
 
                             t->BwdTrans(phys, tmp);
 
                             // Interpolate points to standard region.
                             LibUtilities::Interp2D(
                                 P0, P1, tmp,
                                 m_xmap->GetBasis(0)->GetPointsKey(),
                                 m_xmap->GetBasis(1)->GetPointsKey(),
                                 phys);
 
                             // Forwards transform to get coefficient space.
                             m_xmap->FwdTrans(phys, m_coeffs[i]);
                         }
                     }
                     else if (pdim == 1)
                     {
                         int npts = m_curve->m_points.size();
                         int nEdgePts = (int)sqrt(static_cast<NekDouble>(npts));
                         Array<OneD, NekDouble> tmp (npts);
                         Array<OneD, NekDouble> phys(m_xmap->GetTotPoints());
                         LibUtilities::PointsKey curveKey(
                             nEdgePts, m_curve->m_ptype);
 
                         // Sanity checks:
                         // - Curved faces should have square number of points;
                         // - Each edge should have sqrt(npts) points.
                         ASSERTL0(nEdgePts * nEdgePts == npts,
                                  "NUMPOINTS should be a square number for"
                                  " triangle "
                                  + boost::lexical_cast<string>(m_globalID));
 
                         for (i = 0; i < kNedges; ++i)
                         {
                             ASSERTL0(
                                 m_edges[i]->GetXmap()->GetNcoeffs() == nEdgePts,
                                 "Number of edge points does not correspond to "
                                 "number of face points in triangle "
                                 + boost::lexical_cast<string>(m_globalID));
                         }
 
                         for (i = 0; i < m_coordim; ++i)
                         {
                             for (j = 0; j < npts; ++j)
                             {
                                 tmp[j] = (m_curve->m_points[j]->GetPtr())[i];
                             }
 
                             // Interpolate curve points to standard triangle
                             // points.
                             LibUtilities::Interp2D(
                                 curveKey, curveKey, tmp,
                                 m_xmap->GetBasis(0)->GetPointsKey(),
                                 m_xmap->GetBasis(1)->GetPointsKey(),
                                 phys);
 
                             // Forwards transform to get coefficient space.
                             m_xmap->FwdTrans(phys, m_coeffs[i]);
                         }
                     }
                     else
                     {
                         ASSERTL0(false, "Only 1D/2D points distributions "
                                         "supported.");
                     }
                 }
 
                 Array<OneD, unsigned int> mapArray (nEdgeCoeffs);
                 Array<OneD, int>          signArray(nEdgeCoeffs);
 
                 for(i = 0; i < kNedges; i++)
                 {
                     m_edges[i]->FillGeom();
                     m_xmap->GetEdgeToElementMap(i,m_eorient[i],mapArray,signArray);
 
                     nEdgeCoeffs = m_edges[i]->GetXmap()->GetNcoeffs();
 
                     for(j = 0 ; j < m_coordim; j++)
                     {
                         for(k = 0; k < nEdgeCoeffs; k++)
                         {
                             m_coeffs[j][mapArray[k]] =
                                 signArray[k] * m_edges[i]->GetCoeffs(j)[k];
                         }
                     }
                 }
 
                 m_state = ePtsFilled;
             }
         }

void Nektar::SpatialDomains::TriGeom::v_GenGeomFactors ( )

protectedvirtual

Set up GeoFac for this geometry using Coord quadrature distribution

Implements Nektar::SpatialDomains::Geometry.

Definition at line 413 of file TriGeom.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SpatialDomains::eDeformed, Nektar::SpatialDomains::ePtsFilled, Nektar::SpatialDomains::eRegular, Nektar::SpatialDomains::Geometry::m_coeffs, Nektar::SpatialDomains::Geometry::m_coordim, Nektar::SpatialDomains::Geometry::m_geomFactors, Nektar::SpatialDomains::Geometry::m_geomFactorsState, Nektar::SpatialDomains::Geometry::m_xmap, and v_FillGeom().

         {
             if (m_geomFactorsState != ePtsFilled)
             {
                 GeomType Gtype = eRegular;
 
                 TriGeom::v_FillGeom();
 
                 // check to see if expansions are linear
                 for(int i = 0; i < m_coordim; ++i)
                 {
                     if(m_xmap->GetBasisNumModes(0) != 2 ||
                        m_xmap->GetBasisNumModes(1) != 2)
                     {
                         Gtype = eDeformed;
                     }
                 }
 
                 m_geomFactors = MemoryManager<GeomFactors>::AllocateSharedPtr(
                     Gtype, m_coordim, m_xmap, m_coeffs);
 
                 m_geomFactorsState = ePtsFilled;
             }
         }

const LibUtilities::BasisSharedPtr Nektar::SpatialDomains::TriGeom::v_GetBasis ( const int i )

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 377 of file TriGeom.cpp.

References Nektar::SpatialDomains::Geometry::m_xmap.

         {
             return m_xmap->GetBasis(i);
         }

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::v_GetCartesianEorient ( const int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 727 of file TriGeom.cpp.

References ASSERTL2, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, and m_eorient.

         {
             ASSERTL2((i >=0) && (i <= 3),"Edge id must be between 0 and 3");
             if(i < 2)
             {
                 return m_eorient[i];
             }
             else
             {
                 if(m_eorient[i] == StdRegions::eForwards)
                 {
                     return StdRegions::eBackwards;
                 }
                 else
                 {
                     return StdRegions::eForwards;
                 }
             }
         }

NekDouble Nektar::SpatialDomains::TriGeom::v_GetCoord	(	const int	i,
		const Array< OneD, const NekDouble > &	Lcoord
	)

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 404 of file TriGeom.cpp.

References GetCoord().

         {
             return GetCoord(i,Lcoord);
         }

int Nektar::SpatialDomains::TriGeom::v_GetCoordim ( void ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 368 of file TriGeom.cpp.

References Nektar::SpatialDomains::Geometry::m_coordim.

         {
             return m_coordim;
         }

const Geometry1DSharedPtr Nektar::SpatialDomains::TriGeom::v_GetEdge ( int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 707 of file TriGeom.cpp.

References ASSERTL2, and m_edges.

         {
             ASSERTL2((i >=0) && (i <= 2),"Edge id must be between 0 and 3");
             return m_edges[i];
         }

const LibUtilities::BasisSharedPtr Nektar::SpatialDomains::TriGeom::v_GetEdgeBasis ( const int i )

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 386 of file TriGeom.cpp.

References ASSERTL1, and Nektar::SpatialDomains::Geometry::m_xmap.

         {
             ASSERTL1(i <= 2, "edge is out of range");
 
             if(i == 0)
             {
                 return m_xmap->GetBasis(0);
             }
             else
             {
                 return m_xmap->GetBasis(1);
             }
         }

int Nektar::SpatialDomains::TriGeom::v_GetEid ( int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 677 of file TriGeom.cpp.

References ASSERTL2, and m_edges.

         {
             ASSERTL2((i >=0) && (i <= 2),"Edge id must be between 0 and 2");
             return m_edges[i]->GetEid();
         }

StdRegions::Orientation Nektar::SpatialDomains::TriGeom::v_GetEorient ( const int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 717 of file TriGeom.cpp.

References ASSERTL2, and m_eorient.

         {
             ASSERTL2((i >=0) && (i <= 2),"Edge id must be between 0 and 2");
             return m_eorient[i];
         }

int Nektar::SpatialDomains::TriGeom::v_GetFid ( ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 359 of file TriGeom.cpp.

References m_fid.

         {
             return m_fid;
         }

NekDouble Nektar::SpatialDomains::TriGeom::v_GetLocCoords	(	const Array< OneD, const NekDouble > &	coords,
		Array< OneD, NekDouble > &	Lcoords
	)

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 606 of file TriGeom.cpp.

         {
             NekDouble resid = 0.0;
             TriGeom::v_FillGeom();
 
             // calculate local coordinate for coord
             if(GetMetricInfo()->GetGtype() == eRegular)
             {
                 NekDouble coords2 = (m_coordim == 3)? coords[2]: 0.0;
                 PointGeom dv1, dv2, norm, orth1, orth2;
                 PointGeom xin(m_coordim,0,coords[0],coords[1],coords2);
 
                 // Calculate edge vectors from 0-1 and 0-2 edges.
                 dv1.Sub(*m_verts[1],*m_verts[0]);
                 dv2.Sub(*m_verts[2],*m_verts[0]);
 
                 // Obtain normal to plane in which dv1 and dv2 lie
                 norm.Mult(dv1,dv2);
 
                 // Obtain vector which are proportional to normal of dv1 and dv2.
                 orth1.Mult(norm,dv1);
                 orth2.Mult(norm,dv2);
 
                 // Start with vector of desired points minus vertex_0
                 xin -= *m_verts[0];
 
                 // Calculate length using L/|dv1| = (x-v0).n1/(dv1.n1) for coordiante 1
                 // Then rescale to [-1,1].
                 Lcoords[0] = xin.dot(orth2)/dv1.dot(orth2);
                 Lcoords[0] = 2*Lcoords[0]-1;
                 Lcoords[1] = xin.dot(orth1)/dv2.dot(orth1);
                 Lcoords[1] = 2*Lcoords[1]-1;
             }
             else
             {
                 // Determine nearest point of coords  to values in m_xmap
                 int npts = m_xmap->GetTotPoints();
                 Array<OneD, NekDouble> ptsx(npts), ptsy(npts);
                 Array<OneD, NekDouble> tmpx(npts), tmpy(npts);
 
                 m_xmap->BwdTrans(m_coeffs[0], ptsx);
                 m_xmap->BwdTrans(m_coeffs[1], ptsy);
 
                 const Array<OneD, const NekDouble> za = m_xmap->GetPoints(0);
                 const Array<OneD, const NekDouble> zb = m_xmap->GetPoints(1);
 
                 //guess the first local coords based on nearest point
                 Vmath::Sadd(npts, -coords[0], ptsx,1,tmpx,1);
                 Vmath::Sadd(npts, -coords[1], ptsy,1,tmpy,1);
                 Vmath::Vmul (npts, tmpx,1,tmpx,1,tmpx,1);
                 Vmath::Vvtvp(npts, tmpy,1,tmpy,1,tmpx,1,tmpx,1);
 
                 int min_i = Vmath::Imin(npts,tmpx,1);
 
                 Lcoords[0] = za[min_i%za.num_elements()];
                 Lcoords[1] = zb[min_i/za.num_elements()];
 
                 // recover cartesian coordinate from collapsed coordinate.
                 Lcoords[0] = (1.0+Lcoords[0])*(1.0-Lcoords[1])/2 -1.0;
 
                 // Perform newton iteration to find local coordinates
                 NewtonIterationForLocCoord(coords, ptsx, ptsy, Lcoords,resid);
             }
             return resid;
         }

int Nektar::SpatialDomains::TriGeom::v_GetNumEdges ( ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 783 of file TriGeom.cpp.

References kNedges.

         {
             return kNedges;
         }

int Nektar::SpatialDomains::TriGeom::v_GetNumVerts ( ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 774 of file TriGeom.cpp.

References kNverts.

         {
             return kNverts;
         }

PointGeomSharedPtr Nektar::SpatialDomains::TriGeom::v_GetVertex ( int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 697 of file TriGeom.cpp.

References ASSERTL2, and m_verts.

         {
             ASSERTL2((i >=0) && (i <= 2),"Vertex id must be between 0 and 2");
             return m_verts[i];
         }

int Nektar::SpatialDomains::TriGeom::v_GetVid ( int i ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 687 of file TriGeom.cpp.

References ASSERTL2, and m_verts.

         {
             ASSERTL2((i >=0) && (i <= 2),"Vertex id must be between 0 and 2");
             return m_verts[i]->GetVid();
         }

bool Nektar::SpatialDomains::TriGeom::v_IsElmtConnected	(	int	gvo_id,
		int	locid
	)		const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 344 of file TriGeom.cpp.

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

         {
             std::list<CompToElmt>::const_iterator def;
             CompToElmt ee(gvo_id,locid);
 
             def = find(m_elmtMap.begin(),m_elmtMap.end(),ee);
 
             // Found the element connectivity object in the list
             return (def != m_elmtMap.end());
         }

int Nektar::SpatialDomains::TriGeom::v_NumElmtConnected ( ) const

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 335 of file TriGeom.cpp.

References m_elmtMap.

         {
             return int(m_elmtMap.size());
         }

void Nektar::SpatialDomains::TriGeom::v_Reset	(	CurveMap &	curvedEdges,
		CurveMap &	curvedFaces
	)

protectedvirtual

Reset this geometry object: unset the current state and remove allocated GeomFactors.

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 829 of file TriGeom.cpp.

References Nektar::iterator, m_curve, m_edges, Nektar::SpatialDomains::Geometry::m_globalID, Nektar::SpatialDomains::Geometry::m_xmap, Nektar::SpatialDomains::Geometry::SetUpCoeffs(), SetUpXmap(), and Nektar::SpatialDomains::Geometry::v_Reset().

         {
             Geometry::v_Reset(curvedEdges, curvedFaces);
             CurveMap::iterator it = curvedFaces.find(m_globalID);
 
             if (it != curvedFaces.end())
             {
                 m_curve = it->second;
             }
 
             for (int i = 0; i < 3; ++i)
             {
                 m_edges[i]->Reset(curvedEdges, curvedFaces);
             }
 
             SetUpXmap();
             SetUpCoeffs(m_xmap->GetNcoeffs());
         }

void Nektar::SpatialDomains::TriGeom::v_SetOwnData ( )

protectedvirtual

Reimplemented from Nektar::SpatialDomains::Geometry.

Definition at line 441 of file TriGeom.cpp.

References m_ownData.

         {
             m_ownData = true;
         }

int Nektar::SpatialDomains::TriGeom::v_WhichEdge ( SegGeomSharedPtr edge )

protectedvirtual

Return the edge number of the given edge.

Reimplemented from Nektar::SpatialDomains::Geometry2D.

Definition at line 751 of file TriGeom.cpp.

References Nektar::iterator, and m_edges.

         {
             int returnval = -1;
 
             SegGeomVector::iterator edgeIter;
             int i;
 
             for (i=0,edgeIter = m_edges.begin(); edgeIter != m_edges.end(); ++edgeIter,++i)
             {
                 if (*edgeIter == edge)
                 {
                     returnval = i;
                     break;
                 }
             }
 
             return returnval;
         }