Classes
struct	ConfigOption
	Represents a command-line configuration option. More...

struct	Field

class	FieldConvertComm

class	InputDat
	Input module for Xml files. More...

class	InputFld

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

class	InputNek5000

class	InputPts

class	InputSemtex

class	InputXml

class	Interpolator
	A class that contains algorithms for interpolation between pts fields, expansions and different meshes. More...

class	Iso

class	IsoVertex

class	Module

class	OutputFileBase
	Converter from fld to vtk. More...

class	OutputFld
	Output to fld format. More...

class	OutputInfo

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

class	OutputPts
	Converter from fld to pts. More...

class	OutputStdOut

class	OutputTecplot
	Tecplot output class. More...

class	OutputTecplotBinary
	Tecplot output class, specifically for binary field output. More...

class	OutputVtk
	Converter from fld to vtk. More...

class	OutputXml
	Converter from fld to vtk. More...

class	ProcessAddCompositeID
	This processing module adds a fld with the composite ID. More...

class	ProcessAddFld
	This processing module scales the input fld file. More...

class	ProcessBoundaryExtract
	This processing module sets up for the boundary field to be extracted. More...

class	ProcessC0Projection
	This processing module calculates the Q Criterion and adds it as an extra-field to the output file. More...

class	ProcessCombineAvg
	This processing module combines two fld files containing average fields. More...

class	ProcessConcatenateFld
	This processing module sets up for the boundary field to be extracted. More...

class	ProcessCreateExp
	This processing module scales the input fld file. More...

class	ProcessDeform

class	ProcessDisplacement

class	ProcessDOF
	This processing module calculates the number of DOF. More...

class	ProcessEquiSpacedOutput
	This processing module interpolates one field to another. More...

class	ProcessFieldFromString
	This processing module adds a new field from a string definition. More...

class	ProcessGrad
	This processing module calculates the vorticity and adds it as an extra-field to the output file. More...

class	ProcessHalfModeToFourier
	This processing modifies Fourier Half Mode to a Fourier expansion. More...

class	ProcessHomogeneousPlane
	This processing module replaces all expansions by a single plane from 3DH1D fields, defined by the parameter planeid. More...

class	ProcessHomogeneousStretch
	This processing module stretches the homogeneous direction of a 3DH1D expansion by an integer factor. More...

class	ProcessInnerProduct
	This processing module computes the inner product between two fields. More...

class	ProcessInterpField
	This processing module interpolates one field to another. More...

class	ProcessInterpPointDataToFld
	This processing module interpolates one field to another. More...

class	ProcessInterpPoints
	This processing module interpolates one field to another. More...

class	ProcessInterpPtsToPts
	This processing module interpolates one field to another. More...

class	ProcessIsoContour
	This processing module extracts an isocontour. More...

class	ProcessJacobianEnergy
	This processing module scales the input fld file. More...

class	ProcessL2Criterion
	This processing module calculates the Lambda 2 Criterion and adds it as an extra-field to the output file. More...

class	ProcessMapping
	This processing module scales the input fld file. More...

class	ProcessMean
	This processing module computes the mean of each field. More...

class	ProcessMeanMode
	This processing module replaces all expansions by the mean mode from 3DH1D fields. More...

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

class	ProcessMultiShear
	This processing module calculates the shear stress metrics and writes it to a surface output file. More...

class	ProcessNumModes
	This processing module calculates the vorticity and adds it as an extra-field to the output file. More...

class	ProcessPointDataToFld
	This processing module interpolates one field to another. More...

class	ProcessPrintFldNorms
	This processing module prints the L2 and LInf norms of the variables in the field. More...

class	ProcessQCriterion
	This processing module calculates the Q Criterion and adds it as an extra-field to the output file. More...

class	ProcessQualityMetric
	This processing module scales the input fld file. More...

class	ProcessRemoveField
	This processing module adds a new field from a string definition. More...

class	ProcessScaleInFld
	This processing module scales the input fld file. More...

class	ProcessScalGrad
	This processing module calculates the scalar gradient field and writes it to a surface output file. More...

class	ProcessStreamFunction
	This processing module calculates the stream function of a 2D field and adds it as an extra-field to the output file. More...

class	ProcessSurfDistance
	This processing module calculates the height of an element connected to a surface and adds it as an extra-field to the output file. More...

class	ProcessVorticity
	This processing module calculates the vorticity and adds it as an extra-field to the output file. More...

class	ProcessWSS
	This processing module calculates the wall shear stress and adds it as an extra-field to the output file, and writes it to a surface output file. More...

struct	TriFaceHash

struct	TriFaceIDs

Typedefs
typedef std::shared_ptr< Field >	FieldSharedPtr

typedef std::shared_ptr< Interpolator >	InterpolatorSharedPtr

typedef std::shared_ptr< InputModule >	InputModuleSharedPtr

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

typedef std::shared_ptr< Module >	ModuleSharedPtr

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

typedef std::unordered_map< TriFaceIDs, int, TriFaceHash >	TriFaceMap

typedef std::shared_ptr< Iso >	IsoSharedPtr

Enumerations
enum	ModuleType { eInputModule, eProcessModule, eOutputModule, SIZE_ModuleType }

enum	ModulePriority { eCreateGraph, eCreateFieldData, eModifyFieldData, eCreateExp, eFillExp, eModifyExp, eBndExtraction, eCreatePts, eConvertExpToPts, eModifyPts, eOutput, SIZE_ModulePriority }

enum	TecplotZoneType { eOrdered = 0, eFELineSeg, eFETriangle, eFEQuadrilateral, eFETetrahedron, eFEBrick, eFEPolygon, eFEPolyhedron }

Functions
ModuleFactory &	GetModuleFactory ()

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

template<typename T >
void	swap_endian (T &u)
	Swap endian ordering of the input variable. More...

template<typename T >
void	swap_endian (std::vector< T > &u)

template<typename T >
void	WriteStream (std::ostream &outfile, T data)
	Helper function to write binary data to stream. More...

template<>
void	WriteStream (std::ostream &outfile, std::string data)
	Specialisation of WriteStream to support writing std::string. More...

template<typename T >
void	WriteStream (std::ostream &outfile, Array< OneD, T > data)
	Specialisation of WriteStream to support writing Nektar::Array datatype. More...

template<typename T >
void	WriteStream (std::ostream &outfile, std::vector< T > data)
	Specialisation of WriteStream to support writing std::vector datatype. More...

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

void	TwoPairs (Array< OneD, NekDouble > &cx, Array< OneD, NekDouble > &cy, Array< OneD, NekDouble > &cz, int &pr)

void	ThreeSimilar (const int i, const int j, const int k, int &pr, int &ps)

bool	operator== (const IsoVertex &x, const IsoVertex &y)

bool	operator!= (const IsoVertex &x, const IsoVertex &y)

void	MatSymEVals (NekDouble d1, NekDouble d2, NekDouble d3, NekDouble a, NekDouble b, NekDouble c, NekDouble &l1, NekDouble &l2, NekDouble &l3)
	Calculates eigenvalues of a 3x3 Symmetric matrix. More...

vector< DNekMat >	MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom, StdRegions::StdExpansionSharedPtr chi)

Variables
const char *const	ModuleTypeMap [] = {"Input", "Process", "Output"}

std::string	TecplotZoneTypeMap []

Typedef Documentation

◆ FieldSharedPtr

typedef std::shared_ptr<Field> Nektar::FieldUtils::FieldSharedPtr

Definition at line 762 of file Field.hpp.

◆ InputModuleSharedPtr

typedef std::shared_ptr<InputModule> Nektar::FieldUtils::InputModuleSharedPtr

Definition at line 239 of file FieldUtils/Module.h.

◆ InterpolatorSharedPtr

typedef std::shared_ptr<Interpolator> Nektar::FieldUtils::InterpolatorSharedPtr

Definition at line 108 of file FieldUtils/Interpolator.h.

◆ IsoSharedPtr

typedef std::shared_ptr<Iso> Nektar::FieldUtils::IsoSharedPtr

Definition at line 186 of file ProcessIsoContour.h.

◆ ModuleFactory

typedef LibUtilities::NekFactory<ModuleKey, Module, FieldSharedPtr> Nektar::FieldUtils::ModuleFactory

Definition at line 277 of file FieldUtils/Module.h.

◆ ModuleKey

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

Definition at line 271 of file FieldUtils/Module.h.

◆ ModuleSharedPtr

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

Definition at line 275 of file FieldUtils/Module.h.

◆ TriFaceMap

typedef std::unordered_map<TriFaceIDs, int, TriFaceHash> Nektar::FieldUtils::TriFaceMap

Definition at line 95 of file ProcessDisplacement.cpp.

Enumeration Type Documentation

◆ ModulePriority

enum Nektar::FieldUtils::ModulePriority

Enumerator
eCreateGraph
eCreateFieldData
eModifyFieldData
eCreateExp
eFillExp
eModifyExp
eBndExtraction
eCreatePts
eConvertExpToPts
eModifyPts
eOutput
SIZE_ModulePriority

Definition at line 74 of file FieldUtils/Module.h.

 {
     eCreateGraph,
     eCreateFieldData,
     eModifyFieldData,
     eCreateExp,
     eFillExp,
     eModifyExp,
     eBndExtraction,
     eCreatePts,
     eConvertExpToPts,
     eModifyPts,
     eOutput,
     SIZE_ModulePriority
 };

◆ ModuleType

enum Nektar::FieldUtils::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 FieldUtils/Module.h.

 {
     eInputModule,
     eProcessModule,
     eOutputModule,
     SIZE_ModuleType
 };

◆ TecplotZoneType

enum Nektar::FieldUtils::TecplotZoneType

Enumerator
eOrdered
eFELineSeg
eFETriangle
eFEQuadrilateral
eFETetrahedron
eFEBrick
eFEPolygon
eFEPolyhedron

Definition at line 46 of file OutputTecplot.h.

                     {
     eOrdered = 0,
     eFELineSeg,
     eFETriangle,
     eFEQuadrilateral,
     eFETetrahedron,
     eFEBrick,
     eFEPolygon,
     eFEPolyhedron
 };

Function Documentation

◆ GetModuleFactory()

FIELD_UTILS_EXPORT ModuleFactory & Nektar::FieldUtils::GetModuleFactory ( )

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

Definition at line 48 of file FieldUtils/Module.cpp.

Referenced by Nektar::SolverUtils::FilterFieldConvert::CreateModules(), main(), Nektar::Utilities::InputMCF::Process(), Nektar::Utilities::ProcessOptiExtract::Process(), Nektar::Utilities::ProcessLinear::Process(), Nektar::Utilities::ProcessInsertSurface::Process(), Nektar::Utilities::ProcessProjectCAD::Process(), and Nektar::NekMeshUtils::Octree::WriteOctree().

 {
     static ModuleFactory instance;
     return instance;
 }

◆ MappingIdealToRef()

vector<DNekMat> Nektar::FieldUtils::MappingIdealToRef	(	SpatialDomains::GeometrySharedPtr	geom,
		StdRegions::StdExpansionSharedPtr	chi
	)

inline

Definition at line 118 of file ProcessQualityMetric.cpp.

References ASSERTL0, Nektar::eFULL, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, CG_Iterations::loc, and CellMLToNektar.cellml_metadata::p.

Referenced by Nektar::Utilities::ElUtil::ElUtil(), and Nektar::FieldUtils::ProcessQualityMetric::GetQ().

 {
     vector<DNekMat> ret;
 
     if (geom->GetShapeType() == LibUtilities::eQuadrilateral)
     {
         vector<Array<OneD, NekDouble> > xy;
         for (int i = 0; i < geom->GetNumVerts(); i++)
         {
             Array<OneD, NekDouble> loc(2);
             SpatialDomains::PointGeomSharedPtr p = geom->GetVertex(i);
             p->GetCoords(loc);
             xy.push_back(loc);
         }
 
         Array<OneD, const LibUtilities::BasisSharedPtr> b = chi->GetBase();
         Array<OneD, NekDouble> u                          = b[0]->GetZ();
         Array<OneD, NekDouble> v                          = b[1]->GetZ();
 
         for (int j = 0; j < b[1]->GetNumPoints(); j++)
         {
             for (int i = 0; i < b[0]->GetNumPoints(); i++)
             {
                 NekDouble a1 = 0.5 * (1.0 - u[i]), a2 = 0.5 * (1.0 + u[i]);
                 NekDouble b1 = 0.5 * (1.0 - v[j]), b2 = 0.5 * (1.0 + v[j]);
                 DNekMat dxdz(2, 2, 1.0, eFULL);
 
                 dxdz(0, 0) = 0.5 * (-b1 * xy[0][0] + b1 * xy[1][0] +
                                     b2 * xy[2][0] - b2 * xy[3][0]);
                 dxdz(1, 0) = 0.5 * (-b1 * xy[0][1] + b1 * xy[1][1] +
                                     b2 * xy[2][1] - b2 * xy[3][1]);
 
                 dxdz(0, 1) = 0.5 * (-a1 * xy[0][0] - a2 * xy[1][0] +
                                     a2 * xy[2][0] + a1 * xy[3][0]);
                 dxdz(1, 1) = 0.5 * (-a1 * xy[0][1] - a2 * xy[1][1] +
                                     a2 * xy[2][1] + a1 * xy[3][1]);
 
                 dxdz.Invert();
                 ret.push_back(dxdz);
             }
         }
     }
     else if (geom->GetShapeType() == LibUtilities::eTriangle)
     {
         vector<Array<OneD, NekDouble> > xy;
         for (int i = 0; i < geom->GetNumVerts(); i++)
         {
             Array<OneD, NekDouble> loc(2);
             SpatialDomains::PointGeomSharedPtr p = geom->GetVertex(i);
             p->GetCoords(loc);
             xy.push_back(loc);
         }
 
         Array<OneD, const LibUtilities::BasisSharedPtr> b = chi->GetBase();
         Array<OneD, NekDouble> u                          = b[0]->GetZ();
         Array<OneD, NekDouble> v                          = b[1]->GetZ();
 
         for (int i = 0; i < b[0]->GetNumPoints(); i++)
         {
             for (int j = 0; j < b[1]->GetNumPoints(); j++)
             {
                 DNekMat dxdz(2, 2, 1.0, eFULL);
                 dxdz(0, 0) = -xy[0][0] / 2.0 + xy[1][0] / 2.0;
 
                 dxdz(0, 1) = -xy[0][0] / 2.0 + xy[2][0] / 2.0;
 
                 dxdz(1, 0) = -xy[0][1] / 2.0 + xy[1][1] / 2.0;
 
                 dxdz(1, 1) = -xy[0][1] / 2.0 + xy[2][1] / 2.0;
 
                 dxdz.Invert();
                 ret.push_back(dxdz);
             }
         }
     }
     else if (geom->GetShapeType() == LibUtilities::eTetrahedron)
     {
         vector<Array<OneD, NekDouble> > xyz;
         for (int i = 0; i < geom->GetNumVerts(); i++)
         {
             Array<OneD, NekDouble> loc(3);
             SpatialDomains::PointGeomSharedPtr p = geom->GetVertex(i);
             p->GetCoords(loc);
             xyz.push_back(loc);
         }
 
         Array<OneD, const LibUtilities::BasisSharedPtr> b = chi->GetBase();
         Array<OneD, NekDouble> u                          = b[0]->GetZ();
         Array<OneD, NekDouble> v                          = b[1]->GetZ();
         Array<OneD, NekDouble> z                          = b[2]->GetZ();
 
         for (int i = 0; i < b[0]->GetNumPoints(); i++)
         {
             for (int j = 0; j < b[1]->GetNumPoints(); j++)
             {
                 for (int k = 0; k < b[2]->GetNumPoints(); k++)
                 {
                     DNekMat dxdz(3, 3, 1.0, eFULL);
                     dxdz(0, 0) = -xyz[0][0] / 2.0 + xyz[1][0] / 2.0;
 
                     dxdz(0, 1) = -xyz[0][0] / 2.0 + xyz[2][0] / 2.0;
 
                     dxdz(0, 2) = -xyz[0][0] / 2.0 + xyz[3][0] / 2.0;
 
                     dxdz(1, 0) = -xyz[0][1] / 2.0 + xyz[1][1] / 2.0;
 
                     dxdz(1, 1) = -xyz[0][1] / 2.0 + xyz[2][1] / 2.0;
 
                     dxdz(1, 2) = -xyz[0][1] / 2.0 + xyz[3][1] / 2.0;
 
                     dxdz(2, 0) = -xyz[0][2] / 2.0 + xyz[1][2] / 2.0;
 
                     dxdz(2, 1) = -xyz[0][2] / 2.0 + xyz[2][2] / 2.0;
 
                     dxdz(2, 2) = -xyz[0][2] / 2.0 + xyz[3][2] / 2.0;
 
                     dxdz.Invert();
                     ret.push_back(dxdz);
                 }
             }
         }
     }
     else if (geom->GetShapeType() == LibUtilities::ePrism)
     {
         vector<Array<OneD, NekDouble> > xyz;
         for (int i = 0; i < geom->GetNumVerts(); i++)
         {
             Array<OneD, NekDouble> loc(3);
             SpatialDomains::PointGeomSharedPtr p = geom->GetVertex(i);
             p->GetCoords(loc);
             xyz.push_back(loc);
         }
 
         Array<OneD, const LibUtilities::BasisSharedPtr> b = chi->GetBase();
         Array<OneD, NekDouble> eta1                       = b[0]->GetZ();
         Array<OneD, NekDouble> eta2                       = b[1]->GetZ();
         Array<OneD, NekDouble> eta3                       = b[2]->GetZ();
 
         for (int k = 0; k < b[2]->GetNumPoints(); k++)
         {
             for (int j = 0; j < b[1]->GetNumPoints(); j++)
             {
                 for (int i = 0; i < b[0]->GetNumPoints(); i++)
                 {
                     NekDouble xi1 = 0.5 * (1 + eta1[i]) * (1 - eta3[k]) - 1.0;
                     NekDouble a2  = 0.5 * (1 + xi1);
                     NekDouble b1  = 0.5 * (1 - eta2[j]),
                               b2  = 0.5 * (1 + eta2[j]);
                     NekDouble c1  = 0.5 * (1 - eta3[k]),
                               c2  = 0.5 * (1 + eta3[k]);
 
                     DNekMat dxdz(3, 3, 1.0, eFULL);
 
                     dxdz(0, 0) = 0.5 * (-b1 * xyz[0][0] + b1 * xyz[1][0] +
                                         b2 * xyz[2][0] - b2 * xyz[3][0]);
                     dxdz(1, 0) = 0.5 * (-b1 * xyz[0][1] + b1 * xyz[1][1] +
                                         b2 * xyz[2][1] - b2 * xyz[3][1]);
                     dxdz(2, 0) = 0.5 * (-b1 * xyz[0][2] + b1 * xyz[1][2] +
                                         b2 * xyz[2][2] - b2 * xyz[3][2]);
 
                     dxdz(0, 1) = 0.5 * ((a2 - c1) * xyz[0][0] - a2 * xyz[1][0] +
                                         a2 * xyz[2][0] + (c1 - a2) * xyz[3][0] -
                                         c2 * xyz[4][0] + c2 * xyz[5][0]);
                     dxdz(1, 1) = 0.5 * ((a2 - c1) * xyz[0][1] - a2 * xyz[1][1] +
                                         a2 * xyz[2][1] + (c1 - a2) * xyz[3][1] -
                                         c2 * xyz[4][1] + c2 * xyz[5][1]);
                     dxdz(2, 1) = 0.5 * ((a2 - c1) * xyz[0][2] - a2 * xyz[1][2] +
                                         a2 * xyz[2][2] + (c1 - a2) * xyz[3][2] -
                                         c2 * xyz[4][2] + c2 * xyz[5][2]);
 
                     dxdz(0, 2) = 0.5 * (-b1 * xyz[0][0] - b2 * xyz[3][0] +
                                         b1 * xyz[4][0] + b2 * xyz[5][0]);
                     dxdz(1, 2) = 0.5 * (-b1 * xyz[0][1] - b2 * xyz[3][1] +
                                         b1 * xyz[4][1] + b2 * xyz[5][1]);
                     dxdz(2, 2) = 0.5 * (-b1 * xyz[0][2] - b2 * xyz[3][2] +
                                         b1 * xyz[4][2] + b2 * xyz[5][2]);
 
                     dxdz.Invert();
                     ret.push_back(dxdz);
                 }
             }
         }
     }
     else if (geom->GetShapeType() == LibUtilities::eHexahedron)
     {
         vector<Array<OneD, NekDouble> > xyz;
         for (int i = 0; i < geom->GetNumVerts(); i++)
         {
             Array<OneD, NekDouble> loc(3);
             SpatialDomains::PointGeomSharedPtr p = geom->GetVertex(i);
             p->GetCoords(loc);
             xyz.push_back(loc);
         }
 
         Array<OneD, const LibUtilities::BasisSharedPtr> b = chi->GetBase();
         Array<OneD, NekDouble> eta1                       = b[0]->GetZ();
         Array<OneD, NekDouble> eta2                       = b[1]->GetZ();
         Array<OneD, NekDouble> eta3                       = b[2]->GetZ();
 
         for (int k = 0; k < b[2]->GetNumPoints(); k++)
         {
             for (int j = 0; j < b[1]->GetNumPoints(); j++)
             {
                 for (int i = 0; i < b[0]->GetNumPoints(); i++)
                 {
                     NekDouble a1 = 0.5 * (1 - eta1[i]);
                     NekDouble a2 = 0.5 * (1 + eta1[i]);
                     NekDouble b1 = 0.5 * (1 - eta2[j]),
                               b2 = 0.5 * (1 + eta2[j]);
                     NekDouble c1 = 0.5 * (1 - eta3[k]),
                               c2 = 0.5 * (1 + eta3[k]);
 
                     DNekMat dxdz(3, 3, 1.0, eFULL);
 
                     dxdz(0, 0) =
                         -0.5 * b1 * c1 * xyz[0][0] + 0.5 * b1 * c1 * xyz[1][0] +
                         0.5 * b2 * c1 * xyz[2][0] - 0.5 * b2 * c1 * xyz[3][0] -
                         0.5 * b1 * c2 * xyz[5][0] + 0.5 * b1 * c2 * xyz[5][0] +
                         0.5 * b2 * c2 * xyz[6][0] - 0.5 * b2 * c2 * xyz[7][0];
                     dxdz(1, 0) =
                         -0.5 * b1 * c1 * xyz[0][1] + 0.5 * b1 * c1 * xyz[1][1] +
                         0.5 * b2 * c1 * xyz[2][1] - 0.5 * b2 * c1 * xyz[3][1] -
                         0.5 * b1 * c2 * xyz[5][1] + 0.5 * b1 * c2 * xyz[5][1] +
                         0.5 * b2 * c2 * xyz[6][1] - 0.5 * b2 * c2 * xyz[7][1];
                     dxdz(2, 0) =
                         -0.5 * b1 * c1 * xyz[0][2] + 0.5 * b1 * c1 * xyz[1][2] +
                         0.5 * b2 * c1 * xyz[2][2] - 0.5 * b2 * c1 * xyz[3][2] -
                         0.5 * b1 * c2 * xyz[5][2] + 0.5 * b1 * c2 * xyz[5][2] +
                         0.5 * b2 * c2 * xyz[6][2] - 0.5 * b2 * c2 * xyz[7][2];
 
                     dxdz(0, 1) =
                         -0.5 * a1 * c1 * xyz[0][0] - 0.5 * a2 * c1 * xyz[1][0] +
                         0.5 * a2 * c1 * xyz[2][0] + 0.5 * a1 * c1 * xyz[3][0] -
                         0.5 * a1 * c2 * xyz[5][0] - 0.5 * a2 * c2 * xyz[5][0] +
                         0.5 * a2 * c2 * xyz[6][0] + 0.5 * a1 * c2 * xyz[7][0];
                     dxdz(1, 1) =
                         -0.5 * a1 * c1 * xyz[0][1] - 0.5 * a2 * c1 * xyz[1][1] +
                         0.5 * a2 * c1 * xyz[2][1] + 0.5 * a1 * c1 * xyz[3][1] -
                         0.5 * a1 * c2 * xyz[5][1] - 0.5 * a2 * c2 * xyz[5][1] +
                         0.5 * a2 * c2 * xyz[6][1] + 0.5 * a1 * c2 * xyz[7][1];
                     dxdz(2, 1) =
                         -0.5 * a1 * c1 * xyz[0][2] - 0.5 * a2 * c1 * xyz[1][2] +
                         0.5 * a2 * c1 * xyz[2][2] + 0.5 * a1 * c1 * xyz[3][2] -
                         0.5 * a1 * c2 * xyz[5][2] - 0.5 * a2 * c2 * xyz[5][2] +
                         0.5 * a2 * c2 * xyz[6][2] + 0.5 * a1 * c2 * xyz[7][2];
 
                     dxdz(0, 0) =
                         -0.5 * b1 * a1 * xyz[0][0] - 0.5 * b1 * a2 * xyz[1][0] -
                         0.5 * b2 * a2 * xyz[2][0] - 0.5 * b2 * a1 * xyz[3][0] +
                         0.5 * b1 * a1 * xyz[5][0] + 0.5 * b1 * a2 * xyz[5][0] +
                         0.5 * b2 * a2 * xyz[6][0] + 0.5 * b2 * a1 * xyz[7][0];
                     dxdz(1, 0) =
                         -0.5 * b1 * a1 * xyz[0][1] - 0.5 * b1 * a2 * xyz[1][1] -
                         0.5 * b2 * a2 * xyz[2][1] - 0.5 * b2 * a1 * xyz[3][1] +
                         0.5 * b1 * a1 * xyz[5][1] + 0.5 * b1 * a2 * xyz[5][1] +
                         0.5 * b2 * a2 * xyz[6][1] + 0.5 * b2 * a1 * xyz[7][1];
                     dxdz(2, 0) =
                         -0.5 * b1 * a1 * xyz[0][2] - 0.5 * b1 * a2 * xyz[1][2] -
                         0.5 * b2 * a2 * xyz[2][2] - 0.5 * b2 * a1 * xyz[3][2] +
                         0.5 * b1 * a1 * xyz[5][2] + 0.5 * b1 * a2 * xyz[5][2] +
                         0.5 * b2 * a2 * xyz[6][2] + 0.5 * b2 * a1 * xyz[7][2];
 
                     dxdz.Invert();
                     ret.push_back(dxdz);
                 }
             }
         }
     }
     else
     {
         ASSERTL0(false, "not coded");
     }
 
     return ret;
 }

◆ MatSymEVals()

void Nektar::FieldUtils::MatSymEVals	(	NekDouble	d1,
		NekDouble	d2,
		NekDouble	d3,
		NekDouble	a,
		NekDouble	b,
		NekDouble	c,
		NekDouble &	l1,
		NekDouble &	l2,
		NekDouble &	l3
	)

Calculates eigenvalues of a 3x3 Symmetric matrix.

Parameters

d1,d2,d3	- matrix diagonal entries at [0,0], [1,1] and [2,2]
a	- matrix value at [0,1] and [1,0]
b	- matrix value at [0,2] and [2,0]
c	- matrix value at [1,2] and [2,1]
l1,l2,l3	the computed eigenvalues, ordered l3 >= l2 >= l1

Definition at line 72 of file ProcessL2Criterion.cpp.

References CellMLToNektar.cellml_metadata::p.

Referenced by Nektar::FieldUtils::ProcessL2Criterion::Process().

 {
     NekDouble p = a * a + b * b + c * c;
     if (p == 0)
     {
         l1 = d1;
         l2 = d2;
         l3 = d3;
         if (l1 > l3)
         {
             swap(l1, l3);
         }
         if (l1 > l2)
         {
             swap(l1, l2);
         }
         if (l2 > l3)
         {
             swap(l2, l3);
         }
     }
     else
     {
         NekDouble q = (d1 + d2 + d3) / 3.0;
         p = (d1 - q) * (d1 - q) + (d2 - q) * (d2 - q) + (d3 - q) * (d3 - q) +
             2.0 * p;
         p = sqrt(p / 6.0);
         NekDouble r =
             -0.5 *
             (a * a * d3 - a * a * q - 2.0 * a * b * c + b * b * d2 - b * b * q +
              c * c * d1 - c * c * q - d1 * d2 * d3 + d1 * d2 * q + d1 * d3 * q -
              d1 * q * q + d2 * d3 * q - d2 * q * q - d3 * q * q + q * q * q) /
             (p * p * p);
 
         NekDouble phi = 0;
         if (r <= -1)
         {
             phi = M_PI / 3.0;
         }
         else if (r >= 1)
         {
             phi = 0.0;
         }
         else
         {
             phi = acos(r) / 3.0;
         }
 
         // the eigenvalues satisfy eig3 >= eig2 >= eig1
         l3 = q + 2.0 * p * cos(phi);
         l1 = q + 2.0 * p * cos(phi + (2.0 * M_PI / 3.0));
         // since trace(A) = eig1 + eig2 + eig3
         l2 = 3.0 * q - l1 - l3;
     }
 }

◆ operator!=()

bool Nektar::FieldUtils::operator!=	(	const IsoVertex &	x,
		const IsoVertex &	y
	)

Definition at line 965 of file ProcessIsoContour.cpp.

References Nektar::NekConstants::kNekZeroTol, Nektar::FieldUtils::IsoVertex::m_x, Nektar::FieldUtils::IsoVertex::m_y, and Nektar::FieldUtils::IsoVertex::m_z.

Referenced by Nektar::FieldUtils::IsoVertex::get_iso_vert_id().

 {
     return ((x.m_x-y.m_x)*(x.m_x-y.m_x) + (x.m_y-y.m_y)*(x.m_y-y.m_y) +
             (x.m_z-y.m_z)*(x.m_z-y.m_z) < NekConstants::kNekZeroTol)? 0:1;
 }

◆ operator<<()

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

Prints a given module key to a stream.

Definition at line 57 of file FieldUtils/Module.cpp.

References ModuleTypeMap.

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

◆ operator==() [1/2]

bool Nektar::FieldUtils::operator==	(	TriFaceIDs const &	p1,
		TriFaceIDs const &	p2
	)

Definition at line 78 of file ProcessDisplacement.cpp.

References Nektar::FieldUtils::TriFaceIDs::a, Nektar::FieldUtils::TriFaceIDs::b, and Nektar::FieldUtils::TriFaceIDs::c.

Referenced by Nektar::FieldUtils::IsoVertex::get_iso_vert_id().

 {
     std::vector<int> ids1(3), ids2(3);
 
     ids1[0] = p1.a;
     ids1[1] = p1.b;
     ids1[2] = p1.c;
     ids2[0] = p2.a;
     ids2[1] = p2.b;
     ids2[2] = p2.c;
 
     std::sort(ids1.begin(), ids1.end());
     std::sort(ids2.begin(), ids2.end());
 
     return ids1[0] == ids2[0] && ids1[1] == ids2[1] && ids1[2] == ids2[2];
 }

◆ operator==() [2/2]

bool Nektar::FieldUtils::operator==	(	const IsoVertex &	x,
		const IsoVertex &	y
	)

Definition at line 958 of file ProcessIsoContour.cpp.

References Nektar::NekConstants::kNekZeroTol, Nektar::FieldUtils::IsoVertex::m_x, Nektar::FieldUtils::IsoVertex::m_y, and Nektar::FieldUtils::IsoVertex::m_z.

 {
     return ((x.m_x-y.m_x)*(x.m_x-y.m_x) + (x.m_y-y.m_y)*(x.m_y-y.m_y) +
             (x.m_z-y.m_z)*(x.m_z-y.m_z) < NekConstants::kNekZeroTol)? true:false;
 }

◆ swap_endian() [1/2]

template<typename T >

void Nektar::FieldUtils::swap_endian ( T & u )

Swap endian ordering of the input variable.

Definition at line 94 of file FieldUtils/Module.h.

Referenced by Nektar::FieldUtils::InputNek5000::Process(), Nektar::FieldUtils::InputSemtex::Process(), and swap_endian().

 {
     union
     {
         T u;
         unsigned char u8[sizeof(T)];
     } source, dest;
 
     source.u = u;
 
     for (size_t k = 0; k < sizeof(T); k++)
     {
         dest.u8[k] = source.u8[sizeof(T) - k - 1];
     }
 
     u = dest.u;
 }

◆ swap_endian() [2/2]

template<typename T >

void Nektar::FieldUtils::swap_endian ( std::vector< T > & u )

Definition at line 113 of file FieldUtils/Module.h.

References swap_endian().

 {
     size_t vecSize = u.size();
     for (int i = 0; i < vecSize; ++i)
     {
         swap_endian(u[i]);
     }
 }

◆ ThreeSimilar()

void Nektar::FieldUtils::ThreeSimilar	(	const int	i,
		const int	j,
		const int	k,
		int &	pr,
		int &	ps
	)

Definition at line 314 of file ProcessIsoContour.cpp.

References ASSERTL0.

Referenced by Nektar::FieldUtils::ProcessIsoContour::ExtractContour().

 {
     switch (i + j + k)
     {
         case (3):
             pr = 3;
             ps = 4;
             break;
         case (4):
             pr = 2;
             ps = 4;
             break;
         case (5):
             if (j == 1)
             {
                 pr = 2;
                 ps = 3;
             }
             else
             {
                 pr = 1;
                 ps = 4;
             }
             break;
         case (6):
             if (i == 0)
             {
                 pr = 1;
                 ps = 3;
             }
             else
             {
                 pr = 0;
                 ps = 4;
             }
             break;
         case (7):
             if (i == 0)
             {
                 pr = 1;
                 ps = 2;
             }
             else
             {
                 pr = 0;
                 ps = 3;
             }
             break;
         case (8):
             pr = 0;
             ps = 2;
             break;
         case (9):
             pr = 0;
             ps = 1;
             break;
         default:
             ASSERTL0(false,"Error in 5-point triangulation in ThreeSimilar");
             break;
     }
 }

◆ TwoPairs()

void Nektar::FieldUtils::TwoPairs	(	Array< OneD, NekDouble > &	cx,
		Array< OneD, NekDouble > &	cy,
		Array< OneD, NekDouble > &	cz,
		int &	pr
	)

Definition at line 282 of file ProcessIsoContour.cpp.

Referenced by Nektar::FieldUtils::ProcessIsoContour::ExtractContour().

 {
     if (((cx[0]-cx[1])==0.0)&&
         ((cy[0]-cy[1])==0.0)&&
         ((cz[0]-cz[1])==0.0))
     {
         if (((cx[2]-cx[3])==0.0)&&
             ((cy[2]-cy[3])==0.0)&&
             ((cz[2]-cz[3])==0.0))
         {
             pr=4;
         }
         else
         {
             pr=3;
         }
     }
     else
     {
         pr=1;
     }
 }

◆ WriteStream() [1/4]

template<typename T >

void Nektar::FieldUtils::WriteStream	(	std::ostream &	outfile,
		T	data
	)

Helper function to write binary data to stream.

Definition at line 107 of file OutputTecplot.cpp.

Referenced by Nektar::FieldUtils::OutputTecplotBinary::WriteDoubleOrFloat(), WriteStream(), Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotConnectivity(), Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotHeader(), and Nektar::FieldUtils::OutputTecplotBinary::WriteTecplotZone().

 {
     T tmp = data;
     outfile.write(reinterpret_cast<char *>(&tmp), sizeof(T));
 }

◆ WriteStream() [2/4]

template<>

void Nektar::FieldUtils::WriteStream	(	std::ostream &	outfile,
		std::string	data
	)

Specialisation of WriteStream to support writing std::string.

Tecplot binary formats represent all strings by writing out their characters as 32-bit integers, followed by a 32-bit integer null (0) character to denote the end of the string.

Definition at line 120 of file OutputTecplot.cpp.

References WriteStream().

 {
     // Convert string to array of int32_t
     for (std::string::size_type i = 0; i < data.size(); ++i)
     {
         char strChar = data[i];
         NekInt32 strCharInt = strChar;
         WriteStream(outfile, strCharInt);
     }
 
     // Now dump out zero character to terminate
     WriteStream(outfile, 0);
 }

◆ WriteStream() [3/4]

template<typename T >

void Nektar::FieldUtils::WriteStream	(	std::ostream &	outfile,
		Array< OneD, T >	data
	)

Specialisation of WriteStream to support writing Nektar::Array datatype.

Definition at line 138 of file OutputTecplot.cpp.

 {
     outfile.write(reinterpret_cast<char *>(&data[0]),
                   data.num_elements() * sizeof(T));
 }

◆ WriteStream() [4/4]

template<typename T >

void Nektar::FieldUtils::WriteStream	(	std::ostream &	outfile,
		std::vector< T >	data
	)

Specialisation of WriteStream to support writing std::vector datatype.

Definition at line 148 of file OutputTecplot.cpp.

 {
     outfile.write(reinterpret_cast<char *>(&data[0]),
                   data.size() * sizeof(T));
 }

Variable Documentation

◆ ModuleTypeMap

const char* const Nektar::FieldUtils::ModuleTypeMap[] = {"Input", "Process", "Output"}

Definition at line 72 of file FieldUtils/Module.h.

Referenced by operator<<(), and Nektar::NekMeshUtils::operator<<().

◆ TecplotZoneTypeMap

std::string Nektar::FieldUtils::TecplotZoneTypeMap[]

Initial value:

= {
    "ORDERED",
    "LINESEG",
    "TRIANGLE",
    "QUADRILATERAL",
    "TETRAHEDRON",
    "BRICK",
    "POLYGON",
    "POLYHEDRON"
}

Definition at line 52 of file OutputTecplot.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ FieldSharedPtr

◆ InputModuleSharedPtr

◆ InterpolatorSharedPtr

◆ IsoSharedPtr

◆ ModuleFactory

◆ ModuleKey

◆ ModuleSharedPtr

◆ TriFaceMap

Enumeration Type Documentation

◆ ModulePriority

◆ ModuleType

◆ TecplotZoneType

Function Documentation

◆ GetModuleFactory()

◆ MappingIdealToRef()

◆ MatSymEVals()

◆ operator!=()

◆ operator<<()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ swap_endian() [1/2]

◆ swap_endian() [2/2]

◆ ThreeSimilar()

◆ TwoPairs()

◆ WriteStream() [1/4]

◆ WriteStream() [2/4]

◆ WriteStream() [3/4]

◆ WriteStream() [4/4]

Variable Documentation

◆ ModuleTypeMap

◆ TecplotZoneTypeMap