#include <ProcessCurve.h>

Inheritance diagram for Nektar::Utilities::ProcessCurve:

Collaboration diagram for Nektar::Utilities::ProcessCurve:

Public Member Functions
	ProcessCurve (NekMeshUtils::MeshSharedPtr m)
	Default constructor. More...

virtual	~ProcessCurve ()
	Destructor. More...

Public Member Functions inherited from Nektar::Utilities::ProcessCurvedEdges
	ProcessCurvedEdges (NekMeshUtils::MeshSharedPtr m)
	Default constructor. More...

virtual	~ProcessCurvedEdges ()
	Destructor. More...

virtual void	Process ()
	Write mesh to output file. More...

void	GenerateEdgeNodes (NekMeshUtils::EdgeSharedPtr edge)

Public Member Functions inherited from Nektar::NekMeshUtils::ProcessModule
NEKMESHUTILS_EXPORT	ProcessModule (MeshSharedPtr p_m)

Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT	Module (MeshSharedPtr p_m)

NEKMESHUTILS_EXPORT void	RegisterConfig (std::string key, std::string value)
	Register a configuration option with a module. More...

NEKMESHUTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...

NEKMESHUTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

NEKMESHUTILS_EXPORT MeshSharedPtr	GetMesh ()

virtual NEKMESHUTILS_EXPORT void	ProcessVertices ()
	Extract element vertices. More...

virtual NEKMESHUTILS_EXPORT void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...

virtual NEKMESHUTILS_EXPORT void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...

virtual NEKMESHUTILS_EXPORT void	ProcessElements ()
	Generate element IDs. More...

virtual NEKMESHUTILS_EXPORT void	ProcessComposites ()
	Generate composites. More...

virtual NEKMESHUTILS_EXPORT void	ClearElementLinks ()

Static Public Member Functions
static boost::shared_ptr< Module >	create (NekMeshUtils::MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static NekMeshUtils::ModuleKey	className

Protected Member Functions
void	v_GenerateEdgeNodes (NekMeshUtils::EdgeSharedPtr edge)

Protected Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...

NEKMESHUTILS_EXPORT void	PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)

Private Member Functions
NekDouble	EvaluateCoordinate (NekDouble xCoord)

Private Attributes
bool	m_fromFile

LibUtilities::AnalyticExpressionEvaluator	m_fEval

int	m_fExprId

LibUtilities::PtsFieldSharedPtr	m_fieldPts

Additional Inherited Members
Protected Attributes inherited from Nektar::NekMeshUtils::Module
MeshSharedPtr	m_mesh
	Mesh object. More...

std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

Detailed Description

Definition at line 48 of file ProcessCurve.h.

Constructor & Destructor Documentation

Nektar::Utilities::ProcessCurve::ProcessCurve ( NekMeshUtils::MeshSharedPtr m )

Default constructor.

Definition at line 66 of file ProcessCurve.cpp.

References Nektar::NekMeshUtils::Module::m_config.

                                           : ProcessCurvedEdges(m)
 {
     m_config["function"] = ConfigOption(false, "NotSet",
         "Expression of the curve: y = f(x).");
     m_config["file"] = ConfigOption(false, "NotSet",
         "Pts file containing coordinates (x,y).");
     m_config["niter"] = ConfigOption(false, "50",
         "Number of iterations to perform to obtain evenly distribution of points.");
     m_config["gamma"] = ConfigOption(false, "0.1",
         "Relaxation parameter.");
 }

Nektar::Utilities::ProcessCurve::~ProcessCurve ( )

virtual

Destructor.

Definition at line 81 of file ProcessCurve.cpp.

82 {

83 }

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::ProcessCurve::create ( NekMeshUtils::MeshSharedPtr m )

inlinestatic

Creates an instance of this class.

Definition at line 52 of file ProcessCurve.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

     {
         return MemoryManager<ProcessCurve>::AllocateSharedPtr(m);
     }

NekDouble Nektar::Utilities::ProcessCurve::EvaluateCoordinate ( NekDouble xCoord )

private

Definition at line 210 of file ProcessCurve.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::AnalyticExpressionEvaluator::Evaluate(), Nektar::FieldUtils::Interpolator::Interpolate(), m_fEval, m_fExprId, m_fieldPts, and m_fromFile.

Referenced by v_GenerateEdgeNodes().

 {
     if (m_fromFile)
     {
         Array<OneD, Array<OneD, NekDouble> > tmp(2);
         tmp[0] = Array<OneD, NekDouble>(1, xCoord);
         tmp[1] = Array<OneD, NekDouble>(1, 0.0);
 
         LibUtilities::PtsFieldSharedPtr toPts =
             MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(1, tmp);
 
         FieldUtils::Interpolator interp;
         interp.Interpolate(m_fieldPts, toPts);
 
         return tmp[1][0];
     }
     else
     {
         return m_fEval.Evaluate(m_fExprId, xCoord, 0.0, 0.0, 0.0);
     }
 }

void Nektar::Utilities::ProcessCurve::v_GenerateEdgeNodes ( NekMeshUtils::EdgeSharedPtr edge )

protectedvirtual

This function generates curved edge information in 2D, by including equispaced nodes to an edge following the prescribed function $y = f(x)$ .

An approximately equispaced node distribution is obtained by initially considering a uniform distribution in the $ x$ direction, and then adjusting the interior nodes using the iteration

$x^{n}_{i+1} = x^{n-1}_{i+1} + \Delta x^{n}_{i+1}$

$\Delta x^{n}_{i+1} = \Delta x^{n}_{i} + \gamma (\overline{\Delta s} - \Delta s^{n}_{i}) sign(\Delta x^{n}_{i})$

where $x^{n}$ is the $ x$ coordinate of the $n^{th}$ node, $ i$ is the iteration counter, $\Delta s^{n}$ is the Cartesian distance between nodes $ n$ and $ n-1$ and $\overline{\Delta s}$ is the average of these distances. The relaxation factor $\gamma$ and the fixed number of iterations $ Niter$ are parameters of the module.

In case the correction to $\Delta x$ leads to an invalid distribution (i.e. reversing directions), the relaxation parameter is successively halved until it leads to a valid distribution.

Parameters

edge	Edge which will be modified

Implements Nektar::Utilities::ProcessCurvedEdges.

Definition at line 108 of file ProcessCurve.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::AnalyticExpressionEvaluator::DefineFunction(), Nektar::LibUtilities::ePolyEvenlySpaced, EvaluateCoordinate(), Nektar::LibUtilities::GetCommFactory(), Nektar::NekMeshUtils::Module::m_config, m_fEval, m_fExprId, m_fieldPts, m_fromFile, class_topology::Node, and Vmath::Sadd().

 {
     NodeSharedPtr n1 = edge->m_n1;
     NodeSharedPtr n2 = edge->m_n2;
 
     int       nq    = m_config["N"].as<int>();
     int       niter = m_config["niter"].as<int>();
     NekDouble gamma = m_config["gamma"].as<double>();
 
     edge->m_edgeNodes.resize(nq - 2);
 
     // Read function defining the curve
     if (m_config["function"].as<string>().compare("NotSet") != 0)
     {
         ASSERTL0(m_config["file"].as<string>().compare("NotSet") == 0,
              "Function and file cannot be defined at the same time.");
 
         std::string fstr = m_config["function"].as<string>();
         m_fExprId = m_fEval.DefineFunction("x y z", fstr);
         m_fromFile = false;
     }
     else
     {
         ASSERTL0(m_config["file"].as<string>().compare("NotSet") != 0,
              "Need to define either function or file.");
         std::string inFile = m_config["file"].as<string>();
 
         LibUtilities::CommSharedPtr  c =
                 LibUtilities::GetCommFactory().CreateInstance("Serial", 0, 0);
         LibUtilities::PtsIOSharedPtr ptsIO =
                 MemoryManager<LibUtilities::PtsIO>::AllocateSharedPtr(c);
         ptsIO->Import(inFile, m_fieldPts);
 
         m_fromFile = true;
     }
 
     // Coordinates of points
     Array<OneD, NekDouble> x(nq,0.0);
     Array<OneD, NekDouble> y(nq,0.0);
     // Distances between points
     Array<OneD, NekDouble> dx(nq-1,0.0);
     Array<OneD, NekDouble> dy(nq-1,0.0);
     Array<OneD, NekDouble> ds(nq-1,0.0);
     // Average distance and deviation from average
     Array<OneD, NekDouble> s_deviation(nq-1,0.0);
     NekDouble s_average;
 
     // Fix start point
     x[0] =  n1->m_x;
     y[0] =  EvaluateCoordinate(x[0]);
     // Start with uniform distribution along x-axis
     Vmath::Sadd(nq-1, (n2->m_x - n1->m_x) / (nq-1), dx, 1, dx, 1);
 
     // Iterate a few times to make points more evenly distributed
     for (int s = 0; s < niter; ++s)
     {
         s_average = 0.0;
         for (int k = 1; k < nq; ++k)
         {
             x[k] = x[k-1] + dx[k-1] + gamma*s_deviation[k-1];
             y[k] =  EvaluateCoordinate(x[k]);
 
             dx[k-1] = x[k] - x[k-1];
             dy[k-1] = y[k] - y[k-1];
             ds[k-1] = sqrt(dx[k-1]*dx[k-1] + dy[k-1]*dy[k-1]);
 
             s_average = s_average + ds[k-1]/(nq-1);
         }
         // Calculate correction for next iteration
         for (int k = 0; k < nq-1; ++k)
         {
             s_deviation[k] =  (s_average - ds[k])* 
                                 ( dx[k]/abs(dx[k]));
         }
         // Adjust gama to make sure next partition is valid
         // (no reversals in dx)
         bool valid = false;
         gamma = m_config["gamma"].as<double>();
         while( !valid)
         {
             valid = true;
             for (int k = 0; k < nq-1; ++k)
             {
                 if( dx[k]*(dx[k]+gamma*s_deviation[k]) < 0.0)
                 {
                     gamma = gamma/2;
                     valid = false;
                     continue;
                 }
             }
         }
     }
 
     // Write interior nodes to edge
     for (int k = 1; k < nq-1; ++k)
     {                       
         edge->m_edgeNodes[k-1] = NodeSharedPtr(
                     new Node(0, x[k], y[k], n1->m_z));
     }
     edge->m_curveType = LibUtilities::ePolyEvenlySpaced;
 }

Member Data Documentation

ModuleKey Nektar::Utilities::ProcessCurve::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "curve"), 
    ProcessCurve::create,
    "Creates curved edge information using a function y=f(x) (2D only).")