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

#include <ProcessForceDecompose.h>

Inheritance diagram for Nektar::FieldUtils::ProcessForceDecompose:

Public Member Functions
	ProcessForceDecompose ()

	ProcessForceDecompose (FieldSharedPtr f)

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.

FIELD_UTILS_EXPORT void	PrintConfig ()
	Print out all configuration options for a module.

FIELD_UTILS_EXPORT void	SetDefaults ()
	Sets default configuration options for those which have not been set.

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)

Protected Member Functions
NekDouble	PhysIntegral (MultiRegions::ExpListSharedPtr exp, Array< OneD, NekDouble > value)

void	GetQ (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, NekDouble > &Q)

void	QFromField (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, NekDouble > &Q)

void	QFromPressure (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, NekDouble > &Q)

NekDouble	GetViscosity ()

void	GetGradPressure (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, Array< OneD, NekDouble > > &gradp)

void	GetVelocity (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, Array< OneD, NekDouble > > &vel)

void	GetLaplaceVelocity (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, Array< OneD, NekDouble > > &lapvel)

void	GetStressTensor (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, Array< OneD, NekDouble > > &shear)

void	GetPhi (const Array< OneD, MultiRegions::ExpListSharedPtr > exp, Array< OneD, Array< OneD, NekDouble > > &phi, std::map< int, std::string > &Iphi)

void	GetInfoPhi (std::map< int, std::string > &Iphi)

void	VolumeIntegrateForce (const MultiRegions::ExpListSharedPtr &field, const Array< OneD, Array< OneD, NekDouble > > &data, const LibUtilities::CommSharedPtr &comm, std::map< int, std::string > &Iphi, Array< OneD, NekDouble > &BoundBox, int dir)

int	FindVariable (const std::string &var)

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 ()

Protected Attributes
int	m_spacedim

int	m_expdim

Protected Attributes inherited from Nektar::FieldUtils::Module
std::map< std::string, ConfigOption >	m_config
	List of configuration values.

std::set< std::string >	m_allowedFiles
	List of allowed file formats.

Additional Inherited Members
Public Attributes inherited from Nektar::FieldUtils::Module
FieldSharedPtr	m_f
	Field object.

Detailed Description

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

Definition at line 47 of file ProcessForceDecompose.h.

Constructor & Destructor Documentation

◆ ProcessForceDecompose() [1/2]

Nektar::FieldUtils::ProcessForceDecompose::ProcessForceDecompose ( )

inline

Definition at line 50 of file ProcessForceDecompose.h.

50{};

◆ ProcessForceDecompose() [2/2]

Nektar::FieldUtils::ProcessForceDecompose::ProcessForceDecompose ( FieldSharedPtr f )

Definition at line 46 of file ProcessForceDecompose.cpp.

    : ProcessModule(f)
{
}

Member Function Documentation

◆ FindVariable()

int Nektar::FieldUtils::ProcessForceDecompose::FindVariable ( const std::string & var )

protected

Definition at line 84 of file ProcessForceDecompose.cpp.

{
    auto index = find(m_f->m_variables.begin(), m_f->m_variables.end(), var);
    if (index == m_f->m_variables.end())
    {
        NEKERROR(ErrorUtil::efatal, var + " field not found.");
    }
    return index - m_f->m_variables.begin();
}

References Nektar::ErrorUtil::efatal, Nektar::FieldUtils::Module::m_f, and NEKERROR.

Referenced by GetGradPressure(), GetVelocity(), QFromField(), and QFromPressure().

◆ GetGradPressure()

void Nektar::FieldUtils::ProcessForceDecompose::GetGradPressure	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, Array< OneD, NekDouble > > &	gradp
	)

protected

Definition at line 164 of file ProcessForceDecompose.cpp.

{
    int npoints = exp[0]->GetNpoints();
    if (gradp.size() < m_spacedim)
    {
        gradp = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
    }
    for (size_t i = 0; i < gradp.size(); ++i)
    {
        if (gradp[i].size() < npoints)
        {
            gradp[i] = Array<OneD, NekDouble>(npoints, 0.);
        }
    }
    int iv;
    try
    {
        iv = FindVariable("p");
    }
    catch (...)
    {
        return;
    }
    Array<OneD, NekDouble> pressure(npoints, 0.);
    Vmath::Vcopy(npoints, exp[iv]->GetPhys(), 1, pressure, 1);
    for (int i = 0; i < m_spacedim; ++i)
    {
        exp[0]->PhysDeriv(i, pressure, gradp[i]);
    }
}

References FindVariable(), m_spacedim, and Vmath::Vcopy().

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ GetInfoPhi()

void Nektar::FieldUtils::ProcessForceDecompose::GetInfoPhi ( std::map< int, std::string > & Iphi )

protected

Definition at line 152 of file ProcessForceDecompose.cpp.

{
    Iphi.clear();
    for (size_t i = 0; i < m_f->m_variables.size(); ++i)
    {
        if (std::string::npos != m_f->m_variables[i].find("phi"))
        {
            Iphi[i] = m_f->m_variables[i];
        }
    }
}

References Nektar::FieldUtils::Module::m_f.

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ GetLaplaceVelocity()

void Nektar::FieldUtils::ProcessForceDecompose::GetLaplaceVelocity	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, Array< OneD, NekDouble > > &	lapvel
	)

protected

Definition at line 277 of file ProcessForceDecompose.cpp.

{
    int npoints = exp[0]->GetNpoints();
    Array<OneD, Array<OneD, NekDouble>> vel;
    GetVelocity(exp, vel);
    if (lapvel.size() != vel.size())
    {
        lapvel = Array<OneD, Array<OneD, NekDouble>>(vel.size());
    }
    for (size_t i = 0; i < lapvel.size(); ++i)
    {
        if (lapvel[i].size() < npoints)
        {
            lapvel[i] = Array<OneD, NekDouble>(npoints);
        }
    }
    Array<OneD, Array<OneD, NekDouble>> grad(m_spacedim);
    Array<OneD, NekDouble> tmp(npoints);
    for (int i = 0; i < m_spacedim; ++i)
    {
        grad[i] = Array<OneD, NekDouble>(npoints);
    }
    for (size_t i = 0; i < lapvel.size(); ++i)
    {
        Vmath::Zero(npoints, lapvel[i], 1);
        for (int j = 0; j < m_spacedim; ++j)
        {
            exp[i]->PhysDeriv(j, vel[i], grad[j]);
            exp[i]->PhysDeriv(j, grad[j], tmp);
            Vmath::Vadd(npoints, tmp, 1, lapvel[i], 1, lapvel[i], 1);
        }
    }
}

References GetVelocity(), m_spacedim, Vmath::Vadd(), and Vmath::Zero().

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ GetPhi()

void Nektar::FieldUtils::ProcessForceDecompose::GetPhi	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, Array< OneD, NekDouble > > &	phi,
		std::map< int, std::string > &	Iphi
	)

protected

Definition at line 123 of file ProcessForceDecompose.cpp.

{
    Iphi.clear();
    int npoints = exp[0]->GetNpoints();
    for (size_t i = 0; i < m_f->m_variables.size(); ++i)
    {
        if (std::string::npos != m_f->m_variables[i].find("phi"))
        {
            Iphi[i] = m_f->m_variables[i];
        }
    }
    if (phi.size() != Iphi.size())
    {
        phi = Array<OneD, Array<OneD, NekDouble>>(Iphi.size());
    }
    int i = 0;
    for (const auto &p : Iphi)
    {
        if (phi[i].size() < npoints)
        {
            phi[i] = Array<OneD, NekDouble>(npoints, 0.);
        }
        Vmath::Vcopy(npoints, exp[p.first]->GetPhys(), 1, phi[i], 1);
        ++i;
    }
}

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

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ GetQ()

void Nektar::FieldUtils::ProcessForceDecompose::GetQ	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, NekDouble > &	Q
	)

protected

Definition at line 56 of file ProcessForceDecompose.cpp.

{
    int method = m_config["Q"].as<int>();
    if (method == 1)
    {
        QFromPressure(exp, Q);
    }
    else
    {
        QFromField(exp, Q);
    }
}

References Nektar::FieldUtils::Module::m_config, QFromField(), and QFromPressure().

Referenced by Nektar::FieldUtils::ProcessForceDecomposeVol::v_Process().

◆ GetStressTensor()

void Nektar::FieldUtils::ProcessForceDecompose::GetStressTensor	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, Array< OneD, NekDouble > > &	shear
	)

protected

Definition at line 218 of file ProcessForceDecompose.cpp.

{
    int npoints = exp[0]->GetNpoints();
    Array<OneD, Array<OneD, NekDouble>> vel;
    GetVelocity(exp, vel);
    Array<OneD, Array<OneD, NekDouble>> grad(m_spacedim * m_spacedim);
    Array<OneD, NekDouble> tmp(npoints);
    for (size_t i = 0; i < grad.size(); ++i)
    {
        grad[i] = Array<OneD, NekDouble>(npoints);
    }
 
    if (stress.size() < m_spacedim * m_spacedim)
    {
        stress = Array<OneD, Array<OneD, NekDouble>>(m_spacedim * m_spacedim);
    }
 
    for (size_t i = 0; i < stress.size(); ++i)
    {
        if (stress[i].size() < npoints)
        {
            stress[i] = Array<OneD, NekDouble>(npoints);
        }
    }
 
    for (int i = 0; i < m_spacedim; ++i)
    {
        for (int j = 0; j < m_spacedim; ++j)
        {
            exp[i]->PhysDeriv(j, vel[i], grad[i * m_spacedim + j]);
        }
    }
 
    // Compute stress component terms
    //    tau_ij = mu*(u_i,j + u_j,i) + mu*lambda*delta_ij*div(u)
    for (int i = 0; i < m_spacedim; ++i)
    {
        for (int j = i; j < m_spacedim; ++j)
        {
            Vmath::Vadd(npoints, grad[i * m_spacedim + j], 1,
                        grad[j * m_spacedim + i], 1, stress[i * m_spacedim + j],
                        1);
 
            Vmath::Smul(npoints, GetViscosity(), stress[i * m_spacedim + j], 1,
                        stress[i * m_spacedim + j], 1);
        }
    }
    for (int i = 0; i < m_spacedim; ++i)
    {
        for (int j = 0; j < i; ++j)
        {
            Vmath::Vcopy(npoints, stress[j * m_spacedim + i], 1,
                         stress[i * m_spacedim + j], 1);
        }
    }
}

References GetVelocity(), GetViscosity(), m_spacedim, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vcopy().

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ GetVelocity()

void Nektar::FieldUtils::ProcessForceDecompose::GetVelocity	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, Array< OneD, NekDouble > > &	vel
	)

protected

Definition at line 197 of file ProcessForceDecompose.cpp.

{
    int npoints = exp[0]->GetNpoints();
    if (vel.size() < m_spacedim)
    {
        vel = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
    }
    std::vector<std::string> vars = {"u", "v", "w"};
    for (size_t i = 0; i < m_spacedim; ++i)
    {
        int iv = FindVariable(vars[i]);
        if (vel[i].size() < npoints)
        {
            vel[i] = Array<OneD, NekDouble>(npoints);
        }
        Vmath::Vcopy(npoints, exp[iv]->GetPhys(), 1, vel[i], 1);
    }
}

References FindVariable(), m_spacedim, and Vmath::Vcopy().

Referenced by GetLaplaceVelocity(), and GetStressTensor().

◆ GetViscosity()

NekDouble Nektar::FieldUtils::ProcessForceDecompose::GetViscosity ( )

protected

Definition at line 51 of file ProcessForceDecompose.cpp.

{
    return m_f->m_session->GetParameter("Kinvis");
}

References Nektar::FieldUtils::Module::m_f.

Referenced by GetStressTensor(), and Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process().

◆ PhysIntegral()

NekDouble Nektar::FieldUtils::ProcessForceDecompose::PhysIntegral	(	MultiRegions::ExpListSharedPtr	exp,
		Array< OneD, NekDouble >	value
	)

protected

Definition at line 313 of file ProcessForceDecompose.cpp.

{
    NekDouble sum = 0.;
    for (int i = 0; i < exp->GetExpSize(); ++i)
    {
        sum += exp->GetExp(i)->Integral(value + exp->GetPhys_Offset(i));
    }
    return sum;
}

◆ QFromField()

void Nektar::FieldUtils::ProcessForceDecompose::QFromField	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, NekDouble > &	Q
	)

protected

Definition at line 71 of file ProcessForceDecompose.cpp.

{
    int npoints = m_f->m_exp[0]->GetNpoints();
    int IQ      = FindVariable("Q");
    if (Q.size() < npoints)
    {
        Q = Array<OneD, NekDouble>(npoints);
    }
    Vmath::Vcopy(npoints, exp[IQ]->GetPhys(), 1, Q, 1);
}

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

Referenced by GetQ().

◆ QFromPressure()

void Nektar::FieldUtils::ProcessForceDecompose::QFromPressure	(	const Array< OneD, MultiRegions::ExpListSharedPtr >	exp,
		Array< OneD, NekDouble > &	Q
	)

protected

Definition at line 94 of file ProcessForceDecompose.cpp.

{
    int npoints = exp[0]->GetNpoints();
    int ip      = FindVariable("p");
    if (Q.size() < npoints)
    {
        Q = Array<OneD, NekDouble>(npoints);
    }
 
    Array<OneD, Array<OneD, NekDouble>> grad(m_spacedim);
    Array<OneD, NekDouble> tmp(npoints, 0.);
 
    for (int i = 0; i < m_spacedim; ++i)
    {
        grad[i] = Array<OneD, NekDouble>(npoints);
    }
    Vmath::Zero(npoints, Q, 1);
 
    for (int i = 0; i < m_spacedim; ++i)
    {
        exp[ip]->PhysDeriv(i, m_f->m_exp[ip]->GetPhys(), grad[i]);
        exp[ip]->PhysDeriv(i, grad[i], tmp);
        Vmath::Vadd(npoints, tmp, 1, Q, 1, Q, 1);
    }
    Vmath::Smul(npoints, 0.5, Q, 1, Q, 1);
}

References FindVariable(), Nektar::FieldUtils::Module::m_f, m_spacedim, Vmath::Smul(), Vmath::Vadd(), and Vmath::Zero().

Referenced by GetQ().

◆ VolumeIntegrateForce()

void Nektar::FieldUtils::ProcessForceDecompose::VolumeIntegrateForce	(	const MultiRegions::ExpListSharedPtr &	field,
		const Array< OneD, Array< OneD, NekDouble > > &	data,
		const LibUtilities::CommSharedPtr &	comm,
		std::map< int, std::string > &	Iphi,
		Array< OneD, NekDouble > &	BoundBox,
		int	dir
	)

protected

Definition at line 324 of file ProcessForceDecompose.cpp.

{
    int Nslots   = 100;
    int ndata    = data.size();
    NekDouble dh = (BoundBox[dir * 2 + 1] - BoundBox[dir * 2]) / Nslots;
    Array<OneD, Array<OneD, NekDouble>> slots(ndata);
    for (int i = 0; i < ndata; ++i)
    {
        slots[i] = Array<OneD, NekDouble>(Nslots, 0.);
    }
 
    for (size_t e = 0; e < field->GetExpSize(); ++e)
    {
        LocalRegions::ExpansionSharedPtr exp = field->GetExp(e);
        SpatialDomains::Geometry *geom       = exp->GetGeom();
        int nv                               = geom->GetNumVerts();
        NekDouble gc[3]                      = {0., 0., 0.};
        NekDouble gct[3]                     = {0., 0., 0.};
        bool inside                          = false;
        for (size_t j = 0; j < nv; ++j)
        {
            SpatialDomains::PointGeom *vertex = geom->GetVertex(j);
            vertex->GetCoords(gct[0], gct[1], gct[2]);
            gc[0] += gct[0] / NekDouble(nv);
            gc[1] += gct[1] / NekDouble(nv);
            gc[2] += gct[2] / NekDouble(nv);
            if (BoundBox[0] <= gct[0] && gct[0] <= BoundBox[1] &&
                BoundBox[2] <= gct[1] && gct[1] <= BoundBox[3] &&
                BoundBox[4] <= gct[2] && gct[2] <= BoundBox[5])
            {
                inside = true;
            }
        }
        if (inside)
        {
            int index = floor((gc[dir] - BoundBox[2 * dir]) / dh);
            index     = std::max(std::min(index, Nslots - 1), 0);
            for (int j = 0; j < ndata; ++j)
            {
                slots[j][index] +=
                    exp->Integral(data[j] + field->GetPhys_Offset(e));
            }
        }
    }
    for (int j = 0; j < ndata; ++j)
    {
        comm->AllReduce(slots[j], LibUtilities::ReduceSum);
    }
    if (comm->TreatAsRankZero())
    {
        Array<OneD, NekDouble> sum(ndata, 0.);
        cout << "variables = x";
        for (const auto &phi : Iphi)
        {
            cout << ", f" + phi.second;
        }
        cout << "\n";
        for (int i = 0; i < Nslots; ++i)
        {
            cout << (BoundBox[2 * dir] + (i + 0.5) * dh) << " ";
            for (int j = 0; j < ndata; ++j)
            {
                sum[j] += slots[j][i];
                cout << sum[j] << " ";
            }
            cout << "\n";
        }
        cout << endl;
    }
}

References Nektar::SpatialDomains::PointGeom::GetCoords(), Nektar::SpatialDomains::Geometry::GetNumVerts(), Nektar::SpatialDomains::Geometry::GetVertex(), and Nektar::LibUtilities::ReduceSum.

Referenced by Nektar::FieldUtils::ProcessForceDecomposeVol::v_Process().

Member Data Documentation

◆ m_expdim

int Nektar::FieldUtils::ProcessForceDecompose::m_expdim

protected

Definition at line 83 of file ProcessForceDecompose.h.

Referenced by Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process(), and Nektar::FieldUtils::ProcessForceDecomposeVol::v_Process().

◆ m_spacedim

int Nektar::FieldUtils::ProcessForceDecompose::m_spacedim

protected

Definition at line 82 of file ProcessForceDecompose.h.

Referenced by GetGradPressure(), GetLaplaceVelocity(), GetStressTensor(), GetVelocity(), QFromPressure(), Nektar::FieldUtils::ProcessForceDecomposeBnd::v_Process(), and Nektar::FieldUtils::ProcessForceDecomposeVol::v_Process().

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ProcessForceDecompose() [1/2]

◆ ProcessForceDecompose() [2/2]

Member Function Documentation

◆ FindVariable()

◆ GetGradPressure()

◆ GetInfoPhi()

◆ GetLaplaceVelocity()

◆ GetPhi()

◆ GetQ()

◆ GetStressTensor()

◆ GetVelocity()

◆ GetViscosity()

◆ PhysIntegral()

◆ QFromField()

◆ QFromPressure()

◆ VolumeIntegrateForce()

Member Data Documentation

◆ m_expdim

◆ m_spacedim