Nektar::FieldUtils::ProcessQualityMetric Class Reference

This processing module scales the input fld file. More...

#include <ProcessQualityMetric.h>

Inheritance diagram for Nektar::FieldUtils::ProcessQualityMetric:

Public Member Functions
	ProcessQualityMetric (FieldSharedPtr f)
	~ProcessQualityMetric () override
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 ()
std::vector< ModuleKey >	GetModulePrerequisites ()
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
void	v_Process (po::variables_map &vm) override
	Write mesh to output file. More...
std::string	v_GetModuleName () override
std::string	v_GetModuleDescription () override
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 ()
virtual std::vector< ModuleKey >	v_GetModulePrerequisites ()

Private Member Functions
Array< OneD, NekDouble >	GetQ (LocalRegions::ExpansionSharedPtr e, bool s)

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 scales the input fld file.

Definition at line 44 of file ProcessQualityMetric.h.

Constructor & Destructor Documentation

ProcessQualityMetric()

Nektar::FieldUtils::ProcessQualityMetric::ProcessQualityMetric

(

FieldSharedPtr

f

)

Definition at line 57 of file ProcessQualityMetric.cpp.

                                                           : ProcessModule(f)
{
    m_config["scaled"] = ConfigOption(true, "0", "use scaled jacobian instead");
}

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

~ProcessQualityMetric()

Nektar::FieldUtils::ProcessQualityMetric::~ProcessQualityMetric ( )

override

Definition at line 62 of file ProcessQualityMetric.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 48 of file ProcessQualityMetric.h.

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

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

GetQ()

Array< OneD, NekDouble > Nektar::FieldUtils::ProcessQualityMetric::GetQ ( LocalRegions::ExpansionSharedPtr  e, bool  s  )

private

Definition at line 388 of file ProcessQualityMetric.cpp.

{
    SpatialDomains::GeometrySharedPtr geom    = e->GetGeom();
    StdRegions::StdExpansionSharedPtr chi     = e->GetGeom()->GetXmap();
    LibUtilities::PointsKeyVector p           = chi->GetPointsKeys();
    LibUtilities::PointsKeyVector pElem       = e->GetPointsKeys();
    SpatialDomains::GeomFactorsSharedPtr gfac = geom->GetGeomFactors();
    const int expDim                          = chi->GetNumBases();
    int nElemPts                              = 1;
 
    vector<LibUtilities::BasisKey> basisKeys;
    bool needsInterp = false;
 
    for (int i = 0; i < expDim; ++i)
    {
        nElemPts *= pElem[i].GetNumPoints();
        needsInterp =
            needsInterp || pElem[i].GetNumPoints() < p[i].GetNumPoints() - 1;
    }
 
    if (needsInterp)
    {
        stringstream err;
        err << "Interpolating from higher order geometry to lower order in "
            << "element " << geom->GetGlobalID();
        NEKERROR(ErrorUtil::ewarning, err.str());
    }
 
    for (int i = 0; i < expDim; ++i)
    {
        basisKeys.push_back(
            needsInterp
                ? chi->GetBasis(i)->GetBasisKey()
                : LibUtilities::BasisKey(chi->GetBasisType(i),
                                         chi->GetBasisNumModes(i), pElem[i]));
    }
 
    StdRegions::StdExpansionSharedPtr chiMod;
    switch (chi->DetShapeType())
    {
        case LibUtilities::eTriangle:
            chiMod = MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(
                basisKeys[0], basisKeys[1]);
            break;
        case LibUtilities::eQuadrilateral:
            chiMod = MemoryManager<StdRegions::StdQuadExp>::AllocateSharedPtr(
                basisKeys[0], basisKeys[1]);
            break;
        case LibUtilities::eTetrahedron:
            chiMod = MemoryManager<StdRegions::StdTetExp>::AllocateSharedPtr(
                basisKeys[0], basisKeys[1], basisKeys[2]);
            break;
        case LibUtilities::ePrism:
            chiMod = MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
                basisKeys[0], basisKeys[1], basisKeys[2]);
            break;
        case LibUtilities::eHexahedron:
            chiMod = MemoryManager<StdRegions::StdHexExp>::AllocateSharedPtr(
                basisKeys[0], basisKeys[1], basisKeys[2]);
            break;
        default:
            ASSERTL0(false, "nope");
    }
 
    SpatialDomains::DerivStorage deriv = gfac->GetDeriv(pElem);
 
    const int pts = deriv[0][0].size();
    const int nq  = chiMod->GetTotPoints();
 
    ASSERTL0(pts == nq, "what");
 
    vector<DNekMat> i2rm = MappingIdealToRef(geom, chiMod);
    Array<OneD, NekDouble> eta(nq);
 
    for (int k = 0; k < pts; ++k)
    {
        DNekMat jac(expDim, expDim, 0.0, eFULL);
        DNekMat jacIdeal(expDim, expDim, 0.0, eFULL);
 
        for (int i = 0; i < expDim; ++i)
        {
            for (int j = 0; j < expDim; ++j)
            {
                jac(j, i) = deriv[i][j][k];
            }
        }
 
        jacIdeal         = jac * i2rm[k];
        NekDouble jacDet = 1.0;
 
        if (expDim == 2)
        {
            jacDet = jacIdeal(0, 0) * jacIdeal(1, 1) -
                     jacIdeal(0, 1) * jacIdeal(1, 0);
        }
        else if (expDim == 3)
        {
            jacDet = jacIdeal(0, 0) * (jacIdeal(1, 1) * jacIdeal(2, 2) -
                                       jacIdeal(2, 1) * jacIdeal(1, 2)) -
                     jacIdeal(0, 1) * (jacIdeal(1, 0) * jacIdeal(2, 2) -
                                       jacIdeal(2, 0) * jacIdeal(1, 2)) +
                     jacIdeal(0, 2) * (jacIdeal(1, 0) * jacIdeal(2, 1) -
                                       jacIdeal(2, 0) * jacIdeal(1, 1));
        }
        else
        {
            NEKERROR(ErrorUtil::efatal, "invalid expansion dimension.");
        }
 
        if (s)
        {
            eta[k] = jacDet;
        }
        else
        {
            NekDouble frob = 0.0;
 
            for (int i = 0; i < expDim; ++i)
            {
                for (int j = 0; j < expDim; ++j)
                {
                    frob += jacIdeal(i, j) * jacIdeal(i, j);
                }
            }
 
            NekDouble sigma = 0.5 * (jacDet + sqrt(jacDet * jacDet));
            eta[k]          = expDim * pow(sigma, 2.0 / expDim) / frob;
        }
    }
 
    if (s)
    {
        NekDouble mx = -1.0 * numeric_limits<double>::max();
        NekDouble mn = numeric_limits<double>::max();
        for (int k = 0; k < pts; k++)
        {
            mx = max(mx, eta[k]);
            mn = min(mn, eta[k]);
        }
        for (int k = 0; k < pts; k++)
        {
            eta[k] = mn / mx;
        }
    }
 
    // Project onto output stuff
    if (needsInterp && pts != 1)
    {
        Array<OneD, NekDouble> tmp(nElemPts);
 
        if (expDim == 2)
        {
            LibUtilities::Interp2D(p[0], p[1], eta, pElem[0], pElem[1], tmp);
        }
        else if (expDim == 3)
        {
            LibUtilities::Interp3D(p[0], p[1], p[2], eta, pElem[0], pElem[1],
                                   pElem[2], tmp);
        }
        else
        {
            ASSERTL0(false, "mesh dim makes no sense");
        }
 
        eta = tmp;
    }
 
    if (pts == 1)
    {
        Vmath::Fill(nq - 1, eta[0], &eta[1], 1);
    }
 
    return eta;
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::eFULL, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eTetrahedron, Nektar::LibUtilities::eTriangle, Nektar::ErrorUtil::ewarning, Vmath::Fill(), Nektar::LibUtilities::Interp2D(), Nektar::LibUtilities::Interp3D(), Nektar::FieldUtils::MappingIdealToRef(), NEKERROR, CellMLToNektar.cellml_metadata::p, and tinysimd::sqrt().

Referenced by v_Process().

v_GetModuleDescription()

std::string Nektar::FieldUtils::ProcessQualityMetric::v_GetModuleDescription ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 66 of file ProcessQualityMetric.h.

    {
        return "Adding quality metric to field";
    }

v_GetModuleName()

std::string Nektar::FieldUtils::ProcessQualityMetric::v_GetModuleName ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 61 of file ProcessQualityMetric.h.

    {
        return "ProcessQualityMetric";
    }

v_GetModulePriority()

ModulePriority Nektar::FieldUtils::ProcessQualityMetric::v_GetModulePriority ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 71 of file ProcessQualityMetric.h.

    {
        return eModifyExp;
    }

References Nektar::FieldUtils::eModifyExp.

v_Process()

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

overrideprotectedvirtual

Write mesh to output file.

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 66 of file ProcessQualityMetric.cpp.

{
    m_f->SetUpExp(vm);
 
    int nfields = m_f->m_variables.size();
    m_f->m_variables.push_back("qualitymetric");
    // Skip in case of empty partition
    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];
    }
 
    Array<OneD, NekDouble> &phys   = exp->UpdatePhys();
    Array<OneD, NekDouble> &coeffs = exp->UpdateCoeffs();
 
    for (int i = 0; i < exp->GetExpSize(); ++i)
    {
        // copy Jacobian into field
        LocalRegions::ExpansionSharedPtr Elmt = exp->GetExp(i);
        int offset                            = exp->GetPhys_Offset(i);
        Array<OneD, NekDouble> q   = GetQ(Elmt, m_config["scaled"].as<bool>());
        Array<OneD, NekDouble> out = phys + offset;
 
        ASSERTL0(q.size() == Elmt->GetTotPoints(), "number of points mismatch");
        Vmath::Vcopy(q.size(), q, 1, out, 1);
    }
 
    exp->FwdTransLocalElmt(phys, coeffs);
}

References ASSERTL0, GetQ(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, Nektar::UnitTests::q(), and Vmath::Vcopy().

Member Data Documentation

className

ModuleKey Nektar::FieldUtils::ProcessQualityMetric::className

static

Initial value:

=
    GetModuleFactory().RegisterCreatorFunction(
        ModuleKey(eProcessModule, "qualitymetric"),
        ProcessQualityMetric::create, "add quality metric to field.")

Definition at line 52 of file ProcessQualityMetric.h.