Nektar::Utilities::ProcessCurve Class Reference

#include <ProcessCurve.h>

Inheritance 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=std::string())
	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 std::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::Interpreter	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 47 of file ProcessCurve.h.

Constructor & Destructor Documentation

ProcessCurve()

Nektar::Utilities::ProcessCurve::ProcessCurve

(

NekMeshUtils::MeshSharedPtr

m

)

Default constructor.

Definition at line 65 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.");
}

~ProcessCurve()

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

virtual

Destructor.

Definition at line 80 of file ProcessCurve.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 51 of file ProcessCurve.h.

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

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

EvaluateCoordinate()

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

private

Definition at line 209 of file ProcessCurve.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::Interpreter::Evaluate(), Nektar::LibUtilities::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);

        LibUtilities::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);
    }
}

v_GenerateEdgeNodes()

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 107 of file ProcessCurve.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::Interpreter::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

className

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).")

Definition at line 55 of file ProcessCurve.h.

m_fEval

LibUtilities::Interpreter Nektar::Utilities::ProcessCurve::m_fEval

private

Definition at line 67 of file ProcessCurve.h.

Referenced by EvaluateCoordinate(), and v_GenerateEdgeNodes().

m_fExprId

int Nektar::Utilities::ProcessCurve::m_fExprId

private

Definition at line 68 of file ProcessCurve.h.

Referenced by EvaluateCoordinate(), and v_GenerateEdgeNodes().

m_fieldPts

LibUtilities::PtsFieldSharedPtr Nektar::Utilities::ProcessCurve::m_fieldPts

private

Definition at line 69 of file ProcessCurve.h.

Referenced by EvaluateCoordinate(), and v_GenerateEdgeNodes().

m_fromFile

bool Nektar::Utilities::ProcessCurve::m_fromFile

private

Definition at line 66 of file ProcessCurve.h.

Referenced by EvaluateCoordinate(), and v_GenerateEdgeNodes().