Nektar::FieldUtils::ProcessPhiFromFile Class Reference

#include <ProcessPhiFromFile.h>

Inheritance diagram for Nektar::FieldUtils::ProcessPhiFromFile:

Classes
struct	STLobject
	STL file object. More...
struct	triangle
	Object representing a 3D triangle. More...

Public Member Functions
	ProcessPhiFromFile (FieldSharedPtr f)
	Set up ProcessPhiFromFile object. More...
virtual	~ProcessPhiFromFile ()
virtual void	Process (po::variables_map &vm)
virtual std::string	GetModuleName ()
virtual std::string	GetModuleDescription ()
virtual ModulePriority	GetModulePriority ()
Public Member Functions inherited from Nektar::FieldUtils::ProcessModule
	ProcessModule ()
	ProcessModule (FieldSharedPtr p_f)
Public Member Functions inherited from Nektar::FieldUtils::Module
FIELD_UTILS_EXPORT	Module (FieldSharedPtr p_f)
virtual	~Module ()=default
const ConfigOption &	GetConfigOption (const std::string &key) const
FIELD_UTILS_EXPORT void	RegisterConfig (std::string key, std::string value="")
	Register a configuration option with a module. More...
FIELD_UTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module. More...
FIELD_UTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...
FIELD_UTILS_EXPORT void	AddFile (std::string fileType, std::string fileName)
FIELD_UTILS_EXPORT void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

Static Public Member Functions
static ModuleSharedPtr	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	m_className
	ModuleKey for class. More...

Protected Member Functions
Array< OneD, NekDouble >	ReadVector (std::ifstream &in)
	Read one 3D vector from a STL file, starting from the next line of the input 'ifstream'. Numbers in ifstream are defined as 'float'. More...
STLobject	ReadSTL (std::string filename)
	Read an STL binary file and returns a struct of type 'STLobject' containing the parsed data. More...
NekDouble	PhiFunction (double dist, double coeff)
	Smoothing function for the SPM method given a distance value and a scaling coefficient. More...
void	GetPhifromSession ()
	Assigns to 'phi' the values indicated by 'ShapeFunction'. More...
void	GetPhifromSTL (const STLobject &file)
	Assigns to 'phi' the corresponding values of Phi. More...
bool	CheckHit (const triangle &tri, const Array< OneD, NekDouble > &Origin, const Array< OneD, NekDouble > &Dvec, double &distance, double &u, double &v)
	Checks if a ray traced from 'Origin' with direction 'Dvec' hits the triangle defined by 'tri'. Returns the distance to the plane defined by 'tri' in any case. A negative distance means that the hit happened in the direction oposite that of the ray. Approach to calculate the intersection point found in: More...
void	FindShortestDist (const STLobject &file, const Array< OneD, NekDouble > &x, double &dist)
	Calculates the shortest distance from a point \(x\) to the closed body contained in the STL file. More...
bool	IsEqual (double x, double y, double relTol)
	Returns true if \(x=y\) within the relative tolerance 'relTol' (relative to 'y') More...
bool	IsNegative (double x, double tol)
	Returns true if \(x<tol\). More...
Array< OneD, NekDouble >	Cross (const Array< OneD, NekDouble > &v0, const Array< OneD, NekDouble > &v1)
	Returns the cross product of vectors 'v0' y 'v1'. More...
Array< OneD, NekDouble >	Vector2edge (const Array< OneD, NekDouble > &x, const Array< OneD, NekDouble > &e1, const Array< OneD, NekDouble > &e2)
	Determines the shortest distance from a point 'x' to the segment defined by the points 'e1' and 'e2'. Note that this distance may be equal to that to one of the end points. The vector returned points towards the point 'x'. More...
Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()

Protected Attributes
Octree	m_tree
	Octree object. More...
Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...
std::set< std::string >	m_allowedFiles
	List of allowed file formats. More...

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...

Detailed Description

Converter for STL files.

Definition at line 50 of file ProcessPhiFromFile.h.

Constructor & Destructor Documentation

ProcessPhiFromFile()

Nektar::FieldUtils::ProcessPhiFromFile::ProcessPhiFromFile

(

FieldSharedPtr

f

)

Set up ProcessPhiFromFile object.

Definition at line 59 of file ProcessPhiFromFile.cpp.

                                                       : ProcessModule(f)
{
    m_config["scale"] = ConfigOption(false, "NotSet",
                                     "Scale coefficient for Phi.");
    m_config["file"] = ConfigOption(false, "NotSet",
                                    "File with the IB definition.");
}

References Nektar::FieldUtils::Module::m_config.

~ProcessPhiFromFile()

Nektar::FieldUtils::ProcessPhiFromFile::~ProcessPhiFromFile ( )

virtual

Definition at line 70 of file ProcessPhiFromFile.cpp.

{
}

Member Function Documentation

CheckHit()

bool Nektar::FieldUtils::ProcessPhiFromFile::CheckHit ( const triangle &  tri, const Array< OneD, NekDouble > &  Origin, const Array< OneD, NekDouble > &  Dvec, double &  distance, double &  u, double &  v  )

protected

Checks if a ray traced from 'Origin' with direction 'Dvec' hits the triangle defined by 'tri'. Returns the distance to the plane defined by 'tri' in any case. A negative distance means that the hit happened in the direction oposite that of the ray. Approach to calculate the intersection point found in:

Fast, minimum storage ray/triangle intersection, Tomas Moeller, Ben Trumbore

Parameters

tri
Origin
Dvec
distance
u
v

Returns

true

false

Definition at line 367 of file ProcessPhiFromFile.cpp.

{
    // Edge vectors
    Array<OneD, NekDouble> E1(3);
    Array<OneD, NekDouble> E2(3);
    Vmath::Vsub(3, tri.v1, 1, tri.v0, 1, E1, 1);
    Vmath::Vsub(3, tri.v2, 1, tri.v0, 1, E2, 1);
 
    // If det == 0, ray parallel to triangle
    Array<OneD, NekDouble> Pvec = Cross(Dvec, E2);
    double det = Vmath::Dot(3, Pvec, E1);
    double inv_det = 1.0 / det;
    if (IsEqual(0.0, det, 1e-10))
    {
        distance = numeric_limits<double>::max();
        u        = numeric_limits<double>::max();
        v        = numeric_limits<double>::max();
        return false;
    }
 
    // Vector T and parameter u = (0.0, 1.0)
    Array<OneD, NekDouble> Tvec(3);
    Vmath::Vsub(3, Origin, 1, tri.v0, 1, Tvec, 1);
    u = Vmath::Dot(3, Pvec, Tvec) * inv_det;
 
    // Vector Q and parameter v = (0.0, 1.0)
    Array<OneD, NekDouble> Qvec = Cross(Tvec, E1);
    v = Vmath::Dot(3, Qvec, Dvec) * inv_det;
 
    // There is a hit if (u,v) coordinates are bounded
    distance = Vmath::Dot(3, Qvec, E2) * inv_det;
    if ((u < 0.0 || u > 1.0) || (v < 0.0 || u+v > 1.0))
    {
        return false;
    }
    else
    {
        return true;
    }
}

References Cross(), Vmath::Dot(), IsEqual(), Nektar::FieldUtils::ProcessPhiFromFile::triangle::v0, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v1, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v2, and Vmath::Vsub().

Referenced by FindShortestDist().

create()

static ModuleSharedPtr Nektar::FieldUtils::ProcessPhiFromFile::create ( FieldSharedPtr  f )

inlinestatic

Creates an instance of this class.

Definition at line 54 of file ProcessPhiFromFile.h.

    {
        return MemoryManager<ProcessPhiFromFile>::AllocateSharedPtr(f);
    }

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

Cross()

Array< OneD, NekDouble > Nektar::FieldUtils::ProcessPhiFromFile::Cross ( const Array< OneD, NekDouble > &  v0, const Array< OneD, NekDouble > &  v1  )

protected

Returns the cross product of vectors 'v0' y 'v1'.

Parameters

v0
v1

Returns

Array<OneD, NekDouble>

Definition at line 556 of file ProcessPhiFromFile.cpp.

{
    Array<OneD, NekDouble> out(3);
 
    out[0] = v0[1]*v1[2] - v0[2]*v1[1];
    out[1] = v0[2]*v1[0] - v0[0]*v1[2];
    out[2] = v0[0]*v1[1] - v0[1]*v1[0];
 
    return out;
}

Referenced by CheckHit().

FindShortestDist()

void Nektar::FieldUtils::ProcessPhiFromFile::FindShortestDist ( const STLobject &  file, const Array< OneD, NekDouble > &  x, double &  dist  )

protected

Calculates the shortest distance from a point \(x\) to the closed body contained in the STL file.

Parameters

file
x
dist

Definition at line 419 of file ProcessPhiFromFile.cpp.

{
    // Find closest triangles
    // First, use the ones in the node of 'x'
    int node = m_tree.QueryNode(x);
 
    // Set 'dist' to an unreal value
    dist = numeric_limits<double>::max();
 
    // If the node's depth is less than 3 the point is far from the object
    int depth = m_tree.QueryDepth(node);
 
    if (depth > 2)
    {
        vector<int> treeTriangles;
        vector<int> tmpTriangles = m_tree.QueryPoints(node);
        for (int point : tmpTriangles)
        {
            treeTriangles.push_back(point);
        }
 
        // Then, save the ones in the neighbouring nodes
        vector<int> neighbours = m_tree.QueryNeighbours(node);
        for (int neighNode : neighbours)
        {
            tmpTriangles = m_tree.QueryPoints(neighNode);
            for (int point : tmpTriangles)
            {
                treeTriangles.push_back(point);
            }
        }
 
        // Keep the sign (interior or exterior),
        int distSign = 1;
        // the normal vector of closest triangle so far,
        Array<OneD, NekDouble> triNormal =
            file.triangles[treeTriangles[0]].normal;
        // and the distance to the triangle PLANE
        double tParam = dist;
 
        for (int i = 0; i < treeTriangles.size(); ++i)
        {
            // Find distance to triangle
            triangle tri = file.triangles[treeTriangles[i]];
            double currentTparam;
            double u, v;
            bool hit = CheckHit(tri, x, tri.normal, currentTparam, u, v);
 
            // Save "sign" of 'currentTparam'
            int currentDistSign = (currentTparam >= 0) - (currentTparam < 0);
            // and distance to the triangle
            double currentDist;
 
            // Vector linking the hit point with the node
            Array<OneD, NekDouble> distVector(3);
 
            if (hit)
            {
                Vmath::Smul(3, -currentTparam, tri.normal, 1, distVector, 1);
                currentDist = fabs(currentTparam);
            }
            else
            {
                // The minimum has to be in one of the edges
                if (v < 0)   // Edge V0-V1
                {
                    distVector = Vector2edge(x, tri.v0, tri.v1);
                }
                else if (u < 0)   // Edge V0-V2
                {
                    distVector = Vector2edge(x, tri.v0, tri.v2);
                }
                else   // Edge V1-V2
                {
                    distVector = Vector2edge(x, tri.v1, tri.v2);
                }
                currentDist = sqrt(Vmath::Dot(3, distVector, distVector));
            }
 
            // Update 'dist', MAGIC CONSTANT AHEAD!
            // In the case of corners, check that the new triangle is not
            // giving contradictory information and, if so, use the one
            // closer to 'x'. Otherwise, some exterior points will be treated
            // as interior and viceversa
            if (dist-currentDist > 1e-5*currentDist ||
                (IsEqual(dist, currentDist, 1e-5) &&
                 IsNegative(Vmath::Dot(3, triNormal, tri.normal), 1e-5) &&
                 fabs(currentTparam) > fabs(tParam)))
            {
                dist      = currentDist;
                tParam    = currentTparam;
                distSign  = currentDistSign;
                triNormal = tri.normal;
            }
        }
 
        // Update distance sign
        dist *= -distSign;
    }
}

References CheckHit(), Vmath::Dot(), IsEqual(), IsNegative(), m_tree, Nektar::FieldUtils::ProcessPhiFromFile::triangle::normal, Nektar::FieldUtils::Octree::QueryDepth(), Nektar::FieldUtils::Octree::QueryNeighbours(), Nektar::FieldUtils::Octree::QueryNode(), Nektar::FieldUtils::Octree::QueryPoints(), Vmath::Smul(), tinysimd::sqrt(), Nektar::FieldUtils::ProcessPhiFromFile::STLobject::triangles, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v0, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v1, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v2, and Vector2edge().

Referenced by GetPhifromSTL().

GetModuleDescription()

virtual std::string Nektar::FieldUtils::ProcessPhiFromFile::GetModuleDescription ( )

inlinevirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 70 of file ProcessPhiFromFile.h.

    {
        return "Processing input STL file to calculate Phi";
    }

GetModuleName()

virtual std::string Nektar::FieldUtils::ProcessPhiFromFile::GetModuleName ( )

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 65 of file ProcessPhiFromFile.h.

    {
        return "ProcessPhiFromFile";
    }

GetModulePriority()

virtual ModulePriority Nektar::FieldUtils::ProcessPhiFromFile::GetModulePriority ( )

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 75 of file ProcessPhiFromFile.h.

    {
        return eModifyExp;
    }

References Nektar::FieldUtils::eModifyExp.

GetPhifromSession()

void Nektar::FieldUtils::ProcessPhiFromFile::GetPhifromSession ( )

protected

Assigns to 'phi' the values indicated by 'ShapeFunction'.

Definition at line 213 of file ProcessPhiFromFile.cpp.

{
    // Check that 'ShapeFunction' appears in the session file
    ASSERTL0(m_f->m_session->DefinesFunction("ShapeFunction"),
             "If file=file.stl is not supplied as an argument, a "
             "'ShapeFunction' block must be provided in the session "
             "file.")
 
    // Phi function in session file
    LibUtilities::EquationSharedPtr phiFunction =
        m_f->m_session->GetFunction("ShapeFunction", "Phi");
 
    // Get info about the domain
    int nPts  = m_f->m_exp[0]->GetNpoints();
    int nVars = m_f->m_variables.size();
    int nStrips;
    m_f->m_session->LoadParameter("Strip_Z", nStrips, 1);
 
    // Add new variable
    m_f->m_variables.push_back("phi");
 
    for (int s = 0; s < nStrips; ++s)
    {
        // Get current coords of the point
        Array<OneD, Array<OneD, NekDouble> > coords(3);
        for (int i = 0; i < 3; ++i)
        {
            coords[i] = Array<OneD, NekDouble>(nPts, 0.0);
        }
        m_f->m_exp[s*nVars]->GetCoords(coords[0], coords[1], coords[2]);
 
        // Append Phi expansion to 'm_f'
        MultiRegions::ExpListSharedPtr Exp;
        Exp = m_f->AppendExpList(m_f->m_numHomogeneousDir);
        phiFunction->Evaluate(coords[0], coords[1], coords[2],
                              Exp->UpdatePhys());
        Exp->FwdTrans(Exp->GetPhys(), Exp->UpdateCoeffs());
 
        auto it = m_f->m_exp.begin() + s * (nVars + 1) + nVars;
        m_f->m_exp.insert(it, Exp);
    }
}

References ASSERTL0, and Nektar::FieldUtils::Module::m_f.

Referenced by Process().

GetPhifromSTL()

void Nektar::FieldUtils::ProcessPhiFromFile::GetPhifromSTL ( const STLobject &  file )

protected

Assigns to 'phi' the corresponding values of Phi.

Parameters

file

Definition at line 261 of file ProcessPhiFromFile.cpp.

{
    // Get info about the domain
    int nPts  = m_f->m_exp[0]->GetNpoints();
    int nVars = m_f->m_variables.size();
 
    // Get coordinates
    Array<OneD, Array<OneD, NekDouble> > coords(3);
    for (int i = 0; i < 3; ++i)
    {
        coords[i] = Array<OneD, NekDouble>(nPts, 0.0);
    }
    m_f->m_exp[0]->GetCoords(coords[0], coords[1], coords[2]);
 
    // Add new variable
    m_f->m_variables.push_back("phi");
 
    // Number of homogeneous strips
    int nStrips;
    m_f->m_session->LoadParameter("Strip_Z", nStrips, 1);
 
    // Find bounds of the mesh
    Array<OneD, NekDouble> bounds(6);
    bounds[0] = coords[0][0];
    bounds[1] = coords[0][0];
    bounds[2] = coords[1][0];
    bounds[3] = coords[1][0];
    bounds[4] = coords[2][0];
    bounds[5] = coords[2][0];
    for (int i = 1; i < nPts; ++i)
    {
        bounds[0] = (bounds[0] < coords[0][i]) ? bounds[0] : coords[0][i];
        bounds[1] = (bounds[1] > coords[0][i]) ? bounds[1] : coords[0][i];
        bounds[2] = (bounds[2] < coords[1][i]) ? bounds[2] : coords[1][i];
        bounds[3] = (bounds[3] > coords[1][i]) ? bounds[3] : coords[1][i];
        bounds[4] = (bounds[4] < coords[2][i]) ? bounds[4] : coords[2][i];
        bounds[5] = (bounds[5] > coords[2][i]) ? bounds[5] : coords[2][i];
    }
    // and add a margin to avoid rounding errors
    for (int i = 0; i < 6; ++i)
    {
        bounds[i] -= pow(-1,i) * 1e-10;
    }
 
    // Array of centroids of triangles in the STL object
    Array<OneD, Array<OneD, NekDouble> > centroids(file.numTri);
    for (int i = 0; i < file.numTri; ++i)
    {
        centroids[i] = file.triangles[i].centroid;
    }
 
    // Initialise octree
    m_tree = Octree(centroids, 10, bounds);
 
    // For each strip...
    for (int s = 0; s < nStrips; ++s)
    {
        // Append Phi expansion to 'm_f'
        MultiRegions::ExpListSharedPtr phi;
        phi = m_f->AppendExpList(m_f->m_numHomogeneousDir);
 
        // Parallelisation is highly recommended here
        for (int i = 0; i < nPts; ++i)
        {
            // Get coordinates of each point
            Array<OneD, NekDouble> tmpCoords(3);
            tmpCoords[2] = coords[2][i];
            tmpCoords[1] = coords[1][i];
            tmpCoords[0] = coords[0][i];
 
            // Find the shortest distance to the body(ies)
            double dist;
            FindShortestDist(file, tmpCoords, dist);
 
            // Get corresponding value of Phi
            phi->UpdatePhys()[i] = PhiFunction(dist, 
                                               m_config["scale"].as<double>());
        }
 
        // Update vector of expansions
        phi->FwdTrans(phi->GetPhys(), phi->UpdateCoeffs());
        auto it = m_f->m_exp.begin() + s * (nVars + 1) + nVars;
        m_f->m_exp.insert(it, phi);
    }
}

References FindShortestDist(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, m_tree, Nektar::FieldUtils::ProcessPhiFromFile::STLobject::numTri, PhiFunction(), and Nektar::FieldUtils::ProcessPhiFromFile::STLobject::triangles.

Referenced by Process().

IsEqual()

bool Nektar::FieldUtils::ProcessPhiFromFile::IsEqual ( double  x, double  y, double  relTol  )

protected

Returns true if \(x=y\) within the relative tolerance 'relTol' (relative to 'y')

Parameters

x

Returns

true

false

Definition at line 531 of file ProcessPhiFromFile.cpp.

{
    return (fabs(x-y) <= relTol*y);
}

Referenced by CheckHit(), and FindShortestDist().

IsNegative()

bool Nektar::FieldUtils::ProcessPhiFromFile::IsNegative ( double  x, double  tol  )

protected

Returns true if \(x<tol\).

Parameters

x
relTol

Returns

true

false

Definition at line 544 of file ProcessPhiFromFile.cpp.

{
    return (x < tol);
}

Referenced by FindShortestDist().

PhiFunction()

NekDouble Nektar::FieldUtils::ProcessPhiFromFile::PhiFunction ( double  dist, double  coeff  )

protected

Smoothing function for the SPM method given a distance value and a scaling coefficient.

Parameters

dist
coeff

Returns

NekDouble

Definition at line 204 of file ProcessPhiFromFile.cpp.

{
    return -0.5*(std::tanh(dist/coeff)-1.0);
}

Referenced by GetPhifromSTL().

Process()

void Nektar::FieldUtils::ProcessPhiFromFile::Process ( po::variables_map &  vm )

virtual

Implements Nektar::FieldUtils::Module.

Definition at line 77 of file ProcessPhiFromFile.cpp.

{
    // Ignore warnings due to 'vm'
    boost::ignore_unused(vm);
 
    // Do not run in parallel
    ASSERTL0(m_f->m_session->GetComm()->IsSerial(), "Parallel execution is "
                                                    "not supported yet in "
                                                    "this module.")
 
    // Check if required params are defined
    ASSERTL0(m_f->m_graph, "A session file file must be provided before the "
                           "STL file.")
 
    // Skip in case of empty partition
    if (m_f->m_exp[0]->GetNumElmts() == 0)
    {
        return;
    }
 
    // Read Phi function from the session file...
    if (m_config["file"].as<string>().compare("NotSet") == 0)
    {
        WARNINGL0(m_config["scale"].as<string>().compare("NotSet") == 0,
                  "Reading Phi function from session file, the provided scale "
                  "value will not be used");
        GetPhifromSession();
    }
    // ...or Read STL file and append Phi values to the existing expansions
    else
    {
        ASSERTL0(m_config["scale"].as<string>().compare("NotSet") != 0,
                 "Need to specify a scale coefficient, scale=value");
 
        STLobject phiFile = ReadSTL(m_config["file"].as<string>());
        GetPhifromSTL(phiFile);
    }
}

References ASSERTL0, GetPhifromSession(), GetPhifromSTL(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, ReadSTL(), and WARNINGL0.

ReadSTL()

ProcessPhiFromFile::STLobject Nektar::FieldUtils::ProcessPhiFromFile::ReadSTL ( std::string  filename )

protected

Read an STL binary file and returns a struct of type 'STLobject' containing the parsed data.

Parameters

filename

Returns

ProcessPhiFromFile::STLobject

Definition at line 146 of file ProcessPhiFromFile.cpp.

{
    STLobject out;
 
    // Open file
    ifstream fileStl(filename.c_str(), ios::binary);
    ASSERTL0(fileStl, "An error occurred while trying to open the STL file.")
 
    // Buffers
    char headerBuf[80];
    char numTriBuf[4];
    char dumpBuf[2];
 
    // Read header and num of triangles
    fileStl.read(headerBuf, sizeof(headerBuf));
    fileStl.read(numTriBuf, sizeof(numTriBuf));
    memcpy(&out.numTri, numTriBuf, sizeof(numTriBuf));
 
    // Read triangle data
    out.triangles  = Array<OneD, triangle>(out.numTri);
    for (NekUInt32 i = 0; i < out.numTri; ++i)
    {
        // Read normal vector
        triangle tmpTri;
        tmpTri.normal = ReadVector(fileStl);
 
        // Read three vertices
        tmpTri.v0 = ReadVector(fileStl);
        tmpTri.v1 = ReadVector(fileStl);
        tmpTri.v2 = ReadVector(fileStl);
 
        // Add centroid to the triangle object
        Array<OneD, NekDouble> centre(3);
        centre[0] = (tmpTri.v0[0]+tmpTri.v1[0]+tmpTri.v2[0]) / 3.0;
        centre[1] = (tmpTri.v0[1]+tmpTri.v1[1]+tmpTri.v2[1]) / 3.0;
        centre[2] = (tmpTri.v0[2]+tmpTri.v1[2]+tmpTri.v2[2]) / 3.0;
        tmpTri.centroid = centre;
 
        out.triangles[i] = tmpTri;
 
        // Dump triangle type
        fileStl.read(dumpBuf, sizeof(dumpBuf));
    }
 
    // Close the file
    fileStl.close();
 
    return out;
}

References ASSERTL0, Nektar::FieldUtils::ProcessPhiFromFile::triangle::centroid, Nektar::FieldUtils::ProcessPhiFromFile::triangle::normal, Nektar::FieldUtils::ProcessPhiFromFile::STLobject::numTri, ReadVector(), Nektar::FieldUtils::ProcessPhiFromFile::STLobject::triangles, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v0, Nektar::FieldUtils::ProcessPhiFromFile::triangle::v1, and Nektar::FieldUtils::ProcessPhiFromFile::triangle::v2.

Referenced by Process().

ReadVector()

Array< OneD, NekDouble > Nektar::FieldUtils::ProcessPhiFromFile::ReadVector ( std::ifstream &  in )

protected

Read one 3D vector from a STL file, starting from the next line of the input 'ifstream'. Numbers in ifstream are defined as 'float'.

Parameters

in

Returns

Array<OneD, NekDouble>

Definition at line 123 of file ProcessPhiFromFile.cpp.

{
    Array<OneD, NekDouble> out(3, 0.0);
    float tmp;
    char buf[4];
 
    in.read(buf, sizeof(buf));
    memcpy(&tmp, buf, sizeof(buf)); out[0] = tmp;
    in.read(buf, sizeof(buf));
    memcpy(&tmp, buf, sizeof(buf)); out[1] = tmp;
    in.read(buf, sizeof(buf));
    memcpy(&tmp, buf, sizeof(buf)); out[2] = tmp;
 
    return out;
}

Referenced by ReadSTL().

Vector2edge()

Array< OneD, NekDouble > Nektar::FieldUtils::ProcessPhiFromFile::Vector2edge ( const Array< OneD, NekDouble > &  x, const Array< OneD, NekDouble > &  e1, const Array< OneD, NekDouble > &  e2  )

protected

Determines the shortest distance from a point 'x' to the segment defined by the points 'e1' and 'e2'. Note that this distance may be equal to that to one of the end points. The vector returned points towards the point 'x'.

Parameters

x
e1
e2

Returns

Array<OneD, NekDouble>

Definition at line 580 of file ProcessPhiFromFile.cpp.

{
    size_t n = x.size();
    Array<OneD, NekDouble> e1x(n);
    Array<OneD, NekDouble> e1e2(n);
    Vmath::Vsub(n, x, 1, e1, 1, e1x, 1);
    Vmath::Vsub(n, e2, 1, e1, 1, e1e2, 1);
    double norm = sqrt(Vmath::Dot(n, e1e2, e1e2));
    for (size_t i = 0; i < n; ++i)
    {
        e1e2[i] /= norm;
    }
 
    Array<OneD, NekDouble> out(n);
    double proj = Vmath::Dot(n, e1x, e1e2);
    if (proj < 0.0)
    {
        Vmath::Vsub(n, x, 1, e1, 1, out, 1);
    }
    else if (proj > norm)
    {
        Vmath::Vsub(n, x, 1, e2, 1, out, 1);
    }
    else
    {
        Vmath::Svtsvtp(n, 1.0, e1x, 1, -proj, e1e2, 1, out, 1);
    }
 
    return out;
}

References Vmath::Dot(), tinysimd::sqrt(), Vmath::Svtsvtp(), and Vmath::Vsub().

Referenced by FindShortestDist().

Member Data Documentation

m_className

ModuleKey Nektar::FieldUtils::ProcessPhiFromFile::m_className

static

Initial value:

= {
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "phifile"),
        ProcessPhiFromFile::create,
        "Computes the Phi function from a file, used in IB methods.")
}

ModuleKey for class.

Definition at line 59 of file ProcessPhiFromFile.h.

m_tree

Octree Nektar::FieldUtils::ProcessPhiFromFile::m_tree

protected

Octree object.

Definition at line 101 of file ProcessPhiFromFile.h.

Referenced by FindShortestDist(), and GetPhifromSTL().