Nektar::FieldUtils::ProcessL2Criterion Class Reference

This processing module calculates the Lambda 2 Criterion and adds it as an extra-field to the output file. More...

#include <ProcessL2Criterion.h>

Inheritance diagram for Nektar::FieldUtils::ProcessL2Criterion:

Public Member Functions
	ProcessL2Criterion (FieldSharedPtr f)
virtual	~ProcessL2Criterion ()
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)
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	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 Attributes
static ModuleKey	className

Additional Inherited Members
Protected Member Functions inherited from Nektar::FieldUtils::Module
	Module ()
Protected Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object. More...
std::map< std::string, ConfigOption >	m_config
	List of configuration values. More...

Detailed Description

This processing module calculates the Lambda 2 Criterion and adds it as an extra-field to the output file.

Definition at line 49 of file ProcessL2Criterion.h.

Constructor & Destructor Documentation

ProcessL2Criterion()

Nektar::FieldUtils::ProcessL2Criterion::ProcessL2Criterion

(

FieldSharedPtr

f

)

Definition at line 55 of file ProcessL2Criterion.cpp.

                                                       : ProcessModule(f)
{
}

~ProcessL2Criterion()

Nektar::FieldUtils::ProcessL2Criterion::~ProcessL2Criterion ( )

virtual

Definition at line 59 of file ProcessL2Criterion.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 53 of file ProcessL2Criterion.h.

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

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

GetModuleDescription()

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

inlinevirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 69 of file ProcessL2Criterion.h.

    {
        return "Calculating Lambda 2 Criterion";
    }

GetModuleName()

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

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 64 of file ProcessL2Criterion.h.

    {
        return "ProcessL2Criterion";
    }

GetModulePriority()

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

inlinevirtual

Implements Nektar::FieldUtils::Module.

Definition at line 74 of file ProcessL2Criterion.h.

References Nektar::FieldUtils::eModifyExp.

    {
        return eModifyExp;
    }

Process()

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

virtual

Implements Nektar::FieldUtils::Module.

Definition at line 130 of file ProcessL2Criterion.cpp.

References ASSERTL0, Nektar::FieldUtils::Module::m_f, Nektar::FieldUtils::MatSymEVals(), and Vmath::Vcopy().

{
    boost::ignore_unused(vm);

    auto nfields = m_f->m_variables.size();
    m_f->m_variables.push_back("L2");

    // Skip in case of empty partition
    if (m_f->m_exp[0]->GetNumElmts() == 0)
    {
        return;
    }

    int i, s;
    int expdim   = m_f->m_graph->GetMeshDimension();
    int spacedim = expdim + (m_f->m_numHomogeneousDir);

    ASSERTL0(
        spacedim == 3,
        "ProcessL2Criterion must be computed for a 3D (or quasi-3D) case.");

    int npoints = m_f->m_exp[0]->GetNpoints();

    Array<OneD, Array<OneD, NekDouble>> grad(spacedim * spacedim);

    // Will store the Lambdas
    NekDouble a00, a11, a22, a01, a02, a12;
    NekDouble t1, t2, t3, t4, t5, t6, t7, t8, t10, t11, t13, t14, t15;
    NekDouble outfield1, outfield3;
    Array<OneD, NekDouble> outfield2(npoints);

    int nstrips;
    m_f->m_session->LoadParameter("Strip_Z", nstrips, 1);

    for (i = 0; i < spacedim * spacedim; ++i)
    {
        grad[i] = Array<OneD, NekDouble>(npoints);
    }

    MultiRegions::ExpListSharedPtr Exp;

    for (s = 0; s < nstrips; ++s) // homogeneous strip varient
    {
        for (i = 0; i < spacedim; ++i)
        {
            m_f->m_exp[s * nfields + i]->PhysDeriv(
                m_f->m_exp[s * nfields + i]->GetPhys(), grad[i * spacedim],
                grad[i * spacedim + 1], grad[i * spacedim + 2]);
        }

        /*
         * For each node calculate the S^2+W^2 tensor
         * where S and W are the symmetric and the skew-symmetric
         * parts of the velocity gradient tensor D=grad(u),
         * S=0.5(D+transpose(D)) and W=0.5((D-transpose(D)))
         */
        for (int j = 0; j < npoints; ++j)
        {
            // diff(u,y) + diff(v,x);
            t1 = grad[0 * spacedim + 1][j] + grad[1 * spacedim + 0][j];
            // diff(u,z) + diff(w,x);
            t2 = grad[0 * spacedim + 2][j] + grad[2 * spacedim + 0][j];
            // diff(u,y) - diff(v,x);
            t3 = grad[0 * spacedim + 1][j] - grad[1 * spacedim + 0][j];
            // diff(u,z) - diff(w,x);
            t4 = grad[0 * spacedim + 2][j] - grad[2 * spacedim + 0][j];

            t5 = t2 * t2;
            t6 = t4 * t4;
            t7 = t3 * t3;
            t8 = t1 * t1;

            // diff(w,y) + diff(v,z);
            t10 = grad[2 * spacedim + 1][j] + grad[1 * spacedim + 2][j];
            // diff(w,y) - diff(v,z);
            t11 = grad[2 * spacedim + 1][j] - grad[1 * spacedim + 2][j];

            t13 = 0.25 * (t10 * t2 + t11 * t4) +
                  0.5 * t1 *
                      (grad[0 * spacedim + 0][j] + grad[1 * spacedim + 1][j]);
            t14 = 0.5 * t2 *
                      (grad[0 * spacedim + 0][j] + grad[2 * spacedim + 2][j]) +
                  0.25 * (t1 * t10 - t11 * t3);
            t15 = t10 * t10;
            t11 = t11 * t11;
            t1  = 0.5 * t10 *
                     (grad[1 * spacedim + 1][j] + grad[2 * spacedim + 2][j]) -
                 0.25 * (-t1 * t2 + t3 * t4);

            a00 = 0.25 * (t5 - t6 - t7 + t8) +
                  grad[0 * spacedim + 0][j] * grad[0 * spacedim + 0][j];
            a01 = t13;
            a02 = t14;
            a11 = 0.25 * (-t7 + t8 + t15 - t11) +
                  grad[1 * spacedim + 1][j] * grad[1 * spacedim + 1][j];
            a12 = t1;
            a22 = 0.25 * (t5 - t6 + t15 - t11) +
                  grad[2 * spacedim + 2][j] * grad[2 * spacedim + 2][j];

            // Compute the eigenvalues of a symmetric 3x3 matrix
            MatSymEVals(a00, a11, a22, a01, a02, a12, outfield1, outfield2[j],
                        outfield3);
        }

        Exp = m_f->AppendExpList(m_f->m_numHomogeneousDir);
        Vmath::Vcopy(npoints, outfield2, 1, Exp->UpdatePhys(), 1);
        Exp->FwdTrans_IterPerExp(outfield2, Exp->UpdateCoeffs());
        auto it = m_f->m_exp.begin() + s * (nfields + 1) + nfields;
        m_f->m_exp.insert(it, Exp);
    }
}

Member Data Documentation

className

ModuleKey Nektar::FieldUtils::ProcessL2Criterion::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "L2Criterion"), ProcessL2Criterion::create,
        "Computes Lambda 2 Criterion.")

Definition at line 57 of file ProcessL2Criterion.h.