Nektar::Utilities::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::Utilities::ProcessSurfDistance:

Collaboration diagram for Nektar::Utilities::ProcessSurfDistance:

Public Member Functions
	ProcessSurfDistance (FieldSharedPtr f)
virtual	~ProcessSurfDistance ()
virtual void	Process (po::variables_map &vm)
	Write mesh to output file. More...
Public Member Functions inherited from Nektar::Utilities::ProcessModule
	ProcessModule ()
	ProcessModule (FieldSharedPtr p_f)
	ProcessModule (MeshSharedPtr p_m)
Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)
void	RegisterConfig (string key, string value)
	Register a configuration option with a module. More...
void	PrintConfig ()
	Print out all configuration options for a module. More...
void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...
bool	GetRequireEquiSpaced (void)
void	SetRequireEquiSpaced (bool pVal)
void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)
	Module (MeshSharedPtr p_m)
virtual void	Process ()=0
void	RegisterConfig (string key, string value)
void	PrintConfig ()
void	SetDefaults ()
MeshSharedPtr	GetMesh ()
virtual void	ProcessVertices ()
	Extract element vertices. More...
virtual void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...
virtual void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...
virtual void	ProcessElements ()
	Generate element IDs. More...
virtual void	ProcessComposites ()
	Generate composites. More...
virtual void	ClearElementLinks ()

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

Static Public Attributes
static ModuleKey	className

Additional Inherited Members
Protected Member Functions inherited from Nektar::Utilities::Module
	Module ()
void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
void	PrismLines (int prism, PerMap &perFaces, set< int > &prismsDone, vector< ElementSharedPtr > &line)
Protected Attributes inherited from Nektar::Utilities::Module
FieldSharedPtr	m_f
	Field object. More...
map< string, ConfigOption >	m_config
	List of configuration values. More...
bool	m_requireEquiSpaced
MeshSharedPtr	m_mesh
	Mesh object. 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 50 of file ProcessSurfDistance.h.

Constructor & Destructor Documentation

Nektar::Utilities::ProcessSurfDistance::ProcessSurfDistance

(

FieldSharedPtr

f

)

Definition at line 53 of file ProcessSurfDistance.cpp.

References Nektar::Utilities::Module::m_config, and Nektar::Utilities::Module::m_f.

    : ProcessModule(f)
{
    m_config["bnd"] = ConfigOption(false,"-1","Boundary region to calculate height");
    f->m_writeBndFld = true;
    f->m_declareExpansionAsContField = true;
    m_f->m_fldToBnd = false;
}

Nektar::Utilities::ProcessSurfDistance::~ProcessSurfDistance ( )

virtual

Definition at line 62 of file ProcessSurfDistance.cpp.

{
}

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::ProcessSurfDistance::create ( FieldSharedPtr  f )

inlinestatic

Creates an instance of this class.

Definition at line 54 of file ProcessSurfDistance.h.

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

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

void Nektar::Utilities::ProcessSurfDistance::Process ( po::variables_map &  vm )

virtual

Write mesh to output file.

Implements Nektar::Utilities::Module.

Definition at line 66 of file ProcessSurfDistance.cpp.

References ASSERTL0, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::Utilities::Module::m_config, Nektar::Utilities::Module::m_f, Vmath::Reverse(), Nektar::NekMeshUtils::surf, Vmath::Vsqrt(), Vmath::Vsub(), Vmath::Vvtvp(), and Vmath::Zero().

{
    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));

    // Add this boundary region to the list that we will output.
    m_f->m_bndRegionsToWrite.push_back(surf);

    // Remove existing fields.
    m_f->m_exp.resize(1);

    // Grab boundary expansions.
    Array<OneD, MultiRegions::ExpListSharedPtr> BndExp =
        m_f->m_exp[0]->GetBndCondExpansions();

    // Get map that takes us from boundary element to element.
    Array<OneD, int> BoundarytoElmtID, BoundarytoTraceID;
    m_f->m_exp[0]->GetBoundaryToElmtMap(BoundarytoElmtID, BoundarytoTraceID);

    if (m_f->m_fielddef.size() == 0)
    {
        m_f->m_fielddef = m_f->m_exp[0]->GetFieldDefinitions();
        m_f->m_fielddef[0]->m_fields.push_back("dist");
    }
    else
    {
        // Override field variable
        m_f->m_fielddef[0]->m_fields[0] = "dist";
    }

    ASSERTL0(!(m_f->m_fielddef[0]->m_numHomogeneousDir),
                "Homogeneous expansions not supported");

    for (i = cnt = 0; i < BndExp.num_elements(); ++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;

            // Get boundary and element expansions.
            LocalRegions::ExpansionSharedPtr bndElmt = BndExp[i]->GetExp(j);
            LocalRegions::ExpansionSharedPtr elmt =
                m_f->m_exp[0]->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->GetEdgePhysVals(facetNum, bndElmt, x[k], face1);
                        elmt->GetEdgePhysVals(oppositeNum, bndElmt, x[k], face2);
                        // Consider edge orientation
                        if (elmt->GetEorient(facetNum) ==
                                elmt->GetEorient(oppositeNum))
                        {
                            Vmath::Reverse(nqBnd, face2, 1, face2, 1);
                        }
                    }
                    break;
                    case 3:
                    {
                        // Use orientation from the surface for both faces
                        StdRegions::Orientation orientation =
                                        elmt->GetForient(facetNum);
                        elmt->GetFacePhysVals(facetNum, bndElmt,
                                                x[k], face1, orientation);
                        elmt->GetFacePhysVals(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]->FwdTrans(BndExp[i]->GetPhys(), BndExp[i]->UpdateCoeffs());
    }
}

Member Data Documentation

ModuleKey Nektar::Utilities::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.