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 ()
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 Attributes
static ModuleKey	className

Protected Member Functions
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 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.

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

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

v_GetModuleDescription()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 70 of file ProcessL2Criterion.h.

    {
        return "Calculating Lambda 2 Criterion";
    }

v_GetModuleName()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 65 of file ProcessL2Criterion.h.

    {
        return "ProcessL2Criterion";
    }

v_GetModulePriority()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 75 of file ProcessL2Criterion.h.

    {
        return eModifyExp;
    }

References Nektar::FieldUtils::eModifyExp.

v_Process()

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

overrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 130 of file ProcessL2Criterion.cpp.

{
    m_f->SetUpExp(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
    {
        Exp     = m_f->AppendExpList(m_f->m_numHomogeneousDir);
        auto it = m_f->m_exp.begin() + s * (nfields + 1) + nfields;
        m_f->m_exp.insert(it, 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);
        }
 
        int fid = s * (nfields + 1) + nfields;
        Vmath::Vcopy(npoints, outfield2, 1, m_f->m_exp[fid]->UpdatePhys(), 1);
        m_f->m_exp[fid]->FwdTransLocalElmt(outfield2,
                                           m_f->m_exp[fid]->UpdateCoeffs());
    }
}

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

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.