#include <PtsField.h>

Collaboration diagram for Nektar::LibUtilities::PtsField:

Public Member Functions
	PtsField (const int dim, const Array< OneD, Array< OneD, NekDouble > > &pts)

	PtsField (const int dim, const vector< std::string > fieldnames, const Array< OneD, Array< OneD, NekDouble > > &pts)

	PtsField (const int dim, const vector< std::string > fieldnames, const Array< OneD, Array< OneD, NekDouble > > &pts, const Array< OneD, Array< OneD, float > > &weights, const Array< OneD, Array< OneD, unsigned int > > &neighInds)

void	CalcWeights (const Array< OneD, Array< OneD, NekDouble > > &physCoords, short int coordId=-1)
	Compute the weights for an interpolation of the field values to physical points. More...

void	Interpolate (const Array< OneD, Array< OneD, NekDouble > > &physCoords, Array< OneD, Array< OneD, NekDouble > > &intFields, short int coordId=-1)
	Compute weights and perform the interpolate of field values to physical points. More...

void	Interpolate (Array< OneD, Array< OneD, NekDouble > > &intFields)
	Perform the interpolate of field values to physical points. More...

void	SetWeights (const Array< OneD, Array< OneD, float > > &weights, const Array< OneD, Array< OneD, unsigned int > > &neighbourInds)
	Set the interpolation weights for an interpolation. More...

void	GetWeights (Array< OneD, Array< OneD, float > > &weights, Array< OneD, Array< OneD, unsigned int > > &neighbourInds) const
	Get the interpolation weights and corresponding neighbour indices. More...

void	GetConnectivity (vector< Array< OneD, int > > &conn) const
	Set the connectivity data for ePtsTetBlock and ePtsTriBlock. More...

void	SetConnectivity (const vector< Array< OneD, int > > &conn)
	Get the connectivity data for ePtsTetBlock and ePtsTriBlock. More...

void	SetDim (const int ptsDim)

int	GetDim () const

int	GetNFields () const

vector< std::string >	GetFieldNames () const

std::string	GetFieldName (const int i) const

void	SetFieldNames (const vector< std::string > fieldNames)

void	AddField (const Array< OneD, NekDouble > &pts, const std::string fieldName)

int	GetNpoints () const

NekDouble	GetPointVal (const int fieldInd, const int ptInd) const

void	GetPts (Array< OneD, Array< OneD, NekDouble > > &pts) const

Array< OneD, NekDouble >	GetPts (const int fieldInd) const

void	SetPts (Array< OneD, Array< OneD, NekDouble > > &pts)

vector< int >	GetPointsPerEdge () const

int	GetPointsPerEdge (const int i) const

void	SetPointsPerEdge (const vector< int > nPtsPerEdge)
	Set the number of points per edge. More...

PtsType	GetPtsType () const

void	SetPtsType (const PtsType type)

template<typename FuncPointerT , typename ObjectPointerT >
void	setProgressCallback (FuncPointerT func, ObjectPointerT obj)

Private Member Functions
void	CalcW_Linear (const int physPtIdx, const NekDouble coord)
	Compute interpolation weights for a 1D physical point using linear interpolation. More...

void	CalcW_Shepard (const int physPtIdx, const Array< OneD, NekDouble > &physPtCoords)
	Compute interpolation weights for a physical point using a modified Shepard algorithm. More...

void	CalcW_Quadratic (const int physPtIdx, const NekDouble coord)
	Compute interpolation weights for a 1D physical point using quadratic interpolation. More...

NekDouble	DistSq (const Array< OneD, NekDouble > &point1, const Array< OneD, NekDouble > &point2) const
	Compute the square of the euclidean distance between point1 and point2. More...

void	FindNeighbours (const Array< OneD, NekDouble > &physPtCoords, vector< PtsPoint > &neighbourPts, const unsigned int numPts=1)
	Find nearest neighbours using a brute-force "algorithm". More...

Private Attributes
int	m_dim
	Dimension of the pts field. More...

vector< std::string >	m_fieldNames
	Names of the field variables. More...

Array< OneD, Array< OneD, NekDouble > >	m_pts
	Point data. For a n-dimensional field, the first n fields are the points spatial coordinates. Structure: m_pts[fieldIdx][ptIdx]. More...

vector< int >	m_nPtsPerEdge
	Number of points per edge. Empty if the point data has no specific shape (ePtsLine) or is a block (ePtsTetBlock, ePtsTriBlock), size=1 for ePtsLine and 2 for a ePtsPlane. More...

vector< Array< OneD, int > >	m_ptsConn
	Connectivity data needed for ePtsTetBlock and ePtsTriBlock. For n Blocks with m elements each, m_ptsConn is a vector of n arrays with 3m (ePtsTriBlock) or 4m (ePtsTetBlock) entries. More...

PtsType	m_ptsType
	Type of the PtsField. More...

Array< OneD, Array< OneD, float > >	m_weights
	Interpolation weights for each neighbour. Structure: m_weights[physPtIdx][neighbourIdx]. More...

Array< OneD, Array< OneD, unsigned int > >	m_neighInds
	Indices of the relevant neighbours for each physical point. Structure: m_neighInds[ptIdx][neighbourIdx]. More...

boost::function< void(const int position, const int goal)>	m_progressCallback

Detailed Description

Definition at line 89 of file PtsField.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::PtsField::PtsField	(	const int	dim,
		const Array< OneD, Array< OneD, NekDouble > > &	pts
	)

inline

Definition at line 93 of file PtsField.h.

                                                              :
             m_dim(dim),
             m_pts(pts),
             m_ptsType(ePtsFile)
         {
         };

Nektar::LibUtilities::PtsField::PtsField	(	const int	dim,
		const vector< std::string >	fieldnames,
		const Array< OneD, Array< OneD, NekDouble > > &	pts
	)

inline

Definition at line 102 of file PtsField.h.

                                                              :
             m_dim(dim),
             m_fieldNames(fieldnames),
             m_pts(pts),
             m_ptsType(ePtsFile)
         {
         };

Nektar::LibUtilities::PtsField::PtsField	(	const int	dim,
		const vector< std::string >	fieldnames,
		const Array< OneD, Array< OneD, NekDouble > > &	pts,
		const Array< OneD, Array< OneD, float > > &	weights,
		const Array< OneD, Array< OneD, unsigned int > > &	neighInds
	)

inline

Definition at line 113 of file PtsField.h.

                                                                       :
             m_dim(dim),
             m_fieldNames(fieldnames),
             m_pts(pts),
             m_ptsType(ePtsFile),
             m_weights(weights),
             m_neighInds(neighInds)
         {
         };

Member Function Documentation

void Nektar::LibUtilities::PtsField::AddField	(	const Array< OneD, NekDouble > &	pts,
		const std::string	fieldName
	)

Definition at line 267 of file PtsField.cpp.

References ASSERTL1, m_fieldNames, and m_pts.

 {
     int nTotvars = m_pts.num_elements();
     int nPts = m_pts[0].num_elements();
 
     ASSERTL1(pts.num_elements() ==  nPts, "Field size mismatch");
 
     // redirect existing pts
     Array<OneD, Array<OneD, NekDouble> > newpts(nTotvars + 1);
     for (int i = 0; i < nTotvars; ++i)
     {
         newpts[i] = m_pts[i];
     }
     newpts[nTotvars] = pts;
 
     m_pts = newpts;
 
     m_fieldNames.push_back(fieldName);
 }

void Nektar::LibUtilities::PtsField::CalcW_Linear	(	const int	physPtIdx,
		const NekDouble	coord
	)

private

Compute interpolation weights for a 1D physical point using linear interpolation.

Parameters

physPtIdx	The index of the physical point in its storage array
coord	The coordinate of the physical point

Definition at line 377 of file PtsField.cpp.

References ASSERTL0, m_neighInds, m_pts, m_weights, and npts.

Referenced by CalcWeights().

 {
     int npts = m_pts[0].num_elements();
     int i;
 
     int numPts = 2;
     m_neighInds[physPtIdx] = Array<OneD, unsigned int> (numPts);
     m_weights[physPtIdx] = Array<OneD, float> (numPts, 0.0);
 
     for (i = 0; i < npts - 1; ++i)
     {
         if ((m_pts[0][i] <= coord) && (coord <= m_pts[0][i + 1]))
         {
             NekDouble pdiff = m_pts[0][i + 1] - m_pts[0][i];
 
             m_neighInds[physPtIdx][0] = i;
             m_neighInds[physPtIdx][1] = i + 1;
 
             m_weights[physPtIdx][0] = (m_pts[0][i + 1] - coord) / pdiff;
             m_weights[physPtIdx][1] = (coord - m_pts[0][i]) / pdiff;
 
             break;
         }
     }
     ASSERTL0(i != npts - 1, "Failed to find coordinate " +
              boost::lexical_cast<string>(coord) +
              " within provided input points");
 };

void Nektar::LibUtilities::PtsField::CalcW_Quadratic	(	const int	physPtIdx,
		const NekDouble	coord
	)

private

Compute interpolation weights for a 1D physical point using quadratic interpolation.

Parameters

physPtIdx	The index of the physical point in its storage array
coord	The coordinate of the physical point

Definition at line 471 of file PtsField.cpp.

References ASSERTL0, m_neighInds, m_pts, m_weights, and npts.

Referenced by CalcWeights().

 {
     int npts = m_pts[0].num_elements();
     int i;
 
     int numPts = 3;
     m_neighInds[physPtIdx] = Array<OneD, unsigned int> (numPts);
     m_weights[physPtIdx] = Array<OneD, float> (numPts, 0.0);
 
     for (i = 0; i < npts - 1; ++i)
     {
         if ((m_pts[0][i] <= coord) && (coord <= m_pts[0][i + 1]))
         {
             NekDouble pdiff = m_pts[0][i + 1] - m_pts[0][i];
             NekDouble h1, h2, h3;
 
             if (i < npts - 2)
             {
                 // forwards stencil
                 NekDouble pdiff2 = m_pts[0][i + 2] - m_pts[0][i + 1];
 
                 h1 = (m_pts[0][i + 1] - coord)
                      * (m_pts[0][i + 2] - coord)
                      / (pdiff * (pdiff + pdiff2));
                 h2 = (coord - m_pts[0][i])
                      * (m_pts[0][i + 2] - coord)
                      / (pdiff * pdiff2);
                 h3 = (coord - m_pts[0][i])
                      * (coord - m_pts[0][i + 1])
                      / ((pdiff + pdiff2) * pdiff2);
 
                 m_neighInds[physPtIdx][0] = i;
                 m_neighInds[physPtIdx][1] = i + 1;
                 m_neighInds[physPtIdx][2] = i + 2;
             }
             else
             {
                 // backwards stencil
                 NekDouble pdiff2 = m_pts[0][i] - m_pts[0][i - 1];
 
                 h1 = (m_pts[0][i + 1] - coord)
                      * (coord - m_pts[0][i - 1])
                      / (pdiff * pdiff2);
                 h2 = (coord - m_pts[0][i])
                      * (coord - m_pts[0][i - 1])
                      / (pdiff * (pdiff + pdiff2));
                 h3 = (m_pts[0][i] - coord)
                      * (m_pts[0][i + 1] - coord)
                      / ((pdiff + pdiff2) * pdiff);
 
                 m_neighInds[physPtIdx][0] = i;
                 m_neighInds[physPtIdx][1] = i + 1;
                 m_neighInds[physPtIdx][2] = i - 1;
             }
 
 
             m_weights[physPtIdx][0] = h1;
             m_weights[physPtIdx][1] = h2;
             m_weights[physPtIdx][2] = h3;
 
             break;
         }
     }
     ASSERTL0(i != npts - 1, "Failed to find coordinate " +
              boost::lexical_cast<string>(coord) +
              " within provided input points");
 };

void Nektar::LibUtilities::PtsField::CalcW_Shepard	(	const int	physPtIdx,
		const Array< OneD, NekDouble > &	physPt
	)

private

Compute interpolation weights for a physical point using a modified Shepard algorithm.

Parameters

physPtIdx	The index of the physical point in its storage array
physPt	The coordinates of the physical point

The algorithm is based on Shepard, D. (1968). A two-dimensional interpolation function for irregularly-spaced data. Proceedings of the 1968 23rd ACM National Conference. pp. 517–524.

In order to save memory, for n dimesnions, only 2^n points are considered. Contrary to Shepard, we use a fixed number of points with fixed weighting factors 1/d^n.

Definition at line 422 of file PtsField.cpp.

References FindNeighbours(), m_dim, m_neighInds, m_pts, and m_weights.

Referenced by CalcWeights().

 {
     // find nearest neighbours
     vector<PtsPoint> neighbourPts;
     int numPts = pow(float(2), m_dim);
     numPts = min(numPts, int(m_pts[0].num_elements() / 2));
     FindNeighbours(physPt, neighbourPts, numPts);
 
     m_neighInds[physPtIdx] = Array<OneD, unsigned int> (numPts);
     for (int i = 0; i < numPts; i++)
     {
         m_neighInds[physPtIdx][i] = neighbourPts.at(i).m_idx;
     }
 
     m_weights[physPtIdx] = Array<OneD, float> (numPts, 0.0);
 
     // In case of an exact match, use the exact point and return
     for (int i = 0; i < numPts; ++i)
     {
         if (neighbourPts[i].m_distSq == 0.0)
         {
             m_weights[physPtIdx][i] = 1.0;
             return;
         }
     }
 
     NekDouble wSum = 0.0;
     for (int i = 0; i < numPts; ++i)
     {
         m_weights[physPtIdx][i] = 1 / pow(double(neighbourPts[i].m_distSq),
                                           double(m_dim / float(2)));
         wSum += m_weights[physPtIdx][i];
     }
 
     for (int i = 0; i < numPts; ++i)
     {
         m_weights[physPtIdx][i] = m_weights[physPtIdx][i] / wSum;
     }
 
 }

void Nektar::LibUtilities::PtsField::CalcWeights	(	const Array< OneD, Array< OneD, NekDouble > > &	physCoords,
		short int	coordId = `-1`
	)

Compute the weights for an interpolation of the field values to physical points.

Parameters

physCoords	coordinates of the physical points
coord_id	id of the coordinate to use for interpolation.

Set coord_id to -1 to use n-D interpolation for an n-dimensional field. The most suitable algorithm is chosen automatically.

Definition at line 53 of file PtsField.cpp.

References ASSERTL1, CalcW_Linear(), CalcW_Quadratic(), CalcW_Shepard(), m_dim, m_neighInds, m_progressCallback, m_pts, and m_weights.

Referenced by Interpolate().

 {
     ASSERTL1(physCoords.num_elements() >= m_dim,
              "physCoords is smaller than number of dimesnions");
 
     int nPhysPts = physCoords[0].num_elements();
     int lastProg = 0;
 
     m_weights = Array<OneD, Array<OneD, float> >(nPhysPts);
     m_neighInds = Array<OneD, Array<OneD, unsigned int> >(nPhysPts);
 
     // interpolate points and transform
     for (int i = 0; i < nPhysPts; ++i)
     {
         Array<OneD, NekDouble> physPt(m_dim);
         for (int j = 0; j < m_dim; ++j)
         {
             physPt[j] = physCoords[j][i];
         }
 
         if (m_dim == 1 || coordId >= 0)
         {
             if (m_dim == 1)
             {
                 coordId = 0;
             }
 
             if (m_pts[0].num_elements() <= 2)
             {
                 CalcW_Linear(i, physPt[coordId]);
             }
             else
             {
                 CalcW_Quadratic(i, physPt[coordId]);
             }
         }
         else
         {
             CalcW_Shepard(i, physPt);
         }
 
         int progress = int(100 * i / nPhysPts);
         if (m_progressCallback && progress > lastProg)
         {
             m_progressCallback(i, nPhysPts);
             lastProg = progress;
         }
     }
 }

NekDouble Nektar::LibUtilities::PtsField::DistSq	(	const Array< OneD, NekDouble > &	point1,
		const Array< OneD, NekDouble > &	point2
	)		const

private

Compute the square of the euclidean distance between point1 and point2.

Parameters

point1	The first point
point2	The second point

Definition at line 546 of file PtsField.cpp.

Referenced by FindNeighbours().

 {
     NekDouble d = 0.0;
     NekDouble tmp;
     for (int i = 0; i < point1.num_elements(); i++)
     {
         tmp = point1[i] - point2[i];
         d += tmp * tmp;
     }
 
     return d;
 }

void Nektar::LibUtilities::PtsField::FindNeighbours	(	const Array< OneD, NekDouble > &	physPt,
		vector< PtsPoint > &	neighbourPts,
		const unsigned int	numPts = `1`
	)

private

Find nearest neighbours using a brute-force "algorithm".

Parameters

physPt	Coordinates of the physical point its neighbours we are looking for
neighbourPts	The points we found
numPts	The number of points to find

This iterates over all points, computes the (squared) euclidean distance and chooses the numPts closest points. Thus, its very expensive and inefficient.

Definition at line 573 of file PtsField.cpp.

References DistSq(), m_dim, m_pts, and npts.

Referenced by CalcW_Shepard().

 {
     int npts = m_pts[0].num_elements();
 
     // generate an initial set of intPts
     for (int i = 0; i < numPts; ++i)
     {
         PtsPoint intPt = PtsPoint(-1, Array<OneD, NekDouble>(m_dim), 1E30);
         neighbourPts.push_back(intPt);
     }
 
     // generate and iterate over all intPts
     for (int i = 0; i < npts; ++i)
     {
         Array<OneD, NekDouble> coords(m_dim);
         for (int j = 0; j < m_dim; ++j)
         {
             coords[j] = m_pts[j][i];
         }
         NekDouble d = DistSq(physPt, coords);
 
         if (d < neighbourPts.back().m_distSq)
         {
             // create new point struct
             PtsPoint intPt = PtsPoint(i, coords, d);
 
             // add it to list, sort the list and remove last point from the sorted
             // list
             neighbourPts.push_back(intPt);
             sort(neighbourPts.begin(), neighbourPts.end());
             neighbourPts.pop_back();
         }
     }
 }

void Nektar::LibUtilities::PtsField::GetConnectivity ( vector< Array< OneD, int > > & conn ) const

Set the connectivity data for ePtsTetBlock and ePtsTriBlock.

Parameters

conn	Connectivity data Connectivity data needed for ePtsTetBlock and ePtsTriBlock. For n Blocks with m elements each, m_ptsConn is a vector of n arrays with 3m (ePtsTriBlock) or 4m (ePtsTetBlock) entries.

Definition at line 206 of file PtsField.cpp.

References m_ptsConn.

 {
     conn = m_ptsConn;
 }

int Nektar::LibUtilities::PtsField::GetDim ( ) const

Definition at line 234 of file PtsField.cpp.

References m_dim.

 {
     return m_dim;
 }

std::string Nektar::LibUtilities::PtsField::GetFieldName ( const int i ) const

Definition at line 252 of file PtsField.cpp.

References m_fieldNames.

 {
     return m_fieldNames[i];
 }

vector< std::string > Nektar::LibUtilities::PtsField::GetFieldNames ( ) const

Definition at line 246 of file PtsField.cpp.

References m_fieldNames.

 {
     return m_fieldNames;
 }

int Nektar::LibUtilities::PtsField::GetNFields ( ) const

Definition at line 240 of file PtsField.cpp.

References m_fieldNames.

 {
     return m_fieldNames.size();
 }

int Nektar::LibUtilities::PtsField::GetNpoints ( ) const

Definition at line 289 of file PtsField.cpp.

References m_pts.

 {
     return m_pts[0].num_elements();
 }

vector< int > Nektar::LibUtilities::PtsField::GetPointsPerEdge ( ) const

Definition at line 322 of file PtsField.cpp.

References m_nPtsPerEdge.

 {
     return m_nPtsPerEdge;
 }

int Nektar::LibUtilities::PtsField::GetPointsPerEdge ( const int i ) const

Definition at line 328 of file PtsField.cpp.

References m_nPtsPerEdge.

 {
     return m_nPtsPerEdge[i];
 }

NekDouble Nektar::LibUtilities::PtsField::GetPointVal	(	const int	fieldInd,
		const int	ptInd
	)		const

Definition at line 295 of file PtsField.cpp.

References m_pts.

 {
     return m_pts[fieldInd][ptInd];
 }

void Nektar::LibUtilities::PtsField::GetPts ( Array< OneD, Array< OneD, NekDouble > > & pts ) const

Definition at line 301 of file PtsField.cpp.

References m_pts.

 {
     pts = m_pts;
 }

Array< OneD, NekDouble > Nektar::LibUtilities::PtsField::GetPts ( const int fieldInd ) const

Definition at line 307 of file PtsField.cpp.

References m_pts.

 {
     return m_pts[fieldInd];
 }

PtsType Nektar::LibUtilities::PtsField::GetPtsType ( ) const

Definition at line 358 of file PtsField.cpp.

References m_ptsType.

 {
     return m_ptsType;
 }

void Nektar::LibUtilities::PtsField::GetWeights	(	Array< OneD, Array< OneD, float > > &	weights,
		Array< OneD, Array< OneD, unsigned int > > &	neighbourInds
	)		const

Get the interpolation weights and corresponding neighbour indices.

Parameters

weights	Interpolation weights for each neighbour. Structure: m_weights[physPtIdx][neighbourIdx]
neighbourInds	Indices of the relevant neighbours for each physical point. Structure: m_neighInds[ptIdx][neighbourIdx]

Definition at line 190 of file PtsField.cpp.

References m_neighInds, and m_weights.

 {
     weights = m_weights;
     neighbourInds = m_neighInds;
 }

void Nektar::LibUtilities::PtsField::Interpolate	(	const Array< OneD, Array< OneD, NekDouble > > &	physCoords,
		Array< OneD, Array< OneD, NekDouble > > &	intFields,
		short int	coordId = `-1`
	)

Compute weights and perform the interpolate of field values to physical points.

Parameters

physCoords	coordinates of the physical points
intFields	interpolated field at the physical points
coord_id	id of the coordinate to use for interpolation.

Set coord_id to -1 to use n-D interpolation for an n-dimensional field. The most suitable algorithm is chosen automatically.

Definition at line 116 of file PtsField.cpp.

References CalcWeights().

 {
     CalcWeights(physCoords,  coordId);
     Interpolate(intFields);
 }

void Nektar::LibUtilities::PtsField::Interpolate ( Array< OneD, Array< OneD, NekDouble > > & intFields )

Perform the interpolate of field values to physical points.

Parameters

intFields interpolated field at the physical points

The weights must have already been computed by or set by .

Definition at line 134 of file PtsField.cpp.

References ASSERTL1, m_dim, m_fieldNames, m_neighInds, m_pts, and m_weights.

 {
     ASSERTL1(m_weights[0].num_elements() == m_neighInds[0].num_elements(),
              "weights / neighInds mismatch")
     int nFields = m_fieldNames.size();
     int nPhysPts = m_weights.num_elements();
 
     // interpolate points and transform
     intFields = Array<OneD, Array<OneD, NekDouble> >(nFields);
     for (int i = 0; i < nFields; ++i)
     {
         intFields[i] = Array<OneD, NekDouble>(nPhysPts);
 
         for (int j = 0; j < nPhysPts; ++j)
         {
             intFields[i][j] = 0.0;
 
             int nPts = m_weights[j].num_elements();
             for (int k = 0; k < nPts; ++k)
             {
                 unsigned int nIdx = m_neighInds[j][k];
                 intFields[i][j] += m_weights[j][k] * m_pts[m_dim + i][nIdx];
             }
         }
     }
 }

void Nektar::LibUtilities::PtsField::SetConnectivity ( const vector< Array< OneD, int > > & conn )

Get the connectivity data for ePtsTetBlock and ePtsTriBlock.

Parameters

conn	Connectivity data Connectivity data needed for ePtsTetBlock and ePtsTriBlock. For n Blocks with m elements each, m_ptsConn is a vector of n arrays with 3m (ePtsTriBlock) or 4m (ePtsTetBlock) entries.

Definition at line 219 of file PtsField.cpp.

References ASSERTL1, Nektar::LibUtilities::ePtsTetBlock, Nektar::LibUtilities::ePtsTriBlock, m_ptsConn, and m_ptsType.

 {
     ASSERTL1((m_ptsType == ePtsTetBlock || m_ptsType == ePtsTriBlock),
              "ptsType must be set before connectivity");
 
     m_ptsConn = conn;
 }

void Nektar::LibUtilities::PtsField::SetDim ( const int ptsDim )

Definition at line 228 of file PtsField.cpp.

References m_dim.

 {
     m_dim = ptsDim;
 }

void Nektar::LibUtilities::PtsField::SetFieldNames ( const vector< std::string > fieldNames )

Definition at line 258 of file PtsField.cpp.

References ASSERTL0, m_dim, m_fieldNames, and m_pts.

 {
     ASSERTL0(fieldNames.size() == m_pts.num_elements() - m_dim,
              "Number of given fieldNames does not match the number of stored fields");
 
     m_fieldNames = fieldNames;
 }

void Nektar::LibUtilities::PtsField::SetPointsPerEdge ( const vector< int > nPtsPerEdge )

Set the number of points per edge.

Parameters

nPtsPerEdge Number of points per edge. Empty if the point data has no specific shape (ePtsLine) or is a block (ePtsTetBlock, ePtsTriBlock), size=1 for ePtsLine and 2 for a ePtsPlane

Definition at line 340 of file PtsField.cpp.

References ASSERTL0, Nektar::LibUtilities::ePtsLine, Nektar::LibUtilities::ePtsPlane, m_nPtsPerEdge, m_pts, and m_ptsType.

 {
     ASSERTL0(m_ptsType == ePtsLine || m_ptsType == ePtsPlane,
              "SetPointsPerEdge only supported for ePtsLine and ePtsPlane .");
 
     int totPts(1);
     for (int i = 0; i < nPtsPerEdge.size(); ++i)
     {
         totPts = totPts * nPtsPerEdge.at(i);
     }
 
     ASSERTL0(totPts == m_pts.num_elements(),
              "nPtsPerEdge does not match total number of points");
 
     m_nPtsPerEdge = nPtsPerEdge;
 }

template<typename FuncPointerT , typename ObjectPointerT >

void Nektar::LibUtilities::PtsField::setProgressCallback	(	FuncPointerT	func,
		ObjectPointerT	obj
	)

inline

Definition at line 192 of file PtsField.h.

         {
             m_progressCallback = boost::bind(func, obj, _1, _2);
         }

void Nektar::LibUtilities::PtsField::SetPts ( Array< OneD, Array< OneD, NekDouble > > & pts )

Definition at line 313 of file PtsField.cpp.

References ASSERTL1, and m_pts.

 {
     ASSERTL1(pts.num_elements() ==  m_pts.num_elements(),
              "Pts field count mismatch");
 
     m_pts = pts;
 }

void Nektar::LibUtilities::PtsField::SetPtsType ( const PtsType type )

Definition at line 364 of file PtsField.cpp.

References m_ptsType.

 {
     m_ptsType = type;
 }

void Nektar::LibUtilities::PtsField::SetWeights	(	const Array< OneD, Array< OneD, float > > &	weights,
		const Array< OneD, Array< OneD, unsigned int > > &	neighbourInds
	)

Set the interpolation weights for an interpolation.

Parameters

weights	Interpolation weights for each neighbour. Structure: m_weights[physPtIdx][neighbourIdx]
neighbourInds	Indices of the relevant neighbours for each physical point. Structure: m_neighInds[ptIdx][neighbourIdx]

Definition at line 170 of file PtsField.cpp.

References ASSERTL0, m_neighInds, and m_weights.

 {
     ASSERTL0(weights.num_elements() ==  neighbourInds.num_elements(),
              "weights and neighbourInds not of same number of physical points")
 
     m_weights = weights;
     m_neighInds = neighbourInds;
 
 }

Member Data Documentation

int Nektar::LibUtilities::PtsField::m_dim

private

Dimension of the pts field.

Definition at line 201 of file PtsField.h.

Referenced by CalcW_Shepard(), CalcWeights(), FindNeighbours(), GetDim(), Interpolate(), SetDim(), and SetFieldNames().

vector<std::string> Nektar::LibUtilities::PtsField::m_fieldNames

private

Names of the field variables.

Definition at line 203 of file PtsField.h.

Referenced by AddField(), GetFieldName(), GetFieldNames(), GetNFields(), Interpolate(), and SetFieldNames().

Array<OneD, Array<OneD, unsigned int> > Nektar::LibUtilities::PtsField::m_neighInds

private

Indices of the relevant neighbours for each physical point. Structure: m_neighInds[ptIdx][neighbourIdx].

Definition at line 222 of file PtsField.h.

Referenced by CalcW_Linear(), CalcW_Quadratic(), CalcW_Shepard(), CalcWeights(), GetWeights(), Interpolate(), and SetWeights().

vector<int> Nektar::LibUtilities::PtsField::m_nPtsPerEdge

private

Number of points per edge. Empty if the point data has no specific shape (ePtsLine) or is a block (ePtsTetBlock, ePtsTriBlock), size=1 for ePtsLine and 2 for a ePtsPlane.

Definition at line 210 of file PtsField.h.

Referenced by GetPointsPerEdge(), and SetPointsPerEdge().

boost::function<void (const int position, const int goal)> Nektar::LibUtilities::PtsField::m_progressCallback

private

Definition at line 224 of file PtsField.h.

Referenced by CalcWeights().

Array<OneD, Array<OneD, NekDouble> > Nektar::LibUtilities::PtsField::m_pts

private

Point data. For a n-dimensional field, the first n fields are the points spatial coordinates. Structure: m_pts[fieldIdx][ptIdx].

Definition at line 206 of file PtsField.h.

Referenced by AddField(), CalcW_Linear(), CalcW_Quadratic(), CalcW_Shepard(), CalcWeights(), FindNeighbours(), GetNpoints(), GetPointVal(), GetPts(), Interpolate(), SetFieldNames(), SetPointsPerEdge(), and SetPts().

vector<Array<OneD, int> > Nektar::LibUtilities::PtsField::m_ptsConn

private

Connectivity data needed for ePtsTetBlock and ePtsTriBlock. For n Blocks with m elements each, m_ptsConn is a vector of n arrays with 3*m (ePtsTriBlock) or 4*m (ePtsTetBlock) entries.

Definition at line 214 of file PtsField.h.

Referenced by GetConnectivity(), and SetConnectivity().

PtsType Nektar::LibUtilities::PtsField::m_ptsType

private

Type of the PtsField.

Definition at line 216 of file PtsField.h.

Referenced by GetPtsType(), SetConnectivity(), SetPointsPerEdge(), and SetPtsType().