Nektar::FieldUtils::ProcessMRF Class Reference

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

#include <ProcessMRF.h>

Inheritance diagram for Nektar::FieldUtils::ProcessMRF:

Public Member Functions
	ProcessMRF (FieldSharedPtr f)
	~ProcessMRF () 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
void	ReadMRFData ()
void	TransformVector (std::vector< Array< OneD, NekDouble > > &data)
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 Attributes
NekInt	m_spacedim
std::vector< NekDouble >	m_origin
std::vector< NekDouble >	m_theta
std::vector< NekDouble >	m_pivot

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 48 of file ProcessMRF.h.

Constructor & Destructor Documentation

ProcessMRF()

Nektar::FieldUtils::ProcessMRF::ProcessMRF

(

FieldSharedPtr

f

)

Definition at line 49 of file ProcessMRF.cpp.

                                       : ProcessModule(f)
{
    m_config["vectors"] = ConfigOption(false, "NotSet", "Select variables");
}

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

~ProcessMRF()

Nektar::FieldUtils::ProcessMRF::~ProcessMRF ( )

override

Definition at line 54 of file ProcessMRF.cpp.

{
}

Member Function Documentation

create()

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

inlinestatic

Creates an instance of this class.

Definition at line 52 of file ProcessMRF.h.

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

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

ReadMRFData()

void Nektar::FieldUtils::ProcessMRF::ReadMRFData ( )

protected

Definition at line 146 of file ProcessMRF.cpp.

{
    vector<string> strOrigin = {"X", "Y", "Z"};
    vector<string> strTheta  = {"Theta_x", "Theta_y", "Theta_z"};
    vector<string> strPivot  = {"X0", "Y0", "Z0"};
    m_origin.resize(3, 0.);
    m_pivot.resize(3, 0.);
    for (size_t i = 0; i < strOrigin.size(); ++i)
    {
        if (m_f->m_fieldMetaDataMap.count(strOrigin[i]))
        {
            m_origin[i] = stod(m_f->m_fieldMetaDataMap[strOrigin[i]]);
        }
    }
    for (size_t i = 0; i < strTheta.size(); ++i)
    {
        if (m_f->m_fieldMetaDataMap.count(strTheta[i]))
        {
            if (m_theta.size() < 3)
            {
                m_theta.resize(3, 0.);
            }
            m_theta[i] = stod(m_f->m_fieldMetaDataMap[strTheta[i]]);
        }
    }
    for (size_t i = 0; i < strPivot.size(); ++i)
    {
        if (m_f->m_fieldMetaDataMap.count(strPivot[i]))
        {
            m_pivot[i] = stod(m_f->m_fieldMetaDataMap[strPivot[i]]);
        }
    }
}

References Nektar::FieldUtils::Module::m_f, m_origin, m_pivot, and m_theta.

Referenced by v_Process().

TransformVector()

void Nektar::FieldUtils::ProcessMRF::TransformVector ( std::vector< Array< OneD, NekDouble > > &  data )

protected

Definition at line 180 of file ProcessMRF.cpp.

{
    if (m_theta.size() < 3)
    {
        return;
    }
    if (data.size() < m_spacedim)
    {
        NEKERROR(ErrorUtil::efatal,
                 "data size is small than the space dimension.");
    }
 
    int npoint   = data[0].size();
    int dim      = 2;
    NekDouble sz = sin(m_theta[2]), cz = cos(m_theta[2]);
    Array<OneD, Array<OneD, NekDouble>> tmp(dim);
    for (int i = 0; i < dim; ++i)
    {
        tmp[i] = Array<OneD, NekDouble>(npoint);
        Vmath::Vcopy(npoint, data[i], 1, tmp[i], 1);
    }
    Vmath::Svtsvtp(npoint, cz, tmp[0], 1, -sz, tmp[1], 1, data[0], 1);
    Vmath::Svtsvtp(npoint, sz, tmp[0], 1, cz, tmp[1], 1, data[1], 1);
}

References Nektar::ErrorUtil::efatal, m_spacedim, m_theta, NEKERROR, Vmath::Svtsvtp(), and Vmath::Vcopy().

Referenced by v_Process().

v_GetModuleDescription()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 70 of file ProcessMRF.h.

    {
        return "Applying mapping to field";
    }

v_GetModuleName()

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

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 65 of file ProcessMRF.h.

    {
        return "ProcessMRF";
    }

v_GetModulePriority()

ModulePriority Nektar::FieldUtils::ProcessMRF::v_GetModulePriority ( )

inlineoverrideprotectedvirtual

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 75 of file ProcessMRF.h.

    {
        return eModifyExp;
    }

References Nektar::FieldUtils::eModifyExp.

v_Process()

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

overrideprotectedvirtual

Write mesh to output file.

Reimplemented from Nektar::FieldUtils::Module.

Definition at line 58 of file ProcessMRF.cpp.

{
    m_f->SetUpExp(vm);
    ReadMRFData();
 
    // Skip in case of empty partition
    if (m_f->m_exp[0]->GetNumElmts() == 0)
    {
        return;
    }
 
    // Determine dimensions
    m_spacedim = m_f->m_graph->GetMeshDimension() + m_f->m_numHomogeneousDir;
 
    // transform coordinates
    int nfields          = m_f->m_variables.size();
    int addfields        = m_spacedim;
    int npoints          = m_f->m_exp[0]->GetNpoints();
    string fieldNames[3] = {"xCoord", "yCoord", "zCoord"};
    for (int i = 0; i < addfields; ++i)
    {
        m_f->m_variables.push_back(fieldNames[i]);
    }
    m_f->m_exp.resize(nfields + addfields);
    vector<Array<OneD, NekDouble>> coords(m_spacedim);
    for (int i = 0; i < m_spacedim; ++i)
    {
        coords[i] = Array<OneD, NekDouble>(npoints);
    }
    if (m_spacedim == 1)
    {
        m_f->m_exp[0]->GetCoords(coords[0]);
    }
    else if (m_spacedim == 2)
    {
        m_f->m_exp[0]->GetCoords(coords[0], coords[1]);
    }
    else
    {
        m_f->m_exp[0]->GetCoords(coords[0], coords[1], coords[2]);
    }
    for (int i = 0; i < m_spacedim; ++i)
    {
        Vmath::Sadd(npoints, -m_pivot[i], coords[i], 1, coords[i], 1);
    }
    TransformVector(coords);
    for (int i = 0; i < m_spacedim; ++i)
    {
        Vmath::Sadd(npoints, m_pivot[i] + m_origin[i], coords[i], 1, coords[i],
                    1);
    }
    // Add new information to m_f
    for (int i = 0; i < addfields; ++i)
    {
        m_f->m_exp[nfields + i] = m_f->AppendExpList(m_f->m_numHomogeneousDir);
        Vmath::Vcopy(npoints, coords[i], 1,
                     m_f->m_exp[nfields + i]->UpdatePhys(), 1);
        m_f->m_exp[nfields + i]->FwdTransLocalElmt(
            coords[i], m_f->m_exp[nfields + i]->UpdateCoeffs());
    }
 
    // tranform vectors
    vector<Array<OneD, NekDouble>> data(m_spacedim);
    vector<int> vars;
    if (m_config["vectors"].as<string>().compare("NotSet"))
    {
        ParseUtils::GenerateVariableVector(m_config["vectors"].as<string>(),
                                           m_f->m_variables, vars);
    }
    ASSERTL0(vars.size() % m_spacedim == 0,
             "The number of vector variables is not divisible by the space "
             "dimension.");
    for (int i = 0; i < vars.size() / m_spacedim; ++i)
    {
        for (int d = 0; d < m_spacedim; ++d)
        {
            data[d] = m_f->m_exp[vars[m_spacedim * i + d]]->UpdatePhys();
        }
        TransformVector(data);
        for (int d = 0; d < m_spacedim; ++d)
        {
            int nv = vars[m_spacedim * i + d];
            m_f->m_exp[nv]->FwdTransLocalElmt(data[d],
                                              m_f->m_exp[nv]->UpdateCoeffs());
        }
    }
}

References ASSERTL0, Nektar::UnitTests::d(), Nektar::ParseUtils::GenerateVariableVector(), Nektar::FieldUtils::Module::m_config, Nektar::FieldUtils::Module::m_f, m_origin, m_pivot, m_spacedim, ReadMRFData(), Vmath::Sadd(), TransformVector(), and Vmath::Vcopy().

Member Data Documentation

className

ModuleKey Nektar::FieldUtils::ProcessMRF::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "MRF"), ProcessMRF::create,
    "Add transformed coordinates to output file.")

Definition at line 56 of file ProcessMRF.h.

m_origin

std::vector<NekDouble> Nektar::FieldUtils::ProcessMRF::m_origin

private

Definition at line 84 of file ProcessMRF.h.

Referenced by ReadMRFData(), and v_Process().

m_pivot

std::vector<NekDouble> Nektar::FieldUtils::ProcessMRF::m_pivot

private

Definition at line 86 of file ProcessMRF.h.

Referenced by ReadMRFData(), and v_Process().

m_spacedim

NekInt Nektar::FieldUtils::ProcessMRF::m_spacedim

private

Definition at line 83 of file ProcessMRF.h.

Referenced by TransformVector(), and v_Process().

m_theta

std::vector<NekDouble> Nektar::FieldUtils::ProcessMRF::m_theta

private

Definition at line 85 of file ProcessMRF.h.

Referenced by ReadMRFData(), and TransformVector().