Nektar++
Public Member Functions | Static Public Member Functions | Private Member Functions | List of all members
Nektar::LibUtilities::NodalTriFekete Class Reference

#include <NodalTriFekete.h>

Inheritance diagram for Nektar::LibUtilities::NodalTriFekete:
Inheritance graph
[legend]
Collaboration diagram for Nektar::LibUtilities::NodalTriFekete:
Collaboration graph
[legend]

Public Member Functions

virtual ~NodalTriFekete ()
 
 NodalTriFekete (const PointsKey &key)
 
const MatrixSharedPtrType GetI (const PointsKey &pkey)
 
const MatrixSharedPtrType GetI (const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y)
 
- Public Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
virtual ~Points ()
 
virtual void Initialize (void)
 
unsigned int GetPointsDim () const
 
unsigned int GetNumPoints () const
 
unsigned int GetTotNumPoints () const
 
PointsType GetPointsType () const
 
const Array< OneD, const DataType > & GetZ () const
 
const Array< OneD, const DataType > & GetW () const
 
void GetZW (Array< OneD, const DataType > &z, Array< OneD, const DataType > &w) const
 
void GetPoints (Array< OneD, const DataType > &x) const
 
void GetPoints (Array< OneD, const DataType > &x, Array< OneD, const DataType > &y) const
 
void GetPoints (Array< OneD, const DataType > &x, Array< OneD, const DataType > &y, Array< OneD, const DataType > &z) const
 
const MatrixSharedPtrType & GetD (Direction dir=xDir) const
 
virtual const MatrixSharedPtrType GetI (const Array< OneD, const DataType > &x)
 
virtual const MatrixSharedPtrType GetI (unsigned int numpoints, const Array< OneD, const DataType > &x)
 
virtual const MatrixSharedPtrType GetI (const Array< OneD, const DataType > &x, const Array< OneD, const DataType > &y, const Array< OneD, const DataType > &z)
 
virtual const MatrixSharedPtrType GetGalerkinProjection (const PointsKey &pkey)
 

Static Public Member Functions

static boost::shared_ptr< PointsBaseType > Create (const PointsKey &key)
 

Private Member Functions

 NodalTriFekete ()
 
void CalculatePoints ()
 
void CalculateWeights ()
 
void CalculateDerivMatrix ()
 
void NodalPointReorder2d ()
 
void CalculateInterpMatrix (const Array< OneD, const NekDouble > &xi, const Array< OneD, const NekDouble > &yi, Array< OneD, NekDouble > &interp)
 

Additional Inherited Members

- Public Types inherited from Nektar::LibUtilities::Points< NekDouble >
typedef NekDouble DataType
 
typedef boost::shared_ptr< NekMatrix< DataType > > MatrixSharedPtrType
 
- Protected Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
 Points (const PointsKey &key)
 
- Protected Attributes inherited from Nektar::LibUtilities::Points< NekDouble >
PointsKey m_pointsKey
 
Array< OneD, DataType > m_points [3]
 
Array< OneD, DataType > m_weights
 
MatrixSharedPtrType m_derivmatrix [3]
 
NekManager< PointsKey, NekMatrix< DataType >, PointsKey::opLess > m_InterpManager
 
NekManager< PointsKey, NekMatrix< DataType >, PointsKey::opLess > m_GalerkinProjectionManager
 

Detailed Description

Definition at line 53 of file NodalTriFekete.h.

Constructor & Destructor Documentation

virtual Nektar::LibUtilities::NodalTriFekete::~NodalTriFekete ( )
inlinevirtual

Definition at line 56 of file NodalTriFekete.h.

57  {
58  std::cout << "******* ~NodalTriFekete() destructor called!"
59  << endl;
60  }
Nektar::LibUtilities::NodalTriFekete::NodalTriFekete ( const PointsKey &  key)
inline

Definition at line 62 of file NodalTriFekete.h.

62  :PointsBaseType(key)
63  {
64  }
Nektar::LibUtilities::PointsBaseType
Points< NekDouble > PointsBaseType
Definition: FoundationsFwd.hpp:83
Nektar::LibUtilities::NodalTriFekete::NodalTriFekete ( )
inlineprivate

Definition at line 95 of file NodalTriFekete.h.

95  :PointsBaseType(NullPointsKey)
96  {
97  std::cout << "******* NodalTriFekete() constructor called!"
98  << endl;
99  }
Nektar::LibUtilities::NullPointsKey
static const PointsKey NullPointsKey(0, eNoPointsType)
Nektar::LibUtilities::PointsBaseType
Points< NekDouble > PointsBaseType
Definition: FoundationsFwd.hpp:83

Member Function Documentation

void Nektar::LibUtilities::NodalTriFekete::CalculateDerivMatrix ( )
privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 166 of file NodalTriFekete.cpp.

References Nektar::LibUtilities::Points< NekDouble >::CalculateDerivMatrix(), Nektar::LibUtilities::GetXDerivativeMatrix(), Nektar::LibUtilities::GetYDerivativeMatrix(), Nektar::LibUtilities::Points< NekDouble >::m_derivmatrix, and Nektar::LibUtilities::Points< NekDouble >::m_points.

167  {
168  // Allocate the derivative matrix.
169  PointsBaseType::CalculateDerivMatrix();
170 
171  NekVector<NekDouble> x( m_points[0] );
172  NekVector<NekDouble> y( m_points[1] );
173  NekVector<NekDouble> xi = x;
174  NekVector<NekDouble> yi = y;
175 
176  m_derivmatrix[0] = GetXDerivativeMatrix(x,y,xi,yi);
177  m_derivmatrix[1] = GetYDerivativeMatrix(x,y,xi,yi);
178 
179  }
Nektar::LibUtilities::GetXDerivativeMatrix
Points< NekDouble >::MatrixSharedPtrType GetXDerivativeMatrix(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
Definition: NodalUtil.cpp:852
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Definition: Points.h:349
Nektar::LibUtilities::Points< NekDouble >::m_derivmatrix
MatrixSharedPtrType m_derivmatrix[3]
Definition: Points.h:351
Nektar::LibUtilities::GetYDerivativeMatrix
Points< NekDouble >::MatrixSharedPtrType GetYDerivativeMatrix(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
Definition: NodalUtil.cpp:1303
void Nektar::LibUtilities::NodalTriFekete::CalculateInterpMatrix ( const Array< OneD, const NekDouble > &  xi,
const Array< OneD, const NekDouble > &  yi,
Array< OneD, NekDouble > &  interp 
)
private

Definition at line 147 of file NodalTriFekete.cpp.

References Nektar::LibUtilities::GetInterpolationMatrix(), Nektar::NekVector< DataType >::GetRows(), Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints(), and Nektar::LibUtilities::Points< NekDouble >::m_points.

Referenced by GetI().

149  {
150  NekVector<NekDouble> x( m_points[0] );
151  NekVector<NekDouble> y( m_points[1] );
152  NekVector<NekDouble> xi( xia );
153  NekVector<NekDouble> yi( yia );
154  NekMatrix<NekDouble> interMat = GetInterpolationMatrix(x, y, xi, yi);
155 
156  int rows = xi.GetRows(), cols = GetTotNumPoints();
157  for( int i = 0; i < rows; ++i ) {
158  for( int j = 0; j < cols; ++j ) {
159  interp[j + i*cols] = interMat(i,j);
160  }
161  }
162  }
Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints
unsigned int GetTotNumPoints() const
Definition: Points.h:251
Nektar::LibUtilities::GetInterpolationMatrix
NekMatrix< NekDouble > GetInterpolationMatrix(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &xi, const NekVector< NekDouble > &yi)
Definition: NodalUtil.cpp:609
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Definition: Points.h:349
void Nektar::LibUtilities::NodalTriFekete::CalculatePoints ( )
privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 55 of file NodalTriFekete.cpp.

References ASSERTL1, Nektar::LibUtilities::Points< NekDouble >::CalculatePoints(), Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::LibUtilities::PointsKey::GetTotNumPoints(), Nektar::LibUtilities::Points< NekDouble >::m_points, Nektar::LibUtilities::Points< NekDouble >::m_pointsKey, NodalPointReorder2d(), Nektar::LibUtilities::NodalTriFeketeData, Nektar::LibUtilities::NodalTriFeketeNPTS, Nektar::LibUtilities::perm3A_2d, Nektar::LibUtilities::perm3B_2d, and Nektar::LibUtilities::perm6_2d.

56  {
57  // Allocate the storage for points
58  PointsBaseType::CalculatePoints();
59 
60  int index=0,isum=0;
61  const int offset = 3; //offset to match Datafile
62  NekDouble b,c;
63  unsigned int numPoints = GetNumPoints();
64 
65  // initialize values
66  for(unsigned int i=0; i < numPoints-2; ++i)
67  {
68  index += NodalTriFeketeNPTS[i];
69  }
70 
71  for(unsigned int i=0; i < NodalTriFeketeNPTS[numPoints-2]; ++i, ++index)
72  {
73  if(int(NodalTriFeketeData[index][0]))
74  {
75  b = NodalTriFeketeData[index][4];
76  c = NodalTriFeketeData[index][5];
77 
78  m_points[0][isum] = 2.0*b - 1.0;
79  m_points[1][isum] = 2.0*c - 1.0;
80  isum++;
81  continue;
82  }//end symmetry1
83 
84 
85  if(int(NodalTriFeketeData[index][1]) == 1)
86  {
87  for(unsigned int j=0; j < 3; ++j)
88  {
89  b = NodalTriFeketeData[index][offset+perm3A_2d[j][1]];
90  c = NodalTriFeketeData[index][offset+perm3A_2d[j][2]];
91  m_points[0][isum] = 2.0*b - 1.0;
92  m_points[1][isum] = 2.0*c - 1.0;
93  isum++;
94  }//end j
95  continue;
96  }//end symmetry3a
97 
98  if(int(NodalTriFeketeData[index][1]) == 2)
99  {
100  for(unsigned int j=0; j < 3; ++j)
101  {
102  b = NodalTriFeketeData[index][offset+perm3B_2d[j][1]];
103  c = NodalTriFeketeData[index][offset+perm3B_2d[j][2]];
104  m_points[0][isum] = 2.0*b - 1.0;
105  m_points[1][isum] = 2.0*c - 1.0;
106  isum++;
107  }//end j
108  continue;
109  }//end symmetry3b
110 
111 
112  if(int(NodalTriFeketeData[index][2]))
113  {
114  for(unsigned int j=0; j < 6; ++j)
115  {
116  b = NodalTriFeketeData[index][offset+perm6_2d[j][1]];
117  c = NodalTriFeketeData[index][offset+perm6_2d[j][2]];
118  m_points[0][isum] = 2.0*b - 1.0;
119  m_points[1][isum] = 2.0*c - 1.0;
120  isum++;
121  }//end j
122  continue;
123  }//end symmetry6
124  }//end npts
125 
126  NodalPointReorder2d();
127 
128  ASSERTL1((static_cast<unsigned int>(isum)==m_pointsKey.GetTotNumPoints()),"sum not equal to npts");
129  }
Nektar::LibUtilities::perm3B_2d
static const unsigned int perm3B_2d[3][3]
Definition: NodalTriElecData.h:7
Nektar::LibUtilities::NodalTriFeketeNPTS
static const unsigned int NodalTriFeketeNPTS[NodalTriFeketeAvailable]
Definition: NodalTriFeketeData.h:11
Nektar::LibUtilities::PointsKey::GetTotNumPoints
unsigned int GetTotNumPoints() const
Definition: Points.h:175
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::LibUtilities::perm3A_2d
static const unsigned int perm3A_2d[3][3]
Definition: NodalTriElecData.h:6
Nektar::LibUtilities::Points< NekDouble >::GetNumPoints
unsigned int GetNumPoints() const
Definition: Points.h:246
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Definition: Points.h:349
Nektar::LibUtilities::perm6_2d
static const unsigned int perm6_2d[6][3]
Definition: NodalTriElecData.h:8
Nektar::LibUtilities::NodalTriFeketeData
static const NekDouble NodalTriFeketeData[][6]
Definition: NodalTriFeketeData.h:12
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
void Nektar::LibUtilities::NodalTriFekete::CalculateWeights ( )
privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 131 of file NodalTriFekete.cpp.

References Nektar::LibUtilities::Points< NekDouble >::CalculateWeights(), Nektar::NekVector< DataType >::GetPtr(), Nektar::NekVector< DataType >::GetRows(), Nektar::LibUtilities::Points< NekDouble >::m_points, Nektar::LibUtilities::Points< NekDouble >::m_weights, and Nektar::LibUtilities::MakeQuadratureWeights().

132  {
133  // Allocate the storage for points
134  PointsBaseType::CalculateWeights();
135 
136  typedef DataType T;
137 
138  // Solve the Vandermonde system of integrals for the weight vector
139  NekVector<T> w = MakeQuadratureWeights(NekVector<T>(m_points[0]), NekVector<T>(m_points[1]));
140 
141  m_weights = Array<OneD,T>( w.GetRows(), w.GetPtr() );
142 
143  }
Nektar::LibUtilities::Points< NekDouble >::m_weights
Array< OneD, DataType > m_weights
Definition: Points.h:350
Nektar::LibUtilities::MakeQuadratureWeights
NekVector< NekDouble > MakeQuadratureWeights(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: NodalUtil.cpp:579
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Definition: Points.h:349
boost::shared_ptr< PointsBaseType > Nektar::LibUtilities::NodalTriFekete::Create ( const PointsKey &  key)
static

Definition at line 181 of file NodalTriFekete.cpp.

182  {
183  boost::shared_ptr<PointsBaseType> returnval(MemoryManager<NodalTriFekete>::AllocateSharedPtr(key));
184  returnval->Initialize();
185  return returnval;
186  }
const MatrixSharedPtrType Nektar::LibUtilities::NodalTriFekete::GetI ( const PointsKey &  pkey)
inlinevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 69 of file NodalTriFekete.h.

References ASSERTL0, Nektar::LibUtilities::PointsKey::GetPointsDim(), and Nektar::LibUtilities::PointsManager().

70  {
71  ASSERTL0(pkey.GetPointsDim() == 2,
72  "Fekete Points can only interp to other 2d "
73  "point distributions");
74  Array<OneD, const NekDouble> x, y;
75  PointsManager()[pkey]->GetPoints(x, y);
76  return GetI(x, y);
77  }
Nektar::LibUtilities::NodalTriFekete::GetI
const MatrixSharedPtrType GetI(const PointsKey &pkey)
Definition: NodalTriFekete.h:69
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::LibUtilities::PointsManager
PointsManagerT & PointsManager(void)
Definition: ManagerAccess.cpp:92
const MatrixSharedPtrType Nektar::LibUtilities::NodalTriFekete::GetI ( const Array< OneD, const NekDouble > &  x,
const Array< OneD, const NekDouble > &  y 
)
inlinevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 79 of file NodalTriFekete.h.

References CalculateInterpMatrix(), and Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints().

82  {
83  int numpoints = x.num_elements();
84  unsigned int np = GetTotNumPoints();
85 
86  Array<OneD, NekDouble> interp(GetTotNumPoints()*numpoints);
87  CalculateInterpMatrix(x, y, interp);
88 
89  NekDouble* d = interp.data();
90  return MemoryManager<NekMatrix<NekDouble> >
91  ::AllocateSharedPtr(numpoints, np, d);
92  }
Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints
unsigned int GetTotNumPoints() const
Definition: Points.h:251
Nektar::LibUtilities::NodalTriFekete::CalculateInterpMatrix
void CalculateInterpMatrix(const Array< OneD, const NekDouble > &xi, const Array< OneD, const NekDouble > &yi, Array< OneD, NekDouble > &interp)
Definition: NodalTriFekete.cpp:147
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
void Nektar::LibUtilities::NodalTriFekete::NodalPointReorder2d ( )
private

Definition at line 188 of file NodalTriFekete.cpp.

References Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::NekConstants::kNekZeroTol, and Nektar::LibUtilities::Points< NekDouble >::m_points.

Referenced by CalculatePoints().

189  {
190  int i,j;
191  int cnt;
192  int istart,iend;
193 
194  const int nVerts = 3;
195  const int nEdgeInteriorPoints = GetNumPoints()-2;
196  const int nBoundaryPoints = 3*nEdgeInteriorPoints + 3;
197 
198  if(nEdgeInteriorPoints==0)
199  {
200  return;
201  }
202 
203  // group the points of edge 1 together;
204  istart = nVerts;
205  for(i = cnt = istart; i < nBoundaryPoints; i++)
206  {
207  if( fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
208  {
209  std::swap(m_points[0][cnt], m_points[0][i]);
210  std::swap(m_points[1][cnt], m_points[1][i]);
211  cnt++;
212  }
213  }
214 
215  // bubble sort edge 1 (counterclockwise numbering)
216  iend = istart + nEdgeInteriorPoints;
217  for(i = istart; i < iend; i++)
218  {
219  for(j = istart+1; j < iend; j++)
220  {
221  if(m_points[0][j] < m_points[0][j-1])
222  {
223  std::swap(m_points[0][j], m_points[0][j-1]);
224  std::swap(m_points[1][j], m_points[1][j-1]);
225  }
226  }
227  }
228 
229  // group the points of edge 2 together;
230  istart = iend;
231  for(i = cnt = istart; i < nBoundaryPoints; i++)
232  {
233  if( fabs(m_points[1][i]+m_points[0][i]) < NekConstants::kNekZeroTol)
234  {
235  std::swap(m_points[0][cnt], m_points[0][i]);
236  std::swap(m_points[1][cnt], m_points[1][i]);
237  cnt++;
238  }
239  }
240 
241  // bubble sort edge 2 (counterclockwise numbering)
242  iend = istart + nEdgeInteriorPoints;
243  for(i = istart; i < iend; i++)
244  {
245  for(j = istart+1; j < iend; j++)
246  {
247  if(m_points[1][j] < m_points[1][j-1])
248  {
249  std::swap(m_points[0][j], m_points[0][j-1]);
250  std::swap(m_points[1][j], m_points[1][j-1]);
251  }
252  }
253  }
254 
255  // group the points of edge 3 together;
256  istart = iend;
257  for(i = cnt = istart; i < nBoundaryPoints; i++)
258  {
259  if( fabs(m_points[0][i]+1.0) < NekConstants::kNekZeroTol)
260  {
261  std::swap(m_points[0][cnt], m_points[0][i]);
262  std::swap(m_points[1][cnt], m_points[1][i]);
263  cnt++;
264  }
265  }
266  // bubble sort edge 3 (counterclockwise numbering)
267  iend = istart + nEdgeInteriorPoints;
268  for(i = istart; i < iend; i++)
269  {
270  for(j = istart+1; j < iend; j++)
271  {
272  if(m_points[1][j] > m_points[1][j-1])
273  {
274  std::swap(m_points[0][j], m_points[0][j-1]);
275  std::swap(m_points[1][j], m_points[1][j-1]);
276  }
277  }
278  }
279  return;
280  }
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:51
Nektar::LibUtilities::Points< NekDouble >::GetNumPoints
unsigned int GetNumPoints() const
Definition: Points.h:246
Nektar::LibUtilities::Points< NekDouble >::m_points
Array< OneD, DataType > m_points[3]
Definition: Points.h:349
Generated on Tue Dec 8 2015 23:45:36 for Nektar++ by   doxygen 1.8.9.1