Nektar::FieldUtils::ProcessSurfDistance Class Reference

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

#include <ProcessSurfDistance.h>

Inheritance diagram for Nektar::FieldUtils::ProcessSurfDistance:

Public Member Functions
	ProcessSurfDistance (FieldSharedPtr f)
virtual	~ProcessSurfDistance ()
Public Member Functions inherited from Nektar::FieldUtils::ProcessBoundaryExtract
	ProcessBoundaryExtract (FieldSharedPtr f)
virtual	~ProcessBoundaryExtract ()
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
void	Process (po::variables_map &vm)
std::string	GetModuleName ()
std::string	GetModuleDescription ()
const ConfigOption &	GetConfigOption (const std::string &key) const
ModulePriority	GetModulePriority ()
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 std::shared_ptr< Module >	create (FieldSharedPtr f)
	Creates an instance of this class. More...
Static Public Member Functions inherited from Nektar::FieldUtils::ProcessBoundaryExtract
static std::shared_ptr< Module >	create (FieldSharedPtr f)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	className
Static Public Attributes inherited from Nektar::FieldUtils::ProcessBoundaryExtract
static ModuleKey	className

Protected Member Functions
virtual void	v_Process (po::variables_map &vm) override
	Write mesh to output file. More...
virtual std::string	v_GetModuleName () override
virtual std::string	v_GetModuleDescription () override
Protected Member Functions inherited from Nektar::FieldUtils::ProcessBoundaryExtract
virtual void	v_Process (po::variables_map &vm) override
virtual std::string	v_GetModuleName () override
virtual std::string	v_GetModuleDescription () override
virtual ModulePriority	v_GetModulePriority () override
Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()
virtual void	v_Process (po::variables_map &vm)
virtual std::string	v_GetModuleName ()
virtual std::string	v_GetModuleDescription ()
virtual ModulePriority	v_GetModulePriority ()

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field 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...

Detailed Description

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

Definition at line 49 of file ProcessSurfDistance.h.

Constructor & Destructor Documentation

ProcessSurfDistance()

Nektar::FieldUtils::ProcessSurfDistance::ProcessSurfDistance

(

FieldSharedPtr

f

)

Definition at line 51 of file ProcessSurfDistance.cpp.

    : ProcessBoundaryExtract(f)
{
}

~ProcessSurfDistance()

Nektar::FieldUtils::ProcessSurfDistance::~ProcessSurfDistance ( )

virtual

Definition at line 56 of file ProcessSurfDistance.cpp.

{
}

Member Function Documentation

create()

static std::shared_ptr< Module > Nektar::FieldUtils::ProcessSurfDistance::create ( FieldSharedPtr  f )

inlinestatic

Creates an instance of this class.

Definition at line 53 of file ProcessSurfDistance.h.

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

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

v_GetModuleDescription()

virtual std::string Nektar::FieldUtils::ProcessSurfDistance::v_GetModuleDescription ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::ProcessBoundaryExtract.

Definition at line 71 of file ProcessSurfDistance.h.

    {
        return "Calculating distance to surface";
    }

v_GetModuleName()

virtual std::string Nektar::FieldUtils::ProcessSurfDistance::v_GetModuleName ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::ProcessBoundaryExtract.

Definition at line 66 of file ProcessSurfDistance.h.

    {
        return "ProcessSurfDistance";
    }

v_Process()

void Nektar::FieldUtils::ProcessSurfDistance::v_Process ( po::variables_map &  vm )

overrideprotectedvirtual

Write mesh to output file.

Reimplemented from Nektar::FieldUtils::ProcessBoundaryExtract.

Definition at line 60 of file ProcessSurfDistance.cpp.

{
    ProcessBoundaryExtract::v_Process(vm);
    ASSERTL0(!boost::iequals(m_config["bnd"].as<string>(), "All"),
             "ProcessSurfDistance needs bnd parameter with a single id.");
 
    int i, j, k, cnt;
    int surf   = m_config["bnd"].as<int>();
    int expdim = m_f->m_graph->GetMeshDimension();
 
    ASSERTL0(surf >= 0, "Invalid surface " + boost::lexical_cast<string>(surf));
 
    int nfields = m_f->m_variables.size();
    m_f->m_variables.push_back("dist");
 
    if (m_f->m_exp[0]->GetNumElmts() == 0)
    {
        return;
    }
 
    int NumHomogeneousDir = m_f->m_numHomogeneousDir;
    MultiRegions::ExpListSharedPtr exp;
    if (nfields)
    {
        m_f->m_exp.resize(nfields + 1);
        exp = m_f->AppendExpList(NumHomogeneousDir);
 
        m_f->m_exp[nfields] = exp;
    }
    else
    {
        exp = m_f->m_exp[0];
    }
 
    // Grab boundary expansions.
    Array<OneD, MultiRegions::ExpListSharedPtr> BndExp =
        exp->GetBndCondExpansions();
 
    // Get map that takes us from boundary element to element.
    Array<OneD, int> BoundarytoElmtID, BoundarytoTraceID;
    exp->GetBoundaryToElmtMap(BoundarytoElmtID, BoundarytoTraceID);
 
    ASSERTL0(!(m_f->m_numHomogeneousDir),
             "Homogeneous expansions not supported");
 
    for (i = cnt = 0; i < BndExp.size(); ++i)
    {
        if (i != surf)
        {
            cnt += BndExp[i]->GetExpSize();
            continue;
        }
 
        for (j = 0; j < BndExp[i]->GetExpSize(); ++j, ++cnt)
        {
            int elmtNum     = BoundarytoElmtID[cnt];
            int facetNum    = BoundarytoTraceID[cnt];
            int oppositeNum = 0;
 
            // Get boundary and element expansions.
            LocalRegions::ExpansionSharedPtr bndElmt = BndExp[i]->GetExp(j);
            LocalRegions::ExpansionSharedPtr elmt    = exp->GetExp(elmtNum);
 
            // Determine which face is opposite to the surface
            switch (elmt->DetShapeType())
            {
                case LibUtilities::eQuadrilateral:
                {
                    oppositeNum = (facetNum + 2) % 4;
                }
                break;
 
                case LibUtilities::ePrism:
                {
                    switch (facetNum)
                    {
                        case 1:
                            oppositeNum = 3;
                            break;
                        case 3:
                            oppositeNum = 1;
                            break;
                        default:
                            ASSERTL0(false, "Surface must be on a triangular "
                                            "face of the prism.");
                    }
                }
                break;
 
                case LibUtilities::eHexahedron:
                {
                    switch (facetNum)
                    {
                        case 0:
                            oppositeNum = 5;
                            break;
                        case 1:
                            oppositeNum = 3;
                            break;
                        case 2:
                            oppositeNum = 4;
                            break;
                        case 3:
                            oppositeNum = 1;
                            break;
                        case 4:
                            oppositeNum = 2;
                            break;
                        case 5:
                            oppositeNum = 0;
                            break;
                        default:
                            ASSERTL0(false, "Face out of bound.");
                    }
                }
                break;
 
                default:
                    ASSERTL0(false, "Element not supported");
            }
 
            int nq    = elmt->GetTotPoints();
            int nqBnd = bndElmt->GetTotPoints();
 
            Array<OneD, Array<OneD, NekDouble>> x(3);
            x[0] = Array<OneD, NekDouble>(nq);
            x[1] = Array<OneD, NekDouble>(nq);
            x[2] = Array<OneD, NekDouble>(nq);
            elmt->GetCoords(x[0], x[1], x[2]);
 
            Array<OneD, NekDouble> face1(nqBnd), face2(nqBnd);
            Array<OneD, NekDouble> dist =
                BndExp[i]->UpdatePhys() + BndExp[i]->GetPhys_Offset(j);
 
            // Zero existing value.
            Vmath::Zero(nqBnd, dist, 1);
 
            // Calculate distance between two faces of the element
            for (k = 0; k < expdim; ++k)
            {
                switch (expdim)
                {
                    case 2:
                    {
                        elmt->GetTracePhysVals(facetNum, bndElmt, x[k], face1);
                        elmt->GetTracePhysVals(oppositeNum, bndElmt, x[k],
                                               face2);
                        // Consider edge orientation
                        if (elmt->GetTraceOrient(facetNum) !=
                            elmt->GetTraceOrient(oppositeNum))
                        {
                            Vmath::Reverse(nqBnd, face2, 1, face2, 1);
                        }
                    }
                    break;
                    case 3:
                    {
                        // Use orientation from the surface for both faces
                        StdRegions::Orientation orientation =
                            elmt->GetTraceOrient(facetNum);
                        elmt->GetTracePhysVals(facetNum, bndElmt, x[k], face1,
                                               orientation);
                        elmt->GetTracePhysVals(oppositeNum, bndElmt, x[k],
                                               face2, orientation);
                    }
                    break;
                    default:
                        ASSERTL0(false, "Expansion not supported");
                }
                Vmath::Vsub(nqBnd, face1, 1, face2, 1, face1, 1);
                Vmath::Vvtvp(nqBnd, face1, 1, face1, 1, dist, 1, dist, 1);
            }
            Vmath::Vsqrt(nqBnd, dist, 1, dist, 1);
        }
 
        BndExp[i]->FwdTransLocalElmt(BndExp[i]->GetPhys(),
                                     BndExp[i]->UpdateCoeffs());
    }
}

References ASSERTL0, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, Vmath::Reverse(), Nektar::FieldUtils::ProcessBoundaryExtract::v_Process(), Vmath::Vsqrt(), Vmath::Vsub(), Vmath::Vvtvp(), and Vmath::Zero().

Member Data Documentation

className

ModuleKey Nektar::FieldUtils::ProcessSurfDistance::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "surfdistance"), ProcessSurfDistance::create,
        "Computes height of element connected to a surface.")

Definition at line 57 of file ProcessSurfDistance.h.